typora-copy-images-to: img

Spring_03

学习目标

  • 能够掌握基于注解的AOP配置
  • 能够使用spring的jdbc的模板
  • 能够配置spring的连接池
  • 能够使用jdbc模板完成增删改查的操作
  • 能够应用声明式事务
  • 能够理解事务的传播行为

第一章-Spring中的AOP

知识点-基于XML的AOP配置

1.目标

  • 能够编写Spring的AOP中不同通知的代码

2.路径

  1. 前置通知
  2. 后置通知
  3. 环绕通知
  4. 异常通知
  5. 最终通知

3.讲解

3.1前置通知

需求: 在service的增删改查方法调用之前进行权限的校验

实现步骤:

  1. 导入坐标
  2. 定义Dao和增强的逻辑, 进行注册

  3. 配置AOP

    • 配置切入点
    • 配置切面(切入点和通知结合)

实现:

  • 导入坐标
  1. <dependencies>
  2.     <!--Spring核心容器-->
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-context</artifactId>
  6.         <version>5.0.2.RELEASE</version>
  7.     </dependency>
  8.     <!--SpringAOP相关的坐标-->
  9.     <dependency>
  10.         <groupId>org.aspectj</groupId>
  11.         <artifactId>aspectjweaver</artifactId>
  12.         <version>1.8.7</version>
  13.     </dependency>
  15.     <!--Spring整合单元测试-->
  16.     <dependency>
  17.         <groupId>org.springframework</groupId>
  18.         <artifactId>spring-test</artifactId>
  19.         <version>5.0.2.RELEASE</version>
  20.     </dependency>
  21.     <!--单元测试-->
  22.     <dependency>
  23.         <groupId>junit</groupId>
  24.         <artifactId>junit</artifactId>
  25.         <version>4.12</version>
  26.         <scope>test</scope>
  27.     </dependency>
  28. </dependencies>
  • 导入约束
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.      xmlns:aop="http://www.springframework.org/schema/aop"
    5.      xsi:schemaLocation="http://www.springframework.org/schema/beans
    6.      http://www.springframework.org/schema/beans/spring-beans.xsd
    7.      http://www.springframework.org/schema/aop
    8.      http://www.springframework.org/schema/aop/spring-aop.xsd">
    9. </beans>
  • 定义被增强的业务逻辑类和切面类(增强的) ```java package com.itheima.service.impl;

import com.itheima.service.UserService;

/**

  • 包名:com.itheima.service.impl *
  • @author Leevi
  • 日期2020-08-12 08:36
  • 目标1:在执行增删改查方法之前，都做权限校验 前置通知: before
  • 目标2:在执行增删改查方法之后(没有出现异常)， 都打印日志 后置通知: after-returning
  • 目标3:在执行增删改查方法出现异常之后，都进行友好的提示 异常通知: after-throwing
  • 目标4:在执行增删改查方法之后，无论出没出现异常，均打印一句”执行完毕” 最终通知: after

  • 目标5:计算update方法的执行时间 环绕通知: around */ public class UserServiceImpl implements UserService { @Override public void add() {

    1.  System.out.println("执行添加...");
    2.  int num = 10/0;

    }

    @Override public void delete() {

    1.  System.out.println("执行删除...");

    }

    @Override public void update() {

    1.  try {
    2.      Thread.sleep(3000);
    3.  } catch (InterruptedException e) {
    4.      e.printStackTrace();
    5.  }
    6.  System.out.println("执行修改...");

    }

    @Override public void select() {

    1.  System.out.println("执行查询...");

    } } ```

  1. package com.itheima.aspect;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  5. /**
  6.  * 包名:com.itheima.aspect
  7.  *
  8.  * @author Leevi
  9.  * 日期2020-08-12  08:39
  10.  */
  11. public class PermissionAspect {
  12.     public void checkPermission(){
  13.         System.out.println("校验权限...");
  14.     }
  16.     public void printLog(){
  17.         System.out.println("打印日志...");
  18.     }
  20.     public void showException(){
  21.         System.out.println("出现异常了，请检查...");
  22.     }
  24.     public void showEnd(){
  25.         System.out.println("执行完毕...");
  26.     }
  28.     //计算目标方法的执行时长
  29.     public void showMillions(ProceedingJoinPoint joinPoint){
  30.         //1. 记录当前时间
  31.         long timeMillis1 = System.currentTimeMillis();
  32.         //2. 执行目标方法
  33.         try {
  34.             joinPoint.proceed();
  35.         } catch (Throwable throwable) {
  36.             throwable.printStackTrace();
  37.         }
  38.         //3. 再记录当前时间
  39.         long timeMillis2 = System.currentTimeMillis();
  40.         //4. 将两次的时间相减，得到方法的执行时长
  41.         System.out.println(timeMillis2 - timeMillis1);
  42.     }
  43. }

  • applicationContext.xml配置文件中进行aop配置

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.      xmlns:aop="http://www.springframework.org/schema/aop"
    5.      xsi:schemaLocation="http://www.springframework.org/schema/beans
    6.                          http://www.springframework.org/schema/beans/spring-beans.xsd
    7.                          http://www.springframework.org/schema/aop
    8.                          http://www.springframework.org/schema/aop/spring-aop.xsd">
    9.   <!--全部采用纯配置文件方式-->
    10.   <!--1. 对UserServiceImpl进行IOC配置-->
    11.   <bean id="userService" class="com.itheima.service.impl.UserServiceImpl"></bean>
    12.   <!--2. 对切面类PermissionAspect进行IOC配置-->
    13.   <bean id="permissionAspect" class="com.itheima.aspect.PermissionAspect"></bean>
    14.   <!--
    15.       3. 配置AOP <aop:config>
    16.          1. 配置切入点 <aop:pointcut id="" expression=""/>
    17.             id: 切入点的唯一标识
    18.             expression: 切入点表达式
    19.          2. 配置通知
    20.          3. 配置切面关联通知和切入点
    21.   -->
    22.   <aop:config>
    23.       <!--配置切入点-->
    24.       <aop:pointcut id="pt1"
    25.                     expression="execution(* com.itheima.service.impl.UserServiceImpl.*(..))"/>
    27.       <aop:pointcut id="pt2" expression="execution(* com.itheima.service.impl.UserServiceImpl.update(..))"/>
    28.       <!--配置切面-->
    29.       <aop:aspect id="aspect1" ref="permissionAspect">
    30.           <!--配置前置通知-->
    31.           <aop:before method="checkPermission" pointcut-ref="pt1"></aop:before>
    33.           <!--配置后置通知-->
    34.           <aop:after-returning method="printLog" pointcut-ref="pt1"></aop:after-returning>
    36.           <!--配置异常通知-->
    37.           <aop:after-throwing method="showException" pointcut-ref="pt1"></aop:after-throwing>
    39.           <!--配置最终通知-->
    40.           <aop:after method="showEnd" pointcut-ref="pt1"></aop:after>
    42.           <!--配置环绕通知-->
    43.           <aop:around method="showMillions" pointcut-ref="pt2"></aop:around>
    44.       </aop:aspect>
    45.   </aop:config>
    46. </beans>

知识点-基于注解的AOP配置

1.目标

  • 能够理解spring的AOP的注解

2.分析

2.1路径

  1. 前置通知
  2. 后置通知
  3. 环绕通知
  4. 异常通知
  5. 最终通知

2.2步骤

  1. 创建工程, 导入坐标
  2. 创建Dao和增强的类, 注册
  3. 开启AOP的注解支持
  4. 在增强类上面添加@Aspect

  5. 在增强类的增强方法上面添加

    • @Before()
    • @AfterReturning()
    • @Around()
    • @AfterThrowing()
    • @After()

3.讲解

3.1前置通知

  • 添加坐标
  1. <dependencies>
  2.     <!--Spring核心容器-->
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-context</artifactId>
  6.         <version>5.0.2.RELEASE</version>
  7.     </dependency>
  8.     <!--SpringAOP相关的坐标-->
  9.     <dependency>
  10.         <groupId>org.aspectj</groupId>
  11.         <artifactId>aspectjweaver</artifactId>
  12.         <version>1.8.7</version>
  13.     </dependency>
  15.     <!--Spring整合单元测试-->
  16.     <dependency>
  17.         <groupId>org.springframework</groupId>
  18.         <artifactId>spring-test</artifactId>
  19.         <version>5.0.2.RELEASE</version>
  20.     </dependency>
  21.     <!--单元测试-->
  22.     <dependency>
  23.         <groupId>junit</groupId>
  24.         <artifactId>junit</artifactId>
  25.         <version>4.12</version>
  26.         <scope>test</scope>
  27.     </dependency>
  28. </dependencies>
  • 定义被增强的业务逻辑类 ```java package com.itheima.service.impl;

import com.itheima.service.UserService; import org.springframework.stereotype.Service;

/**

  • 包名:com.itheima.service.impl *
  • @author Leevi
  • 日期2020-08-12 08:36
  • 目标1:在执行增删改查方法之前，都做权限校验 前置通知: before
  • 目标2:在执行增删改查方法之后(没有出现异常)， 都打印日志 后置通知: after-returning
  • 目标3:在执行增删改查方法出现异常之后，都进行友好的提示 异常通知: after-throwing
  • 目标4:在执行增删改查方法之后，无论出没出现异常，均打印一句”执行完毕” 最终通知: after

  • 目标5:计算update方法的执行时间 环绕通知: around */ @Service public class UserServiceImpl implements UserService { @Override public void add() {

    1.  System.out.println("执行添加...");
    2.  int num = 10/0;

    }

    @Override public void delete() {

    1.  System.out.println("执行删除...");

    }

    @Override public void update() {

    1.  try {
    2.      Thread.sleep(3000);
    3.  } catch (InterruptedException e) {
    4.      e.printStackTrace();
    5.  }
    6.  System.out.println("执行修改...");

    }

    @Override public void select() {

    1.  System.out.println("执行查询...");

    } } ```

  • 定义切面类,在切面增强类上面使用注解 @Aspect并且在切面类中定义切入点方法 ```java package com.itheima.aspect;

import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component;

/**

  • 包名:com.itheima.aspect *
  • @author Leevi
  • 日期2020-08-12 08:39 *
    1. 注解方式配置切入点 在方法上添加Pointcut注解配置切入点，方法的名字就是切入点的唯一标识
    1. 配置通知
    1. 前置通知 Before注解
    1. 后置通知 AfterReturning注解
    1. 异常通知 AfterThrowing注解
    1. 最终通知 After注解
    1. 环绕通知 Around注解

    1. 配置切面:在切面类上添加Aspect注解 / @Component @Aspect public class PermissionAspect { @Pointcut(“execution( com.itheima.service.impl.UserServiceImpl.*(..))”) public void pt1(){

      }

      @Pointcut(“execution(* com.itheima.service.impl.UserServiceImpl.update(..))”) public void pt2(){

      }

      @Before(“pt1()”) public void checkPermission(){ System.out.println(“校验权限…”); }

      @AfterReturning(“pt1()”) public void printLog(){ System.out.println(“打印日志…”); }

      @AfterThrowing(“pt1()”) public void showException(){ System.out.println(“出现异常了，请检查…”); }

      @After(“pt1()”) public void showEnd(){ System.out.println(“执行完毕…”); }

      //计算目标方法的执行时长 @Around(“pt2()”) public void showMillions(ProceedingJoinPoint joinPoint){ //1. 记录当前时间 long timeMillis1 = System.currentTimeMillis(); //2. 执行目标方法 try {

      1.   joinPoint.proceed();

      } catch (Throwable throwable) {

      1.   throwable.printStackTrace();

      } //3. 再记录当前时间 long timeMillis2 = System.currentTimeMillis(); //4. 将两次的时间相减，得到方法的执行时长 System.out.println(timeMillis2 - timeMillis1); } } ```

  • 创建配置文件

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.      xmlns:aop="http://www.springframework.org/schema/aop"
    5.      xmlns:context="http://www.springframework.org/schema/context"
    6.      xsi:schemaLocation="http://www.springframework.org/schema/beans
    7.      http://www.springframework.org/schema/beans/spring-beans.xsd
    8.      http://www.springframework.org/schema/aop
    9.      http://www.springframework.org/schema/aop/spring-aop.xsd
    10.      http://www.springframework.org/schema/context
    11.      http://www.springframework.org/schema/context/spring-context.xsd">
    12.   <!--1. 包扫描-->
    13.   <context:component-scan base-package="com.itheima"/>
    15.   <!--
    16.       2. 加载aop的注解驱动
    17.   -->
    18.   <aop:aspectj-autoproxy />
    19. </beans>

第二章 - Spring中的JdbcTemplate 【了解】

知识点-JdbcTemplate基本使用

1.目标

  • 能够使用JdbcTemplate

2.路径

  1. JdbcTemplate介绍
  2. JdbcTemplate入门
  3. 使用JdbcTemplate完成CRUD

3.讲解

3.1JdbcTemplate介绍

  1. Spring除了IOC 和 AOP之外，还对Dao层的提供了支持。 就算没有框架，也对原生的JDBC提供了支持。它是spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。
持久化技术 模版类
JDBC org.springframework.jdbc.core.JdbcTemplate
Hibrenate org.springframework.orm.hibernate5.HibernateTemplate
MyBatis org.mybatis.spring.SqlSessionTemplate

3.2JDBC模版入门案例

  • 创建Maven工程,导入坐标
  1. <dependencies>
  2.     <!--Spring核心容器-->
  3.     <dependency>
  4.         <groupId>org.springframework</groupId>
  5.         <artifactId>spring-context</artifactId>
  6.         <version>5.0.2.RELEASE</version>
  7.     </dependency>
  8.     <!--SpringJdbc-->
  9.     <dependency>
  10.         <groupId>org.springframework</groupId>
  11.         <artifactId>spring-jdbc</artifactId>
  12.         <version>5.0.2.RELEASE</version>
  13.     </dependency>
  15.     <dependency>
  16.         <groupId>mysql</groupId>
  17.         <artifactId>mysql-connector-java</artifactId>
  18.         <version>5.1.6</version>
  19.     </dependency>
  20.     <!--Spring整合单元测试-->
  21.     <dependency>
  22.         <groupId>org.springframework</groupId>
  23.         <artifactId>spring-test</artifactId>
  24.         <version>5.0.2.RELEASE</version>
  25.     </dependency>
  26.     <!--单元测试-->
  27.     <dependency>
  28.         <groupId>junit</groupId>
  29.         <artifactId>junit</artifactId>
  30.         <version>4.12</version>
  31.         <scope>test</scope>
  32.     </dependency>
  34.     <dependency>
  35.         <groupId>org.projectlombok</groupId>
  36.         <artifactId>lombok</artifactId>
  37.         <version>1.18.12</version>
  38.     </dependency>
  40.     <!--druid连接池-->
  41.     <dependency>
  42.         <groupId>com.alibaba</groupId>
  43.         <artifactId>druid</artifactId>
  44.         <version>1.1.18</version>
  45.     </dependency>
  46. </dependencies>
  • Account
  1. package com.itheima.pojo;
  3. import lombok.Data;
  5. /**
  6.  * 包名:com.itheima.pojo
  7.  *
  8.  * @author Leevi
  9.  * 日期2020-08-09  14:55
  10.  */
  11. @Data
  12. public class Account {
  13.     private String name;
  14.     private Integer id;
  15.     private Double money;
  16. }
  • 使用JDBC模版API
  1. //使用JDBC模版保存
  2. public void save(Account account) {
  3.     //1. 创建数据源
  4.     DriverManagerDataSource dataSource = new DriverManagerDataSource();
  5.     dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  6.     dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03");
  7.     dataSource.setUsername("root");
  8.     dataSource.setPassword("123456");
  10.     //2. 创建JDBC模版
  11.     JdbcTemplate jdbcTemplate = new JdbcTemplate();
  12.     jdbcTemplate.setDataSource(dataSource);
  14.     //3.操作数据库
  15.     String sql = "insert into account values(?,?,?)";
  16.     jdbcTemplate.update(sql, null,account.getName(),account.getMoney())
  18. }

3.3.使用JDBC模版完成CRUD

  1. 增加
    1. String sql = "insert into account values(?,?,?)";
    2. jdbcTemplate.update(sql, null,account.getName(),account.getMoney());
  1. 修改
    1. String sql ="update account set name = ? where id = ?";
    2. Object[] objects = {user.getName(), user.getId()};
    3. jdbcTemplate.update(sql,objects);
  1. 删除
    1. String sql = "delete from account where id=?";
    2. jdbcTemplate.update(sql, 6);
  1. 查询单个值
    1. String sql = "select count(*) from t_user";
    2. Long n = jdbcTemplate.queryForObject(sql, Long.class);
  1. String sql = "select name from t_user where id=?";
  2. String name = jdbcTemplate.queryForObject(sql, String.class, 4);
  3. System.out.println(name);
  1. 查询单个对象
    1. String sql = "select * from account where id = ?";
    2. User user = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<>(Account.class),id);
  1. 查询集合
    1. String sql = "select * from account";
    2. List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
    3. System.out.println(list);
  1. String sql = "select * from account";
  2. List<Account> list = List<User> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Account.class));

4.小结

  1. JdbcTemplate是Spring里面的持久层一个工具包, 封装了Jdbc

  2. 使用步骤

    • 创建DataSource
    • 创建JDBCTemplate
    • 调用update(), query(), queryForObject()

知识点-在dao中使用JdbcTemplate

1.目标

  • 能够使用spring的jdbc的模板

2.路径

  1. 方式一在dao中定义JdbcTemplate
  2. 方式二dao继承JdbcDaoSupport

3.讲解

3.1方式一

  1. 这种方式我们采取在dao中定义JdbcTemplate
  • AccountDaoImpl.java
  1. public class AccountDaoImpl implements AccountDao {
  2.     @Autowired
  3.     private JdbcTemplate jdbcTemplate;
  5.     @Override
  6.     public Account findAccountById(Integer id) {
  7.         List<Account> list =  jdbcTemplate.query("select * from account where id = ? ",new AccountRowMapper(),id);
  8.         return list.isEmpty()?null:list.get(0);
  9.     }
  11.     @Override
  12.     public Account findAccountByName(String name) {
  13.         List<Account> list =  jdbcTemplate.query("select * from account where name = ? ",new AccountRowMapper(),name);
  14.         if(list.isEmpty()){
  15.             return null;
  16.         }
  17.         if(list.size()>1){
  18.             throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
  19.         }
  20.         return list.get(0);
  21.     }
  23.     @Override
  24.     public void updateAccount(Account account) {
  25.         jdbcTemplate.update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
  26.     }
  28. }
  • applicationContext.xml
  1.     <!-- 配置一个dao -->
  2.     <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  3.         <!-- 注入jdbcTemplate -->
  4.         <property name="jdbcTemplate" ref="jdbcTemplate"></property>
  5.     </bean>
  7.     <!-- 配置一个数据库的操作模板：JdbcTemplate -->
  8.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  9.         <property name="dataSource" ref="dataSource"></property>
  10.     </bean>
  12.     <!-- 配置数据源 -->
  13.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  14.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  15.         <property name="url" value="jdbc:mysql:///spring_day04"></property>
  16.         <property name="username" value="root"></property>
  17.         <property name="password" value="123456"></property>
  18.     </bean>

3.2方式二

  1. 这种方式我们采取让dao继承JdbcDaoSupport
  • AccountDaoImpl.java
  1. public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
  3.     @Override
  4.     public Account findAccountById(Integer id) {
  5.         //getJdbcTemplate()方法是从父类上继承下来的。
  6.         List<Account> list = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id);
  7.         return list.isEmpty()?null:list.get(0);
  8.     }
  10.     @Override
  11.     public Account findAccountByName(String name) {
  12.         //getJdbcTemplate()方法是从父类上继承下来的。
  13.         List<Account> list =  getJdbcTemplate().query("select * from account where name = ? ",new AccountRowMapper(),name);
  14.         if(list.isEmpty()){
  15.             return null;
  16.         }
  17.         if(list.size()>1){
  18.             throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
  19.         }
  20.         return list.get(0);
  21.     }
  23.     @Override
  24.     public void updateAccount(Account account) {
  25.         //getJdbcTemplate()方法是从父类上继承下来的。
  26.         getJdbcTemplate().update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
  27.     }
  28. }
  • applicationContext.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.         xsi:schemaLocation="http://www.springframework.org/schema/beans 
  5.         http://www.springframework.org/schema/beans/spring-beans.xsd">
  7. <!-- 配置dao2 -->
  8. <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  9.     <!-- 注入dataSource -->
  10.     <property name="dataSource" ref="dataSource"></property>
  11. </bean>
  12. <!-- 配置数据源 -->
  13. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  14.     <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  15.     <property name="url" value="jdbc:mysql:///spring_day04"></property>
  16.         <property name="username" value="root"></property>
  17.         <property name="password" value="123456"></property>
  18.     </bean>
  19. </beans>

4.小结

  1. 方式一: 自己注册JDBCTemplate, 自己在Dao注入JDBCTemplate

  2. 方式二: 继承JdbcDaoSupport, 不需要自己注册JDBCTemplate, 也不需要自己注入JDBCTemplate
    需要注入DataSource

第三章-Spring配置第三方连接池

知识点-Spring配置第三方连接池

1.目标

  • 能够配置spring的连接池

2.路径

  1. Spring配置C3P0连接池
  2. Spring配置Druid连接池
  3. Spring配置HikariCP连接池【扩展】

3.讲解

3.1Spring配置C3P0连接池

官网:http://www.mchange.com/projects/c3p0/

步骤:

  1. 导入c3p0的坐标
  2. 注册连接池(修改DataSource的class以及四个基本项)

实现:

  • 导入坐标
  1.   <dependency>
  2.         <groupId>c3p0</groupId>
  3.         <artifactId>c3p0</artifactId>
  4.         <version>0.9.1.2</version>
  5.   </dependency>
  • 配置数据源连接池
  1.  <!-- 配置C3P0数据库连接池 -->
  2.  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  3.     <property name="jdbcUrl" value="jdbc:mysql:///spring_jdbc" />
  4.     <property name="driverClass" value="com.mysql.jdbc.Driver" />
  5.     <property name="user" value="root" />
  6.     <property name="password" value="123456" />
  7.  </bean>
  8.  <!-- 管理JDBC模版 -->
  9.  <bean id="jdbcTemplete" class="org.springframework.jdbc.core.JdbcTemplate">
  10.     <property name="dataSource" ref="dataSource" />
  11.  </bean>

核心类：`com.mchange.v2.c3p0.ComboPooledDataSource

3.2.Spring配置Druid连接池

官网:http://druid.io/

步骤:

  1. 导入Druid坐标
  2. 修改DataSource的class(四个基本项)

实现:

  • 导入坐标
    1. <dependency>
    2.   <groupId>com.alibaba</groupId>
    3.   <artifactId>druid</artifactId>
    4.   <version>1.0.9</version>
    5. </dependency>
  • 配置数据源连接池
  1.     <!--注册dataSource -->
  2.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
  3.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  4.         <property name="url" value="jdbc:mysql://localhost:3306/spring_day03"></property>
  5.         <property name="username" value="root"></property>
  6.         <property name="password" value="123456"></property>
  7.     </bean>
  9.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  10.         <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
  11.     </bean>

3.3.Spring配置HikariCP连接池【扩展】

官网:https://github.com/brettwooldridge/HikariCP

步骤:

  1. 添加HikariCP坐标
  2. 修改DataSource的class(四个基本项)

实现:

  • 导入HikariCP坐标
    1. <dependency>
    2.  <groupId>com.zaxxer</groupId>
    3.  <artifactId>HikariCP</artifactId>
    4.  <version>3.1.0</version>
    5. </dependency>

  • 配置数据源连接池

    1. <!-- 配置HikariCP数据库连接池 -->
    2. <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
    3.   <property name="jdbcUrl" value="jdbc:mysql:///spring_jdbc" />
    4.   <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    5.   <property name="username" value="root" />
    6.   <property name="password" value="123456" />
    7. </bean>
    9. <!-- 管理JDBC模版 -->
    10. <bean id="jdbcTemplete" class="org.springframework.jdbc.core.JdbcTemplate">
    11. <property name="dataSource" ref="dataSource" />
    12. </bean>
  2.   >  核心类：`com.zaxxer.hikari.HikariDataSource`
  5.    + 为什么HikariCP为什么越来越火?   
  6.       + 效率高
  7.       + 一直在维护  
  8.       + ==SpringBoot2.0 现在已经把HikariCP作为默认的连接池了==
  11.     + 为什么HikariCP被号称为性能最好的Java数据库连接池?  
  13.       + 优化并精简字节码: HikariCP利用了一个第三方的Java字节码修改类库Javassist来生成委托实现动态代理  
  15.       + 优化代理和拦截器：减少代码，代码量越少。一般意味着运行效率越高、发生bug的可能性越低.
  21.     ![1540557295765](img/1540557295765.png)
  23.   + 自定义集合类型ConcurrentBag：ConcurrentBag的实现借鉴于C#中的同名类，是一个专门为连接池设计的lock-less集合，实现了比LinkedBlockingQueue、LinkedTransferQueue更好的并发性能。ConcurrentBag内部同时使用了ThreadLocal和CopyOnWriteArrayList来存储元素，其中CopyOnWriteArrayList是线程共享的。ConcurrentBag采用了queue-stealing的机制获取元素：首先尝试从ThreadLocal中获取属于当前线程的元素来避免锁竞争，如果没有可用元素则再次从共享的CopyOnWriteArrayList中获取。此外，ThreadLocal和CopyOnWriteArrayList在ConcurrentBag中都是成员变量，线程间不共享，避免了伪共享(false sharing)的发生。
  25.   + 使用FastList替代ArrayList: FastList是一个List接口的精简实现，只实现了接口中必要的几个方法。JDK ArrayList每次调用get()方法时都会进行rangeCheck检查索引是否越界，FastList的实现中去除了这一检查，只要保证索引合法那么rangeCheck就成为了不必要的计算开销(当然开销极小)。
  33. ### 4.小结
  35. 1. 导入连接池坐标
  36. 2. 改DataSource的class属性值, 配置属性名
  40. ## 知识点-Spring引入Properties配置文件
  42. ### 1.目标
  44. - [ ] 掌握Spring引入Properties配置文件
  46. ### 2.步骤
  48. 1. 定义jdbc.properties
  49. 2. 把jdbc.properties引入applicationContext.xml
  50. 3. 使用表达式根据key获得value
  54. ### 3.实现
  56. #### 3.1jdbc.properties
  58. ```properties
  59. jdbc.driver=com.mysql.jdbc.Driver
  60. jdbc.url=jdbc:mysql://localhost:3306/spring_day03
  61. jdbc.username=root
  62. jdbc.password=123456

3.2 引入外部properties文件

  • 引入配置文件方式一(不推荐使用)
  1.  <!-- 引入properties配置文件：方式一 (繁琐不推荐使用) -->
  2. <bean id="properties" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
  3.     <property name="location" value="classpath:jdbc.properties" />
  4. </bean>
  • 引入配置文件方式二【推荐使用】
  1.  <!-- 引入properties配置文件：方式二 (简单推荐使用) -->
  2. <context:property-placeholder location="classpath:jdbc.properties" />

classpath表示的是类路径，对于配置文件而言也就是那个resources根目录

  • bean标签中引用配置文件内容
  1.  <!-- hikariCP 连接池 -->
  2. <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
  3.     <property name="jdbcUrl" value="${jdbc.url}" />
  4.     <property name="driverClassName" value="${jdbc.driver}" />
  5.     <property name="username" value="${jdbc.username}" />
  6.     <property name="password" value="${jdbc.password}" />
  7. </bean>

注意:在使用<context:property-placeholder/>标签时，properties配置文件中的key一定要是带点分隔的。例如jdbc.url

4.小结

  1. 定义jdbc.properties
  2. 把jdbc.properties引入到applicationContext.xml
  3. 根据key读取value

第四章-Spring管理事务

知识点-Spring管理事务概述(了解即可)

1.目标

  • 知道Spring管理事务相关的API

2.路径

  1. 概述
  2. 相关的API

3.讲解

3.1概述

  1. 由于Spring对持久层的很多框架都有支持 ， Hibernate 、 jdbc 、JdbcTemplate , MyBatis ，由于使用的框架不同，所以使用事务管理操作API 也不尽相同。 为了规范这些操作， Spring统一定义一个事务的规范 ，这其实是一个接口 。这个接口的名称 ： PlatformTrasactionManager.并且它对已经做好的框架都有支持.
  3. 如果dao层使用的是JDBC,  JdbcTemplate 或者mybatis,那么 可以使用DataSourceTransactionManager 来处理事务
  5. 如果dao层使用的是 Hibernate, 那么可以使用HibernateTransactionManager 来处理事务

3.2相关的API

3.2.1PlatformTransactionManager
  1. 平台事务管理器是一个接口，实现类就是Spring真正管理事务的对象。
  3. 常用的实现类:
  5.     **DataSourceTransactionManager**   :JDBC开发的时候(JDBCTemplate,MyBatis)，使用事务管理。
  7.     HibernateTransactionManager       :Hibernate开发的时候，使用事务管理。

3.2.2 TransactionDefinition
  1. 事务定义信息中定义了事务的隔离级别，传播行为，超时信息，只读。

3.2.3 TransactionStatus:事务的状态信息
  1. 事务状态信息中定义事务是否是新事务，是否有保存点。

4.小结

  1. Spring管理事务是通过事务管理器. 定义了一个接口PlatformTransactionManager

    • DataSourceTransactionManager JDBC,MyBatis,JDBCTemplate
    • HibernateTransactionManager Hibernate

知识点-编程式(通过代码)(硬编码)事务【了解】

1.目标

  • 了解Spring编程式事务

2.步骤

  1. 创建DataSource对象
  2. 创建JDBCTemplate对象
  3. 创建事务管理器, 传入DataSource. DataSourceTransactionManager
  4. 创建事务模版
  5. 通过事务模版进行事务处理
  6. 在事务里面操作数据库

3.实现

  • 添加依赖
  1. <dependencies>
  2.     <!--依赖-->
  3.     <!--1. spring的核心依赖-->
  4.     <dependency>
  5.         <groupId>org.springframework</groupId>
  6.         <artifactId>spring-context</artifactId>
  7.         <version>5.0.2.RELEASE</version>
  8.     </dependency>
  9.     <!--2. spring-jdbc的依赖-->
  10.     <dependency>
  11.         <groupId>org.springframework</groupId>
  12.         <artifactId>spring-jdbc</artifactId>
  13.         <version>5.0.2.RELEASE</version>
  14.     </dependency>
  15.     <!--3. spring-test-->
  16.     <dependency>
  17.         <groupId>org.springframework</groupId>
  18.         <artifactId>spring-test</artifactId>
  19.         <version>5.0.2.RELEASE</version>
  20.     </dependency>
  21.     <!--10. aop的依赖-->
  22.     <dependency>
  23.         <groupId>org.aspectj</groupId>
  24.         <artifactId>aspectjweaver</artifactId>
  25.         <version>1.8.7</version>
  26.     </dependency>
  27.     <!--4. mysql-->
  28.     <dependency>
  29.         <groupId>mysql</groupId>
  30.         <artifactId>mysql-connector-java</artifactId>
  31.         <version>5.1.6</version>
  32.     </dependency>
  33.     <!--5. mybatis-->
  34.     <dependency>
  35.         <groupId>org.mybatis</groupId>
  36.         <artifactId>mybatis</artifactId>
  37.         <version>3.5.3</version>
  38.     </dependency>
  39.     <!--6. mybatis-spring-->
  40.     <dependency>
  41.         <groupId>org.mybatis</groupId>
  42.         <artifactId>mybatis-spring</artifactId>
  43.         <version>1.3.0</version>
  44.     </dependency>
  45.     <!--7. Junit的依赖-->
  46.     <dependency>
  47.         <groupId>junit</groupId>
  48.         <artifactId>junit</artifactId>
  49.         <version>4.12</version>
  50.         <scope>test</scope>
  51.     </dependency>
  52.     <!--8. lombok的依赖-->
  53.     <dependency>
  54.         <groupId>org.projectlombok</groupId>
  55.         <artifactId>lombok</artifactId>
  56.         <version>1.18.10</version>
  57.     </dependency>
  58.     <!--9. 日志的依赖-->
  59.     <!-- log start -->
  60.     <dependency>
  61.         <groupId>log4j</groupId>
  62.         <artifactId>log4j</artifactId>
  63.         <version>1.2.12</version>
  64.     </dependency>
  66.     <dependency>
  67.         <groupId>org.slf4j</groupId>
  68.         <artifactId>slf4j-api</artifactId>
  69.         <version>1.6.6</version>
  70.     </dependency>
  72.     <dependency>
  73.         <groupId>org.slf4j</groupId>
  74.         <artifactId>slf4j-log4j12</artifactId>
  75.         <version>1.6.6</version>
  76.     </dependency>
  77.     <!-- log end -->
  78. </dependencies>
  • 代码
  1. package com.itheima.service.impl;
  3. import com.itheima.dao.AccountDao;
  4. import com.itheima.pojo.Account;
  5. import com.itheima.service.AccountService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  8. import org.springframework.stereotype.Service;
  9. import org.springframework.transaction.TransactionStatus;
  10. import org.springframework.transaction.support.TransactionCallback;
  11. import org.springframework.transaction.support.TransactionTemplate;
  13. import javax.sql.DataSource;
  15. /**
  16.  * 包名:com.itheima.service.impl
  17.  * @author Leevi
  18.  * 日期2020-08-12  10:57
  19.  * 持久层不同的框架有不同的事务控制方案:
  20.  * 1. 原始的JDBC:
  21.  *    1.1 开启事务: connection.setAutoCommit(false);
  22.  *    1.2 提交事务: connection.commit();
  23.  *    1.3 回滚事务: connection.rollback();
  24.  *
  25.  * 2. DBUtils框架: 和原始的JDBC是一样的
  26.  * 3. mybatis框架: 底层也是使用的JDBC的事务
  27.  *    3.1 开启事务: sqlSessionFactory.openSession(); 开启事务
  28.  *    3.2 提交事务: sqlSession.commit();
  29.  *    3.3 回滚事务: sqlSession.rollback();
  30.  * 4. 只要某个持久层框架和spring整合了，那么事务相关的操作就都交给spring控制
  31.  *    4.1 编程式事务(了解)
  32.  *    4.2 声明式事务(重点掌握)
  33.  */
  34. @Service
  35. public class AccountServiceImpl implements AccountService{
  36.     @Autowired
  37.     private AccountDao accountDao;
  38.     @Autowired
  39.     private DataSource dataSource;
  40.     @Override
  41.     public void transfer(String fromName, String toName, double money) {
  42.         //创建事务管理者
  43.         DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
  44.         transactionManager.setDataSource(dataSource);
  45.         //创建事务模板
  46.         TransactionTemplate transactionTemplate = new TransactionTemplate();
  48.         //给事务模板配置事务管理者
  49.         transactionTemplate.setTransactionManager(transactionManager);
  50.         transactionTemplate.execute(new TransactionCallback<Object>() {
  51.             @Override
  52.             public Object doInTransaction(TransactionStatus status) {
  53.                 //1. 转出账户扣款
  54.                 accountDao.updateAccount(new Account(null,fromName,-money));
  56.                 //出现异常
  57.                 int num = 10/0;
  59.                 //2. 转入账户收款
  60.                 accountDao.updateAccount(new Account(null,toName,money));
  61.                 return null;
  62.             }
  63.         });
  65.     }
  66. }

4.小结

  1. 我们项目开发 一般不会使用编程式(硬编码)方式. 一般使用声明式(配置)事务

    • xml方式
    • 注解方式

知识点-Spring声明式事务-xml配置方式【重点】

Spring的声明式事务的作用是: 无论spring集成什么dao框架，事务代码都不需要我们再编写了

声明式的事务管理的思想就是AOP的思想。面向切面的方式完成事务的管理。声明式事务有两种,xml配置方式和注解方式.

1.目标

  • 使用xml方式配置事务

2.步骤

  1. 注册事务管理器, 配置数据源
  2. 配置事务建议(事务规则: 事务隔离级别, 遇到什么异常回滚,是否只读…)

  3. 配置AOP

    • 配置切入点
    • 配置切面

3.讲解

3.1实现

  1. <dependencies>
  2.     <!--依赖-->
  3.     <!--1. spring的核心依赖-->
  4.     <dependency>
  5.         <groupId>org.springframework</groupId>
  6.         <artifactId>spring-context</artifactId>
  7.         <version>5.0.2.RELEASE</version>
  8.     </dependency>
  9.     <!--2. spring-jdbc的依赖-->
  10.     <dependency>
  11.         <groupId>org.springframework</groupId>
  12.         <artifactId>spring-jdbc</artifactId>
  13.         <version>5.0.2.RELEASE</version>
  14.     </dependency>
  15.     <!--3. spring-test-->
  16.     <dependency>
  17.         <groupId>org.springframework</groupId>
  18.         <artifactId>spring-test</artifactId>
  19.         <version>5.0.2.RELEASE</version>
  20.     </dependency>
  21.     <!--10. aop的依赖-->
  22.     <dependency>
  23.         <groupId>org.aspectj</groupId>
  24.         <artifactId>aspectjweaver</artifactId>
  25.         <version>1.8.7</version>
  26.     </dependency>
  27.     <!--4. mysql-->
  28.     <dependency>
  29.         <groupId>mysql</groupId>
  30.         <artifactId>mysql-connector-java</artifactId>
  31.         <version>5.1.6</version>
  32.     </dependency>
  33.     <!--5. mybatis-->
  34.     <dependency>
  35.         <groupId>org.mybatis</groupId>
  36.         <artifactId>mybatis</artifactId>
  37.         <version>3.5.3</version>
  38.     </dependency>
  39.     <!--6. mybatis-spring-->
  40.     <dependency>
  41.         <groupId>org.mybatis</groupId>
  42.         <artifactId>mybatis-spring</artifactId>
  43.         <version>1.3.0</version>
  44.     </dependency>
  45.     <!--7. Junit的依赖-->
  46.     <dependency>
  47.         <groupId>junit</groupId>
  48.         <artifactId>junit</artifactId>
  49.         <version>4.12</version>
  50.         <scope>test</scope>
  51.     </dependency>
  52.     <!--8. lombok的依赖-->
  53.     <dependency>
  54.         <groupId>org.projectlombok</groupId>
  55.         <artifactId>lombok</artifactId>
  56.         <version>1.18.10</version>
  57.     </dependency>
  58.     <!--9. 日志的依赖-->
  59.     <!-- log start -->
  60.     <dependency>
  61.         <groupId>log4j</groupId>
  62.         <artifactId>log4j</artifactId>
  63.         <version>1.2.12</version>
  64.     </dependency>
  66.     <dependency>
  67.         <groupId>org.slf4j</groupId>
  68.         <artifactId>slf4j-api</artifactId>
  69.         <version>1.6.6</version>
  70.     </dependency>
  72.     <dependency>
  73.         <groupId>org.slf4j</groupId>
  74.         <artifactId>slf4j-log4j12</artifactId>
  75.         <version>1.6.6</version>
  76.     </dependency>
  77.     <!-- log end -->
  78. </dependencies>
  • 配置事务管理器
    1. <bean id="transactionManager"         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    2.       <property name="dataSource" ref="dataSource"></property>
    3. </bean>

  • 配置事务建议(事务的规则)

    1. <!--配置事务规则-->
    2. <tx:advice id="transferAdvice" transaction-manager="transactionManager">
    3.   <!--配置事务的属性-->
    4.   <tx:attributes>
    5.       <!--
    6.               哪个方法需要使用什么样的事务配置
    7.                   rollback-for="java.lang.Exception" 什么时候回滚:遇到所有的Exception都会回滚
    8.                   no-rollback-for="java.lang.NullPointerException" 什么时候不回滚:遇到NullPointerException不回滚
    9.                   timeout="-1" 事务的超时时间，默认不超时
    10.                   read-only="false" 是否是只读事务,默认不是只读事务,只读事务只会针对于查询方法，如果是增删改一定不能设置为只读
    11.                   isolation="" 事务的隔离级别: 目的是为了防止不同事务之间相互影响
    12.                       1. Read Uncommitted  读取到未提交的事务，在这种隔离级别下，可能发生脏读、不可重复读、幻读
    13.                       2. Read Committed(Oracle的默认隔离级别) 读取到已提交的事务，在这种隔离级别下，不可能发生脏读，但是可能发生不可重复读和幻读
    14.                       3. Repeatable Read（mysql的默认隔离级别） 可重复读，在这种隔离级别下不会发生脏读、不可重复读，但是有可能发生幻读
    15.                       4. Serializable 串行化的，在这种隔离级别下不会发生脏读、不可重复读、幻读
    17.                   propagation="" 事务的传播行为
    18.                           - PROPAGATION_REQUIRED:默认值，也是最常用的场景.
    19.                             如果当前没有事务，就新建一个事务，
    20.                             如果已经存在一个事务中，加入到这个事务中。
    22.                           - PROPAGATION_SUPPORTS：
    23.                             如果当前没有事务，就以非事务方式执行。
    24.                             如果已经存在一个事务中，加入到这个事务中。
    26.                           - PROPAGATION_MANDATORY
    27.                             如果当前没有有事务，就抛出异常;
    28.                             如果已经存在一个事务中，加入到这个事务中。
    30.                           保证不在同一个事务里:
    31.                           - PROPAGATION_REQUIRES_NEW
    32.                             如果当前有事务，把当前事务挂起,创建新的事务但独自执行
    34.                           - PROPAGATION_NOT_SUPPORTED
    35.                             如果当前存在事务，就把当前事务挂起。不创建事务
    37.                           - PROPAGATION_NEVER
    38.                             如果当前存在事务，抛出异常
    40.           -->
    41.       <tx:method name="transfer"
    42.                  rollback-for="java.lang.Exception"
    43.                  no-rollback-for="java.lang.NullPointerException"/>
    44.   </tx:attributes>
    45. </tx:advice>
  • 配置事务的AOP
    1. <aop:config>
    2.   <!--声明切入点-->
    3.   <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.AccountServiceImpl.transfer(..))"/>
    4.   <!--绑定切入点和事务-->
    5.   <aop:advisor advice-ref="transferAdvice" pointcut-ref="pt1"></aop:advisor>
    6. </aop:config>

3.2事务的传播行为

3.2.1事务的传播行为的作用
  1. 我们一般都是将事务设置在Service层,那么当我们调用Service层的一个方法的时候, 它能够保证我们的这个方法中,执行的所有的对数据库的更新操作保持在一个事务中， 在事务层里面调用的这些方法要么全部成功，要么全部失败。
  3. 如果你的Service层的这个方法中，除了调用了Dao层的方法之外， 还调用了本类的其他的Service方法，那么在调用其他的Service方法的时候， 我必须保证两个service处在同一个事务中，确保事物的一致性。
  5.  事务的传播特性就是解决这个问题的。

3.2.2 事务的传播行为的取值

保证在同一个事务里面:

  • PROPAGATION_REQUIRED:默认值，也是最常用的场景.
    如果当前没有事务，就新建一个事务，
    如果已经存在一个事务中，加入到这个事务中。

  • PROPAGATION_SUPPORTS：
    如果当前没有事务，就以非事务方式执行。
    如果已经存在一个事务中，加入到这个事务中。

  • PROPAGATION_MANDATORY
    如果当前没有有事务，就抛出异常;
    如果已经存在一个事务中，加入到这个事务中。

保证不在同一个事物里:

  • PROPAGATION_REQUIRES_NEW
    如果当前有事务，把当前事务挂起,创建新的事务但独自执行

  • PROPAGATION_NOT_SUPPORTED
    如果当前存在事务，就把当前事务挂起。不创建事务

  • PROPAGATION_NEVER
    如果当前存在事务，抛出异常

4.小结

  1. 注册事务管理器, 需要注入DataSource
  2. 配置事务建议(规则: 隔离级别, 事务传播行为…)

  3. 配置AOP

    • 配置切入点
    • 配置切面

知识点-spring声明式事务-注解方式【重点】

1.目标

  • 使用注解方式配置事务

2.步骤

  1. 注册事务管理器

  2. 开启事务注解支持

  3. 在业务类上面添加@Transactional

3.实现

  • 在applicationContext里面打开注解驱动
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.      xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    5.      xsi:schemaLocation="http://www.springframework.org/schema/beans
    6.                          http://www.springframework.org/schema/beans/spring-beans.xsd
    7.                          http://www.springframework.org/schema/aop
    8.                          http://www.springframework.org/schema/aop/spring-aop.xsd
    9.                          http://www.springframework.org/schema/tx
    10.                          http://www.springframework.org/schema/tx/spring-tx.xsd">
    11.   <import resource="classpath:application-mybatis.xml"></import>
    12.   <!--配置申明式事务-->
    13.   <!--
    14.       注解方式配置声明式事务
    15.           1. 配置事务管理者
    16.           2. 加载事务注解驱动
    17.           3. 在代码中使用Transactional注解来标注，哪个方法需要使用事务
    18.   -->
    19.   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    20.       <property name="dataSource" ref="dataSource"></property>
    21.   </bean>
    22.   <tx:annotation-driven transaction-manager="transactionManager"/>
    23. </beans>
  • 在业务逻辑类上面使用注解
    @Transactional ： 如果在类上声明，那么标记着该类中的所有方法都使用事务管理。也可以作用于方法上， 那么这就表示只有具体的方法才会使用事务。

4.小结

4.1步骤

  1. 注册事务管理器
  2. 开启事务注解支持
  3. 在业务类上面添加@Transactional

4.2两种方式比较

  • xml方式

    • 优点: 只需要配一次, 全局生效, 容易维护
    • 缺点: 相对注解而言 要麻烦一点

  • 注解方式

    • 优点: 配置简单
    • 缺点: 写一个业务类就配置一次, 事务细节不好处理, 不好维护