JDBC

---

一:JDBC规范

一。JDBC规范调用流程【背】
1.将MySql服务器厂商提供Driver接口实现类注册到JVM
    
2.通过JDBC规范中DriverManager在Java工程与MySql服务器之间建立一个【连接通道】
    
3.通过MySql服务器厂商提供Connection接口实现类建立一个交通工【PreparedStatement】
    
4.通过交通工具【PreparedStatement】将SQL命令从Java工程推送到MySql服务器上执行并带回执行结果
    
5.销毁本次交易过程涉及所有资源对象

二。JDBC规范下接口介绍：
1.位置：JDBC规范下接口存在于JDK_1.8.jar下java.sql包

2.分类：
	1）java.sql.DriverManager类：这个类存在于JDK_1.8下。负责将数据库厂商提供
    Driver接口实现进行注册负责在Java工程与MySql服务器之间建立一个【连接通道】
    
	2）java.sql.Connection接口：负责管理Java工程与数据库服务器之间【连接通道】 
	    
	3）java.sql.PreparedStatement接口：负责管理在【连接通道】 上进行往返交通的【交通工具】
    
	4) java.sql.ResultSet接口：负责管理数据库服务器返回【临时表】

三。ps.executeUpdate  与  ps.executeQuery 区别:

 1.ps.executeUpdate：
	1） 负责推送插入命令【insert】，更新命令[update]，删除命令[delete]
	2） 返回结果对表文件进行操作时，收到影响行数，比如插入了多少行，更新了多少行删除了多少行
     
 2.ps.executeQuery：
	1） 负责推送查询命令【select  *  from 表名】
	2） 返回结果是查询命令得到【临时表】，在JDBC规范中【临时表】
		交给ResultSet接口实现类管理。实际上返回ResultSet实例对象

二:补充

1.ResultSet

ResultSet对象---->临时表
   指针---> 			DeptNo  Dname  Loc
    				 10      mike    beijing
    				 20      jack    henan
rs.next()方法:
	next()方法每次执行时,要求指针向下移动一行,如果指针指向位置是一个具体数据行,此时
    next()方法将返回true,如果指针指向位置不是一个数据行,此时返回false
     
    指针只能向下移动,不能向上移动
while(rs.next()){
    //读取指针指向数据行中字段信息
    int deptNo = rs.getInt("DeptNo");
    String dname = rs.getString("Dname");
    String loc = rs.getString("Loc");
}        

2.Batch弹夹

//4.向MySql服务器推送100条数据
for(int i=1;i<=100;i++){
    //通过向预编译SQL命令填充数据生成全新的SQL命令
    ps.setInt(1, i); //inser into dept (deptno,dname,loc) values(1,?,?)
    ps.setString(2, "dept_"+i); //inser into dept (deptno,dname,loc) 	values(1,'dept_1',?)
    ps.setString(3, "北京");//inser into dept (deptno,dname,loc) values(1,'dept_1','北京')
    //在新的SQL语句生成之后，将SQL语句作为子弹添加到PS的弹夹
    ps.addBatch(); //[sql1,sql2,...]
        }

//5.【一次性】通过ps将100条sql语句推送到mysql服务器执行
ps.executeBatch(); // 推送100条SQL命令只需要往返一次

DBUtil–老杜

package jdbc001;

import java.sql.*;

/*
* JDBC工具类,简化JDBC编程
* */
public class DBUtil {
    /*
     * 工具类中的构造方法都是私有的,
     * 因为工具类中的方法都是静态的,不需要new对象,直接采用类名调用
     * */
    //放在静态代码块中,静态代码快只在类时执行,并且只执行一次
    private  DBUtil(){}
        static {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

//这里要扔出异常,因为外面释放资源要catch
    public static Connection getConnection() throws SQLException {
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jdbctext?useSSL=false", "root", "1207071819");

        return conn;
    }

    //关闭资源
    /*
    * conn 连接对象
    * ps 数据操作对象
    * rs 结果集
    * */
    public static void close(Connection conn, Statement ps, ResultSet rs){
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

DBUtilText–老杜

package jdbc001;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/*
* 第一:测试DBUtil是否好用
* 第二:模糊查询怎么写?
* */
public class DBUtilText {
    public static void main(String[] args) {
        Connection conn=null;
        PreparedStatement ps=null;//这里使用preparedStatement(预编译的数据库操作对象),注意这里preparedStatement有个d,下面有没有
        ResultSet rs=null;
        try {
            //获取连接
            conn=DBUtil.getConnection();
            //编译预处理对象
            //SQL语句的框子,其中一个?表示一个占位符,一个?将来接收一个"值",注意:占位符不能使用单引号括起来
            String sql="select realName from t_user where loginPwd like ?";
            ps=conn.prepareStatement(sql);//这里prepareStatement,没有d
            //给占位符 ? 传值(第一个问号下标是1,第二个问号下标是2,JDBC中所有下标从1开始)
            ps.setString(1,"XX%");
            rs=ps.executeQuery();//这里面括号一定不要传"sql"这个变量,传进去就还是会发生sql注入
            while(rs.next()){
                System.out.println(rs.getString("realName"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            DBUtil.close(conn,ps,rs);
        }
    }
}

DBUtil–老杨

package com.bjpowernode.util;

import java.sql.*;

/**
 *  将JDBC规范下相关对象【创建】与【销毁功能】封装到方法
 *
 *   一。JDBC开发步骤：
 *      1.注册数据库服务器提供的Driver接口实现类
 *      2.创建一个连接通道交给Connection接口的实例对象【JDBC4Connection】管理
 *      3.创建一个交通工具交给PreparedStatement接口的实例对象【JDBC4PreparedStatement】管理
 *      4.由交通工具在Java工程与数据库服务器之间进行传输，推送SQL命令并带回执行结果
 *      5.交易结束后，销毁相关资源【Connection,PreparedStatement,ResultSet】
 */
public class JdbcUtil {

    private  Connection con = null;//类文件属性，可以在类文件中所有的方法中使用
    private  PreparedStatement ps=null;//类文件属性，可以在类文件中所有的方法中使用

    //静态语句块 static{}
    //在当前类文件第一次被加载到JVM时，JVM将会自动调用当前类文件静态语句块
    static{
        //1.注册数据库服务器提供的Driver接口实现类

        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println("Driver接口实现类被注册了");
    }

    //封装Connection对象创建细节 不需要考虑使用对象创建细节
    public  Connection  createCon(){
        try {
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/bjpowernode", "root", "123");
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("Connection对象创建失败。。。。。");
        }
        return con;
    }

    //封装PreparedStatement对象创建细节
    public PreparedStatement createStatement(String sql){

        Connection con = createCon();
        try {
            ps = con.prepareStatement(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ps;
    }

    //封装PreparedStatement对象与Connection对象销毁细节
    public void close(){
        if(ps!=null){
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(con!=null){
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //封装PreparedStatement对象与Connection对象与ResultSet对象销毁细节
    public void close(ResultSet rs){
        if(rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        close();

    }
}

DBUtilText–老杨

package com.bjpowernode.test;

import com.bjpowernode.util.JdbcUtil;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Scanner;

/**
 * 2020/4/24
 */
public class TestMain {

    public static void main(String[] args)throws Exception {
         JdbcUtil util = new JdbcUtil();
         PreparedStatement ps=null;
         ResultSet rs = null;
         Scanner request = new Scanner(System.in);
         String  userName,password,deptNo,dname,loc;
         String  sql_1="select count(*) from emp where ename=? and empno=?";
         String  sql_2="insert into dept (deptNo,dname,loc) values(?,?,?)";
         int flag = 0;
         //-----登录验证-----start
        System.out.println("请输入用户名");
        userName = request.next();
        System.out.println("请输入密码");
        password = request.next();
        ps = util.createStatement(sql_1);
        ps.setString(1, userName);
        ps.setString(2, password);
        rs = ps.executeQuery();
        while(rs.next()){
            flag = rs.getInt("count(*)");
        }
        util.close(rs);
        if(flag!=1){
            System.out.println("输入信息不存在，请重新登录。。。。");
            return;
        }
        //-----登录验证-----end

        //-----具体功能页面---start
        System.out.println("******欢迎使用某某公司部门管理系统******");
        System.out.println("******1.添加部门******");
        System.out.println("******2.查询部门******");
        System.out.println("******3.删除部门******");
        System.out.println("******4.更新部门******");
        System.out.println("******请输入操作******");
        flag = request.nextInt();

        if(flag ==1){
            System.out.println("******请输入部门编号******");
            deptNo =request.next();
            System.out.println("******请输入部门名称******");
            dname =request.next();
            System.out.println("******请输入部门位置******");
            loc = request.next();

            ps = util.createStatement(sql_2);
            ps.setInt(1, Integer.valueOf(deptNo));
            ps.setString(2, dname);
            ps.setString(3, loc);
            flag = ps.executeUpdate();
            util.close();

        }else if(flag ==2){

        }else if(flag ==3){

        }else{

        }
        //-----具体功能页面---end
    }
}

DAO创建

DAO类开发规则:
	1):一个DAO类封装的是一张表操作细节
    2):DAO类命名规则:表名+Dao,比如封装emp表操作细节--->EmpDao
        封装Dept表操作细节--->DeptDao
    3):DAO类所在的包命名规:公司网站域名.dao,比如 com.bjpowernode.dao

package com.bjpowernode.dao;

import com.bjpowernode.entity.Dept;
import com.bjpowernode.util.JdbcUtil;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 *   增删改查
 */
public class DeptDao {

    private  JdbcUtil util = new JdbcUtil();
    //添加数据行
    public int add(String deptNo,String dname,String loc){
        String sql="insert into dept (deptNo,dname,loc) values(?,?,?)";
        int result=0;
        PreparedStatement ps = util.createStatement(sql);
        try {
            ps.setInt(1, Integer.valueOf(deptNo));
            ps.setString(2, dname);
            ps.setString(3, loc);
            result=ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            util.close();
        }
        return result;
    }

    //删除数据行
    public int delete(String deptNo){
        String sql ="delete from dept where deptno=?";
        PreparedStatement ps = util.createStatement(sql);
        int result = 0;
        try {
            ps.setInt(1, Integer.valueOf(deptNo));
            result = ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            util.close();
        }
        return result;
    }

    //更新数据行
    public int update(String deptNo,String dname,String loc){
        String  sql ="update dept set dname=?,loc=? where deptno=?";
        PreparedStatement ps = util.createStatement(sql);
        int result=0;
        try {
            ps.setString(1, dname);
            ps.setString(2, loc);
            ps.setInt(3, Integer.valueOf(deptNo));
            result = ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
           util.close();
        }
        return result;
    }

    //查询数据行
    public List findAll(){
        String sql ="select * from dept";
        PreparedStatement ps = util.createStatement(sql);
        ResultSet rs = null;
        List list = new ArrayList();
        try {
            rs = ps.executeQuery();
            //将是临时表数据行转换为实体类实例对象保管
            while(rs.next()){
                int deptNo = rs.getInt("deptno");
                String dname = rs.getString("dname");
                String loc = rs.getString("loc");
                Dept dept = new Dept(deptNo, dname, loc);
                list.add(dept);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            util.close(rs);
        }
        return list;
    }
}

实体类

1).一个实体类用于描述一张表
2).实体类的类名应该于关联的表名保持一致,但是可以忽略大小写
    DEPT.frm--------->public class Dept{}
3).实体类的属性应该和关联的表文件字段保持一致
    Dept.frm---->DEPRNO INT
    			DNAME VARCHAR(20)
    			LOC VARCHAR(20)
    
    public class Dept{
        private Integer deptNo;
        private String dname;
        private String loc;
    }
4).实体类的一个实例对象用于在内存中存储对应的表文件中一个数据行
    Dept.frm------------------>JVM内
    DeptNo dname 	loc          
    10	   Account  NEW York     Dept dept1 = new Dept(10,"Account","NEW York");
    20	   Sales    BeiJing      Dept dept2 = new Dept(20,"Sales","BeiJing");

package com.bjpowernode.entity;

/**
 * 2020/4/24
 */
public class Dept {

    private Integer deptNo;
    private String  dname;
    private String  loc;

    public Integer getDeptNo() {
        return deptNo;
    }

    public void setDeptNo(Integer deptNo) {
        this.deptNo = deptNo;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    public String getLoc() {
        return loc;
    }

    public void setLoc(String loc) {
        this.loc = loc;
    }

    public Dept() {
    }

    public Dept(Integer deptNo, String dname, String loc) {
        this.deptNo = deptNo;
        this.dname = dname;
        this.loc = loc;
    }
}

查询

//查询数据行
   public List findAll(){
       String sql ="select * from dept";
       PreparedStatement ps = util.createStatement(sql);
       ResultSet rs = null;
       List list = new ArrayList();
       try {
           rs = ps.executeQuery();
           //将是临时表数据行转换为实体类实例对象保管
           while(rs.next()){
               int deptNo = rs.getInt("deptno");
               String dname = rs.getString("dname");
               String loc = rs.getString("loc");
               Dept dept = new Dept(deptNo, dname, loc);
               list.add(dept);
           }
       } catch (SQLException e) {
           e.printStackTrace();
       } finally {
           util.close(rs);
       }
       return list;
   }

赏

谢谢你请我吃糖果

支付宝

微信