代理模式
代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。
下来，看一个很简单的代理模式的描述：
/*Subject类，定义了RealSubject和Proxy的公用接口，
这样就可以在任何使用RealSubject的地方使用Proxy
*/
public abstract class Subject {
public abstract void request();
}
/*RealSubject类，定义Proxy所代表的真实实体
*/
public class RealSubject extends Subject {
@Override
public void request() {
System.out.println("真实的请求");
}
}/*Proxy类，保存一个引用使得代理可以访问实体，并提供一个与
Subject的接口相同的接口，这样代理就可以用来代替实体
*/
public class Proxy extends Subject {
private RealSubject realSubject;
@Override
public void request() {
if(realSubject == null) {
realSubject = new RealSubject();
}
realSubject.request();
}
}public class Client {
public static void main(String[] args) {
Proxy proxy = new Proxy();
proxy.request();
}
}以上代码，完成了一个很简单很简单的代理模式，用Proxy的代理对象来访问RealSubject真实实体。
那么，代理模式到底是什么呢，到底有什么用呢？我觉得，提前明白它的应用场景，才能更好的掌握代理模式。以下是从大话设计模式中摘抄的，分为四种应用场景：
1、远程代理，也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。
2、虚拟代理，是根据需要创建开销很大的对象。用过它来存放实例化需要很长时间的真实对象。
3、安全代理，用来控制真实对象访问时的权限。
4、智能指引，指当调用真实的对象时，代理处理另外一些事。
代理模式其实就是在访问对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。客户端(Client)并不直接调用实际的对象(上面的RealSubject)，而是通过调用代理(Proxy)，来间接的调用实际的对象。代理模式的使用场合，一般是由于客户端不想直接访问实际对象，或者访问实际的对象存在技术上的障碍，因而通过代理对象作为桥梁，来完成间接访问。
java代理机制的实现：
一：静态代理
public interface IYcyProgram {
public void programming();
}public class YcyProgram implements IYcyProgram {
private String name;
public YcyProgram(String name) {
this.name = name;
}
@Override
public void programming() {
System.out.println("杨朝阳在编程");
}
}
public class YcyProxy implements IYcyProgram {
private IYcyProgram ycy;
public YcyProxy(IYcyProgram ycy) {
this.ycy = ycy;
}
@Override
public void programming() {
System.out.println("写一个日志......");
this.ycy.programming();
}
}public class Test {
public static void main(String[] args) {
IYcyProgram ycy = new YcyProgram("杨朝阳");
ycy.programming();
IYcyProgram ycyProxy = new YcyProxy(ycy);
ycyProxy.programming();
}
}静态代理的总结
优点：可以做到不对目标对象进行修改的前提下，对目标对象进行功能的扩展和拦截。
缺点：因为代理对象，需要实现与目标对象一样的接口，会导致代理类十分繁多，不易维护，同时一旦接口增加方法，则目标对象和代理类都需要维护。
二：动态代理之InvocationHandler
AOP的原理就是java的动态代理机制。动态代理是指动态的在内存中构建代理对象（需要我们制定要代理的目标对象实现的接口类型），即利用JDK的API生成指定接口的对象，也称之为JDK代理或者接口代理。先明白以下的基础概念：
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
proxy: 指代我们所代理的那个真实对象
method: 指代的是我们所要调用真实对象的某个方法的Method对象
args: 指代的是调用真实对象某个方法时接受的参数
Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法，这个方法的作用就是得到一个动态的代理对象，其接收三个参数，我们来看看这三个参数所代表的含义：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException
loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
interfaces: 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
h: 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
看代码：
ISubject接口:
public interface ISubject {
public void request();
public void fun();
}
实现了ISubject接口的具体类RealSubject：
public class RealSubject implements ISubject {
public RealSubject() {
}
@Override
public void request() {
System.out.println("真实的请求");
}
@Override
public void fun() {
System.out.println("fun");
}
}动态代理类SubProxy，实现了InvocationHandler接口：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class SubProxy implements InvocationHandler {
private Object obj; // 这是我们要代理的真实对象
public SubProxy(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("代理真实对象前的操作");
// 当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
method.invoke(obj, args);
System.out.println("代理真实对象后的操作");
return null;
}
}测试Test类：
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
// 我们要代理的真实对象
ISubject realSubject = new RealSubject();
// 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
SubProxy subProxy = new SubProxy(realSubject);
/*
* 通过Proxy的newProxyInstance方法来创建我们的代理对象，来看看其三个参数 第一个参数
* handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
* 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，
* 表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了 第三个参数handler， 我们这里将这个代理对象关联到了上方的
* InvocationHandler 这个对象上
*/
ISubject subjectProxy = (ISubject) Proxy.newProxyInstance(subProxy.getClass().getClassLoader(),
realSubject.getClass().getInterfaces(), subProxy);
System.out.println(subjectProxy.getClass().getName());
subjectProxy.request();
subjectProxy.fun();
}
}
运行结果：
三：动态代理之CGLIB
JDK代理要求被代理的类必须实现接口，有很强的局限性。而CGLIB动态代理则没有此类强制性要求。简单的说，CGLIB会让生成的代理类继承被代理类，并在代理类中对代理方法进行强化处理(前置处理、后置处理等)。在CGLIB底层，其实是借助了ASM这个非常强大的Java字节码生成框架。
使用CGLib实现动态代理，完全不受代理类必须实现接口的限制，而且CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类（利用Enhancer类提供的setSuperclass()方法）。
1、被代理类：
定义一个类，该类没有实现任何接口：
public class NormalClass {
private int num;
public NormalClass() {
}
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
public final void fun() {
System.out.println("这是一个final方法！");
}
public void normalAction(String str) {
System.out.println(str + ":" + num);
}
}2、拦截器：
拦截器接口：
public interface IIntercepter {
boolean before(Object objject, Object[] args);
void after(Object object, Object result);
void occurException(Object object, Throwable e);
}拦截器类，可以给里面的方法写出拦截的具体过程，或者直接在测试类里面定义匿名类，实现具体的拦截过程：
import java.lang.reflect.Method;
public abstract class IntercepterAdpter implements IIntercepter {
private Class<?> klass;
private Method method;
public IntercepterAdpter(Class<?> klass, Method method) {
this.klass = klass;
this.method = method;
}
public Class<?> getKlass() {
return klass;
}
public Method getMethod() {
return method;
}
@Override
public boolean before(Object object, Object[] args) {
return true;
}
@Override
public void after(Object object, Object result) {
}
@Override
public void occurException(Object object, Throwable e) {
}
}在CGLIB代理具体实现类中，给出生成动态代理对象的方法。可以把拦截器加在一个List中，形成拦截器链，给出增加，删除拦截器的方法。在代理对象调用方法时，CGLib会回调MethodInterceptor接口方法拦截，所以，可以在其前，后，异常情况下，遍历拦截器链List，看看有没有对此方法进行拦截。
public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy)参数：Object为由CGLib动态生成的代理类实例，Method为上文中实体类所调用的被代理的方法引用，Object[]为参数值列表，MethodProxy为生成的代理类对方法的代理引用。
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CGLibProxy {
private volatile static List<IntercepterAdpter> intercepters;
public CGLibProxy() {
if (intercepters == null) {
synchronized (CGLibProxy.class) {
if (intercepters == null) {
intercepters = new ArrayList<>();
}
}
}
}
public void addIntercepter(IntercepterAdpter intercepter) {
if (intercepters.contains(intercepter)) {
return;
}
intercepters.add(intercepter);
}
public void removeIntercepter(IntercepterAdpter intercepter) {
if (!intercepters.contains(intercepter)) {
return;
}
intercepters.remove(intercepter);
}
@SuppressWarnings("unchecked")
public <T> T getProxy(T obj) {
Class<?> klass = obj.getClass();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(klass);
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy)
throws Throwable {
Object result = null;
for (IntercepterAdpter intercepter : intercepters) {
if (!(klass.equals(intercepter.getKlass()) && method.equals(intercepter.getMethod()))) {
continue;
}
if (intercepter.before(obj, args) == false) {
return result;
}
}
try {
result = method.invoke(obj, args);
for (IntercepterAdpter intercepter : intercepters) {
if (!(klass.equals(intercepter.getKlass()) && method.equals(intercepter.getMethod()))) {
continue;
}
intercepter.after(obj, result);
}
} catch (Throwable th) {
for (IntercepterAdpter intercepter : intercepters) {
if (!(klass.equals(intercepter.getKlass()) && method.equals(intercepter.getMethod()))) {
continue;
}
intercepter.occurException(obj, th);
}
}
return result;
}
});
return (T) enhancer.create();
}
}
测试类Test：
import java.lang.reflect.Method;
public class Test {
public static void main(String[] args) {
Method method1;
Method method2;
Method method3;
try {
method1 = NormalClass.class.getMethod("normalAction", new Class<?>[] { String.class });
new CGLibProxy().addIntercepter(new IntercepterAdpter(NormalClass.class, method1) {
@Override
public void occurException(Object object, Throwable e) {
}
@Override
public void after(Object object, Object result) {
System.out.println("在方法" + method1.getName() + "()执行之后……1");
}
@Override
public boolean before(Object object, Object[] args) {
System.out.println("在方法" + method1.getName() + "()执行之前……1");
return true;
}
});
NormalClass normalClass = new CGLibProxy().getProxy(new NormalClass());
normalClass.normalAction("1234");
normalClass.fun();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
}
}
}注意：测试类中，对NormalClass类中的fun()方法和normalAction()方法进行了拦截，但是，结果却有一点点不一样：
发现，对 normalAction()进行了正常的拦截，却没有对fun()方法进行拦截，回过头看一看，原来，fun()方法被定义为了final，所以，需要特别记住一点：CGLib不能对声明为final的方法进行代理，因为CGLib原理是动态生成被代理类的子类。
