JDBC连接数据库教程，postgreSQL

客官°小女子只卖身不卖艺 2023-01-01 09:50 276阅读 0赞

[https://blog.csdn.net/jg15617651654/article/details/63262456/][https_blog.csdn.net_jg15617651654_article_details_63262456]

# JDBC连接数据库教程，postgreSQL #

![426136e8363e68fc321f3d3551b0d579.png][]

[流年你奈我何][Link 1] 2017-03-18 17:17:43 ![11d4e66b47a786d7307438a15382d44a.png][] 17389 ![50c7c045de1e4400c6f27a33ed55cf7c.png][] 收藏 4

分类专栏： [Postgres 修炼之道][Postgres] 文章标签： [postgresql][] [数据库][Link 2] [事务][Link 3] [jdbc][]

版权

## 0、概述 ##

本文借postgreSQL通过JDBC连接[数据库][Link 4]的示例，介绍了常见数据库操作及JDBC的API、JDBC的一般工作流程及JDBC事务。

## 1、准备工作 ##

A、下载安装好postgreSQL数据库。

B、新建一个[Java][]项目，并导入postgreSQL的JDBC驱动程序jar包。

## 2、Java连接postgreSQL代码示例。 ##

**\[java\]** [view plain][] [copy][view plain]

1.  package vertxTest;  
2.    
3.  import java.sql.Connection;  
4.  import java.sql.DriverManager;  
5.  import java.sql.Statement;  
6.    
7.  public class PostgreSQLJDBC \{  
8.      public static void main(String args\[\]) \{  
9.          Connection c = null;  
10.         Statement stmt = null;  
11.         try \{  
12.             Class.forName("org.postgresql.Driver");  
13.             c = DriverManager.getConnection("jdbc:postgresql://localhost:5432/pgsqltest", "postgres", "2016");  
14.             c.setAutoCommit(false); // 把自动提交  
15.             System.out.println("Opened database successfully");  
16.   
17.             stmt = c.createStatement();   
18.             String sql = "CREATE TABLE STUDENTS " +   
19.                          "(ID TEXT PRIMARY KEY     NOT NULL ," +   
20.                          " NAME            TEXT    NOT NULL, " +   
21.                          " SEX             TEXT    NOT NULL, " +   
22.                          " AGE             TEXT    NOT NULL)";   
23.             stmt.executeUpdate(sql);   
24.             System.out.println("Table created successfully");  
25.               
26.             stmt.close();  
27.             c.commit();  
28.             c.close();  
29.         \} catch (Exception e) \{  
30.             System.err.println(e.getClass().getName() + ": " + e.getMessage());  
31.             System.exit(0);  
32.         \}  
33.     \}  
34. \}

## 3、常见增删改查操作。 ##

A、定义记录的类（可选）

**\[java\]** [view plain][] [copy][view plain]

1.  package vertxTest;  
2.    
3.  public class Student \{  
4.      private String Id;  
5.      private String Name;  
6.      private String Sex;  
7.      private String Age;  
8.    
9.      Student(String Id,String Name, String Sex, String Age) \{  
10.         this.Id = Id; //default  
11.         this.Name = Name;  
12.         this.Sex = Sex;  
13.         this.Age = Age;  
14.     \}  
15.   
16.     public String getId() \{  
17.         return Id;  
18.     \}  
19.   
20.     public void setId(String Id) \{  
21.         this.Id = Id;  
22.     \}  
23.   
24.     public String getName() \{  
25.         return Name;  
26.     \}  
27.   
28.     public void setName(String Name) \{  
29.         this.Name = Name;  
30.     \}  
31.   
32.     public String getSex() \{  
33.         return Sex;  
34.     \}  
35.   
36.     public void setSex(String Sex) \{  
37.         this.Sex = Sex;  
38.     \}  
39.   
40.     public String getAge() \{  
41.         return Age;  
42.     \}  
43.   
44.     public void setage(String Age) \{  
45.         this.Age = Age;  
46.     \}  
47. \}

B、JDBC表数据操作方法

**\[java\]** [view plain][] [copy][view plain]

1. package vertxTest;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.PreparedStatement;  
6. import java.sql.ResultSet;  
7. import java.sql.SQLException;  
8.   
9. public class JDBCOperation \{  
10.       
11.     /\*\* 
12.      \* @method getConn() 获取数据库的连接 
13.      \* @return Connection 
14.      \*/  
15.     public Connection getConn() \{  
16.         String driver = "org.postgresql.Driver";  
17.         String url = "jdbc:postgresql://localhost:5432/pgsqltest";  
18.         String username = "postgres";  
19.         String password = "2016";  
20.         Connection conn = null;  
21.         try \{  
22.             Class.forName(driver); // classLoader,加载对应驱动  
23.             conn = (Connection) DriverManager.getConnection(url, username, password);  
24.         \} catch (ClassNotFoundException e) \{  
25.             e.printStackTrace();  
26.         \} catch (SQLException e) \{  
27.             e.printStackTrace();  
28.         \}  
29.         return conn;  
30.     \}  
31.       
32.     /\*\* 
33.      \* @method insert(Student student) 往表中插入数据 
34.      \* @return int 成功插入数据条数 
35.      \*/  
36.     public int insert(Student student) \{  
37.         Connection conn = getConn();  
38.         int i = 0;  
39.         String sql = "insert into students (id,Name,Sex,Age) values(?,?,?,?)";  
40.         PreparedStatement pstmt;  
41.         try \{  
42.             pstmt = (PreparedStatement) conn.prepareStatement(sql);  
43.             pstmt.setString(1, student.getId());  
44.             pstmt.setString(2, student.getName());  
45.             pstmt.setString(3, student.getSex());  
46.             pstmt.setString(4, student.getAge());  
47.             i = pstmt.executeUpdate();  
48.             pstmt.close();  
49.             conn.close();  
50.         \} catch (SQLException e) \{  
51.             e.printStackTrace();  
52.         \}  
53.         return i;  
54.     \}  
55.       
56.     /\*\* 
57.      \* @method delete(Student student) 删除表中数据 
58.      \* @return int 成功删除表中数据条数 
59.      \*/  
60.     public int delete(String name) \{  
61.         Connection conn = getConn();  
62.         int i = 0;  
63.         String sql = "delete from students where Name='" + name + "'";  
64.         PreparedStatement pstmt;  
65.         try \{  
66.             pstmt = (PreparedStatement) conn.prepareStatement(sql);  
67.             i = pstmt.executeUpdate();  
68.             System.out.println("resutl: " + i);  
69.             pstmt.close();  
70.             conn.close();  
71.         \} catch (SQLException e) \{  
72.             e.printStackTrace();  
73.         \}  
74.         return i;  
75.     \}  
76.       
77.     /\*\* 
78.      \* @method update(Student student) 更改表中数据 
79.      \* @return int 成功更改表中数据条数 
80.      \*/  
81.     public int update(Student student) \{  
82.         Connection conn = getConn();  
83.         int i = 0;  
84.         String sql = "update students set Age='" + student.getAge() + "' where Name='" + student.getName() + "'";  
85.         PreparedStatement pstmt;  
86.         try \{  
87.             pstmt = (PreparedStatement) conn.prepareStatement(sql);  
88.             i = pstmt.executeUpdate();  
89.             System.out.println("resutl: " + i);  
90.             pstmt.close();  
91.             conn.close();  
92.         \} catch (SQLException e) \{  
93.             e.printStackTrace();  
94.         \}  
95.         return i;  
96.     \}  
97.       
98.     /\*\* 
99.      \* @method Integer getAll() 查询并打印表中数据 
100.      \* @return Integer 查询并打印表中数据 
101.      \*/  
102.     public Integer getAll() \{  
103.         Connection conn = getConn();  
104.         String sql = "select \* from students";  
105.         PreparedStatement pstmt;  
106.         try \{  
107.             pstmt = (PreparedStatement)conn.prepareStatement(sql);  
108.             ResultSet rs = pstmt.executeQuery();  
109.             int col = rs.getMetaData().getColumnCount();  
110.             System.out.println("============================");  
111.             while (rs.next()) \{  
112.                 for (int i = 1; i <= col; i++) \{  
113.                     System.out.print(rs.getString(i) + "\\t");  
114.                     if ((i == 2) && (rs.getString(i).length() < 8)) \{  
115.                         System.out.print("\\t");  
116.                     \}  
117.                  \}  
118.                 System.out.println("");  
119.             \}  
120.                 System.out.println("============================");  
121.         \} catch (SQLException e) \{  
122.             e.printStackTrace();  
123.         \}  
124.         return null;  
125.     \}  
126. \}

C、[测试][Link 5]类

**\[java\]** [view plain][] [copy][view plain]

1.  package vertxTest;  
2.    
3.  public class JDBCTest \{  
4.      public static void main(String args\[\]) \{  
5.          JDBCOperation op = new JDBCOperation();  
6.          op.getAll();  
7.          op.insert(new Student("001","Achilles", "Male", "14"));  
8.          op.insert(new Student("002","Bean", "Fmale", "15"));  
9.          op.getAll();  
10.         op.update(new Student("002","Bean", "", "7"));  
11.         op.delete("Achilles");  
12.         op.getAll();  
13.     \}  
14. \}

C、输出结果

<table> 
 <tbody> 
 <tr> 
 <td> ============================ ============================ ============================ 001 Achilles&nbsp;&nbsp; Male&nbsp;&nbsp; 14&nbsp; 002 Bean&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Fmale&nbsp; 15&nbsp; ============================ resutl: 1 resutl: 1 ============================ 002 Bean&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Fmale&nbsp; 7&nbsp;&nbsp; ============================ </td> 
 </tr> 
 </tbody> 
</table>

## 4、代码分析 ##

在上述对数据库进行增删改查的过程中，可以发现其共性部分，即通用的流程：

(1)创建Connection对象、SQL查询命令字符串；

(2)对Connection对象传入SQL查询命令，获得PreparedStatement对象；

(3)对PreparedStatement对象执行executeUpdate()或executeQurey()获得结果；

(4)先后关闭PreparedStatement对象和Connection对象。

可见，使用JDBC时，最常打交道的是Connection、PreparedStatement这两个类，以及select中的ResultSet类。

## 5、JDBC的API ##

<table style="width:548px;"> 
 <tbody> 
 <tr> 
 <td> API </td> 
 <td> 说明 </td> 
 </tr> 
 <tr> 
 <td> java.sql.Connection&nbsp; </td> 
 <td> 与特定数据库的连接（会话）。能够通过getMetaData方法获得数据库提供的信息、所支持的SQL语法、存储过程和此连接的功能等信息。代表了数据库。&nbsp; </td> 
 </tr> 
 <tr> 
 <td> java.sql.Driver&nbsp; </td> 
 <td> 每个驱动程序类必需实现的接口，同时，每个数据库驱动程序都应该提供一个实现Driver接口的类。&nbsp; </td> 
 </tr> 
 <tr> 
 <td> java.sql.DriverManager (Class) </td> 
 <td> 管理一组JDBC驱动程序的基本服务。作为初始化的一部分，此接口会尝试加载在”jdbc.drivers”系统属性中引用的驱动程序。只是一个辅助类，是工具。&nbsp; </td> 
 </tr> 
 <tr> 
 <td> java.sql.Statement&nbsp; </td> 
 <td> 用于执行静态SQL语句并返回其生成结果的对象。&nbsp; </td> 
 </tr> 
 <tr> 
 <td> java.sql.PreparedStatement&nbsp; </td> 
 <td> 继承Statement接口，表示预编译的SQL语句的对象，SQL语句被预编译并且存储在PreparedStatement对象中。然后可以使用此对象高效地多次执行该语句。&nbsp; </td> 
 </tr> 
 <tr> 
 <td> java.sql.CallableStatement&nbsp; </td> 
 <td> 用来访问数据库中的存储过程。它提供了一些方法来指定语句所使用的输入/输出参数。&nbsp; </td> 
 </tr> 
 <tr> 
 <td> java.sql.PreparedStatement&nbsp; </td> 
 <td> 继承Statement接口，表示预编译的SQL语句的对象，SQL语句被预编译并且存储在PreparedStatement对象中。然后可以使用此对象高效地多次执行该语句。&nbsp; </td> 
 </tr> 
 <tr> 
 <td> java.sql.CallableStatement&nbsp; </td> 
 <td> 用来访问数据库中的存储过程。它提供了一些方法来指定语句所使用的输入/输出参数。&nbsp; </td> 
 </tr> 
 </tbody> 
</table>

## 6、JDBC的一般工作流程 ##

![20160427233117006][]

### （1）加载驱动 ###

Class.forName(“org.postgresql.Driver”); JAVA规范中明确规定：所有的驱动程序必须在静态初始化代码块中将驱动注册到驱动程序管理器中。

### （2）建立连接 ###

conn=DriverManager.getConnection("jdbc:postgresql://localhost:5432/pgsqltest","postgres", "2016");

Connection连接是通过DriverManager的静态方法getConnection(.....)来得到的，这个方法的实质是把参数传到实际的Driver中的connect()方法中来获得数据库连接的。

postgreSQL URL的格式:

jdbc:postgresql:（协议）@XXX.XXX.X.XXX:XXXX（IP地址及端口号）:XXXXXXX（所使用的库名）

[MySQL][Link 4] URL的写法 例：jdbc:mysql://192.168.8.21:3306/test

### （3）获得Statement对象 ###

Statement stmt = conn.createStatement();

### （4）执行sql语句 ###

stmt.executeQuery(String sql); //返回一个查询结果集。

stmt.executeUpdate(String sql); //返回值为int型，表示影响记录的条数。

将sql语句通过连接发送到数据库中执行，以实现对数据库的操作。

### （5）处理结果集 ###

使用Connection对象获得一个Statement，Statement中的executeQuery(Stringsql) 方法可以使用select语句查询，并且返回一个结果集。 ResultSet，通过遍历这个结果集，可以获得select语句的查寻结果，ResultSet的next()方法会操作一个游标从第一条记录的前面开始读取，直到最后一条记录。

executeUpdate(String sql) 方法用于执行DDL和DML语句，比如可以update，delete操作。

只有执行select语句才有结果集返回。

Statement str=con.createStatement(); //创建Statement

String sql=”insert into test(id,name)values(1,”+”’”+”test”+”’”+”)”;

str. executeUpdate(sql);//执行Sql语句

String sql=”select \* from test”;

ResultSet rs=str. executeQuery(String sql);//执行Sql语句，执行select语句后有结果集

//遍历处理结果集信息

while(rs.next())\{

System.out.println(rs.getInt(“id”));

System.out.println(rs.getString(“name”))

### （6）关闭数据库连接 ###

rs.close();

stmt.close();

con.close();

ResultSet Statement Connection是依次依赖的。

注意：要按先ResultSet结果集，后Statement，最后Connection的顺序关闭资源，因为Statement和ResultSet是需要连接时才可以使用的，所以在使用结束之后有可能其它的Statement还需要连接，所以不能现关闭Connection。

## 7、JDBC事务 ##

事务的4大特性

(1) 原子性

事务的原子性指的是，事务中包含的程序作为数据库的逻辑工作单位，它所做的对数据修改操作要么全部执行，要么完全不执行。

原子操作，也就是不可分割的操作，必须一起成功一起失败。

(2) 一致性

事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。这种特性称为事务的一致性。假如数据库的状态满足所有的完整性约束，就说该数据库是一致的。

(3) 分离性

分离性指并发的事务是相互隔离的。即一个事务内部的操作及正在操作的数据必须封锁起来，不被其它企图进行修改的事务看到。

(4) 持久性

持久性意味着当系统或介质发生故障时，确保已提交事务的更新不能丢失。即一旦一个事务提交，DBMS保证它对数据库中数据的改变应该是永久性的，耐得住任何系统故障。持久性通过数据库备份和恢复来保证。

![20160427233155913][]

[https_blog.csdn.net_jg15617651654_article_details_63262456]: https://blog.csdn.net/jg15617651654/article/details/63262456/
[426136e8363e68fc321f3d3551b0d579.png]: /images/20221120/6196620bc2f84e85a610934b463b2a9f.png
[Link 1]: https://blog.csdn.net/jg15617651654
[11d4e66b47a786d7307438a15382d44a.png]: https://img-blog.csdnimg.cn/img_convert/11d4e66b47a786d7307438a15382d44a.png
[50c7c045de1e4400c6f27a33ed55cf7c.png]: /images/20221120/12751b64d5da40a791f1d267a666fa92.png
[Postgres]: https://blog.csdn.net/jg15617651654/category_6785154.html
[postgresql]: https://www.csdn.net/tags/OtTaYgxsOTIxOC1ibG9n.html
[Link 2]: https://www.csdn.net/tags/NtzaUgysMTg1NC1ibG9n.html
[Link 3]: https://www.csdn.net/tags/MtTaEg0sNDI4ODUtYmxvZwO0O0OO0O0O.html
[jdbc]: https://www.csdn.net/tags/MtzaggzsMDQ0My1ibG9n.html
[Link 4]: http://lib.csdn.net/base/mysql
[Java]: http://lib.csdn.net/base/javase
[view plain]: http://blog.csdn.net/caihuangshi/article/details/51265324#
[Link 5]: http://lib.csdn.net/base/softwaretest
[20160427233117006]: https://img-blog.csdn.net/20160427233117006
[20160427233155913]: https://img-blog.csdn.net/20160427233155913