AOP的实现

1.Aop在Spring中的作用

  提供声明式事务；允许用户自定义切面

 

 SpringAOP中，通过Advice定义横切逻辑，Spring中支持五种Advice也就是五种方法

 

 即AOP在不改变源码的情况下，增加新代码。

2.使用Spring实现AOP

【重点】 使用AOP织入包，需要导入一个依赖包

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

2.1使用原生Spring API接口实现

UserService接口

public interface UserService {
    void Add();
    void Del();
    void Select();
    void Update();
}

UserServiceImpl实现类

public class UserServiceImpl implements UserService{
    public void Add() {
        System.out.println("这是一个Add方法");
    }

    public void Del() {
        System.out.println("这是一个Del方法");
    }

    public void Select() {
        System.out.println("这是一个Select方法");
    }

    public void Update() {
        System.out.println("这是一个Update方法");
    }
}

使用前置切入

public class log implements MethodBeforeAdvice {
    //method：要执行的目标对象的方法
    //args：参数
    //target:目标对象
    public void before(Method method, Object[] args, Object target) throws Throwable {
        //执行方法之前会执行该方法。从而达到不该代码增加新代码
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被执行了");


    }
}

后置返回切入

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);
    }
}

使用IOC容器配置AOP

注意使用AOP首先要导入AOP约束！！

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--    注册bean-->
    <bean id="UserServiceImpl" class="com.jia.service.UserServiceImpl"></bean>
    <bean id="log" class="com.jia.log.log"></bean>
    <bean id="AfterLog" class="com.jia.log.AfterLog"></bean>

<!-- 方式一：使用原生Spring API接口-->
<!--    配置aop:需要导入AOP的约束-->
    <aop:config>
<!--        1.配置切入点: expression表达式 execution(要执行的位置 * * * * *)第一个星号代表需要返回的类型-->
        <aop:pointcut id="pointcut" expression="execution(* com.jia.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加 将log类切入到pointcut中 -->

        <aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor>
        <aop:advisor advice-ref="AfterLog" pointcut-ref="pointcut"></aop:advisor>


    </aop:config>

</beans>

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是接口
        UserService userservice = Context.getBean("UserServiceImpl", UserService.class);
        userservice.Add();
    }
}

2.2使用自定义切入点类

自定义一个diyPointCut类

public class diyPointCut {
    //定义两种方法
    public void before(){
        System.out.println("====方法执行之前=====");

    }
    public void after(){
        System.out.println("====方法执行执行之后=====");
    }
}

 UserService接口

public interface UserService {
    void Add();
    void Del();
    void Select();
    void Update();
}

UserServiceImpl实现类

public class UserServiceImpl implements UserService{
    public void Add() {
        System.out.println("这是一个Add方法");
    }

    public void Del() {
        System.out.println("这是一个Del方法");
    }

    public void Select() {
        System.out.println("这是一个Select方法");
    }

    public void Update() {
        System.out.println("这是一个Update方法");
    }
}

配置xml 

<!--    第一步配置一个bean-->
    <bean id="diy" class="com.jia.diy.diyPointCut"></bean>
    <aop:config>
<!--        切面引用自己定义类的位置-->
        <aop:aspect ref="diy" >
<!--            切入点-->
            <aop:pointcut id="point" expression="execution(* com.jia.service.UserServiceImpl.*(..))"/>

<!--           通知，也就是方法 method是根据应用的位置找到该方法的-->
            <aop:before method="before" pointcut-ref="point"></aop:before>
            <aop:after method="after" pointcut-ref="point"></aop:after>
        </aop:aspect>
    </aop:config>

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext Context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是接口
        UserService userservice = Context.getBean("UserServiceImpl", UserService.class);
        userservice.Select();
    }
}

2.3使用注解实现AOP

使用注解实现AOP必须先导入注解支持【重点】         

       它一共支持两种：第一种是接口的支持 JDK(默认 proxy-target-class="false")

                                    第二种是类的支持 cglib(proxy-target-class="true") 

        这两种方法执行都是一样的

 <aop:aspectj-autoproxy/>

使用注解完成AnnotationPointCut类

//使用注解来代替自定义类
@Aspect  //切入点的引用
public class AnnotationPointCut {
    //切入到哪里
    @Before("execution(* com.jia.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("----方法前----");
    }
    @After("execution(* com.jia.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("----方法后----");
    }

  @Around("execution(* com.jia.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");  //它会比方法前执行的早
        jp.getSignature(); // 获得签名 就是获得执行方法的名字
        Object proceed = jp.proceed(); // 执行方法 相当于过滤操作

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