AOP-简介，专业术语，简单配置，使用场景

最新推荐文章于 2023-08-20 20:41:18 发布
最新推荐文章于 2023-08-20 20:41:18 发布
阅读量211 收藏
点赞数
分类专栏： # Spring-AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shen_R/article/details/105202690
版权

part1-简介：

  • AOP(Aspect Oriented Programming):面向切面编程
  • OOP(Object Oriented Programming):面向对象编程
  • Aspect:方面
  • Orinted:面向，面对
  • 面向切面编程：基于OOP基础上新的编程思想；
    指在程序运行期间，将某段代码动态的切入到指定方法的指定位置进行运行的这种编程方式，面向切面编程

@AOP场景：

例：计算器运行计算方法的时候进行日志记录：
  • 加日志记录：
    1. 直接编写在方法内部，不推荐，修改维护麻烦。
    2. 日志记录：系统的辅助功能；业务逻辑查看（核心功能）；耦合；
    3. 我们希望的是：
      • 业务逻辑：(核心功能)；日志模块；在核心功能运行期间，自己动态的加上。
      • 运行的时候，日志功能可以加上。

1.动态代理：

  • 代理对象：就像对象的替身，用代理对象去执行实际方法。
  • 例：(我们是想去记录日志和业务逻辑的信息)
    //写一个接口
package com.atguigu.inter;

public interface Calculator {

    public int add(int i, int j);
    public int sub(int i, int j);
    public int mul(int i, int j);
    public int div(int i, int j);
}

    //该接口的实现类
package com.atguigu.impl;

import com.atguigu.inter.Calculator;

public class MyMathCalculator implements Calculator {

    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

    //测试
import com.atguigu.impl.MyMathCalculator;
import com.atguigu.inter.Calculator;
import com.atguigu.proxy.CalculatorProxy;
import org.junit.Test;

public class AOPTest {

    @Test
    public void test(){
//        Calculator calculator = new MyMathCalculator();
//        calculator.add(1, 2);

        //如果拿到了这个对象的代理对象，代理对象来执行方法。
        Calculator calculator = new MyMathCalculator();
        Calculator proxy = CalculatorProxy.getProxy(calculator);
        int result = proxy.add(2, 1);
        System.out.println(result);
    }

}

    //第一种：写一个日志工具类，在方法执行前后执行，不可取
package com.atguigu.utils;

public class LogUtils {

    public void logStart(Object... objects){
        System.out.println("【xxx】方法开始了，它使用的参数是["+ objects +"]");
    }
}

    //动态代理的方法
package com.atguigu.proxy;

import com.atguigu.inter.Calculator;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 帮Calculator生成代理对象的类。
 * 对象方法是：Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
 * Calculator calculator:传入的是被代理对象
 */
public class CalculatorProxy {

    //拿到代理对象的方法,为传入的对象生成一个代理对象
    public static Calculator getProxy(final Calculator calculator){
        //被代理对象的类加载器
        ClassLoader loader = calculator.getClass().getClassLoader();
        //被代理对象所实现的接口
        Class<?>[] interfaces = calculator.getClass().getInterfaces();
        //目标方法执行器，帮我们目标对象执行目标方法
        InvocationHandler h = new InvocationHandler() {
            /**
             *
             * @param o:这是代理对象，这是给jdk使用的，任何时候都不要动这个对象
             * @param method：当前将要执行的目标对象的方法
             * @param objects：这个方法调用时，外界传入的参数值
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                System.out.println("这是动态代理将要执行该方法！！！");

                //利用反射执行目标方法,result是目标方法执行后的返回值
                Object result = method.invoke(calculator, objects);
                return result;
            }
        };

        //Proxy为目标对象创建代理对象
        Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
        return (Calculator) proxy;
    }
}

2.动态代理加日志总结：

  • 例：日志的工具类，加上动态代理
    //工具类
package com.atguigu.utils;

import java.lang.reflect.Method;
import java.util.Arrays;

public class LogUtils {

    //日志记录
    public static void logStart(Method method, Object[] objects){
        System.out.println("[" + method.getName() + "]" + "方法开始执行了，用的参数列表是：[" + Arrays.asList(objects) + "]");
    }

    public static void logReturn(Method method, Object[] objects){
        System.out.println("[" + method.getName() + "]" + "方法正常执行完成了。");
    }

    public static void logException(Method method, Exception e){
        System.out.println("[" + method.getName() + "]" + "出现了异常，异常原因是：" + e.getCause());
    }

    public static void logEnd(Method method){
        System.out.println("[" + method.getName() + "]" + "方法执行结束了。");
    }

}

    //代理类的改进
package com.atguigu.proxy;

import com.atguigu.inter.Calculator;
import com.atguigu.utils.LogUtils;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * 帮Calculator生成代理对象的类。
 * 对象方法是：Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
 * Calculator calculator:传入的是被代理对象
 */
public class CalculatorProxy {

    //拿到代理对象的方法,为传入的对象生成一个代理对象
    public static Calculator getProxy(final Calculator calculator){
        //被代理对象的类加载器
        ClassLoader loader = calculator.getClass().getClassLoader();
        //被代理对象所实现的接口
        Class<?>[] interfaces = calculator.getClass().getInterfaces();
        //目标方法执行器，帮我们目标对象执行目标方法
        InvocationHandler h = new InvocationHandler() {
            /**
             *
             * @param o:这是代理对象，这是给jdk使用的，任何时候都不要动这个对象
             * @param method：当前将要执行的目标对象的方法
             * @param objects：这个方法调用时，外界传入的参数值
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                System.out.println("这是动态代理将要执行该方法！！！");

                //利用反射执行目标方法,result是目标方法执行后的返回值
                Object result = null;
                try {
//                    System.out.println("[" + method.getName() + "]" + "方法开始执行了，用的参数列表是：[" + Arrays.asList(objects) + "]");
                    LogUtils.logStart(method, objects);
                    result = method.invoke(calculator, objects);
//                    System.out.println("[" + method.getName() + "]" + "方法正常执行完成了。");
                    LogUtils.logReturn(method, objects);
                } catch (Exception e) {
//                    System.out.println("[" + method.getName() + "]" + "方法出现异常，异常原因是" + e.getCause());
                    LogUtils.logException(method, e);
                } finally {
//                    System.out.println("[" + method.getName() + "]" + "方法执行结束了。");
                    LogUtils.logEnd(method);
                }

                return result;
            }
        };

        //Proxy为目标对象创建代理对象
        Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
        return (Calculator) proxy;
    }
}
  • 动态代理也是有缺陷的：
    • jdk默认的动态代理，如果目标对象没有实现任何接口，是无法为目标对象创建任何代理对象的。
    • 代理对象和被代理对象唯一能产生的关联，就是实现了同一接口。
    • 动态代理已经可以看成是切面编程了。
    • 但是Spring实现以上的动态代理难，所以Spring出现了AOP功能，AOP底层就是动态代理，可以利用Spring一句代码都不写，就可以创建动态代理。
    • AOP实现简单，没有强制要求目标对象必须实现接口。

3.AOP简单总结：

  • 指在程序运行期间，将某段代码（日志）动态的切入到指定方法（加减乘除）的指定位置（方法开始之前或者方法开始之后）进行运行的这种编程方式，称为面向切面编程。（Spring可以简化面向切面编程）

part2-专业术语：

  • 横切关注点：
  • 通知方法：（就像日志工具类LogUtils里面的LogStart、LogReturn等等方法）
  • 切面类：（就像日志工具类LogUtils）
  • 连接点：每一个方法的每一个位置就是一个连接点。
  • 切入点：红色部分，我们真正需要执行日志记录的地方。
  • 图见：
    在这里插入图片描述

part3-简单配置：

1、AOP加日志保存到数据库中；
2、AOP做权限验证；
3、AOP还可以做安全检查；
4、AOP做事务控制；

part4-使用场景：

1、导包：

  • 注意除了基础包，spring支持面向切面编程的包也需要。
  • 注意：除了基础的面向切面编程的aspect包，还有加强版的包（3个），加强版的包的意思是即 使目标对象没有实现任何接口也能创建动态代理。

2、写配置：

  1. 将目标类（例：MyMathCalculator类）和切面类（封装了通知方法（在目标方法执行前后执行的方法）的类，例：LogUtils类）加入到IOC容器中。
  2. 还应该告诉Spring那个是切面类。@Aspect.
  3. 告诉Spring这些方法何时何地运行就额可以了。
package com.atguigu.utils;

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

import java.lang.reflect.Method;
import java.util.Arrays;

@Component
@Aspect
public class LogUtils {

    //日志记录

    /**
     * 告诉spring每个方法都什么时候运行这些方法。
     * @Before:在目标方法之前运行；前置通知。
     * @After:在目标方法运行结束之后执行；后置通知。
     * @AfterReturning:在目标方法正常返回之后；返回通知。
     * @AfterThrowing:在目标方法抛出异常之后运行；异常通知；
     * @Around:环绕；环绕通知。
     *
     * 例：
     * try{
     * @Before
     * method.invoke(obj, args);
     * @AfterReturning
     * }catch(e){
     * @AfterThrowing
     * }finally{
     *@After
     * }
     */

    //第一个方法：想在执行目标方法之前运行,写切入点表达式
    //execution(访问权限符 返回值类型 方法签名)
    @Before("execution(public int com.atguigu.impl.MyMathCalculator.*(int, int))")
    public static void logStart(){
        System.out.println("[]" + "方法开始执行了，用的参数列表是：[]");
    }

    //想在目标方法正常执行完成之后执行
    @AfterReturning("execution(public int com.atguigu.impl.MyMathCalculator.*(int, int))")
    public static void logReturn(){
        System.out.println("[]" + "方法正常执行完成了。");
    }

    //想在目标方法异常时执行
    @AfterThrowing("execution(public int com.atguigu.impl.MyMathCalculator.*(int, int))")
    public static void logException(){
        System.out.println("[" + "出现了异常，异常原因是：" );
    }

    //想在目标方法执行完成之后执行
    @After("execution(public int com.atguigu.impl.MyMathCalculator.*(int, int))")
    public static void logEnd(){
        System.out.println("]" + "方法执行结束了。");
    }

}
  1. 开启基于注解的AOP功能。注意：头名称空间的配置信息，不要少了。
 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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
  • 完成的头名称空间代码如下：
<?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:context="http://www.springframework.org/schema/context"
       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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.atguigu"></context:component-scan>

    <!--开启基于注解的aop功能，aop名称空间-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

3、测试：

import com.atguigu.impl.MyMathCalculator;
import com.atguigu.inter.Calculator;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPTest {

    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");

    @Test
    public void test(){
        //1.从ioc容器中拿到目标对象
        //注意：如果想要用类型获取，一定要用接口类型，不要用它的本类
        Calculator bean = ioc.getBean(Calculator.class);
        bean.add(2, 1);
    }
}
Shen_R
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
AOP的实现原理及应用场景
YANXS1的博客
07-08 4074
AOP的作用 在不修改源代码的情况下，可以实现功能的增强。 AOP横向抽取思想：基于代理思想，对原来目标对象，创建代理对象，在不修改原对象代码情况下，通过代理对象，调用增强功能的代码，从而对原有业务方法进行增强 ！ AOP应用场景 场景一：记录日志 场景二：监控方法运行时间 （监控性能） 场景三：权限控制 场景四：缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ） 场景五：事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ） AOP的
AOP应用场景
thebigdipperbdx的博客
12-31 2245
AOP应用场景 场景一： 记录日志 场景二： 监控方法运行时间 （监控性能） 场景三： 权限控制 场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ） 场景五： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ，如声明式事务） AOP相关概念 Aspect 切面 通常指@Aspect标识的类 Join poi...
Spring的AOP的主要作用和具体应用场景
qq_46130027的博客
07-21 568
总的来说，AOP在Spring中的应用，能够带来更好的代码结构、更高的代码复用性和更方便的维护方式，使开发人员能够更专注于业务逻辑，而将横切关注点抽象出来交给AOP来管理。
Spring AOP在项目中的典型应用场景
江南一点雨的专栏
12-08 5568
学过 Spring 的小伙伴相信都知道 AOP，AOP 学的好的小伙伴相信对 AOP 的概念也是轻车熟路：面向切面编程、切点、切面、通知，Aspect、Pointcut、Advice 等如数家珍。AOP 之所以这么重要，是因为它在项目中有着非常广泛的应用，今天这篇文章，松哥就来和大家总结一下，我们在日常开发中，都有哪些典型场景需要用到 AOP。先来一句话总结下，AOP 的使用，基本上都会涉及到自定义注解，一个非常常见的组合，就是自定义注解+AOP。
AOP在Java应用程序中的六个常见场景
ggjklncffd的博客
04-01 2772
首先需要定义一个注解，用于标记哪些方法需要进行权限控制。例如，可以定义一个名为@RequiresPermissions的注解，用于标记需要进行权限控制的方法。定义一个自定义注解，用于标识需要进行全局异常处理的方法定义一个切面类，使用@Around注解拦截带有注解的方法，并进行异常处理@Aspect@Componenttry {// 调用被拦截的方法// 构造错误响应// 打印错误日志// 返回错误响应// 获取请求路径。
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop-5.1.3.RELEASE-API文档-中英对照版.zip
07-07
赠送jar包：spring-aop-5.1.3.RELEASE.jar； 赠送原API文档：spring-aop-5.1.3.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.1.3.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.1.3.RELEASE.pom；...
spring-aop-5.0.4.RELEASE.jar
12-07
spring-aop-5.0.4.RELEASE.jar。
spring-aop-5.3.10-API文档-中文版.zip
06-04
赠送jar包：spring-aop-5.3.10.jar； 赠送原API文档：spring-aop-5.3.10-javadoc.jar； 赠送源代码：spring-aop-5.3.10-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.3.10.pom； 包含翻译后的API文档：spring...
关于AOP的介绍和使用
Tripmonster的博客
08-20 723
在运行时，AOP框架会自动生成代理对象，将切面逻辑织入到目标对象的方法中，实现对方法的增强和修改。性能监控：AOP可以用于实现性能监控功能，例如在方法调用前记录方法的开始时间，在方法调用后记录方法的结束时间，并计算方法的执行时间。例如，可以在方法调用前记录方法名和参数，以及在方法调用后记录方法的返回值。日志审计：AOP可以用于实现日志审计功能，例如在方法调用前记录用户的操作，包括操作的类型、时间和操作的对象等。具体来说，它通过AOP的方式，在这些方法执行前后添加额外的逻辑，实现对方法的拦截和处理。
aop的使用场景
qq_22169603的博客
05-20 5060
传统的OOP程序经常表现出一些不自然的现象，核心业务中总掺杂着一些不相关联的特殊业务，如日志记录，权限验证，事务控制，性能检测，错误信息检测等等，这些特殊业务可以说和核心业务没有根本上的关联而且核心业务也不关心。 这些特殊业务会带来哪些问题呢？ 1.代码混乱，大量的外围操作可能会混乱核心操作的代码，而且当外围模块有重大修改时也会影响到核心模块。 2.代码分散和冗余：同样的功能代码，在其他的模块几乎随处可见，导致代码分散并且冗余度高。 3.代码质量低扩展难：由于不太相关的业务代码混杂在一起，无法专注核心业务代
AOP的应用场景
u014432203的专栏
01-24 8993
1，AOP思想：基于代理的思想，对原来的对象，创建代理对象，在不修改原来对象代码的情况下，通过代理对象，修改功能代码，从而对原来业务代码进行调整。 2，AOP的使用场景：   I，记录日志。  II，监控性能。 III，权限控制。 IV，缓存优化。  V，事务管理。 3，Aop的实现方式：JDK动态代理和CGLIB动态代理   JDK动态代理针对于有接口实现的类：   publi...
AOP 的概念、名词解释、实现原理、常用场景
codeF4的博客
05-09 4556
AOP概念 1.aop:面向切面编程。是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。 2.在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里 Aop的好处 1.每个事物逻辑位于一个位置, 代码不分散...
Spring AOP 使用场景
weixin_34034261的博客
08-26 515
2019独角兽企业重金招聘Python工程师标准>>> ...
AOP 主要应用场景
青春年少不知疼的博客
12-20 2954
AOP 主要应用场景有： 1. Authentication 权限 2. Caching 缓存 3. Context passing 内容传递 4. Error handling 错误处理 5. Lazy loading 懒加载 6. Debugging 调试 7. logging, tracing, profiling and monitoring 记录跟踪 优化 校...
spring aop应用场景
詹Sir的博客
08-31 6734
场景一： 记录日志 场景二： 监控方法运行时间 （监控性能） 场景三： 权限控制 场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ） 场景五： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ） 提示：aop本质是动态对方法增强，避免代码入侵，优雅的实现横向扩展，是对oop的补充 ...
Spring之AOP系列--使用场景/原理
热门推荐
IT利刃出鞘的博客
10-11 1万+
本文介绍Spring AOP的使用场景、原理、配置、使用方式。
Spring AOP应用场景有哪些？Aop工作原理分析
日月桃子的专栏
07-08 7137
　Spring AOP应用场景有哪些？Aop工作原理分析，面向切面编程，是通过代理的方式为程序添加统一功能，集中解决一些公共问题。应用在Debugging 调试、logging, tracing, profiling and monitoring 记录跟踪优化校准场景中。 　　AOP为Aspect Oriented Programming面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 　　一、AOP应用场景： 　　AOP用来封装横切关注点，具体可以在下面的场
spring-aop-4.3.4jar包
最新发布
11-19
在使用spring-aop-4.3.4.jar包时，我们可以使用注解或XML配置来定义切面（Aspect）和通知（Advice），并将它们织入到目标对象中。切面定义了在何处、何时将通知应用到目标对象的条件，而通知定义了需要执行的逻辑。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值