【JDBC】

置顶 BridgeCloud

已于 2023-04-18 07:54:58 修改

阅读量451

点赞数

分类专栏： Java Knowledge Ocean 文章标签： java jvm 数据库

于 2022-08-11 17:15:03 首次发布

本文链接：https://blog.csdn.net/qq_37168484/article/details/126158616

版权

Java Knowledge Ocean 专栏收录该内容

18 篇文章 0 订阅 ¥89.90 ¥99.00

订阅专栏

本文详细介绍了JDBC的概念、本质和优势，并逐步引导读者从快速入门到掌握PreparedStatement的使用，深入理解SQL注入问题。此外，还探讨了数据库连接池的重要性和Druid的配置与使用，提供了一个全面的JDBC实战案例，涵盖了增删改查操作。

摘要由CSDN通过智能技术生成

1，JDBC概述

1.1 JDBC概念

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

全称：( Java DataBase Connectivity ) Java 数据库连接

1.2 JDBC本质

官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口
各个数据库厂商去实现这套接口，提供数据库驱动jar包
我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

1.3 JDBC好处

各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发
可随时替换底层数据库，访问数据库的Java代码基本不变

以后编写操作数据库的代码只需要面向JDBC（接口），操作哪儿个关系型数据库就需要导入该数据库的驱动包，如需要操作MySQL数据库，就需要再项目中导入MySQL数据库的驱动包。

2 JDBC快速入门

先来看看通过Java操作数据库的流程

第一步：编写Java代码

第二步：Java代码将SQL发送到MySQL服务端

第三步：MySQL服务端接收到SQL语句并执行该SQL语句

第四步：将SQL语句执行的结果返回给Java代码

2.1 编写代码步骤

1.注册驱动

   try {
       Class.forName("com.mysql.jdbc.Driver");		
       } catch (ClassNotFoundException e) { 				
           e.printStackTrace();
       }

注意：Class.forName需要捕获ClassNotFoundException.
Class.forName是把这个类加载到JVM中，加载的时候，就会执行其中的静态初始化块，完成驱动的初始化的相关工作。

2.获得连接

	Connection c = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/exam?characterEncoding=UTF-8", "root", "admin");

三个参数分别是表示：
url：需要连接数据库的位置（网址）
mysql的url：jdbc:mysql://localhost:3306/（mysql数据库名字) ?characterEncoding=UTF-8
JDBC规定url的格式由三部分组成，每个部分中间使用逗号分开
第一部分是jdbc，这是固定的
第二部分是数据库名称，连接mysql数据库
第三部分是有数据库厂商规定的，我们需要了解每个数据库厂商的要求，
mysql第三部分分别由数据库服务器的IP地址，端口号，以及database（数据库的名称）组成
第四部分是编码方式 UTF-8
user：用户名
password：密码

Connection是与特定数据库连接回话的接口，使用的时候需要导包，而且必须在程序结束的时候将其关闭。getConnection方法也需要捕获SQLException异常。
因为在进行数据库的增删改查的时候都需要与数据库建立连接，所以可以在项目中将建立连接写成一个工具方法，用的时候直接调用即可

        /**
	 * 取得数据库的连接
	 * @return 一个数据库的连接
	 */
public static Connection getConnection(){
		Connection conn = null;
		 try {
			 	//初始化驱动类com.mysql.jdbc.Driver
	            Class.forName("com.mysql.jdbc.Driver");
	            conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/exam?characterEncoding=UTF-8","root", "admin");
	            //该类就在 mysql-connector-java-5.0.8-bin.jar中,如果忘记了第一个步骤的导包，就会抛出ClassNotFoundException
	        } catch (ClassNotFoundException e) { 				
	            e.printStackTrace();
	        }catch (SQLException e) {							
	            e.printStackTrace();
	        }
		 return conn;
	}

3.获取语句执行者

//- 使用Statement接口 
 	String sql = “insert into category(cid ,cname) value(‘c007’，‘分类’)”;
	//Statement 语句执行者代码：
	Statement stmt = con.createStatement();
	stmt.execute(sql);



// - 使用PreparedStatement接口
		String sql = "insert into t_course(course_name) values(?)";  
 		//该语句为每个 IN 参数保留一个问号（“？”）作为占位符
		Connection conn = null;				//和数据库取得连接
		PreparedStatement pstmt = null;		//创建statement
		
		conn = DbUtil.getConnection();
		pstmt = (PreparedStatement) conn.prepareStatement(sql);
		pstmt.setString(1, courseName); //给占位符赋值
		pstmt.executeUpdate();			//执行

statement拼接字符串方式，PreparedStatement采用占位符方式。
PreparedStatement每次SQL语句都是一样的，java类就不会再次编译，这样能够显著提高性能。


String sql = "update t_course set course_name =? where course_id=?";

pstmt = (PreparedStatement) conn.prepareStatement(sql);
pstmt.setString(1, courseName);  //利用Preparedstatement的set方法给占位符赋值 这里的参数索引是从1开始的
pstmt.setInt(2, courseId);
pstmt.executeUpdate();

4.执行SQL语句：
int 设置对象 = 对象. excuteUpdate(String sql);执行insert updata delete 语句（DML语句）
ResultSet 设置对象 =对象.executeQuery(String sql) --执行select语句（DQL语句）
boolean 设置对象 = 对象.execute(String sql) --执行select返回true执行其他语句返回false
如果返回true ，需要使用getResultSet()获取查询结果
如果返回false 需要使用getUpdateCount()获取影响行数

PreparedStatement增删改都使用pstmt.executeUpdate();语句进行SQL语句的提交
PreparedStatement查询操作使用executeQuery()进行更新

在添加的过程的，如果添加的数据量比较大的话，可以用批量添加。 PreparedStatement接口提供了相应的批量操作的方法
执行批处理
1. addBatch(String sql);
clearBatch();
excuteBatch();
特点：如果与参数，需要SQL语句中进行拼接，存在SQL注入问题

for(int i=1;i<100;i++){
     pstmt.setInt(1,8000+i);
     pstmt.setString(2,"赵_"+i);
     pstmt.addBatch();
//批量更新
     if(i%10==0){
     pstmt.executeBatch();
    }
}

5.处理结果集
ResultSet实际上就是一张二维的表格，它内部有一个行光标，光标的默认位置在第一行上方
我们调用rs对象的next方法把“行光标”向下一行移动，当第一次调用next方法的时候，行光标就到了第一行记录的位置
这是就可以使用ResultSet提供的getXXX（int col）方法来获取
指定的列数据了
例子：
rs.next();光标移到第一行
rs.getInt(1);获取第一行第一列的数据

	ResultSet类中共了一系列的getXXX()方法，比较常见的;
		Object getObject(int col)获取任意对象
		String getString(int col)获取字符串
		int getInt(int col)获取整型数
		double getdouble(int col)获取双精度浮点数型

ResultSet rs = s.executeQuery(sql);
while (rs.next()){
		int courseId = rs.getInt("course_id");  //getInt(int col)获取整型数，从1开始编码,推荐使用属性名
		String courseName = rs.getString("course_name");
		//每个记录对应一个对象
		Course course = new Course();
//在我的项目中创建了course类，其中定义了set方法，所以这里将查询到的值传给了course，也可以直接打印到控制台
		course.setCourseId(courseId);
		course.setCourseName(courseName);
		//将对象放到集合中
		courseList.add(course);
		}

6.释放资源

遵循从里到外的原则
rs.close();
stsmt.close();
con.close();

/**
	 * 封装三个关闭方法
	 * @param pstmt
	 */
	public static void close(PreparedStatement pstmt){
		if(pstmt != null){						//避免出现空指针异常
			try{
				pstmt.close();
			}catch(SQLException e){
				e.printStackTrace();
			}
			
		}
	}
	
	public static void close(Connection conn){
		if(conn != null){
			try {
				conn.close();
			} catch (SQLException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}
	
	public static void close(ResultSet rs){
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
	}

1. 增

        /**
    * 添加课程
    * @param courseName 课程名称
    */
   public void addCourse(String courseName){
   	String sql = "insert into t_course(course_name) values(?)";  
//该语句为每个 IN 参数保留一个问号（“？”）作为占位符
   	Connection conn = null;				//和数据库取得连接
   	PreparedStatement pstmt = null;		//创建statement
   	try{
   		conn = DbUtil.getConnection();
   		pstmt = (PreparedStatement) conn.prepareStatement(sql);
   		pstmt.setString(1, courseName); //给占位符赋值
   		pstmt.executeUpdate();			//执行
   	}catch(SQLException e){
   		e.printStackTrace();
   	}
   	finally{
   		DbUtil.close(pstmt);
   		DbUtil.close(conn);		//必须关闭
   	}
   }

2. 删

      /**
  * 删除课程
  * @param courseId
  */
 public void delCourse(int courseId){
 	String sql = "delete from t_course where course_id = ?";
 	Connection conn = null;
 	PreparedStatement pstmt = null;
 	try {
 		conn = DbUtil.getConnection();
 		pstmt = (PreparedStatement) conn.prepareStatement(sql);
 		pstmt.setInt(1, courseId);
 		pstmt.executeUpdate();
 	} catch (SQLException e) {
 		// TODO: handle exception
 		e.printStackTrace();
 	}finally{
 		DbUtil.close(pstmt);
 		DbUtil.close(conn);		//必须关闭
 	}
 }

3. 改

       /**
   * 修改课程
   * @param courseId
   * @param courseName
   */
  public void modifyCourse(int courseId,String courseName){
  	String sql = "update t_course set course_name =? where course_id=?";
  	Connection conn = null;
  	PreparedStatement pstmt = null;
  	try {
  		conn = DbUtil.getConnection();
  		pstmt = (PreparedStatement) conn.prepareStatement(sql);
  		pstmt.setString(1, courseName);  //利用Preparedstatement的set方法给占位符赋值
  		pstmt.setInt(2, courseId);
  		pstmt.executeUpdate();
  	} catch (SQLException e) {
  		// TODO: handle exception
  		e.printStackTrace();
  	}finally{
  		DbUtil.close(pstmt);
  		DbUtil.close(conn);		//必须关闭
  	}
  }

Statement和PreparedStatement的异同及优缺点

同：两者都是用来执SQL语句的

异：PreparedStatement需要根据SQL语句来创建，它能够通过设置参数，指定相应的值，不是像Statement那样使用字符串拼接的方式。

PreparedStatement的优点：

1、其使用参数设置，可读性好，不易记错。在statement中使用字符串拼接，可读性和维护性比较差。

2、其具有预编译机制，性能比statement更快。

3、其能够有效防止SQL注入攻击。

execute和executeUpdate的区别

相同点：二者都能够执行增加、删除、修改等操作。

不同点：

1、execute可以执行查询语句，然后通过getResult把结果取出来。executeUpdate不能执行查询语句。

2、execute返回Boolean类型，true表示执行的是查询语句，false表示执行的insert、delete、update等。executeUpdate的返回值是int，表示有多少条数据受到了影响。

3 PreparedStatement

PreparedStatement作用：

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

3.1 SQL注入

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

Statement将用户名和密码拼接到sql语句中，拼接后的sql语句如下

select * from tb_user where username = 'sjdljfld' and password = ''or '1' = '1'

从上面语句可以看出条件 username = 'sjdljfld' and password = '' 不管是否满足，而 or 后面的 '1' = '1' 是始终满足的，最终条件是成立的，就可以正常的进行登陆了。

PreparedStatement对象.是将特殊字符进行了转义，转义的SQL如下：

select * from tb_user where username = 'sjdljfld' and password = '\'or \'1\' = \'1'

PreparedStatement 好处：

预编译SQL，性能更高
防止SQL注入：将敏感字符进行转义

     获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写
      // useServerPrepStmts=true 参数开启预编译功能
      String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";

小结：

在获取PreparedStatement对象时，将sql语句发送给mysql服务器进行检查，编译（这些步骤很耗时）
执行时就不用再进行这些步骤了，速度更快
如果sql模板一样，则只需要进行一次检查、编译

4 数据库连接池

4.1 数据库连接池简介

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

它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；

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

好处

资源重用
提升系统响应速度
避免数据库连接遗漏

使用连接是没有使用都创建一个Connection对象，使用完毕就会将其销毁。这样重复创建销毁的过程是特别耗费计算机的性能的及消耗时间的。

而数据库使用了数据库连接池后，就能达到Connection对象的复用，如下图

连接池是在一开始就创建好了一些连接（Connection）对象存储起来。用户需要连接数据库时，不需要自己创建连接，而只需要从连接池中获取一个连接进行使用，使用完毕后再将连接对象归还给连接池；这样就可以起到资源重用，也节省了频繁创建连接销毁连接所花费的时间，从而提升了系统响应的速度。

4.2 数据库连接池实现

标准接口：DataSource

官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此接口。该接口提供了获取连接的功能：
```
Connection getConnection()
```
那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对象。
常见的数据库连接池
- C3P0:有自动回收空闲连接功能
  c3p0是一个开放源代码的JDBC连接池，它在lib目录中与Hibernate一起发布,包括实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
- DBCP:没有自动回收空闲连接功能
  是 apache 上的一个 java 连接池项目,是一个依赖Jakarta commons-pool对象池机制的数据库连接池.DBCP可以直接的在应用程序中使用，Tomcat的数据源使用的就是DBCP
- Druid:
  是阿里巴巴出品的数据源，而且是淘宝和支付宝专用数据库连接池，但它不仅仅是一个数据库连接池，它还包含一个ProxyDriver，一系列内置的JDBC组件库，一个 SQL Parser。

C3P0提供最大空闲时间，当连接超过最大空闲连接时间时，当前连接就会被断掉
DBCP提供了最大连接数，当连接数超过最大连接数时，所有连接都会被断开

我们现在使用更多的是Druid，它的性能比其他两个会好一些。

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

4.3 Driud使用

导入jar包 druid-1.1.12.jar
定义配置文件
加载配置文件
获取数据库连接池对象
获取连接

现在通过代码实现，首先需要先将druid的jar包放到项目下的lib下并添加为库文件

项目结构如下：

编写配置文件如下：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true
username=root
password=1234
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

mysql8.0.29+mysql-connector-java-8.0.18配置：下载连接
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/testdata?serverTimezone=UTC&useSSL=false

使用druid的代码如下：

/**
 * Druid数据库连接池演示
 */
public class DruidDemo {

    public static void main(String[] args) throws Exception {
        //1.导入jar包
        //2.定义配置文件
        //3. 加载配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
        //4. 获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

        //5. 获取数据库连接 Connection
        Connection connection = dataSource.getConnection();
        System.out.println(connection); //获取到了连接后就可以继续做其他操作了

        //System.out.println(System.getProperty("user.dir"));
    }
}

System.getProperty(user.dir) 获取的是启动项目的容器位置，用IDEA是项目的根目录，部署在tomcat上是tomcat的启动路径，即tomcat/bin的位置

prop.load(DruidTool.class.getClassLoader().getResourceAsStream(“druid.properties”)); /直接查找文件类型FileInputStream
prop.load(new FileReader(String.valueOf(DruidTool.class.getResource(“/”).getPath()+“druid.properties”))); //路径拼接

4.4 druid配置详解

属性	说明	建议值
url	数据库的jdbc连接地址。一般为连接oracle/mysql。示例如下：
	mysql : jdbc:mysql://ip:port/dbname?option1&option2&…
	oracle : jdbc:oracle:thin:@ip:port:oracle_sid

username	登录数据库的用户名
password	登录数据库的用户密码
initialSize	启动程序时，在连接池中初始化多少个连接	10-50已足够
maxActive	连接池中最多支持多少个活动会话
maxWait	程序向连接池中请求连接时,超过maxWait的值后，认为本次请求失败，即连接池	100
	没有可用连接，单位毫秒，设置-1时表示无限等待
minEvictableIdleTimeMillis	池中某个连接的空闲时长达到 N 毫秒后, 连接池在下次检查空闲连接时，将	见说明部分
	回收该连接,要小于防火墙超时设置
	net.netfilter.nf_conntrack_tcp_timeout_established的设置
timeBetweenEvictionRunsMillis	检查空闲连接的频率，单位毫秒, 非正整数时表示不进行检查
keepAlive	程序没有close连接且空闲时长超过 minEvictableIdleTimeMillis,则会执	true
	行validationQuery指定的SQL,以保证该程序连接不会池kill掉,其范围不超
	过minIdle指定的连接个数。
minIdle	回收空闲连接时，将保证至少有minIdle个连接.	与initialSize相同
removeAbandoned	要求程序从池中get到连接后, N 秒后必须close,否则druid 会强制回收该	false,当发现程序有未
	连接,不管该连接中是活动还是空闲, 以防止进程不会进行close而霸占连接。	正常close连接时设置为true
removeAbandonedTimeout	设置druid 强制回收连接的时限，当程序从池中get到连接开始算起，超过此	应大于业务运行最长时间
	值后，druid将强制回收该连接，单位秒。
logAbandoned	当druid强制回收连接后，是否将stack trace 记录到日志中	true
testWhileIdle	当程序请求连接，池在分配连接时，是否先检查该连接是否有效。(高效)	true
validationQuery	检查池中的连接是否仍可用的 SQL 语句,drui会连接到数据库执行该SQL, 如果
	正常返回，则表示连接可用，否则表示连接不可用
testOnBorrow	程序申请连接时,进行连接有效性检查（低效，影响性能）	false
testOnReturn	程序返还连接时,进行连接有效性检查（低效，影响性能）	false
poolPreparedStatements	缓存通过以下两个方法发起的SQL:	true
	public PreparedStatement prepareStatement(String sql)
	public PreparedStatement prepareStatement(String sql,
	int resultSetType, int resultSetConcurrency)
maxPoolPrepareStatementPerConnectionSize	每个连接最多缓存多少个SQL	20
filters	这里配置的是插件,常用的插件有:	stat,wall,slf4j
	监控统计: filter:stat
	日志监控: filter:log4j 或者 slf4j
	防御SQL注入: filter:wall
connectProperties	连接属性。比如设置一些连接池统计方面的配置。
	druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
	比如设置一些数据库连接属性:

5 JDBC案例

5.1 需求

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

查询：查询所有数据
添加：添加品牌
修改：根据id修改
删除：根据id删除

5.2 案例实现

5.2.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

/**
 * 品牌
 * alt + 鼠标左键：整列编辑
 * 在实体类中，基本数据类型建议使用其对应的包装类型
 */
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 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 +
                '}';
    }
}

5.2.2 查询所有

 /**
   * 查询所有
   * 1. SQL：select * from tb_brand;
   * 2. 参数：不需要
   * 3. 结果：List<Brand>
   */

@Test
public void testSelectAll() throws Exception {
    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);

    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = "select * from tb_brand;";
    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4. 设置参数
    //5. 执行SQL
    ResultSet rs = pstmt.executeQuery();
    //6. 处理结果 List<Brand> 封装Brand对象，装载List集合
    Brand brand = null;
    List<Brand> brands = new ArrayList<>();
    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);

        //装载集合
        brands.add(brand);
    }
    System.out.println(brands);
    //7. 释放资源
    rs.close();
    pstmt.close();
    conn.close();
}

5.2.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 description = "绕地球一圈";
    int status = 1;

    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);";
    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4. 设置参数
    pstmt.setString(1,brandName);
    pstmt.setString(2,companyName);
    pstmt.setInt(3,ordered);
    pstmt.setString(4,description);
    pstmt.setInt(5,status);

    //5. 执行SQL
    int count = pstmt.executeUpdate(); // 影响的行数
    //6. 处理结果
    System.out.println(count > 0);

    //7. 释放资源
    pstmt.close();
    conn.close();
}

5.2.4 修改数据

/**
  * 修改
  * 1. SQL：

     update tb_brand
         set brand_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 description = "绕地球三圈";
    int status = 1;
    int id = 4;

    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = " update tb_brand\n" +
        "         set brand_name  = ?,\n" +
        "         company_name= ?,\n" +
        "         ordered     = ?,\n" +
        "         description = ?,\n" +
        "         status      = ?\n" +
        "     where id = ?";

    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);

    //4. 设置参数
    pstmt.setString(1,brandName);
    pstmt.setString(2,companyName);
    pstmt.setInt(3,ordered);
    pstmt.setString(4,description);
    pstmt.setInt(5,status);
    pstmt.setInt(6,id);

    //5. 执行SQL
    int count = pstmt.executeUpdate(); // 影响的行数
    //6. 处理结果
    System.out.println(count > 0);

    //7. 释放资源
    pstmt.close();
    conn.close();
}

5.2.5 删除数据

/**
  * 删除
  * 1. SQL：
            delete from tb_brand where id = ?
  * 2. 参数：需要，id
  * 3. 结果：boolean
  */
@Test
public void testDeleteById() throws Exception {
    // 接收页面提交的参数
    int id = 4;
    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = " delete from tb_brand where id = ?";
    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4. 设置参数
    pstmt.setInt(1,id);
    //5. 执行SQL
    int count = pstmt.executeUpdate(); // 影响的行数
    //6. 处理结果
    System.out.println(count > 0);

    //7. 释放资源
    pstmt.close();
    conn.close();
}

设置参数
pstmt.setString(1,brandName);
pstmt.setString(2,companyName);
pstmt.setInt(3,ordered);
pstmt.setString(4,description);
pstmt.setInt(5,status);
pstmt.setInt(6,id);

//5. 执行SQL
int count = pstmt.executeUpdate(); // 影响的行数
//6. 处理结果
System.out.println(count > 0);

//7. 释放资源
pstmt.close();
conn.close();

}


#### 5.2.5  删除数据

```java
/**
  * 删除
  * 1. SQL：
            delete from tb_brand where id = ?
  * 2. 参数：需要，id
  * 3. 结果：boolean
  */
@Test
public void testDeleteById() throws Exception {
    // 接收页面提交的参数
    int id = 4;
    //1. 获取Connection
    //3. 加载配置文件
    Properties prop = new Properties();
    prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));
    //4. 获取连接池对象
    DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
    //5. 获取数据库连接 Connection
    Connection conn = dataSource.getConnection();
    //2. 定义SQL
    String sql = " delete from tb_brand where id = ?";
    //3. 获取pstmt对象
    PreparedStatement pstmt = conn.prepareStatement(sql);
    //4. 设置参数
    pstmt.setInt(1,id);
    //5. 执行SQL
    int count = pstmt.executeUpdate(); // 影响的行数
    //6. 处理结果
    System.out.println(count > 0);

    //7. 释放资源
    pstmt.close();
    conn.close();
}

BridgeCloud

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
【JDBC】

1.1 JDBC概念1.2 JDBC本质1.3 JDBC好处2，JDBC快速入门2.1 编写代码步骤3.1 SQL注入3，数据库连接池3.1 数据库连接池简介3.2 数据库连接池实现3.3 Driud使用3.4 druid配置详解4，JDBC案例4.1 需求4.2 案例实现4.2.1 环境准备4.2.2 查询所有4.2.3 添加数据4.2.4 修改数据4.2.5 删除数据数据库连接池是个容器，负责分配、管理数据库连接(Connection)
复制链接

扫一扫