vlambda博客
学习文章列表

让我们通过一个真实的例子来理解resource管理问题。您一定曾经在某个时候在网上订购过披萨。如果是这样，从订购比萨饼到交付的过程中涉及的步骤是什么？这个过程有很多步骤——我们首先去披萨公司的在线门户，选择披萨的大小和配料。之后，我们下订单并结帐。订单被最近的披萨店接受；他们相应地准备我们的披萨，相应地放上配料，将披萨包装在袋子中，送货员上门将披萨交给您，最后，您和朋友一起享用披萨。尽管此过程有很多步骤，但您只积极参与其中的几个步骤。比萨公司负责烹饪比萨并顺利送达。您仅在需要时参与，其他步骤由比萨公司负责。正如您在此示例中所见，管理此流程涉及许多步骤，我们还必须相应地将资源分配给每个步骤，以便将其视为完整的任务，而不会中断流程。这是强大的设计模式模板方法模式的完美场景。 Spring 框架实现了这个模板设计模式来处理应用程序的 DAO 层中的此类场景。让我们看看如果我们不使用 Spring，而使用传统应用程序，我们会面临哪些问题。

在传统应用程序中，我们使用 JDBC API 来访问数据库中的数据。这是一个简单的应用程序，我们使用 JDBC API 访问和持久化数据，对于这个应用程序，需要以下步骤：

如果您为同一个应用程序使用 Spring 框架，那么您必须为前面的步骤列表中的某些步骤编写代码，而 Spring 会处理所有涉及低级过程的步骤，例如建立连接、开始一个事务，处理数据层中的任何异常，并关闭连接。 Spring 通过使用模板方法设计模式来管理这些步骤，我们将在下一节中学习。

模板方法设计模式应用广泛，来属于GOF设计模式家族的结构化设计模式。该模式定义了算法的轮廓或骨架，并将细节留给稍后的具体实现。这种模式隐藏了大量的样板代码。 Spring提供了很多模板类，如JdbcTemplate、JmsTemplate、RestTemplate、和 WebServiceTemplate。大多数情况下，这种模式隐藏了前面在比萨示例中讨论的低级资源管理。

在该示例中，该过程是从在线门户订购披萨送货上门。比萨公司遵循的流程对每个客户都有一些固定的步骤，比如接单、准备比萨、根据客户的规格添加配料，然后将其送到客户的地址。我们可以添加这些步骤，或者将这些步骤定义为特定的算法。然后系统可以相应地实施该算法。

Spring 实现了这种模式来访问数据库中的数据。在数据库或任何其他技术中，有一些步骤总是常见的，例如建立与数据库的连接、处理事务、处理异常以及每个数据访问过程所需的一些清理操作。但也有一些步骤不是固定的，而是取决于应用程序的要求。定义这些步骤是开发人员的责任。但是 Spring 允许我们将数据访问过程的固定和动态部分分离为不同的部分，作为模板和回调。所有固定步骤都在模板下，动态自定义步骤在回调下。下图详细描述了两者：

如上图所示，数据访问流程的所有固定部分都封装到了 Spring Framework 的模板类中，如打开和关闭连接、打开和关闭语句、处理异常和管理资源。但其他步骤，如编写 SQL、声明连接参数等，都是回调的一部分，回调由开发人员处理。

Spring提供了几种模板方法设计模式的实现，例如JdbcTemplate、JmsTemplate、RestTemplate< /code> 和 WebServiceTemplate，但在本章中，我将仅解释其对 JDBC API 的实现，即 JdbcTemplate。 JdbcTemplate-NamedParameterJdbcTemplate还有另一个变种，它包装了一个JdbcTemplate来提供命名参数，而不是传统的JDBC“?" 占位符。

        public List<Account> findByAccountNumber(Long accountNumber) { 
          List<Account> accountList = new ArrayList<Account>(); 
          Connection conn = null; 
          String sql = "select account_name,
          account_balance from ACCOUNT where account_number=?"; 
          try { 
            DataSource dataSource = DataSourceUtils.getDataSource(); 
            conn = dataSource.getConnection(); 
            PreparedStatement ps = conn.prepareStatement(sql); 
            ps.setLong(1, accountNumber); 
            ResultSet rs = ps.executeQuery(); 
            while (rs.next()) { 
              accountList.add(new Account(rs.getString(
                "account_name"), ...)); 
            } 
          } catch (SQLException e) { /* what to be handle here? */ } 
          finally { 
            try { 
              conn.close(); 
            } catch (SQLException e) { /* what to be handle here ?*/ } 
          } 
          return accountList; 
        } 

Solving problems with Spring's JdbcTemplate

Spring 的 JdbcTemplate 解决了上一节中列出的 problems。 JdbcTemplate 极大地简化了 JDBC API 的使用，并消除了重复的样板代码。它减轻了常见的错误原因，并在不牺牲能力的情况下正确处理 SQLExceptions。它提供对标准 JDBC 结构的完全访问。让我们看看使用 Spring 的 JdbcTemplate 类来解决这两个问题的相同代码：

• Removing redundant code from the application using JdbcTemplate: Suppose you want a count of the accounts in a bank. The following code is required if you use the JdbcTemplate class:

        int count = jdbcTemplate.queryForObject("SELECT COUNT(*)
         FROM ACCOUNT", Integer.class); 
 

Copy

如果要访问特定用户 ID 的帐户列表：

        List<Account> results = jdbcTemplate.query(someSql,
         new RowMapper<Account>() { 
           public Account mapRow(ResultSet rs, int row) throws 
            SQLException { 
              // map the current row to an Account object 
            } 
        }); 

Copy

正如您在前面的代码中看到的，您不需要编写打开和关闭数据库连接的代码，准备执行查询的语句等等。

• Data Access Exceptions: Spring provides a consistent exception hierarchy to handle technology-specific exceptions like SQLException to its own exception class hierarchy with DataAccessException as the root exception. Spring wraps these original exceptions into different unchecked exceptions. Now Spring does not force the developers to handle these exceptions at development time. Spring provides the DataAccessException hierarchy to hide whether you are using JPA, Hibernate, JDBC, or similar. Actually, it is a hierarchy of sub-exceptions, and not just one exception for everything. It is consistent across all the supported data access technologies. The following diagram depicts the Spring Data Access Exception hierarchy:

• As you can see in the preceding figure, Spring's DataAccessException extends the RuntimeException, that is, it is an unchecked exception. In an enterprise application, unchecked exceptions can be thrown up the call hierarchy to the best place to handle it. The good thing is that the methods in between don't know about it in the application.

在声明 Spring 应用程序中的模板和存储库之前，让我们首先讨论如何使用数据源配置 Spring 以能够连接数据库。

使用 JDBC 驱动程序configure 数据源 bean 是最简单的 data Spring 中的源代码。 Spring提供的三个数据源类如下​​：

让我们看看以下代码，用于在应用程序中使用 Spring 的 DriverManagerDataSource 类配置数据源 bean：

在基于Java的配置中，代码如下：

    DriverManagerDataSource dataSource = new DriverManagerDataSource(); 
    dataSource.setDriverClassName("org.h2.Driver"); 
    dataSource.setUrl("jdbc:h2:tcp://localhost/bankDB"); 
    dataSource.setUsername("root"); 
    dataSource.setPassword("root"); 

在基于 XML 的配置中，代码将如下所示：

    <bean id="dataSource" class="org.springframework.jdbc.datasource .DriverManagerDataSource"> 
     <property name="driverClassName" value="org.h2.Driver"/> 
     <property name="url" value="jdbc:h2:tcp://localhost/bankDB"/> 
     <property name="username" value="root"/> 
     <property name="password" value="root"/> 
    </bean> 

前面代码中定义的数据源是一个非常简单的数据源，我们可以在开发环境中使用。它不是适合生产的数据源。我个人更喜欢使用 JNDI 来配置生产环境的数据源。让我们看看如何。

让我们实现对象池设计模式以提供数据源对象通过配置数据源使用 JNDI。

在 Spring 应用程序中，您可以使用 JNDI 查找来配置数据源。 Spring 提供了来自 Spring 的 JEE 命名空间的 <jee:jndi-lookup> 元素。让我们看看这个配置的代码。

在XML配置中，代码如下：

    <jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/datasource" /> 

在Java配置中，代码如下：

    @Bean 
    public JndiObjectFactoryBean dataSource() { 
      JndiObjectFactoryBean jndiObject = new JndiObjectFactoryBean(); 
      jndiObject.setJndiName("jdbc/datasource"); 
      jndiObject.setResourceRef(true); 
      jndiObject.setProxyInterface(javax.sql.DataSource.class); 
      return jndiObject; 
    } 

WebSphere 或 JBoss 等应用程序服务器允许您配置要通过 JNDI 准备的数据源。甚至像 Tomcat 这样的 Web 容器也允许您配置要通过 JNDI 准备的数据源。这些服务器管理应用程序中的数据源。这是有益的，因为数据源的性能会更好，因为应用程序服务器通常是池化的。它们可以完全在应用程序外部进行管理。这是配置要通过 JNDI 检索的数据源的最佳方法之一。如果您无法在生产环境中通过 JNDI 查找进行检索，您可以选择另一个更好的选项，我们将在下面讨论。

以下开源技术提供汇集的数据 来源：

以下代码配置 DBCP 的 BasicDataSource。

基于 XML 的 DBCP 配置如下：

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> 
      <property name="driverClassName" value="org.h2.Driver"/> 
      <property name="url" value="jdbc:h2:tcp://localhost/bankDB"/> 
      <property name="username" value="root"/> 
      <property name="password" value="root"/> 
      <property name="initialSize" value="5"/> 
      <property name="maxActive" value="10"/> 
    </bean> 

基于 Java 的 DBCP 配置如下：

    @Bean 
    public BasicDataSource dataSource() { 
      BasicDataSource dataSource = new BasicDataSource(); 
      dataSource.setDriverClassName("org.h2.Driver"); 
      dataSource.setUrl("jdbc:h2:tcp://localhost/bankDB"); 
      dataSource.setUsername("root"); 
      dataSource.setPassword("root"); 
      dataSource.setInitialSize(5); 
      dataSource.setMaxActive(10); 
      return dataSource; 
    } 

正如您在前面的代码中看到的，还为池数据源提供程序引入了许多其他属性。下面列出了 Spring 中 BasicDataSource 类的属性：

数据访问层是 business 层和数据库之间的一个方面。数据访问取决于业务调用，并且取决于数据源，例如数据库、平面文件、XML 等。因此，我们可以通过提供接口来抽象所有访问。这称为数据访问对象模式。从应用程序的角度来看，访问关系数据库或使用 DAO 解析 XML 文件没有区别。

在早期版本中，EJB 提供由容器管理的实体 bean；它们是分布式的、安全的和事务性的组件。这些 bean 对客户端是非常透明的，也就是说，对于应用程序中的服务层，它们具有自动持久性，无需底层数据库的关心。但大多数情况下，您的应用程序不需要这些实体 bean 提供的功能，因为您需要将数据持久保存到数据库中。由于，实体 bean 的一些非必需功能（如网络流量）增加了，并且您的应用程序的性能受到了影响。而那个时候，实体 bean 需要在 EJB 容器内运行，这就是为什么很难测试的原因。

简而言之，如果您使用传统的 JDBC API 或更早的 EJB 版本，您的应用程序将面临以下问题：

让我们看看spring是如何解决这些问题的。

正如您之前所了解的，Spring 的 JdbcTemplate 解决了应用程序中的两个主要问题。它解决了应用程序中数据访问代码的冗余代码问题以及不良异常handling。如果您的应用程序中没有 JdbcTemplate，查询一行只需要 20% 的代码，但 80% 是处理异常和管理资源的样板。如果您使用 JdbcTemplate，则无需担心 80% 的样板代码。 Spring的JdbcTemplate，简而言之，负责以下工作：

让我们看看在应用程序中何时使用 JdbcTemplate，以及如何创建它。

JdbcTemplate 在 standalone 应用程序中以及在需要 JDBC 的任何时候都很有用。它适用于实用程序或测试代码以清理杂乱的遗留代码。此外，在任何分层应用程序中，您都可以实现存储库或数据访问对象。让我们看看如何在应用程序中创建它。

    JdbcTemplate template = new JdbcTemplate(dataSource); 

    @Bean 
    public JdbcTemplate jdbcTemplate(DataSource dataSource) { 
      return new JdbcTemplate(dataSource); 
    } 

    package com.packt.patterninspring.chapter7.bankapp.repository; 
 
    import java.sql.ResultSet; 
    import java.sql.SQLException; 
 
    import javax.sql.DataSource; 
 
    import org.springframework.jdbc.core.JdbcTemplate; 
    import org.springframework.jdbc.core.RowMapper; 
    import org.springframework.stereotype.Repository; 
  
    import com.packt.patterninspring.chapter7.bankapp.model.Account; 
    @Repository 
    public class JdbcAccountRepository implements AccountRepository{ 
    
      JdbcTemplate jdbcTemplate; 
    
      public JdbcAccountRepository(DataSource dataSource) { 
        super(); 
        this.jdbcTemplate = new JdbcTemplate(dataSource); 
      } 
 
      @Override 
      public Account findAccountById(Long id){ 
        String sql = "SELECT * FROM Account WHERE id = "+id; 
        return jdbcTemplate.queryForObject(sql,
         new RowMapper<Account>(){ 
           @Override 
           public Account mapRow(ResultSet rs, int arg1) throws
           SQLException { 
             Account account = new Account(id); 
             account.setName(rs.getString("name")); 
             account.setBalance(new Long(rs.getInt("balance"))); 
             return account; 
           } 
         }); 
      } 
    } 

      public interface RowMapper<T> { 
        T mapRow(ResultSet rs, int rowNum) 
        throws SQLException; 
      } 

    package com.packt.patterninspring.chapter7.bankapp.rowmapper; 
 
    import java.sql.ResultSet; 
    import java.sql.SQLException; 
    import org.springframework.jdbc.core.RowMapper; 
    import com.packt.patterninspring.chapter7.bankapp.model.Account; 
    public class AccountRowMapper implements RowMapper<Account>{ 
      @Override 
      public Account mapRow(ResultSet rs, int id) throws SQLException { 
        Account account = new Account(); 
        account.setId(new Long(rs.getInt("id"))); 
        account.setName(rs.getString("name")); 
        account.setBalance(new Long(rs.getInt("balance"))); 
        return account; 
      } 
    } 

    public Account findAccountById(Long id){ 
      String sql = "SELECT * FROM Account WHERE id = "+id; 
      return jdbcTemplate.queryForObject(sql, new AccountRowMapper()); 
    } 

    public List<Account> findAccountById(Long id){ 
      String sql = "SELECT * FROM Account "; 
      return jdbcTemplate.queryForList(sql, new AccountRowMapper()); 
    } 

    public interface RowCallbackHandler { 
      void processRow(ResultSet rs) throws SQLException; 
    } 

    package com.packt.patterninspring.chapter7.bankapp.callbacks; 
    import java.sql.ResultSet; 
    import java.sql.SQLException; 
    import org.springframework.jdbc.core.RowCallbackHandler; 
    public class AccountReportWriter implements RowCallbackHandler { 
      public void processRow(ResultSet resultSet) throws SQLException { 
        // parse current row from ResultSet and stream to output 
        //write flat file, XML 
      } 
    } 

    @Override 
    public void generateReport(Writer out, String branchName) { 
      String sql = "SELECT * FROM Account WHERE branchName = "+
       branchName; 
      jdbcTemplate.query(sql, new AccountReportWriter()); 
    } 

    public interface ResultSetExtractor<T> { 
      T extractData(ResultSet rs) throws SQLException,
      DataAccessException; 
    } 

    package com.packt.patterninspring.chapter7.bankapp.callbacks; 
 
    import java.sql.ResultSet; 
    import java.sql.SQLException; 
    import java.util.ArrayList; 
    import java.util.List; 
 
    import org.springframework.dao.DataAccessException; 
    import org.springframework.jdbc.core.ResultSetExtractor; 
 
    import com.packt.patterninspring.chapter7.bankapp.model.Account; 
 
    public class AccountExtractor implements
     ResultSetExtractor<List<Account>> { 
       @Override 
       public List<Account> extractData(ResultSet resultSet) throws
        SQLException, DataAccessException { 
          List<Account> extractedAccounts = null; 
          Account account = null; 
          while (resultSet.next()) { 
            if (extractedAccounts == null) { 
              extractedAccounts = new ArrayList<>(); 
              account = new Account(resultSet.getLong("ID"),
               resultSet.getString("NAME"), ...); 
            } 
            extractedAccounts.add(account); 
          } 
          return extractedAccounts; 
       } 
    } 

    public List<Account> extractAccounts() { 
      String sql = "SELECT * FROM Account"; 
      return jdbcTemplate.query(sql, new AccountExtractor()); 
    }