一、代理模式
为其他对象提供一个代理以控制对某个对象的访问。代理类主要负责为委托了(真实对象)预处理消息、过滤消息、传递消息给委托类,代理类不现实具体服务,而是利用委托类来完成服务,并将执行结果封装处理。
其实就是代理类为被代理类预处理消息、过滤消息并在此之后将消息转发给被代理类,之后还能进行消息的后置处理。代理类和被代理类通常会存在关联关系(即上面提到的持有的被带离对象的引用),代理类本身不实现服务,而是通过调用被代理类中的方法来提供服务。
二、静态代理
创建一个接口,然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类,同时使其也实现这个接口。在代理类中持有一个被代理对象的引用,而后在代理类方法中调用该对象的方法。
举例:
1.接口:
public interface HelloInterface {
void sayHello();}
2.被代理类:
public class Hello implements HelloInterface{
@Override
public void sayHello() {
System.out.println("Hello zhanghao!");
}
}
3.代理类:
public class HelloProxy implements HelloInterface{
private HelloInterface helloInterface = new Hello();
@Override
public void sayHello() {
System.out.println("Before invoke sayHello" );
helloInterface.sayHello();
System.out.println("After invoke sayHello");
}
}
4.代理类调用:
被代理类被传递给了代理类HelloProxy,代理类在执行具体方法时通过所持用的被代理类完成调用。
public static void main(String[] args) {
HelloProxy helloProxy = new HelloProxy();
helloProxy.sayHello();
}
//输出:
Before invoke sayHello
Hello zhanghao!
After invoke sayHello
使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来:由于代理只能为一个类服务,如果需要代理的类很多,那么就需要编写大量的代理类,比较繁琐。
三、动态代理
利用反射机制在运行时创建代理类。
1.接口、被代理类不变,我们需要构建一个handler类来实现InvocationHandler接口,
并且持有代理对象的引用。
-
用户使用代理类调用接口方法时,会触发 handler所实现的 invoke方法。 真正原有对象的方法是通过反射的方式调用的,即method.invoke(target, args)。
public class ProxyHandler implements InvocationHandler{
private Object object;
public ProxyHandler(Object object){
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before invoke " + method.getName());
method.invoke(object, args);
System.out.println("After invoke " + method.getName());
return null;
}
}
2.执行动态代理:
-
通过java.lang.reflect.Proxy的静态方法 newProxyInstance创建目标对象的代理对象
-
newProxyInstance方法的入参依次是 代理对象的类加载器ClassLoader loader, 代理对象实现的接口列表Class<?>[] interfaces、以及 我们自己实现的InvocationHandler h
public static void main(String[] args) {
System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
HelloInterface hello = new Hello();
InvocationHandler handler = new ProxyHandler(hello);
HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
proxyHello.sayHello();
}
输出:
Before invoke sayHello
Hello zhanghao!
After invoke sayHello
通过Proxy类的静态方法newProxyInstance返回一个接口的代理实例。针对不同的代理类,传入相应的代理程序控制器InvocationHandler。
四、动态代理底层实现
动态代理具体步骤:
-
1. 通过实现 InvocationHandler 接口创建自己的调用处理器;
-
2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类;
-
3. 通过反射机制获得动态代理类的构造函数,其唯一参数类型是调用处理器接口类型;
-
4. 通过构造函数创建动态代理类实例,构造时调用处理器对象作为参数被传入。
最主要的是上面截图的代码:用来生成代理类对象
Class<?> cl = getProxyClass0(loader, intfs);
首先去获取生成的代理类类实例Class<?> cl,getProxyClass0(loader, intfs)方法会首先判断该类实例是否在内存中,如果在则直接获取,如果不在,则进行生成。
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
//如果接口数量大于65535,抛出非法参数错误
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//如果指定接口的代理类已经存在与缓存中,则不用新创建,直接从缓存中取即可;
//如果缓存中没有指定代理对象,则通过ProxyClassFactory来创建一个代理对象。
return proxyClassCache.get(loader, interfaces);
}
然后获取类实例的构造函数。
final Constructor<?> cons = cl.getConstructor(constructorParams);
可以看到,cl.getConstructor代码获取的是参数类型为的constructorParams构造函数,该类型在Proxy类中有定义:
private static final Class<?>[] constructorParams =
{ InvocationHandler.class };
该类型即为我们实现的接口InvocationHandler。最后通过反射调用构造函数来创建类实例,其入参即为Proxy.newInstance传入的第三个参数h,即我们创建的LogJdkHandler对象:
return cons.newInstance(new Object[]{h});