核心解读

AOP：Aspect Oriented Programming，面向切面编程
核心1：将公共的，通用的，重复的代码单独开发，在需要时反织回去
核心2：面向接口编程，即设置接口类型的变量，传入接口类型的参数，返回接口类型的返回值，调用接口类型的变量自身的实现方法
图示

图示分析：例如，在开发中普遍需要使用到日志输出功能，会将日志输出功能大量耦合到项目的不同位置，如上图左侧所示。

而日志输出功能与其实与项目本身的核心业务逻辑无关，我们只是为了不时的查看项目的运行状态。

则可以将日志功能单独提出去开发，在需要的地方将日志输出功能(所谓：日志功能切面)反织回去即可，如上图右侧所示。

手写AOP框架

下面将手写5个版本的AOP框架，在版本的不断优化中，逐步理解AOP面向切面编程的核心，最后一个版本最接近Spring中AOP的原生实现
业务功能和切面功能用简单的输出语句来模拟，主要是为了简洁直观的演示AOP核心思想
手写的AOP框架的业务背景：图书购买业务

项目结构

5个AOP版本分别放在proxy01 ～ proxy05这5个包下，下图左侧为项目结构，右侧为各版本用到的接口和实现类

AOP版本1

整个版本1，只是一个BookService实体类，业务功能和切面功能严重耦合

package com.example.proxy01;

/**
- 图书购买功能和事务切面功能耦合在一个类中
  */
  public class BookService {
  public void buy(){
  try{
  System.out.println("开启事务….");
  System.out.println("图书购买业务….");
  System.out.println("提交事务….");
  }catch (Exception e){
  System.out.println("回滚事务….");
  }
  }
  }
调用BookService实体对象中的buy()方法即可

AOP版本2

通过子类代理来实现将业务功能和切面功能初步拆分解耦
实体类BookService及其子类SubBookService
BookService实体类

package com.example.proxy02;

/**
- 图书购买功能
  */
  public class BookService {
  public void buy(){
  System.out.println("图书购买功能….");
  }
  }
SubBookService子类

package com.example.proxy02;

/**
- 子类代理：将图书购买功能和事务切面划分到不同类中
  */
  public class SubBookService extends BookService{
  @Override
  public void buy() {
  try{
  System.out.println("开启事务事务….");
  super.buy();
  System.out.println("提交事务….");
  }catch (Exception e){
  System.out.println("回滚事务….");
  }
  }
  }
调用SubBookService实体类对象中的buy()方法即可

AOP版本3

通过静态代理，可以进行受代理对象的灵活切换
Service接口

package com.example.proxy03;

/**
- 静态代理接口
  */
  public interface Service {
  //定义业务功能
  void buy();
  }
BookServiceImpl实现类

package com.example.proxy03;

/**
- 目标对象
  */
  public class BookServiceImpl implements Service{
  @Override
  public void buy() {
  System.out.println("图书购买业务….");
  }
  }
ProductServiceImpl实现类

package com.example.proxy03;

/**
- 另外一种业务功能的目标对象
  */
  public class ProductServiceImpl implements Service{
  @Override
  public void buy() {
  System.out.println("产品购买业务….");
  }
  }
静态代理对象

package com.example.proxy03;

/**
- 静态代理对象
  */
  public class Agent implements Service{
  //接口类型的参数
  Service target;
  
  //传入接口类型的参数，灵活调用多种Service接口的实现类
  public Agent(Service target){
  this.target = target;
  }
  
  @Override
  public void buy() {
  try{
  System.out.println("开启事务….");
  target.buy();
  System.out.println("提交事务….");
  }catch (Exception e){
  System.out.println("关闭事务….");
  }
  }
  }
面向接口编程，可灵活代理多种Service接口的实现类，灵活切换受代理对象

package com.example.test;

import com.example.proxy03.Agent;
import com.example.proxy03.ProductServiceImpl;
import com.example.proxy03.Service;
import org.junit.Test;

public class TestProxy03 {
@Test
public void testProxy03(){
//可以灵活切换受代理对象，因为接口类型的参数都能接住
//Service agent = new Agent(new BookServiceImpl());
Service agent = new Agent(new ProductServiceImpl());
agent.buy();
}
}

AOP版本4

AOP版本3中，虽然受代理对象可以灵活切换，但是不同的受代理对象被绑定到相同的切面功能，切面功能无法灵活切换
可以将上述切面功能上升到接口层次，针对不同切面功能有不同实现类
核心：就像Agent代理对象持有Service接口类型的变量一样，若持有切面接口类型的变量，则可以接收不同切面接口的实现类，实现不同切面功能的灵活切换
考虑到切面功能出现在业务功能的前后关系，以及异常处理等情况，可以根据切面出现的时机定义切面接口中的方法
推导出需要定义切面接口以及如何定义接口中方法的思路图示

业务接口：Service接口

package com.example.proxy04;

/**
- 静态代理接口
  */
  public interface Service {
  //定义业务功能
  void buy();
  }
切面接口：Aop接口

package com.example.proxy04;

/**
- 自定义Aop,切面接口
  */
  public interface Aop {
  default void before(){} //default关键字，jdk8的新特性，可以提供空实现，不强迫接口实现类实现所有接口中的方法
  default void after(){} //实现类需要实现哪个方法就实现哪个方法
  default void exception(){}
  }
业务功能实现类：BookServiceImpl和ProductServiceImpl

package com.example.proxy04;

/**
- 目标对象
  */
  public class BookServiceImpl implements Service {
  @Override
  public void buy() {
  System.out.println("图书购买业务….");
  }
  }
package com.example.proxy04;

public class ProductServiceImpl implements Service {
@Override
public void buy() {
System.out.println("产品生产业务….");
}
}
切面功能实现类：TransAopImpl和LogAopImpl

package com.example.proxy04;

public class TransAopImpl implements Aop{
@Override
public void before() {
System.out.println("开启事务….");
}
```
@Override
public void after() {
    System.out.println("提交事务....");
}

@Override
public void exception() {
    System.out.println("回滚事务....");
}
```
}

package com.example.proxy04;

//切面接口中定义方法时使用了default，不必实现所有接口方法，按需实现方法即可
public class LogAopImpl implements Aop{
@Override
public void before() {
System.out.println("前置日志输出….");
}
}
可以实现业务功能和切面功能的灵活组合
而且就像下面第2个测试一样，因为代理对象也是Service的一个实现类，所以代理对象还可以再次被代理，一个业务功能被多个切面包围，实现多切面

此时的版本已经很灵活，也已经揭示出了AOP面向切面编程的核心

package com.example.test;

import com.example.proxy04.*;
import org.junit.Test;

public class TestProxy04 {

//测试：单个业务功能 + 单个切面功能
@Test
public void testProxy04(){
    //分别传入要完成的业务功能和要切入的功能，可以灵活组合，这里就可以有业务功能和切面功能的4种组合：2 x 2
    //Service agent = new Agent(new ProductServiceImpl(), new LogAopImpl());
    //Service agent = new Agent(new ProductServiceImpl(), new TransAopImpl());
    //Service agent = new Agent(new BookServiceImpl(), new LogAopImpl());
    Service agent = new Agent(new BookServiceImpl(), new TransAopImpl());
    agent.buy();
}

//测试：单个业务功能 + 多个切面功能(本例为：日志切面 + 事务切面)
@Test
public void testManyProxies(){
    Service agent = new Agent(new ProductServiceImpl(), new LogAopImpl());
    Service agent2 = new Agent(agent, new TransAopImpl());
    agent2.buy();
}

}

AOP版本5

静态代理可以做到受代理对象的灵活切换，但是不可以做到代理功能的灵活切换，就像我们用动态代理优化静态代理一样，还可以用jdk动态代理继续优化上述AOP版本4
在Spring原生的AOP框架中，底层就是使用的jdk动态代理，AOP版本5最接近Spring原生AOP框架
AOP版本5中除了用ProxyFactory代理工厂来动态获取代理对象外(不再写AOP版本4中的Agent类，4版本是静态的，现在不用写了)，其他接口和实现类与AOP版本4完全一致，不再赘述
新增ProxyFactory类，代替AOP版本4中的Agent类

参数比较多，看起来有些乱(包涵包涵)，若对jdk动态代理不是很熟悉，可以参考mybatis博客集(mybatis 01 对jdk动态代理有详细讨论)

package com.example.proxy05;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**

代理工厂，获取动态代理对象
*/
public class ProxyFactory {

//静态方法获取jdk动态代理对象：传入业务功能对象 + 切面功能对象
public static Object getProxy(Service target, Aop aop){

//该方法有三个参数，第三个参数是一个匿名内部类
return Proxy.newProxyInstance(
        //参数1
        target.getClass().getClassLoader(),
        //参数2
        target.getClass().getInterfaces(),    //参数3：匿名内部类重写的方法又有三个参数
    //其中method用来反射调用外部调用的那个方法，args是调用目标方法时要传的参数
    new InvocationHandler() {
        @Override
        public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
            //用来存放目标对象被调用的方法的返回值
            Object res = null;
            try{
                //切面功能
                aop.before();
                //业务功能，根据外部调用的功能，动态代理目标对象被调用的方法
                res = method.invoke(target, args);
                //切面功能
                aop.after();
            }catch (Exception e){
                //切面功能
                aop.exception();
            }
            //返回目标对象被调用的方法的返回值给外部调用者
            return res;
        }
    }
);

}
}

package com.example.test;

import com.example.proxy05.BookServiceImpl;
import com.example.proxy05.ProxyFactory;
import com.example.proxy05.Service;
import com.example.proxy05.TransAopImpl;
import org.junit.Test;

public class TestProxy05 {
//测试：AOP版本5
@Test
public void testProxy05(){
//获取动态代理对象，传入业务功能对象和切面功能对象，这里传入的业务对象和切面对象可以有多种组合
Service agent = (Service) ProxyFactory.getProxy(new BookServiceImpl(), new TransAopImpl());
//完成业务功能和切面功能的组合
agent.buy();
}
}

开启事务….
图书购买业务….
提交事务….

Process finished with exit code 0

扩展测试

为了体现动态代理的优点，并测试有参数和有返回值的方法都可被代理，为Service接口扩展功能：order（预定图书的功能)
Service接口新增order方法

package com.example.proxy05;

/**
- 静态代理接口
  */
  public interface Service {
  //定义业务功能
  void buy();
  
  //新扩展一个预定功能
  default String order(int orderNums){return null;}
  //default,不强制实现类都实现该方法，按需实现
  }
让BookServiceImpl实现该新增的方法

package com.example.proxy05;

/**
- 目标对象
  */
  public class BookServiceImpl implements Service {
  @Override
  public String order(int orderNums) {
  System.out.println("新预定图书: " + orderNums + " 册");
  return "预定成功";
  }
  @Override
  public void buy() {
  System.out.println("图书购买业务….");
  }
}

package com.example.test;

import com.example.proxy05.BookServiceImpl;
import com.example.proxy05.ProxyFactory;
import com.example.proxy05.Service;
import com.example.proxy05.TransAopImpl;
import org.junit.Test;

public class TestProxy05 {
@Test
public void testProxy05(){
//获取动态代理对象，传入业务功能对象和切面功能对象
Service agent = (Service) ProxyFactory.getProxy(new BookServiceImpl(), new TransAopImpl());
//完成业务功能和切面功能的组合
String res = agent.order(10);
System.out.println("返回结果: " + res);
}
}

开启事务….
新预定图书: 10 册
提交事务….
返回结果: 预定成功

Process finished with exit code 0

小结

在AOP版本3优化了业务功能(静态代理)
在AOP版本4优化了切面功能(AOP面向切面编程)
在AOP版本5优化了代理功能(jdk动态代理)
此时手写的AOP版本5可以做到被代理对象的灵活切换，代理功能的灵活切换，业务功能和切面功能的灵活组合
AOP版本5最接近Spring中AOP的原生实现原理

手机扫一扫

移动阅读更方便

你可能感兴趣的文章

十八、Spring框架（AOP）

Spring(4)——面向切面编程（AOP模块）

第九章 springboot + mybatis + 多数据源（AOP实现）

【开源】.Net Aop(静态织入)框架 BSF.Aop

[ SSH框架 ] Spring框架学习之二（Bean的管理和AOP思想）

第九章 springboot + mybatis + 多数据源（AOP实现）(转载)