• MySQL-JDBC

    1. JDBC介绍

            JDBC（Java Database Connectivity）是 Java 连接数据库的标准接口，它提供了一种与数据库交互的统一方式，使得 Java 程序能够通过标准 API 访问和操作各种关系型数据库。

    2. JDBC使用步骤

            第0步：导bao

            第1步：注册驱动（仅需一次）

            第2步：建立链接（Connection）

            第3步：创建语句传输对象（Statement）

            第4步：运行sql语句

            第5步：处理运行结果（ResultSet）

            第6步：释放资源

            其中，如果是添加，删除，更新操作，可以没有第五步，查询肯定有第五步。

            2.0 导包

            下载相应版本的jar包（下载地址：Maven Repository: MySQL (mvnrepository.com)） 

            

            创建Java项目 ——> 在项目下创建lib文件夹——> 将jar包复制到lib文件夹下——> 右键——> Build Path ——> Add to Build Path

            

            2.1 注册驱动

            创建java类 JDBC_00 （类名随意）

    1.         // 1. 注册驱动
    2. 		Class.forName("com.mysql.cj.jdbc.Driver");
              2.2 建立链接
    1. // 2. 创建链接对象
    2. // 	  如果出现乱码等问题 可以在url后添加设置编码方式
    3. // 	  url : jdbc:mysql://IP:端口/数据库?useUnicode=true&characterEncoding=utf-8
    4. 	  Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/_day_02","root", "root");
            2.3 创建语句传输对象
    1. // 3. 创建语句传输对象
    2. 		Statement statement = conn.createStatement();
    3. 		String sql = "select * from student";
            2.4 运行语句
    1. // 4. 执行sql语句获取结果集
    2. 		ResultSet rs = statement.executeQuery(sql);
            2.5 处理运行结果
    1. // 5. 处理结果集数据
    2. 		while (rs.next()) {
    3. 			// 根据列名获取数据
    4. 			int id = rs.getInt("id");
    5. 			// 根据列的索引获取数据,不建议使用,
    6. 			// int id = rs.getInt(1);
    7. 			String name = rs.getString("name");
    8. 			int tid = rs.getInt("teacher_id");
    9. 			double score = rs.getDouble("score");
    10. 			System.out.println(id + "--" + name + "--" + tid + "--" + score);
    11. 		}
            2.6 释放资源
    1. 		// 6. 关闭资源
    2. 		rs.close();
    3. 		statement.close();
    4. 		conn.close();

    3.代码优化

            添加try...catch...finally异常处理

    1. public class JDBC_00 {
    2. 	public static void main(String[] args) {
    3. 		Connection conn = null;
    4. 		Statement statement = null;
    5. 		ResultSet rs = null;
    6. 		try {
    7. 			// 1. 注册驱动
    8. 			Class.forName("com.mysql.cj.jdbc.Driver");
    9. 			// 2. 创建链接对象
    10. 			// 	  如果出现乱码等问题 可以在url后添加东西
    11. 			// 	  url : jdbc:mysql://IP:端口/数据库?useUnicode=true&characterEncoding=utf-8
    12. 			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/_day_02","root", "abc280619SS");
    13. 			// 3. 创建语句传输对象
    14. 			statement = conn.createStatement();
    15. 			String sql = "select * from student";
    16. 			// 4. 执行sql语句获取结果集
    17. 			rs = statement.executeQuery(sql);
    18. 			// 5. 处理结果集数据
    19. 			while (rs.next()) {
    20. 				// 根据列名获取数据
    21. 				int id = rs.getInt("id");
    22. 				// 根据列的索引获取数据,不建议使用,
    23. 				// int id = rs.getInt(1);
    24. 				String name = rs.getString("name");
    25. 				int tid = rs.getInt("teacher_id");
    26. 				double score = rs.getDouble("score");
    27. 				System.out.println(id + "--" + name + "--" + tid + "--" + score);
    28. 			}
    29. 		} catch (Exception e) {
    30. 			e.printStackTrace();
    31. 		}finally {
    32. 			try {
    33. 				// 6. 关闭资源,先打开的后关闭
    34. 				rs.close();
    35. 				statement.close();
    36. 				conn.close();
    37. 			} catch (SQLException e) {
    38. 				e.printStackTrace();
    39. 			}
    40. 			
    41. 		}
    42. 		
    43. 	}
    44. }

    4. DML

            Data Manipulation Language : 数据操作语言

            涉及的关键字有 : delete,update,insert

            和查询的操作几乎一样,就是把第4步和第5步更改一下

    1. public class JDBC_02 {
    2. 	public static void main(String[] args) {
    3. 		Connection conn = null;
    4. 		Statement statement = null;
    5. 		try {
    6. 			// 加载驱动
    7. 			Class.forName("com.mysql.cj.jdbc.Driver");
    8. 			// 创建链接对象
    9. 			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/_day_02", "root", "abc280619SS");
    10. 			// 创建语句传输对象
    11. 			statement = conn.createStatement();
    12. 			// 编写sql语句
    13. 			// 添加
    14. 			String sql = "insert into teacher(id,`name`) values(3,'宋老师')"; 
    15. 			// 修改
    16. 			sql = "update teacher set `name` = '赵老师' where id = 3";
    17. 			// 删除
    18. 			sql = "delete from teacher where id = 3";
    19. 			// 执行sql语句，增删改使用executeUpdate()方法，查询使用executeQuery()方法
    20. 			int count = statement.executeUpdate(sql);
    21. 			System.out.println("成功，影响了"+ count + "行。" );
    22. 		} catch (Exception e) {
    23. 			e.printStackTrace();
    24. 		}finally {
    25. 			// 关闭资源
    26. 			try {
    27. 				statement.close();
    28. 				conn.close();
    29. 			} catch (SQLException e) {
    30. 				e.printStackTrace();
    31. 			}	
    32. 		}	
    33. 	}
    34. }

    5. PrepareStatement

            添加或删除的时候，尽量使用PrepareStatement，而不是Statement

            Statement和PrepareStatement的区别：

            Statement 用于执行静态SQL语句，在执行的时候，必须指定一个事先准备好的SQL语句，并且相对不安全，会有SQL注入风险。

            PrepareStatement 是预编译的SQL语句对象，SQL语句被预编译i并保存在对象中，被封装的SQL语句中，可以使用动态包含的参数？，在执行的时候可以为？传递参数。

            使用PrepareStatement对象执行SQL语句的时候，sql被数据库进行预编译和预解析，然后被放到缓冲区中，每当执行一个PrepareStatement对象时，他就会被解析一次，但不会被再次编译，可以重复使用，减少编译次数，提高数据库性能。并且能够避免SQL注入,相对安全(把’ 单引号 使用 \ 转义,避免SQL注入 )。

            SQL注入：

            SQL注入（SQL Injection）是一种常见的网络安全攻击技术，通过在应用程序中插入恶意的SQL查询语句，来利用程序缺陷或漏洞，从而对数据库进行非法操作或获取敏感信息。

            SQL注入攻击通常发生在需要用户输入数据并将其嵌入到 SQL 查询语句中的地方，比如登录表单、搜索框、参数化查询等。攻击者利用这些地方未对用户输入进行有效验证和过滤，直接将恶意的SQL代码注入到查询中，从而执行恶意操作。

            

    1.  
    2. /*
    3.  * PrepareStament
    4.  */
    5. public class JDBC_05 {
    6. 	public static void main(String[] args) {
    7. 		Scanner scanner = new Scanner(System.in);
    8. 		System.out.println("请输入用户名：");
    9. 		String username = scanner.nextLine();
    10. 		System.out.println("请输入密码：");
    11. 		String password = scanner.nextLine();
    12. 		// login(username, password);
    13. 		// updatePwd(username, password);
    14. 		loginUser(username, password);
    15. 		
    16. 	}
    17. 	
    18. 	// 用户登录方法
    19. 	public static boolean login(String username,String password) {
    20. 		Connection conn = null;
    21. 		PreparedStatement statement = null;
    22. 		ResultSet rs = null;
    23. 		try {
    24. 			// 加载驱动
    25. 			conn = DBUtil.getConnection();
    26. 			// 编写sql语句
    27. 			String sql = "select count(*) from user where name = ? and password = ?";
    28. 			// 创建输出对象
    29. 			statement = conn.prepareStatement(sql);
    30. 			// 给问号赋值
    31. 			statement.setString(1, username);
    32. 			statement.setString(2, password);
    33. 			// 创建结果集,执行sql语句
    34. 			rs = statement.executeQuery();
    35. 			rs.next();
    36. 			// 返回结果
    37. 			int count = rs.getInt(1);
    38. 			if (count == 0) {
    39. 				System.out.println("登录失败");
    40. 				return false;
    41. 			}else {
    42. 				System.out.println("登录成功");
    43. 				return true;
    44. 			}
    45. 			
    46. 		} catch (Exception e) {
    47. 			e.printStackTrace();
    48. 		} finally {
    49. 			// 关闭资源
    50. 			DBUtil.close(rs);
    51. 			DBUtil.close(statement);
    52. 			DBUtil.close(conn);
    53. 		}
    54. 		return false;
    55. 	}
    56. 	// 修改密码的方法
    57. 	public static void updatePwd(String username,String password) {
    58. 		Connection conn = null;
    59. 		PreparedStatement statement = null;
    60. 		try {
    61. 			// 加载驱动
    62. 			conn = DBUtil.getConnection();
    63. 			// 编写sql语句
    64. 			String sql = "update user set password = ? where name = ?";
    65. 			// 创建输出对象
    66. 			statement = conn.prepareStatement(sql);
    67. 			// 给问号赋值
    68. 			statement.setString(1, password);
    69. 			statement.setString(2, username);
    70. 			// 执行sql语句
    71. 			int count = statement.executeUpdate();
    72. 			System.out.println("修改了"+count+"条数据");
    73.  
    74. 		} catch (Exception e) {
    75. 			e.printStackTrace();
    76. 		} finally {
    77. 			// 关闭资源
    78. 			DBUtil.close(statement);
    79. 			DBUtil.close(conn);
    80. 		}
    81. 	}
    82. 	
    83. 	
    84. 	// 使用statement的登录方法，容易发生sql注入问题
    85. 	// 由于Statement在执行sql语句之前进行了字符串的拼接，所以如果username输入类似'or 1=1 or'格式
    86. 	// 即使用户不存在也能实现登录
    87. 	public static boolean loginUser(String username,String password) {
    88. 		Connection conn = null;
    89. 		Statement statement = null;
    90. 		ResultSet rs = null;
    91. 		try {
    92. 			// 加载驱动
    93. 			conn = DBUtil.getConnection();
    94. 			// 创建输出对象
    95. 			statement = conn.createStatement();
    96. 			// 编写sql语句
    97. 			String sql = "select count(*) from user where name = '"+username+"' and password = '"+password+"'";
    98. 			// 创建结果集,执行sql语句
    99. 			rs = statement.executeQuery(sql);
    100. 			rs.next();
    101. 			// 返回结果
    102. 			int count = rs.getInt(1);
    103. 			if (count == 0) {
    104. 				System.out.println("登录失败");
    105. 				return false;
    106. 			}else {
    107. 				System.out.println("登录成功");
    108. 				return true;
    109. 			}
    110. 			
    111. 		} catch (Exception e) {
    112. 			e.printStackTrace();
    113. 		} finally {
    114. 			// 关闭资源
    115. 			DBUtil.close(rs);
    116. 			DBUtil.close(statement);
    117. 			DBUtil.close(conn);
    118. 		}
    119. 		return false;
    120. 	}		
    121. }

            

    6. 封装工具类

            以上代码中创建链接和关闭资源操作都是相同的，因此可以把这一部分逻辑抽离出来，形成独立的类和方法，在实际应用中直接调用相应的类和方法即可。

            创建JDBCUtil类，提供获取链接的方法和释放资源的方法

    1. public class DBUtil {
    2. 	
    3. 	// 封装方法加载驱动创建链接
    4. 	public static Connection getConnection() throws ClassNotFoundException, SQLException{
    5. 		Class.forName("com.mysql.cj.jdbc.Driver");
    6. 		Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/_day_02","root", "abc280619SS");
    7. 		return conn;
    8. 	}
    9. 	// 封装方法关闭资源
    10. 	public static void close(AutoCloseable obj) {
    11. 		if (obj != null) {
    12. 			try {
    13. 				obj.close();
    14. 			} catch (Exception e) {
    15. 				e.printStackTrace();
    16. 			}
    17. 		}
    18. 	}
    19. }

    7. Batch 多语句操作

            在一次任务中执行多条语句

    1. public class JDBC_Batch {
    2. 	public static void main(String[] args) {
    3. 		// testStatement();
    4. 		testPrepareStatement();
    5. 	}
    6. 	
    7. 	// 使用Statement添加多条数据
    8. 	public static void testStatement() {
    9. 		Connection conn = null;
    10. 		Statement statement = null;
    11. 		try {
    12. 			conn = DBUtil.getConnection();
    13. 			statement = conn.createStatement();
    14. 			
    15. 			statement.addBatch("insert into user(name,password,nickname) values('test1',111,'用户1')");
    16. 			statement.addBatch("insert into user(name,password,nickname) values('test2',222,'用户2')");
    17. 			statement.addBatch("insert into user(name,password,nickname) values('test3',333,'用户3')");
    18. 			statement.executeBatch();
    19. 			System.out.println("添加成功");
    20. 			
    21. 		} catch (ClassNotFoundException | SQLException e) {
    22. 			e.printStackTrace();
    23. 		} finally {
    24. 			DBUtil.close(statement);
    25. 			DBUtil.close(conn);
    26. 		}
    27. 		
    28. 	}
    29. 	
    30. 	
    31. 	// 使用PrepareStatement添加多条数据
    32. 	public static void testPrepareStatement() {
    33. 		Connection conn = null;
    34. 		PreparedStatement preparedStatement = null;
    35. 		try {
    36. 			conn = DBUtil.getConnection();
    37. 			preparedStatement = conn.prepareStatement("insert into user(name,password,nickname) values(?,?,?)");
    38. 			preparedStatement.setString(1, "test1");
    39. 			preparedStatement.setInt(2, 111);
    40. 			preparedStatement.setString(3, "用户1");
    41. 			preparedStatement.addBatch();
    42. 			
    43. 			preparedStatement.setString(1, "test2");
    44. 			preparedStatement.setInt(2, 222);
    45. 			preparedStatement.setString(3, "用户2");
    46. 			preparedStatement.addBatch();
    47. 			
    48. 			preparedStatement.setString(1, "test3");
    49. 			preparedStatement.setInt(2, 333);
    50. 			preparedStatement.setString(3, "用户3");
    51. 			preparedStatement.addBatch();
    52. 			preparedStatement.executeBatch();
    53. 			System.out.println("添加成功");
    54. 			
    55. 		} catch (ClassNotFoundException | SQLException e) {
    56. 			e.printStackTrace();
    57. 		} finally {
    58. 			DBUtil.close(preparedStatement);
    59. 			DBUtil.close(conn);
    60. 		}
    61. 		
    62. 	}
    63. }

  • 相关阅读:
    github push 失败 git did not exit cleanly(exit code 128) 账号登录失败 解决经验
    PREPARE TO FAIL(OVER)
    maven 初学
    大数据与人工智能的交融：向量数据库在具体应用案例中的探索
    设计模式—创建型模式之单例模式
    基于Redis（SETNX）实现分布式锁，案例：解决高并发下的订单超卖，秒杀
    aarch64 麒麟v10系统使用docker部署nvidia_gpu_exporter监控GPU
    倾斜单体化模型技术实现
    猿创征文｜Java之static关键字【实例变量与类变量、实例方法与类方法】
    【JavaEE】Java的前世今身
  • 原文地址：https://blog.csdn.net/apple_59745077/article/details/136306690