设计模式之美学习-行为型-模板模式(二十七)
什么是模板模式
模板方法模式在一个方法中定义一个算法骨架，并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法整体结构的情况下，重新定义算法中的某些步骤。
模板模式的作用
复用以及扩展
标准实现
public abstract class AbstractClass { public final void templateMethod() { ....处理一些初始化操作 或者公用逻辑 //... method1(); //... method2(); //... } //定义好的模板方法1 protected abstract void method1(); //定义好的模板方法2 protected abstract void method2(); } //实现1 public class ConcreteClass1 extends AbstractClass { //父类初始化了 专注自己的处理逻辑 @Override protected void method1() { //... } @Override protected void method2() { //... } } //实现2 public class ConcreteClass2 extends AbstractClass { //父类初始化了 专注自己的处理逻辑 @Override protected void method1() { //... } @Override protected void method2() { //... } } AbstractClass demo = ConcreteClass1(); demo.templateMethod();
源码中的使用
DispatcherServlet
org.springframework.web.servlet.FrameworkServlet做一些初始化操作
protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { long startTime = System.currentTimeMillis(); Throwable failureCause = null; /** * <31>获取当前线程 国际化上下文 从里面会从2个ThreadLocal获取 * org.springframework.web.filter.RequestContextFilter#initContextHolders * 如果配置了这个filter这里每次请求已经初始化 spring boot 验证 */ LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext(); //构建当前线程当本次请求的国际化上下文 LocaleContext localeContext = this.buildLocaleContext(request); /** * <32>获取当前线程请求的RequestAttribute 里面会从2个ThreadLocal获取 * org.springframework.web.filter.RequestContextFilter#initContextHolders已经初始化 spring boot验证 */ RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes(); //<4>如果线程缓存没有构建过,表示之前没初始化过 ServletRequestAttributes requestAttributes = this.buildRequestAttributes(request, response, previousAttributes); /** *会从requsetAttribute里面获取获取不到初始化一个再set进去 key=WebAsyncUtils.WEB_ASYNC_MANAGER_ATTRIBUTE * 表示我们后去都可以根据reqeust.getAttribute(WebAsyncUtils.WEB_ASYNC_MANAGER_ATTRIBUTE)获取 * 用于给管理异步请求 */ WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor()); /** * <5>这里面会存入根据当前对象成语变量区分放到哪个线程缓存里面threadContextInheritable 默认为false * 我们可以利用前面的BeanWapper进行修改 * 表示我们后续都可以根据LocaleContextHolder和RequestContextHolder获取 * */ this.initContextHolders(request, localeContext, requestAttributes); try { //<6>抽象方法 由子类实现 如:DispatcherServlet实现 this.doService(request, response); } catch (ServletException var17) { failureCause = var17; throw var17; } catch (IOException var18) { failureCause = var18; throw var18; } catch (Throwable var19) { failureCause = var19; throw new NestedServletException("Request processing failed", var19); } finally { /** * <7>默认previousLocaleContext previousAttributes 是null * 这里主要是为了将线程缓存的previousLocaleContext previousAttributes清空 */ this.resetContextHolders(request, previousLocaleContext, previousAttributes); if (requestAttributes != null) { requestAttributes.requestCompleted(); } if (this.logger.isDebugEnabled()) { if (failureCause != null) { this.logger.debug("Could not complete request", (Throwable)failureCause); } else if (asyncManager.isConcurrentHandlingStarted()) { this.logger.debug("Leaving response open for concurrent processing"); } else { this.logger.debug("Successfully completed request"); } } //spring事件机制 发布ServletRequestHandlerEvent消息，这个请求是否执行成功都会发布消息的 this.publishRequestHandledEvent(request, response, startTime, (Throwable)failureCause); } }
//抽象方法 protected abstract void doService(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
org.springframework.web.servlet.DispatcherServlet#doService
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception { if (this.logger.isDebugEnabled()) { String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : ""; this.logger.debug("DispatcherServlet with name '" + this.getServletName() + "'" + resumed + " processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]"); } //如果是include请求，保存request attribute快照数据，并在finally中进行还原 Map<String, Object> attributesSnapshot = null; /** * request.getAttribute("javax.servlet.include.request_uri")!=null * <jsp:incluede page="xxx.jsp"/> * jsp里面嵌套上面这个标签 编译器后也是一个servlet来调用 通过这个属性判断是否是include标签 */ if (WebUtils.isIncludeRequest(request)) { attributesSnapshot = new HashMap(); Enumeration attrNames = request.getAttributeNames(); label108: while(true) { String attrName; do { if (!attrNames.hasMoreElements()) { break label108; } attrName = (String)attrNames.nextElement(); } while(!this.cleanupAfterInclude && !attrName.startsWith("org.springframework.web.servlet")); attributesSnapshot.put(attrName, request.getAttribute(attrName)); } } //保存ApplicationContext 到request request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.getWebApplicationContext()); //保存localeResolver 到request request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver); //保存themeResolver 到request request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver); //保存gThemeSource 到request request.setAttribute(THEME_SOURCE_ATTRIBUTE, this.getThemeSource()); //貌似是为了解决重定向302 带参数 长度问题 先保存到服务器 然后302重定向只需要带过来一个对应的key FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response); if (inputFlashMap != null) { request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap)); } //保存一个空的FlashMap request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap()); //保存flashMapManager request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager); try { //<7>执行处理请求 this.doDispatch(request, response); } finally { //还原快照数据 if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted() && attributesSnapshot != null) { this.restoreAttributesAfterInclude(request, attributesSnapshot); } } }
摘自:《SpringMVC源码阅读-一个请求主要处理流程DispatcherServlet(四)》
模板模式和回调
回调标准实现
//回调接口实现 public interface ICallback { void methodToCallback(); } public class BClass { public void process(ICallback callback) { ...执行一系列逻辑 //...调用回调 callback.methodToCallback(); //... } } public class AClass { public static void main(String[] args) { BClass b = new BClass(); //调用处理方法 传入回调 b.process(new ICallback() { //回调对象 @Override public void methodToCallback() { System.out.println("Call back me."); } }); } }
JdbcTemplate
传统通过jdbc实现访问数据库 我们可以发现大量的模板代码 如果 1 2 4 5 6 7 这些步骤几乎每次访问都需要
public class JdbcDemo { public User queryUser(long id) { Connection conn = null; Statement stmt = null; try { //1.加载驱动 Class.forName("com.mysql.jdbc.Driver"); conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/demo", "xzg", "xzg"); //2.创建statement类对象，用来执行SQL语句 stmt = conn.createStatement(); //3.ResultSet类，用来存放获取的结果集 String sql = "select * from user where id=" + id; ResultSet resultSet = stmt.executeQuery(sql); String eid = null, ename = null, price = null; //4.封装结果 while (resultSet.next()) { User user = new User(); user.setId(resultSet.getLong("id")); user.setName(resultSet.getString("name")); user.setTelephone(resultSet.getString("telephone")); return user; } } catch (ClassNotFoundException e) { // 5.TODO: log... 异常处理 } catch (SQLException e) { // 6.TODO: log... 异常处理 } finally { //7.释放连接 if (conn != null) try { conn.close(); } catch (SQLException e) { // TODO: log... } if (stmt != null) try { stmt.close(); } catch (SQLException e) { // TODO: log... } } return null; } }
jdbctemlate使用
public class JdbcTemplateDemo { private JdbcTemplate jdbcTemplate; public User queryUser(long id) { String sql = "select * from user where id="+id; //通过回调传入Mapper 我们只需要关心 封装结果集 和执行sql return jdbcTemplate.query(sql, new UserRowMapper()).get(0); } class UserRowMapper implements RowMapper<User> { public User mapRow(ResultSet rs, int rowNum) throws SQLException { User user = new User(); user.setId(rs.getLong("id")); user.setName(rs.getString("name")); user.setTelephone(rs.getString("telephone")); return user; } } }
setClickListener
set存入成员变量
Button button = (Button) findViewById(R.id.button); //注册点击事件 button.setOnClickListener(new OnClickListener() { @Override public void onClick (View v){ System.out.println("I am clicked."); } });
2者区别
模板模式:通过再父类定义好算法骨架，将具体实现下放到子类 实现复用和扩展 本质通过继承
回调:定义好骨架 通过处理函数传入定制化的处理逻辑执行 或者提前拿通过成员变量注入,在骨架特定地点调用 实现不同需求的定制化逻辑,实现复用,本质是通过 实时传入回调或者组合的方式提前注入 实现代码复用
