设计模式8.委派模式和模板方法模式

最新推荐文章于 2022-10-10 17:14:03 发布
最新推荐文章于 2022-10-10 17:14:03 发布
阅读量154 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43421035/article/details/115358821
版权

一、委派模式
源码例子：ClassLoader、DispaterSeverlet

委派模式定义
委派模式(Delegate Pattern) 又叫委托模式。它的基本作用就是负责任务的调度和分配，将任务的分配和执行分离开来。可以看做是一种特殊情况下的静态代理的全权代理。
不属于GOF 23种设计模式之一。属于行为型模式。

应用场景

  1. 委派对象本身不知道如何处理一个任务(或一个请求)，把请求交给其他对象来处理。
  2. 实现程序的解耦。

类图
在这里插入图片描述

//抽象员工
public interface IEmployee
{
    void doTask(String task);
}
//员工A
public class EmployeeA implements IEmployee
{
    public static String goodAt = "编程";
    @Override
    public void doTask(String task)
    {
        System.out.println("我是员工A,我擅长" + goodAt + ",我开始做" + task);
    }
}
//员工B
public class EmployeeB implements IEmployee {
    public static String goodAt  = "美工";
    @Override
    public void doTask(String task)
    {
        System.out.println("我是员工B,我擅长" + goodAt + ",我开始做" + task);
    }
}

//委派类
public class DelegateLeader implements IEmployee {
    private static Map<String, IEmployee> employeeMap;

    static
    {
        employeeMap = new HashMap<>();
        employeeMap.put(EmployeeA.goodAt, new EmployeeA());
        employeeMap.put(EmployeeB.goodAt, new EmployeeB());
    }

    @Override
    public void doTask(String task)
    {
        if (employeeMap.containsKey(task))
        {
            employeeMap.get(task).doTask(task);
            return;
        }

        System.out.println("超出职责范围，无能为力");
    }
}
//测试
public class Test
{
    public static void main(String[] args) {
        new DelegateLeader().doTask("编程");
        new DelegateLeader().doTask("美工");
        new DelegateLeader().doTask("匪灭");
    }
}
//结果
我是员工A,我擅长编程,我开始做编程
我是员工B,我擅长美工,我开始做美工
超出职责范围，无能为力

**=====================================================**

二、模板方法模式 Template Method Pattern

模板方法模式定义
模板方法模式又叫模板模式，是指定义一个算法的骨架，并允许子类为其中一个或多个步骤提供实现。
模板方法使得子类可以在不改变算法结构的情况下，重新定义算法的某些步骤。
属于行为型设计模式。

模板模式的适用场景
1、 一次性实现一个算法不变的部分，并将可变得行为留给子类来实现。
2、 各子类中公共的行为被提取出来并集中到一个公共的父类中，从而避免代码重复。

样例
在这里插入图片描述

//实现数据库连接池

public class JdbcPool
{
    private String driverClass = "com.mysql.cj.jdbc.Driver";
    private String url = "jdbc:mysql://localhost:3306/sdn?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8";
    private String user = "root";
    private String password = "root";
    private int minIdle = 2;
    private int maxActive = 5;
    private volatile int currentNum = 0;

    private Vector<Connection> pool = new Vector<>();

    private JdbcPool()
    {
        init();
    }

    public static JdbcPool getInstance()
    {
        return InnerClass.INSTANCE;
    }

    private static class InnerClass
    {
        //静态内部类单例
        private static final JdbcPool INSTANCE = new JdbcPool();
    }

    /**
     * 初始化线程池
     */
    private void init()
    {
        try {
            //1. 注册驱动
            Class.forName(driverClass);


            //2. 初始化获取连接
            Connection conn = null;
            for (int i = 1; i < minIdle; i++)
            {
                conn = DriverManager.getConnection(url, user, password);
                pool.add(conn);
                currentNum++;
            }

        }
        catch (Exception ex)
        {
            System.out.println(ex.getMessage());
            System.out.println("线程池初始化失败");
        }
    }

    public Connection getConn()
    {
        Connection conn = null;
        int trytime = 0;
        try {
            while (null == conn) {
                if (trytime >= 3)
                {
                    System.out.println("未获取连接，重试超过3次返回...");
                    break;
                }
                conn = this.getConnection();
                if (null == conn) {
                    Thread.currentThread().sleep(500);
                    trytime++;
                }
            }
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }

        return conn;
    }
    //单独方法，防止死锁
    private synchronized Connection getConnection() throws SQLException
    {
        Connection conn = null;
        if (pool.size() > 0)
        {
            conn = pool.get(0);
            pool.remove(conn);
            System.out.println("获取一个连接");
        }
        else
        {
            if (currentNum < maxActive) {
                conn = DriverManager.getConnection(url, user, password);
                currentNum++;
                System.out.println("新增一个连接");
            }
        }

        return conn;
    }

    public synchronized void release(Connection conn)
    {
        pool.add(conn);
        System.out.println("连接回收放回连接池");
    }
}

//定义统一的转换接口
public interface RowMapper<T> {
    T rowMapper(ResultSet rs, int i);
}

//JDBC查询模板

public abstract class JdbcTemplate<T>
{
    public List<T> executeQuery(String sql, RowMapper<T> mapper, Object[] args) throws SQLException
    {
        //1. 获取连接
        Connection conn = this.getConnection();

        if (null == conn)
        {
            System.out.println("未获取连接!!!!!");
            return null;
        }

        //2. 得到prepared
        PreparedStatement pst = this.preparedStatement(conn, sql);

        //3. 执行查询
        ResultSet result = this.executeQuery(pst, args);

        //4. 返回结果集合
        List<T> list = this.resultMapper(result, mapper);

        //测试延迟放回连接
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //5. 返回连接
        this.closeConnection(conn, pst, result);

        return  list;
    }

    private List<T> resultMapper(ResultSet rs, RowMapper<T> mapper) throws SQLException
    {
        List<T> list = new ArrayList<>();
        int rownum = 0;
        if (null != rs) {
            while (rs.next())
            {
                //抽象方法实现转换
                list.add(mapper.rowMapper(rs, rownum++));
            }
        }
        return list;
    }

    private void closeConnection(Connection conn, PreparedStatement pst, ResultSet result) throws SQLException {
        JdbcPool.getInstance().release(conn);
        if (null != pst)
        {
            pst.close();
        }

        if (result != pst)
        {
            result.close();
        }
    }

    private ResultSet executeQuery(PreparedStatement pst, Object[] args) throws SQLException
    {
        if (null != args) {
            for (int i = 0; i < args.length; i++) {
                //PreparedStatement 条件从1开始
                pst.setObject(i + 1, args[i]);
            }
        }

        return pst.executeQuery();
    }

    private PreparedStatement preparedStatement(Connection conn, String sql) throws SQLException {
        return conn.prepareStatement(sql);
    }

    private Connection getConnection()
    {
        return JdbcPool.getInstance().getConn();
    }
}
//定义实体类

public class User implements RowMapper<User> {
    private int userid;
    private String username;
    private String roleid;
    private String usercode;
    private String password;
    private Date createTime;

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getRoleid() {
        return roleid;
    }

    public void setRoleid(String roleid) {
        this.roleid = roleid;
    }

    public String getUsercode() {
        return usercode;
    }

    public void setUsercode(String usercode) {
        this.usercode = usercode;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    @Override
    public User rowMapper(ResultSet rs, int i)
    {
        User user = new User();
        try {
            user.setUserid(rs.getInt("userid"));
            user.setUsername(rs.getString("username"));
            user.setUsercode(rs.getString("usercode"));
            user.setPassword(rs.getString("password"));
            user.setRoleid(rs.getString("roleid"));
            user.setCreateTime(rs.getDate("createtime"));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return user;
    }

    @Override
    public String toString() {
        return JSON.toJSONString(this);
    }
}

//DAO

public class UserDao extends JdbcTemplate
{
    //通过ID查询用户
    public List<User> queryById(Object[] args)
    {
        String sql = "select * from u_user where userid=?";
        List<User> result = null;
        try
        {
            result = super.executeQuery(sql, new User(), args);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return result;
    }
}

//Service
public class UserService
{
    private UserDao dao = new UserDao();

    public List<User> queryById(Object[] args)
    {
        return dao.queryById(args);
    }
}
//测试

public class Test
{
    public static void main(String[] args) {
        UserService service = new UserService();

        //1. 验证查询结果
        Object[] conds = new Object[]{1};
        List<User> result = service.queryById(conds);
        System.out.println(result);

        RoleService sev2 = new RoleService();
        List<Role> ret2 = sev2.queryById(null);
        System.out.println(ret2);

        //2. 验证线程池
        /**for (int i = 0; i < 6; i++)
        {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 5; j++)
                    {
                        service.queryById(null);
                    }
                }
            }).start();
        }**/
    }
}

//1.结果
获取一个连接
连接回收放回连接池
[{"createTime":"2021-04-06","password":"admin#2021","roleid":"1","usercode":"admin","userid":1,"username":"超级管理员"}]
获取一个连接
连接回收放回连接池
[{"authid":"1,2,3","roleid":1,"rolename":"管理员角色"}, {"authid":"1","roleid":2,"rolename":"访问角色"}]

//2结果
com.lt.architect.templatepattern.Test
获取一个连接
新增一个连接
新增一个连接
新增一个连接
新增一个连接
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
获取一个连接
获取一个连接
获取一个连接
获取一个连接
获取一个连接
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
获取一个连接
获取一个连接
获取一个连接
获取一个连接
获取一个连接
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
获取一个连接
获取一个连接
连接回收放回连接池
获取一个连接
连接回收放回连接池
获取一个连接
获取一个连接
连接回收放回连接池
获取一个连接
连接回收放回连接池
获取一个连接
连接回收放回连接池
连接回收放回连接池
获取一个连接
连接回收放回连接池
获取一个连接
获取一个连接
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
连接回收放回连接池
获取一个连接
连接回收放回连接池
获取一个连接
连接回收放回连接池
获取一个连接
连接回收放回连接池
获取一个连接
连接回收放回连接池
获取一个连接
连接回收放回连接池

Process finished with exit code 0

模板模式的优点

  1. 利用模板方法将相同处理逻辑的代码放到抽象父类中，可以提高代码的复用性。
  2. 将不同的代码放到不同的子类中，通过对子类的扩展增加新的行为，提高代码的扩展性。
  3. 把不变的行为写到父类上，去除子类的重复代码，提供了一个很好的代码复用平台，符合开闭原则。

模板模式的缺点
1、类数目的增加，每一个抽象类都需要一个子类实现，这样导致类的个数增加。
2、类数量的增加，间接的增加了系统实现的复杂度。
3、继承关系自身缺点，如果父类添加新的抽象方法，所有子类都要改一遍。

桃花·心木
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 经典设计模式讲解以及项目实战
06-14
设计模式简介：主要介绍各种设计模式的概念和运用场景等 设计模式综合运用：主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介：主要是讲述Spring源码中运用到的一些设计模式 ...
C#23种设计模式_示例源代码及PDF
07-14
命令模式把发出命令的责任 命令模式 和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方 独 立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收， 以及...
设计模式------委派模式和模板方法模式
烟雨gps
05-04 328
委派模式和模板模式 目录 委派模式和模板模式 1、委派模式 1.1 什么是委派模式 1.2 结构图 1.3 实例演示 1.4 总结 2、模板方法模式 2.1什么是模板方法模式 2.2结构图 2.3实例 2.4小节 1、委派模式 1.1 什么是委派模式 委派模式不属于23种设计模式，在平常其他设计模式中可能也有体现。同样在现实生活中也有相关的体现，比如一个具体...
代理模式 委派模式 策略模式_九、委派模式与模板模式详解
weixin_29025911的博客
12-16 172
14.委派模式14.1.课程目标1 、掌握委派模式， 精简程序逻辑， 提升代码的可读性。2、学会用模板方法模式梳理使用工作中流程标准化的业务场景。14.2.内容定位1 、希望通过对委派模式的学习，让自己写出更加优雅的代码的人群。2、深刻了解模板方法模式的应用场景。14.3.定义委派模式(Delegate Pattern ) 又叫委托模式， 是一种面向对象的设计模式， 允许对象组合实现与 继承相同的...
委派模式和模板方式
qq_34621188的博客
10-20 179
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、委托模式1.概念二、模板方式1.概念总结 提示：以下是本篇文章正文内容，下面案例可供参考 一、委托模式 1.概念 其实就是自己不干活，指派人干活 /** * 抽象员工 */ public interface Employee { void operator(String task); } /** * 员工A */ public class EmployeeA implements Employee {
架构师内功心法-----委派模式与模板方法模式
hx1176406648的博客
03-29 94
委派模式与模板方法模式简介委派模式模板方法模式问题作业总结参考文档 简介 委派模式 模板方法模式 问题 作业 总结 参考文档
九、委派模式与模板模式详解
编程之心的博客
03-14 480
14.委派模式 14.1.课程目标 1 、掌握委派模式， 精简程序逻辑， 提升代码的可读性。 2、学会用模板方法模式梳理使用工作中流程标准化的业务场景。 14.2.内容定位 1 、希望通过对委派模式的学习，让自己写出更加优雅的代码的人群。 2、深刻了解模板方法模式的应用场景。 14.3.定义 委派模式(Delegate Pattern ) 又叫委托模式， 是一种面向对象的设计模式， 允许对象组合实...
设计模式——组合模式、委派模式、模板方法模式
Lucifer ZHAO
05-10 386
组合模式（Composite Pattern） 定义：组合模式也成为整体--部分模式，宗旨是通过将单个对象和组合对象用相同的接口进行表示。使客户端对单个对象和组合对象保持一致的方式处理。属于结构型模式。 适用场景：希望客户端可以忽略组合对象和单个对象的差异时；对象层次具备整体和部分，呈树形结构时。 委派模式（Delegate Pattern） 定义：委派模式又称委托模式，基本作用是负责任务的调度和任务分配，将任务的分配和执行分离开来，可以看做是一种特殊情况下的静态代理的全权处理。属于行为型模式，不是
Java中23种设计模式
热门推荐
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
常用设计模式[归纳].pdf
10-12
在实际项目中，设计模式的应用可以提高代码的可读性、可维护性和复用性，帮助开发者更好地理解和组织代码。例如，装饰模式在需要扩展功能时，提供了一种比继承更加灵活的解决方案，避免了类爆炸的问题。通过理解并...
两篇android设计模式[归纳].pdf
10-13
在Android开发中，设计模式尤其重要，因为它们帮助我们创建可维护、可扩展和高效的应用程序。本文将重点讨论在Android框架设计中常用的两种设计模式：Observer模式和Template Method模式。 1. **Observer模式**： ...
pyzmq-26.0.0b2-cp312-cp312-manylinux_2_28_x86_64.whl
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
C++冒泡排序（基础内容）
06-19
1.循环两个变量：外层（轮数）、内层每轮的次数； 2.总轮数=元素长度-1=最大下标 3.每轮次数=元素长度-1-轮数=最大下标-轮数； 4.轮数（++），次数（++）； 5.两两交换，大的放后面 冒泡排序基础内容，自学可用； 分为三个部分，推到过程，总结，题目样例 很详细，欢迎一起学习交流
pyzmq-25.1.0-cp36-cp36m-win32.whl
最新发布
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
protobuf-3.20.3-cp38-cp38-win_amd64.whl
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
protobuf-3.11.0-py2.7.egg
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
cryptography-0.7-cp32-none-win32.whl
06-19
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
小程序版通过CNN卷积神经网络的香料分类识别-不含数据集图片-含逐行注释和说明文档.zip
06-19
本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 如果有环境安装不会的，可自行网上搜索如何安装python和pytorch,这些环境安装都是有很多教程的，简单的 环境需要自行安装,推荐安装anaconda然后再里面推荐安装python3.7或3.8的版本，pytorch推荐安装1.7.1或1.8.1版本 首先是代码的整体介绍 总共是3个py文件，十分的简便 且代码里面的每一行都是含有中文注释的,小白也能看懂代码 然后是关于数据集的介绍。 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 在数据集文件夹下是我们的各个类别,这个类别不是固定的，可自行创建文件夹增加分类数据集 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行01数据集文本生成制作.py,是将数据集文件夹下的图片路径和对应的标签生成txt格式,划分了训练集和验证集 运行02深度学习模型训练.py,
SpringMVC的设计模式
09-10
SpringMVC采用了一种名为"前端控制器"的设计模式。...总结起来，SpringMVC的设计模式主要包括前端控制器模式、MVC模式、委派模式和适配器模式。这些设计模式的使用使得SpringMVC具有良好的扩展性、灵活性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值