JDBC01 利用JDBC連接數據庫【不使用數據庫連接池】

?目錄：

　　1 什么是JDBC

　　2 JDBC主要接口

　　3 JDBC編程步驟【學渣版本】

　　5 JDBC編程步驟【學神版本】

　　6 JDBC編程步驟【學霸版本】

1 什么是JDBC

　　JDBC是JAVA提供的一套標準連接數據庫的接口，規定了連接數據庫的步驟和功能；不同的數據庫提供商提供了一套JDBC實現類，他們稱為數據庫驅動。

2 JDBC的主要接口

　　　Connection　　與數據庫連接有關

　　　DriverManager ? 與創建數據庫連接對象有關

　　　Statement ?與執行SQL語句有關

　　　ResultSet ?與返回的結果及有關

　　　注意：通過JDBC操作數據庫是自動提交的，當然也可是設置成手動提交

3 利用JDBC操作數據庫的步驟【學渣版本】

　　3.1 導入數據庫驅動

　　　　Class.forName(“數據庫驅動包”);

　　　　注意：Class.forName的底層實際上是利用的java反射機制

　　　　例如：Class.forName("com.mysql.jdbc.Driver"); //mysql驅動包的固定寫法

　　3.2 創建連接

　　　　Connection conn = DriverManager.getConnection(“jdbc:mysql:// + IP + : + 端口 + ?/ + 數據庫名稱”，“數據庫用戶名”，“密碼”);

　　　　注意：DriverManager是一個驅動管理類，通過調用該類的靜態方法DriverManager來創建連接對象

　　　　例如：　　Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", // jdbc:mysql:// + IP + : + 端口 + / + 數據庫名稱  "root", // 用戶名"182838"); // 用戶密碼

　　3.3 創建語句對象

　　　　Statement state = conn.createStatement();

　　　　注意：利用連接對象來創建語句對象

　　3.4 執行SQL語句

　　　　ResultSet executeQuery(String sql)

　　　　　　用來執行查詢語句(DQL)的方法,返回的是一個查詢結果集

　　　　Integer?executUpdate(String sql)

　　　　　　用來執行DML語句的方法,返回值為執行了該DML后影響了數據庫中多少條數據

　　　　boolean execute(String sql) ?　　　

　　　　　　　　可以執行所有類型的SQL語句,但是DQL,DML都有專門的方法,所以該方法通常
　　　　　　用來執行DDL語句.當返回值為true時表示該SQL語句執行后有結果集,沒有結果集
　　　　　　的都是返回的false.(并不是根據語句的對錯來返回true或者false)

　　　　注意：利用語句對象來執行SQL語句，DQL指查詢，DML指修改、刪除、插入，DDL指新建

?　　　 ? 注意：如果是查詢語句會得到一個結果集，結果集類型是ResultSet，可對結果集進行遍歷

　　3.5 遍歷結果集

　　3.6 關閉語句對象、關閉連接對象

　　　　執行對象.close();

　　　　連接對象.close();

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 2   <modelVersion>4.0.0</modelVersion>
 3   <groupId>cn.xiangxu</groupId>
 4   <artifactId>testJDBC</artifactId>
 5   <version>0.0.1-SNAPSHOT</version>
 6   <dependencies>
 7       <dependency>
 8           <groupId>mysql</groupId>
 9           <artifactId>mysql-connector-java</artifactId>
10           <version>5.1.37</version>
11       </dependency>
12       <dependency>
13           <groupId>junit</groupId>
14           <artifactId>junit</artifactId>
15           <version>4.12</version>
16       </dependency>
17   </dependencies>
18 </project>

maven依賴包

 1 CREATE TABLE user (
 2     id INT (10)  PRIMARY KEY,
 3     name VARCHAR (10),
 4     pwd VARCHAR (10)
 5 );
 6 
 7 DESC USER;
 8 
 9 DROP TABLE user;
10 
11 SELECT * FROM user;

SQL語句

 1 package testJDBC;
 2 
 3 import java.sql.Connection;
 4 import java.sql.DriverManager;
 5 import java.sql.ResultSet;
 6 import java.sql.SQLException;
 7 import java.sql.Statement;
 8 
 9 import org.junit.Test;
10 
11 public class TestCase {
12     @Test
13     public void test01() {
14         Connection conn = null;
15         try {
16             // 01 導入驅動模塊
17             Class.forName("com.mysql.jdbc.Driver");
18             
19             // 02 初始化連接對象（以為在之前就創建了，進行初始化就行啦）
20             conn = DriverManager.getConnection(
21                     "jdbc:mysql://localhost:3306/test", "root", "182838");
22             
23             // 03 創建執行對象
24             Statement state = conn.createStatement();
25             
26             String sql = "SELECT * FROM user ";
27             
28             // 04 執行SQL語句
29             ResultSet rs = state.executeQuery(sql);  // 查詢結果的類型為ResultSet
30             
31             // 05 遍歷查詢結果
32             while(rs.next()) {  // 遍歷結果集
33                 System.out.println(rs.getString("name"));  
34             }
35             
36             // 06 關閉執行對象、連接對象
37             state.close();
38             conn.close();
39             
40         } catch (ClassNotFoundException e) {
41             // TODO Auto-generated catch block
42             e.printStackTrace();
43         } catch (SQLException e) {
44             // TODO Auto-generated catch block
45             e.printStackTrace();
46         } finally {
47             if(null != conn) { // 判斷連接是否關閉
48                 try {
49                     conn.close();
50                 } catch (SQLException e) {
51                     // TODO Auto-generated catch block
52                     e.printStackTrace();
53                 }
54             }
55         }
56         
57     }
58 }

java代碼

?4 存在的問題

　　4.1 重復編譯問題

　　　　利用 Statement對象執行SQL語句時每執行一條SQL語句在數據庫端就會進行一次變異，如果是類似的SQL語句也是這樣；嚴重加大了數據庫的負擔

　　　　改進：利用預編譯的Statement

　　　　　　　　注意：預編譯statement向數據庫中發送一個sql語句，數據庫編譯sql語句，并把編譯的結果保存在數據庫磚的緩存中。下次再發sql時，如果sql相同，則不會再編譯，直接使用緩存中的。

　　4.2 釋放資源問題　　

　　　　程序執行后應該對結果集、執行對象、連接對象進行釋放，而且在finally那里還需要判斷是否成功釋放（注意：try里面定義的變量在finally是獲取不到的）

　　　　改進：在程序的最前面定義連接對象、執行對象、結果集對象；在程序結束后調用各自的close方法來釋放資源，在finally中判斷這三個對象是否成功關閉

5?jdbc編程步驟【學神版本】

　　加載數據庫驅動

　　創建并獲取數據庫鏈接

　　創建jdbc statement對象

　　設置sql語句

　　設置sql語句中的參數(使用preparedStatement)

　　通過statement執行sql并獲取結果

　　對sql執行結果進行解析處理

　　釋放資源(resultSet、preparedstatement、connection)

 1 package testJDBC;
 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 import org.junit.Test;
10 
11 public class TestCase {
12     @Test
13     public void test01() {
14         Connection conn = null;
15         PreparedStatement ps = null;
16         ResultSet rs = null;
17         try {
18             Class.forName("com.mysql.jdbc.Driver"); // 加載數據庫驅動
19             
20             conn = DriverManager.getConnection( // 初始化連接對象
21                     "jdbc:mysql://localhost:3306/test", "root", "182838");
22             
23             
24             String sql = "SELECT * FROM user WHERE pwd = ? "; // 拼接SQL語句，位置參數用？代替
25             
26             ps = conn.prepareStatement(sql); // 初始化預編譯執行對象
27             
28             ps.setString(1, "182838"); // 設置SQL語句中的位置位置參數（注意：是從1開始數不是從0開始數）
29             
30             rs = ps.executeQuery(); // 執行SQL語句
31             
32             while(rs.next()) { // 遍歷結果集
33                 System.out.println("====================");
34                 System.out.println(rs.getInt("id"));
35                 System.out.println(rs.getString("name"));
36                 System.out.println(rs.getString("pwd"));
37             }
38             
39             // 釋放資源
40             rs.close();
41             ps.close(); 
42             conn.close();
43             
44         } catch (Exception e) {
45             // TODO Auto-generated catch block
46             e.printStackTrace();
47         } finally {
48             if(rs != null) {
49                 try {
50                     rs.close();
51                 } catch (SQLException e) {
52                     // TODO Auto-generated catch block
53                     e.printStackTrace();
54                 }
55             }
56             if(ps != null) {
57                 try {
58                     ps.close();
59                 } catch (SQLException e) {
60                     // TODO Auto-generated catch block
61                     e.printStackTrace();
62                 }
63             }
64             if(conn != null) {
65                 try {
66                     conn.close();
67                 } catch (SQLException e) {
68                     // TODO Auto-generated catch block
69                     e.printStackTrace();
70                 }
71             }
72         }
73         
74     }
75 }

優化后的java代碼

6 可優化的地方【學霸版本】

　　沒有將查詢到的結果封裝換成一個對象

 1 package cn.xiangxu.entity;
 2 
 3 import java.io.Serializable;
 4 
 5 public class User implements Serializable {
 6 
 7     private static final long serialVersionUID = -5109978284633713580L;
 8     
 9     private Integer id;
10     private String name;
11     private String pwd;
12     public User() {
13         super();
14         // TODO Auto-generated constructor stub
15     }
16     public User(Integer id, String name, String pwd) {
17         super();
18         this.id = id;
19         this.name = name;
20         this.pwd = pwd;
21     }
22     @Override
23     public int hashCode() {
24         final int prime = 31;
25         int result = 1;
26         result = prime * result + ((id == null) ? 0 : id.hashCode());
27         return result;
28     }
29     @Override
30     public boolean equals(Object obj) {
31         if (this == obj)
32             return true;
33         if (obj == null)
34             return false;
35         if (getClass() != obj.getClass())
36             return false;
37         User other = (User) obj;
38         if (id == null) {
39             if (other.id != null)
40                 return false;
41         } else if (!id.equals(other.id))
42             return false;
43         return true;
44     }
45     public Integer getId() {
46         return id;
47     }
48     public void setId(Integer id) {
49         this.id = id;
50     }
51     public String getName() {
52         return name;
53     }
54     public void setName(String name) {
55         this.name = name;
56     }
57     public String getPwd() {
58         return pwd;
59     }
60     public void setPwd(String pwd) {
61         this.pwd = pwd;
62     }
63     @Override
64     public String toString() {
65         return "User [id=" + id + ", name=" + name + ", pwd=" + pwd + "]";
66     }
67     
68     
69 
70 }

user表對應的實體類

 1 package testJDBC;
 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 import java.util.ArrayList;
 9 import java.util.List;
10 
11 import org.junit.Test;
12 
13 import cn.xiangxu.entity.User;
14 
15 public class TestCase {
16     @Test
17     public void test01() {
18         Connection conn = null;
19         PreparedStatement ps = null;
20         ResultSet rs = null;
21         try {
22             Class.forName("com.mysql.jdbc.Driver"); // 加載數據庫驅動
23             
24             conn = DriverManager.getConnection( // 初始化連接對象
25                     "jdbc:mysql://localhost:3306/test", "root", "182838");
26             
27             
28             String sql = "SELECT * FROM user WHERE pwd = ? "; // 拼接SQL語句，位置參數用？代替
29             
30             ps = conn.prepareStatement(sql); // 初始化預編譯執行對象
31             
32             ps.setString(1, "182838"); // 設置SQL語句中的位置位置參數（注意：是從1開始數不是從0開始數）
33             
34             rs = ps.executeQuery(); // 執行SQL語句
35             
36             List<User> users = new ArrayList<User>(); // 創建一個集合來存放記錄對象
37             while(rs.next()) { // 遍歷結果集
38 //                System.out.println("====================");
39 //                System.out.println(rs.getInt("id"));
40 //                System.out.println(rs.getString("name"));
41 //                System.out.println(rs.getString("pwd"));
42                 User user = new User();
43                 user.setId(rs.getInt("id"));
44                 user.setName(rs.getString("name"));
45                 user.setPwd(rs.getString("pwd"));
46                 users.add(user); // 向集合中添加元素
47             }
48             
49             System.out.println(users); // 打印輸出集合
50             for(User user : users) {
51                 System.out.println(user);
52             }
53             
54             // 釋放資源
55             rs.close();
56             ps.close(); 
57             conn.close();
58             
59         } catch (Exception e) {
60             // TODO Auto-generated catch block
61             e.printStackTrace();
62         } finally {
63             if(rs != null) {
64                 try {
65                     rs.close();
66                 } catch (SQLException e) {
67                     // TODO Auto-generated catch block
68                     e.printStackTrace();
69                 }
70             }
71             if(ps != null) {
72                 try {
73                     ps.close();
74                 } catch (SQLException e) {
75                     // TODO Auto-generated catch block
76                     e.printStackTrace();
77                 }
78             }
79             if(conn != null) {
80                 try {
81                     conn.close();
82                 } catch (SQLException e) {
83                     // TODO Auto-generated catch block
84                     e.printStackTrace();
85                 }
86             }
87         }
88         
89     }
90 }

對查詢結果進行封裝了的java代碼

7 小案例

　　用戶登錄、轉賬系統

  1 package day01;
  2 
  3 import java.sql.Connection;
  4 import java.sql.DriverManager;
  5 import java.sql.ResultSet;
  6 import java.sql.SQLException;
  7 import java.sql.Statement;
  8 import java.util.ArrayList;
  9 import java.util.List;
 10 import java.util.Scanner;
 11 
 12 /**
 13  * 用戶登錄系統
 14  * Description: 
 15  */
 16 public class Service {
 17     private static final int USER_REG = 1;
 18     private static final int USER_LOGIN = USER_REG + 1;
 19     private static final int USER_UPDATE = USER_LOGIN + 1;
 20     private static final int USER_DELETE = USER_UPDATE + 1;
 21     private static final int USER_INFO = USER_DELETE + 1;
 22     private static final int USER_TRANSFER = USER_INFO + 1;
 23     private static final int USER_QUIT = USER_TRANSFER + 1;
 24     private static final int EXIT = USER_QUIT + 1;
 25     
 26     UserInfo user = null;
 27     
 28     public static void main(String[] args) {
 29         Service serv = new Service();
 30         serv.start();
 31     }
 32     
 33     private void start() {
 34         welcome();
 35         int code = getCode();
 36         execute(code);
 37     }
 38 
 39     /**
 40      * 執行選擇
 41      * Description: 
 42      */
 43     private void execute(int code) {
 44         switch (code) {
 45         case USER_REG:
 46             user_reg();
 47             break;
 48         case USER_LOGIN:
 49             user_login();
 50             break;
 51         case USER_UPDATE:
 52             user_update();
 53             break;
 54         case USER_DELETE:
 55             user_delete();
 56             break;
 57         case USER_INFO:
 58             user_info();
 59             break;
 60         case USER_TRANSFER:
 61             user_transfer();
 62             break;
 63         case USER_QUIT:
 64             user_quit();
 65             break;
 66         case EXIT:
 67             exit();
 68             break;
 69         default:
 70             System.out.println("輸入錯誤，請重新輸入");
 71             start();
 72             break;
 73         }
 74     }
 75 
 76     /**
 77      * Description: 
 78      */
 79     private void exit() {
 80         // TODO Auto-generated method stub
 81         if(null != this.user) {
 82             System.out.println("當前用戶還沒有退出，所以執行自動退出當前用戶");
 83             user_quit();
 84         }else {
 85             System.out.println("你選擇了退出系統");
 86             System.out.println("系統退出成功");
 87         }
 88         
 89     }
 90 
 91     /**
 92      * 退出當前用戶
 93      * Description: 
 94      */
 95     private void user_quit() {
 96         // TODO Auto-generated method stub
 97         if(null != this.user) {
 98             System.out.println("你選擇了退出當前用戶功能");
 99             this.user = null;
100             if(null == this.user) {
101                 System.out.println("成功退出當前用戶");
102             }else {
103                 System.out.println("退出當前用戶失敗");
104             }
105         }else {
106             System.out.println("你還沒有登錄成功，還不能使用該功能");
107             System.out.println("請登錄！");
108             user_login();
109         }
110         start();
111     }
112 
113     /**
114      * 轉賬功能
115      * Description: 
116      */
117     private void user_transfer() {
118         // TODO Auto-generated method stub
119         if(null != this.user) {
120             System.out.println("你選擇了轉賬功能！");
121             Scanner scanner = new Scanner(System.in);
122             System.out.println("請輸入轉入賬戶的用戶名：");
123             String name = scanner.nextLine();
124             System.out.println("請輸入轉賬金額：");
125             int money = Integer.parseInt(scanner.nextLine());
126             
127             Connection conn = null;
128             try {
129                 Class.forName("com.mysql.jdbc.Driver");
130                 conn = DriverManager.getConnection(
131                         "jdbc:mysql://localhost:3306/test",
132                         "root",
133                         "182838");
134                 Statement state = conn.createStatement();
135                 
136                 //轉出
137                 String out_sql = "UPDATE userinfo_fury "
138                         + "SET account = account - '"+money+"' "
139                         + "WHERE username = '"+this.user.getUsername()+"' ";
140                 int judge01 = state.executeUpdate(out_sql);
141                 if(judge01 > 0) {
142                     System.out.println("轉出成功");
143                 }else {
144                     System.out.println("轉出失敗");
145                 }
146                 
147                 //轉入
148                 String in_sql = "UPDATE userinfo_fury "
149                         + "SET account = account + '"+money+"' "
150                         + "WHERE username = '"+name+"' ";
151                 int judge02 = state.executeUpdate(in_sql);
152                 if(judge02 > 0) {
153                     System.out.println("轉入成功");
154                 }else {
155                     System.out.println("轉入失敗");
156                 }
157             }catch(Exception e) {
158                 e.printStackTrace();
159             }finally {
160                 if(null != conn) {
161                     try {
162                         conn.close();
163                     }catch(SQLException e1) {
164                         e1.printStackTrace();
165                     }
166                 }
167             }
168         }else {
169             System.out.println("請先登錄！");
170             user_login();
171         }
172         start();
173     }
174 
175     /**
176      * 查詢表中的所有數據
177      * Description: 
178      */
179     private void user_info() {
180         // TODO Auto-generated method stub
181         if(null != this.user) {
182             System.out.println("你選擇了查詢所有用戶功能！");
183             Connection conn = null;
184             try {
185                 Class.forName("com.mysql.jdbc.Driver");
186                 conn = DriverManager.getConnection(
187                         "jdbc:mysql://localhost:3306/test",
188                         "root",
189                         "182838");
190                 Statement state = conn.createStatement();
191                 String sql = "SELECT id,username,password,email,nickname,account "
192                         + "FROM userinfo_fury ";
193                 ResultSet rs = state.executeQuery(sql);
194                 List<UserInfo> list = new ArrayList<UserInfo>();
195                 
196                 while(rs.next()) {
197                     int id = rs.getInt("id");
198                     String username = rs.getString("username");
199                     String password = rs.getString("password");
200                     String email = rs.getString("email");
201                     String nickname = rs.getString("nickname");
202                     double account = rs.getDouble("account");
203                     UserInfo userinfo = new UserInfo(id, username, password, email, nickname, account);
204                     list.add(userinfo);
205                 }
206                 for(UserInfo lis : list) {
207                     System.out.println(lis);
208                 }
209             }catch(Exception e) {
210                 e.printStackTrace();
211             }finally {
212                 if(null != conn) {
213                     try {
214                         conn.close();
215                     }catch(SQLException e1) {
216                         e1.printStackTrace();
217                     }
218                 }
219             }
220         }else {
221             System.out.println("請先登錄");
222             user_login();
223         }
224         start();
225     }
226 
227     /**
228      * 刪除用戶
229      * Description: 
230      */
231     private void user_delete() {
232         // TODO Auto-generated method stub
233         if(null != this.user) {
234             System.out.println("你選擇了刪除用戶功能");
235             System.out.println("你不是超級用戶，你無法使用刪除用戶功能");
236         }else {
237             System.out.println("請先登錄！");
238             user_login();
239         }
240         start();
241     }
242 
243     /**
244      * 修改用戶信息
245      * Description: 
246      */
247     private void user_update() {
248         // TODO Auto-generated method stub
249         if(null != this.user) {
250             System.out.println("你選擇了修改當前用戶功能!");
251             //可改進 -->> 可由用戶選擇需要修改的字段
252             System.out.println("你當前的昵稱為：" + this.user.getNickname());
253             Scanner scanner = new Scanner(System.in);
254             System.out.println("你想將你的昵稱修改為：");
255             String nickname = scanner.nextLine();
256             
257             Connection conn = null;
258             try {
259                 Class.forName("com.mysql.jdbc.Driver");
260                 conn = DriverManager.getConnection(
261                         "jdbc:mysql://localhost:3306/test",
262                         "root",
263                         "182838");
264                 Statement state = conn.createStatement();
265                 
266                 String sql = "UPDATE userinfo_fury "
267                         + "SET nickname = '"+nickname+"' "
268                         + "WHERE username = '"+this.user.getUsername()+"' ";
269                 int judge = state.executeUpdate(sql);
270                 if(judge > 0) {
271                     this.user.setNickname(nickname);
272                     System.out.println("修改昵稱成功,當前昵稱為：" + this.user.getNickname());
273                 }else {
274                     System.out.println("修改昵稱失敗");
275                 }
276             }catch(Exception e) {
277                 e.printStackTrace();
278             }finally {
279                 if(null != conn) {
280                     try {
281                         conn.close();
282                     }catch(SQLException e1) {
283                         e1.printStackTrace();
284                     }
285                 }
286             }
287         }else {
288             System.out.println("請登錄成功后在進行此操作！");
289             user_login();
290         }
291         start();
292     }
293 
294     /**
295      * 用戶登錄
296      * Description: 
297      */
298     private void user_login() {
299         // TODO Auto-generated method stub
300         System.out.println("你選擇了用戶登錄功能！");
301         Scanner scanner = new Scanner(System.in);
302         System.out.println("請輸入用戶名:");
303         String username = scanner.nextLine();
304         System.out.println("請輸入密碼：");
305         String password = scanner.nextLine();
306         
307         Connection conn = null;
308         try {
309             Class.forName("com.mysql.jdbc.Driver");
310             conn = DriverManager.getConnection(
311                     "jdbc:mysql://localhost:3306/test",
312                     "root",
313                     "182838");
314             Statement state = conn.createStatement();
315             
316             String sql = "SELECT id, username, password,email, nickname,account "
317                     + "FROM userinfo_fury "
318                     + "WHERE username = '"+username+"' "
319                     + "AND password = '"+password+"' ";
320             System.out.println(sql);
321             ResultSet rs = state.executeQuery(sql);
322             if(rs.next()) {
323                 int id = rs.getInt("id");
324                 String name = rs.getString("username");
325                 String word = rs.getString("password");
326                 String email = rs.getString("email");
327                 String nickname = rs.getString("nickname");
328                 double account = rs.getDouble("account");
329                 UserInfo userinfo = new UserInfo(id, name, word, email, nickname, account);
330                 this.user = userinfo;
331                 System.out.println("登錄成功,你的昵稱為：" + this.user.getNickname());
332             }else {
333                 System.out.println("登錄失敗:" + this.user);
334             }
335             /*
336              * 注意：
337              *         當用戶輸入的密碼個的格式是：    任意字符' or '數值開頭      時無論用戶名和密碼正確與否，都會登錄成功
338              *         因為  如果這樣輸入就改變了 SQL 語句的原意（在SQL語句中AND的優先級要高于OR）
339              *         實例 ： asdfaer1234' or '1
340              */
341         }catch(Exception e) {
342             e.printStackTrace();
343         }finally {
344             if(null != conn) {
345                 try {
346                     conn.close();
347                 }catch(SQLException e1) {
348                     e1.printStackTrace();
349                 }
350             }
351         }
352         start();
353     }
354 
355     /**
356      * 用戶注冊
357      * Description: 
358      */
359     private void user_reg() {
360         System.out.println("你選擇了用戶注冊功能！");
361         Scanner scanner = new Scanner(System.in);
362         System.out.println("請輸入用戶名：");
363         String username = scanner.nextLine();
364         System.out.println("請輸入密碼：");
365         String password = scanner.nextLine();
366         System.out.println("請輸入郵箱：");
367         String email = scanner.nextLine();
368         System.out.println("請輸入昵稱：");
369         String nickname = scanner.nextLine();
370         Connection conn = null;
371         try {
372             Class.forName("com.mysql.jdbc.Driver");
373             conn = DriverManager.getConnection(
374                     "jdbc:mysql://localhost:3306/test",
375                     "root",
376                     "182838");
377             Statement state = conn.createStatement();
378             String sql = "INSERT INTO userinfo_fury "
379                     + "(username,password,email,nickname) "
380                     + "VALUES "
381                     + "('"+username+"','"+password+"','"+email+"','"+nickname+"')";
382             int judge = state.executeUpdate(sql);
383             if(judge > 0) {
384                 System.out.println("注冊成功");
385             }else {
386                 System.out.println("注冊失敗");
387             }
388         }catch(Exception e) {
389             e.printStackTrace();
390         }finally {
391             if(null != conn) {
392                 try {
393                     conn.close();
394                 }catch(SQLException e1) {
395                     e1.printStackTrace();
396                 }
397             }
398         }
399         start();
400     }
401 
402     /**
403      * 功能選擇
404      * Description: 
405      */
406     private int  getCode() {
407         System.out.println("請選擇功能：");
408         Scanner scanner = new Scanner(System.in);
409         int code = Integer.parseInt(scanner.nextLine());
410         return code;
411     }
412 
413     /**
414      * 界面信息
415      * Description: 
416      */
417     private void welcome() {
418         System.out.println("歡迎使用用戶登錄系統！");
419         System.out.println("請輸入需要操作的功能序號");
420         System.out.println("======================");
421         System.out.println("================");
422         System.out.println("1 : 用戶注冊");
423         System.out.println("2 : 用戶登錄");
424         System.out.println("3 : 修改用戶信息");
425         System.out.println("4 : 刪除用戶");
426         System.out.println("5 : 查看所有用戶信息");
427         System.out.println("6 : 轉賬業務");
428         System.out.println("7 : 用戶退出");
429         System.out.println("8 : 退出系統");
430         System.out.println("================");
431         System.out.println("======================");
432     }
433 }