閱讀目錄
JDBC是連接java應用程序和數據庫之間的橋梁。
什麼是JDBC?
Java語言訪問數據庫的一種規范,是一套API。
JDBC (Java Database Connectivity) API，即Java數據庫編程接口，是一組標准的Java語言中的接口和類，使用這些接口和類，Java客戶端程序可以訪問各種不同類型的數據庫。比如建立數據庫連接、執行SQL語句進行數據的存取操作。
JDBC代表Java數據庫連接。
JDBC庫中所包含的API任務通常與數據庫使用：
連接到數據庫
創建SQL或MySQL語句
在數據庫中執行SQL或MySQL查詢
查看和修改記錄
比如：
先新建Java 工程，將jar包導進去：
然後新建相應的數據庫和表。
編寫DBUtil.java
1 package com.study.db;
2
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.ResultSet;
6 import java.sql.Statement;
7
8 public class DBUtil {
9
10 private static final String URL="jdbc:mysql://localhost:3306/demo_jdbc";
11 private static final String NAME="root";
12 private static final String PASSWORD="root";
13
14 public static void main(String[] args) throws Exception{
15
16 //1.加載驅動程序
17 Class.forName("com.mysql.jdbc.Driver");
18 //2.獲得數據庫的連接
19 Connection conn = DriverManager.getConnection(URL, NAME, PASSWORD);
20 //3.通過數據庫的連接操作數據庫，實現增刪改查
21 Statement stmt = conn.createStatement();
22 ResultSet rs = stmt.executeQuery("select user_name,age from imooc_goddess");//選擇import java.sql.ResultSet;
23 while(rs.next()){//如果對象中有數據，就會循環打印出來
24 System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
25 }
26 }
27 }
采用MVC三層架構：建議由下往上開發（DB->view,需求讀懂以後，設計數據庫，然後根據數據庫映射模型，再寫控制層，再寫視圖層）
先新增對應的model層：按照數據庫表對應的字段編寫實體類。
1 package com.study.model;
2
3 import java.util.Date;
4
5 public class Goddess {
6 private Integer id;
7 private String userName;
8 private Integer sex;
9 private Integer age;
10 private Date birthday;
11 private String email;
12 private String mobile;
13 private String createUser;
14 private Date createDate;
15 private String updateUser;
16 private Date updateDate;
17 private Integer isDel;
18 public Integer getId() {
19 return id;
20 }
21 public void setId(Integer id) {
22 this.id = id;
23 }
24 public String getUserName() {
25 return userName;
26 }
27 public void setUserName(String userName) {
28 this.userName = userName;
29 }
30 public Integer getSex() {
31 return sex;
32 }
33 public void setSex(Integer sex) {
34 this.sex = sex;
35 }
36 public Integer getAge() {
37 return age;
38 }
39 public void setAge(Integer age) {
40 this.age = age;
41 }
42 public Date getBirthday() {
43 return birthday;
44 }
45 public void setBirthday(Date birthday) {
46 this.birthday = birthday;
47 }
48 public String getEmail() {
49 return email;
50 }
51 public void setEmail(String email) {
52 this.email = email;
53 }
54 public String getMobile() {
55 return mobile;
56 }
57 public void setMobile(String mobile) {
58 this.mobile = mobile;
59 }
60 public String getCreateUser() {
61 return createUser;
62 }
63 public void setCreateUser(String createUser) {
64 this.createUser = createUser;
65 }
66 public Date getCreateDate() {
67 return createDate;
68 }
69 public void setCreateDate(Date createDate) {
70 this.createDate = createDate;
71 }
72 public String getUpdateUser() {
73 return updateUser;
74 }
75 public void setUpdateUser(String updateUser) {
76 this.updateUser = updateUser;
77 }
78 public Date getUpdateDate() {
79 return updateDate;
80 }
81 public void setUpdateDate(Date updateDate) {
82 this.updateDate = updateDate;
83 }
84 public Integer getIsDel() {
85 return isDel;
86 }
87 public void setIsDel(Integer isDel) {
88 this.isDel = isDel;
89 }
90
91 }
然後開始新增Dao層，並修改DBUtil.java
DBUtil.java代碼如下：
1 package com.study.db;
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 public class DBUtil {
10
11 private static final String URL="jdbc:mysql://localhost:3306/demo_jdbc";
12 private static final String NAME="root";
13 private static final String PASSWORD="root";
14
15 private static Connection conn=null;
16 //靜態代碼塊（將加載驅動、連接數據庫放入靜態塊中）
17 static{
18 try {
19 //1.加載驅動程序
20 Class.forName("com.mysql.jdbc.Driver");
21 //2.獲得數據庫的連接
22 conn = DriverManager.getConnection(URL, NAME, PASSWORD);
23 } catch (ClassNotFoundException e) {
24 e.printStackTrace();
25 } catch (SQLException e) {
26 e.printStackTrace();
27 }
28 }
29 //對外提供一個方法來獲取數據庫連接
30 public static Connection getConnection(){
31 return conn;
32 }
33
34 public static void main(String[] args) throws Exception{
35
36 //3.通過數據庫的連接操作數據庫，實現增刪改查
37 Statement stmt = conn.createStatement();
38 ResultSet rs = stmt.executeQuery("select user_name,age from imooc_goddess");//選擇import java.sql.ResultSet;
39 while(rs.next()){//如果對象中有數據，就會循環打印出來
40 System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
41 }
42 }
43 }
goddessDao.java 代碼如下：
1 package com.study.dao;
2
3 import java.sql.Connection;
4 import java.sql.ResultSet;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7 import java.util.ArrayList;
8 import java.util.List;
9
10 import com.study.db.DBUtil;
11 import com.study.model.Goddess;
12
13 public class GoddessDao {
14
15 public void addGoddess(){
16
17 }
18
19 public void updateGoddess(){
20
21 }
22 public void delGoddess(){
23
24 }
25
26 public List<Goddess> query() throws Exception{
27 Connection con=DBUtil.getConnection();
28 Statement stmt=con.createStatement();
29 ResultSet rs=stmt.executeQuery("select user_name,age from imooc_goddess");
30 List<Goddess> gs=new ArrayList<Goddess>();
31 Goddess g=null;
32 while(rs.next()){//如果對象中有數據，就會循環打印出來
33 g=new Goddess();
34 g.setUserName(rs.getString("user_name"));
35 g.setAge(rs.getInt("age"));
36 gs.add(g);
37 }
38 return gs;
39 }
40
41 //查詢單個女神
42 public Goddess get(){
43 return null;
44 }
45 }
新增Controller層：GoddessAction.java
1 package com.study.controller;
2
3 import java.util.List;
4
5 import com.study.dao.GoddessDao;
6 import com.study.model.Goddess;
7
8 public class GoddessAction {
9
10 public static void main(String[] args) throws Exception {
11 GoddessDao gd=new GoddessDao();
12 List<Goddess> gs=gd.query();
13 for (Goddess goddess : gs) {
14 System.out.println(goddess.getUserName()+","+goddess.getAge());
15 }
16
17 }
18
19 }
PS：CRUD：增加(Create)、讀取(Retrieve)（重新得到數據-->高級應用：報表、分頁）、更新(Update)和刪除(Delete)
新增create操作：
1 //添加女神
2 public void addGoddess(Goddess g) throws Exception{
3 Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
4 String sql="" +
5 "insert into imooc_goddess"+
6 "(user_name,sex,age,birthday,email,mobile,"+
7 "create_user,create_date,update_user,update_date,isdel) "+
8 "values("+
9 "?,?,?,?,?,?,?,current_date(),?,current_date(),?)";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
10 //預編譯sql語句
11 PreparedStatement psmt = con.prepareStatement(sql);
12 //先對應SQL語句，給SQL語句傳遞參數
13 psmt.setString(1, g.getUserName());
14 psmt.setInt(2, g.getSex());
15 psmt.setInt(3, g.getAge());
16 //注意：setDate()函數第二個參數需要的是java.sql.Date類型，我們傳進來的是java.util.Date，類型不符，需要做一下轉換
17 psmt.setDate(4, new Date(g.getBirthday().getTime()));
18 psmt.setString(5, g.getEmail());
19 psmt.setString(6, g.getMobile());
20 psmt.setString(7, g.getCreateUser());
21 psmt.setString(8, g.getUpdateUser());
22 psmt.setInt(9, g.getIsDel());
23 //執行SQL語句
24 psmt.execute();
25 /**
26 * prepareStatement這個方法會將SQL語句加載到驅動程序conn集成程序中，但是並不直接執行
27 * 而是當它調用execute()方法的時候才真正執行；
28 *
29 * 上面SQL中的參數用?表示，相當於占位符，然後在對參數進行賦值。
30 * 當真正執行時，這些參數會加載在SQL語句中，把SQL語句拼接完整才去執行。
31 * 這樣就會減少對數據庫的操作
32 */
33 }
測試：
package com.study.controller;
import java.util.Date;
import java.util.List;
import com.study.dao.GoddessDao;
import com.study.model.Goddess;
public class GoddessAction {
public static void main(String[] args) throws Exception {
GoddessDao gd=new GoddessDao();
Goddess g1=new Goddess();
g1.setUserName("小夏");
g1.setAge(22);
g1.setSex(1);
g1.setBirthday(new Date());
g1.setEmail("[email protected]");
g1.setMobile("123456789");
g1.setCreateUser("admin");
g1.setUpdateUser("admin");
g1.setIsDel(1);
//添加女神
gd.addGoddess(g1);
}
}
修改、刪除、查詢(根據id)操作：
1 //更新女神
2 public void updateGoddess(Goddess g) throws SQLException{
3 Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
4 String sql="" +
5 "update imooc_goddess "+
6 "set user_name=?,sex=?,age=?,birthday=?,email=?,mobile=?,"+
7 "update_user=?,update_date=current_date(),isdel=?) "+
8 "where id=?";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
9 //預編譯sql語句
10 PreparedStatement psmt = con.prepareStatement(sql);
11 //先對應SQL語句，給SQL語句傳遞參數
12 psmt.setString(1, g.getUserName());
13 psmt.setInt(2, g.getSex());
14 psmt.setInt(3, g.getAge());
15 //注意：setDate()函數第二個參數需要的是java.sql.Date類型，我們傳進來的是java.util.Date，類型不符，需要做一下轉換
16 psmt.setDate(4, new Date(g.getBirthday().getTime()));
17 psmt.setString(5, g.getEmail());
18 psmt.setString(6, g.getMobile());
19 psmt.setString(7, g.getUpdateUser());
20 psmt.setInt(8, g.getIsDel());
21 psmt.setInt(9, g.getId());
22 //執行SQL語句
23 psmt.execute();
24 }
25
26 //刪除女神
27 public void delGoddess(Integer id) throws SQLException{
28 Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
29 String sql="" +
30 "delete from imooc_goddess "+
31 "where id=?";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
32 //預編譯sql語句
33 PreparedStatement psmt = con.prepareStatement(sql);
34 //先對應SQL語句，給SQL語句傳遞參數
35 psmt.setInt(1, id);
36 //執行SQL語句
37 psmt.execute();
38 }
39
40 //查詢單個女神(根據id去查詢)
41 public Goddess get(Integer id) throws SQLException{
42 Goddess g=null;
43 Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
44 String sql="" +
45 "select * from imooc_goddess "+
46 "where id=?";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
47 //預編譯sql語句
48 PreparedStatement psmt = con.prepareStatement(sql);
49 //先對應SQL語句，給SQL語句傳遞參數
50 psmt.setInt(1, id);
51 //執行SQL語句
52 /*psmt.execute();*///execute()方法是執行更改數據庫操作（包括新增、修改、刪除）;executeQuery()是執行查詢操作
53 ResultSet rs = psmt.executeQuery();//返回一個結果集
54 //遍歷結果集
55 while(rs.next()){
56 g=new Goddess();
57 g.setId(rs.getInt("id"));
58 g.setUserName(rs.getString("user_name"));
59 g.setAge(rs.getInt("age"));
60 g.setSex(rs.getInt("sex"));
61 //rs.getDate("birthday")獲得的是java.sql.Date類型。注意：java.sql.Date類型是java.util.Date類型的子集，所以這裡不需要進行轉換了。
62 g.setBirthday(rs.getDate("birthday"));
63 g.setEmail(rs.getString("email"));
64 g.setMobile(rs.getString("mobile"));
65 g.setCreateUser(rs.getString("create_user"));
66 g.setCreateDate(rs.getDate("create_date"));
67 g.setUpdateUser(rs.getString("update_user"));
68 g.setUpdateDate(rs.getDate("update_date"));
69 g.setIsDel(rs.getInt("isdel"));
70 }
71 return g;
72 }
查詢（根據name\mobile等）操作
1 //查詢單個女神(根據姓名等信息去查詢)
2 public List<Goddess> get(String name,String mobile) throws SQLException{
3 List<Goddess> result=new ArrayList<Goddess>();
4 Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
5 StringBuffer sb=new StringBuffer();
6 sb.append("select * from imooc_goddess ");
7 sb.append("where user_name like ? and mobile like ?");
8 //預編譯sql語句
9 PreparedStatement psmt = con.prepareStatement(sb.toString());
10 //先對應SQL語句，給SQL語句傳遞參數
11 psmt.setString(1, "%"+name+"%");
12 psmt.setString(2, "%"+mobile+"%");
13 System.out.println(sb.toString());
14 //執行SQL語句
15 /*psmt.execute();*///execute()方法是執行更改數據庫操作（包括新增、修改、刪除）;executeQuery()是執行查詢操作
16 ResultSet rs = psmt.executeQuery();//返回一個結果集
17 Goddess g=null;
18 //遍歷結果集
19 while(rs.next()){
20 g=new Goddess();
21 g.setId(rs.getInt("id"));
22 g.setUserName(rs.getString("user_name"));
23 g.setAge(rs.getInt("age"));
24 g.setSex(rs.getInt("sex"));
25 //rs.getDate("birthday")獲得的是java.sql.Date類型。注意：java.sql.Date類型是java.util.Date類型的子集，所以這裡不需要進行轉換了。
26 g.setBirthday(rs.getDate("birthday"));
27 g.setEmail(rs.getString("email"));
28 g.setMobile(rs.getString("mobile"));
29 g.setCreateUser(rs.getString("create_user"));
30 g.setCreateDate(rs.getDate("create_date"));
31 g.setUpdateUser(rs.getString("update_user"));
32 g.setUpdateDate(rs.getDate("update_date"));
33 g.setIsDel(rs.getInt("isdel"));
34
35 result.add(g);//將結果封裝到對象中
36 }
37 return result;
38 }
測試：
1 package com.study.controller;
2
3 import java.util.Date;
4 import java.util.List;
5
6 import com.study.dao.GoddessDao;
7 import com.study.model.Goddess;
8
9 public class GoddessAction {
10
11 public static void main(String[] args) throws Exception {
12 GoddessDao gd=new GoddessDao();
13 /*//查詢所有女神
14 List<Goddess> gs=gd.query();
15 for (Goddess goddess : gs) {
16 System.out.println(goddess.getUserName()+","+goddess.getAge());
17 }*/
18
19 Goddess g1=new Goddess();
20 g1.setUserName("小夏");
21 g1.setAge(22);
22 g1.setSex(1);
23 g1.setBirthday(new Date());
24 g1.setEmail("[email protected]");
25 g1.setMobile("123456789");
26 g1.setCreateUser("admin");
27 g1.setUpdateUser("admin");
28 g1.setIsDel(1);
29 //添加女神
30 // gd.addGoddess(g1);
31
32 //查詢單個女神（根據id）
33 /*Goddess g2 = gd.get(4);
34 System.out.println(g2.toString());*/
35
36 //查詢單個女神（根據姓名等信息）
37 List<Goddess> list = gd.get("小溪", "139");
38 //遍歷結果集
39 for(int i=0;i<list.size();i++){
40 System.out.println(list.get(i).toString());
41 }
42 }
43
44 }
運行結果：
select * from imooc_goddess where user_name like ? and mobile like ? Goddess [id=1, userName=小溪, sex=1, age=22, birthday=2000-12-12, [email protected], mobile=13911111111, createUser=ADMIN, createDate=2015-01-08, updateUser=ADMIN, updateDate=2015-01-08, isDel=0]
查詢操作的進一步完善：
1 //查詢單個女神(根據姓名等信息去查詢)----->使用Map存儲條件信息；防止條件為空可加一條where 1=1
2 public List<Goddess> get(List<Map<String, Object>> params) throws SQLException{
3 List<Goddess> result=new ArrayList<Goddess>();
4 Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
5 StringBuffer sb=new StringBuffer();
6 sb.append("select * from imooc_goddess where 1=1 ");//注意where 1=1 的小技巧
7 if(params !=null && params.size()>0){//先判斷集合是否為空
8 //遍歷集合
9 for(int i=0;i<params.size();i++){
10 Map<String, Object> map=params.get(i);
11 sb.append("and "+map.get("name")+" " +map.get("rela")+" "+map.get("value")+" ");//查詢什麼？關系是什麼？以及值是什麼，我們都可以通過參數傳進來。
12 }
13
14 }
15 //預編譯sql語句
16 PreparedStatement psmt = con.prepareStatement(sb.toString());
17 System.out.println(sb.toString());
18 //執行SQL語句
19 /*psmt.execute();*///execute()方法是執行更改數據庫操作（包括新增、修改、刪除）;executeQuery()是執行查詢操作
20 ResultSet rs = psmt.executeQuery();//返回一個結果集
21 Goddess g=null;
22 //遍歷結果集
23 while(rs.next()){
24 g=new Goddess();
25 g.setId(rs.getInt("id"));
26 g.setUserName(rs.getString("user_name"));
27 g.setAge(rs.getInt("age"));
28 g.setSex(rs.getInt("sex"));
29 //rs.getDate("birthday")獲得的是java.sql.Date類型。注意：java.sql.Date類型是java.util.Date類型的子集，所以這裡不需要進行轉換了。
30 g.setBirthday(rs.getDate("birthday"));
31 g.setEmail(rs.getString("email"));
32 g.setMobile(rs.getString("mobile"));
33 g.setCreateUser(rs.getString("create_user"));
34 g.setCreateDate(rs.getDate("create_date"));
35 g.setUpdateUser(rs.getString("update_user"));
36 g.setUpdateDate(rs.getDate("update_date"));
37 g.setIsDel(rs.getInt("isdel"));
38
39 result.add(g);//將結果封裝到對象中
40 }
41 return result;
42 }
測試：
1 //查詢單個女神(根據姓名等信息去查詢)----->使用Map存儲條件信息
2 List<Map<String, Object>> params=new ArrayList<Map<String,Object>>();
3 Map<String, Object> param=new HashMap<String, Object>();
4 param.put("name", "user_name");
5 // param.put("rela", "=");
6 // param.put("value", "'小溪'");//注意加上單引號，因為這個變量是字符串的形式
7 param.put("rela", "like");
8 param.put("value", "'%小溪%'");//注意加上單引號，因為這個變量是字符串的形式
9 params.add(param);
10 param=new HashMap<String, Object>();
11 param.put("name", "mobile");
12 param.put("rela", "like");
13 param.put("value", "'%139%'");
14 params.add(param);
15 List<Goddess> list1 = gd.get(params);
16 //遍歷結果集
17 for(int i=0;i<list1.size();i++){
18 System.out.println(list1.get(i).toString());
19 }
運行結果：
select * from imooc_goddess where 1=1 and user_name like '%小溪%' and mobile like '%139%' Goddess [id=1, userName=小溪, sex=1, age=22, birthday=2000-12-12, [email protected], mobile=13911111111, createUser=ADMIN, createDate=2015-01-08, updateUser=ADMIN, updateDate=2015-01-08, isDel=0]
這個查詢的亮點在於：使用get(List<Map<String,Object>> params) 和 where 1=1；
jdbc傳參數過多的時候：用List<Map<String,Object>> params雙泛型作為參數.
我們查詢的每一個條件都是一個鍵值對。鍵值對的數據結構就是Map。
然後是因為查詢的條件可能是多個，數量不確定，所以用List 比較好，所以就會是List<Map<key,value>>這樣的數據結構了。
上面使用where 1=1的原因主要是下面的語句直接就跟著一個and。SQL語句後面需要跟著where，但不確定where後面是否有語句，就要加上1=1，保證語法不會出錯。
一般用於構造動態SQL語句，"SELECT ... FROM ... WHERE 1=1 "+動態構造條件子句。
控制層起到一個橋梁的作用，連接模型層和視圖層。
1 package com.study.controller;
2
3 import java.util.List;
4 import java.util.Map;
5
6 import com.study.dao.GoddessDao;
7 import com.study.model.Goddess;
8
9 public class GoddessAction1 {
10
11 //添加女神
12 public void add(Goddess goddess) throws Exception{
13 GoddessDao dao=new GoddessDao();
14 goddess.setSex(1);
15 goddess.setIsDel(0);
16 dao.addGoddess(goddess);
17 }
18
19 //修改女神
20 public void edit(Goddess goddess) throws Exception{
21 GoddessDao dao=new GoddessDao();
22 dao.updateGoddess(goddess);
23 }
24
25 //刪除女神
26 public void del(Integer id) throws Exception{
27 GoddessDao dao=new GoddessDao();
28 dao.delGoddess(id);
29 }
30
31 //查詢所有女神信息
32 public List<Goddess> query() throws Exception{
33 GoddessDao dao=new GoddessDao();
34 return dao.query();
35 }
36
37 //查詢單個女神信息(根據id)
38 public Goddess get(Integer id) throws Exception{
39 GoddessDao dao=new GoddessDao();
40 return dao.get(id);
41 }
42
43 //查詢單個女神信息（根據姓名等信息）
44 public List<Goddess> get(List<Map<String, Object>> params) throws Exception{
45 GoddessDao dao=new GoddessDao();
46 return dao.get(params);
47 }
48 }
代碼實例：
1 package com.study.view;
2
3 import java.text.ParseException;
4 import java.text.SimpleDateFormat;
5 import java.util.Date;
6 import java.util.List;
7 import java.util.Scanner;
8
9 import com.study.controller.GoddessAction1;
10 import com.study.model.Goddess;
11
12 public class View {
13
14 //提示語
15 private static final String CONTEXT="歡迎來到女神禁區：\n" +
16 "下面是女神禁區的功能列表：\n" +
17 "[MAIN/M]:主菜單\n" +
18 "[QUERY/Q]:查看全部女神的信息\n" +
19 "[GET/G]:查看某位女神的詳細信息\n" +
20 "[ADD/A]:添加女神信息\n" +
21 "[UPDATE/U]:更新女神信息\n" +
22 "[DELETE/D]:刪除女神信息\n" +
23 "[SEARCH/S]:查詢女神信息(根據姓名、手機號來查詢)\n" +
24 "[EXIT/E]:退出女神禁區\n" +
25 "[BREAK/B]:退出當前功能，返回主菜單";
26
27 //操作標記
28 private static final String OPERATION_MAIN="MAIN";
29 private static final String OPERATION_QUERY="QUERY";
30 private static final String OPERATION_GET="GET";
31 private static final String OPERATION_ADD="ADD";
32 private static final String OPERATION_UPDATE="UPDATE";
33 private static final String OPERATION_DELETE="DELETE";
34 private static final String OPERATION_SEARCH="SEARCH";
35 private static final String OPERATION_EXIT="EXIT";
36 private static final String OPERATION_BREAK="BREAK";
37
38 public static void main(String[] args) {
39 //輸出提示
40 System.out.println(CONTEXT);
41 //怎麼保持程序的一直運行:while(true){}
42 Scanner scanner=new Scanner(System.in);//接受控制台的輸入
43 Goddess goddess=new Goddess();
44 GoddessAction1 action=new GoddessAction1();
45
46 String prenious=null;//標記，記住上一次請求
47 Integer step=1;//步驟標記
48 while(scanner.hasNext()){//scanner.hasNext()有數值時才進行循環，沒有就不進行循環
49 String in=scanner.next().toString();
50 if(OPERATION_EXIT.equals(in.toUpperCase())
51 || OPERATION_EXIT.substring(0, 1).equals(in.toUpperCase())){
52 System.out.println("您已成功退出女神禁區。");
53 break;//退出當前while循環
54 }else if(OPERATION_QUERY.equals(in.toUpperCase())
55 ||OPERATION_QUERY.substring(0, 1).equals(in.toUpperCase())){
56 try {
57 List<Goddess> list=action.query();
58 for (Goddess go : list) {
59 System.out.println(go.getId()+",姓名："+go.getUserName());
60 }
61 } catch (Exception e) {
62 e.printStackTrace();
63 }
64 }else if(OPERATION_ADD.equals(in.toUpperCase())
65 || OPERATION_ADD.substring(0, 1).equals(in.toUpperCase())
66 || OPERATION_ADD.equals(prenious)){
67 prenious=OPERATION_ADD;
68 //新增女神
69 if(1==step){//如果是第一次進來
70 System.out.println("請輸入女神的［姓名］");
71 }else if(2==step){
72 goddess.setUserName(in);
73 System.out.println("請輸入女神的［年齡］");
74 }else if(3==step){
75 goddess.setAge(Integer.valueOf(in));//string轉換為int型
76 System.out.println("請輸入女神的［生日］，格式如：yyyy-MM-dd");
77 }else if(4==step){
78 SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
79 Date birthday=null;
80 try {
81 birthday = sf.parse(in);
82 goddess.setBirthday(birthday);
83 System.out.println("請輸入女神的［郵箱］");
84 } catch (ParseException e) {
85 e.printStackTrace();
86 System.out.println("您輸入的格式有誤，請重新輸入");
87 step=3;
88 }
89 }else if(5==step){
90 goddess.setEmail(in);
91 System.out.println("請輸入女神的［手機號］");
92 }else if(6==step){
93 goddess.setMobile(in);
94 try {
95 action.add(goddess);
96 System.out.println("新增女神成功");
97 } catch (Exception e) {
98 e.printStackTrace();
99 System.out.println("新增女神失敗");
100 }
101 }
102 if(OPERATION_ADD.equals(prenious)){
103 step++;
104 }
105 }else{
106 System.out.println("您輸入的值為："+in);
107 }
108 }
109 }
110 }
運行結果:
1、JDBC的基本概念：JDBC是連接數據庫的橋梁；
是由Java語言編寫的類和接口組成，可以為多種數據庫提供統一的訪問。
2、采用MVC三層結構:
DB（數據庫）、Model（模型層）、Control（控制層）、View（視圖層）
模型層（DB + DAO）：封裝了實現類
控制層：負責調用模型層
視圖層調用控制層3、JDBC各種連接方式的對比：
- 1、JDBC + ODBC橋的方式。特點：需要數據庫的ODBC驅動，僅適用於微軟的系統
這種方式，JDBC將調用傳遞給ODBC，然後ODBC再調用本地的數據庫驅動代碼。
- 2、JDBC + 廠商API的形式。特點：廠商API一般使用C編寫
這種方式，JDBC將調用直接傳遞給廠商API的服務，然後在調用本地的數據庫驅動。
- 3、JDBC + 廠商Database Connection Server + DataBase的形式。
特點：在JAVA與DATABASE之間架起了一台專門用於數據庫連接的服務器（一般有數據庫廠商提供）
這種方式，JDBC將調用傳遞給中間服務器，中間服務器再將調用轉換成數據庫能夠被調用的形式，在調用數據庫服務器。中間增設數據庫服務器能夠提升效率，但不如直接操作數據庫便捷。
- 4、JDBC + DATABASE的連接方式。
特點：這使得Application與數據庫分開，開發者只需關心內部邏輯的實現而不需注重數據庫連接的具體實現。（沒有中間環節，是推薦方式！）
