spring jdbc(1)

7/31/2019 Spring JDBC(1)

http://slidepdf.com/reader/full/spring-jdbc1 1/23

Tania Tritean

Presented by

Introduction to

Spring JDBC, DAO



• JDBC Advantages & Disadvantages

• DAO Pattern

• Spring JDBC

• Spring DAO•

Transactions• Transactions with Spring AOP

• Q & A

Agenda



JDBC Advantages



JDBC Disadvantages



Used to: abstract all access to the data source.

encapsulate all access to the data source.

manages the connection with the data source to obtain and store data.

DAO Pattern



Get to the subject!!!!!!!



Used to:

Define connection parameters

Open the connection

Specify the statement

Prepare and execute the statement

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

Do the work for each iteration

Process any exception

Handle transactions

Close the connection

Spring JDBC



Define connection parameters /DataSource

Data sourceimplementation



JDBCTemplate:

central class in the JDBC core package

handles the creation and release of resources

handles exceptions

You have just to:

Provide the query

Implement a Callback interface

Used to process the result of the query

Specify statement - JdbcTemplate



Examples

You can compare with:basic jdbc

What don’t you like here?

http://www.devdaily.com/java/edu/JDBC-SQLProcessor/Simple_JDBC_Example.shtml





NamedParameterJdbcTemplate

adds support for programming JDBC statements using named parameters

Example:

private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

public void setDataSource(DataSource dataSource) {this.namedParameterJdbcTemplate = new

NamedParameterJdbcTemplate(dataSource);

}

public int countOfActorsByFirstName(String firstName) {

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

SqlParameterSource namedParameters = new

MapSqlParameterSource("first_name", firstName);

return namedParameterJdbcTemplate.queryForInt(sql, namedParameters);

}



SqlParameterSource

MapSqlParameterSource

BeanPropertySqlParameterSource:

Example:

public int countOfActors(Actor exampleActor) {

// notice how the named parameters match the properties of the above 'Actor‘

String sql = "select count(0) from T_ACTOR where first_name = :firstName

and last_name = :lastName";

SqlParameterSource namedParameters = new

BeanPropertySqlParameterSource(exampleActor);

return this.namedParameterJdbcTemplate.queryForInt(sql,namedParameters);

}



takes advantage of JAVA 5 features

Varargs

Autoboxing

combines the most commonly used features of JdbcTemplate andNamedParameterJdbcTemplate

SimpleJdbcTemplate



Provides consistency in:

Exception Hierarchy

Why is this important?

translation from technology-specific exceptions such as Hibernate-relatedexceptions or JDBC-related exceptions by having its own hierarchy of data access-related exceptions

Abstract classes

Why is this important?

There is one abstract class each for various data persistence technologies. Theseabstract classes have methods that can be used to set the required configurableproperties that are specific to each technology.

DAO module of the Spring Framework

JdbcDaoSupport Abstraction for accessing data using JDBC

You provide the DataSource instance

JdbcDaoSupport provides the JdbcTemplate instance, created from thesupplied DataSource instanceto each technology.

it is provided as a convenience only



Definition:

All or Nothing / Commit or Rollback

Transactions



What can happen with multiple teams(transactions) trying to use same resources?

Conflicts can appear



T2 reads data that is being modified by T1 that has not yet committed.

Real example:

1. Cheating on an exam! – removing the response

2.

Transaction A begins.

UPDATE employee SET salary = 31650 WHERE empno = '000090'

Transaction B begins.

SELECT * FROM employee

(Transaction B sees data updated by transaction A. Those updates have not yet beencommitted.

A rollback can appear!

(maybe salary can not be modified – stupid example)

Conflict 1: Dirty Reads



a query returns data that would be different if the query were repeated withinthe same transaction.

Non-repeatable reads can occur when other transactions are modifying datathat a transaction is reading.

Real example:

1. Cheating on an exam! – response changed

2.

Empno has a salary = 00050

transaction A begins.

SELECT * FROM employee WHERE empno = '000090'


UPDATE employee SET salary = 30100 WHERE empno = '000090'

Transaction B commit

Transaction A commit

Transaction A result will be? ………. Not up to date

Conflict 2: Non-Repeatable Reads



Records that appear in a set being read by another transaction.

can occur when other transactions insert rows that would satisfy the WHERE

clause of another transaction's statement. Real example:

1. Cheating on an exam! – multiple choice question

2.

Transaction A begins.

SELECT * FROM employee WHERE salary > 30000


INSERT INTO employee (empno, firstnme, midinit, lastname, job, salary) VALUES('000350', 'NICK', 'A','GREEN','LEGAL COUNSEL',35000)

Transaction B commit

Transaction A commit

Result of Transaction A will be? ........... It will miss one row

Conflict 3: Phantom Reads



Isolation levels = the solution

TRANSACTION_SERIALIZABLE All problems fixed, but no concurrency any more

TRANSACTION_REPEATABLE_READ

prevent only dirty reads and non-repeatable reads, but NOT phantoms

TRANSACTION_READ_COMMITTED prevent only dirty reads

Default!

TRANSACTION_READ_UNCOMMITTED

anything can happen

Solving Conflicts



Provides a consistent programming model across different transaction APIssuch as JTA, JDBC, Hibernate, iBATIS Database Layer and JDO.

Provides a simpler, easier to use, API for programmatic transactionmanagement than most of these transaction APIs

Integrates with the Spring data access abstraction

Supports Spring declarative transaction management

Transactions with SPRING

i i h



You have to

Define a transactionManager

Define Interceptor for adding transaction(use of AOP)

Eg. : <bean id=" transactionManager " class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

</bean>

<bean id="riskService" class=" org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<property name="transactionManager">

<ref bean=" transactionManager " />

</property>

<property name="target">

<ref bean="riskServiceTarget" />

</property>

<property name="transactionAttributes">

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

Transactions with SPRING AOP

spring jdbc(1)

Documents