SpringBoot——数据访问

最新推荐文章于 2024-10-20 18:44:38 发布
最新推荐文章于 2024-10-20 18:44:38 发布
阅读量518 收藏 1
点赞数
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/rubulai/article/details/84311369
版权

一、SpringBoot的数据访问方式
  对于数据访问层，无论是SQL还是NOSQL，SpringBoot默认采用整合SpringData的方式进行统一处理，SpringBoot中添加了大量的自动配置，屏蔽了很多设置。引入各种XxxTemplate，XxxRepository来简化我们对数据访问层的操作，对我们来说只需要进行简单的设置即可。

二、SpringBoot整合JDBC
 1、创建项目，引入Jdbc的启动器和Mysql驱动

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<scope>runtime</scope>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

 2、在application.properties或application.yml中配置数据库连接

spring:
  datasource:
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.2.107:3306/docker_jdbc

 3、测试数据源配置

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootJdbcApplicationTests {

    @Autowired
    DataSource dataSource;
    @Test
    public void contextLoads() {
        try {
            System.out.print(">>>>>" + dataSource.getClass());
            Connection connection = dataSource.getConnection();
            System.out.print(">>>>>"+connection);
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

 结果：

>>>>>class com.zaxxer.hikari.HikariDataSource
>>>>>>HikariProxyConnection@886386381

  低版本的SpringBoot使用org.apache.tomcat.jdbc.pool.DataSource作为默认数据源

三、自动配置原理
  数据源的相关属性配置都在DataSourceProperties类里面，数据源自动配置相关的类都在org.springframework.boot.autoconfigure.jdbc包下：
在这里插入图片描述
 1、数据源的配置类DataSourceConfiguration，该类会根据我们的配置决定使用哪种数据源，默认使用org.apache.tomcat.jdbc.pool.DataSource作为数据源：可以使用spring.datasource.type来改变数据源类型，比如改为c3p0

abstract class DataSourceConfiguration {

	@SuppressWarnings("unchecked")
	protected static <T> T createDataSource(DataSourceProperties properties,
			Class<? extends DataSource> type) {
		return (T) properties.initializeDataSourceBuilder().type(type).build();
	}

	/**
	 * Tomcat Pool DataSource configuration.
	 */
	@ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.tomcat.jdbc.pool.DataSource", matchIfMissing = true)//没有该项配置时，默认使用org.apache.tomcat.jdbc.pool.DataSource
	static class Tomcat {

		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.tomcat")
		public org.apache.tomcat.jdbc.pool.DataSource dataSource(
				DataSourceProperties properties) {
			org.apache.tomcat.jdbc.pool.DataSource dataSource = createDataSource(
					properties, org.apache.tomcat.jdbc.pool.DataSource.class);
			DatabaseDriver databaseDriver = DatabaseDriver
					.fromJdbcUrl(properties.determineUrl());
			String validationQuery = databaseDriver.getValidationQuery();
			if (validationQuery != null) {
				dataSource.setTestOnBorrow(true);
				dataSource.setValidationQuery(validationQuery);
			}
			return dataSource;
		}

	}

	/**
	 * Hikari DataSource configuration.
	 */
	@ConditionalOnClass(HikariDataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource", matchIfMissing = true)
	static class Hikari {

		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.hikari")
		public HikariDataSource dataSource(DataSourceProperties properties) {
			return createDataSource(properties, HikariDataSource.class);
		}

	}

	/**
	 * DBCP DataSource configuration.
	 *
	 * @deprecated as of 1.5 in favor of DBCP2
	 */
	@ConditionalOnClass(org.apache.commons.dbcp.BasicDataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.commons.dbcp.BasicDataSource", matchIfMissing = true)
	@Deprecated
	static class Dbcp {

		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.dbcp")
		public org.apache.commons.dbcp.BasicDataSource dataSource(
				DataSourceProperties properties) {
			org.apache.commons.dbcp.BasicDataSource dataSource = createDataSource(
					properties, org.apache.commons.dbcp.BasicDataSource.class);
			DatabaseDriver databaseDriver = DatabaseDriver
					.fromJdbcUrl(properties.determineUrl());
			String validationQuery = databaseDriver.getValidationQuery();
			if (validationQuery != null) {
				dataSource.setTestOnBorrow(true);
				dataSource.setValidationQuery(validationQuery);
			}
			return dataSource;
		}

	}

	/**
	 * DBCP DataSource configuration.
	 */
	@ConditionalOnClass(org.apache.commons.dbcp2.BasicDataSource.class)
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.commons.dbcp2.BasicDataSource", matchIfMissing = true)
	static class Dbcp2 {

		@Bean
		@ConfigurationProperties(prefix = "spring.datasource.dbcp2")
		public org.apache.commons.dbcp2.BasicDataSource dataSource(
				DataSourceProperties properties) {
			return createDataSource(properties,
					org.apache.commons.dbcp2.BasicDataSource.class);
		}

	}

	/**
	 * Generic DataSource configuration.
	 */
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type")
	static class Generic {

		@Bean
		public DataSource dataSource(DataSourceProperties properties){
			return properties.initializeDataSourceBuilder().build();
		}

	}
}

  SpringBoot默认支持的数据源类型有：

org.apache.tomcat.jdbc.pool.DataSource
com.zaxxer.hikari.HikariDataSource
org.apache.commons.dbcp.BasicDataSource//即dbcp
org.apache.commons.dbcp2.BasicDataSource//即dbcp2

  SpringBoot也支持自定义数据源：使用DataSourceBuilder创建数据源，利用反射创建相应type的数据源，并且绑定相关属性

@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type")
static class Generic {

	@Bean
	public DataSource dataSource(DataSourceProperties properties) {
		return properties.initializeDataSourceBuilder().build();
	}

}

 2、数据源的自动配置类DataSourceAutoConfiguration：在该类中有一个DataSourceInitializer，可用来初始化数据：

/**
 * Bean to handle {@link DataSource} initialization by running {@literal schema-*.sql} on
 * {@link PostConstruct} and {@literal data-*.sql} SQL scripts on a
 * {@link DataSourceInitializedEvent}.
 *
 * @author Dave Syer
 * @author Phillip Webb
 * @author Eddú Meléndez
 * @author Stephane Nicoll
 * @author Kazuki Shimizu
 * @since 1.1.0
 * @see DataSourceAutoConfiguration
 */
class DataSourceInitializer implements ApplicationListener<DataSourceInitializedEvent> {

	private static final Log logger = LogFactory.getLog(DataSourceInitializer.class);

	private final DataSourceProperties properties;

	private final ApplicationContext applicationContext;

	private DataSource dataSource;

	private boolean initialized = false;

	DataSourceInitializer(DataSourceProperties properties,
			ApplicationContext applicationContext) {
		this.properties = properties;
		this.applicationContext = applicationContext;
	}

	@PostConstruct
	public void init() {
		if (!this.properties.isInitialize()) {
			logger.debug("Initialization disabled (not running DDL scripts)");
			return;
		}
		if (this.applicationContext.getBeanNamesForType(DataSource.class, false,
				false).length > 0) {
			this.dataSource = this.applicationContext.getBean(DataSource.class);
		}
		if (this.dataSource == null) {
			logger.debug("No DataSource found so not initializing");
			return;
		}
		runSchemaScripts();
	}

	private void runSchemaScripts() {
		List<Resource> scripts = getScripts("spring.datasource.schema",
				this.properties.getSchema(), "schema");
		if (!scripts.isEmpty()) {
			String username = this.properties.getSchemaUsername();
			String password = this.properties.getSchemaPassword();
			runScripts(scripts, username, password);
			try {
				this.applicationContext
						.publishEvent(new DataSourceInitializedEvent(this.dataSource));
				// The listener might not be registered yet, so don't rely on it.
				if (!this.initialized) {
					runDataScripts();
					this.initialized = true;
				}
			}
			catch (IllegalStateException ex) {
				logger.warn("Could not send event to complete DataSource initialization ("
						+ ex.getMessage() + ")");
			}
		}
	}

	@Override
	public void onApplicationEvent(DataSourceInitializedEvent event) {
		if (!this.properties.isInitialize()) {
			logger.debug("Initialization disabled (not running data scripts)");
			return;
		}
		// NOTE the event can happen more than once and
		// the event datasource is not used here
		if (!this.initialized) {
			runDataScripts();
			this.initialized = true;
		}
	}

	private void runDataScripts() {
		List<Resource> scripts = getScripts("spring.datasource.data",
				this.properties.getData(), "data");
		String username = this.properties.getDataUsername();
		String password = this.properties.getDataPassword();
		runScripts(scripts, username, password);
	}

	private List<Resource> getScripts(String propertyName, List<String> resources,
			String fallback) {
		if (resources != null) {
			return getResources(propertyName, resources, true);
		}
		String platform = this.properties.getPlatform();
		List<String> fallbackResources = new ArrayList<String>();
		fallbackResources.add("classpath*:" + fallback + "-" + platform + ".sql");
		fallbackResources.add("classpath*:" + fallback + ".sql");
		return getResources(propertyName, fallbackResources, false);
	}

	private List<Resource> getResources(String propertyName, List<String> locations,
			boolean validate) {
		List<Resource> resources = new ArrayList<Resource>();
		for (String location : locations) {
			for (Resource resource : doGetResources(location)) {
				if (resource.exists()) {
					resources.add(resource);
				}
				else if (validate) {
					throw new ResourceNotFoundException(propertyName, resource);
				}
			}
		}
		return resources;
	}

	private Resource[] doGetResources(String location) {
		try {
			SortedResourcesFactoryBean factory = new SortedResourcesFactoryBean(
					this.applicationContext, Collections.singletonList(location));
			factory.afterPropertiesSet();
			return factory.getObject();
		}
		catch (Exception ex) {
			throw new IllegalStateException("Unable to load resources from " + location,
					ex);
		}
	}

	private void runScripts(List<Resource> resources, String username, String password) {
		if (resources.isEmpty()) {
			return;
		}
		ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
		populator.setContinueOnError(this.properties.isContinueOnError());
		populator.setSeparator(this.properties.getSeparator());
		if (this.properties.getSqlScriptEncoding() != null) {
			populator.setSqlScriptEncoding(this.properties.getSqlScriptEncoding().name());
		}
		for (Resource resource : resources) {
			populator.addScript(resource);
		}
		DataSource dataSource = this.dataSource;
		if (StringUtils.hasText(username) && StringUtils.hasText(password)) {
			dataSource = DataSourceBuilder.create(this.properties.getClassLoader())
					.driverClassName(this.properties.determineDriverClassName())
					.url(this.properties.determineUrl()).username(username)
					.password(password).build();
		}
		DatabasePopulatorUtils.execute(populator, dataSource);
	}

}

 该类中有两个方法：
  ①runSchemaScripts()：先执行，可运行建表语句
  ②runDataScripts()：后执行，可运行插入数据的等语句
 根据该类的注释可看出我们只需要将文件命名为：

schema‐*.sql或data‐*.sql

 默认情况下使用schema.sql或者schema-all.sql来命名，并把该sql文件放在类路径的根目录下，在项目启动的时候就会加载并执行sql文件中的sql进行建表等操作：
在这里插入图片描述
 上面是使用的SpringBoot默认的命名方式，我们也可以通过设置spring.datasource.schema来设置这些sql文件的名称和位置：data也是一样

spring:
  datasource:
    schema:
      - classpath:department.sql
      - classpath:employee.sql

 3、进行数据库操作的配置类JdbcTemplateAutoConfiguration：在该类中SpringBoot在容器中添加了JdbcTemplate和NamedParameterJdbcTemplate：我们在使用的时候直接使用@Autowired注入即可

@Configuration
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnSingleCandidate(DataSource.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class JdbcTemplateAutoConfiguration {

	private final DataSource dataSource;

	public JdbcTemplateAutoConfiguration(DataSource dataSource) {
		this.dataSource = dataSource;
	}

	@Bean
	@Primary
	@ConditionalOnMissingBean(JdbcOperations.class)
	public JdbcTemplate jdbcTemplate() {
		return new JdbcTemplate(this.dataSource);
	}

	@Bean
	@Primary
	@ConditionalOnMissingBean(NamedParameterJdbcOperations.class)
	public NamedParameterJdbcTemplate namedParameterJdbcTemplate() {
		return new NamedParameterJdbcTemplate(this.dataSource);
	}
}

  举例如下：

@RestController
public class JdbcController {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @RequestMapping("/query")
    public Map<String, Object> query() {
        List<Map<String, Object>> list = (List<Map<String, Object>>) jdbcTemplate.queryForList("select * from department");
        return list.get(0);
    }
}
深入理解Spring Boot中的数据访问层设计
省赚客开发者博客
07-07 439
在上述示例中，UserService类中的updateUserEmail方法使用了@Transactional注解，确保了在方法执行期间的数据操作是在一个事务中进行的。如果方法抛出异常，则事务会回滚到之前的状态，确保数据的一致性。Spring Boot为开发者提供了强大的数据访问支持，通过简化的配置和强大的ORM工具（如Spring Data JPA）来提高开发效率和系统性能。Spring Data JPA是Spring提供的一个用于简化JPA开发的框架，它通过提供标准化的数据访问方式来简化开发者的工作。
SpringBoot避坑指南（二）——构建数据访问层
luomo0203的博客
08-29 260
一、JDBC规范 1.1 JDBC简介 JDBC 是 Java Database Connectivity 的全称，它的设计初衷是提供一套能够应用于各种数据库的统一标准，这套标准需要不同数据库厂家之间共同遵守，并提供各自的实现方案供 JDBC 应用程序调用。 作为一套统一标准，JDBC 规范具备完整的架构体系，如下图所示： 从上图中可以看到，Java 应用程序通过 JDBC 所提供的 API 进行数据访问，而这些 API 中包含了开发人员所需要掌握的各个核心编程对象，下面我们一起来看下。 1.2 JDBC
SpringBoot（3）之SpringBoot访问数据库
Karen博客
10-19 1万+
SpringBoot_3 SpringBoot访问数据库
Springboot入门之数据访问层
Clare Tung
12-20 3427
一、Springboot整合使用jdbcTemplete 1.pom文件引入 org.springframework.boot spring-boot-starter-parent 1.5.2.RELEASE org.springframework.boot
Spring Boot - 构建数据访问层
热门推荐
小工匠
05-16 2万+
文章目录基础规范： JDBC 关系型数据库访问规范JDBC 规范中的核心编程对象DriverManagerDataSourceConnectionStatement/PreparedStatementResultSet如何使用 JDBC 规范访问数据库数据访问: JdbcTemplate 访问关系型数据库 基础规范： JDBC 关系型数据库访问规范 我们将进入 Spring Boot 另一个核心技术体系的讨论，即数据访问技术体系。无论是互联网应用还是传统软件，对于任何一个系统而言，数据的存储和访问都是不
超详细讲解SpringBoot——数据访问
m0_45270667的博客
09-28 843
前言： 大部分系统都离不开数据访问，数据库包括SQL和NOSQL，SQL是指关系型数据库，常见的有SQL Server，Oracle，MySQL(开源)，NOSQL是泛指非关系型数据库，常见的有MongoDB，Redis。 用spring开发时我们常用的ORM框架有JDBC、Mybatis，Hibernate，现在最常用的应该是Mybatis。 在Springboot中对于数据访问层，无论是SQL还是NOSQL，都默认采用整合Spring Data的方式进行统一处理，Springboot会帮我们添加大量自动
springboot默认数据源如何设置连接数_超详细讲解SpringBoot——数据访问
weixin_39942995的博客
11-20 2922
一、引言大部分系统都离不开数据访问，数据库包括SQL和NOSQL，SQL是指关系型数据库，常见的有SQL Server，Oracle，MySQL(开源)，NOSQL是泛指非关系型数据库，常见的有MongoDB，Redis。用spring开发时我们常用的ORM框架有JDBC、Mybatis，Hibernate，现在最常用的应该是Mybatis。在Springboot中对于数据访问层，无论是SQL还是...
SpringBoot——什么是SpringBoot、SpringBoot入门、创建SpringBoot
12-21
3. 自动配置：SpringBoot根据项目依赖自动配置相关组件，如数据源、缓存、消息等，大大减少了XML配置。 4. 命令行工具：提供命令行接口（CLI）工具，方便进行快速原型开发。 5. 打包可执行的JAR：SpringBoot应用可以...
springboot——员工管理系统源码
01-15
在系统架构层面，SpringBoot的模块化设计使得我们可以清晰地划分业务层、数据访问层、控制层等。例如，业务层（Service层）负责处理业务逻辑，常使用`@Service`注解标记；数据访问层（Repository层）通过`@...
SpringBoot简介及整合数据访问层
Talk is cheap,show me the code!
05-28 474
SpringBoot简介、整合mybatis、mybatis-plus、redis
三、SpringBoot整合数据库访问层
qq23001186的博客
03-22 1190
目录一、springboot整合使用JdbcTemplate二、整合mybatis框架查询三、整合mybatis框架插入 一、springboot整合使用JdbcTemplate 1.pom依赖 <!--SpringBoot整合jdbc模板框架--> <dependency> <groupId>org.springframework.boot</groupId> <art
Spring Boot 数据访问层详解：使用Spring Data JPA简化数据库操作
阿里渣渣java研发组-群主
05-31 864
Spring Data JPA是Spring Data项目的一部分，旨在简化基于JPA（Java Persistence API）的数据访问层开发。它通过提供一组通用的Repository接口，使得我们可以快速实现基本的CRUD操作，同时还支持复杂查询、分页和排序等功能。
【SpringBoot2】开发实用篇-数据层解决方案（NoSQL）
亮点菌
10-01 1845
本章节主要内容都是和数据存储与读取相关，前期学习的知识与数据层有关的技术基本上都围绕在数据库这个层面上，所以本章要讲的第一个大的分支就是SQL解决方案相关的内容，除此之外，数据的来源还可以是非SQL技术相关的数据操作
Springboot 三层架构（Controller（控制层）、Dao（数据访问层）、Service（业务逻辑层））
最新发布
weixin_68576312的博客
10-20 7532
客户端向服务端发起请求，由控制层接收并调用业务逻辑层中的方法，在处理逻辑时会对数据库中的数据进行调用，这时就要去调用数据访问层数据访问层将会把查询到的数据进行传递给业务逻辑层，而此时的数据需要做逻辑处理，处理完毕之后，在传递给控制层，这时客户端的数据已经拿到了，但是不能直接去传递，需要将数据以HTTP协议的规范进行传递（可以直接创建一个Result类进行单独处理），规范完之后，在传递给客户端。注意：上述中的“传递。
开发一个SpringBoot数据访问项目
AI天才研究院
01-31 35
1.背景介绍 2 开发一个 Spring Boot 数据访问项目 作者：禅与计算机程序设计艺术 1. 背景介绍 随着互联网时代的到来，越来越多的企业和组织开始将自己的业务转移到网络平台上，从而带来了对数据处理和管理的巨
SpringBoot数据访问
戚爱斌
06-24 309
1.整合jdbc 2.整合数据源 3.整合mybatis 注解版 4.整合mybatis xml配置版 5.整合PageHelper 6.输出调试信息 1.整合jdbc 理解原理 默认是用org.apache.tomcat.jdbc.pool.DataSource作为数据源；数据源的相关配置都在DataSourceProperties里面；自动配置原理：org.springfra...
springboot的数据访问
ShaneHolmes
04-29 1388
Spring_Boot专栏 上一篇 主目录 下一篇 目录 【前言】
boot spring 插入一条数据_超详细讲解SpringBoot——数据访问
06-10
好的，关于在 Spring Boot 中插入一条数据，我们可以按照以下步骤进行操作： 1. 首先，我们需要在 pom.xml 中引入 Spring Boot 的相关依赖，包括 Spring Boot Starter 和 Spring Boot Starter Data JPA，如下所示： ```xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> </dependencies> ``` 2. 在 application.properties 或 application.yml 配置文件中，配置数据库连接信息，例如： ```properties spring.datasource.url=jdbc:mysql://localhost:3306/test spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.jdbc.Driver ``` 3. 创建一个实体类，用于映射数据库中的表结构，例如： ```java @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private Integer age; // 省略 getter 和 setter 方法 } ``` 4. 创建一个 Repository 接口，用于操作数据库，例如： ```java @Repository public interface UserRepository extends JpaRepository<User, Long> { } ``` 5. 在业务逻辑中调用 UserRepository 的 save() 方法即可插入一条数据，例如： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public void addUser() { User user = new User(); user.setName("张三"); user.setAge(20); userRepository.save(user); } } ``` 以上就是在 Spring Boot 中插入一条数据的详细步骤。需要注意的是，在实际开发中，我们需要根据具体的业务需求进行适当的调整，例如增加数据校验、事务管理等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值