一、什么是AOP

面向切面编程,利用AOP可以对业务逻辑各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率
通俗的来说:就是不通过修改源代码的方式,在主干功能里面添加新功能。

二、AOP底层原理(使用动态代理)

 /**
 *
 *  AOP底层原理 
 * @author Herz
 * @date 2021/4/9 17:49
 */

public class JDKProxy {
    public static void main(String[] args) {

        Class[] interfaces = {UserDao.class};

        UserDao userdao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(new UserDaoImpl()));

        System.out.println(userdao.sum(1, 2));

        userdao.update("张三");
    }
}


@SuppressWarnings("all")
//创建代理对象代码
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("方法"+ method.getName() +"执行后");

        return res;
    }
}

public interface UserDao {
    
        public int sum(int a, int b);
    
        public String update(String name);
    
    }
    
    /**
     *
     * 被增强的类
     *
     * @author Herz
     * @date 2021/4/9 17:48
     */
    public class UserDaoImpl implements UserDao {
        @Override
        public int sum(int a, int b) {
            System.out.println("sum()方法执行了。。。");
            return a + b;
        }
    
        @Override
        public String update(String name) {
            System.out.println("update()方法执行了。。。。");
            return name;
        }
    }

1)有接口情况,使用 JDK 动态代理。

创建接口实现类的代理对象,增强类的方法

2)没有接口情况,使用CGLIB 动态代理

创建当前类子类的代理对象,增强类的方法

三、AOP操作术语

1)连接点:所有可以被增强的方法,都称为连接点。
2)切入点:实际被增强的方法,成为切入点
3)通知(增强):实际增加的增强逻辑部分被成为通知(增强)。
通知(增强)种类:前置通知、后置通知、环绕通知、异常通知、最终通知
4)切面:把通知应用到切入点的过程

四、AOP操作

1)Spring框架一般都是基于AspectJ实现AOP操作

AspectJ 不是 Spring的组成部分,独立的AOP框架。一般把Spring和AspectJ框架一起使用,进行AOP操作。

2)基于AspectJ实现AOP操作

(1)基于xml配置文件实现
(2)基于注解方式实现

3)切入点表达式:

作用:知道对哪个或哪些类的哪个或哪些方法进行增强。
语法结构: execution( 权限修饰符 返回值类型 类的全路径.方法名(参数列表) )

例1:对com.tianfei.UserDao类中add()方法进行增强:
execution(* com.tianfei.UserDao.add(..))

例2:对com.tianfei.UserDao类中所有方法进行增强
execution( com.tianfei.UserDao.(..))

例3:对com.tianfei包中所有类中所有方法进行增强
execution( com.tianfei..*(..))

五、AOP操作基于AspectJ注解实现AOP操作

1、创建被增强类User,在类中定义方法

//被增强的类
@Component //创建该类对象
public class User {

    public void add() {
        int i = 10 / 0;

        System.out.println("add.................");
    }
}

2、创建增强类1:UserProxy和增强类2:PersonProxy(编写增强逻辑)

/**
 *
 *
 * 增强类 1:
 *
 *
 * @author Herz
 * @date 2021/4/12 10:18
 */
@SuppressWarnings("all")

@Component  //创建该类对象
@Aspect    //创建代理对象
@Order(3)
public class UserProxy {

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

    }


    //前置通知
    @Before(value = "pointCommon()")
    public void before(){
        System.out.println("before................");
    }

    //后置通知(返回通知):在出现异常后不执行
    @AfterReturning(value = "execution(* com.tianfei.aopanno.User.add(..))")
    public void afetReturning(){
        System.out.println("afetReturning................");
    }

    //最终通知:任何时候都会执行
    @After(value = "execution(* com.tianfei.aopanno.User.add(..))")
    public void after(){
        System.out.println("after................");
    }

    //异常通知:只有在被增强的方法出现异常时执行
    @AfterThrowing(value = "execution(* com.tianfei.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing................");
    }


    //环绕通知:被增强的方法出现异常时,只执行环绕之前的代码
    @Around(value = "execution(* com.tianfei.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前................");

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

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


/**
 *
 * 增强类 2
 *
 *
 *
 * @author Herz
 * @date 2021/4/12 15:56
 */
@Component  //创建对象
@Aspect     //创建代理对象
@Order(1)   //数字值越小优先级越高
public class PersonProxy {

    @Before(value = "execution(* com.tianfei.aopanno.User.add(..))")
    public void personBerfore(){
        System.out.println("Person...Before...........");
    }
}

3、进行通知的配置

(1)在Spring配置文件中,开启注解扫描

<!--开启注解扫描组件-->
<context:component-scan base-package="com.tianfei.aopanno"></context:component-scan>

(2)使用注解创建 被增强类User 和 增强类 UserProxy 对象
(3)在增强类上面添加注解 @Aspect
(4)在 spring 配置文件中开启生成代理对象

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

补充:也可以使用完全注解方式(可省略步骤1和4)

创建一个类作为配置类:

/**
 *
 * 完全注解方式
 *      创建一个配置类
 *
 * @author Herz
 * @date 2021/4/12 16:29
 */
@Configuration   //作为配置类
@ComponentScan(value = {"com.tianfei.aopanno"})   //开启扫描组件
@EnableAspectJAutoProxy(proxyTargetClass = true)  //开启 AspectJ 生成代理对象
public class UserConfig {
}

测试:

p

ublic class testaop {
    //AspectJ基于注解实现AOP操作  测试
    @Test
    public void testAnno(){
//        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //完全注解
        ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);

        User user = context.getBean("user", User.class);
        user.add();
    }
}

六、AOP操作基于AspectJ XML配置实现AOP操作

1、创建被增强类Book,在类中定义方法

/**
 *
 * 被增强类
 *
 * @author Herz
 * @date 2021/4/12 16:11
 */
public class Book {

    public void add(){
        System.out.println("Book.....add.......");
    }
}

2、创建增强类BookProxy(编写增强逻辑)

/**
 *
 * 增强类
 *
 * @author Herz
 * @date 2021/4/12 16:12
 */
public class BookProxy {

    public void before(){
        System.out.println("Book....before.......");
    }
}

3、进行通知的配置

(1)在Spring配置文件中配置创建 被增强类Book 和 增强类 BookProxy 对象
(2)在 spring 配置文件中配置aop增强

<!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.tianfei.aopxml.Book.add(..))"></aop:pointcut>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>

测试:

public class testaop {

    //AspectJ基于xml配置文件实现AOP操作  测试
    @Test
    public void testXml(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

        Book book = context.getBean("book", Book.class);
        book.add();
    }
}