java代理通俗简单解析

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