JVAV设计模式-代理模式实现原理伪代码

柔情只为你懂 2022-03-18 06:41 206阅读 0赞

**动态代理：它能代理所有实现类的方法调用：根据传进来的业务实现类和方法名进行具体调用**

**JDK动态代理**：JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建，JVM根据传进来的 业务实现类对象 以及 方法名 ，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用**。**我们需要做的，只需指定代理类的预处理、调用后操作即可

实现代码：

定义抽象接口：

package pers.ly.learn.designModel.proxy.dynamicProxy;
    
    public interface IDynJDKProsecutors {
    	
    	void appeal();
    
    }

定义接口具体实现类：

package pers.ly.learn.designModel.proxy.dynamicProxy;
    
    public class DynJDKProsecutor implements IDynJDKProsecutors{
    
    	@Override
    	public void appeal() {
    		System.out.println("我是一个具体起诉人，我要起诉xxx...");
    	}
    
    }

定义JDK代理类：

package pers.ly.learn.designModel.proxy.dynamicProxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * JDK动态代理的代理对象在创建时，需要使用业务实现类所实现的接口作为参数（因为在后面代理方法时需要根据接口内的方法名进行调用）。
     * 如果业务实现类是没有实现接口而是直接定义业务方法的话，就无法使用JDK动态代理了。并且，如果业务实现类中新增了接口中没有的方法，
     * 这些方法是无法被代理的（因为无法被调用）
     * @author banma
     *
     */
    public class DynJDKProsecutorProxy implements InvocationHandler{
    	
    	private Object target;
    	
    	/**
    	 * 将代理类中target与实际业务实现类绑定 返回一个代理类
    	 * 具体实现：通过反射机制创建一个代理类的实例对象
    	 * 创建对象时：传该实现类的类加载器、接口、代理实现类
    	 * @param obj
    	 * @return
    	 */
    	public Object bind(Object obj) {
    		this.target = obj;
    		return Proxy.newProxyInstance(target.getClass().getClassLoader(),
    				target.getClass().getInterfaces(), this);
    	}
    	
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		
    		System.out.println("代理对象调用具体业务方法之前，处理xxx....");
    		
    		Object invoke = method.invoke(target, args);
    		
    		System.out.println("代理对象调用具体业务方法之后，处理xxx....");
    		
    		return invoke;
    	}
    	
    }

Cglib代理：**cglib是针对类来实现代理的，原理是对指定的业务类生成一个子类，并覆盖其中业务方法实现代理。因为采用的是继承，所以不能对final修饰的类进行代理**

定义具体的业务类：

package pers.ly.learn.designModel.proxy.cglibProxy;
    
    public class Prosecutor {
    
    	public void appeal() {
    		System.out.println("我是一个具体起诉人，我要起诉xxx...");
    	}
    
    }

定义代理类：

package pers.ly.learn.designModel.proxy.cglibProxy;
    
    import java.lang.reflect.Method;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    /**
     * cglib代理模式无需实现接口，具体类（里面各个方法）都直接可以代理
     * 代理类则实现MethodInterceptor接口，通过类加强器Enhancer为代理类指定父类，即代理的业务类，然后设置回调函数，生成代理对象
     * 代理对象调用类中的方法时会回调代理类中的intercept方法，通过intercept方法调用真实对象的方法，并在调用前后进行预处理等操作
     * @author banma
     *
     */
    public class CglibProsecutorProxy implements MethodInterceptor {
    	
    	private Object target;
    	
    	public Object getInstance(Object obj) {
    		this.target = obj;
    		
    		//加强器，用来创建动态代理类
    		Enhancer enhancer = new Enhancer();
    		//指定代理业务类（为生成的代理类指定父类）
    		enhancer.setSuperclass(this.target.getClass());
    		//设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
    		enhancer.setCallback(this);
    		//创建代理类
    		return enhancer.create();
    		
    	}
    
    	//实现回调方法
    	@Override
    	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
    		 System.out.println("预处理——————");
    	     proxy.invokeSuper(obj, args); //调用业务类（父类中）的方法
    	     System.out.println("调用后操作——————");
    	     return null; 
    	}
    
    }

**静态代理**：静态代理的缺点很明显：一个代理类只能对一个业务接口的实现类进行包装，如果有多个业务接口的话就要定义很多实现类和代理类才行。而且，如果代理类对业务方法的预处理、调用后操作都是一样的（比如：调用前输出提示、调用后自动关闭连接），则多个代理类就会有很多重复代码

定义抽象接口

package pers.ly.learn.designModel.proxy.staticProxy;
    
    public interface IProsecutors {
    	
    	void appeal();
    
    }

定义接口的具体实现类：

package pers.ly.learn.designModel.proxy.staticProxy;
    
    public class Prosecutor implements IProsecutors{
    
    	@Override
    	public void appeal() {
    		System.out.println("我是一个具体起诉人，我要起诉xxx...");
    	}
    
    }

定义代理类：

package pers.ly.learn.designModel.proxy.staticProxy;
    
    /**
     * 代理的意义在于在操作的实际实现类的方法的同时能做一些其他的逻辑
     * （类似于Spring 的 AOP，不过Spring的AOP是动态代理）
     * 
     * 首先定义一个抽象接口、一个具体实现类、一个代理类
     * 代理类和具体实现类都去实现这个抽象接口的抽象方法
     * 代理类中实现抽象方法时去调用具体实现类中的方法，并在方法处理的前后同时做一些其他的处理逻辑
     * 
     * 静态代理则把具体的实现类定死了，可用性不高
     * 
     */
    public class ProsecutorProxy implements IProsecutors {
    	
    	private IProsecutors iProsecutors = new Prosecutor();
    
    	@Override
    	public void appeal() {
    		System.out.println("处理前的逻辑：我是起诉人的代理律师，我现在代表我的委托人...");
    		iProsecutors.appeal();
    		System.out.println("处理后的逻辑：我是起诉人的代理律师，起诉结束...");
    	}
    	
    }

测试：

package pers.ly.learn.designModel.proxy;
    
    import pers.ly.learn.designModel.proxy.cglibProxy.CglibProsecutorProxy;
    import pers.ly.learn.designModel.proxy.cglibProxy.Prosecutor;
    import pers.ly.learn.designModel.proxy.dynamicProxy.DynJDKProsecutor;
    import pers.ly.learn.designModel.proxy.dynamicProxy.DynJDKProsecutorProxy;
    import pers.ly.learn.designModel.proxy.dynamicProxy.IDynJDKProsecutors;
    import pers.ly.learn.designModel.proxy.staticProxy.ProsecutorProxy;
    
    public class Test {
    	
    	
    	public static void main(String[] args) {
    		
    //		testStaticProxy();//静态代理测试
    		testCglibProxy();//Cglib代理测试
    //		testJDKDynProxy();//JDK代理测试
    		
    	}
    	
    	public static void testCglibProxy() {
    		Prosecutor prosecutor = new Prosecutor();
    		CglibProsecutorProxy cglibProsecutorProxy = new CglibProsecutorProxy();
    		Prosecutor instance = (Prosecutor) cglibProsecutorProxy.getInstance(prosecutor);
    		instance.appeal();
    	}
    	
    	public static void testJDKDynProxy() {
    		DynJDKProsecutor dynJDKProsecutor = new DynJDKProsecutor();
    		DynJDKProsecutorProxy dynJDKProsecutorProxy = new DynJDKProsecutorProxy();
    		IDynJDKProsecutors iDynJDKProsecutors = (IDynJDKProsecutors) dynJDKProsecutorProxy.bind(dynJDKProsecutor);
    		iDynJDKProsecutors.appeal();
    	}
    	
    	
    	public static void testStaticProxy() {
    		ProsecutorProxy prosecutorProxy = new ProsecutorProxy();
    		prosecutorProxy.appeal();
    	}
    
    }

测试结果：

处理前的逻辑：我是起诉人的代理律师，我现在代表我的委托人...
    我是一个具体起诉人，我要起诉xxx...
    处理后的逻辑：我是起诉人的代理律师，起诉结束...
    
    
    预处理——————
    我是一个具体起诉人，我要起诉xxx...
    调用后操作——————
    
    
    代理对象调用具体业务方法之前，处理xxx....
    我是一个具体起诉人，我要起诉xxx...
    代理对象调用具体业务方法之后，处理xxx....