设计模式之模板方法模式

 定义：定义一个操作中算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤。

                     模板方法模式结构图：

 AbstractClass是抽象类，其实也就是一个抽象模板，定义并实现了一个模板方法。这个模板方法一般是一个具体方法。它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。顶级逻辑也有可能调用一些具体的方法。

 ConcreteClass，实现父类所定义的一个或多个抽象方法。每一个AbstractClass都可以有任意多个ConcreteClass与之对应，而每一个ConcreteClass都可以给出这些抽象方法的不同实现，从而使得顶级逻辑的实现不同。

 正如在mybatis中mapper接口使用的增删改查一样，接口命名和逻辑大致一样，我们可以将逻辑骨架抽取出来。

父类：

package com.gznb.framework.service;

import com.gznb.framework.common.Constant;
import com.gznb.framework.common.model.ServiceResult;
import com.gznb.framework.common.model.ServiceResultHelper;
import com.gznb.framework.dao.BaseGeneratedMapper;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.jdbc.SqlRunner;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ClassUtils;
import org.springframework.util.CollectionUtils;

public abstract class AbstractBaseAOService<EntityAO, EntityCriteria> implements IBaseAOService<EntityAO, EntityCriteria> {
    protected static final Logger LOG = LoggerFactory.getLogger(AbstractBaseAOService.class);
    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    public AbstractBaseAOService() {
    }

    protected abstract BaseGeneratedMapper<EntityAO, EntityCriteria> getGeneratedMapper();

    @Transactional(
        readOnly = true
    )
    public ServiceResult<EntityAO> selectByPrimaryKey(String id) {
        EntityAO sr = this.getGeneratedMapper().selectByPrimaryKey(id);
        return sr != null ? ServiceResultHelper.genResultWithSuccess(sr) : ServiceResultHelper.genResult(false, Constant.FAILED, "没有查找到指定数据，ID:[" + id + "]", (Object)null);
    }
    
}

子类：

package com.gznb.app.wisdomradio.service;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import com.gznb.app.wisdomradio.appobject.BannerAO;
import com.gznb.app.wisdomradio.dao.gen.BannerGeneratedMapper;
import com.gznb.app.wisdomradio.entity.gen.BannerCriteria;
import com.gznb.framework.dao.BaseGeneratedMapper;
import com.gznb.framework.service.AbstractBaseAOService;


@Service
public class BannerService extends AbstractBaseAOService<BannerAO, BannerCriteria> {

    private static Logger LOG = LoggerFactory.getLogger(BannerService.class);

    @Resource
    private BannerGeneratedMapper bannerGeneratedMapper;

    @Override
    protected BaseGeneratedMapper<BannerAO, BannerCriteria> getGeneratedMapper() {
        return bannerGeneratedMapper;
    }

}

调用类：

package com.gznb.app.wisdomradio.controller.pc.manage.tpuser;

import com.gznb.app.wisdomradio.dto.req.BannerRequest;
import com.gznb.app.wisdomradio.entity.gen.BannerCriteria;
import com.gznb.app.wisdomradio.service.IBannerService;
import com.gznb.framework.web.controller.BaseController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

public class BannerController extends BaseController {
    @Resource
    private IBannerService bannerService;

    @RequestMapping(value = "/list", method = {RequestMethod.POST})
    public Object list(BannerRequest req, HttpServletRequest request) {
        String bannerType = req.getBannerType();
        BannerCriteria bannerCriteria = new BannerCriteria();
        bannerCriteria.createCriteria().andIdIsNotNull().andStatusEqualTo(Byte.parseByte("1")).andShelvesFlagEqualTo(1).andBannerTypeEqualTo(bannerType);
        return bannerService.selectByCriteria(bannerCriteria);
    }
}

 模板方法特点：通过把不变行为搬移到超类，去除子类中的重复代码来提现它的优势。当不变的和可变的行为在方法的子类实现中混合在一起的时候，不变的行为就会在子类中重复出现。我们通过模板方法模式把这些行为搬移到单一的地方，这样就帮助子类摆脱重复的不变行为的纠缠。