Java数据库连接--JDBC基础知识(操作数据库：增删改查)

一、JDBC简介

　　JDBC是连接java应用程序和数据库之间的桥梁。

　　什么是JDBC?

　　Java语言访问数据库的一种规范,是一套API。

　　JDBC (Java Database Connectivity) API，即Java数据库编程接口，是一组标准的Java语言中的接口和类，使用这些接口和类，Java客户端程序可以访问各种不同类型的数据库。比如建立数据库连接、执行SQL语句进行数据的存取操作。

　　JDBC全称是java数据库连接，可以为多种数据库提供统一的访问。体现了Java“一次编写，处处运行”的高大上精神。

　　JDBC库中所包含的API任务通常与数据库使用：

　　　　连接到数据库。

　　　　创建SQL或MYSQL语句

　　　　在数据库中执行SQL或MYSQL语句。

　　　　查看或修改记录

　　比如：

二、JDBC使用详解

1、打通数据库

　　<1>工欲善其事必先利其器

　　　　明确目的：需求(做什么)

　　　　　　　　　　实现屌丝逆袭

　　　　　　　　　　拥有女神禁区，享有查看，添加，修改，删除等功能。

　　　　指导思想：概述详设(怎么做)

　　　　工具准备：Mysql、Eclipse、Navicat(数据库管理工具)

　　<2>JDBC编程步骤

　　　　加载驱动程序：Class.forName(driverClass);

　　　　加载mysql驱动：Class.forName("com.mysql.jdbc.Driver");

　　　　加载Oracle驱动：Class.forName("oracle.jdbc.driver.OracleDriver");

　　　　获得数据库连接：DriverManager.getConnection("jdbc:mysql:localhost:3306/mydb","root","mysql123");

　　　　创建Statement对象：conn.createStatement();

　　<3>简单测试:DBUtil.java

 1  public class DBUtil {
 2       
 3      private static final String URL="jdbc:mysql://localhost:3306/mydb";
 4      private static final String NAME="root";
 5      private static final String PASSWORD="mysql";
 6  
 7      public static void main(String[] args) throws Exception{
 8          
 9          //1.加载驱动程序
10          Class.forName("com.mysql.jdbc.Driver");
11          //2.获得数据库的连接
12          Connection conn = DriverManager.getConnection(URL, NAME, PASSWORD);
13          //3.通过数据库的连接操作数据库，实现增删改查
14          Statement stmt = conn.createStatement();
15          ResultSet rs = stmt.executeQuery("select user_name,age from imooc_goddess");//选择import java.sql.ResultSet;
16          while(rs.next()){//如果对象中有数据，就会循环打印出来
17             System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
18          }
19      }
20  }

DBUtil.java

　　<4>运行结果

2、搭建模型层

　　详设：

　　　　采用MVC三层结构

　　采用MVC三层架构：建议从下往上开发(DB->view，需求读懂以后，设计数据库，然后根据数据库映射模型，再写控制层，再写视图层)

　　　　--View视图层：展示数据，反馈用户行为

　　　　--Control控制层：控制数据流通过程，协调视图层和数据层

　　　　--Model模型层：与数据库建立映射，与数据进行交互

　　　　--DB数据库

　　先新增对应的model层，按照数据库表对应的字段编写实体类。

 1 package sql.model;
 2 
 3 import java.util.Date;
 4 
 5 public class Goddess {
 6     private Integer id;
 7     private String userName;
 8     private String 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 String getSex(){
31         return sex;
32     }
33     public void setSex(String 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     public String toString(){
91         return "Goddess:[ user_name="+userName+",sex="+sex+",age="+age+",birthday="+birthday+",email="+email
92                 +",mobile="+mobile+",create_user="+createUser+",create_date="+createDate+",update_user="+
93                 updateUser+",update_date="+updateDate+",isdel="+isDel+" ]";
94     }
95 }

Goddess.java

　　然后开始新增Dao层，并修改DBUtil.java

 1 package sql.Dao;
 2 
 3 import java.sql.DriverManager;
 4 import java.sql.ResultSet;
 5 import java.sql.Connection;
 6 import java.sql.SQLException;
 7 import java.sql.Statement;
 8 
 9 import test.staticTest;
10 
11 public class DBUtil {
12     private static final String URL="jdbc:mysql://localhost:3306/mydb";
13     private static final String NAME="root";
14     private static final String PASSWORD="mysql123";
15     private static Connection conn=null;
16     
17     //静态代码块(将加载驱动、连接数据库放入静态快中)
18     static{
19         try {
20             //1.加载驱动程序
21             Class.forName("com.mysql.jdbc.Driver");
22             //2.获得数据库的连接
23             conn=DriverManager.getConnection(URL,NAME,PASSWORD);
24         } catch (SQLException e) {
25             // TODO: handle exception
26             e.printStackTrace();
27         }catch(ClassNotFoundException e){
28             e.printStackTrace();
29         }
30     }
31     
32     //对外提供一个方法来获取数据库；连接
33     public static Connection getConnection(){
34         return conn;
35     }
36     public static void main(String []args) throws Exception{
37         
38         
39         //3.通过数据库的连接操作数据库，实现增删改查
40         Statement stmt =conn.createStatement();
41         ResultSet rs=stmt.executeQuery("select user_name,age from imooc_goddess");
42         while(rs.next()){
43             System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
44         }
45     }
46 }

DBUtil.java

 1 package sql.Dao;
 2 
 3 import java.sql.Connection;
 4 import java.sql.Date;
 5 import java.sql.PreparedStatement;
 6 import java.sql.ResultSet;
 7 import java.sql.SQLException;
 8 import java.sql.Statement;
 9 import java.util.ArrayList;
10 import java.util.List;
11 import java.util.Map;
12 
13 import sql.model.Goddess;
14 import db.DBCPUtil;
15 
16 
17         public class GoddessDao {
18     
19         }
20     //更新女神
21     public void updateGoddess(Goddess gs) throws Exception{
22         
23     }
24     public void delGoddess(Integer id) throws SQLException{
25         
26     }
27     public List<Goddess> query() throws Exception{
28         Connection con=DBUtil.getConnection();
29         Statement stmt=con.createStatement();
30         ResultSet rs=stmt.executeQuery("select id,user_name,age from imooc_goddess");
31         List<Goddess> gs=new ArrayList<Goddess>();
32         Goddess g=null;
33         while(rs.next()){
34             g=new Goddess();
35             g.setId(rs.getInt("id"));
36             g.setUserName(rs.getString("user_name"));
37             g.setAge(rs.getInt("age"));
38             gs.add(g);
39         }
40         return gs;
41     }
42     
43     //查询单个女神
44     public Goddess get(Integer id) throws SQLException{
45         return null;
46     }
47     
48 }

GoddessDao.java

　　新增Controller层：GoddessAction.java　

 1 package controller;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Date;
 5 import java.util.HashMap;
 6 import java.util.List;
 7 import java.util.Map;
 8 
 9 import sql.Dao.GoddessDao;
10 import sql.model.Goddess;
11 
12 public class GoddessAction {
13     public static void main(String []args) throws Exception {
14         GoddessDao gdDao=new GoddessDao();
15         List<Goddess> gs=gdDao.query();
16         
17         for(Goddess goddess:gs){
18             System.out.println(goddess.getUserName()+","+goddess.getAge());
19         }
20 }

GoddessAction.java

　运行结果：

　　PS:CRUD:增加Create、读取Retrieve(重新得到数据-->高级应用：报表，分页)、更新Update和删除Delete

3、搭建模型层--CRUD操作

　　新增create操作

 1 public void addGoddess(Goddess gs) throws Exception{
 2         Connection connection=DBUtil.getConnection();//首先拿到数据库的连接
 3         String sql=""+
 4                     "insert into imooc_goddess"+
 5                     "(user_name,sex,age,birthday,email,mobile, "+
 6                     "create_user,create_date,update_user,update_date,isdel) "+
 7                     "values("+
 8                     "?,?,?,?,?,?,?,current_date(),?,current_date(),?)";//?表示占位符；用mysql的日期函数current_date()
 9         //来获取当前日期。
10         
11         //预编译SQL语句
12         PreparedStatement psmt=connection.prepareStatement(sql);
13         //先对应SQL语句，给SQL语句传递参数
14         psmt.setString(1, gs.getUserName());
15         psmt.setString(2, gs.getSex());
16         psmt.setInt(3, gs.getAge());
17         //注意：setDate()函数第二个参数需要的是java.sql.Date类型，我们传进来是java.util.Date类型，需要做一下转换。
18         psmt.setDate(4, new Date(gs.getBirthday().getTime()));
19         psmt.setString(5, gs.getEmail());
20         psmt.setString(6, gs.getMobile());
21         psmt.setString(7, gs.getCreateUser());
22         psmt.setString(8, gs.getUpdateUser());
23         psmt.setInt(9, gs.getIsDel());
24         //执行sql语句
25         psmt.execute();
26         
27         /**
28          * prepareStatement这个方法会将SQL语句加载到驱动程序conn集成程序中，但是不直接执行
29          * 而是当它调用execute()方法的时候才真正执行
30          * 
31          * 上面的sql中的参数用？表示，相当于占位符，然后再对参数进行赋值
32          * 当真正执行时，这些参数会加载在SQL语句中，把SQL语句拼接完整采取执行。
33          * 这样就会减少对数据库的操作。
34          * */
35     }

addGoddess(Goddess g)添加女神方法

　　测试：

 1 package controller;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Date;
 5 import java.util.HashMap;
 6 import java.util.List;
 7 import java.util.Map;
 8 
 9 import sql.Dao.GoddessDao;
10 import sql.model.Goddess;
11 
12 public class GoddessAction {
13     public static void main(String []args) throws Exception {
14         GoddessDao gdDao=new GoddessDao();
15         Goddess g1=new Goddess();
16         g1.setUserName("陈好");
17         g1.setAge(29);
18         g1.setSex("女");
19         g1.setBirthday(new Date());
20         g1.setEmail("wangmeili@qq.com");
21         g1.setMobile("123");
22         g1.setCreateUser("admin");
23         g1.setUpdateUser("admin");
24         g1.setIsDel(1);
25         gdDao.addGoddess(g1);//增加女神
26         }
27 }

GoddessAction.java

　　运行结果：

　　修改、删除、查询(根据ID)操作：

 1     //更新女神
 2     public void updateGoddess(Goddess gs) throws Exception{
 3         Connection connection=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         //来获取当前日期。
10         
11         //预编译SQL语句
12         PreparedStatement psmt=connection.prepareStatement(sql);
13         //先对应SQL语句，给SQL语句传递参数
14         psmt.setString(1, gs.getUserName());
15         psmt.setString(2, gs.getSex());
16         psmt.setInt(3, gs.getAge());
17         //注意：setDate()函数第二个参数需要的是java.sql.Date类型，我们传进来是java.util.Date类型，需要做一下转换。
18         psmt.setDate(4, new Date(gs.getBirthday().getTime()));
19         psmt.setString(5, gs.getEmail());
20         psmt.setString(6, gs.getMobile());
21         psmt.setString(7, gs.getUpdateUser());
22         psmt.setInt(8, gs.getIsDel());
23         psmt.setInt(9, gs.getId());
24         //执行sql语句
25         psmt.execute();
26         
27     }
28     public void delGoddess(Integer id) throws SQLException{
29         Connection connection=DBUtil.getConnection();
30         String sql=""+
31                     "delete from imooc_goddess "+
32                     "where id=?";
33         PreparedStatement psmt=connection.prepareStatement(sql);
34         psmt.setInt(1, id);
35         psmt.execute();
36     }
37     public List<Goddess> query() throws Exception{
38         Connection con=DBUtil.getConnection();
39         Statement stmt=con.createStatement();
40         ResultSet rs=stmt.executeQuery("select id,user_name,age from imooc_goddess");
41         List<Goddess> gs=new ArrayList<Goddess>();
42         Goddess g=null;
43         while(rs.next()){
44             g=new Goddess();
45             g.setId(rs.getInt("id"));
46             g.setUserName(rs.getString("user_name"));
47             g.setAge(rs.getInt("age"));
48             gs.add(g);
49         }
50         return gs;
51     }
52     
53     //查询单个女神
54     public Goddess get(Integer id) throws SQLException{
55         Goddess goddess=null;
56         Connection connection=DBUtil.getConnection();
57         String sql=""+
58                 "select * from imooc_goddess "+
59                 "where id=?";
60         PreparedStatement psmt=connection.prepareStatement(sql);
61         psmt.setInt(1, id);
62         //psmt.execute();execute()是执行更改数据库操作(包括新增、修改、删除)；executeQuery()是执行查询操作
63         ResultSet rsResultSet=psmt.executeQuery();
64         while(rsResultSet.next()){
65             goddess=new Goddess();
66             goddess.setId(rsResultSet.getInt("id"));
67             goddess.setUserName(rsResultSet.getString("user_name"));
68             goddess.setSex(rsResultSet.getString("sex"));
69             goddess.setAge(rsResultSet.getInt("age"));
70             goddess.setBirthday(rsResultSet.getDate("birthday"));
71             goddess.setEmail(rsResultSet.getString("email"));
72             goddess.setMobile(rsResultSet.getString("mobile"));
73             goddess.setCreateUser(rsResultSet.getString("create_user"));
74             goddess.setCreateDate(rsResultSet.getDate("create_date"));
75             goddess.setUpdateUser(rsResultSet.getString("update_user"));
76             goddess.setUpdateDate(rsResultSet.getDate("update_date"));
77             goddess.setIsDel(rsResultSet.getInt("isdel"));
78         }
79         return goddess;
80     }

updateGoddess()、delGoddess()、get()

　　查询(根据name/mobile等)操作：

 1 //查询单个女神，(根据姓名等信息去查询)
 2     public List<Goddess> get(String name,String mobile) throws SQLException{
 3         List<Goddess> result=new ArrayList<>();
 4         Connection conn =DBUtil.getConnection();
 5         StringBuffer sb =new StringBuffer();
 6         System.out.print("sql: ");
 7         sb.append("select * from imooc_goddess ");
 8         sb.append("where user_name like ? and mobile like ?");
 9         
10         //预编译sql语句
11         PreparedStatement psmt=conn.prepareStatement(sb.toString());
12         //先对应sql语句，给sql语句传递参数
13         psmt.setString(1, "%"+name+"%");
14         psmt.setString(2, "%"+mobile+"%");
15         System.out.println(sb.toString());
16         
17         //执行sql语句
18         ResultSet rsResultSet=psmt.executeQuery();
19         Goddess goddess=null;
20         while(rsResultSet.next()){
21             goddess=new Goddess();
22             goddess.setId(rsResultSet.getInt("id"));
23             goddess.setUserName(rsResultSet.getString("user_name"));
24             goddess.setSex(rsResultSet.getString("sex"));
25             goddess.setAge(rsResultSet.getInt("age"));
26             goddess.setBirthday(rsResultSet.getDate("birthday"));
27             goddess.setEmail(rsResultSet.getString("email"));
28             goddess.setMobile(rsResultSet.getString("mobile"));
29             goddess.setCreateUser(rsResultSet.getString("create_user"));
30             goddess.setCreateDate(rsResultSet.getDate("create_date"));
31             goddess.setUpdateUser(rsResultSet.getString("update_user"));
32             goddess.setUpdateDate(rsResultSet.getDate("update_date"));
33             goddess.setIsDel(rsResultSet.getInt("isdel"));
34             
35             result.add(goddess);//将结果封装到对象中
36         }
37         return result;
38     }

get(String name,String mobile)

　　测试：

 1 package controller;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Date;
 5 import java.util.HashMap;
 6 import java.util.List;
 7 import java.util.Map;
 8 
 9 import sql.Dao.GoddessDao;
10 import sql.model.Goddess;
11 
12 public class GoddessAction {
13     public static void main(String []args) throws Exception {
14         GoddessDao gdDao=new GoddessDao();    
15         //查询单个女神(根据姓名等信息)
16         List<Goddess> list=gdDao.get("蔡妍", "123456");
17         //遍历结果集
18         for(int i=0;i<list.size();i++){
19             System.out.println(list.get(i).toString());
20         }
21         }
22 }

GoddessAction.java

　　运行结果：

　　查询操作的进一步完善：

 1 //查询单个女神，(根据姓名等信息去查询----->使用Map存储条件信息，防止条件为空可加一条where 1=1,目的是为了保证语法不会出错)
 2     public List<Goddess> get(List<Map<String, Object>> params) throws SQLException{
 3         List<Goddess> result=new ArrayList<>();
 4         Connection conn =DBUtil.getConnection();
 5         StringBuffer sb =new StringBuffer();
 6         System.out.print("sql: ");
 7         sb.append("select * from imooc_goddess where 1=1");//注意where 1=1的小技巧
 8         if(params!=null&&params.size()>0){
 9             //遍历集合
10             for(int i=0; i<params.size();i++){
11                 Map<String, Object> map=params.get(i);
12                 sb.append(" and "+map.get("name")+" "+map.get("rela")+" "+map.get("value")+" ");
13                 //查询什么？关系是什么？以及值是什么，我们都可以通过参数传进来
14             }
15         }
16         
17         
18         //预编译sql语句
19         PreparedStatement psmt=conn.prepareStatement(sb.toString());
20         //先对应sql语句，给sql语句传递参数
21         System.out.println(sb.toString());
22         
23         //执行sql语句
24         ResultSet rsResultSet=psmt.executeQuery();
25         Goddess goddess=null;
26         while(rsResultSet.next()){
27             goddess=new Goddess();
28             goddess.setId(rsResultSet.getInt("id"));
29             goddess.setUserName(rsResultSet.getString("user_name"));
30             goddess.setSex(rsResultSet.getString("sex"));
31             goddess.setAge(rsResultSet.getInt("age"));
32             goddess.setBirthday(rsResultSet.getDate("birthday"));
33             goddess.setEmail(rsResultSet.getString("email"));
34             goddess.setMobile(rsResultSet.getString("mobile"));
35             goddess.setCreateUser(rsResultSet.getString("create_user"));
36             goddess.setCreateDate(rsResultSet.getDate("create_date"));
37             goddess.setUpdateUser(rsResultSet.getString("update_user"));
38             goddess.setUpdateDate(rsResultSet.getDate("update_date"));
39             goddess.setIsDel(rsResultSet.getInt("isdel"));
40             
41             result.add(goddess);//将结果封装到对象中
42         }
43         return result;
44     }

get(List<Map<String,Object>>)

　　测试：

 1 package controller;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Date;
 5 import java.util.HashMap;
 6 import java.util.List;
 7 import java.util.Map;
 8 
 9 import sql.Dao.GoddessDao;
10 import sql.model.Goddess;
11 
12 public class GoddessAction {
13     public static void main(String []args) throws Exception {
14         GoddessDao gdDao=new GoddessDao();                
15         //查询单个女神，(根据姓名等信息去查询----->使用Map存储条件信息，防止条件为空可加一条where 1=1,目的是为了保证语法不会出错)
16         List<Map<String, Object>> params=new ArrayList<Map<String,Object>>();
17         Map<String, Object> param=new HashMap<>();
18         param.put("name", "user_name");
19         param.put("rela", "like");
20         param.put("value", "'%蔡素%'");
21         params.add(param);
22         param=new HashMap<>();
23         param.put("name", "mobile");
24         param.put("rela", "like");
25         param.put("value", "'%123456789%'");
26         params.add(param);
27         List<Goddess> list1=gdDao.get(params);
28         //遍历结果集
29         for(int i=0;i<list1.size();i++){
30             System.out.println(list1.get(i).toString());
31         }
32         }
33 }

GoddessAction.java

　　运行结果：

　　这个查询的亮点在于：使用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 "+动态构造条件子句。

4、搭建控制层

　　控制层起到一个桥梁的作用，连接模型层和视图层。

 1 package controller;
 2 
 3 import java.util.List;
 4 import java.util.Map;
 5 import sql.Dao.GoddessDao;
 6 import sql.model.Goddess;
 7 
 8 
 9 /*
10  * 控制层起到一个桥梁的作用，连接模型层和视图层*/
11 
12 
13 public class GoddessAction1 {
14     
15     //添加女神
16     public void add(Goddess goddess) throws Exception{
17         GoddessDao dao=new GoddessDao();
18         goddess.setSex("女");
19         goddess.setIsDel(0);
20         dao.addGoddess(goddess);
21     }
22     
23     //修改女神
24     public void edit(Goddess goddess) throws Exception{
25         GoddessDao dao=new GoddessDao();
26         dao.updateGoddess(goddess);
27     }
28     
29     //删除女神
30     public void del(Integer id) throws Exception{
31         GoddessDao dao=new GoddessDao();
32         dao.delGoddess(id);
33     }
34     
35     //查询所有女神
36     public List<Goddess> query() throws Exception{
37         GoddessDao dao=new GoddessDao();
38         return dao.query();
39     }
40     
41     //查询单个女神信息(根据id)
42     public Goddess get(Integer id) throws Exception{
43         GoddessDao dao=new GoddessDao();
44         return dao.get(id);
45     }
46     
47     //查询单个女神(根据姓名等信息)
48     public List<Goddess> get(List<Map<String, Object>> params) throws Exception{
49         GoddessDao dao=new GoddessDao();
50         return dao.get(params);
51     }
52 }

GoddessAction1.java

5、搭建视图层

　　<1>流程

　　　　程序启动后，一直保持在运行状态

　　　循环接收控制台的输入参数

　　　调用Action(控制层)响应，并将返回结果展示在控制台中。

　　　知道输入特定的输入标记(如EXIT)后，程序退出。

　　<2>问题点

　　　　循环接收参数

　　　某个功能的保持

　　<3>代码示例

  1 package view;
  2 
  3 import java.util.Date;
  4 import java.text.ParseException;
  5 import java.text.SimpleDateFormat;
  6 import java.util.List;
  7 import java.util.Scanner;
  8 
  9 import sql.model.Goddess;
 10 import controller.GoddessAction1;
 11 
 12 
 13      
 14 
 15 public class View {
 16     //提示语
 17     private static final String CONTEXT="欢迎来到女神禁区：
" +
 18             "下面是女神禁区的功能列表：
" +
 19             "[MAIN/M]:主菜单
" +
 20             "[QUERY/Q]:查看全部女神的信息
" +
 21             "[GET/G]:查看某位女神的详细信息
" +
 22             "[ADD/A]:添加女神信息
" +
 23             "[UPDATE/U]:更新女神信息
" +
 24             "[DELETE/D]:删除女神信息
" +
 25             "[SEARCH/S]:查询女神信息(根据姓名、手机号来查询)
" +
 26            "[EXIT/E]:退出女神禁区
" +
 27            "[BREAK/B]:退出当前功能，返回主菜单";
 28     
 29     //操作标记
 30     private static final String OPERATION_MAIN="MAIN";
 31     private static final String OPERATION_QUERY="QUERY";
 32     private static final String OPERATION_GET="GET";
 33     private static final String OPERATION_ADD="ADD";
 34     private static final String OPERATION_UPDATE="UPDATE";
 35     private static final String OPERATION_DELETE="DELETE";
 36     private static final String OPERATION_SEACHR="SEARCH";
 37     private static final String OPERATION_EXIT="EXIT";
 38     private static final String OPERATION_BREAK="BREAK";
 39     
 40     public static void main(String []args){
 41         //输出提示
 42         System.out.println(CONTEXT);
 43         //怎么保持程序的一直运行：while(true)
 44         Scanner inScanner=new Scanner(System.in);//受程序台的控制
 45         Goddess go=new Goddess();
 46         GoddessAction1 action=new GoddessAction1();
 47         
 48         String prenious=null;//标记，记住上一次的请求
 49         Integer step=1;//步骤标记
 50         while(inScanner.hasNext()){
 51             //有数值时，才进行循环，没有就不进行。
 52             String string=inScanner.next().toString();
 53             if (OPERATION_EXIT.equals(string.toUpperCase())
 54                     || OPERATION_EXIT.substring(0, 1).equals(string.toUpperCase())) {
 55                 System.out.println("您已成功退出女神禁区！");
 56                 break;//退出当前while循环
 57             }else if(OPERATION_QUERY.equals(string.toUpperCase())
 58                     || OPERATION_QUERY.substring(0,1).equals(string.toUpperCase())){
 59                 try {
 60                     List<Goddess> list=action.query();
 61                     for(Goddess g : list){
 62                         System.out.println(g.getId()+", 姓名："+g.getUserName());
 63                     }
 64                 } catch (Exception e) {
 65                     // TODO: handle exception
 66                     e.printStackTrace();
 67                 }
 68             }else if (OPERATION_ADD.equals(string.toUpperCase())
 69                     || OPERATION_ADD.substring(0,1).equals(string.toUpperCase())
 70                     || OPERATION_ADD.equals(prenious)) {
 71                 prenious=OPERATION_ADD;
 72                 //新增女神
 73                 if (step==1) {
 74                     System.out.println("请输入女神 [姓名] ");    
 75                 }else if (step==2) {
 76                     go.setUserName(string);
 77                     System.out.println("请输入女神 [年龄] ");
 78                 }else if (step==3) {
 79                     go.setAge(Integer.valueOf(string));//string转换为int型
 80                     System.out.println("请输入女神 [生日] ");
 81                 }else if (step==4) {
 82                     SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
 83                     Date birthday=null;
 84                     try {
 85                         birthday=sf.parse(string);
 86                         go.setBirthday(birthday);
 87                         System.out.println("请输入女神 [邮箱]");
 88                     } catch (Exception e) {
 89                         // TODO: handle exception
 90                         e.printStackTrace();
 91                         System.out.println("您的输入有误，请重新输入");
 92                         step=3;
 93                     }
 94                 }else if (step==5) {
 95                     go.setEmail(string);
 96                     System.out.println("请输入女神 [手机号] ");
 97                 }else if (step==6) {
 98                     go.setMobile(string);
 99                     try {
100                         action.add(go);
101                         System.out.println("新增女神成功");
102                     } catch (Exception e) {
103                         // TODO: handle exception
104                         e.printStackTrace();
105                         System.out.println("新增女神失败");
106                     }
107                     
108                 }if(OPERATION_ADD.equals(prenious)){
109                     step++;
110                 }
111             }else {
112                 System.out.println("您的输入值为："+inScanner);
113             }
114                 
115         }
116     }
117 }

View.java

　　<4>运行结果

三、JDBC总结

　　 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与数据库分开，开发者只需关心内部逻辑的实现而不需注重数据库连接的具体实现。（没有中间环节，是推荐方式！

转载：Java数据库连接

相关阅读:
su和sudo命令详解
 JS线程Web worker
Navicat 批处理自动备份数据库
 MySql【Error笔记】
vue入门
 动态库
 环境变量
 cmake_learn
自动编译
 网络编程
原文地址：https://www.cnblogs.com/liuzhongfeng/p/6058866.html