前言
所谓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层就搞完了，怎么样，是不是很简单？