装饰者模式的应用场景
装饰者模式（DecoratorPattern）是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能），属于结构型模式。装饰者模式在我们生活中应用也比较多如给煎饼加鸡蛋；给蛋糕加上一些水果；给房子装修等，为对象扩展一些额外的职责。装饰者在代码程序中适用于以下场景：
1、用于扩展一个类的功能或给一个类添加附加职责。
2、动态的给一个对象添加功能，这些功能可以再动态的撤销。
来看一个这样的场景，上班族白领其实大多有睡懒觉的习惯，每天早上上班都是踩点，于是很多小伙伴为了多赖一会儿床都不吃早餐。那么，也有些小伙伴可能在上班路上碰到卖煎饼的路边摊，都会顺带一个到公司茶水间吃早餐。卖煎饼的大姐可以给你的煎饼加鸡蛋，也可以加香肠。
下面我们用代码还原一下码农的生活。首先创建一个煎饼 Battercake 类:
public class Battercake {
protected String getMsg(){
return "煎饼";
}
public int getPrice(){
return 5;
}
}
创建一个加鸡蛋的煎饼 BattercakeWithEgg 类：
public class BattercakeWithEgg extends Battercake{
@Override
protected String getMsg() {
return super.getMsg() + "+1个鸡蛋";
}
@Override
//加一个鸡蛋加1块钱
public int getPrice() {
return super.getPrice() + 1;
}
}
再创建一个既加鸡蛋又加香肠的 BattercakeWithEggAndSausage 类：
public class BattercakeWithEggAndSausage extends BattercakeWithEgg{
@Override
protected String getMsg() {
return super.getMsg() + "+1根香肠";
}
@Override
//加一个香肠加2块钱
public int getPrice() {
return super.getPrice() + 2;
}
}
编写客户端测试代码：
public class BattercakeTest {
public static void main(String[] args) {
Battercake battercake = new Battercake();
System.out.println(battercake.getMsg() + ",总价格：" + battercake.getPrice());
Battercake battercakeWithEgg = new BattercakeWithEgg();
System.out.println(battercakeWithEgg.getMsg() + ",总价格：" + battercakeWithEgg.getPrice());
Battercake battercakeWithEggAndSausage = new BattercakeWithEggAndSausage();
System.out.println(battercakeWithEggAndSausage.getMsg() + ",总价格：" + battercakeWithEggAndSausage.getPrice());
}
}
运行结果：
运行结果没有问题。但是，如果用户需要一个加 2 个鸡蛋加 1 根香肠的煎饼，那么用我 们现在的类结构是创建不出来的，也无法自动计算出价格，除非再创建一个类做定制。 如果需求再变，一直加定制显然是不科学的。那么下面我们就用装饰者模式来解决上面 的问题。首先创建一个建煎饼的抽象 Battercake 类：
public abstract class Battercake {
protected abstract String getMsg();
protected abstract int getPrice();
}
创建一个基本的煎饼（或者叫基础套餐）BaseBattercake：
public class BaseBattercake extends Battercake {
protected String getMsg(){
return "煎饼";
}
public int getPrice(){
return 5;
}
}
然后，再创建一个扩展套餐的抽象装饰者 BattercakeDecotator 类：
public abstract class BattercakeDecorator extends Battercake {
//静态代理，委派
private Battercake battercake;
public BattercakeDecorator(Battercake battercake) {
this.battercake = battercake;
}
protected abstract void doSomething();
@Override
protected String getMsg() {
return this.battercake.getMsg();
}
@Override
protected int getPrice() {
return this.battercake.getPrice();
}
}
然后，创建鸡蛋装饰者 EggDecorator 类：
public class EggDecorator extends BattercakeDecorator {
public EggDecorator(Battercake battercake) {
super(battercake);
}
protected void doSomething() {
}
@Override
protected String getMsg() {
return super.getMsg() + "+1个鸡蛋";
}
@Override
protected int getPrice() {
return super.getPrice() + 1;
}
}
创建香肠装饰者 SausageDecorator 类：
public class SausageDecorator extends BattercakeDecorator {
public SausageDecorator(Battercake battercake) {
super(battercake);
}
protected void doSomething() {
}
@Override
protected String getMsg() {
return super.getMsg() + "+1根香肠";
}
@Override
protected int getPrice() {
return super.getPrice() + 2;
}
}
编写客户端测试代码：
public class BattercakeTest {
public static void main(String[] args) {
Battercake battercake;
//路边摊买一个煎饼
battercake = new BaseBattercake();
//煎饼有点小，想再加一个鸡蛋
battercake = new EggDecorator(battercake);
//再加一个鸡蛋
// battercake = new EggDecorator(battercake);
//很饿，再加根香肠
battercake = new SausageDecorator(battercake);
battercake = new SausageDecorator(battercake);
battercake = new SausageDecorator(battercake);
battercake = new SausageDecorator(battercake);
battercake = new SausageDecorator(battercake);
//跟静态代理最大区别就是职责不同
//静态代理不一定要满足is-a的关系
//静态代理会做功能增强，同一个职责变得不一样
//装饰器更多考虑是扩展
System.out.println(battercake.getMsg() + ",总价：" + battercake.getPrice());
}
}
运行结果：
来看一下类图：
为了加深印象，我们再来看一个应用场景。是否还有小伙伴记得我们上次讲个的适配器 模式，为了实现新功能与老功能兼容，创建一个新的类继承已有的类，实现功能扩展，遵循开闭原则。今天我们再用装饰者模式再来升级一次代码，同时也做一个更好的对比。 先看原来的代码，Member 类：
public class Member {
private String username;
private String password;
private String mid;
private String info;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getMid() {
return mid;
}
public void setMid(String mid) {
this.mid = mid;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
ResultMsg 类：
public class ResultMsg {
private int code;
private String msg;
private Object data;
public ResultMsg(int code, String msg, Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}
ISigninService 接口：
public interface ISigninService {
ResultMsg regist(String username, String password);
/**
* 登录的方法
* @param username
* @param password
* @return
*/
ResultMsg login(String username, String password);
}
SigninService 实现类：
public class SigninService implements ISigninService {
public ResultMsg regist(String username,String password){
return new ResultMsg(200,"注册成功",new Member());
}
/**
* 登录的方法
* @param username
* @param password
* @return
*/
public ResultMsg login(String username,String password){
return null;
}
}
来看升级以后的代码，创建一个新的接口继承原来的接口：
public interface ISiginForThirdService extends ISigninService {
/**
* QQ登录
* @param id
* @return
*/
ResultMsg loginForQQ(String id);
/**
* 微信登录
* @param id
* @return
*/
ResultMsg loginForWechat(String id);
/**
* 记住登录状态后自动登录
* @param token
* @return
*/
ResultMsg loginForToken(String token);
/**
* 手机号登录
* @param telphone
* @param code
* @return
*/
ResultMsg loginForTelphone(String telphone, String code);
/**
* 注册后自动登录
* @param username
* @param passport
* @return
*/
ResultMsg loginForRegist(String username, String passport);
}
创建新的逻辑处理类 SigninForThirdService，实现新创建的接口:
public class SiginForThirdService implements ISiginForThirdService {
private ISigninService signinService;
public SiginForThirdService(ISigninService signinService) {
this.signinService = signinService;
}
public ResultMsg regist(String username, String password) {
return signinService.regist(username,password);
}
public ResultMsg login(String username, String password) {
return signinService.login(username,password);
}
public ResultMsg loginForQQ(String id) {
return null;
}
public ResultMsg loginForWechat(String id) {
return null;
}
public ResultMsg loginForToken(String token) {
return null;
}
public ResultMsg loginForTelphone(String telphone, String code) {
return null;
}
public ResultMsg loginForRegist(String username, String passport) {
return null;
}
}
客户端测试代码：
public class DecoratorTest {
public static void main(String[] args) {
//满足一个is-a
ISiginForThirdService siginForThirdService = new SiginForThirdService(new SigninService());
siginForThirdService.loginForQQ("sdfasfdasfsf");
}
}
装饰者模式最本质的特征是讲原有类的附加功能抽离出来，简化原有类的逻辑。通过这 样两个案例，我们可以总结出来，其实抽象的装饰者是可有可无的，具体可以根据业务 模型来选择。
装饰者模式和适配器模式对比
装饰者和适配器模式都是包装模式（Wrapper Pattern），装饰者也是一种特殊的代理模式。
装饰者模式在源码中的应用
装饰器模式在源码中也应用得非常多，在 JDK 中体现最明显的类就是 IO 相关的类，如 BufferedReader、InputStream、OutputStream，看一下常用的 InputStream 的类结 构图：
看看 MyBatis 中的一段处理缓存的设计 org.apache.ibatis.cache.Cache 类，找到它的包定位：
从名字上来看其实更容易理解了。比如 FifoCache 先入先出算法的缓存；LruCache 最近 最少使用的缓存；TransactionlCache 事务相关的缓存，都是采用装饰者模式。MyBatis 源码在我们后续的课程也会深入讲解，感兴趣的小伙伴可以详细看看这块的源码，也可 以好好学习一下 MyBatis 的命名方式，今天我们还是把重点放到设计模式上。
装饰者模式的优缺点
优点：
1、装饰者是继承的有力补充，比继承灵活，不改变原有对象的情况下动态地给一个对象 扩展功能，即插即用。
2、通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果。
3、装饰者完全遵守开闭原则。
缺点：
1、会出现更多的代码，更多的类，增加程序复杂性。
2、动态装饰时，多层装饰时会更复杂。