谈及设计模式里面的代理模式,不得不说,这个模式在网上有很多的应用场景。例如说,Spring里面的代理机制,dubbo的动态代理模式生成proxy过程等等。
代理模式的概念:
代理模式是指使用代理对象来执行某一个对象所要执行的相应方法。
我们常说的代理模式主要划分为了两种类型:
静态代理
所谓的静态代理我的认识就是一种灵活性较差的代理设计。其基本的设计结构图如下所示:
每次做代理的时候,都需要实现原来的接口方法,然后在构造函数中将相应的代理对象给注入进去。这样子做起来显得有点繁琐。如果说我们不去实现它相应的接口的话,那么这样所带来的效果就不是叫做代理了。(因为只能实现接口中的部分功能,并不够完善)。
例如说以下案例代码:
/**
* 作者:idea
* 日期:2018/5/30
* 描述:
*/
public interface Subject {
public void request();
}
/**
* 作者:idea
* 日期:2018/5/30
* 描述:代理对象
*/
public class ProxySubject implements Subject{
public Subject subject;
public ProxySubject(){
this.subject=new RealSubject();
}
public void before(){
System.out.println("this is before");
}
public void after(){
System.out.println("this is after");
}
@Override
public void request() {
this.before();
this.subject.request();
this.after();
}
}
/**
* 作者:idea
* 日期:2018/5/30
* 描述:
*/
public class RealSubject implements Subject{
@Override
public void request() {
System.out.println("请求-------");
}
}
/**
* 作者:idea
* 日期:2018/5/30
* 描述:
*/
public class Test {
public static void main(String[] args) {
Subject subject=new ProxySubject();
subject.request(); //使用了代理对象之后,相应的请求会被横向拦截
}
}
动态代理
关于动态代理部分而言,我们常说的几种类型分别就是cglib代理,还有jdk代理了。
举个简单的jdk代理模式代码案例:
/**
* @author idea
* @data 2018/11/11
*/
public interface Decode {
String decode(String content);
}
/**
* @author idea
* @data 2018/11/11
*/
public class DecodeImpl implements Decode{
@Override
public String decode(String content){
return content+"decode";
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理工厂
*
* @author idea
* @data 2018/11/11
*/
public class InvocationFactory implements InvocationHandler {
private Object target;
public InvocationFactory(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理执行");
Object value = method.invoke(target, args);
return value;
}
public static void main(String[] args) {
InvocationHandler invocationHandler = new InvocationFactory(new DecodeImpl());
Decode decode = (Decode) Proxy.newProxyInstance(DecodeImpl.class.getClassLoader(), DecodeImpl.class.getInterfaces(), invocationHandler);
System.out.println(decode.decode("asd"));
}
}
通过上述的一个简单案例可以先大致的了解什么是jdk代理,以及jdk代理的基本实现步骤。使用jdk来进行代理的时候,要求被代理对象有相应的接口和接口实现类。在代理Proxy创建的时候需要获取到相应目标对象的类加载器,以及接口,还有InvocationHandler的实例。在InvocationHandler里面,对于invoke部分可以引用相应的对象句柄,然后进行方法的扩展实现,从而实现代理的效果。
cglib的代理机制代码案例:
/**
* @author idea
* @data 2018/11/11
*/
public class Car {
public void test(){
System.out.println("this is test");
}
}
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @author idea
* @data 2018/11/11
*/
public class CarCglib implements MethodInterceptor {
private Object target;
public Object getTarget(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 o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("cglib执行代理");
Object value = methodProxy.invokeSuper(o, objects);
return value;
}
public static void main(String[] args) {
Car car=new Car();
CarCglib carCglib=new CarCglib();
Car car2= (Car) carCglib.getTarget(car);
car2.test();
}
}
对于cglib而言,在执行代理的时候,可以动态地调整相应的返回值:
public Object getTarget2(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
//设置它的代理对象
enhancer.setSuperclass(this.target.getClass());
//回调对象
enhancer.setCallback(new FixedValue() {
@Override
public Object loadObject() throws Exception {
return "使用fixedvalue可以替换掉方法的返回值";
}
});
return enhancer.create();
}
public Object getTarget3(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
//设置它的代理对象
enhancer.setSuperclass(this.target.getClass());
//回调对象
enhancer.setCallback(new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
if (method.getDeclaringClass() != Object.class && method.getReturnType() == String.class) {
return "Hello cglib!";
} else {
return method.invoke(o, objects);
}
}
});
return enhancer.create();
}
public Object getTarget4(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
//设置它的代理对象
enhancer.setSuperclass(this.target.getClass());
//回调对象
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
if(method.getDeclaringClass() != Object.class && method.getReturnType() == String.class) {
return "Hello cglib!";
} else {
return methodProxy.invokeSuper(o, objects);
}
}
});
return enhancer.create();
}
这里面尽量少用InvocationHandler来充当回调对象,这样容易产生死循环现象的发生。
来看看下边的一个比较图:
cglib动态代理 | jdk动态代理 |
---|---|
cglib主要是通过和目标对象使用相同的一个父类,然后来实现相应的代理机制。这种机制并不要求目标对象要实现接口 | Jdk的动态代理,是使用反射技术获得类的加载器并且创建实例,根据类执行的方法在执行方法的前后发送通知。 |
代理模式的应用场景也是蛮多的,例如说Spring里面的AOP,Dubbo里面的RPC调用,都有使用到代理模式的这种思想,因此感觉这块的知识的也是蛮重要的。