今日内容
  • Spring中的JdbcTemplate
  • 作业：Spring基于AOP的事务控制
  • Spring中的事务控制
    • 基于XML的
    • 基于注解的
一、JdbcTemplate
1、JdbcTemplate的概述和入门
持久层总图
  • JdbcTemplate的作用
    • 用于和数据库交互，实现对表的CRUD操作
  • 如何获取该对象
  • 对象中的常用方法
  1. package com.itheima.jdbcTemplate;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4. import org.springframework.jdbc.datasource.DriverManagerDataSource;
  6. import java.sql.DriverManager;
  8. /**
  9.  * JdbcTemplate的最基本用法
  10.  */
  11. public class JdbcTemplateDemo1 {
  12.     public static void main(String[] args) {
  13.         //准备数据源：c3p0、dbcp都可，今天介绍Spring的内置数据源
  14.         DriverManagerDataSource ds = new DriverManagerDataSource();
  15.         ds.setDriverClassName("com.mysql.jdbc.Driver");
  16.         ds.setUrl("jdbc:mysql://localhost:3306/eesy");
  17.         ds.setUsername("root");
  18.         ds.setPassword("root");
  19.         //1.创建JdbcTemplate对象
  20.         JdbcTemplate jt = new JdbcTemplate();//可以加带数据源的构造方法
  21.         //给jt设置数据源
  22.         jt.setDataSource(ds);
  23.         //2.执行操作
  24.         jt.execute("insert into account(name,money) values('ccc',1000)");
  25.     }
  26. }
2、JdbcTemplate在spring的ioc中使用
配置在类中修改比较麻烦，需要配置到配置文件中
  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">
  6.     <!--配置JdbcTemplate-->
  7.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  8.         <property name="dataSource" ref="dataSource"></property>
  9.     </bean>
  10.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  11.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  12.         <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
  13.         <property name="username" value="root"></property>
  14.         <property name="password" value="root"></property>
  15.     </bean>
  16. </beans>
  1. package com.itheima.jdbcTemplate;
  2. import org.springframework.context.ApplicationContext;
  3. import org.springframework.context.support.ClassPathXmlApplicationContext;
  4. import org.springframework.jdbc.core.JdbcTemplate;
  5. import org.springframework.jdbc.datasource.DriverManagerDataSource;
  6. import java.sql.DriverManager;
  7. /**
  8.  * JdbcTemplate的最基本用法
  9.  */
  10. public class JdbcTemplateDemo1 {
  11.     public static void main(String[] args) {
  12.         //1.获取容器
  13.         ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  14.         //2.获取对象
  15.         JdbcTemplate jt = ac.getBean("jdbcTemplate",JdbcTemplate.class);
  16.         //2.执行操作
  17.         jt.execute("insert into account(name,money) values('ccc',1000)");
  18.     }
  19. }
3、JdbcTemplate的CRUD操作
JdbcTemplate和queryRunner的区别
  1. package com.itheima.jdbcTemplate;
  3. import com.itheima.domain.Account;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  8. import org.springframework.jdbc.core.RowMapper;
  10. import java.sql.ResultSet;
  11. import java.sql.SQLException;
  12. import java.util.List;
  14. /**
  15.  * JdbcTemplate的CRUD操作
  16.  */
  17. public class JdbcTemplateDemo3 {
  18.     public static void main(String[] args) {
  19.         //1.获取容器
  20.         ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  21.         //2.获取对象
  22.         JdbcTemplate jt = ac.getBean("jdbcTemplate",JdbcTemplate.class);
  23.         //2.可带参数的执行操作（单表）
  24.         //保存
  25.         //jt.update("insert into account(name,money) values (?,?)","ssss",333f);
  26.         //更新
  27.         //jt.update("update account set name=?,money=? where id=?","ssss",333f,5);
  28.         //删除
  29.         //jt.update("delete from account where id=?",1);
  30.         //查询所有
  31.         //queryRunner提供的
  32.         //List<Account> accounts = jt.query("select * from account where money > ?",new AccountRowMapper(),100f);
  33.         //Spring提供的
  34.         /*List<Account> accounts1 = jt.query("select * from account where money > ?",new BeanPropertyRowMapper<Account>(Account.class),100f);
  35.         for (Account account : accounts1) {
  36.             System.out.println(account);
  37.         }*/
  38.         //查询一个
  39.         /*List<Account> account = jt.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),1);
  40.         System.out.println(account.isEmpty()?"没有内容":account.get(0));*/
  41.         //使用聚合函数查询，返回一行一列，但不加groupby子句
  42.         //int count = jt.queryForObject("select count(*) from account where money >= ?",Integer.class,100f);
  43.         Long count = jt.queryForObject("select count(*) from account where money >= ?",Long.class,100f);
  44.         //大数据，常用long接收
  45.         System.out.println(count);
  46.     }
  47. }
  49. /**
  50.  * 定义Account的封装策略
  51.  */
  52. class AccountRowMapper implements RowMapper<Account> {
  53.     /**
  54.      * 把结果集中的数据封装到Account中，然后由Spring把每个Account加入到集合中
  55.      * @param resultSet
  56.      * @param i
  57.      * @return
  58.      * @throws SQLException
  59.      */
  60.     @Override
  61.     public Account mapRow(ResultSet resultSet, int i) throws SQLException {
  62.         Account account = new Account();
  63.         account.setId(resultSet.getInt("id"));
  64.         account.setName(resultSet.getString("name"));
  65.         account.setMoney(resultSet.getFloat("money"));
  66.         return account;
  67.     }
  68. }
4、JdbcTemplate在Dao中的使用
  1.    <!--配置账户的持久层-->
  2.     <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  3.         <property name="jdbcTemplate" ref="jdbcTemplate"></property>
  4.     </bean>
  5.     <!--配置JdbcTemplate-->
  6.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  7.         <property name="dataSource" ref="dataSource"></property>
  8.     </bean>
  1. package com.itheima.dao.impl;
  3. import com.itheima.dao.IAccountDao;
  4. import com.itheima.domain.Account;
  5. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  6. import org.springframework.jdbc.core.JdbcTemplate;
  8. import java.util.List;
  10. /**
  11.  * 账户的持久层实现类
  12.  */
  13. public class AccountDaoImpl implements IAccountDao {
  14.     private JdbcTemplate jdbcTemplate;
  16.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  17.         this.jdbcTemplate = jdbcTemplate;
  18.     }
  20.     @Override
  21.     public Account findAccounById(Integer accountId) {
  22.         List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
  23.         return accounts.isEmpty()?null:accounts.get(0);
  24.     }
  26.     @Override
  27.     public Account findAccountByName(String accounName) {
  28.         List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accounName);
  29.         if (accounts.isEmpty()){
  30.             return null;
  31.         }
  32.         if (accounts.size()>1){
  33.             throw new RuntimeException("结果集不一致");
  34.         }
  35.         return accounts.get(0);
  36.     }
  38.     @Override
  39.     public void updateAccount(Account account) {
  40.         jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
  41.     }
  42. }
  1. package com.itheima.jdbcTemplate;
  3. import com.itheima.dao.IAccountDao;
  4. import com.itheima.domain.Account;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. /**
  10.  * JdbcTemplate的最基本用法
  11.  */
  12. public class JdbcTemplateDemo4 {
  13.     public static void main(String[] args) {
  14.         //1.获取容器
  15.         ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
  16.         //2.获取对象
  17.         IAccountDao accountDao =ac.getBean("accountDao",IAccountDao.class);
  18.         Account account = accountDao.findAccounById(5);
  19.         System.out.println(account);
  20.         account.setMoney(10000f);
  21.         accountDao.updateAccount(account);
  22.     }
  23. }
5、JdbcDaoSupport的使用以及Dao的两种编写方式
不同dao的重复代码
使用注解配置和使用JdbcDaoSupport冲突
  1. /**
  2.  * 账户的持久层实现类
  3.  */
  4. @Repository
  5. public class AccountDaoImpl2 implements IAccountDao {
  6.     @Autowired
  7.     private JdbcTemplate jdbcTemplate;
  9.     /*public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  10.         this.jdbcTemplate = jdbcTemplate;
  11.     }*/
  13.     @Override
  14.     public Account findAccounById(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.     }
  1. package com.itheima.dao.impl;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  5. import javax.sql.DataSource;
  7. /**
  8.  * 此类用于抽取dao中的重复代码
  9.  */
  10. public class JdbcDaoSupport {
  11.     private JdbcTemplate jdbcTemplate;
  12.     public JdbcTemplate getJdbcTemplate() {
  13.         return jdbcTemplate;
  14.     }
  15.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  16.         this.jdbcTemplate = jdbcTemplate;
  17.     }
  19.     public DataSource getDateSource() {
  20.         return dateSource;
  21.     }
  23.     public void setDateSource(DataSource dateSource) {
  24.         //this.dateSource = dateSource;
  25.         if(jdbcTemplate == null){
  26.             jdbcTemplate = createJdbcTemplate(dateSource);
  27.         }
  28.     }
  30.     private JdbcTemplate createJdbcTemplate(DataSource dateSource) {
  31.         return new JdbcTemplate(dateSource);//支持构造函数和set方法
  32.     }
  33.     private DataSource dateSource;
  35. }
  1. /**
  2.  * 账户的持久层实现类
  3.  */
  4. public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
  5.     /*private JdbcTemplate jdbcTemplate;
  7.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  8.         this.jdbcTemplate = jdbcTemplate;
  9.     }*/
  11.     @Override
  12.     public Account findAccounById(Integer accountId) {
  13.         List<Account> accounts = getJdbcTemplate() .query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
  14.         return accounts.isEmpty()?null:accounts.get(0);
  15.     }
  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">
  6.     <!--配置账户的持久层-->
  7.     <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  8.         <property name="dateSource" ref="dataSource"></property>
  9.     </bean>
  10.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  11.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  12.         <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
  13.         <property name="username" value="root"></property>
  14.         <property name="password" value="root"></property>
  15.     </bean>
  16. </beans>
二、作业：AOP实现事务控制
1、基于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">
  10.     <!-- 配置Service -->
  11.     <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
  12.         <!-- 注入dao对象 -->
  13.         <property name="accountDao" ref="accountDao"></property>
  15.     </bean>
  16.     <!--配置dao对象-->
  17.     <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  18.         <!--注入QueryRunner-->
  19.         <property name="runner" ref="runner"></property>
  20.         <!--注入ConnectionUtils-->
  21.         <property name="connectionUtils" ref="connectionUtils"></property>
  22.     </bean>
  23.     <!--配置QueryRunner对象-->
  24.     <!--不再提供Connection对象，没有数据源，不会从数据源中获取连接-->
  25.     <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>
  26.     <!--配置数据源-->
  27.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  28.         <!--连接数据库的必备信息-->
  29.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  30.         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy02"></property>
  31.         <property name="user" value="root"></property>
  32.         <property name="password" value="root"></property>
  33.     </bean>
  34.     <!--配置Connection的工具类-ConnectionUtils-->
  35.     <bean id="connectionUtils" class="com.itheima.utils.ConnectionUtils">
  36.         <!--注入数据源的配置-->
  37.         <property name="dataSource" ref="dataSource"></property>
  38.     </bean>
  39.     <!--配置事务管理器-->
  40.     <bean id="txManager" class="com.itheima.utils.TransactionManager">
  41.         <!--注入ConnectionUtils-->
  42.         <property name="connectionUtils" ref="connectionUtils"></property>
  43.     </bean>
  44.     <!--配置AOP-->
  45.     <aop:config>
  46.         <aop:aspect id="txAdvice" ref="txManager">
  47.             <!--配置通用的切入点表达式-->
  48.             <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"/>
  49.             <!--配置前置通知：开启事务-->
  50.             <aop:before method="beginTransaction" pointcut-ref="pt1"></aop:before>
  51.             <!--配置后置通知：提交事务-->
  52.             <aop:after-returning method="commit" pointcut-ref="pt1"></aop:after-returning>
  53.             <!--配置异常通知：回滚事务-->
  54.             <aop:after-throwing method="rollback" pointcut-ref="pt1"></aop:after-throwing>
  55.             <!--配置最终通知：释放连接-->
  56.             <aop:after method="release" pointcut-ref="pt1"></aop:after>
  57.         </aop:aspect>
  58.     </aop:config>
  59. </beans>
2、基于注解的AOP实现事务控制及问题分析1
  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.     <!--配置Spring创建容器时要扫描的包-->
  13.     <context:component-scan base-package="com.itheima"></context:component-scan>
  14.     <!-- 配置Service -->
  16.     <!--配置QueryRunner对象-->
  17.     <!--不再提供Connection对象，没有数据源，不会从数据源中获取连接-->
  18.     <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>
  19.     <!--配置数据源-->
  20.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  21.         <!--连接数据库的必备信息-->
  22.         <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  23.         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy02"></property>
  24.         <property name="user" value="root"></property>
  25.         <property name="password" value="root"></property>
  26.     </bean>
  27.     <!--开启Spring对注解aop的支持-->
  28.     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  29. </beans>
  1. package com.itheima.utils;
  3. import org.aspectj.lang.annotation.*;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Component;
  7. import java.sql.SQLException;
  9. /**
  10.  * 和事务管理相关的工具类，包含开启事务、提交事务、回滚事务和释放连接
  11.  */
  12. @Component("txManager")
  13. public class TransactionManager {
  14.     //获取当前线程上的Connection
  15.     @Autowired
  16.     private ConnectionUtils connectionUtils;
  17.     @Pointcut("execution(* com.itheima.*.*(..))")
  18.     private void pt1(){}
  19.     /**
  20.      * 开启事务
  21.      */
  22.     @Before("pt1")
  23.     public void beginTransaction(){
  24.         try {
  25.             connectionUtils.getThreadConnection().setAutoCommit(true);
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  30.     /**
  31.      * 提交事务
  32.      */
  33.     @AfterReturning("pt1")
  34.     public void commit(){
  35.         try {
  36.             connectionUtils.getThreadConnection().commit();
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41.     /**
  42.      * 回滚事务
  43.      */
  44.     @AfterThrowing("pt1")
  45.     public void rollback(){
  46.         try {
  47.             connectionUtils.getThreadConnection().rollback();
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52.     /**
  53.      * 释放连接
  54.      */
  55.     @After("pt1")
  56.     public void release(){
  57.         try {
  58.             connectionUtils.getThreadConnection().close();//并不是真正关闭连接，而是还回连接池中
  59.             connectionUtils.removeConnection();//进行线程的解绑
  60.         } catch (Exception e) {
  61.             e.printStackTrace();
  62.         }
  63.     }
  64. }
  1. package com.itheima.utils;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Component;
  6. import javax.sql.DataSource;
  7. import java.sql.Connection;
  8. import java.sql.SQLException;
  10. /**
  11.  *  连接的工具类，用于从数据源中获取一个连接，并且实现和线程的绑定
  12.  */
  13. @Component("connectionUtils")
  14. public class ConnectionUtils {
  15.     private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
  16.     @Autowired
  17.     private DataSource dataSource;
  18.     /**
  19.      * 获取当前线程上的连接
  20.      */
  21.     public Connection getThreadConnection(){
  22.         try {
  23.             //1.先从ThreadLocal上获取
  24.             Connection conn = tl.get();
  25.             //2.判断当前线程上是否有连接
  26.             if (conn == null){
  27.                 //3.从数据源中获取一个连接，并且和线程绑定，存入ThreadLocal中
  28.                 conn = dataSource.getConnection();
  29.                 tl.set(conn);
  30.             }
  31.             //4.返回当前线程上的连接
  32.             return conn;
  33.         } catch (Exception e) {
  34.             throw new RuntimeException(e);
  35.         }
  36.     }
  38.     /**
  39.      * 把连接和线程解绑
  40.      */
  41.     public void removeConnection(){
  42.         tl.remove();
  43.     }
  44. }
3、基于注解的AOP实现事务控制及问题分析2
  1. package com.itheima.service.impl;
  3. import com.itheima.dao.IAccountDao;
  4. import com.itheima.domain.Account;
  5. import com.itheima.service.IAccountService;
  6. import com.itheima.utils.TransactionManager;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Service;
  10. import java.util.List;
  12. /**
  13.  * 账户的业务层实现类
  14.  * 事务控制应当在业务层
  15.  */
  16. @Service("accountService")
  17. public class AccountServiceImpl implements IAccountService {
  18.     /**
  19.      * 每次获取连接，无法实现事务控制
  20.      */
  21.     @Autowired
  22.     private IAccountDao accountDao;
  23.     @Override
  24.     public List<Account> findAllAccount() {
  25.         return accountDao.findAllAccount();
  26.     }
  28.     @Override
  29.     public Account findAccountById(Integer accountId) {
  30.         //2.执行操作
  31.         return accountDao.findAccountById(accountId);
  33.     }
  35.     @Override
  36.     public void saveAccount(Account account) {
  37.         accountDao.saveAccount(account);
  38.     }
  40.     @Override
  41.     public void updateAccount(Account account) {
  42.         accountDao.updateAccount(account);
  43.     }
  45.     @Override
  46.     public void deleteAccount(Integer accountId) {
  47.         accountDao.deleteAccount(accountId);
  48.     }
  50.     @Override
  51.     public void transfer(String sourceName, String targetName, Float money) {
  52.         System.out.println("transfer开始执行");
  53.         //2.1根据名称查询转出账户
  54.         Account source = accountDao.findAccountByName(sourceName);
  55.         //2.2根据名称查询转入账户
  56.         Account target = accountDao.findAccountByName(targetName);
  57.         //2.3转出账户金额减少
  58.         source.setMoney(source.getMoney() - money);
  59.         //2.4.转入账户金额增加
  60.         target.setMoney(target.getMoney() + money);
  61.         //int i = 1 / 0;
  62.         //2.5.更新转出账户
  63.         accountDao.updateAccount(source);
  64.         //2.6.更新转入账户
  65.         accountDao.updateAccount(target);
  66.         //3.提交事务
  67.         //txManager.commit();
  68.     }
  69. }
  1. package com.itheima.utils;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.*;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Component;
  8. import java.sql.SQLException;
  10. /**
  11.  * 和事务管理相关的工具类，包含开启事务、提交事务、回滚事务和释放连接
  12.  */
  13. @Component("txManager")
  14. public class TransactionManager {
  15.     //获取当前线程上的Connection
  16.     @Autowired
  17.     private ConnectionUtils connectionUtils;
  18.     @Pointcut("execution(* com.itheima.*.*(..))")
  19.     private void pt1(){}
  20.     /**
  21.      * 开启事务
  22.      */
  23.     public void beginTransaction(){
  24.         try {
  25.             connectionUtils.getThreadConnection().setAutoCommit(true);
  26.         } catch (Exception e) {
  27.             e.printStackTrace();
  28.         }
  29.     }
  30.     /**
  31.      * 提交事务
  32.      */
  33.     @AfterReturning("pt1")
  34.     public void commit(){
  35.         try {
  36.             connectionUtils.getThreadConnection().commit();
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41.     /**
  42.      * 回滚事务
  43.      */
  44.     public void rollback(){
  45.         try {
  46.             connectionUtils.getThreadConnection().rollback();
  47.         } catch (Exception e) {
  48.             e.printStackTrace();
  49.         }
  50.     }
  51.     /**
  52.      * 释放连接
  53.      */
  54.     public void release(){
  55.         try {
  56.             connectionUtils.getThreadConnection().close();//并不是真正关闭连接，而是还回连接池中
  57.             connectionUtils.removeConnection();//进行线程的解绑
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         }
  61.     }
  62.     @Around("pt1")
  63.     public Object aroundAdvice(ProceedingJoinPoint pjp){
  64.         Object rtValue = null;
  65.         try {
  66.             //1.获取参数
  67.             Object[] args = pjp.getArgs();
  68.             //2.开启事务
  69.             this.beginTransaction();
  70.             //3.执行方法
  71.             rtValue = pjp.proceed(args);
  72.             //4.提交事务
  73.             this.commit();
  74.             //返回结果
  75.             return rtValue;
  76.         } catch (Throwable e) {
  77.             //5.回滚事务
  78.             this.rollback();
  79.             throw new RuntimeException(e);
  80.         } finally {
  81.             //6.释放资源
  82.             this.release();
  83.         }
  85.     }
  86. }
使用环绕通知可以解决回滚数据不改变@Around("pt1")
三、Spring中的事务控制
1、spring中事务控制的一组API
2、spring事务控制的代码准备
  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">
  6.     <!--配置业务层-->
  7.     <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
  8.         <property name="accountDao" ref="accountDao"></property>
  9.     </bean>
  10.     <!--配置账户的持久层-->
  11.     <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  12. <!--        <property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
  13.         <property name="dataSource" ref="dataSource"></property>
  14.     </bean>
  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/eesy"></property>
  18.         <property name="username" value="root"></property>
  19.         <property name="password" value="root"></property>
  20.     </bean>
  21. </beans>
  1. import java.util.List;
  2. /**
  3.  * 使用Junit单元测试：测试我们的配置
  4.  */
  5. @RunWith(SpringJUnit4ClassRunner.class)
  6. @ContextConfiguration(locations = {"classpath:bean.xml"})
  7. public class AccountServiceTest {
  8.     @Autowired
  9.     private IAccountService as;
  10.     @Test
  11.     public void testTransfer(){
  12.         as.transfer("aaa","bbb",100f);
  13.     }
  14. }
3、spring基于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.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xmlns:tx="http://www.springframework.org/schema/tx"
  6.        xsi:schemaLocation="
  7.         http://www.springframework.org/schema/beans
  8.         http://www.springframework.org/schema/beans/spring-beans.xsd
  9.         http://www.springframework.org/schema/tx
  10.         http://www.springframework.org/schema/tx/spring-tx.xsd
  11.         http://www.springframework.org/schema/aop
  12.         http://www.springframework.org/schema/aop/spring-aop.xsd">
  13.     <!--配置业务层-->
  14.     <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
  15.         <property name="accountDao" ref="accountDao"></property>
  16.     </bean>
  17.     <!--配置账户的持久层-->
  18.     <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  19. <!--        <property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
  20.         <property name="dataSource" ref="dataSource"></property>
  21.     </bean>
  23.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  24.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  25.         <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
  26.         <property name="username" value="root"></property>
  27.         <property name="password" value="root"></property>
  28.     </bean>
  29.     <!--Spring中基于XML的声明式事务配置步骤
  30.         1、配置事务管理器
  31.         2、配置事务的通知
  32.             此时需要导入事务的约束：tx名称空间和约束，同时也需要aop的
  33.             使用tx:advice标签配置事务通知
  34.                 属性：
  35.                     id:给事务通知起一个唯一标识
  36.                     transaction-manager：给事务通知提供一个事务管理器引用
  37.         3、配置AOP中的通用切入点表达式
  38.         4、建立事务通知和切入点表达式的对应关系
  39.         5、配置事务的属性
  40.             在事务的通知tx:advice标签的内部配置
  41.     -->
  42.     <!--配置事务管理器-->
  43.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  44.         <property name="dataSource" ref="dataSource"></property>
  45.     </bean>
  46.     <!--配置事务通知的标签-->
  47.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  48.         <!--配置事务的属性-->
  49.         <tx:attributes>
  50.     <!--标识transfer是业务层接口的方法，其需要一些属性
  51.          isolation="" 指定事务的隔离级别，默认是default，表示是数据库的默认隔离级别
  52.          no-rollback-for="" 用于指定一个异常，当产生该异常时，事务不会滚 ，产生其他异常时，事务回滚。没有默认值，表示任何异常都回滚
  53.          propagation="" 用于指定事务的传播行为，默认是REQUIRED，表示一定会有事务，增删改的选择，查询方法可以选择SUPPORT
  54.          read-only="" 指定事务是否只读，只有查询才能设置为true，默认为false表示读写
  55.          rollback-for="" 用于指定一个异常，当产生异常时，事务回滚。产生其他异常时，事务不回滚，没有默认值，表示任何异常都会滚
  56.          timeout="" 指定事务的超时时间，默认值是-1，表示永不超时，如果指定了数值，以秒为单位
  57.     -->
  58.             <tx:method name="*" read-only="false" propagation="REQUIRED"/>
  59.             <!--指定查询方法-->
  60.             <tx:method name="find*" propagation="SUPPORTS" read-only="true"></tx:method>
  61.         </tx:attributes>
  62.     </tx:advice>
  63.     <!--配置AOP-->
  64.     <aop:config>
  65.         <!--配置切入点表达式-->
  66.         <aop:pointcut id="pt1" expression="execution(* com.itheima.*.*(..))"/>
  67.         <!--建立切入点表达式和事务通知的对应关系-->
  68.         <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
  69.     </aop:config>
  70. </beans>
4、spring基于注解的声明式事务控制
先把IOC改为注解
修改名称空间
  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:tx="http://www.springframework.org/schema/tx"
  6.        xmlns:context="http://www.springframework.org/schema/context"
  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/tx
  10.         http://www.springframework.org/schema/tx/spring-tx.xsd
  11.         http://www.springframework.org/schema/aop
  12.         http://www.springframework.org/schema/aop/spring-aop.xsd
  13.         http://www.springframework.org/schema/context
  14.         http://www.springframework.org/schema/context/spring-context.xsd">
  15.     <!--配置业务层-->
  16.     <!--配置spring创建容器时要扫描的包-->
  17.     <context:component-scan base-package="com.itheima"></context:component-scan>
  18.     <!--配置JdbcTemplate-->
  19.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  20.         <property name="dataSource" ref="dataSource"></property>
  21.     </bean>
  22.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  23.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  24.         <property name="url" value="jdbc:mysql://localhost:3306/eesy02"></property>
  25.         <property name="username" value="root"></property>
  26.         <property name="password" value="root"></property>
  27.     </bean>
  28.     <!--Spring中基于注解的声明式事务配置步骤
  29.         1、配置事务管理器
  30.         2、开启Spring对注解事务的支持
  31.         3、在需要事务支持的地方使用@Transactional注解
  32.         4、建立事务通知和切入点表达式的对应关系
  33.         5、配置事务的属性
  34.             在事务的通知tx:advice标签的内部配置
  35.     -->
  36.     <!--配置事务管理器-->
  37.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  38.         <property name="dataSource" ref="dataSource"></property>
  39.     </bean>
  40.     <!--开启Spring对注解事务的支持-->
  41.     <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
  42. </beans>
  1. package com.itheima.service.impl;
  3. import com.itheima.dao.IAccountDao;
  4. import com.itheima.domain.Account;
  5. import com.itheima.service.IAccountService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.transaction.annotation.Propagation;
  9. import org.springframework.transaction.annotation.Transactional;
  11. @Service("accountService")
  12. @Transactional(propagation = Propagation.SUPPORTS,readOnly = true)//只读型事务控制
  13. public class AccountServiceImpl implements IAccountService {
  14.     @Autowired
  15.     private IAccountDao accountDao;
  17.     @Override
  18.     public Account findAccountById(Integer accountId) {
  19.         return accountDao.findAccountById(accountId);
  20.     }
  21.     //需要的是读写型事务控制
  22.     @Transactional(propagation = Propagation.REQUIRED,readOnly = false)//读写型
  23.     //xml一劳永逸
  24.     @Override
  25.     public void transfer(String sourceName, String targetName, Float money) {
  26.         System.out.println("transfer开始执行");
  27.         //2.1根据名称查询转出账户
  28.         Account source = accountDao.findAccountByName(sourceName);
  29.         //2.2根据名称查询转入账户
  30.         Account target = accountDao.findAccountByName(targetName);
  31.         //2.3转出账户金额减少
  32.         source.setMoney(source.getMoney() - money);
  33.         //2.4.转入账户金额增加
  34.         target.setMoney(target.getMoney() + money);
  35.         //2.5.更新转出账户
  36.         accountDao.updateAccount(source);
  37.         //2.6.更新转入账户
  38.         accountDao.updateAccount(target);
  39.         //int i = 1 / 0;
  40.         //3.提交事务
  41.         //txManager.commit();
  42.     }
  43. }
  1. /**
  2.  * 账户的持久层实现类
  3.  */
  4. @Repository("accountDao")
  5. public class AccountDaoImpl  implements IAccountDao {
  6.     @Autowired
  7.     private JdbcTemplate jdbcTemplate;
  9.     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
  10.         this.jdbcTemplate = jdbcTemplate;
  11.     }
5、spring基于纯注解的声明式事务控制
注解IOC和注解事务进行整合
  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/eesy02
  3. jdbc.username=root
  4. jdbc.password=root
  6. package config;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.jdbc.core.JdbcTemplate;
  10. import org.springframework.jdbc.datasource.DriverManagerDataSource;
  12. import javax.sql.DataSource;
  14. /**
  15.  * 和连接数据库相关的配置类
  16.  */
  17. public class JdbcConfig {
  18.     @Value("${jdbc.driver}")
  19.     private String driver;
  20.     @Value("${jdbc.url}")
  21.     private String url;
  22.     @Value("${jdbc.username}")
  23.     private String username;
  24.     @Value("${jdbc.password}")
  25.     private String password;
  26.     /**
  27.      * 创建JdbcTemplate对象
  28.      * @param dataSource
  29.      * @return
  30.      */
  31.     //进入容器需要bean注解
  32.     @Bean(name="jdbcTemplate")
  33.     public JdbcTemplate createJdbcTemplate(DataSource dataSource){
  34.         return new JdbcTemplate(dataSource);
  35.     }
  37.     /**
  38.      * 创建一个数据源对象
  39.      * @return
  40.      */
  41.     @Bean(name="dataSource")
  42.     public DataSource createDatasouce(){
  43.         DriverManagerDataSource ds = new DriverManagerDataSource();
  44.         ds.setDriverClassName(driver);
  45.         ds.setUrl(url);
  46.         ds.setUsername(username);
  47.         ds.setPassword(password);
  48.         return ds;
  49.     }
  50. }
  1. package config;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  5. import org.springframework.transaction.PlatformTransactionManager;
  7. import javax.sql.DataSource;
  9. /**
  10.  * 和事务相关的配置类
  11.  */
  12. public class TransactionConfig {
  13.     /**
  14.      * 用于创建事务管理器对象
  15.      * @param dataSource
  16.      * @return
  17.      */
  18.     @Bean(name="transactionManager")
  19.     public PlatformTransactionManager createTransactionManager(DataSource dataSource){
  20.         return new DataSourceTransactionManager(dataSource);
  21.     }
  22. }
  1. package config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.Import;
  6. import org.springframework.context.annotation.PropertySource;
  7. import org.springframework.transaction.annotation.EnableTransactionManagement;
  9. /**
  10.  * Spring的配置类，相当于bean.xml
  11.  */
  12. @Configuration
  13. @ComponentScan("com.itheima")
  14. @Import({JdbcConfig.class,TransactionConfig.class})
  15. @PropertySource("jdbcConfig.properties")
  16. @EnableTransactionManagement //开启事务注解的支持
  17. public class SpringConfiguration {
  18. }
6、spring编程式事务控制-了解
实际开发中，不常使用
  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">
  6.     <!--配置业务层-->
  7.     <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
  8.         <property name="accountDao" ref="accountDao"></property>
  9.         <property name="transactionTemplate" ref="transactionTemplate"></property>
  10.     </bean>
  11.     <!--配置账户的持久层-->
  12.     <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
  13. <!--        <property name="jdbcTemplate" ref="jdbcTemplate"></property>-->
  14.         <property name="dataSource" ref="dataSource"></property>
  15.     </bean>
  17.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  18.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
  19.         <property name="url" value="jdbc:mysql://localhost:3306/eesy02"></property>
  20.         <property name="username" value="root"></property>
  21.         <property name="password" value="root"></property>
  22.     </bean>
  23.     <!--配置事务管理器-->
  24.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  25.         <property name="dataSource" ref="dataSource"></property>
  26.         <!--注入连接池数据源-->
  27.     </bean>
  28.     <!--配置事务模板对象-->
  29.     <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
  30.         <property name="transactionManager" ref="transactionManager"></property>
  31.     </bean>
  32. </beans>
7、spring5新特性的介绍
修改jdk版本


Spring04:JdbcTemplate及事务控制（AOP、XML、注解）的更多相关文章

  1. Spring jdbctemplate和事务管理器 全注解配置 不使用xml

    /** * spring的配置类,相当于bean.xml */@Configuration//@Configuration标注在类上,相当于把该类作为spring的xml配置文件中的<beans ...

  2. 28Spring_的事务管理_银行转账业务加上事务控制_基于注解进行声明式事务管理

    将applicationContext.xml 和 AccountServiceImpl 给备份一个取名为applicationContext2.xml 和 AccountServiceImpl2.j ...

  3. Spring的事务控制-基于xml方式

    介绍:该程序模拟了转账操作,即Jone减少500元,tom增加500元 1.导入坐标 <dependency> <groupId>junit</groupId> & ...

  4. 使用Spring实现AOP(XML+注解)

    一.Spring对AOP的支持 AOP并不是Spring框架特有的,Spring只是支持AOP编程的框架之一,每一个框架对AOP的支持各有特点,有些AOP能够对方法的参数进行拦截,有些AOP对方法进行 ...

  5. Spring第八篇【XML、注解实现事务控制】

    前言 本博文主要讲解Spring的事务控制,如何使用Spring来对程序进行事务控制-. 一般地,我们事务控制都是在service层做的..为什么是在service层而不是在dao层呢??有没有这样的 ...

  6. Spring的事务控制-基于注解的方式

    模拟转账操作,即Jone减少500,tom增加500 如果有疑问请访问spring事务控制-基于xml方式 1.创建数据表 2.创建Account实体类 public class Account { ...

  7. 阶段3 2.Spring_10.Spring中事务控制_1 基于XML的AOP实现事务控制

    新建项目 首先把依赖复制进来 aop必须引入.aspectjweaver 复制src下的所有内容 复制到我们的新项目里面 factory文件夹删掉 删除后测试类必然就报错 配置文件 beanFacto ...

  8. Java实战之03Spring-05Spring中的事务控制（基于AOP）

    五.Spring中的事务控制(基于AOP) 1.Spring中事务有关的接口 1.1.明确: JavaEE体系进行分层开发,事务处理位于业务层,Spring提供了分层设计业务层的事务处理解决方案 1. ...

  9. spring基于XML的声明式事务控制

    <?xml version="1.0" encoding="utf-8" ?><beans xmlns="http://www.sp ...

  10. SpringBoot系列: JdbcTemplate 事务控制

    ============================Spring JdbcTemplate 事务控制============================之前使用 JDBC API 操作, 经常 ...

随机推荐

  1. Elasticsearch：Elasticsearch HQ 介绍

  2. Beats：通过Metricbeat实现外部对Elastic Stack的监控

  3. SonarQube 之 gitlab-plugin 配合 gitlab-ci 完成每次 commit 代码检测

    转载自:https://cloud.tencent.com/developer/article/1010601 1.背景介绍 我们知道使用 SonarQube 可以在日常开发中检测代码质量,除了使用 ...

  4. C#-02 传入参数的一些用法2

    C#＿02 参数应用2 一.关于 "ref" 局部变量和 "ref" 返回 在前面已经明白了 ref 关键词传递一个对象引用给方法调用,这样在方法中对对象修改过 ...

  5. vue中的v-if查找数组中最后一个，给他加上新的样式

    vue: var app=new Vue({ el:".xiaomi", data: { typeInfo: [{img:"image/type/phone_1.webp ...

  6. 自己动手写ls命令——Java版

    自己动手写ls命令--Java版 介绍 在前面的文章Linux命令系列之ls--原来最简单的ls这么复杂当中,我们仔细的介绍了关于ls命令的使用和输出结果,在本篇文章当中我们用Java代码自己实现ls ...

  7. C语言之走迷宫深度和广度优先（利用堆栈和队列）

    完成以下迷宫 利用二维数组储存每一个数组里的值,若是不能走则为1,若是可行就是0,走过了就设为2. 一般是再复制一个数组,用来记录. 堆栈的思想就是将一个点的上下左右都遍历一遍,若可行进栈,跳出遍历, ...

  8. 成功 解决 @keyup.enter=“search()“ 在el-input 组件中不生效的问题

    1.问题描述 在输入框中.输入内容.点击回车.没有效果 问题代码 2.问题解决思路 查看官网的解释说明: 要使用.native修饰符 3.问题解决 修改后的代码 修改后的效果

  9. 【React】学习笔记（二）——组件的生命周期、React脚手架使用

    原教程视频:ttps://www.bilibili.com/video/BV1wy4y1D7JT?p=2&spm_id_from=pageDriver 目录 一.组件的生命周期 1.1.生命周 ...

  10. 跟我学Python图像处理丨图像特效处理：毛玻璃、浮雕和油漆特效

    摘要:本文讲解常见的图像特效处理,从而让读者实现各种各样的图像特殊效果,并通过Python和OpenCV实现. 本文分享自华为云社区<[Python图像处理] 二十四.图像特效处理之毛玻璃.浮雕 ...