JDBC 数据库连接

Posted 大梦千古

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JDBC 数据库连接相关的知识,希望对你有一定的参考价值。

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

 

首先我们需要往所用的软件中添加相对应的sqljdbc.jar。

大体流程


 

1、加载JDBC驱动程序:

  在连接数据库之前,首先要加载想要连接的数据库的驱动到JVM(Java虚拟机),这通过java.lang.Class类的静态方法forName(String  className)实现。

2、提供JDBC连接的URL。

3、创建数据库的连接:

  •要连接数据库,需要向java.sql.DriverManager请求并获得Connection对象, 该对象就代表一个数据库的连接。  

  •使用DriverManager的getConnectin(String url , String username , String password )方法传入指定的欲连接的数据库的路径、数据库的用户名和密码来获得。 

4、创建一个Statement:

  •要执行SQL语句,必须获得java.sql.Statement实例,Statement实例分为以下3种类型:   
      (1)执行静态SQL语句。通常通过Statement实例实现。   Statement stmt = con.createStatement() ; 
      (2)执行动态SQL语句。通常通过PreparedStatement实例实现。 PreparedStatement pstmt = con.prepareStatement(sql) ;   
      (3)执行数据库存储过程。通常通过CallableStatement实例实现。   CallableStatement cstmt = con.prepareCall("{CALL demoSp(? , ?)}") ;  

5、执行SQL语句:

  Statement接口提供了三种执行SQL语句的方法:executeQuery 、executeUpdate和execute   
    (1)ResultSet executeQuery(String sqlString):执行查询数据库的SQL语句,返回一个结果集(ResultSet)对象。   
    (2)int executeUpdate(String sqlString):用于执行INSERT、UPDATE或DELETE语句以及SQL DDL语句,如:CREATE TABLE和DROP TABLE等   
    (3)execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的语句。   
     ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;   
     int rows = stmt.executeUpdate("INSERT INTO ...") ;   
     boolean flag = stmt.execute(String sql) ;  

6、处理结果:

  两种情况:   
     (1)执行更新返回的是本次操作影响到的记录数。   
     (2)执行查询返回的结果是一个ResultSet对象。   
      • ResultSet包含符合SQL语句中条件的所有行,并且它通过一套get方法提供了对这些行中数据的访问。   
      • 使用结果集(ResultSet)对象的访问方法获取数据:

  //(列是从左到右编号的,并且从列1开始)   
     while(rs.next()){   
         String name = rs.getString("name") ;   
        int id= rs.getInt("id") ;
     }

7、关闭JDBC对象    
     操作完成以后要把所有使用的JDBC对象全都关闭,以释放JDBC资源,关闭顺序和声明顺序相反:   
     1、关闭记录集   
     2、关闭声明   
     3、关闭连接对象            

if(rs != null){   // 关闭记录集   
        try{   
            rs.close() ;   
        }catch(SQLException e){   
            e.printStackTrace() ;   
        }   
          }   
          if(stmt != null){   // 关闭声明   
        try{   
            stmt.close() ;   
        }catch(SQLException e){   
            e.printStackTrace() ;   
        }   
          }   
          if(conn != null){  // 关闭连接对象   
         try{   
            conn.close() ;   
         }catch(SQLException e){   
            e.printStackTrace() ;   
         }   
          }

  

一、JDBC简介

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

什么是JDBC?

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

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

JDBC代表Java数据库连接。

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

  • 连接到数据库

  • 创建SQL或mysql语句

  • 在数据库中执行SQL或MySQL查询

  • 查看和修改记录

比如:

 

二、JDBC使用详解

1、打通数据库

先新建Java 工程,将jar包导进去:

然后新建相应的数据库和表。

编写DBUtil.java

package com.study.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class DBUtil {
    
    private static final String URL="jdbc:mysql://localhost:3306/demo_jdbc";
    private static final String NAME="root";
    private static final String PASSWORD="root";

    public static void main(String[] args) throws Exception{
        
        //1.加载驱动程序
        Class.forName("com.mysql.jdbc.Driver");
        //2.获得数据库的连接
        Connection conn = DriverManager.getConnection(URL, NAME, PASSWORD);
        //3.通过数据库的连接操作数据库,实现增删改查
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("select user_name,age from imooc_goddess");//选择import java.sql.ResultSet;
        while(rs.next()){//如果对象中有数据,就会循环打印出来
            System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
        }
    }
}

  

2、搭建模型层

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

  • View视图层——展示数据,反馈用户行为
  •  Control控制层——控制数据流通过程,协调视图层和数据层
  •  Model模型层——与数据库建立映射,与数据进行交互
  • (DB数据库)

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

package com.study.model;

import java.util.Date;

public class Goddess {
    private Integer id;
    private String userName;
    private Integer sex;
    private Integer age;
    private Date birthday;
    private String email;
    private String mobile;
    private String createUser;
    private Date createDate;
    private String updateUser;
    private Date updateDate;
    private Integer isDel;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    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 getCreateUser() {
        return createUser;
    }
    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }
    public Date getCreateDate() {
        return createDate;
    }
    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }
    public String getUpdateUser() {
        return updateUser;
    }
    public void setUpdateUser(String updateUser) {
        this.updateUser = updateUser;
    }
    public Date getUpdateDate() {
        return updateDate;
    }
    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }
    public Integer getIsDel() {
        return isDel;
    }
    public void setIsDel(Integer isDel) {
        this.isDel = isDel;
    }
    
}

  

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

DBUtil.java代码如下:

package com.study.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class DBUtil {
    
    private static final String URL="jdbc:mysql://localhost:3306/demo_jdbc";
    private static final String NAME="root";
    private static final String PASSWORD="root";
    
    private static Connection conn=null;
    //静态代码块(将加载驱动、连接数据库放入静态块中)
    static{
        try {
            //1.加载驱动程序
            Class.forName("com.mysql.jdbc.Driver");
            //2.获得数据库的连接
            conn = DriverManager.getConnection(URL, NAME, PASSWORD);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    //对外提供一个方法来获取数据库连接
    public static Connection getConnection(){
        return conn;
    }
    
    public static void main(String[] args) throws Exception{
        
        //3.通过数据库的连接操作数据库,实现增删改查
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("select user_name,age from imooc_goddess");//选择import java.sql.ResultSet;
        while(rs.next()){//如果对象中有数据,就会循环打印出来
            System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
        }
    }
}

  goddessDao.java 代码如下:

package com.study.dao;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import com.study.db.DBUtil;
import com.study.model.Goddess;

public class GoddessDao {

    public void addGoddess(){
        
    }
    
    public void updateGoddess(){
             
    }
    public void delGoddess(){
        
    }
    
    public List<Goddess> query() throws Exception{
        Connection con=DBUtil.getConnection();
        Statement stmt=con.createStatement();
        ResultSet 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.setUserName(rs.getString("user_name"));
            g.setAge(rs.getInt("age"));
            gs.add(g);
        }
        return gs;
    }
    
    //查询单个女神
    public Goddess get(){
        return null;
    }
}

  新增Controller层:GoddessAction.java

package com.study.controller;

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();
        List<Goddess> gs=gd.query();
        for (Goddess goddess : gs) {
            System.out.println(goddess.getUserName()+","+goddess.getAge());
        }

    }

}

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

//添加女神
    public void addGoddess(Goddess g) throws Exception{
        Connection con=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(),?)";//参数用?表示,相当于占位符;用mysql的日期函数current_date()来获取当前日期
        //预编译sql语句
        PreparedStatement psmt = con.prepareStatement(sql);
        //先对应SQL语句,给SQL语句传递参数
        psmt.setString(1, g.getUserName());
        psmt.setInt(2, g.getSex());
        psmt.setInt(3, g.getAge());
        //注意:setDate()函数第二个参数需要的是java.sql.Date类型,我们传进来的是java.util.Date,类型不符,需要做一下转换
        psmt.setDate(4, new Date(g.getBirthday().getTime()));
        psmt.setString(5, g.getEmail());
        psmt.setString(6, g.getMobile());
        psmt.setString(7, g.getCreateUser());
        psmt.setString(8, g.getUpdateUser());
        psmt.setInt(9, g.getIsDel());
        //执行SQL语句
        psmt.execute();
        /**
         * prepareStatement这个方法会将SQL语句加载到驱动程序conn集成程序中,但是并不直接执行
         * 而是当它调用execute()方法的时候才真正执行;
         * 
         * 上面SQL中的参数用?表示,相当于占位符,然后在对参数进行赋值。
         * 当真正执行时,这些参数会加载在SQL语句中,把SQL语句拼接完整才去执行。
         * 这样就会减少对数据库的操作
         */
    }

  测试:

 

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("xiaoxia@qq.com");
        g1.setMobile("123456789");
        g1.setCreateUser("admin");
        g1.setUpdateUser("admin");
        g1.setIsDel(1);
        //添加女神
        gd.addGoddess(g1);
    }

}

  修改、删除、查询(根据id)操作:

//更新女神
    public void updateGoddess(Goddess g) throws SQLException{
        Connection con=DBUtil.getConnection();//首先拿到数据库的连接
        String sql="" + 
                "update imooc_goddess "+
                "set user_name=?,sex=?,age=?,birthday=?,email=?,mobile=?,"+
                "update_user=?,update_date=current_date(),isdel=?) "+
                "where id=?";//参数用?表示,相当于占位符;用mysql的日期函数current_date()来获取当前日期
        //预编译sql语句
        PreparedStatement psmt = con.prepareStatement(sql);
        //先对应SQL语句,给SQL语句传递参数
        psmt.setString(1, g.getUserName());
        psmt.setInt(2, g.getSex());
        psmt.setInt(3, g.getAge());
        //注意:setDate()函数第二个参数需要的是java.sql.Date类型,我们传进来的是java.util.Date,类型不符,需要做一下转换
        psmt.setDate(4, new Date(g.getBirthday().getTime()));
        psmt.setString(5, g.getEmail());
        psmt.setString(6, g.getMobile());
        psmt.setString(7, g.getUpdateUser());
        psmt.setInt(8, g.getIsDel());
        psmt.setInt(9, g.getId());
        //执行SQL语句
        psmt.execute();    
    }

//删除女神
    public void delGoddess(Integer id) throws SQLException{
        Connection con=DBUtil.getConnection();//首先拿到数据库的连接
        String sql="" + 
                "delete from imooc_goddess "+
                "where id=?";//参数用?表示,相当于占位符;用mysql的日期函数current_date()来获取当前日期
        //预编译sql语句
        PreparedStatement psmt = con.prepareStatement(sql);
        //先对应SQL语句,给SQL语句传递参数
        psmt.setInt(1, id);
        //执行SQL语句
        psmt.execute();    
    }

//查询单个女神(根据id去查询)
    public Goddess get(Integer id) throws SQLException{
        Goddess g=null;
        Connection con=DBUtil.getConnection();//首先拿到数据库的连接
        String sql="" + 
                "select * from imooc_goddess "+
                "where id=?";//参数用?表示,相当于占位符;用mysql的日期函数current_date()来获取当前日期
        //预编译sql语句
        PreparedStatement psmt = con.prepareStatement(sql);
        //先对应SQL语句,给SQL语句传递参数
        psmt.setInt(1, id);
        //执行SQL语句
        /*psmt.execute();*///execute()方法是执行更改数据库操作(包括新增、修改、删除);executeQuery()是执行查询操作
        ResultSet rs = psmt.executeQuery();//返回一个结果集
        //遍历结果集
        while(rs.next()){
            g=new Goddess();
            g.setId(rs.getInt("id"));
            g.setUserName(rs.getString("user_name"));
            g.setAge(rs.getInt("age"));
            g.setSex(rs.getInt("sex"));
            //rs.getDate("birthday")获得的是java.sql.Date类型。注意:java.sql.Date类型是java.util.Date类型的子集,所以这里不需要进行转换了。
            g.setBirthday(rs.getDate("birthday"));
            g.setEmail(rs.getString("email"));
            g.setMobile(rs.getString("mobile"));
            g.setCreateUser(rs.getString("create_user"));
            g.setCreateDate(rs.getDate("create_date"));
            g.setUpdateUser(rs.getString("update_user"));
            g.setUpdateDate(rs.getDate("update_date"));
            g.setIsDel(rs.getInt("isdel"));
        }
        return g;
    }

  查询(根据name\\mobile等)操作

//查询单个女神(根据姓名等信息去查询)
        public List<Goddess> get(String name,String mobile) throws SQLException{
            List<Goddess> result=new ArrayList<Goddess>();
            Connection con=DBUtil.getConnection();//首先拿到数据库的连接
            StringBuffer sb=new StringBuffer();
            sb.append("select * from imooc_goddess ");
            sb.append("where user_name like ? and mobile like ?");
            //预编译sql语句
            PreparedStatement psmt = con.prepareStatement(sb.toString());
            //先对应SQL语句,给SQL语句传递参数
            psmt.setString(1, "%"+name+"%");
            psmt.setString(2, "%"+mobile+"%");    
            System.out.println(sb.toString());
            //执行SQL语句
            /*psmt.execute();*///execute()方法是执行更改数据库操作(包括新增、修改、删除);executeQuery()是执行查询操作
            ResultSet rs = psmt.executeQuery();//返回一个结果集
            Goddess g=null;
            //遍历结果集
            while(rs.next()){
                g=new Goddess();
                g.setId(rs.getInt("id"));
                g.setUserName(rs.getString("user_name"));
                g.setAge(rs.getInt("age"));
                g.setSex(rs.getInt("sex"));
                //rs.getDate("birthday")获得的是java.sql.Date类型。注意:java.sql.Date类型是java.util.Date类型的子集,所以这里不需要进行转换了。
                g.setBirthday(rs.getDate("birthday"));
                g.setEmail(rs.getString("email"));
                g.setMobile(rs.getString("mobile"));
                g.setCreateUser(rs.getString("create_user"));
                g.setCreateDate(rs.getDate("create_date"));
                g.setUpdateUser(rs.getString("update_user"));
                g.setUpdateDate(rs.getDate("update_date"));
                g.setIsDel(rs.getInt("isdel"));
                
                result.add(g);//将结果封装到对象中
            }
            return result;
        }

  测试:

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();
        /*//查询所有女神
        List<Goddess> gs=gd.query();
        for (Goddess goddess : gs) {
            System.out.println(goddess.getUserName()+","+goddess.getAge());
        }*/
        
        Goddess g1=new Goddess();
        g1.setUserName("小夏");
        g1.setAge(22);
        g1.setSex(1);
        g1.setBirthday(new Date());
        g1.setEmail("xiaoxia@qq.com");
        g1.setMobile("123456789");
        g1.setCreateUser("admin");
        g1.setUpdateUser("admin");
        g1.setIsDel(1);
        //添加女神
//        gd.addGoddess(g1);
        
        //查询单个女神(根据id)
        /*Goddess g2 = gd.get(4);
        System.out.println(g2.toString());*/
        
        //查询单个女神(根据姓名等信息)
        List<Goddess> list = gd.get("小溪", "139");
        //遍历结果集
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i).toString());
        }
    }

}

   查询操作的进一步完善:

//查询单个女神(根据姓名等信息去查询)----->使用Map存储条件信息;防止条件为空可加一条where 1=1
                public List<Goddess> get(List<Map<String, Object>> params) throws SQLException{
                    List<Goddess> result=new ArrayList<Goddess>();
                    Connection con=DBUtil.getConnection();//首先拿到数据库的连接
                    StringBuffer sb=new StringBuffer();
                    sb.append("select * from imooc_goddess where 1=1 ");//注意where 1=1 的小技巧
                    if(params !=null && params.size()>0){//先判断集合是否为空
                        //遍历集合
                        for(int i=0;i<params.size();i++){
                            Map<String, Object> map=params.get(i);
                            sb.append("and "+map.get("name")+" " +map.get("rela")+" "+map.get("value")+" ");//查询什么?关系是什么?以及值是什么,我们都可以通过参数传进来。
                        }
                        
                    }
                    //预编译sql语句
                    PreparedStatement psmt = con.prepareStatement(sb.toString());
                    System.out.println(sb.toString());
                    //执行SQL语句
                    /*psmt.execute();*///execute()方法是执行更改数据库操作(包括新增、修改、删除);executeQuery()是执行查询操作
                    ResultSet rs = psmt.executeQuery();//返回一个结果集
                    Goddess g=null;
                    //遍历结果集
                    while(rs.next()){
                        g=new Goddess();
                        g.setId(rs.getInt("id"));
                        g.setUserName(rs.getString("user_name"));
                        g.setAge(rs.getInt("age"));
                        g.setSex(rs.getInt("sex"));
                        //rs.getDate("birthday")获得的是java.sql.Date类型。注意:java.sql.Date类型是java.util.Date类型的子集,所以这里不需要进行转换了。
                        g.setBirthday(rs.getDate("birthday"));
                        g.setEmail(rs.getString("email"));
                        g.setMobile(rs.getString("mobile"));
                        g.setCreateUser(rs.getString("create_user"));
                        g.setCreateDate(rs.getDate("create_date"));
                        g.setUpdateUser(rs.getString("update_user"));
                        g.setUpdateDate(rs.getDate("update_date"));
                        g.setIsDel(rs.getInt("isdel"));
                        
                        result.add(g);//将结果封装到对象中
                    }
                    return result;
                }

  测试:

//查询单个女神(根据姓名等信息去查询)----->使用Map存储条件信息
        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", "=");
//        param.put("value", "\'小溪\'");//注意加上单引号,因为这个变量是字符串的形式
        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", "\'%139%\'");
        params.add(param);
        List<Goddess> list1 = gd.get(params);
        //遍历结果集
        for(int i=0;i<list1.size();i++){
            System.out.println(list1.get(i).toString());
        }

  

这个查询的亮点在于:使用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、搭建控制层

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

package com.study.controller;

import java.util.List;
import java.util.Map;

import com.study.dao.GoddessDao;
import com.study.model.Goddess;

public class GoddessAction1 {

    //添加女神
    public void add(Goddess goddess) throws Exception{
        GoddessDao dao=new GoddessDao();
        goddess.setSex(1);
        goddess.setIsDel(0);
        dao.addGoddess(goddess);
    }
    
    //修改女神
    public void edit(Goddess goddess) throws Exception{
        GoddessDao dao=new GoddessDao();
        dao.updateGoddess(goddess);
    }
    
    //删除女神
    public void del(Integer id) throws Exception{
        GoddessDao dao=new GoddessDao();
        dao.delGoddess(id);
    }
    
    //查询所有女神信息
    public List<Goddess> query() throws Exception{
        GoddessDao dao=new GoddessDao();
        return dao.query();
    }
    
    //查询单个女神信息(根据id)
    public Goddess get(Integer id) throws Exception{
        GoddessDao dao=new GoddessDao();
        return dao.get(id);
    }
    
    //查询单个女神信息(根据姓名等信息)
    public List<Goddess> get(List<Map<String, Object>> params) throws Exception{
        GoddessDao dao=new GoddessDao();
        return dao.get(params);
    }
}

  

5、搭建视图层

package com.study.view;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Scanner;

import com.study.controller.GoddessAction1;
import com.study.model.Goddess;

public class View {
    
    //提示语
    private 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);
        //怎么保持程序的一直运行:while(true){}
        Scanner scanner=new Scanner(System.in);//接受控制台的输入
        Goddess goddess=new Goddess();
        GoddessAction1 action=new GoddessAction1();
        
        String prenious=null;//标记,记住上一次请求
        Integer step=1;//步骤标记
        while(scanner.hasNext()){//scanner.hasNext()有数值时才进行循环,没有就不进行循环
            String in=scanner.next().toString();
            if(OPERATION_EXIT.equals(in.toUpperCase()) 
                    || OPERATION_EXIT.substring(0, 1).equals(in.toUpperCase())){
                System.out.println("您已成功退出女神禁区。");
                break;//退出当前while循环
            }else if(OPERATION_QUERY.equals(in.toUpperCase())
                    ||OPERATION_QUERY.substring(0, 1).equals(in.toUpperCase())){
                try {
                    List<Goddess> list=action.query();
                    for (Goddess go : list) {
                        System.out.println(go.getId()+",姓名:"+go.getUserName());
                    }
                } 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(1==step){//如果是第一次进来
                    System.out.println("请输入女神的[姓名]");
                }else if(2==step){
                    goddess.setUserName(in);
                    System.out.println("请输入女神的[年龄]");
                }else if(3==step){
                    goddess.setAge(Integer.valueOf(in));//string转换为int型
                    System.out.println("请输入女神的[生日],格式如:yyyy-MM-dd");
                }else if(4==step){
                    SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
                    Date birthday=null;
                    try {
                        birthday = sf.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){
                    goddess.setMobile(in);
                    try {
                        action.add(goddess);
                        System.out.println("新增女神成功");
                    } catch (Exception e) {
                        e.printStackTrace();
                        System.out.println("新增女神失败");
                    }
                }
                if(OPERATION_ADD.equals(prenious)){
                    step++;                    
                }
            }else{
                System.out.println("您输入的值为:"+in);
            }
        }
    }
}

  

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

以上是关于JDBC 数据库连接的主要内容,如果未能解决你的问题,请参考以下文章

jdbc连接数据库的代码问题jdbc连接mysql数据库

关于mysql驱动版本报错解决,Cause: com.mysql.jdbc.exceptions.jdbc4Unknown system variable ‘query_cache_size(代码片段

JDBC——数据库连接池以及JDBC代码模版模版

求用jdbc 连接数据库的java代码(只连接部分即可)

JDBC连接数据库

JDBC连接数据库