代理模式

最新推荐文章于 2024-07-05 23:58:56 发布

黄晶谛

最新推荐文章于 2024-07-05 23:58:56 发布

阅读量154

点赞数

分类专栏： # DesignPattern

本文链接：https://blog.csdn.net/SUNBOYmxbsH/article/details/106506262

版权

DesignPattern 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一、简介
代理模式，Proxy，通过代理对象访问目标对象，可以在目标对象的实现基础上，增强额外的功能，即扩展目标对象的功能。被代理的对象可以是远程对象、需要安全控制的对象或创建开销较大的对象。
代理模式主要有三种，即静态代理、动态代理(JDK代理、接口代理)和Cblib代理(可以在内存中动态创建对象，不需要实现接口，属于动态代理范畴)。

二、实现
1）静态代理
静态代理在使用时，需要定义接口或者父类，被代理对象(即目标对象)与代理对象一起实现相同接口或继承同一个父类。

package com.giser.designpattern.proxy.staticproxy;

public interface ITeacherDao {
	void teach();
}

package com.giser.designpattern.proxy.staticproxy;

public class TeacherDao implements ITeacherDao {

	@Override
	public void teach() {
		System.out.println("正在授课。。。");
	}

}

package com.giser.designpattern.proxy.staticproxy;

// 代理对象
public class TeacherDaoProxy implements ITeacherDao {

	private ITeacherDao target;//通过接口聚合
	
	public TeacherDaoProxy(ITeacherDao target) {
		super();
		this.target = target;
	}

	@Override
	public void teach() {
		System.out.println("静态代理开始");
		target.teach();
		System.out.println("静态代理结束");
	}

}

测试

package com.giser.designpattern.proxy.staticproxy;

public class Client {
	public static void main(String[] args) {
		// 1、创建目标对象，即被代理对象
		TeacherDao teacherDao = new TeacherDao();
		
		// 2、创建代理对象，同时传递目标对象
		TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
		
		// 3、通过代理对象，调用目标对象的方法
		teacherDaoProxy.teach();
	}
}

注意：

优点：在不修改目标对象功能的前提下，通过代理对象扩展目标对象的功能；
缺点：由于代理对象需要实现和目标对象一样的接口，会造成很多代理类；
一旦几口增加方法，则目标对象和代理对象都需要维护。

2）动态代理
在动态代理中，代理对象不需要实现接口，但是目标对象需要实现接口，否则不能使用动态代理；主要通过JDK的API在内存中动态构建代理对象；动态代理也称为JDK代理、接口代理。

package com.giser.designpattern.proxy.dynamicproxy;

public interface ITeacherDao {
	void teach();
	void sayHello(String name);
}

package com.giser.designpattern.proxy.dynamicproxy;

public class TeacherDao implements ITeacherDao {
	@Override
	public void teach() {
		System.out.println("teach...");
	}

	@Override
	public void sayHello(String name) {
		System.out.println("Hello " + name);
	}
}

package com.giser.designpattern.proxy.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 
 * @Note {代理工厂，生成代理对象}
 * @author giserDev
 * @Date 2020-04-11 12:48:05
 */
public class ProxyFactory  {
	
	/**
	 * 	维护一个目标对象
	 */
	private Object target;

	public ProxyFactory(Object target) {
		this.target = target;
	}
	
	public Object getProxyInstance() {
		/**newProxyInstance参数说明：
		 * loader： the class loader to define the proxy class 
		 * 						 定义目标对象的类加载器
		 * interfaces： the list of interfaces for the proxy class to implement 
		 * 						目标对象实现的接口列表 
		 * h： the invocation handler to dispatch method invocations to
		 * 						 执行目标对象的方法时，会触发事情处理器方法, 会把当前执行的目标对象方法作为参数传入
		 */
		return 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代理开始");
						/**invoke方法的参数含义：
						 * obj： the object the underlying method is invoked from 被调用的方法来源于的对象
						 * args： the arguments used for the method call 方法的参数
						 */
						Object retVal = method.invoke(target, args);
						System.out.println("JDK代理结束");
						return retVal;
					}
				});
	}
	
}

测试

package com.giser.designpattern.proxy.dynamicproxy;

public class Client {
	
	public static void main(String[] args) {
		// 创建目标对象
		ITeacherDao target = new TeacherDao();
		
		// 为目标对象创建代理对象
		ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
		
		// 通过代理对象调用目标对象的方法
		proxyInstance.teach();
		proxyInstance.sayHello("giser");
	}

}

3）Cglib代理
静态代理和JDK代理模式都要求目标对象实现一个接口，但有时候目标对象只是一个单独的对象，并没有实现任何接口，此时可以使用慕白哦对象的子类来实现代理，即Cglib代理。
Cglib代理又称为子类代理，它是在内存中构建一个子类对象，从而实现对目标对象功能的扩展。Cglib是一个强大的、高性能的代码生成包，可以在运行期扩展类和接口，它广泛地应用在需要AOP框架中，如Spring AOP，实现方法拦截。其底层是通过使用字节码处理框架ASM来转换字节码并生成新的类。
在AOP编程中如何选择代理模式，有以下两个方面：
其一，目标对象需要实现接口，用JDK代理；
其二，目标对象不需要实现接口，使用Cglib代理。

Cglib代理需要引入相关jar包，如下：

<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm-commons -->
<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-commons</artifactId>
    <version>8.0.1</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm-tree -->
<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-tree</artifactId>
    <version>8.0.1</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm</artifactId>
    <version>8.0.1</version>
</dependency>

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

实现

package com.giser.designpattern.proxy.cglibproxy;

public class TeacherDao {

	public String teach() {
		System.out.println("cglib代理，不需要实现接口");
		return "cglib";
	}
	
}

package com.giser.designpattern.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;

/**
 * @Note {cglib代理}
 * @author giserDev
 * @Date 2020-04-11 16:12:23
 */
public class ProxyFactory implements MethodInterceptor {
	
	// 维护一个目标对象
	private Object target;
	
	// 构造器 传入一个被代理的对象
	public ProxyFactory(Object target) {
		this.target = target;
	}

	// 返回一个代理对象： 是target对象的代理对象
	public Object getProxyInstance() {
		// 1、创建一个工具类
		Enhancer enhancer = new Enhancer();
		// 2、设置父类
		enhancer.setSuperclass(target.getClass());
		// 3、设置回调函数
		enhancer.setCallback(this);
		// 4、创建子类对象，即代理对象
		return enhancer.create();
	}

	@Override
	public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
		System.out.println("Cglib代理模式start");
		Object returnVal = method.invoke(target, args);
		System.out.println("Cglib代理模式submit");
		return returnVal;
	}
	
}

测试：

package com.giser.designpattern.proxy.cglibproxy;

/**
 1. @Note {cglib代理}
 2. @author giserDev
 3. @Date 2020-04-11 16:21:53
 */
public class Client {
	public static void main(String[] args) {
		// 创建目标对象
		TeacherDao target = new TeacherDao();
		// 获取代理对象，并且将目标对象传递给代理对象
		TeacherDao proxyInstance = (TeacherDao) new ProxyFactory(target).getProxyInstance();
		
		// 执行代理方法
		String result = proxyInstance.teach();
		System.out.println(result);
	}
}

注意：
a、在内存中动态构建子类，注意代理的类不能为final，否则会报错java.lang.IllegalArgumentException。
b、目标对象的方法如果为final或static，则不会被拦截，即不会执行目标对象额外的业务方法。

三、几种常见的代理总结
1）防火墙代理
内网通过代理穿透防火墙，实现对公网的访问。
2）缓存代理
如当请求图片、文件等资源时，先从缓存代理取资源，如取到则返回，否则从公网或数据库取，然后放入缓存。
3）远程代理
即远程对象的本地代理，通过它可以把远程对象当作本地对象来调用。远程代理通过网络和真正的远程对象通信。
4）同步代理
主要用于多线程编程中，完成多线程间的同步。