Spring-AOP

Spring Aop

Aop：面向切面编程，这个种编程的底层实现是代理模式，它允许用户自定义切面，其实就是再不改变原来代码的情况下，去增加功能。

有三种方式来实现Aop：第一种使用Spring的API来实现；第二种自定义类来实现；第三种通过注解来实现

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice

这里主要是在常用编程的增、删、改、查中添加日志来实现AOP

Aop的依赖

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

还需要去配置xml文件

---

方式一：使用Spring的API实现

XML文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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="userService" class="com.zkw.service.UserServiceImpl"/>
    <bean id="beforeLog" class="com.zkw.log.BeforeLog"/>
    <bean id="afterLog" class="com.zkw.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置Aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.zkw.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

1、execution(): 表达式主体 (必须加上execution)。

2、第一个*号：表示返回值类型，*号表示所有的类型。

3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.zkw.service.*(…)包、子孙包下所有类的方法。

4、第二个*号：表示类名，*号表示所有的类。

5、*(…):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。

书写的注意事项：execution(* com.zkw.service.*(…).*.*(…))

业务接口

package com.zkw.service;

public interface UserService {
    public void add();
    public void del();
    public void modify();
    public void select();
}

业务接口实现

package com.zkw.service;

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }

    public void del() {
        System.out.println("删除了一个用户");
    }

    public void modify() {
        System.out.println("修改了一个用户");
    }

    public void select() {
        System.out.println("查询了一个用户");
    }
}

日志类（前置日志、后置日志）

package com.zkw.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class BeforeLog implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"使用了"+method.getName()+"方法");
    }
}

package com.zkw.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(method.getName()+"方法被使用了，方法的返回值为："+returnValue);
    }
}

测试类

import com.zkw.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void TestAop(){
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
        userService.modify();
    }
}

结果如下

---

方式二：自定义类实现

此时只需要把XML文件的方式一那一部分替换成这个就可以了

XML文件

<!--方式二： 自定义类：切面-->
<bean id="diy" class="com.zkw.diy.DiyPointCut"/>
<aop:config>
    <!--自定义切面，ref 要引用的类-->
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.zkw.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

日志类

package com.zkw.diy;

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

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

其它的不变执行结果如下

---

方式三：通过注解来实现

XML文件

 <!--方式三：通过注解实现-->
    <bean id="annotationPointCut" class="com.zkw.diy.AnnotationPointCut"/>
   <!-- 开启注解支持 JDK(默认 <aop:aspectj-autoproxy proxy-target-class="true"/>) cglib(proxy-target-class="false")-->
    <aop:aspectj-autoproxy />

日志类

package com.zkw.diy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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.zkw.service.UserServiceImpl.*(..))")
    public void AnnotationBefore(){
        System.out.println("====方法执行前====");
    }

   @After("execution(* com.zkw.service.UserServiceImpl.*(..))")
    public void AnnotationAfter(){
        System.out.println("====方法执行后====");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入点
    @Around("execution(* com.zkw.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");

        Signature signature = pjp.getSignature();//获得标签
        System.out.println(signature);

        pjp.proceed();//执行方法

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

其它不变，结果如下