java--动态代理技术
动态代理技术
在学习动态代理之前，需要了解的是一种常用的设计模式—代理模式，而对于代理，根据创建代理类的时间点，又可以分为静态代理和动态代理。
代理模式
代理模式是常用的java设计模式，他的特点是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等，它们之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途。
静态代理
静态代理是由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成，缺点是接口与代理类是1v1，有多个接口需要代理，就需要新建多个代理类，比较繁琐。
静态代理的列子
显示方法运行的时间
UserServiceTarget 目标类 实现了UserService
TimeHandler 包含了重复代码，间接调用目标
UserServiceProxy 代理类 实现了UserService
接口
public interface UserService {public void b();public void c();}
委托类实现接口
// 目标类public class UserServiceTarget implements UserService {public void b() {System.out.println("b");}public void c() {System.out.println("c");}}
代理类实现接口
// 静态代理 - 自己编码实现的代理类// 动态代理 - jdk可以在运行期间，动态地生成这个代理类// proxy 代理 (封装复杂逻辑，它去间接调用 TimeHandler 和 业务代码), 让使用者觉得简单public class UserServiceProxy implements UserService {public void b() {try {TimeHandler timeHandler = new TimeHandler();//得到方法 类名.class.getMethod(方法名)Method b = UserServiceTarget.class.getMethod("b");//反射调用，传递方法，下面的计算类里就可以调用此方法timeHandler.invoke(b);} catch (NoSuchMethodException e) {e.printStackTrace();}}public void c() {try {TimeHandler timeHandler = new TimeHandler();Method c = UserServiceTarget.class.getMethod("c");timeHandler.invoke(c);} catch (NoSuchMethodException e) {e.printStackTrace();}}}
计算时间的代码
public class TimeHandler {private UserServiceTarget userService = new UserServiceTarget();// b() c()public void invoke(Method method) {System.out.println("==================================");long start = System.nanoTime();// 调用这个方法 method// 正常调用： 对象.方法名(参数)// 反射调用： 方法.invoke(对象, 参数);try {//调用 UserServiceTarget 中的方法method.invoke(userService);} catch (Exception e) {e.printStackTrace();}long end = System.nanoTime();System.out.println("花费了： " + (end - start));}}
测试类
public class TestTimeHandler {public static void main(String[] args) {UserServiceProxy proxy = new UserServiceProxy();proxy.b();proxy.c();}}
结果
==================================b花费了： 201800==================================c花费了： 65691
动态代理（Dynamic Proxy ）
原始编写java 代码的方式是从java文件编译为class文件，然后class文件经过翻译后变为机器语言，而动态代理就是体现了class文件到机器语言这一过程。
- 原始编写java 代码的方式
.java -> javac -> *.class -> 类加载
- 动态代理
.class -> 类加载
动态代理例子
显示方法运行的时间
UserServiceTarget 目标类 实现了UserService
TestDynamicProxy 包含了计算时间代码，间接调用目标
UserServiceProxy 代理类 实现了UserService
接口
public interface UserService {public void a(int x, int y);public void b();public void c();}
目标类（委托类）
// 目标类public class UserServiceTarget implements UserService {public void a(int x, int y) {System.out.println("a");}public void b() {System.out.println("b");}public void c() {System.out.println("c");}}
测试类
import java.io.FileOutputStream;import java.io.IOException;import java.lang.reflect.Constructor;import java.lang.reflect.InvocationHandler;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;// dynamic 动态的// proxy 代理public class TestDynamicProxy {public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {// 1. 生成了类的字节码// 参数1 string 表示代理类的名字，随意起// 参数2 class[] 表示代理类要实现的接口// 返回的结果就是 代理类 的字节码byte[] bytes = ProxyGenerator.generateProxyClass("UserServiceProxy2", new Class[]{UserService.class});// 2. 执行类加载// 类加载的最终结果体现为 Class 类对象, 要借助类加载器ClassLoader cl = new ClassLoader() {@Overrideprotected Class<?> findClass(String name) throws ClassNotFoundException {return defineClass(name, bytes, 0, bytes.length);}};Class c = cl.loadClass("UserServiceProxy2"); // 进行类加载, 获得了 UserServiceProxy 类对象// 3. 创建代理类实例对象// 不能正常创建它的实例对象， new UserServiceProxy2();// 获取代理类的构造方法Constructor constructor = c.getConstructor(InvocationHandler.class);UserServiceTarget target = new UserServiceTarget();// 创建实例对象, 强制转换为它的接口类型UserService proxy = (UserService)constructor.newInstance(new InvocationHandler() {@Override// method 就是 a , b, c 等方法对象public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("进入了 invoke");long start = System.nanoTime();// 方法.invoke(目标, 参数); 通过这行代码调用目标类的方法method.invoke(target, args);long end = System.nanoTime();System.out.println("花费了:" + (end - start));return null;}});// 4. 使用代理对象proxy.b();proxy.c();proxy.a(10,20);}}
结果
进入了 invokeb花费了:682903进入了 invokec花费了:233935进入了 invokea花费了:267017
以上两种代理方法可以看出，静态代理中的方法实现太过繁琐（业务逻辑多），相比之下，动态代理的业务逻辑就简洁多了。
总结
简而言之，动态代理也就是间接的调用委托的方法，并完善方法的过程，这样使代码简洁，并且在编码时，代理逻辑与业务逻辑相互独立，个不影响，没有侵入，没有耦合（耦合也就是一处代码修改，另一处代码也要修改，如果偶合性强，那么修改一处代码时，需要改多处代码，才可以把程序修改完毕，反之则修改处少）。
深藏阁楼爱情的钟
偏执的太偏执、
Bertha 。
刺骨的言语ヽ痛彻心扉
超、凢脫俗
小灰灰
爱被打了一巴掌
还没有评论，来说两句吧...