SpringBoot 整合JPA

Dear 丶 2022-04-25 09:42 377阅读 0赞

### 一、SpringBoot 整合JPA ###

Spring Boot 底层使用 Spring Data 来访问数据库，Spring Data JPA 等于在ORM之上又进行了一次封装，但具体的对数据库的访问依然要依赖于底层的ORM框架，Spring Data JPA 默认是通过 Hibernate 实现的。

**传送门：[Spring Data JPA和介绍和使用。][Spring Data JPA]**

**1、在创建SpringBoot 的项目时，选择mysql，JPA，web的组件，或者自己手动在maven中添加库依赖：**

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.21</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.13</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>

**2、在 application.yml（或aproperties）中添加相应的配置：**

server.port=80
    
    spring.datasource.url=jdbc:mysql://localhost:3306/my_springboot?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    
    # JPA配置
    spring.jpa.database=mysql
    # 数据库平台
    spring.jpa.database-platform=mysql
    # 每次启动项目时，数据库初始化策略
    spring.jpa.hibernate.ddl-auto=update
    # 指定默认的存储引擎为InnoDB
    spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
    # 在控制台打印SQL
    spring.jpa.properties.hibernate.show_sql=true
    spring.jpa.properties.hibernate.format_sql=true

**3、新建一个model, dao类:**

在测试类中测试，所以 service 和controller就不写了

@Entity
    @Table(name = "t_user1")
    public class User {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增
        @Column(name = "id")
        private Integer id;
        @Column(name = "username")
        private String username;
        @Column(name = "pazzword")
        private String pazzword;
        @Column(name = "sex")
        private String sex;
        @Column(name = "age")
        private int age;
        @Column(name = "birthday")
        private Date birthday;
        
        ...
    }

public interface UserDao extends JpaRepository<User, Integer> {
        /*
         * 我们在这里直接继承 JpaRepository 的 方法
         * 这也是JPA的一大优点
         * */
    }

截图看一下 JpaRepository 中的一些方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

**4、 在 测试类中 进行 CRUD**

@SpringBootApplication
    public class  SpringbootdemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run( SpringbootdemoApplication.class, args);
        }
    
    }

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class SpringbootdemoApplicationTests {
    
        @Autowired
        private UserDao userDao;
    
        @Test
        public void contextLoads() throws SQLException {
        
            System.out.println(userDao);
    //        // 新增
    //        User user = new User();
    //        user.setUsername("张三");
    //        user.setPazzword("zhs123");
    //        user.setSex("男");
    //        user.setAge(20);
    //        user.setBirthday(new Date());
    //        userDao.save(user);
    
            // 删除
    //        userDao.deleteById(2);
    
            // 查询
            User user = userDao.findById(1).get();
            System.out.println(user);
    
            // 对查到的 user 修改 UID
            user.setUsername("张三1");
            user.setSex("女");
            userDao.save(user);
        }
    
    }

![20190531102626827.png][]

JPA 生成的表

CREATE TABLE `t_user1` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `age` int(11) DEFAULT NULL,
      `birthday` datetime DEFAULT NULL,
      `pazzword` varchar(255) DEFAULT NULL,
      `sex` varchar(255) DEFAULT NULL,
      `username` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=MyISAM AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

### 二、SpringBoot 配置多数据源之Spring Data JPA ###

不同于MyBatis和JdbcTemplate，在Jpa中，事务一定要配置。@Primary必须指明优先使用哪个实例。

**1、在创建SpringBoot 的项目时，引入依赖**

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.21</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.13</version>
            </dependency>

**2、在 application.aproperties中添加两个数据源的配置信息**

server.port=8088
    
    # 配置两个数据源
    spring.datasource.dsone.url=jdbc:mysql://localhost:3306/sbtdb1?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT
    spring.datasource.dsone.username=root
    spring.datasource.dsone.password=123456
    spring.datasource.dsone.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.dsone.driver-class-name=com.mysql.cj.jdbc.Driver
    
    spring.datasource.dstwo.url=jdbc:mysql://localhost:3306/sbtdb2?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT
    spring.datasource.dstwo.username=root
    spring.datasource.dstwo.password=123456
    spring.datasource.dstwo.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.dstwo.driver-class-name=com.mysql.cj.jdbc.Driver
    
    # JPA配置
    spring.jpa.database=mysql
    # 数据库平台
    spring.jpa.database-platform=mysql
    # 每次启动项目时，数据库初始化策略
    spring.jpa.hibernate.ddl-auto=update
    # 指定默认的存储引擎为InnoDB
    spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
    # 在控制台打印SQL
    spring.jpa.properties.hibernate.show_sql=true
    spring.jpa.properties.hibernate.format_sql=true

**3、在配置类中，定义两个DataSource Bean**

@Configuration
    public class DataSourceConfig {
        /**
         * 定义两个DataSource
         * 使用spring.datasource.dsone前缀的数据库配置去创建一个DataSource.
         * @Primary表示当某一个类存在多个实例时，优先使用哪个实例。注解@Primary一定不能少，否则在项目启动时会出错，
         */
        @Bean("dsOne")
        @Primary
        @ConfigurationProperties(prefix = "spring.datasource.dsone")
        DataSource dsOne() {
            return DruidDataSourceBuilder.create().build();
        }
    
        @Bean("dsTwo")
        @ConfigurationProperties(prefix = "spring.datasource.dstwo")
        DataSource dsTwo() {
            return DruidDataSourceBuilder.create().build();
        }
    
    }

**4、提供两个Bean，并配置数据源**

@Configuration
    @EnableJpaRepositories(basePackages = "com.example.jpa.dao1", //设置Repository所在位置
            entityManagerFactoryRef = "localContainerEntityManagerFactoryBeanOne",
            transactionManagerRef = "platformTransactionManagerOne")
    public class JpaConfigOne {
        @Autowired
        @Qualifier(value = "dsOne")
        DataSource dsOne;
    
        /**
         * 注入JpaProperties，它是系统提供的一个实例，里边的数据就是我们在application.properties中配置的jpa相关的配置。
         */
        @Autowired
        JpaProperties jpaProperties;
    
    
        @Bean
        @Primary
        LocalContainerEntityManagerFactoryBean localContainerEntityManagerFactoryBeanOne(EntityManagerFactoryBuilder builder) {
            return builder.dataSource(dsOne)
                    .packages("com.example.jpa.pojo") // 指定的包就是这个数据源对应的实体类所在的位置。
                    .properties(jpaProperties.getProperties())
                    .persistenceUnit("persistenceUnit1")
                    .build();
        }
    
        // 注入事务
        @Bean
        PlatformTransactionManager platformTransactionManagerOne(EntityManagerFactoryBuilder builder) {
            LocalContainerEntityManagerFactoryBean factoryBeanOne = localContainerEntityManagerFactoryBeanOne(builder);
            return new JpaTransactionManager(factoryBeanOne.getObject());
        }
    }

@Configuration
    @EnableJpaRepositories(basePackages = "com.example.jpa.dao2",
            entityManagerFactoryRef = "localContainerEntityManagerFactoryBeanTwo",
            transactionManagerRef = "platformTransactionManagerTwo")
    public class JpaConfigTwo {
        @Resource(name = "dsTwo")
        DataSource dsTwo;
    
        @Autowired
        JpaProperties jpaProperties;
    
    
        @Bean
        LocalContainerEntityManagerFactoryBean localContainerEntityManagerFactoryBeanTwo(EntityManagerFactoryBuilder builder) {
            return builder.dataSource(dsTwo)
                    .packages("com.example.jpa.pojo")
                    .properties(jpaProperties.getProperties())
                    .persistenceUnit("persistenceUnit2")
                    .build();
        }
    
        @Bean
        PlatformTransactionManager platformTransactionManagerTwo(EntityManagerFactoryBuilder builder) {
            LocalContainerEntityManagerFactoryBean factoryBeanTwo = localContainerEntityManagerFactoryBeanTwo(builder);
            return new JpaTransactionManager(factoryBeanTwo.getObject());
        }
    }

**5、dao创建**

public interface UserDao1 extends JpaRepository<User, Integer> {
    }

public interface UserDao2 extends JpaRepository<User, Integer> {
    }

@Entity
    @Table(name = "t_user")
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增
        private int id;
        private String name;
        private String password;
    
    ...
    }

**6、测试**

@SpringBootApplication
    public class JpaApplication {
        public static void main(String[] args) {
            SpringApplication.run(JpaApplication.class, args);
        }
    
    }

@RestController
    public class UserController {
        @Autowired
        public UserDao1 userDao1;
    
        @Autowired
        public UserDao2 userDao2;
    
        @GetMapping("/list1")
        public List<User> list1(){
            List<User> list = userDao1.findAll();
            return list;
        }
    
        @GetMapping("/list2")
        public List<User> list2(){
            List<User> list = userDao2.findAll();
            return list;
        }
    }

![20201105111811861.png][]

测试访问ok。在Service中注入不同的UserDao，不同的UserDao操作会使用不同的数据源。我这里简单处理省略了service，pojo使用共同的类。

ends ~

[Spring Data JPA]: https://blog.csdn.net/qq_42402854/article/details/107217417
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20220125/4533d7bac32846c0b7ecbb611e12bf84.png
[20190531102626827.png]: /images/20220125/b35b3a5fd24e4f72b2c0656cdc638a0a.png
[20201105111811861.png]: /images/20220125/dda65aa1dd78496d9fae231374dc01bb.png