Spring Framework Part 2

By Haroon Idrees

Recap

Spring-JDBC

Spring-ORM

Spring-Transactions

Agenda

Recap

Architecture & Modules

Dependency Injection & IOC

Spring configuration

Example

Recap

Architecture & Modules

Architecture & Modules

IoC and DI features based onthe BeanFactory containerconcept

Powerful languagefor querying andmanipulating anobject graph atruntime

Build on the base of Beans and Core. Provide way to access objects, support for i18n, resource loading

Architecture & Modules

Architecture & Modules

Object/XMLmappingimplementationslike JAXB orXStream

JDBC – providesan abstraction layer

Programmatic ordeclarativetransactionmanagement.

ORM – providesintegration layersfor popular ORMAPIs like JPA,Hibernate oriBatis. Support ofdeclarativetransactionmanagement.

Instead of objects invoking other objects, the dependant objects are added through an external entity/container.

Dependencies are “injected” by container during runtime.

Beans define their dependencies through constructor arguments or properties

Dependency Injection & Inversion of Control

Dependency Injection & Inversion of Control

Implementation of the Inversion of Control pattern

BeanFactory responsible for instantiating all components based on a configuration

Spring configuration

Spring managed beans configuration

<?xml version="1.0" encoding="UTF-8"?><beans >

<bean id=“BookDemoService” class=“BookDemoServiceImpl”>

<property name=“dao" ref=“bookDAO”/></bean><bean id=" bookDAO " class="BookDemoDao" >

</bean>

Example(Dependency Injection)

public class BookDemoServiceImpl implements BookDemoService {

private BookDemoDao dao;

public void addPublisherToBook(Book book) {

String isbn = book.getIsbn(); if (book.getPublisher() == null && isbn != null) { Publisher publisher = dao.findPublisherByIsbn(isbn); book.setPublisher(publisher); }} public void setBookDemoDao(BookDemoDao dao) { this.dao = dao; } }

14

Lesson Summary

We have so far seen:◦ Spring Architecture and Core Module◦ IOC & Dependency Injection◦ Spring configuration’s and Examples of

Dependency Injection in Spring

Spring-JDBC

Learning Objectives

◦ Learn core functionality of Spring’s JDBC framework

◦ Understand templates and callback mechanism

◦ Understand How Spring provides a way to actually model database operations as objects

Spring-JDBC

Action Spring You

Define connection parameters.

X

Open the connection. X  

Specify the SQL statement.   X

Declare parameters and provide parameter values

  X

Prepare and execute the statement.

X  

Set up the loop to iterate through the results (if any).

X  

Do the work for each iteration.

  X

Process any exception. X  

Handle transactions. X  

Close the connection, statement and resultset.

X  

Spring-JDBC

Spring JDBC - who does what?

Problem with JDBC codepublic void GettingRows() {Connection conn=null;Statement stmt=null;Resultset rset=null;try{ conn = dataSource.getConnection(); stmt = conn.createStatement (); rset = stmt.executeQuery ("select empno, ename,job from emp");

while (rset.next()) { System.out.print (rset.getString (1));}

} catch (SQLException e) {LOGGER.error(e); throw e;

}finally{ //code to clean up resources

Declare connection parameters

Open connection

Create statement

Execute statement

Iterate over resultset

Handle exceptions

clean up resources

19

Using JDBC with Spring

Spring separates the fixed and variant parts of the data access process into two distinct classes: ◦ Templates: manage the fixed part of the process

like controlling transactions, managing resources,

handling exceptions etc

◦ Callbacks: define implementation details,

specific to application ie. Creating statements,

binding parameters etc

20

Choosing a style

There are a number of options for selecting an approach to form the basis for your JDBC database access◦ JdbcTemplate◦ NamedParameterJdbcTemplate◦ SimpleJdbcTemplate◦ SimpleJdbcInsert and SimpleJdbcCall◦ RDBMS Objects including MappingSqlQuery,

SqlUpdate and StoredProcedure

21

The JdbcTemplate class

Central class in JDBC framework Manages all database communication and

exception handling Based on template style of programming;

some calls are handled entirely by JdbcTemplate while others require the calling class to provide callback methods that contain implementation for parts of the JDBC workflow

22

The DataSource

To work with data from a database, we need to obtain a

connection to the database - through a DataSource

Many implementations of DataSource exist. Eg:

◦ BasicDataSource

◦ PoolingDataSource

◦ SingleConnectionDataSource

◦ DriverManagerDataSource The datasource can be programmatically configured. Eg

DriverManagerDataSource ds = new DriverManagerDataSource();

ds.setDriverClassName(driver); ds.setUrl(url);

ds.setUsername(username); ds.setPassword(password);

Configuring data sources declaratively : Eg<bean id="dataSource" class= “org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/> <property name="url“ value="jdbc:oracle:thin:@oraserver:1521:oradb"/> <property name="username" value="scott"/> <property name="password" value="tiger"/></bean><bean id="dataSource" class=“org.springframework.jndi.JndiObjectFactoryBean"> <property name=“jndiName" value=“/jdbc/TrgDatasource"/> <property name=“resourceRef “ value=“true"/></bean>

Wiring beans in the Spring context file <bean id=”jdbcTemplate”

class=”org.springframework.jdbc.core.JdbcTemplate”> <property name=”dataSource”><ref local=”

myDataSource” /> </property> </bean> <bean id=“myDataSource " <!– the datasource configuration comes here

</bean> <bean id=“jdbcTemplateDemo”

class=“JdbcTemplateDemo”> <property name= “jdbcTemplate” ref= “jdbcTemplate”

/> <bean>class JdbcTemplateDemo{public void setJdbcTemplate(JdbcTemplate jdbcTemplate){ this. jdbcTemplate= jdbcTemplate; }

25

JdbcTemplate : Query methods

int count = jt.queryForInt(“select count(*) from emp”);

String name = (String) jt.queryForObject("select name from

mytable where empno=1022", String.class);

List rows = jt.queryForList("select * from mytable");

Object params[] = new Object[]{new Double(1000.0)};

List rows1 = jt.queryForList(“Select * from emp where sal

> ?”,params);

JdbcTemplate jt = new JdbcTemplate(dataSource);Some examples:

JdbcTemplate : execute methods

public class ExecuteAStatement {

private JdbcTemplate jt, DataSource dataSource;

public void doExecute() {

jt = new JdbcTemplate(dataSource);

jt.execute("create table mytable (id integer, name

varchar(100))");

}

public void setDataSource(DataSource dataSource) {

this.dataSource = dataSource;

}

}

27

JdbcTemplate : update methods

int x=jt.update(“insert into Book(id,name) values(1,’Core

Java’)”);

int x=jt.update(“Update Book set name=‘Advanced Java’

where id=?”, new Object[]{new Integer(3)});

int x=jt.update(“Delete from Book where id=2”);

String sql = “insert into person(id,fname,lname) values (?,?,?)”;

Object[] params = new Object[]{ p.getId(), p.getFname(), p.getLname()};int[] types = new Int[]{Types.INTEGER, Types.VARCHAR, Types.VARCHAR};int count = jdbcTemplate.update(sql,params,types);

Some examples:

28

JdbcTemplate Row-handling callback interfaces

JdbcTemplate class supports the callback methods concept for performing different SQL operations.

Callback methods allow the developer to manage database operations using a higher level of abstraction.

Interfaces that can be implemented to handle the returned rows are :◦ ResultSetExtractor◦ RowCallbackHandler◦ RowMapper

The NamedParameterJdbcTemplate class add supports for programming JDBC statements using named parameters, as opposed to programming JDBC statements using only classic placeholder ('?') arguments.

The NamedParameterJdbcTemplate class wraps a JdbcTemplate, and delegates to the wrappedJdbcTemplate to do much of its work.

 NamedParameterJdbcTemplate

NamedParameterJdbcTemplate: example

// some JDBC-backed DAO class...

private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

public void setDataSource(DataSource dataSource) {

this.namedParameterJdbcTemplate = new

NamedParameterJdbcTemplate(dataSource);

}

public int countOfActorsByFirstName(String firstName) {

String sql = "select count(*) from T_ACTOR where first_name = :first_name";

Map namedParameters = Collections.singletonMap("first_name", firstName);

return this.namedParameterJdbcTemplate.queryForInt(sql,

namedParameters);

}

31

Lesson Summary

We have so far seen:◦ How Spring’s JDBC framework offers an

excellent way to implement very low-level data access code without having to spend too much time writing tedious JDBC code.

◦ Convenience methods of the JdbcTemplate class

◦ Flexible NameParameterJdbcTemplate

style of programming using parameters ◦ Examples of JdbcTemplate and

NameParameterJdbcTemplate

Spring-ORM

The Spring Framework supports integration with Hibernate, Java Persistence API (JPA), Java Data Objects (JDO) and iBATIS SQL Maps for resource management, data access object (DAO) implementations, and transaction strategies. 

Benefits of using the Spring Framework to create your ORM DAOs

◦ Easier testing.

◦ Common data access exceptions. 

◦ General resource management.

◦ Integrated transaction management. 

 Introduction to ORM with Spring

In the beginning – Hibernate 2.x

Session s = HibernateUtil.getSessionFactory().getCurrentSession();

Transaction tx;try {

tx = sess.beginTransaction();//do some worktx.commit();

}catch (Exception e) {

if (tx!=null) tx.rollback();throw e;

}finally {

sess.close();}

Hibernate Integration

Spring came with a really nice class

Session sess = SessionFactoryUtils.getSession

(getSessionFactory(), false);

sess.save(item);

Hibernate Integration (cont.)

Now Hibernate 3 and Spring 3

Session s = getSessionFactory().getCurrentSession();s.save(item);

Hibernate Integration (cont.)

Concrete DAO class extend HibernateDaoSupport

Directly injecting a HibernateTemplate into your DAO class

Directly injecting the Hibernate SessionFactory into your DAO class◦ Possible because of Hibernate 3

3 ways to Integrate Hibernate with Spring

SessionFactory instead of DataSource SessionFactory setup in a Spring

container

Hibernate 3

<beans> <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="org.hsqldb.jdbcDriver"/> <property name="url" value="jdbc:hsqldb:hsql://localhost:9001"/> <property name="username" value="sa"/> <property name="password" value=""/> </bean> <bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource" ref="myDataSource"/> <property name="mappingResources"> <list> <value>product.hbm.xml</value> </list> </property> <property name="hibernateProperties"> <value> hibernate.dialect=org.hibernate.dialect.HSQLDialect </value> </property> </bean> </beans>

Annotation Session Factory

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<property name="dataSource" ref="dataSource"/>

<property name="hibernateProperties">

<ref bean="hibernateProjectProperties" />

</property>

<property name="annotatedClasses" ref="secFileList"/>

</bean>

Transaction Manager for Hibernate

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean>

IBatis ◦ org.springframework.orm.ibatis.SqlMapClientFacto

ryBean JPA

◦ "org.springframework.orm.jpa.LocalEntityManagerFactoryBean

JDO◦ org.springframework.orm.jdo.LocalPersistenceMan

agerFactoryBean

Other ORM Support

42

Lesson Summary

We have so far seen:◦ How Spring’s JDBC framework offers an

excellent way to integrate ORM Libraries

◦ How Spring Supports Transaction’s for ORM Tool

◦ Hibernate Configuration’s and annotation support and integration with Spring

◦ Examples of Hibernate Integration with Spring

Spring’s Transaction

Spring’s Transaction Why Spring Transaction Transaction Manager Programmatic Transaction Handling Declarative Transaction

◦ XML◦ @Transactional

Why Spring Transactions?

Why Spring Transaction? Uniform API On and off server Programmatic Transaction Declarative Transaction Propagation Behaviors

Uniform API

JDBC

Spring Transaction

ORM JCA

Application

JTA

On and Off Server

Spring

Java

J(2)EEContainer

ServletContainer

Spring Spring

Transaction Manager

Transaction ManagerTransactional

Resource

Transaction Manager

Transaction Managers Native transaction managers

◦ JDBC: DataSourceTransactionManager◦ Hibernate: HibernateTransactionManager◦ TopLink: TopLinkTransactionManager◦ JDO: JdoTransactionManager◦ etc

Native strategies work in any environment◦ but only against a single database!

no distributed transaction coordination◦ leverage full power of underlying resource

isolation levels, savepoints, etc

Using the TransactionTemplate. Using

PlatformTransactionManager implementation directly.

Programmatic transaction

public Object someServiceMethod() { return transactionTemplate.execute(new TransactionCallback() { // the code in this method executes in a transactional context public Object doInTransaction(TransactionStatus status) { updateOperation1(); return resultOfUpdateOperation2(); } }); }

public Object someServiceMethod() { return transactionTemplate.execute(new TransactionCallback() { // the code in this method executes in a transactional context public Object doInTransaction(TransactionStatus status) { updateOperation1(); return resultOfUpdateOperation2(); } }); }

Using PlatformTransactionManager

DefaultTransactionDefinition def = newDefaultTransactionDefinition(); // explicitly setting the transaction name is something that can only be done programmatically def.setName("SomeTxName"); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); TransactionStatus status = txManager.getTransaction(def); try { // execute your business logic here } catch (MyException ex) { txManager.rollback(status); throw ex; } txManager.commit(status);

Adding -MyCheckedException here specifies that if the method throws MyCheckedException or any subclasses, the transaction will automatically be rolled back. Multiple rollback rules can be specified here, comma-separated. A - prefix forces rollback; a + prefix specifies commit.

Declarative Transaction<bean id="petStoreTarget"> ... </bean>

<bean id="petStore" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager" ref="txManager"/> <property name="target" ref="petStoreTarget"/> <property name="transactionAttributes"> <props> <prop key="insert*">PROPAGATION_REQUIRED,- MyCheckedException</prop> <prop key="update*">PROPAGATION_REQUIRED</prop> <prop key="*">PROPAGATION_REQUIRED,readOnly</prop> </props> </property> </bean>

Declarative Transaction with AOP

<bean id="txManager”class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /> </bean>

<tx:advice id="txAdvice" transaction-manager="txManager"> <!-- the transactional semantics... --> <tx:attributes> <tx:method name="*" propagation="REQUIRED"/> <!-- >tx:method name="get" propagation="REQUIRED"/--> </tx:attributes> </tx:advice>

<aop:config proxy-target-class="true"> <aop:pointcut id="serviceOperation" expression="execution(* com.demo.springdemo.*Service.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation"/>

</aop:config>

Declarative Transaction Annotation

Propagation behaviors◦ MANDATORY 

          Support a current transaction, throw an exception if none exists.

◦ NESTED           Execute within a nested transaction if a current transaction exists, behave like PROPAGATION_REQUIRED else.

◦ NEVER           Execute non-transactionally, throw an exception if a transaction exists.

◦ NOT_SUPPORTED           Execute non-transactionally, suspend the current transaction if one exists.

◦ REQUIRED           Support a current transaction, create a new one if none exists.

◦ REQUIRES_NEW           Create a new transaction, suspend the current transaction if one exists.

◦ SUPPORTS           Support a current transaction, execute non-transactionally if none exists.

58

Lesson Summary

We have so far seen:◦ Spring’s Transactions Benefits◦ Spring Programmatic Transactions◦ Spring Declaratives Transactions◦ Spring Declaratives Transactions with AOP◦ Spring Annotations for Transactions ◦ Spring Transactions Propagations Behavior

What Next!

Spring Web