SpringBoot-默认数据源HikariDataSource对数据库操作及自动装配原理

转x33g5p2x  于2022-05-18 转载在 Spring  
字(8.5k)|赞(0)|评价(0)|浏览(869)

默认数据源HikariDataSource对数据库操作

  1. 在创建项目时选择JDBC以及MySQL驱动，让SpringBoot自动装配所需组件

创建完成后默认的pom.xml文件如下

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.1.7.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  12.     <groupId>com.guih</groupId>
  13.     <artifactId>spring-boot-data-jdbc</artifactId>
  14.     <version>0.0.1-SNAPSHOT</version>
  15.     <name>spring-boot-data-jdbc</name>
  16.     <description>JDBC Demo project for Spring Boot</description>
  18.     <properties>
  19.         <java.version>1.8</java.version>
  20.     </properties>
  22.     <dependencies>
  23.       <!-- SpringBoot集成的JDBC以及数据库连接包 -->
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-jdbc</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>mysql</groupId>
  30.             <artifactId>mysql-connector-java</artifactId>
  31.             <scope>runtime</scope>
  32.         </dependency>
  33.       
  34.       
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-web</artifactId>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.springframework.boot</groupId>
  41.             <artifactId>spring-boot-starter-test</artifactId>
  42.             <scope>test</scope>
  43.         </dependency>
  44.     </dependencies>
  46.     <build>
  47.         <plugins>
  48.             <plugin>
  49.                 <groupId>org.springframework.boot</groupId>
  50.                 <artifactId>spring-boot-maven-plugin</artifactId>
  51.             </plugin>
  52.         </plugins>
  53.     </build>
  55. </project>
  1. 创建 application.yml 文件，配置连接数据库的参数
  1. spring:
  2.   datasource:
  3.     username: root
  4.     password: 123456
  5.     driver-class-name: com.mysql.cj.jdbc.Driver
  6.     url: jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=false
  1. 测试是否能获取到数据源
  1. // 单元测试代码
  2. @RunWith(SpringRunner.class)
  3. @SpringBootTest
  4. public class SpringBootDataJdbcApplicationTests {
  6.     @Autowired
  7.     private DataSource dataSource;
  9.     @Test
  10.     public void test() throws SQLException {
  11.         Connection data = dataSource.getConnection();
  12.       
  13.         System.out.println("------" + data.getClass());
  14.         
  15.         System.out.println("------" + dataSource.getClass());
  16.       
  17.      	  data.close();
  18.     }
  20. }

输出结果如下，数据源获取成功，说明SpringBoot2.1.7默认使用的是Hikari连接池**（SpringBoot2.0之前使用的是tomcat连接池）**

  1. ------class com.zaxxer.hikari.pool.HikariProxyConnection
  2. ------class com.zaxxer.hikari.HikariDataSource

  1. 使用数据源对数据库进行操作

  2. 为了方便测试，这里使用的数据库是本机上的数据库

  1. 编写代码测试访问数据库
  1. @Controller
  2. public class JDBCTest {
  4.     @Autowired
  5.     private JdbcTemplate jdbcTemplate;
  7.     @RequestMapping("/query")
  8.     @ResponseBody
  9.     public Map<String, Object> query() {
  10.         List<Map<String, Object>> list = jdbcTemplate.queryForList("SELECT * FROM test1");
  11.         return list.get(0);
  12.     } 
  13. }
  1. 启动SpringBoot程序并使用Postman进行测试

SpringBoot默认数据源自动装配原理

  1. 参考org.springframework.boot.autoconfigure.jdbc包下的DataSourceConfigration类
  1. package org.springframework.boot.autoconfigure.jdbc;
  3. import javax.sql.DataSource;
  5. import com.zaxxer.hikari.HikariDataSource;
  7. import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
  8. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
  9. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  10. import org.springframework.boot.context.properties.ConfigurationProperties;
  11. import org.springframework.boot.jdbc.DatabaseDriver;
  12. import org.springframework.context.annotation.Bean;
  13. import org.springframework.context.annotation.Configuration;
  14. import org.springframework.util.StringUtils;
  16. abstract class DataSourceConfiguration {
  18. 	@SuppressWarnings("unchecked")
  19. 	protected static <T> T createDataSource(DataSourceProperties properties, Class<? extends DataSource> type) {
  20. 		return (T) properties.initializeDataSourceBuilder().type(type).build();
  21. 	}
  23.   // 根据容器中的情况来进行逻辑判断，添加不同的数据源
  24. 	@Configuration
  25. 	@ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
  26. 	@ConditionalOnMissingBean(DataSource.class)
  27. 	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.tomcat.jdbc.pool.DataSource",
  28. 			matchIfMissing = true)
  29. 	static class Tomcat {
  31. 		@Bean
  32. 		@ConfigurationProperties(prefix = "spring.datasource.tomcat")
  33. 		public org.apache.tomcat.jdbc.pool.DataSource dataSource(DataSourceProperties properties) {
  34. 			org.apache.tomcat.jdbc.pool.DataSource dataSource = createDataSource(properties,
  35. 					org.apache.tomcat.jdbc.pool.DataSource.class);
  36. 			DatabaseDriver databaseDriver = DatabaseDriver.fromJdbcUrl(properties.determineUrl());
  37. 			String validationQuery = databaseDriver.getValidationQuery();
  38. 			if (validationQuery != null) {
  39. 				dataSource.setTestOnBorrow(true);
  40. 				dataSource.setValidationQuery(validationQuery);
  41. 			}
  42. 			return dataSource;
  43. 		}
  45. 	}
  47. 	@Configuration
  48. 	@ConditionalOnClass(HikariDataSource.class)
  49. 	@ConditionalOnMissingBean(DataSource.class)
  50. 	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource",
  51. 			matchIfMissing = true)
  52. 	static class Hikari {
  54. 		@Bean
  55. 		@ConfigurationProperties(prefix = "spring.datasource.hikari")
  56. 		public HikariDataSource dataSource(DataSourceProperties properties) {
  57. 			HikariDataSource dataSource = createDataSource(properties, HikariDataSource.class);
  58. 			if (StringUtils.hasText(properties.getName())) {
  59. 				dataSource.setPoolName(properties.getName());
  60. 			}
  61. 			return dataSource;
  62. 		}
  64. 	}
  66.   // 也可以指定其他的数据源
  67. 	@Configuration
  68. 	@ConditionalOnClass(org.apache.commons.dbcp2.BasicDataSource.class)
  69. 	@ConditionalOnMissingBean(DataSource.class)
  70. 	@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "org.apache.commons.dbcp2.BasicDataSource",
  71. 			matchIfMissing = true)
  72. 	static class Dbcp2 {
  74. 		@Bean
  75. 		@ConfigurationProperties(prefix = "spring.datasource.dbcp2")
  76. 		public org.apache.commons.dbcp2.BasicDataSource dataSource(DataSourceProperties properties) {
  77. 			return createDataSource(properties, org.apache.commons.dbcp2.BasicDataSource.class);
  78. 		}
  80. 	}
  82. 	@Configuration
  83. 	@ConditionalOnMissingBean(DataSource.class)
  84. 	@ConditionalOnProperty(name = "spring.datasource.type")
  85. 	static class Generic {
  87. 		@Bean
  88. 		public DataSource dataSource(DataSourceProperties properties) {
  89.       // 使用DataSourceBuilder创建数据源，利用反射创建响应type的数据源，并且绑定相关属性
  90. 			return properties.initializeDataSourceBuilder().build();
  91. 		}
  93. 	}
  95. }

从代码中可以看出SpringBoot是根据用户的配置来自动配置不同的数据源，目前支持的数据源有以下三种

  1. com.zaxxer.hikari.HikariDataSource （Spring Boot 2.0 以上，默认使用此数据源）
  3. org.apache.tomcat.jdbc.pool.DataSource
  5. org.apache.commons.dbcp2.BasicDataSource

还可以在配置文件中使用 “spring.datasource.type” 属性来配置用户指定的数据源

  1. 在同一个包下的另一个类 DataSourceInitializer，当我们要在SpringBoot启动时运行sql建表语句或插入数据时就会用得上
  1. // DataSourceInitializer类部分代码
  3. public boolean createSchema() {
  4. 		List<Resource> scripts = getScripts("spring.datasource.schema", this.properties.getSchema(), "schema");
  5. 		if (!scripts.isEmpty()) {
  6. 			if (!isEnabled()) {
  7. 				logger.debug("Initialization disabled (not running DDL scripts)");
  8. 				return false;
  9. 			}
  10. 			String username = this.properties.getSchemaUsername();
  11. 			String password = this.properties.getSchemaPassword();
  12. 			runScripts(scripts, username, password);
  13. 		}
  14. 		return !scripts.isEmpty();
  15. 	}
  17. 	public void initSchema() {
  18. 		List<Resource> scripts = getScripts("spring.datasource.data", this.properties.getData(), "data");
  19. 		if (!scripts.isEmpty()) {
  20. 			if (!isEnabled()) {
  21. 				logger.debug("Initialization disabled (not running data scripts)");
  22. 				return;
  23. 			}
  24. 			String username = this.properties.getDataUsername();
  25. 			String password = this.properties.getDataPassword();
  26. 			runScripts(scripts, username, password);
  27. 		}
  28. 	}
  30. 	private void runScripts(List<Resource> resources, String username, String password) {
  31. 		if (resources.isEmpty()) {
  32. 			return;
  33. 		}
  34. 		ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
  35. 		populator.setContinueOnError(this.properties.isContinueOnError());
  36. 		populator.setSeparator(this.properties.getSeparator());
  37. 		if (this.properties.getSqlScriptEncoding() != null) {
  38. 			populator.setSqlScriptEncoding(this.properties.getSqlScriptEncoding().name());
  39. 		}
  40. 		for (Resource resource : resources) {
  41. 			populator.addScript(resource);
  42. 		}
  43. 		DataSource dataSource = this.dataSource;
  44. 		if (StringUtils.hasText(username) && StringUtils.hasText(password)) {
  45. 			dataSource = DataSourceBuilder.create(this.properties.getClassLoader())
  46. 					.driverClassName(this.properties.determineDriverClassName()).url(this.properties.determineUrl())
  47. 					.username(username).password(password).build();
  48. 		}
  49. 		DatabasePopulatorUtils.execute(populator, dataSource);
  50. 	}

从代码中可以看出SpringBoot会从配置文件中读取 “spring.datasource.schema” 属性用于数据库建表，读取 “spring.datasource.data” 属性用于写入数据，所以在需要程序在创建时运行sql文件可以通过这个参数来配置

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://lebron.blog.csdn.net/article/details/124832590

内容来源于网络，如有侵权，请联系作者删除！

Javaspringboot数据库

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com