JAVA的23种设计模式---代理模式（二）

概要：

该文章参考了《设计模式之禅》一书及一些前辈的博客文章

1.该文章阐述了代理模式的基础原理及示例代码；
2.该文章适合初学设计模式的技术人员研习；
3.该文章有许多不足之处，请各位大咖指正，喷子绕道；
4.该文章是《JAVA的23种设计模式—代理模式（一）》的续写，点此跳转到第一部分

正文：

4.代理模式的多接口实现示例代码：

package com.csdn;
/**
 * 代理扩展方法接口
 * @author Administrator
 *
 */
public interface IProxy {
    //代管店铺收取费用方法
    public void pay();  
}

package com.csdn;
/**
 * 抽象开店
 * @author Administrator
 *
 */
public interface Shop {
    //开门营业
    public void openTheDoor();
    //卖东西
    public void sell();
    //关门打烊
    public void closeTheDoor();
}

package com.csdn;
/**
 * 具体的一家店
 * @author Administrator
 *
 */
public class Boss implements Shop {
    //店主名字
    private String name = "";
    //构造器限制谁能创建对象，并同时传递店主名
    public Boss(Shop shop,String _name)throws Exception {
        if(shop == null){
            throw new Exception("不能创建一个店铺");
        }else{
            this.name = _name;
        }
    }
    //店门打开方法
    @Override
    public void openTheDoor() {
        System.out.println(this.name+"的店门打开了..");
    }
    //营业、卖东西方法
    @Override
    public void sell() {
        System.out.println(this.name+"的店开始出售东西..");
    }
    //关门打烊方法
    @Override
    public void closeTheDoor() {
        System.out.println(this.name+"的店门关上了..");
    }
}

package com.csdn;
/**
 * 代理开店服务
 * @author Administrator
 *
 */
public class BossProxy implements Shop,IProxy{
    private Shop boss = null;
    //通过构造函数来传递对谁的店进行代理
    public BossProxy(String _boss){
        try {
            boss = new Boss(this, _boss);
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    //代理打开店门方法
    @Override
    public void openTheDoor() {
        this.boss.openTheDoor();
    }
    //代理营业、卖东西方法
    @Override
    public void sell() {
        this.boss.sell();
    }
    //代理关门打烊方法
    @Override
    public void closeTheDoor() {
        this.boss.closeTheDoor();
        this.pay();
    }
    @Override
    public void pay() {
        System.out.println("代理收取代管费100元..");
    }
}

package com.csdn;
/**
 * 模拟代理经营店铺
 * @author Administrator
 *
 */
public class Business {
    public static void main(String[] args) {        
        //“小明”的店铺需要代理服务
        Shop proxy = new BossProxy("小明");
        //代理打开小明的店门
        proxy.openTheDoor();
        //代理帮小明卖东西
        proxy.sell();
        //代理关上小明的店门并向小明收取了管理费
        proxy.closeTheDoor();       
    }
}

输出：

小明的店门打开了..
小明的店开始出售东西..
小明的店门关上了..
代理收取代管费100元..

注：
a：该示例与之前相比增加了IProxy接口，增加了pay方法以及其实现，并在closeTheDoor方法中调用了它的实现方法
b：代理的职责并不单一，可以组合其他的真实角色，也可以实现自己的职责，它可以为真实角色预处理消息、过滤消息、消息转发、事后处理消息等功能。

5.通用代理模式模板代码实现：

package com.csdn;
/**
 * 抽象类，可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求
 * @author Administrator
 *
 */
public interface Subject {  
    //定义一个方法  
    public void request();  
} 

package com.csdn;
/**
 * 具体类，也叫被委托的角色、被代理的角色，它才是最重要的，是业务逻辑的具体执行者。 
 * @author Administrator
 *
 */ 
public class RealSubject implements Subject {  
    @Override  
    public void request() {  
        //业务逻辑处理  
    }  
} 

package com.csdn;
/**
 * 代理类
 * @author Administrator
 *
 */ 
public class Proxy implements Subject {  
    //要代理哪个实现类  
    private Subject subject = null;  
    //默认被代理者  
    public Proxy() {  
        this.subject = new Proxy();  
    }  
    //通过构造方法传递代理者  
    public Proxy(Object...objects) {  
    }  
    //实现接口中的方法  
    @Overrdie  
    public void request() {  
        this.before();  
        this.subject.request();  
        this.after();  
    }       
    //预处理  
    private void before() {  
        //do something  
    }       
    //善后处理  
    private void after() {  
        //do something  
    }  
} 

5.虚拟代理模式代码实现：

package com.csdn;
/**
 * 虚拟代理类
 * @author Administrator
 *
 */ 
public class Proxy implements Subject {  
    //要代理哪个实现类  
    private Subject subject;   
    //实现接口中的方法  
    @Overrdie  
    public void request() {  
        if(subject == null){
            subject = new RealSubject();
        }
        subject.request();
    }        
} 

注：在需要的时候才初始化主题对象，可以避免被代理对象较多而引起的初始化缓慢问题

6.动态代理模式代码实现示例代码：

package com.csdn;
/**
 * 抽象开店
 * @author Administrator
 *
 */
public interface Shop {
    //开门营业
    public void openTheDoor();
    //卖东西
    public void sell();
    //关门打烊
    public void closeTheDoor();
}

package com.csdn;
/**
 * 具体的一家店
 * @author Administrator
 *
 */
public class Boss implements Shop {
    //店主名字
    private String name = "";
    //带参构造器
    public Boss(String _name) {
        this.name = _name;
    }
    //店门打开方法
    @Override
    public void openTheDoor() {
        System.out.println(this.name+"的店门打开了..");
    }
    //营业、卖东西方法
    @Override
    public void sell() {
        System.out.println(this.name+"的店开始出售东西..");
    }
    //关门打烊方法
    @Override
    public void closeTheDoor() {
        System.out.println(this.name+"的店门关上了..");
    }
}

package com.csdn;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * 动态代理类
 * @author Administrator
 *
 */
public class DynamicAgent implements InvocationHandler{
    //被代理者
    Class clazz = null;
    //被代理的实例
    Object obj = null;
    //要代理谁
    public DynamicAgent(Object _obj){
        this.obj = _obj;
    }
    //调用被代理的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(this.obj, args);
        //此处可以加入面向切面的功能，AOP（面向切面的编程）的提现处
        //如在门被打开时的提醒功能
        if(method.getName().equalsIgnoreCase("openTheDoor")){
            System.out.println("(有人正在打开店门！)");
        }       
        return result;
    }
}

package com.csdn;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

/**
 * 模拟动态代理经营店铺
 * @author Administrator
 *
 */
public class Business {
    public static void main(String[] args) {
        //初始化“小明”的店铺
        Boss boss = new Boss("小明");
        //“小明”的店铺需要动态代理服务
        InvocationHandler handler = new DynamicAgent(boss);
        //获得类的类加载器
        ClassLoader cl = boss.getClass().getClassLoader();
        //动态产生一个代理者
        Shop proxy = (Shop)Proxy.newProxyInstance(cl,new Class[]{Shop.class}, handler);
        //代理打开小明的店门
        proxy.openTheDoor();
        //代理帮小明卖东西
        proxy.sell();
        //代理关上小明的店门
        proxy.closeTheDoor();
    }
}

输出：

小明的店门打开了..
(有人正在打开店门！)
小明的店开始出售东西..
小明的店门关上了..

注：
a：invoke方法是InvocationHandler定义必须实现的，他完成对真实方法的调用，所有被代理的方法都由InvocationHandler接管实际的处理任务
b：对于日志、事物、权限等都可以在系统设计阶段不用去考虑，而在设计后通过AOP（面向切面的编程）的方式切过去

7.通用动态代理模式模板代码：

package com.csdn;
/**
 * 抽象类
 * @author Administrator
 *
 */
public interface Subject {  
    //业务操作 
    public void doSomething(String str);  
} 

package com.csdn;
/**
 * 具体类
 * @author Administrator
 *
 */ 
public class RealSubject implements Subject {  
    //业务操作
    @Override  
    public void doSomething(String str){
        System.out.println("do something----->" + str);
    };   
} 

package com.csdn;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * 动态代理的Handler类
 * @author Administrator
 *
 */
public class MyInvocationHandler implements InvocationHandler {
    //被代理的对象
    private Object target = null;
    //通过构造函数传递一个对象
    public MyInvocationHandler(Object _obj){
        this.target = _obj;
    }
    //代理方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //执行被代理的方法
        return method.invoke(this.target, args);
    }
}

package com.csdn;

import java.lang.reflect.InvocationHandler;

/**
 * 动态代理类
 * @author Administrator
 *
 * @param <T>
 */
public class DynamicProxy<T> {
    public static <T> T newProxyInstance(ClassLoader loader,Class<?>[]interfaces,InvocationHandler h){
        //寻找JoinPoint连接点，AOP框架使用元数据定义
        if(true){
            //执行一个前置通知
            (new BeforeAdvice()).exec();
        }
        //执行目标并返回结果
        return (T)Proxy.newProxyInstance(loader, interfaces, h);        
    }
}

package com.csdn;
/**
 * 通知接口
 * @author Administrator
 *
 */
public interface IAdvice {
    //通知的方法
    public void exec();
}

package com.csdn;
/**
 * 通知实现类
 * @author Administrator
 *
 */
public class BeforeAdvice implements IAdvice {
    @Override
    public void exec() {
        System.out.println("前置通知");
    }
}

package com.csdn;

import java.lang.reflect.InvocationHandler;

/**
 * 动态代理场景类
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        //定义一个主题
        Subject subject = new RealSubject();
        //定义一个Handler
        InvocationHandler handler = new MyInvocationHandler(subject);
        //定义主题的代理
        Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(), handler);
        //代理的行为
        proxy.doSomething("Finish");
    }
}

输出：

前置通知
do something----->Finish

注：
a：在动态代理类中newProxyInstance方法有三个参数，其中c.getInterfaces查找该类的所有接口，然后实现接口的所有方法，由new MyInvocationHandler(subject)这个对象接管

扩展：

package com.csdn;

import java.lang.reflect.InvocationHandler;
/**
 * 具体业务的动态代理
 * @author Administrator
 *
 */
public class SubjectDynamicProxy extends DynamicProxy{
    public static <T> T newProxyInstance(Subject subject){
        //获得类加载器
        ClassLoader loader = subject.getClass().getClassLoader();
        //获得接口数据
        Class<?>[] classes = subject.getClass().getInterfaces();
        //获得Handler
        InvocationHandler handler = new MyInvocationHandler(subject);
        return newProxyInstance(loader, classes, handler);
    }
}

package com.csdn;

/**
 * 动态代理场景类
 * @author Administrator
 *
 */
public class Client {
    public static void main(String[] args) {
        //定义一个主题
        Subject subject = new RealSubject();
        //定义主题的代理
        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
        //代理的行为
        proxy.doSomething("Finish");
    }
}

注：
a：动态代理的主要意图就是横切面编程，在不改变我们已有的代码结构的情况下增强或控制对象的行为