一文带你学会Spring JDBC的使用

2023-02-23 0 3,286

目录

1、JDBC

JDBC 就是 数据库开发 操作的 代名词,因为只要是现代商业项目的开发那么一定是离不开 数据库 的,不管你搞的是什么,只要是想使用动态的开发结构,那么一定就是 JDBC ,那么下面首先来回顾一下传统JDBC的使用。
一文带你学会Spring JDBC的使用
JDBC有四种连接: 像JDBC-ODBC的连接已经确定不再使用了、主要采用的是 JDBC网络连接模式
在JDBC的开发之中,一定要 配置相应数据库的驱动程序 后才可以使用,所以这就属于标准的做法,同时还有一点必须明确,不管未来出现了什么样的 Java数据库开发框架,那么核心的本质只有一点: JDBC,可是JDBC 标准里面所定义的 操作结构 是属于 较为底层 的操作形式,所以使用起来 非常的繁琐,因为几乎所有的数据库的项目都需要加载驱动、创建数据库连接、数据库的操作对象、关闭数据库,只有中间的数据库的CRUD操作是有区别的,那么就需要考虑对JDBC进行封装了,那么这个时候就有了ORM组件(全称ORMapping、对象关联映射,采用对象的形式实现JDBC的开发操作)。
一文带你学会Spring JDBC的使用
​ 从历史的发展上来讲,ORMapping组件出现较多:JDO、Entity Bean、Hibernate、IBatis、SpringJDBC、MyBatis、JPA标准,当然随着技术的发展与淘汰,基本上现在阶段剩下的ORM组件,常用的就是MyBatis(国内互联网公司)、JPA(国外机构),而SpringJDBC是属于JDBC的轻度包装组件(其他的组件都属于重度包装),所以使用SpringJDBC可以 简化JDBC 传统开发里面繁琐的操作步骤。
一文带你学会Spring JDBC的使用
添加依赖
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<spring.version>5.3.21</spring.version>
<mysql.version>8.0.30</mysql.version>
</properties>

<dependencies>
<!--核心依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<!--spring-jdbc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
</dependency>
<!--数据库依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

<!--测试-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.8.2</version>
</dependency>

<!--日志依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.25</version>
</dependency>
<!--日志依赖-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.25</version>
</dependency>
</dependencies>

log4j.properties 日志配置文件 (当启动程序,没有任何报错,但是没有信息打印时,需要配置日志)
#将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.ImmediateFlush=true
log4j.appender.console.Target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%-5p] %d(%r) --> [%t] %l: %m %x %n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/logFile.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

2、使用

要想使用JDBC,配置数据源,是关键性的一步。

2.1、配置数据源

2.1.1、注册数据源对像
创建数据源的配置类:(基于配置类的方式)
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import javax.sql.DataSource;
@Configuration
public class DataSourceConfig {
@Bean
public DataSource dataSource() {
// 驱动数据源
DriverManagerDataSource dataSource = new DriverManagerDataSource();
// 加载驱动程序
dataSource.setDriverClassName(\"com.mysql.cj.jdbc.Driver\");
dataSource.setUrl(\"jdbc:mysql://localhost:3306/yootk\");
dataSource.setUsername(\"root\");
dataSource.setPassword(\"317311\");
return dataSource;
}
}

创建数据源的配置类:(基于xml的方式)
<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<beans xmlns=\"http://www.springframework.org/schema/beans\"
xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
xmlns:p=\"http://www.springframework.org/schema/p\"
xmlns:c=\"http://www.springframework.org/schema/c\"
xsi:schemaLocation=\"http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd\">

<!--数据源的配置-->
<bean id=\"dataSource\" class=\"org.springframework.jdbc.datasource.DriverManagerDataSource\">
<property name=\"driverClassName\" value=\"com.mysql.cj.jdbc.Driver\"/>
<property name=\"url\" value=\"jdbc:mysql://localhost:3306/yootk\"/>
<property name=\"username\" value=\"root\"/>
<property name=\"password\" value=\"317311\"/>
</bean>
</beans>

2.1.2、测试
import look.word.jdbc.config.DataSourceConfig;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import javax.sql.DataSource;

@ContextConfiguration(classes = DataSourceConfig.class) // 两者二选一即可
//@ContextConfiguration(locations ={\"classpath:data-source.xml\"})
@ExtendWith(SpringExtension.class)
public class TestDataSource {
// 日志工厂对象
private static final Logger LOGGER = LoggerFactory.getLogger(TestDataSource.class);
@Autowired
private DataSource dataSource;
@Test
public void testConnection() throws Exception{
LOGGER.info(\"【数据库连接对象】:{}\",dataSource);
}
}

// 执行结果 输入数据源对象,说明连接成功
// [INFO ] 2022-09-14 12:18:59,307(386) --> [main] look.word.test.TestDataSource.testConnection(TestDataSource.java:29): 【数据库连接对象】:org.springframework.jdbc.datasource.DriverManagerDataSource@535779e4

但是基于这种连接操作的性能是非常一般的,请追随源代码,一探究竟。
一文带你学会Spring JDBC的使用
然后找到我们的AbstractDriverBasedDataSource.getConnection()方法,进入getConnectionFromDriver()方法。
一文带你学会Spring JDBC的使用
找到getConnectionFromDriver(),他是一个抽象方法,然后找到其子类,DriverManagerDataSource
一文带你学会Spring JDBC的使用
然后又会发现,我们回到了DriverManagerDataSource,然后我们在进入getConnectionFromDriverManager方法。
一文带你学会Spring JDBC的使用
最终获取连接的方式,
一文带你学会Spring JDBC的使用
2.1.3、默认连接方式的缺点
​ 这种连接的管理方式,是在每一次 获取连接 的时候 才进行 数据库连接的操作了,那么现在的问题就来了,这样的管理方式好吗 ?首先在数据库连接的处理之中,一定会建立若干个Socket 连接,那么会有耗时,而在数据库关闭的时候也会存在有同样的耗时处理,这样在“次次次高并发”的处理下很难得到有效的控制。所以在实际项目中最佳数据库连接的管理,一定是基于数据库连接池方式实现的。所以此时可以考虑在 Spring 内部去实现一个连接池的维护。早期的数据库连接池组件提供有一个 C3P0组件,但是现在已经停止维护了。

2.2、HikariCP

​ 在实际的项目应用开发过程之中,为了解决JDBC连接与关闭的延时以及性能问题,提供了数据库连接池的解决方案,并且针对于该方案提供了成型的HikariCP服务组件。HikariCP (Hikari来自日文,是“光”的含义)是由日本程序员开源的一个数据库连接池组件,该组件拥有如下特点:

  • 宇节码更加的精简,这样可以在缓存中添加更多的程序代码;
  • 实现了一个无锁集合,减少了并发访问造成的资源竞争问题;
  • 使用了自定义数组类型(FastList)代替了ArrayList,提高了get()与remove()的操作性能;
  • 针对CPU的时间片算法进行了优化,尽可能在一个时间片内完成所有处理操作。

​ 在Spring之中默认推荐的数据库连接池组件就是HikariCP,不建议再使用其他的数据库连接池组件,当然国内也有优秀的CP组件,那么就是阿里推出的Druid(在性能上可能低于HikariCP,但是提供有完整的管理界面),如果要想使用这个组件,可以采用如下的步骤进行配置。
2.2.1、使用
添加依赖:
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>5.0.1</version>
</dependency>

编写配置类:
这次我们再用配置文件的方式,方便扩展
创建配置文件:src/main/profiles/dev/config/database.properties
一文带你学会Spring JDBC的使用
yootk.database.driverClassName=com.mysql.cj.jdbc.Driver
yootk.database.jdbcUrl=jdbc:mysql://localhost:3306/yootk
yootk.database.username=root
yootk.database.password=317311
# 【Hikaricp】配置数据库连接超时时间 单位【毫秒】
yootk.database.connectionTimeOut=3000
# 【Hikaricp】一个连接最小维持的时间 单位【毫秒】
yootk.database.idleTimeOut=3000
# 【Hikaricp】一个连接最长存活的时间 单位【毫秒】
yootk.database.maxLifetime=6000
# 【Hikaricp】最大保存的数据库连接实例
yootk.database.maximumPoolSize=60
# 【Hikaricp】最小保存的数据库连接实例 (在没有任何用户访问时,最少维持的连接数量)
yootk.database.minimumIdle=20
# 【Hikaricp】是否为只读
yootk.database.readOnly=false

创建配置对象
@Configuration
//读取指定位置的资源文件
@PropertySource(\"classpath:config/database.properties\")
public class HikariCpDataSourceConfig {
/**
* 绑定资源文件中的配置数据项
*/
@Value(\"${yootk.database.driverClassName}\")
private String driverClassName;
@Value(\"${yootk.database.jdbcUrl}\")
private String jdbcUrl;
@Value(\"${yootk.database.username}\")
private String username;
@Value(\"${yootk.database.password}\")
private String password;
@Value(\"${yootk.database.connectionTimeOut}\")
private Long connectionTimeOut;
@Value(\"${yootk.database.idleTimeOut}\")
private Long idleTimeOut;
@Value(\"${yootk.database.maxLifetime}\")
private Long maxLifetime;
@Value(\"${yootk.database.maximumPoolSize}\")
private Integer maximumPoolSize;
@Value(\"${yootk.database.minimumIdle}\")
private Integer minimumIdle;
@Value(\"${yootk.database.readOnly}\")
private boolean readOnly;

@Bean(\"dataSource\")
public DataSource dataSource() {
// Hikari连接池数据源
HikariDataSource dataSource = new HikariDataSource();
dataSource.setDriverClassName(driverClassName);
dataSource.setJdbcUrl(jdbcUrl);
dataSource.setUsername(username);
dataSource.setPassword(password);
dataSource.setPassword(password);
// 超时时间
dataSource.setConnectionTimeout(connectionTimeOut);
// 空闲超时
dataSource.setIdleTimeout(idleTimeOut);
// 连接的最长时间
dataSource.setMaxLifetime(maxLifetime);
// 连接池最大数量
dataSource.setMaximumPoolSize(maximumPoolSize);
// 当没有连接时 最小保留的连接数量
dataSource.setMinimumIdle(minimumIdle);
// 是否只读数据库
dataSource.setReadOnly(readOnly);
return dataSource;
}
}

测试类:
import look.word.jdbc.config.HikariCpDataSourceConfig;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import javax.sql.DataSource;
@ContextConfiguration(classes = HikariCpDataSourceConfig.class)
@ExtendWith(SpringExtension.class)
public class TestDataSource {
private static final Logger LOGGER = LoggerFactory.getLogger(TestDataSource.class);

@Autowired
private DataSource dataSource;

@Test
public void testConnection() throws Exception {
LOGGER.info(\"【数据库连接对象】:{}\", dataSource.getConnection());
}
}

​ 如果出错,可以看看日志输入信息。
这样我们就实现了,使用HikariCP获取连接对象了,接下来就会使用HikariCP对具体的数据库进行操作。

2.3、JdbcTempLate

JdbcTempLate的使用很简单,只需要为其指定数据源即可。
我们采用配置类的方式,为其配置数据源
2.3.1、增
添加配置类:
@Configuration
public class JdbcTempLateConfig {
@Bean // 方法形参 会自动从容器中注入对象
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
return jdbcTemplate;
}
}

编写测试类:
@ContextConfiguration(classes = {HikariCpDataSourceConfig.class, JdbcTempLateConfig.class})
@ExtendWith(SpringExtension.class)
public class TestJdbcTempLate {
private static final Logger LOGGER = LoggerFactory.getLogger(TestJdbcTempLate.class);

@Autowired
private JdbcTemplate jdbcTemplate;

@Test
public void testConnection() throws Exception {
String sql = \"insert into book(title,author,price) values(\'java入门\',\'李老师\',99.90)\";
LOGGER.info(\"【插入执行结果】:{}\", jdbcTemplate.update(sql));
}
}

执行结果:
一文带你学会Spring JDBC的使用
这个时候就是用JdbcTemplate轻松地实现了数据的插入操作。
但是,可以发现,我们上面的操作,还是存在问题的,比如没有对sql 进行预处理,会出现 Sql 注入的风险。
2.3.2、改
测试类
@Test
public void testUpdate() {
String sql = \"update yootk.book set title = ? where bid = ?\";
LOGGER.info(\"【插入执行结果】:{}\", jdbcTemplate.update(sql, \"Python入门\", 2));
}

2.3.3、删
测试类
@Test
public void testDelete() {
String sql = \"delete from yootk.book where bid = ?\";
LOGGER.info(\"【插入执行结果】:{}\", jdbcTemplate.update(sql, 2));
}

2.3.4、增 (返回id)
在MySQL数据库里面,有一种功能,可以通过一个next()处理函数获取当前所生成的ID号(主要针对于自动增长列),实际上这个功能主要的目的是为了解决增加数据时的ID返回处理问题了,因为很多的时候需要在数据增加成功之后对指定的ID进行控制,所以才提供了专属的处理函数,Oracle之中直接使用序列即可,但是MySQL的实现就需要专属的处理函数了。.在程序的开发之中,如果要想获取到增长后的ID数据,在SpringJDBC里面提供有了一个KeyHolder接口,在这个接口里面定义了获取主键内容的处理方法。
​ 在平常开发中,我们经常会遇到,插入这个数据后,会需要这个数据的id,然后对其进行一系类操作。
​ 如果要想获取到增长后的ID数据,在SpringJDBC里面提供有了一个KeyHolder接口,在这个接口里面定义了获取主键内容的处理方法。
测试类
@Test
public void testInsertReturnId() {
String sql = \"insert into yootk.book(title,author,price) values(?,?,?)\";
GeneratedKeyHolder keyHolder = new GeneratedKeyHolder(); // 获取KEY的处理信息
int count = jdbcTemplate.update(new PreparedStatementCreator() {
@Override
public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
PreparedStatement ps = con.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS); // 对sql进行预处理
ps.setString(1, \"Springboot实战\");
ps.setString(2, \"老李\");
ps.setDouble(3, 99.00);
return ps;
}
}, keyHolder);
LOGGER.info(\"【插入执行影响行数】:{},当前插入数据的ID:{}\", count, keyHolder.getKey());
}
// 执行结果
// look.word.test.TestJdbcTempLate.testInsertReturnId(TestJdbcTempLate.java:61): 【插入执行影响行数】:1,当前插入数据的ID:4

如果在 PreparedStatement ps = con.prepareStatement(sql);中,没有指定需要返回KEY,则会出现异常。
2.3.5、批处理
一文带你学会Spring JDBC的使用
测试类:
这种方式是基于集合的。
@Test
public void testInsertBatch() {
List<String> titles = List.of(\"Springboot开发实战\", \"SSM开发案例\", \"Netty开发实战\", \"Redis开发实战\");
List<Double> prices = List.of(90.1, 98.9, 78.9, 98.9);
String sql = \"insert into yootk.book(title,author,price) values(?,?,?)\";
this.jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() { // 执行批量插入
//@param i 集合索引
@Override
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setString(1, titles.get(i));
ps.setString(2, \"老李老师\");
ps.setDouble(3, prices.get(i));
}
@Override
public int getBatchSize() {
return titles.size(); //总长度
}
});
}

基于对象
@Test
public void testInsertBatch2() {
List<Object[]> params = List.of(
new Object[]{\"Spring开发实战\", \"11\", 89.0},
new Object[]{\"Spring开发实战1\", \"11\", 89.0},
new Object[]{\"Spring开发实战2\", \"11\", 89.0},
new Object[]{\"Spring开发实战3\", \"11\", 89.0}
);
String sql = \"insert into yootk.book(title,author,price) values(?,?,?)\";
int[] result = jdbcTemplate.batchUpdate(sql, params);//批量插入
System.out.println(\"result = \" + result);
}

2.3.4、查
​ 在数据库操作过程中,除了数据更新操作之外,最为繁琐的就是数据库的查询功能了。由于JdbcTemplate设计的定位属于ORMapping组件,所以就需要在查询完成之后,可以自动的将查询结果转为VO类型的实例,而为了解决该问题,在SpringJDBC中提供了一个RowMapper接口,这个接口可以实现ResultSet向指定对象实例的转换。该接口提供有一个mapRow()处理方法,可以接收查询结果每行数据的结果集,用户可以将指定列取出,并保存在自标VO实例之中
一文带你学会Spring JDBC的使用
查询单个
Book 对象 根据数据库创建
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
private Integer bid;
private String title;
private String author;
private Double price;
}

测试类:
// 查询单个
@Test
public void testQuery() {
String sql = \"select bid, title, author, price from yootk.book where bid = ?\";
Book book = jdbcTemplate.queryForObject(sql, new RowMapper<Book>() {
@Override
public Book mapRow(ResultSet rs, int rowNum) throws SQLException {
Book book = new Book();
book.setBid(rs.getInt(1));
book.setTitle(rs.getString(2));
book.setAuthor(rs.getString(3));
book.setPrice(rs.getDouble(4));
return book;
}
}, 3); // 这里的3 是对预处理数据的回填 多个需按照顺序编写
System.out.println(\"【queryForObject 查询结果】book = \" + book);
}

查询多个
// 查询所有
@Test
public void testQueryAll() {
String sql = \"select bid, title, author, price from yootk.book \";
List<Book> list = jdbcTemplate.query(sql, new RowMapper<Book>() {
@Override
public Book mapRow(ResultSet rs, int rowNum) throws SQLException {
Book book = new Book();
book.setBid(rs.getInt(1));
book.setTitle(rs.getString(2));
book.setAuthor(rs.getString(3));
book.setPrice(rs.getDouble(4));
return book;
}
});
list.stream().forEach(System.out::println);
}

分页查询
// 分页
@Test
public void testQuerySpAll() {
int current = 2; // 页数
int size = 5;// 每页数量
String sql = \"select bid, title, author, price from yootk.book limit ? ,? \";
List<Book> list = jdbcTemplate.query(sql, new RowMapper<Book>() {
@Override
public Book mapRow(ResultSet rs, int rowNum) throws SQLException {
Book book = new Book();
book.setBid(rs.getInt(1));
book.setTitle(rs.getString(2));
book.setAuthor(rs.getString(3));
book.setPrice(rs.getDouble(4));
return book;
}
}, (current - 1) * size, size);
list.stream().forEach(System.out::println);
}

统计行数
// 查询行数
@Test
public void testQueryCount() {
String sql = \"select count(*) from yootk.book where title like ?\";
long count = jdbcTemplate.queryForObject(sql, new RowMapper<Long>() {
@Override
public Long mapRow(ResultSet rs, int rowNum) throws SQLException {
return rs.getLong(1);
}
}, \"%Spring%\");
LOGGER.info(\"【数据库记录总行数】{}\", count);
}

以上就是一文带你学会Spring JDBC的使用的详细内容,更多关于Spring JDBC的资料请关注其它相关文章!

资源下载此资源下载价格为1小猪币,终身VIP免费,请先
由于本站资源来源于互联网,以研究交流为目的,所有仅供大家参考、学习,不存在任何商业目的与商业用途,如资源存在BUG以及其他任何问题,请自行解决,本站不提供技术服务! 由于资源为虚拟可复制性,下载后不予退积分和退款,谢谢您的支持!如遇到失效或错误的下载链接请联系客服QQ:442469558

:本文采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可, 转载请附上原文出处链接。
1、本站提供的源码不保证资源的完整性以及安全性,不附带任何技术服务!
2、本站提供的模板、软件工具等其他资源,均不包含技术服务,请大家谅解!
3、本站提供的资源仅供下载者参考学习,请勿用于任何商业用途,请24小时内删除!
4、如需商用,请购买正版,由于未及时购买正版发生的侵权行为,与本站无关。
5、本站部分资源存放于百度网盘或其他网盘中,请提前注册好百度网盘账号,下载安装百度网盘客户端或其他网盘客户端进行下载;
6、本站部分资源文件是经压缩后的,请下载后安装解压软件,推荐使用WinRAR和7-Zip解压软件。
7、如果本站提供的资源侵犯到了您的权益,请邮件联系: 442469558@qq.com 进行处理!

猪小侠源码-最新源码下载平台 PHP教程 一文带你学会Spring JDBC的使用 http://www.20zxx.cn/586413/xuexijiaocheng/qes.html

猪小侠源码,优质资源分享网

常见问题
  • 本站所有资源版权均属于原作者所有,均只能用于参考学习,请勿直接商用。若由于商用引起版权纠纷,一切责任均由使用者承担
查看详情
  • 最常见的情况是下载不完整: 可对比下载完压缩包的与网盘上的容量,建议提前注册好百度网盘账号,使用百度网盘客户端下载
查看详情

相关文章

官方客服团队

为您解决烦忧 - 24小时在线 专业服务