Three ways to implement AOP using Spring

1. What is AOP?

AOP (Aspect Oriented Programming) means: a technology for aspect-oriented programming, which realizes the unified maintenance of program functions through pre-compilation and dynamic agents during runtime. AOP is a continuation of OOP, a hot spot in software development, and an important content in the Spring framework. It is a derivative generic of functional programming. Using AOP can isolate various parts of business logic, thereby making business logic The degree of coupling between the various parts is reduced, improving the reusability of the program, while increasing the frequency of development.

Explanation of terms in AOP:

• Cross-cutting concerns: methods or functions that span multiple modules of an application. That is, it has nothing to do with our business logic, but the part we need to focus on is cross-cutting concerns, such as logging, security, caching, transactions, etc ...
• ASPECT: A special object whose cross-cutting concerns are modularized, that is, a class.
• Notification (Advice): The work that must be done by the aspect, that is, a method in the class.
• Target: The notified object.
• Proxy: An object created after applying a notification to a target object.
• Pointcut (PointCut): the definition of the "place" where the aspect notification is executed.
• Connection point (jointPoint): the execution point that matches the entry point.
  
  AOP adds new functions without changing the original code.

Using Spring to implement AOP

Imported dependencies

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.10</version>
	</dependency>

method one

Use Spring's API interface [main SpringAPI interface implementation]
1. UserService

public interface UserService{
    void add();
    void delete();
    void update();
    void select();
}

2.UserServiceImpl

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }
    public void delete() {
        System.out.println("删除了一个用户");
    }
    public void update() {
        System.out.println("修改了一个用户");
    }
    public void select() {
        System.out.println("查询了一个用户");
    }
}

3.BeforeLog

public class BeforeLog implements MethodBeforeAdvice {
    //method:要执 行的目标对象的方法
    //args:多数
    //target:目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
}

4.AfterLog

public class AfterLog implements AfterReturningAdvice {
    //returnValue;返问值
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法。返回结果为" + returnValue);
    }
}

5.applicationContext.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
        https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="com.tt.service.UserServiceImpl"/>
    <bean id="beforeLog" class="com.tt.log.BeforeLog"/>
    <bean id="afterLog" class="com.tt.log.AfterLog"/>
    <!--方式一 :使用原生Spring API接口1-->
    <!--配置aop:需要导入aop的约束-->
    <aop:config>
        <!--切入点: expression: 表达式，execution( 要执行的位置! * ****)-->
        <!--execution(修饰符，哪个类，哪个方法（方法后参数不限）)-->
        <aop:pointcut id="pointcut" expression="execution(* com.tt.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加! -->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>

    </aop:config>

</beans>

6.MyTest

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口:注意点
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

Method two

Customize to achieve AOP [mainly the definition of the aspect]
1.DiyPointCut

public class DiyPointCut {
    public void before() {
        System.out.println("=======方法执行前=======");
    }
    public void after() {
        System.out.println("=======方法执行后=======");
    }

}

2.applicationContext.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
        https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="com.tt.service.UserServiceImpl"/>
   
        <!--方式二:自定义类-->
        <bean id="diy" class="com.tt.diy.DiyPointCut"/>
        <aop:config>
            <!--自定义切面，ref 要引用的类-->
            <aop:aspect ref="diy">
                <!--切入点-->
                <aop:pointcut id="point" expression=" execution(* com.tt.service.UserServiceImpl.*(..))"/>
                <!--.通知-->
                <aop:before method="before" pointcut-ref="point"/>
                <aop:after method="after" pointcut-ref="point"/>
            </aop:aspect>

        </aop:config>

</beans>

3.MyTest

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口:注意点
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

Way three

1.AnnotationPointCut

//方式三:使用注解方式实现AOP
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.lenovo.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("====方法执行前=====");
    }

    @After("execution(* com.lenovo.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("====方法执行后=====");
    }
    
    
    
    //在环绕增强中，我们可以给定一一个参数。代表我们要获取处理切入的点:
    @Around("execution(* com.tt.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //Signature signature = jp.getSignature();//获得签名
        //System.out.println("signature:" + signature);
        Object proceed = jp.proceed(); //执行方法
        System.out.println("环绕后");
       //System.out.println(proceed);
    }
}

2.applicationContext.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
        https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--注册bean-->
    <bean id="userService" class="com.tt.service.UserServiceImpl"/>
    <!--方式三-->
    <bean id=" annotationPointCut" class="com.tt.diy.AnnotationPointCut"/>
    <!--开启注解支持! -->
    <aop:aspectj-autoproxy/>
</beans>

3.MyTest

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口:注意点
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}