Java设计模式之代理模式☞再谈JDK的动态代理
前言
为什么要再谈，因为动态代理是aop编程的核心。后面分析spring aop的源代码的最重要的理论基础。
再谈动态代理
首先动态代理需要哪些角色呢？
1.抽象角色。这个抽象角色必须为接口。
2.具体角色。这个具体角色必须实现抽象接口。
3.IAdvice接口和BeforeAdviceImple实现类。
4.InvocationHandler的实现类。这个类为动态代理的Handler类。
5.产生代理的接口，抽象类，工厂类。
6.场景类Client。
1.我们先新增一个抽象角色ISubject接口。这个接口定义一个方法handle。代码如下所示：
1 package com.example.pattern.proxy.dynamic.second; 2 3 public interface ISubject { 4 5 public void handle(); 6 }
第5行，定义接口handle。
2.定义一个具体角色RealSubject。这个角色实现ISubject接口。代码如下所示：
1 package com.example.pattern.proxy.dynamic.second; 2 3 public class RealSubject implements ISubject { 4 @Override 5 public void handle() { 6 System.out.println("-----handle-----"); 7 } 8 }
第6行，处理handle业务逻辑。
3.新增一个通知事件的接口和实现类，代码如下所示。
1 package com.example.pattern.proxy.dynamic.second; 2 3 public interface IAdvice { 4 5 public void execute(); 6 }
1 package com.example.pattern.proxy.dynamic.second; 2 3 public class BeforeAdviceImpl implements IAdvice { 4 @Override 5 public void execute() { 6 System.out.println("执行前置通知"); 7 } 8 }
第6行，定义execute业务前置逻辑。
4.再来新增一个InvocationHandler的默认处理器。
1 package com.example.pattern.proxy.dynamic.second; 2 3 import java.lang.reflect.InvocationHandler; 4 import java.lang.reflect.Method; 5 6 public class DefaultInvocationHandler implements InvocationHandler { 7 8 private Object instance = null; 9 10 public DefaultInvocationHandler(Object instance) { 11 this.instance = instance; 12 } 13 14 @Override 15 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 16 return method.invoke(this.instance, args); 17 } 18 }
第8行，定义被代理对象的实例。
5.产生代理的接口，抽象类，实现类。
1 package com.example.pattern.proxy.dynamic.second; 2 3 import java.lang.reflect.InvocationHandler; 4 5 public interface IDynamicProxy<T> { 6 7 public <T> T newProxyInstace(Class<T> clazz, InvocationHandler h); 8 9 }
package com.example.pattern.proxy.dynamic.second; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; public abstract class AbstractDynamixProxy<T> implements IDynamicProxy<T> { public abstract void before() ; @Override public T newProxyInstace(Class clazz, InvocationHandler h) { this.before(); ClassLoader classLoader = clazz.getClassLoader(); Class[] interfaces = clazz.getInterfaces(); return (T)Proxy.newProxyInstance(classLoader, interfaces, h); } }
1 package com.example.pattern.proxy.dynamic.second; 2 3 public class SubjectDynamicProxyImpl<ISubject> extends AbstractDynamixProxy<ISubject>{ 4 5 @Override 6 public void before() { 7 8 IAdvice advice = new BeforeAdviceImpl(); 9 advice.execute(); 10 11 } 12 }
①有接口，有抽象类，有具体方法？我为什么要这么设计呢？为什么不是直接写在场景类中呢？那如果有10个场景需要，是不是在10出都要写相同或者相似的代码呢？如果一旦有改动，那么，改动的工作量不说，容易产生潜伏性bug。 接口是声明主要用途，抽象类是用来提取公共代码。具体类是为了构建个性化代码，比如before方法。 就是一个典型的钩子函数。说了这么多，这难道不是模板模式的应用吗？
②IDynamicProxy<T>这是一个泛型接口。T可以是一个接口或者普通类，具体是什么类型，由场景来类决定，这不就实现了代码非常灵活的复用吗？同时不也是提高了可读性吗？
6.增加场景类Client。
1 public class Client { 2 3 public static void main(String[] args) { 4 ISubject subject = new RealSubject(); 5 6 InvocationHandler invocationHandler = new DefaultInvocationHandler(subject); 7 8 IDynamicProxy<ISubject> dynamicProxy = new SubjectDynamicProxyImpl(); 9 ISubject proxyInstance = dynamicProxy.newProxyInstace(subject.getClass(), invocationHandler); 10 11 proxyInstance.handle(); 12 } 13 }
执行的结果如下图所示：
1 执行前置通知 2 -----handle-----
我们为什么要使用IAdvice呢。这已经引入了aop中的一些术语，在什么地方执行什么行为，是不是可以理解 在连接点执行什么通知呢？这已经是一个简单的面向切面过程的示例，Advice是什么呢？也正是我们要去切入的类。
