1.JDBC的概述:
在开发中,我们使用的是java语言,那么必须要掌握用java语言来操作数据库,建立数据库的连接,接下来我们一起来学习JDBC.
—
ps:前置条件:JavaSE,Mysql
JDBC的概述:
JDBC 就是使Java语言操作关系型数据库的一套API.
全称:(Java DataBase Connectivity)Java数据库连接.
Java就是调用一套标准的接口,一个规范,使我们使用同一套代码操作不同的数据库.JDBC中定义了所有操作关系型数据库的规则。众所周知 接口是无法直接使用的，我们需要使用接口的实现类，而这套实现 类（称之为：驱动）就由各自的数据库厂商给出。
我们这里使用的驱动是:
mysql-connector-j-8.0.33.jar
JDBC本质:
-
官方（sun公司）定义的一套操作所有关系型数据库的规则，即 接口;
-
各个数据库厂商去实现这套接口，提供数据库驱动jar包
-
我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动 jar包中的实现类
2.JDBC的连接过程:
IDEA(Java)------------(Connection)------------Mysql--------Navicate
-
在Java项目下创建一个lib文件夹存放Mysql的驱动**(导包)**:
-
右键单击jar包,选择Add As Library:
-
选择到当前模块就可以了:
点击Ok就成功导入了Mysql的驱动了.
注意:Mysql的驱动的版本一定要正确,我最开始是5.x的版本,我导入后,进行后面的连接,会给我报无法连接到数据的错误:Exception in thread “main” com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create connection to database server. at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) …,这个错误是因为版本不一致,我使用Navicat for mysql 连接没有问题，但是一用项目连接就出现上面错误，造成这个错误的主要原因是安装的是mysql8.0版本，而项目使用的驱动包是5.1版本，将项目驱动版本改成8.0.11成功解决了此问题.
转载自[mysql版本问题]([com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create connection to_Yeah-小海的博客-CSDN博客](https://blog.csdn.net/zht741322694/article/details/82464024?ops_request_misc=%7B%22request%5Fid%22%3A%22169556158216800215087134%22%2C%22scm%22%3A%2220140713.130102334.pc%5Fall.%22%7D&request_id=169556158216800215087134&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allfirst_rank_ecpm_v1~rank_v31_ecpm-1-82464024-null-null.142v94insert_down1&utm_term=Exception in thread main com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException%3A Could not create connection to database server. at sun.reflect.NativeConstructorAccessorImpl.newInstanc&spm=1018.2226.3001.4187)).
3.代码层面的连接:
1.注册驱动:
//1.注册驱动:(可省略)
Class.forName("com.mysql.cj.jdbc.Driver");
对于现在我和刚学完Java基础的那你是不是很熟悉这局代码,这里是反射获取Class实例的一种方法.前提是已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取.
2.获取连接:
//2.获取连接(如果连接的是本地mysql并且端口号是3306,则简化写:)
String url="jdbc:mysql:///exer";
String userName="root";
String passwd="123456";
Connection conn = DriverManager.getConnection(url, userName, passwd);
//3.定义sql语句
String sql="update tb_user set age=20 where id=2";
//4.获取执行sql对象
Statement statement = conn.createStatement();
//5.执行sql
int count = statement.executeUpdate(sql);//受影响的行数
//6.处理结果
System.out.println(count);
//7.释放资源
statement.close();
conn.close();
4.API的详解:
DriverManager（驱动管理类）作用：
主要就是这两个静态方法很重要:
getConnection(String url, String user, String password)- registerDriver(Driver driver)
我们查询MySQL提供的Driver类，看它是如何实现的，源码如 下：
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
public Driver() throws SQLException {
}
static {
try {
DriverManager.registerDriver(new Driver());
} catch (SQLException var1) {
throw new RuntimeException("Can't register driver!");
}
}
}
Driver类里面是有一个静态代码块的,是随着类的加载而加载的,静态代码块里面是:
DriverManager.registerDriver(new Driver());
所以我们在建立数据库的连接时,Driver类已经自动给我们注册驱动了,我们可以省略如下代码:
Class.forName("com.mysql.cj.jdbc.Driver");//注册驱动
获取连接的方法:
Connection conn = DriverManager.getConnection(url, userName, passwd);
参数说明:
- url ： 连接路径;
语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参 数键值对1&参数键值对2… 示例：jdbc:mysql://127.0.0.1:3306/db1 细节： 如果连接的是本机mysql服务器，并且mysql服务默 认端口是3306，则url可以简写为：jdbc:mysql:///数 据库名称?参数键值对 配置 useSSL=false 参数，禁用安全连接方式，解决 警告提示.
- user ：用户名
- password:密码
Connection:
Connection（数据库连接对象）作用：
- 获取执行 SQL 的对象 ;
- 管理事务
我还没接触第一个,就先说第二个事务管理吧
先回顾一下MySQL事务管理的操作：
- 开启事务 ： BEGIN; 或者 START TRANSACTION;
- 提交事务 ： COMMIT;
- 回滚事务 ： ROLLBACK;
ps:MySQL默认是自动提交事务
接下来学习JDBCd对应的事务管理的方法。
//开启事务
conn.setAutoCommit(false);
//提交事务
conn.commit();
//回滚事务
conn.rollback();
我们将上面的完整流程加入事务,并且增加一条sql更新语句,事务具有原子性,要么都执行,要么都不执行,当出现错误,就回滚事务,所谓我们会将事务操作写在try-catch中去捕获错误:
数据库在执行代码之前的数据:
我们在java 中的更新操作语句是:
String sql="update tb_user set age=50 where id=2";
String sql1="update tb_user set age=50 where id=6";
加入事务后的完整代码:
//1.注册驱动:(可省略)
// Class.forName("com.mysql.cj.jdbc.Driver");
//2.获取连接(如果连接的是本地mysql并且端口号是3306,则简化写:)
String url="jdbc:mysql:///exer";
String userName="root";
String passwd="123456";
Connection conn = DriverManager.getConnection(url, userName, passwd);
//3.定义sql语句
String sql="update tb_user set age=50 where id=2";
String sql1="update tb_user set age=50 where id=6";
//4.获取执行sql对象
Statement statement = conn.createStatement();
try {
//开启事务
conn.setAutoCommit(false);
//5.执行sql
int count = statement.executeUpdate(sql);//受影响的行数
//6.处理结果
System.out.println(count);
//5.执行sql
int a=3/0;
int count1 = statement.executeUpdate(sql1);
//6.处理结果
System.out.println(count1);
//提交事务
conn.commit();//这里就是使用sql语句数据表中有几行会受影响.
} catch (Exception throwables) {
//回滚事务
conn.rollback();
throwables.printStackTrace();
}
//7.释放资源
statement.close();
conn.close();
}
返回count:
数据库的数据:
- 我们可以人为的在执行sql语句中故意出错,比如int i=3/0那么我们的事务就会回滚,执行catch里面的代码,我们的数据库的数据也不会改变!
- 那么我们不使用事务,且sql有错误,结果是张三的年龄为50,王勇的年龄不会改变,并且java会抛出异常.
Statement:
Statement对象的作用就是用来执行SQL语句。而针对不同类型的 SQL语句使用的方法也不一样。
-
执行DDL,DML语句
对数据表,库的操作,增(insert/create),删(delete/drop),改(update).
-
执行DQL语句
该方法涉及到了 ResultSet 对象,我们下一个APL详解就是它.对数据查询的操作(select)
当前我们数据库的数据如下:
表数据
数据库:
执行代码:
public static void main(String[] args) throws Exception {
//1.注册驱动:(可省略)
// Class.forName("com.mysql.cj.jdbc.Driver");
//2.获取连接(如果连接的是本地mysql并且端口号是3306,则简化写:)
String url="jdbc:mysql:///exer";
String userName="root";
String passwd="123456";
Connection conn = DriverManager.getConnection(url, userName, passwd);
//3.定义sql语句
//DML
String sql="update tb_user set age=20 where id=2";
//DDL
String sql1="drop database tb2";
//4.获取执行sql对象
Statement statement = conn.createStatement();
//5.执行sql
int count = statement.executeUpdate(sql);//受影响的行数
int count1 = statement.executeUpdate(sql1);//执行成功,默认为0
//6.处理结果
System.out.println(count);
System.out.println(count1);
if (count>0){
System.out.println("执行成功!");
}else {
System.out.println("执行失败!");
}
//7.释放资源
statement.close();
conn.close();
}
执行结果:
数据库数据情况:
ps以后开发很少使用java代码操作DDL语句(经典白雪哈哈).
ResultSet
执行DQL语句,查询到数据库表中的数据,返回的一个数据结果集.
ResultSet（结果集对象）作用:
- 封装了SQL查询语句的结果。
而执行了DQL语句后就会返回该对象，对应执行DQL语句的方法如 下：
//获取执行sql对象
Statement statement = conn.createStatement();
//执行sql
ResultSet resultSet = statement.executeQuery(sql);
那么我们就需要从 ResultSet 对象中获取我们想要的数据。 ResultSet 对象提供了操作查询结果数据的方法，如下：
boolean next();
- 将光标从当前位置向前移动一行
- 判断当前行是否为有效行
方法返回值说明：
true ： 有效航，当前行有数据
false ： 无效行，当前行没有数据
xxx getXxx(参数)：获取数据:
xxx : 数据类型；如： int getInt(参数) ；String getString(参 数)
参数
- int类型的参数：列的编号，从1开始
- String类型的参数： 列的名称
如下图为执行SQL语句后的结果(next()的执行过程):
一开始光标指定于第一行前，如图所示红色箭头指向于表头行。当 我们调用了 next() 方法后，光标就下移到第一行数据，并且方法 返回true，此时就可以通过 getInt(“id”) 获取当前行id字段的 值，也可以通过 getString(“name”) 获取当前行name字段的 值。如果想获取下一行的数据，继续调用 next() 方法，以此类推。
代码实现:
这是当前数据库表中的数据:
执行代码:
public static void main(String[] args) throws Exception {
//1.注册驱动:(可省略)
// Class.forName("com.mysql.cj.jdbc.Driver");
//2.获取连接(如果连接的是本地mysql并且端口号是3306,则简化写:)
String url="jdbc:mysql:///exer";
String userName="root";
String passwd="123456";
Connection conn = DriverManager.getConnection(url, userName, passwd);
//3.定义sql语句
String sql="select * from tb_user";
//4.获取执行sql对象
Statement statement = conn.createStatement();
//5.执行sql
ResultSet resultSet = statement.executeQuery(sql);
//6.处理结果,遍历resultSet中的所有数据
//6.1光标向下移动一行,并且判断当前行是否有数据
// while (resultSet.next()){
//通过列索引获取数据,从1开始
// int id = resultSet.getInt(1);
// String name = resultSet.getString(2);
// int age = resultSet.getInt(3);
// String sex = resultSet.getString(4);
// String hobby = resultSet.getString(5);
//
// System.out.println(id);
// System.out.println(name);
// System.out.println(age);
// System.out.println(sex);
// System.out.println(hobby);
//
//
// System.out.println("___________________________");
// }
while (resultSet.next()){
//通过列名称(数据库目标表的列名称)获取数据
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
String sex = resultSet.getString("sex");
String hobby = resultSet.getString("hobby");
System.out.println(id);
System.out.println(name);
System.out.println(age);
System.out.println(sex);
System.out.println(hobby);
System.out.println("___________________________");
}
//7.释放资源
resultSet.close();
statement.close();
conn.close();
}
执行结果:
接下来我们结合实例练习一下:
- 需求：查询account账户表数据，封装为Account对象中，并且 存储到ArrayList集合中
操作过程:
该图是来着黑马jdbc资料图,具体数据库表的数据根据上面的数据情况.
代码实现:
1.需要创建一个Account类,里面封装好数据库列名的数据
package pojo;
public class Account {
//顺序和数据库列名顺序一样
private int id;
private String name;
private int age;
private String sex;
private String hobby;
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", hobby='" + hobby + '\'' +
'}';
}
}
2.获取数据并输入:
public void testResultSet() throws Exception{
//1.注册驱动:(可省略)
// Class.forName("com.mysql.cj.jdbc.Driver");
//2.获取连接(如果连接的是本地mysql并且端口号是3306,则简化写:)
String url="jdbc:mysql:///exer";
String userName="root";
String passwd="123456";
Connection conn = DriverManager.getConnection(url, userName, passwd);
//3.定义sql语句
String sql="select * from tb_user";
//4.获取执行sql对象
Statement statement = conn.createStatement();
//5.执行sql
ResultSet resultSet = statement.executeQuery(sql);
//创建集合
List<Account> list=new ArrayList<>();
//6.处理结果
//6.1光标向下移动一行,并且判断当前行是否有数据,有则为true,没有则为false
while (resultSet.next()){
//创建对象
Account account=new Account();
//通过列名称获取数据
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age");
String sex = resultSet.getString("sex");
String hobby = resultSet.getString("hobby");
//创建对象
account.setId(id);
account.setName(name);
account.setAge(age);
account.setSex(sex);
account.setHobby(hobby);
//存入集合
list.add(account);
}
System.out.println(list);
//7.释放资源
resultSet.close();
statement.close();
conn.close();
}
执行结果:
PreparedStatement
- 作用:预编译SQL语句并执行：预防SQL注入问题
什么是SQL注入:
SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达 到执行代码对服务器进行攻击的方法。
演示SQL注入:
学习资料来自黑马程序员JDBC课程资料
首先修改资料中的配置文件(application.properties),根据自己mysql账户修改:
spring.datasource.username=root
spring.datasource.password=123456//根据自己修改用户名和密码
-
在自己的MYSQL中创建一个名为test的数据库
-
create database test;
-
在当前文件夹单击右键,进入命令行模式,输入java -jar ./sql.jar运行jar包:
-
-
此时就运行起来了,看到started…就成功了.(我还没学到SpringBoot哈哈).
-
运行后,我们可以在数据库test中看到两张表:
-
-
接下来在浏览器的地址栏输入 localhost:8080/login.html 就能 看到如下页面:
-
-
我们就可以在如上图中输入用户名和密码进行登陆。用户名和密码 输入正确就登陆成功，跳转到首页。用户名和密码输入错误则给出 错误提示，如下图:
-
-
登录进去的界面:
-
-
登录失败:
-
-
可以看一看上面数据库中的两张表,会发现,user表中就是用户名和登录密码的信息,不匹配就登录失败,登录成功后就是product表中的数据.
-
但是我可以通过输入一些特殊的字符登陆到首页。 用户名随意写，密码写成 ’ or ‘1’ ='1
-
-
这就是SQL注入漏洞，也是很危险的。当然现在市面上的系统都不 会存在这种问题了，所以大家也不要尝试用这种方式去试其他的系统。
-
那么该如何解决呢？这里就可以将SQL执行对象 Statement 换成 PreparedStatement 对象。
代码演示模拟SQL注入问题:
正常登录代码:
public void testLogin() throws Exception {
String URL="jdbc:mysql:///exer?useSSL=false";
String name="root";
String passwd="123456";
//获取连接
Connection connection = DriverManager.getConnection(URL, name, passwd);
//获取用户输入 用户名和密码
String userName="zhangsan";
String pwd="123";
//定义sql语句
String sql="select * from tb_user1 where username = '"+userName+"' and passwd ='"+pwd+"'";//字符串拼接
//获取sql对象
Statement statement = connection.createStatement();
//执行sql语句
ResultSet resultSet = statement.executeQuery(sql);
//判断登录是否成功
if (resultSet.next()){
System.out.println("登录成功!");
} else {
System.out.println("登录失败!!");
}
//释放资源
resultSet.close();
statement.close();
connection.close();
}
登录成功:
SQL注入登录:
public void testLogin_Injext() throws Exception {
String URL="jdbc:mysql:///exer?useSSL=false";
String name="root";
String passwd="123456";
//获取连接
Connection connection = DriverManager.getConnection(URL, name, passwd);
//获取用户输入 用户名和密码
String userName="jihfhiahfh";//随便乱输入的
String pwd="' or '1' = '1";//密码就不是123,但是可以登录成功
//定义sql语句
String sql="select * from tb_user1 where username = '"+userName+"' and passwd ='"+pwd+"'";//拼接字符串是sql注入的问题所在
System.out.println(sql);
//获取sql对象
Statement statement = connection.createStatement();
//执行sql语句
ResultSet resultSet = statement.executeQuery(sql);
//判断登录是否成功
if (resultSet.next()){
System.out.println("登录成功!");
} else {
System.out.println("登录失败!!");
}
//释放资源
resultSet.close();
statement.close();
connection.close();
}
密码就不是123,但是可以登录成功:
所有我们就需要解决这个用户密码错误还登录成功的现象,为啥会错误?主要就是sql语句里字符串的拼接:
String sql="select * from tb_user1 where username = '"+userName+"' and passwd ='"+pwd+"'"
从上面语句可以看出条件 username = ‘sjdljfld’ and password = ‘’ 不管是否满足，而 or 后面的 ‘1’ = ‘1’ 是始终 满足的，最终条件是成立的，就可以正常的进行登陆了。
我们刚刚打印的sql语句变成了
select * from tb_user1 where username = 'jihfhiahfh' and passwd ='' or '1' = '1'
再数据库上去看看:
所以我们就要防止这个字符串的拼接,接下来我们来学习PreparedStatement对象.
PreparedStatement概述:
作用:
预编译SQL语句并执行：预防SQL注入问题.
获取 PreparedStatement 对象:
//定义sql语句
//sql语句中的参数值,使用?占用符替代
String sql="select * from tb_user1 where username=? and passwd=?";
//获取执行sql对象
PreparedStatement preparedStatement = connection.prepareStatement(sql);
设置参数值:
上面的sql语句中参数使用 ? 进行占位，在之前之前肯定要设置 这些 ? 的值。
PreparedStatement对象：setXxx(参数1，参数2)：给 ? 赋 值
- Xxx：数据类型 ； 如 setInt (参数1，参数2)
- 参数：
- 参数1： ？的位置编号，从1 开始
- 参数2： ？的值
//设置SQL语句中?的值
preparedStatement.setString(1,userName);//参数1表示sql语句中第一个?所代表数据(数据库的表中的列名)
preparedStatement.setString(2,pwd);//参数2表示sql语句中第二个?所代表数据(数据库的表中的列名)
执行SQL语句:
//执行sql语句
//不需要传递参数sql了
ResultSet resultSet = preparedStatement.executeQuery();
完整代码:
public void testPreparedStatement() throws Exception {
String URL="jdbc:mysql:///exer?useSSL=false";
String name="root";
String passwd="123456";
//获取连接
Connection connection = DriverManager.getConnection(URL, name, passwd);
//获取用户输入 用户名和密码
String userName="zhangsan";//随便乱输入的
String pwd="' or '1' = '1";
//定义sql语句
//sql语句中的参数值,使用?占用符替代
String sql="select * from tb_user1 where username=? and passwd=?";
//获取执行sql对象
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//设置?的值
preparedStatement.setString(1,userName);
preparedStatement.setString(2,pwd);
//执行sql语句
//不需要传递参数sql了
ResultSet resultSet = preparedStatement.executeQuery();
//判断登录是否成功
if (resultSet.next()){
System.out.println("登录成功!");
} else {
System.out.println("登录失败!!");
}
//释放资源
resultSet.close();
preparedStatement.close();
connection.close();
}
运行代码,就会登录失败!就防止了SQL的注入,我们主要就是修改了SQL语句,然后用PreparedStatment设置SQL中?的参数值,然后运行SQL就可以了.
那么PreparedStatement又是如何解决的呢？它是将特殊字符进行了转 义，转义的SQL如下：
select * from tb_user1 where username = 'jihfhiahfh' and passwd ='\' or \'1\' = \'1';//将单引号'转义了,就防止了sql的注入,防止了字符串的拼接.
PreparedStatement原理:
PreparedStatement 好处：
- 预编译SQL，性能更高
- 防止SQL注入：将敏感字符进行转义
Java代码操作数据库流程如图所示：
- 将sql语句发送到MySQL服务器端
- MySQL服务端会对sql语句进行如下操作
- 检查SQL语句,的语法是否正确。
- 编译SQL语句。将SQL语句编译成可执行的函数。 检查SQL和编译SQL花费的时间比执行SQL的时间还要长。如 果我们只是重新设置参数，那么检查SQL语句和编译SQL语 句将不需要重复执行。这样就提高了性能。
- 执行SQL语句
SQL要执行预编译功能需要开启,默认是关闭的
在代码中编写url时需要加上以下参数。而我们之前根本就没有 开启预编译功能，只是解决了SQL注入漏洞。
// useServerPrepStmts=true 参数开启预编译功能
String url = "jdbc:mysql:///exer?
useSSL=false&useServerPrepStmts=true";
小结:
- 在获取PreparedStatement对象时，将sql语句发送给mysql 服务器进行检查，编译（这些步骤很耗时）
- 执行时就不用再进行这些步骤了，速度更快
- 如果sql模板一样，则只需要进行一次检查、编译
数据库连接池:
1.数据库连接池简介:
-
数据库连接池是个容器，负责分配、管理数据库连接 (Connection)
-
它允许应用程序重复使用一个现有的数据库连接，而不是再 重新建立一个；
-
释放空闲时间超过最大空闲时间的数据库连接来避免因为没 有释放数据库连接而引起的数据库连接遗漏
-
好处
1.资源重用
2.提升系统响应速度
3.避免数据库连接遗漏
之前我们代码中使用连接是没有使用都创建一个Connection对象， 使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算 机的性能的及消耗时间的。 而数据库使用了数据库连接池后，就能达到Connection对象的复 用，如下图
连接池是在一开始就创建好了一些连接（Connection）对象存储起 来。用户需要连接数据库时，不需要自己创建连接，而只需要从连 接池中获取一个连接进行使用，使用完毕后再将连接对象归还给连 接池；这样就可以起到资源重用，也节省了频繁创建连接销毁连接 所花费的时间，从而提升了系统响应的速度
2. 数据库连接池实现:
- 标准接口：DataSource
官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此 接口。该接口提供了获取连接的功能：
//获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//获取数据库连接
Connection connection = dataSource.getConnection();
那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对 象。
常见的数据库连接池:
- DBCP
- C3P0
- Druid
我们现在使用更多的是Druid，它的性能比其他两个会好一些。
Druid（德鲁伊）:
- Druid连接池是阿里巴巴开源的数据库连接池项目
- 功能强大，性能优秀，是Java语言最好的数据库连接池之一
3.Driud使用:
- 导入jar包 druid-1.1.12.jar
- 定义配置文件
- 加载配置文件
- 获取数据库连接池对象
- 获取连接
3.1导入jar包:
资源来自黑马程序员JDBC课程资料
和我们之前导入JDBC的jar包一样,先把jar包复制粘贴到lib目录下,然后右键单价jar包,将其添加为库文件:
项目结构如下:
3.2编写配置文件:
3.3使用druid连接池代码获取数据库连接如下:
public static void main(String[] args) throws Exception {
//1.导入jar包//(已完成)
//2.定义配置文件//(已定义)
//加载配置文件
Properties prop=new Properties();
prop.load(new FileInputStream("src/druid.properties"));
//获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
//获取数据库连接
Connection connection = dataSource.getConnection();
System.out.println(connection);
// System.out.println(System.getProperty(user.dir));
}
连接到数据库后,就和前面一样了,根据需求定义sql语句,执行,处理SQL结果集等操作.
5.JDBC练习:
完成商品品牌数据的增删改查操作:
查询：查询所有数据
添加：添加品牌
修改：根据id修改
删除：根据id删除
5.1环境准备:
数据库表 tb_brand:
-- 删除tb_brand表
drop table if exists tb_brand;
-- 创建tb_brand表
create table tb_brand (
-- id 主键
id int primary key auto_increment,
-- 品牌名称
brand_name varchar(20),
-- 企业名称
company_name varchar(20),
-- 排序字段
ordered int,
-- 描述信息
description varchar(100),
-- 状态：0：禁用 1：启用
status int
);
-- 添加数据
insert into tb_brand (brand_name, company_name,
ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上
火', 0),
('华为', '华为技术有限公司', 100, '华为致力于把
数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世
界', 1),
('小米', '小米科技有限公司', 50, 'are you ok',
1);
在pojo包下实体类 Brand:
package pojo;
/**
*@描述 品牌
*
*@创建人 小小瓶
*@创建时间 2023/10/2
//可以先把创建SQL语句复制到IDEA中,然后快捷键批量修改定义变量
//选择一个要修改的符号按ctrl+f 选择Select All Occurences;即可修改符合的所有符号
//鼠标滑轮向下拉可以整列的修改
在实体类中,基本数据类型都建议使用包装类型
*/
public class Brand {
// id 主键
private Integer id ;
// 品牌名称
private String brandName ;
// 企业名称
private String companyName ;
// 排序字段
private Integer ordered ;
// 描述信息
private String description ;
// 状态：0：禁用 1:禁用;
private Integer status ;
public Integer getId() {
return id;
}
public String getBrandName() {
return brandName;
}
public String getCompanyName() {
return companyName;
}
public Integer getOrdered() {
return ordered;
}
public String getDescription() {
return description;
}
public Integer getStatus() {
return status;
}
public void setId(Integer id) {
this.id = id;
}
public void setBrandName(String brandName) {
this.brandName = brandName;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public void setOrdered(Integer ordered) {
this.ordered = ordered;
}
public void setDescription(String description) {
this.description = description;
}
public void setStatus(Integer status) {
this.status = status;
}
@Override
public String toString() {
return "Brand{" +
"id=" + id +
", brandName='" + brandName + '\'' +
", companyName='" + companyName + '\'' +
", ordered=" + ordered +
", description='" + description + '\'' +
", status=" + status +
'}';
}
}
5.2查询所有数据:
package example;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;
import pojo.Brand;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
/**
*@描述 品牌数据的测试工作
*
*@创建人 小小瓶
*@创建时间 2023/10/2
*/
public class BrandTest {
/**
* 查询所有
* 1.SQL:select * from tb_brand;
* 2.参数:无
* 3.结果:List<Brand>;
*/
@Test
public void BrandTest() throws Exception {
//1.获取连接(连接池的方式):
//1.1加载配置文件
Properties properties=new Properties();
properties.load(new FileInputStream("src/druid.properties"));
//1.2获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
//1.3获取数据库连接
Connection connection = dataSource.getConnection();
// System.out.println(connection);
//2.定义SQL语句
String sql="select * from tb_brand;";
//3.获取执行SQL语句的对象(Statement)
PreparedStatement preparedStatement = connection.prepareStatement(sql);
//4.设置参数(本场景无(SQL语句没有?占位参数))
//5.执行SQL语句
ResultSet resultSet = preparedStatement.executeQuery();
//6.处理结果List<Brand>:封装Brand对象,装载List集合
Brand brand=null;
List<Brand> brands=new ArrayList<Brand>();
while (resultSet.next()){
//获取数据
int id = resultSet.getInt("id");
String brandName = resultSet.getString("brand_name");
String companyName = resultSet.getString("company_name");
int ordered = resultSet.getInt("ordered");
String description = resultSet.getString("description");
int status = resultSet.getInt("status");
//封装集合
brand=new Brand();
brand.setId(id);
brand.setBrandName(brandName);
brand.setCompanyName(companyName);
brand.setOrdered(ordered);
brand.setDescription(description);
brand.setStatus(status);
//装载集合
brands.add(brand);
}
System.out.println(brands);
//释放资源
resultSet.close();
preparedStatement.close();
connection.close();
}
}
输出结果:
5.3添加数据:
首先看我们的数据库中表的数据:
代码如下:
/**
* 添加
* 1.SQL语句:insert into tb_brand(brand_name,company_name,ordered,description,status)
* values(?,?,?,?,?);
*
* 2.参数:需要:除了id之外的所有信息
*
* 3.结果:boolean
*/
@Test
public void testAdd() throws Exception {
//页面提交的参数
String brandName="哇哈哈";
String companyName="可口可乐";
int ordered=1;
String descriptiom="哇哈哈有点甜";
int status=1;
//1.获取连接(连接池的方式):
//1.1加载配置文件
Properties properties=new Properties();
properties.load(new FileInputStream("src/druid.properties"));
//1.2获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
//1.3获取数据库连接
Connection connection = dataSource.getConnection();
//2.定义SQL语句
String sql="insert into tb_brand(brand_name,company_name,ordered,description,status)values(?,?,?,?,?);";
//3.获取SQL语句执行对象
PreparedStatement statement = connection.prepareStatement(sql);
//4.设置参数:(将SQL语句中?替代为页面的数据)
statement.setString(1,brandName);
statement.setString(2,companyName);
statement.setInt(3,ordered);
statement.setString(4,descriptiom);
statement.setInt(5,status);
//5.执行SQL语句:
int count = statement.executeUpdate();//影响的行数
//6.处理结果
if (count>0){
System.out.println("添加成功!");
}
//7.释放资源:
statement.close();
connection.close();
}
id是自增的,所有我们不需要传入它的值.
运行成功再看我们的数据库:
我这里id是5,可能是因为我是做的第二遍,之前确实是4,我后面的删除,把id为4的数据删除了.
5.4修改数据:
/**
* 修改
* 1.SQL语句:update tb_brand set nrand_name=?,company_name=?,ordered=?,description=?,status=? where id=?;
*
* 2.参数:需要:需要所有数据
*
* 3.结果:boolean
*/
@Test
public void testUpdate() throws Exception {
//页面提交的参数(用户在网页输入的数据)
String brandName="哇哈哈";
String companyName="可口可乐";
int ordered=1000;
String descriptiom="哇哈哈有点甜,你知道吗";
int status=1;
int id=5;//这里也得变,之前是4
//1.获取连接(连接池的方式):
//1.1加载配置文件
Properties properties=new Properties();
properties.load(new FileInputStream("src/druid.properties"));
//1.2获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
//1.3获取数据库连接
Connection connection = dataSource.getConnection();
//2.定义SQL语句
String sql="update tb_brand set brand_name=?,company_name=?,ordered=?,description=?,status=? where id=?";
//3.获取SQL语句执行对象
PreparedStatement statement = connection.prepareStatement(sql);
//4.设置参数:(将SQL语句中?替代为页面的数据)
statement.setString(1,brandName);
statement.setString(2,companyName);
statement.setInt(3,ordered);
statement.setString(4,descriptiom);
statement.setInt(5,status);
statement.setInt(6,id);
//5.执行SQL语句:
int count = statement.executeUpdate();//影响的行数
//6.处理结果
if (count>0){
System.out.println("添加成功!");
}
//7.释放资源:
statement.close();
connection.close();
}
运行成功后,查看数据库数据:
5.5:删除数据:
/**
* 删除
* 1.SQL语句:delete from tb_brand where id=?;
*
* 2.参数:需要:需要id
*
* 3.结果:boolean
*/
@Test
public void testDelete() throws Exception {
//页面提交的参数
int id=4;
//1.获取连接(连接池的方式):
//1.1加载配置文件
Properties properties=new Properties();
properties.load(new FileInputStream("src/druid.properties"));
//1.2获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
//1.3获取数据库连接
Connection connection = dataSource.getConnection();
//2.定义SQL语句
String sql="delete from tb_brand where id=?;";
//3.获取SQL语句执行对象
PreparedStatement statement = connection.prepareStatement(sql);
//4.设置参数:(将SQL语句中?替代为页面的数据)
statement.setInt(1,id);
//5.执行SQL语句:
int count = statement.executeUpdate();//影响的行数
//6.处理结果
if (count>0){
System.out.println("添加成功!");
}
//7.释放资源:
statement.close();
connection.close();
}
我就不删除了,如果你删除数据后,你再重新去添加数据,索引是会加1的,不是从删除的索引位置开始的!
850
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
