首页 > 软件编程 > java > SpringBoot整合数据源

在SpringBoot中整合数据源的示例详解

2023-06-29 15:06:07 作者：万猫学社

这篇文章主要介绍了在SpringBoot中如何整合数据源,本文介绍了如何在SpringBoot项目中整合常见的数据源，包括JdbcTemplate、MyBatis和JPA，并探讨了如何配置和使用多数据源，需要的朋友可以参考下

在企业级应用开发中，数据存储是必不可少的一环。为了简化数据访问层的开发，SpringBoot提供了对多种数据源的整合支持。本文将介绍如何在SpringBoot项目中整合常见的数据源，包括JdbcTemplate、MyBatis和JPA，并探讨如何配置和使用多数据源。

1. 数据源的选择与配置

1.1. 常见的数据源类型

在Java开发中，常见的数据源类型有以下几种：

JDBC：Java数据库连接，是Java访问数据库的标准API。使用JDBC可以直接操作数据库，但需要编写大量的SQL语句和处理结果集，开发效率较低。
JdbcTemplate：基于JDBC的一个封装库，简化了JDBC的使用，提高了开发效率。
MyBatis：一个优秀的持久层框架，支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。
JPA：Java持久化API，是一种ORM（对象关系映射）规范，实现了对象模型和关系型数据库之间的映射。Hibernate是JPA的一种实现。

1.2. 数据源配置文件的编写

在SpringBoot项目中，我们通常在application.properties或application.yml文件中配置数据源。以下是一个典型的数据源配置示例：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

其中，url指定了数据库的连接地址，username和password分别表示数据库的用户名和密码，driver-class-name是数据库驱动类的全限定名。

1.3. SpringBoot自动配置数据源的原理

在SpringBoot中，数据源的配置得到了极大的简化，这得益于其自动配置的特性。一旦我们在项目中添加了相应的依赖并正确配置了数据源信息，SpringBoot便会自动创建一个DataSource对象，并将其注册到Spring容器中，从而实现了数据源的自动化管理。

具体而言，SpringBoot会根据项目中的依赖来智能选择合适的数据源实现。例如，如果项目中引入了HikariCP、Tomcat连接池或者C3P0等依赖，SpringBoot会自动选择并使用这些数据源实现。而在没有引入这些依赖的情况下，SpringBoot则会采用默认的数据源实现。

通过这种方式，SpringBoot为我们提供了一种简洁、高效的数据源配置方法，使得我们能够更专注于业务逻辑的实现，而无需过多关注底层的数据源配置细节。

2. SpringBoot整合JdbcTemplate

2.1. JdbcTemplate的简介与作用

JdbcTemplate是Spring框架中提供的一个简化JDBC操作的工具类，它可以帮助我们避免编写大量的重复代码，提高开发效率。JdbcTemplate主要提供了以下功能：

简化数据库连接的获取和释放；
简化SQL语句的执行；
简化结果集的处理。

2.2. 在SpringBoot中配置JdbcTemplate

要在SpringBoot项目中使用JdbcTemplate，首先需要引入相关依赖：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

然后，在配置文件中配置数据源信息，如前文所述。

最后，在需要使用JdbcTemplate的地方，通过@Autowired注解注入JdbcTemplate对象：

@Autowired
private JdbcTemplate jdbcTemplate;

2.3. 使用JdbcTemplate进行数据库操作

使用JdbcTemplate进行数据库操作非常简单，以下是一个简单的示例：

public List<User> findAllUsers() {
  String sql = "SELECT * FROM user";
  return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
}

在这个示例中，我们使用JdbcTemplate的query方法执行了一个查询语句，并将结果集映射为User对象的列表。这里使用了BeanPropertyRowMapper作为结果集的映射器，它会自动将结果集中的列映射到Java对象的属性上。

3. SpringBoot整合MyBatis

3.1. MyBatis的简介与作用

MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis的主要特点包括：

灵活的SQL编写，支持动态SQL；
易于集成，可以与Spring、SpringBoot等框架无缝集成；
支持多种数据库和多种数据源；
提供了丰富的映射类型，支持一对一、一对多等关联查询。

3.2. 在SpringBoot中配置MyBatis

要在SpringBoot项目中使用MyBatis，首先需要引入相关依赖：

<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>2.1.4</version>
</dependency>

然后，在配置文件中配置数据源信息和MyBatis的相关配置，例如：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  mybatis:
    mapper-locations: classpath:mapper/*.xml
    type-aliases-package: com.example.demo.entity

其中，mapper-locations指定了MyBatis的映射文件的位置，type-aliases-package指定了实体类的包名。

3.3. 使用MyBatis进行数据库操作

使用MyBatis进行数据库操作需要编写Mapper接口和映射文件。以下是一个简单的示例：

编写Mapper接口：

public interface UserMapper {
  List<User> findAll();
}

编写映射文件：

<mapper namespace="com.example.demo.mapper.UserMapper">
  <select id="findAll" resultType="User">
    SELECT * FROM user
  </select>
</mapper>

在需要使用UserMapper的地方，通过@Autowired注解注入UserMapper对象：

@Autowired
private UserMapper userMapper;

调用UserMapper的方法进行数据库操作：

public List<User> findAllUsers() {
  return userMapper.findAll();
}

4. SpringBoot整合JPA

4.1. JPA的简介与作用

JPA（Java Persistence API）是Java EE 5规范中的持久化规范，它的目的是简化实体Bean的持久化操作。JPA的主要特点包括：

提供了一种基于注解的对象关系映射；
支持多种数据库和多种数据源；
提供了丰富的查询方式，包括JPQL（Java Persistence Query Language）和Criteria API；
支持事务管理。

4.2. 在SpringBoot中配置JPA

要在SpringBoot项目中使用JPA，首先需要引入相关依赖：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

然后，在配置文件中配置数据源信息和JPA的相关配置，例如：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

其中，ddl-auto表示Hibernate的自动建表策略，show-sql表示是否打印SQL语句。

4.3. 使用JPA进行数据库操作

使用JPA进行数据库操作需要编写实体类和Repository接口。以下是一个简单的示例：

编写实体类：

@Entity
@Table(name = "user")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String name;
  private Integer age;
  // 省略getter和setter方法
}

编写Repository接口：

public interface UserRepository extends JpaRepository<User, Long> {
}

在需要使用UserRepository的地方，通过@Autowired注解注入UserRepository对象：

@Autowired
private UserRepository userRepository;

调用UserRepository的方法进行数据库操作：

public List<User> findAllUsers() {
  return userRepository.findAll();
}

5. 多数据源的配置与使用

5.1. 在SpringBoot中配置多数据源

在某些场景下，我们需要在一个项目中使用多个数据源。要在SpringBoot中配置多数据源，首先需要在配置文件中配置多个数据源的信息，例如：

spring:
  datasource:
    primary:
      url: jdbc:mysql://localhost:3306/test1
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
    secondary:
      url: jdbc:mysql://localhost:3306/test2
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver

然后，需要编写一个配置类，用于创建多个数据源对象：

@Configuration
public class DataSourceConfig {
  @Bean
  @Primary
  @ConfigurationProperties(prefix = "spring.datasource.primary")
  public DataSource primaryDataSource() {
    return DataSourceBuilder.create().build();
  }
  @Bean
  @ConfigurationProperties(prefix = "spring.datasource.secondary")
  public DataSource secondaryDataSource() {
    return DataSourceBuilder.create().build();
  }
}

5.2. 使用多数据源进行数据库操作

在配置了多数据源之后，我们可以在不同的场景下使用不同的数据源。以下是一个使用多数据源的示例：

编写一个Service类，用于操作不同的数据源：

@Service
public class UserService {
  @Autowired
  @Qualifier("primaryJdbcTemplate")
  private JdbcTemplate primaryJdbcTemplate;
  @Autowired
  @Qualifier("secondaryJdbcTemplate")
  private JdbcTemplate secondaryJdbcTemplate;
  public List<User> findAllUsersFromPrimary() {
    String sql = "SELECT * FROM user";
    return primaryJdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
  }
  public List<User> findAllUsersFromSecondary() {
    String sql = "SELECT * FROM user";
    return secondaryJdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
  }
}

在需要使用多数据源的地方，调用UserService的方法进行数据库操作：

public List<User> findAllUsers() {
  List<User> primaryUsers = userService.findAllUsersFromPrimary();
  List<User> secondaryUsers = userService.findAllUsersFromSecondary();
  return Stream.concat(primaryUsers.stream(), secondaryUsers.stream()).collect(Collectors.toList());
}

总结

本文介绍了如何在SpringBoot项目中整合常见的数据源，包括JdbcTemplate、MyBatis和JPA，并探讨了如何配置和使用多数据源。通过使用SpringBoot提供的自动配置和简化的API，我们可以轻松地在项目中使用不同的数据源，提高开发效率。

到此这篇关于在SpringBoot中整合数据源的示例详解的文章就介绍到这了,更多相关SpringBoot整合数据源内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！