代理设计模式
代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
RealSubject 是原对象（本文把原对象称为"委托对象"），Proxy 是代理对象。
Subject 是委托对象和代理对象都共同实现的接口。
Request() 是委托对象和代理对象共同拥有的方法
public class ProxyDemo {
public static void main(String args[]){
RealSubject subject = new RealSubject();
Proxy p = new Proxy(subject);
p.request();
}
}
interface Subject{
void request();
}
class RealSubject implements Subject{
public void request(){
System.out.println("request");
}
}
class Proxy implements Subject{
private Subject subject;
public Proxy(Subject subject){
this.subject = subject;
}
public void request(){
System.out.println("PreProcess");
subject.request();
System.out.println("PostProcess");
}
}
- 定义一个委托类和公共接口。
- 自己定义一个类（调用处理器类，即实现 InvocationHandler 接口），这个类的目的是指定运行时将生成的代理类需要完成的具体任务（包括Preprocess和Postprocess），即代理类调用任何方法都会经过这个调用处理器类（在本文最后一节对此进行解释）。
- 生成代理对象（当然也会生成代理类），需要为他指定(1)委托对象(2)实现的一系列接口(3)调用处理器类的实例。因此可以看出一个代理对象对应一个委托对象，对应一个调用处理器实例。
Java 实现动态代理主要涉及以下几个类：
java.lang.reflect.Proxy: 这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy 类，即 DynamicProxyClass extends Proxy。
java.lang.reflect.InvocationHandler: 这里称他为"调用处理器"，他是一个接口，我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现 InvocationHandler 接口。
Proxy 类主要方法为：
//创建代理对象
static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler handler)
{
//1. 根据类加载器和接口创建代理类
Class clazz = Proxy.getProxyClass(loader, interfaces);
//2. 获得代理类的带参数的构造函数
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });
//3. 创建代理对象，并制定调用处理器实例为参数传入
Interface Proxy = (Interface)constructor.newInstance(new Object[] {handler});
}
具体过程：
public class DynamicProxyDemo01 {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject(); //1.创建委托对象
ProxyHandler handler = new ProxyHandler(realSubject); //2.创建调用处理器对象
Subject proxySubject = (Subject)Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
RealSubject.class.getInterfaces(), handler); //3.动态生成代理对象
proxySubject.request(); //4.通过代理对象调用方法
}
}
/**
* 接口
*/
interface Subject{
void request();
}
/**
* 委托类
*/
class RealSubject implements Subject{
public void request(){
System.out.println("====RealSubject Request====");
}
}
/**
* 代理类的调用处理器
*/
class ProxyHandler implements InvocationHandler{
private Subject subject;
public ProxyHandler(Subject subject){
this.subject = subject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("====before====");//定义预处理的工作，当然你也可以根据 method 的不同进行不同的预处理工作
Object result = method.invoke(subject, args);
System.out.println("====after====");
return result;
}
}
cglib动态代理：
public class TransctionHandle implements InvocationHandler{
// 增强
private TransactionManagear tx;
private Object object;
public TransctionHandle(TransactionManagear tx,Object object){
this.tx = tx;
this.object = object;
}
/**
* proxy:代理对象
* method：目标对象中正在执行的方法
* args：参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
tx.begin();
Object invoke = method.invoke(object, args); //调用目标方法
tx.commit();
return invoke;
}
}
public void testDynamicProxy() {
// 1.增强
TransactionManagear tx = new TransactionManagear();
// 2.目标对象
UserServiceImpl userService = new UserServiceImpl();
// 3.实例化拦截器
TransactionManagerInterceptor tmi = new TransactionManagerInterceptor(tx);
// 4.创建代理类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(userService.getClass()); // 设置目标对象
enhancer.setCallback(tmi);
// 5.得到代理对象
UserServiceImpl userServiceProxy = (UserServiceImpl)enhancer.create();
// 6.调用目标方法
userServiceProxy.add();
System.out.println("==========================");
userServiceProxy.fidnById(10);
}
静态代理和jdk动态代理对比：
-
静态代理
1)必须要有接口
2)代理类和目标对象都要实现该接口
3)由代理对象调用目标对象
4)可以实现AOP的思想，但是每个目标对象都要创建一个代理，代理类过多。 -
jdk实现动态代理
1)如何实现
a)定义handle
1)要写一个handle实现InvocationHandler
2)在这个handle里面传入
a)目标对象
b)增强
c)创建代理对象
1)目标对象的类加载器
2)目标对象的接口
3)自定义的handle
2)动态代理解决了静态代理遗留的问题(代理类过多)，但是它也存在缺点，必须要有接口 -
基于cglib实现的动态代理
1)定义一个方法的拦截器
a)要实现MethodInterceptor接口
2)通过Enhancer创建代理对象
a)要设置父类的calss
b)要设置拦截器
3)底层实现
1)给目标对象创建一个子类，所以在设置的时候enhancer.setSuperclass(userService.getClass())
2)复写父类中的方法
3)给子类的方法加了一个拦截器
3)我们看到的代理对象其实就是子类
4)缺点是给目标对象中的所有方法都加了增加
