（四）Spring超全面快速入门-Spring JDBC Template

文章目录

• 前言
• 增改
• 删查
• JDBC实例：

前言

所谓JDBC Template就是在尽量保持代码灵活性的前提下，减少代码的书写，之前我们学JDBC的时候，需要连接驱动，创建语句，查询语句，获取查找返回值，设值等等…很不方便。

这两种其实都能达到目的，肯定使用代码少的方法呀。

增改

其实JDBC不过就是增删改查，我们看看JDBC Template帮我们简化了什么操作：
可以增加一条sql语句，可以增加多条sql语句：
增加或者说创建有两种方法，一种叫execute，但是它一般是用来创建表的，但是你想让他执行插入语句也可以，但是它底层是Statement实现的，所以并不能设置占位符，而真正适合执行插入语句的应该使用update方法，这个方法底层是PreparedStatement实现的，所以可以实现占位符插入，非常适合EE开发，我们简单介绍一下使用方法：
第一步：
配置applicationContext.xml:

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/selection_course?serverTimezone=GMT%2B8"/>
        <property name="username" value="root"/>
        <property name="password" value="12345678"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

非常简单，这样就把jdbcTemplate注册到bean当中了，然后我们通过注解调用它：
还是先获得Bean对象：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
JdbcTemplate jt = (JdbcTemplate)applicationContext.getBean("jdbcTemplate");

这样就获得了JdbcTemplate对象
如果我们想要非要使用execute方法：

    public void testInsert() {
        jt.execute("insert into course values (1004,'高等数学',5)");
    }

还有修改操作：

    public void testUpdate2() {
        String sql = "update course set score=? where id = ?";
        jt.update(sql,new Object[]{2,1005});
    }

这样就可以了，如果想要设置占位符的方式：
JdbcTemplate.update(String sql, Object[] obj)

    public void testUpdate() {
        String sql  = "insert into course values (?,?,?)";
        jt.update(sql,new Object[]{1005, "线性代数",3});
    }

当前前面这样的开发方式不如下面这种方式， 不过他们效果是一样的：
public int update(String sql, Object… args)
可以添加任意条占位符：

    public void testUpdate3() {
        String sql = "update course set score = ? where id = ?";
        jt.update(sql,3,1005);
    }

这样比较方便，如果想执行多条语句：
public int[] batchUpdate(final String… sql)

    public void testBatchUpdate() {
        String[] sqls = {
                "insert into student values(1003, '星彩', '女', '1995-06-01')",
                "insert into student values(1004,'貂蝉','女','1996-05-04')",
                "update student set born = '1997-01-12' where id = 1002"
        };
        jt.batchUpdate(sqls);
    }

上面这种插入是针对多种不同的语句的，而且不可以设置占位符，想要设置占位符并且执行批量操作，则不可以执行多条语句：
public int[] batchUpdate(String sql, List<Object[]> batchArgs)

    public void testBatchUpdate2() {
        String sql = "insert into selection(student, course) values(?,?)";
        List<Object[]> list = new LinkedList<>();
        list.add(new Object[]{1001,1003});
        list.add(new Object[]{1002,1001});
        jt.batchUpdate(sql,list);
    }

第一个sql就是表示只能批量操作这一条sql语句，而后面的List数组表示的数要更新的多组数据

删查

想查询怎么办？
public T queryForObject(String sql, Class requiredType)
先看个最简单的查询语句：

    public void testQuery() {
        String sql = "select count(*) from course";
        Integer i = jt.queryForObject(sql, Integer.class);
        System.out.println(i);
    }

第一个参数sql是你要查询的语句，第二个参数是你查询后结果的返回值是啥类型的
查询结果为多条咋办？
public List queryForList(String sql, Class elementType)

    public void testQueryList() {
        String sql = "select name from course where score = 5";
        List<String> list = jt.queryForList(sql, String.class);
        System.out.println(list);
    }

要使用queryForList方法，将结果保存到一个List列表中

怎么能像传统jdbc那样，将查询结果保存到实体类中呢？
public T queryForObject(String sql, RowMapper rowMapper, @Nullable Object… args)
第一个参数还是你要执行查询的sql语句
第二个参数是一个接口，这个接口中有一个方法是mapRow，它的执行操作跟传统jdbc一样，请看下面的例子
第三个参数是不定参数，里面是sql语句中的占位符

    public void testQueryEntity() {
        String sql = "select * from student where id = ?";
        Student o = jt.queryForObject(sql, new StudentRowMapper(), 1001);
        System.out.println(o);
    }
    private class StudentRowMapper implements RowMapper<Student> {

        @Override
        public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
            Student student = new Student();
            student.setId(rs.getInt("id"));
            student.setName(rs.getString("name"));
            student.setSex(rs.getString("sex"));
            student.setBorn(rs.getString("born"));
            return student;
        }
    }

如果想查询多条结果呢？比如select * from xxx;
public List query(String sql, RowMapper rowMapper)

    public void testQueryEntity2() {
        String sql = "select * from student";
        List<Student> list = jt.query(sql,new StudentRowMapper());
        System.out.println(list);
    }

操作比传统jdbc简单吧

JDBC实例：

跟传统开发一样，我们先得搞一个接口：

package com.bean.dao;

import com.bean.pojo.Course;

import java.util.List;

public interface CourseDao {
    void insert(Course course);
    void update(Course course);
    void delete(int id);
    Course search(int id);
    List<Course> selectAll();
}

然后是一个实现类:

package com.bean.dao.impl;

import com.bean.dao.CourseDao;
import com.bean.pojo.Course;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Repository
public class CourseDaoImpl implements CourseDao {

    @Resource(name = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Override
    public void insert(Course course) {
        String sql = "insert into course(id,name,score) values (?,?,?)";
        jdbcTemplate.update(sql,course.getId(),course.getName(),course.getScore());
    }

    @Override
    public void update(Course course) {
        String sql = "update course set name = ?, score = ? where id = ?";
        jdbcTemplate.update(sql,course.getName(), course.getScore(),course.getId());
    }

    @Override
    public void delete(int id) {
        String sql = "delete from course where id = ?";
        jdbcTemplate.update(sql,id);
    }

    @Override
    public Course search(int id) {
        String sql = "select * from course where id = ?";
        Course course = jdbcTemplate.queryForObject(sql, new StudentRowMapper(), id);
        return course;
    }

    @Override
    public List<Course> selectAll() {
        String sql = "select * from course";
        List<Course> query = jdbcTemplate.query(sql, new StudentRowMapper());
        return query;
    }

    private class StudentRowMapper implements RowMapper<Course> {

        @Override
        public Course mapRow(ResultSet rs, int rowNum) throws SQLException {
            Course course = new Course();
            course.setId(rs.getInt("id"));
            course.setName(rs.getString("name"));
            course.setScore(rs.getInt("score"));
            return course;
        }
    }
}

这样Dao层就搞完了，怎么样，是不是很简单？