Shulou(Shulou.com)06/03 Report--

This article introduces the relevant knowledge of "how to quickly fix the template mode". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Overview

The template pattern is to define an algorithm skeleton in an operation and then defer some steps to a subclass. The template method enables subclasses to redefine some of the steps of the algorithm without changing the structure of the algorithm.

Working with scen

Drink tea

We all know that the basic steps of making tea (algorithm skeleton) are:

Boil water, make tea, drink tea.

The key step in the whole process is to make tea. what kind of tea do you need to run? For how long? Leave it to the subclasses to implement on their own.

API

Code friends who have written the API interface know that there are usually four steps to write API:

Parameter parsing, parameter verification, business processing, organization return parameters.

Parse the request parameters into the request parameters of the service json into entity classes. For parameter verification, you can use a general method to determine whether the parameters are empty, or you can define a special verification method. Generally, each API for business processing is different and is basically implemented by yourself. As for the return parameters, you may have to return them according to the API API business.

Pay the order

Anyone who has done a payment-related system knows that paying an order is roughly divided into these three steps:

The organization requests the bank or a third party to pay the company's request parameters, initiates the payment, and processes the returned results.

The steps in the above three scenarios are the algorithm skeleton. As for each step, everyone may have different tea preferences, the API interface business is different, and the payment processing of banks or third-party payments is different, so you may need to do your own special processing.

Scene reality

Implement an API interface

Algorithm class

Package com.tian.springbootdemo.controller;import com.tian.springbootdemo.rep.Result;/** * @ auther: Lao Tian * @ Description: template class * / public abstract class AbstractTemplate {/ * algorithm skeleton * / public Result execute () {/ / first step: parse parameter parseRequestParameters (); / / second step: verify parameter checkRequestParameters () / / step 3: business processing Object data= doBusiness (); / / step 4: organization return parameter return assembleResponseParameters (data);} / * * parsing parameter * / public abstract void parseRequestParameters (); / * * verification parameter * / public abstract void checkRequestParameters () / * Business processing * / public abstract Object doBusiness (); / * * Organization return parameter * / public abstract Result assembleResponseParameters (Object object);}

Implement class one

Import com.tian.springbootdemo.rep.Result;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.ResponseBody / * * @ auther: Lao Tian * @ Description: api interface * / @ RequestMapping ("/ api") @ Controllerpublic class MyApiController extends AbstractTemplate {@ RequestMapping (value = "/ users", method = RequestMethod.POST) @ ResponseBody @ Override public Result execute () {return super.execute ();} @ Override public void parseRequestParameters () {System.out.println ("* parsing parameters *") } @ Override public void checkRequestParameters () {System.out.println ("* check parameter *");} @ Override public Object doBusiness () {System.out.println ("* handle business *"); / / TODO: call service on 2018-11-17 to process business User user = new User () User.setName ("Oda"); user.setId (1); user.setAge (20); user.setSex ("man"); return user;} @ Override public Result assembleResponseParameters (Object object) {System.out.println ("* return parameter *"); Result result = new Result ("200", "processed successfully") Result.setData (object); return result;}}

Implementation class two

Import com.tian.springbootdemo.dao.domain.User;import com.tian.springbootdemo.rep.Result;import org.springframework.web.bind.annotation.*;/** * @ auther: Lao Tian * @ Description: api interface * / @ RequestMapping ("/ api") @ RestControllerpublic class LoginController extends AbstractTemplate {@ PostMapping (value = "/ login") @ Override public Result execute () {return super.execute () } @ Override public void parseRequestParameters () {System.out.println ("resolve login parameters");} @ Override public void checkRequestParameters () {System.out.println ("verify whether the login user name is empty and the password is empty");} @ Override public Object doBusiness () {System.out.println ("query whether this user exists by user name") System.out.println ("verify whether the user's password is correct"); System.out.println ("login successful"); User user = new User (); user.setName ("Oda"); user.setId (1); user.setAge (20); user.setSex ("man"); return user } @ Override public Result assembleResponseParameters (Object object) {System.out.println ("* return parameter *"); Result result = new Result ("200", "login successful"); result.setData (object); return result;}}

Related class

/ * * @ auther: Lao Tian * @ Description: return message * / public class Result {/ / return code private String responseCode; / / description private String message; / / data private Object data; public Result () {} public Result (String responseCode, String message) {this.responseCode = responseCode; this.message = message } public Result (String responseCode, String message, Object data) {this.responseCode = responseCode; this.message = message; this.data = data;} public String getResponseCode () {return responseCode;} public void setResponseCode (String responseCode) {this.responseCode = responseCode;} public String getMessage () {return message } public void setMessage (String message) {this.message = message;} public Object getData () {return data;} public void setData (Object data) {this.data = data;}} import java.io.Serializable;/** * @ auther: Lao Tian * @ Description: data * / public class User implements Serializable {/ / id private Integer id; / / user name private String name / / gender private String sex; / / Age private int age; public User () {} public User (Integer id, String name, String sex, int age) {this.id = id; this.name = name; this.sex = sex; this.age = age;} public Integer getId () {return id } public void setId (Integer id) {this.id = id;} public String getName () {return name;} public void setName (String name) {this.name = name;} public String getSex () {return sex;} public void setSex (String sex) {this.sex = sex;} public int getAge () {return age } public void setAge (int age) {this.age = age;}}

test

Here, the REST Client under the Tools of idea is used for interface testing:

Enter image description here

Enter image description here

Let's take a look at the message printed by the console Console:

Enter image description here

Enter image description here

In this way, we apply the template design pattern to our specific code, and we can also implement other API implementation classes.

In addition, parameter verification can also implement a default method in AbstractTemplate, for example: verify whether the parameter is empty, but subclasses can also override this method and do a special verification by themselves; for example, if there is a mobile phone number in the parameter, we can not only verify whether the mobile phone number is empty, but also verify whether the mobile phone number is 11 digits, whether it is legal, and so on.

Advantages and disadvantages of template pattern

Advantages

Improve the reusability of the code and put the same part of the code in the abstract class

Improve extensibility, put different ones into different implementation classes, and add some behaviors you need through the extension of the implementation class.

Realize the reverse control, realize the operation of the class through a parent class call, add new behavior to the extension of the implementation class, and realize the reverse control.

Shortcoming

Because of the introduction of abstract classes, each different implementation needs a subclass to implement, which will lead to an increase in the number of classes, resulting in the complexity of system implementation.

How do bosses use it in the framework?

In Spring

The refreash method in AbstractApplicationContext is the template method, and the source code is:

@ Overridepublic void refresh () throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {/ / call the method that the container is ready to refresh, get the current time of the container, / / set the synchronization identity prepareRefresh () to the container at the same time / / tell the subclass to start the refreshBeanFactory () method, / / Bean define the loading of the resource file from the refreshBeanFactory () method of the subclass to start ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory (); / / configure container features for BeanFactory, such as class loaders, event handlers, etc. PrepareBeanFactory (beanFactory) Try {/ / specifies special BeanPost event handlers for some subclasses of the container / /-subclasses to implement postProcessBeanFactory (beanFactory); / / calls Bean invokeBeanFactoryPostProcessors (beanFactory) of all registered BeanFactoryPostProcessor; / / registers BeanPost event handlers for BeanFactory. / / BeanPostProcessor is the Bean post processor, / / it is used to listen to the event registerBeanPostProcessors (beanFactory) triggered by the container; / / initialize the information source, which is related to internationalization. InitMessageSource (); / / initialize the container event propagator. InitApplicationEventMulticaster (); / / call some special Bean initialization methods of the subclass / /-subclass to implement onRefresh (); / / register the event listener for the event propagator. RegisterListeners (); / / initialize all remaining singleton Bean finishBeanFactoryInitialization (beanFactory); / / initialize the container's lifecycle event handler, / / and publish the container's lifecycle event finishRefresh (); /.

This method is the context startup template method. This is one of the scenarios where the template pattern is applied in Spring.

In Mybatis

The update method in BaseExecutor is a template method.

/ * SqlSession.update/insert/delete will call this method * template method * / @ 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.") } / / clear local cache first, then update, how to update subclass, / / template method mode clearLocalCache (); / / implement (hook method) return doUpdate (ms, parameter) by subclass;}

Methods are only defined in BaseExecutor, but the implementation is in subclasses

/ / Update protected abstract int doUpdate (MappedStatement ms, Object parameter) throws SQLException;// query protected abstract List doQuery (MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;//. The methods at the beginning of the query are left to the specific subclass to implement on its own.

The implementation classes of BaseExecutor are as follows:

Enter image description here

Implementation of doUpdate method in class SimpleExecutor

@ Overridepublic int doUpdate (MappedStatement ms, Object parameter) throws SQLException {Statement stmt = null; try {Configuration configuration = ms.getConfiguration (); / / create a new StatementHandler / / see here that ResultHandler passes in null StatementHandler handler = configuration.newStatementHandler (this, ms, parameter, RowBounds.DEFAULT, null, null); / / preparation statement stmt = prepareStatement (handler, ms.getStatementLog ()) / / StatementHandler.update return handler.update (stmt);} finally {closeStatement (stmt);}}

Implementation of doUpdate method in class ReuseExecutor

@ Override public int doUpdate (MappedStatement ms, Object parameter) throws SQLException {Configuration configuration = ms.getConfiguration (); / / like SimpleExecutor, / / create a new StatementHandler / / see here that ResultHandler passes in null StatementHandler handler = configuration.newStatementHandler (this, ms, parameter, RowBounds.DEFAULT, null, null); / / preparation statement Statement stmt = prepareStatement (handler, ms.getStatementLog (); return handler.update (stmt);}

This is the classic application of the template method pattern in Mybatis.

This is the end of "how to quickly fix the template mode". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.