你还不懂设计模式？ - 模版设计模式

56 阅读 0 评论 37 点赞

我是靠谱客的博主彩色羊，最近开发中收集的这篇文章主要介绍你还不懂设计模式？ - 模版设计模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

模板模式（Template Pattern）顾名思义，就是定义一个操作流程的模版。然后不同子类去重写指定的模版方法。适用于能够确定操作流程。不能确定具体操作的场景。

在父类中定义处理流程的框架，在子类中实现具体的操作细节。这种代码编写方式就是模版设计模式。模版设计模式的还可以抽象出公共的逻辑。而把一些不同的操作留给子类实现。在Java的各个技术框架中有着广泛的应用。

还是举个简单栗子。比如我每天吃饭的过程。平时吃的简单点，过节的时候吃的好一点。我们可以这样来实现。

① 创建吃饭流程的模版，先吃早饭，再吃午饭，再吃晚饭。如下：

public abstract class MyAbstractEat {
/**
* 吃早饭
*/
public abstract void handleBreakfast();
/**
* 吃中饭
*/
public abstract void handleLunch();
/**
* 吃晚餐
*/
public abstract void handleDinner();
public void eat(){
//这里可以添加公共逻辑
handleBreakfast();
//这里可以添加公共逻辑
handleLunch();
//这里可以添加公共逻辑
handleDinner();
//这里可以添加公共逻辑
}
}

② 平时吃饭流程，实现一个子类

public class UsuallyEat extends MyAbstractEat {
@Override
public void handleBreakfast() {
System.out.println("早上吃白馒头");
}
@Override
public void handleLunch() {
System.out.println("中午吃外卖");
}
@Override
public void handleDinner() {
System.out.println("晚上喝粥");
}
}

③ 节假日吃饭流程。新建一个子类

public class HolidayEat extends MyAbstractEat {
@Override
public void handleBreakfast() {
System.out.println("早上喝牛奶吃面包");
}
@Override
public void handleLunch() {
System.out.println("中午去酒店吃满汉全席");
}
@Override
public void handleDinner() {
System.out.println("晚上去西餐厅吃牛排");
}
}

测试一下：

	MyAbstractEat usuallyEat = new UsuallyEat();
MyAbstractEat holidayEat = new HolidayEat();
System.out.println("工作日吃饭流程：");
usuallyEat.eat();
System.out.println("..............................");
System.out.println("节假日吃饭流程：");
holidayEat.eat();
输出结果：
工作日吃饭流程：
早上吃白馒头
中午吃外卖
晚上喝粥
..............................
节假日吃饭流程：
早上喝牛奶吃面包
中午去酒店吃满汉全席
晚上去西餐厅吃牛排

可以看到，模版设计模式。可以很好的定义流程框架。模版设计模式很简单，但是实际使用还是要充分结合业务场景。毕竟编码都是为了业务来服务的！

模版设计模式在Spring ,mytais等等框架中有广泛使用，下面来看一下在mytais源码中的应用。

在mybatis中执行数据操作的核心接口是Executor，而其核心子类BaseExecutor中就完美的应用了模版设计模式。来看源码：

public abstract class BaseExecutor implements Executor {
...
@Override
public void close(boolean forceRollback) {
try {
try {
rollback(forceRollback);
} finally {
if (transaction != null) {
transaction.close();
}
}
} catch (SQLException e) {
// Ignore.
There's nothing that can be done at this point.
log.warn("Unexpected exception on closing transaction.
Cause: " + e);
} finally {
transaction = null;
deferredLoads = null;
localCache = null;
localOutputParameterCache = null;
closed = true;
}
}
@Override
public boolean isClosed() {
return closed;
}
@Override
public int update(MappedStatement ms, Object parameter) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
clearLocalCache();
return doUpdate(ms, parameter);
}
@Override
public List<BatchResult> flushStatements() throws SQLException {
return flushStatements(false);
}
public List<BatchResult> flushStatements(boolean isRollBack) throws SQLException {
if (closed) {
throw new ExecutorException("Executor was closed.");
}
return doFlushStatements(isRollBack);
}
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
@SuppressWarnings("unchecked")
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
List<E> list;
try {
queryStack++;
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
if (list != null) {
handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
queryStack--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return list;
}
@Override
public <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
return doQueryCursor(ms, parameter, rowBounds, boundSql);
}
@Override
public void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType) {
if (closed) {
throw new ExecutorException("Executor was closed.");
}
DeferredLoad deferredLoad = new DeferredLoad(resultObject, property, key, localCache, configuration, targetType);
if (deferredLoad.canLoad()) {
deferredLoad.load();
} else {
deferredLoads.add(new DeferredLoad(resultObject, property, key, localCache, configuration, targetType));
}
}
@Override
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
if (closed) {
throw new ExecutorException("Executor was closed.");
}
CacheKey cacheKey = new CacheKey();
cacheKey.update(ms.getId());
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
cacheKey.update(boundSql.getSql());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
// mimic DefaultParameterHandler logic
for (ParameterMapping parameterMapping : parameterMappings) {
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) {
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
cacheKey.update(value);
}
}
if (configuration.getEnvironment() != null) {
// issue #176
cacheKey.update(configuration.getEnvironment().getId());
}
return cacheKey;
}
@Override
public boolean isCached(MappedStatement ms, CacheKey key) {
return localCache.getObject(key) != null;
}
@Override
public void commit(boolean required) throws SQLException {
if (closed) {
throw new ExecutorException("Cannot commit, transaction is already closed");
}
clearLocalCache();
flushStatements();
if (required) {
transaction.commit();
}
}
@Override
public void rollback(boolean required) throws SQLException {
if (!closed) {
try {
clearLocalCache();
flushStatements(true);
} finally {
if (required) {
transaction.rollback();
}
}
}
}
protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;
protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;
protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)throws SQLException;
protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException;
}