JavaWeb（JDBC编程）看这一篇就够了 —— 如何使用Java操纵mysql数据库 ...

金歌  金牌会员 | 2024-7-14 03:19:41 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 862|帖子 862|积分 2586

前言

   本文主要介绍了java面向JDBC编程的根本知识和用到的接口和方法。
  一、简介(面向接口编程)

   JDBC概念：
JDBC就是使用Java语言操纵关系型数据库的一套API
JDBC(Java Database Connectivity)全称为Java数据库毗连。
JABC是一套毗连数据库的标准接口，Java可以通过JDBC编程实现操纵差别的数据库。
差别的数据库想要被Java代码操纵，都要定义本身对于JDBC的实现类，也就是数据库驱动。
JDBC本质：
官方（sun公司）定义的一套所有关系型数据库的规则，即接口
各个数据库厂商去实现这套接口，提供数据库驱动jar包
我们可以使用这套接口（JDBC）编程，真正实行的代码是驱动jar包中的实现类。
JDBC利益
各数据库厂商使用相同的接口，Java代码不需要针对差别数据库分别开发
可随时替换底层数据库，访问数据库的Java代码根本稳固。
这种方式也叫面向接口编程。
  
二、JDBC操纵步骤

2.1创建工程，导入驱动jar包

   1.创建好工程后，右击工程名，点击New->Directory,创建一个lib目录
  

   2.复制粘贴mysql驱动jar包到这个目录下
  

   3.右击驱动jar包，点击Add as Library->Mudule Library->OK.导入成功
  


2.2JDBC代码快速实现

  1. package com.practice;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.Statement;
  7. /**
  8. * @Author YJ
  9. * @Date 2023/7/19 10:06
  10. * Description:JDBC编程
  11. */
  12. public class JDBCDemo {
  13.     public static void main(String[] args) throws Exception {
  14.         //1.注册驱动
  15.         Class.forName("com.mysql.jdbc.Driver");
  16.         //2.获取连接
  17.         //用户名和密码就是mysql注册时自己的用户名和密码
  18.         //demo1表示要连接的数据库名
  19.         String url = "jdbc:mysql://127.0.0.1:3306/demo1";
  20.         String username = "root";
  21.         String passWord = "123456";
  22.         //DriverManager.getConnection有一个返回值
  23.         Connection coon = DriverManager.getConnection(url, username, passWord);
  24.         //3.定义sql语句
  25.         String sql = "update emp set salary = 10000 where name='张三'";
  26.         //4.获取执行sql的对象Statement
  27.         Statement statement = coon.createStatement();
  28.         //5.执行sql
  29.         //返回影响的行数
  30.         int count = statement.executeUpdate(sql);
  31.         //6.处理结果
  32.         System.out.println(count);
  33.         //7.释放资源
  34.         //倒着释放，先创建的后释放
  35.         statement.close();
  36.         coon.close();
  37.     }
  38. }
复制代码
  上面的代码实行的sql语句是修改demo1数据库中的表emp中的内容，update emp set salary = 10000 where name='张三'表示将emp表中的姓名为张三的salary改为10000。
如下表示运行成功：
  java运行结果

mysql表中原数据

代码实行后

三、JDBC的API详解

3.1DriverManager

   DriverManager（驱动管理类）：
1.注册驱动
2.获取数据库毗连
    1.注册驱动
在注册驱动时我们用到的是Class.forName("com.mysql.jdbc.Driver");而这段代码底层也是调用的DriverManager.registerDriver()，在mysql5之后的驱动jar包下，这段代码可以省略，这是因为在mysql驱动jar包目录下有一个META.INF文件夹，其中有一个services目录，里面有个文件java.sql.Driver,里面就记录了驱动的类的名称。
  

   2.获取毗连
getConnection​(String url, String user, String password)
1.url:毗连路径
语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2..
如果毗连的是本机mysql服务器，并且Mysql服务默认端口号是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对1&参数键值对2..
设置useSSL=false参数，禁用安全毗连方式，解决警告提示
2.user:用户名
3.password:暗码
  
3.2Connection

   Connection(数据库毗连对象):
1.获取实行sql的对象
2.管理事务
    获取实行sql的对象
平凡实行SQL对象
Statement createStatement()
    **2.事务管理
MYSQL事务管理:
开启事务：BEGIN;/START TRANSACTION;
提交事务：COMMIT;
回滚事务：ROLLBACK;
MYSQL默认主动提交事务
JDBC事务管理：
通过Connection接口进行管理
开启事务：setAutoCommit(boolean autoCommit):true主动提交，false手动提交；
提交事务：commit()
回滚事务：rollback()
  
事务管理代码演示

  1. package com.practice;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. /**
  9. * @Author YJ
  10. * @Date 2023/7/19 10:36
  11. * Description:JDBC编程--Connection
  12. */
  13. public class JDBCDemoConnection {
  14.     public static void main(String[] args) throws Exception {
  15.         //1.注册驱动
  16.         //Class.forName("com.mysql.jdbc.Driver");
  17.         //2.获取连接
  18.         //用户名和密码就是mysql注册时自己的用户名和密码
  19.         //demo1表示要连接的数据库名
  20.         String url = "jdbc:mysql://127.0.0.1:3306/demo1?useSSL=false";
  21.         String username = "root";
  22.         String passWord = "123456";
  23.         //DriverManager.getConnection有一个返回值
  24.         Connection coon = DriverManager.getConnection(url, username, passWord);
  25.         //3.定义sql语句
  26.         String sql1 = "update emp set salary = 300 where name='张三'";
  27.         String sql2 = "update emp set salary = 600 where name='李四'";
  28.         //4.获取执行sql的对象Statement
  29.         Statement statement = coon.createStatement();
  30.         try {
  31.             //开启事务
  32.             coon.setAutoCommit(false);
  33.             //5.执行sql
  34.             //返回影响的行数
  35.             int count1 = statement.executeUpdate(sql1);
  36.             //5.执行sql
  37.             //返回影响的行数
  38.             int count2 = statement.executeUpdate(sql2);
  39.             //6.处理结果
  40.             System.out.println(count2);
  41.             //提交事务
  42.             coon.commit();
  43.         } catch (Exception throwables) {
  44.             //回滚事务
  45.             coon.rollback();
  46.             throwables.printStackTrace();
  47.         }
  48.         //7.释放资源
  49.         //倒着释放，先创建的后释放
  50.         statement.close();
  51.         coon.close();
  52.     }
  53. }
复制代码
结果

   要注意的是：在进行事务回滚操纵时，Java用的是异常处理机制。
  
3.3Statement

   Statement作用：
实行sql语句
int executeUpdate(sql)：实行DML、DDL语句
返回值：(1)DML语句影响的行数(2)DDL语句实行成功也可能返回0
ResultSet executeQuery(sql)：实行DQL语句
返回值：ResultSet 结果集对象
  1. package com.practice;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.Statement;
  7. /**
  8. * @Author YJ
  9. * @Date 2023/7/20 8:15
  10. * Description:DML
  11. */
  12. public class JDBCDemo2 {
  13.     public static void main(String[] args) throws Exception {
  14.         //1.注册驱动
  15.         //Class.forName("com.mysql.jdbc.Driver");
  16.         //2.获取连接
  17.         //用户名和密码就是mysql注册时自己的用户名和密码
  18.         //demo1表示要连接的数据库名
  19.         String url = "jdbc:mysql://127.0.0.1:3306/demo1?useSSL=false";
  20.         String username = "root";
  21.         String passWord = "123456";
  22.         //DriverManager.getConnection有一个返回值
  23.         Connection coon = DriverManager.getConnection(url, username, passWord);
  24.         //3.定义sql语句
  25.         String sql = "update emp set salary = 300 where name='张三'";
  26.         //4.获取执行sql的对象Statement
  27.         Statement statement = coon.createStatement();
  28.         //5.执行sql
  29.         //返回影响的行数
  30.         int count = statement.executeUpdate(sql);
  31.         //6.处理结果
  32.         if(count > 0) {
  33.             System.out.println("修改成功~");
  34.         } else {
  35.             System.out.println("修改失败~");
  36.         }
  37.         //7.释放资源
  38.         //倒着释放，先创建的后释放
  39.         statement.close();
  40.         coon.close();
  41.     }
  42. }
复制代码
3.4ResultSet

   ResultSet(结果集对象)作用：
封装了DQL查询语句的结果
ResultSet stmt.executeQuery(sql):实行DQL语句，返回ResultSet对象
获取查询结果
boolean next():
(1)将光标从当前位置向前移动一行
(2)判定当前行是否为有用行
返回值:
true:有用行，当前行有数据
false:无效行，当前行无数据
xxx getXxx(参数)：获取数据
xxx:数据类型；如int getInt(参数)
参数：
int :列的编号，从1开始
String:列的名称
  1. package com.practice;
  3. import java.math.BigDecimal;
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.ResultSet;
  7. import java.sql.Statement;
  9. /**
  10. * @Author YJ
  11. * @Date 2023/7/20 8:15
  12. * Description:ResultSet  执行DQL语句
  13. */
  14. public class JDBCDemo5 {
  15.     public static void main(String[] args) throws Exception {
  16.         //1.注册驱动
  17.         //Class.forName("com.mysql.jdbc.Driver");
  18.         //2.获取连接
  19.         //用户名和密码就是mysql注册时自己的用户名和密码
  20.         //demo1表示要连接的数据库名
  21.         String url = "jdbc:mysql://127.0.0.1:3306/demo1?useSSL=false";
  22.         String username = "root";
  23.         String passWord = "123456";
  24.         //DriverManager.getConnection有一个返回值
  25.         Connection coon = DriverManager.getConnection(url, username, passWord);
  26.         //3.定义sql
  27.         String sql = "select * from emp";
  28.         //4.获取Statement对象
  29.         Statement stmt = coon.createStatement();
  30.         //5.执行sql
  31.         ResultSet resultSet = stmt.executeQuery(sql);
  32.         //6.处理结果
  33.         //6.1光标向下移动，判断是否有数据
  34.         while (resultSet.next()) {
  35.             //6.2获取数据
  36.             String name = resultSet.getString(1);
  37.             String sex = resultSet.getString(2);
  38.             String depart = resultSet.getString(3);
  39.             BigDecimal salary = resultSet.getBigDecimal(4);
  40.             System.out.println(name);
  41.             System.out.println(sex);
  42.             System.out.println(depart);
  43.             System.out.println(salary);
  44.             System.out.println("-----------------------");
  45.         }
  46.         //也可在getXxx(参数)参数位置写sql中的字段名
  47.         /*while (resultSet.next()) {
  48.             //6.2获取数据
  49.             String name = resultSet.getString("name");
  50.             String sex = resultSet.getString("sex");
  51.             String depart = resultSet.getString("depart");
  52.             BigDecimal salary = resultSet.getBigDecimal("salary");
  53.             System.out.println(name);
  54.             System.out.println(sex);
  55.             System.out.println(depart);
  56.             System.out.println(salary);
  57.             System.out.println("-----------------------");
  58.         }*/
  59.         //7.释放资源
  60.         resultSet.close();
  61.         stmt.close();
  62.         coon.close();
  63.     }
  64. }
复制代码
   通过获取数据库的数据封装到一个聚会合
1.创建一个类，与数据库数据类型相对应，创建一个该类的聚集
2.获取数据库数据
3.将获取的数据封装到类中
4.将封装好的类添加到聚集
  1. package com.practice.pojo;
  3. import java.math.BigDecimal;
  5. /**
  6. * @Author YJ
  7. * @Date 2023/7/20 10:27
  8. * Description:封装数据库数据的类
  9. */
  10. public class Account {
  11.     private String name;
  12.     private String sex;
  13.     private String depart;
  14.     private BigDecimal salary;
  16.     public Account() {
  17.     }
  19.     public Account(String name, String sex, String depart, BigDecimal salary) {
  20.         this.name = name;
  21.         this.sex = sex;
  22.         this.depart = depart;
  23.         this.salary = salary;
  24.     }
  26.     /**
  27.      * 获取
  28.      * @return name
  29.      */
  30.     public String getName() {
  31.         return name;
  32.     }
  34.     /**
  35.      * 设置
  36.      * @param name
  37.      */
  38.     public void setName(String name) {
  39.         this.name = name;
  40.     }
  42.     /**
  43.      * 获取
  44.      * @return sex
  45.      */
  46.     public String getSex() {
  47.         return sex;
  48.     }
  50.     /**
  51.      * 设置
  52.      * @param sex
  53.      */
  54.     public void setSex(String sex) {
  55.         this.sex = sex;
  56.     }
  58.     /**
  59.      * 获取
  60.      * @return depart
  61.      */
  62.     public String getDepart() {
  63.         return depart;
  64.     }
  66.     /**
  67.      * 设置
  68.      * @param depart
  69.      */
  70.     public void setDepart(String depart) {
  71.         this.depart = depart;
  72.     }
  74.     /**
  75.      * 获取
  76.      * @return salary
  77.      */
  78.     public BigDecimal getSalary() {
  79.         return salary;
  80.     }
  82.     /**
  83.      * 设置
  84.      * @param salary
  85.      */
  86.     public void setSalary(BigDecimal salary) {
  87.         this.salary = salary;
  88.     }
  90.     public String toString() {
  91.         return "Account{name = " + name + ", sex = " + sex + ", depart = " + depart + ", salary = " + salary + "}";
  92.     }
  93. }
复制代码
  1. package com.practice;
  3. import com.practice.pojo.Account;
  5. import java.math.BigDecimal;
  6. import java.sql.Connection;
  7. import java.sql.DriverManager;
  8. import java.sql.ResultSet;
  9. import java.sql.Statement;
  10. import java.util.ArrayList;
  12. /**
  13. * @Author YJ
  14. * @Date 2023/7/20 10:26
  15. * Description:ResultSet  封装到一个集合中
  16. */
  17. public class JDBCDemo7 {
  18.     public static void main(String[] args) throws Exception {
  19.         //1.注册驱动
  20.         //Class.forName("com.mysql.jdbc.Driver");
  21.         //2.获取连接
  22.         //用户名和密码就是mysql注册时自己的用户名和密码
  23.         //demo1表示要连接的数据库名
  24.         String url = "jdbc:mysql://127.0.0.1:3306/demo1?useSSL=false";
  25.         String username = "root";
  26.         String passWord = "123456";
  27.         //DriverManager.getConnection有一个返回值
  28.         Connection coon = DriverManager.getConnection(url, username, passWord);
  29.         //3.定义sql
  30.         String sql = "select * from emp";
  31.         //4.获取Statement对象
  32.         Statement stmt = coon.createStatement();
  33.         //5.执行sql
  34.         ResultSet resultSet = stmt.executeQuery(sql);
  35.         //创建集合
  36.         ArrayList<Account> list = new ArrayList<>();
  37.         //6.处理结果
  38.         //6.1光标向下移动，判断是否有数据
  39.         while (resultSet.next()) {
  40.             Account account = new Account();
  41.             //6.2获取数据
  42.             String name = resultSet.getString("name");
  43.             String sex = resultSet.getString("sex");
  44.             String depart = resultSet.getString("depart");
  45.             BigDecimal salary = resultSet.getBigDecimal("salary");
  46.             //赋值
  47.             account.setName(name);
  48.             account.setSex(sex);
  49.             account.setDepart(depart);
  50.             account.setSalary(salary);
  51.             //存入集合
  52.             list.add(account);
  53.         }
  54.         System.out.println(list);
  55.         //7.释放资源
  56.         resultSet.close();
  57.         stmt.close();
  58.         coon.close();
  59.     }
  60. }
复制代码
3.5PreparedStatement

   PreparedStatement作用：
1.预编译SQL语句并实行：防备SQL注入问题
SQL注入：是通过操纵输入来修改事先定义好的SQL语句，用以达到实行代码对服务器进行攻击的方法。
SQL注入演示：
  1. package com.practice;
  3. import com.practice.pojo.Account;
  5. import java.math.BigDecimal;
  6. import java.sql.Connection;
  7. import java.sql.DriverManager;
  8. import java.sql.ResultSet;
  9. import java.sql.Statement;
  10. import java.util.ArrayList;
  12. /**
  13. * @Author YJ
  14. * @Date 2023/7/20 10:26
  15. * Description:ResultSet  SQL注入演示
  16. */
  17. public class JDBCDemo8 {
  18.     public static void main(String[] args) throws Exception {
  19.         //1.注册驱动
  20.         //Class.forName("com.mysql.jdbc.Driver");
  21.         //2.获取连接
  22.         //用户名和密码就是mysql注册时自己的用户名和密码
  23.         //demo1表示要连接的数据库名
  24.         String url = "jdbc:mysql://127.0.0.1:3306/demo1?useSSL=false";
  25.         String username = "root";
  26.         String passWord = "123456";
  27.         Connection coon = DriverManager.getConnection(url, username, passWord);
  28.         String name = "afafafaf";
  29.         String depart = "' or '1' = '1";
  30.         String sql = "select * from emp where name = '"+name+"' and depart = '"+depart+"' ";
  31.         //获取stmt对象
  32.         Statement stmt = coon.createStatement();
  33.         //执行sql
  34.         ResultSet resultSet = stmt.executeQuery(sql);
  35.         //判断登录是否成功
  36.         if (resultSet.next()) {
  37.             System.out.println("有数据~");
  38.         } else {
  39.             System.out.println("无数据！");
  40.         }
  41.         //7.释放资源
  42.         resultSet.close();
  43.         stmt.close();
  44.         coon.close();
  45.     }
  46. }
复制代码

   1.预编译SQL并实行SQL语句
(1)获取PreparedStatement对象
//SQL语句中的参数使用?占位符替换
String sql = "select * from student where name = ? and age = ?";
//通过Connection对象获取，并传入对应的sql语句
PreparedStatement pstmt = coon.preparedStatement(sql);
(2)设置参数值
PreparedStatement 对象：setXxx(参数一，参数二)：给?赋值
(3)实行sql
exxcuteUpdate():/executeQuery();:不需要在通报sql
  1. package com.practice;
  3. import java.sql.*;
  5. /**
  6. * @Author YJ
  7. * @Date 2023/7/20 10:26
  8. * Description:ResultSet  解决SQL注入
  9. */
  10. public class JDBCDemo9 {
  11.     public static void main(String[] args) throws Exception {
  12.         //1.注册驱动
  13.         //Class.forName("com.mysql.jdbc.Driver");
  14.         //2.获取连接
  15.         //用户名和密码就是mysql注册时自己的用户名和密码
  16.         //demo1表示要连接的数据库名
  17.         String url = "jdbc:mysql://127.0.0.1:3306/demo1?useSSL=false";
  18.         String username = "root";
  19.         String passWord = "123456";
  20.         Connection coon = DriverManager.getConnection(url, username, passWord);
  21.         String name = "afafafaf";
  22.         String depart = "' or '1' = '1";
  23.         //定义sql
  24.         String sql = "select * from emp where name = ? and depart = ? ";
  25.         //获取对象
  26.         PreparedStatement prept = coon.prepareStatement(sql);
  27.         //设置?的值
  28.         prept.setString(1,username);
  29.         prept.setString(2,depart);
  30.         //执行sql
  31.         ResultSet resultSet = prept.executeQuery();
  32.         //判断登录是否成功
  33.         if (resultSet.next()) {
  34.             System.out.println("有数据~");
  35.         } else {
  36.             System.out.println("无数据！");
  37.         }
  38.         //7.释放资源
  39.         resultSet.close();
  40.         prept.close();
  41.         coon.close();
  42.     }
  43. }
复制代码

3.6PreparedStatement原理

   PreparedStatement利益：
1.预编译SQL,性能更高
2.防备SQL注入：将敏感字符进行转义
预编译功能开启：useServerPrepStmts=true
同时还要在mysql安装目录下的my.ini文件中设置一串代码:
  1. log-output=FILE
  2. general-log=1
  3. general_log_file="D:\MyApp\mysql.log"
  4. slow-query-log=1
  5. slow_query_log_file="D:\MyApp\mysql_slow.log"
  6. long_query_time=2
复制代码
  PreparedStatement原理：
1.在获取PreparedStatement对象时，将sql语句发送给mysql服务器进行检查、编译（很耗时）
2.实行时就不用在进行这些步骤了，速率很快
3.如果sql模板一样，则只需进行一次检查、编译
当预编译功能开启后，每次实行代码，都会在日志文件中记录。
  

四、数据库毗连池

4.1简介

   数据库毗连池是个容器，负责分配、管理数据库毗连（Connection）
它答应应用程序重复使用一个现有的数据库毗连，而不是重新建立一个
释放空间时间超过最大空闲时间的数据库毗连来制止因为没有释放数据库毗连而引起的数据库毗连遗漏
利益：
资源重用
提升系统响应速率
制止数据库毗连遗漏
  4.2数据库毗连池的实现

   标准接口：DataSource
官方提供的数据库毗连池标准接口，由第三方组织实现此接口。
功能：获取毗连
Connection getConnection()
常见的数据库毗连池
DBCP
C3P0
Druid
Druid(德鲁伊)
是阿里巴巴开源的数据库毗连池项目
功能强大，性能良好，时Java语言最好的数据毗连池之一
    1.导入druid.jar包，方法同mysql.jar包的导入
2.定义设置文件：
定义一个文件druid.properties并编写如下代码：
  1. driverClassName=com.mysql.jdbc.Driver
  2. url=jdbc:mysql///demo1useSSL=false&useServerPrepStmts=true
  3. username=root
  4. password=123456
  5. # 初始化连接数量
  6. initialSize=5
  7. # 最大连接数
  8. maxActive=10
  9. # 最大等待时间
  10. maxWait=3000
复制代码
  1. package com.practice.druid;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  5. import javax.sql.DataSource;
  6. import java.io.FileInputStream;
  7. import java.sql.Connection;
  8. import java.util.Properties;
  10. /**
  11. * @Author YJ
  12. * @Date 2023/7/20 12:44
  13. * Description:Druid 数据库连接池演示
  14. */
  15. public class DruidDemo1 {
  16.     public static void main(String[] args) throws Exception {
  17.         //加载配置文件
  18.         //获取连接池对象
  19.         Properties prop = new Properties();
  20.         prop.load(new FileInputStream("jdbc-7-20/src/druid.properties"));
  21.         DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  22.         //获取数据库连接
  23.         Connection coon = dataSource.getConnection();
  24.         System.out.println(coon);
  25.     }
  26. }
复制代码
总结

   经过本文的学习，我们可以初步的掌握JDBC编程，来实现java与数据库的毗连和管理，通过java实现对数据库的增删改查操纵，欢迎小同伴们点赞+评论，我会持续学习更新！！！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

金歌

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表