Spring学习笔记——带你真正了解掌握Spring框架

时间  2019-11-15
标签 spring 学习 笔记 真正 了解 掌握 框架 栏目 Spring 繁體版
原文   原文链接

Spring简介

Spring 是一个开源框架，是一个分层的 JavaEE 一站式框架。html

所谓一站式框架是指 Spring 有 JavaEE 开发的每一层解决方案。java

  • WEB层：SpringMVC
  • Service层：Spring的Bean管理，声明式事务
  • DAO层：Spring的JDBC模板，ORM模板

优势：mysql

  • IOC：方便解耦合
  • AOP：对程序进行扩展
  • 轻量级框架
  • 方便与其余框架整合

Spring使用

Spring开发包解压后的目录介绍：web

  • docs: Spring 开发规范和API
  • libs: Spring jar 包和源代码
  • schema: Spring 配置文件的约束

DataAccess 用于数据访问，WEB 用于页面显示，核心容器也就是IOC部分。面试

控制反转（IOC）

控制反转（Inversion of Control）是指将对象的建立权反转（交给）Spring。spring

使用IOC就须要导入IOC相关的包，也就是上图中核心容器中的几个包：beans,context,core,expression四个包。sql

实现原理

传统方式建立对象：数据库

UserDAO userDAO=new UserDAO();express

进一步面向接口编程，能够多态：apache

UserDAO userDAO=new UserDAOImpl();

这种方式的缺点是接口和实现类高耦合，切换底层实现类时，须要修改源代码。程序设计应该知足OCP元祖，在尽可能不修改程序源代码的基础上对程序进行扩展。此时，可使用工厂模式：

class BeanFactory{

    public static UserDAO getUserDAO(){

        return new UserDAOImpl();

    }

}

此种方式虽然在接口和实现类之间没有耦合，可是接口和工厂之间存在耦合。

使用工厂+反射+配置文件的方式，实现解耦，这也是 Spring 框架 IOC 的底层实现。

//xml配置文件

//<bean id="userDAO" class="xxx.UserDAOImpl"></bean>

class BeanFactory{

    public static Object getBean(String id){

        //解析XML

        //反射

        Class clazz=Class.forName();

        return clazz.newInstance();

    }

}

IOC XML 开发

在 docs 文件中包含了 xsd-configuration.hmtl 文件。其中定义了 beans schema。

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    //在此配置bean

    <bean id="userService" class="x.y.UserServiceImpl">

    </bean>

</beans>

调用类：

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService=(UserService)applicationContext.getBean("userService");

userService.save();

IOC 和 DI

DI 指依赖注入，其前提是必须有 IOC 的环境，Spring 管理这个类的时候将类的依赖的属性注入进来。

例如，在UserServiceImpl.java中：

public class UserServiceImpl implements UserService{

private String name;

public void setName(String name){

this.name=name;

}

public void save(){

System.out.println("save "+name);

}

}

在配置文件中：

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="spring.demo1.UserServiceImpl">

    <!--配置依赖的属性-->

      <property name="name" value="tony"/>

    </bean>

</beans>

测试代码：

@Test

public void demo2(){

//建立Spring工厂

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");

UserService userService=(UserService)applicationContext.getBean("userService");

userService.save();

}

运行结果：

save tony

能够看到，在配置文件中配置的属性，在 Spring 管理该类的时候将其依赖的属性成功进行了设置。若是不使用依赖注入，则没法使用接口，只能使用实现类来进行设置，由于接口中没有该属性。

Spring 的工厂类

  • BeanFactory: 老版本的工厂类，在调用getBean()方法时，才会生成类的实例。
  • ApplicationContext: 在加载配置文件的时候，就会将 Spring 管理的类都实例化。有两个实现类：
  1. ClassPathXmlApplicationContext: 加载类路径下的配置文件
  2. FileSystemXmlApplicationContext: 加载磁盘下的配置文件

bean标签配置

  • id: 惟一约束，不能出现特殊字符
  • name: 理论上能够重复，可是开发中最好不要。能够出现特殊字符

生命周期：

  • init-method: bean被初始化的时候执行的方法
  • destroy-method: bean被销毁的时候执行的方法

做用范围：

  • scope： bean的做用范围，有以下几种，经常使用的是前两种
  • singleton: 默认使用单例模式建立
  • prototype: 多例
  • request: 在web项目中，spring 建立类后，将其存入到 request 范围中
  • session: 在web项目中，spring 建立类后，将其存入到 session 范围中
  • globalsession: 在web项目中，必须用在 porlet 环境

属性注入设置

  1. 构造方法方式的属性注入： Car 类在构造方法中有两个属性，分别为 name 和 price。
<bean id="car" class="demo.Car">

    <constructor-arg name="name" value="bmw">

    <constructor-arg name="price" value="123">

</bean>
  1. set 方法属性注入： Employee 类在有两个 set 方法，分别设置普通类型的 name 和引用类型的 Car （使用 ref 指向引用类型的 id 或  name）。
<bean id="employee" class="demo.Employee">

    <property name="name" value="xiaoming">

    <property name="car" ref="car">

</bean>
  1. P名称空间的属性注入： 首先须要引入p名称空间：
<beans xmlns="http://www.springframework.org/schema/beans"

    //引入p名称空间

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

若是是普通属性：

<bean id="car" class="demo.Car" p:name="bmv" p:price="123">

</bean>

若是是引用类型：

<bean id="employee" class="demo.Employee" p:name="xiaoming" p:car-ref:"car">

</bean>
  1. SpEL(Spring Expression Language)属性注入（Spring 3.x以上版本）
<bean id="car" class="demo.Car">

    <property name="name" value="#{'xiaoming'}">

    <property name="car" ref="#{car}">

</bean>
  1. 集合类型属性注入：
<bean id="car" class="demo.Car">

    <property name="namelist">

        <list>

            <value>qirui</value>

            <value>baoma</value>

            <value>benchi</value>

        </list>

    </property>

</bean>

多模块开发配置

  1. 在加载配置文件的时候，加载多个配置文件
  2. 在一个配置文件中引入多个配置文件，经过实现

若是你对技术提高很感兴趣，欢迎1~5年的工程师能够加入个人Java进阶之路来交流学习：908676731。里面都是同行，有资源共享，还有大量面试题以及解析。欢迎一到五年的工程师加入，合理利用本身每一分每一秒的时间来学习提高本身，不要再用"没有时间“来掩饰本身思想上的懒惰！趁年轻，使劲拼，给将来的本身一个交代！

IOC 注解开发

示例

  1. 引入jar包： 除了要引入上述的四个包以外，还须要引入aop包。
  2. 建立 applicationContext.xml ，使用注解开发引入 context 约束（xsd-configuration.html）
<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"> 

        <!-- bean definitions here -->

</beans>
  1. 组件扫描： 使用IOC注解开发，须要配置组件扫描，也就是哪些包下的类使用IOC的注解。

<context:component-scan base-package="demo1">

  1. 在类上添加注解
  2. 使用注解设置属性的值

属性若是有set方法，将属性注入的注解添加到set方法

属性没有set方法，将注解添加到属性上。

@Component("UserDao")//至关于配置了一个<bean> 其id为UserDao,对应的类为该类

public class UserDAOImpl implements UserDAO {

@Override

public void save() {

// TODO Auto-generated method stub

System.out.println("save");

} 

}

注解详解

  1. @Component

组件注解，用于修饰一个类，将这个类交给 Spring 管理。

有三个衍生的注解，功能相似，也用来修饰类。

  • @Controller：修饰 web 层类
  • @Service：修饰 service 层类
  • @Repository：修饰 dao 层类

2.属性注入

  • 普通属性使用 @Value 来设置属性的值
  • 对象属性使用 @Autowired  ，这个注解是按照类型来进行属性注入的。若是但愿按照 bean 的名称或id进行属性注入，须要用 @Autowired 和 @Qualifier 一块儿使用
  • 实际开发中，使用 @Resource(name=" ") 来进行按照对象的名称完成属性注入

3.其余注解

  • @PostConstruct 至关于 init-method，用于初始化函数的注解
  • @PreDestroy 至关于 destroy-method，用于销毁函数的注解
  • @Scope 做用范围的注解，经常使用的是默认单例，还有多例 @Scope("prototype")

IOC 的 XML 和注解开发比较

  • 适用场景：XML 适用于任何场景；注解只适合本身写的类，不是本身提供的类没法添加注解。
  • 可使用 XML 管理 bean，使用注解来进行属性注入

AOP开发

AOP 是 Aspect Oriented Programming 的缩写，意为面向切面编程，经过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，是OOP的延续。

AOP 可以对程序进行加强，在不修改源码的状况下，能够进行权限校验，日志记录，性能监控，事务控制等。

也就是说功能分为两大类，一类是核心业务功能，一类是辅助加强功能。两类功能彼此独立进行开发。好比登陆功能是核心业务功能，日志功能是辅助加强功能，若是有须要，将日志和登陆编制在一块儿。辅助功能就称为切面，这种能选择性的、低耦合的把切面和核心业务功能结合的编程思想称为切面编程。

底层实现

JDK 动态代理只能对实现了接口的类产生代理。Cglib 动态代理能够对没有实现接口的类产生代理对象，生成的是子类对象。

使用 JDK 动态代理：

public interface UserDao {

public void insert();

public void delete();

public void update();

public void query();

}

实现类：

public class UserDaoImpl implements UserDao { @Override public void insert() { System.out.println("insert"); } @Override public void delete() { System.out.println("delete"); } @Override public void update() { System.out.println("update"); } @Override public void query() { System.out.println("query"); } }

JDK 代理：

public class JDKProxy implements InvocationHandler{

private UserDao userDao;

public JDKProxy(UserDao userDao){

this.userDao=userDao;

}

public UserDao createProxy(){

UserDao userDaoProxy=(UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(),

userDao.getClass().getInterfaces(), this);

return userDaoProxy;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

if("update".equals(method.getName())){

System.out.println("权限校验");

return method.invoke(userDao, args);

}

return method.invoke(userDao, args);

}

}

经过动态代理加强了 update 函数。 测试类：

public class Demo1 {

@Test

public void demo1(){

UserDao userDao=new UserDaoImpl();

UserDao proxy=new JDKProxy(userDao).createProxy();

proxy.insert();

proxy.delete();

proxy.update();

proxy.query();

}

}

运行结果为：

insert

delete

权限校验

update

query

CglibCglib 是第三方开源代码生成类库，能够动态添加类的属性和方法。

与上边JDK代理不一样，Cglib的使用方式以下：

public class CglibProxy implements MethodInterceptor{

//传入加强的对象

private UserDao customerDao;

public CglibProxy(UserDao userDao){

this.userDao=userDao;

}

public UserDao createProxy(){

Enhancer enhancer=new Enhancer();

enhancer.setSuperclass(userDao.getClass());

enhancer.setCallback(this);

UserDao proxy=(UserDao)enhancer.create();

return proxy;

}

@Override

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

if("save".equals(method.getName())){

System.out.println("enhance function");

return methodProxy.invokeSuper(proxy, args);

}

return methodProxy.invokeSuper(proxy, args);

}

}

若是实现了接口的类，底层采用JDK代理。若是不是实现了接口的类，底层采用 Cglib代理。

IOC与传统方式的比较

  1. 获取对象方式：传统经过 new 关键字主动建立一个对象。IOC 方式中，将对象的生命周期交给 Spring 管理，直接从 Spring 获取对象。也就是控制反转————将控制权从本身手中交到了 Spring 手中。

Spring 的 AOP 开发（AspectJ 的 XML 方式）

AspectJ 是一个 AOP 的框架，Spring 引入 AspectJ，基于 AspectJ 进行 AOP 的开发。

相关术语

  • Joinpoint: 链接点，能够被拦截到的点。也就是能够被加强的方法都是链接点。
  • Pointcut: 切入点，真正被拦截到的点，也就是真正被加强的方法
  • Advice: 通知，方法层面的加强。对某个方法进行加强的方法，好比对 save 方法进行权限校验，权限校验的方法称为通知。
  • Introduction: 引介，类层面的加强。
  • Target: 目标，被加强的对象（类）。
  • Weaving: 织入，将 advice 应用到 target 的过程。
  • Proxy: 代理对象，被加强的对象。
  • Aspect: 切面，多个通知和多个切入点的组合。

使用方法

  1. 引入相关包
  2. 引入配置文件
<?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: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/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->

</beans>
  1. 编写目标类并配置：
public class ProductDaoImpl implements ProductDao {

@Override

public void save() {

System.out.println("save");

}

@Override

public void update() {

System.out.println("update");

}

@Override

public void find() {

System.out.println("find");

}

@Override

public void delete() {

System.out.println("delete");

}

}

<bean id="productDao" class="demo1.ProductDaoImpl"></bean>
  1. 编写切面类，假设用于权限验证并配置
public class MyAspectXML {

public void checkPri(){

System.out.println("check auth");

}

}

<bean id="myAspect" class="demo1.MyAspectXML"></bean>
  1. 经过AOP配置完成对目标类的加强
<aop:config>

<aop:pointcut expression="execution(* demo1.ProductDaoImpl.save(..))" id="pointcut1"/>

<aop:aspect ref="myAspect">

<aop:before method="chechPri" pointcut-ref="pointcut1"/>

</aop:aspect> 

</aop:config>

通知类型

  1. 前置通知：在目标方法执行前操做，能够得到切入点信息
<aop:before method="chechPri" pointcut-ref="pointcut1"/>

public void checkPri(JoinPoint joinPoint){

System.out.println("check auth "+joinPoint);

}
  1. 后置通知：在目标方法执行后操做，能够得到方法返回值
<aop:after-returning method="writeLog" pointcut-ref="pointcut2" returning="result"/>

public void writeLog(Object result){

    System.out.println("writeLog "+result);

}
  1. 环绕通知：在目标方法执行前和后操做，能够阻止目标方法执行
<aop:around method="around" pointcut-ref="pointcut3"/>

public Object around(ProceedingJoinPoint joinPoint) throws Throwable{

System.out.println("before");

Object result=joinPoint.proceed();

System.out.println("after");

return result;

}
  1. 异常抛出通知：程序出现异常时操做
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"/>

public void afterThrowing(Throwable ex){

System.out.println("exception "+ex.getMessage());

}
  1. 最终通知：至关于finally块，不管代码是否有异常，都会执行
<aop:after method="finallyFunc" pointcut-ref="pointcut4"/>

public void finallyFunc(){

System.out.println("finally");

}
  1. 引介通知：不经常使用

Spring 切入点表达式

基于 execution 函数完成

语法：[访问修饰符] 方法返回值 包名.类名.方法名(参数)

其中任意字段可使用*代替表示任意值

Spring 的 AOP 基于 AspectJ 注解开发

开发步骤

  1. 引入jar包
  2. 设置配置文件：
<?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"

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">

</beans>
  1. 编写配置目标类
<bean id="orderDao" class="demo1.OrderDao"></bean>

public class OrderDao {

public void save(){

System.out.println("save order");

}

public void update(){

System.out.println("update order");

}

public void delete(){

System.out.println("delete order");

}

public void find(){

System.out.println("find order");

}

}
  1. 开启aop注解自动代理

<aop:aspectj-autoproxy/>

  1. 编写切面类并配置

@Aspect

public class MyAspectAnno {

@Before(value="execution(* demo1.OrderDao.save(..))")

public void before(){

System.out.println("before");

}

}

<bean id="myAspect" class="demo1.MyAspectAnno">

注解通知类型

  • @Before： 前置通知
  • @AfterReturning: 后置通知
@AfterReturning(value="execution(* demo1.OrderDao.save(..))",returning="result")

public void after(Object result){

System.out.println("after "+result);

}
  • @Around：环绕通知
@Around(value="execution(* demo1.OrderDao.save(..))")

public Object around(ProceedingJoinPoint joinPoint) throws Throwable{

System.out.println("before");

Object obj=joinPoint.proceed();

System.out.println("after");

return obj;

}
  • @AfterThrowing: 抛出异常
@AfterThrowing(value="execution(* demo1.OrderDao.save(..))",throwing="e")

public void afterThrowing(Throwable e){

System.out.println("exception:"+e.getMessage();

}
  • @After: 最终通知
@After(value="execution(* demo1.OrderDao.save(..))")

public void after(){

System.out.println("finally");

}
  • @PointCut:切入点注解

@PointCut(value="execution(* demo1.OrderDao.save(..))")

private void pointcut1(){}

此时，在上述通知的注解中，value能够替换为该函数名，例如：

@After(value="MyAspect.pointcut1()")

public void after(){

System.out.println("finally");

}

这个注解的好处是，只须要维护切入点便可，不用在修改时修改每一个注解。

Spring 的 JDBC 模板

Spring 对持久层也提供了解决方案，也就是 ORM 模块和 JDBC 的模板。针对 JDBC ，提供了 org.springframework.jdbc.core.JdbcTemplate 做为模板类。

使用 JDBC 模板

  1. 引入jar包，数据库驱动，Spring 的 jdbc 相关包。
  2. 基本使用：
public void demo1(){

    //建立链接池

DriverManagerDataSource dataSource=new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql:///spring4");

dataSource.setUsername("root");

dataSource.setPassword("123456");

//建立JDBC模板 

JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);

jdbcTemplate.update("insert into account values (null,?,?)", "xiaoming",1000d);

}
  1. 将链接池和模板交给 Spring 管理
  • 配置文件：
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource;">

<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>

<property name="url" value="jdbc:mysql:///spring4"></property>

<property name="username" value="root"></property>

<property name="password" value="123456"></property>

</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate;"> 

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

</bean>
  • 测试文件：

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class JdbcDemo2 {

@Resource(name="jdbcTemplate")

private JdbcTemplate jdbcTemplate;

@Test

public void demo2(){

jdbcTemplate.update("insert into account values (null,?,?)", "xiaolan",1000d);

}

}

使用开源数据库链接池

  1. 使用 DBCP 的配置：
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>

<property name="url" value="jdbc:mysql://192.168.66.128/spring4"></property>

<property name="username" value="root"></property>

<property name="password" value="123456"></property>
  1. 使用 C3P0 的配置：
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

<property name="driverClass" value="com.mysql.jdbc.Driver"></property>

<property name="jdbcUrl" value="jdbc:mysql://192.168.66.128/spring4"></property>

<property name="user" value="root"></property>

<property name="password" value="123456"></property>

</bean>
  1. 引入外部属性文件

首先创建外部属性文件：

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://192.168.66.128/spring4

jdbc.username=root

jdbc.password=123456

而后对属性文件进行配置：

<context:property-placeholder location="classpath:jdbc.properties"/>

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

<property name="driverClass" value="${jdbc.driverClass}"></property>

<property name="jdbcUrl" value="${jdbc.url}"></property>

<property name="user" value="${jdbc.username}"></property>

<property name="password" value="${jdbc.password}"></property>

</bean>

CRUD操做

insert, update, delete 语句都借助模板的 update 方法进行操做。

public void demo(){

jdbcTemplate.update("insert into account values (null,?,?)", "xiaoda",1000d);

jdbcTemplate.update("update account set name=?,money=? where id=?", "xiaoda",1000d,2);

jdbcTemplate.update("delete from account where id=?", 6);

}

查询操做：

public void demo3(){

String name=jdbcTemplate.queryForObject("select name from account where id=?",String.class,5);

long count=jdbcTemplate.queryForObject("select count(*) from account",Long.class);

}

将返回的结果封装成为类：

public void demo4(){

Account account=jdbcTemplate.queryForObject("select * from account where id=?", new MyRowMapper(),5);

}

其中：

class MyRowMapper implements RowMapper<Account>{

@Override

public Account mapRow(ResultSet rs, int rowNum) throws SQLException {

Account account=new Account();

account.setId(rs.getInt("id"));

account.setName(rs.getString("name"));

account.setMoney(rs.getDouble("money"));

return account;

}

}

Spring的事务管理

事务

事务是指逻辑上的一组操做，组成这组操做的各个单元，要么所有成功，要么所有失败。

具备四个特性：

  • 原子性：事务不可分
  • 一致性：事务执行先后数据完整性保持一致
  • 隔离性：一个事务的执行不该该受到其余事务干扰
  • 持久性：一旦事务结束，数据就持久化到数据库

若是不考虑隔离性会引起安全性问题：

  • 读问题：
  • 脏读：一个事务读到另外一个事务未提交的数据
  • 不可重复读：一个事务读到另外一个事务已经提交的 update 数据，致使一个事务中屡次查询结果不一致
  • 幻读：一个事务读到另外一个事务已经提交的 insert 数据，致使一个事务中屡次查询结果不一致
  • 写问题：
  • 丢失更新

解决读问题：设置事务隔离级别

  • Read uncommitted: 未提交读，没法解决任何读问题
  • Read committed: 已提交读，解决脏读问题
  • Repeatable read: 重复读，解决脏读和不可重复读问题
  • Serializable：序列化，解决全部读问题

事务管理API

  1. PlatformTransactionManager: 平台事务管理器

这是一个接口，拥有多个不一样的实现类，如 DataSourceTransactionManager 底层使用了JDBC 管理事务； HibernateTransactionManager 底层使用了 Hibernate 管理事务。

  1. TransactionDefinition: 事务定义信息

用于定义事务的相关信息，如隔离级别、超时信息、传播行为、是否只读等

  1. TransactionStatus: 事务的状态

用于记录在事务管理过程当中，事务的状态的对象。

上述API的关系： Spring 在进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务管理，在事务管理过程中，产生各类此状态，将这些状态信息记录到事务状态的对象当中。

事务的传播行为

事务的传播行为主要解决业务层（Service）方法相互调用的问题，也就是不一样的业务中存在不一样的事务时，如何操做。

Spring 中提供了7种事务的传播行为，分为三类：

  • 保证多个操做在同一个事务中
  • PROPAGATION_REQUIRED: B方法调用A方法，若是A中有事务，使用A中的事务并将B中的操做包含到该事务中；不然新建一个事务，将A和B中的操做包含进来。（默认）
  • PROPAGATION_SUPPORTS：若是A中有事务，使用A的事务；不然不使用事务
  • PROPAGATION_MANDATORY：若是A中有事务，使用A的事务；不然抛出异常
  • 保证多个操做不在同一个事务中
  • PROPAGATION_REQUIRES_NEW：若是A中有事务，将其挂起，建立新事务，只包含自身操做。不然，新建一个事务，只包含自身操做。
  • PROPAGATION_NOT_SUPPORTED：若是A中有事务，挂起，不使用事务。
  • PROPAGATION_NEVER：若是A中有事务，抛出异常，也即不能用事务运行。
  • 嵌套事务
  • PROPAGATION_NESTED：若是A有事务，按照A的事务执行，执行完成后，设置一个保存点，而后执行B的操做。若是出现异常，能够回滚到最初状态或保存点状态。

实例

以转帐为例，业务层的DAO层类以下：

public interface AccountDao {

public void outMoney(String from,Double money);

public void inMoney(String to,Double money);

}

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{

@Override

public void outMoney(String from, Double money) {

 this.getJdbcTemplate().update("update account set money = money - ? where name = ?",money,from);

}

@Override

public void inMoney(String to, Double money) {

this.getJdbcTemplate().update("update account set money = money + ? where name = ?",money,to);

}

}

public interface AccountService {

public void transfer(String from,String to,Double money);

}

public class AccountServiceImpl implements AccountService {

private AccountDao accountDao;

public void setAccountDao(AccountDao accountDao) {

this.accountDao = accountDao;

}

@Override

public void transfer(String from, String to, Double money) {

accountDao.outMoney(from, money);

accountDao.inMoney(to, money);

}

}

在xml中进行类的配置：

<bean id="accountService" class="tx.demo.AccountServiceImpl">

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

</bean>

<bean id="accountDao" class="tx.demo.AccountDaoImpl">

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

</bean>

事务管理1: 编程式事务管理

  1. 配置平台事务管理器
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

</bean>
  1. 配置事务管理模板类
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">

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

</bean>
  1. 在业务层注入事务管理模板
<bean id="accountService" class="tx.demo1.AccountServiceImpl">

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

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

</bean>
  1. 编码实现事务管理
//ServiceImpl类中：

private TransactionTemplate transactionTemplate;

@Override

public void transfer(String from, String to, Double money) {

transactionTemplate.execute(new TransactionCallbackWithoutResult() {

@Override

protected void doInTransactionWithoutResult(TransactionStatus arg0) {

accountDao.outMoney(from, money);

accountDao.inMoney(to, money);

}

});

}

声明式事务管理（配置实现，基于AOP思想）

  1. XML 方式的声明式事务管理
  • 配置事务管理器
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

</bean>
  • 配置事务通知
<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="transfer" propagation="REQUIRED"/>

</tx:attributes>

</tx:advice>
  • 配置aop事务
<aop:config>

<aop:pointcut expression="execution(* tx.demo2.AccountServiceImpl.*(..))" id="pointcut1"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>

</aop:config>
  1. 注解方式
  • 配置事务管理器，和上方一致
  • 开启事务管理的注解：

<tx:annotation-driven transaction-manager="transactionManager"/>

  • 在使用事务的类上添加一个注解@Transactional

若是以为文章不错欢迎你们收藏点个关注哟。

若是你对技术提高很感兴趣，欢迎1~5年的工程师能够加入个人Java进阶之路来交流学习：908676731。里面都是同行，有资源共享，还有大量面试题以及解析。欢迎一到五年的工程师加入，合理利用本身每一分每一秒的时间来学习提高本身，不要再用"没有时间“来掩饰本身思想上的懒惰！趁年轻，使劲拼，给将来的本身一个交代！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程