装饰者模式-java实现

的简介

装饰模式又称为“包装(Wrapper)模式”，以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。动态地给对象添加一些额外地职责，就增加功能而言，装饰模式比生成子类更加灵活。

一般来说，一些特殊场景，需要主类有一些额外的功能，如添加新的字段，逻辑，方法等，而这些内容，仅仅是在某些特殊场景才会用到，这时候如果使用继承的方式，会使得类变得更加复杂和冗余，于是我们可以考虑使用装饰模式，在特殊场景下，我们可以将主类封装到装饰类中，在装饰类中写上特殊场景下额外的功能逻辑，这样我们就将特殊场景的逻辑和主类分离了，是一个很好的解决方案。

意图：

装饰器模式是为已有的功能对象动态地添加更多功能的一种方式，就增加功能而言，会比继承更加灵活

请注意，是“动态”添加功能，意味着是在运行时才会体现，即是针对于对象的

类图

 

角色及职责：

抽象构件（Component）角色：给出一个抽象接口，以规范准备接收附加责任的对象

具体构件（Concrete Component）角色：定义一个将要接收附加责任的类，及被包装类，也就是我们简介中所说的主类

装饰（Decorator）角色：持有一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口，然后可以在此基础上添加新的附加功能规范。

具体装饰角色（Concrete Decorator）：负责给构件对象“贴上”附加的责任或功能，其实就是实现装饰接口，编写具体的附加逻辑功能。

优缺点：

优点

1. 装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性（如防止主类过于复杂）。
2. 通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同附加行为的组合。

缺点

使用装饰模式可以比使用继承关系需要较少数目的类，使用较少的类可以使设计比较易于进行;但是在另一方面,使用装饰模式会产生比使用继承关系更多的对象，更多的对象会使得查错变得困难，特别是这些对象看上去都很相似。同时，比继承更加灵活机动的特性，也意味着装饰模式比继承更加易于出错。

使用案例

现在我们有一个课程类，课程服务类，在特殊情况下，如管理员查看时，需要展示选择了该课程的学生集合。

现在我们不希望在课程类中加入学生集合这个属性（因为会变得冗余），那么我们可以使用装饰模式来进行该项附加字段以及功能。

那么我们根据上面的类图去定义：

先定义一个课程类Course：

public class Course {
    private Integer id;//课程编号
    private String name;//课程名称

    public Course(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Course{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

然后

1、定义抽象构件接口，即原始功能接口CourseService

//原始课程服务规范
public interface CourseService {
    //返回所有课程
    List<Course> getAllCourse();
}

2、定义具体构件，即原始主类

public class CourseServiceImpl implements CourseService{
    @Override
    public List<Course> getAllCourse() {
        List<Course> list=new ArrayList<>();
        list.add(new Course(1,"高等数学"));
        list.add(new Course(2,"数据结构"));
        list.add(new Course(3,"java"));
        return list;
    }
}

3、定义装饰接口CourseServiceDecorator，要记得继承原来的接口

public interface CourseServiceDecorator extends CourseService{
    //返回课程，以及返回选择该课程的学生姓名
    //这里通过map去进行返回
    Map<Course, List<String>> getAllCourseAndStudent();
}

4、定义装饰接口的实现类

//具体装饰类
public class ConcreteDecorator implements CourseServiceDecorator{
    //保持对旧接口实例的引用
    private CourseService courseService;

    public ConcreteDecorator(CourseService courseService) {
        this.courseService = courseService;
    }

    @Override
    public List<Course> getAllCourse() {
        return courseService.getAllCourse();
    }

    @Override
    public Map<Course, List<String>> getAllCourseAndStudent() {
        Map<Course,List<String>> map=new HashMap<>();
        //获取所有学生
        List<Course> courseList = courseService.getAllCourse();
        //将学生输入到map中
        Iterator<Course> iterator = courseList.iterator();
        Course course=null;
        while (iterator.hasNext()){
            course=iterator.next();
            map.put(course,getStudent(course));
        }

        return map;
    }
    //工具方法，返回指定课程的学生集合
    public List<String> getStudent(Course course){
        List<String> list=new ArrayList<>();
        if (course.getName().equals("java")){
            list.add("苏小白");
            list.add("柳青");
            list.add("李逍遥");
        }
        else {
            list.add("李白");
            list.add("柳青");
            list.add("杜甫");
        }
        return list;
    }
}

然后我们进行测试

/*
装饰器模式-测试入口
在我们有一个课程服务类，在特殊情况下，如管理员查看时，需要展示选择了该课程的学生集合。
*/
public class Client {
    public static void main(String[] args) {
        CourseService courseService=new CourseServiceImpl();
        //普通用户使用课程服务时
        List<Course> allCourse = courseService.getAllCourse();
        for (Course course : allCourse) {
            System.out.println(course);
        }

        System.out.println("=========================管理员场景下===================================");
        //管理员使用课程服务时,对主类进行包装
        CourseServiceDecorator courseServiceDecorator=new ConcreteDecorator(courseService);
        Map<Course, List<String>> courseListMap = courseServiceDecorator.getAllCourseAndStudent();
        Set<Map.Entry<Course, List<String>>> entries = courseListMap.entrySet();
        for (Map.Entry<Course, List<String>> entry : entries) {
            Course key = entry.getKey();
            List<String> value = entry.getValue();
            System.out.print(key);
            System.out.print("-->");
            System.out.println(value);
        }
    }
}

运行结果

小结

总的来说，装饰器模式是继承的一种替代方案，适合用于某些特殊场景下才会需要的额外功能逻辑，不在主类中添加，而是在装饰类中添加附加的逻辑，这样能很好的将附加功能与主类进行分离，能保证主类中的代码简洁。