37Spring框架

Posted fengfusheng

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了37Spring框架相关的知识,希望对你有一定的参考价值。

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 容器

1bean配置细节

<!-- 把对象加入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>

3DI依赖注入

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

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代理!

       因为是通过jdkapi在运行时期,动态的生成代理对象的!

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;

}

}

3Cglib代理

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

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

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

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

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

 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       定义一个切入点表达式变量  (后面使用这个切入点表达式的时候,直接引用方法名即可)

2XML配置方式

步骤:

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?)             方法声明的异常

?(表示01

*(*代表任意

参数(..表示任意)

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 * *(..))"

  1. 拦截所有的save方法

expression="execution(* save(..))"

  1. 拦截所有的包含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. 事务代码,与业务逻辑处理代码,耦合在一起!

事务代码,不能共用! 重新写事务控制操作!

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

 

声明式事务管理  (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. 使用

1XML配置方式实现

<?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 整合

SpringHibernate整合,

* 单例的SessionFactory对象,交给springIOC容器创建!

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

1Spring创建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>     

2Springdao操作的支持

如下:

1. JDBC

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

2. Hibernate

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

 

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

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

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

à (推荐)HibernateDaoSupport工具类  

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

HibernateDaoSupporthibernateTemlate类进行了封装

 

以上是关于37Spring框架的主要内容,如果未能解决你的问题,请参考以下文章

框架 day37 Spring3,AOP,代理模式(动态/CGLIB/工厂bean),传统AOP,AspectJ框架(基于xml/注解),切入点表达式,jdbcTemplate

Cloudera impala 与 spring 框架?

Spring框架的圆形视图路径异常

2017第37周三

Web 框架:Play 与 Spring MVC 有何不同? [关闭]

Spring Boot(5)一个极简且完整的后台框架