12---JDBC

关注

最新推荐文章于 2023-08-25 17:36:53 发布 · 667 阅读

原创 ·

本内容遵循 CC 4.0 BY-SA 版权协议

JDBC连接oracle 12c，数据表转JSON格式啦啦 package data; import java.io.*; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.ResultSetMetaData; import java.sql.SQLException; import java.s 阅读详情

JDBC：

JDBC的全称是Java数据库连接（Java Database Connectivity）,它是一套用于执行SQL语句的Java API。应用程序可通过这套API连接到关系型数据库，并使用SQL语句来完成对数据库中数据的查询、更新、新增和删除的操作。

JDBC编程步骤：

装载相应数据库的JDBC驱动并进行初始化

导入专用的jar包（不同的数据库需要的jar包不同）

访问MySQL数据库需要用到第三方的类，这些第三方的类，都被压缩在一个.Jar的文件里。mysql-connector-java-5.0.8-bin.jar包可以在网上下载，或者在MySQL的安装目录下找到。通常下载到该jar包之后将其放到在项目的lib目录下。

初始化驱动

通过初始化驱动类com.mysql.jdbc.Driver，该类就在 mysql-connector-java-5.0.8-bin.jar中。如果你使用的是oracle数据库那么该驱动类将不同。


try {
        Class.forName("com.mysql.jdbc.Driver");		
        } catch (ClassNotFoundException e) { 				
            e.printStackTrace();
}

lass.forName是把这个类加载到JVM中，加载的时候，就会执行其中的静态初始化块，完成驱动的初始化的相关工作。

建立JDBC和数据库之间的Connection连接

这里需要提供：数据库服务端的IP地址:127.0.0.1 (这是本机，如果连接其他电脑上的数据库，需填写相应的IP地址)
                         数据库的端口号： 3306 （mysql专用端口号）
                         数据库名称 test（根据你自己数据库中的名称填写）
                         编码方式 UTF-8
                         账号 root
                         密码 root（如果你在创建数据库的时候没有使用默认的账号和密码，请填写自己设置的账号和密码）


Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test?characterEncoding=UTF-8", "root", "root");
//(string url,string user,string pwd)
//jdbc:mysql://hostname:port/databasename
//(hostname可以为localhost或127.0.0.1)

Connection是与特定数据库连接回话的接口，使用的时候需要导包，而且必须在程序结束的时候将其关闭。getConnection方法也需要捕获SQLException异常。


	public static void main(String[] args) throws SQLException {
		Connection conn = null;
		PreparedStatement  preStmt = null;
			try {
	             // 加载数据库驱动
				Class.forName("com.mysql.jdbc.Driver");
				String url = "jdbc:mysql://localhost:3306/jdbc";
				String username = "root";
				String password = "root";
            } catch (ClassNotFoundException e) {
				e.printStackTrace();
	
			} catch (SQLException e) {
				e.printStackTrace();
			}
					conn = null;
	}

创建Statement或者PreparedStatement接口，执行SQL语句

使用Statement接口

通过Connection对象获取Statement对象Connection创建Statement的方式有如下3种。

1.createStatement()：创建基本的Statement对象。

2.prepareStatement()：创建PreparedStatement对象。

3.prepareCall()：创建CallableStatement对象。

基本的Statement

statement stmt=conn.createStatement();

Statement接口创建之后，可以执行SQL语句，完成对数据库的增删改查。其中，增删改只需要改变SQL语句的内容就能完成，然而查询略显复杂。在Statement中使用字符串拼接的方式，该方式存在句法复杂，容易犯错等缺点，具体在下文中的对比中介绍。所以Statement在实际过程中使用的非常的少，所以具体的放到PreparedStatement那里给出详细代码。

字符串拼接方式的SQL语句是非常繁琐的，中间有很多的单引号和双引号的混用，极易出错。


Statement s = conn.createStatement();
// 准备sql语句
// 注意： 字符串要用单引号'
String sql = "insert into t_courses values(null,"+"'数学')";
//在statement中使用字符串拼接的方式，这种方式存在诸多问题
s.execute(sql);
System.out.println("执行插入语句成功");

使用PreparedStatement接口

与 Statement一样，PreparedStatement也是用来执行sql语句的与创建Statement不同的是，需要根据sql语句创建PreparedStatement。除此之外，还能够通过设置参数，指定相应的值，而不是Statement那样使用字符串拼接。

使用PreparedStatement时，它的SQL语句不再采用字符串拼接的方式，而是采用占位符的方式。“？”在这里就起到占位符的作用。这种方式除了避免了statement拼接字符串的繁琐之外，还能够提高性能。每次SQL语句都是一样的，java类就不会再次编译，这样能够显著提高性能。

String sql = "update t_course set course_name =? where course_id=?";


Statement s = conn.createStatement();
// 准备sql语句
// 注意： 字符串要用单引号'
String sql = "INSERT INTO users(name,password,email,birthday)"
						+ "VALUES(?,?,?,?)";
//在statement中使用字符串拼接的方式，这种方式存在诸多问题
s.execute(sql);
System.out.println("执行插入语句成功");

后面需要用到PreparedStatement接口创建的pstmt的set方法给占位符进行赋值。注意一点，这里的参数索引是从1开始的。


preStmt = conn.prepareStatement(sql);
				preStmt.setString(1, "zl");
				preStmt.setString(2, "123456");
				preStmt.setString(3, "zl@sina.com");
				preStmt.setString(4, "1789-12-23");
				preStmt.executeUpdate();

增删改都使用pstmt.executeUpdate();语句进行SQL语句的提交

使用Statement 执行SQL语句

所有的Statement 都有如下3种执行SQL语句的方法。

1.execute()：可以执行任何SQL语句。

2.executeQuery()：通常执行查询语句，执行后返回代表结果集的ResultSet对象。

3.executeUpdate()：主要用于执行DML和DDL语句。执行DML语句，如 INSERT、UPDATE或DELETE时，返回受SQL语句影响的行数，执行DDL语句返回0。

以 executeQuery()方法为例，其使用方式如下。


//执行SQL语句，获取结果集
ResultSetResultSet rs = stmt.executeQuery (sql);

操作ResultSet结果集

如果执行的SQL语句是查询语句，执行结果将返回一个ResultSet对象，该对象里保存了
SQL语句查询的结果。程序可以通过操作该ResultSet对象来取出查询结果。

可以通过next（）方法由前向后逐个获取结果集的数据，如果想获取结果集中任意位置的数据，则需要创建statement对象中，设置两个resultset定义的常量


Statement st = conn.createStatement (ResultSet.TYPE_SCROLL_ TNSENITIVE,//表示结果集可以滚动
                                     ResultSet.CONCUR READ ONLY);//表示以只读形式打开结果集
ResultSet rs = st.excuteQuery (sql);

使用resultset对象指定数据信息


package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Example03 {
	public static void main(String[] args) {
		    Connection conn = null;
			Statement stmt = null;
			try {
			   Class.forName("com.mysql.jdbc.Driver");
			   String url = "jdbc:mysql://localhost:3306/jdbc";
			   String username = "root";
			   String password = "root";
			   //1.获取Connection对象
			   conn = DriverManager.getConnection(url, username, password);
			   String sql = "select * from users";
			   //2.创建Statement对象并设置常量
	           Statement st =conn.createStatement(
						ResultSet.TYPE_SCROLL_INSENSITIVE, 
						ResultSet.CONCUR_READ_ONLY);
	           //3.执行SQL并将获取的数据信息存放在ResultSet中
				ResultSet rs = st.executeQuery(sql);
			   //4.取出ResultSet中指定数据的信息
				System.out.print("第2条数据的name值为:");
				rs.absolute(2);        //将指针定位到结果集中第2行数据
				System.out.println(rs.getString("name"));
				System.out.print("第1条数据的name值为:");
				rs.beforeFirst();      //将指针定位到结果集中第1行数据之前
				rs.next();              //将指针向后滚动
				System.out.println(rs.getString("name"));
				System.out.print("第4条数据的name值为:");
				rs.afterLast();        //将指针定位到结果集中最后一条数据之后
				rs.previous();         //将指针向前滚动
				System.out.println(rs.getString("name"));
			} catch (Exception e) {
				e.printStackTrace();
			} finally { // 释放资源
				if (stmt != null) {
					try {
						stmt.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
					stmt = null;
				}
				if (conn != null) {
					try {
						conn.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
					conn = null;
				}
			}
		}
	}

关闭连接，释放资源

每次操作数据库结束后都要关闭数据库连接，释放资源，包括关闭ResultSet、Statement
和Connection等资源。
至此，JDBC程序的大致实现步骤已经讲解完成。接下来，依照上面所讲解的步骤来演示
JDBC的使用。该程序从users表中读取数据，并将结果打印在控制台。

步骤

搭建数据库环境

在MySQL中创建一个名称为jdbc的数据库，然后在该数据库中创建一个users表

CREATE DATABASE jdbc;
USE jdbc;
CREATE TABLE users (
        id INT PRIMARY KEY AUTO INCREMENT,name VARCHAR(40),
        password VARCHAR(40),
        email VARCHAR(60),
        birthday DATE
)CHARACTER SET utf8 COLLATE utf8_general_ci;

数据库和表创建成功后，再向users表中插入3条数据，插入的SQL语句如下所示。


INSERT INTO users (NAME,PASSWORD, email,birthday)VALUES('zs','123456', 'zs0sina.com', '1980-12-04');
INSERT INTO users(NAME,PASSWORD,email,birthday)
VALUES('lisi', '123456', 'lisi0sina.com','1981-12-04');INSERT INTO users (NAME,PASSWORD,email,birthday)
VALUES('wangwu','123456', 'wangwu@sina.com','1979-12-04');

创建项目环境，导入数据库驱动

导入下载好的MySQL数据库驱动文件

编写JDBC程序

创建Example01，用于读取数据库中的users表，并将结果输出控制台


package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Date;
public class Example01 {
	public static void main(String[] args) throws SQLException {
		Statement stmt = null;
		ResultSet rs = null;
		Connection conn = null;
		try {
			// 1. 注册数据库的驱动
			Class.forName("com.mysql.jdbc.Driver");
			// 2.通过DriverManager获取数据库连接
			String url = "jdbc:mysql://localhost:3306/jdbc";
			String username = "root";
			String password = "root";
			conn = DriverManager.getConnection (url, username, 
		     			password);
			// 3.通过Connection对象获取Statement对象
			 stmt = conn.createStatement();
			// 4.使用Statement执行SQL语句。
			String sql = "select * from users";
			rs = stmt.executeQuery(sql);
			// 5. 操作ResultSet结果集
			System.out.println("id | name   | password | email  | birthday");
			while (rs.next()) {
				int id = rs.getInt("id"); // 通过列名获取指定字段的值
				String name = rs.getString("name");
				String psw = rs.getString("password");
				String email = rs.getString("email");
				Date birthday = rs.getDate("birthday");
				System.out.println(id + " | " + name + " | " + psw + " | " + email
							+ " | " + birthday);
			}
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally{
			// 6.回收数据库资源
			if(rs!=null) {
				try {
					rs.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
				rs = null;
			}
			if(stmt!=null) {
				try {
					stmt.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
				stmt = null;
			}
			if(conn!=null) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
				conn = null;
			}
		}		
	}
}

首先注册了MySQL数据库驱动，通过DriverManager获取一个Connection对象，然后使用Connection对象创建一个Statement对象，Statement对象通过executeQuery()方法执行SQL语句，并返回结果集ResultSet。接下来，通过遍历ResultSet得到最终的查询结果，最后关闭连接，回收了数据库资源。
程序执行成功后，控制台的打印结果如图所示

注意：

1.注册驱动

虽然使用 DriverManager.registerDriver(new com.mysql.jdbc.Driver())方法也可以完成注
册，但此方式会使数据库驱动被注册两次。这是因为Driver类的源码已经在静态代码块中完成了
数据库驱动的注册。所以，为了避免数据库驱动被重复注册，只需在程序中使用Class.forName()
方法加载驱动类即可。

2.释放资源

由于数据库资源非常宝贵，数据库允许的并发访问连接数量有限，因此，当数据库资源使用完毕后，一定要记得释放资源。为了保证资源的释放，在Java程序中，应该将最终必须要执行的操作放在 finally 代码块中。

创建Example02的类，在类中使用PreparedStatement对象对数据库进行插入数据的操作，预编译信息储存在PreparedStatement对象，提高数据访问效率


package cn.itcast.jdbc.example;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement ;
import java.sql.SQLException;
public class Example02 {
	public static void main(String[] args) throws SQLException {
		Connection conn = null;
		PreparedStatement  preStmt = null;
			try {
	             // 加载数据库驱动
				Class.forName("com.mysql.jdbc.Driver");
				String url = "jdbc:mysql://localhost:3306/jdbc";
				String username = "root";
				String password = "root";
	             // 创建应用程序与数据库连接的Connection对象
				conn = DriverManager.getConnection(url, username, password);
				// 执行的SQL语句
				String sql = "INSERT INTO users(name,password,email,birthday)"
						+ "VALUES(?,?,?,?)";
	             // 创建执行SQL语句的PreparedStatement 对象
				preStmt = conn.prepareStatement(sql);
				preStmt.setString(1, "zl");
				preStmt.setString(2, "123456");
				preStmt.setString(3, "zl@sina.com");
				preStmt.setString(4, "1789-12-23");
				preStmt.executeUpdate();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} finally {    // 释放资源
				if (preStmt != null) {
					try {
						preStmt.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
					preStmt = null;
				}
				if (conn != null) {
					try {
						conn.close();
					} catch (SQLException e) {
						e.printStackTrace();
					}
					conn = null;
				}
			}
		}
	}

首先通过Connection对象的prepareStatement()方法生成PreparedStatement对象，然后调用PreparedStatement对象的setXxx()方法，给SQL语句中的参数赋值，最后通讨调executeUpdate()方法执行SQL语句。
文件运行成功后，会在users表中插入一条数据。进入MySQL数据库，使用SELECT句查看users表，查询结果如9-5所示。

使用JDBC完成数据的增删改查

创建JavaBean，创建一个用于保存用户数据User类


package cn.itcast.jdbc.example.domain;
import java.util.Date;
public class User {
	private int id;
	private String username;
	private String password;
	private String email;
	private Date birthday;
	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 Date getBirthday() {
			return birthday;
		}
		public void setBirthday(Date birthday) {
			this.birthday = birthday;
		}
}

创建工具类

每次操作数据库都需要加载驱动，建立数据库连接以及关闭数据库连接，为避免代码重复书写，专门建立一个数据库相关操作的工具类


package cn.itcast.jdbc.example.utils;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBCUtils {
	// 加载驱动，并建立数据库连接
	public static Connection getConnection() throws SQLException,
				ClassNotFoundException {
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://localhost:3306/jdbc";
			String username = "root";
	    		String password = "root";
			Connection conn = DriverManager.getConnection(url, username, 
					password);
			return conn;
		}
		// 关闭数据库连接，释放资源
		public static void release(Statement stmt, Connection conn) {
			if (stmt != null) {
				try {
					stmt.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
				stmt = null;
			}
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
				conn = null;
			}
		}
	     public static void release(ResultSet rs, Statement stmt, 
	     		Connection conn){
			if (rs != null) {
				try {
					rs.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
				rs = null;
			}
			release(stmt, conn);
		}
}

创建Dao

创建UersDao的类，封装对表users的添加、查询、删除和更新等操作


package cn.itcast.jdbc.example.dao;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import cn.itcast.jdbc.example.domain.User;
import cn.itcast.jdbc.example.utils.JDBCUtils;
public class UsersDao {
	// 添加用户的操作
	public boolean insert(User user) {
		Connection conn = null;
		Statement stmt = null;
		ResultSet rs = null;
		try {
		// 获得数据的连接
		conn = JDBCUtils.getConnection();
		// 获得Statement对象
		stmt = conn.createStatement();
		// 发送SQL语句
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String birthday = sdf.format(user.getBirthday());
	    String sql = "INSERT INTO users(id,name,password,email,birthday) "+
					"VALUES("
					+ user.getId()
					+ ",'"
					+ user.getUsername()
					+ "','"
					+ user.getPassword()
					+ "','"
					+ user.getEmail()
					+ "','"
					+ birthday + "')";
			int num = stmt.executeUpdate(sql);
			if (num > 0) {
				return true;
			}
			return false;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtils.release(rs, stmt, conn);
		}
		return false;
	}
	// 查询所有的User对象
	public ArrayList<User> findAll() {
		Connection conn = null;
		Statement stmt = null;
		ResultSet rs = null;
		ArrayList<User> list = new ArrayList<User>();
		try {
			// 获得数据的连接
			conn = JDBCUtils.getConnection();
			// 获得Statement对象
			stmt = conn.createStatement();
			// 发送SQL语句
			String sql = "SELECT * FROM users";
			rs = stmt.executeQuery(sql);
			// 处理结果集
			while (rs.next()) {
				User user = new User();
				user.setId(rs.getInt("id"));
				user.setUsername(rs.getString("name"));
				user.setPassword(rs.getString("password"));
				user.setEmail(rs.getString("email"));
				user.setBirthday(rs.getDate("birthday"));
				list.add(user);
			}
			return list;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtils.release(rs, stmt, conn);
		}
		return null;
	}
	// 根据id查找指定的user
	public User find(int id) {
		Connection conn = null;
		Statement stmt = null;
		ResultSet rs = null;
		try {
			// 获得数据的连接
			conn = JDBCUtils.getConnection();
			// 获得Statement对象
			stmt = conn.createStatement();
			// 发送SQL语句
			String sql = "SELECT * FROM users WHERE id=" + id;
			rs = stmt.executeQuery(sql);
			// 处理结果集
			while (rs.next()) {
				User user = new User();
				user.setId(rs.getInt("id"));
				user.setUsername(rs.getString("name"));
				user.setPassword(rs.getString("password"));
				user.setEmail(rs.getString("email"));
				user.setBirthday(rs.getDate("birthday"));
				return user;
				}
				return null;
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JDBCUtils.release(rs, stmt, conn);
			}
			return null;
		}
		// 删除用户
		public boolean delete(int id) {
			Connection conn = null;
			Statement stmt = null;
			ResultSet rs = null;
			try {
				// 获得数据的连接
				conn = JDBCUtils.getConnection();
				// 获得Statement对象
				stmt = conn.createStatement();
				// 发送SQL语句
				String sql = "DELETE FROM users WHERE id=" + id;
				int num = stmt.executeUpdate(sql);
				if (num > 0) {
					return true;
				}
				return false;
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JDBCUtils.release(rs, stmt, conn);
			}
			return false;
		}
		// 修改用户
		public boolean update(User user) {
			Connection conn = null;
			Statement stmt = null;
			ResultSet rs = null;
			try {
				// 获得数据的连接
				conn = JDBCUtils.getConnection();
				// 获得Statement对象
				stmt = conn.createStatement();
				// 发送SQL语句
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				String birthday = sdf.format(user.getBirthday());
				String sql = "UPDATE users set name='" + user.getUsername()
						+ "',password='" + user.getPassword() + "',email='"
						+ user.getEmail() + "',birthday='" + birthday
						+ "' WHERE id=" + user.getId();
				int num = stmt.executeUpdate(sql);
				if (num > 0) {
					return true;
				}
				return false;
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				JDBCUtils.release(rs, stmt, conn);
			}
			return false;
		}
	}

编写测试类FindUersTest实现读取users表中的数据


package cn.itcast.jdbc.example;
import java.util.ArrayList;
import cn.itcast.jdbc.example.dao.UsersDao;
import cn.itcast.jdbc.example.domain.User;
public class FindAllUsersTest{
	public static void main(String[] args) {
		//创建一个名称为usersDao的对象
		UsersDao usersDao = new UsersDao();
		//将UsersDao对象的findAll()方法执行后的结果放入list集合
		ArrayList<User> list = usersDao.findAll();
		//循环输出集合中的数据
		for (int i = 0; i < list.size(); i++) {
				System.out.println("第" + (i + 1) + "条数据的username值为:"
						+ list.get(i).getUsername());
			}
		}
}

打印users表中所有username值

编写FindUerByldTest读取users表中指定数据

package cn.itcast.jdbc.example;
import cn.itcast.jdbc.example.dao.UsersDao;
import cn.itcast.jdbc.example.domain.User;
public class FindUserByIdTest {
    public static void main(String[] args) {
        UsersDao usersDao = new UsersDao();
        User user = usersDao.find(1);
        System.out.println("id为1的User对象的name值为：" + user.getUsername());
    }
}

编写测试类UpdayeUerTest实现修改users表中数据操作


package cn.itcast.jdbc.example;
import java.util.Date;
import cn.itcast.jdbc.example.dao.UsersDao;
import cn.itcast.jdbc.example.domain.User;
public class UpdateUserTest{
	public static void main(String[] args) {
         // 修改User对象的数据
		UsersDao usersDao = new UsersDao();
		User user = new User();
			user.setId(4);
			user.setUsername("zhaoxiaoliu");
			user.setPassword("456");
			user.setEmail("zhaoxiaoliu@sina.com");
			user.setBirthday(new Date());
			boolean b = usersDao.update(user);
			System.out.println(b);
		}
}

编写测试类DeletUserTest实现删除users表数据

 package cn.itcast.jdbc.example;
 import cn.itcast.jdbc.example.dao.UsersDao;
 public class DeleteUserTest{
     public static void main(String[] args) {
         // 删除操作
         UsersDao usersDao = new UsersDao();
         boolean b = usersDao.delete(4);
         System.out.println(b);
     }
 }

总结

请简述什么是JDBC

JDBC的全称是Java数据库连接（Java Database Connectivity），它是一套用于执行SQL语句的Java API。应用程序可通过这套API连接到关系数据库，并使用SQL语句来完成对数据库中数据的查询、更新和删除等处理。

简述JDBC的实现步骤

1.加载并注册数据库驱动

2.通过DriverManager获取数据库连接

3.通过Connection对象获取Statement对象

4.使用Statement执行SQL语句

5.操作ResultSet结果集

6.关闭连接，释放资源