数据库-连接池和JdbcTemplate-笔记

ゝ一世哀愁。 2021-12-14 04:34 408阅读 0赞

# 连接池和JdbcTemplate #

## 回顾 ##

### 核心API的功能： ###

<table> 
 <thead> 
  <tr> 
   <th><strong>类名</strong></th> 
   <th><strong>作用</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>DriverManager实现类</strong></td> 
   <td>注册驱动,创建连接</td> 
  </tr> 
  <tr> 
   <td><strong>Connection接口</strong></td> 
   <td>表示数据库的连接</td> 
  </tr> 
  <tr> 
   <td><strong>Statement接口</strong></td> 
   <td>执行SQL语句的对象</td> 
  </tr> 
  <tr> 
   <td><strong>ResultSet接口</strong></td> 
   <td>数据库返回的结果集</td> 
  </tr> 
 </tbody> 
</table>

### Connection接口中的方法： ###

<table> 
 <thead> 
  <tr> 
   <th><strong>Connection接口中的方法</strong></th> 
   <th><strong>方法名</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>得到Statement</strong></td> 
   <td>createStatement</td> 
  </tr> 
 </tbody> 
</table>

### Statement接口中的方法： ###

<table> 
 <thead> 
  <tr> 
   <th><strong>Statement接口中的方法</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>int executeUpdate(String sql)</strong></td> 
   <td>更新INSERT UPDATE DELETE, DML</td> 
  </tr> 
  <tr> 
   <td><strong>ResultSet executeQuery(String sql)</strong></td> 
   <td>查询SELECT</td> 
  </tr> 
 </tbody> 
</table>

### ResultSet接口的方法： ###

<table> 
 <thead> 
  <tr> 
   <th><strong>ResultSet接口中的方法</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>boolean next()</strong></td> 
   <td>将游标向下移动,看有下一行数据</td> 
  </tr> 
  <tr> 
   <td><strong>数据类型 getXxx(参数)</strong></td> 
   <td>获取这条记录某个字段的数据</td> 
  </tr> 
 </tbody> 
</table>

## 学习目标 ##

1.  能够通过PreparedStatement完成增、删、改、查
2.  能够完成PreparedStatement改造登录案例
3.  能够理解连接池解决现状问题的原理
4.  能够使用C3P0连接池
5.  能够使用DRUID连接池
6.  能够编写连接池工具类
7.  掌握JdbcTemplate实现增删改
8.  掌握JdbcTemplate实现查询操作

## 1、PreparedSatement预编译对象 ##

### 目标 ###

能够理解什么是SQL注入

能够理解PreparedSatement的执行原理

### 讲解 ###

#### SQL注入问题 ####

sql注入：由于没有对用户输入进行充分检查，而SQL又是拼接而成，在用户输入参数时，在参数中添加一些SQL 关键字，达到改变SQL运行结果的目的，也可以完成恶意攻击。

简单来说就是：用户在页面提交数据的时候人为的添加一些特殊字符，使得sql语句的结构发生了变化，最终可以在没有用户名或者密码的情况下进行登录。

案例：模拟登陆。

#### sql注入原因演示\_模拟登陆： ####

sql注入代码演示：

需求: 根据用户名和密码 查询用户信息(只知道用户名,不知道密码)。

恶意注入方式：在sql语句中添加 – 是mysql的注释。

用户名username输入 zhangsan’ 空格–空格 ，密码password 随意。

select \* from user where username =‘zhangsan’ – ’ and password =‘kajajha’’’ ;

对上述sql语句进行说明：

– ’ and password =‘kajajha’’’ ; – 表示注释的意思，这样就会将密码都给注释掉了，就相当于只根据用户名zhangsan来查询了。

![\[外链图片转存失败(img-Q9COVeFg-1562515862571)(img/sql注入问题.bmp)\]][img-Q9COVeFg-1562515862571_img_sql_.bmp]

注意：以上的 zhangsan’ 空格–空格 中的用户名zhangsan是数据库存在的。

@Test
    	public void ZhuRu2() {
        
    		// 需求: 根据用户名和密码 查询用户信息(只知道用户名,不知道密码)
    		Connection conn = null;
    		Statement stmt = null;
    		ResultSet rs = null;
    		try {
        
    			// 获得连接
    			conn = JDBCUtils.getConnection();
    			// 获得发送sql的对象
    			stmt = conn.createStatement();
    			// 执行sql 获得结果
    			String uname = "zhangsan' -- ";
    			String upwd = "skjflskfjslfksf";
    			String sql = "select * from user where username='" + uname + "' and password='" + upwd + "'";
    //上述sql语句等同于sql="select * from user where username='zhangsan' -- ' and password='skjflskfjslfksf'";
    			System.out.println(sql);
    			rs = stmt.executeQuery(sql);
    			// 处理结果
    			if (rs.next()) {
        
    				int id = rs.getInt("id");
    				String username = rs.getString("username");
    				String pwd = rs.getString("password");
    
    				System.out.println(id + ":::" + username + "===" + pwd);
    			} else {
        
    				System.out.println("没有查到对应的用户信息!");
    			}
    		} catch (Exception e) {
        
    			e.printStackTrace();
    		} finally {
        
    			// 释放资源
    			JDBCUtils.release(conn, stmt, rs);
    		}
    	}

### 小结 ###

**问题根本原因：**

之所以有sql注入的问题，无非是在参数中设置了一些特殊字符，使sql语句在拼接这些参数的时候因为特殊字符的原因改变了sql语句原来的规则。

**问题的解决方案：**

使用PreparedStatement 解决SQL注入问题，运行在SQL中参数以 ? 占位符的方式表示。

## 2、PreparedStatement解决SQL注入方案 ##

### 目标 ###

掌握PreparedStatement是如何解决SQL注入问题的

### 讲解 ###

1.获取PreparedStatement对象

PreparedStatement是Statement的子接口，可以防止sql注入问题。可以通过Connection接口中的prepareStatement(sql)方法获得PreparedStatement的对象。

方法如下所示：

PreparedStatement	prepareStatement(String sql)  创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。

注意：sql提前创建好的。sql语句中需要参数。使用？进行占位。

举例：

select \*from user where username=‘zhangsan’ and password = ‘123456’;

使用？进行占位

select \*from user where username=? and password = ?;

String sql=”select \*from user where username=? and password = ?”;

步骤一：PreparedStatement pstmt = conn.prepareStatement(sql); -----需要你事先传递sql。如果sql需要参数，使用？进行占位。

步骤二：设置参数（执行sql之前）：pstmt.setXXX(int index, 要放入的值) -----根据不同类型的数据进行方法的选择。第一个参数index表示的是？出现的位置。从1开始计数，有几个问号，就需要传递几个参数。

方法的参数说明：

第一个参数：int index ;表示的是问号出现的位置。 问号是从1开始计数

第二个参数：给问号的位置传入的值。

步骤三、执行，不需要在传递sql了。

pstmt.executeQuery();—执行select

pstmt.executeUpdate();—执行insert，delete，update

## 3、PreparedStatement的 应用(掌握) ##

### 目标 ###

能够掌握PreparedSatement实现查询和添加数据

### 讲解 ###

**1、需求: 根据用户名和密码查询用户信息。**

代码如下所示：

说明：导包必须都得使用java.sql包下的。

@Test
    	public void demo1() {
        
    		// 需求: 根据用户名和密码 查询用户信息
    		Connection conn = null;
    		PreparedStatement pstmt = null;
    		ResultSet rs = null;
    
    		try {
        
    			// 获得连接
    			conn = JDBCUtils.getConnection();
    			// 获得发送sql的对象
    			String sql = "select * from user where username=? and password=?";
    			pstmt = conn.prepareStatement(sql);
    			// 如果有问号,需要 设置参数,注意:下标从1开始
    			pstmt.setString(1, "lisi");
    			pstmt.setString(2, "abc");
    			// 执行sql 获得结果
    			rs = pstmt.executeQuery();
    			// 处理结果
    			if (rs.next()) {
        
    				int id = rs.getInt("id");
    				String username = rs.getString("username");
    				String pwd = rs.getString("password");
    
    				System.out.println(id + ":::" + username + "===" + pwd);
    			} else {
        
    				System.out.println("没有查到对应的用户信息!");
    			}
    		} catch (Exception e) {
        
    			e.printStackTrace();
    		} finally {
        
    			JDBCUtils.release(conn, pstmt, rs);
    		}
    	}

**2、 需求: 插入用户名 liuyan ，密码123.**

@Test
    	public void demo2() {
        
    		// 需求: 插入 用户 liuyan 123
    		Connection conn = null;
    		PreparedStatement pstmt = null;
    
    		try {
        
    			// 获得连接
    			conn = JDBCUtils.getConnection();
    			// 获得发送sql的对象
    			String sql = "insert into user values(null, ?, ?)";
    			pstmt = conn.prepareStatement(sql);
    			// 如果有问号 必须设置
    			pstmt.setString(1, "liuyan");
    			pstmt.setString(2, "123");
    			// 执行sql 获得结果
    			int sum = pstmt.executeUpdate();
    			// 处理结果
    			System.out.println(sum);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    		} finally {
        
    			JDBCUtils.release(conn, pstmt,null);
    		}
    	}

## 4、三层开发业务的案例分析(掌握) ##

1、开发中，常使用分层思想

1) 不同的层次结构分配不同的解决过程，各个层次间组成严密的封闭系统

2)不同层级结构彼此平等

3)分层的目的是：

a:解耦，就是降低代码之间的依赖关系。

b:可维护性，哪一层出现问题，直接维护哪一层。

c:可扩展性，哪一层需要添加代码，直接添加即可。

d:可重用性，一个方法可以被其它层重复调用。

2、不同层次，使用不同的包表示

1）[com.itheima.web][] web层 公司域名倒写。和前端页面直接交互。

2）com.itheima.service service层。也叫做业务层。专门用来处理业务的，比如事务。

3）com.itheima.dao dao层。数据处理层。操作数据库的代码都书写在这一层。直接和数据库交互。

4）com.itheima.domain javabean 存放实体类。

5）com.itheima.utils 存放工具类。

具体的三层开发如下图所示：

![\[外链图片转存失败(img-ptwS5FXc-1562515862572)(img/三层开发流程图.bmp)\]][img-ptwS5FXc-1562515862572_img_.bmp]

## 5、连接池介绍 ##

### 目标 ###

能够理解连接池的原理和好处

### 讲解 ###

#### 没有连接池的现状 ####

首先我们通过画图的形式来分析一下我们目前所学的jdbc程序的结构。

![\[外链图片转存失败(img-TgLIpmCJ-1562515862572)(img/jdbc操作数据库图解.bmp)\]][img-TgLIpmCJ-1562515862572_img_jdbc_.bmp]

说明：以前使用的jdbc的缺点：

1、操作数据库都需要创建连接，操作完成还需要关闭连接

2、创建连接和关闭连接需要可能比执行sql需要的时间都长

3、一个网站需要高频繁的访问数据库，如果短时间频繁的访问数据库服务器，就容易造成服务器的宕机，即死机。

#### 连接池解决现状问题的原理 ####

注意：

通过画图分析得出：当前的jdbc程序每次访问数据库都需要创建一个新的连接，访问完毕之后，还需要释放资源。那么在这样的一个过程中，连接的创建和销毁所消耗的资源是远远大于我们发送sql并执行的时间的。基于这样的情况，我们发现我们的jdbc程序将大量的资源浪费在了连接的创建和销毁上。

举例：就像在上海坐地铁，就一站2分钟的路程，往往在买地铁票的过程需要等待至少10分钟以上的时间。这样是不合理的。所以我们 需要对这样的结构进行优化。

思考上面的结构，大部分的时间浪费在了创建和销毁上。那么我们能不能实现将这些连接回收和利用呢？这样我们就不需要不停的创建和销毁了。只需要创建一次，放在指定的地方。当我们使用的时候，直接从里面拿就行了。用完放回原来的地方。不去销毁，当我再次使用的时候，去拿就行了。而这样的解决方案就是我们需要的。

优化后的结构如下：

说明：首先创建一定数量的连接，然后放到指定的地方。当我们需要获取连接的时候，直接从指定的地方获取。用完了，我们再将连接放回去。这样就能将我们连接的回收利用。并且不用花费大量时间在创建和销毁连接上。

解决方案如下图所示：

![\[外链图片转存失败(img-fJZlgkh9-1562515862573)(img/数据库连接池原理.bmp)\]][img-fJZlgkh9-1562515862573_img_.bmp]

#### 连接池好处 ####

连接池中保存了一些数据库连接，这些连接是可以重复使用的。节省数据库的资源消耗。

#### 常用连接池的介绍 ####

`javax.sql.DataSource`表示数据库**连接池**，DataSource本身只是Sun公司提供的一个接口,没有具体的实现，它的实现由连接池的数据库厂商去实现。我们只需要学习这个工具如何使用即可。

该接口如下：

public interface DataSource {
        
    	Connection getConnection();
    }

常用的连接池实现组件有以下这些：

1.  **阿里巴巴-德鲁伊Druid连接池：Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。该项目主要是为了扩展JDBC的一些限制，可以让程序员实现一些特殊的需求。**
2.  **C3P0是一个开源的JDBC连接池，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。C3P0有自动回收空闲连接功能。**
3.  DBCP(DataBase Connection Pool)数据库连接池，是Apache上的一个Java连接池项目。dbcp没有自动回收空闲连接的功能。

### 小结 ###

连接池的好处？  
连接池内部会保存好一些连接,这些连接可以反复使用,提高连接的使用率,降低数据库资源消耗  
连接池的原理?  
1.创建连接池时,连接池内部就会创建一些连接  
2.当需要使用连接时,就直接从连接池里面取出连接  
3.当连接使用完毕时,重新放回连接池

## 6、C3P0连接池 ##

### 目标 ###

能够使用C3P0连接池

### 讲解 ###

#### C3P0连接池简介 ####

C3P0 是一个开源的JDBC连接池，目前spring 和 hibernate框架对C3P0是支持的。

使用c3p0数据库连接池之前，首先需要在资料中找到如下的jar包，加载到项目中。

C3P0的核心jar包：`c3p0-0.9.1.2.jar`  
![\[外链图片转存失败(img-j6FvcnAI-1562515862573)(img/1550387401441.png)\]][img-j6FvcnAI-1562515862573_img_1550387401441.png]

对上述核心包进行Add as Library…

最后生成如下内容：

![\[外链图片转存失败(img-YU70lM2H-1562515862573)(img/解压后的c3p0结构.bmp)\]][img-YU70lM2H-1562515862573_img_c3p0_.bmp]

#### C3P0常用的配置参数解释 ####

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>driverClass</td> 
   <td>数据库驱动类。例如：com.mysql.jdbc.Driver</td> 
  </tr> 
  <tr> 
   <td>jdbcUrl</td> 
   <td>连接数据库的url地址。例如：jdbc:mysql://localhost:3306/day05_db</td> 
  </tr> 
  <tr> 
   <td>user</td> 
   <td>连接数据库的用户名。例如：root</td> 
  </tr> 
  <tr> 
   <td>password</td> 
   <td>连接数据库的密码。例如：1234</td> 
  </tr> 
  <tr> 
   <td>initialPoolSize</td> 
   <td>刚创建好连接池的时候连接数量</td> 
  </tr> 
  <tr> 
   <td>maxPoolSize</td> 
   <td>连接池中最多可以放多少个连接</td> 
  </tr> 
 </tbody> 
</table>

#### C3P0配置文件方式获取数据库连接 ####

我们看到要使用C3P0连接池，需要设置一些参数。那么这些参数怎么设置最为方便呢？使用配置文件方式。

我们可以找到c3p0的主页index.html。即c3p0的API帮助文档。

![\[外链图片转存失败(img-zKmnjavx-1562515862574)(img/1.bmp)\]][img-zKmnjavx-1562515862574_img_1.bmp]

打开该页面，如下图所示：

![\[外链图片转存失败(img-JEayaY3s-1562515862574)(img/2.bmp)\]][img-JEayaY3s-1562515862574_img_2.bmp]

这里我们采用xml的配置方式：

![\[外链图片转存失败(img-n48M5PuS-1562515862574)(img/3.bmp)\]][img-n48M5PuS-1562515862574_img_3.bmp]

点击进去，如下模板：

![\[外链图片转存失败(img-jtGIy2qA-1562515862574)(img/4.bmp)\]][img-jtGIy2qA-1562515862574_img_4.bmp]

那么接下来就会有几个问题，这些配置信息存放的配置文件叫什么？

![\[外链图片转存失败(img-ibeo3JaF-1562515862574)(img/5.bmp)\]][img-ibeo3JaF-1562515862574_img_5.bmp]

通过读取API得知，要求c3p0数据库连接池的配置文件的名字必须叫做：c3p0-config.xml。

配置文件存放到哪里？

![\[外链图片转存失败(img-7HI3xIfp-1562515862575)(img/6.bmp)\]][img-7HI3xIfp-1562515862575_img_6.bmp]

说明：WEB-INF/classes 属于web项目中的目录，在javase项目下就相当于src目录。

所以我们需要将c3p0-config.xml配置文件存放到src目录下。

这样C3P0数据库连接池自己就会去找这个文件，并且读取文件中信息。

具体操作步骤如下所示：

1）点击src-----》右键new--------》选择File

![\[外链图片转存失败(img-CeqSv7i4-1562515862575)(img/7.bmp)\]][img-CeqSv7i4-1562515862575_img_7.bmp]

1.  在弹出的框中输入配置文件的名字c3p0-config.xml--------》点击OK

![\[外链图片转存失败(img-KrsRmSjl-1562515862575)(img/8.bmp)\]][img-KrsRmSjl-1562515862575_img_8.bmp]

3）配置文件创建好之后，将API中的配置信息存放到c3p0-config.xml文件中，并修改配置文件，如下所示：

配置文件配置完成之后，接下来我们开始学习相关的API

#### API介绍 ####

`com.mchange.v2.c3p0.ComboPooledDataSource`类表示C3P0的连接池对象，常用2种创建连接池的方式：

`1.无参构造，使用默认配置`，

`2.有参构造，使用命名配置`

1.      public ComboPooledDataSource()
        无参构造使用默认配置（使用xml中default-config标签中对应的参数）
2.      public ComboPooledDataSource(String configName)
        有参构造使用命名配置（configName：xml中配置的名称，使用xml中named-config标签中对应的参数）
3.      public Connection getConnection() throws SQLException
        从连接池中取出一个连接

#### 使用步骤 ####

1.  导入jar包`c3p0-0.9.1.2.jar`
2.  编写`c3p0-config.xml`配置文件，配置对应参数
3.  将配置文件放在src目录下
4.  创建连接池对象`ComboPooledDataSource`，使用默认配置或命名配置
5.  从连接池中获取连接对象
6.  使用连接对象操作数据库
7.  关闭资源

#### 注意事项 ####

C3P0配置文件名称必须为`c3p0-config.xml`  
C3P0命名配置可以有多个

#### 案例代码 ####

1.  准备数据
    
        create database day05_db;
        
        use day05_db;
        
        create table emp(
        	id int primary key auto_increment,
        	name varchar(50),
        	city varchar(50)
        );
        
        insert into emp values(null, '刘备', '北京');
        insert into emp values(null, '关羽', '上海');
        insert into emp values(null, '张飞', '广州');
        
        select * from emp;
2.  java代码
    
        @Test
        	public void demo2() throws PropertyVetoException {
              
        		// 需求：遍历emp的用户。
        		// 首先创建c3p0的数据库连接池
        		ComboPooledDataSource cpds = new ComboPooledDataSource();
        
        		Connection conn = null;
        		PreparedStatement stmt = null;
        		ResultSet rs = null;
        
        		try {
              
        			// 从连接池中获取连接
        			conn = cpds.getConnection();
        			// 获得发送sql的对象
        			String sql = "select * from emp";
        			stmt = conn.prepareStatement(sql);
        			// 执行sql 获得结果
        			rs = stmt.executeQuery();
        			// 处理结果
        			while (rs.next()) {
              
        				int id = rs.getInt("id");
        				String name = rs.getString("name");
        				String city = rs.getString("city");
        			     System.out.println("C3P0::::: " + id + ">>>" + name + ">>>" + city);
        			}
        		} catch (Exception e) {
              
        			e.printStackTrace();
        		} finally {
              
        			// 释放资源: 关闭stmt 和 rs
        			JDBCUtils.release(conn, stmt, rs);
        		}
        
        	}

#### 案例效果 ####

![\[外链图片转存失败(img-r6AYh2u0-1562515862575)(img/9.bmp)\]][img-r6AYh2u0-1562515862575_img_9.bmp]

**说明：**

**1）、我们发现在创建c3p0数据库连接池对象的时候，没有进行设置参数，就可以和数据库建立连接了。说明在创建数据库连接池对象的时候，数据库连接池就会去src下找c3p0-config.xml,并且读取该配置文件中的配置信息从而来连接数据库。因为C3P0 自己按照约定去找src目录下的 c3p0-config.xml 文件，**

**2）、上述打印红色的内容是在创建c3p0核心类ComboPooledDataSource对象和调用conn = cpds.getConnection();方法时打印的。**

**3）、关于打印主要信息解释：**

**驱动类：driverClass -> com.mysql.jdbc.Driver**

**连接池可以存放的最大连接数：maxPoolSize -> 15**

**连接池可以存放的最小连接数：minPoolSize -> 3**

> 注意：配置文件名称必须为：`c3p0-config.xml`，将配置文件放在src目录下

#### 使用命名配置操作指定的数据库 ####

需求：现在想读取day04\_db数据库下面的user表中的信息。

1、修改c3p0-config.xml配置文件中的配置信息：

<?xml version="1.0" encoding="UTF-8"?>
    <c3p0-config>
      <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day_05db</property>
        <property name="user">root</property>
        <property name="password">123</property>
      </default-config>
    
      <named-config name="day04">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day_04db</property>
        <property name="user">root</property>
        <property name="password">123</property> 
      </named-config>
    </c3p0-config>

2、java代码

@Test
    	public void demo2() throws PropertyVetoException {
        
    		// 需求：遍历emp的用户。
    		// 首先创建c3p0的数据库连接池构造方法ComboPooledDataSource(configName) configName表示新增的名字
    		ComboPooledDataSource cpds = new ComboPooledDataSource(“day04”);
    
    		Connection conn = null;
    		PreparedStatement stmt = null;
    		ResultSet rs = null;
    
    		try {
        
    			// 从连接池中获取连接
    			conn = cpds.getConnection();
    			// 获得发送sql的对象
    			String sql = "select * from user";
    			stmt = conn.prepareStatement(sql);
    			// 执行sql 获得结果
    			rs = stmt.executeQuery();
    			// 处理结果
    			while (rs.next()) {
        
    				int id = rs.getInt("id");
    				String username = rs.getString("name");
    				String password= rs.getString("password");
    
    				System.out.println("C3P0::::: " + id + ">>>" + username + ">>>" + password);
    			}
    		} catch (Exception e) {
        
    			e.printStackTrace();
    		} finally {
        
    			// 释放资源: 关闭stmt 和 rs
    			JDBCUtils.release(conn, stmt, rs);
    		}
    }

小结：

如何快速切换不同的数据源呢？ 根据实例化数据源ComboPooledDataSource(String configName) 指定不同的参数

![\[外链图片转存失败(img-gV8SCpKc-1562515862576)(img/10.bmp)\]][img-gV8SCpKc-1562515862576_img_10.bmp]

只需要单独修改配置文件，不用修改代码  
多个配置的好处：

1.  可以连接不同的数据库：db1,db2
2.  可以使用不同的连接池参数：maxPoolSize
3.  可以连接不同厂商的数据库：Oracle或MySQL

### 小结 ###

CP30使用步骤？

1.导入jar包  
2.复制配置文件到src下:c3p0-config.xml  
3.修改配置信息  
4.创建ComboPooledDataSource()连接池  
5.使用连接池获取连接:getConnection();  
6.后续操作  
7.关闭资源

注意：

1、配置文件名称是 c3p0-config.xml 文件，并且必须在src 目录下

2、c3p0会自动寻找这个文件，加载里面的配置信息。

## 7、Druid连接池 ##

### 目标 ###

能够掌握Druid连接池的使用

### 讲解 ###

#### DRUID简介 ####

Druid是阿里巴巴开发的号称为监控而生的数据库连接池(可以监控访问数据库的性能)，Druid是目前最好的数据库连接池。在功能、性能、扩展性方面，都超过其他数据库连接池。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署的严苛考验。如：一年一度的双十一活动，每年春运的抢火车票。

Druid的下载地址：[https://github.com/alibaba/druid][https_github.com_alibaba_druid]

DRUID连接池使用的jar包：druid-1.0.9.jar

![\[外链图片转存失败(img-aZFnPbj7-1562515862576)(img/1550388331344.png)\]][img-aZFnPbj7-1562515862576_img_1550388331344.png]

#### Druid常用的配置参数 ####

<table> 
 <thead> 
  <tr> 
   <th><strong>url</strong></th> 
   <th><strong>数据库</strong>连接字符串<strong>jdbc:mysql://localhost:3306/数据库名</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>username</strong></td> 
   <td><strong>数据库的用户名</strong></td> 
  </tr> 
  <tr> 
   <td><strong>password</strong></td> 
   <td><strong>数据库的密码</strong></td> 
  </tr> 
  <tr> 
   <td><strong>driverClassName</strong></td> 
   <td><strong>驱动类名。根据url自动识别，这一项可配可不配，如果不配置druid会根据url自动识别数据库的类型，然后选择相应的数据库驱动名</strong></td> 
  </tr> 
  <tr> 
   <td><strong>initialSize</strong></td> 
   <td><strong>初始化时建立的物理连接的个数。初始化发生在显式调用init方法，或者第一次获取连接对象时</strong></td> 
  </tr> 
  <tr> 
   <td><strong>maxActive</strong></td> 
   <td><strong>连接池中最大连接数</strong></td> 
  </tr> 
  <tr> 
   <td><strong>maxWait</strong></td> 
   <td><strong>获取连接时最长等待时间，单位是毫秒。</strong></td> 
  </tr> 
 </tbody> 
</table>

#### Druid连接池基本使用 ####

##### API介绍 #####

核心类：**DruidDataSourceFactory**

获取数据源的方法：使用**com.alibaba.druid.pool.DruidDataSourceFactory**类中的静态方法：

public static DataSource createDataSource(Properties properties)
    创建一个连接池，连接池的参数使用properties中的数据

配置信息在properties属性对象中。

我们可以看到Druid连接池在创建的时候需要一个Properties对象来设置参数，所以我们使用properties文件来保存对应的参数。

Druid连接池的配置文件名称随便，放到src目录或者项目根目录下面加载  
`druid.properties`文件内容：

# 数据库连接参数
    url=jdbc:mysql://localhost:3306/day05_db
    username=root
    password=123
    driverClassName=com.mysql.jdbc.Driver

#### 使用步骤 ####

1.  导入核心包druid-1.0.9.jar

![\[外链图片转存失败(img-tuZdYYen-1562515862576)(img/11.bmp)\]][img-tuZdYYen-1562515862576_img_11.bmp]

1.  在项目下创建一个properties文件，文件名随意，设置对应参数

![\[外链图片转存失败(img-KpoEtMrT-1562515862576)(img/12.bmp)\]][img-KpoEtMrT-1562515862576_img_12.bmp]

1.  加载properties文件的内容到Properties对象中
2.  创建DRUID连接池，使用配置文件中的参数
3.  从DRUID连接池中取出连接
4.  执行SQL语句
5.  关闭资源

#### 案例代码 ####

1.  属性文件：在项目下新建一个druid配置文件，命名为：druid.properties

# 数据库连接参数
    url=jdbc:mysql://localhost:3306/day05_db
    username=root
    password=123
    driverClassName=com.mysql.jdbc.Driver

2.java代码

public class Demo03 {
        
        public static void main(String[] args) throws Exception {
        
            //加载properties文件的内容到Properties对象中
            Properties info = new Properties();
            //加载项目下的属性文件
            FileInputStream fis = new FileInputStream("druid.properties");
            //从输入流中加载属性
            info.load(fis);
            System.out.println(info);
            //创建DRUID连接池，使用配置文件中的参数
            DataSource dataSource = DruidDataSourceFactory.createDataSource(info);
           //从DRUID连接池中取出连接
            //Connection conn = dataSource.getConnection();
            //System.out.println("conn = " + conn);
    // 需求: 根据用户名和密码 查询用户信息
            Connection conn = null;
            PreparedStatement pstmt = null;
            ResultSet rs = null;
    
            try {
        
                // 获得连接
                conn = dataSource.getConnection();
                // 获得发送sql的对象
                String sql = "select * from user where username=? and password=?";
                pstmt = conn.prepareStatement(sql);
                // 如果有问号,需要 设置参数,注意:下标从1开始
                pstmt.setString(1, "zhangsan");
                pstmt.setString(2, "abcdef");
                // 执行sql 获得结果
                rs = pstmt.executeQuery();
                // 处理结果
                if (rs.next()) {
        
                    int id = rs.getInt("id");
                    String username = rs.getString("username");
                    String pwd = rs.getString("password");
    
                    System.out.println(id + ":::" + username + "===" + pwd);
                } else {
        
                    System.out.println("没有查到对应的用户信息!");
                }
            } catch (Exception e) {
        
              } finally {
        
                JDBCUtils.release(conn, pstmt, rs);
            }
        }
    }

#### 案例效果 ####

![\[外链图片转存失败(img-xxCXiIm5-1562515862577)(img/13.bmp)\]][img-xxCXiIm5-1562515862577_img_13.bmp]

## 8、编写连接池工具类 ##

### 目标 ###

能够编写一个连接池的工具类，简化获取连接池中的连接对象

### 讲解 ###

通过观察以前的工具类JDBCUtils，我们会发现获取连接很麻烦，所以接下来我们开始优化以前的JDBCUtils工具类，使之变得更加简单，具体优化方案如下。

#### 编写c3p0数据库连接池工具类 ####

在JDBCUtils类中将之前获取连接和加载配置文件中的信息代码都删除，直接换成一行代码：

static ComboPooledDataSource cpds = new ComboPooledDataSource();

![\[外链图片转存失败(img-omMH3Uzk-1562515862577)(img/14.bmp)\]][img-omMH3Uzk-1562515862577_img_14.bmp]

#### 编写德鲁伊数据库连接池工具类 ####

我们之前是在JDBCUtils类中使用的是c3p0数据库连接池获取连接，我们可以在JDBCUtils工具类中再添加一个方法，使用德鲁伊来获取连接。

具体代码如下：

public static Connection getDruidConnection()
    {
        
        try {
        
            //创建Properties集合对象
            Properties p = new Properties();
            //调用方法加载配置文件中的数据
            p.load(new FileInputStream("druid.properties"));
            //使用德鲁伊核心类调用静态方法获取配置文件中的数据
            DataSource ds = DruidDataSourceFactory.createDataSource(p);
            //从德鲁伊数据库连接池中获取连接
            Connection conn = ds.getConnection();
            //返回连接
            return conn;
        } catch (Exception e) {
        
            throw new RuntimeException(e);
        }
    }

说明：工具类既有使用c3p0数据库连接池获取连接的方法，还有使用德鲁伊获取数据库连接池的方法，想使用哪个都可以，看具体需求。

## 9、JdbcTemplate介绍 ##

### 目标 ###

能够理解JdbcTemplate模板的概念

### 讲解 ###

#### 原始的jdbc操作数据库中的数据的弊端 ####

在实际开发中我们使用三层架构进行开发，层与层之间会将传递的参数封装成实体对象，那么接下来我们来看一下dao(数据处理层)层是如何将查询出的结果封装成user对象的：

说明：封装到User类的对象中是因为我们要把查询的结果进行显示和其他的处理。

举例：

用户想在浏览器查询自己的个人信息，那么我们需要到数据库查询出来，然后把个人的全部信息封装到User类的对象中。然后在将User类的对象传递给前台，最后经过相关技术显示到页面浏览器中，达到显示个人信息的效果。

其实我们生活中到淘宝网站购买商品，查看某个商品信息也是这样做的，将数据库中有关商品信息都先全部封装到Product类的对象中。最后显示到页面中。

按照如下操作，书写代码：

新建一个User类，具体属性如下所示：

![\[外链图片转存失败(img-WXcNWKBv-1562515862577)(img/15.bmp)\]][img-WXcNWKBv-1562515862577_img_15.bmp]

在DAO层使用JDBC将查询的数据封装到User类的对象中的代码，如下所示：

@Test
    	public void show() {
        
    		// 初始化值
    		Connection conn = null;
    		ResultSet rs = null;
    		PreparedStatement pst = null;
    		try {
        
    			conn = JDBCUtils.getConnection();
    			String sql = "select * from emp";
    			// 获取发送sql的对象
    			pst = conn.prepareStatement(sql);
    			// 执行sql
    			rs = pst.executeQuery();
    			//定义集合将遍历结果集封装到List集合中
    			List<User> list=new ArrayList<User>();
    			// 处理结果
    			while (rs.next()) {
        
    				//由于数据库中有多行，所以需要多个User类的对象
    				User u = new User();
    				u.setId(rs.getInt("id"));
    				u.setName(rs.getString("name"));
    				u.setCity(rs.getString("city"));
    				// 将对象添加到集合中
    				list.add(u);
    			}
    			System.out.println(list.size());//3
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			
    		} finally {
        
    			JDBCUtils.release(rs, pst, conn);// 不要关闭连接，每次使用完之后，把连接还给连接池
    		}
    	}

说明：

上述将从数据库中查询的数据封装到User类的对象中，相对来说比较复杂。我们这里用户属性相对比较少，如果属性多的话会更加复杂。所以，我们完全可以使用更为简单的方式来对数据进行封装到User类的对象中。

即可以使用JdbcTemplate对上述操作的代码进行优化。

#### JdbcTemplate概念 ####

JDBC已经能够满足大部分用户最基本的需求，但是在使用JDBC时，必须自己来管理数据库资源。

如：获取PreparedStatement，设置SQL语句参数，关闭连接等步骤。并且向JavaBean中封装数据也比较麻烦。

JdbcTemplate就是Spring对JDBC的封装，目的是使JDBC更加易于使用。JdbcTemplate是Spring的一部分。JdbcTemplate处理了资源的建立和释放。他帮助我们避免一些常见的错误，比如忘了总要关闭连接。他运行核心的JDBC工作流，如PreparedStatement的建立和执行，而我们只需要提供SQL语句和提取结果。

Spring下载地址：[http://projects.spring.io/spring-framework/][http_projects.spring.io_spring-framework]

![\[外链图片转存失败(img-1qHEdTNA-1562515862577)(img/16.bmp][img-1qHEdTNA-1562515862577_img_16.bmp])\]

**在JdbcTemplate类中执行SQL语句的方法大致分为3类：**

<table> 
 <thead> 
  <tr> 
   <th><strong>JdbcTemplate</strong>中的方法</th> 
   <th><strong>功能说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>execute()</strong></td> 
   <td>用于执行DDL语句，如：建表 了解</td> 
  </tr> 
  <tr> 
   <td><strong>update()</strong></td> 
   <td>用于执行DML语句，实现对数据库表的增删改操作 掌握</td> 
  </tr> 
  <tr> 
   <td><strong>queryXxx()</strong></td> 
   <td>用于执行DQL语句，实现对数据库表的各种查询的操作 一定掌握</td> 
  </tr> 
 </tbody> 
</table>

## 10、执行DDL(建表)语句(了解) ##

### 目标 ###

能够使用JdbcTemplate执行DDL语句创建表

### 讲解 ###

#### API介绍 ####

JdbcTemplate类：

**查阅API对于JdbcTemplate类的描述方式：**

**1）在下发的资料目录下：资料\\开源数据库连接池\\JdbcTemplate\\doc**

**找到spring下关于jdbc的文档jar包进行解压。**

![\[外链图片转存失败(img-abIjJPep-1562515862578)(img/17.bmp)\]][img-abIjJPep-1562515862578_img_17.bmp]

**2）进入spring-jdbc-5.0.0.RELEASE-javadoc 文件夹中找到index.html，并将其打开。**

![\[外链图片转存失败(img-bkmpGR35-1562515862578)(img/18.bmp)\]][img-bkmpGR35-1562515862578_img_18.bmp]

**3）在API左侧查找JdbcTemplate类 即可。**

![\[外链图片转存失败(img-VJbIaNuJ-1562515862578)(img/19.bmp)\]][img-VJbIaNuJ-1562515862578_img_19.bmp]

**JdbcTemplate类的构造方法：**

![\[外链图片转存失败(img-bo87Ad0n-1562515862579)(img/20.bmp)\]][img-bo87Ad0n-1562515862579_img_20.bmp]

说明：在创建JdbcTemplate类的对象时使用上述构造方法，而构造方法的参数需要一个数据库连接池的对象作为参数。我们学习过两种数据库连接池(C3P0和druid德鲁伊)，提供哪个都可以。这里我们提供c3p0的数据库连接池。

了解完JdbcTemplate之后，我们首先创建一个JdbcUtils工具类提供一个获取数据库连接池的方法和一个提供连接的方法：

public class JDBCUtils{
        
        //创建数据库连接池
        private static ComboPooledDataSource cpds = new ComboPooledDataSource();
        //定义一个静态方法让外界获取连接 从数据库连接池中获取连接
        public static Connection getConnection() throws Exception
        {
        
    
            Connection conn = cpds.getConnection();
            //返回连接
            return conn;
        }
        //定义一个静态方法让外界获取连接池
        public static DataSource getDataSource()
        {
        
    
            //返回连接池
            return cpds;
        }
        /*
            获取德鲁伊数据库连接池
         */
        public static DataSource getDruidDataSource()
        {
        
            try {
        
                //创建Properties集合对象
                Properties p = new Properties();
                //调用方法加载配置文件中的数据
                p.load(new FileInputStream("druid.properties"));
                //使用德鲁伊核心类调用静态方法获取配置文件中的数据
                DataSource ds = DruidDataSourceFactory.createDataSource(p);
                //返回连接池
                return ds;
            } catch (Exception e) {
        
                throw new RuntimeException(e);
            }
        }
        public static Connection getDruidConnection()
        {
        
            try {
        
                //创建Properties集合对象
                Properties p = new Properties();
                //调用方法加载配置文件中的数据
                p.load(new FileInputStream("druid.properties"));
                //使用德鲁伊核心类调用静态方法获取配置文件中的数据
                DataSource ds = DruidDataSourceFactory.createDataSource(p);
                //从德鲁伊数据库连接池中获取连接
                Connection conn = ds.getConnection();
                //返回连接
                return conn;
            } catch (Exception e) {
        
                throw new RuntimeException(e);
            }
        }
    
    }

说明：工具类提供了获取c3p0数据库连接池和获取德鲁伊数据库连接池的2个方法，想使用哪个都可以，看具体需求。

创建完成之后，就可以通过工具类提供数据库连接池了。

**JdbcTemplate类中创建表的方法：**

**public void execute(String sql)执行建表语句，没有返回值。参数是SQL语句，属于String类型。**

#### 使用步骤 ####

1.  准备C3P0连接池

A:将c3p0-config.xml配置文件放到src目录下：

![\[外链图片转存失败(img-Ro4AjuXH-1562515862579)(img/21.bmp)\]][img-Ro4AjuXH-1562515862579_img_21.bmp]

B:新建一个包，com.itheima.sh.utils .然后将之前写好的工具类复制到该包下。

![\[外链图片转存失败(img-L9wRTwR5-1562515862579)(img/22.bmp)\]][img-L9wRTwR5-1562515862579_img_22.bmp]

1.  导入依赖的jar包

![\[外链图片转存失败(img-wKetceJV-1562515862579)(img/23.bmp)\]][img-wKetceJV-1562515862579_img_23.bmp]

说明：

commons-logging-1.2.jar 表示日志记录包。记录使用spring的时候生成的文件，如果报错，可以使用其里面的内容可以进行查看。想使用spring的jdbc必须要导入这个包。核心包要依赖于它。

将 资料\\开源数据库连接池\\JdbcTemplate\\lib 目录下所有的包导入到模块下的lib中，并对所有的包进行Add as Library…：

![\[外链图片转存失败(img-YS2kYV5N-1562515862580)(img/24.bmp)\]][img-YS2kYV5N-1562515862580_img_24.bmp]

1.  创建JdbcTemplate对象，传入C3P0连接池
2.  调用execute()方法

#### 案例代码 ####

1、需求：创建一个学生表id,name,birthday

1.  id是主键，整数类型，自增长
2.  name是varchar(20)，非空
3.  生日是date类型

创建表语句：

create table student(
    	id int primary key auto_increment, 
    	name varchar(20) not null, 
    	birthday date);
    String sql = "create table student(id int primary key auto_increment,name varchar(20) not null,birthday date)";

java代码：

package com.itheima.sh;
    
    import com.itheima.sh.utils.JDBCUtils;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class Demo04 {
        
        public static void main(String[] args) {
        
            String sql = "create table student(id int primary key auto_increment,name varchar(20) not null,birthday date)";
            //1. 创建JdbcTemplate对象，传入C3P0连接池,模板对象自己获得连接并且自己释放资源
            JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
            //2. 创建表，执行DDL语句
            jdbcTemplate.execute(sql);
        }
    }

#### 案例效果 ####

![\[外链图片转存失败(img-wjX1LnfD-1562515862580)(img/25.bmp)\]][img-wjX1LnfD-1562515862580_img_25.bmp]

## 11、JdbcTemplate实现增删改 ##

### 目标 ###

能够掌握JdbcTemplate实现增删改

### 讲解 ###

#### API介绍 ####

org.springframework.jdbc.core.JdbcTemplate类方便执行SQL语句

<table> 
 <thead> 
  <tr> 
   <th><strong>JdbcTemplate类的方法</strong></th> 
   <th><strong>说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>public int update(String sql, Object…args)</strong></td> 
   <td>执行DML语句，对数据库表中的数据进行增删改操作返回：影响的行数参数：1) sql语句2) args是用来替换占位符的真实值，可变的参数</td> 
  </tr> 
 </tbody> 
</table>

#### 使用步骤 ####

1.  创建JdbcTemplate类的对象
2.  编写SQL语句
3.  使用JdbcTemplate类的对象调用update方法进行对数据库中的student表的增删改的操作：

a) 每条update向表中添加1条记录，一共添加6条记录

b) 修改编号为2的学生名字和生日

c) 删除编号为6的记录

#### 案例代码 ####

package com.itheima.jdbctemplate;
    
    import com.itheima.utils.DataSourceUtils;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    /**
     * 实现DML操作
     */
    public class Demo2DML {
        
    
        private static JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
    
        public static void main(String[] args) {
        
    //        insert();
            //update();
            delete();
        }
    
        //添加记录
        public static void insert() {
        
            jdbcTemplate.update("insert into student values (null, ?,?)", "孙悟空","1999-12-10");
            jdbcTemplate.update("insert into student values (null, ?,?)", "孙悟天","1999-12-10");
            jdbcTemplate.update("insert into student values (null, ?,?)", "孙悟饭","1999-12-10");
            jdbcTemplate.update("insert into student values (null, ?,?)", "龟仙人","1999-12-10");
            jdbcTemplate.update("insert into student values (null, ?,?)", "牛魔王","1999-12-10");
            jdbcTemplate.update("insert into student values (null, ?,?)", "18号","1997-12-10");
        }
    
        //修改记录
        public static void update() {
        
            int row = jdbcTemplate.update("update student set name=?, birthday=? where id=?", "苦林", "1994-12-10", 2);
            System.out.println("更新了" + row + "行记录");
        }
    
        //删除记录
        public static void delete() {
        
            int row = jdbcTemplate.update("delete from student where id=?", 6);
            System.out.println("删除" + row + "行记录");
        }
    }

### 小结 ###

JdbcTemplate的update方法用于执行DML语句。同时还可以在SQL语句中使用？占位，在update方法的Object… args可变参数中传入对应的参数。JdbcTemplate的`update`方法用于执行DML语句。同时还可以在SQL语句中使用？占位，在update方法的`Object... args`可变参数中传入对应的参数。

## 12、执行DQL语句的API介绍(非常重要) ##

### 1)API介绍 ###

<table> 
 <thead> 
  <tr> 
   <th><strong>方法名</strong></th> 
   <th><strong>功能说明</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>query()</strong></td> 
   <td>通用的查询方法，有多个同名方法的重载，可以自定义查询结果集封装成什么样的对象。如果要封装成List对象，使用query()方法。</td> 
  </tr> 
  <tr> 
   <td><strong>queryForMap()</strong></td> 
   <td>返回Map&lt;String,Object&gt;的查询结果，其中键是列名，值是表中对应的记录。用于查询结果只有1条记录的情况。如果结果集返回多条记录会出现异常。<img src="https://img-blog.csdnimg.cn/20190708002010963.png" alt="[外链图片转存失败(img-dPTmJj2H-1562515862580)(img/111.bmp)]"></td> 
  </tr> 
  <tr> 
   <td><strong>queryForObject()</strong></td> 
   <td>返回查询只有单一对象的结果，这个单一结果应该是简单的数据类型，如：Integer.class、Long.class、String.class，不能直接封装成JavaBean对象。可以用于聚合函数的查询结果。</td> 
  </tr> 
  <tr> 
   <td><strong>queryForList()</strong></td> 
   <td>返回多条记录的查询结果，封装成一个List集合默认List集合中的每个元素是Map对象，即List&lt;Map&lt;String,Object&gt;&gt;如果要封装成List对象，使用query()方法。</td> 
  </tr> 
 </tbody> 
</table>

数据准备：实体类JavaBean，属性名必须与列名完全一样

import java.sql.Date;
    public class Student {
        
        private int id;  //编号
        private String name;  //姓名
        private Date birthday; //生日
    }

### 2)queryForObject返回一个指定类型(掌握) ###

#### 方法介绍 ####

public <T> T queryForObject(String sql, Class<T> requiredType, Object... args):传入参数, 执行查询语句，返回一个指定类型的数据。
    说明：
    1）返回查询只有单一对象的结果，这个单一结果应该是简单的数据类型，如：int.class、long.class、		String.class。也可以用于聚合函数的查询结果。
    2）参数：
    	sql:表示要执行的sql语句.
    	requiredType:表示必须给的类型，最后需要返回的Class类的对象.
    	args：属于可变参数，传入的真实参数，例如给sql语句的占位符赋值的真实值.
    	使用举例：
    		String name= jdbcTemplate.queryForObject("select name from student where 			id=?",String.class,2);
      			第一个参数表示一条sql语句
      			String.class表示查询出来name列的类型的Class对象
    			2 表示id是2的数据
    
    3）查询的是单行单列。

#### 使用步骤 ####

1.  创建JdbcTemplate对象
2.  编写查询的SQL语句
3.  使用JdbcTemplate对象的queryForObject方法，并传入需要返回的数据的类型
4.  输出结果

#### 案例代码 ####

需求1:查询有多少名学生

需求2：查询学生id是2的学生姓名

/**
    * 查询单行单列
         * 查询有多少名学生
         */
    public void querForObjectCount() {
        
            //创建模板类的对象
       	   JdbcTemplate jdbcTemplate = new JdbcTemplate(JdbcUtils.getDataSource());
        //书写sql语句
            String sql = "select count(*) from student";
            //执行方法，传入参数开始查询
            int count = jdbcTemplate.queryForObject(sql, int.class);
            //输出查询结果
            System.out.println(count);
        }
       /**
         * 查询学生id是2的学生姓名
         */
    public void querForObjecName() {
        
            //创建模板类的对象
       	   JdbcTemplate jdbcTemplate = new JdbcTemplate(JdbcUtils.getDataSource());
        //书写sql语句
            String sql = "select name from student where id=?";
            //执行方法，传入参数开始查询 由于name的类型是String类型，所以这里书写String.class 这里的2表示id
            String name= jdbcTemplate.queryForObject(sql, String.class,2);
            //输出查询结果
            System.out.println(name);
    }

### 3)queryForMap返回一个Map集合对象 ###

#### 方法介绍 ####

public Map<String, Object> queryForMap(String sql, Object... args) 传入参数，执行查询语句，将一条记录放到一个Map中。
    说明：
    1）参数：
    	sql 表示查询的sql语句
    	args 表示给第一个参数的sql语句的占位符，设置值的
    	使用举例：
     	Map<String, Object> map = jdbcTemplate.queryForMap("select * from student where 		id=?", 2);
     	 第一个参数表示一条sql语句
    	2 表示id是2的数据
    2）查询单行多列

#### 使用步骤 ####

1.  创建JdbcTemplate对象
2.  编写查询的SQL语句
3.  使用JdbcTemplate对象的queryForMap方法
4.  处理结果

#### 案例代码 ####

/**
     * 查询操作
     */
    public class Demo3DQL {
        
        //创建JdbcTemplate对象，传入数据源
        private JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
        /**
         * 使用JdbcTemplate对象的queryForMap()方法查询结果
         */
        public void queryForMap() {
        
            Map<String, Object> map = jdbcTemplate.queryForMap("select * from student where id=?", 2);
            System.out.println(map);
        }
    }

### 4)queryForList返回一个List集合对象，集合对象存储Map类型数据 ###

#### 方法介绍 ####

public List<Map<String, Object>> queryForList(String sql, Object... args) 传入参数，执行查询语句，返回一个List集合，List中存放的是Map类型的数据。
    说明：
    1）使用举例：
    	List<Map<String, Object>> mapList = jdbcTemplate.queryForList("select * from 		student");
    	Key :表示列名
    	Object:value 表示列值
    2）多行多列。

#### 使用步骤 ####

1.  创建JdbcTemplate对象
2.  编写查询的SQL语句
3.  使用JdbcTemplate对象的queryForList方法
4.  处理结果

#### 案例代码 ####

需求：查询所有的学生，使用List<Map<String,Object>>	queryForList(String sql))方法查询
    注：queryForList(String sql)这个方法默认返回的List中的每个元素是Map对象
    使用举例：
    List<Map<String, Object>> mapList = jdbcTemplate.queryForList("select * from student");

/**
         * 查询多条记录封装成List<Map<String,Object>>
         */
        @Test
        public void queryForList() {
        
            List<Map<String, Object>> mapList = jdbcTemplate.queryForList("select * from student");
            for (Map<String,Object> map: mapList ) {
        
                System.out.println(map);
            }
        }

#### 案例结果 ####

![\[外链图片转存失败(img-tuwttTtM-1562515862581)(img/26.bmp)\]][img-tuwttTtM-1562515862581_img_26.bmp]

### 5)query使用BeanPropertyRowMapper做映射返回对象封装成List ###

#### 目标 ####

将数据库中的所有学生数据封装到JavaBean即Student类的对象中。多个对象需要放到List集合中， List。

#### 方法介绍 ####

public <T> List<T> query(String sql, RowMapper<T> rowMapper)执行查询语句，返回一个List集合，List中存放的是RowMapper指定类型的数据。

说明：  
1）query()必须要指定查询的结果集与JavaBean属性之间的对应关系，而结果集与JavaBean属性之间的对应关系需要传递一个接口作为query方法参数来确定。这个接口就是：RowMapper。  
而RowMapper属于接口，不能创建对象，我们使用其实现类BeanPropertyRowMapper来创建对象。  
BeanPropertyRowMapper类如下所示：

public class BeanPropertyRowMapper<T> implements RowMapper<T>

我们发现：BeanPropertyRowMapper类实现了RowMapper接口。所以我们只需要创建BeanPropertyRowMapper类的对象，然后将创建好的对象作 为query方法的第二个参数传递即可。  
2）BeanPropertyRowMapper类的构造方法说明：BeanPropertyRowMapper(Class mappedClass)  
补充：mappedClass表示某个类的Class对象，这里我们在使用的时候只需要在构造方法中给某个类的.class即可。  
例如：Student.class。  
只要我们给某个类的.class对象，在底层那么就会将数据库表中对应的字段值给这个类的成员变量赋值，所以在创建JavaBean的时候，要求成员变量名一定要和数据库表中的字段名一致，这样才可以完成封装。  
使用举例：

List<Student> students = jdbcTemplate.query("select * from student", new BeanPropertyRowMapper<>(Student.class));

#### 使用步骤 ####

1.  定义Student类
2.  创建JdbcTemplate对象
3.  编写查询的SQL语句
4.  使用JdbcTemplate对象的query方法，并传入BeanPropertyRowMapper对象

#### 案例代码 ####

/**
         * 查询所有的学生
         */
        @Test
        public void findAll() {
        
            List<Student> students = jdbcTemplate.query("select * from student", new BeanPropertyRowMapper<>(Student.class));
            for (Student student : students) {
        
                System.out.println(student);
            }
        }

#### 案例结果 ####

![\[外链图片转存失败(img-RwaVK9pm-1562515862581)(img/27.bmp)\]][img-RwaVK9pm-1562515862581_img_27.bmp]

注意：

1）JdbcTemplate的query()方法用于执行DQL语句，简化JDBC的代码。同时还可以在SQL语句中使用？占位符通过在query方法的Object… args可变参数中传入对应的参数。

2）使用BeanPropertyRowMapper类向Javabean封装数据的前提是，Javabean的属性名必须和数据库的字段名一致。

**3）从今天开始，Javabean中的所有的成员变量的数据类型如果是基本数据类型，都书写对应的包装类型，基本数据类型不能封装null。**

**例如：int—》要定义成Integer类型。**

[img-Q9COVeFg-1562515862571_img_sql_.bmp]: /images/20211213/b6062c579d1a4a25936ca09c1aa985fe.png
[com.itheima.web]: http://com.itheima.web
[img-ptwS5FXc-1562515862572_img_.bmp]: /images/20211213/f05b6eaec1054e329fa29485bb7819d4.png
[img-TgLIpmCJ-1562515862572_img_jdbc_.bmp]: /images/20211213/45450e1142fa47478b41c39012805719.png
[img-fJZlgkh9-1562515862573_img_.bmp]: /images/20211213/1f712e3db1034a1e932a35c256fb56af.png
[img-j6FvcnAI-1562515862573_img_1550387401441.png]: /images/20211213/e59fbc63d33149ca84d5e94d97bb857f.png
[img-YU70lM2H-1562515862573_img_c3p0_.bmp]: /images/20211213/c28b0f400795467c819dcf18984a0083.png
[img-zKmnjavx-1562515862574_img_1.bmp]: /images/20211213/ebdd30e30de44edba082cf95ebc95738.png
[img-JEayaY3s-1562515862574_img_2.bmp]: /images/20211213/5de5ce22ea454a57b79383b4d696e67f.png
[img-n48M5PuS-1562515862574_img_3.bmp]: /images/20211213/4a1f0ea36a2247c49dc5f06706b346de.png
[img-jtGIy2qA-1562515862574_img_4.bmp]: /images/20211213/4f274c9973304184b1aee6a6d3186015.png
[img-ibeo3JaF-1562515862574_img_5.bmp]: /images/20211213/bcd3b00e83634e4082d53552bde72861.png
[img-7HI3xIfp-1562515862575_img_6.bmp]: /images/20211213/8bb82dd85fe64dc3aaab356ac7276dd6.png
[img-CeqSv7i4-1562515862575_img_7.bmp]: /images/20211213/302a3424c7094832b4082a2975f40244.png
[img-KrsRmSjl-1562515862575_img_8.bmp]: /images/20211213/3adf25100e574091aabda544dd469871.png
[img-r6AYh2u0-1562515862575_img_9.bmp]: /images/20211213/383b15d20da047ac80dfe97de622e77b.png
[img-gV8SCpKc-1562515862576_img_10.bmp]: /images/20211213/2e804ab295554ed1afa836a786b2efaa.png
[https_github.com_alibaba_druid]: https://github.com/alibaba/druid
[img-aZFnPbj7-1562515862576_img_1550388331344.png]: /images/20211213/da30ae982ce44b3ca49e94d1b9b185fb.png
[img-tuZdYYen-1562515862576_img_11.bmp]: /images/20211213/73d8489bece041e8a97d501d6f65e8db.png
[img-KpoEtMrT-1562515862576_img_12.bmp]: /images/20211213/f0619af848094dcb9e79891154b4c682.png
[img-xxCXiIm5-1562515862577_img_13.bmp]: /images/20211213/f1158d14ab9647149e692f8f5e8b20d3.png
[img-omMH3Uzk-1562515862577_img_14.bmp]: /images/20211213/93624e0ec5d74cbfac9b9d694aacb0de.png
[img-WXcNWKBv-1562515862577_img_15.bmp]: /images/20211213/ddd5d22b7c874b7b854a0fca4a57fd88.png
[http_projects.spring.io_spring-framework]: http://projects.spring.io/spring-framework/
[img-1qHEdTNA-1562515862577_img_16.bmp]: /images/20211213/daadd516db47485aa72aa5c90f25bf38.png
[img-abIjJPep-1562515862578_img_17.bmp]: /images/20211213/d11d819fee3e481a96974058a07c1487.png
[img-bkmpGR35-1562515862578_img_18.bmp]: /images/20211213/2f17902cb97b41b5a905f18ea304c44a.png
[img-VJbIaNuJ-1562515862578_img_19.bmp]: /images/20211213/6ba5d7ada33f4b94962d5d02800ff6d2.png
[img-bo87Ad0n-1562515862579_img_20.bmp]: /images/20211213/5acf223bce004a80a59a0c6d2ec16a0b.png
[img-Ro4AjuXH-1562515862579_img_21.bmp]: /images/20211213/74a260edbc234decb10fe85402cf03f2.png
[img-L9wRTwR5-1562515862579_img_22.bmp]: /images/20211213/abd073740a7e4fb1897f980768c32934.png
[img-wKetceJV-1562515862579_img_23.bmp]: /images/20211213/6dc09ed46dce4b5bbb8ef3e3dab0b6eb.png
[img-YS2kYV5N-1562515862580_img_24.bmp]: /images/20211213/5f020012d2f9464a920de149f64564dd.png
[img-wjX1LnfD-1562515862580_img_25.bmp]: /images/20211213/c990e6d6f71b4cd5b21b0496496f938b.png
[img-tuwttTtM-1562515862581_img_26.bmp]: /images/20211213/c3ed2fb3e00346e2a98a8c178450d200.png
[img-RwaVK9pm-1562515862581_img_27.bmp]: /images/20211213/495719d9045242d9be2a80fff55e785b.png