JDBCTemplate使用步骤

Spring JDBC

• Spring 框架对 JDBC 进行了简单的封装，提供了一个 JDBCTemplate 对象简化 JDBC 的开发

使用步骤

1. 使用 maven 创建一个Java项目，导入所需要的依赖。

      <dependencies>
           <!-- JDBCTemplate所需依赖-->
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-jdbc</artifactId>
               <version>5.3.14</version> <!-- 替换为你需要的版本号 -->
           </dependency>
           <!-- MySQL数据库连接驱动 -->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>8.0.27</version> <!-- 替换为你需要的版本号 -->
           </dependency>
           <!-- Druid 数据库连接池 -->
           <dependency>
               <groupId>com.alibaba</groupId>
               <artifactId>druid</artifactId>
               <version>1.2.6</version> <!-- 替换为你需要的版本号 -->
           </dependency>
           <!-- 测试依赖-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.13.2</version> <!-- 替换为你需要的版本号 -->
               <scope>compile</scope>
           </dependency>
       </dependencies>
   

2. 创建工具类，使用 Druid 连接池。

   import com.alibaba.druid.pool.DruidDataSourceFactory;
   
   import javax.sql.DataSource;
   import java.io.InputStream;
   import java.sql.Connection;
   import java.sql.SQLException;
   import java.util.Properties;
   // 工具类
   public class JdbcUtils {
       private static DataSource dataSource;
   
       static {
           try {
               // 加载配置文件
               Properties properties = new Properties();
               InputStream inputStream = JdbcUtils.class.getClassLoader().getResourceAsStream("druid.properties");
               properties.load(inputStream);
               // 创建数据源
               dataSource = DruidDataSourceFactory.createDataSource(properties);
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   
       // 获取数据库连接
       public static Connection getConnection() throws SQLException {
           System.out.println(dataSource);
           return dataSource.getConnection();
       }
   
       // 释放资源
       public static void close(Connection conn) {
           if (conn != null) {
               try {
                   conn.close();
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
       }
   
       // 获取数据库连接池对象
       public static DataSource getDataSource(){
           return dataSource;
       }
   }
   

3. 在【src-main-resources】下边创建文件 【druid.properties】（更换自己的数据库用户名和密码）

   url = jdbc:mysql://localhost:3306/test
   username = root
   password = root
   

4. 创建实体类，封装由数据库查询到的数据

   public class Account {
       private int id;
       private String name;
       private double balance;
   
       public Account() {
       }
   
       public Account(int id, String name, double balance) {
           this.id = id;
           this.name = name;
           this.balance = balance;
       }
   
       public int getId() {
           return id;
       }
   
       public void setId(int id) {
           this.id = id;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public double getBalance() {
           return balance;
       }
   
       public void setBalance(double balance) {
           this.balance = balance;
       }
   
       @Override
       public String toString() {
           return "Account{" +
                   "id=" + id +
                   ", name='" + name + '\'' +
                   ", balance=" + balance +
                   '}';
       }
   }
   

5. 在【src-main-java】下边创建类 Test，几种使用方法（可以看的时候参考下下边的方法介绍）

   import org.springframework.jdbc.core.BeanPropertyRowMapper;
   import org.springframework.jdbc.core.JdbcTemplate;
   import java.util.List;
   import java.util.Map;
   import java.util.Set;
   
   
   public class Test {
   
       private JdbcTemplate template;
   
       {
           // 创建 JdbcTemplate 对象，依赖于数据源
           template = new JdbcTemplate(JdbcUtils.getDataSource());
       }
   
       @org.junit.Test
       public void test1(){
           // 调用 JdbcTemplate 完成 增删改操作
           String sql = "UPDATE account SET balance = 1000 WHERE id = ?";
           int i = template.update(sql,2);
           System.out.println(i);
       }
   
       /*查询的结果集只能有一行，多行报错，可删除条件试试*/
       @org.junit.Test
       public void test2(){
           // 定义查询语句
           String sql = "SELECT * FROM account WHERE id = ?";
           // 将结果封装为 Map 集合
           Map<String, Object> map = template.queryForMap(sql , 2);
           // 遍历集合
           Set<String> keySet = map.keySet();
           for (String key : keySet) {
               Object obj = map.get(key);
               System.out.println(key + "--" + obj);
           }
       }
   
       /*查询的结果可以多行，将每一行封装成一个 map 集合，再将多行 map 封装成一个 list 集合*/
       @org.junit.Test
       public void test3(){
           // 定义查询语句
           String sql = "SELECT * FROM account";
           // 将结果封装成 List 集合
           List<Map<String, Object>> maps = template.queryForList(sql);
           // 遍历集合
           for (Map<String, Object> map : maps) {
               System.out.println(map);
           }
       }
   
       /*查询的结果，由数据库封装到实体类中，然后 从实体类中遍历得到所有结果*/
       @org.junit.Test
       public void test4(){
           // 定义查询语句
           String sql = "SELECT * FROM account";
           // 完成数据到 JavaBean 的自动封装
           BeanPropertyRowMapper<Account> bean = new BeanPropertyRowMapper<>(Account.class);
           List<Account> list = template.query(sql, bean);
           for (Account l : list) {
               System.out.println(l);
           }
       }
   }
   

---

JDBCTemplate方法介绍

方法	作用	注意事项
update()	执行DML语句，增删改
queryForMap()	查询结果封装为map集合	查询的结果长度只能是1，只能查1行数据
queryForList()	查询结果封装为list集合	将每一行记录封装成一个 map 集合，再将 map 集合封装到 list 集合中
queryForObject()	查询结果封装为对象	一般用于聚合函数的查询
query()	查询结果封装为 Javabean 对象	使用 BeanPropertyRowMapper 实现类，完成数据到JavaBean 的自动分装 格式：new BeanPropertyRowMapper<类型>(类型.class)

注意：类型指的是，Java中的实体类，依照表格字段我们创建的类