模板方法设计模式：Spring框架中八大经典应用场景

码到π退休

已于 2024-09-13 07:39:48 修改

阅读量1.2k

点赞数 27

分类专栏： Java 文章标签：设计模式 spring java 模板方法模式

于 2024-09-13 07:36:49 首次发布

本文链接：https://blog.csdn.net/lilinhai548/article/details/142190564

版权

Java 专栏收录该内容

132 篇文章

订阅专栏

🧑 博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于分享所学，希望通过我的实践经历和见解，启发他人的创新思维。在这里，我希望能与志同道合的朋友交流探讨，共同进步，一起在技术的世界里不断学习成长。

在这里插入图片描述

模板方法设计模式：Spring框架中八大经典应用场景

引言

在前面的文章中，我们详细介绍了模板方法设计模式，知道模板方法（Template Method）设计模式是一种行为型设计模式，它定义了一个操作中的算法骨架，而将一些步骤延迟到子类中实现。模板方法使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。

其实在我们熟悉的Spring框架中，模板方法设计模式被广泛应用，尤其是在处理数据库操作、消息队列、事务管理等场景中。本文通过筛选的八个典型有关在spring框架中使用模板方法设计模式的代码示例场景，将详细解释模板方法设计模式在Spring框架中的应用及其好处，使我们能更加深入的理解模板方法设计模式，好在今后更多的将它应用到实际开发项目，以提高应用程序的灵活性，扩展性等非功能性设计。

1. JdbcTemplate

1.1 场景描述

在Spring框架中，JdbcTemplate是一个非常常见的类，用于简化JDBC操作。它通过模板方法设计模式，将数据库操作的通用部分（如连接管理、异常处理等）封装在基类中，而将具体的SQL执行逻辑留给子类或回调函数实现。

1.2 代码示例

public class JdbcTemplate {
    public <T> T query(final String sql, final ResultSetExtractor<T> rse) throws DataAccessException {
        // 模板方法的核心逻辑
        Connection con = null;
        Statement stmt = null;
        ResultSet rs = null;
        try {
            con = getConnection();
            stmt = con.createStatement();
            rs = stmt.executeQuery(sql);
            return rse.extractData(rs); // 具体的SQL执行逻辑由回调函数实现
        } catch (SQLException ex) {
            // 异常处理
        } finally {
            // 资源释放
        }
    }
}

1.3 示例解释

JdbcTemplate中的query方法定义了数据库查询的基本流程，包括获取连接、执行SQL、处理结果集等。
具体的SQL执行逻辑通过ResultSetExtractor接口的回调函数实现，这样可以将通用的数据库操作逻辑与具体的业务逻辑分离。

1.4 好处

代码复用：通过模板方法，可以复用数据库操作的通用逻辑，减少重复代码。
灵活性：具体的SQL执行逻辑可以通过回调函数灵活实现，便于扩展和维护。

2. JmsTemplate

2.1 场景描述

JmsTemplate是Spring框架中用于简化JMS（Java Message Service）操作的类。它通过模板方法设计模式，将消息发送和接收的通用逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现。

2.2 代码示例

public class JmsTemplate {
    public void send(final Destination destination, final MessageCreator messageCreator) throws JmsException {
        // 模板方法的核心逻辑
        Connection con = null;
        Session session = null;
        MessageProducer producer = null;
        try {
            con = getConnection();
            session = con.createSession();
            producer = session.createProducer(destination);
            Message message = messageCreator.createMessage(session); // 具体的业务逻辑由回调函数实现
            producer.send(message);
        } catch (JMSException ex) {
            // 异常处理
        } finally {
            // 资源释放
        }
    }
}

2.3 示例解释

JmsTemplate中的send方法定义了消息发送的基本流程，包括获取连接、创建会话、发送消息等。
具体的业务逻辑通过MessageCreator接口的回调函数实现，这样可以将通用的消息发送逻辑与具体的业务逻辑分离。

2.4 好处

代码复用：通过模板方法，可以复用消息发送的通用逻辑，减少重复代码。
灵活性：具体的业务逻辑可以通过回调函数灵活实现，便于扩展和维护。

3. TransactionTemplate

3.1 场景描述

TransactionTemplate是Spring框架中用于简化事务管理的类。它通过模板方法设计模式，将事务管理的通用逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现。

3.2 代码示例

public class TransactionTemplate {
    public <T> T execute(TransactionCallback<T> action) throws TransactionException {
        // 模板方法的核心逻辑
        TransactionStatus status = getTransactionManager().getTransaction(new DefaultTransactionDefinition());
        try {
            T result = action.doInTransaction(status); // 具体的业务逻辑由回调函数实现
            getTransactionManager().commit(status);
            return result;
        } catch (Exception ex) {
            getTransactionManager().rollback(status);
            throw ex;
        }
    }
}

3.3 示例解释

TransactionTemplate中的execute方法定义了事务管理的基本流程，包括获取事务、执行业务逻辑、提交或回滚事务等。
具体的业务逻辑通过TransactionCallback接口的回调函数实现，这样可以将通用的事务管理逻辑与具体的业务逻辑分离。

3.4 好处

代码复用：通过模板方法，可以复用事务管理的通用逻辑，减少重复代码。
灵活性：具体的业务逻辑可以通过回调函数灵活实现，便于扩展和维护。

4. RestTemplate

4.1 场景描述

RestTemplate是Spring框架中用于简化RESTful API调用的类。它通过模板方法设计模式，将HTTP请求的通用逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现。

4.2 代码示例

public class RestTemplate {
    public <T> T getForObject(String url, Class<T> responseType, Object... uriVariables) throws RestClientException {
        // 模板方法的核心逻辑
        RequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
        ResponseExtractor<T> responseExtractor = responseEntityExtractor(responseType);
        return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
    }

    public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... uriVariables) throws RestClientException {
        // 模板方法的核心逻辑
        ClientHttpRequest request = createRequest(url, method);
        requestCallback.doWithRequest(request); // 具体的业务逻辑由回调函数实现
        ClientHttpResponse response = request.execute();
        return responseExtractor.extractData(response); // 具体的业务逻辑由回调函数实现
    }
}

4.3 示例解释

RestTemplate中的getForObject方法定义了HTTP GET请求的基本流程，包括创建请求、执行请求、处理响应等。
具体的业务逻辑通过RequestCallback和ResponseExtractor接口的回调函数实现，这样可以将通用的HTTP请求逻辑与具体的业务逻辑分离。

4.4 好处

代码复用：通过模板方法，可以复用HTTP请求的通用逻辑，减少重复代码。
灵活性：具体的业务逻辑可以通过回调函数灵活实现，便于扩展和维护。

5. JpaTemplate

5.1 场景描述

JpaTemplate是Spring框架中用于简化JPA（Java Persistence API）操作的类。它通过模板方法设计模式，将JPA操作的通用逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现。

5.2 代码示例

public class JpaTemplate {
    public <T> T execute(final JpaCallback<T> action) throws DataAccessException {
        // 模板方法的核心逻辑
        EntityManager em = getEntityManager();
        try {
            return action.doInJpa(em); // 具体的业务逻辑由回调函数实现
        } finally {
            em.close();
        }
    }
}

5.3 示例解释

JpaTemplate中的execute方法定义了JPA操作的基本流程，包括获取实体管理器、执行业务逻辑、关闭实体管理器等。
具体的业务逻辑通过JpaCallback接口的回调函数实现，这样可以将通用的JPA操作逻辑与具体的业务逻辑分离。

5.4 好处

代码复用：通过模板方法，可以复用JPA操作的通用逻辑，减少重复代码。
灵活性：具体的业务逻辑可以通过回调函数灵活实现，便于扩展和维护。

6. HibernateTemplate

6.1 场景描述

HibernateTemplate是Spring框架中用于简化Hibernate操作的类。它通过模板方法设计模式，将Hibernate操作的通用逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现。

6.2 代码示例

public class HibernateTemplate {
    public <T> T execute(final HibernateCallback<T> action) throws DataAccessException {
        // 模板方法的核心逻辑
        Session session = getSession();
        try {
            return action.doInHibernate(session); // 具体的业务逻辑由回调函数实现
        } finally {
            session.close();
        }
    }
}

6.3 示例解释

HibernateTemplate中的execute方法定义了Hibernate操作的基本流程，包括获取会话、执行业务逻辑、关闭会话等。
具体的业务逻辑通过HibernateCallback接口的回调函数实现，这样可以将通用的Hibernate操作逻辑与具体的业务逻辑分离。

6.4 好处

代码复用：通过模板方法，可以复用Hibernate操作的通用逻辑，减少重复代码。
灵活性：具体的业务逻辑可以通过回调函数灵活实现，便于扩展和维护。

7. RedisTemplate

7.1 场景描述

RedisTemplate是Spring框架中用于简化Redis操作的类。它通过模板方法设计模式，将Redis操作的通用逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现。

7.2 代码示例

public class RedisTemplate<K, V> {
    public <T> T execute(RedisCallback<T> action) throws DataAccessException {
        // 模板方法的核心逻辑
        RedisConnection connection = getConnection();
        try {
            return action.doInRedis(connection); // 具体的业务逻辑由回调函数实现
        } finally {
            releaseConnection(connection);
        }
    }
}

7.3 示例解释

RedisTemplate中的execute方法定义了Redis操作的基本流程，包括获取连接、执行业务逻辑、释放连接等。
具体的业务逻辑通过RedisCallback接口的回调函数实现，这样可以将通用的Redis操作逻辑与具体的业务逻辑分离。

7.4 好处

代码复用：通过模板方法，可以复用Redis操作的通用逻辑，减少重复代码。
灵活性：具体的业务逻辑可以通过回调函数灵活实现，便于扩展和维护。

8. RabbitTemplate

8.1 场景描述

RabbitTemplate是Spring框架中用于简化RabbitMQ操作的类。它通过模板方法设计模式，将RabbitMQ操作的通用逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现。

8.2 代码示例

public class RabbitTemplate {
    public void convertAndSend(String exchange, String routingKey, Object object) throws AmqpException {
        // 模板方法的核心逻辑
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                // 具体的业务逻辑由回调函数实现
                return message;
            }
        };
        convertAndSend(exchange, routingKey, object, messagePostProcessor);
    }
}

8.3 示例解释

RabbitTemplate中的convertAndSend方法定义了RabbitMQ消息发送的基本流程，包括消息转换、发送消息等。
具体的业务逻辑通过MessagePostProcessor接口的回调函数实现，这样可以将通用的RabbitMQ操作逻辑与具体的业务逻辑分离。

8.4 好处

代码复用：通过模板方法，可以复用RabbitMQ操作的通用逻辑，减少重复代码。
灵活性：具体的业务逻辑可以通过回调函数灵活实现，便于扩展和维护。

总结

综上，可以看出，模板方法设计模式在Spring框架中得到了广泛应用，通过将通用的逻辑封装在基类中，而将具体的业务逻辑留给子类或回调函数实现，模板方法设计模式不仅提高了代码的复用性，还增强了代码的灵活性和可维护性。在Spring框架中，JdbcTemplate、JmsTemplate、TransactionTemplate、RestTemplate、JpaTemplate、HibernateTemplate、RedisTemplate和RabbitTemplate等类都是模板方法设计模式的典型应用场景。通过这些示例，我们可以看到模板方法设计模式在简化复杂操作、提高代码复用性和灵活性方面的巨大优势。