Spring中得Aop相关概念及运用

Aop常用概念：

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
Joint point（连接点）：表示在程序中明确定义的点，包括方法调用，对类成员的访问以及异常处理程序块的执行等，它自身还可以嵌套其它 joint point。
**Pointcut（切点）：**表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
**Advice（增强）：**Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
Target（目标对象）：织入 Advice 的目标对象.。
Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程。

package aopanno;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1)
public class PersonDemo {
    
    
    @After(value="execution(* aopanno.User.add(..))")
    public void after(){
    
    
        System.out.println("我是Personafter先执行的哦................");
    }
}

package aopanno;

import org.springframework.stereotype.Component;

@Component
public class User {
    
    
    public void add(){
    
    
        System.out.println("add........");
    }
}

package aopanno;

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

//被增强的类
@Component
@Aspect
@Order(9)
//生成代理对象
public class UserProxd {
    
    
    //相同切入点抽取
    @Pointcut(value = "execution(* aopanno.User.add(..))")
    public  void pointcut(){
    
    

    }
    @Before(value="pointcut()")
    //@Before 表示add方法前置通知
    public void before(){
    
    
        //前置通知
        System.out.println("before....................");
    }
    @After(value="execution(* aopanno.User.add(..))")
    public void after(){
    
    
        System.out.println("after................");
    }
    //返回后通知
    @AfterReturning(value="execution(* aopanno.User.add(..))")
    public void afterreturning(){
    
    
        System.out.println("afterreturning................");
    }
    //异常通知
    @AfterThrowing(value="execution(* aopanno.User.add(..))")
    public void afterthrowing(){
    
    
        int i=9/7;
        System.out.println("afterthrowing................");
    }
    @Around(value="execution(* aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
    
    
        System.out.println("around前");
        //被增强得方法执行
        proceedingJoinPoint.proceed();
        System.out.println("around后");

    }
}

测试类

package aopanno.Test;

import aopanno.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    
    
    @Test
    public static void main(String[] args) {
    
    
        ApplicationContext  context=new ClassPathXmlApplicationContext("Bean1.xml");
        User user = context.getBean("user",User.class);
        user.add();
    }
}

<?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:p="http://www.springframework.org/schema/p"
       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="aopanno"></context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

创作不容易哦，听说帅哥美女都会在下方点赞关注的哦！