#1 需要解决的疑惑
目前jdbc、jdbcTemplate、hibernate、jpa、spring之间有或多或少的关系。在使用它们的时候有着各种各样的配置,初学者很容易分不清到底各自都做了什么事情,如果对自己要求高点,那就测试下下面几个问题:
- jdbc的几个主要对象是什么?
- jdbc的原生方式是什么样的?怎么配置?怎么使用事务?
- jdbcTemplate又是如何封装jdbc的?怎么使用事务?
- hibernate的几个主要对象是什么?
- hibernate的原生xml方式是什么样的?注解方式是什么样?怎么配置?怎么使用事务?
- 为什么会出现jpa?如果是你来设计,你该如何来设计jpa?同时事务又怎么办?
- jpa的几个主要对象是什么?
- jpa的原生的开发方式是什么样的?怎么配置?怎么使用事务?
- spring为了让大家使用jpa更加方便,又做了哪些封装?又如何把datasource加进来?这时候,其他的orm又该如何集成?
- spring为了再进一步的封装,产生spring-data-jpa,它的xml方式和注解方式又是什么样?它又是如何在前面的基础上做封装呢?
从上面可以再进一步总结:
- 事务的发展历程是什么样的?
- 对数据库的操作,xml方式和注解方式又是如何逐步简化的?
#2 实验案例
为了彻底搞清楚它们之间的关系,做了以下几个案例:
-
spring-jdbc:jdbc的原生方式开发和事务的使用
-
spring-jdbcTemplate:使用spring封装的JdbcTemplate开发和事务的使用
-
spring-hibernate-xml: hibernate的原生xml方式开发
-
spring-hibernate-xml-tx:hibernate的原生xml方式的事务的使用
-
spring-hibernate-annotation:hibernate的原生的注解方式开发
-
spring-hibernate-annotation-tx:hibernate的原生的注解方式的事务的使用
-
spring-jpa-hibernate:jpa的原生xml方式开发和事务的使用
-
spring-springjpa-hibernate:jpa的spring集成方式开发和事务的使用
-
spring-springjpa-hibernate-multDataSource:多数据源下jpa与spring集成开发和事务的使用
-
spring-data-jpa-hibernate:spring-data-jpa方式开发和事务的使用
案例都是使用SpringMVC搭建的环境,主要是可以在此基础上方便开发。而学习过程的测试案例都是使用的是spring-test来进行测试的。
项目地址如下jdbc-hibernate-jpa-spring
#3 实验案例的详细说明:
##3.1数据库和表的准备
所有的案例都使用的数据库为test,表名为user,表user有id,name,age属性,User类如下:
public class User {
private Long id;
private String name;
private int age;
//略
}
目前使用的hibenrate版本是最新的4.3.8.Final。
##3.2 jdbc开发和事务的使用
###3.2.1 项目地址
该案例是项目spring-jdbc
###3.2.2 项目配置和使用分析
第一步: 先注册驱动类
Class.forName("com.mysql.jdbc.Driver");
第二步: 使用DriverManager来获取连接Connection
Connection conn=DriverManager.getConnection(url, user, password);
第三步: 使用Connection来执行sql语句,以及开启、回滚、提交事务
Connection conn=jdbcDao.getConnection();
conn.setAutoCommit(false);
try {
PreparedStatement ps=conn.prepareStatement("insert into user(name,age) value(?,?)");
ps.setString(1,user.getName());
ps.setInt(2,user.getAge());
ps.execute();
conn.commit();
} catch (Exception e) {
e.printStackTrace();
conn.rollback();
}finally{
conn.close();
}
缺点:
- 每次都是获取一个连接,用完之后就释放掉,应该是用完再放回去,等待下一次使用,所以应该使用连接池datasource
- Connection、PreparedStatement这种操作很麻烦,不方便
- 业务代码和事务代码相互交叉,都嵌套在try catch中,代码很不美观
针对上述问题,spring开发了JdbcTemplate来完成相应的封装
##3.3 spring-jdbcTemplate开发和事务的使用
###3.3.1 项目地址
该案例是项目spring-jdbcTemplate
###3.3.2 项目配置
首先注册dataSource,用于管理Connection,每次使用完Connection,仍旧放回连接池,等待下一次使用
<bean id="dataSource"
class="com.mchange.v2.c3p0.ComboPooledDataSource"
destroy-method="close">
<property name="driverClass">
<value>${jdbc.driverClass}</value>
</property>
<property name="jdbcUrl">
<value>${jdbc.url}</value>
</property>
<property name="user">
<value>${jdbc.user}</value>
</property>
<property name="password">
<value>${jdbc.password}</value>
</property>
<!--连接池中保留的最小连接数。-->
<property name="minPoolSize">
<value>${jdbc.minPoolSize}</value>
</property>
<!--连接池中保留的最大连接数。Default: 15 -->
<property name="maxPoolSize">
<value>${jdbc.maxPoolSize}</value>
</property>
<!--初始化时获取的连接数,取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
<property name="initialPoolSize">
<value>${jdbc.initialPoolSize}</value>
</property>
</bean>
然后注册jdbcTemplate,使用上述dataSource
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
对于事务,要注册对应的事务管理器,这里使用的是dataSource,所以要使用DataSourceTransactionManager,下面可以看到不同的事务管理器
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
然后开启注解式的事务配置,即开启@Transactional的功能:
<tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager"/>
###3.3.3 项目使用分析
配置说完了,来看具体的业务代码了:
@Repository
public class UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Transactional
public void save(User user){
jdbcTemplate.update("insert into user(name,age) value(?,?)",user.getName(),user.getAge());
}
}
和之前的jdbc开发相比,就非常简洁了,一行代码就可以搞定。
来详细看下jdbcTemplate.update的执行过程,其实也是从dataSource中获取Connection,然后使用PreparedStatement这样的对象来完成对应的sql语句
源码如下:
Connection con = DataSourceUtils.getConnection(getDataSource());
PreparedStatement ps = null;
try {
Connection conToUse = con;
if (this.nativeJdbcExtractor != null &&
this.nativeJdbcExtractor.isNativeConnectionNecessaryForNativePreparedStatements()) {
conToUse = this.nativeJdbcExtractor.getNativeConnection(con);
}
ps = psc.createPreparedStatement(conToUse);
applyStatementSettings(ps);
PreparedStatement psToUse = ps;
if (this.nativeJdbcExtractor != null) {
psToUse = this.nativeJdbcExtractor.getNativePreparedStatement(ps);
}
T result = action.doInPreparedStatement(psToUse);
handleWarnings(ps);
return result;
}
我们再来看看,它又是如何来实现事务功能的。首先我们知道jdbcTemplate原理是就是对jdbc的封装,要想实现事务的功能,也必须对Connection执行以下的事务代码:
conn.commit();
conn.rollback();
我们还知道一个重要信息就是: <font color=red>
- jdbc中执行sql的Connection和执行事务功能的的Connection必须是同一个Connection
这是非常需要明确的一点,因为后面要实现业务代码和事务代码的分离,所以必须要确保分离之后的两者使用的是同一个Connection,否则事务是不起作用的。 </font>
而Spring的@Transactional背后,则是使用SpringAOP来对我们的UserDao进行了代理。代理的方式有2种,jdk代理或者cglib代理。 如UserDao的实例是我们要代理的对象,暂且称作target
- jdk代理针对那些实现了相应的接口的类,创建出的代理对象也是实现了同样的接口,同时该代理对象包含一个target
- cglib代理针对类都可以进行代理,创建出的代理对象是继承了target类,同时该代理对象内部包含一个target
上述的具体细节见我的博客SpringAOP源码分析系列
而我们采用的事务注解配置是:
<tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager"/>
中采用的是proxy-target-class="true" 表示我们要使用cglib来进行代理,所以我们在使用UserDao的时候其实是使用的代理对象,这个代理对象其实是继承了UserDao,同时内部包含一个UserDao的实例,如下所示:
这个代理对象加入了事务拦截器TransactionInterceptor,可以想象成在真正执行代理对象内部target的save方法时,代理对象已经在外部进行了一层try catch包裹,在执行save的过程中,一旦发现异常,就使用transactionManager来进行事务的回滚。
而我们使用的transactionManager是DataSourceTransactionManager,它对事物的回滚也是通过Connection的rollback方法来完成的,DataSourceTransactionManager的源码如下:
@Override
protected void doRollback(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
}
try {
con.rollback();
}
catch (SQLException ex) {
throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
}
}
此时我们知道了jdbcTemplate.update方法使用Connection来完成sql功能,事务的提交和回滚也是通过Connection来完成的,只有这两个Connection是同一个Connection的时候,才能真正起到事务作用。jdbcTemplate.update方法使用Connection是通过DataSourceUtils来获取的Connection,这个Connection是和当前线程绑定的,DataSourceTransactionManager进行事务的提交和回滚所使用的Connection也是和当前线程绑定的,所以他们是同一个Connection。具体的验证比较麻烦,原理就是使用ThreadLocal策略,可自行查看源码
jdbcTemplate只是简化了开发,仍然使用手写sql的方式来开发,没有使用orm,接下来就看看orm框架hibernate
##3.4 Hibernate的原生xml方式开发和事务的使用
###3.4.1 项目地址
该案例是项目spring-hibernate-xml
###3.4.2 项目配置
hibernate的原生xml方式涉及到2种配置文件
-
hibernate.cfg.xml : 用于配置数据库连接和方言等等
<hibernate-configuration> <session-factory name="hibernateSessionFactory"> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">ligang</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.show_sql">true</property> <property name="hibernate.default_schema">test</property> <mapping resource="hibernate/mapping/User.hbm.xml"/> </session-factory> </hibernate-configuration>
-
User.hbm.xml:用于配置实体User和数据库user表之间的关系
<hibernate-mapping> <class name="com.demo.entity.User" table="user"> <id name="id" column="id" type="long"> <generator class="identity"/> </id> <property name="name" column="name" type="string"/> <property name="age" column="age" type="int"/> </class> </hibernate-mapping>
然后就是怎么使用hibernate原生的api来加载这两个文件。
-
加载hibernate.cfg.xml
Configuration config=new Configuration(); config.configure("hibernate/base/hibernate.cfg.xml"); sessionFactory=config.buildSessionFactory();
其中的文件路径是classpath路径下的hibernate/base/hibernate.cfg.xml。
如果使用的是
config.configure();
则默认加载的是classpath路径下的hibernate.cfg.xml文件
-
加载User.hbm.xml(如下三种方式)
-
1 直接在hibernate.cfg.xml文件中引入该文件
如上述hibernate.cfg.xml方式
-
2 使用代码添加类
config.addClass(User.class);
这种方式会在User类所在路径下寻找 User.cfg.xml文件
-
3 使用代码添加资源映射文件
config.addResource("hibernate/mapping/User.cfg.xml");
这种方式会在classpath路径下寻找hibernate/mapping/User.cfg.xml。
-
注意,写路径的时候不要再写classpath: 了。
###3.4.3 主要的对象
SessionFactory、Session、Transaction 这些都是hibernate的原生的对象
-
SessionFactory
刚才加载hibernate.cfg.xml配置文件就产生了这样的一个session工厂,它负责创建session
-
Session
简单理解起来就是:Session和jdbc中一个Connection差不多,Session对Connection进行了封装
-
Transaction
是hibernate自己的事务对象接口定义,通过session可以开启一个事务,使用如下:
Transaction tx=null; try { tx=session.beginTransaction(); session.save(user); tx.commit(); } catch (Exception e) { if(tx!=null){ tx.rollback(); } }finally{ session.close(); }
###3.4.4 具体的使用和事务分析
使用方式就是如下:
@Repository
public class HibernateDao {
private SessionFactory sessionFactory;
public HibernateDao(){
Configuration config=new Configuration();
config.configure("hibernate/base/hibernate.cfg.xml");
sessionFactory=config.buildSessionFactory();
}
public Session openSession(){
return sessionFactory.openSession();
}
}
public class UserDao {
@Autowired
private HibernateDao hibernateDao;
public void save(User user){
Session session=hibernateDao.openSession();
Transaction tx=null;
try {
tx=session.beginTransaction();
session.save(user);
tx.commit();
} catch (Exception e) {
if(tx!=null){
tx.rollback();
}
}finally{
session.close();
}
}
}
先根据hibernate.cfg.xml配置文件来创建SessionFactory,然后我们每次就可以通过SessionFactory来获取一个Session,然后通过Session来开启一个事务Transaction,来回滚或者提交。
这里其实对业务代码和事务代码做了一定的分离:
- 业务代码由Session来完成
- 事务代码由Transaction来完成
我们就需要明确的一点就是,这两个对象的Connection必须是同一个Connection。
对于这个Transaction是如何实现的呢?来看下Transaction接口的实现类:
JdbcTransaction、JtaTransaction、CMTTransaction
我们来看下JdbcTransaction:
public class JdbcTransaction extends AbstractTransactionImpl {
private Connection managedConnection;
protected void doBegin() {
try {
if ( managedConnection != null ) {
throw new TransactionException( "Already have an associated managed connection" );
}
managedConnection = transactionCoordinator().getJdbcCoordinator().getLogicalConnection().getConnection();
wasInitiallyAutoCommit = managedConnection.getAutoCommit();
if ( wasInitiallyAutoCommit ) {
LOG.debug( "disabling autocommit" );
managedConnection.setAutoCommit( false );
}
}
}
protected void doCommit() throws TransactionException {
try {
managedConnection.commit();
}
//略
}
protected void doRollback() throws TransactionException {
try {
managedConnection.rollback();
}
//略
}
}
从其中可以看到,JdbcTransaction内部也是拥有一个Connection的,事务的提交和回滚等操作都是通过这个Connection来完成的。而这个Connection来自于Session。所以他们也保证了业务代码和事务代码所使用的Connection是同一个Connection。
对于JtaTransaction,不再详细去说明,可以参考下这两篇文章:
##3.5 hibernate的原生xml方式与spring集成以及事务的使用
###3.5.1 项目地址
该该案例是项目spring-hibernate-xml-tx
###3.5.2 配置
其实上面已经说到Hibernate的事务,如果想使用spring的@Transactional来使业务代码和事务代码进行分离,可以如下操作:
-
第一步:注册dataSource
前一个项目使用的hibernate,并没有使用dataSource。
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass"> <value>${jdbc.driverClass}</value> </property> <property name="jdbcUrl"> <value>${jdbc.url}</value> </property> <property name="user"> <value>${jdbc.user}</value> </property> <property name="password"> <value>${jdbc.password}</value> </property> <!--连接池中保留的最小连接数。--> <property name="minPoolSize"> <value>${jdbc.minPoolSize}</value> </property> <!--连接池中保留的最大连接数。Default: 15 --> <property name="maxPoolSize"> <value>${jdbc.maxPoolSize}</value> </property> <!--初始化时获取的连接数,取值应在minPoolSize与maxPoolSize之间。Default: 3 --> <property name="initialPoolSize"> <value>${jdbc.initialPoolSize}</value> </property> </bean>
-
第二步:使用spring的LocalSessionFactoryBean来创建SessionFactory
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> <property name="mappingResources"> <list> <value>hibernate/mapping/User.hbm.xml</value> </list> </property> <property name="hibernateProperties"> <value> hibernate.dialect=org.hibernate.dialect.MySQLDialect hibernate.show_sql=true </value> </property> </bean>
这种创建方式相当于前面的通过核心配置文件hibernate.cfg.xml来创建SessionFactory的方式。
同样有数据库的连接信息和hibernate的其他的一些设置,只不过数据库连接信息交给了dataSource。
-
第三步:注册hibernate的事务管理器 HibernateTransactionManager
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /> </bean>
HibernateTransactionManager依赖于上述sessionFactory
-
第四步:启用spring的@Transactional的注解支持
<tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager"/>
使用上述的事务管理器
###3.5.3 使用和事务分析
@Repository
public class UserDao {
@Autowired
private SessionFactory sessionFactory;
@Transactional
public void save(User user){
//Session session=sessionFactory.openSession();
Session session=sessionFactory.getCurrentSession();
session.save(user);
throw new RuntimeException();
}
}
sessionFactory.openSession()是新开启一个session,sessionFactory.getCurrentSession()是获取当前线程绑定的session,只不过这时候必须使用sessionFactory.getCurrentSession()才能使事务有效,还是为了保证业务代码中使用的session和事务代码中使用的session是同一个session(这样的话,就可以保证他们使用的connection是同一个connection)。
所以这里需要进一步封装,使得用户获取session的时候,都是通过sessionFactory.getCurrentSession()来获取的
来详细了解下save方法的整个前前后后:
-
1 在执行save方法之前,使用了HibernateTransactionManager开启了相应的事务
- 1.1 先使用sessionFactory的openSession()来创建一个session
- 1.2 使用这个的session从dataSource中获取了一个connection
- 1.3 使用session的getTransaction方法开启了一个Hibernate的一个Transaction事务
- 1.4 把这个connection绑定到了当前线程
- 1.5 把当前session绑定到当前线程
源码如下:
protected void doBegin(Object transaction, TransactionDefinition definition) { HibernateTransactionObject txObject = (HibernateTransactionObject) transaction; Session session = null; try { if (txObject.getSessionHolder() == null || txObject.getSessionHolder ().isSynchronizedWithTransaction()) { //1.1 先使用sessionFactory的openSession()来创建一个session Interceptor entityInterceptor = getEntityInterceptor(); Session newSession = (entityInterceptor != null ? getSessionFactory().withOptions().interceptor(entityInterceptor) .openSession() : getSessionFactory().openSession()); txObject.setSession(newSession); } session = txObject.getSessionHolder().getSession(); if (this.prepareConnection && isSameConnectionForEntireSession(session)) { //1.2 使用这个的session从dataSource中获取了一个connection Connection con = ((SessionImplementor) session).connection(); Integer previousIsolationLevel = DataSourceUtils. prepareConnectionForTransaction(con, definition); txObject.setPreviousIsolationLevel(previousIsolationLevel); } Transaction hibTx; int timeout = determineTimeout(definition); if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) { //1.3 使用session的getTransaction方法开启了一个Hibernate的一个Transaction事务 hibTx = session.getTransaction(); hibTx.setTimeout(timeout); hibTx.begin(); } else { // Open a plain Hibernate transaction without specified timeout. hibTx = session.beginTransaction(); } // Add the Hibernate transaction to the session holder. txObject.getSessionHolder().setTransaction(hibTx); // Register the Hibernate Session's JDBC Connection for the DataSource, if set. if (getDataSource() != null) { //1.4 把这个connection绑定到了当前线程 Connection con = ((SessionImplementor) session).connection(); ConnectionHolder conHolder = new ConnectionHolder(con); TransactionSynchronizationManager.bindResource(getDataSource(), conHolder); txObject.setConnectionHolder(conHolder); } // Bind the session holder to the thread. if (txObject.isNewSessionHolder()) { //1.5 把当前session绑定到当前线程 TransactionSynchronizationManager.bindResource( getSessionFactory(), txObject.getSessionHolder()); } txObject.getSessionHolder().setSynchronizedWithTransaction(true); }
}
-
2 我们通过使用sessionFactory.getCurrentSession()就获取到了当前线程绑定的session,就是上述方式创建的session
-
3 使用session来持久化user
-
4 当抛出异常的时候,获取与当前线程绑定的sessiion,再获取其事务,就是步骤1中创建的事务,使用该事务进行回滚操作
源码如下:
protected void doRollback(DefaultTransactionStatus status) { HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction(); try { txObject.getSessionHolder().getTransaction().rollback(); } }
##3.6 hibernate的原生注解方式开发和事务的使用
有了xml方式的经验后,就很容易理解注解方式了,不同点就是前者以实体映射的xml文件告诉sessionFactory,后者以类所在的包的形式告诉sessionFactory,所以可以参考Hibernate的原生xml方式开发和事务的使用
###3.6.1 项目地址
###3.6.2 配置
注解方式,就是把User实体的映射文件,改成注解配置,如下:
@Entity
@Table(name="user")
public class User {
@Id
@GeneratedValue
private Long id;
private String name;
private int age;
}
这里的注解用的是javax.persistence包中的注解。然后就是如何让hibernate知道User是一个实体呢?在hibernate的核心配置文件中hibernate.cfg.xml,这样来声明,使用mapping class:
<hibernate-configuration>
<session-factory name="hibernateSessionFactory">
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.password">ligang</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.default_schema">test</property>
<mapping class="com.demo.entity.User"/>
</session-factory>
</hibernate-configuration>
##3.7 hibernate的注解方式开发与Spring集成和事务的使用
可以参考参考hibernate的原生xml方式与spring集成以及事务的使用
###3.7.1 项目地址
###3.7.2 配置与使用
参考hibernate的原生xml方式与spring集成以及事务的使用
他们的不同点还是将User实体告诉sessionFactory的方式不同,如下:
-
xml方式:
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> <property name="mappingResources"> <list> <value>hibernate/mapping/User.hbm.xml</value> </list> </property> //其他略 </bean>
-
注解方式:
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> <property name="packagesToScan"> <list> <value>com.demo.entity</value> </list> </property> //其他略 </bean>
#4 未完待续
内容很多了,下一篇文章再介绍
欢迎关注微信公众号:乒乓狂魔