目录

简单介绍

举例子说明

底层原理

实际开发

一般基于注解方式使用

简单介绍

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，可以理解为一个类中函数之间存在切面，我可以在在这个切面中加入一些功能，使得整个类原有的功能得到增强，同时不改动原先的代码。AOP可以说是对OOP的补充和完善。

oop一般指面向对象程序设计—>(Object Oriented Programming)

举例子说明

或者是 日志、监控等功能都可以采用AOP这种侵入性很小的方式加入。

底层原理

aop的底层原理是动态代理。

代理模式详解：

设计模式之代理模式_trigger333的博客-CSDN博客

package com.atguigu.spring5;

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

public class JDKProxy { //代理类，就是他增强了原先userDao 的add 和 update功能
    public static void main(String[] args) {

        UserDao userDao = new UserDaoImpl();//创建原先的类的实例，new UserDaoProxy(userDao)实现功能增强，再得到增强后的实例proxyInstance 

        Class[] interfaces = {UserDao.class};
        UserDao proxyInstance = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add = proxyInstance.add(1, 2);
        System.out.println(add);
        System.out.println("-------------------------");
        System.out.println(proxyInstance.update("kiki"));

    }


}
class UserDaoProxy implements InvocationHandler{

    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法之前执行...."+"    "+method.getName()+" :传递的参数..."+ Arrays.toString(args));


        Object res = method.invoke(obj, args);
        //方法之后
        System.out.println("方法之后执行...."+obj+"  ");
        return res;

    }
}

package com.atguigu.spring5;

public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了.....");
        return a+b;
    }

    @Override
    public String update(String id) {
        System.out.println("update方法执行了.....");
        return id;
    }
}

方法之前执行….    add :传递的参数…[1, 2]
add方法执行了…..
方法之后执行….com.atguigu.spring5.UserDaoImpl@2b193f2d  
3
————————-
方法之前执行….    update :传递的参数…[kiki]
update方法执行了…..
方法之后执行….com.atguigu.spring5.UserDaoImpl@2b193f2d  
kiki 

实际开发

实际开发时直接用现有的框架来做。

一般基于注解方式使用

首先引入相关的依赖，再配置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: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.spring5.aopanno"></context:component-scan>

    <!-- 开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

package com.atguigu.spring5.aopanno;

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

//增强的类
@Component
@Aspect  //生成代理对象
@Order(3)  //如果有多个代理都对同一个函数进行增强，那么顺序可以通过注解@order来标识 
public class UserProxy {

    //相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo() {

    }

    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "pointdemo()")
    public void before() {
        System.out.println("before.........");
    }

    //后置通知（返回通知） 有异常不执行
    @AfterReturning(value = "pointdemo()")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知 不管有没有异常都会执行
    @After(value = "pointdemo()")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知
    @AfterThrowing(value = "pointdemo()")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //环绕通知
    @Around(value = "pointdemo()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前.........");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后.........");
    }
}

资料来源：B站尚硅谷