1.JDBC简介
JDBC就像桥梁一样连接着我们的java和数据库。本节课程我们将会学到
1.JDBC简介
2.使用详解
- JDBC常用接口
- JDBC编程步骤
- 执行SQL语句
- 管理结果集
- 事务管理
3.高级应用
- 分页
- 高级查询
- 高级函数的使用
4.整理总结
下面我们开始JDBC的学习之旅。
JDBC的基本概念，JDBC全程为Java Data Base Connectivity（java数据库连接） 可以为多种数据库提供统一的访问，体现了java“编写一次，处处运行”的高大上精神。JAVA应用程序就可以通过JDBC连接不同的数据库，比如oracle，mysql还有sql server数据库等。
2.JDBC项目展示
课程小项目
3.JDBC实战–打通数据库
JDBC编程步骤：
- 加载驱动程序：
Class.forName(driverClass)，利用反射功能，通过一个类名反射将类加载到我们的程序中。
加载mysql驱动：Class.forName("com.mysql.jdbc.Driver");
加载oracle驱动：Class.forName("oracle.jdbc.driver.OracleDriver"); - 获得数据库的连接：
DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/imooc","root","password"); - 创建Statement对象：
conn.createStatement();
在这里我们需要注意的是，mysql驱动程序要下载下来，然后保存到lib包中，加载到环境变量中去。这里IDEA的操作步骤是，直接把文件拖到lib包下，然后File——Project Structure——右边中间的Module source——点击+号，第一个选择对应的jar包，然后点ok就可以了。因为没有加载好出现了两个错误，Exception in thread “main” java.lang.NoClassDefFoundError 还有ClassNotFoundException，前者是可以编译，但是在实际运行时调用不了那个类，后者是没有加载该类。
import java.sql.*;
/**
* Created by Administrator on 2017/8/10.
*/
public class DBUtil {
//建立三个常量来存储mysql地址，用户名和密码
private static final String URL="jdbc:mysql://127.0.0.1:3306/imooc?useSSL=false";
//jdbc连接的是mysql数据库，它的地址是本机127.0.0.1端口号
//3306，数据库的名称imooc。
private static final String USER="root";
private static final String PASSWORD="123456789";
public static void main(String[] args) {
try {
//1.加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
//2.获得数据库的连接，JDBC提供给我们一个驱动类，
//DriverManager，它里面有个方法获取连接。通过地址，
//用户名和密码。
Connection conn=DriverManager.getConnection(URL,USER,PASSWORD);
//3.通过数据库的连接操作数据库，实现增删改查
Statement stmt= conn.createStatement();
//通过Statement的这个对象来操作数据库，这里返回的结果
//是ResultSet类型的，注意，选择时会有两个，一个是
//java.sql包下的，另一个是jdbc.sql包下的，选择第一
//个。查询语句是executeQuery，增删改查是execute。
ResultSet rs=stmt.executeQuery("SELECT user_name,age FROM imooc_goddess");
//那么如何输出想要的结果呢？这里有一个方法是.next方
//法，如果返回值是true则代表有数据
while(rs.next()){
System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}catch (SQLException e) {
e.printStackTrace();
}
}
}4.JDBC实战—搭建模型层 Ⅰ
详设：这里我们也采用实际开放中最常用的MVC三层架构，即：
View视图层
Control控制层
Model模型层
数据库
最下面就是我们的DB数据库。模型主要包括两个部分，一个是对应的数据库的映射，还有就是对数据库映射的抽象方法，比如说增加删除修改查询简称CRUD，控制层控制我们数据的流通过程，视图层是展示给用户的。一般当要开发的程序足够大，就会有人专门负责视图层也就是前端，他们不用过多的考虑业务逻辑以及后端的实现，另一部分人则专注于后台的开发。开发的时候可以从上往下，也可以从下往上，一般建议是从下往上进行开发。
建立一个对应数据库的实体类。
import java.util.Date;
/**
* Created by Administrator on 2017/8/12.
* 数据库对应的实体类
*/
public class Goddess {
private Integer id;
private String user_name;
private Integer sex;
private Integer age;
private Date birthday;//注意是util包下的，不是sql包下的
private String email;
private String mobile;
private String create_user;
private String update_user;
private Date create_date;
private Date update_date;
private Integer isdel;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUser_name() {
return user_name;
}
public void setUser_name(String user_name) {
this.user_name = user_name;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public String getCreate_user() {
return create_user;
}
public void setCreate_user(String create_user) {
this.create_user = create_user;
}
public String getUpdate_user() {
return update_user;
}
public void setUpdate_user(String update_user) {
this.update_user = update_user;
}
public Date getCreate_date() {
return create_date;
}
public void setCreate_date(Date create_date) {
this.create_date = create_date;
}
public Date getUpdate_date() {
return update_date;
}
public void setUpdate_date(Date update_date) {
this.update_date = update_date;
}
public Integer getIsdel() {
return isdel;
}
public void setIsdel(Integer isdel) {
this.isdel = isdel;
}
}有了这个模型还不够，我们还需要一些具体的方法，比如说对女神的增删改查的操作，那么我们要操作数据库，如何才能将数据插入进去呢？我们知道首先要加载驱动，然后获取数据库的连接，咱们才能对数据库进行操作。所以我们需要把这个连接引用到这个类里才能继续操作。这里我们可以通过修改以前的类来实现。将之前加载驱动程序获取连接的程序放到程序的一个静态模块中，然后再创建一个方法去获取这个连接，如下所示：
public class DBUtil {
//建立三个常量来存储mysql地址，用户名和密码
private static final String URL="jdbc:mysql://127.0.0.1:3306/imooc?useSSL=false";
private static final String USER="root";
private static final String PASSWORD="123456789";
private static Connection conn=null;
static{
//1.加载驱动程序
try {
Class.forName("com.mysql.jdbc.Driver");
//2.获得数据库的连接
conn=DriverManager.getConnection(URL,USER,PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
}catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static Connection getConnection(){
return conn;
}
......
}修改类名IDEA可以用shift+F6的方式来改。这里有了连接之后我们可以尝试着写一个查询的代码来测试下。
//查询，因为查询可能返回多个女神，所以用List集合
public List<Goddess> query() throws Exception{
Connection conn=DBUtil.getConnection();
//3.通过数据库的连接操作数据库，实现增删改查
Statement stmt= null;
stmt = conn.createStatement();
ResultSet rs= null;
rs = stmt.executeQuery("SELECT user_name,age FROM imooc_goddess");
List<Goddess> gs=new ArrayList<Goddess>();
Goddess g=null;
while(rs.next()){
g=new Goddess();
g.setUser_name(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
gs.add(g);
}
return gs;
}
//控制层调用尝试输出一下上面查询方法的结果
package action;
import dao.GoddessDao;
import model.Goddess;
import java.util.List;
/**
* Created by Administrator on 2017/9/11.
*/
public class GoddessAction {
public static void main(String[] args) throws Exception {
GoddessDao g=new GoddessDao();
List<Goddess> gs=g.query();
for(Goddess a:gs){
System.out.println(a.getUser_name()+","+a.getAge());
}
}
}5. JDBC实战—搭建模型层 Ⅱ
//增加女神的方法
public void addGoddess(Goddess goddess) throws Exception{
Connection conn=DBUtil.getConnection();
String sql="insert into imooc_goddess (user_name,sex,age,birthday,email,mobile," +
"create_user,create_date,update_user,update_date,isdel) VALUES " +
"(?,?,?,?,?,?,?,current_date,?,current_date,?)";
PreparedStatement ptmt=conn.prepareStatement(sql);//预编译sql语句
//这个方法会将sql语句加载到驱动程序的执行程序中，但是呢并不直接执行，而是当它调用execute方法时，
//才真正的执行。那valuse中的参数怎么表示呢？用？,然后在实际执行之前再给他们赋值，这样执行的时候就是完整的
//这样就减少对数据库的操作，这里我们赋值不能直接写死，不然前台就没办法操作了。一共11个参数挨个赋值也会很麻烦
//这里有个方法是直接在方法里传递一个参数，这个参数就是女神Goddess本分，然后通过它来获取属性信息
ptmt.setString(1,goddess.getUser_name());
ptmt.setInt(2,goddess.getSex());
ptmt.setInt(3,goddess.getAge());
ptmt.setDate(4,new Date(goddess.getBirthday().getTime()));//这里注意会报错，因为setDate方法要求传递的是
//sql包下的date类型，java.sql.Date，因此我们要进行一波转换。new Date(goddess.getBirthday().getTime())
ptmt.setString(5,goddess.getEmail());
ptmt.setString(6,goddess.getMobile());
ptmt.setString(7,goddess.getCreate_user());
ptmt.setString(8,goddess.getUpdate_user());
ptmt.setInt(9,goddess.getIsdel());
ptmt.execute();
}//测试
public class GoddessAction {
public static void main(String[] args) throws Exception {
GoddessDao g=new GoddessDao();
Goddess gs=new Goddess();
gs.setUser_name("小樱");
gs.setAge(25);
gs.setSex(1);
gs.setBirthday(new Date());
gs.setEmail("xiaoying@imooc.com");
gs.setMobile("12828282828");
gs.setCreate_user("admin");
gs.setUpdate_user("admin");
gs.setIsdel(1);
g.addGoddess(gs);
}
}刷新结果已经多出来了一行。
6.JDBC实战—搭建模型层 Ⅲ
//修改女神的方法
public void updateGoddess(Goddess goddess) throws Exception{
Connection conn=DBUtil.getConnection();
String sql="update imooc_goddess set user_name=?,sex=?,age=?,birthday=?,email=?," +
"mobile=?," +
"update_user=?,update_date=current_date(),isdel=? where id=?";
PreparedStatement ptmt=conn.prepareStatement(sql);//预编译sql语句
//这个方法会将sql语句加载到驱动程序的执行程序中，但是呢并不直接执行，而是当它调用execute方法时，
//才真正的执行。那valuse中的参数怎么表示呢？用？,然后在实际执行之前再给他们赋值，这样执行的时候就是完整的
//这样就减少对数据库的操作，这里我们赋值不能直接写死，不然前台就没办法操作了。一共11个参数挨个赋值也会很麻烦
//这里有个方法是直接在方法里传递一个参数，这个参数就是女神Goddess本分，然后通过它来获取属性信息
ptmt.setString(1,goddess.getUser_name());
ptmt.setInt(2,goddess.getSex());
ptmt.setInt(3,goddess.getAge());
ptmt.setDate(4,new Date(goddess.getBirthday().getTime()));//这里注意会报错，因为setDate方法要求传递的是
//sql包下的date类型，java.sql.Date，因此我们要进行一波转换。new Date(goddess.getBirthday().getTime())
ptmt.setString(5,goddess.getEmail());
ptmt.setString(6,goddess.getMobile());
ptmt.setString(7,goddess.getUpdate_user());
ptmt.setInt(8,goddess.getIsdel());
ptmt.setInt(9,goddess.getId());
ptmt.execute();
}
//删除女神的方法
public void delGoddess(Integer id) throws Exception{
Connection conn=DBUtil.getConnection();
String sql="delete from imooc_goddess where id=?";
PreparedStatement ptmt=conn.prepareStatement(sql);//预编译sql语句
//这个方法会将sql语句加载到驱动程序的执行程序中，但是呢并不直接执行，而是当它调用execute方法时，
//才真正的执行。那valuse中的参数怎么表示呢？用？,然后在实际执行之前再给他们赋值，这样执行的时候就是完整的
//这样就减少对数据库的操作，这里我们赋值不能直接写死，不然前台就没办法操作了。一共11个参数挨个赋值也会很麻烦
//这里有个方法是直接在方法里传递一个参数，这个参数就是女神Goddess本分，然后通过它来获取属性信息
ptmt.setInt(1,id);
ptmt.execute();
}
//查询单个女神的方法
public Goddess get(Integer id) throws SQLException{
Goddess g=null;
Connection conn=DBUtil.getConnection();
String sql="select * from imooc_goddess where id=?";
PreparedStatement ptmt=conn.prepareStatement(sql);//预编译sql语句
//这个方法会将sql语句加载到驱动程序的执行程序中，但是呢并不直接执行，而是当它调用execute方法时，
//才真正的执行。那valuse中的参数怎么表示呢？用？,然后在实际执行之前再给他们赋值，这样执行的时候就是完整的
//这样就减少对数据库的操作，这里我们赋值不能直接写死，不然前台就没办法操作了。一共11个参数挨个赋值也会很麻烦
//这里有个方法是直接在方法里传递一个参数，这个参数就是女神Goddess本分，然后通过它来获取属性信息
ptmt.setInt(1,id);
ResultSet rs=ptmt.executeQuery();//这里注意就不是execute的方法了，这个是用来更改数据库的操作，如新增修改删除，咱们这儿是查询
//executeQuery会返回一个查询的结果。
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUser_name(rs.getString("user_name"));
g.setSex(rs.getInt("sex"));
g.setAge(rs.getInt("age"));
g.setBirthday(rs.getDate("birthday"));
//注意上面这句需要的参数是java.util.Date类型，但直接获取的是sql.date类型的，
//此时是可以直接使用不需要再转换的，反之就要转换，这是因为sql.date类型是util.date类型的一个子集。
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreate_date(rs.getDate("create_date"));
g.setCreate_user(rs.getString("create_user"));
g.setUpdate_date(rs.getDate("update_date"));
g.setUpdate_user(rs.getString("update_user"));
g.setIsdel(rs.getInt("isdel"));
}
return g;
}
//控制层，测试类，需要重写toString()方法
/**
* Created by Administrator on 2017/9/11.
*/
public class GoddessAction {
public static void main(String[] args) throws Exception {
GoddessDao g=new GoddessDao();
Goddess gs=new Goddess();
gs.setUser_name("小樱");
gs.setAge(23);
gs.setSex(1);
gs.setBirthday(new Date());
gs.setEmail("xiaoying@imooc.com");
gs.setMobile("16565656565");
gs.setUpdate_user("ADMIN");
gs.setIsdel(1);
gs.setId(3);
//g.addGoddess(gs);
//g.updateGoddess(gs);
//g.delGoddess(3);
Goddess g1=g.get(2);
System.out.println(g1.toString());
}
}7.JDBC实战—搭建模型层 IV
这里主要是更改一下查询女神的方法，之前是直接全部查询然后输出，现在改成根据姓名或者手机号来查询，可以做成模糊查询，像这样它是可以无限传输参数的，但是越多会越大，这时也可以考虑其他的方法。通过将参数作为集合来传递进去，第二段代码就是。
//根据姓名和电话来查询，因为查询可能返回多个女神，所以用List集合
public List<Goddess> query(String name,String mobile) throws Exception{
Connection conn=DBUtil.getConnection();
List<Goddess> gs=new ArrayList<Goddess>();
//3.通过数据库的连接操作数据库，实现增删改查
StringBuilder sql=new StringBuilder();
sql.append("SELECT * from imooc_goddess");
sql.append(" where user_name like ? and mobile like ? ");
PreparedStatement stmt= null;
stmt = conn.prepareStatement(sql.toString());
stmt.setString(1,"%"+name+"%");
stmt.setString(2,"%"+mobile+"%");
ResultSet rs= null;
rs = stmt.executeQuery();
Goddess g=null;
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUser_name(rs.getString("user_name"));
g.setSex(rs.getInt("sex"));
g.setAge(rs.getInt("age"));
g.setBirthday(rs.getDate("birthday"));
//注意上面这句需要的参数是java.util.Date类型，但直接获取的是sql.date类型的，
//此时是可以直接使用不需要再转换的，反之就要转换，这是因为sql.date类型是util.date类型的一个子集。
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreate_date(rs.getDate("create_date"));
g.setCreate_user(rs.getString("create_user"));
g.setUpdate_date(rs.getDate("update_date"));
g.setUpdate_user(rs.getString("update_user"));
g.setIsdel(rs.getInt("isdel"));
gs.add(g);
}
return gs;
}public List<Goddess> query(List<Map<String,Object>> params) throws Exception{
Connection conn=DBUtil.getConnection();
List<Goddess> gs=new ArrayList<Goddess>();
//3.通过数据库的连接操作数据库，实现增删改查
StringBuilder sql=new StringBuilder();
sql.append("SELECT * from imooc_goddess where 1=1");
//where 1=1永远成立，这个小技巧在实际开发中经常使用到，因为我们后面要跟and
if(params!=null&¶ms.size()>0){
sql.append(" and (");
for(int i=0;i<params.size();i++){
Map<String,Object> map=params.get(i);
if(i<(params.size()-1))sql.append(" "+map.get("name")+" "+map.get("rela")+" "+
map.get("value")+" or ");
if(i==(params.size()-1))sql.append(" "+map.get("name")+" "+map.get("rela")+" "+
map.get("value")+")");
}
}
System.out.println(sql.toString());
PreparedStatement stmt= null;
stmt = conn.prepareStatement(sql.toString());
ResultSet rs= null;
rs = stmt.executeQuery();
Goddess g=null;
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUser_name(rs.getString("user_name"));
g.setSex(rs.getInt("sex"));
g.setAge(rs.getInt("age"));
g.setBirthday(rs.getDate("birthday"));
//注意上面这句需要的参数是java.util.Date类型，但直接获取的是sql.date类型的，
//此时是可以直接使用不需要再转换的，反之就要转换，这是因为sql.date类型是util.date类型的一个子集。
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreate_date(rs.getDate("create_date"));
g.setCreate_user(rs.getString("create_user"));
g.setUpdate_date(rs.getDate("update_date"));
g.setUpdate_user(rs.getString("update_user"));
g.setIsdel(rs.getInt("isdel"));
gs.add(g);
}
return gs;
}
//测试
GoddessDao g=new GoddessDao();
List<Map<String,Object>> params=new ArrayList<Map<String,Object>>();
Map<String,Object> param=new HashMap<String,Object>();
param.put("name","user_name");
param.put("rela","like");
param.put("value","'%小美%'");
params.add(param);
param=new HashMap<String,Object>();
param.put("name","mobile");
param.put("rela","like");
param.put("value","'%12345678998%'");
params.add(param);
param=new HashMap<String,Object>();
param.put("name","birthday");
param.put("rela","=");
param.put("value","'2000-12-12'");
params.add(param);
List<Goddess> result=g.query(params);
for(int i=0;i<result.size();i++){
System.out.println(result.get(i).toString());
}8.JDBC实战—搭建控制层
接下来我们进行控制层的编码，我们知道控制层是用来接收视图层的用户输入的信息的，并调用模型层，模型层将结果返回控制层，控制层再传递给用户，也就是更新视图层。
在重新查看我们的详设之后，我们会发现无非就是更删改查四个操作，所以控制层也要有这些方法。
public void add(Goddess goddess) throws Exception{
GoddessDao dao=new GoddessDao();
dao.addGoddess(goddess);
}
public void del(Integer id) throws Exception{
GoddessDao dao=new GoddessDao();
dao.delGoddess(id);
}
public void edit(Goddess goddess)throws Exception{
GoddessDao dao=new GoddessDao();
dao.updateGoddess(goddess);
}
public Goddess get(Integer id) throws Exception{
GoddessDao dao=new GoddessDao();
return dao.get(id);
}
public List<Goddess> query()throws Exception{
GoddessDao dao=new GoddessDao();
return dao.query();
}
public List<Goddess> query(List<Map<String,Object>> params) throws Exception{
GoddessDao dao=new GoddessDao();
return dao.query(params);
}
9.JDBC-搭建视图层
无数个if elseif~~
import action.GoddessAction;
import model.Goddess;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Scanner;
import java.util.List;
/**
* Created by Administrator on 2017/9/12.
*/
public class view {
public static final String CONTEXT = "欢迎来到女神禁区：\n" +
"下面是女神禁区的功能列表：\n" +
"[MAIN/M]:主菜单\n" +
"[QUERY/Q]:查看全部女神的信息\n" +
"[GET/G]:查看某位女神的详细信息\n" +
"[ADD/A]:添加女神信息\n" +
"[UPDATE/U]:更新女神信息\n" +
"[DELETE/D]:删除女神信息\n" +
"[SEARCH/S]:查询女神信息(根据姓名、手机号来查询)\n" +
"[EXIT/E]:退出女神禁区\n" +
"[BREAK/B]:退出当前功能，返回主菜单";
private static final String OPERATION_MAIN = "MAIN";
private static final String OPERATION_QUERY = "QUERY";
private static final String OPERATION_GET = "GET";
private static final String OPERATION_ADD = "ADD";
private static final String OPERATION_UPDATE = "UPDATE";
private static final String OPERATION_DELETE = "DELETE";
private static final String OPERATION_SEARCH = "SEARCH";
private static final String OPERATION_EXIT = "EXIT";
private static final String OPERATION_BREAK = "BREAK";
public static void main(String[] args) {
System.out.println(CONTEXT);
Scanner scan = new Scanner(System.in);
Goddess goddess = new Goddess();
GoddessAction action = new GoddessAction();
String prenious = null;
Integer step = 1;
String name = null;
int x = 0;//更新的ID
//怎么保持程序的一直运行
while (scan.hasNext()) {//scan.hasNext()，有输入值的时候就循环，没有就不循环。
String in = scan.next().toString();
if ((OPERATION_EXIT.equals(in.toUpperCase()))//将输入的值变为大写
|| OPERATION_EXIT.substring(0, 1).equals(in.toUpperCase())) {//截取第一个字母E
System.out.println("您已成功退出女神禁区。");
break;
}else if((OPERATION_MAIN.equals(in.toUpperCase()))
|| OPERATION_MAIN.substring(0, 1).equals(in.toUpperCase())){
prenious =null;
step=1;
System.out.println(CONTEXT);
} else if ((OPERATION_BREAK.equals(in.toUpperCase()))
|| OPERATION_BREAK.substring(0, 1).equals(in.toUpperCase())) {
prenious =null;
step=1;
System.out.println("退出当前功能，返回主菜单");
System.out.println(CONTEXT);
} else if ((OPERATION_UPDATE.equals(in.toUpperCase()))
|| OPERATION_UPDATE.substring(0, 1).equals(in.toUpperCase())
|| OPERATION_UPDATE.equals(prenious)) {
prenious = OPERATION_UPDATE;
if (step == 1) {
System.out.println("请输入您要更新的女神编号：");
} else if (step == 2) {
x = Integer.parseInt(in);
goddess.setId(x);
try {
Goddess goddess2 = new Goddess();
goddess2 = action.get(x);
goddess.setUser_name(goddess2.getUser_name());
goddess.setAge(goddess2.getAge());
goddess.setBirthday(goddess2.getBirthday());
goddess.setEmail(goddess2.getEmail());
goddess.setMobile(goddess2.getMobile());
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("请输入更新后女神的姓名（不变则输入null即可）：");
} else if (step == 3) {
if (!(in.equals("null"))) {
{
goddess.setUser_name(in);
System.out.println("请输入更新后女神的年龄（不变则输入null即可）：");
}
}
}else if (step == 4) {
if (!(in.equals("null"))) {
int y = Integer.valueOf(in);
goddess.setAge(y);
System.out.println("请输入更新后的女神生日（不变则输入null即可）：");
}else{
System.out.println("请输入更新后的女神生日（不变则输入null即可）：");
}
} else if (step == 5) {
if (!(in.equals("null"))) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date birthday = null;
try {
birthday = sdf.parse(in);
goddess.setBirthday(birthday);
System.out.println("请输入更新后女神的邮箱（不变则输入null即可）：");
} catch (ParseException e) {
e.printStackTrace();
}
}else{
System.out.println("请输入更新后女神的邮箱（不变则输入null即可）：");
}
} else if (step == 6) {
if (!(in.equals("null"))) {
goddess.setEmail(in);
System.out.println("请输入更新后女神电话（不变则输入null即可）：");
}else{
System.out.println("请输入更新后女神电话（不变则输入null即可）：");
}
} else if (step == 7) {
if (!(in.equals("null"))) {
goddess.setMobile(in);
try {
action.edit(goddess);
System.out.println("女神信息更新成功");
prenious =null;
step=1;
} catch (Exception e) {
e.printStackTrace();
System.out.println("女神信息更新失败");
}
}else{
try {
action.edit(goddess);
System.out.println("女神信息更新成功");
prenious =null;
step=1;
} catch (Exception e) {
e.printStackTrace();
System.out.println("女神信息更新失败");
}
}
}
if (OPERATION_UPDATE.equals(prenious)) {
step++;
}
} else if ((OPERATION_SEARCH.equals(in.toUpperCase()))
|| OPERATION_SEARCH.substring(0, 1).equals(in.toUpperCase())
|| OPERATION_SEARCH.equals(prenious)) {
prenious = OPERATION_SEARCH;
if (step == 1) {
System.out.println("请输入您要查询的女神姓名：");
} else if (step == 2) {
name = in;
System.out.println("请输入您要查询的女神手机：");
} else if (step == 3) {
String mobile = in;
try {
List<Goddess> result = action.search(name, mobile);
for (Goddess a : result) {
System.out.println(a.toString());
}
prenious =null;
step=1;
} catch (Exception e) {
e.printStackTrace();
}
}
if (OPERATION_SEARCH.equals(prenious)) {
step++;
}
} else if ((OPERATION_GET.equals(in.toUpperCase()))
|| OPERATION_GET.substring(0, 1).equals(in.toUpperCase())
|| OPERATION_GET.equals(prenious)) {
prenious = OPERATION_GET;
if (step == 1) {
System.out.println("请输入具体要查看的女神的编号：");
} else if (step == 2) {
try {
x = Integer.parseInt(in);
goddess = action.get(x);
System.out.println(goddess.toString());
prenious =null;
step=1;
} catch (Exception e) {
e.printStackTrace();
}
}
if (OPERATION_GET.equals(prenious)) {
step++;
}
}else if ((OPERATION_DELETE.equals(in.toUpperCase()))
|| OPERATION_DELETE.substring(0, 1).equals(in.toUpperCase())
|| OPERATION_DELETE.equals(prenious)) {
prenious = OPERATION_DELETE;
if (step == 1) {
System.out.println("请输入您要删除的女神id：");
} else if (step == 2) {
try {
x = Integer.parseInt(in);
action.del(x);
System.out.println("删除女神成功");
prenious =null;
step=1;
} catch (Exception e) {
e.printStackTrace();
System.out.println("删除女神失败");
}
}
if (OPERATION_DELETE.equals(prenious)) {
step++;
}
} else if ((OPERATION_QUERY.equals(in.toUpperCase()))
|| OPERATION_QUERY.substring(0, 1).equals(in.toUpperCase())) {
try {
System.out.println("禁区女神的基本信息如下：");
List<Goddess> result = action.query();
for (Goddess a : result) {
System.out.println("编号：" + a.getId() + ",姓名：" + a.getUser_name());
}
} catch (Exception e) {
e.printStackTrace();
}
} else if ((OPERATION_ADD.equals(in.toUpperCase()))
|| OPERATION_ADD.substring(0, 1).equals(in.toUpperCase())
|| OPERATION_ADD.equals(prenious)) {
prenious = OPERATION_ADD;
if (step == 1) {
System.out.println("请输入女神的[姓名]：");
} else if (2 == step) {
goddess.setUser_name(in);
System.out.println("请输入女神的[年龄]");
} else if (3 == step) {
goddess.setAge(Integer.valueOf(in));
System.out.println("请输入女神的[生日]，格式为：“yyyy-MM-dd”");
} else if (4 == step) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date birthday = null;
try {
birthday = sdf.parse(in);
goddess.setBirthday(birthday);
System.out.println("请输入女神的邮箱：");
} catch (ParseException e) {
e.printStackTrace();
System.out.println("您输入的格式有误，请重新输入：");
step = 3;
}
} else if (5 == step) {
goddess.setEmail(in);
System.out.println("请输入女神的手机号码：");
} else if (6 == step) {
try {
goddess.setMobile(in);
action.add(goddess);
System.out.println("新增女神成功");
prenious =null;
step=1;
} catch (Exception e) {
e.printStackTrace();
System.out.println("新增女神失败");
}
}
if (OPERATION_ADD.equals(prenious)) {
step++;
}
}
}
}
}10.课程总结
JDBC的连接方式：
1.JDBC+ODBC桥
特点：需要数据库的ODBC驱动，仅适用于微软的系统
2.JDBC+厂商API
特点厂商API一般使用C编写
3.JDBC+厂商Database Connection Server+DataBase
特点：在JAVA与Database之间假期了一台专门用于数据库连接的服务器（一般有数据库厂商提供）
4.JDBC+DATABASE（推荐使用）
特点：这使得Application与数据库分开开发者只需要关心内部逻辑的实现而不需要注重数据库连接的具体实现
常用的orm映射工具：
1.mybaits
2.hibernate
用来代替JDBC进行数据库的操作
47
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
