两万字速通JDBC

转x33g5p2x  于2022-02-18 转载在 其他  
字(19.3k)|赞(0)|评价(0)|浏览(391)

一、JDBC简介

1.1、JDBC概念

1.2、JDBC本质

1.3、JDBC好处

1.4、关系图示：

1.5、 MySQLjar包下载地址

一、DriverManager

1、注册驱动：

二、Connection

2.1、获取执sql对象

2.2、事务管理

  2.2.1、mysql事务管理

2.2.2、演示jdbc的事务

三、Statement

3.1、执行sql语句

四、ResultSet

ResultSet案例

五、PreparedStatement

5.1、PreparedStatement作用：

5.2、SQL注入

演示普通登录：

5.2.1、 sql注入演示：

5.3、PreparedStatement解决SQL注入

5.4、PrepareStatement原理

六、数据库连接池简介

6.1、数据库连接池优点

6.2、数据录库连接池实现

6.3、Driud使用步骤

七、完成商品品牌数据的增删改查操作

表的信息

1、查询所有 

运行结果： 

2、增加数据

乱码问题: 

3、修改数据

运行结果： 

4、删除数据

运行结果：​

一、JDBC简介

1.1、JDBC概念

①JDBC就是使用Java语言操作关系型数据录的一套API

②全称是(Java DataBase Connectivity),叫Java数据库连接。

1.2、JDBC本质

①官方（sun公司）定义的一套操作所有关系型数据库的规则，即为接口。

②各个数据库厂商去实现这套接口，提供数据库驱动jar包。

③我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

1.3、JDBC好处

①各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发不同的代码

②可随时替换底层数据库，访问数据库的Java代码基本不变

1.4、关系图示：

1.5、 MySQLjar包下载地址

MySQL :: MySQL Community Downloadshttps://dev.mysql.com/downloads/一般选择独立于平台的这个选项

①创建新的项目

②之后再建立一个模块

③在新建的的jdbc-demo模块中创建一个lib目录，将mysql的jar包复制粘贴到此处

④将刚才导入的jar包设置作用范围(右键jar包)

⑤在src下创建一个类

⑥ 类中：

  1. package com.jdbc;
  3. import com.mysql.jdbc.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.Statement;
  7. public class JDBCDemo {
  8.     public static void main(String[] args) throws Exception {
  9.         //1、注册驱动
  10.         Class.forName("com.mysql.jdbc.Driver");
  11.        //2、获取连接
  12.          //url的格式是："jdbc:mysql://mysql的ip:端口号/操作的数据库"
  13.         String url="jdbc:mysql://127.0.0.1:3306/kc_db01";
  14.         //username是你的mysql用户名
  15.         String username="root";
  16.         //password是你的mysql密码
  17.         String password="123456";
  18.         Connection conn= (Connection) DriverManager.getConnection(url, username, password);
  19.         //3、定义sql
  20.         String sql="update emp set salary=666 where ename='zhangsan'";
  21.         //4、获取执行sql的Statement对象
  22.         Statement stat=conn.createStatement();
  23.         //5、执行sql语句，count就是影响的行数
  24.         int count=stat.executeUpdate(sql);
  25.         //6处理结果
  26.         System.out.println("影响的行数:"+count);
  27.         //7、释放资源(先开后释放)
  28.         stat.close();
  29.         conn.close();
  30.     }
  31. }

数据库之前：

** 运行结果：**

** 运行之后数据库：**

一、DriverManager

DriverManager(驱动管理类)作用：
1、注册驱动

2、获取数据库连接

1、注册驱动：

  1. Class.forName("com.mysql.jdbc.Driver");

注册驱动的书写方法，表面上没有使用  DriverManager类，选中Driver，ctrl+b看源码可知

  1. package com.mysql.jdbc;
  3. import java.sql.DriverManager;
  4. import java.sql.SQLException;
  6. public class Driver extends NonRegisteringDriver implements java.sql.Driver {
  7.     public Driver() throws SQLException {
  8.     }
  10.     static {
  11.         try {
  12.             DriverManager.registerDriver(new Driver());
  13.         } catch (SQLException var1) {
  14.             throw new RuntimeException("Can't register driver!");
  15.         }
  16.     }
  17. }

它使用了 DriverManager.registerDriver（）的方法

在MySQL5之后的驱动包，可以省略注册驱动的步骤

自动加载jar包中的META-INF/services/java.sql.Driver文件的驱动类

2、获取连接
static Connection         getConnection(String url,String user,String password)

参数

1、url：连接路径
语法：jdbc:mysql://ip地址(域名):端口号/数据库名称？参数键值对1&参数键值对2....

举例：jdbc:mysql://127.0.0.1:3306/db1(本机127.0.0.1，本机域名：localhost)

 细节： 如果连接的是本机mysql服务器，并且mysql默认端口号是3306  ，则url可以简写为:jdbc:mysql://数据库名称？参数键值对如：jdbc:mysql:///db1

配置userSSL=false参数，禁用安全连接方式，解决警告提示

2、user:用户名

3、password：密码

解决警告提示：

?userSSL=false

  1. String url="jdbc:mysql://127.0.0.1:3306/db1？useSSL=false";

二、Connection

Connection（数据库连接对象）作用：

1、获取执行SQL的对象

2、管理事务

2.1、获取执sql对象

  • 普通执行SQL对象
    Statement   createStatement()

  • 预编译SQL的执行SQL对象：防止SQL注入
    PrepareStatement    prepareStatement(sql)

  • 执行存储过程对象
    CallableStatement   prepareCall(sql)

2.2、事务管理

    2.2.1、mysql事务管理

开启事务：BEGIN；/START  TRANSACTION(start transaction)

提交事务：COMMIT;

回滚事务：ROLLBACK;

(MySQL默认自动提交事务)

JDBC事务管理： 

   Connection接口中定义了3个对应的方法

开启事务:setAutoCommit(boolean autoCommit);true为自动提交事务，false为手动提交事务（开启事务）

提交事务：commit()

回滚事务：rollback()

2.2.2、演示jdbc的事务

复制前面弄过的类到包下

  1. package com.jdbc;
  3. import com.mysql.jdbc.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  9. public class JDBCConnectionDemo {
  10.     public static void main(String[] args) throws Exception {
  11.         //1、注册驱动
  12.         Class.forName("com.mysql.jdbc.Driver");
  13.        //2、获取连接
  14.          //url的格式是："jdbc:mysql://mysql的ip:端口号/操作的数据库"
  15.         String url="jdbc:mysql://127.0.0.1:3306/kc_db01";
  16.         //username是你的mysql用户名
  17.         String username="root";
  18.         //password是你的mysql密码
  19.         String password="123456";
  20.         Connection conn= (Connection) DriverManager.getConnection(url, username, password);
  21.         //3、定义sql
  22.         String sql1="update emp set salary=6666 where ename='zhangsan'";
  23.         String sql2="update emp set salary=6666 where ename='lisi'";
  24.         //4、获取执行sql的Statement对象
  25.         Statement stat=conn.createStatement();
  26.          
  27.       //选中要处理的异常部分，ctrl+alt+t快捷键生成
  28.         try {
  29.             //开启事务
  30.            conn.setAutoCommit(false);
  31.            //执行sql
  32.             int count1=stat.executeUpdate(sql1);
  33.             //处理结果
  34.             System.out.println("影响的行数:"+count1);
  36.             //执行时sql
  37.             int count2=stat.executeUpdate(sql2);
  38.             //处理结果
  39.             System.out.println("影响的行数:"+count2);
  41.             //提交事务
  42.             conn.commit();
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.             //回滚事务(回到开启事务之前，即什么也没处理前)
  46.              conn.rollback();
  47.         }finally {
  48.             //7、释放资源(先开后释放)
  50.             stat.close();
  51.             conn.close();
  52.         }
  54.     }
  55. }

运行之前数据库emp表：

运行结果：

运行之后数据库emp表：

try之中的发生了异常 ，就会 被catch捕获，发生回滚，回滚到还没有开启事务之前，就是数据没有修改之前，若是没有用事务，就会导致可能一个成功一个失败，这是我们不愿意看到的。** 启用了事务，用了回滚事务，可以保证多个事务要么同时成功，要么同时失败。**

三、Statement

Statemen作用：

3.1、执行sql语句

int  executeUpdate(sql): 执行DML(对数据的增删改)、**DDL(对表和库的增删改)**语句

返回值:(1)DML语句影响的行数（2）DDL语句执行后，执行成功也可能返回0

ResultSet   executeQuery（sql）:执行**DQL(对数据的查询操作)**语句

返回值：ResultSet结果对象

四、ResultSet

ResultSet(结果集对象)作用：

1.封装了DQL查询语句的结果
ResultSet  stmt.executeQuery(sql):执行DQL语句，返回ResultSet对象

获取查询结果

boolean   next():（1）将光标从当前位置向前移动一行（2）判断当前行是否是有效行

 返回值：当前行有数据返回true，当前没数据返回false。

xxx     getXxx(参数)：获取数据

  解释：xxx表示数据类型；如int  getInt(参数)；String getString(参数)；

  参数：对于int是列的编号，从1开始，对于String是列的名称。

使用步骤：

1、游标向下移动一行，并判断该行是否有数据：next()

2、获取数据：getXxx(参数)

示例：

  1. while(rs.next()){
  2.     rs.getXxx(参数);
  3. }

实例：

  1. package com.jdbc;
  3. import com.mysql.jdbc.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.ResultSet;
  7. import java.sql.Statement;
  9. public class JDBCDemo3_ResultSet {
  10.     public static void main(String[] args) throws Exception {
  11.         //1、注册驱动
  12.         Class.forName("com.mysql.jdbc.Driver");
  13.        //2、获取连接
  14.          //url的格式是："jdbc:mysql://mysql的ip:端口号/操作的数据库"
  15.         String url="jdbc:mysql://127.0.0.1:3306/kc_db01";
  16.         //username是你的mysql用户名
  17.         String username="root";
  18.         //password是你的mysql密码
  19.         String password="123456";
  20.         Connection conn= (Connection) DriverManager.getConnection(url, username, password);
  21.         //3、定义sql
  22.         String sql="select *from emp";
  23.         //4、获取执行sql的Statement对象
  24.         Statement stmt=conn.createStatement();
  25.         //5、执行sql语句
  26.         ResultSet rs=stmt.executeQuery(sql);
  27.         //6处理结果
  28.       while(rs.next()){
  29.           //获取数据 getXxx();括号中可以写所在行，也可以写列名
  30.           int id=rs.getInt(1);
  31.           String ename=rs.getString(2);
  32.           int salary=rs.getInt(3);
  33.           //另一种写法：写行的名称
  34. //          int id=rs.getInt("id");
  35. //          String ename=rs.getString("ename");
  36. //          int salary=rs.getInt("salary");
  37.           System.out.println(id);
  38.           System.out.println(ename);
  39.           System.out.println(salary);
  40.           System.out.println("-----------");
  41.       }
  42.         //7、释放资源(先开后释放)
  43.         rs.close();
  44.         stmt.close();
  45.         conn.close();
  47.     }
  48. }

数据库中emp表

运行之后：

 ResultSet案例

需求：查询account账户数据，封装为Account对象中，并且存储到ArrayList集合中

创建一个pojo包，用来存放对象的。

创建了一个类，提供getSet方法

  1. package com.pojo;
  3. public class Account {
  4.     private int id;
  5.     private String ename;
  6.     private int salary;
  8.     public int getId() {
  9.         return id;
  10.     }
  12.     public void setId(int id) {
  13.         this.id = id;
  14.     }
  16.     public String getEname() {
  17.         return ename;
  18.     }
  20.     public void setEname(String ename) {
  21.         this.ename = ename;
  22.     }
  24.     public int getSalary() {
  25.         return salary;
  26.     }
  28.     public void setSalary(int salary) {
  29.         this.salary = salary;
  30.     }
  31.     //为了更好的显示，重写toString()方法
  33.     @Override
  34.     public String toString() {
  35.         return "Account{" +
  36.                 "id=" + id +
  37.                 ", ename='" + ename + '\'' +
  38.                 ", salary=" + salary +
  39.                 '}'+"\n";
  40.     }
  41. }

jdbc包下创建的类中

  1. package com.jdbc;
  3. import com.mysql.jdbc.Connection;
  4. import com.pojo.Account;
  6. import java.sql.DriverManager;
  7. import java.sql.ResultSet;
  8. import java.sql.Statement;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. public class JDBCDemo4_ResultSet {
  13.     public static void main(String[] args) throws Exception {
  14.         //1、注册驱动
  15.         Class.forName("com.mysql.jdbc.Driver");
  16.        //2、获取连接
  17.          //url的格式是："jdbc:mysql://mysql的ip:端口号/操作的数据库"
  18.         String url="jdbc:mysql://127.0.0.1:3306/kc_db01";
  19.         //username是你的mysql用户名
  20.         String username="root";
  21.         //password是你的mysql密码
  22.         String password="123456";
  23.         Connection conn= (Connection) DriverManager.getConnection(url, username, password);
  24.         //3、定义sql
  25.         String sql="select *from emp";
  26.         //4、获取执行sql的Statement对象
  27.         Statement stmt=conn.createStatement();
  28.         //5、执行sql语句
  29.         ResultSet rs=stmt.executeQuery(sql);
  30.         //6处理结果
  31.         //创建集合对象
  32.         List<Account> list=new ArrayList<>();
  33.       while(rs.next()){
  34.           //创建Account对象
  35.           Account account=new Account();
  36.           //获取数据 getXxx();括号中可以写所在行，也可以写列名
  37.           int id=rs.getInt(1);
  38.           String ename=rs.getString(2);
  39.           int salary=rs.getInt(3);
  40.           //赋值数据
  41.           account.setId(id);
  42.           account.setEname(ename);
  43.           account.setSalary(salary);
  44.           list.add(account);
  45.       }
  46.         System.out.println(list);
  47.         //7、释放资源(先开后释放)
  48.         rs.close();
  49.         stmt.close();
  50.         conn.close();
  52.     }
  53. }

运行结果：

五、PreparedStatement

5.1、PreparedStatement作用：

1、预编译SQL语句并执行：预防SQL注入问题

5.2、SQL注入

SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法。

演示普通登录：

首先数据录kc_db1下的emp表为：

  1. package com.jdbc;
  3. import com.mysql.jdbc.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.ResultSet;
  7. import java.sql.Statement;
  9. public class JDBCDemo5_UserLogin {
  10.     public static void main(String[] args) throws Exception {
  12.        //2、获取连接
  13.          //url的格式是："jdbc:mysql://mysql的ip:端口号/操作的数据库"
  14.         String url="jdbc:mysql://127.0.0.1:3306/kc_db01";
  15.         //username是你的mysql用户名
  16.         String username="root";
  17.         //password是你的mysql密码
  18.         String password="123456";
  19.         Connection conn= (Connection) DriverManager.getConnection(url, username, password);
  20.            String name="zhangsan";
  21.            String pwd="1233";
  22.         //3、定义sql
  23.         String sql="select *from emp where ename='"+name+"'and password='"+pwd+"'" ;
  24.         System.out.println("这条SQL语句是:"+sql);
  25.         //4、获取执行sql的Statement对象
  26.         Statement stat=conn.createStatement();
  27.         //5、执行sql语句
  28.         ResultSet rs = stat.executeQuery(sql);
  29.         //6处理结果,rs有值说明查找成功
  30.       if(rs.next()){
  31.           System.out.println("登录成功");
  32.       }else{
  33.           System.out.println("登录失败");
  34.       }
  35.         //7、释放资源(先开后释放)
  36.         rs.close();
  37.         stat.close();
  38.         conn.close();
  40.     }
  41. }

运行结果：

输入其他(不成功的原因是数据库中没有账号密码为这个的)：

5.2.1、 sql注入演示：

对于这条sql语句来说不点在于密码，账号任意

  1. String name="随便写的名";
  2.  String pwd=" ' or '1'='1";

运行结果：

这条SQL语句是:select *from emp where ename='随便写的名'and password=' ' or  '1'='1'

** sql注入的本质就是改变原有的SQL语句，加入or之后1=1恒为真，所以这条语句就是true**

5.3、PreparedStatement解决SQL注入

①获取PreparedStatement对象

  1. //sql语句中的参数，使用？占位符代替
  2. String sql="select *from user where username=? and password=?";
  3. //通过Connection对象获取，并传入对应的sql语句
  4. PreparedStatement  pstmt=conn.prepareStatement(sql);

②设置参数

PreparedStatement对象：setXxx(参数1，参数2)：表示给参数1(?的位置)赋值为参数2

Xxx：数据类型；任意setInt(参数1，参数2)

参数：

  •    参数1：表示？的位置编号，从1开始
  •    参数2： ？的值

③执行sql

executeUpdate();/excuteQuery();括号内不需要传递sql。

创建类：

  1. package com.jdbc;
  3. import com.mysql.jdbc.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.sql.Statement;
  9. import java.util.Scanner;
  11. public class JDBCDemo5_UserLogin {
  12.     public static void main(String[] args) throws Exception {
  14.        //2、获取连接
  15.          //url的格式是："jdbc:mysql://mysql的ip:端口号/操作的数据库"
  16.         String url="jdbc:mysql://127.0.0.1:3306/kc_db01";
  17.         //username是你的mysql用户名
  18.         String username="root";
  19.         //password是你的mysql密码
  20.         String password="123456";
  21.         Connection conn= (Connection) DriverManager.getConnection(url, username, password);
  22.            String name="随便写的名";
  23.            String pwd=" ' or '1'='1";
  24.         //3、定义sql
  25.         String sql="select *from emp where ename=? and password=?" ;
  27.         //4、获取的PreparedStatement对象
  28.         PreparedStatement pstmt = conn.prepareStatement(sql);
  29.         //设置参数
  30.         pstmt.setString(1, name);
  31.         pstmt.setString(2, pwd);
  33.         //5、执行sql语句
  34.         ResultSet rs =pstmt.executeQuery();
  35.         System.out.println("这条SQL语句是:"+sql);
  36.         //6处理结果,rs有值说明查找成功
  37.       if(rs.next()){
  38.           System.out.println("登录成功");
  39.       }else{
  40.           System.out.println("登录失败");
  41.       }
  42.         //7、释放资源(先开后释放)
  43.         rs.close();
  44.        pstmt.close();
  45.         conn.close();
  47.     }
  48. }

** 运行结果：**

这样就防止了sql注入，setXxx会对传入的参数会进行转义，不会拼接成字符串而是' or\ ' 1' = ' 1'

输入正确的：

 5.4、PrepareStatement原理

PrepareStatement好处：

1、预编译SQL，性能更高

2、防止sql注入。

my.ini配置文件可以看到日志

  1. log-output=FILE 
  2. general-log=1
  3. general_log_file="D:\mysql.log" 
  4. slow-query-log=1
  5. slow_query_log_file="D:\mysql_slow.log" 
  6. long_query_time=2

预编译功能默认关闭

①：PreparedStatement预编译功能开启：userServerPrepStmts=true

在sql语句?之后书写参数

  1. String url="jdbc:mysql://127.0.0.1:3306/kc_db01"?userServerPrepStmts=true;

开启就会要prepare预编译： 

关闭之后就没有Prepare阶段

六、数据库连接池简介

①数据库连接池是个容器，负责分配管理数据库连接(Connection)

②他允许应用程序重复使用一个现有的数据录连接，而不是再重新建立一个(其实就是提前建立好连接之后直接用)

③释放空闲时间超过最大空闲时间的数据库链接来避免因为没有释放数据库连接而引起的数据库连接遗漏

6.1、数据库连接池优点

①资源重用（用完放回，而不释放）

②提升系统的响应速度（提前申请好了，要用是直接重连接池拿即可）

③避免数据录连接遗漏(某一资源超过最大时间强制会放回)

6.2、数据录库连接池实现

标准接口：DataSource

官方（SUN）提供的数据库连接池标准接口，由第三方组织实线这个接口

功能：获取连接

  1. Connection getConnection()

常见的数据库连接池：

DBCP

C3P0

Druid(德鲁伊)：Druid连接池是阿里巴巴开源的数据库连接池项目，功能强大，性能优秀，是Java语言最好的数据库连接池之一。

6.3、Driud使用步骤

1、导入Driud的jar包

2、定义配置文件

3、加载配置文件

4、获取数据库连接池对象

5、获取连接

1、导入Druid的jar包，直接赋值jar包到lib目录下即可

选中jar包右键选择添加库，选择jar的作用范围为模块即可
2、定义配置文件druid.properties

内容一般为：

  1. driverClassName=com.mysql.jdbc.Driver
  2. url=jdbc:mysql://127.0.0.1:3306/kc_db01?useSSL=false&useServerPrepStmts=true
  3. username=root
  4. password=123456
  5. #初始化连接数量
  6. initialSize=5
  7. #最大连接数量
  8. maxActive=10
  9. #最大等待时间
  10. maxWait=3000

直接赋值刚才写的配置文件druid.properties复制到src下

类下：

  1. package com.druid;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  5. import javax.sql.DataSource;
  7. import java.io.FileInputStream;
  8. import java.sql.Connection;
  9. import java.util.Properties;
  11. public class druidDemo {
  12.     public static void main(String[] args) throws Exception {
  13.         //1、导入jar包
  14.         //2、定义配置文件
  15.         //3、加载配置文件
  16.         Properties prop=new Properties();
  17.        //加载
  18.       prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
  19.         //4、获取连接池对象
  20.         DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  21.        //5、获取数据库连接Connection
  22.         Connection connection = dataSource.getConnection();
  24.      System.out.println(connection);
  25.      //打印当前路径
  26.         System.out.println(System.getProperty("user.dir"));//E:\jdbc
  27.     }
  28. }

运行结果: 

七、完成商品品牌数据的增删改查操作

查询：查询所有数据

添加：添加品牌

修改:根据id修改

删除：根据id删除

准备环境：

数据库表tb-brand

实体类Brand

测试用例

 表的信息

  1. drop table if exists tb_brand;
  2. -- 创建tb_brand表
  3. create table tb_brand
  4. ( 
  5. 	-- id 主键 
  6. 	id 	int primary key auto_increment, 
  7. 	-- 品牌名称
  8. 	brand_name varchar(20), 
  9. 	-- 企业名称
  10. 	company_name varchar(20), 
  11.   -- 排序字段
  12. 	ordered int, 
  13. 	-- 描述信息
  14. 	description varchar(100), 
  15.     -- 状态:0:禁用1启用
  16. 	`status` int 
  17. )
  18. character set utf8;
  19. -- 添加数据 
  20. insert into tb_brand (brand_name, company_name, ordered, description, `status`)
  21. values ('三只松鼠','三只松鼠股份有限公司',5,'好吃不上火',0), 
  22. ('华为','华为技术有限公司',100,'华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界',1),
  23. ('小米','小米科技有限公司', 50,'are you ok', 1);
  24. SELECT * FROM tb_brand;

整列编辑：alt+鼠标左键

快捷生成方法：alt+insert

1、查询所有 

在pojo包下创建一个类(pojo就是用来存放对象的Brand)：

  1. package com.pojo;
  3. public class Brand {
  4.     // id 主键
  5.     private Integer id;
  6.     // 品牌名称
  7.     private String brand_name;
  8.     // 企业名称
  9.     private String company_name;
  10.     // 排序字段
  11.     private Integer ordered;
  12.     // 描述信息
  13.     private String description;
  14.     // 状态:0:禁用1启用
  15.     private Integer status;
  17.     public Integer getId() {
  18.         return id;
  19.     }
  21.     public void setId(Integer id) {
  22.         this.id = id;
  23.     }
  25.     public String getBrand_name() {
  26.         return brand_name;
  27.     }
  29.     public void setBrand_name(String brand_name) {
  30.         this.brand_name = brand_name;
  31.     }
  33.     public String getCompany_name() {
  34.         return company_name;
  35.     }
  37.     public void setCompany_name(String company_name) {
  38.         this.company_name = company_name;
  39.     }
  41.     public Integer getOrdered() {
  42.         return ordered;
  43.     }
  45.     public void setOrdered(Integer ordered) {
  46.         this.ordered = ordered;
  47.     }
  49.     public String getDescription() {
  50.         return description;
  51.     }
  53.     public void setDescription(String description) {
  54.         this.description = description;
  55.     }
  57.     public Integer getStatus() {
  58.         return status;
  59.     }
  61.     public void setStatus(Integer status) {
  62.         this.status = status;
  63.     }
  65.     @Override
  66.     public String toString() {
  67.         return "Brand{" +
  68.                 "id=" + id +
  69.                 ", brand_name='" + brand_name + '\'' +
  70.                 ", company_name='" + company_name + '\'' +
  71.                 ", ordered='" + ordered + '\'' +
  72.                 ", description='" + description + '\'' +
  73.                 ", status=" + status +
  74.                 '}'+"\n";
  75.     }
  76. }

因为status是状态0或1，如果我们弄int类型，默认值是0，而用Integer包装类默认值则是null，符合我们的要求。

新建一个example创建一个BrandText类

  1. package com.example;
  3. import com.alibaba.druid.pool.DruidDataSourceFactory;
  4. import com.pojo.Brand;
  5. import org.junit.Test;
  7. import javax.sql.DataSource;
  8. import java.io.FileInputStream;
  9. import java.sql.Connection;
  10. import java.sql.PreparedStatement;
  11. import java.sql.ResultSet;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14. import java.util.Properties;
  16. /**
  17.  * 品牌数据的增删改查
  18.  */
  19. public class BrandText {
  20.     /**
  21.      * 查询所有的
  22.      * 1、SQL:select*from tb_brand
  23.      * 2、参数：不需要
  24.      * 3、结果：List<Brand>
  25.      */
  26.     @Test
  27.     public void textSelectAll() throws Exception{
  28.     //1、获取Connection连接对象
  29.         Properties prop=new Properties();
  30.         //加载
  31.         prop.load(new FileInputStream("E://JDBC/jdbc-demo/src/druid.properties"));
  32.         //获取连接池对象
  33.         DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  34.         //获取数据库连接Connection
  35.         Connection conn = dataSource.getConnection();
  36.     //2、定义SQL
  37.         String sql="select*from tb_brand";
  38.     //3、获取pstmt对象
  39.         PreparedStatement pstmt=conn.prepareStatement(sql);
  40.     //4、设置参数
  41.     //5、执行sql
  42.         ResultSet rs=pstmt.executeQuery();
  43.     //6、处理结果List<Brand>  封装Brand对象，装载到List集合
  44.         //创建List集合对象
  45.         List<Brand> list=new ArrayList<>();
  46.         Brand brand=null;
  47.         while(rs.next()){
  48.             //获取数据
  49.             int id = rs.getInt("id");//快捷键ctrl+alt+v生成左边
  50.             String brandName = rs.getString("brand_name");
  51.             String companyName = rs.getString("company_name");
  52.             int ordered = rs.getInt("ordered");
  53.             String description = rs.getString("description");
  54.             int status = rs.getInt("status");
  55.             //封装Brand对象
  56.              brand=new Brand();
  57.             brand.setId(id);
  58.             brand.setBrand_name(brandName);
  59.             brand.setCompany_name(companyName);
  60.             brand.setOrdered(ordered);
  61.             brand.setDescription(description);
  62.             brand.setStatus(status);
  63.             list.add(brand);
  64.         }
  65.         System.out.println(list);
  66.      //7、释放资源
  67.         rs.close();
  68.         pstmt.close();
  69.         conn.close();
  70.     }
  71. }

运行结果： 

2、增加数据

  1. /**
  2.      * 添加
  3.      * SQL:insert into tb_brand (brand_name, company_name, ordered, description, status)values(?,?,?,?,?);
  4.      * 参数是除了id之外的所有参数信息
  5.      * 结果：boolean
  6.      * @throws Exception
  7.      */
  8.     @Test
  9.       public void textAdd()throws Exception{
  10.         /*
  11.         模拟页面提交的参数
  12.          品牌名称[]'
  13.         */
  14.         String brand_name="阿里巴巴";
  15.         // 企业名称
  16.            String company_name="阿里巴巴";
  17.         // 排序字段
  18.            int ordered=1;
  19.         // 描述信息
  20.            String description="知名top企业";
  21.         // 状态:0:禁用1启用
  22.            int status=1;
  24.         //1、获取Connection连接对象
  25.         Properties prop=new Properties();
  26.         //加载
  27.         prop.load(new FileInputStream("E://JDBC/jdbc-demo/src/druid.properties"));
  28.         //获取连接池对象
  29.         DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  30.         //获取数据库连接Connection
  31.         Connection conn = dataSource.getConnection();
  32.         //2、定义SQL
  33.         String sql="insert into tb_brand (brand_name, company_name, ordered, description, status)values(?,?,?,?,?)";
  34.         //3、获取pstmt对象
  35.         PreparedStatement pstmt=conn.prepareStatement(sql);
  36.         //4、设置参数
  37.         pstmt.setString(1, brand_name);//ctrl+b快速复制
  38.         pstmt.setString(2, company_name);
  39.         pstmt.setInt(3, ordered);
  40.         pstmt.setString(4, description);
  41.         pstmt.setInt(5, status);
  42.         //5、执行sql
  43.         int count = pstmt.executeUpdate();
  44.         System.out.println(count>0);
  46.         //7、释放资源
  48.         pstmt.close();
  49.         conn.close();
  50.     }

乱码问题: 

我们运行之后发查询数据库发现乱码了，此时说明编码不一致，只需要在配置文件druid.properties中加入：

  1. characterEncoding=utf8

加完之后运行：

3、修改数据

  1. @Test
  2.     public void textUpdate()throws Exception{
  3.         /*
  4.         模拟页面提交的参数
  5.          品牌名称[]'
  6.         */
  7.         String brand_name="一本正经";
  8.         // 企业名称
  9.         String company_name="一本";
  10.         // 排序字段
  11.         int ordered=666;
  12.         // 描述信息
  13.         String description="心心比心";
  14.         // 状态:0:禁用1启用
  15.         int status=1;
  16.         int id=3;
  18.         //1、获取Connection连接对象
  19.         Properties prop=new Properties();
  20.         //加载
  21.         prop.load(new FileInputStream("E://JDBC/jdbc-demo/src/druid.properties"));
  22.         //获取连接池对象
  23.         DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  24.         //获取数据库连接Connection
  25.         Connection conn = dataSource.getConnection();
  26.         //2、定义SQL
  27.         String sql="update tb_brand set brand_name=?,company_name=?,ordered=?,description=?,status=? where id=?";
  28.         //3、获取pstmt对象
  29.         PreparedStatement pstmt=conn.prepareStatement(sql);
  30.         //4、设置参数
  31.         pstmt.setString(1, brand_name);//ctrl+b快速复制
  32.         pstmt.setString(2, company_name);
  33.         pstmt.setInt(3, ordered);
  34.         pstmt.setString(4, description);
  35.         pstmt.setInt(5, status);
  36.         pstmt.setInt(6, id);
  37.         //5、执行sql
  38.         int count = pstmt.executeUpdate();
  39.         System.out.println(count>0);
  41.         //7、释放资源
  43.         pstmt.close();
  44.         conn.close();
  45.     }

**运行结果： **

** 数据库中的数据变化：**

 4、删除数据

  1. /**
  2.      * 删除数据的sql为delete from 表名 where 删除条件
  3.      * @throws Exception
  4.      */
  5.     @Test
  6.     public void textDelete()throws Exception{
  8.         //1、获取Connection连接对象
  9.         Properties prop=new Properties();
  10.         //加载
  11.         prop.load(new FileInputStream("E://JDBC/jdbc-demo/src/druid.properties"));
  12.         //获取连接池对象
  13.         DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
  14.         //获取数据库连接Connection
  15.         Connection conn = dataSource.getConnection();
  16.         //2、定义SQL
  17.         String sql="delete from tb_brand where id=3";
  18.         //3、获取pstmt对象
  19.         PreparedStatement pstmt=conn.prepareStatement(sql);
  21.         //5、执行sql
  22.         int count = pstmt.executeUpdate();
  23.         System.out.println("删除"+(count>0));
  25.         //7、释放资源
  27.         pstmt.close();
  28.         conn.close();
  29.     }

运行结果：

数据库对比图;

后面也可以通过前端回传数据到后端接收来使用数据

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_60719453/article/details/122860388

内容来源于网络，如有侵权，请联系作者删除！

JavasqlmysqljdbcJDBC从初识到掌握

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    目录

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com