Spring学习day_03事务控制两种动态代理SpringAOP注解与xml

最新推荐文章于 2020-03-04 22:12:22 发布

就是闫先森

最新推荐文章于 2020-03-04 22:12:22 发布

阅读量150

点赞数

分类专栏：大聖的JavaWorld 文章标签： spring aop 动态代理注解事务控制

本文链接：https://blog.csdn.net/chenchen818/article/details/102643539

版权

大聖的JavaWorld 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Spring中的AOP

完善day02的案例

添加一个新方法：转账(public void transfer(String sourceName, String targetName, Float Money))

工具类：连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定

public class ConnectionUtils {

    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
    * 获取当前线程上的连接
    * @return
    */
    public Connection getThreadConnection() {
        try{
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    /**
    * 把连接和线程解绑
    */
    public void removeConnection(){
        tl.remove();
    }
}

工具类：和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接

public class TransactionManager {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
    * 开启事务
    */
    public  void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
    * 提交事务
    */
    public  void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
    * 回滚事务
    */
    public  void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
    * 释放连接
    */
    public  void release(){
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

业务层实现事务控制

public class AccountServiceImpl_OLD implements IAccountService{

    private IAccountDao accountDao;
    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public List<Account> findAllAccount() {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return accounts;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }
    }

    @Override
    public Account findAccountById(Integer accountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            Account account = accountDao.findAccountById(accountId);
            //3.提交事务
            txManager.commit();
            //4.返回结果
            return account;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }
    }

    @Override
    public void saveAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.saveAccount(account);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }

    @Override
    public void updateAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.updateAccount(account);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }

    @Override
    public void deleteAccount(Integer acccountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.deleteAccount(acccountId);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作

            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
            //3.提交事务
            txManager.commit();

        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
            e.printStackTrace();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }
}

分析案例中的问题

代码很臃肿，重复代码很多
依赖严重—存在于方法之间，如txManager.beginTransaction()

回顾动态代理

特点：字节码随用随创建，随用随加载
作用：不修改源码的基础上对方法增强
分类：
- 基于接口的动态代理：
- 基于子类的动态代理：

基于接口的动态代理：

涉及的类：Proxy
提供者：JDK官方
如何创建代理对象：
- 使用Proxy类中的newProxyInstance方法
创建代理对象的要求
- 被代理类最少实现一个接口，如果没有则不能使用
newProxyInstance方法的参数
- ClassLoader：类加载器，用于加载代理对象字节码。写的是被代理对象的类加载器(和被代理对象使用相同的类加载器，固定写法，即代理谁就写谁的类.getClass().getClassLoader())
- Class[]：字节码数组，它是用于让代理对象和被代理对象有相同的方法。只要两个实现同一个接口，就都会由相同的方法(代理谁就写谁的类.getClass().getInterfaces())
- InvocationHandler：用于提供增强的代码。它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不必须(此接口的实现类都是谁用谁写)
InvocationHandler位置invoke方法的参数
- proxy：代理对象的引用
- method：当前执行的方法
- args：当前执行方法所需的参数
- 返回值：和被代理对象有相同的返回值

例子：

public class Client {

    public static void main(String[] args) {
        final Producer producer = new Producer();

    IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;

                        //1.获取方法执行的参数
                        Float money = (Float)args[0];
                        //2.判断当前方法是不是销售
                        if("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer, money*0.8f);
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000f);
    }
}

问题：必须实现接口，如果是普通类，则不行

基于子类的动态代理

第三方jar包(cglib)

<dependencies>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.1_3</version>
    </dependency>
</dependencies>

涉及的类：Enhancer
提供者：第三方cglib库
如何创建代理对象：
- 使用Enhancer类中的create方法
创建代理对象的要求
- 被代理类不能是最终类(最终类不能创建子类，也就不能创建代理对象了)
create方法的参数
- Class：字节码。用于指定被代理对象的字节码(即要代理谁，就写谁的.getClass())
- Callback：用于提供增强的代码。它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不必须(此接口的实现类都是谁用谁写)。我们一般写的都是该接口的子接口实现类：MethodInterceptor(方法拦截)
Callback位置MethodInterceptor方法的参数
- proxy：代理对象的引用
- method：当前执行的方法
- args：当前执行方法所需的参数
- methodProxy：当前执行方法的代理对象
- 返回值：和被代理对象有相同的返回值

实例：

public class Client {

    public static void main(String[] args) {
        final Producer producer = new Producer();

        Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(), new MethodInterceptor() {

            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //提供增强的代码
                Object returnValue = null;
                //1.获取方法执行的参数
                Float money = (Float)args[0];
                //2.判断当前方法是不是销售
                if("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer, money*0.8f);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduct(12000f);
    }
}

动态代理改造案例(基于子类的动态代理)

public class BeanFactory {

    private IAccountService accountService;
    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }
    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    /**
     * 获取Service代理对象
     * @return
     */
    public IAccountService getAccountService() {
        return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     *
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        if("test".equals(method.getName())){
                            return method.invoke(accountService,args);
                        }

                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

<!-- bean.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置代理的service-->
    <bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>

    <!--配置beanfactory-->
    <bean id="beanFactory" class="com.itheima.factory.BeanFactory">
        <!-- 注入service -->
        <property name="accountService" ref="accountService"></property>
        <!-- 注入事务管理器 -->
        <property name="txManager" ref="txManager"></property>
    </bean>
    <!-- ... -->
    <!--配置Dao对象-->
    <!--配置QueryRunner-->
    <!-- 配置数据源 -->
    <!-- 配置Connection的工具类 ConnectionUtils -->
    <!-- 配置事务管理器-->

AOP的概念

Aspect Orented Programing 即面向切面编程
在软件业，AOP为Aspect Oriented Programming的缩写，意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是**OOP(面向对象编程)**的延续,是软件开发中的一-个热点，也是Spring框架中的一一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
简单地说就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的情况下基础上，对我们的已有方法进行增强
优势：减少重复代码、提高开发效率、维护方便

spring总的AOP相关术语

Joinpoint(连接点)：
- 所谓连接点是指那些被拦截到的点，在spring中，这些点指的是方法，因为spring只支持方法类型的连接点。(比如业务层中的方法)
Ponitcut(切入点)：
- 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
- 所有的切入点都是连接点，但只有被增强的连接点才是切入点
Advice(通知 /增强 ):
- 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
- 通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
- method.invoke前面的就是前置，后面的就是后置，catch里面的就是异常，finally里面的就是最终，整个invoke方法正在执行就是环绕通知(在环绕通知中有明确的的切入点方法调用)
Introduction(引介 :
- 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field(字段)。
Target(目标对象):
- 代理的目标对象/被代理对象。
Weaving(织入):
- 是指把增强应用到目标对象来创建新的代理对象的过程。(原本的service不支持事务，我们用动态代理的方式返回了一个代理对象，返回代理对象的时候从中加入了事务，这个过程就是织入)
- spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理） :
- 一个类被 AOP 织入增强后，就产生一个结果代理类。(return 回去的)
Aspect(切面 ):
- 是切入点和通知（引介）的结合。(哪些方法哪些配置哪些顺序)
- 也就是配种文件中，声明切入点于通知间的关系

基于XML的AOP配置

入门入门入门

把通知Bean也交给spring来管理
使用aop:config标签表明开始AOP的配置
使用aop:aspect标签表明配置切面
- id属性：是给切面提供一个唯一表示
- ref属性：是指定通知bean的id
在aop:aspect标签的内部使用对应标签来配置通知的类型
- 比方说我们现在的实例是让printLog方法在切入点方法执行前执行，所以是前置通知
- aop:before：表示前置通知
  - method属性：用于指定Logger类中哪个方法是前置通知
  - pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法进行增强
- 切入点表达式的写法
  - 关键字：execution(表达式)
  - 表达式：访问修饰符返回值包名.包名.包名…类名.方法名(参数列表)
  - 标准写法：public void com.my.service.impl.AccountServiceImpl.saveAccount()
  - 访问修饰符可以省略
  - 返回值可以使用通配符，表示任意返回值
  - 包名可以使用通配符，表示任意包，但是有几级包就需要写几个*.
  - 包名可以使用..表示当前包及其子包
  - 类名和方法名都可以使用*来实现通配
  - 参数列表可以直接写数据类型(基本类型写名称，引用类型写包名.类名的方式)，也可以写通配符表示任意类型，但是必须有参数，一个参数就一个*，也可以使用..表示任意参数
  - 全通配写法：* *..*.*(..)
  - 实际开发中通常写法：切到业务层实现类的所有方法

实例

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    <!-- 配置Logger类 -->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>
    <!--配置AOP-->
    <aop:config>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>

</beans>

四种通知类型

配置前置通知：在切入点方法执行之前执行
配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个
配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个
配置最终通知：无论切入点方法是否正常执行它都会在其后面执行
配置切入点表达式
- id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
- 此标签写在aop:aspect标签内部只能当前切面使用。
- 它还可以写在aop:aspect外面，此时就变成了所有切面可用
配置环绕通知详细的注释请看Logger类中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <!-- 配置Logger类 -->
    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            
            <aop:before method="beforePrintLog" pointcut-ref="pt1" ></aop:before>
            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>

            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>

</beans>

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 前置通知
     */
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }

    /**
     * 环绕通知
     */
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }
}

问题：
- 当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
分析：
- 通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
解决：
- Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
- 该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。(说白了就会直接用就行)
spring中的环绕通知：
- 它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。

基于注解的AOP配置

xml开启AOP功能
@Aspect注解表示当前类是一个切面类

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.itheima"></context:component-scan>

    <!-- 配置spring开启注解AOP的支持 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

package com.itheima.utils;

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

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {

    //指定切入点表达式
    @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 前置通知
     */
    @Before("pt1()")
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
    @AfterReturning("pt1()")
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
    @AfterThrowing("pt1()")
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
    @After("pt1()")
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }

    /**
     * 环绕通知
     */
    @Around("pt1()")
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }
}

纯注解

@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}

就是闫先森

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring学习day_03事务控制两种动态代理SpringAOP注解与xml

Spring中的AOP完善day02的案例添加一个新方法：转账(public void transfer(String sourceName, String targetName, Float Money))工具类：连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定public class ConnectionUtils { private ThreadLocal...
复制链接

扫一扫