一、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&¶ms.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="欢迎来到女神禁区：\n" +
18 "下面是女神禁区的功能列表：\n" +
19 "[MAIN/M]:主菜单\n" +
20 "[QUERY/Q]:查看全部女神的信息\n" +
21 "[GET/G]:查看某位女神的详细信息\n" +
22 "[ADD/A]:添加女神信息\n" +
23 "[UPDATE/U]:更新女神信息\n" +
24 "[DELETE/D]:删除女神信息\n" +
25 "[SEARCH/S]:查询女神信息(根据姓名、手机号来查询)\n" +
26 "[EXIT/E]:退出女神禁区\n" +
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将调用传递给中间服务器，中间服务器再将调用转换成数据库能够被调用的形式，在调用数据库服务器。中间增设数据库服务器能够提升效率，但不如直接操作数据库便捷。
特点：这使得Application与数据库分开，开发者只需关心内部逻辑的实现而不需注重数据库连接的具体实现。（没有中间环节，是推荐方式！
转载：Java数据库连接
当神已无能为力，那便是魔渡众生
