设计模式

[TOC]

责任链模式

这是一个面向对象的思想，当存在可分的，多步骤的且连续的和顺序的事务要进行处理时，我们通过将每个部分抽离成一个handler对象处理这一个过程，将每个对象以或链表或存储集合，形成一个有序链条，依次执行handler对象的方法，从而完成整个事务的设计思想叫做责任链模式。

登录处理

public void login(String loginName,String loginPass){
    {
        //参数校验
        //...
    }
    {
        //用户信息校验
        //...
    }
    {
        //权限信息校验
        //...
    }
}

这样的检验性代码一般都是必不可少的，但是写在具体的业务代码中又显得非常臃肿,如果使用责任链模式，将步骤拆分，可以使我们在编码时更加专注于某一个具体的业务逻辑处理。

使用责任链模式

public abstract class Handler {
    protected Handler chain;

    public void next(Handler handler){
        this.chain = handler;
    }

    public abstract void doHandle(Member member);

}

public class ValidateHandler extends Handler {
    public void doHandle(Member member) {
        {
            //参数校验
            //...
        }
        chain.doHandle(member);
    }
}


public class LoginHandler extends Handler {

    public void doHandle(Member member) {
        {
            //用户数据匹配
            //...
        }
        chain.doHandle(member);
    }
}


public class AuthHandler extends Handler {

    public void doHandle(Member member) {
        {
            //权限校验
            //...
        }
}

通过单向链表的结构，将每个步骤串联起来

然后再将他们串联起来

public class Chain {
    public void login(String loginName,String loginPass){
        Handler validateHandler = new ValidateHandler();
        Handler loginHandler = new LoginHandler();
        Handler authHandler = new AuthHandler();

        validateHandler.next(loginHandler);
        loginHandler.next(authHandler);

        validateHandler.doHandle(new Member(loginName,loginPass));
    }
}

如果还没有体会到责任链模式的好处，我们可以看看Mybatis是如何使用责任链模式的。

Mybatis在实现用户自定义对执行SQL的功能增强例如日志记录、性能统计、分页查询、动态参数处理等等时，就通过拦截器使用了责任链模式

本质是：我们在进行拦截的时候，有很多的需求需要处理，于是采用责任链模式将拦截后对其处理拆分成若干个Intercepter（类似于Handler，但是优于handler），从而可以使我们在编码时更加专注于某一个具体的业务逻辑处理。

spring boot启动的时候要扫描Mapper并注册到

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);

Mybatis Mapper的bean的存储是一个Map，key就是Mapper接口首字母小写的名称，value会根据设置的beanClass创建出一个MapperFactoryBean

21:34:05-1689341644720.png

SqlSessionFactoryBean在调用buildSqlSessionFactory()生成SqlSessionFactory实例的时候，会给它的成员变量Configuration对象添加拦截器

17:07:32-1689325652627.png

在Configuration对象里的IntercepterChain里，用一个list集合维护所有拦截器，从这里我们已经可以看到责任链模式的影子了，每一个拦截器对应一个事务处理

interceptorChain.pluginAll传入代理对象,将所有拦截器加到代理对象上

21:00:59-1689339659250.png

用户通过XML、配置类、注解等方式进行拦截器的注册，从而实现功能的增强

21:21:57-1689340917237.png

重写Intercept方法

@Override 
Object intercept(Invocation invocation) throws Throwable{
    doSomePreThings();
    Invocation.proceed();
    doSomePostThings();
}

遍历interceptors，interceptor.plugin(target)传入target代理对象

17:15:58-1689326158629.png

过程：给target加上一个插件-->interceptor1(target)-->再赋值给target

遍历下一个interceptor，再给target加上一个插件-->interceptor2(interceptor1(target))以此类推

最后返回一个加满插件的代理对象

执行该对象的invoke方法：

public static void main(String[] args){
    doInterceptor4();
    doInterceptor3();
    doInterceptor2();
    doInterceptor1();
    target()//执行sql
    doInterceptor1();
    doInterceptor2();
    doInterceptor3();
    doInterceptor4();
}

建造者模式

首先，我们可以结合上面的责任链模式，进行一个基于建造者模式的改造升级

public abstract class Handler<T> {
    protected Handler chain;

    public void next(Handler handler){
        this.chain = handler;
    }

    public abstract void doHandle(Member member);

    public static class Builder<T> {
        private Handler<T> head;
        private Handler<T> tail;

        public Builder<T> addHandler(Handler<T> handler) {
                if (this.head == null) {
                    this.head = this.tail = handler;
                    return this;
                }
                this.tail.next(handler);
                this.tail = handler;

            return this;
        }

        public Handler<T> build() {
            return this.head;
        }
    }
    
}

在处理器Handler中增加一个静态内部类Builder建造者，用于为维护该链表

public class Service {
    public void login(String loginName,String loginPass){

        Handler.Builder builder = new Handler.Builder();
        builder.addHandler(new ValidateHandler())
                .addHandler(new LoginHandler())
                .addHandler(new AuthHandler());

        builder.build().doHandle(new Member(loginName,loginPass));

    }
}

因为建造者模式要构建的是节点处理者，所以我们把Builder作为Handler的静态内部类，并且因为用户不需要进行链式组装，所以还可以把链式组装方法next()方法设置为private，使Handler更加高聚合

public abstract class Handler<T> {
    protected Handler chain;

    private void next(Handler handler){
        this.chain = handler;
    }
...
}

装饰器模式

模板模式

模板方法，模式在一个方法中定义一个算法（业务逻辑）骨架（模板），并将某些步骤推迟到子类中实现。模板方法模式可以让子类在不改变算法（业务逻辑）整体架构的情况下，重新定义算法（业务逻辑）中的某些步骤。

模板模式主要是用来解决复用和扩展两个问题。

复用

模板模式把一个业务逻辑中不变的流程抽象到父类的模板方法 templateMethod() 将，将可变的部分 method1()、method2()作为抽象方法留给子类 ContreteClass1 和 ContreteClass2 来实现。所有的子类都可以复用父类中模板方法定义的流程代码。

扩展

模板模式的第二大作用的是扩展。这里说的扩展，并不是指代码的扩展性，而是指框架的扩展性，有点类似控制反转。基于这个作用，模板模式常用在框架的开发中，让框架用户在可以不修改框架源码的情况下，定制化框架的功能。

典型案例：Tomcat中的Servlet就使用到了模板模式

GenericServlet

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    // 定义一个transient修饰的ServletConfig类型的成员变量
    private transient ServletConfig config;
    
    // 实现ServletConfig接口中的方法，获取Servlet的初始化参数
    public String getInitParameter(String name) {
        return getServletConfig().getInitParameter(name);
    }
    
    // 实现ServletConfig接口中的方法，获取Servlet的所有初始化参数名
    public Enumeration<String> getInitParameterNames() {
        return getServletConfig().getInitParameterNames();
    }
    
    // 实现ServletConfig接口中的方法，获取Servlet的Servlet上下文对象
    public ServletContext getServletContext() {
        return getServletConfig().getServletContext();
    }
    
    // 实现ServletConfig接口中的方法，获取Servlet的名称
    public String getServletName() {
        return getServletConfig().getServletName();
    }
    
    // 实现Servlet接口中的方法，获取Servlet的配置信息
    public ServletConfig getServletConfig() {
        return config;
    }
    
    // 实现Servlet接口中的方法，获取Servlet的描述信息
    public String getServletInfo() {
        return "";
    }
    
    // 实现Servlet接口中的方法，将日志信息写入Servlet容器的日志文件中
    public void log(String msg) {
        getServletContext().log(getServletName() + ": " + msg);
    }
    
    // 实现Servlet接口中的方法，将日志信息和异常信息写入Servlet容器的日志文件中
    public void log(String message, Throwable t) {
        getServletContext().log(getServletName() + ": " + message, t);
    }
    
    // 实现Servlet接口中的方法，初始化Servlet
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        init();
    }
    
    // 定义一个抽象方法，用于子类实现初始化逻辑
    public abstract void init() throws ServletException;
    
    // 实现Servlet接口中的方法，销毁Servlet
    public void destroy() {
        destroy();
    }
    
    // 定义一个抽象方法，用于子类实现销毁逻辑
    public abstract void destroy();
    
    // 实现Servlet接口中的方法，处理HTTP请求
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        service((HttpServletRequest) req, (HttpServletResponse) res);
    }
    
    // 定义一个方法，用于子类实现HTTP请求的处理逻辑
    protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        String method = req.getMethod();
        if (method.equals("GET")) {
            doGet(req, res);
        } else if (method.equals("POST")) {
            doPost(req, res);
        } else {
            service(req, res);
        }
    }
    
    // 定义一个抽象方法，用于子类实现HTTP GET请求的处理逻辑
    protected abstract void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException;
    
    // 定义一个抽象方法，用于子类实现HTTP POST请求的处理逻辑
    protected abstract void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException;
}

将固定好的实现写好，用户不需要关心的实现细节封装起来，留下抽象方法供子类重写

针对于web开发，HttpServlet对GenericServlet进一步抽象,在此基础上增加了一些针对HTTP协议的处理方法和属性

public abstract class HttpServlet extends GenericServlet {
    // 定义一个静态的String类型的常量，表示HTTP GET请求方法
    public static final String METHOD_GET = "GET";
    
    // 定义一个静态的String类型的常量，表示HTTP POST请求方法
    public static final String METHOD_POST = "POST";
    
    // 实现GenericServlet类中的doGet()方法，处理HTTP GET请求
    protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = "HTTP method GET is not supported by this URL";
        if (protocol.endsWith("1.1")) {
            res.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            res.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }
    
    // 实现GenericServlet类中的doPost()方法，处理HTTP POST请求
    protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        String protocol = req.getProtocol();
        String msg = "HTTP method POST is not supported by this URL";
        if (protocol.endsWith("1.1")) {
            res.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
        } else {
            res.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
        }
    }
    
    // 定义一个方法，用于处理HTTP请求
    protected void service(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        String method = req.getMethod();
        if (method.equals(METHOD_GET)) {
            doGet(req, res);
        } else if (method.equals(METHOD_POST)) {
            doPost(req, res);
        } else {
            service(req, res);
        }
    }
    
    // 实现GenericServlet类中的init()方法，用于初始化Servlet
    public void init() throws ServletException {
        super.init();
    }
    
    // 实现GenericServlet类中的destroy()方法，用于销毁Servlet
    public void destroy() {
        super.destroy();
    }
}

用户只需要关心具体需要实现的业务逻辑

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String servletPath = request.getServletPath();
        String contextPath = request.getContextPath();
        HttpSession session = request.getSession();
        Object username = session.getAttribute("username");
                if (username != null) {
            if ("/dept/list".equals(servletPath)) {
                doList(request,response);
            } else if ("/dept/details".equals(servletPath)) {
                doDetails(request,response);
            } else if ("/dept/add".equals(servletPath)) {
                doAdd(request,response);
            } else if ("/dept/delete".equals(servletPath)) {
                doDel(request,response);
            } else if ("/dept/modify".equals(servletPath)) {
                doModify(request,response);
            }
        }else {
            response.sendRedirect(contextPath);
        }
        
    public void doList(ServletRequest req,ServletResponse resp){
       //...
    }
    public void doDetails(ServletRequest req,ServletResponse resp){
        //...
    }
        //...
}

适配器模式

单例模式