spring 学习（四）: spring 的 jdbcTemplate 操作

spring 学习（四）: spring 的 jdbcTemplate 操作

spring 针对 javaee 的每一层，都提供了相应的解决技术，jdbcTemplate 的主要操作在 dao 层。

下面我们来使用 jdbcTemplate 对数据库进行 crud 操作。

准备工作

1 我们首先来导入 jar 包，还是相似的使用 maven 来导入，修改配置文件，需要导入 jar 包的配置：

		<!-- jdbcTemplate 使用的 jar 包 -->
		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
		<!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.12</version>
        </dependency>

2 创建对象，设置数据库信息。这里以我自己的为例：

DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///sampledb");
        dataSource.setUsername("root");
        dataSource.setPassword("");

3 创建 jdbcTemplate 对象，设置数据源：

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

4 调用 jdbcTemplate 对象里面的方法来实现curd 操作。

下面就分别来讲下 jdbcTemplate 的 curd 操作。

首先先创建一个数据库命名为 sampledb， 在数据库中新增一个表。添加几条记录，如下：

增加

//1.添加操作
    @Test
    public void add(){
        //设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///sampledb");
        dataSource.setUsername("root");
        dataSource.setPassword("");

        //创建jdbcTemplate对象,设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        //调用jdbcTemplate对象里面的方法实现操作
        //创建sql 语句
        String sql = "insert into user values(?,?)";
        int rows = jdbcTemplate.update(sql, "lucy", "250");
        System.out.println(rows);
    }

修改

//2.修改操作
    @Test
    public void update(){
        //设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///sampledb");
        dataSource.setUsername("root");
        dataSource.setPassword("");

        //创建jdbcTemplate对象,设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        //调用jdbcTemplate对象里面的方法实现操作
        //创建sql 语句
        String sql = "update user set password=? where username=?";
        int rows = jdbcTemplate.update(sql, "1314", "lucy");
        System.out.println(rows);
    }

删除

//3.删除操作
    @Test
    public void delete(){
        //设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///sampledb");
        dataSource.setUsername("root");
        dataSource.setPassword("");

        //创建jdbcTemplate对象,设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        //调用jdbcTemplate对象里面的方法实现操作
        //创建sql 语句
        String sql = "DELETE FROM USER WHERE username=?";
        int rows = jdbcTemplate.update(sql, "lucy");
        System.out.println(rows);
    }

这里的增删改操作都是使用 jdbcTemplate.update() 方法。

查询

查询返回某一个值

使用 queryForObject(String sql, Class<T> requiredType) 方法。

（1）第一个参数是 sql 语句。

（2）第二个参数返回类型的 class。

举个栗子：

//查询操作
    @Test
    public void query(){
        //设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///sampledb");
        dataSource.setUsername("root");
        dataSource.setPassword("");

        //创建jdbcTemplate对象,设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        //调用jdbcTemplate对象里面的方法实现操作
        //查询方法得到记录数
        String sql = "select count(*) from user";
        //调用 jdbcTemplate的方法
        int count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }

将从 user 表中查询所有的记录数量。

jdbc实现

为了方便理解，我们使用 jdbc 来实现查询某个返回对象的操作。

还是举个栗子，查询 user 表下的所有返回对象。

新建 User.java 文件，对数据库中的 username 和 password 实现封装操作：

package cn.itcast.jdbc;

public class User {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

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

    public String getPassword() {
        return password;
    }

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

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

使用 jdbc 实现查询返回 User 对象操作：

 //jdbc 实现代码
    @Test
    public void testJDBC() throws SQLException {
        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;
        //加载驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
            //创建连接
            conn = DriverManager.getConnection("jdbc:mysql:///sampledb", "root" , "");
            //编写 sql 语句
            String sql = "select * from user where username=?";
            //预编译 sql
            psmt = conn.prepareStatement(sql);
            //设置参数值
            psmt.setString(1, "lucy");
            //执行 sql
            rs = psmt.executeQuery();
            //遍历结果集
            while (rs.next()){
                //得到返回值
                String username = rs.getString("username");
                String password = rs.getString("password");
                //放到 user 对象里
                User user = new User();
                user.setUsername(username);
                user.setPassword(password);

                System.out.println(user);
            }
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            rs.close();
            conn.close();
            psmt.close();
        }
    }

使用 jdbcTemplate 实现查询返回对象操作

将使用到 queryForObject(String sql, RowMapper<T> rowMapper, Object... args) 方法。

• 第一个参数是 SQL 语句
• 第二个参数是 RowMapper，是接口，需要自己封装
• 第三一参数是可变参数

还是举个栗子：

//查询返回对象
    @Test
    public void testObject(){
        //设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///sampledb");
        dataSource.setUsername("root");
        dataSource.setPassword("");

        //创建jdbcTemplate对象,设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        //写 SQL 语句,根据 username 查询
        String sql = "select * from user where username=?";
        //调用 jdbcTemplate的方法实现
        //第二个参数是接口 rowMapper, 需要自己写类实现接口,自己做数据封装
        User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "lucy");
        System.out.println(user);
    }

RowMapper 封装的接口类：

class MyRowMapper implements RowMapper<User> {

    @Override
    public User mapRow(ResultSet rs, int num) throws SQLException {
        //1 从结果集里面把数据得到
        String username = rs.getString("username");
        String password = rs.getString("password");

        //2 把得到数据封装到对象里面
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);

        return user;
    }
}

查询返回列表

使用 query(String sql, RowMapper<T> rowMapper, Object... args):List<T> 方法。

• 第一个参数：SQL 语句
• 第二个参数：RowMapper 接口，自己写类实现数据封装
• 第三个参数：可变参数

举个栗子：

  //查阅返回列表
    @Test
    public void testList(){
        //设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///sampledb");
        dataSource.setUsername("root");
        dataSource.setPassword("");

        //创建jdbcTemplate对象,设置数据源
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        //写 SQL 语句,根据 username 查询
        String sql = "select * from user";
        //调用 jdbcTemplate的方法实现
        //第二个参数是接口 rowMapper, 需要自己写类实现接口,自己做数据封装
        List<User> list = jdbcTemplate.query(sql, new MyRowMapper());
        System.out.println(list);
    }
}

spring 配置连接池和 dao 层使用 jdbcTemplate

上述的方法虽然能实现数据库的 crud 操作，但未免太过繁琐，我们更希望能以更简单的方式来实现数据的 crud 操作，spring 为我们提供了通过配置 xml 文件的方式来实现上述操作。

spring 配置 c3p0连接池

首先我们导入相应的 jar 包，还是相似的，利用 maven 来导入：

        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>mchange-commons-java</artifactId>
            <version>0.2.15</version>
        </dependency>

然后创建 spring 配置文件，配置连接池：

<!-- 配置c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 注入属性值 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///sampledb"></property>
        <property name="user" value="root"></property>
        <property name="password" value=""></property>
    </bean>

dao 使用 jdbctemplate

（1）创建 UserDao.java 和 UserService.java 文件

UserDao.java:

package cn.itcast.c3p0;

import org.springframework.jdbc.core.JdbcTemplate;

public class UserDao {

    //得到 jdbcTemplate 对象
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void add(){
        String sql = "insert into user values(?,?)";
        jdbcTemplate.update(sql, "李雷", "520");
    }
}

UserService.java:

package cn.itcast.c3p0;

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        userDao.add();
    }
}

（2）将代码放在配置文件中进行配置：

 <!-- 创建 jdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 把 dataSource 传递到模板对象里面 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 创建service 和 dao 对象,在 service 注入 dao 对象 -->
    <bean id="userDao" class="cn.itcast.c3p0.UserDao">
        <!-- 注入 jdbcTemplate对象 -->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <bean id="userService" class="cn.itcast.c3p0.UserService">
        <!-- 注入 dao 对象 -->
        <property name="userDao" ref="userDao"></property>
    </bean>

（3）创建测试文件 TestService.java：

package cn.itcast.c3p0;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestService {
    @Test
    public void testDemo(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService service = (UserService) context.getBean("userService");
        service.add();
    }
}

运行测试文件，我们在数据库中查看结果：

可以看到成功插入了"李雷"这条记录。