37Spring框架

Posted 2020-11-04 fengfusheng

1. Spring框架

1）专业术语

高内聚、低耦合：

类内部的关系越紧密越好，类与类的关系越少越好！

非侵入式设计：

侵入式设计：

引入的组件对现有的类的结构会有影响，这种就是“侵入式设计”的组件！

非侵入式设计：

引入组件对现有的类的结构没有影响！

Struts2:     侵入式设计！

Hibernate:   非侵入式设计！

Spring, 非侵入式设计

IOC 容器

Inversion of control  控制反转

控制反转容器!   -à 对象创建的问题！

解释：

User user = new User();  自己控制对象的创建

现在需要对象，自己不创建，交给外部的容器创建，叫控制反转！

IOC容器= bean.xml配置 + ApplicationContext容器类

DI

dependency  injection 依赖注入

创建对象后，处理对象的依赖关系！

User  user = new User();

user.setAddress(..)  ;// 需要DI（依赖注入）

 

  Aop…

 

2）六大模块:

Spring Core：核心功能，主要提供IOC容器，创建对象/依赖关系

Spring AOP：面向切面编程

Spring Web：对Web开发的支持

Spring DAO ：对Jdbc操作的支持

Spring ORM：对hibernate/对象关系映射的支持

Spring JEE ：对JavaEE其他模块的支持。

2. Spring 第一个案例

1) 引入jar文件 (3.2版本) 在这个版本中，只有spring的核心功能，spring依赖的组件，需单独下载！ 例如：日志jar文件。

commons-logging-1.1.3.jar       【单独下载】 spring-beans-3.2.5.RELEASE.jar 【spring源码, bean节点管理】 spring-context-3.2.5.RELEASE.jar      【spring上下文类】 spring-core-3.2.5.RELEASE.jar         【IOC容器】 spring-expression-3.2.5.RELEASE.jar    【spring表达式】

2) 新建applicationContext.xml , 源码中拷贝约束（xml名称可改）

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:context="http://www.springframework.org/schema/context"     xsi:schemaLocation="         http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd"> </beans>

3) 配置

<!-- 创建Dao实例 --> <bean id="userDao" class="cn.itcast.dao.UserDao"></bean> <!-- 创建Service实例 --> <bean id="userService" class="cn.itcast.service.UserService"> <property name="userDao" ref="userDao"></property> </bean> <!-- 创建Action实例 --> <bean id="userAction" class="cn.itcast.action.UserAction"> <property name="userService" ref="userService"></property> </bean>

4）从IOC容器获取对象

// 容器对象(加载applicationContext.xml配置文件) ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); // 获取对象 UserAction userAction = (UserAction) ac.getBean("userAction"); userAction.execute();

3. Spring IOC 容器

1）bean配置细节

<!-- 把对象加入IOC容器 --> <!-- 细节1： id 与   name： id 不能以数字开头，不能含有特殊符号, 不能有空格、逗号等；  id 不能重复！ name 多个以空格或者逗号分隔。可以以数字开头，可以有特殊符合， 如果name值重复，编译没有问题但运行报错！ -->  <bean id="user" name="user2,user3 user4" class="cn.itcast.a_config.User"></bean> <!-- 细节2： (单例（同一个对象）/多例)  --> <!-- scope="singleton"   默认单例！ prototype表示多例 init-method="初始化方法"      在创建完对象之后执行初始化方法 destroy-method="销毁方法"   在调用容器类ac.destroy()时调用（单例有效） lazy-init="true"    延迟初始化，默认为False（单例有效）true表示第一次访问时才创建单例对象。 --> <bean id="user" class="cn.itcast.a_config.User"  init-method="init"  destroy-method="destroy_"  lazy-init="false"  scope="prototype"></bean> </beans>

2）创建对象的几种方式

1）无参数构造器 <bean id="user1" class="cn.itcast.b_create_obj.User">

2）有参数构造器 <bean id="user" class="cn.itcast.b_create_obj.User"> <constructor-arg value="Jack"></constructor-arg> <--ref:表示引用的是IOC容器中的对象--> <constructor-arg ref="user1"></constructor-arg> </bean>

3）工厂  <!-- * 工厂静态方法,创建对象 --> <!-- class 指定工厂的类；    factory-method: 工厂类的静态方法 --> <bean id="user1" class="cn.itcast.b_create_obj.UserFactory" factory-method="getStaticInstace"></bean>   <!-- * 非静态方法创建对象 -->  <!-- 先创建工厂实例 --> <bean id="factory" class="cn.itcast.b_create_obj.UserFactory"></bean> <bean id="user" factory-bean="factory" factory-method="getInstace"></bean>

3）DI依赖注入

就是给对象属性赋值的几种方式：

1) 构造函数赋值

2)  set方法注入值（最常用） <bean id="user" class="cn.itcast.c_di.User"> <property name="id" value="1000"></property> <!-- list集合赋值 --> <property name="list"> <list> <value>cn</value> <value>usa</value> </list> </property> <!-- map 集合赋值 --> <property name="map"> <map> <entry key="cn" value="China"></entry> </map> </property> <!-- Properties对象赋值 --> <property name="prop"> <props> <prop key="cn">China</prop> </props> </property> </bean>

3） p名称空间，给属性注入值 xmlns:p="http://www.springframework.org/schema/p" <bean id="userDao" class="cn.itcast.d_di2.UserDao"></bean> <bean id="userService" class="cn.itcast.d_di2.UserService" p:userDao-ref="userDao"></bean> <bean id="userAction" class="cn.itcast.d_di2.UserAction" p:userService-ref="userService"></bean>

4)自动装配(了解) <!-- a. default-autowire="byType"  配置到全局(配置到约束头上) 当前所有的bean都采用”根据类型自动装配“ b. 配置到bean节点 autowire="byName"  根据名称自动装配，会去容器找指定名称的对象，注入到set方法的参数中！ autowire="byType"  根据类型自动装配, 要确保该类型对应的对象在IOC容器中唯一，否则报错！ 总结：简化配置，但是维护麻烦！  --> <bean id="userService" class="cn.itcast.e_autowire.UserService" autowire="byName"  ></bean>

5)注解 <!-- 1. 开启注解扫描 --> <context:component-scan base-package="cn.itcast.f_anno"></context:component-scan> 代码中///把userDao对象加入IOC容器 @Component("userdao")  // <bean id=userDao class="...">（类名之前）

注解类型： 创建对象： @Component  表示一个组件(类)，把当前组件加入ioc容器  加入容器的组件的名称默认是类名第一个字母小写 @Component(“”)   指定加入ioc容器的组件类的类名 @Scope("prototype") 指定对象单例/多例 @Repository    标识是一个持久层的组件 @Service       标识是一个业务逻辑层的组件 @Controller     标识是一个控制层的组件 获取对象： @Resource     1. 默认根据修饰的字段名称会取ioc容器找对象自动注入 找到后注入   2. 如果名称没有找到，再根据类型查找  找到后就立刻注入      如果该类型在ioc容器中有多个对象，报错！   3. 根据类型也没有找到对象，报错！ @Resource(name =””) 会根据指定的名称去容器找对象自动注入

 

总结：

配置方式与注解方式:

1. 配置， 便于维护

(配置过多，比较繁琐)

2. 注解， 开发方便

(简化配置，不利于后期维护，如果修改对象创建、关系处理，需要改代码！)

4. 代理模式

Proxy, 表示代理！ 提供了对目标对象另外的访问方式，即通过代理访问目标对象！

1）静态代理

特点：

1. 目标对象必须要实现接口

2. 代理对象，要实现与目标对象一样的接口

缺点：

1. 代理对象，需要依赖目标对象的接口！

       如果接口功能变化，目标对象变化，会引入代理对象的变化!

2. 对每一个目标对象，都要分别写一个代理类，麻烦！

2）动态代理

动态代理：

1. 通常说的动态代理，就是指jdk代理!

       因为是通过jdk的api在运行时期，动态的生成代理对象的！

2. 目标对象一定要实现接口,  代理对象不用实现接口!

 

JDK 生成代理对象的Api

|-- Proxy  

static Object

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

参数loader : 当前目标对象使用的类加载器！

参数interfaces :  当前目标对象实现的接口

参数 h: 接口类型，事件处理器.

 

当执行目标对象方法的时候，会触发事件； 把当前执行的方法(method对象)，传入事件处理器方法参数中,  这样就可以根据业务逻辑，判断是否执行目标对象方法或扩展功能！

public class ProxyFactory { // 接收一个目标对象 private Object target; public ProxyFactory(Object target) { this.target = target; } // 返回对目标对象(target)代理后的对象(proxy) public Object getProxyInstance() { Object proxy = Proxy.newProxyInstance( target.getClass().getClassLoader(),  // 目标对象使用的类加载器 target.getClass().getInterfaces(),   // 目标对象实现的所有接口 new InvocationHandler() { // 执行代理对象方法时候触发 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("开启事务..."); // 执行目标对象方法 Object result = method.invoke(target, args); System.out.println("提交事务..."); return result; } } ); return proxy; } }

3）Cglib代理

u 也叫”子类代理”，在运行时动态在内存中构建子类对象的方法，从而对目标对象扩展。

u 当目标对象没有实现接口，就不能使用jdk提供的代理，可以以子类的方式实现！

u Spring也支持cglib代理，核心包中已经包含此功能！

l JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用Cglib实现。

l  Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

l  Cglib包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

//cglib代理：代理工厂，给多个目标对象生成代理对象！ public class ProxyFactory implements MethodInterceptor{ // 接收一个目标对象 private Object target; public ProxyFactory(Object target) { this.target = target; } // 返回目标对象代理后的子类对象 public Object getProxyInstance() { // 对target生成子类对象 // 字节码生成工具类 Enhancer en = new Enhancer(); // 设置父类 en.setSuperclass(target.getClass()); // 设置回调函数 en.setCallback(this); // 创建子类对象 return en.create(); } // 事件处理器，执行目标方法时候触发 @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("开启事务..."); Object result = method.invoke(target, args); System.out.println("提交事务..."); return result; } }

 

5. Aop编程

在SpringAop编程中，

如果目标对象有实现接口，spring使用jdk提供的代理生成代理对象！

如果目标对象没有实现接口，使用cglib代理！

如果目标没有实现接口、且为final , 不能进行aop编程，报错！不能生成代理！

Spring生成代理对象的过程？

1. 创建容器对象的时候，根据“切入点表达式”拦截的类，生成代理对象；

2. 如果目标对象有实现接口，使用jdk代理！

3. 如果目标对象没有实现接口，使用cglib代理！

4. 从容器获取代理后的对象

5. 执行代理对象的方法，在运行时期，动态植入“切面”类中的“通知”!

 

概念：

Aop 编程：Aspect Object Programming 面向切面编程! (使用jdk/cglib代理)

分离业务代码与关注点代码！在执行业务代码时候动态植入关注点代码！

关注点：

重复执行的代码, 也叫关注点代码!

切面：

关注点代码形成的类，就叫做切面（例如：事务，权限控制, 日志等）

切入点表达式：

拦截方法，给方法所在的类生成代理对象！

Spring在初始化容器的时候，会根据切入点表达式的规则，会给符合拦截规则的方法所在的类生成代理对象！

1）注解方式

1. 引入aop 相关 jar文件

(aspectj 在spring之前，面向切面开发的公用组件)

aopalliance.jar               【spring-framework-2.5.6\lib\aopalliance】

aspectjrt.jar    【spring-framework-2.5.6\lib\aspectj】

aspectjweaver.jar             【spring-framework-2.5.6\lib\aspectj】

spring-aop-3.2.5.RELEASE.jar    【Spring3.2源码】

2. 引入aop名称空间，开启aop注解

<beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:context="http://www.springframework.org/schema/context"     xmlns:aop="http://www.springframework.org/schema/aop"     xsi:schemaLocation="         http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd         http://www.springframework.org/schema/aop         http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启注解扫描 --> <context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan> <!-- 开启aop注解 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>

3. 使用Aop相关注解

@Aspect       指定一个类为切面类（切面类也需要实例化）

（切面类中的方法，也叫做通知）

@Before(“切入点表达式”) 前置通知【在执行目标对象方法之前执行】

@After(“切入点表达式”) 后置通知【在执行目标对象方法之后执行】

@AfterReturning() 返回通知【在执行完目标对象方法后执行，出现异常不执行】

@AfterThrowing()   异常通知【在执行目标对象方法出现异常时候执行】

@Around(“pointcut_”)  环绕通知【环绕目标方法执行】

@Pointcut       定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）

2）XML配置方式

步骤：

1. 引入aop 相关jar文件

2. bean.xml  引入aop名称空间

3. Aop配置

<!-- 实例dao对象 --> <bean id="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean> <!-- 实例化切面对象 --> <bean id="aop" class="cn.itcast.f_aop_xml.TransactionAop"></bean> <!-- Aop相关配置 --> <aop:config> <!-- 切入点表达式定义 --> <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.UserDao.*(..))" id="pt"/> <!-- 切面配置 --> <aop:aspect ref="aop"> <!-- 【前置通知】 在目标方法之前执行 --> <aop:before method="before" pointcut-ref="pt" /> <!-- 【环绕通知】 --> <aop:around method="方法名" pointcut-ref="pt"/> <!-- 【后置通知】 --> <aop:after method="方法名" pointcut-ref="pt"/> <!-- 【返回后通知】 --> <aop:after-returning method="方法名" pointcut-ref="pt"/ <!-- 异常通知 --> <aop:after-throwing method="方法名" pointcut-ref="pt"/> </aop:aspect> </aop:config> </beans>

3）切入点表达式语法详解

execution(

modifiers-pattern?    拦截的方法的访问修饰符

ret-type-pattern        方法返回类型，必须指定

declaring-type-pattern? 拦截的方法所在的类

name-pattern(param-pattern)   拦截的方法（以及方法的参数列表）

throws-pattern?)             方法声明的异常

?（表示0或1）

*（*代表任意）

参数（..表示任意）

execution(* 类名*（参数）)

1. 拦截指定的方法(通用) expression="execution(* cn.itcast.g_execution.UserDao.save())"  2. 拦截指定的类下所有的方法 expression="execution(* cn.itcast.g_execution.UserDao.*(..))" 3. 拦截指定包下所有的类的所有方法 expression="execution(* cn.itcast.g_execution.*.*(..))" 4. 拦截指定包，以及其子包下所有类的所有方法 expression="execution(* cn..*.*(..))" 5. 拦截所有的public方法 expression="execution(public * *(..))" 拦截所有的save方法 expression="execution(* save(..))" 拦截所有的包含save方法 expression="execution(* *save*(..))" 8. 拦截UserDao.save()方法与OrderDao.save() expression="execution(* cn..UserDao.save(..)) || execution(* cn..OrderDao.save(..))" expression="execution(* cn..UserDao.save(..)) or execution(* cn..OrderDao.save(..))" 9. 不拦截UserDao.save()方法 expression="!execution(* cn..UserDao.save(..))" expression=" not execution(* cn..UserDao.save(..))" 10. 拦截UserDao.save()同时拦截OrderDao.save() 注意： 这种很少用，一般都是或者的关系即: || 、 or expression="execution(* cn..UserDao.save(..)) and execution(* cn..OrderDao.save(..))" expression="execution(* cn..UserDao.save(..)) && execution(* cn..OrderDao.save(..))"

6. Spring 对jdbc模块的支持

Spring 对象Jdbc的支持，

Spring 对jdbc的操作进行了简化！

提供了JdbcTemplate模板工具类，简化jdbc的操作！

导包：

spring-jdbc-3.2.5.RELEASE.jar     工具类包

spring-tx-3.2.5.RELEASE.jar       事务支持依赖包

连接池、数据库驱动包！

jdbcTemplate方法： update(“sql”);增删改 query(“sql”,new MyRowMapper()，sql中的变量);

// 封装Springjdbc查询的结果集 class MyRowMapper implements RowMapper<Dept>{ // 如何解析一行 @Override public Dept mapRow(ResultSet rs, int rowNum) throws SQLException { Dept dept = new Dept(); dept.setId(rs.getInt("id")); dept.setName(rs.getString("deptName")); return dept; } }

7. Spring声明式事务管理

1）概念

n 事务是一组操作的执行单元，相对于数据库操作来讲，事务管理的是一组SQL指令，比如增加，修改，删除等，事务的一致性，要求，这个事务内的操作必须全部执行成功，如果在此过程种出现了差错，比如有一条SQL语句没有执行成功，那么这一组操作都将全部回滚

n 事务特性（ACID）

• Atomic(原子性):要么都成功，要么都失败 
• Consistent(一致性):数据应该不被破坏
• Isolate(隔离性):用户间操作不相混淆
• Durable(持久性):永久保存 

程序中两种事务管理方式

n      编程式事务管理

n         编写程序式的事务管理可以清楚的定义事务的边界，可以实现细粒度的事务控制，比如你可以通过程序代码来控制你的事务何时开始，何时结束等，与后面介绍的声明式事务管理相比，它可以实现细粒度的事务控制，例如jdbc,hibernate，spring中不提倡使用。

 

JDBC事务控制：

con.setAutoCommite (false);   设置事务手动提交

Hibernate中事务控制：

session.beginTransaction();     开启事务

 

优缺点：

1. 事务控制精确

2. 事务代码，与业务逻辑处理代码，耦合在一起!

事务代码，不能共用！ 重新写事务控制操作！

开发效率低，不便于维护！  (不想用事务，要改代码！)

 

n 声明式事务管理  (在Spring中使用)

n     如果你并不需要细粒度的事务控制，你可以使用声明式事务，在Spring中，你只需要在Spring配置文件中做一些配置，即可将操作纳入到事务管理中，解除了和代码的耦合， 这是对应用代码影响最小的选择，从这一点再次验证了Spring关于AOP的概念。当你不需要事务管理的时候，可以直接从Spring配置文件中移除该设置

 

 特点：

1. Spring提供的声明式事务管理，用到Aop概念！

2. 对指定的方法添加事务控制，这里只需要配置即可！

3. 修改事务控制实现或删除事务控制操作，只需要移除xml事务相关配置！

注意：

只能对某个方法应用事务！ （因为“切入点表达式”拦截的是方法，控制不了方法内部代码！）

所以，Spring声明式事务管理，即为粗粒度的事务控制！

 

 

  声明式事务管理器类：

Jdbc:

DataSourceTransactionManager   管理jdbc中事务控制

Hibernate:

HibenateTransactionManager     管理hibernate中事务控制

2）声明式事务管理 – JDBC

事务控制在Service层：

 

步骤：

1. 引入jar文件

Spring 核心

Spring Aop 切面编程

Spring-jdbc  / Spring-tx /  驱动包、连接池

2. dao/service

3. 配置

*数据源

* JdbcTemplate

* Dao/Service

* spring声明式事务管理配置

(拦截service方法的执行，动态植入事务控制代码！)

4. 使用

（1）XML配置方式实现

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"  xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd         http://www.springframework.org/schema/aop         http://www.springframework.org/schema/aop/spring-aop.xsd         http://www.springframework.org/schema/tx         http://www.springframework.org/schema/tx/spring-tx.xsd">   <!-- 1. 数据源配置 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> <property name="initialPoolSize" value="3"></property> <property name="maxPoolSize" value="6"></property> </bean>   <!-- 2. JdbcTemplate配置 ,  注入数据源--> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean>   <!-- 3. dao实例，注入jdbcTemplate --> <bean id="deptDao" class="cn.itcast.a_tx_jdbc.DeptDao"> <property name="jdbcTemplate" ref="jdbcTemplate"></property> </bean>   <!-- 4. Service实例，注入dao实例 --> <bean id="deptService" class="cn.itcast.a_tx_jdbc.DeptService"> <property name="deptDao" ref="deptDao"></property> </bean>   <!-- 5. Spring声明式事务管理配置 -->   <!-- 5.1 配置事务管理器类 --> <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean>   <!-- 5.2 事务通知配置, 拦截到指定的方法后如何管理事务 --> <!--name:与事务属性关联的方法名。通配符（*）例如：find*  find开头的方法--> <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="find*" read-only="true"/> <tx:method name="get*" read-only="true"/> <tx:method name="*" read-only="false"/> </tx:attributes> </tx:advice>   <!-- 5.3 事务Aop配置 = 切入点表达式  + 应用上面的事务通知 --> <aop:config> <aop:pointcut expression="execution(* cn.itcast.a_tx_jdbc.*Service.*(..))" id="pt"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/> </aop:config>   </beans>

（2）注解方式实现

步骤：

1. 引入aop相关包

2. 开启

<!-- 5.1 配置事务管理器类 --> <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <!-- spring声明式事务管理，注解开启 --> <tx:annotation-driven transaction-manager="txManager"/>

 

3. 使用@Transactional  注解

在需要添加事务控制的方法上写这个注解

@Transactional

写到方法上， 表示当前方法应用事务控制

写到类上，  表示当前类的所有方法都会应用事务

写到父类上， 当执行父类的这个方法时候才应用事务！

（3）事务属性

// 当前方法应用事务

@Transactional(

readOnly=false,      // 读写的事务，当修改数据时候用；如果查询就设置为true

isolation=Isolation.DEFAULT,  // 事务隔离级别

timeout=-1, // 事务执行的超时时间, -1 表示不超时

noRollbackFor=ArithmeticException.class,   // 遇到指定的异常不回滚

propagation=Propagation.REQUIRES_NEW      // 事务传播行为

)

 

Propagation事务传播行为:

REQUIRES_NEW  当前方法必须在事务环境下运行！且当前方法始终开启一个新的事务！    

REQUIRED       当前方法必须在事务环境下运行！

如果调用当前方式时候已经有一个事务环境，当前执行方法会加入当前事务环境，就 不开启新的事务；如果调用当前方法时候没有事务环境，就开启一个新的事务!

SUPPORTS       支持事务环境！ 如果当前方法没有事务，也可以运行！

Never           当前方法不能在事务环境下运行！

8. Spring 与 Hibernate 整合

Spring与Hibernate整合，

* 单例的SessionFactory对象，交给spring的IOC容器创建！

* 事务管理，交给spring声明式事务管理器

1）Spring创建SessionFactory几种方式

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans      http://www.springframework.org/schema/beans/spring-beans.xsd       http://www.springframework.org/schema/context          http://www.springframework.org/schema/context/spring-context.xsd          http://www.springframework.org/schema/aop          http://www.springframework.org/schema/aop/spring-aop.xsd          http://www.springframework.org/schema/tx       http://www.springframework.org/schema/tx/spring-tx.xsd">             <!-- 连接池, 通过spring管理 -->     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">      <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>      <property name="driverClass" value="com.mysql.jdbc.Driver"></property>      <property name="user" value="root"></property>      <property name="password" value="root"></property>      <property name="initialPoolSize" value="3"></property>      <property name="maxPoolSize" value="6"></property>     </bean>             <!-- Spring 与   Hibenate整合  (Spring创建SessionFactory) -->             <!-- 方式1： 直接加载hibernate.cfg.xml的方式，创建sessionFactory对象     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">     <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>     </bean>      -->            <!-- 方式2： 连接池交给spring管理，其他配置还是写到hibernate.cfg.xml中      <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">       <property name="dataSource" ref="dataSource"></property>       <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>      </bean>      -->            <!-- 方式3：(推荐) 所有的配置都在spring中完成-->      <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">       <!-- a. 注入连接池 -->       <property name="dataSource" ref="dataSource"></property>             <!-- b. hibernate常用配置： 方言、自动建表、显示sql -->       <property name="hibernateProperties">       <props>       <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>       <prop key="hibernate.show_sql">true</prop>       <prop key="hibernate.hbm2ddl.auto">update</prop>       </props>       </property>             <!-- c. 加载所有的映射(根据路径加载)       <property name="mappingLocations">       <list>       <value>classpath:cn/itcast/entity/*.hbm.xml</value>       </list>       </property>       -->       <!-- c. 根据目录加载所有的映射 -->       <property name="mappingDirectoryLocations">       <list>       <value>classpath:cn/itcast/entity</value>       </list>       </property>      </bean>    <!-- 创建dao实例 --> <bean id="deptDao" class="cn.itcast.dao.DeptDao"> <property name="sessionFactory" ref="sessionFactory"></property> </bean>   <!-- 创建service实例 --> <bean id="deptService" class="cn.itcast.service.DeptService"> <property name="deptDao" ref="deptDao"></property> </bean>   <!-- Spring声明式事务管理配置-->  <!-- a. 事务管理器 -->  <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">   <property name="sessionFactory" ref="sessionFactory"></property>  </bean>    <!-- b. 事务通知 -->  <tx:advice id="txAdvice" transaction-manager="txManager">   <tx:attributes>   <tx:method name="*" read-only="false"/>   </tx:attributes>  </tx:advice>    <!-- c. Aop配置  = 切入点表达式  + 应用通知规则 -->  <aop:config>   <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn..*Service.*(..))"/>  </aop:config> </beans>

2）Spring对dao操作的支持

如下：

1. JDBC

Spring 提供了JdbcTemplate模板工具类，对原始的jdbc操作进行简化！

2. Hibernate

Spring 提供了对hibernate的sessionFactory创建的支持 (整合)

 

à 直接在dao中使用sessionFactory对象操作数据库

à 使用Spring提供的 HibernateTemplate 工具类操作数据库

优点： 对session的常用操作进行封装！ 比较方便!

à (推荐)HibernateDaoSupport工具类  

Dao类直接继承HibernateDaoSupport工具类即可

HibernateDaoSupport对hibernateTemlate类进行了封装