设计模式之代理模式（Java实现）

忘是亡心i 2021-12-13 14:19 252阅读 0赞

代理模式是一种很常见的设计模式，所谓代理，就是指拥有与目标对象的相同的职责的对象，代理对象在实际中代替目标对象与客户端交互。代理对象除了执行目标对象的方法之外，可以额外执行自己的相关逻辑。

代理模式是在不修改目标对象的基础上，进行的扩展，遵循设计原则的开闭原则，也就是对修改关闭，对扩展开放。

Java中代理模式分为静态代理和动态代理，而动态代理的实现又可以分为利用jdk动态代理和cglib来实现。

代理模式设计中，涉及到代理对象，目标对象，为了让代理对象拥有目标对象的职责，可以抽象出一个接口，目标对象和代理对象都实现这个接口，只不过，代理对象中保留一个目标对象的实例，代理对象的接口实现中，实际是调用的目标对象的方法。这就是静态代理的实现方式，通过代码表现出来就是：

HelloService.java

package com.xxx.proxy.statics;
    
    public interface HelloService {
    	String hello(String name);
    }

HelloServiceImpl.java

package com.xxx.proxy.statics;
    
    public class HelloServiceImpl implements HelloService{
    	public String hello(String name){
    		return "hello,"+name;
    	}
    }

HelloServiceProxy.java

package com.xxx.proxy.statics;
    
    public class HelloServiceProxy implements HelloService{
    	
    	private HelloService target;
    	
    	public HelloServiceProxy(HelloService target){
    		this.target = target;
    	}
    	
    	public String hello(String name){
    		return target.hello(name);
    	}
    }

Client.java

package com.xxx.proxy.statics;
    
    public class Client {
    	public static void main(String[] args) {
    		HelloService service = new HelloServiceProxy(new HelloServiceImpl());
    		String greet = service.hello("world");
    		System.out.println(greet);
    	}
    }

运行程序，结果如下：

hello,world

以上通过程序实现了静态代理。这里如果目标对象有了goodbye()方法，那么代理对象如果想要这个goodbye职责，那么他也必须实现goodbye()方法，如果目标对象方法越来越多，代理对象需要代替目标对象行使相关职责，那么代理对象也需要实现相关的接口，为了解决静态代理的这个缺陷，就产生了动态代理。

动态代理不需要代理对象实现目标对象抽象出来的所有方法，简化了代理对象。

动态代理的实现方式有jdk自带的代理方式和spring-aop提供的cglib方式。

jdk自带的代理方式，是通过反射来实现的，代理对象需要实现一个InvocationHandler接口。 实现了InvocationHandler接口的类，只能算是一个在反射中使用handler，要真正创建一个代理对象，还需要通过反射Proxy.newInstance(ClassLoader classLoader,Class<?> interfaces,InvocationHandler handler)；这个方法带有三个参数，分别是classLoader，目标对象类加载器

，interfaces，目标对象接口集合，handler，反射调用处理手柄对象。 jdk自带的代理方式实现代理代码如下：

HelloService.java

package com.xxx.proxy.jdk;
    
    public interface HelloService {
    	String hello(String name);
    	String goodbye(String name);
    }

HelloServiceImpl.java

package com.xxx.proxy.jdk;
    
    public class HelloServiceImpl implements HelloService {
    
    	@Override
    	public String hello(String name) {
    		return "hello,"+name;
    	}
    
    	@Override
    	public String goodbye(String name) {
    		return "goodbye,"+name;
    	}
    
    }

HelloServiceProxy.java

package com.xxx.proxy.jdk;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class HelloServiceProxy implements InvocationHandler {
    	
    	private HelloService target;
    	
    	public HelloServiceProxy(HelloService target) {
    		this.target = target;
    	}
    
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		System.out.println("method="+method.getName());
    		Object result = method.invoke(target, args);
    		System.out.println("result="+result);
    		return result;
    	}
    
    	public Object getInstance(){
    		ClassLoader loader = target.getClass().getClassLoader();
    		Class<?>[] interfaces = target.getClass().getInterfaces();
    		return Proxy.newProxyInstance(loader, interfaces, this);
    	}
    }

JDKProxyMain.java

package com.xxx.proxy.jdk;
    public class JDKProxyMain {
    
    	public static void main(String[] args) {
    		HelloService service = new HelloServiceImpl();
    		HelloService proxy = (HelloService) new HelloServiceProxy(service).getInstance();
    		proxy.hello("world");
    		proxy.goodbye("world");
    	}
    
    }

运行JDKProxyMain类的主方法，打印信息如下：

method=hello
    result=hello,world
    method=goodbye
    result=goodbye,world

使用jdk自带代理实现的代理，我们并没有实现目标类HelloServiceImpl对应的任何接口，我们只是实现了InvocationHandler接口，并且利用反射Proxy.newInstance()来构建了一个加强对象。

下面介绍通过cglib方式来实现动态代理。cglib是spring-aop用来做切面编程，它需要定义一个实现了拦截器的类，利用该类来创建一个代理对象。具体实现代码如下：

如果是maven工程，需要引入如下依赖：

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.4.RELEASE</version>
    </dependency>

HelloService.java

package com.xxx.proxy.cglib;
    
    public class HelloService {
    	public String hello(String name){
    		return "hello,"+name;
    	}
    	public String goodbye(String name){
    		return "goodbye,"+name;
    	}
    }

HelloServiceProxy.java

package com.xxx.proxy.cglib;
    
    import java.lang.reflect.Method;
    
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    public class HelloServiceProxy implements MethodInterceptor {
    	
    	private Object target;
    	
    	public Object getInstance(Object target){
    		this.target = target;
    		Enhancer enhancer = new Enhancer();
    		enhancer.setSuperclass(this.target.getClass());
    		enhancer.setCallback(this);
    		return enhancer.create();
    	}
    
    	@Override
    	public Object intercept(Object obj, Method method, Object[] args,
    			MethodProxy proxy) throws Throwable {
    		Object result = null;
    		System.out.println("before method="+method.getName());
    		try {
    			result = proxy.invokeSuper(obj, args);
    		} catch (Exception e) {
    			throw e;
    		}finally{
    			System.out.println("after result="+result);
    		}
    		return result;
    	}
    
    }

CGLibProxyMain.java

package com.xxx.proxy.cglib;
    
    public class CGLibProxyMain {
    
    	public static void main(String[] args) {
    		HelloService target = new HelloService();
    		HelloServiceProxy proxy = new HelloServiceProxy();
    		HelloService service = (HelloService) proxy.getInstance(target);
    		service.hello("world");
    		service.goodbye("world");
    	}
    
    }

运行CGLibProxyMain类的主方法，打印结果如下：

before method=hello
    after result=hello,world
    before method=goodbye
    after result=goodbye,world

cglib动态代理也是不需要实现目标类的接口。要使用cglib方式实现动态代理，需要加入spring-aop依赖，可以直接加入spring-context依赖即可。