• JDBC那些事

    JDBC

    JAVA Database Connectivity java 数据库连接

    • 为什么会出现JDBC

    SUN公司提供的一种数据库访问规则、规范, 由于数据库种类较多，并且java语言使用比较广泛，sun公司就提供了一种规范，让其他的数据库提供商去实现底层的访问规则。 我们的java程序只要使用sun公司提供的jdbc驱动即可。

    使用JDBC的基本步骤

    1. 注册驱动

      DriverManager.registerDriver(new com.mysql.jdbc.Driver());

    2. 建立连接

      //DriverManager.getConnection("jdbc:mysql://localhost/test?user=monty&password=greatsqldb"); //2. 建立连接 参数一： 协议 + 访问的数据库 ， 参数二： 用户名 ， 参数三： 密码。 conn = DriverManager.getConnection("jdbc:mysql://localhost/student", "root", "root");

    3. 创建statement

      //3. 创建statement ， 跟数据库打交道，一定需要这个对象 st = conn.createStatement();

    4. 执行sql ，得到ResultSet

      //4. 执行查询 ， 得到结果集 String sql = "select * from t_stu"; rs = st.executeQuery(sql);

    5. 遍历结果集

      //5. 遍历查询每一条记录 while(rs.next()){ int id = rs.getInt("id"); String name = rs.getString("name"); int age = rs.getInt("age"); System.out.println("id="+id + "===name="+name+"==age="+age);

      }

    6. 释放资源

      if (rs != null) {
    try {
        rs.close();
    } catch (SQLException sqlEx) { } // ignore 
    rs = null;
}

...

    JDBC 工具类构建

    1. 资源释放工作的整合

    2. 使用properties配置文件

      1. 在src底下声明一个配置文件 xxx.properties ，里面的内容如下：

        driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost/student?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8 
name=root
password=root

      2. 工具类JDBCUtil

        package com.itheima.util;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;


public class JDBCUtil {
    static String driverClass = null;
    static String url = null;
    static String name = null;
    static String password = null;
    
    //使用静态代码块，读取配置文件properties
    static {
        try {
            //创建一个属性配置对象
            Properties properties = new Properties();
            //将配置文件转换为输入流从而导入使用(使用类加载器去读取src底下的资源文件)
            InputStream is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
            //导入输入流
            properties.load(is);
            
            //读取属性
            driverClass = properties.getProperty("driverClass");
            url = properties.getProperty("url");
            name = properties.getProperty("name");
            password = properties.getProperty("password");

        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
//连接对象
    public static Connection getConn() {
        Connection conn = null;
        try {
            // 1.注册驱动
            Class.forName(driverClass);//注意这个也可以不用写的
            // 2.建立连接,参数一：协议+数据库名；参数二：用户名；参数三：密码
            conn = DriverManager.getConnection(url,name, password);
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
        return conn;
        
    }
    
    
//释放资源
    public static void release (Connection conn, Statement st,ResultSet rs) {
        closeRs(rs);
        closeSt(st);
        CloseConn(conn);
    }
    public static void release (Connection conn, Statement st) {
        closeSt(st);
        CloseConn(conn);
    }
    
//实现
    private static void closeRs(ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            rs = null;
        }
    }
    
    private static void closeSt(Statement st) {
        try {
            if (st != null) {
                st.close();
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            st = null;
        }
    }
    
    private static void CloseConn(Connection conn) {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            conn = null;
        }
    }
}

    使用单元测试，测试代码

    1. 定义一个类， TestXXX , 里面定义方法 testXXX.

    2. 添加junit的支持。

      右键工程 --- add Library --- Junit --- Junit4

    3. 在方法的上面加上注解 ， 其实就是一个标记。

      @Test
 public void testQuery() { ... }

    4. 光标选中方法名字，然后右键执行单元测试。 或者是打开outline视图， 然后选择方法右键执行。

    数据库的CRUD sql

    • insert

      @Test
    public void testInsert() {
        Connection conn = null;
        Statement st = null;
        try {
            // 1、获取连接对象
            conn = JDBCUtil.getConn();
            // 2、由连接对象获取statement对象
            st = conn.createStatement();
            // 3、由statement执行sql语句
            String sql = "insert into t_stu values(4,'王六','女')";
            int result = st.executeUpdate(sql);
            // 4、返回结果是一个整型值，表示数据表几行会受到影响
            if(result>0) {
                System.out.println("添加成功");
            }else {
                System.out.println("添加失败");
            }
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, st);
        }
    }

    • delete

      @Test
    public void testDelete() {
        Connection conn = null;
        Statement st = null;
        try {
            
            //1、建立连接
            conn = JDBCUtil.getConn();
            //2、由连接获取statement对象
            st = conn.createStatement();
            //3、执行sql语句
            String sql = "delete from t_stu where name = '王六'";
            int result = st.executeUpdate(sql);
            if (result > 0) {
                System.out.println("删除成功");
            } else {
                System.out.println("删除失败");
            } 
        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, st);
        }
    }

    • query

      @Test
    public void testQuary() {
        // 查询
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            // 1、获取连接对象
            conn = JDBCUtil.getConn();
            // 2、由连接对象，得到statement对象
            st = conn.createStatement();
            // 3、执行sql语句返回结果集resultSet
            String sql = "select * from t_stu";
            rs = st.executeQuery(sql);
            // 4、遍历结果集
            while (rs.next()) {
                String name = rs.getString("name");
                String sex = rs.getString("sex");

                System.out.println(name + "   " + sex);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.release(conn, st, rs);
        }
    }

    • update

      @Test
    public void testUpdate() {
        Connection conn = null;
        Statement st = null;
        try {
            //1、建立连接
            conn = JDBCUtil.getConn();
            //2、通过连接对象获取statement对象
            st = conn.createStatement();
            //3、执行sql语句
            String sql = "update t_stu set sex = '男' where name = '王五'";
            int result = st.executeUpdate(sql);
            if(result>0) {
                System.out.println("更新成功");
            }else {
                System.out.println("更新失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, st);
        }
        
    }

     

    Dao模式

    Data Access Object 数据访问对象

    1. 新建一个dao的接口， 里面声明数据库访问规则

      /**
 * 定义操作数据库的方法
 */
public interface UserDao {

    /**
     * 查询所有
     */
    void findAll();
}

    2. 新建一个dao的实现类，具体实现早前定义的规则

      public class UserDaoImpl implements UserDao{

@Override
public void findAll() {
    Connection conn = null;
    Statement st = null;
    ResultSet rs = null;
    try {
        //1. 获取连接对象
        conn = JDBCUtil.getConn();
        //2. 创建statement对象
        st = conn.createStatement();
        String sql = "select * from t_user";
        rs = st.executeQuery(sql);

        while(rs.next()){
            String userName = rs.getString("username");
            String password = rs.getString("password");

            System.out.println(userName+"="+password);
        }

    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        JDBCUtil.release(conn, st, rs);
    }
}

      }

    3. 直接使用实现

      @Test public void testFindAll(){ UserDao dao = new UserDaoImpl(); dao.findAll(); }

    Statement安全问题

    1. Statement执行 ，其实是拼接sql语句的。 先拼接sql语句，然后在一起执行。

      String sql = "select * from t_user where username='"+ username  +"' and password='"+ password +"'";

UserDao dao = new UserDaoImpl();
dao.login("admin", "100234khsdf88' or '1=1");（可以通过加上一个true的语句来共同组成密码使得密码整体是正确的）

SELECT * FROM t_user WHERE username='admin' AND PASSWORD='100234khsdf88' or '1=1' 

前面先拼接sql语句， 如果变量里面带有了 数据库的关键字，那么一并认为是关键字。 不认为是普通的字符串。 
rs = st.executeQuery(sql);

    PrepareStatement

    该对象就是替换前面的statement对象。

    1. 相比较以前的statement， 预先处理给定的sql语句，对其执行语法检查。 在sql语句里面使用 ? 占位符来替代后续要传递进来的变量。 后面进来的变量值，将会被看成是字符串，不会产生任何的关键字。

      // 2、创建preparestatement对象,预先对sql进行语法的校验，？对应的内容，后面不管传什么进来都将其看作是字符串，不会像statement对象将其看作是关键字（or）从而出现安全问题
String sql = "select * from t_user where name = ? and password = ?";
PreparedStatement ps = conn.prepareStatement(sql);
//对应的索引从1开始
ps.setString(1, username);
ps.setString(2, password);
// 3、返回结果集
rs = ps.executeQuery();

    ​用  PrepareStatement+dao模式 实现　登录&增&删&改&查（UserDao+UserDaoImpl+TestUserDaoImpl）

    UserDao

    public interface UserDao {
    
    /**
     * @更新操作
     *
     */
    void update(String username,int id);
    
    
    /**
     * @删除操作
     *
     */
    void delete(int id);
    
    
    /**
     * @执行添加
     *
     */
    void insert(String username,String password);
    
    
    /**
     * @查询所有
     *
     */
    void findAll();
    
    
    /**
     * @登录方法
     *
     */
    void login(String username,String password);
    
}

    UserDaoImpl

    package com.itheima.dao.impl;

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

import com.itheima.dao.UserDao;
import com.itheima.util.JDBCUtil;




public class UserDaoImpl implements UserDao {
    
    /**
     * @更新操作实现
     *
     */
    @Override
    public void update(String username, int id) {
        Connection conn = null;
        PreparedStatement ps = null;
        
        try {
            //1、建立连接
            conn = JDBCUtil.getConn();
            //2、创建prepareStatement对象，检验sql语句
            String sql = "update t_user set name = ? where id = ?";
            ps = conn.prepareStatement(sql);
            //3、给占位符赋值
            ps.setString(1, username);
            ps.setInt(2, id);
            //4、验证添加，用int值接收操作成功后数据表受影响的行数
            int result = ps.executeUpdate();
            if(result>0) {
                System.out.println("更新成功");
            }else {
                System.out.println("更新失败");
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, ps);//这里是因为statement是preparestatement的父类所以可以传ps
        }
        
        
    }
    
    
    /**
     * @删除操作实现
     *
     */
    @Override
    public void delete(int id) {
        Connection conn = null;
        PreparedStatement ps = null;
        
        try {
            //1、建立连接
            conn = JDBCUtil.getConn();
            //2、创建prepareStatement对象，检验sql语句
            String sql = "delete from t_user where id = ?";
            ps = conn.prepareStatement(sql);
            //3、给占位符赋值
            ps.setInt(1, id);
            //4、验证添加，用int值接收操作成功后数据表受影响的行数
            int result = ps.executeUpdate();
            if(result>0) {
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, ps);//这里是因为statement是preparestatement的父类所以可以传ps
        }
        
    }
    
    
        /**
     * @执行添加实现
     *
     */
    @Override
    public void insert(String username, String password) {
        Connection conn = null;
        PreparedStatement ps = null;
        
        try {
            //1、建立连接
            conn = JDBCUtil.getConn();
            //2、创建prepareStatement对象，检验sql语句
            String sql = "insert into t_user values(null,?,?)";
            ps = conn.prepareStatement(sql);
            //3、给占位符赋值
            ps.setString(1, username);
            ps.setString(2, password);
            //4、验证添加，用int值接收操作成功后数据表受影响的行数
            int result = ps.executeUpdate();
            if(result>0) {
                System.out.println("添加成功");
            }else {
                System.out.println("添加失败");
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, ps);//这里是因为statement是preparestatement的父类所以可以传ps
        }
    }
    
    
        /**
     * @查询所有实现
     *
     */
    @Override
    public void findAll() {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;

        try {
            // 1、建立数据库连接
            conn = JDBCUtil.getConn();
            // 2、创建statement对象
            st = conn.createStatement();
            // 3、执行sql语句,返回结果集
            String sql = "select * from t_user";
            rs = st.executeQuery(sql);
            // 4、对结果集输出
            while (rs.next()) {
                String name = rs.getString("name");
                String password = rs.getString("password");
                System.out.println(name + ":" + password);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtil.release(conn, st, rs);
        }
    }
    
    /*下面的是用statement对象进行的操作由于存在安全问题所以将其注释，
          在下面会用PrepareStatement替换
     
    @Override
    public void login(String username, String password) {
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            // 1、建立连接
            conn = JDBCUtil.getConn();
            // 2、创建statement对象
            st = conn.createStatement();
            // 3、执行sql语句,返回结果集
            String sql = "select * from t_user where name = '"+username+"' and password = '"+password+"'";
            rs = st.executeQuery(sql);
            // 4、是否满足登录条件
            if(rs.next()) {
                System.out.println("登录成功");
            }else {
                System.out.println("登录失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, st, rs);
        }

    }
*/
    
    
    /**
     * @登录方法实现
     *
     */
    @Override
    public void login(String username, String password) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            // 1、建立连接
            conn = JDBCUtil.getConn();
            // 2、创建preparestatement对象,预先对sql进行语法的校验，？对应的内容，后面不管传什么进来都将其看作是字符串，不会像statement对象将其看作是关键字（or）从而出现安全问题
            String sql = "select * from t_user where name = ? and password = ?";
            ps = conn.prepareStatement(sql);
            //对应的索引从1开始
            ps.setString(1, username);
            ps.setString(2, password);
            // 3、返回结果集
            rs = ps.executeQuery();
            // 4、是否满足登录条件
            if(rs.next()) {
                System.out.println("登录成功");
            }else {
                System.out.println("登录失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, ps, rs);
        }

    }

}

    TestUserDaoImpl

    package com.itheima.test;

import org.junit.jupiter.api.Test;

import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;



public class TestUserDaoImpl {
    
    /**
     * @更新操作测试
     *
     */
    @Test
    public void testUpdate() {
        UserDao dao = new UserDaoImpl();
        dao.update("lan", 4);
    }

    
        /**
     * @删除操作测试
     *
     */
    @Test
    public void testDelete() {
        UserDao dao = new UserDaoImpl();
        dao.delete(3);
    }

    
        /**
     * @执行添加测试
     *
     */
    @Test
    public void testInsert() {
        UserDao dao = new UserDaoImpl();
        dao.insert("hah", "123");
    }

    
        /**
     * @查询所有测试
     *
     */
    @Test
    public void testFindAll() {
        //接口引用指向类对象
        UserDao dao = new UserDaoImpl();
        dao.findAll();
    }

    
        /**
     * @登录方法测试
     *
     */
    @Test
    public void testLogin() {
        UserDao dao = new UserDaoImpl();
        dao.login("admin", "10086");
        //下述sql语句表示形式为：select * from t_user where name = 'admin' and password = '10080' or '1=1'
        //dao.login("admin", "10080' or ' 1=1");//由statement漏洞来破解密码
    }
}

    总结：

    1. JDBC入门

    2. 抽取工具类 ###

    3. Statement CRUD ###

      演练crud

    4. Dao模式 ###

      声明与实现分开

    5. PrepareStament CRUD ###

      预处理sql语句，解决上面statement出现的问题
  • 相关阅读:
    IOS 模块并且发布到NPM
    处理npm publish报错问题
    IOS 应用发布流程
    《温故而知新》JAVA基础八
    Beta冲刺 （5/7）
    Beta冲刺 （4/7）
    Beta冲刺 （3/7）
    Beta冲刺 （2/7）
    软件测试(团队)
    福大软工 · BETA 版冲刺前准备（团队）
  • 原文地址：https://www.cnblogs.com/guo-2020/p/12674360.html
Copyright © 2020-2023  润新知