实现：JDK动态代理和CGLIB动态代理

分手后的思念是犯贱 2022-05-12 06:44 354阅读 0赞

可以参看我的另外一篇博客，了解一下静态代理和动态代理：[GOF（一） 代理模式][GOF_]

### JDK动态代理 ###

JDK动态代理只能对实现了接口的类生成代理，而不能针对类；实现InvocationHandler接口，重写invoke()方法。

模拟链家找房子

**1. 接口**

定义一个方法，searchHouse()，找房子

/**
     * 接口
     * @author 75736
     *
     */
    public interface Person {
    	 void searchHouse(); 
    }

**2. 目标类**

目标类实现接口，重写接口方法

/**
     * 目标类
     * 实现接口
     * @author 75736
     *
     */
    public class Master implements Person {
    
    	@Override
    	public void searchHouse() {
           System.out.println("找房子");
    	}
    
    }

**3. 代理类**

代理类持有对目标对象的引用

/**
     * 代理类
     * 持有目标类的引用
     * @author 75736
     *
     */
    public class HomeLink implements InvocationHandler{
    
    	 private Person target;   // 代理对象
    	    
    	 	/**
    	 	 * 初始化代理对象
    	 	 * @param target
    	 	 * @return
    	 	 */
    	    public Object getInstance(Person target){
    	        this.target = target;
    	        Class clazz = target.getClass();
    	        
    	        // static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
    	        // loader：指明代理对象使用哪个类加载器，代理类的类加载器
    	        // interfaces：用来指明生成哪个对象的代理对象，通过接口指定，代理类实现的接口
    	        // h：用来指明产生的这个代理对象要做什么事情，代理对象
    	        Object obj = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    	        
    	        return obj;
    	    }
    
    	    @Override
    	    public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
    	        System.out.println("我是链家，我帮别人找房子..");
    	        
    	        // invoke(obj, args) 
    	        // target：也就是被代理类的对象
    	        // args：方法中的参数
    	        method.invoke(target, args);
    	       
    	        System.out.println("我是链家，已经找完了..");
    	        return null;
    	    }
    
    }

**4. 测试**

public class TestSearchHouse {
    
    	public static void main(String[] args) {
    		// 获取代理对象实例
    		Person person = (Person) new HomeLink().getInstance(new Master());
    		
    		person.searchHouse();
    	}
    }

### CGLIB动态代理 ###

CGLIB是针对类实现代理，其原理是通过目标类的字节码为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。

**1. 目标类**

/**
     * 目标类
     * 没有可实现的父接口
     * @author 75736
     *
     */
    public class Master{
    
    	public void searchHouse() {
           System.out.println("找房子");
    	}
    
    }

**2. 代理类**

/**
     * 代理类 
     * 原理： 通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑
     * 
     * @author 75736
     *
     */
    public class HomeLink implements MethodInterceptor {
    
    	// net.sf.cglib.proxy.Enhancer：主要增强类，通过字节码技术动态创建委托类的子类实例；
    	private Enhancer enhancer = new Enhancer();
    
    	/**
    	 * 获取代理对象
    	 * 
    	 * @param clazz
    	 * @return
    	 */
    	public Object getProxy(Class clazz) {
    		// 进行代理，设置需要创建子类的类
    		enhancer.setSuperclass(clazz);
    		// 设置织入逻辑
    		enhancer.setCallback(this);
    		// 生成代理实例，通过字节码技术动态创建子类实例
    		return enhancer.create();
    	}
    
    	/**
    	 * 实现MethodInterceptor接口方法 实现具体拦截处理 
    	 * @param obj：动态生成的代理对象 
    	 * @param method ： 实际调用的方法 
    	 * @param args：调用方法入参
    	 * @param proxy：java Method类的代理类，可以实现委托类对象的方法的调用
    	 */
    	@Override
    	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    		System.out.println("前置代理");
    		// 通过代理类调用父类中的方法
    		Object result = proxy.invokeSuper(obj, args);
    		System.out.println("后置代理");
    		return result;
    	}
    
    }

**3. 测试**

public class TestSearchHouse {
    
    	public static void main(String[] args) {
    		HomeLink proxy = new HomeLink();
    		// 通过生成子类的方式创建代理类
    		Master proxyImp = (Master) proxy.getProxy(Master.class);
    		proxyImp.searchHouse();  // 调用intercept方法
    	}
    }

[GOF_]: https://blog.csdn.net/qq_41541619/article/details/80557577