MYSQL阶段_DAY12-DAY16(附笔记)

【注意】：DBUtils就是JDBC的简化开发工具包。获取一个用来执行SQL语句的对象   QueryRunner。

1 QueryRunnerDemo
 * 使用Dbutis,（QueryRunner）
 *     对数据表  增加 删除 更新
 *         update(Connection conn, String sql, Object... params) ，用来完成表数据的增加 删除 更新操作
 *         Object... params是可变参数
 * 
 

public class QueryRunnerDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		insert();
//		update();
		delete();
	}

	
	public static void insert(){
		try {
			//创建QueryRunner对象，用来完成SQL语句的执行
			QueryRunner qr = new QueryRunner();
			
			String sql = "INSERT INTO zhangwu(id,name,money) VALUES(?,?,?)";
			Object[] params = {8, "打扑克收入", 5000};
			
			Connection conn = JDBCUtilsVersion2.getConnection();//获取驱动，数据库连接
			
			
			int line = qr.update(conn,sql,params);// 用来完成表数据的增加、删除 更新 操作
			
			//结果集处理
			System.out.println("line = " + line);
			
			//关闭资源
			DbUtils.closeQuietly(conn);
			
		} catch (SQLException e) {
			throw new RuntimeException(e);
		}
	}
	public static void update(){
		try {
			//创建QueryRunner对象，用来完成SQL语句的执行
			QueryRunner qr = new QueryRunner();
			//执行SQL语句
			String sql = "UPDATE zhangwu SET money = ? , name=? WHERE id=? ";
			Object[] params = {9999,"打扑克收入11",8};
			Connection conn = JDBCUtilsVersion2.getConnection();
			int line = qr.update(conn, sql, params);
			//结果集的处理
			System.out.println("line="+line);
			//关闭资源
			DbUtils.closeQuietly(conn);
		} catch (SQLException e) {
			throw new RuntimeException(e);
		}
	}
	
	public static void delete(){
		try {
			//创建QueryRunner对象，用来完成SQL语句的执行
			QueryRunner qr = new QueryRunner();
			//执行SQL语句
			String sql = "DELETE FROM zhangwu WHERE name = ?";
			Object[] params = {"打扑克收入11"};
			Connection conn = JDBCUtilsVersion2.getConnection();
			int line = qr.update(conn, sql, params);
			//结果集的处理
			System.out.println("line="+line);
			//关闭资源
			DbUtils.closeQuietly(conn);
		} catch (SQLException e) {
			throw new RuntimeException(e);
		}
	}



	
}

2  QueryRunnerDemo2 , QueryRunnerDemo3

使用Dbutis,（QueryRunner）
 对数据表  查询（8种）

    ArrayHandler：将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
   ArrayListHandler：将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。

         BeanHandler    ：将结果集中第一条记录封装到一个指定的javaBean中。
         BeanListHandler    ：将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
 
 
         ColumnListHandler：将结果集中指定的列的字段值，封装到一个List集合中
 
       ScalarHandler：它是用于单数据。例如select count(*) from 表操作。
 
 
        MapHandler    将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
        MapListHandler    将结果集封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合

javabean：

/*
 * 账务类,javaBean,封装数据
 */
public class ZhangWu {
	private int id;
	private String name;
	private double money;


	public ZhangWu() {
		super();
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getMoney() {
		return money;
	}
	public void setMoney(double money) {
		this.money = money;
	}


	@Override
	public String toString() { //该方法可以省略
		return "ZhangWu [id=" + id + ", name=" + name + ", money=" + money + "]";
	}
}

查询： 

public class QueryRunnerDemo2 {

	public static void main(String[] args) throws SQLException {

		Connection conn = JDBCUtilsVersion2.getConnection();
		
//		ArrayHandler(conn);
		arrayListHandler(conn);
	}
	
	
	// 测试DbUtils查询数据: ArrayListHandler
	private static void arrayListHandler(Connection conn) throws SQLException {
	    // 创建QueryRunner对象
	    QueryRunner queryRunner = new QueryRunner();
	    // 定义SQL
	    String sql = "SELECT * FROM sort";
	    // 执行语句
	    List result = queryRunner.query(conn, sql, new ArrayListHandler());
	    // 遍历集合,集合的每个元素是一个数组
	    for (Object[] objects : result) {
	        // 继续遍历每条记录的object数组，遍历集合中的元素，即遍历数组元素
	        for (Object value : objects) {
	            // 打印该条记录的每列的值
	            System.out.print(value + "\t");
	        }
	        // 打印完一条记录后换行
	        System.out.println();
	    }
	    // 释放资源
	    DbUtils.close(conn);
	}
	

	/*
	 * 结果集接口的实现类1--->ArrayListHandler
	 * 
	 * 测试DbUtils查询数据: ArrayListHandler
	 * 只能查询结果集的第一条记录，并封装为对象数组
	 * 
	 * */ 
	private static void ArrayHandler(Connection conn) throws SQLException {
		// 创建QueryRunner对象
		QueryRunner queryRunner = new QueryRunner();
		// 定义SQL
		String sql = "SELECT * FROM sort";
		// 执行语句
		Object[] result = queryRunner.query(conn, sql, new ArrayHandler());
		// 遍历集合
		for(Object obj:result){
			System.out.print(obj+"   ");
		}
		
		// 释放资源
		DbUtils.close(conn);
	}

}

public class QueryRunnerDemo3 {
	public static void main(String[] args) throws SQLException {
//		 BeanHandler();
		 BeanListHandler();
		// ColumnListHandler();
		// ScalarHandler();
		// MapHandler();
//		MapListHandler();

	}
//	BeanHandler	：将结果集中第一条记录封装到一个指定的javaBean中
	public static void BeanHandler() throws SQLException{
		
			//获取QueryRunner 
			QueryRunner qr = new QueryRunner();
			//执行SQL语句
			String sql = "SELECT * FROM zhangwu WHERE id=? or id=?";
			Object[] params = {1,3};
			Connection conn = JDBCUtilsVersion2.getConnection();
			ZhangWu zw = qr.query(conn, sql, new BeanHandler(ZhangWu.class), params);
			
			System.out.println(ZhangWu.class); //class MyJDBC_06.ZhangWu
			//结果集处理
			System.out.println(zw);
			
			DbUtils.close(conn);
	}
	
	
	//	BeanListHandler	：将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
	public static void BeanListHandler() throws SQLException{
	
			//获取QueryRunner 
			QueryRunner qr = new QueryRunner();
			//执行SQL语句
			String sql = "SELECT * FROM zhangwu WHERE money>?";
			Object[] params = {2000};
			Connection conn = JDBCUtilsVersion2.getConnection();
			List list = qr.query(conn, sql, new BeanListHandler(ZhangWu.class), params);
			//结果集处理
			for (ZhangWu zw : list) {
				System.out.println(zw);
			}
			
			DbUtils.close(conn);
	}
	
	//ColumnListHandler：将结果集中指定的列的字段值，封装到一个List集合中
	public static void ColumnListHandler() throws SQLException{
		
			//获取QueryRunner对象
			QueryRunner qr = new QueryRunner();
			//执行SQL语句
			String sql = "SELECT name FROM zhangwu WHERE money>?";
			Object[] params = {2000};
			Connection conn = JDBCUtilsVersion2.getConnection();
			List list = qr.query(conn, sql, new ColumnListHandler(), params); 
			//结果集的处理
			for (String str : list) {
				System.out.println(str);
			}

			DbUtils.close(conn);
	
	}
	
	//ScalarHandler：它是用于单数据。例如select count(*) from 表操作
	public static void ScalarHandler() throws SQLException{
		
			//获取QueryRunner对象
			QueryRunner qr = new QueryRunner();
			
			//执行SQL语句
			String sql = "SELECT MAX(money) FROM zhangwu";
			Object[] params = {};
			Connection conn = JDBCUtilsVersion2.getConnection();
			Double max = qr.query(conn, sql, new ScalarHandler(), params);
			//结果集的处理
			System.out.println("max=" + max);
			
			conn.close();
	}
	//MapHandler	将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
	public static void  MapHandler() throws SQLException{
		//获取QueryRunner对象
		QueryRunner qr = new QueryRunner();
		//执行SQL
		String sql = "select * from sort";
		
		Connection conn = JDBCUtilsVersion2.getConnection();
		
		Map map = qr.query(conn, sql, new MapHandler());
		
		System.out.println(map);
		//根据对应的key返回值
		System.out.println(map.get("sid"));
		
		DbUtils.close(conn);
    }

	// MapListHandler 将结果集的记录以Map形式存储,然后将Map集合存储到List集合

	public static void MapListHandler() throws SQLException {
		// 获取QueryRunner对象
		QueryRunner qr = new QueryRunner();
		// 执行SQL
		String sql = "select * from sort";

		Connection conn = JDBCUtilsVersion2.getConnection();

		List> list = qr.query(conn, sql, new MapListHandler());

		for (Object obj : list) {
			System.out.println(obj);
		}

		System.out.println("--------");

		for (Map map : list) {
			System.out.println(map);
		}

		System.out.println("--------");

		for (Map map : list) {
			System.out.println(map.get("sname"));
		}
		DbUtils.close(conn);
	}

}

---------------------------至此，JDBC与DBUtils知识到此为止。--------------------------------------------

 

---------------------------所以，接下来将DBCP连接池知识。-----------------------------------------------

【注意】：用池来管理Connection，这样可以重复使用Connection。有了池，所以我们就不用自己来创建Connection，而是通过池来获取Connection对象。当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。池就可以再利用这个Connection对象了。 

 

1 DataSourceDemo

      连接池jar包中，有一个类：BasicDataSource
      DBCP的BasicDataSource类: 实现了javax.sql.DataSource接口
 

public class DataSourceDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//创建DataSource接口的实现类对象
		//实现类，org.apache.commons.dbcp
		BasicDataSource dataSource = new BasicDataSource();
		
		//连接数据库的4个基本信息，通过setXXX方法设置进来
		dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
		dataSource.setUrl("jdbc:mysql://localhost:3306/hanstudy");
		dataSource.setUsername("root");
		dataSource.setPassword("123456");
		try{
			//调用对象方法getConnection获取数据库连接
			Connection conn = dataSource.getConnection();
			System.out.println(conn);
		}catch(SQLException e){
//			e.printStackTrace();
			throw new RuntimeException("数据库连接失败");  
			//抛出异常,如果没有这条语句，后面会执行别的语句（因为catch抛出后，没有处理，所以相当于throw结束main方法了，因为throw后面的代码不会执行了）
		}
		
		System.out.println("666");
		
	}
	
	

}

2 JDBCUtils ， TestJDBCUtils

JDBC工具类: v3.0 (JDBC_DBUtils项目中已有两个版本的JDBC工具类）
可以读取配置文件
使用DBCP连接池技术

对数据表进行CRUD操作

【注意】：现在就是不需要获取连接了，直接获取连接池对象。这就是DBCP存在的意义！

public class JDBCUtils {

    // 声明静态变量
	//创建连接池对象
    private static BasicDataSource dataSource = new BasicDataSource();
    private static String driver;
    private static String url;
    private static String username;
    private static String password;

    // 静态代码块进行初始化
    static {
        try {
            // 读取配置文件
            readConfig();
            // 设置连接池必选4个配置
            dataSource.setDriverClassName(driver);
            dataSource.setUrl(url);
            dataSource.setUsername(username);
            dataSource.setPassword(password);
            // 设置连接池可选4个配置
            dataSource.setInitialSize(10);  // 初始连接数 
            dataSource.setMaxActive(8);     // 最大活跃连接数
            dataSource.setMaxIdle(5);       // 最大空闲连接数
            dataSource.setMinIdle(1);       // 最小空闲连接数
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("数据库连接失败");
        }
    }

    // 私有构造方法
    private JDBCUtils() {}

    // 读取配置文件方法
    private static void readConfig() throws Exception {
        // 使用类加载器加载bin目录下的配置文件, 获取输入流
        InputStream in = JDBCUtils.class.getClassLoader().getResourceAsStream("database.properties");
        // 创建Properties对象
        Properties properties = new Properties();
        // 加载数据
        properties.load(in);
        // 通过键获取值
        driver = properties.getProperty("driver");
        url = properties.getProperty("url");
        username = properties.getProperty("user");
        password = properties.getProperty("password");
    }

    // 获取连接池数据源对象
    public static DataSource getDataSource() {
        return dataSource;
    }
}

测试JDBC工具类3.0

public class TestJDBCUtils {
	 // 定义静态变量
    private static QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());  // 不需要Connection了，即创建连接对象了，在连接池中获取

    public static void main(String[] args) {
        insert();
//        select();
//    	delete();
//    	update();
    }

    // 查询测试
    private static void select() {
        try {
            // 定义sql
            String sql = "select * from sort";
            // 执行语句
            List list = queryRunner.query(sql, new ArrayListHandler());
            for (Object[] objects : list) {
                for (Object object : objects) {
                    System.out.print(object + "\t");
                }
                System.out.println();
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("查询数据失败");
        }
    }

    // 插入测试
    private static void insert() {
        try {
            // 定义sql语句
            String sql = "insert into sort values (?, ?, ?);";
            // 定义参数
            Object[] params = {13,"雪糕",120.8};
            // 执行语句
            int rows = queryRunner.update(sql, params);
            System.out.println(rows);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("插入数据失败");
        }
    }
    
//    ----------------------------------------------------------------------------------------------
  //删除功能

  	public static void delete(){
  		try {
  			//创建一个QueryRunner对象，用来完成SQL语句的执行
  			QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
  			//执行SQL语句
  			String sql = "DELETE FROM zhangwu WHERE name = ?";
  			Object[] params = {"股票收入"};
  			int line = qr.update(sql, params);
  			//结果集的处理
  			System.out.println("line="+line);
  			
  		} catch (SQLException e) {
  			throw new RuntimeException(e);
  		}
  	}
  	
  	//更新功能
  	public static void update(){
  		try {
  			//创建一个QueryRunner对象，用来完成SQL语句的执行
  			QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
  			//执行SQL语句
  			String sql = "UPDATE zhangwu SET money = money+1000 WHERE name=?";
  			Object[] params = {"吃饭支出"};
  			int line = qr.update(sql, params);
  			//结果集的处理
  			System.out.println("line="+line);
  			
  		} catch (SQLException e) {
  			throw new RuntimeException("?"+e);
  		}
  	}
  	
  

    
}

3 登录注册功能通过MYSQL实现例子！！

操作User表的dao类，此类来操作数据库。

用户操作界面 operater类，此类来调用dao类，进行界面操作等。

package MyDBCP_03_dao;

import java.sql.SQLException;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import MyDBCP_02.JDBCUtils;

/*
		操作User表的dao类,操作数据库
 */
public class UsersDao {

    // 定义QueryRunner对象
    private QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());

    // 登录方法
    public boolean login(String username, String password) {
        try {
            // 定义SQL语句
            String sql = "SELECT * FROM user WHERE name=? AND password=?;";
            // 定义参数
            Object[] params = {username, password};
            // 执行语句
            Object[] result = queryRunner.query(sql, new ArrayHandler(), params);
            // 判断是否有结果
            if (result.length == 0)
                // 没有查到用户信息, 不能登录
                return false;
            // 如果能查到用户信息, 则允许登录
            return true;
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("登录dao操作失败");
        }
    }
    
    
 // 注册方法
    public boolean register(String username, String password) {
        try {
            // 定义查询用户名是否被占用的SQL语句
            String sql = "SELECT name FROM user WHERE name=?";
            // 执行语句
            String user = queryRunner.query(sql, new ScalarHandler(), username);  //用于单数据
            // 判断是否能够查到用户名
            if (user != null)
                // 能查到相同的用户名, 则结果不为空，则说明已被占用, 不能注册
                return false;
            // 如果能执行到这里, 则结果为空，说明用户名没有被占用, 直接插入数据库
            // 定义插入用户名和密码的sql
            sql = "INSERT INTO user (name, password) VALUES (?, ?);";
            // 定义参数
            Object[] params = {username, password};
            // 执行语句
            queryRunner.update(sql, params);
            // 直接返回注册成功的结果
            return true;
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("注册dao操作失败");
        }
    
    }
}

package MyDBCP_03_ui;

import java.util.Scanner;

import MyDBCP_03_dao.UsersDao;

/*
用户操作界面，此类来调用dao类，进行界面操作等。
 */
public class UserOperater {

    // 定义静态变量Scanner
    private static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        // 创建dao对象
        UsersDao dao = new UsersDao();

        while (true) {
            // 调用输入选项的方法
            String number = chooser();
            // 根据输入选项调用不同的功能
            switch (number) {
            case "1":  // 登录
                // 提示当前功能
                System.out.println("当前是[登录]功能, 请输入用户名");
                String username = scanner.next();
                System.out.println("请输入密码:");
                String password = scanner.next();
                //调用登录方法
                boolean canLogin = dao.login(username, password);
                // 判断结果, 给出提示
                if (canLogin) {
                    System.out.println("登录成功");
                } else {
                    System.out.println("登录失败");
                }
                break;
            case "2":  // 注册
                // 提示功能
                System.out.println("当前是注册功能, 请输入用户名:");
                username = scanner.next();
                System.out.println("请输入密码:");
                password = scanner.next();
                // 调用dao的注册方法
                boolean success = dao.register(username, password);
                // 根据结果给出提示
                if (success) {
                    System.out.println("注册成功");
                } else {
                    System.out.println("当前用户名已被占用, 请尝试" + username + "_123");
                }
                break;
            case "3":  // 退出
                System.out.println("再见");
                System.exit(0);
             /*   System.out.println("11");
                break;*/
            default:
                // 提示选项错误
                System.out.println("抱歉, 没有该选项");
                break;
            }
        }
    }

    // 获取键盘输入选项
    private static String chooser() {
        // 打印菜单
        System.out.println("---===欢迎光临===---");
        System.out.println("请输入您的选项:");
        System.out.println("1.登录 2.注册 3.退出");
        // 获取键盘录入的选项, 并返回
        return scanner.next();
    }
}

笔记地址：MySQL: MySQL学习笔记 (gitee.com)

---------------------------------至此，DBCP知识就已完成，接下来学习管家婆知识------------------