Spring_four

Spring_four

基于XML的AOP实现事务控制

坐标xml

  1. <dependencies>
  2.  <dependency>
  3.  <groupId>org.springframework</groupId>
  4.  <artifactId>spring-context</artifactId>
  5.  <version>5.0.2.RELEASE</version>
  6.  </dependency>
  7.  <dependency>
  8.  <groupId>org.springframework</groupId>
  9.  <artifactId>spring-test</artifactId>
  10.  <version>5.0.2.RELEASE</version>
  11.  </dependency>
  12.  <dependency>
  13.  <groupId>commons-dbutils</groupId>
  14.  <artifactId>commons-dbutils</artifactId>
  15.  <version>1.4</version>
  16.  </dependency>
  18.  <dependency>
  19.  <groupId>mysql</groupId>
  20.  <artifactId>mysql-connector-java</artifactId>
  21.  <version>5.1.6</version>
  22.  </dependency>
  24.  <dependency>
  25.  <groupId>c3p0</groupId>
  26.  <artifactId>c3p0</artifactId>
  27.  <version>0.9.1.2</version>
  28.  </dependency>
  30.  <dependency>
  31.  <groupId>junit</groupId>
  32.  <artifactId>junit</artifactId>
  33.  <version>4.12</version>
  34.  </dependency>
  36.  <dependency>
  37.  <groupId>org.aspectj</groupId>
  38.  <artifactId>aspectjweaver</artifactId>
  39.  <version>1.8.7</version>
  40.  </dependency>
  41.  </dependencies>

1562083495746

删除AccountServiceTest测试类上的@Qualifier的注解，不产生代理对象

  1. /**
  2. * 使用Junit单元测试：测试我们的配置
  3. */
  4. @RunWith(SpringJUnit4ClassRunner.class)
  5. @ContextConfiguration(locations = "classpath:applicationContext.xml")
  6. public class AccountServiceTest {
  8.  @Autowired
  9.  private AccountService as;
  11.  @Test
  12.  public void testTransfer(){
  13.         as.transfer("aaa","bbb",100f);
  14.  }
  16. }

此时事务没有控制住

【配置文件】添加spring的aop

applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:aop="http://www.springframework.org/schema/aop"
  4.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  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">
  10.  <!-- 配置Service -->
  11.  <bean id="accountService" class="com.it.service.impl.AccountServiceImpl">
  12.  <!-- 注入dao -->
  13.  <property name="accountDao" ref="accountDao"></property>
  14.  <!--注入事务管理器
  15.         <property name="txManager" ref="txManager"></property>-->
  16.  </bean>
  18.  <!--配置Dao对象-->
  19.  <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl">
  20.  <!-- 注入QueryRunner -->
  21.  <property name="runner" ref="runner"></property>
  22.  <!-- 注入ConnectionUtils -->
  23.  <property name="connectionUtils" ref="connectionUtils"></property>
  24.  </bean>
  26.  <!--配置QueryRunner-->
  27.  <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
  28.  <!--<constructor-arg name="ds" ref="dataSource"></constructor-arg>-->
  29.  </bean>
  31.  <!-- 配置数据源 -->
  32.  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  33.  <!--连接数据库的必备信息-->
  34.  <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  35.  <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  36.  <property name="user" value="root"></property>
  37.  <property name="password" value="root"></property>
  38.  </bean>
  40.  <!-- 配置Connection的工具类 ConnectionUtils -->
  41.  <bean id="connectionUtils" class="com.it.utils.ConnectionUtils">
  42.  <!-- 注入数据源-->
  43.  <property name="dataSource" ref="dataSource"></property>
  44.  </bean>
  46.  <!-- 配置事务管理器-->
  47.  <bean id="txManager" class="com.it.utils.TransactionManager">
  48.  <!-- 注入ConnectionUtils -->
  49.  <property name="connectionUtils" ref="connectionUtils"></property>
  50.  </bean>
  52.  <aop:config>
  53.  <aop:pointcut id="pc" expression="execution(* com.it.service..*.*(..))"></aop:pointcut>
  54.  <aop:aspect ref="txManager">
  55.  <!--配置前置通知：开启事务-->
  56.  <aop:before method="beginTransaction" pointcut-ref="pc"></aop:before>
  57.  <!--配置后置通知：提交事务-->
  58.  <aop:after-returning method="commitTransaction" pointcut-ref="pc"></aop:after-returning>
  59.  <!--配置异常通知：回滚事务-->
  60.  <aop:after-throwing method="rollbackTransaction" pointcut-ref="pc"></aop:after-throwing>
  61.  <!--配置最终通知：释放连接-->
  62.  <aop:after method="closeTransaction" pointcut-ref="pc"></aop:after>
  63.  </aop:aspect>
  64.  </aop:config>
  65. </beans>

【注解】添加spring的aop

可以使用【前置通知】、【后置通知】、【异常通知】、【最终通知】

坐标

  1. <dependencies>
  2.  <dependency>
  3.  <groupId>org.springframework</groupId>
  4.  <artifactId>spring-context</artifactId>
  5.  <version>5.0.2.RELEASE</version>
  6.  </dependency>
  7.  <dependency>
  8.  <groupId>org.springframework</groupId>
  9.  <artifactId>spring-test</artifactId>
  10.  <version>5.0.2.RELEASE</version>
  11.  </dependency>
  12.  <dependency>
  13.  <groupId>commons-dbutils</groupId>
  14.  <artifactId>commons-dbutils</artifactId>
  15.  <version>1.4</version>
  16.  </dependency>
  18.  <dependency>
  19.  <groupId>mysql</groupId>
  20.  <artifactId>mysql-connector-java</artifactId>
  21.  <version>5.1.6</version>
  22.  </dependency>
  24.  <dependency>
  25.  <groupId>c3p0</groupId>
  26.  <artifactId>c3p0</artifactId>
  27.  <version>0.9.1.2</version>
  28.  </dependency>
  30.  <dependency>
  31.  <groupId>junit</groupId>
  32.  <artifactId>junit</artifactId>
  33.  <version>4.12</version>
  34.  </dependency>
  35.  <dependency>
  36.  <groupId>org.aspectj</groupId>
  37.  <artifactId>aspectjweaver</artifactId>
  38.  <version>1.8.7</version>
  39.  </dependency>
  40.  </dependencies>

配置AccountServiceImpl.java的注解

  1. @Service
  2. public class AccountServiceImpl implements AccountService {
  4.  @Autowired
  5.  private AccountDao accountDao;
  6. }

配置AccountDaoImpl.java的注解

  1. @Repository
  2. public class AccountDaoImpl implements AccountDao {
  4.  @Autowired
  5.  private QueryRunner runner;
  6.  @Autowired
  7.  private ConnectionUtils connectionUtils;
  8. }

配置ConnectionUtils.java的注解

  1. @Component
  2. public class ConnectionUtils {
  4.  private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
  6.  @Autowired
  7.  private DataSource dataSource;
  8. }

配置TransactionManager.java的注解

  1. @Component
  2. @Aspect // 切面
  3. public class TransactionManager {
  5.  @Autowired
  6.  private ConnectionUtils connectionUtils;
  8.  @Pointcut(value = "execution(* com.it.service..*.*(..))") // 切入点
  9.  public void pc(){};
  11.  /**
  12.      * 开启事务
  13.      */
  14.  @Before(value = "pc()")
  15.  public void beginTransaction(){
  16.  try {
  17.  System.out.println("前置通知");
  18.             connectionUtils.getThreadConnection().setAutoCommit(false);
  19.  }catch (Exception e){
  20.             e.printStackTrace();
  21.  }
  22.  }
  24.  /**
  25.      * 提交事务
  26.      */
  27.  @AfterReturning(value = "pc()")
  28.  public void commit(){
  29.  try {
  30.  System.out.println("后置通知");
  31.             connectionUtils.getThreadConnection().commit();
  32.  }catch (Exception e){
  33.             e.printStackTrace();
  34.  }
  35.  }
  37.  /**
  38.      * 回滚事务
  39.      */
  40.  @AfterThrowing(value = "pc()")
  41.  public void rollback(){
  42.  try {
  43.  System.out.println("异常通知");
  44.             connectionUtils.getThreadConnection().rollback();
  45.  }catch (Exception e){
  46.             e.printStackTrace();
  47.  }
  48.  }
  51.  /**
  52.      * 释放连接
  53.      */
  54.  @After(value = "pc()")
  55.  public void release(){
  56.  try {
  57.  System.out.println("最终通知");
  58.             connectionUtils.getThreadConnection().close();//把连接还回连接池中
  59.             connectionUtils.removeConnection();
  60.  }catch (Exception e){
  61.             e.printStackTrace();
  62.  }
  63.  }
  64. }

配置spring容器

配置applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:aop="http://www.springframework.org/schema/aop"
  4.  xmlns:context="http://www.springframework.org/schema/context"
  5.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  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.  <!--开启注解支持的组件扫描-->
  13.  <context:component-scan base-package="com.it"></context:component-scan>
  14.  <!--开启aop的注解支持-->
  15.  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  17.  <!--配置QueryRunner-->
  18.  <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
  19.  <!--<constructor-arg name="ds" ref="dataSource"></constructor-arg>-->
  20.  </bean>
  22.  <!-- 配置数据源 -->
  23.  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  24.  <!--连接数据库的必备信息-->
  25.  <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  26.  <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  27.  <property name="user" value="root"></property>
  28.  <property name="password" value="root"></property>
  29.  </bean>
  30. </beans>

text

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = "classpath:applicationContext.xml")
  3. public class AccountServiceTest {
  5.  @Autowired
  6.  private AccountService as;
  8.  @Test
  9.  public void testTransfer(){
  10.         as.transfer("aaa","bbb",100f);
  11.  }
  13. }

但是发现，抛出异常。

1562083852643

因为注解的方式执行顺序是【前置通知】、【最终通知】、【异常通知】/【后置通知】

1562083867841

我们需要使用环绕通知解决问题。

配置TransactionManager.java

  1. @Component
  2. @Aspect
  3. public class TransactionManager {
  5.  @Autowired
  6.  private ConnectionUtils connectionUtils;
  8.  @Pointcut(value = "execution(* com.it.service..*.*(..))")
  9.  public void pc(){};
  11.  /**
  12.      * 开启事务
  13.      */
  14.  //@Before(value = "pc()")
  15.  public void beginTransaction(){
  16.  try {
  17.  System.out.println("前置通知");
  18.             connectionUtils.getThreadConnection().setAutoCommit(false);
  19.  }catch (Exception e){
  20.             e.printStackTrace();
  21.  }
  22.  }
  24.  /**
  25.      * 提交事务
  26.      */
  27.  //@AfterReturning(value = "pc()")
  28.  public void commit(){
  29.  try {
  30.  System.out.println("后置通知");
  31.             connectionUtils.getThreadConnection().commit();
  32.  }catch (Exception e){
  33.             e.printStackTrace();
  34.  }
  35.  }
  37.  /**
  38.      * 回滚事务
  39.      */
  40.  //@AfterThrowing(value = "pc()")
  41.  public void rollback(){
  42.  try {
  43.  System.out.println("异常通知");
  44.             connectionUtils.getThreadConnection().rollback();
  45.  }catch (Exception e){
  46.             e.printStackTrace();
  47.  }
  48.  }
  51.  /**
  52.      * 释放连接
  53.      */
  54.  //@After(value = "pc()")
  55.  public void release(){
  56.  try {
  57.  System.out.println("最终通知");
  58.             connectionUtils.getThreadConnection().close();//把连接还回连接池中
  59.             connectionUtils.removeConnection();
  60.  }catch (Exception e){
  61.             e.printStackTrace();
  62.  }
  63.  }
  65.  @Around(value="pc()")
  66.  public Object around(ProceedingJoinPoint joinPoint){
  67.  Object returnValue = null;
  68.  try {
  69.  this.beginTransaction(); // 开启事务
  70.             returnValue = joinPoint.proceed(joinPoint.getArgs());
  71.  this.commit(); // 提交事务
  72.  } catch (Throwable throwable) {
  73.             throwable.printStackTrace();
  74.  this.rollback(); // 回滚事务
  75.  }
  76.  finally {
  77.  this.release(); // 释放资源
  78.  }
  79.  return returnValue;
  80.  }
  81. }

Spring中的JdbcTemplate

1\dbcTemplate概述

它是spring框架中提供的一个对象，是对原始Jdbc API对象的简单封装。spring框架为我们提供了很多的操作模板类。

操作关系型数据的：

JdbcTemplate （操作JDBC，操作数据库）

HibernateTemplate （操作hibernate，操作数据库）

操作nosql数据库的： RedisTemplate（操作Redis，非关系型数据库）

操作消息队列（MQ）的： JmsTemplate （操作ActiveMQ，消息队列）

* 短信平台

* 邮件平台

操作索引库的：ElasticSearchTemplate（操作ElasticSearch，全文检索）

我们今天的主角在spring-jdbc-5.0.2.RELEASE.jar中，我们在导包的时候，除了要导入这个jar包外，还需要导入一个spring-tx-5.0.2.RELEASE.jar（它是和事务相关的）。

坐标xml

  1. <dependencies>
  2.  <dependency>
  3.  <groupId>org.springframework</groupId>
  4.  <artifactId>spring-context</artifactId>
  5.  <version>5.0.2.RELEASE</version>
  6.  </dependency>
  8.  <dependency>
  9.  <groupId>org.springframework</groupId>
  10.  <artifactId>spring-jdbc</artifactId>
  11.  <version>5.0.2.RELEASE</version>
  12.  </dependency>
  14.  <dependency>
  15.  <groupId>org.springframework</groupId>
  16.  <artifactId>spring-tx</artifactId>
  17.  <version>5.0.2.RELEASE</version>
  18.  </dependency>
  20.  <dependency>
  21.  <groupId>mysql</groupId>
  22.  <artifactId>mysql-connector-java</artifactId>
  23.  <version>5.1.6</version>
  24.  </dependency>
  25.  </dependencies>

创建类Account.java

  1. /**
  2. * 账户的实体类
  3. */
  4. public class Account implements Serializable {
  6.  private Integer id;
  7.  private String name;
  8.  private Float money;
  9. }

创建类JdbcTemplateDemo1.java

使用spring提供的数据源

  1. /**
  2. * JdbcTemplate的最基本用法
  3. */
  4. public class JdbcTemplateDemo1 {
  6.  public static void main(String[] args) {
  7.  //准备数据源：spring的内置数据源
  8.  DriverManagerDataSource ds = new DriverManagerDataSource();
  9.         ds.setDriverClassName("com.mysql.jdbc.Driver");
  10.         ds.setUrl("jdbc:mysql://localhost:3306/itcastspring");
  11.         ds.setUsername("root");
  12.         ds.setPassword("root");
  14.  //1.创建JdbcTemplate对象
  15.  JdbcTemplate jt = new JdbcTemplate();
  16.  //给jt设置数据源
  17.         jt.setDataSource(ds);
  18.  //2.执行操作
  19.         jt.execute("insert into account(name,money)values('ccc',1000)");
  20.  }
  21. }

2\使用spring容器创建数据源和JdbcTemplate

配置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.  <!--配置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://localhost:3306/itcastspring"></property>
  16.  <property name="username" value="root"></property>
  17.  <property name="password" value="root"></property>
  18.  </bean>
  19. </beans>

创建JdbcTemplateDemo2.java

  1. /**
  2. * JdbcTemplate的最基本用法
  3. */
  4. public class JdbcTemplateDemo2 {
  6.  public static void main(String[] args) {
  7.  //1.获取容器
  8.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  9.  //2.获取对象
  10.  JdbcTemplate jt = ac.getBean("jdbcTemplate",JdbcTemplate.class);
  11.  //3.执行操作
  12.         jt.execute("insert into account(name,money)values('eee',2222)");
  15.  /*   //准备数据源：spring的内置数据源
  16.         DriverManagerDataSource ds = new DriverManagerDataSource();
  17.         ds.setDriverClassName("com.mysql.jdbc.Driver");
  18.         ds.setUrl("jdbc:mysql://localhost:3306/eesy");
  19.         ds.setUsername("root");
  20.         ds.setPassword("1234");
  22.         //1.创建JdbcTemplate对象
  23.         JdbcTemplate jt = new JdbcTemplate();
  24.         //给jt设置数据源
  25.         jt.setDataSource(ds);
  26.         //2.执行操作
  27.         jt.execute("insert into account(name,money)values('ccc',1000)");*/
  28.  }
  29. }

3\使用JdbcTemplate操作数据库的CRUD

创建测试类JdbcTemplateDemo3.java

  1. /**
  2. * JdbcTemplate的CRUD操作
  3. */
  4. public class JdbcTemplateDemo3 {
  6.  public static void main(String[] args) {
  7.  //1.获取容器
  8.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  9.  //2.获取对象
  10.  JdbcTemplate jt = ac.getBean("jdbcTemplate",JdbcTemplate.class);
  11.  //3.执行操作
  12.  //保存
  13. //        jt.update("insert into account(name,money)values(?,?)","eee",3333f);
  14.  //更新
  15. //        jt.update("update account set name=?,money=? where id=?","test",4567,7);
  16.  //删除
  17. //        jt.update("delete from account where id=?",3);
  18.  //查询所有
  19. //        List<Account> accounts = jt.query("select * from account where money > ?",new AccountRowMapper(),1000f);
  20. //        List<Account> accounts = jt.query("select * from account where money > ?",new BeanPropertyRowMapper<Account>(Account.class),1000f);
  21. //        for(Account account : accounts){
  22. //            System.out.println(account);
  23. //        }
  24.  //查询一个
  25. //        List<Account> accounts = jt.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),1);
  26. //        System.out.println(accounts.isEmpty()?"没有内容":accounts.get(0));
  27. //        Account account = jt.queryForObject("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class),1);
  28. //        System.out.println(account);
  29.  //查询返回一行一列（使用聚合函数）
  30. //        Long count = jt.queryForObject("select count(*) from account where money > ?",Long.class,1000f);
  31. //        System.out.println(count);
  34.  }
  35. }
  37. /**
  38. * 定义Account的封装策略（解决实体的属性和数据库的字段名称不一致）
  39. */
  40. class AccountRowMapper implements RowMapper<Account> {
  41.  /**
  42.      * 把结果集中的数据封装到Account中，然后由spring把每个Account加到集合中
  43.      * @param rs
  44.      * @param rowNum
  45.      * @return
  46.      * @throws SQLException
  47.      */
  48.  public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
  49.  Account account = new Account();
  50.         account.setId(rs.getInt("id"));
  51.         account.setName(rs.getString("name"));
  52.         account.setMoney(rs.getFloat("money"));
  53.  return account;
  54.  }
  55. }

4\ JdbcTemplate操作Dao

创建AccountDao接口

  1. /**
  2. * 账户的持久层接口
  3. */
  4. public interface AccountDao {
  6.  /**
  7.      * 根据Id查询账户
  8.      * @param accountId
  9.      * @return
  10.      */
  11.  Account findAccountById(Integer accountId);
  13.  /**
  14.      * 根据名称查询账户
  15.      * @param accountName
  16.      * @return
  17.      */
  18.  Account findAccountByName(String accountName);
  20.  /**
  21.      * 更新账户
  22.      * @param account
  23.      */
  24.  void updateAccount(Account account);
  25. }

创建接口的实现类AccountDaoImpl.java

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. public class AccountDaoImpl implements AccountDao {
  6.  JdbcTemplate jdbcTemplate;
  8.  public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  9.  this.jdbcTemplate = jdbcTemplate;
  10.  }
  12.  public Account findAccountById(Integer accountId) {
  13.  List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
  14.  return accounts.isEmpty()?null:accounts.get(0);
  15.  }
  17.  public Account findAccountByName(String accountName) {
  18.  List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
  19.  if(accounts.isEmpty()){
  20.  return null;
  21.  }
  22.  if(accounts.size()>1){
  23.  throw new RuntimeException("结果集不唯一");
  24.  }
  25.  return accounts.get(0);
  26.  }
  28.  public void updateAccount(Account account) {
  29.         jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
  30.  }
  31. }

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.  <!-- 配置账户的持久层-->
  8.  <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl">
  9.  <property name="jdbcTemplate" ref="jdbcTemplate"></property>
  10.  </bean>
  12.  <!--配置JdbcTemplate-->
  13.  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  14.  <property name="dataSource" ref="dataSource"></property>
  15.  </bean>
  17.  <!-- 配置数据源-->
  18.  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  19.  <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  20.  <property name="url" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  21.  <property name="username" value="root"></property>
  22.  <property name="password" value="root"></property>
  23.  </bean>
  24. </beans>

test

  1. /**
  2. * JdbcTemplate的最基本用法
  3. */
  4. public class JdbcTemplateDemo4 {
  6.  public static void main(String[] args) {
  7.  //1.获取容器
  8.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  9.  //2.获取对象
  10.  AccountDao accountDao = ac.getBean("accountDao",AccountDao.class);
  12.  Account account = accountDao.findAccountById(1);
  13.  System.out.println(account);
  15.         account.setMoney(30000f);
  16.         accountDao.updateAccount(account);
  17.  }
  18. }

5\ Spring提供JdbcDaoSupport的使用

使用AccountDaoImpl继承JdbcDaoSupport，实现AccountDao

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
  7.  public Account findAccountById(Integer accountId) {
  8.  List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
  9.  return accounts.isEmpty()?null:accounts.get(0);
  10.  }
  12.  public Account findAccountByName(String accountName) {
  13.  List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
  14.  if(accounts.isEmpty()){
  15.  return null;
  16.  }
  17.  if(accounts.size()>1){
  18.  throw new RuntimeException("结果集不唯一");
  19.  }
  20.  return accounts.get(0);
  21.  }
  23.  public void updateAccount(Account account) {
  24.  super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
  25.  }
  26. }

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.  <!-- 配置账户的持久层-->
  8.  <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl">
  9.  <!--<property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
  10.  <property name="dataSource" ref="dataSource"></property>
  11.  </bean>
  13.  <!--配置JdbcTemplate
  14.         <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  15.             <property name="dataSource" ref="dataSource"></property>
  16.         </bean>
  17.         -->
  19.  <!-- 配置数据源-->
  20.  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  21.  <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  22.  <property name="url" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  23.  <property name="username" value="root"></property>
  24.  <property name="password" value="root"></property>
  25.  </bean>
  26. </beans>

test

  1. /**
  2. * JdbcTemplate的最基本用法
  3. */
  4. public class JdbcTemplateDemo5 {
  6.  public static void main(String[] args) {
  7.  //1.获取容器
  8.  ApplicationContext ac = new
  9. ClassPathXmlApplicationContext("applicationContext.xml");
  10.  //2.获取对象
  11.  AccountDao accountDao = ac.getBean("accountDao",AccountDao.class);
  13.  Account account = accountDao.findAccountById(1);
  14.  System.out.println(account);
  16.         account.setMoney(30000f);
  17.         accountDao.updateAccount(account);
  18.  }
  19. }

6\ 使用JdbcDaoSupport的注解开发

创建AccountDao接口

  1. /**
  2. * 账户的持久层接口
  3. */
  4. public interface AccountDao {
  6.  /**
  7.      * 根据Id查询账户
  8.      * @param accountId
  9.      * @return
  10.      */
  11.  Account findAccountById(Integer accountId);
  13.  /**
  14.      * 根据名称查询账户
  15.      * @param accountName
  16.      * @return
  17.      */
  18.  Account findAccountByName(String accountName);
  20.  /**
  21.      * 更新账户
  22.      * @param account
  23.      */
  24.  void updateAccount(Account account);
  25. }

创建AccountDaoImpl2实现AccountDao

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. @Repository("accountDao")
  5. public class AccountDaoImpl2 extends JdbcDaoSupport implements AccountDao {
  7.  @Autowired // 放置到属性上，也可以放置到set方法上（将spring容器中创建的对象，通过set方法的形参传递给该方法）
  8.  public void setDi(DataSource dataSource){
  9.  super.setDataSource(dataSource);
  10.  }
  14.  public Account findAccountById(Integer accountId) {
  15.  List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
  16.  return accounts.isEmpty()?null:accounts.get(0);
  17.  }
  19.  public Account findAccountByName(String accountName) {
  20.  List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
  21.  if(accounts.isEmpty()){
  22.  return null;
  23.  }
  24.  if(accounts.size()>1){
  25.  throw new RuntimeException("结果集不唯一");
  26.  }
  27.  return accounts.get(0);
  28.  }
  30.  public void updateAccount(Account account) {
  31.         jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
  32.  }
  33. }

applicationContext-anno.xml

重新创建applicationContext-anno.xml演示，表示使用注解

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:context="http://www.springframework.org/schema/context"
  4.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  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/context
  8.                  http://www.springframework.org/schema/context/spring-context.xsd">
  11.  <context:component-scan base-package="com.it"></context:component-scan>
  14.  <!-- 配置数据源-->
  15.  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  16.  <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  17.  <property name="url" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  18.  <property name="username" value="root"></property>
  19.  <property name="password" value="root"></property>
  20.  </bean>
  21. </beans>

test

  1. /**
  2. * JdbcTemplate的最基本用法，使用注解
  3. */
  4. public class JdbcTemplateDemo5 {
  6.  public static void main(String[] args) {
  7.  //1.获取容器
  8.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext-anno.xml");
  9.  //2.获取对象
  10.  AccountDao accountDao = ac.getBean("accountDao",AccountDao.class);
  12.  Account account = accountDao.findAccountById(1);
  13.  System.out.println(account);
  15.         account.setMoney(30000f);
  16.         accountDao.updateAccount(account);
  17.  }
  18. }

Spring中的事务控制

1.1 Spring事务控制我们要明确的

第一：JavaEE体系进行分层开发，事务处理位于业务层，Spring提供了分层设计业务层的事务处理解决方案。

第二：spring框架为我们提供了一组事务控制的接口 。具体在后面的第二小节介绍。这组接口是在spring-tx-5.0.2.RELEASE.jar中。

第三：spring的事务控制都是基于AOP的，它既可以使用编程的方式实现，也可以使用配置的方式（声明式）实现。我们学习的重点是使用配置（声明式事务处理）的方式实现。

1.2 Spring中事务控制的API介绍

1.2.1 PlatformTransactionManager

此接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法，如下图：

img

我们在开发中都是使用它的实现类：

真正管理事务的对象

org.springframework.jdbc.datasource.DataSourceTransactionManager 使用Spring JDBC或myBatis 进行持久化数据时使用

org.springframework.orm.hibernate5.HibernateTransactionManager 使用Hibernate版本进行持久化数据时使用

JpaTransactionManager，使用Jpa操作持久化数据时使用

1.2.2 TransactionDefinition

它是事务的定义信息对象，里面有如下方法：

img

1：事务的隔离级别

2img

2：事务的传播行为

REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）

SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）

MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常

REQUERS_NEW:新建事务，如果当前在事务中，把当前事务挂起，从新开启一个新的事务。

NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起

NEVER:以非事务方式运行，如果当前存在事务，抛出异常

NESTED:如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作。

3：事务超时时间

默认值是-1，没有超时限制。如果有，以秒为单位、会进行设置，在事务提交/回滚后多长时间，事务失效。

4：是否是只读事务

建议查询时设置为只读。

增删改设置可写。

1.2.3TransactionStatus（了解）

此接口提供的是事务具体的运行状态，方法介绍如下图：

img

Spring的编程式事务处理

坐标xml

  1. <dependencies>
  2.  <dependency>
  3.  <groupId>org.springframework</groupId>
  4.  <artifactId>spring-context</artifactId>
  5.  <version>5.0.2.RELEASE</version>
  6.  </dependency>
  8.  <dependency>
  9.  <groupId>org.springframework</groupId>
  10.  <artifactId>spring-jdbc</artifactId>
  11.  <version>5.0.2.RELEASE</version>
  12.  </dependency>
  14.  <dependency>
  15.  <groupId>org.springframework</groupId>
  16.  <artifactId>spring-tx</artifactId>
  17.  <version>5.0.2.RELEASE</version>
  18.  </dependency>
  20.  <dependency>
  21.  <groupId>org.springframework</groupId>
  22.  <artifactId>spring-test</artifactId>
  23.  <version>5.0.2.RELEASE</version>
  24.  </dependency>
  26.  <dependency>
  27.  <groupId>mysql</groupId>
  28.  <artifactId>mysql-connector-java</artifactId>
  29.  <version>5.1.6</version>
  30.  </dependency>
  32.  <dependency>
  33.  <groupId>org.aspectj</groupId>
  34.  <artifactId>aspectjweaver</artifactId>
  35.  <version>1.8.7</version>
  36.  </dependency>
  38.  <dependency>
  39.  <groupId>junit</groupId>
  40.  <artifactId>junit</artifactId>
  41.  <version>4.12</version>
  42.  </dependency>
  43.  </dependencies>

AccountDao.java

  1. /**
  2. * 账户的持久层接口
  3. */
  4. public interface AccountDao {
  6.  /**
  7.      * 根据Id查询账户
  8.      * @param accountId
  9.      * @return
  10.      */
  11.  Account findAccountById(Integer accountId);
  13.  /**
  14.      * 根据名称查询账户
  15.      * @param accountName
  16.      * @return
  17.      */
  18.  Account findAccountByName(String accountName);
  20.  /**
  21.      * 更新账户
  22.      * @param account
  23.      */
  24.  void updateAccount(Account account);
  25. }

AccountDaoImpl.java

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
  7.  public Account findAccountById(Integer accountId) {
  8.  List<Account> accounts = this.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
  9.  return accounts.isEmpty()?null:accounts.get(0);
  10.  }
  12.  public Account findAccountByName(String accountName) {
  13.  List<Account> accounts = this.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
  14.  if(accounts.isEmpty()){
  15.  return null;
  16.  }
  17.  if(accounts.size()>1){
  18.  throw new RuntimeException("结果集不唯一");
  19.  }
  20.  return accounts.get(0);
  21.  }
  23.  public void updateAccount(Account account) {
  24.  this.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
  25.  }
  26. }

AccountService.java

  1. /**
  2. * 账户的业务层接口
  3. */
  4. public interface AccountService {
  5.  /**
  6.      * 根据id查询账户信息
  7.      * @param accountId
  8.      * @return
  9.      */
  10.  Account findAccountById(Integer accountId);
  12.  /**
  13.      * 转账
  14.      * @param sourceName    转成账户名称
  15.      * @param targetName    转入账户名称
  16.      * @param money         转账金额
  17.      */
  18.  void transfer(String sourceName, String targetName, Float money);
  19. }

AccountServiceImpl.java

  1. /**
  2. * 账户的业务层实现类
  3. *
  4. * 事务控制应该都是在业务层
  5. */
  6. public class AccountServiceImpl implements AccountService {
  8.  private AccountDao accountDao;
  10.  public void setAccountDao(AccountDao accountDao) {
  11.  this.accountDao = accountDao;
  12.  }
  14.  public Account findAccountById(Integer accountId) {
  15.  return accountDao.findAccountById(accountId);
  17.  }
  19.  public void transfer(String sourceName, String targetName, Float money) {
  20.  System.out.println("transfer....");
  21.  //2.1根据名称查询转出账户
  22.  Account source = accountDao.findAccountByName(sourceName);
  23.  //2.2根据名称查询转入账户
  24.  Account target = accountDao.findAccountByName(targetName);
  25.  //2.3转出账户减钱
  26.         source.setMoney(source.getMoney()-money);
  27.  //2.4转入账户加钱
  28.         target.setMoney(target.getMoney()+money);
  29.  //2.5更新转出账户
  30.         accountDao.updateAccount(source);
  32.  int i=1/0;
  34.  //2.6更新转入账户
  35.         accountDao.updateAccount(target);
  36.  }
  37. }

applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:context="http://www.springframework.org/schema/context"
  4.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  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/context
  8.                             http://www.springframework.org/schema/context/spring-context.xsd">
  9.  <!-- 配置账户的业务层-->
  10.  <bean id="accountService" class="com.it.service.impl.AccountServiceImpl">
  11.  <property name="accountDao" ref="accountDao"></property>
  12.  </bean>
  14.  <!-- 配置账户的持久层-->
  15.  <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl">
  16.  <property name="dataSource" ref="dataSource"></property>
  17.  </bean>
  19.  <!-- 配置数据源-->
  20.  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  21.  <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  22.  <property name="url" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  23.  <property name="username" value="root"></property>
  24.  <property name="password" value="root"></property>
  25.  </bean>
  26. </beans>

test

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(locations = "classpath:applicationContext.xml")
  3. public class AccountServiceTest {
  5.  @Autowired
  6.  private AccountService as;
  8.  @Test
  9.  public void testTransfer() {
  10.         as.transfer("aaa", "bbb", 100f);
  11.  }
  13. }

编程式事务控制

Jdbc的操作，需要配置Jdbc的事务管理器

配置applicationContext.xml

  1. <!-- 一：配置事务管理器=============== -->
  2. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  3.  <property name="dataSource" ref="dataSource"/>
  4. </bean>

配置事务管理模板

配置applicationContext.xml

  1. <!-- 二：配置事务管理的模板 -->
  2. <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
  3.  <property name="transactionManager" ref="transactionManager"/>
  4. </bean>

在业务层注入事务管理模板

配置applicationContext-tx1.xml

  1. <!-- 配置账户的业务层-->
  2. <bean id="accountService" class="com.it.service.impl.AccountServiceImpl">
  3.  <property name="accountDao" ref="accountDao"></property>
  4.  <property name="transactionTemplate" ref="transactionTemplate"/>
  5. </bean>

AccountServiceImpl.java

  1. public class AccountServiceImpl implements AccountService {
  3.  // 注入事务管理的模板
  4.  private TransactionTemplate transactionTemplate;
  6.  public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
  7.  this.transactionTemplate = transactionTemplate;
  8.  }
  10.  private AccountDao accountDao;
  12.  public void setAccountDao(AccountDao accountDao) {
  13.  this.accountDao = accountDao;
  14.  }
  18.  public Account findAccountById(Integer accountId) {
  19.  return accountDao.findAccountById(accountId);
  21.  }
  23.  public void transfer(final String sourceName, final String targetName, final Float money) {
  24.  System.out.println("transfer....");
  25.         transactionTemplate.execute(new TransactionCallbackWithoutResult() {
  26.  @Override
  27.  protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
  28.  System.out.println(transactionStatus.isNewTransaction() + "     "+transactionStatus.isCompleted());
  29.  //2.1根据名称查询转出账户
  30.  Account source = accountDao.findAccountByName(sourceName);
  31.  //2.2根据名称查询转入账户
  32.  Account target = accountDao.findAccountByName(targetName);
  33.  //2.3转出账户减钱
  34.                 source.setMoney(source.getMoney()-money);
  35.  //2.4转入账户加钱
  36.                 target.setMoney(target.getMoney()+money);
  37.  //2.5更新转出账户
  38.                 accountDao.updateAccount(source);
  40. //                int i=1/0;
  42.  //2.6更新转入账户
  43.                 accountDao.updateAccount(target);
  44.  }
  45.  });
  47.  }
  48. }

Spring的声明式事务处理（**）

配置applicationContext.xml

同时去掉：TransactionTemplate的操作

1562085156877

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:context="http://www.springframework.org/schema/context"
  4.  xmlns:aop="http://www.springframework.org/schema/aop"
  5.  xmlns:tx="http://www.springframework.org/schema/tx"
  6.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  7.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  8.                             http://www.springframework.org/schema/beans/spring-beans.xsd
  9.                             http://www.springframework.org/schema/context
  10.                             http://www.springframework.org/schema/context/spring-context.xsd
  11.                             http://www.springframework.org/schema/aop
  12.                             http://www.springframework.org/schema/aop/spring-aop.xsd
  13.                             http://www.springframework.org/schema/tx
  14.                             http://www.springframework.org/schema/tx/spring-tx.xsd">
  15.  <!-- 配置账户的业务层-->
  16.  <bean id="accountService" class="com.it.service.impl.AccountServiceImpl">
  17.  <property name="accountDao" ref="accountDao"></property>
  18.  </bean>
  20.  <!-- 配置账户的持久层-->
  21.  <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl">
  22.  <property name="dataSource" ref="dataSource"></property>
  23.  </bean>
  25.  <!-- 配置数据源-->
  26.  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  27.  <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  28.  <property name="url" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  29.  <property name="username" value="root"></property>
  30.  <property name="password" value="root"></property>
  31.  </bean>
  33.  <!-- spring中基于XML的声明式事务控制配置步骤
  34.         1、配置事务管理器
  35.         2、配置事务的通知
  36.                 此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的
  37.                 使用tx:advice标签配置事务通知
  38.                     属性：
  39.                         id：给事务通知起一个唯一标识
  40.                         transaction-manager：给事务通知提供一个事务管理器引用
  41.         3、配置AOP中的通用切入点表达式
  42.         4、建立事务通知和切入点表达式的对应关系
  43.         5、配置事务的属性
  44.                是在事务的通知tx:advice标签的内部
  46.      -->
  47.  <!-- 一：配置事务管理器 -->
  48.  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  49.  <property name="dataSource" ref="dataSource"></property>
  50.  </bean>
  52.  <!-- 二：配置事务的通知-->
  53.  <tx:advice id="txAdvice" transaction-manager="transactionManager">
  54.  <!-- 配置事务的属性
  55.                 isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
  56.                 propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。
  57.                 read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
  58.                 timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。
  59.                 rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
  60.                 no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
  61.       测试：no-rollback-for="java.lang.ArithmeticException"，遇到算数异常不回滚
  63.         -->
  64.  <tx:attributes>
  65.  <tx:method name="*" propagation="REQUIRED" read-only="false"/>
  66.  <tx:method name="find*" propagation="SUPPORTS" read-only="true"></tx:method>
  67.  </tx:attributes>
  68.  </tx:advice>
  70.  <!-- 三：配置aop-->
  71.  <aop:config>
  72.  <!-- 配置切入点表达式-->
  73.  <aop:pointcut id="pc" expression="execution(* com.it.service..*.*(..))"></aop:pointcut>
  74.  <!--建立切入点表达式和事务通知的对应关系 -->
  75.  <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"></aop:advisor>
  76.  </aop:config>
  79. </beans>

注解

配置AccountDaoImpl.java

  1. @Repository
  2. public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
  4.  @Autowired
  5.  public void setDi(DataSource dataSource){
  6.  super.setDataSource(dataSource);
  7.  }
  9. }

配置AccountServiceImpl.java

  1. @Service
  2. @Transactional(readOnly = true)
  3. public class AccountServiceImpl implements AccountService {
  5.  @Autowired
  6.  private AccountDao accountDao;
  9.  public Account findAccountById(Integer accountId) {
  10.  return accountDao.findAccountById(accountId);
  12.  }
  13.  @Transactional(readOnly = false,propagation = Propagation.REQUIRED)
  14.  public void transfer( String sourceName, String targetName, Float money) {
  15.  System.out.println("transfer....");
  17.  //2.1根据名称查询转出账户
  18.  Account source = accountDao.findAccountByName(sourceName);
  19.  //2.2根据名称查询转入账户
  20.  Account target = accountDao.findAccountByName(targetName);
  21.  //2.3转出账户减钱
  22.         source.setMoney(source.getMoney() - money);
  23.  //2.4转入账户加钱
  24.         target.setMoney(target.getMoney() + money);
  25.  //2.5更新转出账户
  26.         accountDao.updateAccount(source);
  28.  int i=1/0;
  30.  //2.6更新转入账户
  31.         accountDao.updateAccount(target);
  33.  }
  34. }

注意：方法级别的事务会覆盖类级别的事务

配置applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:context="http://www.springframework.org/schema/context"
  4.  xmlns:aop="http://www.springframework.org/schema/aop"
  5.  xmlns:tx="http://www.springframework.org/schema/tx"
  6.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  7.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  8.                             http://www.springframework.org/schema/beans/spring-beans.xsd
  9.                             http://www.springframework.org/schema/context
  10.                             http://www.springframework.org/schema/context/spring-context.xsd
  11.                             http://www.springframework.org/schema/aop
  12. http://www.springframework.org/schema/aop/spring-aop.xsd
  13.                             http://www.springframework.org/schema/tx
  14. http://www.springframework.org/schema/tx/spring-tx.xsd">
  16.  <context:component-scan base-package="com.it"></context:component-scan>
  18.  <!--配置JdbcTemplate-->
  19.  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  20.  <property name="dataSource" ref="dataSource"></property>
  21.  </bean>
  23.  <!-- 配置数据源-->
  24.  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  25.  <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  26.  <property name="url" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  27.  <property name="username" value="root"></property>
  28.  <property name="password" value="root"></property>
  29.  </bean>
  31.  <!-- spring中基于XML的声明式事务控制配置步骤
  32.         1、配置事务管理器
  33.         2、配置事务的通知，通过注解的方式
  34.      -->
  35.  <!-- 配置事务管理器 -->
  36.  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  37.  <property name="dataSource" ref="dataSource"></property>
  38.  </bean>
  40.  <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
  42. </beans>

Spring整体的总结：

总结：

1：IOC DI（xml和注解）

2：AOP（5种通知）（xml和注解）

3：声明式事务处理（xml和注解）

  • * DBUtils（第三方提供的）
  • * JDBCTemplate（是spring提供的）

4：spring3的新特性（纯注解开发）

  • @Configuration
  • @ConnectionScan
  • @Import
  • @Bean

自己创建的对象：使用注解

第三方创建的对象（数据源…）：使用配置文件

posted @ 2019-07-03 00:40  不穿格子衫的徍爺  阅读(112)  评论(0)  编辑  收藏  举报