设计模式：装饰者模式与组合模式
装饰者模式
概念
动态地给一个对象添加一些额外的职责。与继承的模式对比，装饰者模式更为灵活。
类图
以上共有四个角色：
抽象构件(Component)角色：给出一个抽象接口，以规范准备接收附加责任的对象。
具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类。
装饰(Decorator)角色：持有一个构件(Component)对象的实例，并定义一个与抽象构件接口一致的接口。
具体装饰(ConcreteDecorator)角色：负责给构件对象“贴上”附加的责任。
实例介绍
火锅包括锅底与配菜，有很多的组合方式，适合用装饰者模式实现。
1.定义被装饰对象基类GuoDi（可以是抽象类也可以是接口） 相当于Component
package com.example.demo;
public interface GuoDi {
/**
* 锅底的价格
* @return
*/
public float cost();
/**
* 锅底的名字
* @return
*/
public String name();
}
2.定义具体被装饰对象（也就是各种锅底，这里有两种） 相当于ConcreteComponent
package com.example.demo;
public class YuanYang implements GuoDi {
/**
* 锅底的价格
*
* @return
*/
@Override
public float cost() {
return 50.0f;
}
/**
* 锅底的名字
*
* @return
*/
@Override
public String name() {
return "鸳鸯锅底";
}
}
package com.example.demo;
public class XiangLa implements GuoDi {
/**
* 锅底的价格
*
* @return
*/
@Override
public float cost() {
return 40.0f;
}
/**
* 锅底的名字
*
* @return
*/
@Override
public String name() {
return "香辣锅底";
}
}
3.定义装饰者抽象类PeiCai，相当于Decorator
package com.example.demo;
public class PeiCai implements GuoDi {
private GuoDi guodi;
public PeiCai(GuoDi guodi) {
super();
this.guodi = guodi;
}
/**
* 锅底的价格
*
* @return
*/
@Override
public float cost() {
return guodi.cost();
}
/**
* 锅底的名字
*
* @return
*/
@Override
public String name() {
return guodi.name();
}
}
4.定义具体的装饰者对象（这里也是定义两个），相当于ConcreteDecorator
package com.example.demo;
public class MaLaNiuRou extends PeiCai {
public MaLaNiuRou(GuoDi guodi) {
super(guodi);
}
@Override
public float cost() {
return super.cost()+60f;
}
@Override
public String name() {
return super.name()+"+麻辣牛肉";
}
}
package com.example.demo;
public class DouFuPi extends PeiCai{
public DouFuPi(GuoDi guodi) {
super(guodi);
}
@Override
public float cost() {
return super.cost()+20.0f;
}
@Override
public String name() {
return super.name()+"+豆腐皮";
}
}
5.创建一个测试类Test
package com.example.demo;
public class Test {
public static void main(String[] args) {
//点个香辣锅底
GuoDi guodi = new XiangLa ();
//来个麻辣牛肉
MaLaNiuRou niurou = new MaLaNiuRou(guodi);
//再来一个豆腐皮
DouFuPi douFuPi = new DouFuPi(niurou);
System.out.println("您点了"+douFuPi.name());
System.out.println("共消费"+douFuPi.cost());
}
}
基本思想
1.编写一个类，实现与被装饰类相同的接口，目的是他们有相同的行为。
我们做了MaLaNiuRou这个类，实现与被装饰类XiangLa 相同的接口GuoDi，目的是他们有相同的行为：cost()，name()。
2.定义一个实例变量，引用被装饰的对象，目的与原来的老对象进行交接。
也就是
//点个香辣锅底
GuoDi guodi = new XiangLa ();
//来个麻辣牛肉
MaLaNiuRou niurou = new MaLaNiuRou(guodi);
3,定义构造方法。把被装饰的对象注入进来。
public MaLaNiuRou(GuoDi guodi) {
super(guodi);
}
4.对于不需要改写的方法，调用被装饰对象的方法。
5.对于要改写的方法，改写即可。
@Override
public float cost() {
return super.cost()+60f;
}
@Override
public String name() {
return super.name()+"+麻辣牛肉";
}
优点
（1）装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。装饰模式允许系统动态决定“贴上”一个需要的“装饰”，或者除掉一个不需要的“装饰”。继承关系则不同，继承关系是静态的，它在系统运行前就决定了。
（2）通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。
缺点
被装饰者一旦身份增加，作为装饰类，也需要相应的扩展，这必然造成编码的负担。
这个个人觉得其实不算是缺点，与继承相比，装饰功能的细化必然会导致产生很多的装饰对象。鱼与熊掌不可兼得。
混淆点
与代理模式的区别
对于装饰者模式来说，装饰者与被装饰者都实现同一个接口，对于代理模式来说，代理类与真实处理的类都实现同一个接口。而且都要把后者注入到前者。实现方式差别不大。
但是其中的关注点是不一样的。
| 代理模式 | 偏重因自己无法完成或自己无需关心，需要他人干涉事件流程，更多的是对对象的控制。 |
|---|---|
| 装饰者模式 | 偏重对原对象功能的扩展，扩展后的对象仍是是对象本身。 |
也就是思想的侧重点不一样。
在我们实际业务中装饰模式使用的案例就是IO类，经常可以看到一个流包装之后再包装。而代理模式的使用就有Spring AOP和Spring 事务。不过它们使用的是动态代理。因为普通的代理例如上面的例子称为静态代理，只能代理某一类对象，但在我们实际业务中不可能为每个类都去写一个代理类，所以这个时候就出现了动态代理。动态代理是使用反射的方法实现的，只用传入类的类型就可以达到增强类的方法。
应用场景
IO类（上文提到），或者遇到需要动态添加职能的场景。
组合模式
概念
组合模式对多个对象形成树形结构以表示具有“整体部分”关系的层次结构。组合模式对叶子对象和组合对象使用具有一致性。
类图
说明：
Component：为叶子与容器的抽象。定义操作叶子的方法，比如增删改，获取叶子等另外还要定义叶子的行为。
Leaf:叶子结点，没有子节点。实现叶子具体的行为。
Composite：容器节点对象，也就是非叶子节点。内部有集合存储子节点。可以实现访问子节点的方法。在组合模式中，由于容器仍然包含容器容器，所以容器需要使用递归方法对子元素进行处理。
示例介绍
文件夹杀毒业务：
常规实现
package demo1;//为了突出核心框架代码，我们对杀毒过程的实现进行了大量简化
import java.util.ArrayList;
//图像文件类
class ImageFile {
private String name;
public ImageFile(String name) {
this.name = name;
}
public void killVirus() {
//简化代码，模拟杀毒
System.out.println("----对图像文件'" + name + "'进行杀毒");
}
}
//文本文件类
class TextFile {
private String name;
public TextFile(String name) {
this.name = name;
}
public void killVirus() {
//简化代码，模拟杀毒
System.out.println("----对文本文件'" + name + "'进行杀毒");
}
}
//文件夹类
class Folder {
private String name;
//定义集合folderList，用于存储Folder类型的成员
private ArrayList<Folder> folderList = new ArrayList<Folder>();
//定义集合imageList，用于存储ImageFile类型的成员
private ArrayList<ImageFile> imageList = new ArrayList<ImageFile>();
//定义集合textList，用于存储TextFile类型的成员
private ArrayList<TextFile> textList = new ArrayList<TextFile>();
public Folder(String name) {
this.name = name;
}
//增加新的Folder类型的成员
public void addFolder(Folder f) {
folderList.add(f);
}
//增加新的ImageFile类型的成员
public void addImageFile(ImageFile image) {
imageList.add(image);
}
//增加新的TextFile类型的成员
public void addTextFile(TextFile text) {
textList.add(text);
}
public void killVirus() {
System.out.println("****对文件夹'" + name + "'进行杀毒"); //模拟杀毒
//如果是Folder类型的成员，递归调用Folder的killVirus()方法
for(Object obj : folderList) {
((Folder)obj).killVirus();
}
//如果是ImageFile类型的成员，调用ImageFile的killVirus()方法
for(Object obj : imageList) {
((ImageFile)obj).killVirus();
}
//如果是TextFile类型的成员，调用TextFile的killVirus()方法
for(Object obj : textList) {
((TextFile)obj).killVirus();
}
}
}
测试类
class Client {
public static void main(String args[]) {
Folder folder1,folder2,folder3;
folder1 = new Folder("Sunny的资料");
folder2 = new Folder("图像文件");
folder3 = new Folder("文本文件");
ImageFile image1,image2;
image1 = new ImageFile("小龙女.jpg");
image2 = new ImageFile("张无忌.gif");
TextFile text1,text2;
text1 = new TextFile("九阴真经.txt");
text2 = new TextFile("葵花宝典.doc");
folder2.addImageFile(image1);
folder2.addImageFile(image2);
folder3.addTextFile(text1);
folder3.addTextFile(text2);
folder1.addFolder(folder2);
folder1.addFolder(folder3);
folder1.killVirus();
}
}
该实现的弊端：
1.文件夹类Folder在进行多个集合存储需要针对不同的成员进行增删改方法，比较冗余。
2.客户端无法对容器和叶子进行统一的处理，因为没有进行抽象。
3.如果增加新的叶子类型，比如视频文件，需要修改Folder类。
用组合模式进行解决：
import java.util.*;
//抽象文件类：抽象构件
abstract class AbstractFile {
public abstract void add(AbstractFile file);
public abstract void remove(AbstractFile file);
public abstract AbstractFile getChild(int i);
public abstract void killVirus();
}
//图像文件类：叶子构件
class ImageFile extends AbstractFile {
private String name;
public ImageFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对图像文件'" + name + "'进行杀毒");
}
}
//文本文件类：叶子构件
class TextFile extends AbstractFile {
private String name;
public TextFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对文本文件'" + name + "'进行杀毒");
}
}
//视频文件类：叶子构件
class VideoFile extends AbstractFile {
private String name;
public VideoFile(String name) {
this.name = name;
}
public void add(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public void remove(AbstractFile file) {
System.out.println("对不起，不支持该方法！");
}
public AbstractFile getChild(int i) {
System.out.println("对不起，不支持该方法！");
return null;
}
public void killVirus() {
//模拟杀毒
System.out.println("----对视频文件'" + name + "'进行杀毒");
}
}
//文件夹类：容器构件
class Folder extends AbstractFile {
//定义集合fileList，用于存储AbstractFile类型的成员
private ArrayList<AbstractFile> fileList=new ArrayList<AbstractFile>();
private String name;
public Folder(String name) {
this.name = name;
}
public void add(AbstractFile file) {
fileList.add(file);
}
public void remove(AbstractFile file) {
fileList.remove(file);
}
public AbstractFile getChild(int i) {
return (AbstractFile)fileList.get(i);
}
public void killVirus() {
System.out.println("****对文件夹'" + name + "'进行杀毒"); //模拟杀毒
//递归调用成员构件的killVirus()方法
for(Object obj : fileList) {
((AbstractFile)obj).killVirus();
}
}
}
客户端测试方法：
class Client {
public static void main(String args[]) {
//针对抽象构件编程
AbstractFile file1,file2,file3,file4,file5,folder1,folder2,folder3,folder4;
folder1 = new Folder("Sunny的资料");
folder2 = new Folder("图像文件");
folder3 = new Folder("文本文件");
folder4 = new Folder("视频文件");
file1 = new ImageFile("小龙女.jpg");
file2 = new ImageFile("张无忌.gif");
file3 = new TextFile("九阴真经.txt");
file4 = new TextFile("葵花宝典.doc");
file5 = new VideoFile("笑傲江湖.rmvb");
folder2.add(file1);
folder2.add(file2);
folder3.add(file3);
folder3.add(file4);
folder4.add(file5);
folder1.add(folder2);
folder1.add(folder3);
folder1.add(folder4);
//从“Sunny的资料”节点开始进行杀毒操作
folder1.killVirus();
}
}
改进的效果
由于
进行了抽象，所以能够针对不同的成员进行增删改方法。
而且如果增加新的叶子类型，比如视频文件，不需要修改Folder类，只需要写一个实现AbstractFile接口的视频文件类就行了。而且各个容器相对独立，符合开闭原则，也方便管理。
实现的基本思想
1.定义抽象类或者接口。定义操作叶子的方法，比如增删改，获取叶子等另外还要定义具体的业务行为。
2.分别实现叶子类与容器类，叶子类主要实现业务的行为。容器类内部维护一个抽象类的集合，并且通过这个集合实现增删改叶子。然后通过递归的方式便利集合实现业务行为。
优点
1.组合模式可以无差别的使用容器对象与叶子对象。
2.新增容器与叶子都很友好。
3.与常规的操作树的方式比，组合模式通过递归的方式，可以形成复杂的树形结构，但对树形结构的控制却非常简单。
缺点
新增构件只要实现抽象就能进入父构件中，不能进行约束，如果非要约束的话，需要在运行中进行类型检查来实现。
应用场景
业务场景中具有树形结构或者层次结构中，比如文件夹，企业的组织构成业务。
