java设计模式的2种设计模式-组合模式和组合实体模式

1. 组合模式
   适用于树形式的场景，有整体和部分的概念，比如企业、树、目录等，有树枝、叶子，树枝能往下继续发展，但是叶子没有
   
   
   leaf和composit都继承component，但是leaf只实现show方法，因为叶子没有下一级
   在客户端中，虽然有component这类，没有直接实例它，都是通过compsite和leaf去实现它

Composite folderRoot = new Composite("网关组需求US文件夹");
        folderRoot.add(new Leaf("特性说明文档模板.docx"));
        folderRoot.add(new Leaf("开发简单设计文档模板.docx"));

        Composite folderLevel1 = new Composite("32.2版本开发需求");
        folderRoot.add(folderLevel1);

        Composite folderLevel2 = new Composite("23.2 迭代一需求");
        folderLevel1.add(folderLevel2);

        folderLevel2.add(new Leaf("网关动态路由转发需求开发设计文档.docx"));
        folderLevel2.add(new Leaf("网关鉴权功能开发设计文档.docx"));

        Leaf leaf = new Leaf("测试.txt");
        folderRoot.add(leaf);
        folderRoot.remove(leaf);

        folderRoot.show(0);

2. 组合实体模式
   在实施上就是有多个类，一层一层实例化引用，特点是更新组合实体，内部的依赖对象也会自动更新，是比较简单的思想了
   
   组合实体模式涉及的角色有：

依赖对象Dependent Object:Java Bean,生命周期由粗粒度对象维护（内部方法和数据由粗粒度对象调用和维护）

粗粒度对象Coarse-Grained Object:内部包含依赖对象，管理依赖对象的生命周期。

组合实体Composite Entity:包含粗粒度对象，维护粗粒度对象的生命周期。

策略Strategies:如何实现组合实体。

实践
依赖对象1：DependentObject1.java

package compositeentitypattern;

/**
 * 依赖对象1
 */
public class DependentObject1 {
    private String data;

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

依赖对象2：DependentObject2.java

package compositeentitypattern;

/**
 * 依赖对象2
 */
public class DependentObject2 {
    private String data;

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

粗粒度对象：CoarseGrainedObject.java

package compositeentitypattern;

/**
 * 粗粒度对象，管理依赖对象的生命周期
 */
public class CoarseGrainedObject {
    DependentObject1 dependentObject1 = new DependentObject1();

    DependentObject2 dependentObject2 = new DependentObject2();

    public void setData(String data1, String data2) {
        dependentObject1.setData(data1);
        dependentObject2.setData(data2);
    }

    public String[] getData() {
        return new String[] {dependentObject1.getData(), dependentObject2.getData()};
    }
}

组合实体：CompositeEntity.java

package compositeentitypattern;

/**
 * 组合实体，管理粗粒度对象的生命周期
 */
public class CompositeEntity {
    private CoarseGrainedObject coarseGrainedObject = new CoarseGrainedObject();

    public void setData(String data1, String data2) {
        coarseGrainedObject.setData(data1, data2);
    }

    public String[] getData() {
        return coarseGrainedObject.getData();
    }
}

客户端：Client.java

package compositeentitypattern;

/**
 * 客户端
 */
public class Client {
    private CompositeEntity compositeEntity = new CompositeEntity();

    public void printData() {
        for (String data : compositeEntity.getData()) {
            System.out.println("Data:" + data);
        }
    }

    public void setData(String data1, String data2) {
        compositeEntity.setData(data1, data2);
    }
}

组合实体模式验证demo：CompositeEntityDemo.java

package compositeentitypattern;

public class CompositeEntityDemo {
    public static void main(String[] args) {
        Client client = new Client();
        client.setData("Test", "Data");
        client.printData();

        client.setData("Test2", "Data2");
        client.printData();
    }
}

结果：

Data:Test
Data:Data
Data:Test2
Data:Data2
总结：粗粒度对象管理依赖对象的生命周期，组合实体管理粗粒度对象的生命周期，策略用于实现组合实体。合到一块用于实现EJB持久化机制，平时开发中了解即可。