Spring——AOP实现的三种方式

1. 通过Spring接口来实现
2. 自定义类实现
3. 使用注解实现
源码：Gihub Gitee码云
实现AOP织入前需导入依赖包

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

applicationContext.xml需引入AOP约束

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"

UserService接口

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

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 selete() {
        System.out.println("查找用户");
    }
}

一，通过Spring接口实现AOP
编写增强类
前增强

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class BeforeLog implements MethodBeforeAdvice {
//    method要执行的目标对象的方法
//    args参数
//    target目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

后增强

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
//    returnValue返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"返回结果为"+returnValue);
    }
}

aop切入实现

    <!--注册bean-->
    <bean id="userService" class="com.yyx.service.UserServiceImpl"/>
    <bean id="beforeLog" class="com.yyx.log.BeforeLog"/>
    <bean id="afterLog" class="com.yyx.log.AfterLog"/>
        <!--aop的配置-->
    <aop:config>
        <!--切入点 expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.yyx.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

二，自定义类实现
自己定义一个切入类

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

使用AOP的标签实现切入

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="MyPointcut" class="com.yyx.config.MyPointcut"/>
<!--aop的配置-->
<aop:config>
   <!--第二种方式：使用AOP的标签实现-->
   <aop:aspect ref="MyPointcut">
       <aop:pointcut id="myPointcut" expression="execution(* com.yyx.service.UserServiceImpl.*(..))"/>
       <aop:before pointcut-ref="myPointcut" method="before"/>
       <aop:after pointcut-ref="myPointcut" method="after"/>
   </aop:aspect>
</aop:config>

三，使用注解实现
编写注解实现的增强类

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect//标注这个类是一个切面类
public class AnnotationPointCut {
    @Before("execution(* com.yyx.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("=====方法执行前====");
    }
    @After("execution(* com.yyx.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("====方法执行后====");
    }
    //在环绕时我们给定一个参数，代表我们要获取的切入点
    @Around("execution(* com.yyx.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("-环绕前-");
        proceedingJoinPoint.proceed();//执行方法
        System.out.println("-环绕后-");
    }
}

在Spring配置文件中，注册bean，并增加支持注解的配置

    <bean id="annotationPointCut" class="com.yyx.config.AnnotationPointCut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>