29_Java_数据库_第29天（JDBC、DBUtils）_讲义

川长思鸟来 2022-04-02 08:00 359阅读 0赞

# 今日内容介绍 #

 SQL语句查询  
 JDBC

## 01JDBC概念和数据库驱动程序 ##

*  A: JDBC概念和数据库驱动程序
    
     *  a: JDBC概述
        
         *  JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，  
            可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范
         *  JDBC提供了一种基准,据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序。
         *  JDBC需要连接驱动，驱动是两个设备要进行通信，满足一定通信数据格式，数据格式由设备提供商规定，  
            设备提供商为设备提供驱动软件，通过软件可以与该设备进行通信。
         *  我们使用的是mysql的驱动mysql-connector-java-5.1.39-bin.jar
     *  b: 总结
        
         *  JDBC是java提供给开发人员的一套操作数据库的接口
         *  数据库驱动就是实现该接口的实现类

## 02JDBC原理 ##

*  A: JDBC原理  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]
    
     *  a: 描述
        
         *  Java提供访问数据库规范称为JDBC，而生产厂商提供规范的实现类称为驱动
         *  JDBC是接口，驱动是接口的实现，没有驱动将无法完成数据库连接，从而不能操作数据库！  
            每个数据库厂商都需要提供自己的驱动，用来连接自己公司的数据库，也就是说驱动一般都由数据库生成厂商提供。  
            ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]

## 03准备数据 ##

*  A: 准备数据
    
     *  a: 创建数据库和表结构  
        \#创建数据库  
        create database mybase;  
        \#使用数据库  
        use mybase;  
        \#\#\#创建分类表  
        create table sort(  
        sid int PRIMARY KEY AUTO\_INCREMENT,  
        sname varchar(100),  
        sprice DOUBLE,  
        sdesc VARCHAR(500)  
        );
     *  b: 向表中插入数据  
        \#初始化数据  
        insert into sort(sname,sprice,sdesc) values(‘家电’,2000, ‘优惠的促销’);  
        insert into sort(sname,sprice,sdesc) values(‘家具’,8900, ‘家具价格上调,原材料涨价’);  
        insert into sort(sname,sprice,sdesc) values(‘儿童玩具’,290, ‘赚家长的钱’);  
        insert into sort(sname,sprice,sdesc) values(‘生鲜’,500.99, ‘生鲜商品’);  
        insert into sort(sname,sprice,sdesc) values(‘服装’,24000, ‘换季销售’);  
        insert into sort(sname,sprice,sdesc) values(‘洗涤’,50, ‘洗发水促销’);

## 04JDBC的开发步骤 ##

*  A: JDBC的开发步骤
    
     *  a: 步骤介绍  
        1.注册驱动  
        告知JVM使用的是哪一个数据库的驱动  
        2.获得连接  
        使用JDBC中的类,完成对MySQL数据库的连接  
        3.获得语句执行平台  
        通过连接对象获取对SQL语句的执行者对象  
        4.执行sql语句  
        使用执行者对象,向数据库执行SQL语句  
        获取到数据库的执行后的结果  
        5.处理结果  
        6.释放资源 一堆close()  
        **前面三个步骤以及最后一个步骤是固定的**

## 05导入mysql数据库驱动程序jar包 ##

*  A: 导入mysql数据库驱动程序jar包
    
     *  a: 步骤
        
         *  创建lib目录，用于存放当前项目需要的所有jar包
         *  选择jar包，右键执行build path / Add to Build Path

## 06注册数据库驱动程序 ##

代码：Class.forName("com.mysql.jdbc.Driver");

JDBC规范定义驱动接口：java.sql.Driver，MySql驱动包提供了实现类：com.mysql.jdbc.Driver  
DriverManager工具类，提供注册驱动的方法 registerDriver()，方法的参数是java.sql.Driver，所以我们可以通过如下语句进行注册:  
DriverManager.registerDriver(new com.mysql.jdbc.Driver());  
以上代码不推荐使用，存在两方面不足

1.  硬编码，后期不易于程序扩展和维护
2.  驱动被注册两次。  
    通常开发我们使用Class.forName() 加载一个使用字符串描述的驱动类。  
    如果使用Class.forName()将类加载到内存，该类的静态代码将自动执行。  
    通过查询com.mysql.jdbc.Driver源码，我们发现Driver类“主动”将自己进行注册  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]  
    ![加粗样式][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]

*  A: 注册数据库驱动程序
    
     *  a: 案例代码

## 07获取数据库的连接对象 ##

*  A：获取数据库的连接对象
    
     *  a: 案例代码

public class JDBCDemo {
                public static void main(String[] args)throws ClassNotFoundException,SQLException{
                    //1.注册驱动 反射技术,将驱动类加入到内容
                    // 使用java.sql.DriverManager类静态方法 registerDriver(Driver driver)
                    // Diver是一个接口,参数传递,MySQL驱动程序中的实现类
                    //DriverManager.registerDriver(new Driver());
                    //驱动类源代码,注册2次驱动程序
                    Class.forName("com.mysql.jdbc.Driver");
                    
                    //2.获得数据库连接  DriverManager类中静态方法
                    //static Connection getConnection(String url, String user, String password)  
                    //返回值是Connection接口的实现类,在mysql驱动程序
                    //url: 数据库地址  jdbc:mysql://连接主机IP:端口号//数据库名字
                    String url = "jdbc:mysql://localhost:3296/mybase";
                    //用户名和密码用自己的
                    String username="root";
                    String password="123";
                    Connection con = DriverManager.getConnection(url, username, password);
                    System.out.println(con);                    
                }
            }

## 08获取SQL语句的执行对象对象 ##

*  A: 获取SQL语句的执行对象对象
    
     *  a: 案例代码

public class JDBCDemo {
                public static void main(String[] args)throws ClassNotFoundException,SQLException{
                    //1.注册驱动 反射技术,将驱动类加入到内容
                    // 使用java.sql.DriverManager类静态方法 registerDriver(Driver driver)
                    // Diver是一个接口,参数传递,MySQL驱动程序中的实现类
                    //DriverManager.registerDriver(new Driver());
                    //驱动类源代码,注册2次驱动程序
                    Class.forName("com.mysql.jdbc.Driver");
                    
                    //2.获得数据库连接  DriverManager类中静态方法
                    //static Connection getConnection(String url, String user, String password)  
                    //返回值是Connection接口的实现类,在mysql驱动程序
                    //url: 数据库地址  jdbc:mysql://连接主机IP:端口号//数据库名字
                    String url = "jdbc:mysql://localhost:3296/mybase";
                    String username="root";
                    String password="123";
                    Connection con = DriverManager.getConnection(url, username, password);
                    
                    //3.获得语句执行平台, 通过数据库连接对象,获取到SQL语句的执行者对象
                    // con对象调用方法   Statement createStatement() 获取Statement对象,将SQL语句发送到数据库
                    // 返回值是 Statement接口的实现类对象,,在mysql驱动程序
                    Statement stat = con.createStatement();
                    System.out.println(stat);
                }
            }

## 09执行insert语句获取结果集 ##

package cn.itcast.demo;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    import com.mysql.jdbc.Driver;
    
    
    /*
     * JDBC开发步骤
    	1.	注册驱动
    		告知JVM使用的是哪一个数据库的驱动
    	2.	获得连接
    		使用JDBC中的类,完成对MySQL数据库的连接
    	3.	获得语句执行平台
    		通过连接对象获取对SQL语句的执行者对象
    	4.	执行sql语句
    		使用执行者对象,向数据库执行SQL语句
    		获取到数据库的执行后的结果
    	5.	处理结果
    	6.	释放资源 一堆close()
     */
    public class JDBCDemo {
    	public static void main(String[] args) throws ClassNotFoundException, SQLException {	
    		//使用java.sql.DriverManager类静态方法registerDriver(Driver driver)
    		//Driver是一个接口,参数传递,MySQL驱动程序中的实现类
    		//驱动类源代码,注册2次驱动程序
    		DriverManager.registerDriver(new Driver());
    		//上面的方法,我们发现源码又一次注册驱动程序,源码中提示解决方法：
    		//When a Driver class is loaded, it should create an instance of itself and register it with the DriverManager. This means that a user can load and register a
    		//driver by doing Class.forName("foo.bah.Driver")
    		//1.注册驱动 反射技术,将驱动类加入到内容
    		Class.forName("com.mysql.jdbc.Driver");
    		
    		//2.获得连接
    		//static Connection getConnection(String url, String user, String password)  
    		//返回值是Connection接口的实现类,在mysql驱动程序
    		//url:数据库的链接地址  格式：jdbc:mysql://连接主机IP:端口号//数据库的名字
    		String url = "jdbc:mysql://localhost:3306/mybase";
    		String username = "root";
    		String password = "123";
    		Connection con = DriverManager.getConnection(url, username, password);
    		System.out.println(con);
    		
    		//3.获得语句执行平台,通过数据库连接对象,获取到SQL语句的执行者对象
    		//con对象调用方法  Statement createStatement()  
    		//创建一个 Statement 对象来将 SQL 语句发送到数据库
    		//返回值是Statement接口的实现类对象,在mysql驱动程序
    		//import java.sql.Statement;
    		Statement stat = con.createStatement();
    		
    		//4.执行SQL语句
    		//通过执行者对象调用方法执行SQL语句,获取结果
    		// int executeUpdate(String sql)  执行数据库中的SQL语句,insert delete update
    		//返回值int,操作成功数据表多少行
    		int row = stat.executeUpdate
    				("INSERT INTO sort(sname,sprice,sdesc) VALUES('汽车用品','200000','疯狂涨价')");
    		System.out.println(row);
    		
    		//5.增删改没什么需要处理结果
    		
    		//6.释放资源 一堆close()
    		stat.close();
    		con.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]

## 10执行select语句获取结果集 ##

*  A: 执行select语句获取结果集
    
     *  a: 案例代码

package cn.itcast.demo;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    
    /*
     * JDBC技术,查询数据表,获取结果集
     */
    public class JDBCDemo1 {
    	public static void main(String[] args) throws Exception {
    		//1.注册驱动
    		Class.forName("com.mysql.jdbc.Driver");
    		
    		//2.获取连接对象
    		String url = "jdbc:mysql://localhost:3306/mybase";
    		String username = "root";
    		String password = "123";
    		Connection con = DriverManager.getConnection(url, username, password);
    		
    		//3.获取执行SQL语句对象
    		Statement stat = con.createStatement();
    		//拼写查询的SQL,最后在SQLyog内写好SQL语句复制过来
    		String sql = "SELECT * FROM sort";
    		
    		//4.调用执行者对象方法,执行SQL语句获取结果集
    		//ResultSet executeQuery(String sql)  执行SQL语句中的select查询
    		//执行给定的 SQL 语句，该语句返回单个 ResultSet 对象
    		//返回值ResultSet接口的实现类对象,实现类在mysql驱动中
    		ResultSet rs = stat.executeQuery(sql);
    		
    		//5.处理结果集
    		//System.out.println(rs);
    		//com.mysql.jdbc.JDBC4ResultSet@106fbd7
    		//ResultSet接口方法boolean next() 返回true,有结果集,返回false没有结果集
    		while(rs.next()){
    			//获取每列数据,使用的是ResultSet接口的方法getXX
    			System.out.println(rs.getInt("sid") + "\t" + rs.getString("sname")
    			+ "\t" +  rs.getString("sprice") + "\t" + rs.getString("sdesc"));
    		}
    
    		//6.释放资源 一堆close()
    		rs.close();
    		stat.close();
    		con.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]

## 11SQL注入攻击 ##

*  A: SQL注入攻击
    
     *  a: 注入问题
        
         *  假设有登录案例SQL语句如下:
         *  SELECT \* FROM 用户表 WHERE NAME = 用户输入的用户名 AND PASSWORD = 用户输的密码;
         *  此时，当用户输入正确的账号与密码后，查询到了信息则让用户登录。  
            但是当用户输入的账号为XXX 密码为：XXX’ OR ‘a’=’a时，则真正执行的代码变为：
            
             *  SELECT \* FROM 用户表 WHERE NAME = ‘XXX’ AND PASSWORD =’ XXX’ OR ’a’=’a’;
         *  此时，上述查询语句时永远可以查询出结果的。那么用户就直接登录成功了，显然我们不
         *  希望看到这样的结果，这便是SQL注入问题。
     *  b: 案例演示  
        CREATE TABLE users(  
        id INT PRIMARY KEY AUTO\_INCREMENT,  
        username VARCHAR(100),  
        PASSWORD VARCHAR(100)  
        );
        
        INSERT INTO users (username,PASSWORD) VALUES (‘a’,‘1’),(‘b’,‘2’);
        
        SELECT \* FROM users;
        
        – 登录查询  
        SELECT \* FROM users WHERE username=‘dsfsdfd’ AND PASSWORD='wrethiyu’1  
        OR 1=1
        
        SELECT \* FROM users WHERE username=‘a’ AND PASSWORD=‘1’OR’1=1’  
        键盘录入：  
        1  
        1’OR’ 1=1

## 12SQL注入攻击用户登录案例 ##

package cn.itcast.demo;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.util.Scanner;
    
    /*
     * Java程序实现用户登陆,用户名和密码,数据库检查
     * 演示被别人注入共计
     */
    public class JDBCDemo2 {
    	public static void main(String[] args) throws Exception {
    		//1.注册驱动
    		Class.forName("com.mysql.jdbc.Driver");
    		
    		//2.获取连接对象
    		String url = "jdbc:mysql://localhost:3306/mybase";
    		String username = "root";
    		String password = "123";
    		Connection con = DriverManager.getConnection(url, username, password);
    		
    		//3.获取执行SQL语句对象
    		Statement stat = con.createStatement();
    		
    		//用户登陆输入
    		Scanner sc = new Scanner(System.in);
    		String user = sc.nextLine();
    		String pass = sc.nextLine();
    		
    		//拼写查询的SQL,最后在SQLyog内写好SQL语句复制过来
    		String sql = "SELECT * FROM users WHERE username='" + user + "' AND upassword='" + pass + "'";
    		System.out.println("注入语句： " + sql);
    		
    		//4.调用执行者对象方法,执行SQL语句获取结果集
    		//ResultSet executeQuery(String sql)  执行SQL语句中的select查询
    		//执行给定的 SQL 语句，该语句返回单个 ResultSet 对象
    		//返回值ResultSet接口的实现类对象,实现类在mysql驱动中
    		ResultSet rs = stat.executeQuery(sql);
    		
    		//5.处理结果集
    		//System.out.println(rs);
    		//com.mysql.jdbc.JDBC4ResultSet@106fbd7
    		//ResultSet接口方法boolean next() 返回true,有结果集,返回false没有结果集
    		while(rs.next()){
    			//获取每列数据,使用的是ResultSet接口的方法getXX
    			System.out.println(rs.getString("username") + "\t" + rs.getString("upassword"));
    		}
    		
    		//6.释放资源 一堆close()
    		rs.close();
    		stat.close();
    		con.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]

## 13PrepareStatement接口预编译SQL语句 ##

*  A: PrepareStatement接口预编译SQL语句
    
     *  a: 预处理对象
        
         *  使用PreparedStatement预处理对象时，建议每条sql语句所有的实际参数，都使用逗号分隔。
         *  String sql = “insert into sort(sid,sname) values(?,?)”;;
         *  PreparedStatement预处理对象代码：
         *  PreparedStatement psmt = conn.prepareStatement(sql)
     *  b: 执行SQL语句的方法介绍
        
         *  int executeUpdate(); --执行insert update delete语句.
         *  ResultSet executeQuery(); --执行select语句.
         *  boolean execute(); --执行select返回true 执行其他的语句返回false.
     *  c: 设置实际参数
        
         *  void setXxx(int index, Xxx xx) 将指定参数设置为给定Java的xx值。在将此值发送到数据库时，驱动程序将它转换成一个 SQL Xxx类型值。
         *  例如：
            
             *  setString(2, “家用电器”) 把SQL语句中第2个位置的占位符？ 替换成实际参数 “家用电器”
     *  d: 案例代码  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]

## 14PrepareStatement接口预编译SQL语句执行修改 ##

package cn.itcast.demo1;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    
    /*
     * 使用PreparedStatement接口,实现数据表的更新操作
     */
    public class JDBCDemo {
    	public static void main(String[] args) throws Exception {
    		//1.注册驱动
    		Class.forName("com.mysql.jdbc.Driver");
    		
    		//2.获取连接对象
    		String url = "jdbc:mysql://localhost:3306/mybase";
    		String username = "root";
    		String password = "123";
    		Connection con = DriverManager.getConnection(url, username, password);
    		
    		//3.获取执行SQL语句对象
    		//拼写修改的SQL语句,参数采用?占位
    		String sql = "UPDATE sort SET sname=?,sprice=? WHERE sid=?";
    		//调用数据库连接对象con的方法PreparedStatement获取SQL语句的预编译对象
    		PreparedStatement pst = con.prepareStatement(sql);
    		//调用pst的方法setXXX设置?占位
    		pst.setObject(1, "汽车美容");
    		pst.setObject(2, 49988);
    		pst.setObject(3, 7);
    		
    		//4.执行SQL语句
    		//通过执行者对象调用方法执行SQL语句,获取结果
    		// int executeUpdate(String sql)  执行数据库中的SQL语句,insert delete update
    		//返回值int,操作成功数据表多少行
    		pst.executeUpdate();
    			
    		//6.释放资源 一堆close()
    		pst.close();
    		con.close();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]

## 15PrepareStatement接口预编译SQL语句执行查询 ##

package cn.itcast.demo1;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    /*
     * PreparedStatement接口实现数据表的查询操作
     */
    public class JDBCDemo1 {
    	public static void main(String[] args) throws Exception {
    		//1.注册驱动
    		Class.forName("com.mysql.jdbc.Driver");
    		
    		//2.获取连接对象
    		String url = "jdbc:mysql://localhost:3306/mybase";
    		String username = "root";
    		String password = "123";
    		Connection con = DriverManager.getConnection(url, username, password);
    		
    		//3.获取执行SQL语句对象
    		String sql = "SELECT * FROM sort";
    		//调用数据库连接对象con的方法PreparedStatement获取SQL语句的预编译对象
    		PreparedStatement pst = con.prepareStatement(sql);
    				
    		//4.调用执行者对象方法,执行SQL语句获取结果集
    		//ResultSet executeQuery(String sql)  执行SQL语句中的select查询
    		//执行给定的 SQL 语句，该语句返回单个 ResultSet 对象
    		//返回值ResultSet接口的实现类对象,实现类在mysql驱动中
    		//调用pst对象的方法,执行查询语句,select
    		ResultSet rs = pst.executeQuery();//注意这里
    		
    		//5.处理结果集
    		//System.out.println(rs);
    		//com.mysql.jdbc.JDBC4ResultSet@106fbd7
    		//ResultSet接口方法boolean next() 返回true,有结果集,返回false没有结果集
    		while(rs.next()){
    			//获取每列数据,使用的是ResultSet接口的方法getXX
    			System.out.println(rs.getString("sid") + "\t" + rs.getString("sname") + "\t" + rs.getString("sprice") 
    			+ "\t" + rs.getString("sdesc"));
    		}
    		
    		//6.释放资源 一堆close()
    		rs.close();
    		pst.close();
    		con.close();
    	}
    }

输出结果：

1	家电	2000	优惠的促销
    2	家具	8900	家具价格上调,原材料涨价
    3	儿童玩具	300	赚家长钱
    4	生鲜	500.99	生鲜商品
    5	服装	24000	换季销售
    6	洗涤	50	洗发水促销
    7	汽车美容	49988	疯狂涨价
    8	汽车用品	200000	疯狂涨价

## 16JDBC的工具类和测试 ##

*  A: JDBC的工具类和测试
    
     *  a: 案例代码

package cn.itcast.jdbcutil;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    /*
     * 实现JDBC的工具类
     * 定义方法,直接返回数据库的连接对象
     */
    public class JDBCUtils {
    	private JDBCUtils(){}
    	private static Connection con;
    	
    	static{
    		try {
    			//1.注册驱动
    			Class.forName("com.mysql.jdbc.Driver");
    			
    			//2.获取连接对象
    			String url = "jdbc:mysql://localhost:3306/mybase";
    			String username = "root";
    			String password = "123";
    			con = DriverManager.getConnection(url, username, password);
    		} catch (Exception ex) {
    			throw new RuntimeException(ex + "数据库连接失败");
    		}
    	}
    	
    	/*
    	 * 定义静态方法,返回数据库的连接对象
    	 */
    	public static Connection getConnection(){
    		return con;
    	}
    	
    	public static void close(Connection con,Statement stat){
    		if(stat != null){
    			try {
    				stat.close();
    			} catch (SQLException ex) {}
    		}
    		
    		if(con != null){
    			try {
    				con.close();
    			} catch (SQLException ex) {}
    		}
    	}
    	
    	public static void close(Connection con,Statement stat,ResultSet rs){
    		if(rs != null){
    			try {
    				rs.close();
    			} catch (SQLException ex) {}
    		}
    		
    		if(stat != null){
    			try {
    				stat.close();
    			} catch (SQLException ex) {}
    		}
    		
    		if(con != null){
    			try {
    				con.close();
    			} catch (SQLException ex) {}
    		}
    	}
    }

package cn.itcast.jdbcutil;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    
    /*
     * 测试JDBCUtils工具类的代码
     */
    public class TestJDBCUtils {
    	public static void main(String[] args) throws Exception {
    		//1.注册驱动
    		//2.获取连接对象
    		Connection con = JDBCUtils.getConnection();
    		
    		//3.获取执行SQL语句对象
    		String sql = "SELECT sname FROM sort";
    		//调用数据库连接对象con的方法PreparedStatement获取SQL语句的预编译对象
    		PreparedStatement pst = con.prepareStatement(sql);
    		
    		//4.调用执行者对象方法,执行SQL语句获取结果集
    		//调用pst对象的方法,执行查询语句,select
    		ResultSet rs = pst.executeQuery();
    		
    		//5.处理结果集
    		//ResultSet接口方法boolean next() 返回true,有结果集,返回false没有结果集
    		while(rs.next()){
    			System.out.println(rs.getString("sname"));
    		}
    		
    		//6.释放资源 一堆close()  关闭驱动对象、执行者对象,结果集对象
    		JDBCUtils.close(con, pst, rs);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]

## 17数据表数据存储对象 ##

*  A: 数据表数据存储对象
    
     *  a: 准备工作
        
         *  导入jar包
         *  拷贝day32定义的工具类JDBCUtils
     *  b: 案例代码

package cn.itcast.domain;
    /*
     * 定义实体类Sort
     */
    public class Sort {
    	private int sid;
    	private String sname;
    	private double sprice;
    	private String sdesc;
    		
    	public Sort(int sid, String sname, double sprice, String sdesc) {
    		super();
    		this.sid = sid;
    		this.sname = sname;
    		this.sprice = sprice;
    		this.sdesc = sdesc;
    	}
    	
    	public Sort() {
    		super();
    		
    	}
    
    	public int getSid() {
    		return sid;
    	}
    
    	public void setSid(int sid) {
    		this.sid = sid;
    	}
    
    	public String getSname() {
    		return sname;
    	}
    
    	public void setSname(String sname) {
    		this.sname = sname;
    	}
    
    	public double getSprice() {
    		return sprice;
    	}
    
    	public void setSprice(double sprice) {
    		this.sprice = sprice;
    	}
    
    	public String getSdesc() {
    		return sdesc;
    	}
    
    	public void setSdesc(String sdesc) {
    		this.sdesc = sdesc;
    	}
    
    	@Override
    	public String toString() {
    		return "Sort [sid=" + sid + ", sname=" + sname + ", sprice=" + sprice + ", sdesc=" + sdesc + "]";
    	}	
    }

package cn.itcast.demo2;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.util.ArrayList;
    import java.util.List;
    
    import cn.itcast.domain.Sort;
    import cn.itcast.jdbcutil.JDBCUtils;
    
    /*
     * 后续会用到,重要的案例
     * JDBC读取数据表sort,每行数据封装到Sort类的对象中
     * 很多个Sort类对象,存储到List集合中
     */
    public class JDBCDemo {
    	public static void main(String[] args) throws Exception {
    		//使用JDBC工具类,直接获取数据库连接对象
    		//1.注册驱动
    		//2.获取连接对象
    		Connection con = JDBCUtils.getConnection();
    		
    		//3.获取执行SQL语句对象
    		String sql = "SELECT * FROM sort";
    		//调用数据库连接对象con的方法PreparedStatement获取SQL语句的预编译对象
    		PreparedStatement pst = con.prepareStatement(sql);
    		
    		//4.调用执行者对象方法,执行SQL语句获取结果集
    		//调用pst对象的方法,执行查询语句,select
    		//使用查询方法,获取结果集
    		ResultSet rs = pst.executeQuery();
    		
    		//创建集合对象
    		List<Sort> list = new ArrayList<Sort>(); 
    		
    		//5.处理结果集
    		//ResultSet接口方法boolean next() 返回true,有结果集,返回false没有结果集
    		while(rs.next()){
    			//获取到每个列数据,封装到Sort对象中
    			Sort s = new Sort(rs.getInt("sid"),rs.getString("sname"),rs.getDouble("sprice"),rs.getString("sdesc"));
    			//封装的Sort对象,存储到集合中
    			list.add(s);
    		}
    		
    		//6.释放资源 一堆close()  关闭驱动对象、执行者对象,结果集对象
    		JDBCUtils.close(con, pst, rs);
    		
    		//遍历List集合
    		for(Sort s : list){
    			System.out.println(s);
    		}
    		
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]

## 18properties配置文件 ##

*  A: properties配置文件
    
     *  a: 相关介绍
        
         *  开发中获得连接的4个参数（驱动、URL、用户名、密码）通常都存在配置文件中，方便后期维护，程序如果需要更换数据库，  
            只需要修改配置文件即可。
         *  通常情况下，我们习惯使用properties文件，此文件我们将做如下要求：
            
            1.  文件位置：任意，建议src下
            2.  文件名称：任意，扩展名为properties
            3.  文件内容：一行一组数据，格式是“key=value”.  
                a) key命名自定义，如果是多个单词，习惯使用点分隔。例如：jdbc.driver  
                b) value值不支持中文，如果需要使用非英文字符，将进行unicode转换。

## 19properties文件的创建和编写 ##

*  A: properties文件的创建和编写
    
     *  a: properties文件的创建
        
         *  src路径下建立database.properties(其实就是一个文本文件)
     *  b: properties文件的编写(内容如下)  
        driverClass=com.mysql.jdbc.Driver  
        url=jdbc:mysql://localhost:3296/mybase  
        username=root  
        password=123  
        ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]

driverClass=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/mybase
    username=root
    password=123

## 20加载配置文件 ##

*  A: 加载配置文件
    
     *  a: 案例代码

/*
             *  加载properties配置文件
             *  IO读取文件,键值对存储到集合
             *  从集合中以键值对方式获取数据库的连接信息,完成数据库的连接
             */
            public class PropertiesDemo {
                public static void main(String[] args) throws Exception{
                    FileInputStream fis = new FileInputStream("database.properties");
                    System.out.println(fis);
                    //使用类的加载器
                    InputStream in = PropertiesDemo.class.getClassLoader().getResourceAsStream("database.properties");
                    System.out.println(in);
                    Properties pro = new Properties();
                    pro.load(in);
                    System.out.println(in);                 
                }
            }

## 21通过配置文件连接数据库 ##

package cn.itcast.properties;
    
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.util.Properties;
    
    import com.mysql.jdbc.Driver;
    
    /*
     * 加载PropertiesDemo配置文件
     * IO读取文件,键值对存储到集合
     * 从集合中以键值对方式获取数据库的连接信息,完成数据库的连接
     */
    public class PropertiesDemo {
    	public static void main(String[] args) throws Exception {
    		//database.properties (系统找不到指定的文件)
    		//不采用这种方式加载路径,因为给别人代码,是bin文件,路径不好确定
    		//FileInputStream fis = new FileInputStream("database.properties");
    		//System.out.println(fis);
    		
    		//使用类的加载类
    		//他是从bin文件夹中加载进来的
    		//这个bin中文件夹中配置文件,是与src中文件夹中配置文件，是同时创建的（配置内容一致）
    		InputStream in = PropertiesDemo.class.getClassLoader().getResourceAsStream("database.properties");
    		System.out.println(in);
    		Properties pro = new Properties();
    		pro.load(in);
    		System.out.println(in);
    		//获取集合中键值对
    		String driverClass = pro.getProperty("driverClass");
    		String url = pro.getProperty("url");
    		String username = pro.getProperty("username");
    		String password = pro.getProperty("password");
    		Class.forName(driverClass);
    		Connection con = DriverManager.getConnection(url, username, password);
    		System.out.println(con);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]

## 22读取配置文件的工具类 ##

*  A: 读取配置文件的工具类
    
     *  a: 案例代码

package cn.itcast.jdbcutil;
    /*
     * 编写JDBC的工具类,获取数据库的连接
     * 采用读取配置文件的方式
     * 读取配置文件,获取连接,执行一次,static{}
     */
    
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.util.Properties;
    
    public class JDBCUtilsConfig {
    	private static Connection con;
    	private static String driverClass;
    	private static String url;
    	private static String username;
    	private static String password;
    	
    	static{
    		try {
    			readConfig();
    			Class.forName(driverClass);
    			con = DriverManager.getConnection(url, username, password);
    		} catch (Exception ex) {
    			throw new RuntimeException("数据库连接失败");
    		}
    	}
    	
    	private static void readConfig() throws Exception{
    		InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("database.properties");
    		Properties pro = new Properties();
    		pro.load(in);
    		driverClass = pro.getProperty("driverClass");
    		url = pro.getProperty("url");
    		username = pro.getProperty("username");
    		password = pro.getProperty("password");
    	}
    	
    	public static Connection getConnection(){
    		return con;
    	}
    }

## 23测试工具类 ##

package cn.itcast.jdbcutil;
    
    import java.sql.Connection;
    
    /*
     * 测试JDBCUtils配置文件的代码
     */
    public class TextJDBCUtilsConfig {
    
    	public static void main(String[] args) {
    		Connection con = JDBCUtilsConfig.getConnection();
    		System.out.println(con);
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220402/928b6c203dca44e2adda3ca7e32403ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220402/bd2df92180394a8797fc3904930de560.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220402/370018ae5fe64d12a984037256b3cbae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220402/90133e370c20413a92392c4cf3ccadb4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220402/6a9af8199b0547efbe6bc9a37cb08db3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220402/3a6ea2bfc2b94b918c837e0f1226c79f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220402/c51b3a1dcd4d479f87883fc1848cf378.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220402/0e0017a960774538bf9338805b9e9b6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220402/ef1b7cfa6abd4c5186600cf35f6b0a01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220402/c49cfe2d28e243ae99e6ee5e120f6f7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220402/df262b8dfe194921b9b82785e4dd17ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220402/feea847cc63f4403831fb5883822dc43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220402/aed9dce01a304851983f9fe98ea52d6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220402/e340bebc09aa482297341ac89fc54d5f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220402/40084fbeefb843fa8e7266ce4da55897.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]: /images/20220402/fce1ac027d874b0c8305bd8eb27b1b43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]: /images/20220402/73a66374e4064e24b5cb759319ab0e30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 17]: /images/20220402/7b4b89c096704ad2b4c166aba44f1b6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 18]: /images/20220402/e53c5b49b07f458683eeed8885697414.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 19]: /images/20220402/3eaf9248b86c4b5c8a2f99f8b3515d39.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 20]: /images/20220402/ab923f666ad14f2cbd12a1ba4ee61f78.png