一、静态代理静态代理的使用静态代理，代理类和被代理的类实现了同样的接口，代理类同时持有被代理类的引用，这样，当我们需要调用被代理类的方法时，可以通过调用代理类的方法来做到。
举例：假设领导的工作是开会和给员工考评。
先定义一个接口：
package com.sharpcj;public interface iwork { void meeting(); int evaluate(string name);}
然后定义领导类：
package com.sharpcj;import java.util.random;public class leader implements iwork { @override public void meeting() { system.out.println("领导早上要组织会议"); } @override public int evaluate(string name) { int score = new random(system.currenttimemillis()).nextint(20) + 80; system.out.println(string.format("领导给%s的考评为%s分", name, score)); return score; }}
秘书类：
package com.sharpcj;public class secretary implements iwork { private leader mleader; public secretary(leader mleader) { this.mleader = mleader; } @override public void meeting() { system.out.println("秘书先给老板准备材料"); mleader.metting(); } @override public int evaluate(string name) { return mleader.evaluate(name); }}
测试类：
package com.sharpcj;public class testapp { public static void main(string[] args) { leader leader = new leader(); secretary secretary = new secretary(leader); secretary.meeting(); secretary.evaluate("joy"); }}
执行结果：
这个代码很简单，注意在调用secretary类的 meeting 方法时，我们调用了leader类的 meeting 的方法，在此之前，我们还扩充了该方法。这时有的人可能有疑惑了，这看起来有点是装饰者模式了。这到底怎么回事？
与装饰者模式的区别实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。
我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。
先看看两者的 uml 类图区别：
代理模式：
装饰者模式：
两者伪代码：
代理模式:
interface subject { void doaction()}public class realsubject implements subject{ @override public void doaction() {};}public class proxy implements subject{ private realsubject realsubject; public proxy(realsubject realsubject) { //关系在编译时确定 this.realsubject = realsubject; } @override public void doaction() { …. realsubject.doaction(); …. }}
装饰者模式;
interface component { void doaction()}public class concretecomponent implement component { @override public void doaction() {};}public class decorator implements component { private component component; public decorator(component component) { //关系在编译时确定 this.component = new component; } public void doaction() { …. component.doaction(); …. }}
其实代理模式和装饰者模式侧重点不一样，代理模式重点在于明确了被代理的类。如上例中，秘书很明确要代理的是的领导。而装饰者模式侧重于拓展类的方法，装饰类持有的实现component接口的类的对象不是固定的，也就是说，装饰类可以根据在调用时传入的参数，装饰任意一个实现了 component 接口的类。
二、动态代理动态代理的根据实现方式的不同可以分为 jdk 动态代理和 cglib 动态代理。
jdk 动态代理：利用反射机制生成一个实现代理接口的类，在调用具体方法前调用invokehandler来处理。
cglib 动态代理：利用asm（开源的java字节码编辑库，操作字节码）开源包，将代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
区别：jdk代理只能对实现接口的类生成代理；cglib是针对类实现代理，对指定的类生成一个子类，并覆盖其中的方法，这种通过继承类的实现方式，不能代理final修饰的类。
jdk 动态代理还是以上面的例子为例：
首先，定一个类实现 invocationhandler 接口，并实现 invoke 方法：
package com.sharpcj;import java.lang.reflect.invocationhandler;import java.lang.reflect.method;public class workinvocationhandler implements invocationhandler { private object object; public workinvocationhandler(object object) { this.object = object; } @override public object invoke(object proxy, method method, object[] args) throws throwable { system.out.println("object: " + object.getclass().getsimplename()); system.out.println("proxy: " + proxy.getclass().getsimplename()); if ("meeting".equals(method.getname())) { system.out.println("代理先准备会议材料..."); return method.invoke(object, args); } else if ("evaluate".equals(method.getname())) { if(args[0] instanceof string) { if ("james".equals(args[0])) { system.out.println("james 犯过错误，所以考评分数较低..."); return 70; } } return method.invoke(object, args); } return null; }}
然后通过 proxy.newproxyinstance() 方法创建代理对象：
package com.sharpcj;import java.lang.reflect.proxy;public class testapp { public static void main(string[] args) { /*leader leader = new leader(); secretary secretary = new secretary(leader); secretary.meeting(); secretary.evaluate("joy");*/ leader leader = new leader(); iwork proxy = (iwork) proxy.newproxyinstance(leader.class.getclassloader(), new class[]{iwork.class}, new workinvocationhandler(leader)); proxy.meeting(); proxy.evaluate("joy"); proxy.evaluate("james"); }}
输出结果：
我们看到，通过 workinvocationhandler 类，我们同样可以代理 leader 类的方法的实现，实际上我们实现的是任意的方法的实现，只是我们在创建代理对象的时候传入的是 iwork 接口以及 leader 类对象。
这里需要注意的是：在 invocationhandler 接口的 invoke 方法中第一个参数 proxy, 并不是我们调用方法的对象，那这个参数是什么呢？代码中，我特别增加相应打印，打印出了 proxy 的类名，实际上 proxy 是代理对象本身，它的意义在于，我们可以在 invoke 方法中，返回该代理对象，然后进行连续调用。
看如下例子：
package com.sharpcj.proxytest;public interface iwork { iwork work(string subject);}
package com.sharpcj.proxytest;import java.lang.reflect.invocationhandler;import java.lang.reflect.method;public class workinvocationhandler implements invocationhandler { private object object; public workinvocationhandler(object object) { this.object = object; } @override public object invoke(object proxy, method method, object[] args) throws throwable { if ("work".equals(method.getname())){ system.out.println("--- work: " + args[0]); return proxy; } return null; }}
package com.sharpcj.proxytest;import java.lang.reflect.proxy;public class testapp { public static void main(string[] args) { iwork worker = (iwork) proxy.newproxyinstance(iwork.class.getclassloader(), new class[]{iwork.class}, new workinvocationhandler(new iwork() { @override public iwork work(string subject) { return null; } })); worker.work("aaa").work("bbb").work("ccc"); }}
结果如下：
cglib 动态代理实现首先添加 cglib 依赖
build.gradle 文件：
... dependencies { // 引入 cglib 库 compile 'cglib:cglib:3.1' testcompile group: 'junit', name: 'junit', version: '4.12'}...
前面说了，cglib 针对类进行代理，我们以上面的 leader 类为例，先创建一个类实现 methodinterceptor接口：
package com.sharpcj;import net.sf.cglib.proxy.methodinterceptor;import net.sf.cglib.proxy.methodproxy;import java.lang.reflect.method;public class leadermethodinterceptor implements methodinterceptor { @override public object intercept(object o, method method, object[] objects, methodproxy methodproxy) throws throwable { if ("meeting".equals(method.getname())) { system.out.println("代理先准备会议材料..."); return methodproxy.invokesuper(o, objects); } else if ("evaluate".equals(method.getname())) { if(objects[0] instanceof string) { if ("james".equals(objects[0])) { system.out.println("james 犯过错误，所以考评分数较低..."); return 70; } } return methodproxy.invokesuper(o, objects); } return null; }}
测试代码：
package com.sharpcj;import net.sf.cglib.core.debuggingclasswriter;import net.sf.cglib.proxy.enhancer;import java.lang.reflect.proxy;public class testapp { public static void main(string[] args) { // system.setproperty(debuggingclasswriter.debug_location_property, "d:\temp\code"); //保存生成的 class 文件 enhancer enhancer = new enhancer(); // 通过cglib动态代理获取代理对象的过程 enhancer.setsuperclass(leader.class); // 设置enhancer对象的父类 enhancer.setcallback(new leadermethodinterceptor()); // 设置enhancer的回调对象 leader proxy= (leader)enhancer.create(); // 创建代理对象 // 通过代理对象调用目标方法 proxy.meeting(); proxy.evaluate("joy"); proxy.evaluate("james"); }}
结果如下：
methodinterceptor 接口只有一个 intercept 方法，这个方法有4个参数：
1）obj表示增强的对象，即实现这个接口类的一个对象；
2）method表示要被拦截的方法；
3）args表示要被拦截方法的参数；
4）proxy表示要触发父类的方法对象；
需要注意的是:实际调用是 methodproxy.invokesuper(), 如果使用 invoke() 方法，则需要传入被代理的类对象，否则出现死循环，造成 stackoverflow 。
以上就是java动态代理与静态代理的实例分析的详细内容。