Java訪問數據庫的具體步：

發布時間：2021-09-15 09:57:09 來源：億速云閱讀：125 作者：chen 欄目：數據庫

本篇內容介紹了“Java訪問數據庫的具體步：”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

一：Java訪問數據庫的具體步驟：

1 加載（注冊）數據庫

　驅動加載就是把各個數據庫提供的訪問數據庫的API加載到我們程序進來，加載JDBC驅動，并將其注冊到DriverManager中，每一種數據庫提供的數據庫驅動不一樣，加載驅動時要把jar包添加到lib文件夾下，下面看一下一些主流數據庫的JDBC驅動加裁注冊的代碼:

//Oracle8/8i/9iO數據庫(thin模式)

Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();

//Sql Server7.0/2000數據庫 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

//Sql Server2005/2008數據庫 Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

//DB2數據庫

Class.froName("com.ibm.db2.jdbc.app.DB2Driver").newInstance();

//MySQL數據庫 Class.forName("com.mysql.jdbc.Driver").newInstance();

2 建立鏈接 　　

建立數據庫之間的連接是訪問數據庫的必要條件，就像南水北調調水一樣，要想調水首先由把溝通的河流打通。建立連接對于不同數據庫也是不一樣的，下面看一下一些主流數據庫建立數據庫連接，取得Connection對象的不同方式：

//Oracle8/8i/9i數據庫(thin模式)

String url="jdbc:oracle:thin:@localhost:1521:orcl";

String user="scott";

String password="tiger";

Connection conn=DriverManager.getConnection(url,user,password);

//Sql Server7.0/2000/2005/2008數據庫

String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";

String user="sa";

String password="";

Connection conn=DriverManager.getConnection(url,user,password);

//DB2數據庫

String url="jdbc:db2://localhost:5000/sample";

String user="amdin"

String password=-"";

Connection conn=DriverManager.getConnection(url,user,password);

//MySQL數據庫

String url="jdbc:mysql://localhost:3306/testDB?user=root&password=root&useUnicode=true&characterEncoding=gb2312";

Connection conn=DriverManager.getConnection(url);

3. 執行SQL語句 　

數據庫連接建立好之后，接下來就是一些準備工作和執行sql語句了，準備工作要做的就是建立Statement對象PreparedStatement對象，例如：

//建立Statement對象

Statement stmt=conn.createStatement();

//建立PreparedStatement對象

String sql="select * from user where userName=? and password=?";

PreparedStatement pstmt=Conn.prepareStatement(sql);

pstmt.setString(1,"admin");

pstmt.setString(2,"liubin");

做好準備工作之后就可以執行sql語句了，執行sql語句：

String sql="select * from users";

ResultSet rs=stmt.executeQuery(sql);

//執行動態SQL查詢

ResultSet rs=pstmt.executeQuery();

//執行insert update delete等語句，先定義sql

stmt.executeUpdate(sql);

4 處理結果集 　

　訪問結果記錄集ResultSet對象。例如：

while(rs.next)

{

out.println("你的第一個字段內容為："+rs.getString("Name"));

out.println("你的第二個字段內容為："+rs.getString(2));

}

5 關閉數據庫

依次將ResultSet、Statement、PreparedStatement、Connection對象關閉，釋放所占用的資源.例如:

rs.close();

stmt.clost();

pstmt.close();

con.close();

二：JDBC事務

什么是事務:

首先,說說什么事務。我認為事務，就是一組操作數據庫的動作集合。

事務是現代數據庫理論中的核心概念之一。如果一組處理步驟或者全部發生或者一步也不執行，我們稱該組處理步驟為一個事務。當所有的步驟像一個操作一樣被完整地執行，我們稱該事務被提交。由于其中的一部分或多步執行失敗，導致沒有步驟被提交，則事務必須回滾到最初的系統狀態。

事務必須服從ISO/IEC所制定的ACID原則。ACID是原子性（atomicity）、一致性（consistency）、隔離性（isolation）和持久性（durability）的縮寫。事務的原子性表示事務執行過程中的任何失敗都將導致事務所做的任何修改失效。一致性表示當事務執行失敗時，所有被該事務影響的數據都應該恢復到事務執行前的狀態。隔離性表示在事務執行過程中對數據的修改，在事務提交之前對其他事務不可見。持久性表示當系統或介質發生故障時，確保已提交事務的更新不能丟失。持久性通過數據庫備份和恢復來保證。

JDBC 事務是用 Connection 對象控制的。JDBC Connection 接口( java.sql.Connection )提供了兩種事務模式：自動提交和手工提交。 java.sql.Connection 提供了以下控制事務的方法：
public void setAutoCommit(boolean)
public boolean getAutoCommit()
public void commit()
public void rollback()
使用 JDBC 事務界定時，您可以將多個 SQL 語句結合到一個事務中。JDBC 事務的一個缺點是事務的范圍局限于一個數據庫連接。一個 JDBC 事務不能跨越多個數據庫。

三：java操作數據庫連接池

在總結java操作數據庫連接池發現一篇很好的文章，所以就不做具體總結了，直接上地址：

http://www.blogjava.net/chunkyo/archive/2007/01/16/94266.html

最后附一段比較經典的代碼吧：

[java]
view plaincopyprint?

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Vector;
public class ConnectionPool {
private String jdbcDriver = ""; // 數據庫驅動
private String dbUrl = ""; // 數據 URL
private String dbUsername = ""; // 數據庫用戶名
private String dbPassword = ""; // 數據庫用戶密碼
private String testTable = ""; // 測試連接是否可用的測試表名，默認沒有測試表
private int initialConnections = 10; // 連接池的初始大小
private int incrementalConnections = 5;// 連接池自動增加的大小
private int maxConnections = 50; // 連接池最大的大小
private Vector connections = null; // 存放連接池中數據庫連接的向量 , 初始時為 null
// 它中存放的對象為 PooledConnection 型
/**
* 構造函數
*
* @param jdbcDriver String JDBC 驅動類串
* @param dbUrl String 數據庫 URL
* @param dbUsername String 連接數據庫用戶名
* @param dbPassword String 連接數據庫用戶的密碼
*
*/
public ConnectionPool(String jdbcDriver,String dbUrl,String dbUsername,String dbPassword) {
this.jdbcDriver = jdbcDriver;
this.dbUrl = dbUrl;
this.dbUsername = dbUsername;
this.dbPassword = dbPassword;
}
/**
* 返回連接池的初始大小
*
* @return 初始連接池中可獲得的連接數量
*/
public int getInitialConnections() {
return this.initialConnections;
}
/**
* 設置連接池的初始大小
*
* @param 用于設置初始連接池中連接的數量
*/
public void setInitialConnections(int initialConnections) {
this.initialConnections = initialConnections;
}
/**
* 返回連接池自動增加的大小、
*
* @return 連接池自動增加的大小
*/
public int getIncrementalConnections() {
return this.incrementalConnections;
}
/**
* 設置連接池自動增加的大小
* @param 連接池自動增加的大小
*/
public void setIncrementalConnections(int incrementalConnections) {
this.incrementalConnections = incrementalConnections;
}
/**
* 返回連接池中最大的可用連接數量
* @return 連接池中最大的可用連接數量
*/
public int getMaxConnections() {
return this.maxConnections;
}
/**
* 設置連接池中最大可用的連接數量
*
* @param 設置連接池中最大可用的連接數量值
*/
public void setMaxConnections(int maxConnections) {
this.maxConnections = maxConnections;
}
/**
* 獲取測試數據庫表的名字
*
* @return 測試數據庫表的名字
*/
public String getTestTable() {
return this.testTable;
}
/**
* 設置測試表的名字
* @param testTable String 測試表的名字
*/
public void setTestTable(String testTable) {
this.testTable = testTable;
}
/**
*
* 創建一個數據庫連接池，連接池中的可用連接的數量采用類成員
* initialConnections 中設置的值
*/
public synchronized void createPool() throws Exception {
// 確保連接池沒有創建
// 如果連接池己經創建了，保存連接的向量 connections 不會為空
if (connections != null) {
return; // 如果己經創建，則返回
}
// 實例化 JDBC Driver 中指定的驅動類實例
Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
DriverManager.registerDriver(driver); // 注冊 JDBC 驅動程序
// 創建保存連接的向量 , 初始時有 0 個元素
connections = new Vector();
// 根據 initialConnections 中設置的值，創建連接。
createConnections(this.initialConnections);
System.out.println(" 數據庫連接池創建成功！ ");
}
/**
* 創建由 numConnections 指定數目的數據庫連接 , 并把這些連接
* 放入 connections 向量中
*
* @param numConnections 要創建的數據庫連接的數目
*/
@SuppressWarnings("unchecked")
private void createConnections(int numConnections) throws SQLException {
// 循環創建指定數目的數據庫連接
for (int x = 0; x < numConnections; x++) {
// 是否連接池中的數據庫連接的數量己經達到最大？最大值由類成員 maxConnections
// 指出，如果 maxConnections 為 0 或負數，表示連接數量沒有限制。
// 如果連接數己經達到最大，即退出。
if (this.maxConnections > 0 && this.connections.size() >= this.maxConnections) {
break;
}
//add a new PooledConnection object to connections vector
// 增加一個連接到連接池中（向量 connections 中）
try{
connections.addElement(new PooledConnection(newConnection()));
}catch(SQLException e){
System.out.println(" 創建數據庫連接失敗！ "+e.getMessage());
throw new SQLException();
}
System.out.println(" 數據庫連接己創建 ......");
}
}
/**
* 創建一個新的數據庫連接并返回它
*
* @return 返回一個新創建的數據庫連接
*/
private Connection newConnection() throws SQLException {
// 創建一個數據庫連接
Connection conn = DriverManager.getConnection(dbUrl, dbUsername, dbPassword);
// 如果這是第一次創建數據庫連接，即檢查數據庫，獲得此數據庫允許支持的
// 最大客戶連接數目
//connections.size()==0 表示目前沒有連接己被創建
if (connections.size() == 0) {
DatabaseMetaData metaData = conn.getMetaData();
int driverMaxConnections = metaData.getMaxConnections();
// 數據庫返回的 driverMaxConnections 若為 0 ，表示此數據庫沒有最大
// 連接限制，或數據庫的最大連接限制不知道
//driverMaxConnections 為返回的一個整數，表示此數據庫允許客戶連接的數目
// 如果連接池中設置的最大連接數量大于數據庫允許的連接數目 , 則置連接池的最大
// 連接數目為數據庫允許的最大數目
if (driverMaxConnections > 0 && this.maxConnections > driverMaxConnections) {
this.maxConnections = driverMaxConnections;
}
}
return conn; // 返回創建的新的數據庫連接
}
/**
* 通過調用 getFreeConnection() 函數返回一個可用的數據庫連接 ,
* 如果當前沒有可用的數據庫連接，并且更多的數據庫連接不能創
* 建（如連接池大小的限制），此函數等待一會再嘗試獲取。
*
* @return 返回一個可用的數據庫連接對象
*/
public synchronized Connection getConnection() throws SQLException {
// 確保連接池己被創建
if (connections == null) {
return null; // 連接池還沒創建，則返回 null
}
Connection conn = getFreeConnection(); // 獲得一個可用的數據庫連接
// 如果目前沒有可以使用的連接，即所有的連接都在使用中
while (conn == null){
// 等一會再試
wait(250);
conn = getFreeConnection(); // 重新再試，直到獲得可用的連接，如果
//getFreeConnection() 返回的為 null
// 則表明創建一批連接后也不可獲得可用連接
}
return conn;// 返回獲得的可用的連接
}
/**
* 本函數從連接池向量 connections 中返回一個可用的的數據庫連接，如果
* 當前沒有可用的數據庫連接，本函數則根據 incrementalConnections 設置
* 的值創建幾個數據庫連接，并放入連接池中。
* 如果創建后，所有的連接仍都在使用中，則返回 null
* @return 返回一個可用的數據庫連接
*/
private Connection getFreeConnection() throws SQLException {
// 從連接池中獲得一個可用的數據庫連接
Connection conn = findFreeConnection();
if (conn == null) {
// 如果目前連接池中沒有可用的連接
// 創建一些連接
createConnections(incrementalConnections);
// 重新從池中查找是否有可用連接
conn = findFreeConnection();
if (conn == null) {
// 如果創建連接后仍獲得不到可用的連接，則返回 null
return null;
}
}
return conn;
}
/**
* 查找連接池中所有的連接，查找一個可用的數據庫連接，
* 如果沒有可用的連接，返回 null
*
* @return 返回一個可用的數據庫連接
*/
private Connection findFreeConnection() throws SQLException {
Connection conn = null;
PooledConnection pConn = null;
// 獲得連接池向量中所有的對象
Enumeration enumerate = connections.elements();
// 遍歷所有的對象，看是否有可用的連接
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
if (!pConn.isBusy()) {
// 如果此對象不忙，則獲得它的數據庫連接并把它設為忙
conn = pConn.getConnection();
pConn.setBusy(true);
// 測試此連接是否可用
if (!testConnection(conn)) {
// 如果此連接不可再用了，則創建一個新的連接，
// 并替換此不可用的連接對象，如果創建失敗，返回 null
try{
conn = newConnection();
}catch(SQLException e){
System.out.println(" 創建數據庫連接失敗！ "+e.getMessage());
return null;
}
pConn.setConnection(conn);
}
break; // 己經找到一個可用的連接，退出
}
}
return conn;// 返回找到到的可用連接
}
/**
* 測試一個連接是否可用，如果不可用，關掉它并返回 false
* 否則可用返回 true
*
* @param conn 需要測試的數據庫連接
* @return 返回 true 表示此連接可用， false 表示不可用
*/
private boolean testConnection(Connection conn) {
try {
// 判斷測試表是否存在
if (testTable.equals("")) {
// 如果測試表為空，試著使用此連接的 setAutoCommit() 方法
// 來判斷連接否可用（此方法只在部分數據庫可用，如果不可用 ,
// 拋出異常）。注意：使用測試表的方法更可靠
conn.setAutoCommit(true);
} else {// 有測試表的時候使用測試表測試
//check if this connection is valid
Statement stmt = conn.createStatement();
stmt.execute("select count(*) from " + testTable);
}
} catch (SQLException e) {
// 上面拋出異常，此連接己不可用，關閉它，并返回 false;
closeConnection(conn);
return false;
}
// 連接可用，返回 true
return true;
}
/**
* 此函數返回一個數據庫連接到連接池中，并把此連接置為空閑。
* 所有使用連接池獲得的數據庫連接均應在不使用此連接時返回它。
*
* @param 需返回到連接池中的連接對象
*/
public void returnConnection(Connection conn) {
// 確保連接池存在，如果連接沒有創建（不存在），直接返回
if (connections == null) {
System.out.println(" 連接池不存在，無法返回此連接到連接池中 !");
return;
}
PooledConnection pConn = null;
Enumeration enumerate = connections.elements();
// 遍歷連接池中的所有連接，找到這個要返回的連接對象
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
// 先找到連接池中的要返回的連接對象
if (conn == pConn.getConnection()) {
// 找到了 , 設置此連接為空閑狀態
pConn.setBusy(false);
break;
}
}
}
/**
* 刷新連接池中所有的連接對象
*
*/
public synchronized void refreshConnections() throws SQLException {
// 確保連接池己創新存在
if (connections == null) {
System.out.println(" 連接池不存在，無法刷新 !");
return;
}
PooledConnection pConn = null;
Enumeration enumerate = connections.elements();
while (enumerate.hasMoreElements()) {
// 獲得一個連接對象
pConn = (PooledConnection) enumerate.nextElement();
// 如果對象忙則等 5 秒 ,5 秒后直接刷新
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
// 關閉此連接，用一個新的連接代替它。
closeConnection(pConn.getConnection());
pConn.setConnection(newConnection());
pConn.setBusy(false);
}
}
/**
* 關閉連接池中所有的連接，并清空連接池。
*/
public synchronized void closeConnectionPool() throws SQLException {
// 確保連接池存在，如果不存在，返回
if (connections == null) {
System.out.println(" 連接池不存在，無法關閉 !");
return;
}
PooledConnection pConn = null;
Enumeration enumerate = connections.elements();
while (enumerate.hasMoreElements()) {
pConn = (PooledConnection) enumerate.nextElement();
// 如果忙，等 5 秒
if (pConn.isBusy()) {
wait(5000); // 等 5 秒
}
//5 秒后直接關閉它
closeConnection(pConn.getConnection());
// 從連接池向量中刪除它
connections.removeElement(pConn);
}
// 置連接池為空
connections = null;
}
/**
* 關閉一個數據庫連接
*
* @param 需要關閉的數據庫連接
*/
private void closeConnection(Connection conn) {
try {
conn.close();
}catch (SQLException e) {
System.out.println(" 關閉數據庫連接出錯： "+e.getMessage());
}
}
/**
* 使程序等待給定的毫秒數
*
* @param 給定的毫秒數
*/
private void wait(int mSeconds) {
try {
Thread.sleep(mSeconds);
} catch (InterruptedException e) {
}
}
/**
*
* 內部使用的用于保存連接池中連接對象的類
* 此類中有兩個成員，一個是數據庫的連接，另一個是指示此連接是否
* 正在使用的標志。
*/
class PooledConnection {
Connection connection = null;// 數據庫連接
boolean busy = false; // 此連接是否正在使用的標志，默認沒有正在使用
// 構造函數，根據一個 Connection 構告一個 PooledConnection 對象
public PooledConnection(Connection connection) {
this.connection = connection;
}
// 返回此對象中的連接
public Connection getConnection() {
return connection;
}
// 設置此對象的，連接
public void setConnection(Connection connection) {
this.connection = connection;
}
// 獲得對象連接是否忙
public boolean isBusy() {
return busy;
}
// 設置對象的連接正在忙
public void setBusy(boolean busy) {
this.busy = busy;
}
}
}
=======================================
這個例子是根據POSTGRESQL數據庫寫的，
請用的時候根據實際的數據庫調整。
調用方法如下：
①　ConnectionPool connPool
= new ConnectionPool("org.postgresql.Driver"
,"jdbc:postgresql://dbURI:5432/DBName"
,"postgre"
,"postgre");
②　connPool .createPool();
　　Connection conn = connPool .getConnection();

“Java訪問數據庫的具體步：”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！

向AI問一下細節

中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

Java訪問數據庫的具體步：

猜你喜歡

中文字幕av专区_日韩电影在线播放_精品国产精品久久一区免费式_av在线免费观看网站

Java訪問數據庫的具體步：

猜你喜歡

最新資訊

相關推薦

相關標簽