1.JDBC
概念:全称 Java DataBase Connectivity
,即Java 数据库连接 是用Java操作关系型数据库的一套API。
驱动:SUN公司指定了一套标准接口(JDBC),JDBC中定义了所有操作关系型数据库的规则,而接口的实现类由各自的数据库厂商给出,这套实现类称之为驱动。想要使用同一套Java代码操作不同的关系型数据库,只需要加载该数据库厂商对应的驱动即可。
2.JDBC本质:
3.Java操作数据库的流程:
1.首先查询自己本地安装的MySQL版本,此处我的MySQL版本是 8.0.32
mysql -V
2.根据自己本地的MySQL版本,去MySQL官网下载对应的版本的zip
压缩包
MySQL官网下载地址:https://dev.mysql.com/downloads/connector/j/
点击Archives
,进入历史版本
选择好版本和操作系统后,点击Download
下载zip压缩包
8.0.32
Platform Independent
,不依赖平台3.解压zip
包以后,拿出里面的jar
包即可,此处解压后得到 mysql-connector-j-8.0.32.jar
准备一张account
表,插入两条数据如下:
-- 删除账户表
drop table if exists account;
-- 创建账户表
create table account
(
id int primary key AUTO_INCREMENT comment 'ID',
name varchar(10) comment '姓名',
money double(10, 2) comment '余额'
) comment '账户表';
-- 向账户表插入数据
insert into account(name, money) VALUES ('张三', 2000), ('李四', 2000);
-- 查询账户表
select * from account;
1.创建新的项目,定义项目的名称,并指定位置。
2.生成的项目结构如下,首先删除src
文件夹下Main.java
,然后在项目下新建一个目录,一般取名叫lib
,用于存放jar
包。
将下载好的 mysql-connector-j-8.0.32.jar
拖到该 lib
目录下,最终得到的项目结构如下:
3.右键lib
目录,点击 Add as Library
,将该 jar
包添加为库文件
在添加为库文件的时候,有如下三个选项
4.src
文件夹下,新建一个java
文件,此处取名JDBCDemo
编写代码一共分为以下七步:
将以下代码复制到 JDBCDemo.java
中运行:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 1.注册驱动
Class.forName("com.mysql.jdbc.Driver");
// 2.获取连接
String url = "jdbc:mysql://127.0.0.1:3306/itheima"; // 数据库URL
String username = "root"; // 用户名
String password = "123456"; // 密码
Connection conn = DriverManager.getConnection(url, username, password);
// 3.定义sql
String sql = "update account set money = 3000 where id = 1";
// 4.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
// 5.执行sql
int count = stmt.executeUpdate(sql); // 受影响的行数
// 6.处理结果
System.out.println(count);
// 7.释放资源
stmt.close();
conn.close();
}
}
运行结束后,查询account
表,张三的余额变成了3000
,说明JDBC
运行成功了:
DriverManager(驱动管理类)的作用:
1.注册驱动:registerDriver(Driver driver)
方法用于注册驱动
MySQL提供的Driver类,实现注册驱动的源码如下:
在该类中的静态代码块中已经执行了 DriverManager
对象的 registerDriver()
方法进行驱动的注册了,那么我们只需要加载 Driver
类,该静态代码块就会执行。而 Class.forName()
方法就可以加载 Driver
类。
Class.forName("com.mysql.jdbc.Driver"); // 注册驱动
注:MySQL 5之后的驱动包,可以省略注册驱动的步骤,会自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类。
2.获取数据库连接:getConnection()
方法
getConnection(String url, String user, String password);
参数说明:
jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…
jdbc:mysql://127.0.0.1:3306/itheima
注:
1.如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称?参数键值对
2.url中配置 useSSL=false 参数,禁用安全连接方式,可以解决警告提示
Connection(数据库连接对象)的作用:
1.普通执行SQL对象
Statement createStatement()
2.预编译SQL的执行SQL对象:防止SQL注入
PreparedStatement prepareStatement(sql)
3.执行存储过程的对象
CallableStatement prepareCall(sql)
MySQL事务管理的操作命令:
BEGIN
或者 START TRANSACTION
COMMIT
ROLLBACK
注:MySQL默认自动提交事务
Connection接口中定义了3个对应的方法:
1.开启事务 :setAutoCommit(boolean autoCommit)
其中参数 autoCommit
表示是否自动提交事务,true表示自动提交事务,false表示手动提交事务。而开启事务需要将该参数设为为false。
2.提交事务:commit()
3.回滚事务 :rollback()
代码实现如下:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
//1. 注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2. 获取连接
String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
//3. 定义sql
String sql1 = "update account set money = 3000 where id = 1";
String sql2 = "update account set money = 3000 where id = 2";
//4. 获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
try {
// ============开启事务==========
conn.setAutoCommit(false);
//5. 执行sql
int count1 = stmt.executeUpdate(sql1);//受影响的行数
//6. 处理结果
System.out.println(count1);
int i = 3/0; // 构造程序异常,如需正常运行,注释该行即可
//5. 执行sql
int count2 = stmt.executeUpdate(sql2);//受影响的行数
//6. 处理结果
System.out.println(count2);
// ============提交事务==========
//程序运行到此处,说明没有出现任何问题,则需提交事务
conn.commit();
} catch (Exception e) {
// ============回滚事务==========
//程序在出现异常时会执行到这个地方,此时就需要回滚事务
conn.rollback();
e.printStackTrace();
}
//7. 释放资源
stmt.close();
conn.close();
}
}
Statement对象的作用就是用来执行SQL语句,不同类型的SQL语句使用的方法也不一样。
方法分类如下:
executeUpdate(String sql)
:执行DDL、DML语句,返回受影响的行数,或者不返回内容。executeQuery(String sql)
:执行DQL语句,返回单个 ResultSet对象。注:DQL语句涉及
ResultSet
对象,放到3.4
节再讲述
执行DML语句:使用executeUpdate(String sql)
方法执行DML语句,返回受影响的行数
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 1.注册驱动,mysql8的驱动会自动加载注册,此行可以注释掉
// Class.forName("com.mysql.jdbc.Driver");
// 2.获取连接
String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
// 3.定义sql
String sql = "update account set money = 3000 where id = 1";
// 4.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
// 5.执行sql
int count = stmt.executeUpdate(sql); // 执行完DML语句,受影响的行数
// 6.处理结果
if(count > 0){
System.out.println("修改成功~");
}else{
System.out.println("修改失败~");
}
//7. 释放资源
stmt.close();
conn.close();
}
}
执行DDL语句:使用executeUpdate(String sql)
方法执行DDL语句,不返回内容
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 1.注册驱动,mysql8的驱动会自动加载注册,此行可以注释掉
// Class.forName("com.mysql.jdbc.Driver");
// 2.获取连接
String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
// 3.定义sql
String sql = "alter table account add remark varchar(20)"; // 添加字段remark
// 4.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
// 5.执行sql
int count = stmt.executeUpdate(sql); // 执行完DDL语句,可能是0
// 6.处理结果
System.out.println(count);
//7. 释放资源
stmt.close();
conn.close();
}
}
ResultSet(结果集对象)的作用:封装了SQL查询语句的结果,ResultSet executeQuery(sql)
执行DQL 语句,返回 ResultSet 对象。
ResultSet
对象提供了操作查询结果数据的方法:
1.boolean next()
:
2.xxx getXxx(参数)
:获取该字段的数据,如 String getString(String columnLabel)
、String getString(int columnIndex)
xxx
: 表示数据类型参数
:
注:此处要注意,列的编号是从
1
开始的,而不是0
示例:一开始光标指定于第一行前,也就是指向表头行,当调用了 next()
方法后,光标就下移到第一行数据,并且方法返回true。
此时就可以通过 getInt("id")
获取当前行id字段的值,也可以通过 getString("name")
获取当前行name字段的值。
如果想获取下一行的数据,需要继续调用 next()
方法,以此类推。
执行DQL语句:使用executeQuery(String sql)
方法执行DQL语句,返回结果集
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 1.注册驱动,mysql8的驱动会自动加载注册,此行可以注释掉
// Class.forName("com.mysql.jdbc.Driver");
// 2.获取连接
String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
// 3.定义sql
String sql = "select * from account";
// 4.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
// 5.执行sql
ResultSet rs = stmt.executeQuery(sql);
// 6.处理结果,遍历rs中的所有数据
// 光标向下移动一行,并且判断当前行是否有数据
while (rs.next()){
// 获取数据 getXxx()
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");
System.out.println(id);
System.out.println(name);
System.out.println(money);
System.out.println("--------------");
}
//7. 释放资源
rs.close();
stmt.close();
conn.close();
}
}
运行结果如下:
对比数据库中查询的语句如下:
注:获取数据的方法也可以替换为以下
// 使用参数为列的名称
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");
// 使用参数为列的编号
int id = rs.getInt(1);
String name = rs.getString(2);
double money = rs.getDouble(3);
需求:查询account账户表数据,封装为Account对象,并且存储到ArrayList集合中。
1.创建Account
实体类,对应account
账户表数据
public class Account {
private Integer id; // ID
private String name; // 姓名
private Double money; // 余额
public Integer getId() {
return id;
}
public void setId(Integer 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 "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
2.执行查询语句
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
/**
* 查询account账户表数据,封装到Account对象中,并且存储到ArrayList集合中
* 1. 定义实体类Account
* 2. 查询数据,封装到Account对象中
* 3. 将Account对象存入ArrayList集合中
*/
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 1.注册驱动,mysql8的驱动会自动加载注册,此行可以注释掉
// Class.forName("com.mysql.jdbc.Driver");
// 2.获取连接
String url = "jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
// 3.定义sql
String sql = "select * from account";
// 4.获取执行sql的对象 Statement
Statement stmt = conn.createStatement();
// 5.执行sql
ResultSet rs = stmt.executeQuery(sql);
List<Account> accountList = new ArrayList<>(); // 创建集合
// 6.处理结果,遍历rs中的所有数据
while (rs.next()){
Account account = new Account(); // 创建account对象
// 获取数据
int id = rs.getInt("id");
String name = rs.getString("name");
double money = rs.getDouble("money");
//给account对象赋值
account.setId(id);
account.setName(name);
account.setMoney(money);
accountList.add(account); // 存入集合
}
System.out.println(accountList);
//7. 释放资源
rs.close();
stmt.close();
conn.close();
}
}
运行结果:
[Account{id=1, name='张三', money=3000.0}, Account{id=2, name='李四', money=2000.0}]
PreparedStatement作用:预编译SQL语句并执行(预防SQL注入问题)
SQL注入:通过操作输入来修改事先定义好的SQL语句,用以达到执行代码对服务器进行攻击的方法。
准备材料如下:百度网盘链接:https://pan.baidu.com/s/1vzYHt1y4fEvcnyTyiRRDDw ,提取码:d1wy
sql.jar
application.properties
1.修改application.properties
文件,修改配置为自己本地的数据库用户名和密码
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/itheima?useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456
2.打开终端,输入命令运行程序
java -jar sql.jar
注:
application.properties
和sql.jar
这两个文件需放在同一级目录下,否则会报错
3.运行后,会自动创建test
数据库,并创建user
表
user
表内容如下:存放用户名和密码信息
4.在浏览器中输入 http://localhost:8080/login.html
,进入登录页面,先测试登录页面是否有效。
输入正确的用户名和密码:zhangsan
和 123
输入错误的用户名和密码:
zhangsan
和 1234
abc
和 123
5.演示SQL注入,登录时用户名任意输入一个,但密码输入特定的字符串,发现可以登录成功。
输入用户名和密码如下:abc
和 ' or '1' ='1
代码模拟SQL注入的过程:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 获取连接
String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
// 接收用户输入的用户名和密码,然后拼接成sql
/*String name = "zhangsan";
String pwd = "123";*/
String name = "abc";
String pwd = "' or '1' = '1";
String sql = "select * from user where username = '"+name+"' and password = '"+pwd+"'";
System.out.println(sql); // select * from user where username = 'abc' and password = '' or '1' = '1'
// 获取Statement对象
Statement stmt = conn.createStatement();
// 执行sql
ResultSet rs = stmt.executeQuery(sql);
// 判断登录是否成功
if(rs.next()){
System.out.println("登录成功~");
}else{
System.out.println("登录失败~");
}
// 释放资源
rs.close();
stmt.close();
conn.close();
}
}
上述代码是将用户名和密码拼接到sql语句中,拼接后的sql语句如下:
select * from user where username = 'abc' and password = '' or '1' = '1'
从上面语句可以看出条件 username = 'abc' and password = ''
不管是否满足,而 or
后面的 '1' = '1'
是始终满足的,最终条件是成立的,就可以正常的进行登录了。
PreparedStatement
:使用PreparedStatement
对象,可以预防SQL注入问题。
PreparedStatement
对象的用法:
1.获取 PreparedStatement 对象
// SQL语句中的参数值,使用?占位符替代
String sql = "select * from user where username = ? and password = ?";
// 通过Connection对象获取,并传入对应的sql语句
PreparedStatement pstmt = conn.prepareStatement(sql);
2.设置参数值,也就是 ?
的值
上面的sql语句中参数使用
?
进行占位,在执行sql之前肯定需要设置这些?
的值。
PreparedStatement
对象提供了设置参数值的方法:setXxx(参数1,参数2)
,如setString(int parameterIndex, String x)
?
的位置编号,从1 开始?
的值3.执行SQL语句
executeUpdate()
:执行DDL语句和DML语句executeQuery()
:执行DQL语句注:调用这两个方法时不需要传递SQL语句,因为获取SQL语句执行对象时已经对SQL语句进行预编译了
使用PreparedStatement
改进:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 获取连接
String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
// 接收用户输入的用户名和密码
String name = "zhangsan";
// String pwd = "123";
String pwd = "' or '1' = '1";
// 定义sql
String sql = "select * from user where username = ? and password = ?";
// 获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
// 设置参数 ? 的值
pstmt.setString(1,name);
pstmt.setString(2,pwd);
System.out.println(sql);
// 执行sql
ResultSet rs = pstmt.executeQuery();
// 判断登录是否成功
if(rs.next()){
System.out.println("登录成功~");
}else{
System.out.println("登录失败~");
}
// 释放资源
rs.close();
pstmt.close();
conn.close();
}
}
运行结果:SQL注入失败,登录失败
PreparedStatement是通过将特殊字符进行了转义,防止了SQL注入,转义的SQL语句如下:
select * from user where username = 'zhangsan' and password = '\'or \'1\' = \'1'
PreparedStatement 好处:
Java代码操作数据库流程如图所示:
将sql语句发送到MySQL服务器端
MySQL服务端会对sql语句进行如下操作
检查SQL语句
检查SQL语句的语法是否正确
编译SQL语句,将SQL语句编译成可执行的函数
检查SQL和编译SQL花费的时间比执行SQL的时间还要长。如果我们只是重新设置参数,那么检查SQL语句和编译SQL语句将不需要重复执行。这样就提高了性能。
执行SQL语句
接下来我们通过查询mysql日志来看一下原理:
1.开启预编译功能
在编写url时需要加上以下参数即可:
useServerPrepStmts=true
2.配置MySQL执行日志(重启mysql服务后生效)
在MySQL安装路径下,找到my.ini
,修改日志相关的内容如下:
# General and Slow logging.
log-output=FILE
general-log=1
general_log_file="D:\mysqlLog\mysql.log"
slow-query-log=1
slow_query_log_file="D:\mysqlLog\mysql-slow.log"
long_query_time=2
Win+R
输入services.msc
打开服务,找到MySQL服务重启后,查看刚刚配置的日志路径下,文件是否生成,如果生成说明配置生效了。
3.编写测试代码
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 获取连接,useServerPrepStmts=true 参数开启预编译功能
String url = "jdbc:mysql://127.0.0.1:3306/test?useSSL=false&useServerPrepStmts=true&allowPublicKeyRetrieval=true";
String username = "root";
String password = "123456";
Connection conn = DriverManager.getConnection(url, username, password);
// 接收用户输入的用户名和密码
String name = "zhangsan";
String pwd = "' or '1' = '1";
// 定义sql
String sql = "select * from user where username = ? and password = ?";
// 获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
// 执行第一次查询
// Thread.sleep(5000);
ResultSet rs = null;
pstmt.setString(1,name);
pstmt.setString(2,pwd);
rs = pstmt.executeQuery();
// 执行第二次查询
pstmt.setString(1,"abc");
pstmt.setString(2,"123");
rs = pstmt.executeQuery();
// 判断登录是否成功
if(rs.next()){
System.out.println("登录成功~");
}else{
System.out.println("登录失败~");
}
// 释放资源
rs.close();
pstmt.close();
conn.close();
}
}
运行代码后,打开mysql.log
文件,查看打印的内容:
下图圈中的三行语句中,第一行的 Prepare
是对SQL语句进行预编译。第二行和第三行是执行了两次SQL语句,而第二次执行前并没有对SQL进行预编译。
总结:
- 在获取PreparedStatement对象时,将sql语句发送给mysql服务器进行检查,编译(这些步骤很耗时)
- 执行时就不用再进行这些步骤了,速度更快
- 如果sql模板一样,则只需要进行一次检查、编译
1.数据库连接池的概念:
2.使用数据库连接池的好处:
之前我们代码中使用连接是没有使用都创建一个Connection对象,使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。而数据库使用了数据库连接池后,就能达到Connection对象的复用,如下图:
连接池是在一开始就创建好了一些连接(Connection)对象存储起来。用户需要连接数据库时,不需要自己创建连接,而只需要从连接池中获取一个连接进行使用,使用完毕后再将连接对象归还给连接池,这样就可以起到资源重用,也节省了频繁创建连接销毁连接所花费的时间,从而提升了系统响应的速度。
3.数据库连接池的实现
标准接口:DataSource
官方(SUN) 提供的数据库连接池标准接口,由第三方组织实现此接口。该接口提供了获取连接的功能:
Connection getConnection()
那么以后就不需要通过 DriverManager
对象获取 Connection
对象,而是通过连接池(DataSource
)获取 Connection
对象。
4.常见的数据库连接池
DBCP
C3P0
Druid
(常用)Druid(德鲁伊):
Driud的使用步骤如下:
1.jar包下载
Driud jar包下载地址:https://repo1.maven.org/maven2/com/alibaba/druid/
拉到最后,找到最新版本的jar包,点击下载:druid-1.2.9.jar
2.导入jar包,也就是将druid-1.2.9.jar
拖入到项目的lib
文件夹下并添加为库文件
3.src目录下,新建一个 driud.properties
配置文件
4.编写driud.properties
配置文件,内容如下:
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/itheima?useSSL=false&useServerPrepStmts=true
username=root
password=123456
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000
5.编写druid的代码
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;
/**
* Druid数据库连接池演示
*/
public class JDBCDemo {
public static void main(String[] args) throws Exception {
// 获取用户当前的工作目录
// System.out.println(System.getProperty("user.dir"));
// 1.导入jar包
// 2.定义配置文件
// 3.加载配置文件
Properties prop = new Properties();
prop.load(new FileInputStream("src/driud.properties"));
// 4.获取连接池对象
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
// 5.获取数据库连接 Connection
Connection connection = dataSource.getConnection();
System.out.println(connection); // 获取到了连接后就可以继续做其他操作了
}
}
小技巧:可以通过
System.getProperty("user.dir")
,获取用户当前的工作目录,从而知道加载文件的相对路径。
需求:完成商品品牌数据的增删改查操作
1.创建数据库表 tb_brand
-- 删除tb_brand表
drop table if exists tb_brand;
-- 创建tb_brand表
create table tb_brand (
id int primary key auto_increment, -- id主键
brand_name varchar(20), -- 品牌名称
company_name varchar(20), -- 企业名称
ordered int, -- 排序字段
description varchar(100), -- 描述信息
status int -- 状态:0:禁用 1:启用
);
-- 向tb_brand表插入数据
insert into tb_brand (brand_name, company_name, ordered, description, status)
values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),
('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织,构建万物互联的智能世界', 1),
('小米', '小米科技有限公司', 50, 'are you ok', 1);
-- 查询tb_brand表
select * from tb_brand;
2.在pojo包下创建实体类 Brand
package com.itheima.pojo;
/**
* 品牌
* 在实体类中,基本数据类型建议使用其对应的包装类型
*/
public class Brand {
private Integer id; // id 主键
private String brandName; // 品牌名称
private String companyName; // 企业名称
private Integer ordered; // 排序字段
private String description; // 描述信息
private Integer status; // 状态:0:禁用 1:启用
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getBrandName() {
return brandName;
}
public void setBrandName(String brandName) {
this.brandName = brandName;
}
public String getCompanyName() {
return companyName;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public Integer getOrdered() {
return ordered;
}
public void setOrdered(Integer ordered) {
this.ordered = ordered;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Integer getStatus() {
return status;
}
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 +
'}';
}
}
项目结构如下:
/**
* 查询所有
* 1. SQL:select * from tb_brand;
* 2. 参数:不需要
* 3. 结果:List
*/
@Test
public void selectAll() throws Exception{
// 加载配置文件,并获取连接池对象
Properties prop = new Properties();
prop.load(new FileInputStream("src/driud.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
// 获取数据库连接
Connection conn = dataSource.getConnection();
// 定义sql
String sql = "select * from tb_brand";
// 获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
// 执行查询语句
ResultSet rs = pstmt.executeQuery();
List<Brand> brandList = new ArrayList<>();
Brand brand = null;
while (rs.next()){
// 获取数据
int id = rs.getInt("id");
String brandName = rs.getString("brand_name");
String companyName = rs.getString("company_name");
int ordered = rs.getInt("ordered");
String description = rs.getString("description");
int status = rs.getInt("status");
//封装Brand对象
brand = new Brand();
brand.setId(id);
brand.setBrandName(brandName);
brand.setCompanyName(companyName);
brand.setOrdered(ordered);
brand.setDescription(description);
brand.setStatus(status);
// 存入集合
brandList.add(brand);
}
System.out.println(brandList);
// 释放资源
rs.close();
pstmt.close();
conn.close();
}
运行结果如下:
/**
* 添加
* 1. SQL:insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);
* 2. 参数:需要,除了id之外的所有参数信息
* 3. 结果:boolean
*/
@Test
public void add() throws Exception{
// 页面提交的数据
String brandName = "香飘飘";
String companyName = "香飘飘";
int ordered = 1;
String description = "绕地球一圈";
int status = 1;
// 加载配置文件,并获取连接池对象
Properties prop = new Properties();
prop.load(new FileInputStream("src/driud.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
// 获取数据库连接
Connection conn = dataSource.getConnection();
// 定义sql
String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?)";
// 获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
// 设置参数
pstmt.setString(1,brandName);
pstmt.setString(2,companyName);
pstmt.setInt(3,ordered);
pstmt.setString(4,description);
pstmt.setInt(5,status);
// 执行插入语句
int count = pstmt.executeUpdate();
System.out.println(count > 0);
// 释放资源
pstmt.close();
conn.close();
}
运行上述代码后,查询品牌表:
/**
* 修改
* 1. SQL:
update tb_brand
set brand_name = ?, company_name = ?, ordered = ?, description = ?, status = ?
where id = ?
* 2. 参数:需要,所有数据
* 3. 结果:boolean
*/
@Test
public void update() throws Exception{
// 页面提交的数据
String brandName = "香飘飘";
String companyName = "香飘飘";
int ordered = 1000;
String description = "绕地球三圈";
int status = 1;
int id = 4;
// 加载配置文件,并获取连接池对象
Properties prop = new Properties();
prop.load(new FileInputStream("src/driud.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
// 获取数据库连接
Connection conn = dataSource.getConnection();
// 定义sql
String sql = "update tb_brand\n" +
"set brand_name = ?, company_name = ?, ordered = ?, description = ?, status = ?\n" +
"where id = ?";
// 获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
// 设置参数
pstmt.setString(1,brandName);
pstmt.setString(2,companyName);
pstmt.setInt(3,ordered);
pstmt.setString(4,description);
pstmt.setInt(5,status);
pstmt.setInt(6,id);
// 执行更新语句
int count = pstmt.executeUpdate();
System.out.println(count > 0);
// 释放资源
pstmt.close();
conn.close();
}
运行上述代码后,查询品牌表:
/**
* 删除
* 1. SQL:delete from tb_brand where id = ?
* 2. 参数:需要,id
* 3. 结果:boolean
*/
@Test
public void deleteById() throws Exception{
// 页面提交的数据
int id = 4;
// 加载配置文件,并获取连接池对象
Properties prop = new Properties();
prop.load(new FileInputStream("src/driud.properties"));
DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
// 获取数据库连接
Connection conn = dataSource.getConnection();
// 定义sql
String sql = "delete from tb_brand where id = ?";
// 获取PreparedStatement对象
PreparedStatement pstmt = conn.prepareStatement(sql);
// 设置参数
pstmt.setInt(1,id);
// 执行删除语句
int count = pstmt.executeUpdate();
System.out.println(count > 0);
// 释放资源
pstmt.close();
conn.close();
}
运行上述代码后,查询品牌表: