泛型和模板设计模式

当两个或多个功能很大一部分实现都一样，只有其中一部分处理逻辑不同的情况下。我们通常都会采用模板设计模式来实现，这样既可以满足功能的需求也可以很好地实现代码的维护。这也正是设计模式的精髓所在。但是，如果有这样一个需求，该如何实现呢？既满足了模板设计模式的条件，也就是说两个或多个功能的总体实现流程是一致的，只是部分处理逻辑上存在差异；但有点特别的是根据不同的功能，返回值类型有所差别。这样的情况下我们可以通过模板设计模式结合泛型来很好地实现相应的功能。

技术要点

我们先来看下模板设计模式的技术点，模板设计模式使用的技术点是：

• 抽象类：控制程序总体逻辑（骨架）
• 实现类：继承于抽象类，实现具体差异部分的逻辑

此处要求返回值类型根据不同的业务，返回不同类型的响应信息，因此还需要用到泛型。

• 泛型于设计模式的结合

具体实现如下：

响应实体泛型的定义

public class Result<T> {
    T response;

    public T getResponse() {
        return response;
    }

    public void setResponse(T response) {
        this.response = response;
    }
}

程序骨架，模板设计模式

public abstract class BaseService<T> {

    /**
     * 定义了程序的主要实现流程-骨架
     * @return
     */
    public Result handle() {
        Result result = new Result();
        method1();
        result.setResponse(method2());
        return result;
    }

    /**
     * 返回值-泛型，根据不同的业务返回不同的响应类型
     * @return
     */
    private T method2() {
        T response = initResponse();//获取子类初始化的响应实例
        System.out.println("BaseService method2");
        return response;
    }

    /**
     * 公共处理业务
     */
    private void method1() {
        System.out.println("BaseService method1");
    }

    /**
     * 响应类型-泛型，提供出去给具体实现类进行初始化
     * @return
     */
    protected abstract T initResponse();
}

模板抽象类需要注意的几个点：

• BaseService<T>，模板类提供泛型支持
• Result里的response返回值类型，由子类进行控制
• 返回值类型，通过提供抽象方法，子类进行初始化来实现。protected abstract T initResponse();

至此，根据不同业务类型返回不同响应类型的模板设计模式的总体框架已经搭建完成了。

差异业务实现类

• 定义返回值类型
• 继承于模板抽象类-业务实现类
• 实现模板抽象类的方法

返回值类型

/**
 *
 * 返回值类型基类，公共部分
 */
public class BaseResponse {
    private int age;
    private String name;

    public String getName() {
        return name;
    }

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

/**
 *
 * 返回值类型
 */
public class ChinaResponse extends BaseResponse {

    List<String> province;

    public List<String> getProvince() {
        return province;
    }

    public void setProvince(List<String> province) {
        this.province = province;
    }
}

/**
 *
 * 返回值类型
 */
public class AmericaResponse extends BaseResponse {
    List<String> state;

    public List<String> getState() {
        return state;
    }

    public void setState(List<String> state) {
        this.state = state;
    }
}

继承于模板抽象类-业务实现类

/**
 *
 * 业务实现类1
 */
public class ChinaServiceImpl extends BaseService<ChinaResponse> {

    public Result<ChinaResponse> handle() {
        Result result = super.handle();
        return result;
    }

    /**
     * 实现抽象方法，初始化返回值类型
     * @return
     */
    @Override
    protected ChinaResponse initResponse() {
        return new ChinaResponse();
    }
}

/**
 *
 * 业务实现类2
 */
public class AmericaServiceImpl extends BaseService<AmericaResponse> {

    /**
     * 实现抽象方法，初始化返回值类型
     * @return
     */
    @Override
    protected AmericaResponse initResponse() {
        return new AmericaResponse();
    }
}

测试

    public static void main(String[] args) {
        BaseService<ChinaResponse> baseService = new ChinaServiceImpl();
        Result<ChinaResponse> result = baseService.handle();
        ChinaResponse chinaResponse = result.getResponse();
        System.out.println(chinaResponse.toString());

        BaseService<AmericaResponse> americaService = new AmericaServiceImpl();
        Result<AmericaResponse> americaResult = americaService.handle();
        AmericaResponse americaResponse = americaResult.getResponse();
        System.out.println(americaResponse.toString());
    }

测试结果：

BaseService method1
BaseService method2
com.designpatterns.template.generic.response.ChinaResponse@28d93b30
BaseService method1
BaseService method2
com.designpatterns.template.generic.response.AmericaResponse@1b6d3586

总结

通过模板设计模式和泛型的结合，可以非常灵活地处理通用流程和处理逻辑之间的差异；又可以很好地满足不同业务不同返回值类型的需求。