文档章节

代理模式

 开着坦克的瑞兽
发布于 2017/05/21 02:30
字数 1749
阅读 5
收藏 0

概述:

   代理模式,提供了对目标对象另外的访问方式。简单讲在不改变目标对象的提前下,为其添加额外功能以供其他对象使用。而对于开发人员来讲,其实就是不改变原有的代码,对相应功能进行扩展,比如限制对原有代码的访问权限,记录原有代码的执行时间,对运行过的代码写日志.....

  代理模式有静态代理和动态代理。其关键点是,代理对象与目标对象、代理对象是对目标对象的扩展,并调用目标对象。

代理模式的角色:

抽象对象:声明了目标对象和代理对象的共同接口,这样一来在任何可以使用目标对象的地方都可以使用代理对象。

目标对象:定义了代理对象所代表的目标对象。

代理对象:代理对象内部含有目标对象的引用,从而可以在任何时候操作目标对象。

 

一、静态代理

静态代理有聚合和继承两种实现方式。下面我们以“一只程序猿在写代码为例子”,分别为其记录日志和时间。

1、继承实现方式:

//抽象对象:
public interface People {
    public void code();
}
//目标对象
public class Programmer implements People {
    @Override
    public void code() {
        System.out.println("我在写代码");
    }
}
//继承代理  
public class TimeProxy extends Programmer {
    public void proxy(){
        System.out.println("time Strat");
        super.code();
        System.out.println("time end");
    }
}

此时我们对程序猿的代理进行执行:

public class Client {
    public static void main(String[] args) {
        TimeProxy timpProxty = new TimeProxy();    
        timpProxty.proxy();    
    }
}

输出结果:

这里代理模式(继承)就实现了,但这里有一个问题如果我要先记录对这只程序猿的行为的时间,然后为他记录日志。此时我们的代码可能是

public class LogAndTimeProxy extends  Programmer {
    public void logAndTimeProxy(){
        System.out.println("time start");
        System.out.println("log start");
        super.code();
    }    
}

但是如果需要先记录日志再记录时间,那此时就要修改原有的代理或者新增代理类,这种做法代码的实现不灵活。我们应该要做到分别定义一个时间代理,一个日志代理,不管时间、日志谁先谁后,都不需要去修改原有的代理或许添加新代理类

    

2、聚合实现方式:    

//抽象对象:
public interface People {
    public void code();
}
//目标对象
public class Programmer implements People {
    @Override
    public void code() {
        System.out.println("我在写代码");
    }
}
//时间代理类(聚合)
public class TimeProxy implements People {
    private People people;
    
    public TimeProxy(People people){
        this.people=people;
    }

    @Override
    public void code() {
        System.out.println("time start");
        people.code();
        System.out.println("time end");
    }
}
//日志代理类(聚合)
public class LogProxy  implements People {
    private People people;
    
    public LogProxy(People people){
        this.people=people;
    }
    
    @Override
    public void code() {
        System.out.println("logging start");
        people.code();
        System.out.println("logging end");
    }
}
//如果我们要先记录时间,后记录日志实现方式
public class Client {
    public static void main(String[] args) {
        People p = new Programmer();
        TimeProxy timpProxty = new TimeProxy(p);
        LogProxy logProxty = new LogProxy(timpProxty);
        logProxty.code();    
    }
}

执行结果:

 如果要实现新记录日志再记录时间 

public class Client {
    public static void main(String[] args) {
        People p = new Programmer();
        LogProxy logProxty = new LogProxy(p);    
        TimeProxy timpProxty = new TimeProxy(logProxty);
        timpProxty.code();    
    }
}

结果:

这样就可以不用修改代理类的情况下,更改代理类了。

但这里有一个问题就是每个代理类要继承一个接口或者实现一个类。如果一个项目比较大的话,那就需要添加很多的类,一旦接口增加方法,目标对象与代理对象都要维护。工作量会很大。

 

二、动态代理

动态代理有两种实现方法,分别是jdk代理和Cglib代理。

     Jdk代理主要实现Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)。其中ClassLoader 表示当前目标对象使用的类加载器,Class<?>表示目标对象实现的接口的类型,InvocationHandler 表示事件处理,当执行目标对象是会触发该方法。

    这里同样使用“一只程序猿在写代码,休息”为例子

//抽象对象:
public interface DynamicPeople {
    public void codeing();
    public void doOtherThing(String things);
}
//目标对象
public class DynamicProgrammer implements DynamicPeople {
    @Override
    public void codeing() {
        System.out.println("我在写代码...");
    }
    @Override
    public void doOtherThing(String things) {
        System.out.println(things+"...");
    }
}
//动态代理类
public class JdkDynamicProxy {
    public Object object;
    
    public JdkDynamicProxy(Object object){
        this.object=object;
    }

    //获取一个代理
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                object.getClass().getClassLoader(), 
                object.getClass().getInterfaces(), 
                new InvocationHandler(){
                    @Override
                 //这里proxy表示代理目标,methos表示方法,args表示参数
                    public Object invoke(Object proxy, Method method,
                            Object[] args) throws Throwable {
                        System.out.println("写日志");
                        //执行对应的方法
                        Object result =method.invoke(object, args);
                        return result;
                    }                
                });
    }
}

调用程序猿的方法,看看代理效果:

public class DynamicClient {
    public static void main(String[] args) {
        DynamicPeople programmer = new DynamicProgrammer();
        DynamicPeople proxy = (DynamicPeople) new JdkDynamicProxy(programmer).getProxyInstance();
        
        proxy.codeing();
        System.out.println("*************");
        proxy.doOtherThing("休息中");
    }
}

执行结果

 

    可见动态代理已经成功了。但这时我们需要实现上面所说的“分别定义一个时间代理,一个日志代理,不管时间、日志谁先谁后,都不需要去修改原有的代理或许添加新代理类”。这些我们需要改下newProxyInstance的InvocationHandler。我们分别定义时间处理类DynamicTimeHandler和日志处理类DynamicLogHandler,两者都继承InvocationHandler,代码如下:

public class DynamicTimeHandler implements InvocationHandler {
    //目标对象
    private Object object;
    public DynamicTimeHandler(Object object){
        this.object=object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {    
        System.out.println("开始时间");
        Object result = method.invoke(object, args);
        return result;
    }
}
public class DynamicLogHandler implements InvocationHandler {
    private Object object;
    public DynamicLogHandler(Object object){
        this.object=object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("开始日志");
        Object result = method.invoke(object, args);
        return result;
    }
}

修改代理类:

public class JdkDynamicProxy {
    public Object object;
    public InvocationHandler h;
    
    public JdkDynamicProxy(Object object,InvocationHandler h){
        this.object=object;
        this.h = h ;
    }

    //获取一个代理
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                object.getClass().getClassLoader(), 
                object.getClass().getInterfaces(), 
                h);
    }
}

调用程序猿的方法,看看代理效果     

public class DynamicClient {
    public static void main(String[] args) {
        DynamicPeople programmer = new DynamicProgrammer();
        InvocationHandler time = new DynamicTimeHandler(programmer);
        DynamicPeople timeProxy = (DynamicPeople) new JdkDynamicProxy(programmer,time).getProxyInstance();
        
        InvocationHandler log  = new DynamicLogHandler(timeProxy);
        DynamicPeople logProxy = (DynamicPeople) new JdkDynamicProxy(programmer,log).getProxyInstance();
        
        logProxy.codeing();
        System.out.println("*************");
        logProxy.doOtherThing("休息中");    
    }
}

执行结果:

 

   

    这样就实现了上面所说的效果了。但jdk的实现限制,就是目标对象必须实现一个接口。这个缺陷,我们用Cglib代理是可以解决的(Cglib在Spring的核心包中)。

这里我们以“开车去看美女”为例子

//定义一个目标对象汽车类
public class Car {
    public void running(){
        System.out.println("开着汽车...");
    }
    public void doSomething(String things){
        System.out.println("开着汽车"+things);
    }
}
//写代理方法
public class CglibDynamicProxy implements MethodInterceptor{
    public Object b;
    
    public CglibDynamicProxy(Object b){
        this.b=b;
    }
    
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(b.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object arg0, Method method, Object[] arg2,
            MethodProxy arg3) throws Throwable {
            System.out.println("开始代理...");
            //执行目标对象的方法
            Object returnValue = method.invoke(b, arg2);
            return returnValue;
    }
}

调用方法,看一下执行效果

public class DynamicClient {
    public static void main(String[] args) {
        Car car = new Car();
        Car newCar= (Car) new CglibDynamicProxy(car).getProxyInstance();
        newCar.doSomething("看美女");
        newCar.running();
    }    
}

执行结果

 

对于如何“分别定义一个时间代理,一个日志代理,不管时间、日志谁先谁后,都不需要去修改原有的代理或许添加新代理类”还没研究,等以后补上,O(∩_∩)O

© 著作权归作者所有

下一篇: Java动态编译
粉丝 0
博文 3
码字总数 3259
作品 0
深圳
私信 提问

暂无文章

Docker搭建Mysql集群、主从同步复制

1、创建数据挂载点: mkdir /opt/mysql-master/mysql、/opt/mysql-master/conf.d、/opt/mysql-slave/conf.d、/opt/mysql-slave/conf.d 2、分别在master、slave节点文件目录conf.d下创建touch......

WALK_MAN
32分钟前
6
0
手把手教你做中间件开发(分布式缓存篇)-借助redis已有的网络相关.c和.h文件,半小时快速实现一个epoll异步网络框架,程序demo

本文档配合主要对如下demo进行配合说明: 借助redis已有的网络相关.c和.h文件,半小时快速实现一个epoll异步网络框架,程序demo 0. 手把手教你做中间件、高性能服务器、分布式存储技术交流群 ...

y123456yz
33分钟前
2
0
阿里技术男的成长史:越想证明自己死得越快……

在上海工作8年后,身为部门经理的钱磊,管理着一家ERP公司的百十来号员工,“再往上爬就是老板和他儿子了……从这个领域的技术角度来讲算是做到了顶。”05年,钱磊就开始关注一家名字奇怪,做...

阿里云云栖社区
37分钟前
3
0
Spring-boot单元测试(私有方法测试)

Spring-boot的单元测试网上有了很多,当项目是可以使用spring-boot正常运行时,只要在测试类上添加如下配置就使用@Autowired的方式进行单元测试 @RunWith(SpringJUnit4ClassRunner.class)@...

琴兽
54分钟前
1
0
spring cloud(第一部)框架概述

关于微服务 近几年,'微服务'这个词越来越多的被身边的人所提及,到底什么是微服务,为什么微服务总是伴随着spring cloud被人们所提及,这里笔者结合多年的技术经历跟大家分享下自己的理解:...

白中墨
55分钟前
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部