代理模式（Proxy pattern）
- 核心作用：
通过代理，控制对对象的访问,可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。
AOP(Aspect Oriented Programming面向切面编程）的核心实现机制。 - 核心角色：
**抽象角色：**定义代理角色和真实角色的公共对外方法。
**真实角色：**实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。
关注真正的业务逻辑
**代理角色：**实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并附加自己的操作。
将统一的流程控制放到代理角色中处理。 - 应用场景：
安全代理：屏蔽对真实决角色的直接访问
远程代理：通过代理类处理远程方法调用（RMI）
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。 - 分类：
4.1静态代理：
接口类定义Star：
public interface Star {
/**面试*/
void confer();
/**签合同*/
void signContract();
/**订机票*/
void bookTicket();
/**唱歌*/
void sing();
/**收没款*/
void collectMoney();
}
真实对象RealStar:
public class RealStar implements Star {
@Override
public void confer() {
System.out.println("RealStar confer()");
}
@Override
public void signContract() {
System.out.println("RealStar signContract()");
}
public void bookTicket() {
System.out.println("RealStar bookTicket()");
}
@Override
public void sing() {
System.out.println("RealStar(明星) sing()");
}
@Override
public void collectMoney() {
System.out.println("RealStar collectMoney()");
}
}
代理类ProxyStar：
public class ProxyStar implements Star {
RealStar realStar;
public ProxyStar(RealStar realStar) {
super();
this.realStar = realStar;
}
@Override
public void confer() {
System.out.println("ProxyStar confer");
}
@Override
public void signContract() {
System.out.println("ProxyStar signContract");
}
@Override
public void bookTicket() {
System.out.println("ProxyStar bookTicket");
}
@Override
public void sing() {
realStar.sing();//真实的对象去做
}
@Override
public void collectMoney() {
System.out.println("ProxyStar collectMoney");
}
}
测试：
public class Testd {
public static void main(String[] args) {
RealStar realStar=new RealStar();
ProxyStar proxyStar=new ProxyStar(realStar);
proxyStar.confer();
proxyStar.signContract();
proxyStar.sing();
proxyStar.collectMoney();
}
}
结论
4.2动态代理：
相比静态代理优先：抽象角色中（接口）声明的所以方法都被转移待调用处理器一个集中的方法处理，这样，我们可以使用更加灵活和统一的处理众多的方法。
4.2.1 JDK自带动态代理
java.lang.reflect.InvocationHandler (处理器接口)
可以通过invoke方法实现对真实角色的代理访问
每次通过Proxy生成代理类对象时都要指定对应的处理器对象
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
JdkInterface jdk;
public MyInvocationHandler(JdkInterface jdk) {
this.jdk = jdk;
}
//java.lang.reflect.InvocationHandler (处理器接口)
//可以通过invoke方法实现对真实角色的代理访问
//每次通过Proxy生成代理类对象时都要指定对应的处理器对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("前置处理：目标方法执行之前");//目标方法执行之前处理逻辑与业务
method.invoke(jdk, args);//执行目标方法
System.out.println("后置处理：目标方法执行之后");//目标方法执行之后处理逻辑
return null;
}
}
接口定义：
public interface JdkInterface {
void say(String message);
}
实现类：
public class JDKInterfaceImpl implements JdkInterface {
@Override
public void say(String message) {
System.out.println("输出语句："+message);
}
}
测试方法
import java.lang.reflect.Proxy;
public class TestMy {
public static void main(String[] args) {
JdkInterface jdkInterfaceImpl=new JDKInterfaceImpl();
MyInvocationHandler my=new MyInvocationHandler(jdkInterfaceImpl);
JdkInterface projdk= (JdkInterface)Proxy.newProxyInstance(jdkInterfaceImpl.getClass().getClassLoader(), jdkInterfaceImpl.getClass().getInterfaces(), my);
//Proxy.newProxyInstance(loader, interfaces, h);
//ClassLoader loader :指定当前目标对象使用类加载器，写法固定
//Class<?>[] interfaces:目标对象实现的接口的类型，写法固定
//InvocationHandler h :事件处理接口，需传入一个实现类，一般使用匿名内部类
projdk.say("目标方法执行");
}
}
4.2.2 javaassist字节码操作库实现
4.2.3 CGLIB
目标类不能为final,目标对象的方法如果为final/static,那么就不会被拦截，即不会执行目标对象额外的业务方法。
该类实现了创建子类的方法与代理的方法。getProxy(SuperClass.class)方法通过入参即父类的字节码，通过扩展父类的class来创建代理对象。intercept()方法拦截所有目标类方法的调用，obj表示目标类的实例，method为目标类方法的反射对象，args为方法的动态入参，proxy为代理类实例。proxy.invokeSuper(obj, args)通过代理类调用父类中的方法。
定义目标类：
public class Chinese {
/**目标方法未实现任何的接口*/
public void sing() {
System.out.println("吃面条");
}
}
定义CGLIB代理类工场
public class ProxyFactory implements MethodInterceptor {
//给目标对象创建一个代理对象
public Object getProxyInstance(Class target) {
//1.工具类
Enhancer enhancer=new Enhancer();
//2.设置父类
enhancer.setSuperclass(target);
//3.设置回调函数
enhancer.setCallback(this);
//4.通过字节码技术动态创建子类实例（代理对象）
return enhancer.create();
}
//实现MethodInterceptor接口方法
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("执行目标方法之前：拿起筷子");
Object object = proxy.invokeSuper(obj, args);//调用父类中的方法，执行目标方法
System.out.println("执行目标方法之后：放下筷子");
return object;
}
}
测试方法：
public class CGLIBMain {
public static void main(String[] args) {
ProxyFactory proxyFactory= new ProxyFactory();
//通过生成子类的方式创建代理类
Chinese proxyInstance = (Chinese)proxyFactory.getProxyInstance(Chinese.class);
proxyInstance.sing();
System.out.println();
System.out.println(proxyInstance);
}
}
执行结果：
第二种参数写法
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();
}
//实现MethodInterceptor接口方法
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("执行目标方法之前：拿起筷子");
Object object = method.invoke(target, args);//调用父类中的方法，执行目标方法
System.out.println("执行目标方法之后：放下筷子");
return object;
}
}
测试方法：
public class CGLIBMain {
public static void main(String[] args) {
Chinese chinese=new Chinese();
ProxyFactory proxyFactory= new ProxyFactory(chinese);
//通过生成子类的方式创建代理类
Chinese proxyInstance = (Chinese)proxyFactory.getProxyInstance();
proxyInstance.sing();
System.out.println();
System.out.println(proxyInstance);
}
}
测试结果
4.2.4 ASM(底层使用指令，可维护性较差）