spring in action 通过Spring和JDBC征服

作者: Theodore的技术站 | 来源:发表于2018-12-05 14:09 被阅读8次

通过 spring 征服 JDBC

spring 的数据访问哲学

image.png

spring 异常体系

image.png

Spring将数据访问过程中固定的和可变的部分明确划分为两个不同的类：模板（template）和回调（callback）。模板管理过程中固定的部分，而回调处理自定义的数据访问代码。

image.png

针对不同的持久化平台，Spring提供了多个可选的模板。如果直接使用JDBC，那你可以选择JdbcTemplate。如果你希望使用对象关系映射框架，那HibernateTemplate或JpaTemplate可能会更适合你。表10.2列出了Spring所提供的所有数据访问模板及其用途。

image.png

配置数据源

使用 JDNI 数据
利用Spring，我们可以像使用Spring bean那样配置JNDI中数据源的引用并将其装配到需要的类中。位于jee命名空间下的<jee:jndilookup>元素可以用于检索JNDI中的任何对象（包括数据源）并将其作为Spring的bean。例如，如果应用程序的数据源配置在JNDI中，我们可以使用<jee:jndi-lookup>元素将其装配到Spring中，如下所示：

<jee:jndi-lookup id="dataSource" jndi-name="/jdbc/SpitterDS" resource-ref="true"/>

如果想使用Java配置的话，那我们可以借助JndiObjectFactoryBean从JNDI中查找DataSource：

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

使用数据源连接池
是配置DBCP BasicDataSource的方式：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
    p:driverClassName="org.h2.Driver"
    p:url="jdbc:h2:tcp://localhost/~/spitter"
    p:username="sa"
    p:password=""
    p:initialSize="5"
    p:maxActive="10"/>

@Bean
    public BasicDataSource dataSource(){
        BasicDataSource ds = new BasicDataSource();
        ds.setDriverClassName("org.h2.Driver");
        ds.setUrl("jdbc:h2:tcp://localhost/~/spitter");
        ds.setUsername("sa");
        ds.setPassword("");
        ds.setInitalSize(5);
        ds.setMaxActive(10);
        return ds;
    }

BasicDataSource 配置属性

image.png

基于 JDBC 驱动的数据源
在Spring中，通过JDBC驱动定义数据源是最简单的配置方式。Spring提供了三个这样的数据源类（均位于org.springframework.jdbc.datasource包中）供选择：

-DriverManagerDataSource：在每个连接请求时都会返回一个新建的连接。与DBCP的BasicDataSource不同，由DriverManagerDataSource提供的连接并没有进行池化管理；

-SimpleDriverDataSource：与DriverManagerDataSource的工作方式类似，但是它直接使用JDBC驱动，来解决在特定环境下的类加载问题，这样的环境包括OSGi容器；

-SingleConnectionDataSource：在每个连接请求时都会返回同一个的连接。尽管SingleConnectionDataSource不是严格意义上的连接池数据源，但是你可以将其视为只有一个连接的池。

@Bean
    public DataSource dataSource(){
        DriverMangerDataSource ds = new DriverMangerDataSource();
        ds.setDriverClassName("org.h2.Driver");
        ds.setUrl("jdbc:h2:tcp://localhost/~/spitter");
        ds.setUsername("sa");
        ds.setPassword("");
        return ds;
    }

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"
    p:driverClassName="org.h2.Driver"
    p:url="jdbc:h2:tcp://localhost/~/spitter"
    p:username="sa"
    p:password="" />

尽管这些数据源对于小应用或开发环境来说是不错的，但是要将其用于生产环境，你还是需要慎重考虑。因为SingleConnectionDataSource有且只有一个数据库连接，所以不适合用于多线程的应用程序，最好只在测试的时候使用。而DriverManagerDataSource和SimpleDriverDataSource尽管支持多线程，但是在每次请求连接的时候都会创建新连接，这是以性能为代价的。鉴于以上的这些限制，我强烈建议应该使用数据源连接池。

使用嵌入式的数据源
使用jdbc命名空间配置嵌入式数据库

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:c="http://www.springframework.org/schema/c"
    xsi:schemaLocation="http://www.springframework.org/schema/jdbc
    http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">
...
    <jdbc:embedded-database id="dataSource" type="H2">
        <jdbc:script location="com/habuma/spitter/db/jdbc/schema.sql"/>
        <jdbc:script location="com/habuma/spitter/db/jdbc/test-data.sql"/>
    </jdbc:embedded-database>
</beans>

我们将<jdbc:embedded-database>的type属性设置为H2，表明嵌入式数据库应该是H2数据库（要确保H2位于应用的类路径下）。另外，我们还可以将type设置为DERBY，以使用嵌入式的ApacheDerby数据库。

除了搭建嵌入式数据库以外，<jdbc:embedded-database>元素还会暴露一个数据源，我们可以像使用其他的数据源那样来使用它。在这里，id属性被设置成了dataSource，这也是所暴露数据源的bean ID。因此，当我们需要javax.sql.DataSource的时候，就可以注入dataSource bean。
如果使用Java来配置嵌入式数据库时，不会像jdbc命名空间那么简便，我们可以使用EmbeddedDatabaseBuilder来构建

@Bean
    public DataSource dataSource(){
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("classpath:schema.sql")
            .addScript("classpath:test-data.sql")
            .build();
    }

使用profile选择数据源
对于开发期来说，<jdbc:embedded-database>元素是很合适的，而在QA环境中，你可能希望使用DBCP的BasicDataSource，在生产部署环境下，可能需要使用<jee:jndi-lookup>。


public class DataSourceConfiguration {
    @Profile("development")
    @Bean
    public DataSource embeddedDataSource(){
        return new EmbeddedDatabaseBuilder()
                    .setType(EmbeddedDatabaseType.H2)
                    .addScript("classpath:schema.sql")
                    .addScript("classpath:test-data.sql")
                    .build();
    }

    @Profile("qa")
    @Bean
    public DataSource Data(){
        BasicDataSource ds = new BasicDataSource();
        ds.setDriverClassName("org.h2.Driver");
        ds.setUrl("jdbc.h2:tcp://localhost/~/spitter");
        ds.setUsername("sa");
        ds.setPassword("");
        ds.setInitialSize(5);
        ds.setMaxActive(10);
        return ds;
    }
    
    
    @Profile("production")
    @Bean
    public DataSource dataSource(){
            JndiObjectFactoryBean jndiObjectFactoryBean
                    = new JndiObjectFactoryBean();
            jndiObjectFactoryBean.setJndiName("jdbc/SpittrDS");
            jndiObjectFactoryBean.setResourceRef(true);
            jndiObjectFactoryBean.setProxyInterface(javax.sql.DataSource.class);
            return (DataSource) jndiObjectFactoryBean.getObject();
        }
    }
}

通过使用profile功能，会在运行时选择数据源，这取决于哪一个profile处于激活状态。如程序清单10.2配置所示，当且仅当developmentprofile处于激活状态时，会创建嵌入式数据库，当且仅当qa profile处于激活状态时，会创建DBCPBasicDataSource，当且仅当productionprofile处于激活状态时，会从JNDI获取数据源。

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/jdbc
        http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <beans profile="development">
    <jdbc:embedded-database id="dataSource" type="H2">
    <jdbc:script location="com/habuma/spitter/db/jdbc/schema.sql"/>
    <jdbc:script location="com/habuma/spitter/db/jdbc/test-data.sql"/>
    </jdbc:embedded-database>
    </beans>

    <beans profile="qa">
        <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
              p:driverClassName="org.h2.Driver"
              p:url="jdbc:h2:tcp://localhost/~/spitter"
              p:username="sa"
              p:password=""
              p:initialSize="5"
              p:maxActive="10"/>
    </beans>
    
    <beans profile="production">
        <jee:jndi-lookup id="dataSource"
                         jndi-name="/jdbc/SpitterDS"
                         resource-ref="true"/>
    </beans>
</beans>

在 spring 中使用 JDBC

使用 JDBC 在数据库插入一行

private static final String SQL_INSERT_SPITTER = "insert into spitter (username,password,fullname) values (?,?,?)";
private DataSource dataSource;

public void addSpitter (Spitter spitter){
    Connection conn = null;
    PreparedStatement stmt = null;
    try{
        conn = dataSource.getConnection();
        stmt = conn.prepareStatement(SQL_INSERT_SPITTER);
        stmt.setString(1,spitter.getUsername());
        stmt.setString(2.spitter.getPassword());
        stmt.setString(3,spiiter.getFullName());
        stmt.execute();
        }catch(SQLException e){
            //do somthing...not sure what, though
        }finally{
            try{
                if(stmt != null){
                    stmt.close();
                }
                if(conn != null){
                    conn.close();
                }
            }catch(SQLException e){
                //I'm even less sure about what to do here
            }
        }
}

使用 JDBC 在数据库更新一行

private static final String SQL_UPDATE_SPITTER = "update spitter set username = ?,password = ?, fullname = ? " + "where id =?";

public void saveSpitter(Spitter spitter) {
    Connection conn = null;
    PreparedStatement stmt = null;
    try{
        conn = dataSource.getConnection();
        stmt = conn.prepareStatement(SQL_UPDATE_SPITTER);
        stmt.setString(1,spitter.getUsername());
        stmt.setString(2,spitter.getPassword());
        stmt.setString(3,spitter.getFullname());
        stmt.setLong(4,spitter.getId());
        stmt.execute();
        }catch(SQLException e){
        //still not sure what I'm supposed to do here
        }finally{
            try{
                if(stmt != null){
                    stmt.close();
                }
                if(conn != null){
                    conn.close();
                }
            }catch(SQLException e){
        //or here                                        
            }
        }
}

使用 JDBC 数据库查询一行数据

private static final String SQL_SELECT_SPITTER = "select id username,fullname from spitter where id = ?";
public Spitter findOne(long id) {
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;
        try{
            conn = dataSource.getConnection();
            stmt = conn.prepareStatement(SQL_SELECT_SPITTER);
            stmt.setLong(1,id);
            rs = stmt.executeQuery();
            Spitter spitter = null;
            if (rs.next()){
                spitter = new Spitter();
                spitter.setId(rs.getLong("id"));
                spitter.setUsername(rs.getString("username"));
                spitter.setUsername(rs.getString("password"));
                spitter.setUsername(rs.getString("fullname"));
            }
            return spitter;
        }catch(SQLException e){
        }finally{
            if(rs != null){
                try{
                    rs.close();
                }catch(SQLException e){}
            }
            if(stmt != null){
                try{
                    stmt.close();
                }catch(SQLException e){}
            }
            if(conn != null){
                try{
                    conn.close();
                }catch(SQLException e){}
            }
        }
}

上面三个示例代码都比较冗长，但是保证了代码的健壮性，下面我们来看看如何使用 JDBC 模板来简化代码：
Spring的JDBC框架承担了资源管理和异常处理的工作，从而简化了JDBC代码，让我们只需编写从数据库读写数据的必需代码。

-JdbcTemplate：最基本的Spring JDBC模板，这个模板支持简单的JDBC数据库访问功能以及基于索引参数的查询；
-NamedParameterJdbcTemplate：使用该模板类执行查询时可以将值以命名参数的形式绑定到SQL中，而不是使用简单的索引参数；
-SimpleJdbcTemplate：该模板类利用Java 5的一些特性如自动装箱、泛型以及可变参数列表来简化JDBC模板的使用。

使用 JdbcTemplate 插入数据

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

现在，我们可以将jdbcTemplate装配到Repository中并使用它来访问数据库。例如，SpitterRepository使用了JdbcTemplate：

@Repository
public class JdbcSpitterRepository implements SpitterRepository{
    private JdbcOperations jdbcOperations;

    @Inject
    public JdbcSpitterRepository(JdbcOperations jdbcOperations){
        this.jdbcOperations = jdbcOperations;
    }
...
}

在这里，JdbcSpitterRepository类上使用了@Repository注解，这表明它将会在组件扫描的时候自动创建。它的构造器上使用了@Inject注解，因此在创建的时候，会自动获得一个JdbcOperations对象。JdbcOperations是一个接口，定义了JdbcTemplate所实现的操作。通过注入JdbcOperations，而不是具体的JdbcTemplate，能够保证JdbcSpitterRepository通过JdbcOperations接口达到与JdbcTemplate保持松耦合。
作为另外一种组件扫描和自动装配的方案，我们可以将JdbcSpitterRepository显式声明为Spring中的bean，如下所示：

@Bean
    public SpitterRepository spitterRepository(JdbcTemplate jdbcTemplate)    {
        return new JdbcSpitterRepository(jdbcTemplate);
    }

基于JdbcTemplate的addSpitter()方法如下：

public void addSpitter(Spitter spitter){
        jdbcOperations.update(INSERT_SPITTER,
                spitter.getUsername(),
                spitter.getPassword(),
                spitter.getFullName(),
                spitter.getEmail(),
                spitter.isUpdateByEmail());
    }

使用JdbcTemplate查询Spitter

public Spitter findOne(long id){
        return jdbcOperations.queryForObject(SELECT_SPITTER_BY_ID,new SpitterRowMapper(),id);
    }
    ...
    private static final class SpitterRowMapper implements RowMapper<Spitter>{
        public Spitter mapRow(ResultSet rs, int rowNum)throws SQLException{
            return new Spitter(rs.getLong("Id"),
                    rs.getString("username"),
                    rs.getString("password"),
                    rs.getString("fullName"),
                    rs.getString("email"),
                    rs.getBoolean("updateByEmail"));
        }
    }

使用Spring JDBC模板的命名参数功能

private static final String INSERT_SPITTER = "insert into Spitter" +
            "(username,password,fullname,email,updateByEmail)" +
            "values" + "(:username,:password,:fullname,:email,:updateByEmail)";
    public void addSpitter(Spitter spitter){
        Map<String,Object> paramMap = new HashMap<>();
        paramMap.put("username",spitter.getUserName());
        paramMap.put("password",spitter.getPassword());
        paramMap.put("fullname",spitter.getFullName());
        paramMap.put("email",spitter.getEmail());
        paramMap.put("updateByEmail",spitter.isUpdateByEmail());
        jdbcOperation.update(INSERT_SPITTER,paramMap);
    }

spring in action 通过Spring和JDBC征服

通过 spring 征服 JDBC

spring 的数据访问哲学

spring 异常体系

配置数据源

在 spring 中使用 JDBC

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读