【源码分析设计模式 6】Mybatis中的组合模式

野性酷女 2021-08-29 20:07 361阅读 0赞

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70][] ##

## 一、基本介绍 ##

组合模式，将对象组合成树形结构以表示“整体-部分”的层次结构，一种对象结构型模式。

由于在软件开发中存在大量的树形结构，因此组合模式是一种使用频率较高的结构型设计模式，Java SE中的AWT和Swing包的设计就基于组合模式。除此以外，在XML解析、组织结构树处理、文件系统设计等领域，组合模式都得到了广泛应用。

组合模式的分类：

### 1、透明组合模式 ###

透明组合模式中，抽象构件角色中声明了所有对于管理成员对象的方法，透明组合模式是组合模式的标准形式。

### 2、安全组合模式 ###

安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在容器构件类中声明并实现这些方法。

## 二、组合模式的结构 ##

### 1、Component（抽象构件） ###

它可以是接口或抽象类，以叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。

### 2、Composite（容器构件） ###

它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了抽象构件中定义的行为，包括哪些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

### 3、Leaf（叶子构件） ###

它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。

组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

## 三、组合模式优缺点 ##

### 1、优点 ###

（1）组合模式可以清晰的定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。

（2）客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。

（3）在组合模式中增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符合“开闭原则”。

（4）组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

### 2、缺点 ###

（1）使得设计更加复杂，客户端需要花更多时间理清类之间的层次关系。

（2）在增加新构件时很难对容器中的构件类型进行限制。

## 四、组合模式的使用场景 ##

1、在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致地对待它们。

2、在一个使用面向对象语言开发的系统中需要处理一个树形结构。

3、在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。

## 五、组合模式实现学校院系展示 ##

### 1、抽象构件 ###

package designMode.advance.composite;
    
    public abstract class OrganizationComponent {
        private String name; // 名字
        private String des; // 说明
    
        protected  void add(OrganizationComponent organizationComponent) {
            //默认实现
            throw new UnsupportedOperationException();
        }
    
        protected  void remove(OrganizationComponent organizationComponent) {
            //默认实现
            throw new UnsupportedOperationException();
        }
    
        //构造器
        public OrganizationComponent(String name, String des) {
            super();
            this.name = name;
            this.des = des;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getDes() {
            return des;
        }
    
        public void setDes(String des) {
            this.des = des;
        }
    
        //方法print, 做成抽象的, 子类都需要实现
        protected abstract void print();
    }

### 2、容器构件 --> 学校类 ###

package designMode.advance.composite;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class University extends OrganizationComponent {
        List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
    
        // 构造器
        public University(String name, String des) {
            super(name, des);
        }
    
        // 重写add
        @Override
        protected void add(OrganizationComponent organizationComponent) {
            organizationComponents.add(organizationComponent);
        }
    
        // 重写remove
        @Override
        protected void remove(OrganizationComponent organizationComponent) {
            organizationComponents.remove(organizationComponent);
        }
    
        @Override
        public String getName() {
            return super.getName();
        }
    
        @Override
        public String getDes() {
            return super.getDes();
        }
    
        // print方法，就是输出University 包含的学院
        @Override
        protected void print() {
            System.out.println("--------------" + getName() + "--------------");
            //遍历 organizationComponents
            for (OrganizationComponent organizationComponent : organizationComponents) {
                organizationComponent.print();
            }
        }
    }

###  3、容器构件 --> 学院类 ###

package designMode.advance.composite;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class College extends OrganizationComponent {
        //List 中 存放的Department
        List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
    
        // 构造器
        public College(String name, String des) {
            super(name, des);
        }
    
        // 重写add
        @Override
        protected void add(OrganizationComponent organizationComponent) {
            //  将来实际业务中，Colleage 的 add 和  University add 不一定完全一样
            organizationComponents.add(organizationComponent);
        }
    
        // 重写remove
        @Override
        protected void remove(OrganizationComponent organizationComponent) {
            organizationComponents.remove(organizationComponent);
        }
    
        @Override
        public String getName() {
            return super.getName();
        }
    
        @Override
        public String getDes() {
            return super.getDes();
        }
    
        // print方法，就是输出University 包含的学院
        @Override
        protected void print() {
            System.out.println("--------------" + getName() + "--------------");
            //遍历 organizationComponents
            for (OrganizationComponent organizationComponent : organizationComponents) {
                organizationComponent.print();
            }
        }
    }

### 4、叶子节点 --> 专业类 ###

package designMode.advance.composite;
    
    public class Department extends OrganizationComponent {
        //没有集合
        public Department(String name, String des) {
            super(name, des);
        }
    
        //add , remove 就不用写了，因为他是叶子节点
        @Override
        public String getName() {
            return super.getName();
        }
    
        @Override
        public String getDes() {
            return super.getDes();
        }
    
        @Override
        protected void print() {
            System.out.println(getName());
        }
    }

### 5、测试类 ###

package designMode.advance.composite;
    
    public class Client {
        public static void main(String[] args) {
            //从大到小创建对象 学校
            OrganizationComponent university = new University("清华大学", " 中国顶级大学 ");
    
            //创建 学院
            OrganizationComponent computerCollege = new College("计算机学院", " 计算机学院 ");
            OrganizationComponent infoEngineercollege = new College("信息工程学院", " 信息工程学院 ");
    
    
            //创建各个学院下面的系(专业)
            computerCollege.add(new Department("软件工程", " 软件工程不错 "));
            computerCollege.add(new Department("网络工程", " 网络工程不错 "));
            computerCollege.add(new Department("计算机科学与技术", " 计算机科学与技术是老牌的专业 "));
    
            //
            infoEngineercollege.add(new Department("通信工程", " 通信工程不好学 "));
            infoEngineercollege.add(new Department("信息工程", " 信息工程好学 "));
    
            //将学院加入到 学校
            university.add(computerCollege);
            university.add(infoEngineercollege);
    
            university.print();
            //infoEngineercollege.print();
        }
    }

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1][] ##

## 六、Java集合类HashMap 源码分析 ##

HashMap 提供了putAll方法，可以将另一个Map对象放入自己的存储空间中，如有相同的key则会覆盖之前的key值所对应的value值。

### 1、代码实例 ###

package designMode.advance.composite;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class HashMapComposite {
        public static void main(String[] args) {
            Map<Integer,String> universityMap = new HashMap<>();
            universityMap.put(1,"清华大学");
            universityMap.put(2,"北京大学");
            universityMap.put(3,"辽宁石油化工大学");
            System.out.println("universityMap: " + universityMap);
            Map<Integer,String> collegeMap = new HashMap<>();
            collegeMap.put(1,"计算机学院");
            collegeMap.put(4,"信息工程学院");
            System.out.println("collegeMap: " + collegeMap);
            universityMap.putAll(collegeMap);
            System.out.println("universityMap.putAll(collegeMap),"+universityMap);
        }
    }

### 2、控制台输出 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2][]

### 3、源码分析 ###

![20200608145421131.png][]

putAll接收的参数为父类Map类型，所以hashmap是一个容器类，map的子类为叶子类，当然如果map的其它子类也实现了putAll方法，那么他们既是容器类，又都是叶子类；

同理，ArrayList 中的 addAll(Collection<? extends E> c) 方法也是一个组合模式的应用；

## 七、Mybatis SqlNode中的组合模式 ##

MyBatis 的强大特性之一便是它的动态SQL，其通过 if, choose, when, otherwise, trim, where, set, foreach 标签，可组合成非常灵活的SQL语句，从而提高开发人员的效率。

### 动态SQL – IF ###

<select id="findActiveBlogLike"  resultType="Blog">
      SELECT * FROM BLOG WHERE state = ‘ACTIVE’ 
      <if test="title != null">
        AND title like #{title}
      </if>
      <if test="author != null and author.name != null">
        AND author_name like #{author.name}
      </if>
    </select>

### 动态SQL – choose, when, otherwise ###

<select id="findActiveBlogLike"  resultType="Blog">
      SELECT * FROM BLOG WHERE state = ‘ACTIVE’
      <choose>
        <when test="title != null">
          AND title like #{title}
        </when>
        <when test="author != null and author.name != null">
          AND author_name like #{author.name}
        </when>
        <otherwise>
          AND featured = 1
        </otherwise>
      </choose>
    </select>

### 动态SQL – where ###

<select id="findActiveBlogLike"  resultType="Blog">
      SELECT * FROM BLOG 
      <where> 
        <if test="state != null">
             state = #{state}
        </if> 
        <if test="title != null">
            AND title like #{title}
        </if>
        <if test="author != null and author.name != null">
            AND author_name like #{author.name}
        </if>
      </where>
    </select>

### 动态SQL – foreach ###

<select id="selectPostIn" resultType="domain.blog.Post">
      SELECT * FROM POST P WHERE ID in
      <foreach item="item" index="index" collection="list"
          open="(" separator="," close=")">
            #{item}
      </foreach>
    </select>

Mybatis在处理动态SQL节点时，应用到了组合设计模式，MyBatis会将映射文件中定义的静态SQL节点、文本节点等解析成对应的SqlNode实现，形成树形结构。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70]: /images/20210813/7bafaf5000af466abcfb666cba21ef46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 1]: /images/20210813/b401b895c25e41e9befd91eccd8c1ffd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh_size_16_color_FFFFFF_t_70 2]: /images/20210813/86e9a4ae6bb9451f93eba5633dd31bd7.png
[20200608145421131.png]: /images/20210813/8dc4b38b66d94249aeccf15fe3318721.png