Das Spring Framework - Einführung in leichtgewichtige J2EE Architektur. Jürgen Höller. Organized by:

Transcription

1 Do 3.4 Das Spring Framework - Einführung in leichtgewichtige J2EE Architektur Jürgen Höller Organized by: Lindlaustr. 2c, Troisdorf, Tel.: +49 (0) , Fax.: +49 (0)

2 The Spring Framework Introduction to Lightweight J2EE Architecture Jürgen Höller Agenda J2EE Reviewed Spring Framework Spring and J2EE Core Container AOP Framework Transactions Data Access 2 1

3 J2EE Reviewed (1) J2EE specifies system services Servlets, JSP, JTA, JDBC, JMS, JavaMail builds on underlying standard Java runtime J2EE also specifies component models Servlets for HTTP endpoints EJBs for middle tier components Focus on traditional 3-tier server layout focus on physical separation between tiers middle tier always requires application server Low-level APIs direct usage in applications often cumbersome comfortable high-level APIs? 3 J2EE Reviewed (2) EJB = server-side component model separate deployment units special deployment descriptors separate class loader "remote EJBs" = distributed components original idea: analogous to CORBA "local EJBs" often just used for declarative transactions EJBs absolutely need an EJB container heavy deployment process hard to test 4 2

4 J2EE Reviewed (3) Scope of J2EE is limited EJBs are coarse-grained components mainly for (remote) service façades special deployment effort for every component How to deal with fine-grained, co-located application objects? forced to use custom solutions common: open source libraries / frameworks How to run outside of an application server? not covered by traditional J2EE important for unit tests and integration tests also important for productive development 5 Spring Framework (1) Java / J2EE Application Framework based on Rod Johnson s book J2EE Design & Development (Wiley, 2002) current book: "J2EE Development without EJB" (Rod Johnson, Jürgen Höller; Wiley, 2004) Focus on "Plain Old Java Objects" (POJOs) natural, generic component model for applications flexible alternative to EJB, not tied to J2EE Open Source Project on SourceForge Apache license since February developers 6 3

5 Spring Framework (2) Business objects as decoupled POJOs configuration and wiring through framework or usage as normal Java objects independent from the actual environment no unnecessary ties to a framework reusable in any kind of environment in particular: testability in unit / integration tests Generic middleware services e.g. declarative transactions for POJOs flexible alternative to EJB CMT for all applications, including standalone leverage J2EE container services when available 7 Spring Framework (3) Integration with existing solutions Object/Relational Mapping tools web frameworks remoting protocols "It s all about choice" JDBC, JDO, JPA, Hibernate, Oracle TopLink, Apache OJB, ibatis SQL Maps Spring Web MVC, Spring Web Flow, Struts, WebWork, Tapestry, JSF HTTP invoker, RMI invoker, conventional RMI, JAX-RPC (WSDL/SOAP), Hessian, Burlap 8 4

6 Spring and J2EE (1) J2EE provides standard system services to be leveraged by higher-level components Spring abstractions can run on top of J2EE Application components Spring application container Spring service abstractions J2EE system services J2EE deployment and management 9 Spring and J2EE (2) Spring is a de-facto standard Java / J2EE application framework typically running on top of J2EE server but: application components are not tied to J2EE Most popular "lightweight container" widespread adoption over the past 2.5 years endorsed / supported by BEA, Oracle, etc e.g.: support partnership for Spring on WebLogic EJB 3.0 specification follows Spring model adopts some important ideas from Spring 10 5

7 Core Container (1) "Inversion of Control" configuration and lifecycle of application objects objects do not configure themselves, but get configured from the outside objects don't know the origin of their configuration "Dependency Injection" "setter-based" (JavaBean properties) "constructor-based" (constructor arguments) alternative: "Service Lookup" for example: JNDI 11 Core Container (2) public class PetStoreImpl implements PetStoreFacade { private OrderDao orderdao; private ItemDao itemdao;... public void setorderdao(orderdao orderdao) { this.orderdao = orderdao; public void setitemdao(itemdao itemdao) { this.itemdao = itemdao;... public void insertorder(order order) { this.orderdao.insertorder(order); this.itemdao.updatequantity(order); 12 6

8 Core Container (3) Fine-grained externalized configuration representing the internal structure of the application references to other components configuration parameters enables flexible configuration management at fine-grained component level switching between different deployment scenarios XML bean definitions most common configuration format often: separate admin properties file linked into XML bean definitions through placeholders 13 Core Container (4) <bean id="datasource" class="org.apache.commons.dbcp.basicdatasource"> <property name="driverclassname" value="${jdbc.driver"/> <property name="url" value="${jdbc.url"/> <property name="username" value="${jdbc.username"/> <property name="password" value="${jdbc.password"/> </bean> <bean id="itemdao" class="org.springframework.samples.jpetstore.dao.ibatis.sqlmapitemdao"> <property name="datasource" ref="datasource"/> <property name="sqlmap" ref="sqlmap"/> </bean> <bean id="petstore" class="org.springframework.samples.jpetstore.domain.logic.petstoreimpl"> <property name="orderdao" ref="orderdao"/> <property name="itemdao" ref="itemdao"/> </bean> 14 7

9 AOP Framework (1) "Aspect-Oriented Programming" flexible combination of advices/interceptors no fixed component model ("EJB a la carte") "Method Interception" proxies for arbitrary POJOs actions at the beginning/end of a method call Caller Target method intercept 15 AOP Framework (2) Interceptor implementations can be applied to arbitrary target methods usually delegate to target ("proceed") can also abort invocations reuse of pre-built interceptors public class TestInterceptor implements MethodInterceptor { public Object invoke(methodinvocation inv) throws Throwable { System.out.println("before invocation"); Object rval = inv.proceed(); System.out.println("after invocation"); return rval; 16 8

10 AOP Framework (3) Do not repeat code: factor out interceptor "Cross-Cutting Concerns" e.g. logging: configurable trace log e.g. security: authorization checks e.g. common exception handling e.g. transaction demarcation Interceptor configuration interceptor can be enabled/disabled AOP Alliance: MethodInterceptor interface reuse of interceptors across different AOP frameworks 17 Transactions (1) Transaction Strategy Abstraction PlatformTransactionManager SPI switching between JTA and native transactions Transaction Demarcation Options programmatic demarcation a la JTA declarative demarcation for arbitrary POJOs Transaction Definitions all EJB CMT propagation codes supported REQUIRED, REQUIRES_NEW, etc optional transaction semantics beyond EJB nested, isolation level, timeout, read-only flag 18 9

11 Transactions (2) <bean id="petstoretarget class="org.springframework.samples.jpetstore.domain.logic.petstoreimpl"> <property name="orderdao" ref="orderdao"/> <property name="itemdao" ref="itemdao"/> </bean> <bean id="transactionmanager" class="org.springframework.transaction.jta.jtatransactionmanager"/> <bean id="petstore" class="org.springframework.transaction.interceptor.transactionproxyfactorybean"> <property name="transactionmanager" ref="transactionmanager"/> <property name="target" ref="petstoretarget"/> <property name="transactionattributes"> <props> <prop key="insert*">propagation_required</prop> <prop key="update*">propagation_required</prop> <prop key="*">propagation_required,readonly</prop> </props> </property> </bean> 19 Transactions (3) Alternative: JDK 1.5 annotation public class PetStoreImpl implements PetStoreFacade { private OrderDao orderdao; private ItemDao itemdao;... public void setorderdao(orderdao orderdao) { this.orderdao = orderdao; public void setitemdao(itemdao itemdao) { this.itemdao = public void insertorder(order order) { this.orderdao.insertorder(order); this.itemdao.updatequantity(order); 20 10

12 Data Access (1) DataAccessException hierarchy independent of JDBC, Hibernate, JDO, etc unchecked, as most failures are not recoverable subclasses like OptimisticLockingFailureException Support for DAO implementations implicit access to resources many operations become one-liners no try/catch blocks anymore Pre-built integration classes for many solutions e.g. JDBC: JdbcTemplate e.g. Hibernate: HibernateTemplate 21 Data Access (2) Example for a JDBC-based DAO public class ExampleJdbcDao extends JdbcDaoSupport { public void cleardatabase() throws DataAccessException { getjdbctemplate().update("delete FROM imagedb"); public void deleteimage(int imageid) throws DataAccessException { getjdbctemplate().update("delete FROM imagedb WHERE id=?", new Object[] {new Integer(imageId)); public int getnrofimages() throws DataAccessException { return getjdbctemplate().queryforint( "SELECT COUNT(*) FROM imagedb"); 22 11

13 Data Access (3) Example for a Hibernate-based DAO public class ExampleHibernateDao extends HibernateDaoSupport { public List getvets() throws DataAccessException { return gethibernatetemplate().find( "from Vet vet order by vet.lastname, vet.firstname"); public List findowners(string lastname) throws DataAccessException { return gethibernatetemplate().find( "from Owner owner where owner.lastname like?", lastname + "%"); public Owner loadowner(int id) throws DataAccessException { return gethibernatetemplate().load(owner.class, new Integer(id)); 23 Remoting Export POJOs as remote services in server-side Spring applications through Spring remote service exporter Make remote services accessible in client-side Spring applications through Spring remote proxy factory Protocol choice is configuration matter Hessian, Burlap, SOAP, RMI, HTTP invoker protocol to be chosen according to requirements Support for integration of EJBs through Spring EJB proxy factory declarative proxies for Stateless Session Beans 24 12

14 Further Services JMS Support lightweight message senders & listeners JCA Support convenient access to CCI Connectors Mail Support JavaMailSender, handling of attachments Scheduling Support Quartz, Timer, ThreadPoolExecutor, WorkManager Web Application Support Servlet & Portlet environments 25 Server and Application (1) J2EE servers are often managed conservatively many applications running on a single server server updates are generally hard major server updates often not acceptable J2EE applications are self-contained each application runs in own class loader can contain any libraries, any versions updating applications is usually easy 26 13

15 Server and Application (2) Spring happily provides its full services within any J2EE application can be used on J2EE 1.2 and later: e.g. WebLogic 7.0/8.1, WebSphere 4.0/5.0/5.1 can of course also be used on J2EE 5.0, alongside or as alternative to EJB 3.0 Spring provides full services outside of a full J2EE server as well e.g. declarative transactions on Tomcat 27 Summary (1) Spring is a popular Java application framework core container, AOP framework transactions, data access, remoting dedicated support for J2EE environments integrating with many existing solutions Solves ubiquitous architectural issues wiring and configuration of components flexible configuration of interceptors declarative transaction demarcation implicit management of resources 28 14

16 Summary (2) Works in any environment no special compilation or deployment steps no special class loader can run on J2EE, but not tied to J2EE seamless switching between deployment scenarios For any kind of application J2EE web applications running on e.g. Tomcat full J2EE applications running on e.g. WebLogic rich clients (usually with J2EE server as backend) standalone applications (with GUI or headless)