代理设计模式(普通静态代理、JDK动态代理、cglib动态代理)

布满荆棘的人生 2022-05-30 03:57 300阅读 0赞

1、普通静态代理:

代理设计模式:

代理设计模式中，一个类代表另外一个类的功能，这种类型的设计模式属于结构性设计模式。

对于被代理人来讲，这件事情是一定要去做的，但是我自己又不想做或者没有时间做，则需要找代理。

当我们想要对一个类的访问做出一些个控制，这个时候我们就要使用代理设计模式。

代理设计模式的使用场景：

西游记的案例：

猪八戒要去高老庄找高翠兰小姐，但是找到的确是孙悟空变化成的高翠兰。

这个场景可以这样理解：

先把高翠兰的外貌特征抽取出来变成一个接口，然后高翠兰本人和孙悟空两个类都去实现这个外貌的接口，当猪八戒去访问的时候，猪八戒其实访问的是

孙悟空，但是由于外貌是高翠兰的，所以他看不出来是孙悟空。在这里，高翠兰本人是被代理类，孙悟空是代理类

火车站售票点的案例：

火车站售票点帮助火车站出售火车票，场景也可以自行推倒。

下面是整个代码的案例结构(其中Image接口表示高翠兰的长相，RealImage是高翠兰本人，ProxyImage是孙悟空这个代理)：

![SouthEast][]

下面代码是西游记案例的实现代码：

Image,java

package com.zwz.test;
    
    public interface Image {
    
    	
    	public void display();
    	
    	
    }

ProxyImage.java

package com.zwz.test;
    
    
    public class ProxyImage implements Image{
    
    	private String filename;
    
    	private RealImage realImage;
    	
    	
    	public String getFilename() {
    		return filename;
    	}
    
    	public void setFilename(String filename) {
    		this.filename = filename;
    	}
    
    	public ProxyImage(String filename) {
    		super();
    		this.filename = filename;
    	}
    
    	@Override
    	public void display() {
    		// TODO Auto-generated method stub
    		//System.out.println(filename+"   display");
    		if(realImage==null){
    			realImage = new RealImage( filename);
    		}
    		realImage.display();
    	
    	}
    	
    }

RealImage.java

package com.zwz.test;
    
    public class RealImage implements Image{
    
    	private String filename;
    
    	
    	
    	public String getFilename() {
    		return filename;
    	}
    
    
    
    	public void setFilename(String filename) {
    		this.filename = filename;
    	}
    
    
    
    	public RealImage(String filename) {
    		super();
    		this.filename = filename;
    		loadFromDisk();
    	}
    
    
    
    	private void loadFromDisk() {
    		// TODO Auto-generated method stub
    		System.out.println(filename+"    is loading");
    	}
    
    
    
    	@Override
    	public void display( ) {
    		// TODO Auto-generated method stub
    
    		System.out.println(filename+"   display");
    		
    	}
    	
    	
    	
    	
    }

ProxyPatternDemo.java

package com.zwz.test;
    
    public class ProxyPatternDemo {
    
    	public static void main(String[] args) {
    		
    		Image image = new ProxyImage("gaocuilan");
    		
    		image.display();
    		
    	}
    	
    }

最后的输出结果如下图所示：

![SouthEast 1][]

上面的篇幅以及代码主要介绍的 java中的静态代理，下面的代码则是介绍 动态代理，动态代理在springAOP的代码中应用较为广泛，

在面向切面(AOP)编程当中，动态代理可以理解为，想要实现一种功能，我们不让其本类去直接实现，而是去

获取到其代理类，让代理类在实现功能的前后干点坏事，spring当中 AOP的具体体现就是 前置通知、后置通知、环绕通知、异常通知这些。

2.JDK动态代理

在实现 JDK 动态代理之前，需要新建一个接口文件，让某个需要被代理的类去实现这个接口，然后待会儿jdk创建出来的代理对象也实现  InvocationHandler 这个接口，用来代理被代理的对象，完成其方法，并且可以在其方法前后增加代码.

具体实现如下：

首先先建一个接口文件:

Hello.java

public interface Hello {
    
    	public void sayHello();
    	
    }

然后新建一个实现这个接口的Class类

HelloImpl.java

public class HelloImpl implements Hello{
    
    	public void sayHello() {
    		// TODO Auto-generated method stub
    		System.out.println("HelloImpl say hello!!");
    	}
    
    }

实现JDK动态代理的类（需要实现 InvocationHandler接口）：

JDKProxy.java

public class JDKProxy implements InvocationHandler{
    
    	//这个obj是要被jdk动态代理的对象
    	private Object obj;
    
    	//传入要被代理的对象
    	public JDKProxy(Object obj) {
    		super();
    		this.obj = obj;
    	}
    
    	public void before(){
    		System.out.println("say before!!");
    	}
    	
    	public void after(){
    		System.out.println("say after!!");
    	}
    	
    	//invoke方法 是   代理对象执行 被代理对象的方法
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		// TODO Auto-generated method stub
    		//代理方法之前干点坏事
    		before();
    		
    		Object result = method.invoke(obj, args);
    		//代理方法之后干点坏事
    		after();
    		
    		return result;
    	
    	}
    
    	/*
    	 Proxy.newProxyInstance这个方法的三个传入参数和含义如下:
    	 参数1:传入一个   当前类的加载器
    	 参数2:传入一个  当前类的接口文件
    	 参数3:实现了  InvokeHandler的子类对象  
    	 */
    	public <T>T getProxy( ){
    		return (T)Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    	}
    	
    	public static void main(String[] args) {
    		
    		HelloImpl hi = new HelloImpl();
    		JDKProxy proxy = new JDKProxy(hi);
    		
    		Hello hii = proxy.getProxy();
    		hii.sayHello();
    		
    	}
    	
    	
    }

运行main函数输出结果：

![SouthEast 2][]

3.CGLIB 动态代理

cglib的动态代理和jdk的动态代理最大的区别在于，cglib当中被代理的对象不需要实现接口，cglib直接代理其对象。

CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法(继承)

实现代码如下  CGlibProxy.java：

public class CGlibProxy implements MethodInterceptor{
    
    	public void before(){
    		System.out.println("before method");
    	}
    	
    	public void after(){
    		System.out.println("after method");
    	}
    	
    	public <T>T getProxy(Class<T>cls){
    		return (T)Enhancer.create(cls, this);
    	}
    	
    	public Object intercept(Object obj, Method method, Object[] args,
    			MethodProxy methodProxy) throws Throwable {
    		// TODO Auto-generated method stub
    		
    		before();
    		
    		Object result = methodProxy.invokeSuper(obj, args);
    		
    		after();
    		return result;
    	}
    
    	public static void main(String[] args) {
    		
    		CGlibProxy proxy = new CGlibProxy();
    		
    		HelloImpl hi = proxy.getProxy(HelloImpl.class);
    	
    		hi.sayHello();
    	
    	}
    }

运行代码，得到输出:

![SouthEast 3][]

在spring的代码当中jdk的动态代理和cglib的动态代理都会使用到

在spring的  DefaultAopProxyFactory.java  文件中 createAopProxy  方法代码如下：

@Override
    	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    			Class<?> targetClass = config.getTargetClass();
    			if (targetClass == null) {
    				throw new AopConfigException("TargetSource cannot determine target class: " +
    						"Either an interface or a target is required for proxy creation.");
    			}
    			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
    				return new JdkDynamicAopProxy(config);
    			}
    			return new ObjenesisCglibAopProxy(config);
    		}
    		else {
    			return new JdkDynamicAopProxy(config);
    		}
    	}

可以看到在spring源码中判断当前的类是否有实现接口，如果没有实现则使用cglib的动态代理，如果实现了，则使用jdk的动态代理。

[SouthEast]: /images/20220530/2cc56eb5338f48ccbe7807a7809c25bb.png
[SouthEast 1]: /images/20220530/61767486e11244cba3c267cba88a3d55.png
[SouthEast 2]: /images/20220530/cff144c50d934198a55f069d8a89044a.png
[SouthEast 3]: /images/20220530/d47208c4727c4d998adedbf49fb00c42.png