Spring framework - D3Sd3s.mff.cuni.cz/research/seminar/download/2005-11-29-Kalina-Spring.… ·...
Transcript of Spring framework - D3Sd3s.mff.cuni.cz/research/seminar/download/2005-11-29-Kalina-Spring.… ·...
Spring framework
Petr Kalina
This Presentation
1. The minimal basics
2. Spring in action – 5 examples
3. Spring role in j2ee world discussion
Minimal Basics
Spring is a framework extending the j2ee stackAddresses many of the common problems of this stackThe "all or nothing" situation with the use of EJBsSpring makes EJBs optional and services selective
This Presentation
1. The minimal basics
2. Spring in action – 5 examples
3. Spring role in j2ee world discussion
Example 1:Absolute Basics
-Inversion of Control-Dependency Injection
Example 1:
class Seminar, needs some instance of a class implementing DiscussionModerator ifacethe problem is, how to locate the instance of such class
Seminar
<<interface>>
Bures
DiscussionModerator
Kalibera
Bulej
Example 1:
pure Java (hardcoding):Seminar seminar = new Seminar();seminar.discussionModerator = new Bulej();
Example 1:
Spring:ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext( new String[] { "seminar.xml" }
);
BeanFactory beanFactory = (BeanFactory) appContext;
Seminar seminar = new Seminar();seminar.discussionModerator = ( DiscussionModerator) beanFactory.getBean("DiscussionModerator");
<bean id="DiscussionModerator" class="example.Bulej"/>
seminar.xml:
Example 1:
the difference: – declarative definition of references– instantiation left on Spring
advantages– swap in and out different implementations of objects at will– create different configurations for different deployment scenarios
or for testing purposes
Discussion
Dependency Injection– the dependencies are "injected" to the program by the framework
and can be dealt with in a declarative wayInversion of Control
– the program is not in control of the framework, but to the contrary, the framework controls the program
Example 2:The JNDI steps in..
Example 2: motivation
we want to use some kind of a Locator pattern:the idea of a Locator:
– multiple tiers– client/service needs to locate collaborator– no lookups in the client/business code, all wrapped in single class,
a Locator
Example 2: Locator pattern
JNDI lookup with Locator – a "good" j2ee classics
client locator initialContext EJBHome EJBObject
get instanceof locator
get service
create initialcontext
lookup homeobject
lookup homeobject
create EJBobjectget EJB object
performoperation
completeoperation
Example 2: Locator pattern
Locator pattern in Spring:Asumptions:
– services are programmed to interfaces – can be EJBs, POJOs or webservices..
CalculatorClient CalculatorIface
CalculatorImplEJB
CalculatorImplPOJO
Example 2: Locator pattern
as an EJB<bean id="CalculatorImpl" class="org.springframework.ejb.access.
LocalStatelessSessionProxyFactoryBean"><property name="jndiName"><value>calculatorBean</value>
</property>
<property name="businessInterface"><value>exmaple.CalculatorIface</value>
</property>
</bean>
BeanFactory bf = ( BeanFactory ) appContext; CalculatorIface calculator = bf.getBean( "CalculatorImpl" );
Client code
Example 2: Locator pattern
as a POJO<bean id="calculatorImpl"
class="example.calculatorImplPOJO"></bean>
BeanFactory bf = (BeanFactory) appContext; CalculatorIface calculator = bf.getBean("CalculatorImpl");
Client code ..is the same..
Example 2: Locator pattern
Advantages:– the same as Locator, but..
the EJB nature of the CalculatorImpl service is hidden from the clientthe configuration can be changed declarativelywe don't need to write Locator
Immediate impact on testing:– we can easily swap EJB objects for stubbed objects for Unit
Testing .. (stubbed = POJO returning already stub-wrapped responses – don't depend on container at all)
Example 2: Locator pattern
Alert– Spring dependency in client !!!– ... isn't necessary, we can inject the dependencies from the
application context
<bean id="adderImpl" .. <bean id="multiplierImpl" ..
<bean id="calculatorImpl"class="example.calculatorImplPOJO">
<ref bean="adderImpl" /> <ref bean="multiplierImpl" />...
</bean>
Example 3:Datasources &
Exceptions
Example 3: motivation
JDBC datasources..Imagine a classical database handling block in JDBC:
Example 3: motivation
Connection con = null;
try { javax.sql.Datasource ds =
(javax.sql.Datasource) ctx.Lookup("myDataSource");con = ds.getConnection(); Statement stmt = con.createStatement();String query = "SELECT NAME,SURENAME FROM SEMINARSTUDENTS";ResultSet rs = stmt.executeQuery( query );while ( rs.next() ) {
String student.name = rs.getString("NAME");String student.surename = rs.getString("SURENAME");studentlist.add( student );
} }catch (SQLException ex) {
logger.error("SQL ERROR!",ex);}finally { con.close(); }
Example 3: more motivation
what's wrong there?– nothing, it works, but...– proliferate code– datasource-nature (JNDI) specific code– the SQLException
Example 3: datasources & exceptions
Spring datasources accessed as beans..<bean id="myDataSourceJNDI" class="org.springframework.jndi.JndiObjectFactoryBean"><property name="jndiName"><value>java:comp/env/jdbc/myds</value>
</property></bean>
<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"><property name="driverClassName"><value>org.gjt.mm.mysql.Driver</value></property>
<property name="url"><value>jdbc:mysql://seminar/students</value></property>
<property name="username"><value>petr</value></property>
<property name="password"><value>password</value></property>
</bean>
Example 3: datasources & exceptions
Spring templates...class StudentsRowMapper implements RowMapper {
public Object mapRow(ResultSet rs, int index) throws SQLException {Student student = new Student();student.setFirstName( rs.getString( 1) );student.setLastName( rs.getString( 2 ) );return student;
}
DataSource ds = (DataSource) bf.getBean("myDataSource");JdbcTemplate temp = new JdbcTemplate(ds);List studentList = temp.query( "select student.name FROM students",new StudentsRowMapper() );
Example 3: datasources & exceptions
And where did the exceptions go?– Templates map SQL exception into standard DAO exceptions– DAO exceptions are Unchecked
DataAccessException
DataIntegrityViolation InvalidDataAccessApiUsageException
... ...
......
... ...
Example 3: summary
Discussion:– swap JDBC datasources declaratively– handle only the exceptions we want in database independent way
Immediate impact on testing:– swap JNDI for non-JNDI
Example 4:Aspects
(flavor only..)
Example 4: aspects (flavor only..)
Imagine a typical business object in enterprise environment:
Example 4: aspects (flavor only..)
public class MyBusinessClass extends OtherBusinessClass {// Core data members// Other data members: Log stream, data-consistency flag// Override methods in the base class
public void performSomeOperation(OperationInformation info) {// Ensure authentication// Ensure info satisfies contracts// Lock the object to ensure data-consistency// Ensure the cache is up to date// Log the start of operation// ==== Perform the core operation ====// Log the completion of operation// Unlock the object
}public void save(PersitanceStorage ps) {}public void load(PersitanceStorage ps) {}
}
Example 4: aspects (flavor only..)
AOP framework– crosscutting aspects and concerns– intercept method calls (accesses to members..) and perform
routines before or after this happens– from outside the program
no repetitious codethe aspects and concerns are dealt with as aspects and concerns of the whole application
Example 4: aspects (flavor only..)
the flavor:– application accesses data on remote datasource and serves them
to the client on request.– we write the application without caching, then we want to change
this aspect and we want to have all once served data cached– the business methods:
serveDataById( int id );serveDataByName( string name );serveDataBy...
Example 4: aspects (flavor only..)
DataAccessorIface
DataAccessorImpl "Implementation"
Java class Spring bean
our buisiness object..
ServeMethodAdvice
serve*(*){};
serve*(*);
Object invoke(Params params) {// decode params,// try to get from cache// if not in cache, retrieve,// add to cache and return
}
"AspectAction"
"Weaver"bean wiring up all
"Interceptor"
bean intercepting calls to mehods by regexp..<property name="pattern">
<value>(serve).*</value></property>
no c
achi
ng..
cach
ing
supp
ort..
Example 4: aspects (flavor only..)
Observation:– there's an AOP framework in Spring
Example 5:Transactions(flavor only..)
Transactions (flavor..)
Problems of classical transaction scenarios:– Datasource vendor dependency and only local transactions
when using local (ds specific) transactions– Container lock-in, force of use of JNDI, non declarative approach
when we controll transactions programatically with JTA (sun api for transaction management relying on services of the j2ee container)
– Container and EJB lock-inwhen we decide to use the CMT (Container Managed Transactions), which is a service of j2ee container for EJBs only
Remember DB templates from ex. 3..
Example 5: Transactions (flavor..)
Spring solves this problem in a classical way: by inserting a level of absatraction
hibernate_DS
JNDI_DS
JDBC_DS
spring.hibernate_MGR
spring.JTA_MGR
spring.DS_MGR
internally asingle set ofinterfacesaccessed bydb templates
JdbcTemplate temp = new Jdbc(Hibernate, JDO)Template(ds);temp.query( "update... )...
Spring beans..
Transactions (flavor..)
Then Spring offers controll on various levels:
declarativeDB templates
DS Utils
Transaction Templates programmatic
aspect oriented approach totransactions
Leftovers:
Leftovers (not even flavor..)
Spring web and MVC– Model-View-Controller
patternperform requested operations
manage userview/input
View(view utils)
Model(Business logic and data storage)
Controllerget commandscall output routines
call businessmethods
summary:
What we've been through?
We saw Spring in action in several of the main areas
Now we're ready for discussion of it's role in the "J2EE world"
This Presentation
1. The minimal basics
2. Spring in action – 5 examples
3. Spring role in j2ee world discussion
j2ee & Spring
Spring is based upon design patterns presented in a book by Rod Johnson (Expert One-on-One J2EE Design andDevelopment, 2002)He is a member and a consultant of the Spring developer teamMy understanding of the abstract of the book:
– j2ee is generally a good thing, only one has to be very selective about what parts he really needs
– the j2ee bundle does not enforce or even advocate a good design strategy on developer and thus is vary often misused
– respecting some design patterns leads to lower-cost / higher performance, reusability, testability applications
– the EJBs are overused in j2ee common practice
the EJBs
against EJBs:– testing implications – container lock-in– heavyweight, steep learning curve– hinder simple design
the EJBs
for EJBs:– scalability (clustering, distribution)– distribution (stateless session EJBs)– message driven scenarios (MDBs)– no need to write complex multithreaded code– transparent global transaction management in the container– security services in the container– EJBs are more or less familiar to everyone– DB vendor independence
EJB - Observation
EJBs are heavyweinght, make simple things hard (and hard things simple..)many times misused causing bad development efficiency and performance
Spring Role(s)
POJO development with j2ee services– transactions, AOP...
Use of services is selective (not all Spring..)Advocate "good" design patternsAdvocate IoC for better manageability
Do we need EJBs at all?Is Springs role to replace the EJB containers?
Jboss vs. Spring
Discussion in Spring forums:– "EJBs are "political" decission, no reasons to use them on technical
background".. Spring extended by other frameworks (Tomcat , ActiveMQ)
– "the idea that Spring can be used as a generic applicationserver replacement is absurd"
.. Spring applications deployed inside JBoss– Conclusion??
• Good analysis and case-by-case approach is the key!!• If we really need full featured container, it's JBoss or like..• For the rest (a very big part..) it's the Spring
Questions
and.. Thank you for your attention!