设计模式_代理模式_由浅入深

核心目标：

以最小的代价给目标方法加上前置和后置处理功能。

比如某账本类的查询方法，想在查询前增加鉴权，和查询后记录查询日志。

基本原理：

在目标类前面加一个代理类，将直接调用目标方法改为调用代理类的同名方法，再由代理类的同名方法调用目标方法，前/后置逻辑写在代理类的同名方法中。

//TO-DO 添加示意图

核心理论和技术：

1、代理模式

2、反射

3、JDK动态代理

4、Cglib动态代理

5、spring AOP面向切面编程

6、回调模式

技术实现举例：逻辑由易至难，开发由难至易

以账本为例，具有查询和更新两个方法，要在这两个方法前后加上前置和后置处理

IAccount接口：

package com.common;public interface IAccount {public void queryAccount();public void updateAccount();}

AccountImpl1实现：

package com.common;public class AccountImpl1 implements IAccount {public void queryAccount() {System.out.println("查询账户.......");}public void updateAccount() {System.out.println("更新账户......");}}

AccountImpl2实现2：

package com.common;public class AccountImpl2 implements IAccount {public void queryAccount() {System.out.println("当前账户名为：匿名账户");}public void updateAccount() {System.out.println("更新账户名为：张三");}}

菜鸟：天下无招

设计思路：

      修改账本实现类

      新增两个方法：前置方法、后置方法

      在执行查询和更新前后，调用前置和后置方法

package com.general;import com.common.IAccount;public class AccountImpl implements IAccount {public void queryAccount() {beforeOperate();System.out.println("查询账户.......");afterOperate();}public void updateAccount() {beforeOperate();System.out.println("更新账户......");afterOperate();}public void beforeOperate(){System.out.println("前置处理.....");}public void afterOperate(){System.out.println("后置处理.....");}}

优点：

      逻辑简单，不费脑

缺点：

     核心业务代码与辅助性代码高耦合

     前置和后置属于通用代码，调用代码重复开发

     前后置内容容易随需求发生改变，代码修改会造成核心业务风险

大虾：静态代理，看到武功秘籍，功力大增

设计思路：

       1、使用代理设计模式

       2、新增代理，即新增一个跟被代理账本1实现了相同账本接口的代理类，具备相同的方法

       3、绑定代理关系，即将被代理的账本实现类作为自身的一个属性

       4、代理类新增前置和后置处理方法

       5、强化需要被代理的方法，即真正的业务处理仍由被代理的对方受理，但在将请求转发给被代理对象之前和之后，分别加上前置和后置处理逻辑

       6、修改业务调用逻辑，即将直接调用被代理对象的方法，改为调用代理类的同名方法

package com.staticProxy.staticProxy1;import com.common.AccountImpl1;import com.common.IAccount;public class AccountProxy1 implements IAccount{private AccountImpl1 accountImpl;public AccountProxy1(AccountImpl1 accountImpl){this.accountImpl=accountImpl;}public void queryAccount() {beforeOperate();accountImpl.queryAccount();afterOperate();System.out.println();}public void updateAccount() {beforeOperate();accountImpl.updateAccount();afterOperate();System.out.println();}public void beforeOperate(){System.out.println("前置处理.....");}public void afterOperate(){System.out.println("后置处理.....");}public AccountImpl1 getAccountImpl() {return accountImpl;}public void setAccountImpl(AccountImpl1 accountImpl) {this.accountImpl = accountImpl;}}

测试：

package com.staticProxy.staticProxy1;import com.common.AccountImpl1;import com.common.IAccount;public class test {public static void main(String[] args) {AccountImpl1 accountImpl=new AccountImpl1();IAccount account=new AccountProxy1(accountImpl);account.queryAccount();account.updateAccount();}}

若再来一个账本实现类，则有需要写一个代理类，而且除了代理的实现类不一样外，其余全部一样

package com.staticProxy.staticProxy2;import com.common.AccountImpl2;import com.common.IAccount;public class AccountProxy2 implements IAccount{private AccountImpl2 accountImpl;public AccountProxy2(AccountImpl2 accountImpl){this.accountImpl=accountImpl;}public void queryAccount() {beforeOperate();accountImpl.queryAccount();afterOperate();System.out.println();}public void updateAccount() {beforeOperate();accountImpl.updateAccount();afterOperate();System.out.println();}public void beforeOperate(){System.out.println("前置处理.....");}public void afterOperate(){System.out.println("后置处理.....");}public AccountImpl2 getAccountImpl() {return accountImpl;}public void setAccountImpl(AccountImpl2 accountImpl) {this.accountImpl = accountImpl;}}

测试：

package com.staticProxy.staticProxy2;import com.common.AccountImpl2;import com.common.IAccount;public class test {public static void main(String[] args) {AccountImpl2 accountImpl=new AccountImpl2();IAccount account=new AccountProxy2(accountImpl);account.queryAccount();account.updateAccount();}}

优点：

       1、前后置辅助代码跟业务代码完全解耦

       2、修改前后置方法不影响原核心业务

缺点：

       1、每代理一个类，就得新增一个代理类，开发量大

       2、需要修改被代理方法的调用代码，若被调用的地方很多，改造量大

牛人：动态代理，悟性高，会借力

设计思路：

       1、代理模式必备要素：要实现代理模式，抽象出来无外乎五样东西

            1.1 有一个代理类，用于写前置和后置处理方法

            1.2 有一个被代理类，不关心具体是什么，以object抽象

            1.3 需要绑定代理关系，即将被代理类跟代理类绑定

            1.4 需要知道被强化的方法，不关心具体方法名，以method抽象，不关心传入参数，以args[]抽象，不关心返回参数，以object抽象，可以通过反射来调用

            1.5 每个被代理对象需要一个专用的前置代理实例，不关心代理实例是否有真身（java类），只要存在于内存中，具备被代理对象的所有方法即可

            1.6 代理实例的方法不需实现任何业务逻辑，只需要接收调用请求，拿到被调用的方法名、参数即可，然后将方法、参数和代理实例本身，传给代理类的回调函数，使用反射原理统一加强处理

      2、动态代理简要流程

            2.1 生成代码已有两套现成的，直接拿来用

                  2.1.1 jdk动态代理，只能给实现了接口的类动态生成代理（java自带，所以首选该方案）

                  2.1.2 Cglib动态代理，能给没有实现接口的类动态生成代理，实现接口的也支持（第三方代码，所以次选）

                           全称Code generation library 代码生成类库

            2.2 生成流程

                  2.2.1 代理类和被代理类绑定（属性）

                  2.2.2 使用jdk或者Cglib，根据代理类、被代理类、回调方法，动态生成一个代理实例，该实例只存在于内存中，负责具体的代理工作

                  2.2.3 动态生成的代理实例，具有被代理对象的所有方法，该方法被调用时，会回调预设的回调方法（jdk是invoke()，Cglib是intercept()）

                  2.2.3 代理类需要有一个回调方法，该方法实现被代理方法的强化，即加上前置后后置方法

借助JDK动态代理（被代理的类必须实现接口）

package com.jdkDynamicProxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class AccountJdkDynamicProxy implements InvocationHandler{private Object proxyedObject;public Object getProxy(Object proxyedObject){this.proxyedObject=proxyedObject;return Proxy.newProxyInstance(proxyedObject.getClass().getClassLoader(), proxyedObject.getClass().getInterfaces(), this);}public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {beforeOperate();Object result=method.invoke(proxyedObject, args);afterOperate();System.out.println();return result;}public void beforeOperate(){System.out.println("前置处理.....");}public void afterOperate(){System.out.println("后置处理.....");}public Object getProxyedObject() {return proxyedObject;}public void setProxyedObject(Object proxyedObject) {this.proxyedObject = proxyedObject;}}

测试：写一次代理类，动态代理多个实现类

 package com.jdkDynamicProxy;import com.common.AccountImpl1;import com.common.AccountImpl2;import com.common.IAccount;public class test1 {public static void main(String[] args) {AccountJdkDynamicProxy proxy=new AccountJdkDynamicProxy();/*代理账本1*/IAccount account=new AccountImpl1();IAccount accountProxy=(IAccount)proxy.getProxy(account);accountProxy.queryAccount();accountProxy.updateAccount();/*代理账本2*/account=new AccountImpl2();accountProxy=(IAccount)proxy.getProxy(account);accountProxy.queryAccount();accountProxy.updateAccount();}}

借Cglib动态代理（不要求被代理的类必须实现接口）

package com.cglibDynamicProxy;import java.lang.reflect.Method;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;public class AccountCglibDynamicProxy implements MethodInterceptor {private Object proxyedObject;public Object getProxy(Object proxedObject){this.proxyedObject=proxedObject;Enhancer enhancer=new Enhancer();enhancer.setSuperclass(proxyedObject.getClass());enhancer.setCallback(this);return enhancer.create();}public Object intercept(Object arg0, Method arg1, Object[] arg2,MethodProxy proxy) throws Throwable {beforeOperate();Object result=proxy.invokeSuper(arg0, arg2);afterOperate();System.out.println();return result;}public void beforeOperate(){System.out.println("前置处理.....");}public void afterOperate(){System.out.println("后置处理.....");}public Object getProxyedObject() {return proxyedObject;}public void setProxyedObject(Object proxyedObject) {this.proxyedObject = proxyedObject;}}

测试：

package com.cglibDynamicProxy;import com.common.AccountImpl2;import com.common.AccountImpl4;public class test {public static void main(String[] args) {/*使用代理_非接口类*/AccountCglibDynamicProxy proxy=new AccountCglibDynamicProxy();AccountImpl4 account=new AccountImpl4();AccountImpl4 accountProxy=(AccountImpl4)proxy.getProxy(account);accountProxy.queryAccount();accountProxy.updateAccount();/*使用代理_接口类*/AccountImpl2 account2=new AccountImpl2();AccountImpl2 accountProxy2=(AccountImpl2)proxy.getProxy(account2);accountProxy2.queryAccount();accountProxy2.updateAccount();}}

优点：

        代理类只需写一份，具体被代理的代理实例动态生成，开发量小

缺点：

        1、接口类和非接口类，需要不同的实现

        2、依赖于JDK和Cglib的代理规范，属于重开发

        3、代理类编写复杂，技术要求高，未实现POJO编程

        4、被代理对象的所有方法均被代理，可自定义程度低

大牛：拳无拳意无意，无意之中是真意：Spring的AOP面向切面编程

设计思路：

       1、spring的POJO编程思想，即Plain Ordinary Java Object简单的Java对象

       2、业务类，就写业务方法

       3、代理类，就写前置和后置方法

       4、依赖关系由xml配置文件维护

       5、spring封装jdk和cglib，对用户不可见

代理类：

package com.springDynamicProxy;public class AspectBean {public void beforeOperate(){System.out.println("前置处理.....");}public void afterOperate(){System.out.println("后置处理.....");}}

代理关系注册：

<?xml version="1.0" encoding="utf-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/aop      http://www.springframework.org/schema/aop/spring-aop-3.2.xsd"><bean id="accountImpl1" class="com.common.AccountImpl1" /><bean id="accountImpl4" class="com.common.AccountImpl4" /><bean id="aspectBean" class="com.springDynamicProxy.AspectBean" /><!-- 对Test类进行AOP拦截 --><aop:config><aop:aspect id="TestAspect" ref="aspectBean"><!--配置切面--><aop:pointcut id="businessService"expression="(execution(* com.common.AccountImpl1.queryAccount(..))) or (execution(* com.common.AccountImpl4.queryAccount(..)))"/><aop:before pointcut-ref="businessService" method="beforeOperate" /><aop:after pointcut-ref="businessService" method="afterOperate" /></aop:aspect></aop:config></beans>

测试：

package com.springDynamicProxy;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import com.common.AccountImpl4;import com.common.IAccount;public class test {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("com/springDynamicProxy/test.xml");/*接口类：使用JDK代理*/IAccount accountImpl1=(IAccount) ctx.getBean("accountImpl1");System.out.println(accountImpl1.getClass().getSimpleName());System.out.println("super class is "+accountImpl1.getClass().getSuperclass());accountImpl1.queryAccount();/*非接口类：使用Cglib代理*/AccountImpl4 accountImpl4=(AccountImpl4)ctx.getBean("accountImpl4");System.out.println(accountImpl4.getClass().getSimpleName());System.out.println("super class is "+accountImpl4.getClass().getSuperclass());accountImpl4.queryAccount();}}

优点：

       1、不直接依赖于JDK和Cglib的规范，真正实现POJO编程

       2、代理关系统一配置，维护简单，使用灵活

       3、代理类编写简单，开发量小