顶级架构师学习——第七阶段：我的JDBC，在哪里？

痛定思痛。 2021-09-27 15:16 293阅读 0赞

这一次学习使用JDBC来操作数据库。

1、什么是JDBC?

JDBC（Java DataBase Connectivity）就是Java数据库连接，说白了就是用Java语言来操作数据库。原来我们操作数据库是在控制台使用SQL语句来操作数据库，JDBC是用Java语言向数据库发送SQL语句。

2、JDBC原理

早期SUN公司的天才们想编写一套可以连接天下所有数据库的API，但是当他们刚刚开始时就发现这是不可完成的任务，因为各个厂商的数据库服务器差异太大了。后来SUN开始与数据库厂商们讨论，最终得出的结论是，由SUN提供一套访问数据库的规范（就是一组接口），并提供连接数据库的协议标准，然后各个数据库厂商会遵循SUN的规范提供一套访问自己公司的数据库服务器的API出现。SUN提供的规范命名为JDBC，而各个厂商提供的，遵循了JDBC规范的，可以访问自己数据库的API被称之为驱动！

![70][]

JDBC是接口，而JDBC驱动才是接口的实现，没有驱动无法完成数据库连接！每个数据库厂商都有自己的驱动，用来连接自己公司的数据库。当然还有第三方公司专门为某一数据库提供驱动，不过这样的驱动往往不是开源免费的！

3、JDBC核心接口介绍

JDBC中的核心类有：DriverManager、Connection、Statement，和ResultSet！

DriverManger（驱动管理器）的作用有两个：

1.  注册驱动：这可以让JDBC知道要使用的是哪个驱动；
2.  获取Connection：如果可以获取到Connection，那么说明已经与数据库连接上了。

Connection对象表示连接，与数据库的通讯都是通过这个对象展开的：

1.  Connection最为重要的一个方法就是用来获取Statement对象；
2.  Statement是用来向数据库发送SQL语句的，这样数据库就会执行发送过来的SQL语句
3.  void executeUpdate(String sql)：执行更新操作（insert、update、delete等）；
4.  ResultSet executeQuery(String sql)：执行查询操作，数据库在执行查询后会把查询结果，查询结果就是ResultSet；

ResultSet对象表示查询结果集，只有在执行查询操作后才会有结果集的产生。结果集是一个二维的表格，有行有列。操作结果集要学习移动ResultSet内部的“行光标”，以及获取当前行上的每一列上的数据：

1.  boolean next()：使“行光标”移动到下一行，并返回移动后的行是否存在；
2.  XXX getXXX(int col)：获取当前行指定列上的值，参数就是列数，列数从1开始，而不是0。

4、hello JDBC（一个简单的示例程序，感谢IT黑马的Never Say Never老师提供）

下面开始编写第一个JDBC程序

单元测试junit来对编写的代码进行测试。

**4.1 导入mysql数据库的驱动jar包：**

mysql-connector-java-5.1.39-bin.jar；

**4.2 注册驱动**

**看清楚了，注册驱动就只有一句话：Class.forName(“com.mysql.jdbc.Driver”)，下面的内容都是对这句代码的解释。今后我们的代码中，与注册驱动相关的代码只有这一句。**

DriverManager类的registerDriver()方法的参数是java.sql.Driver，但java.sql.Driver是一个接口，实现类由mysql驱动来提供，mysql驱动中的java.sql.Driver接口的实现类为com.mysql.jdbc.Driver！那么注册驱动的代码如下：

DriverManager.registerDriver(new com.mysql.jdbc.Driver());

上面代码虽然可以注册驱动，但是出现硬编码（代码依赖mysql驱动jar包），如果将来想连接Oracle数据库，那么必须要修改代码的。并且其实这种注册驱动的方式是注册了两次驱动！

JDBC中规定，驱动类在被加载时，需要自己“主动”把自己注册到DriverManger中，下面我们来看看com.mysql.jdbc.Driver类的源代码：

com.mysql.jdbc.Driver.java

com.mysql.jdbc.Driver类中的static块会创建本类对象，并注册到DriverManager中。这说明只要去加载com.mysql.jdbc.Driver类，那么就会执行这个static块，从而也就会把com.mysql.jdbc.Driver注册到DriverManager中，所以可以把**注册驱动类**的代码修改为**加载驱动类**。

Class.forName(“com.mysql.jdbc.Driver”);

**4.3 获取连接**

获取连接需要两步，一是使用DriverManager来注册驱动，二是使用DriverManager来获取Connection对象。

获取连接的也只有一句代码：

DriverManager.getConnection(url,username,password)，

其中username和password是登录数据库的用户名和密码，如果我没说错的话，你的mysql数据库的用户名和密码分别是：root、123。

url查对复杂一点，它是用来找到要连接数据库“网址”，就好比你要浏览器中查找百度时，也需要提供一个url。下面是mysql的url：

jdbc:mysql://localhost:3306/mydb1

JDBC规定url的格式由三部分组成，每个部分中间使用冒号分隔。

1.  第一部分是jdbc，这是固定的；
2.  第二部分是数据库名称，那么连接mysql数据库，第二部分当然是mysql了；
3.  第三部分是由数据库厂商规定的，我们需要了解每个数据库厂商的要求，mysql的第三部分分别由数据库服务器的IP地址（localhost）、端口号（3306），以及DATABASE名称(mydb1)组成。

下面是获取连接的语句：

Connection con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/web08”,”root”,”root”);

还可以在url中提供参数：

jdbc:mysql://localhost:3306/web08**?useUnicode=true&characterEncoding=UTF8**

useUnicode参数指定这个连接数据库的过程中，使用的字节集是Unicode字节集；

characherEncoding参数指定穿上连接数据库的过程中，使用的字节集编码为UTF-8编码。请注意，mysql中指定UTF-8编码是给出的是UTF8，而不是UTF-8。要小心了！

**4.4 获取Statement**

在得到Connectoin之后，说明已经与数据库连接上了，下面是通过Connection获取Statement对象的代码：

Statement stmt = con.createStatement();

Statement是用来向数据库发送要执行的SQL语句的！

**4.5 发送SQL查询语句**

String sql = “select \* from user”;

ResultSet rs = stmt.executeQuery(sql);

请注意，执行查询使用的不是executeUpdate()方法，而是executeQuery()方法。executeQuery()方法返回的是ResultSet，ResultSet封装了查询结果，我们称之为结果集。

**4.6 读取结果集中的数据**

ResultSet就是一张二维的表格，它内部有一个“行光标”，光标默认的位置在“第一行上方”，我们可以调用rs对象的next()方法把“行光标”向下移动一行，当第一次调用next()方法时，“行光标”就到了第一行记录的位置，这时就可以使用ResultSet提供的getXXX(int col)方法来获取指定列的数据了：

rs.next();//光标移动到第一行

rs.getInt(1);//获取第一行第一列的数据

当你使用rs.getInt(1)方法时，你必须可以肯定第1列的数据类型就是int类型，如果你不能肯定，那么最好使用rs.getObject(1)。在ResultSet类中提供了一系列的getXXX()方法，比较常用的方法有：

Object getObject(int col)

String getString(int col)

int getInt(int col)

double getDouble(int col)

**4.7 关闭**

与IO流一样，使用后的东西都需要关闭！关闭的顺序是先得到的后关闭，后得到的先关闭。

rs.close();

stmt.close();

con.close();

**4.8 完成查询操作代码 **

<table style="width:464.3pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:464.3pt;"> public&nbsp;static&nbsp;Connection getConnection() throws&nbsp;Exception { Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/web08"; return&nbsp;DriverManager.getConnection(url, "root", "root"); } </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:464.3pt;"> @Test public&nbsp;void&nbsp;query() throws&nbsp;Exception { Connection con = getConnection(); Statement stmt = con.createStatement(); String sql = "select * from user"; ResultSet rs = stmt.executeQuery(sql); while(rs.next()) { String username = rs.getString(1); String password = rs.getString(2); System.out.println(username + ", "&nbsp;+ password); } } </td> 
 </tr> 
 </tbody> 
</table>

**4.9 规范化代码**

所谓规范化代码就是无论是否出现异常，都要关闭ResultSet、Statement，以及Connection，如果你还记得IO流的规范化代码，那么下面的代码你就明白什么意思了。

<table style="width:464.3pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:464.3pt;"> @Test public&nbsp;void&nbsp;query() { Connection con = null; Statement stmt = null; ResultSet rs = null; try&nbsp;{ con = getConnection(); stmt = con.createStatement(); String sql = "select * from user"; rs = stmt.executeQuery(sql); while(rs.next()) { String username = rs.getString(1); String password = rs.getString(2); System.out.println(username + ", "&nbsp;+ password); } } catch(Exception e) { throw&nbsp;new&nbsp;RuntimeException(e); } finally&nbsp;{ try&nbsp;{ if(rs != null) rs.close(); if(stmt != null) stmt.close(); if(con != null) con.close(); } catch(SQLException e) {} } } </td> 
 </tr> 
 </tbody> 
</table>

5、JDBC对象介绍

**1 JDBC中的主要类（接口）**

在JDBC中常用的类有：

1.  DriverManager；
2.  Connection；
3.  Statement；
4.  ResultSet。

**2 DriverManager**

其实我们今后只需要会用DriverManager的getConnection()方法即可：

Class.forName(“com.mysql.jdbc.Driver”);//注册驱动

String url = “jdbc:mysql://localhost:3306/web08”;

String username = “root”;

String password = “root”;

Connection con = DriverManager.getConnection(url, username, password);

注意，上面代码可能出现的两种异常：

ClassNotFoundException：这个异常是在第1句上出现的，出现这个异常有两个可能：

1.  你没有给出mysql的jar包；
2.  你把类名称打错了，查看类名是不是com.mysql.jdbc.Driver。

SQLException：这个异常出现在第5句，出现这个异常就是三个参数的问题，往往username和password一般不是出错，所以需要认真查看url是否打错。

对于DriverManager.registerDriver()方法了解即可，因为我们今后注册驱动只会Class.forName()，而不会使用这个方法。

**3 Connection**

Connection最为重要的方法就是获取Statement：

1.  Statement stmt = con.createStatement();

后面在学习ResultSet方法时，还要学习一下下面的方法：

1.  Statement stmt = con.createStatement(int,int);

**4 Statement**

Statement最为重要的方法是：

1.  int executeUpdate(String sql)：执行更新操作，即执行insert、update、delete语句，其实这个方法也可以执行create table、alter table，以及drop table等语句，但我们很少会使用JDBC来执行这些语句；
2.  ResultSet executeQuery(String sql)：执行查询操作，执行查询操作会返回ResultSet，即结果集。
3.  boolean execute()

Statement还有一个boolean execute()方法，这个方法可以用来执行增、删、改、查所有SQL语句。该方法返回的是boolean类型，表示SQL语句是否执行成功。

如果使用execute()方法执行的是更新语句，那么还要调用int getUpdateCount()来获取insert、update、delete语句所影响的行数。

如果使用execute()方法执行的是查询语句，那么还要调用ResultSet getResultSet()来获取select语句的查询结果。

**5 ResultSet之滚动结果集（了解）**

ResultSet表示结果集，它是一个二维的表格！ResultSet内部维护一个行光标（游标），ResultSet提供了一系列的方法来移动游标：

1.  void beforeFirst()：把光标放到第一行的前面，这也是光标默认的位置；
2.  void afterLast()：把光标放到最后一行的后面；
3.  boolean first()：把光标放到第一行的位置上，返回值表示调控光标是否成功；
4.  boolean last()：把光标放到最后一行的位置上；
5.  boolean isBeforeFirst()：当前光标位置是否在第一行前面；
6.  boolean isAfterLast()：当前光标位置是否在最后一行的后面；
7.  boolean isFirst()：当前光标位置是否在第一行上；
8.  boolean isLast()：当前光标位置是否在最后一行上；
9.  boolean previous()：把光标向上挪一行；
10. boolean next()：把光标向下挪一行；
11. boolean relative(int row)：相对位移，当row为正数时，表示向下移动row行，为负数时表示向上移动row行；
12. boolean absolute(int row)：绝对位移，把光标移动到指定的行上；
13. int getRow()：返回当前光标所有行。

上面方法分为两类，一类用来判断游标位置的，另一类是用来移动游标的。如果结果集是不可滚动的，那么只能使用next()方法来移动游标，而beforeFirst()、afterLast()、first()、last()、previous()、relative()方法都不能使用！！！

结果集是否支持滚动，要从Connection类的createStatement()方法说起。也就是说创建的Statement决定了使用Statement创建的ResultSet是否支持滚动。

Statement createStatement(int resultSetType, int resultSetConcurrency)

resultSetType的可选值：

1.  ResultSet.TYPE\_FORWARD\_ONLY：不滚动结果集；
2.  ResultSet.TYPE\_SCROLL\_INSENSITIVE：滚动结果集，但结果集数据不会再跟随数据库而变化；
3.  ResultSet.TYPE\_SCROLL\_SENSITIVE：滚动结果集，但结果集数据不会再跟随数据库而变化；

可以看出，如果想使用滚动的结果集，我们应该选择TYPE\_SCROLL\_INSENSITIVE！其实很少有数据库驱动会支持TYPE\_SCROLL\_SENSITIVE的特性！通常我们也不需要查询到的结果集再受到数据库变化的影响。

resultSetConcurrency的可选值：

1.  CONCUR\_READ\_ONLY：结果集是只读的，不能通过修改结果集而反向影响数据库；
2.  CONCUR\_UPDATABLE：结果集是可更新的，对结果集的更新可以反向影响数据库。

通常可更新结果集这一“高级特性”我们也是不需要的！

获取滚动结果集的代码如下：

Connection con = …

Statement stmt = con.createStatement(ResultSet.TYPE\_SCROLL\_INSENSITIVE, CONCUR\_READ\_ONLY);

String sql = …//查询语句

ResultSet rs = stmt.executeQuery(sql);//这个结果集是可滚动的

**6 ResultSet之获取列数据**

可以通过next()方法使ResultSet的游标向下移动，当游标移动到你需要的行时，就需要来获取该行的数据了，ResultSet提供了一系列的获取列数据的方法：

1.  String getString(int columnIndex)：获取指定列的String类型数据；
2.  int getInt(int columnIndex)：获取指定列的int类型数据；
3.  double getDouble(int columnIndex)：获取指定列的double类型数据；
4.  boolean getBoolean(int columnIndex)：获取指定列的boolean类型数据；
5.  Object getObject(int columnIndex)：获取指定列的Object类型的数据。

上面方法中，参数columnIndex表示列的索引，列索引从1开始，而不是0，这第一点与数组不同。如果你清楚当前列的数据类型，那么可以使用getInt()之类的方法来获取，如果你不清楚列的类型，那么你应该使用getObject()方法来获取。

ResultSet还提供了一套通过列名称来获取列数据的方法：

1.  String getString(String columnName)：获取名称为columnName的列的String数据；
2.  int getInt(String columnName)：获取名称为columnName的列的int数据；
3.  double getDouble(String columnName)：获取名称为columnName的列的double数据；
4.  boolean getBoolean(String columnName)：获取名称为columnName的列的boolean数据；
5.  Object getObject(String columnName)：获取名称为columnName的列的Object数据；

### PreparedStatement ###

**1 什么是SQL攻击**

在需要用户输入的地方，用户输入的是SQL语句的片段，最终用户输入的SQL片段与我们DAO中写的SQL语句合成一个完整的SQL语句！例如用户在登录时输入的用户名和密码都是为SQL语句的片段！

**2 演示SQL攻击**

首先我们需要创建一张用户表，用来存储用户的信息。

<table style="width:464.3pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:464.3pt;"> CREATE TABLE user( uid CHAR(32) PRIMARY KEY, username VARCHAR(30) UNIQUE KEY NOT NULL, PASSWORD VARCHAR(30) ); &nbsp; INSERT INTO user VALUES('U_1001', 'zs', 'zs'); SELECT * FROM user; </td> 
 </tr> 
 </tbody> 
</table>

现在用户表中只有一行记录，就是zs。

下面我们写一个login()方法！

<table style="width:464.3pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:464.3pt;"> public&nbsp;void&nbsp;login(String username, String password) { Connection con = null; Statement stmt = null; ResultSet rs = null; try&nbsp;{ con = JdbcUtils.getConnection(); stmt = con.createStatement(); String sql = "SELECT * FROM user WHERE "&nbsp;+ "username='"&nbsp;+ username + "' and password='"&nbsp;+ password + "'"; rs = stmt.executeQuery(sql); if(rs.next()) { System.out.println("欢迎"&nbsp;+ rs.getString("username")); } else&nbsp;{ System.out.println("用户名或密码错误！"); } } catch&nbsp;(Exception e) { throw&nbsp;new&nbsp;RuntimeException(e); } finally&nbsp;{ JdbcUtils.close(con, stmt, rs); } } </td> 
 </tr> 
 </tbody> 
</table>

下面是调用这个方法的代码：

<table style="width:464.3pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:464.3pt;"> login("a' or 'a'='a", "a' or 'a'='a"); </td> 
 </tr> 
 </tbody> 
</table>

这行当前会使我们登录成功！因为是输入的用户名和密码是SQL语句片段，最终与我们的login()方法中的SQL语句组合在一起！我们来看看组合在一起的SQL语句：

<table style="width:464.3pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:464.3pt;"> SELECT * FROM tab_user WHERE&nbsp;username='a' or 'a'='a' and password='a' or 'a'='a' </td> 
 </tr> 
 </tbody> 
</table>

**3 防止SQL攻击**

1.  过滤用户输入的数据中是否包含非法字符；
2.  分步校验！先使用用户名来查询用户，如果查找到了，再比较密码；
3.  使用PreparedStatement。

**4 PreparedStatement是什么？**

PreparedStatement叫预编译声明！

PreparedStatement是Statement的子接口，你可以使用PreparedStatement来替换Statement。

PreparedStatement的好处：

1.  防止SQL攻击；
2.  提高代码的可读性，以可维护性；
3.  提高效率。

**5 PreparedStatement的使用**

1.  使用Connection的prepareStatement(String sql)：即创建它时就让它与一条SQL模板绑定；
2.  调用PreparedStatement的setXXX()系列方法为问号设置值
3.  调用executeUpdate()或executeQuery()方法，但要注意，调用没有参数的方法；

<table style="width:426.1pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:426.1pt;"> String sql = “select * from tab_student where s_number=?”; PreparedStatement pstmt = con.prepareStatement(sql); pstmt.setString(1, “S_1001”); ResultSet rs = pstmt.executeQuery(); rs.close(); pstmt.clearParameters(); pstmt.setString(1, “S_1002”); rs = pstmt.executeQuery(); </td> 
 </tr> 
 </tbody> 
</table>

在使用Connection创建PreparedStatement对象时需要给出一个SQL模板，所谓SQL模板就是有“?”的SQL语句，其中“?”就是参数。

在得到PreparedStatement对象后，调用它的setXXX()方法为“?”赋值，这样就可以得到把模板变成一条完整的SQL语句，然后再调用PreparedStatement对象的executeQuery()方法获取ResultSet对象。

注意PreparedStatement对象独有的executeQuery()方法是没有参数的，而Statement的executeQuery()是需要参数（SQL语句）的。因为在创建PreparedStatement对象时已经让它与一条SQL模板绑定在一起了，所以在调用它的executeQuery()和executeUpdate()方法时就不再需要参数了。

PreparedStatement最大的好处就是在于重复使用同一模板，给予其不同的参数来重复的使用它。这才是真正提高效率的原因。

**所以，建议大家在今后的开发中，无论什么情况，都去需要PreparedStatement，而不是使用Statement。**

5、连接池以及工具类的使用

为了方便讲解，这里将两个单元合并。

我们从上面的代码中可以看到，每一次使用JDBC来操作数据库都有很大一部分的重复代码，冗余十分严重，为了减少代码量，我们自然而然的想到了使用工具类！

**自定义工具类简化连接**

这里给出一个简单的工具类的代码：

public class JDBCUtils_V3 {
    	private static String driver;
    	private static String url;
    	private static String username;
    	private static String password;
    
    	/**
    	 * 静态代码块加载配置文件信息
    	 */
    	static {
    		try {
    			// 1.通过当前类获取类加载器
    			ClassLoader classLoader = JDBCUtils_V3.class.getClassLoader();
    			// 2.通过类加载器的方法获得一个输入流
    			InputStream is = classLoader.getResourceAsStream("db.properties");
    			// 3.创建一个properties对象
    			Properties props = new Properties();
    			// 4.加载输入流
    			props.load(is);
    			// 5.获取相关参数的值
    			driver = props.getProperty("driver");
    			url = props.getProperty("url");
    			username = props.getProperty("username");
    			password = props.getProperty("password");
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    	/**
    	 * 获取连接方法
    	 * 
    	 * @return
    	 */
    	public static Connection getConnection() {
    		Connection conn = null;
    		try {
    			Class.forName(driver);
    			conn = DriverManager.getConnection(url, username, password);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return conn;
    	}
    
    	public static void release(Connection conn, PreparedStatement pstmt, ResultSet rs) {
    		if (rs != null) {
    			try {
    				rs.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    		if (pstmt != null) {
    			try {
    				pstmt.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    		if (conn != null) {
    			try {
    				conn.close();
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    
    	}
    }

我们可以通过调用getConnection()和release()方法来轻松的获取和断开数据库的连接。

**连接池**

这里介绍两种类型的连接池C3P0以及DBCP，我们将使用这两种连接池完成对数据库的基本操作。

1.连接池的概念

用池来管理Connection，这样可以重复使用Connection。有了池，所以我们就不用自己来创建Connection对象，而是从连接池中取得对象，在使用完后调用Connection的close()方法也不会销毁Connection，而是将Connection返回给连接池。池就可以再一次的使用这个Connection对象。

2.规范

Java为数据库连接池提供了公共接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口，这样应用程序可以方便的切换不同的厂商。

3.一个简单的自定义连接池的实例

public class MyDataSource implements DataSource{
 	// 创建一个List集合用于存放多个连接对象.
 	private List<Connection> list = new ArrayList<Connection>();
 	// 在程序开始的时候，初始化几个连接,将连接存放到list中.
 	public MyDataSource() {
 		// 初始化3个连接:
 		for(int i=1;i<=3;i++){
 			Connection conn = JDBCUtils.getConnection();
 			list.add(conn);
 		}
 	}
 	
 	@Override
 	// 获得连接的方法：
 	public Connection getConnection() throws SQLException {
 		if(list.size() <= 0){
 			for(int i=1;i<=3;i++){
 				Connection conn = JDBCUtils.getConnection();
 				list.add(conn);
 			}	
 		}
 		Connection conn = list.remove(0);
 		return conn;
 	}
 	
 	// 归还连接的方法：
 	public void addBack(Connection conn){
 		list.add(conn);
 	}
 ...
 }

4.自定义连接池的常见问题及其解决

**问题?**

1.  如果使用自定义连接池,那么需要额外记住自定义连接池中的API.
2.  能不能使用面向接口的编程方式.

**解决：**

**不额外提供API方法，就可以解决上述两个问题！！！**

能不能还调用Connection的close方法.能不能增强Connection的close方法,原有的销毁变为归还!!!

**如何增强Connection的close方法:**

**\* 增强一个Java类中的某个方法有几种方式???**

**    \* 第一种方式：继承的方式.**

** \* 能够控制这个类的构造的时候,才可以使用继承.**

**    \* 第二种方式：装饰者模式方式.**

**        ****\* 包装对象和被包装的对象都要实现相同的接口.**

**        \* 包装的对象中需要获得到被包装对象的引用.**

**        \*\*\*\*\* 缺点：如果接口的方法比较多,增强其中的某个方法.其他的功能的方法需要原有调用.**

**    \* 第三种方式：动态代理的方式.**

**        ****\* 被增强的对象实现接口就可以.**

下面分别给出继承和装饰者来解决问题的过程代码

**继承**

/**
     * 继承的方式增强一个类中某个方法:
     */
    class Man{
    	public void run(){
    		System.out.println("跑....");
    	}
    }
     
    class SuperMan extends Man{
    	public void run(){
    		// super.run();
    		System.out.println("飞....");
    	}
    }
     
    /**
     * 使用装饰者的方式完成类的方法的增强
     */
    interface Waiter{
    	public void server();
    }
     
    class Waiteress implements Waiter{
     
    	@Override
    	public void server() {
    		System.out.println("服务...");
    	}
    	
    }
     
    class WaiteressWrapper implements Waiter{
        private Waiter waiter;
     
    	public WaiteressWrapper(Waiter waiter) {
        	this.waiter = waiter;
    	}
    	
    	@Override
    	public void server() {
    		System.out.println("微笑...");
    		// this.waiter.server();
    		
    	}
    	
    }

**使用装饰者模式增强Connection的close方法**

public class MyConnection implements Connection{
 
 	private Connection conn;
 	private List<Connection> list;
 
 	public MyConnection(Connection conn,List<Connection> list) {
 		this.conn = conn;
 		this.list = list;
 	}
 
 
 	@Override
 	public void close() throws SQLException {
 		list.add(conn);
 	}
 ...
 }
 
 连接池的getConnection方法：
 	@Override
 	// 获得连接的方法：
 	public Connection getConnection() throws SQLException {
 		if(list.size() <= 0){
 			for(int i=1;i<=3;i++){
 				Connection conn = JDBCUtils.getConnection();
 				list.add(conn);
 			}	
 		}
 		Connection conn = list.remove(0);
 		MyConnection myConn = new MyConnection(conn, list);
 		return myConn;
 	}

5.常见开源数据库连接池

**DBCP**

DBCP(DataBase connection pool),[数据库连接池][Link 1]。是 apache 上的一个 java 连接池项目，也是 tomcat 使用的连接池组件。单独使用dbcp需要2个包：commons-dbcp.jar,commons-pool.jar由于建立数据库连接是一个非常耗时[耗资源][Link 2]的行为，所以通过连接池预先同数据库建立一些连接，放在内存中，应用程序需要建立数据库连接时直接到连接池中申请一个就行，用完后再放回去。

它的使用很简单：

第一步：引入DBCP连接池的jar包.

第二步：编写DBCP代码：

\* 手动设置参数

\* 配置文件设置参数

// DBCP连接池的使用
    	@Test
    	/**
    	 * 手动方式:
    	 */
    	public void demo1(){
    		Connection conn = null;
    		PreparedStatement stmt = null;
    		ResultSet rs = null;
    		BasicDataSource dataSource = new BasicDataSource();
    		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    		dataSource.setUrl("jdbc:mysql:///web_07");
    		dataSource.setUsername("root");
    		dataSource.setPassword("123");
    		try{
    			// 获得连接:
    			conn = dataSource.getConnection();
    			// 编写SQL:
    			String sql = "select * from category";
    			// 预编译SQL:
    			stmt = conn.prepareStatement(sql);
    			// 执行SQL:
    			rs = stmt.executeQuery();
    			while(rs.next()){
    				System.out.println(rs.getInt("cid")+"   "+rs.getString("cname"));
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}finally{
    			JDBCUtils.release(rs, stmt, conn);
    		}
    	}
    	
    	@Test
    	/**
    	 * 配置文件方式：
    	 */
    	public void demo2(){
    		Connection conn = null;
    		PreparedStatement stmt = null;
    		ResultSet rs = null;
    		Properties properties = new Properties();
    		
    		try{
    			properties.load(new FileInputStream("src/dbcpconfig.properties"));
    			DataSource dataSource = BasicDataSourceFactory.createDataSource(properties);
    			// 获得连接:
    			conn = dataSource.getConnection();
    			// 编写SQL:
    			String sql = "select * from category";
    			// 预编译SQL:
    			stmt = conn.prepareStatement(sql);
    			// 执行SQL:
    			rs = stmt.executeQuery();
    			while(rs.next()){
    				System.out.println(rs.getInt("cid")+"   "+rs.getString("cname"));
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}finally{
    			JDBCUtils.release(rs,stmt, conn);
    		}
    	}

由于DBCP加载的是.properties文件，而在实际项目中使用的更多的是xml文件，也就是下面要说的C3P0连接池所使用的，因此，对应DBCP连接池，仅做了解即可。

**C3P0**

C3P0是一个开源的JDBC[连接池][Link 3]，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的[开源项目][Link 4]有Hibernate，Spring等。

C3P0的使用：

第一步：引入C3P0连接池的jar包.

第二步：编写代码：

\* 手动设置参数

\* 配置文件设置参数

它获取连接池的方式与DBCP不同，使用ComboPooledDataSource。

public class JDBCUtils2 {
    	private static final ComboPooledDataSource DATA_SOURCE =new ComboPooledDataSource();
    	/**
    	 * 获得连接的方法
    	 */
    	public static Connection getConnection(){
    		Connection conn = null;
    		try {
    			conn = DATA_SOURCE.getConnection();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return conn;
    	}
    ...
    }

再重点说说它的配置项。

C3P0有固定的配置文件名称c3p0-config.xml，不能随意更改，文件配置在src路径下，配置文件的具体项下面给出：

命名配置，使用时需要加上配置名称，即下图中的-------->itcast

![70 1][]

当没有指定名称时使用默认配置：

![70 2][]

![70 3][]

常见配置项如下

![70 4][]

![70 5][]

如果需要使用指定的命名配置，可以这样~

// 原代码
    private static final ComboPooledDataSource DATA_SOURCE =new ComboPooledDataSource();
    // 使用itcast命名配置
    private static final ComboPooledDataSource DATA_SOURCE =new ComboPooledDataSource("itcast");

C3P0在工程项目中使用很多，我们在文末会给出代码文件，感谢IT黑马的资料。

6.DBUtil的使用

要使用DBUtil，就要使用到JavaBean。JavaBean我相信你们已经在不知不觉之中使用过了，没错，它就是一个非常普通的类的封装，提供无参构造，只要再加上get和set方法就行了，它需要实现接口java.io.Serializable，不过通常偷懒省略了。

DBUtil是java编程中的数据库操作的实用工具，小巧简单实用，它封装了对JDBC的操作，可以大大减少代码量。DBUtil有三个核心，下面一一进行介绍。

**QueryRunner核心类**

它有三个接口：

QueryRunner(DataSource ds)  提供数据源（连接池）,DBUtil底层自动维护连接Connection

update(String sql, Object... param)  执行更新数据

query(String sql, ResultSetHandler<T> rsh, Object... params)  执行查询

**ResultSetHandler结果集处理类**

它有如下几个类型的Handler，我们只要掌握红色的几个handler即可，其余的如果有时间再继续学习。

![70 6][]

![70 7][]

我们知道在执行select语句之后得到的是ResultSet，然后我们还需要对ResultSet进行转换，得到最终我们想要的数据。你可以希望把ResultSet的数据放到一个List中，也可能想把数据放到一个Map中，或是一个Bean中。

DBUtils提供了一个接口ResultSetHandler，它就是用来ResultSet转换成目标类型的工具。你可以自己去实现这个接口，把ResultSet转换成你想要的类型。

DBUtils提供了很多个ResultSetHandler接口的实现，这些实现已经基本够用了，我们通常不用自己去实现ResultSet接口了。

1. MapHandler：单行处理器！把结果集转换成Map<String,Object>，其中列名为键！
2. MapListHandler：多行处理器！把结果集转换成List<Map<String,Object>>；
3. BeanHandler：单行处理器！把结果集转换成Bean，该处理器需要Class参数，即Bean的类型；
4. BeanListHandler：多行处理器！把结果集转换成List<Bean>；
5. ColumnListHandler：多行单列处理器！把结果集转换成List<Object>，使用ColumnListHandler时需要指定某一列的名称或编号，例如：new ColumListHandler(“name”)表示把name列的数据放到List中。
6. ScalarHandler：单行单列处理器！把结果集转换成Object。一般用于聚集查询，例如select count(\*) from tab\_student。

Map处理器

![70 8][]

Bean处理器

![70 9][]

Column处理器

![70 10][]

Scalar处理器

![70 11][]

**DbUtils工具类**

closeQuietly(Connection conn)  关闭连接，如果有异常try后不抛

commitAndCloseQuietly(Connection conn)  提交并关闭连接

rollbackAndCloseQuietly(Connection conn)  回滚并关闭连接

**示例代码**

public class TestDBUtils1 {
 
 	/**
 	 * 添加用户方法
 	 */
 	@Test
 	public void testAddUser() {
 		try {
 			// 1.创建核心类QueryRunner
 			QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
 			// 2.编写SQL语句
 			String sql = "insert into tbl_user values(null,?,?)";
 			// 3.为站位符设置值
 			Object[] params = { "余淮", "耿耿" };
 			// 4.执行添加操作
 			int rows = qr.update(sql, params);
 			if (rows > 0) {
 				System.out.println("添加成功!");
 			} else {
 				System.out.println("添加失败!");
 			}
 		} catch (SQLException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 	
 	/**
 	 * 根据id修改用户方法
 	 * 
 	 */
 	@Test
 	public void testUpdateUserById() {
 		try {
 			// 1.创建核心类QueryRunner
 			QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
 			// 2.编写SQL语句
 			String sql = "update tbl_user set upassword=? where uid=?";
 			// 3.为站位符设置值
 			Object[] params = { "xxx", 21 };
 			// 4.执行添加操作
 			int rows = qr.update(sql, params);
 			if (rows > 0) {
 				System.out.println("修改成功!");
 			} else {
 				System.out.println("修改失败!");
 			}
 		} catch (SQLException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 	
 	/**
 	 * 根据id删除用户方法
 	 */
 	@Test
 	public void testDeleteUserById() {
 		try {
 			// 1.创建核心类QueryRunner
 			QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
 			// 2.编写SQL语句
 			String sql = "delete from tbl_user where uid=?";
 			// 3.为站位符设置值
 			Object[] params = {19};
 			// 4.执行添加操作
 			int rows = qr.update(sql, params);
 			if (rows > 0) {
 				System.out.println("删除成功!");
 			} else {
 				System.out.println("删除失败!");
 			}
 		} catch (SQLException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 /*
 	 * 查询所有用户方法
 	 */
 	@Test
 	public void testQueryAll() {
 		try {
 			// 1.获取核心类queryRunner
 			QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
 			// 2.编写sql语句
 			String sql = "select * from tbl_user";
 			// 3.执行查询操作
 			List<User> users = qr.query(sql, new BeanListHandler<User>(User.class));
 			// 4.对结果集集合进行遍历
 			for (User user : users) {
 				System.out.println(user.getUname() + " : " + user.getUpassword());
 			}
 		} catch (SQLException e) {
 			throw new RuntimeException(e);
 		}
 	}
 }

关注我们的公众号：落饼枫林，发送  jdbc  即可获得这一次的项目代码，在文章最后，再一次对IT黑马表示感谢！

![70 12][]

[70]: /images/20210923/af8359f97e754126820838adab14dbaf.png
[Link 1]: http://baike.baidu.com/view/84055.htm
[Link 2]: http://baike.baidu.com/view/630544.htm
[Link 3]: http://baike.baidu.com/view/1528732.htm
[Link 4]: http://baike.baidu.com/view/188327.htm
[70 1]: /images/20210923/3c6ef5a6b8a442b99a86727ed6929706.png
[70 2]: /images/20210923/3e5a7b83040c482e825773fb5a75b8e8.png
[70 3]: /images/20210923/15bac188aff64720ac4d363d6cf4fce8.png
[70 4]: /images/20210923/28b4dc70a5004fd3ad56bd386376b0b5.png
[70 5]: /images/20210923/2bd7d283995b46eaa60b787f2a94bbef.png
[70 6]: /images/20210923/90c27031d8e64ad59319d219e9ce1500.png
[70 7]: /images/20210923/5476ab05ae1140b09c09b0d2542272e6.png
[70 8]: /images/20210923/5c46c50f16b24774a4b4d715b6b8490a.png
[70 9]: /images/20210923/77228173ea8f46a19289c43bc8bffca0.png
[70 10]: /images/20210923/9683745de84c40c9babd3187e4f895ac.png
[70 11]: /images/20210923/dd7052853c3045a5a409309171137f30.png
[70 12]: /images/20210923/6d3a1b7735864b98ab962c83890fff54.png