概述:
还像往常一样先了解下基础知识:
Hibernate是一个开源的ORM框架,能自动为对象生成相应SQL并透明的持久化对象到数据库,我们首先来了解一下什么是“ORM”。
ORM全称对象关系映射(Object/Relation Mapping),指将Java对象状态自动映射到关系数据库中的数据上,从而提供透明化的持久化支持,即把一种形式转化为另一种形式。
对象与关系数据库之间是不匹配,我们把这种不匹配称为阻抗失配,主要表现在:
其中这些阻抗失配只是其中的一小部分,比如还有如何将SQL集合函数结果集映射到对象,如何在对象中处理主键等。ORM框架就是用来解决这种阻抗失配,提供关系数据库的对象化支持。
目前已经有许多ORM框架产生,如Hibernate、JDO、JPA、iBATIS等等,这些ORM框架各有特色,Spring对这些ORM框架提供了很好的支持。
集中式声明事务管理源码下载 注解式事务管理源码下载 结合原文更容易理解
Hibernate是一个开源的ORM框架,能自动为对象生成相应SQL并透明的持久化对象到数据库,我们首先来了解一下什么是“ORM”。
ORM全称对象关系映射(Object/Relation Mapping),指将Java对象状态自动映射到关系数据库中的数据上,从而提供透明化的持久化支持,即把一种形式转化为另一种形式。
对象与关系数据库之间是不匹配,我们把这种不匹配称为阻抗失配,主要表现在:
- 关系数据库首先不支持面向对象技术,如继承、多态;
- 关系数据库是由表来存放数据,而面向对象使用对象来存放状态;
- 如何将对象透明的持久化到关系数据库表中;
其中这些阻抗失配只是其中的一小部分,比如还有如何将SQL集合函数结果集映射到对象,如何在对象中处理主键等。ORM框架就是用来解决这种阻抗失配,提供关系数据库的对象化支持。
目前已经有许多ORM框架产生,如Hibernate、JDO、JPA、iBATIS等等,这些ORM框架各有特色,Spring对这些ORM框架提供了很好的支持。
集中式声明事务管理源码下载 注解式事务管理源码下载 结合原文更容易理解
下面来看具体配置:
集中式声明事务管理:
pom.xml
![](https://img-my.csdn.net/uploads/201311/14/1384436663_4488.jpg)
1)先来看jar含义
虽然只加了这么几个包,但是来看看maven帮我们添加的最终依赖包,从这就可以看出maven管理项目的好处:
虽然不是每个包都被用到但是这样就会减少管理jar的繁琐,况且也可以手动的删除这些jar,maven还是很不错吧!
[INFO] antlr:antlr:jar:2.7.7:compile
一个语言转换工具,Hibernate利用它实现 HQL 到 SQL 的转换
[INFO] aopalliance:aopalliance:jar:1.0:compile
包含了针对面向切面的接口。
[INFO] com.alibaba:druid:jar:0.2.25:compile
阿里巴巴开发的一个高效的数据库连接池:druid。
[INFO] commons-logging:commons-logging:jar:1.1.1:compile
是使用Spring-core.jar的必备包
[INFO] dom4j:dom4j:jar:1.6.1:compile
dom4j XML 解析器
[INFO] junit:junit:jar:4.11:compile
测试工具
[INFO] mysql:mysql-connector-java:jar:5.1.26:compile
连接mysql插件
[INFO] org.aspectj:aspectjweaver:jar:1.7.3:compile
切面用到的包,也就是AOP
[INFO] org.hamcrest:hamcrest-core:jar:1.3:compile
是junit的依赖包,在4.11这个版本里,不包含这个包,4.8版本就不需要这个包
[INFO] org.hibernate:hibernate-core:jar:4.2.5.Final:compile
hibernate核心包
[INFO] org.hibernate.common:hibernate-commons-annotations:jar:4.0.2.Final:compile
hibernate的annotation必备包
[INFO] org.hibernate.javax.persistence:hibernate-jpa-2.0-api:jar:1.0.1.Final:compile
实体类中使用的注解都是在这个JAR包中定义的
[INFO] org.javassist:javassist:jar:3.15.0-GA:compile
代码生成工具, Hibernate用它在运行时扩展 Java类和实现,同cglib
[INFO] org.jboss.logging:jboss-logging:jar:3.1.0.GA:compile
Hibernate的默认包
[INFO] org.jboss.spec.javax.transaction:jboss-transaction-api_1.1_spec:jar:1.0.1.Final:compile
Hibernate的默认包
[INFO] org.springframework:spring-aop:jar:3.2.4.RELEASE:compile
这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性,如声明型事务管理(Declarative Transaction Management ),也要在应用里包含这 个jar包。
[INFO] org.springframework:spring-beans:jar:3.2.4.RELEASE:compile
这个jar文件是所有应用都要用到的,它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection(IoC/DI)操作相关的所有类。
springIoC(依赖注入)的基础实现
如果应用只需基本的IoC/DI支持,引入spring-core.jar及spring-beans.jar文件就可以了。
[INFO] org.springframework:spring-context:jar:3.2.4.RELEASE:compile
spring 提供在基础 IoC 功能上的扩展服务,此外还提供许多企业级服务的支持,如 邮件
服务、任务调度、JNDI定位、EJB 集成、远程访问、 缓存以及各种视图层框架的封装等。
[INFO] org.springframework:spring-core:jar:3.2.4.RELEASE:compile
这个jar文件包含Spring框架基本的核心工具类,Spring其它组件要都要使用到这个包里的类,是其它组件的基本核心,当然你也可以在自己的应用系统中使用这些工具类。
[INFO] org.springframework:spring-expression:jar:3.2.4.RELEASE:compile
spring 表达式语言也就是 spel表达式
[INFO] org.springframework:spring-jdbc:jar:3.2.4.RELEASE:compile
这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。
[INFO] org.springframework:spring-orm:jar:3.2.4.RELEASE:compile
这个jar文件包含Spring对DAO特性集进行了扩展,使其支持 iBATIS、JDO、OJB、TopLink,因为Hibernate已经独立成包了,现在不包含在这个包里了。这个jar文件里大部分的类都 要依赖 spring-dao.jar里的类,用这个包时你需要同时包含spring-dao.jar包。
[INFO] org.springframework:spring-tx:jar:3.2.4.RELEASE:compile
也就是spring对于事务的一些管理
虽然我们这个案例有很多没有用到的jar,但是不管怎么样至少我们不用对用哪个jar而烦心了,但是maven的添加也是由于根据包里所必须的类或方法而添加的虽然我们不用。
再来看一看包之间的依赖关系:
[INFO] +- junit:junit:jar:4.11:compile
[INFO] | \- org.hamcrest:hamcrest-core:jar:1.3:compile
[INFO] +- mysql:mysql-connector-java:jar:5.1.26:compile
[INFO] +- com.alibaba:druid:jar:0.2.25:compile
[INFO] +- org.springframework:spring-context:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-aop:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-beans:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-core:jar:3.2.4.RELEASE:compile
[INFO] | | \- commons-logging:commons-logging:jar:1.1.1:compile
[INFO] | \- org.springframework:spring-expression:jar:3.2.4.RELEASE:compile
[INFO] +- org.springframework:spring-orm:jar:3.2.4.RELEASE:compile
[INFO] | +- aopalliance:aopalliance:jar:1.0:compile
[INFO] | +- org.springframework:spring-jdbc:jar:3.2.4.RELEASE:compile
[INFO] | \- org.springframework:spring-tx:jar:3.2.4.RELEASE:compile
[INFO] +- org.hibernate:hibernate-core:jar:4.2.5.Final:compile
[INFO] | +- antlr:antlr:jar:2.7.7:compile
[INFO] | +- org.jboss.logging:jboss-logging:jar:3.1.0.GA:compile
[INFO] | +- dom4j:dom4j:jar:1.6.1:compile
[INFO] | +- org.jboss.spec.javax.transaction:jboss-transaction-api_1.1_spec:jar:1.0.1.Final:compile
[INFO] | +- org.hibernate.common:hibernate-commons-annotations:jar:4.0.2.Final:compile
[INFO] | \- org.javassist:javassist:jar:3.15.0-GA:compile
[INFO] +- org.aspectj:aspectjweaver:jar:1.7.3:compile
[INFO] \- org.hibernate.javax.persistence:hibernate-jpa-2.0-api:jar:1.0.1.Final:compile
明白了吧!!是不是对jar不是那么畏惧啦!!
虽然不是每个包都被用到但是这样就会减少管理jar的繁琐,况且也可以手动的删除这些jar,maven还是很不错吧!
[INFO] antlr:antlr:jar:2.7.7:compile
一个语言转换工具,Hibernate利用它实现 HQL 到 SQL 的转换
[INFO] aopalliance:aopalliance:jar:1.0:compile
包含了针对面向切面的接口。
[INFO] com.alibaba:druid:jar:0.2.25:compile
阿里巴巴开发的一个高效的数据库连接池:druid。
[INFO] commons-logging:commons-logging:jar:1.1.1:compile
是使用Spring-core.jar的必备包
[INFO] dom4j:dom4j:jar:1.6.1:compile
dom4j XML 解析器
[INFO] junit:junit:jar:4.11:compile
测试工具
[INFO] mysql:mysql-connector-java:jar:5.1.26:compile
连接mysql插件
[INFO] org.aspectj:aspectjweaver:jar:1.7.3:compile
切面用到的包,也就是AOP
[INFO] org.hamcrest:hamcrest-core:jar:1.3:compile
是junit的依赖包,在4.11这个版本里,不包含这个包,4.8版本就不需要这个包
[INFO] org.hibernate:hibernate-core:jar:4.2.5.Final:compile
hibernate核心包
[INFO] org.hibernate.common:hibernate-commons-annotations:jar:4.0.2.Final:compile
hibernate的annotation必备包
[INFO] org.hibernate.javax.persistence:hibernate-jpa-2.0-api:jar:1.0.1.Final:compile
实体类中使用的注解都是在这个JAR包中定义的
[INFO] org.javassist:javassist:jar:3.15.0-GA:compile
代码生成工具, Hibernate用它在运行时扩展 Java类和实现,同cglib
[INFO] org.jboss.logging:jboss-logging:jar:3.1.0.GA:compile
Hibernate的默认包
[INFO] org.jboss.spec.javax.transaction:jboss-transaction-api_1.1_spec:jar:1.0.1.Final:compile
Hibernate的默认包
[INFO] org.springframework:spring-aop:jar:3.2.4.RELEASE:compile
这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性,如声明型事务管理(Declarative Transaction Management ),也要在应用里包含这 个jar包。
[INFO] org.springframework:spring-beans:jar:3.2.4.RELEASE:compile
这个jar文件是所有应用都要用到的,它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection(IoC/DI)操作相关的所有类。
springIoC(依赖注入)的基础实现
如果应用只需基本的IoC/DI支持,引入spring-core.jar及spring-beans.jar文件就可以了。
[INFO] org.springframework:spring-context:jar:3.2.4.RELEASE:compile
spring 提供在基础 IoC 功能上的扩展服务,此外还提供许多企业级服务的支持,如 邮件
服务、任务调度、JNDI定位、EJB 集成、远程访问、 缓存以及各种视图层框架的封装等。
[INFO] org.springframework:spring-core:jar:3.2.4.RELEASE:compile
这个jar文件包含Spring框架基本的核心工具类,Spring其它组件要都要使用到这个包里的类,是其它组件的基本核心,当然你也可以在自己的应用系统中使用这些工具类。
[INFO] org.springframework:spring-expression:jar:3.2.4.RELEASE:compile
spring 表达式语言也就是 spel表达式
[INFO] org.springframework:spring-jdbc:jar:3.2.4.RELEASE:compile
这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。
[INFO] org.springframework:spring-orm:jar:3.2.4.RELEASE:compile
这个jar文件包含Spring对DAO特性集进行了扩展,使其支持 iBATIS、JDO、OJB、TopLink,因为Hibernate已经独立成包了,现在不包含在这个包里了。这个jar文件里大部分的类都 要依赖 spring-dao.jar里的类,用这个包时你需要同时包含spring-dao.jar包。
[INFO] org.springframework:spring-tx:jar:3.2.4.RELEASE:compile
也就是spring对于事务的一些管理
虽然我们这个案例有很多没有用到的jar,但是不管怎么样至少我们不用对用哪个jar而烦心了,但是maven的添加也是由于根据包里所必须的类或方法而添加的虽然我们不用。
再来看一看包之间的依赖关系:
[INFO] +- junit:junit:jar:4.11:compile
[INFO] | \- org.hamcrest:hamcrest-core:jar:1.3:compile
[INFO] +- mysql:mysql-connector-java:jar:5.1.26:compile
[INFO] +- com.alibaba:druid:jar:0.2.25:compile
[INFO] +- org.springframework:spring-context:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-aop:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-beans:jar:3.2.4.RELEASE:compile
[INFO] | +- org.springframework:spring-core:jar:3.2.4.RELEASE:compile
[INFO] | | \- commons-logging:commons-logging:jar:1.1.1:compile
[INFO] | \- org.springframework:spring-expression:jar:3.2.4.RELEASE:compile
[INFO] +- org.springframework:spring-orm:jar:3.2.4.RELEASE:compile
[INFO] | +- aopalliance:aopalliance:jar:1.0:compile
[INFO] | +- org.springframework:spring-jdbc:jar:3.2.4.RELEASE:compile
[INFO] | \- org.springframework:spring-tx:jar:3.2.4.RELEASE:compile
[INFO] +- org.hibernate:hibernate-core:jar:4.2.5.Final:compile
[INFO] | +- antlr:antlr:jar:2.7.7:compile
[INFO] | +- org.jboss.logging:jboss-logging:jar:3.1.0.GA:compile
[INFO] | +- dom4j:dom4j:jar:1.6.1:compile
[INFO] | +- org.jboss.spec.javax.transaction:jboss-transaction-api_1.1_spec:jar:1.0.1.Final:compile
[INFO] | +- org.hibernate.common:hibernate-commons-annotations:jar:4.0.2.Final:compile
[INFO] | \- org.javassist:javassist:jar:3.15.0-GA:compile
[INFO] +- org.aspectj:aspectjweaver:jar:1.7.3:compile
[INFO] \- org.hibernate.javax.persistence:hibernate-jpa-2.0-api:jar:1.0.1.Final:compile
明白了吧!!是不是对jar不是那么畏惧啦!!
(1).maven-compiler-plugin:
<!-- compiler插件, 设定JDK版本 -->
maven-compiler-plugin用来编译Java代码
(2).maven-war-plugin:
<!-- war插件用于打包成war项目 -->
使用maven-war-plugin这个插件可以在执行打包命令的时候指定我要打哪个环境的包, 而不需要去关注我现在要用什么配置文件了.当然只适用于Maven项目.
虽然不是web项目但是可以把这个项目当脚手架啊!还会扩展成web项目的所以先加上吧!
(3).maven-resources-plugin:
<!-- resource插件, 设定编码 -->
maven-compiler-plugin用来编译Java代码,maven-resources-plugin则用来处理资源文件。默认的主资源文件目录是src/main/resources,很多用户会需要添加额外的资源文件目录,这个时候就可以通过配置maven-resources-plugin来实现。
此外,资源文件过滤也是Maven的一大特性,你可以在资源文件中使用${propertyName}形式的Maven属性,然后配置maven-resources-plugin开启对资源文件的过滤,之后就可以针对不同环境通过命令行或者Profile传入属性的值,以实现更为灵活的构建。
xml、properties文件都是资源文件,编码的时候遇到中文总要进行转码!用什么编码?UTF-8,那就记得强制
(4).maven-jar-plugin
用于打成jar包
(5). maven-source-plugin:
<!-- 源码插件 -->
maven-source-plugin提供项目自动将源码打包并发布的功能
(6). maven-clean-plugin:
清除target 文件夹下由install产生的一些东西例如 war
(7). maven-install-plugin:
用于自动安装项目的主要工件(JAR、WAR或EAR),其POM和任何附加构件(来源、javadoc等)所产生的一个特定的项目。
(8). maven-dependency-plugin:
maven-dependency-plugin最大的用途是帮助分析项目依赖,dependency:list能够列出项目最终解析到的依赖列表,dependency:tree能进一步的描绘项目依赖树,dependency:analyze可以告诉你项目依赖潜在的问题,如果你有直接使用到的却未声明的依赖
,该目标就会发出警告。maven-dependency-plugin还有很多目标帮助你操作依赖文件,例如dependency:copy-dependencies能将项目依赖从本地Maven仓库复制到某个特定的文件夹下面。
<!-- compiler插件, 设定JDK版本 -->
maven-compiler-plugin用来编译Java代码
(2).maven-war-plugin:
<!-- war插件用于打包成war项目 -->
使用maven-war-plugin这个插件可以在执行打包命令的时候指定我要打哪个环境的包, 而不需要去关注我现在要用什么配置文件了.当然只适用于Maven项目.
虽然不是web项目但是可以把这个项目当脚手架啊!还会扩展成web项目的所以先加上吧!
(3).maven-resources-plugin:
<!-- resource插件, 设定编码 -->
maven-compiler-plugin用来编译Java代码,maven-resources-plugin则用来处理资源文件。默认的主资源文件目录是src/main/resources,很多用户会需要添加额外的资源文件目录,这个时候就可以通过配置maven-resources-plugin来实现。
此外,资源文件过滤也是Maven的一大特性,你可以在资源文件中使用${propertyName}形式的Maven属性,然后配置maven-resources-plugin开启对资源文件的过滤,之后就可以针对不同环境通过命令行或者Profile传入属性的值,以实现更为灵活的构建。
xml、properties文件都是资源文件,编码的时候遇到中文总要进行转码!用什么编码?UTF-8,那就记得强制
(4).maven-jar-plugin
用于打成jar包
(5). maven-source-plugin:
<!-- 源码插件 -->
maven-source-plugin提供项目自动将源码打包并发布的功能
(6). maven-clean-plugin:
清除target 文件夹下由install产生的一些东西例如 war
(7). maven-install-plugin:
用于自动安装项目的主要工件(JAR、WAR或EAR),其POM和任何附加构件(来源、javadoc等)所产生的一个特定的项目。
(8). maven-dependency-plugin:
maven-dependency-plugin最大的用途是帮助分析项目依赖,dependency:list能够列出项目最终解析到的依赖列表,dependency:tree能进一步的描绘项目依赖树,dependency:analyze可以告诉你项目依赖潜在的问题,如果你有直接使用到的却未声明的依赖
,该目标就会发出警告。maven-dependency-plugin还有很多目标帮助你操作依赖文件,例如dependency:copy-dependencies能将项目依赖从本地Maven仓库复制到某个特定的文件夹下面。
数据库
- CREATE TABLE `user` (
- `id` int(10) NOT NULL auto_increment,
- `name` varchar(30) default NULL,
- `age` int(3) default NULL,
- PRIMARY KEY (`id`)
- )
applicationContext-dataSource.xml
- <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
- init-method="init" destroy-method="close">
- <property name="url" value="jdbc:mysql://localhost:3306/test2" />
- <property name="username" value="root" />
- <property name="password" value="123" />
- <property name="initialSize" value="1" />
- <property name="maxActive" value="20" />
- </bean>
数据源,druid连接池的简单配置
applicationContext-hibernate.xml
- <import resource="applicationContext-dataSource.xml" />
- <bean id="sessionFactory"
- class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
- <property name="dataSource" ref="dataSource" />
- <property name="packagesToScan" value="com.entity" /><!--自动扫描指定的包下面注解的实体类,也就是User类 -->
- <property name="hibernateProperties">
- <props>
- <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
- <prop key="hibernate.show_sql">true</prop>
- <prop key="hibernate.format_sql">false</prop>
- <prop key="hibernate.use_sql_comments">false</prop>
- <prop key="hibernate.cache.use_second_level_cache">false</prop>
- </props>
- </property>
- </bean>
- <!-- start spring集中式声明 -->
- <tx:advice id="txAdvice" transaction-manager="transactionManager">
- <tx:attributes>
- <tx:method name="saveUser*" />
- <tx:method name="saveUserThrowException*" rollback-for="Exception"/>
- <tx:method name="findUsers*" <span style="font-family: Arial, Helvetica, sans-serif;">read-only="true"</span><span style="font-family: Arial, Helvetica, sans-serif;">/></span>
- <!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到session-->
- <tx:method name="*" propagation="REQUIRED" />
- </tx:attributes>
- </tx:advice>
- <aop:config>
- <aop:pointcut id="productServiceMethods" expression="execution(* com.service..*.*(..))"/>
- <aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods" />
- </aop:config>
- <!-- spring集中式声明 -->
- <bean id="userService" class="com.service.impl.UserService">
- <property name="userDao">
- <bean class="com.dao.impl.UserDaoImpl">
- <property name="sessionFactory" ref="sessionFactory"></property>
- </bean>
- </property>
- </bean>
- <!-- 事务管理器 -->
- <bean id="transactionManager"
- class="org.springframework.orm.hibernate4.HibernateTransactionManager">
- <property name="sessionFactory" ref="sessionFactory" />
- </bean>
下面我们来看看这个配置文件各个参数的作用吧!
1).<import resource="applicationContext-dataSource.xml" />导入数据源
2).<bean id="sessionFactory"
class=" org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" /> <!--把dataSource链接进来-->
<property name="packagesToScan" value="com.entity" /> <!--自动扫描指定的包下面注解的实体类,也就是User类 -->
<property name="hibernateProperties"> <!--配置hibernate的属性-->
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <!--定义mysql方言-->
<prop key="hibernate.show_sql">true</prop> <!--输出所有SQL语句到控制台-->
<prop key="hibernate.format_sql">false</prop> <!--在log和console中打印出更漂亮的SQL-->
<prop key="hibernate.use_sql_comments">false</prop> <!--如果开启, Hibernate将在SQL中生成有助于调试的注释信息-->
<prop key="hibernate.cache.use_second_level_cache">false</prop> <!--能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定<cache>的类,会默认开启二级缓存-->
</props>
</property>
</bean>
3).<!-- start spring集中式声明 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="saveUser*" />
<tx:method name="saveUserThrowException*" rollback-for="Exception"/>
<tx:method name="findUsers*" read-only="true"/>
<!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到session-->
<tx:method name="*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="productServiceMethods" expression="execution(* com.service..*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods" />
</aop:config>
<!-- spring集中式声明 -->
集中式声明也就是采用AOP的方式,进行拦截式声明
我们再来了解下expression的表达式作用:
* com.service..*.*(..)
第一个*代表所有的返回值类型
第二个*代表所有的类
第三个*代表类所有方法
最后一个(..)代表所有的参数。
service.. 意思是:service包或者子包
service. 意思是:service包
再来了解下网上给的常见的例子:我再详细解释下
4).<bean id="userService" class="com.service.impl.UserService">
<property name="userDao">
<bean class="com.dao.impl.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</property>
</bean>
把dao注入到service中而没有采用,注解的方式自动装载
5). <!-- 事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
这个不用多说了吧!一个事务的管理器
1).<import resource="applicationContext-dataSource.xml" />导入数据源
2).<bean id="sessionFactory"
class=" org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" /> <!--把dataSource链接进来-->
<property name="packagesToScan" value="com.entity" /> <!--自动扫描指定的包下面注解的实体类,也就是User类 -->
<property name="hibernateProperties"> <!--配置hibernate的属性-->
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <!--定义mysql方言-->
<prop key="hibernate.show_sql">true</prop> <!--输出所有SQL语句到控制台-->
<prop key="hibernate.format_sql">false</prop> <!--在log和console中打印出更漂亮的SQL-->
<prop key="hibernate.use_sql_comments">false</prop> <!--如果开启, Hibernate将在SQL中生成有助于调试的注释信息-->
<prop key="hibernate.cache.use_second_level_cache">false</prop> <!--能用来完全禁止使用二级缓存. 对那些在类的映射定义中指定<cache>的类,会默认开启二级缓存-->
</props>
</property>
</bean>
3).<!-- start spring集中式声明 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="saveUser*" />
<tx:method name="saveUserThrowException*" rollback-for="Exception"/>
<tx:method name="findUsers*" read-only="true"/>
<!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到session-->
<tx:method name="*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="productServiceMethods" expression="execution(* com.service..*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="productServiceMethods" />
</aop:config>
<!-- spring集中式声明 -->
集中式声明也就是采用AOP的方式,进行拦截式声明
我们再来了解下expression的表达式作用:
* com.service..*.*(..)
第一个*代表所有的返回值类型
第二个*代表所有的类
第三个*代表类所有方法
最后一个(..)代表所有的参数。
service.. 意思是:service包或者子包
service. 意思是:service包
再来了解下网上给的常见的例子:我再详细解释下
- 任意公共方法的执行:大概意思是符合 public *(所有返回值) *(所有方法名) (..)(所有的参数)
- execution(public * *(..))
- 任何一个以“set”开始的方法的执行:*(所有返回值) set*(所有名) (..)(所有的参数)
- execution(* set*(..))
- AccountService 接口的任意方法的执行:*(所有返回值) .*(所有方法名) (..)(所有的参数)
- execution(* com.xyz.service.AccountService.*(..))
- 定义在service包里的任意方法的执行:*(所有返回值) .*(service包下的所有类) .*(所有方法名) (..)(所有的参数)
- execution(* com.xyz.service.*.*(..))
- 定义在service包或者子包里的任意类的任意方法的执行:*(所有返回值) ..*(service包或子包下的所有类) .*(所有方法名) (..)(所有的参数)
- execution(* com.xyz.service..*.*(..))
4).<bean id="userService" class="com.service.impl.UserService">
<property name="userDao">
<bean class="com.dao.impl.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</property>
</bean>
把dao注入到service中而没有采用,注解的方式自动装载
5). <!-- 事务管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
这个不用多说了吧!一个事务的管理器
至此集中式声明就配置完毕啦!!
下面再来看看dao service test吧!
IUserDao.java
- public interface IUserDao {
- public void save(User user);
- public List<User> query(String sql,Object[] args);
- }
UserDaoImpl.java
- public class UserDaoImpl extends AbstractHibernateDao<User> implements IUserDao {
- public UserDaoImpl() {
- super(User.class);
- }
- }
AbstractHibernateDao.java
- public abstract class AbstractHibernateDao <E extends Serializable>{
- private Class<E> entityClass;
- private SessionFactory sessionFactory;
- protected AbstractHibernateDao(Class<E> entityClass) {
- this.entityClass = entityClass;
- }
- public Session getCurrentSession() {
- return sessionFactory.getCurrentSession();
- }
- public E findById(Serializable id) {
- return (E) getCurrentSession().get(entityClass, id);
- }
- public void save(E e) {
- getCurrentSession().save(e);
- }
- public void delete(E e) {
- getCurrentSession().delete(e);
- }
- public List<E> query(String hql, Object[] args) {
- Query query=getCurrentSession().createQuery(hql);
- if(args!=null){
- for (int i = 0; i < args.length; i++) {
- query.setParameter(i, args[i]);
- }
- }
- return query.list();
- }
- public Class<E> getEntityClass() {
- return entityClass;
- }
- public void setEntityClass(Class<E> entityClass) {
- this.entityClass = entityClass;
- }
- public SessionFactory getSessionFactory() {
- return sessionFactory;
- }
- public void setSessionFactory(SessionFactory sessionFactory) {
- this.sessionFactory = sessionFactory;
- }
- }
User.java
- @Entity
- @Table(name="user")
- public class User implements Serializable{
- private static final long serialVersionUID = 1724315528421427938L;
- @Id
- @GeneratedValue(strategy=GenerationType.IDENTITY)
- @Column(name = "id", nullable = false)
- private Long id;
- @Column(name="name",nullable=true,length=25)
- private String name;
- @Column(name="age",nullable=true)
- private Integer age;
- ........
- set...
- get...
- ........
- @Override
- public String toString() {
- return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
- }
- }
IUserService.java
- public interface IUserService {
- void saveUser();
- void saveUserThrowException() throws Exception;
- void findUsers();
- }
UserService.java
- public class UserService implements IUserService{
- private IUserDao userDao;
- public IUserDao getUserDao() {
- return userDao;
- }
- public void setUserDao(IUserDao userDao) {
- this.userDao = userDao;
- }
- public void saveUser() {
- User u1=new User();
- u1.setName("邵");
- u1.setAge(24);
- userDao.save(u1);
- User u2=new User();
- u2.setName("陈");
- u2.setAge(20);
- userDao.save(u2);
- }
- public void saveUserThrowException() throws Exception {
- User u1=new User();
- u1.setName("邵");
- u1.setAge(24);
- userDao.save(u1);
- if(1+1>1){
- throw new Exception("Runtime error...");//抛出一般的异常:Exception
- }
- User u2=new User();
- u2.setName("陈");
- u2.setAge(20);
- userDao.save(u2);
- }
- public void findUsers() {
- List<User> users=userDao.query("from User where name=?", new Object[]{"邵"});
- for (User user : users) {
- System.out.println(user);
- }
- }
- }
SpringHibernateTest.java
- public class SpringHibernateTest {
- private static ApplicationContext ctx = null;
- @BeforeClass
- public static void onlyOnce() {
- ctx = new ClassPathXmlApplicationContext("applicationContext-hibernate.xml");
- }
- @Test
- public void testSave(){
- IUserService service=ctx.getBean("userService",IUserService.class);
- service.saveUser();
- }
- // @Test
- public void testSaveThrowException() throws Exception{
- IUserService service=ctx.getBean("userService",IUserService.class);
- service.saveUserThrowException();
- }
- @Test
- public void testJDBCDaoQuery(){
- IUserService service=ctx.getBean("userService",IUserService.class);
- service.findUsers();
- }
- }
注解式事务管理:
applicationContext-dataSource.xml
与上面声明式事务一样的配置
applicationContext-hibernate.xml
- <import resource="applicationContext-dataSource.xml" />
- <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
- <property name="dataSource" ref="dataSource" />
- <property name="packagesToScan" value="com.entity" />
- <property name="hibernateProperties">
- <props>
- <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
- <prop key="hibernate.show_sql">true</prop>
- <prop key="hibernate.format_sql">false</prop>
- <prop key="hibernate.use_sql_comments">false</prop>
- <prop key="hibernate.cache.use_second_level_cache">false</prop>
- </props>
- </property>
- </bean>
- <bean id="userService" class="com.service.impl.UserService">
- <property name="userDao">
- <bean class="com.dao.impl.UserDaoImpl">
- <property name="sessionFactory" ref="sessionFactory"></property>
- </bean>
- </property>
- </bean>
- <!-- 事务管理器 -->
- <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
- <property name="sessionFactory" ref="sessionFactory"/>
- </bean>
- <tx:annotation-driven transaction-manager="transactionManager"/><!--启动注解用注解来管理事务-->
<tx:annotation-driven transaction-manager="transactionManager"/>
它是注解配置事务的关键
AbstractHibernateDao、UserDaoImpl、IUserDao、User、IUserService的配置与声明式事务一样的配置
不一样的地方:
UserService.java
- @Transactional//默认propagation=Propagation.REQUIRED所以不像集中式声明那样都要配置
- public class UserService implements IUserService{
- private IUserDao userDao;
- public void saveUser() {
- User u1=new User();
- u1.setName("邵");
- u1.setAge(24);
- userDao.save(u1);
- //测试时,可以添加此异常,或去掉异常,测试Spring对事物的管理
- // if(1+1>1){
- // throw new RuntimeException("Runtime error...");//抛出运行时异常:RuntimeException
- // }
- User u2=new User();
- u2.setName("陈");
- u2.setAge(20);
- userDao.save(u2);
- }
- @Transactional(rollbackFor={Exception.class})
- public void saveUserThrowException() throws Exception {
- User u1=new User();
- u1.setName("邵");
- u1.setAge(24);
- userDao.save(u1);
- if(1+1>1){
- throw new Exception("Runtime error...");//抛出一般的异常:Exception
- }
- User u2=new User();
- u2.setName("陈");
- u2.setAge(20);
- userDao.save(u2);
- }
- @Transactional(readOnly=true)
- public void findUsers() {
- List<User> users=userDao.query("from User where name=?", new Object[]{"邵"});
- for (User user : users) {
- System.out.println(user);
- }
- }
- public IUserDao getUserDao() {
- return userDao;
- }
- public void setUserDao(IUserDao userDao) {
- this.userDao = userDao;
- }
- }
@Transactional//默认propagation=Propagation.REQUIRED所以不像集中式声明那样都要配置
@Transactional(readOnly=true) readOnly=true表明所注解的方法或类只是读取数据。
readOnly=false表明所注解的方法或类是增加,删除,修改数据。