AOP

Spring 框架通过定义切面, 通过拦截切点实现了不同业务模块的解耦，这个就叫面向切面编程 - Aspect Oriented Programming (AOP)

AOP在Spring中的作用

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ….
  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
  • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
  • 目标（Target）：被通知对象。
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 切入点（PointCut）：切面通知 执行的 “地点”的定义。
  • 连接点（JointPoint）：与切入点匹配的执行点。

AOP的实现方式

通过Spring API实现

1
2
3
4
5
6
7
//首先实现一个接口类
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void search();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//具体实现
public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("增加用户");
    }
    @Override
    public void delete() {
        System.out.println("删除用户");
    }
    @Override
    public void update() {
        System.out.println("更新用户");
    }
    @Override
    public void search() {
        System.out.println("查询用户");
    }
}

接下来我们需要完成对于这个增强类的前置增强和后置增强

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Log implements MethodBeforeAdvice {
    // method : 要执行的目标对象的方法
    // objects : 被调用的方法的参数
    // Object : 目标对象
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName() + "的" + method.getName() + "方法被执行了");
    }
}

public class AfterLog implements AfterReturningAdvice {
    // returnValue 返回值
    // method 被调用的方法
    // args 被调用的方法的对象的参数
    // target 被调用的目标对象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + target.getClass().getName() + "的" + method.getName() + "方法, 返回值：" + returnValue);
    }
}

我们可以去xml文件中进行注册

1
2
3
4
5
6
7
8
9
10
11
12
<!--注册bean-->
<bean id="userService" class="com.kuang.service.UserServiceImpl"/>
<bean id="log" class="com.kuang.log.Log"/>
<bean id="afterLog" class="com.kuang.log.AfterLog"/>
<!--aop的配置-->
<aop:config>
    <!--切入点 expression:表达式匹配要执行的方法-->
    <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
    <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>

使用自定义类来实现AOP

1
2
3
4
5
6
7
8
public class DiyPointcut {
    public void before() {
        System.out.println("---------方法执行前---------");
    }
    public void after() {
        System.out.println("---------方法执行后---------");
    }
}

去Spring中进行配置

1
2
3
4
5
6
7
8
9
10
11
12
<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>
    <!--第二种方式：使用AOP的标签实现-->
    <aop:aspect ref="diy">
        <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <aop:before pointcut-ref="diyPonitcut" method="before"/>
        <aop:after pointcut-ref="diyPonitcut" method="after"/>
    </aop:aspect>
</aop:config>

使用注解实现

编写一个注解实现的增强类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("---------方法执行前---------");
    }
    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("---------方法执行后---------");
    }
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:" + jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

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

1
2
3
<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy proxy-target-class=”true”/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用 Cglib 生成一个被代理对象的子类来作为代理，如下图所示：

Spring AOP 属于运行时增强，而 AspectJ 是编译时增强。 Spring AOP 基于代理(Proxying)，而 AspectJ 基于字节码操作(Bytecode Manipulation)。

代理模式

使用AOP肯定绕不开代理模式

静态代理

1
2
3
4
//抽象出一个租房的角色
public interface Rent {
    public void rent();
}
1
2
3
4
5
6
//真实角色: 房东，房东要出租房子
public class Host implements Rent {
    public void rent() {
        System.out.println("房屋出租");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Proxy implements Rent {
    private Host host;
    public Proxy() { }
    public Proxy(Host host) {
        this.host = host;
    }
    //租房
    public void rent() {
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse() {
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare() {
        System.out.println("收中介费");
    }
}

静态代理的好处是什么

  1. 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
  2. 公共的业务由代理来完成 . 实现了业务的分工 ,
  3. 公共业务发生扩展时变得更加集中和方便 .

静态代理的劣势是什么
需要手动的生成大量的类，复杂

此时我们可以捋一下思路对于上面的静态代理模式，就是如果我们需要实现一个中间商的身份去干我们本来需要别的类干的活，我们需要将这个类给抽象出来，（中介去干了房东的活）同时，这也就是AOP的核心的思想，在不改变原有代码的功能下实现对于原有功能的增强

动态代理

  1. 动态代理的角色和静态代理的一样 .
  2. 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
  3. 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
    1. 基于接口的动态代理—-JDK动态代
    2. 基于类的动态代理–cglib

使用动态代理的时候我们需要了解两个类
核心： InvocationHandler 和 Proxy

调用处理程序

Proxy

代码实现：

1
2
3
4
//抽象角色：租房
public interface Rent {
    public void rent();
}
1
2
3
4
5
6
//真实角色: 房东，房东要出租房子
public class Host implements Rent {
    public void rent() {
        System.out.println("房屋出租");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;
    //private Object target
    public void setRent(Rent rent) {
        this.rent = rent;
    }
    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }
    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心：本质利用反射实现！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }
    //看房
    public void seeHouse() {
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare() {
        System.out.println("收中介费");
    }
}

此时我们可以在看一下测试类

1
2
3
4
5
6
7
8
9
10
11
public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //将真实角色放置进去！
        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }
}

此时再回过头看AOP

Spring AOP中，有五种类型的Advice

advice