javaweb学习（3）：JDBC进阶之路

最新推荐文章于 2022-07-31 13:43:15 发布

name_s_Jimmy

最新推荐文章于 2022-07-31 13:43:15 发布

阅读量706

点赞数 1

分类专栏： javaWeb 文章标签： java mysql jdbc DBUtils 库

本文链接：https://blog.csdn.net/qq_32166627/article/details/54583621

版权

javaWeb 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

前言：

JDBC学习起来并不难，但是随着学习的深入，涉及到的知识越来越多，见到的框架也越来越多。

于是乎，很有必要对学过的知识做个总结。以下代码都是在eclipse中完成的。

第一章：单连接操作

起初学习jdbc，一上来我们接触到的jdbc就是jdk的标准“单连接”操作，

首先下载jdbc的java包：点击下载jar包

一个完整的标准操作代码应如下所示：

package com.jimmy.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Demo1 {
	public static void main(String[] args) throws Exception {
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rts = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/emp", "root", "123456");
			ps = conn.prepareStatement("select * from emp");
			rts = ps.executeQuery();
			while(rts.next()){
				System.out.println(rts.getObject(2));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {	
			if (rts != null) {				
				try {
					rts.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
				rts = null;
			}
			if (ps != null) {				
				try {
					ps.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
				ps = null;
			}
			if (conn != null) {
				try {
					conn.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
				conn = null;
			}
		}
	}
}

这样操作的弊端显而易见，主要有两方面的缺陷：

1，重复的大量代码在执行相同的操作，如：取得连接，关闭资源等。

2，每次只取得一个连接，然后再关闭，效率极其低下。

针对以上方面的缺点，我们来一一攻破。

第二章：自己写一个封装类

自己写一个类，将获得连接和关闭资源的重复代码封装一下：

1，首先我们在src目录下写一个配置文件：mysqlInfo.properties，将一些配置信息写进去：

 driverClass = com.mysql.jdbc.Driver
 url = jdbc:mysql://localhost:3306/user
 username = root
 password = 123456

2，MyJDBCUtils.java类用于读取配置文件，并封装代码：

package com.jimmy.MyDBUtils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ResourceBundle;

public class MyJDBCUtils {
	//数据库连接用到的字段我们从配置文件中读取
	private static String driverClass;
	private static String url;
	private static String username;
	private static String password;
	//下面的静态代码块就是读取配置文件中的数据
	static{
		ResourceBundle rb = ResourceBundle.getBundle("mysqlInfo");
		driverClass = rb.getString("driverClass");
		url = rb.getString("url");
		username = rb.getString("username");
		password = rb.getString("password");
	}
	//取得连接函数
	public static Connection getConnection() throws Exception {
		Class.forName(driverClass);
		Connection conn = DriverManager.getConnection(url,username, password);
		return conn;
	}
	//关闭资源函数
	public static void closeRes(ResultSet rst, Statement stmt, Connection conn){
		if (rst != null) {				
			try {
				rst.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
			rst = null;
		}
		if (stmt != null) {				
			try {
				stmt.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
			stmt = null;
		}
		if (conn != null) {
			try {
				conn.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
			conn = null;
		}
	}
}

这样一来，我们再写第一章中的代码时，会是如下这个样子：

package com.jimmy.MyDBUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import org.junit.Test;

public class MyJDBCUtilsTest {
	@Test
	public void testSelect() throws Exception{
		Connection conn = null;
		PreparedStatement ps = null;
		
		conn = MyJDBCUtils.getConnection();  //获得连接
		ps = conn.prepareStatement("select * from emp");
		ResultSet rts = ps.executeQuery();
		while (rts.next()) {
			System.out.println(rts.getString(2));
		}
		MyJDBCUtils.closeRes(rts, ps, conn);  //关闭资源
	}
}

这样一来，获得连接和关闭资源的代码被大大的简化了，关键是我们写的封装代码类可以重复使用。

当然，我们只是简单的封装，后面会有第三方jar包完成更简化的封装。

第三章：连接池（也叫数据源）解决单连接问题

我们可以自己写一个类，实现连接池，思路如下：

首先创建10个连接对象conn，然后将这10个conn放到一个List中，每次使用时，从List中取出一个，用完后放回List。较麻烦，就不实现了。

三方库大多都是基于以上思想实现了连接池，那么我们就来介绍一个第三方jar包：C3P0包（点击下载jar包）

下载解压后，将lib包里的c3p0-0.9.1.2.jar添加到BuildPath中去。

1，首先在src路径下新建一个配置文件：“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/user</property>
	<property name="user">root</property>
	<property name="password">123456</property>
    	<property name="initialPoolSize">10</property>
    	<property name="maxIdleTime">30</property>
    	<property name="maxPoolSize">100</property>
    	<property name="minPoolSize">10</property>
  </default-config>
</c3p0-config>

2，新建一个类：C3P0Utils.java，其封装了C3P0提供的一些方法。

package com.jimmy.C3P0;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;


public class C3P0Utils {
	//得到一个数据源（连接池）对象
	private static DataSource ds = new ComboPooledDataSource();
	//对外提供返回数据源的方法
	public static DataSource getDs() { return ds;}
	
	//封装了数据源从池中获取拿到连接的方法
	public static Connection getConnection() {
		try {
			return ds.getConnection();
		} catch (SQLException e) {
			throw new RuntimeException("服务器异常");
		}
	}
	
	//关闭资源方法
	public static void closeRes(Connection conn, Statement stmt, ResultSet rts) {
		if(rts!=null){
			try {
				rts.close();    //关闭对象
			} catch (Exception e) {
				e.printStackTrace();
			}
			rts = null;
		}
		if(stmt!=null){
			try {
				stmt.close();    //关闭对象
			} catch (Exception e) {
				e.printStackTrace();
			}
			stmt = null;
		}
		if(conn!=null){
			try {
				conn.close();   //那么，这里的close()方法不再是关闭连接，而是将conn放回了池中。
			} catch (Exception e) {
				e.printStackTrace();
			}
			conn = null;
		}
	}
}

那么，我们来写一个测试类：

package com.jimmy.C3P0;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.junit.Test;

public class C3P0test {
	@Test
	public void test() {
		Connection conn = null;
		PreparedStatement ps = null;
		
		try {
			conn = C3P0Utils.getConnection();
			ps = conn.prepareStatement("INSERT INTO account(username,money) VALUES(?,?)");
			ps.setString(1, "jimmy");
			ps.setDouble(2, 521);
			ps.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		} finally{
			C3P0Utils.closeRes(conn, ps, null);
		}
	}
}

那么，测试代码看来与第二章中我们自己写的代码很像，不过代码背后真实千差万别。

第四章：DBUtils.jar包

这个包是由apache提供的，是对jdbc的进一步封装（执行sql语句将只有2行代码），并且支持线程池（也叫数据源）。一起来看看吧。

首先下载jar包（点击下载），添加commons-dbutils-1.4.jar到Build Path中。

1，开发中，往往要将数据库中的每条数据封装到一个java对象中去，或者将从网页输入中得到的数据也封装到java对象中去。

所以在使用DBUtils之前，要创建一个实体类，该实体类的成员变量要跟数据库表的列名一样。

比如：DB中有个User表，字段名和类型如下;

id int,
username varchar(20),
password varchar(20),
email varchar(20),
birthday varchar(20)

那么我们就要创建一个java类：

package com.jimmy.DBUtils;

import java.io.Serializable;

public class User implements Serializable{
	//成员变量名应该与DB中表的列名一模一样
	private int id;
	private String username;
	private String password;
	private String email;
	private String birthday;
	
	//自动生成成员变量的set和get方法
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getBirthday() {
		return birthday;
	}
	public void setBirthday(String birthday) {
		this.birthday = birthday;
	}
	
	//toString()方法只是为了看效果。
	@Override
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", password="
				+ password + ", email=" + email + ", birthday=" + birthday
				+ "]";
	}
}

2，本案例要用到连接池，我们用上一章中C3P0Utils.java类提供的返回连接池方法：getDs()方法。

然后我们就可以很轻松地取出数据了。

package com.jimmy.DBUtils;

import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.junit.Test;

import com.jimmy.C3P0.C3P0Utils;

public class DBUtilsCRUDDemo1 {

	
	@Test
	public void testSelect2() throws Exception{
		//1,创建QueryRunner对象,并得到c3p0提供的连接池。
		QueryRunner qr = new QueryRunner(C3P0Utils.getDs());
		//2,当query方法执行了select语句后，将结果集以参数的形式传递给第2个参数，第2个参数将结果封装到User对象中，最后将各个对象放进List中.
		List<User> list = qr.query("select * from user where id=?", new BeanListHandler<User>(User.class),1);
		
		for (User user : list) {
			System.out.println(user);
		}
	}
}

这样就取出了id为1的那行数据。

这样可以看出，操作数据库就只有2行代码了。不仅简化了重复代码，而且使用到了连接池技术。解决了一开始我们提出的2个弊端。

往后还会学习到各种各样的jdbc框架，学到了就再来补充。