代理模式是一种常用的结构型设计模式，其目的就是为其他对象提供一个代理以控制对该对象的访问，对该对象解耦，同时在不更改该对象的情况下，扩展该对象的功能。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理，可以在不更改目标对象（委托类）的情况下，扩展功能。代理分为静态代理和动态代理。
1、静态代理
静态代理：由程序员手动创建代理类，在程序运行前代理类的.class文件就已经存在了。静态代理在使用时，需要定义接口或者父类，委托类（目标对象）和代理类需要一起实现同一接口或者继承同一父类。
接口类：
定义一只程序猿，有一个通用功能需要实现
public interface ICoder {
public void commonFunc();
}
目标对象：
实现通用功能
public class CoderImpl implements ICoder {
@Override
public void commonFunc() {
System.out.println("----commonFunc-----");
}
}
代理对象：
产品经理来了一个新需求，在原有功能上，增加新功能，通用功能有其他地方在用不能更改。因此可以新建一个类将原先的代理复制过来，但是这样会导致以后维护困难；这时代理出现了，代理目标对象，并赋予新功能。
public class CoderImplProxy implements ICoder {
// 目标对象接口
private ICoder iCoder;
public CoderImplProxy(ICoder iCoder) {
super();
this.iCoder = iCoder;
}
@Override
public void commonFunc() {
iCoder.commonFunc();
System.out.println("-----specificFunc-----");
}
}
测试类：
public class CoderTest {
public static void main(String[] args) {
ICoder coderImpl = new CoderImpl();
ICoder codeImplProxy = new CoderImplProxy(coderImpl);
codeImplProxy.commonFunc();
}
}
测试结果
----commonFunc-----
-----specificFunc-----
2、动态代理
上面的代理，使客户端可以不需要知道目标对象的具体实现，只要知道代理对象即可（解耦），但是因为需要同目标对象实现相同的接口，当要求对不同的对象代理时，就需要对不同的对象分别进行代理，系统大时无法处理；同时目标对象增加了新的方法，代理对象也要增加方法，增加了维护难度。动态代理很好的解决了这些问题。
动态代理：代理类在程序运行时创建的代理方式。动态代理通过反射机制实现动态代理，能代理各种不同的对象。
2.1 jdk动态代理
接口类：
跟静态代理一样，定义一只程序猿，有一个通用功能需要实现
public interface ICoder {
public void commonFunc(String funcName, int index);
}
目标对象：
通用方法的实现
public class CoderImpl implements ICoder {
@Override
public void commonFunc(String funcName, int index) {
System.out.println("第"+index+"个方法，名为"+funcName);
}
}
代理类：
Java的动态代理，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy类的支持，实现InvocationHandler接口。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class CoderProxyFactory implements InvocationHandler {
// 目标对象接口，此处用Object，可以代理所有的目标对象
private Object target;
/**
* 绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。
* @param target
* @return
*/
public Object newProxyInstance(Object target){
this.target=target;
//该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
//第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器
//第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口
//第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法
//根据传入的目标返回一个代理对象
return Proxy.newProxyInstance(
target.getClass().getClassLoader(), // 类加载器
target.getClass().getInterfaces(), //
this
);
}
//关联的这个实现类的方法被调用时将被执行
// InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
Object result=null;
try{
//调用目标方法
result = method.invoke(target, args);
// 扩展
System.out.println("-----specificFunc-----");
}catch(Exception e){
e.printStackTrace();
throw e;
}
return result;
}
}
测试类
public class CoderTest {
public static void main(String[] args) {
CoderProxyFactory coderProxyFactory = new CoderProxyFactory();
ICoder coderImpl = (ICoder) coderProxyFactory.newProxyInstance(new CoderImpl());
coderImpl.commonFunc("sayHello", 2);
}
}
2.2 cglib代理
虽然动态代理不需要对每个目标对象做代理，但是我们发现，无论是静态代理还是jdk动态代理，所代理的对象都是实现一个或多个接口，也即是针对接口做代理。如果需要针对类做代理，可以通过cglib代理实现。
目标对象
public class Coder {
public Integer commonFunc(String funcName, int index) {
System.out.println("第"+index+"个方法，名为"+funcName);
return 1;
}
}
代理类
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class ProxyFactory implements MethodInterceptor {
private Object target;
public ProxyFactory(Object target) {
super();
this.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 obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
Object result=null;
try{
//调用目标方法
result = method.invoke(target, args);
// 扩展
System.out.println("-----specificFunc-----");
}catch(Exception e){
e.printStackTrace();
throw e;
}
return result;
}
}
测试类
public class CglibTest {
public static void main(String[] args) {
Coder target = new Coder();
Coder proxy = (Coder) new ProxyFactory(target).getProxyInstance();
Integer res = proxy.commonFunc("sayHello", 2);
System.out.println(res);
}
}
至此，java的三种代理实现就介绍完了。
cglib动态代理也可以针对接口做代理，跟jdk动态代理一样都是在运行期生成字节码，但是cglib动态代理的实现原理更复杂，效率也比jdk动态更低，这个以后再详细讨论。
网友评论