java之Spring(AOP)前奏-动态代理设计模式(上)

我们常常会遇到这样的事,项目经理让你为一个功能类再加一个功能A,然后你加班为这个类加上了功能A;

过了两天又来了新需求,再在A功能后面加上一个新功能B,你加班写好了这个功能B,加在了A后面;又过

了几天天,项目经理说这两个新加的功能顺序需要调换一下,然后你找到一个礼拜之前的写的源代码,看了

一遍想起来当时是怎么实现的了,这部分是功能A,那部分是功能B,然后巴拉巴拉换了顺序。看到这是不是

觉得很烦,动不动就要在源码上加新功能,完了又要在源码上换新功能的顺序,那么一大坨源码,还好是自

己写的源码,理解起来很快,操作起来也很快,万一是别人的源码,别人的编程习惯可能和自己的不一样,

看他的源码,又要多花点时间,真是卷铺盖走人的心都有了。

这个时候,我们就可以用代理来为源码有序地添加新功能。

1.定义一个接口

public interface InterfaceDo {
    public void dosomething();
}

2.定义原始功能类

public class Persontodo implements InterfaceDo {
    public void dosomething() {
        System.out.println("要干什么呢--------");
    }
}

我们可以看到,这个类实现了之前的接口, 但是只做一件事:思考人生!

3.定义额外功能类,并实现对原始功能的调用

public class Impeat implements InterfaceDo {
    private InterfaceDo todo;
    public Impeat(InterfaceDo todo) {
        super();
        this.todo = todo;
    }
    public void dosomething() {
        todo.dosomething();
        System.out.println("我要吃饭了啊--------");
    }
}

我们看到这个类引入了一个成员变量,类型为InterfaceDo(接口)类型,

构造函数实现为成员变量赋值,那么当我们实例化这个类的时候,它内部的成员变量是指向传入的参数对象的实例的。

Persontodo a = new Persontodo();

Impeat b  = new Impeat(a);

那么,b.dosomething()这个方法实现的功能是:先执行实例化时候传进来的参数todo的todo.dosomething()方法,然后

再执行语句System.out.println("我要吃饭了啊------------");

在上面的例子由于传进来的参数是a,那么b.dosomething()就同等于以下两步操作:

①a.dosomething();

②System.out..println("我要吃饭了啊------------");

结果控制台打印输出:

要干什么呢--------

我要吃饭了啊---------

弄懂之后我们再来新建个Impeat这样的类,同样是实现InterfaceDo接口

public class Impgame implements InterfaceDo {
    private InterfaceDo todo;
    public Impgame(InterfaceDo todo) {
        super();
        this.todo = todo;
    }
    public void dosomething() {
        System.out.println("我要玩游戏了啊--------");
        todo.dosomething();
    }
}

上面接口实现类的含参构造函数的参数是InterfaceDo(接口)类型,所以参数可以是该接口所有实现类的实例化对象。

4.多态的运用

public class Testperson {
    public static void main(String[] args) {
        Persontodo a = new Persontodo();
        Impeat c = new Impeat(a);
        Impgame d = new Impgame(c);
        Impsleep b = new Impsleep(d);
        b.dosomething();
    }
}

我们可以看到这个测试类,将原始功能类的实例化对象作为参数传给Impeat的含参构造器,然后将Impeat的实例化对象

作为参数传给Impgame的含参构造器,再将Impgame的实例化对象作为参数传给Impsleep的含参构造器,最后调用了

Impgame的实例化对象的dosomething()方法。

那么,实际上这个方法是:

先调用参数的dosomething()方法然后打印一条语句,而参数的dosomething()方法也是

先调用参数的dosomething()方法然后打印一条语句,如此循环,可以用一张图表示。

-----------------------------------------------------------------------------

java之Spring(AOP)前奏-动态代理设计模式(上)_第1张图片

-----------------------------------------------------------------------------

每个框都是一个类,当然新增功能顺序可以自由选择,你也可以先实现功能2在实现1。

如此一来每个除原始功能类之外的功能类,都是具备往其他功能类上添加功能的能力的。

由于上面所有的类都是实现InterfaceDo接口的,那么可以将上面的代码改写一下:

public class Testperson {
    public static void main(String[] args) {
        InterfaceDo a = new Persontodo();
        InterfaceDo c = new Impeat(a);
        InterfaceDo d = new Impgame(c);
        InterfaceDo b = new Impsleep(d);
        b.dosomething();
    }
}

不难看出,这就是引用多态,接口的引用指向实现类的对象。

c在a的功能基础上添加了功能;

d在c的功能基础上添加了功能;

b在d的功能基础上添加了功能。

这就实现了静态代理。

转载于:https://www.cnblogs.com/eco-just/p/7853180.html

你可能感兴趣的:(设计模式,java)