Spring学习笔记之jdbctemplate操作_jdbctemplate es-优快云博客

本文链接：https://blog.youkuaiyun.com/u013393958/article/details/79763587

一、Spring对不同持久化技术的支持

1.Spring框架为一站式框架，针对每一层都有解决技术，在Dao层，使用jdbcTemplate

2.对ORM持久化技术的模板类

ORM持久化技术	模板类
JDBC	org.springframework.jdbc.core.JdbcTemplate
Hibernate	org.springframework.orm.hibernate5.HibernateTemplate
IBatis(MyBatis)	org.springframework.orm.ibatis.SqlMapClientTemplate
JPA	org.springframework.orm.jpa.JpaTemplate

二、jdbcTemplate实现CRUD操作

1.增加操作

（1）导入jdbcTemplate的jar包以及数据库驱动jar包

spring-jdbc-5.0.4.RELEASE.jar
spring-tx-5.0.4.RELEASE.jar
mysql-connector-java-5.1.44-bin.jar

（2）创建对象，设置数据库信息
（3）创建jdbcTemplate对象，设置数据源
（4）调用jdbcTemplate对象里面的方法实现操作
代码示例：

package com.jxs.jdbcTemplate;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**
 * Created by jiangxs on 2018/3/29.
 */
public class jdbcTemplateDemo {

    @Test
    public void add() {

        //设置数据库信息
        // JDBC模板依赖连接池获得数据库连接，所以必须先构造连接池
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

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

        // 调用jdbcTemplate对象里面的方法实现操作
        //创建sql语句
        String sql = "insert into girl(user_name,sex,age,mobile,email) values(?,?,?,?,?)";
        int row = jdbcTemplate.update(sql, "sbjmf", 1, 12, "15065655656", "hdjshd@yeah.net");
        System.out.println(row);

    }
}

2.删除操作

public class jdbcTemplateDemo {

    //删除数据
    @Test
    public void delete() {

        // 设置数据库信息
        // JDBC模板依赖连接池获得数据库的连接，所以必须先构造连接池
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

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

        // 调用jdbcTemplate对象中的方法实现操作
        // 创建sql语句
        String sql = "delete from girl where user_name=?";
        int row = jdbcTemplate.update(sql, "sbjmf");
        System.out.println(row);
    }
}

3.修改操作

public class jdbcTemplateDemo {
    // 修改数据
    @Test
    public void update() {

        // 设置数据库的信息
        // JDBC依靠连接池获得数据库连接，所以必须先构造连接池
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

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

        // 调用jdbcTemplate对象中的方法实现操作
        // 创建sql语句
        String sql = "update girl set mobile=?,email=? where user_name=?";
        int row = jdbcTemplate.update(sql, "13223232233", "dddd@163.com", "sbjmf");
        System.out.println(row);
    }
}

4.查询具体实现

（1）查询返回某一个值

public class jdbcTemplateDemo {
/**
     * 使用DBUtils时候，有接口ResultSetHandler,DBUtils提供了针对不同的结果实现类
     * QueryRunner runner = new QueryRunner(datasource);
     * // 返回对象
     * runner.query(sql,new BeanHandler<User>(User.class));
     * // 返回list集合
     * runner.query(sql,new BeanListHander<User>(User.class));
     * <p>
     * 使用jdbcTemplate实现查询，有接口RowMapper,
     * jdbcTemplate针对这个接口没有提供实现类，得到不同的类型数据需要自己进行数据封装
     */

    // 查询有多少条记录
    @Test
    public void queryCount() {

        // 设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

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

        // 调用jdbcTemplate对象中的方法实现操作
        // 创建sql语句
        String sql = "select count(*) from girl";
        int row = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(row);
    }
}

（2）查询返回对象
这个功能是对原生的JDBC做的封装，首先先看看原生JDBC如何对返回一个对象：
Girl.java

package com.jxs.jdbcTemplate;

import java.util.Date;

/**
 * Created by jiangxs on 2018/3/29.
 */
public class Girl {

    private Integer id;
    private String userName;
    private Integer sex;
    private Integer age;
    private Date birthday;
    private String mobile;
    private String email;
    private String createUser;
    private Date createDate;
    private String updateUser;
    private Date updateDate;
    private Integer isdel;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getCreateUser() {
        return createUser;
    }

    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public String getUpdateUser() {
        return updateUser;
    }

    public void setUpdateUser(String updateUser) {
        this.updateUser = updateUser;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }

    public Integer getIsdel() {
        return isdel;
    }

    public void setIsdel(Integer isdel) {
        this.isdel = isdel;
    }

    @Override
    public String toString() {
        return "Girl{" +
                "userName='" + userName + '\'' +
                ", mobile='" + mobile + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

package com.jxs.jdbcTemplate;

import org.junit.Test;

import java.sql.*;

/**
 * Created by jiangxs on 2018/3/29.
 */
public class jdbcTemplateDemo2 {

    private static final String URL = "jdbc:mysql://127.0.0.1:3306/mydb2";
    private static final String USERNAME = "root";
    private static final String PASSWOERD = "root";

    @Test
    public void testJdbc() {


        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        Girl girl = null;

        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 创建连接
            connection = DriverManager.getConnection(URL, USERNAME, PASSWOERD);
            // 编写SQL语句
            String sql = "select * from girl where id=?";
            // 预编译sql
            ps = connection.prepareStatement(sql);
            // 测试参数值
            ps.setInt(1,1);
            // 执行sql
            resultSet = ps.executeQuery();
            // 遍历结果集
            while (resultSet.next()) {

                girl = new Girl();
                String userName = resultSet.getString("user_name");
                String mobile = resultSet.getString("mobile");
                girl.setUserName(userName);
                girl.setMobile(mobile);
            }
            System.out.println(girl);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("查询数据库出错！");
        } finally {
            try {
                connection.close();
                ps.close();
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
                System.out.println("关闭数据库失败！");
            }
        }
    }
}

查询返回对象需要使用方法：

queryForObject(String sql,Rowmapper<T> rowMapper,Object... args):T

第一个参数是sql语句
第二个参数是RowMapper,是接口，类似于dbutils中BeanHandler接口
第三个参数是可变参数，值为sql语句中需要输入的值
该方法相当于将原生的代码工作到了遍历结果集处，而实现RowMapper接口的过程实际上是去参数和设置参数的过程，也就是相当于原生代码的遍历结果集并取参合设置参数的过程。
代码示例：

import org.springframework.lang.Nullable;

import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * Created by jiangxs on 2018/3/29.
 */
public class jdbcTemplateDemo {

    private static final String URL = "jdbc:mysql://127.0.0.1:3306/mydb2";
    private static final String USERNAME = "root";
    private static final String PASSWOERD = "root";

    @Test
    // 查询返回对象
    public void queryObject() {

        // 设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl(URL);
        dataSource.setUsername(USERNAME);
        dataSource.setPassword(PASSWOERD);

        // 创建jdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 构造sql语句，根据user_name进行查询
        String sql = "select * from girl where user_name=?";

        // 第二个参数是接口RowMapper,需要自己写实现接口，自己做数据封装
        Girl girl = jdbcTemplate.queryForObject(sql, new RowMapper<Girl>() {

            @Nullable
            @Override
            public Girl mapRow(ResultSet resultSet, int i) throws SQLException {

                // 从结果集中获取数据
                String userName = resultSet.getString("user_name");
                String mobile = resultSet.getString("mobile");
                String email = resultSet.getString("email");

                // 把得到的数据封装到对象中
                Girl girl = new Girl();
                girl.setUserName(userName);
                girl.setMobile(mobile);
                girl.setEmail(email);
                return girl;
            }
        },"酱萌烦");

        // 将得到的对象进行打印
        System.out.println(girl);
    }
}

（3）查询返回list集合
第一个参数是sql语句
第二个参数是RowMapper,是接口（需要自己实现），类似于dbutils中BeanListHander接口
第三个参数是可变参数，值为sql语句中需要输入的值
查询返回对象需要使用方法：

queryForObject(String sql,Rowmapper<T> rowMapper,Object... args):List<T>

代码示例：

package com.jxs.jdbcTemplate;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.lang.Nullable;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

/**
 * Created by jiangxs on 2018/3/29.
 */
public class jdbcTemplateDemo {

    private static final String URL = "jdbc:mysql://127.0.0.1:3306/mydb2";
    private static final String USERNAME = "root";
    private static final String PASSWOERD = "root";
    // 查询返回集合
    @Test
    public void queryList() {

        // 设置数据库信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl(URL);
        dataSource.setUsername(USERNAME);
        dataSource.setPassword(PASSWOERD);

        // 创建jdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 构造sql语句，查询数据库中所有对象
        String sql = "select * from girl";
        List<Girl> girls = jdbcTemplate.query(sql, new RowMapper<Girl>() {

            @Nullable
            @Override
            public Girl mapRow(ResultSet resultSet, int i) throws SQLException {

                // 从结果集中获取数据
                String userName = resultSet.getString("user_name");
                String mobile = resultSet.getString("mobile");
                String email = resultSet.getString("email");

                // 将得到的数据封装到对象中去
                Girl girl = new Girl();
                girl.setUserName(userName);
                girl.setMobile(mobile);
                girl.setEmail(email);

                return girl;
            }
        });

        System.out.println(girls);
    }
}

三、Spring配置连接池和Dao使用jdbcTemplate

1.导入jar包

需导入下面的jar包：

c3p0-0.9.5.2-sources.jar
mchange-commons-java-0.2.15.jar

附：
mchange-commons-java的jar包下载地址：
http://mvnrepository.com/artifact/com.mchange/mchange-commons-java
c3p0-0.9.5.2-sources的jar包下载地址：
https://sourceforge.net/projects/c3p0/?source=typ_redirect

2.Dao使用jdbcTemplate

原始方式的做法：

    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass("com.mysql.jdbc.Driver");
    dataSource.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/mydb2");
    dataSource.setUser("root");
    dataSource.setPassword("root");

使用xml配置文件代替上面的操作：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

    <!-- 注入属性值 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/mydb2"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>

    </bean>

</beans>

2.dao使用jdbcTemplate

（1）创建GirlService和GirlDao，配置girlService和girlDao对象，在girlService中注入girlDao对象。
（2）创建jdbcTemplate对象，把模板对象注入到girlDao中
（3）将dataSource对方放入jdbcTemplate中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置c3p0连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

        <!-- 注入属性值 -->
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/mydb2"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>

    </bean>

    <!-- 创建UserDao对象 -->
    <bean id="girlDao" class="com.jxs.c3p0.GirlDao">
        <!-- 注入jdbcTemplate对象 -->
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
    <!-- 创建GirlSerive对象 -->
    <bean id="girlService" class="com.jxs.c3p0.GirlService">
        <!-- 注入userDao对象 -->
        <property name="girlDao" ref="girlDao"></property>
    </bean>
    <!-- 创建jdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 把dataSource传入到jdbcTemplate对象中 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

GirlDao.java

package com.jxs.c3p0;

import org.springframework.jdbc.core.JdbcTemplate;

/**
 * Created by jiangxs on 2018/3/30.
 */
public class GirlDao {

    // 得到jdbcTemplate对象
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

        this.jdbcTemplate = jdbcTemplate;
    }

    // 添加操作
    public void add() {

        String sql = "insert into girl(" +
                " user_name,mobile,email)" +
                " values(" +
                "?,?,?)";
        jdbcTemplate.update(sql, "xiha", "13020202020", "xiha@mail.com");

    }
}

GirlService.java

package com.jxs.c3p0;

/**
 * Created by jiangxs on 2018/3/30.
 */
public class GirlService {

    private GirlDao girlDao;

    public void setGirlDao(GirlDao girlDao) {

        this.girlDao = girlDao;
    }

    public void add() {

        girlDao.add();
    }
}

测试代码：

package com.jxs.c3p0;

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

/**
 * Created by jiangxs on 2018/3/30.
 */
public class TestService {

    @Test
    public void testGirlService() {

        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");
        GirlService service = (GirlService) context.getBean("girlService");
        service.add();
    }
}