Soteware_programming_design_refactoringAndDesignPattern

　　19:44:48

1. 使用 Builder 简化 Composite 模式

package com.srdc.tech.service.webConstructure;



import com.srdc.tech.service.seleniumAction.Execution.ExecutionType;
import com.srdc.tech.service.seleniumAction.Location.LocationType;
import java.util.ArrayList;
import java.util.List;

public class WebItem {
    private String name;
    private String value;
    private String locationPath;
    private ExecutionType exeType;
    private LocationType locateType;
    private WebItem parent;
    private List<WebItem> children = new ArrayList<>();

    public WebItem(String name) {
        this.name = name;
    }


    public String getName() {
        return name;
    }

    public String getValue() {
        return value;
    }

    public String getLocationPath() {
        return locationPath;
    }

    public ExecutionType getExeType() {
        return exeType;
    }

    public LocationType getLocateType() {
        return locateType;
    }

    public void add(WebItem entry) {
        children.add(entry);
    }

    public void setParent(WebItem parent) {
        this.parent = parent;
    }

    public WebItem getParent() {
        return this.parent;
    }

    public List<WebItem> getChildren() {
        return children;
    }

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

    public void setValue(String value) {
        this.value = value;
    }

    public void setLocationPath(String locationPath) {
        this.locationPath = locationPath;
    }

    public void setExeType(String exeType) {
        if(exeType.equalsIgnoreCase("webDefault")){
            this.exeType = ExecutionType.webDefault;
        }
        if(exeType.equalsIgnoreCase("jsExecutor")){
            this.exeType = ExecutionType.JSExecutor;
        }
        if(exeType.equalsIgnoreCase("actions")){
            this.exeType = ExecutionType.actions;
        }
    }

    public void setLocateType(String locateType) {
        if(locateType.equalsIgnoreCase("xpath")){
            this.locateType = LocationType.xpath;
        }
        if(locateType.equalsIgnoreCase("id")){
            this.locateType = LocationType.id;
        }
        // todo: remain
    }

    public void setChildren(List<WebItem> children) {
        this.children = children;
    }

}

模仿 《重构与模式》 第六章节 Builder 简化 Composite 模式，但发现在获取单个 Item 时的不便，或是自己理解不够。Builder的应用有所得

package com.srdc.tech.service.webConstructure;

public class WebBuilder {
    private WebItem rootItem;
    private WebItem currentItem;

    public WebBuilder(String name){
        rootItem = new WebItem(name);
        currentItem = rootItem;
    }

    public void addTo(WebItem parent, WebItem willBeAddedItem){
        currentItem = willBeAddedItem;
        parent.add(currentItem);
    }

    public void addChild(WebItem childItem){
        addTo(currentItem,childItem);
    }

    public void addSibling(String currentName,WebItem siblingItem){
        WebItem parent = findParentItemBy(currentName);
        addTo(parent,siblingItem);
    }

    public void addToParent(String parentName, WebItem willBeAddedItem){
        WebItem parent = findParentItemBy(parentName);
        if(parent == null){
            throw new RuntimeException(String.format("missing parent web element: {0}", parentName));
        }
        parent.add(willBeAddedItem);
    }

    public WebItem findParentItemBy(String parentName){
        WebItem parent = currentItem;

        while(parent != null){
            if(parent.getName().equalsIgnoreCase(parentName)){
                return parent;
            }
            parent = parent.getParent();
        }
        return null;
    }

    public WebItem buildWebConstructure(){
        return this.rootItem;
    }

}

 

---

---

2019-12-21  19:08:53

Decorator

代码向类的核心职责提供装饰功能，动态添加新的功能。

 

 把每个装饰功能放在单独的类中，并让这个类包装它所要装饰的对象，当需要执行特殊行为时，代码就可以在运行时使用装饰功能包装对象。

以下情况不适用 Decorator 

1. 需要搬移装饰功能的类包含许多的公共方法， 则不使用装饰模式， 因为 transparent enclosure 透明地包装，必须实现它索要装饰的类的

所有公共方法（这会导致很多无用的代码）

  （如果存在要执行对象类型的检查，需要调整代码避开此项检查）

2. 涉及多个 decorator 时，顺序要符合预期的流程。 可通过 Creation method 来访问 decorator 的组合

需要熟悉对象组合

Protection Proxy 用来保护对象， Decorator 用来为对象添加行为。

 

Decorator 与  Strategy

将装饰功能搬移到 Decorator 重构和 用 Strategy 替换条件逻辑重构彼此之间是竞争关系。

都可以去除与特殊情况或选择性行为相关联的条件逻辑，且它们都通过把这些行为从原来的类搬移到一个

或多个新类中达到这一目的。

不同的是 如何使用这些新类， Decorator 实例把自己包装在一个对象之外（或彼此包装），而一个或多个Strategy 实例则用在一个对象当中。

1. 不能共享 Decorator实例--每个实例只能包装一个对象，另一方面，可以通过使用 Singleton 或 Flyweight 模式很容易地共享 Strategy 实例。

2. Strategy 可以随意定义自己的接口，而 Decorator 必须与它所装饰的类的接口一致。

3. Decorator 可以透明地为多个不同的类添加行为，只要这些类与Decorator 共享同一接口。 另一方面，想使用Strategy 对象的类必须知道

  它们的存在并了解如何使用它们。

4. 对包含很多数据或实现很多公共方法的类使用一个或多个 Strategy 是很常见的。另一方面，Decorator类会变得过重，占用内存过多，

如果用它们来装饰这种包含很多数据或实现很多公共方法的类。

 

要减少公共方法的数量， 删除，搬移或改变方法的可见性，或者考虑应用其他重构。

实现：

1 确定或创建包装类型 enclosure type ，接口或类， 声明了客户代码需要的被修饰类的公共方法。 这个包装类型被称为 ：Decorator Component

如果已经有了包装类型，它应该是被修饰类所实现的接口或者被装饰类的超类。 包含状态信息的类并不是合适的包装类型。

因为 Decorator 会继承这些不需要的状态。 如果没有合适的包装类型， 应该统一接口重构/或提炼接口重构来创建一个包装类型。

 2 找到为被修饰类添加装饰功能的条件逻辑 （ switch 或 If 语句），并应用 多态替换条件式重构去除这些逻辑。

在应用 多态替换条件式重构之前， 通常需要应用以 子类取代类型码 重构或用 State/Strategy 替换类型代码重构。

如果应用 以子类取代类型码重构，上一步就是创建一个 Creation Method 封装类型代码。

如果需要这样的Creation Method, 要确保它的返回类型是包装类型。

从超类中去除这些类型代码字段的时候，并不需要把类型代码的访问方法声明为抽象方法。

如果存在必须在装饰代码之前和/或之后执行的逻辑，在应用以子类取代类型码重构时， 可能需要使用形成 Template  Method 重构。

3 步骤2 产生了被修饰类的一个或多个子类，应用 以委托取代继承把这些子类转换成委托类。

  3.1 使每个委托类都实现包装类型

  3.2 把委托类的委托字段的类型声明为包装类型

  3.3 决定装饰代码在委托类调用委托之前还是之后执行。

 

如果在步骤2 中形成了 Template Method 重构， 委托类可能会需要调用 Template Method 引用的委托（例如，被修饰的类）的非公共方法，

如果存在该情况，改变这些方法的可见性并重新应用统一接口重构。

如果委托类委托了被修饰类中的返回未修饰对象实例的方法，确保委托类在把实例交给对象代码之前修饰它。

4。 每个委托类都用被修饰类的新建实例对自己的委托字段进行了赋值。确保这个赋值逻辑语句在委托类的构造函数中。

然后，应用 提取参数重构 提取赋值语句中实例化被修饰类的部分。 如果可能的话，重复应用 移除参数重构来移除构造函数中不必要的参数。

 

=========