spring aop源码想到的代理模式

代理（pxoxy）无处不在，哪怕在现实生活中

在看源码的时候，看到了aop，

就以此引出代理的知识扩展。

为什么要有代理呢，主要是不改变原来代码的功能的前提下，增加一些特殊功能，比如记录日志，权限认证，事务相关。

代理有静态代理和动态代理，而动态代理有两种实现方式：jdk代理和cglib代理，下面分别介绍下其实现方式

0 静态代理

这是很古老的方式了，一开始入行时用的代理就是这样方式实现的。核心伪代码如下

/**
 * 
 * @author dgm
 * @describe "产品接口"
 * @date 2020年4月20日
 */
public interface ProductDao {
    Product createProduct(String name, String size);
}

public class ProductDaoImpl implements ProductDao {

	public ProductDaoImpl() {
	}
	public Product createProduct(String name, String size) {
		return new Product(name,size);
	}
}

/**
 * 
 * @author dgm
 * @describe "静态代理"
 * @date 2020年4月20日
 */
public class ProductStaticProxy implements ProductDao {

	private ProductDao target;
	
	public ProductStaticProxy(ProductDao target) {
		this.target = target;
	}

	@Override
	public Product createProduct(String name, String size) {
		System.out.println("代理执行，开始工地干活生产房子办公楼产品了...");
		return target.createProduct(name,size);
	}
}

public class ProductStaticProxyTest {

	public static void main(String[] args) {
		// 目标对象
		ProductDao dao = new ProductDaoImpl();
		System.out.println("目标对象: " + dao.getClass());
		// 获取代理对象
		ProductDao proxy = new ProductStaticProxy(dao);
		System.out.println("代理对象: "+proxy.getClass());
		// 代理生产产品
		System.out.println(proxy.createProduct("手机屏幕", "4寸"));
	}
}

执行结果图示

此种方式简单，但随着项目量越来越大，维护的代码也就越多，且接口改动也频繁，迫切需要一种新的方式，这时动态代理登场了

1. jdk动态代理（自带功能，不需要引入第三方包）

先介绍下java.lang.reflect.Proxy类，它提供的一个newProxyInstance方法用来创建一个对象的代理对象

 public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

newProxyInstance方法用来返回一个代理对象，这个方法总共有3个参数，ClassLoader loader用来指明生成代理对象使用哪个类装载器，Class<?>[] interfaces用来指明生成哪个对象的代理对象，通过接口指定，InvocationHandler h用来指明产生的这个代理对象要做什么事情。所以我们只需要调用newProxyInstance方法就可以得到某一个对象的代理对象了。

示例代码：

/**
 * 
 * @author dgm
 * @describe "jdk动态代理"
 * @date 2020年4月20日
 */
public class ProductJdkDynamicProxy {
	// 接收一个目标对象
	private Object target;

	public ProductJdkDynamicProxy(Object target) {
		this.target = target;
	}

	// 返回对目标对象(target)代理后的对象(proxy)
	public Object getProxyInstance() {
		Object proxy = Proxy.newProxyInstance(target.getClass()
				.getClassLoader(), // 目标对象使用的类加载器
				target.getClass().getInterfaces(), // 目标对象实现的所有接口
				new InvocationHandler() { // 执行代理对象方法时候触发
					@Override
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {

						System.out.println("原生jdk开启生产产品线，拼命加班中");
						// 执行目标对象方法
						Object result = method.invoke(target, args);
						System.out.println("原生jdk干的不错，结束生产产品");

						return result;
					}
				});
		return proxy;
	}
}


public class ProductJdkDynamicProxyTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//目标对象
		ProductDao target = new  ProductDaoImpl();
		System.out.println("目标对象: "+target.getClass());
		//代理生产产品
		ProductDao proxy = (ProductDao) new ProductJdkDynamicProxy(target).getProxyInstance();
		System.out.println("代理对象: "+proxy.getClass());
        //执行代理业务具体业务操作
		System.out.println(proxy.createProduct("手机屏幕", "4寸"));
	}

}

测试效果：

spring aop的实现方式之一就是它实现的

2. cglib代理

慢慢地工作到了一定阶段，时代在发展为了快速开发，项目化运作，开始大量引进框架和第三方库，真的很好用（特别是项目开发），比如cglib，由于它是针对类实现的代理，故类不能是final类型。

/**
 * 
 * @author dgm
 * @describe "cglib动态代理"
 * @date 2020年4月20日
 */
public class ProductCglibDynamicProxy implements MethodInterceptor {

	@Override
	public Object intercept(Object obj, Method method, Object[] args,
			MethodProxy methodProxy) throws Throwable {
		try {
			before(method);// 前置通知
			Object ret = methodProxy.invokeSuper(obj, args);// 目标方法执行
			after(method, ret);// 后置通知
			return ret;
		} catch (Exception e) {
			exception();// 异常通知
		} finally {
			afterReturning();// 方法返回通知
		}
		return null;
	}

	// 前置增强
	private void before(Method method) {
		System.out.printf("cglib 动态代理:%s", method.getName());
	}

	// 后置增强
	private void after(Method method, Object ret) {
		System.out.printf("，cglib动态代理:%s, ret:%s", method.getName(), ret);
	}

	// 异常增强
	private void exception() {
		System.out.println("，程序出错了！");
	}

	// after返回增强
	private void afterReturning() {
		System.out.println("，产品成型");
	}

}


/**
 * 
 * @author dgm
 * @describe "测试cglib动态代理"
 * @date 2020年4月20日
 */
public class ProductCglibDynamicProxyTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//代理对象
		ProductDao proxy = CglibProxyFactory.create();
		System.out.println("代理对象: "+proxy.getClass());
        //执行代理业务具体业务操作
		System.out.println(proxy.createProduct("手机屏幕", "4寸"));
	}

}

运行结果：

spring-aop的另一实现也是基于此

简单总结：

静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但静态代理只能为一个目标对象服务，如果目标对象过多，则会产生很多代理类。
JDK动态代理需要目标对象实现业务接口，代理类只需实现InvocationHandler接口。
静态代理在编译时产生class字节码文件，可以直接使用，效率高。
动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
cglib代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。

spring aop源码想到的代理模式

猜你喜欢