Spring—学习笔记#day03

最新推荐文章于 2024-09-30 15:46:40 发布
最新推荐文章于 2024-09-30 15:46:40 发布
阅读量1k 收藏
点赞数
分类专栏： Spring 文章标签： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36910634/article/details/98478960
版权

目录

1、完善我们的account案例

2、分析案例中问题

新的问题

3、动态代理回顾

动态代理的特点

动态代理常用的有两种方式

4、基于接口的动态代理

5、基于子类的动态代理

使用 CGLib的Enhancer类创建代理对象

环境配置

6、解决案例中的问题

7、AOP的相关概念 [理解] 

7.1AOP概述

7.1.1什么是 AOP

7.1.2AOP的作用及优势

7.1.3AOP的实现方式

8、Spring中的 AOP[掌握]

Spring中AOP的细节

AOP 相关术语

学习 spring中的 AOP要明确的事

关于代理的选择

基于XML的 AOP配置

环境搭建

第一步：把通知类用 bean 标签配置起来

第二步：使用 aop:config  声明 aop 配置

第三步：使用 aop:aspect  配置切面

第四步：使用 aop:pointcut  配置切入点表达式

第五步：使用 aop:xxx  配置 对应的通知类型

切入点表达式说明

环绕通知

基于注解的 AOP配置

环境搭建

第一步：把通知类也使用注解配置

第二步：在通知类上使用@Aspect注解声明为切面

第三步：在增强的方法上使用注解配置通知

不使用 XML 的配置方式

1、完善我们的account案例

https://i-blog.csdnimg.cn/blog_migrate/8ad34263c7d4a2e3c0ba34d3cf7ae3b2.png ​

2、分析案例中问题

问题就是：
事务被自动控制了。换言之，我们使用了 connection 对象的 setAutoCommit(true)此方式控制事务，如果我们每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql语句，这种方式就无法实现功能了。

当我们执行时，由于执行有异常，转账失败。但是因为我们是每次执行持久层方法都是独立事务，导致无法实现事务控制（不符合事务的一致性）

https://i-blog.csdnimg.cn/blog_migrate/9844f7993b870196c73e2d54c3822237.png

​解决办法：
让业务层来控制事务的提交和回滚。注：业务层实现类没有使用 spring 的 的 IoC.

https://i-blog.csdnimg.cn/blog_migrate/20671700bea386d0574c2f8120c69557.png ​

ConnectionUtils工具类

/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 */
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();
    }
}

TransactionManager工具类

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 */
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();
        }
    }
}

新的问题

上一小节的代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题：业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了。
试想一下，如果我们此时提交，回滚，释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。
思考：
这个问题能不能解决呢？
答案是肯定的，使用下一小节中提到的技术。

3、动态代理回顾

动态代理的特点

字节码随用随创建，随用随加载。
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
装饰者模式就是静态代理的一种体现。

动态代理常用的有两种方式

基于接口的动态代理
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
基于子类的动态代理
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。

4、基于接口的动态代理

  • 要实现接口（基于接口的动态代理）
/**
 * 对生产厂家要求的接口
 */
public interface IProducer {

    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money);

    /**
     * 售后
     * @param money
     */
    public void afterService(float money);
}
 
/**
 * 一个生产者
 */
public class Producer implements IProducer{

    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money){
        System.out.println("销售产品，并拿到钱："+money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(float money){
        System.out.println("提供售后服务，并拿到钱："+money);
    }
}
 
/**
 * 模拟一个消费者
 */
public class Client {

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

        /**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于接口的动态代理：
         *      涉及的类：Proxy
         *      提供者：JDK官方
         *  如何创建代理对象：
         *      使用Proxy类中的newProxyInstance方法
         *  创建代理对象的要求：
         *      被代理类最少实现一个接口，如果没有则不能使用
         *  newProxyInstance方法的参数：
         *      ClassLoader：类加载器
         *          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
         *      Class[]：字节码数组
         *          它是用于让代理对象和被代理对象有相同方法。固定写法。
         *      InvocationHandler：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         */
        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.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 {
                        //提供增强的代码
                        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);
    }
}

5、基于子类的动态代理

  • 不需要实现接口（基于子类的动态代理）

使用 CGLib的Enhancer类创建代理对象

环境配置

 https://i-blog.csdnimg.cn/blog_migrate/380c73af05c9259c5fd8ea253a725d85.png ​ https://i-blog.csdnimg.cn/blog_migrate/df79d8368c435ce4f76cce1e8cf71477.png ​

/**
 * 一个生产者
 */
public class Producer {

    /**
     * 销售
     * @param money
     */
    public void saleProduct(float money){
        System.out.println("销售产品，并拿到钱："+money);
    }

    /**
     * 售后
     * @param money
     */
    public void afterService(float money){
        System.out.println("提供售后服务，并拿到钱："+money);
    }
}
 
/**
 * 模拟一个消费者
 */
public class Client {

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

        /**
         * 动态代理：
         *  特点：字节码随用随创建，随用随加载
         *  作用：不修改源码的基础上对方法增强
         *  分类：
         *      基于接口的动态代理
         *      基于子类的动态代理
         *  基于子类的动态代理：
         *      涉及的类：Enhancer
         *      提供者：第三方cglib库
         *  如何创建代理对象：
         *      使用Enhancer类中的create方法
         *  创建代理对象的要求：
         *      被代理类不能是最终类
         *  create方法的参数：
         *      Class：字节码
         *          它是用于指定被代理对象的字节码。
         *
         *      Callback：用于提供增强的代码
         *          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
         *          此接口的实现类都是谁用谁写。
         *          我们一般写的都是该接口的子接口实现类：MethodInterceptor（方法拦截）
         */
        Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            /**
             * 执行被代理对象的任何方法都会经过该方法
             * @param proxy
             * @param method
             * @param args
             *    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
             * @param methodProxy ：当前执行方法的代理对象
             * @return
             * @throws Throwable
             */
            @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);
    }
}

6、解决案例中的问题

/**
 * 用于创建Service的代理对象的工厂
 */
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();
                        }
                    }
                });

    }
}

7、AOP的相关概念 [理解] 

7.1AOP概述

7.1.1什么是 AOP

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。

https://i-blog.csdnimg.cn/blog_migrate/b709a73f3f728fd6b290b9f83a4f80e4.png ​

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

7.1.2AOP的作用及优势

作用：
在程序运行期间，不修改源码对已有方法进行增强。
优势：
减少重复代码
提高开发效率
维护方便

7.1.3AOP的实现方式

使用动态代理技术

8、Spring中的 AOP[掌握]

Spring中AOP的细节

AOP 相关术语

Joinpoint( 连接点):
所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

所有的切入点都是连接点
Pointcut( 切入点):
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。

https://i-blog.csdnimg.cn/blog_migrate/a24d943c72c2db756a5f9991550f0153.png ​

不是所有的切入点都是连接点，只有被增强的才是
Advice( 通知/ 增强):
所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

TransactionManager

https://i-blog.csdnimg.cn/blog_migrate/6f423230fc33e68a2643cffee819bac0.jpeg ​

Introduction( 引介):
引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target( 目标对象):
代理的目标对象。（被代理对象）

https://i-blog.csdnimg.cn/blog_migrate/f5828a26e9a8bdbd525d195e764551ad.png ​
Weaving( 织入):
是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

加入事务支持的过程
Proxy （代理）:
一个类被 AOP 织入增强后，就产生一个结果代理类。

https://i-blog.csdnimg.cn/blog_migrate/b19192efa2a33ef6f59589d5e6ff85f5.png ​
Aspect( 切面):
是切入点和通知（引介）的结合。

学习 spring中的 AOP要明确的事

a 、开发阶段（我们做的）
编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。
在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。
b 、运行阶段（Spring  框架完成的）
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

关于代理的选择

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

基于XML的 AOP配置

环境搭建

https://i-blog.csdnimg.cn/blog_migrate/cefa5ce5683baef851a196af42d20de6.png ​

第一步：把通知类用 bean 标签配置起来

<!-- 配置通知 -->
<bean id="txManager" class="com.itheima.utils.TransactionManager">
<property name="dbAssit" ref="dbAssit"></property>
</bean>

第二步：使用 aop:config  声明 aop 配置

aop:config:
作用：用于声明开始 aop 的配置
<aop:config>
<!-- 配置的代码都写在此处 -->
</aop:config>

第三步：使用 aop:aspect  配置切面

aop:aspect:
作用：
用于配置切面。
属性：
id：给切面提供一个唯一标识。
ref：引用配置好的通知类 bean 的 id。
<aop:aspect id="txAdvice" ref="txManager">
<!--配置通知的类型要写在此处-->
</aop:aspect>

第四步：使用 aop:pointcut  配置切入点表达式

aop:pointcut ：
作用：
用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识
<aop:pointcut expression="execution(
public void com.itheima.service.impl.AccountServiceImpl.transfer(
java.lang.String, java.lang.String, java.lang.Float)
)" id="pt1"/>

第五步：使用 aop:xxx  配置 对应的通知类型

aop:before
作用：
用于配置前置通知。指定增强的方法在切入点方法之前执行
属性：
method:用于指定通知类中的增强方法名称
ponitcut-ref：用于指定切入点的表达式的引用
poinitcut：用于指定切入点表达式 
执行时间点：
切入点方法执行之前执行
<aop:before method="beginTransaction" pointcut-ref="pt1"/>

aop:after-returning
作用：
用于配置后置通知
属性：
method ：指定通知中方法的名称。
pointct ：定义切入点表达式
pointcut-ref ：指定切入点表达式的引用
执行时间点：
切入点方法正常执行之后。它和异常通知只能有一个执行
<aop:after-returning method="commit" pointcut-ref="pt1"/>


aop:after-throwing
作用：
用于配置异常通知
属性：
method ：指定通知中方法的名称。
pointct ：定义切入点表达式
pointcut-ref ：指定切入点表达式的引用
执行时间点：
切入点方法执行产生异常后执行。它和后置通知只能执行一个
<aop:after-throwing method="rollback" pointcut-ref="pt1"/>


aop:after
作用：
用于配置最终通知
属性：
method ：指定通知中方法的名称。
pointct ：定义切入点表达式
pointcut-ref ：指定切入点表达式的引用
执行时间点：
无论切入点方法执行时是否有异常，它都会在其后面执行。
<aop:after method="release" pointcut-ref="pt1"/>

切入点表达式说明

execution:匹配方法的执行(常用)
execution(表达式)
表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
写法说明：
全匹配方式：
public  void
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
访问修饰符可以省略
void
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)

返回值可以使用*号，表示任意返回值
*
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
包名可以使用*号，表示任意包，但是有几级包，需要写几个*
* *.*.*.*.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
使用..来表示当前包，及其子包
* com..AccountServiceImpl.saveAccount(com.itheima.domain.Account)
类名可以使用*号，表示任意类
* com..*.saveAccount(com.itheima.domain.Account)
方法名可以使用*号，表示任意方法
* com..*.*( com.itheima.domain.Account)
参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
* com..*.*(*)
参数列表可以使用..表示有无参数均可，有参数可以是任意类型
* com..*.*(..)
全通配方式：
* *..*.*(..)
注：
通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。
execution(* com.itheima.service.impl.*.*(..))

bean.xml

https://i-blog.csdnimg.cn/blog_migrate/c050c790cbc75f9d9af06bbb69914928.png ​

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

    <!--spring中基于XML的AOP配置步骤
        1、把通知Bean也交给spring来管理
        2、使用aop:config标签表明开始AOP的配置
        3、使用aop:aspect标签表明配置切面
                id属性：是给切面提供一个唯一标识
                ref属性：是指定通知类bean的Id。
        4、在aop:aspect标签的内部使用对应标签来配置通知的类型
               我们现在示例是让printLog方法在切入点方法执行之前之前：所以是前置通知
               aop:before：表示配置前置通知
                    method属性：用于指定Logger类中哪个方法是前置通知
                    pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

            切入点表达式的写法：
                关键字：execution(表达式)
                表达式：
                    访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
                标准的表达式写法：
                    public void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                访问修饰符可以省略
                    void com.itheima.service.impl.AccountServiceImpl.saveAccount()
                返回值可以使用通配符，表示任意返回值
                    * com.itheima.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                    * *.*.*.*.AccountServiceImpl.saveAccount())
                包名可以使用..表示当前包及其子包
                    * *..AccountServiceImpl.saveAccount()
                类名和方法名都可以使用*来实现通配
                    * *..*.*()
                参数列表：
                    可以直接写数据类型：
                        基本类型直接写名称           int
                        引用类型写包名.类名的方式   java.lang.String
                    可以使用通配符表示任意类型，但是必须有参数
                    可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：
                    * *..*.*(..)

                实际开发中切入点表达式的通常写法：
                    切到业务层实现类下的所有方法
                        * com.itheima.service.impl.*.*(..)
    -->

    <!-- 配置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>

环绕通知

配置方式:
<aop:config>
<aop:pointcut  expression="execution(*  com.itheima.service.impl.*.*(..))"
id="pt1"/>
<aop:aspect id="txAdvice" ref="txManager">
<!-- 配置环绕通知 -->
<aop:around method="transactionAround" pointcut-ref="pt1"/>
</aop:aspect>
</aop:config>
aop:around ：
作用：
用于配置环绕通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
说明：
它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
通常情况下，环绕通知都是独立使用的

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
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方法开始记录日志了。。。");
    }

    /**
     * 环绕通知
     * 问题：
     *      当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
     * 分析：
     *      通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
     * 解决：
     *      Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     *      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     *
     * spring中的环绕通知：
     *      它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    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方法开始记录日志了。。。最终");
        }
    }
}

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"
       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>
        <!-- 配置切入点表达式 id属性用于指定表达式的唯一标识。expression属性用于指定表达式内容
              此标签写在aop:aspect标签内部只能当前切面使用。
              它还可以写在aop:aspect外面，此时就变成了所有切面可用
          -->
        <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>-->

            <!-- 配置环绕通知 详细的注释请看Logger类中-->
            <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

基于注解的 AOP配置

环境搭建

https://i-blog.csdnimg.cn/blog_migrate/e66e466326bf538903eba8e064b847fe.png ​

导入注解相关标签

https://i-blog.csdnimg.cn/blog_migrate/5e20bc2437d45f4362f56aab9e1ccc0e.png ​

第一步：把通知类也使用注解配置

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
public class Logger {
    /**
     * 前置通知
     */
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

第二步：在通知类上使用@Aspect注解声明为切面

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {
    /**
     * 前置通知
     */
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

第三步：在增强的方法上使用注解配置通知

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@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方法开始记录日志了。。。");
    }

不使用 XML 的配置方式

https://i-blog.csdnimg.cn/blog_migrate/07fc043c24280871406fb645de64f10e.png ​

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

源码：https://github.com/DiCaprio17/Spring/tree/master/spring_day03

安藤青司
关注
专栏目录
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
2020/2/19学习笔记-day01
01-20
【Java学习笔记-day01】 Java是一门广泛应用于软件开发的高级编程语言，自1995年诞生以来，经历了多次版本更新，逐渐发展成为现代软件工程的重要支柱。本篇笔记主要介绍了Java学习的一些基础知识，包括XML、面向...
Spring源码(15) -- Aop动态代理之 Enhancer
最新发布
一生编程，快乐编程
09-30 480
源码： org.springframework.cglib.core.AbstractClassGenerator#createtry {//获取类加载器//双重检查锁， 设置 ClassLoaderData。并设置缓存。// 生成对象throw ex;
Spring 工具类 ConfigurationClassEnhancer
Details Inside Spring
01-31 2787
概述 Spring中存在这样一个工具类ConfigurationClassEnhancer,它会对应用中每个配置类，也就是一般通过@Configuration注解定义的类进行一个增强。通过增强以后，配置类中使用@Bean注解的bean定义方法就不再是普通的方法了，它们具有了如下跟bean作用域有关的能力，以单例bean为例 ： 1. 它们首次被调用时，相应方法逻辑会被执行用于创建bean实例； 2...
CGLIB实现AOP，MethodInterceptor接口和Enhancer详解——Spring AOP（四）
方圆几里
10-26 6493
上一章讲到了使用JDK的Proxy实现AOP： https://blog.csdn.net/qq_34598667/article/details/83380628 这一章我们讲另外一种方式，使用CGLIB实现AOP 使用CGLIB实现AOP功能 上一章我们已经说过，要产生某个对象的代理对象，这个对象必须实现一个接口，动态代理技术只能基于接口进行代理。 可是有时候我们在开发时碰到一些对象没有接口...
Spring的动态代理原理
Alexon Xu的博客
05-09 2131
Spring动态代理原理 Spring动态代理有两种：CGLIB动态代理和JDK动态代理。 JDK动态代理可以代理接口，不能代理没有实现接口的类；而CGLIB通过字节码技术可以动态生成被代理类的子类，从而可以代理没有实现接口的类；但是不能代理非public和final的方法，因为子类不可见。 Spring框架中使用DefaultAopProxyFactory来确定使用CGLIB或者JDK的动态代理 一般满足以下条件之一 就会进行CGLIB动态代理： optimize标志位被设定 proxyTargetCl
Spring 四天学习笔记 _day2
Hack_ZZQ
03-30 312
1. 注解配置Spring   1.1注解代替配置文件：步骤          1.为配置文件配置新的命名空间           2.开启使用注解代替配置文件           3. 在类中使用注解 完成配置（如果是新版本的spring 框架需要加上一个spring-aop-4.2.4.RELEASE.jar）               4. 因为在项目开发中 ，需要明确的分明注解所在的位置...
springboot学习笔记day13.xmind
04-21
springboot学习笔记day13.xmind
Spring—学习笔记#day04
安藤青司的博客
08-06 632
目录 1、spring中的JdbcTemplate[会用] JdbcTemplate的作用 JdbcTemplate对象的创建 spring中配置数据源 在spring配置文件中配置 JdbcTemplate 最基本使用 使用xml文件 保存、更新、删除、查询操作 在dao中使用 JdbcTemplate 第二种方式：让dao继承 JdbcDaoSupport 2、Spr...
springboot学习笔记day12.xmind
03-30
springboot学习笔记day12.xmind
使用CGLIB enhancer实现类的增强
Evan's Blog ٩(๑❛ᴗ❛๑)۶
10-31 1366
今天在读spring源码的时候，比较深入如的研究了一下@Configuration注解。发现@Configurtion注解的类，实际实现了CGLIB动态代理，这个后续会写一篇博客专门说明。这里简单的记录下CGLIB动态代理的使用。 一、使用CGLIB代理需要注意的问题 如果类是抽象类，只能调用已实现方法方法，如果调用抽象方法的时候会报java.lang.AbstractMethodErr...
spring小结一
欢迎关注免费星球ComfySpace：https://t.zsxq.com/19H0cfM1O
01-09 1202
一、概述     1. Spring是一个开源框架，其目的是为了解决企业应用开发的复杂性.     2. Spring功能：使用基本的JavaBean代替EJB，并提供更多的企业应用功能.     3. 简单说，Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架. 二、Spring的jar包和配置文件     1.Spring的jar包         （1）s
spring的AOP使用3
qq_35426012的博客
05-14 246
动态代理的第二种方式 使用CGLib的 Enhancer 类创建代理对象 创建maven,在pom.xml添加CGLib的依赖 <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.1_3</version> </dependency&g
[Spring]Cannot enhance @Configuration bean definition....
zsensei的博客
12-04 1万+
在 Spring 中使用基于 Java 的配置时，配置 Mybatis 的 mapperScannerConfigurer 如@Bean MapperScannerConfigurer mapperScannerConfigurer() { MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigure
spring aop类内部调用不拦截原因及解决方案
夢の殇
06-08 1万+
spring对应java web开发的同学来说，都不陌生，其中事务@Transactional在service层更是常常使用。 1.aop类内部调用不拦截原因 细心的同学也许早就发现当service中的某个没标注@Transactional的方法调用另一个标注了@Transactional的方法时，居然没开启事务。例如 @Service public class UserService {
Spring—学习笔记#day02
俊墨客
12-20 133
目录 1、环境搭建 第一步：在基于注解的配置中，我们还要多拷贝一个 aop 的 jar 包 第二步：使用@Component  注解配置管理的资源 第三步：创建 spring的 xml  配置文件并开启对注解的支持 2、spring中ioc的常用注解 2.1用于创建对象的 2.1.1@Component 2.1.2@Controller @Service @Repository...
springboot学习笔记day11.xmind
03-11
springboot学习笔记day11.xmind
【python图像处理】图像的增强（ImageEnhance类详解）
热门推荐
guduruyu的专栏
05-03 5万+
python中PIL模块中有一个叫做ImageEnhance的类，该类专门用于图像的增强处理，不仅可以增强（或减弱）图像的亮度、对比度、色度，还可以用于增强图像的锐度。
Spring boot(20) Spring /Spring boot使用AOP、强制使用cglib（以记录方法耗时为例子）
kkgbn的博客
08-08 1万+
1. Spring boot1.1 Spring boot默认使用了AOP和动态代理RPC，AOP都会用到代理，代理的技术有jdk的Proxy代理(必须传入接口)，cglib(可以是类而非接口, spring)，Javassist(jboss )而Spring boot本身也在方方面面使用了代理技术。 我们看下Spring boot的依赖 <dependency>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值