原博文:https://blog.csdn.net/KongZhongNiao/article/details/80704184
学习装饰模式
一:初识装饰模式
包括:定义、结构、参考实现
二:体会装饰模式
包括:场景问题、不用模式的解决方案、使用模式的解决方案
三:理解装饰模式
包括:认识装饰模式、Java中的装饰模式应用、装饰模式和AOP 、
装饰模式的优缺点
四:思考装饰模式
包括:装饰模式的本质、何时选用
初识装饰模式
定义
动态地给一个对象添加一些额外的职责。就增加功能来说,装饰模式比生
成子类更为灵活。
结构和说明
Component:
组件对象的接口,可以给这些对象动态的添加职责。
ConcreteComponent:
具体的组件对象,实现组件对象接口,通常就是被装饰器装饰的原始对
象,也就是可以给这个对象添加职责。
Decorator:
所有装饰器的抽象父类,需要定义一个与组件接口一致的接口,并持有一
个Component对象,其实就是持有一个被装饰的对象。
注意这个被装饰的对象不一定是最原始的那个对象了,也可能是被其它装
饰器装饰过后的对象,反正都是实现的同一个接口,也就是同一类型。
ConcreteDecorator:
实际的装饰器对象,实现具体要向被装饰对象添加的功能。
示例
组件对象的接口,可以给这些对象动态的添加职责
package cn.javass.dp.decorator.example3;
/**
* 组件对象的接口,可以给这些对象动态的添加职责
*/
public abstract class Component {
/**
* 示例方法
*/
public abstract void operation();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
装饰器接口,维持一个指向组件对象的接口对象,
package cn.javass.dp.decorator.example3;
/**
* 装饰器接口,维持一个指向组件对象的接口对象,
* 并定义一个与组件接口一致的接口
*/
public abstract class Decorator extends Component {
/**
* 持有组件对象
*/
protected Component component;
/**
* 构造方法,传入组件对象
* @param component 组件对象
*/
public Decorator(Component component) {
this.component = component;
}
public void operation() {
//转发请求给组件对象,可以在转发前后执行一些附加动作
component.operation();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
具体实现组件对象接口的对象
package cn.javass.dp.decorator.example3;
/**
* 具体实现组件对象接口的对象
*/
public class ConcreteComponent extends Component {
public void operation() {
//相应的功能处理
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
装饰器的具体实现对象,向组件对象添加职责
package cn.javass.dp.decorator.example3;
/**
* 装饰器的具体实现对象,向组件对象添加职责
*/
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
/**
* 添加的状态
*/
private String addedState;
public String getAddedState() {
return addedState;
}
public void setAddedState(String addedState) {
this.addedState = addedState;
}
public void operation() {
//调用父类的方法,可以在调用前后执行一些附加动作
//在这里进行处理的时候,可以使用添加的状态
System.out.println("begin---------->");
super.operation();
System.out.println("begin---------->");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
装饰器的具体实现对象,向组件对象添加职责
package cn.javass.dp.decorator.example3;
/**
* 装饰器的具体实现对象,向组件对象添加职责
*/
public class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
/**
* 需要添加的职责
*/
private void addedBehavior() {
//需要添加的职责实现
}
public void operation() {
//调用父类的方法,可以在调用前后执行一些附加动作
super.operation();
addedBehavior();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
体会装饰模式
复杂的奖金计算
奖金计算是相对复杂的功能,尤其是对于业务部门的奖金计算方式,是非
常复杂的,除了业务功能复杂外,另外一个麻烦之处是计算方式还经常需要变
动,因为业务部门经常通过调整奖金的计算方式来激励士气。
先从业务上看看现有的奖金计算方式的复杂性:
- 1:首先是奖金分类:对于个人,大致有个人当月业务奖金、个人累计奖金、个人业
务增长奖金、及时回款奖金、限时成交加码奖金等等; - 2:对于业务主管或者是业务经理,除了个人奖金外,还有:团队累计奖金、团队业
务增长奖金、团队盈利奖金等等。 - 3:其次是计算奖金的金额,又有这么几个基数:销售额、销售毛利、实际回款、业
务成本、奖金基数等等; - 4:另外一个就是计算的公式,针对不同的人、不同的奖金类别、不同的计算奖金的
金额,计算的公式是不同的,就算是同一个公式,里面计算的比例参数也有可能
是不同的。
简化后的奖金计算体系
看了上面奖金计算的问题,所幸我们只是来学习设计模式,并不是真的要
去实现整个奖金计算体系的业务,因此也没有必要把所有的计算业务都罗列在这
里,为了后面演示的需要,简化一下,演示用的奖金计算体系如下:
- 1:每个人当月业务奖金 = 当月销售额 X 3%
- 2:每个人累计奖金 = 总的回款额 X 0.1%
- 3:团队奖金 = 团队总销售额 X 1%
不用模式的解决方案
示例
在内存中模拟数据库,准备点测试数据,好计算奖金
package cn.javass.dp.decorator.example1;
import java.util.*;
/**
* 在内存中模拟数据库,准备点测试数据,好计算奖金
*/
public class TempDB {
private TempDB(){}
/**
* 记录每个人的月度销售额,只用了人员,月份没有用
*/
public static Map<String,Double> mapMonthSaleMoney = new HashMap<String,Double>();
static{
//填充测试数据
mapMonthSaleMoney.put("张三",10000.0);
mapMonthSaleMoney.put("李四",20000.0);
mapMonthSaleMoney.put("王五",30000.0);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
计算奖金的对象
package cn.javass.dp.decorator.example1;
import java.util.Date;
/**
* 计算奖金的对象
*/
public class Prize {
/**
* 计算某人在某段时间内的奖金,有些参数在演示中并不会使用,
* 但是在实际业务实现上是会用的,为了表示这是个具体的业务方法,
* 因此这些参数被保留了
* @param user 被计算奖金的人员
* @param begin 计算奖金的开始时间
* @param end 计算奖金的结束时间
* @return 某人在某段时间内的奖金
*/
public double calcPrize(String user,Date begin,Date end){
double prize = 0.0;
//计算当月业务奖金,所有人都会计算
prize = this.monthPrize(user, begin, end);
//计算累计奖金
prize += this.sumPrize(user, begin, end);
//需要判断该人员是普通人员还是业务经理,团队奖金只有业务经理才有
if(this.isManager(user)){
prize += this.groupPrize(user, begin, end);
}
return prize;
}
/**
* 计算某人的当月业务奖金,参数重复,就不再注释了
*/
private double monthPrize(String user, Date begin, Date end) {
//计算当月业务奖金,按照人员去获取当月的业务额,然后再乘以3%
double prize = TempDB.mapMonthSaleMoney.get(user) * 0.03;
System.out.println(user+"当月业务奖金"+prize);
return prize;
}
/**
* 计算某人的累计奖金,参数重复,就不再注释了
*/
public double sumPrize(String user, Date begin, Date end) {
//计算累计奖金,其实这里应该按照人员去获取累计的业务额,然后再乘以0.1%
//简单演示一下,假定大家的累计业务额都是1000000元
double prize = 1000000 * 0.001;
System.out.println(user+"累计奖金"+prize);
return prize;
}
/**
* 判断人员是普通人员还是业务经理
* @param user 被判断的人员
* @return true表示是业务经理,false表示是普通人员
*/
private boolean isManager(String user){
//应该从数据库中获取人员对应的职务
//为了演示,简单点判断,只有王五是经理
if("王五".equals(user)){
return true;
}
return false;
}
/**
* 计算当月团队业务奖,参数重复,就不再注释了
*/
public double groupPrize(String user, Date begin, Date end) {
//计算当月团队业务奖金,先计算出团队总的业务额,然后再乘以1%,假设都是一个团队的
double group = 0.0;
for(double d : TempDB.mapMonthSaleMoney.values()){
group += d;
}
double prize = group * 0.01;
System.out.println(user+"当月团队业务奖金"+prize);
return prize;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
客户端
package cn.javass.dp.decorator.example1;
public class Client {
public static void main(String[] args) {
//先创建计算奖金的对象
Prize p = new Prize();
//日期对象都没有用上,所以传null就可以了
double zs = p.calcPrize("张三",null,null);
System.out.println("==========张三应得奖金:"+zs);
double ls = p.calcPrize("李四",null,null);
System.out.println("==========李四应得奖金:"+ls);
double ww = p.calcPrize("王五",null,null);
System.out.println("==========王经理应得奖金:"+ww);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
有何问题
对于奖金计算,光是计算方式复杂,也就罢了,不过是实现起来会困难
点,相对而言还是比较好解决的,不过是用程序把已有的算法表达出来。
最痛苦的是,这些奖金的计算方式,经常发生变动,几乎是每个季度都会
有小调整,每年都有大调整,这就要求软件的实现要足够灵活,要能够很快进行
相应调整和修改,否则就不能满足实际业务的需要。
举个简单的例子来说,现在根据业务需要,需要增加一个“环比增长奖
金”,就是本月的销售额比上个月有增加,而且要达到一定的比例,当然增长比
例越高,奖金比例越大。那么软件就必须要重新实现这么个功能,并正确的添加
到系统中去。过了两个月,业务奖励的策略发生了变化,不再需要这个奖金了,
或者是另外换了一个新的奖金方式了,那么软件就需要把这个功能从软件中去
掉,然后再实现新的功能。
那么上面的要求该如何实现呢?
很明显,一种方案是通过继承来扩展功能;另外一种方案就是到计算奖金
的对象里面,添加或者删除新的功能,并在计算奖金的时候,调用新的功能或是
不调用某些去掉的功能,这种方案会严重违反开-闭原则。
还有一个问题,就是在运行期间,不同人员参与的奖金计算方式也是不同
的,举例来说:如果是业务经理,除了参与个人计算部分外,还要参加团队奖金
的计算,这就意味着需要在运行期间动态来组合需要计算的部分,也就是会有一
堆的if-else。
总结一下,奖金计算面临如下问题:
- (1)计算逻辑复杂
- (2)要有足够灵活性,可以方便的增加或者减少功能
- (3)要能动态的组合计算方式,不同的人参与的计算不同
上面描述的奖金计算的问题,绝对没有任何夸大成分,相反已经简化不少
了,还有更多麻烦没有写上来,毕竟我们的重点在设计模式,而不是业务。
把上面的问题抽象一下,设若有一个计算奖金的对象,现在需要能够灵活
的给它增加和减少功能,还需要能够动态的组合功能,每个功能就相当于在计算
奖金的某个部分。
现在的问题就是:如何才能够透明的给一个对象增加功能,并实现功能的
动态组合呢?
使用模式来解决的思路
虽然经过简化,业务简单了很多,但是需要解决的问题不会少,还是要解
决:要透明的给一个对象增加功能,并实现功能的动态组合。
所谓透明的给一个对象增加功能,换句话说就是要给一个对象增加功能,
但是不能让这个对象知道,也就是不能去改动这个对象。而实现了能够给一个对
象透明的增加功能,自然就能够实现功能的动态组合。
在装饰模式的实现中,为了能够和原来使用被装饰对象的代码实现无缝结
合,是通过定义一个抽象类,让这个类实现与被装饰对象相同的接口,然后在具
体实现类里面,转调被装饰的对象,在转调的前后添加新的功能,这就实现了给
被装饰对象增加功能,这个思路跟“对象组合”非常类似。
在转调的时候,如果觉得被装饰的对象的功能不再需要了,还可以直接替
换掉,也就是不再转调,而是在装饰对象里面完全全新的实现。
使用模式来解决的类图
画个图来说明奖金的计算过程
这个图很好的揭示了装饰模式的组合和调用过程,请仔细体会一下。
示例
在内存中模拟数据库,准备点测试数据,好计算奖金
package cn.javass.dp.decorator.example4;
import java.util.*;
/**
* 在内存中模拟数据库,准备点测试数据,好计算奖金
*/
public class TempDB {
private TempDB(){}
/**
* 记录每个人的月度销售额,只用了人员,月份没有用
*/
public static Map<String,Double> mapMonthSaleMoney = new HashMap<String,Double>();
static{
//填充测试数据
mapMonthSaleMoney.put("张三",10000.0);
mapMonthSaleMoney.put("李四",20000.0);
mapMonthSaleMoney.put("王五",30000.0);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
装饰器的接口,需要跟被装饰的对象实现同样的接口
package cn.javass.dp.decorator.example4;
import java.util.Date;
/**
* 装饰器的接口,需要跟被装饰的对象实现同样的接口
*/
public abstract class Decorator extends Component{
/**
* 持有被装饰的组件对象
*/
protected Component c;
/**
* 通过构造方法传入被装饰的对象
* @param c被装饰的对象
*/
public Decorator(Component c){
this.c = c;
}
public double calcPrize(String user, Date begin, Date end) {
//转调组件对象的方法
return c.calcPrize(user, begin, end);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
计算奖金的组件接口
package cn.javass.dp.decorator.example4;
import java.util.*;
/**
* 计算奖金的组件接口
*/
public abstract class Component {
/**
* 计算某人在某段时间内的奖金,有些参数在演示中并不会使用,
* 但是在实际业务实现上是会用的,为了表示这是个具体的业务方法,
* 因此这些参数被保留了
* @param user 被计算奖金的人员
* @param begin 计算奖金的开始时间
* @param end 计算奖金的结束时间
* @return 某人在某段时间内的奖金
*/
public abstract double calcPrize(String user,Date begin,Date end);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
基本的实现计算奖金的类,也是被装饰器装饰的对象
package cn.javass.dp.decorator.example4;
import java.util.Date;
/**
* 基本的实现计算奖金的类,也是被装饰器装饰的对象
*/
public class ConcreteComponent extends Component{
public double calcPrize(String user, Date begin, Date end) {
//只是一个默认的实现,默认没有奖金
return 0;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
装饰器对象,计算当月团队业务奖金
package cn.javass.dp.decorator.example4;
import java.util.Date;
/**
* 装饰器对象,计算当月团队业务奖金
*/
public class GroupPrizeDecorator extends Decorator{
public GroupPrizeDecorator(Component c){
super(c);
}
public double calcPrize(String user, Date begin, Date end) {
//1:先获取前面运算出来的奖金
double money = super.calcPrize(user, begin, end);
//2:然后计算当月团队业务奖金,先计算出团队总的业务额,然后再乘以1%
//假设都是一个团队的
double group = 0.0;
for(double d : TempDB.mapMonthSaleMoney.values()){
group += d;
}
double prize = group * 0.01;
System.out.println(user+"当月团队业务奖金"+prize);
return money + prize;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
装饰器对象,计算累计奖金
package cn.javass.dp.decorator.example4;
import java.util.Date;
/**
* 装饰器对象,计算累计奖金
*/
public class SumPrizeDecorator extends Decorator{
public SumPrizeDecorator(Component c){
super(c);
}
public double calcPrize(String user, Date begin, Date end) {
//1:先获取前面运算出来的奖金
double money = super.calcPrize(user, begin, end);
//2:然后计算累计奖金,其实这里应该按照人员去获取累计的业务额,然后再乘以0.1%
//简单演示一下,假定大家的累计业务额都是1000000元
double prize = 1000000 * 0.001;
System.out.println(user+"累计奖金"+prize);
return money + prize;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
装饰器对象,计算当月业务奖金
package cn.javass.dp.decorator.example4;
import java.util.Date;
/**
* 装饰器对象,计算当月业务奖金
*/
public class MonthPrizeDecorator extends Decorator{
public MonthPrizeDecorator(Component c){
super(c);
}
public double calcPrize(String user, Date begin, Date end) {
//1:先获取前面运算出来的奖金
double money = super.calcPrize(user, begin, end);
//2:然后计算当月业务奖金,按照人员和时间去获取当月的业务额,然后再乘以3%
double prize = TempDB.mapMonthSaleMoney.get(user) * 0.03;
System.out.println(user+"当月业务奖金"+prize);
return money + prize;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
客户端
package cn.javass.dp.decorator.example4;
/**
* 使用装饰模式的客户端
*/
public class Client {
public static void main(String[] args) {
//先创建计算基本奖金的类,这也是被装饰的对象
Component c1 = new ConcreteComponent();
//然后对计算的基本奖金进行装饰,这里要组合各个装饰
//说明,各个装饰者之间最好是不要有先后顺序的限制,也就是先装饰谁和后装饰谁都应该是一样的
//先组合普通业务人员的奖金计算
Decorator d1 = new MonthPrizeDecorator(c1);
Decorator d2 = new SumPrizeDecorator(d1);
//注意:这里只需要使用最后组合好的对象调用业务方法即可,会依次调用回去
//日期对象都没有用上,所以传null就可以了
Decorator d4 = new MonthPrizeDecorator(d2);
double zs = d4.calcPrize("张三",null,null);
System.out.println("==========张三应得奖金:"+zs);
double ls = d2.calcPrize("李四",null,null);
System.out.println("==========李四应得奖金:"+ls);
//如果是业务经理,还需要一个计算团队的奖金计算
Decorator d3 = new GroupPrizeDecorator(d2);
double ww = d3.calcPrize("王五",null,null);
System.out.println("==========王经理应得奖金:"+ww);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
理解装饰模式
认识装饰模式
1:装饰模式的功能
装饰模式能够实现动态的为对象添加功能,是从一个对象外部来给对象增
加功能,相当于是改变了对象的外观。当装饰过后,从外部使用系统的角度看,
就不再是使用原始的那个对象了,而是使用被一系列的装饰器装饰过后的对象。
这样就能够灵活的改变一个对象的功能,只要动态组合的装饰器发生了改
变,那么最终所得到的对象的功能也就发生了改变。
变相的还得到了另外一个好处,那就是装饰器功能的复用,可以给一个对
象多次增加同一个装饰器,也可以用同一个装饰器装饰不同的对象。
2:对象组合
在面向对象设计中,有一条很基本的规则就是“尽量使用对象组合,而不
是对象继承”来扩展和复用功能 ,装饰模式的思考起点就是这个规则 。
3:装饰器
装饰器实现了对被装饰对象的某些装饰功能,可以在装饰器里面调用被装
饰对象的功能,获取相应的值,这其实是一种递归调用。
在装饰器里不仅仅是可以给被装饰对象增加功能,还可以根据需要选择是
否调用被装饰对象的功能,如果不调用被装饰对象的功能,那就变成完全重新实
现了,相当于动态修改了被装饰对象的功能。
另外一点,各个装饰器之间最好是完全独立的功能,不要有依赖,这样在
进行装饰组合的时候,才没有先后顺序的限制,也就是先装饰谁和后装饰谁都应
该是一样的,否则会大大降低装饰器组合的灵活性。
4:装饰器和组件类的关系
装饰器是用来装饰组件的,装饰器一定要实现和组件类一致的接口,保证
它们是同一个类型,并具有同一个外观,这样组合完成的装饰才能够递归的调用
下去。
组件类是不知道装饰器的存在的,装饰器给组件添加功能是一种透明的包
装,组件类毫不知情。需要改变的是外部使用组件类的地方,现在需要使用包装
后的类,接口是一样的,但是具体的实现类发生了改变。
示例
A
package cn.javass.dp.decorator.example2;
public class A {
public void a1(){
System.out.println("now in A.a1");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
B
package cn.javass.dp.decorator.example2;
public class B {
public void b1(){
System.out.println("now in B.b1");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
C1 extends A
package cn.javass.dp.decorator.example2;
public class C1 extends A{
public void c11(){
System.out.println("now in C1.c11");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
C2 内部实现组合
package cn.javass.dp.decorator.example2;
public class C2 {
/**
* 创建A对象的实例
*/
private A a = new A();
public void a1(){
//转调A对象的功能
a.a1();
}
public void c11(){
System.out.println("now in C2.c11");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
C3 内部实现组合
package cn.javass.dp.decorator.example2;
public class C3 {
private A a = new A();
private B b = new B();
public void a1(){
//转调A对象的功能
a.a1();
}
public void b1(){
//转调B对象的功能
b.b1();
}
public void c11(){
System.out.println("now in C3.c11");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
示例直接在属性上创建需要组合的对象
package cn.javass.dp.decorator.example2;
public class C4 {
//示例直接在属性上创建需要组合的对象
private A a = new A();
//示例通过外部传入需要组合的对象
private B b = null;
public void setB(B b){
this.b = b;
}
public void a1(){
//转调A对象的功能
a.a1();
}
public void b1(){
//转调B对象的功能
b.b1();
}
public void c11(){
System.out.println("now in C4.c11");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
5:退化形式
如果仅仅只是想要添加一个功能,就没有必要再设计装饰器的抽象类了,
直接在装饰器里面实现跟组件一样的接口,然后实现相应的装饰功能就可以了。
但是建议最好还是设计上装饰器的抽象类,这样有利于程序的扩展。
Java中的装饰模式应用
Java中典型的装饰模式应用——I/O流
Java的I/O对象层次图
查看上图会发现,它的结构和装饰模式的结构几乎是一样的:
- 1:InputStream就相当于装饰模式中的Component。
- 2:其实FileInputStream、ObjectInputStream、StringBufferInputStream这几个
对象是直接继承了InputSream,还有几个直接继承InputStream的对象,比如:
ByteArrayInputStream、PipedInputStream等。这些对象相当于装饰模式中的
ConcreteComponent,是可以被装饰器装饰的对象。 - 3:那么FilterInputStream就相当于装饰模式中的Decorator,而它的子类
DataInputStream、BufferedInputStream、LineNumberInputStream和
PushbackInputStream就相当于装饰模式中的ConcreteDecorator了。另外
FilterInputStream和它的子类对象的构造器,都是传入组件InputStream类型,
这样就完全符合前面讲述的装饰器的结构了。
自己实现的I/O流的装饰器——第一版
来个功能简单点的,实现把英文加密存放吧,也谈不上什么加密算法,就
是把英文字母向后移动两个位置,比如:a变成c,b变成d,以此类推,最后的y
变成a,z就变成b,而且为了简单,只处理小写的,够简单的吧。
示例
IOTest
package cn.javass.dp.decorator.example5;
import java.io.*;
public class IOTest {
public static void main(String[] args)throws Exception {
//流式读取文件
DataInputStream din = null;
try{
din = new DataInputStream(
new BufferedInputStream(
new FileInputStream("IOTest.txt")
)
);
//然后就可以获取文件内容了
byte bs []= new byte[din.available()];
din.read(bs);
String content = new String(bs);
System.out.println("文件内容===="+content);
}finally{
din.close();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
实现简单的加密
package cn.javass.dp.decorator.example5;
import java.io.*;
/**
* 实现简单的加密
*/
public class EncryptOutputStream extends OutputStream{
//持有被装饰的对象
private OutputStream os = null;
public EncryptOutputStream(OutputStream os){
this.os = os;
}
public void write(int a) throws IOException {
//先统一向后移动两位
a = a+2;
//97是小写的a的码值
if(a >= (97+26)){
//如果大于,表示已经是y或者z了,减去26就回到a或者b了
a = a-26;
}
this.os.write(a);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
客户端
package cn.javass.dp.decorator.example5;
import java.io.*;
public class Client {
public static void main(String[] args) throws Exception {
//流式输出文件
DataOutputStream dout =
new DataOutputStream(
new BufferedOutputStream(
new EncryptOutputStream(
new FileOutputStream("MyEncrypt.txt"))));
//然后就可以输出内容了
dout.write("abcdxy".getBytes());
dout.close();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
测试中可能会出现输出一片空白,要把这个问题搞清楚,就需要把上面I/O
流的内部运行和基本实现搞明白,分开来看看具体的运行过程吧。
示例
package cn.javass.dp.decorator.example5;
import java.io.*;
public class Client {
public static void main(String[] args) throws Exception {
//流式输出文件
DataOutputStream dout =
new DataOutputStream(
new EncryptOutputStream(
new BufferedOutputStream(
new FileOutputStream("MyEncrypt.txt"))));
//然后就可以输出内容了
dout.write("abcdxy".getBytes());
dout.close();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
先看看成功输出流中的内容的写法的运行过程:
- 1:当执行到“dout.write(”abcdxyz“.getBytes());”这句话的时候,会调用
DataOutputStream的write方法,把数据输出到BufferedOutputStream中; - 2:由于BufferedOutputStream流是一个带缓存的流,它默认缓存8192byte,也就是
默认流中的缓存数据到了8192byte,它才会自动输出缓存中的数据; 3:而目前要输出的字节肯定不到8192byte,因此数据就被缓存在
BufferedOutputStream流中了,而不会被自动输出4:当执行到“dout.close();”这句话的时候:会调用关闭DataOutputStream流,
这会转调到传入DataOutputStream中的流的close方法,也就是
BufferedOutputStream的close方法,而BufferedOutputStream的close方法继承
自FilterOutputStream,在FilterOutputStream的close方法实现里面,会先调
用输出流的方法flush,然后关闭流。也就是此时BufferedOutputStream流中缓
存的数据会被强制输出;- 5:BufferedOutputStream流中缓存的数据被强制输出到EncryptOutputStream流,
也就我们自己实现的流,没有缓存,经过处理后继续输出; - 6:EncryptOutputStream流会把数据输出到FileOutputStream中,
FileOutputStream会直接把数据输出到文件中,因此,这种实现方式会输出文件
的内容。
再来看看不能输出流中的内容的写法的运行过程:
- 1:当执行到“dout.write(”abcdxyz“.getBytes());”这句话的时候,会调用
DataOutputStream的write方法,把数据输出到EncryptOutputStream中; - 2:EncryptOutputStream流,也就是我们自己实现的流,没有缓存,经过处理后继续输
出,把数据输出到BufferedOutputStream中; - 3:由于BufferedOutputStream流是一个带缓存的流,它默认缓存8192byte,也就是默认
流中的缓存数据到了8192byte,它才会自动输出缓存中的数据; - 4:而目前要输出的字节肯定不到8192byte,因此数据就被缓存在BufferedOutputStream
流中了,而不会被自动输出 - 5:当执行到“dout.close();”这句话的时候:会调用关闭DataOutputStream流,这会
转调到传入DataOutputStream流中的流的close方法,也就是EncryptOutputStream的
close方法,而EncryptOutputStream的close方法继承自OutputStream,在
OutputStream的close方法实现里面,是个空方法,什么都没有做。因此,这种实现
方式没有flush流的数据,也就不会输出文件的内容,自然是一片空白了。
自己实现的I/O流的装饰器——第二版
要让我们写的装饰器跟其它Java中的装饰器一样用,最合理的方案就应该
是:让我们的装饰器继承装饰器的父类,也就是FilterOutputStream类,然后使
用父类提供的功能来协助完成想要装饰的功能。
示例
实现简单的加密
package cn.javass.dp.decorator.example5;
import java.io.*;
/**
* 实现简单的加密
*/
public class EncryptOutputStream2 extends java.io.FilterOutputStream{
public EncryptOutputStream2(OutputStream os){
//调用父类的构造方法
super(os);
}
public void write(int a) throws IOException {
//先统一向后移动两位
a = a+2;
//97是小写的a的码值
if(a >= (97+26)){
//如果大于,表示已经是y或者z了,减去26就回到a或者b了
a = a-26;
}
//调用父类的方法
super.write(a);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
客户端
package cn.javass.dp.decorator.example5;
import java.io.*;
public class Client {
public static void main(String[] args) throws Exception {
//流式输出文件
DataOutputStream dout =
new DataOutputStream(
new EncryptOutputStream2(
new BufferedOutputStream(
new FileOutputStream("MyEncrypt.txt"))));
//然后就可以输出内容了
dout.write("abcdxy".getBytes());
dout.close();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
装饰模式和AOP
关于AOP的知识,可以参看私塾在线上关于AOP的课程,或者是Spring的课程。
可以使用装饰模式做出类似AOP的效果
示例
商品销售管理的业务接口
package cn.javass.dp.decorator.example6;
/**
* 商品销售管理的业务接口
*/
public interface GoodsSaleEbi {
/**
* 保存销售信息,本来销售数据应该是多条,太麻烦了,为了演示,简单点
* @param user 操作人员
* @param customer 客户
* @param saleModel 销售数据
* @return 是否保存成功
*/
public boolean sale(String user,String customer,SaleModel saleModel);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
实现商品销售管理的业务
package cn.javass.dp.decorator.example6;
public class GoodsSaleEbo implements GoodsSaleEbi{
public boolean sale(String user,String customer, SaleModel saleModel) {
System.out.println(user+"保存了"+customer+"购买 "+saleModel+" 的销售数据");
return true;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
装饰器的接口,需要跟被装饰的对象实现同样的接口
package cn.javass.dp.decorator.example6;
/**
* 装饰器的接口,需要跟被装饰的对象实现同样的接口
*/
public abstract class Decorator implements GoodsSaleEbi{
/**
* 持有被装饰的组件对象
*/
protected GoodsSaleEbi ebi;
/**
* 通过构造方法传入被装饰的对象
* @param ebi被装饰的对象
*/
public Decorator(GoodsSaleEbi ebi){
this.ebi = ebi;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
实现日志记录
package cn.javass.dp.decorator.example6;
import java.text.*;
import java.util.Date;
/**
* 实现日志记录
*/
public class LogDecorator extends Decorator{
public LogDecorator(GoodsSaleEbi ebi){
super(ebi);
}
public boolean sale(String user,String customer, SaleModel saleModel) {
//执行业务功能
boolean f = this.ebi.sale(user, customer, saleModel);
//在执行业务功能过后,记录日志
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
System.out.println("日志记录:"+user+"于"+df.format(new Date())+"时保存了一条销售记录,客户是"+customer+",购买记录是"+saleModel);
return f;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
实现权限控制
package cn.javass.dp.decorator.example6;
/**
* 实现权限控制
*/
public class CheckDecorator extends Decorator{
public CheckDecorator(GoodsSaleEbi ebi){
super(ebi);
}
public boolean sale(String user,String customer, SaleModel saleModel) {
//简单点,只让张三执行这个功能
if(!"张三".equals(user)){
System.out.println("对不起"+user+",你没有保存销售单的权限");
//就不再调用被装饰对象的功能了
return false;
}else{
return this.ebi.sale(user, customer, saleModel);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
客户端
package cn.javass.dp.decorator.example6;
public class Client {
public static void main(String[] args) {
//得到业务接口,组合装饰器
GoodsSaleEbi ebi = new LogDecorator(new CheckDecorator(new GoodsSaleEbo()));
//准备测试数据
SaleModel saleModel = new SaleModel();
saleModel.setGoods("Moto手机");
saleModel.setSaleNum(2);
//调用业务功能
ebi.sale("张三","张三丰", saleModel);
ebi.sale("李四","张三丰", saleModel);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
装饰模式的优缺点
- 1:比继承更灵活
- 2:更容易复用功能
- 3:简化高层定义
- 4:会产生很多细粒度对象
思考装饰模式
装饰模式的本质
装饰模式的本质是:动态组合
何时选用装饰模式
- 1:如果需要在不影响其它对象的情况下,以动态、透明的方式给对象添加职责,可
以使用装饰模式,这几乎就是装饰模式的主要功能 - 2:如果不合适使用子类来进行扩展的时候,可以考虑使用装饰模式,因为装饰模式
是使用的“对象组合”的方式。所谓不适合用子类扩展的方式,比如:扩展功能
需要的子类太多,造成子类数目呈爆炸性增长。