1 代理
1.1 代理的概念和作用
代理的概念很好理解，就像黄牛代替票务公司给你提供票，经纪人代理艺人和别人谈合作。Java的代理是指实现类作为代理类的属性对象，代理类提供方法给外部调用，代理类内部再去调用实现类的方法，实现具体的业务。也就是代理类作为对外接口人，实现类不直接对外。这就是java代理的概念。
代理的作用是当你需要增加一些而外的操作，而又不想去修改实现类的。可以通过代理来实现，在代理类中增加附件的操作。例如需要增加权限过滤，但是业务类已经开发好，不想将权限和业务混在一起，想让每个类的功能尽可能单一，各司其职。，此时我们就可以做一个该类的代理类，由该代理类做权限判断，如果安全则调用实际类的业务开始处理。
代理分为静态代理和动态代理，动态代理有分为jdk动态代理和cglib动态代理。
1.2 静态代理
先定义一个接口Subject，然后实现类RealSubject和代理类Proxy都继承这个接口，实现接口的方法。代理类构造函数的形参是接口引用Subject subject，实现类对象作为代理类构造函数的实参传入，保存到代理类的接口类型的Subject属性中。用户调用代理类的方法，代理类方法内部通过接口引用再去调用实现类的方法。
//定义接口
interface Subject {
void request();
}
//实现类实现接口
class RealSubject implements Subject {
public void request(){
System.out.println("RealSubject");
}
}
//代理类实现接口
class Proxy implements Subject {
private Subject subject;
public Proxy(Subject subject){//代理构造函数接口形参，以实现类对象为实参
this.subject = subject;
}
public void request(){
System.out.println("begin");
subject.request();//调用实现类的方法
System.out.println("end");
}
}
//调用实例
public class ProxyTest {
public static void main(String args[]) {
RealSubject subject = new RealSubject();//创建实现类对象
Proxy p = new Proxy(subject);//创建代理类对象
p.request();//调用代理类的方法，内部再去调用实现类的request方法
}
}
1.3 Jdk动态代理
1.3.1 Jdk动态代理实现
Jdk动态代理实际上是利用了java的反射机制。利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口定义代理类的实现。将实现类的接口信息传入到代理类的静态构造函数Proxy.newProxyInstance中，代理类的构造函数内部通过反射的机制，获取实现类的方法，代理类的代理方法对实现类的方法进行了包装。调用代理类的方法，内部调用实现类的方法。实际上静态代理和动态代理本质上是一样的，只是动态代理利用的反射的机制获取实现类的方法。
（1）//定义实现类继承的接口
public interface Service {
//目标方法
public abstract void add();
}
（2）//实现类并继承接口，实现方法add
public class UserServiceImpl implements Service {
public void add() {
System.out.println("This is add service");
}
}
（3）利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口定义代理类的实现。重写InvocationHandler的invoke方法。
class MyInvocatioHandler implements InvocationHandler {
private Object target;//接口属性
public MyInvocatioHandler(Object target) {//构造函数，实参实现类对象
this.target = target;
}
//重写代理类InvocationHandler的invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("-----before-----");
Object result = method.invoke(target, args);
System.out.println("-----end-----");
return result;
}
// 生成代理对象方法
public Object getProxy() {
//获取类加载器
ClassLoader loader = Thread.currentThread().getContextClassLoader();
//获取实现类的方法接口，提供反射机制的方法名称
Class<?>[] interfaces = target.getClass().getInterfaces();
//调用Proxy的静态方法创建代理对象
return Proxy.newProxyInstance(loader, interfaces, this);
}
}
（4）使用动态代理实例
public class ProxyTest {
public static void main(String[] args) {
//创建实现类对象
Service service = new UserServiceImpl();
//实现类对象以实参形式传入代理类，保存在tartget属性中
MyInvocatioHandler handler = new MyInvocatioHandler(service);
//获取代理对象
Service serviceProxy = (Service)handler.getProxy();
//通过代理对象调用方法
serviceProxy.add();//执行方法
}
}
执行结果：
-----before-----
This is add service
-----end-----
1.3.2 Jdk动态代理反推过程
从步骤（4）开始在逆向推到一遍。先创建一个实现类对象service，作为入参传给 new MyInvocatioHandler(service);构造函数，保存在target属性中。通过getProxy()方法创建代理对象。Proxy.newProxyInstance(loader, interfaces, this);入参分别是loader加载类对象，interfaces实现类对象target的方法信息，this是MyInvocatioHandler指针。在newProxyInstance函数内部通过反射机制，根据interfaces传入的方法名称等信息，获取实现类的方法method。同时代理类内部对实现类的每个方法都对应实现了代理方法。serviceProxy.add();调用了代理类的代理方法，代理方法内部通过调用MyInvocatioHandler的invoke方法，返回invoke(Object proxy, Method method, Object[] args)去调用实现类的Method。在invoke方法里面就可以增加其他的操作，比如说日志打印；其中Method参数是通过反射机制，根据interfaces信息获取到的实现类的方法。和静态映射的原理差不多，只是将代理类进行了包装。
1.3.3 jdk代理类源码解析
为了更清楚的理解动态代理，通过以下方式把代理类字节码生成class文件。
byte[] classFile = ProxyGenerator.generateProxyClass("com.sun.proxy.$Proxy.1", service.getClass().getInterfaces());
FileOutputStream out = new FileOutputStream("com.sun.proxy.$Proxy.1.class");
out.write(classFile);
out.flush();
使用 反编译工具 jad jad com.sun.proxy.$Proxy.1 看看代理类如何实现，反编译出来的java代码如下：
//代理类继承extends类，和实现类一样也实现了Service接口
public final class $proxy1 extends Proxy implements Service {
//构造函数
public $proxy1(InvocationHandler invocationhandler) {
super(invocationhandler);
}
//代理类的代理方法
public final boolean equals(Object obj) {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[] {
obj
})).booleanValue();
}
catch(Error _ex) { }
catch(Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final String toString() {
try {
return (String)super.h.invoke(this, m2, null);
}
catch(Error _ex) { }
catch(Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
//这里调用的是实现类add代理方法
public final void add() {
try {
//内部调用的是MyInvocatioHandler的invoke方法
super.h.invoke(this, m3, null);
return;
}
catch(Error _ex) { }
catch(Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final int hashCode() {
try {
return ((Integer)super.h.invoke(this, m0, null)).intValue();
}
catch(Error _ex) { }
catch(Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
//定义静态Method变量
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
//通过反射机制和interfaces提供的信息获取实现类的方法
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
Class.forName("java.lang.Object")
});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
//通过反射机制获取实现类的方法
m3 = Class.forName("zzzzzz.Service").getMethod("add", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
}
catch(NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
}
catch(ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
}
1.4 不用实现接口的Cglib代理
1.4.1 Cglib代理的简单实现
静态代理和jdk动态代理都需要通过实现一个接口，只能对该类接口中定义的方法实现代理，这在实际编程中有一定的局限性。使用cglib[Code Generation Library]实现动态代理，并不要求实现类必须实现接口。
使用步骤
（1）先定义实现类，实现方法add
public class UserServiceImpl {
public void add() {
System.out.println("This is add service");
}
}
（2）实现MyMethodInterceptor实现MethodInterceptor接口，定义方法的拦截器intercept方法，该对象会被传入代理类中，相当于回调函数的作用，代理类内部调用intercept方法，intercept方法的四个参数：1）代理对象；2）实现类方法；3）方法参数；4）代理方法的MethodProxy对象。
public class MyMethodInterceptor implements MethodInterceptor {
public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy) throws Throwable {
System.out.println("Before:" + method);
Object object = proxy.invokeSuper(obj, arg);
System.out.println("After:" + method);
return object;
}
}
（3）利用Enhancer类生成代理类；创建Enhancer enhancer对象，将实现类作为入参传入enhancer，作为代理类的父类。设置拦截器MyMethodInterceptor 到enhancer内部，作为回调。
Enhancer enhancer = new Enhancer();//创建Enhancer类对象
enhancer.setSuperclass(UserServiceImpl.class); //传入实现类的class，为反射提供信息 ，同时实现类是Enhancer的父类
enhancer.setCallback(new MyMethodInterceptor()); //设置拦截器对象，通过拦截器回调。Enhancer是CGLib的字节码增强器，可以方便的对类进行扩展，内部调用GeneratorStrategy.generate方法生成代理类。传入了实现类作为父类，传入MyMethodInterceptor对象，作为拦截回调。
UserServiceImpl userService = (UserServiceImpl)enhancer.create();//创建代理类对象，因为代理类继承了实现类，所以可以用父类引用接收子类对象。
（4）userService.add()；方法的执行输出结果。
Before: add
This is add service
After: add
1.4.2 代理类反向编译源码解析
对(UserServiceImpl)enhancer.create();返回的代理类进行反向编译，得到代理类的源码如下。
这样可能还是不能理解，代理类内部是怎么实现的；
import net.sf.cglib.core.Signature;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
//
// Decompiled by Procyon v0.5.30
//
//（1）enhancer代码生成器自动生成了类UserService$$EnhancerByCGLIB$$394dddeb，继承了实现类UserService，实现了接口Factory。
public class UserService$$EnhancerByCGLIB$$394dddeb extends UserService implements Factory
{
private boolean CGLIB$BOUND;
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private MethodInterceptor CGLIB$CALLBACK_0;//这里保存步骤（4）中通过enhancer.setCallback(new MyMethodInterceptor());传入的对象
private static final Method CGLIB$add$0$Method;
private static final MethodProxy CGLIB$add$0$Proxy;
private static final Object[] CGLIB$emptyArgs;
static void CGLIB$STATICHOOK2() {
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
//通过反射机制获取代理类
final Class<?> forName = Class.forName("UserService$$EnhancerByCGLIB$$394dddeb");
final Class<?> forName3;
//查找到实现类的add方法
CGLIB$add$0$Method = ReflectUtils.findMethods(new String[] { "add", "()V" }, (forName3 = Class.forName("UserService")).getDeclaredMethods())[0];
//创建MethodProxy对象，每个被代理的方法都对应一个MethodProxy对象，methodProxy.invokeSuper方法最终调用实现类的add方法
CGLIB$add$0$Proxy = MethodProxy.create((Class)forName3, (Class)forName, "()V", "add", "CGLIB$add$0");//将代理类的两个代理方法传入
}
//最终调用的方法是父类，也就是实现类的方法add
final void CGLIB$add$0() {
super.add();
}
public final void add() {
MethodInterceptor cglib$CALLBACK_0;
cglib$CALLBACK_0=this. CGLIB$CALLBACK_0;
//先判断拦截器对象MethodInterceptor是否为空，不为空则执行回调intercept；
if (cglib$CALLBACK_0 != null) {
cglib$CALLBACK_0.intercept((Object)this, UserService$$EnhancerByCGLIB$$394dddeb.CGLIB$add$0$Method, UserService$$EnhancerByCGLIB$$394dddeb.CGLIB$emptyArgs, UserService$$EnhancerByCGLIB$$394dddeb.CGLIB$add$0$Proxy);
return;
}
super.add();
}
static {
CGLIB$STATICHOOK2();
}
}
1.4.3 Cglib代理的整体流程
详细步骤如下
（1） 定义实现类UserServiceImpl和拦截器MyMethodInterceptor，拦截器实现intercept方法；
（2） 创建Enhancer enhancer对象，通过enhancer.setSuperclass(UserServiceImpl.class); 传入实现类的class，作为代理类的父类。通过enhancer.setCallback(new MyMethodInterceptor()); //设置拦截器对象，保存在代理类的cglib$CALLBACK_0属性中。提供回调代理类会调用MyMethodInterceptor的函数intercept函数返回调用；
（3） Enhancer是CGLib的字节码增强器，生成代理类的代码，代理类继承了实现类UserServiceImpl，代理类实现了两个代理方法final void CGLIB$add$0()和public final void add()方法；这里不知道为什么要这样设计。CGLIB$add$0()是最终调用的方法；
（4） 创建代理类对象UserServiceImpl userService = (UserServiceImpl)enhancer.create();userService.add()；调用代理类的在步骤三中的public final void add()；方法；先判断cglib$CALLBACK_0对象是否为空。不为空，则执行MethodInterceptor的回调函数cglib$CALLBACK_0.intercept(Object obj, Method method, Object[] arg, MethodProxy proxy)；
（5） Intercept回调函数实现实际上调用了参数MethodProxy proxy的proxy.invokeSuper方法；
public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy) throws Throwable {
System.out.println("Before:" + method);
Object object = proxy.invokeSuper(obj, arg);
System.out.println("After:" + method);
return object;
}
（6） proxy又是从哪里来的呢，步骤（4）中传入的实参是这样实现的
//创建MethodProxy对象，每个被代理的方法都对应一个MethodProxy对象，methodProxy.invokeSuper方法最终调用实现类的add方法
CGLIB$add$0$Proxy = MethodProxy.create((Class)forName3, (Class)forName, "()V", "add", "CGLIB$add$0");//将代理类的两个代理方法传入
（7） 每个被代理的方法都对应一个MethodProxy对象，methodProxy.invokeSuper方法最终调用实现类的add方法proxy.invokeSuper的内部的实现如下
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
init();
FastClassInfo fci = fastClassInfo;
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
实现方法中创建了一个FastClassInfo fci对象，然后调用了fci.f2.invoke(fci.i2, obj, args);
（8）单看invokeSuper方法的实现，似乎看不出实现类add方法调用，在MethodProxy实现中，通过FastClassInfo维护了实现类和代理类的FastClass。
private static class FastClassInfo {
FastClass f1;
FastClass f2;
int i1;
int i2;
}
以add方法的methodProxy为例，f1指向实现类对象，f2指向代理类对象，i1和i2分别是方法add和CGLIB$add$0在对象中索引位置。那么fci.f2.invoke(fci.i2, obj, args);的含义就是调用代理对象的invoke方法，传入参数是代理类的实现方法CGLIB$add$0、代理对象、函数参数；
（9）这样有回到了代理类中的方法CGLIB$add$0()
final void CGLIB$add$0() {
super.add();
}
（10）super是父类的意思，指向的是实现类，然后执行实现类的add方法。绕了一个好大的圈终于绕回来了。不知道什么原因要这样搞。
1.4.4 FastClass实现机制
FastClass其实就是对Class对象进行特殊处理，提出下标概念index，通过索引保存方法的引用信息，将原先的反射调用，转化为方法的直接调用，从而体现所谓的fast，下面通过一个例子了解一下FastClass的实现机制。
1、定义原类
class Test {
public void f(){
System.out.println("f method");
}
public void g(){
System.out.println("g method");
}
}
2、定义Fast类
class FastTest {
public int getIndex(String signature){
switch(signature.hashCode()){
case 3078479:
return 1;
case 3108270:
return 2;
}
return -1;
}
public Object invoke(int index, Object o, Object[] ol){
Test t = (Test) o;
switch(index){
case 1:
t.f();
return null;
case 2:
t.g();
return null;
}
return null;
}
}
在FastTest中有两个方法，getIndex中对Test类的每个方法根据hash建立索引，invoke根据指定的索引，直接调用目标方法，避免了反射调用。所以当调用methodProxy.invokeSuper方法时，实际上是调用代理类的CGLIB$add$0方法，CGLIB$add$0直接调用了实现类的add方法。
自己开发了一个股票智能分析软件，功能很强大，需要的点击下面的链接获取：
https://www.cnblogs.com/bclshuai/p/11380657.html
百度云盘下载地址：
链接：https://pan.baidu.com/s/1swkQzCIKI3g3ObcebgpIDg
提取码：mc8l
微信公众号获取最新的软件和视频介绍
QStockView
