Spring配置DBCP和C3P0连接池对象和JDBC 模板的增删改查（十一）

配置DBCP连接池对象

在Spring中配置DBCP连接池对象，其实跟以前的使用方法差不多，只不过跟以前不用的是，将创建DataSource对象的工作交个Spring来处理。

其实也就是将DBCP创建连接池的类交给Spring的Bean标签管理，由Spring来帮我们创建DataSource对象，同时在配置文件中注入相应属性。

需要引入三个jar包：

commons-dbcp2-2.5.0，commons-pool2-2.6.0，commons-logging-1.2

然后在XML配置中将类托管：

配置DBCP的连接池的对象
<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
	<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
	<property name="url"
			  value="jdbc:mysql://localhost:3306/an?characterEncoding=UTF-8&amp;serverTimezone=UTC&amp;useSSL=false"/>
	<property name="username" value="root"/>
	<property name="password" value="root"/>
</bean>

同时配置Spring内置的JDBC模板对象，可以用来使用DataSoucre对象

<!--配置Spring的JDBC模板-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"/>
</bean>

测试类test中的使用：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class test {
    @Resource(name="jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    
    @Test
    public void test2(){
        jdbcTemplate.update("insert into user values (null,?,?)","kk3","asd4");
    }
}

配置C3P0连接池对象

配置C3P0连接池对象的方式和使用方式其实跟配置DBCP的方式是一样的，同样是将创建DataSource的类托管给Spring，由Spring来创建连接池对象，并且注入属性。

需要导入两个jar包：c3p0-0.9.5.2.jar，mchange-commons-java-0.2.12.jar

所以配置方式为：

<!--配置C3PO的连接池对象-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
	<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/an?characterEncoding=UTF-8&amp;serverTimezone=UTC&amp;useSSL=false"/>
	<property name="user" value="root"/>
	<property name="password" value="root"/>
</bean>
<!--配置Spring的JDBC模板-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"/>
</bean>

test测试类的使用方法其实是一样的：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class test {
    @Resource(name="jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    
    @Test
    public void test2(){
        jdbcTemplate.update("insert into user values (null,?,?)","kk3","asd4");
    }
}

---

引入外部配置文件

由于在实际开发中，applicationContext.xml配置文件中需要配置非常多的东西，所以对于连接池对象的连接参数定义就没有必要放置在配置文件中。

一般是建立一个jdbc.properties 文件，用于存放jdbc连接所需要的参数，再将这个文件引入到配置文件中使用即可。

jdbc.properties：

#定义连接参数
jdbc.driverClass=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/an?characterEncoding=UTF-8&;serverTimezone=UTC&useSSL=false
jdbc.username=root      
jdbc.password=root

在xml配置文件中引入这个属性配置文件，一般使用context标签的引入方式：

<!--引入属性文件-->
<!--第一种方式，通过bean标签的形式引入,少用-->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	<property name="location" value="classpath:jdbc.properties"/>
</bean>

<!--第二种方式，通过context标签引入，常用-->
<context:property-placeholder location="classpath:jdbc.properties"/>

引入属性配置文件后，在配置文件中，通过Spring的固定表达式${ }来获取属性配置文件中的值。

<!--配置C3PO的连接池对象-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="${jdbc.driverClass}"/>
	<property name="jdbcUrl" value="${jdbc.url}"/>
	<property name="user" value="${jdbc.username}"/>
	<property name="password" value="${jdbc.password}"/>
</bean>

Spring JDBC 模板的增删改查

在配置好了上面的连接池，测试环境以后，可以使用Spring框架本身自带的JDBC模板功能，来进行对数据库的增删改操作。

不过还需要在xml配置文件中将JDBC模板类托管给Spring：

<!--配置Spring的JDBC模板-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"/>
</bean>

配置好bean标签以后就可以使用了：

增删改：（update）

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class test {
 @Resource(name="jdbcTemplate")
 private JdbcTemplate jdbcTemplate;
 
	@Test
	public void test2(){
	    //增加操作
	    jdbcTemplate.update("insert into user values (null,?,?)","kk3","asd4");
	
	    //删除操作
	    jdbcTemplate.update("delete  from user where identity = ?",2);
	
	    //修改操作
	    jdbcTemplate.update("update user set user=? ,password=?","aa","bb3");
	}
}

查询操作：（queryForObject）

• 查询单个值：

//看查询的返回值，如果是一个值的话，可以使用第二个参数来创建一个接收类型，String，long等等
String user = jdbcTemplate.queryForObject("select user from user where id = ?", String.class, 2);
System.out.println(user);

• 查询一条记录，封装到一个对象中：

先创建一个实体类userDomain，用来承载对象

public class userDomain {
    private String user;
    private String password;

    @Override
    public String toString() {
        return "userDomain{" +
                "user='" + user + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

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

还需要创建一个类MyRowMapper，并且要实现RowMapper< T>的接口，到时候用于封装返回的值，类似于DButils的BeanHandler类封装返回值一样。

MyRowMapper：（queryForObject）

//创建一个类，继承RowMapper，并且指定封装返回值的对象类型
class MyRowMapper implements RowMapper<userDomain>{
    @Override
    public userDomain mapRow(ResultSet resultSet, int i) throws SQLException {
        userDomain user = new userDomain();
        user.setUser(resultSet.getString("user"));
        user.setPassword(resultSet.getString("password"));
        return user;
    }
}

最后是使用JDBC模板方式的查询：

public void test2(){
    //查询一条记录，封装到一个对象
    //使用我们自己创建并继承RowMapper<T>接口的类，来封装返回值到一个指定对象中
    userDomain user1 = jdbcTemplate.queryForObject("select * from user where id = ?",new MyRowMapper(),2);
    System.out.println(user1);
}

• 查询多条记录：（query）

查询多条记录跟上面的封装到对象的情况类似，只不过返回值为一个对象的集合，也就是返回一个List集合

同样还是使用MyRowMapper类封装对象，再将其存放到List集合中。

 //查询多条记录，返回值为List集合
 List<userDomain> list = jdbcTemplate.query("select * from user", new MyRowMapper());
 for (userDomain user:list) {
     System.out.println(user);
 }