4. Architecture & Modules
Dependency Injection & IOC
Spring configuration
Example
5.
6.
7. IoC and DI features based on
the BeanFactory container
concept
Powerful
language
for querying
and
manipulating
an
object graph
at
runtime
Build on the base of Beans and
Core. Provide way to access
objects, support for i18n, resource
loading
8. JDBC –
provides
an abstraction
layer
Object/XML
mapping
implementations
like JAXB or
XStream
Programmatic or
declarative
transaction
management.
ORM –
provides
integration
layers
for popular
ORM
APIs like JPA,
Hibernate or
iBatis. Support
of
declarative
transaction
management.
9. 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
10. Implementation of the Inversion of Control
pattern
BeanFactory responsible for instantiating all
components based on a configuration
13. 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. 14
We have so far seen:
◦ Spring Architecture and Core Module
◦ IOC & Dependency Injection
◦ Spring configuration’s and Examples of
Dependency Injection in Spring
15.
16. 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
17. Action Spring You
Define connection
parameters.
X
Open the connection. X
Specify the SQL statement. X
Declare parameters and
X
provide parameter values
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,
X
statement and resultset.
18. public void GettingRows() {
Connection conn=null;
Statement stmt=null;
Resultset rset=null;
try{
Declare connection parameters
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
Open connection
Create statement
Execute statement
Iterate over resultset
Handle exceptions
clean up resources
19. 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
19
20. 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,
20
SqlUpdate and StoredProcedure
21. 21
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. To work with data from a database, we need to obtain a
connection to the database - through a DataSource
22
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);
25. JdbcTemplate jt = new JdbcTemplate(dataSource);
Some examples:
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);
25
26. 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. Some examples:
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(),
27
p.getLname()};
int[] types = new Int[]{Types.INTEGER, Types.VARCHAR,
Types.VARCHAR};
int count = jdbcTemplate.update(sql,params,types);
28. 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
28
29. 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.
30. // 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. 31
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
32.
33. 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.
34. In the beginning – Hibernate 2.x
Session s =
HibernateUtil.getSessionFactory().getCurrentSession();
Transaction tx;
try {
tx = sess.beginTransaction();
//do some work
tx.commit();
}
catch (Exception e) {
if (tx!=null) tx.rollback();
throw e;
}
finally {
sess.close();
}
35. Spring came with a really nice class
Session sess = SessionFactoryUtils.getSession
(getSessionFactory(), false);
sess.save(item);
36. Now Hibernate 3 and Spring 3
Session s =
getSessionFactory().getCurrentSession();
s.save(item);
37. 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
42. 42
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
43.
44. Why Spring Transaction
Transaction Manager
Programmatic Transaction Handling
Declarative Transaction
◦ XML
◦ @Transactional
45.
46. Uniform API
On and off server
Programmatic Transaction
Declarative Transaction
Propagation Behaviors
51. 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
52. public Object someServiceMethod() { return transactionTemplate.execute(new TransactionCallback() { // the code in this method executes in a transactional context
Using the TransactionTemplate.
Using
PlatformTransactionManager implementation
directly.
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();
}
});
}
53. DefaultTransactionDefinition def = newDefaultTransactionDefinition();
// explicitly setting the transaction name is something that can only be
done programmatically
def.setName("SomeTxName");
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRE
D);
TransactionStatus status = txManager.getTransaction(def);
try {
// execute your business logic here
}
catch (MyException ex) {
txManager.rollback(status); throw ex;
}
txManager.commit(status);
54. <bean id="petStoreTarget"> ... </bean>
<bean id="petStore"
class="org.springframework.transaction.interceptor.TransactionProxy
FactoryBean">
<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>
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.
57. ◦ 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. 58
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