1.Spring提供的一个操作数据库的技术JdbcTemplate，是对Jdbc的封装。语法风格非常接近DBUtils。

JdbcTemplate可以直接操作数据库，加快效率，而且学这个JdbcTemplate也是为声明式事务做准备，毕竟要对数据库中的数据进行操纵！

JdbcTemplate中并没有提供一级缓存，以及类与类之间的关联关系！就像是spring提供的一个DBUtils。

Spring对数据库的操作使用JdbcTemplate来封装JDBC，结合Spring的注入特性可以很方便的实现对数据库的访问操作。使用JdbcTemplate可以像JDBC一样来编写数据库的操作代码

2.为啥要使用Jdbc_template进行开发呢？

Spring对数据库的操作在jdbc上面做了深层次的封装，使用spring的注入功能，可以把DataSource注册到JdbcTemplate之中。

Spring提供的JdbcTemplate对jdbc做了封装，大大简化了数据库的操作。找到Spring JdbcTemplate源码，可以看到如下方法：

Connection con = DataSourceUtils.getConnection(getDataSource());

如果直接使用JDBC的话，需要我们加载数据库驱动、创建连接、释放连接、异常处理等一系列的动作；繁琐且代码看起来不直观。

此外，Spring提供的JdbcTempate能直接数据对象映射成实体类，不再需要获取ResultSet去获取值/赋值等操作，提高开发效率；

如下：return (User) jdbcTemplate.queryForObject("select * from tb_test1 where id = 100", User.class)

3.配置环境

①导入jar包

[1]IOC容器需要的jar包

commons-logging-1.1.3.jar

spring-aop-4.0.0.RELEASE.jar //注解会使用到的包

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

[2]MySQL驱动、C3P0jar包

c3p0-0.9.1.2.jar

mysql-connector-java-5.1.37-bin.jar

[3]JdbcTemplate需要的jar包

spring-jdbc-4.0.0.RELEASE.jar

spring-orm-4.0.0.RELEASE.jar

spring-tx-4.0.0.RELEASE.jar

②在IOC容器中配置数据源

1 
     2 
     3 
     4 
     
      5 　　
      6 　　
      7 　　
      8 　　
      9 
     

其中jdbc.properties文件内容：

jdbc.user=root

jdbc.passowrd=123456

jdbc.url=jdbc:mysql://localhost:3306/test

jdbc.driver=com.mysql.jdbc.Driver

③在IOC容器中配置JdbcTemplate对象的bean，并将数据源对象装配到JdbcTemplate对象中.

参照文档:实验_JDBCTemplate.txt逐一进行试验！

当然为了进行试验，我们首先需要导入实验 JDBCTemplate.sql语句，然后才能试验！

将数据库连接信息改为：jdbc.url=jdbc:mysql://localhost:3306/jdbc_template

1 
     2 
     
      3 　　
      4 
     

实验：【参照文档:实验_JDBCTemplate.txt逐一进行试验！】

实验1：测试数据源

1 @Test2 public void test() throws SQLException {3 　　ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");4 　　DataSource bean = ioc.getBean(DataSource.class);5 　　System.out.println(bean.getConnection());6 }

实验2：将emp_id=5的记录的salary字段更新为1300.00【更新操作】

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private JdbcTemplate template=ioc.getBean(JdbcTemplate.class); 4  5 　　@Test 6 　　public void test01(){ 7 　　　　//实验2：将emp_id=5的记录的salary字段更新为1300.00 8 　　　　String sql = "UPDATE employee SET salary = ? WHERE emp_id = ?"; 9 　　　　template.update(sql, 1300,5);//第一个是sql语句，后面的按着顺序传入参数即可，这个update方法是接收的可变参数！10 　　}11 }

从上述实验中就可以看到，该操作不用我们自己再去获取数据库连接信息了，而是直接传递sql语句及其参数！

实验3：批量插入

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private JdbcTemplate template=ioc.getBean(JdbcTemplate.class); 4 　　@Test 5 　　public void testBatch(){ 6　　　　 String sql="INSERT INTO employee(`emp_name`,`salary`) VALUES(?,?)"; 7 　　　　//执行sql语句需要传递的参数 8 //     Object[][] params = new Object[3][2]; 9 //     params[0] = new Object[]{"Tom2015",1000};10 //     params[1] = new Object[]{"Tom2016",2000};11 //     params[2] = new Object[]{"Tom2017",3000};12 //    13 　　　　List
     
       list = new ArrayList
      
       ();14 　　　　list.add(new Object[]{
   "Tom2015",1000});15 　　　　list.add(new Object[]{
   "Tom2016",2000});16　　　　 list.add(new Object[]{
   "Tom2017",3000});17 18 　　　　template.batchUpdate(sql, list);19 　　}20 }
      
     

实验4：查询emp_id=5的数据库记录，封装为一个Java对象返回

分析：封装为一个对象返回的话，首先我们需要有一个与数据表对应的实体类！

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private JdbcTemplate template=ioc.getBean(JdbcTemplate.class); 4  5 　　@Test 6 　　public void test01(){ 7　　　　 //需要注意的是：sql语句中的别名要与对应实体类的属性名保持一致！ 8 　　　　String sql = "SELECT emp_id AS empId,emp_name AS empName,salary FROM employee WHERE emp_id=?"; 9 10 　　　　//RowMapper是一个接口,这里我们使用其子类11 　　　　RowMapper
     
       rowMapper = new BeanPropertyRowMapper
      
       (Employee.class);12 　　　　//最后一个参数是可变参数，用于向sql语句中依次传递参数!13 　　　　Employee employee = template.queryForObject(sql, rowMapper, 5);14 　　　　System.out.println(employee);15 　　}16 }
      
     

实验5：查询salary>4000的数据库记录，封装为List集合返回

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private JdbcTemplate template=ioc.getBean(JdbcTemplate.class); 4  5 　　@Test 6 　　public void test01(){ 7 　　　　//需要注意的是：sql语句中的别名要与对应实体类的属性名保持一致！ 8 　　　　String sql = "SELECT emp_id AS empId,emp_name AS empName,salary FROM employee WHERE salary > ?"; 9 10 　　　　//RowMapper是一个接口,这里我们使用其子类11 　　　　RowMapper
     
       rowMapper = new BeanPropertyRowMapper
      
       (Employee.class);12 　　　　//该query方法查询出来的是一个list列表,query方法的最后一个参数是可变参数！13 　　　　List
       
         list = template.query(sql, rowMapper, 4000);14 15 　　　　for (Employee employee : list) {16 　　　　　　System.out.println(employee);17 　　　　}18 　　}19 }
       
      
     

从上面可以看出，查询结果是一个实体还是一个list列表是靠template对象的不同方法实现的！

实验6：查询最大salary

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private JdbcTemplate template=ioc.getBean(JdbcTemplate.class); 4  5 　　@Test 6 　　public void test01(){ 7 　　　　String sql = "SELECT MAX(salary) FROM employee"; 8 　　　　//需要指定返回值的类型,而且类型必须是包装类型 9 　　　　Double maxSalary = template.queryForObject(sql, Double.class);10 　　　　System.out.println(maxSalary);11 　　}12 }

实验7：使用带有具名参数的SQL语句插入一条员工记录，并以Map形式传入参数值

具名参数:是指基于名称的，前面我们使用的都是用?作为占位符，然后是使用基于位置的！

如果要使用具名参数的sql语句就必须在spring配置文件中配置NamedParameterJdbcTemplat这个模板类，而不能使用

原来的JdbcTemplate，因为JdbcTemplate不能完成这样的任务！

1 
      2 
      3 
      4 
     
       5 　　
       6 　　
       7 　　
       8 　　
       9 
     10 11 
     12 
     
      13 　　
      14 
     15 
     16 
     17 
     
      18 　　
      19 　　
      20 
     

 

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class); 4  5　　 @Test 6 　　public void test01(){ 7 　　　　String sql="INSERT INTO employee(`emp_name`,`salary`) VALUES(:paramName,:paramSalary)"; 8 　　　　Map
     
       paramMap = new HashMap
      
       (); 9 　　　　paramMap.put("paramName","张学友" );10 　　　　paramMap.put("paramSalary",1000);11 12 　　　　namedJdbcTemplate.update(sql, paramMap);13 　　}14 }
      
     

实验8：重复实验7，以SqlParameterSource形式传入参数值

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class); 4  5 　　@Test 6 　　public void test01(){ 7 　　　　String sql="INSERT INTO employee(`emp_name`,`salary`) VALUES(:empName,:salary)"; 8 　　　　//该BeanPropertySqlParameterSource类构造器需要一个对象参数，该对象参数是一个封装了sql语句参数的对象！ 9 　　　　//此时要求对象的属性名要和sql中的参数名保持一致！这里我们使用Employee对象来完成10 　　　　Employee employee= new Employee(null, "郭富城", 1500);11 　　　　//以实体对象的形式封装具名参数和值12 　　　　SqlParameterSource source = new BeanPropertySqlParameterSource(employee);13 14 　　　　namedJdbcTemplate.update(sql, source);15 　　}16 }

 

实验9：创建JdbcTemplateDao，自动装配JdbcTemplate对象

1.创建dao类：

1 @Repository2 public class JdbcTemplateDao {3 　　@Autowired4 　　private JdbcTemplate jdbcTemplate;5 6 　　public void update(String sql,Object ...args){7 　　　　jdbcTemplate.update(sql, args);8 　　}9 }

2.配置spring的配置文件

1 
      2 
      3 
      4 
      5 
      6 
     
       7 　　
       8 　　
       9 　　
      10 　　
      11 
     12 13 
     14 
     
      15 　　
      16 
     

3.测试该dao

1 public class TestDataSource { 2 　　private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml"); 3 　　private NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class); 4  5 　　@Test 6 　　public void test01(){ 7 　　　　JdbcTemplateDao dao = ioc.getBean(JdbcTemplateDao.class); 8 　　　　String sql = "INSERT INTO employee(`emp_name`,`salary`) VALUES(?,?)"; 9 　　　　dao.update(sql, "比尔盖茨",10000000);10 11　　 }12 }