标签：持久 springboot spring 查询 datasource 整合 new id user

springboot整合持久层

1、整合mybatis

这里以多数据源为例

第一步创建springboot时，选上mybatis依赖

在添加数据库驱动依赖：

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
 </dependency>

第二步在配置文件中进行配置数据库信息

spring.datasource.one.jdbcUrl=jdbc:mysql:///mybatis?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
spring.datasource.one.username=root
spring.datasource.one.password=123456

spring.datasource.two.jdbcUrl=jdbc:mysql:///mybatis?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
spring.datasource.two.username=root
spring.datasource.two.password=123456

第三步在配置类中进行配置数据源

@Configuration
public class DataSourceConfig {
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.one")
    DataSource dsOne(){
        return new HikariDataSource();
    }
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.two")
    DataSource dsTwo(){
        return new HikariDataSource();
    }
}

同样通过 HikariDataSource 来创建数据源

第四步也是在配置类中对 mybatis进行配置

@Configuration
@MapperScan(basePackages = "com.xrr.mybatis.mapper1",sqlSessionFactoryRef = "sqlSessionFactory1",sqlSessionTemplateRef = "sqlSessionTemplate1")
public class MybatisConfigOne {
    @Autowired
    @Qualifier("dsOne")
    DataSource ds;

    @Bean
    SqlSessionFactory sqlSessionFactory1(){
        SqlSessionFactory sqlSessionFactory = null;
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(ds);
        try {
            sqlSessionFactory = bean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sqlSessionFactory;
    }

    @Bean
    SqlSessionTemplate sqlSessionTemplate1(){
        return new SqlSessionTemplate(sqlSessionFactory1());
    }
}

在类中需要配置 SqlSessionFactory 的bean 与 SqlSessionTemplate 的 bean，

其中SqlSessionTemplate是Mybatis—Spring的核心，是用来代替默认Mybatis实现的DefaultSqlSessionFactory，也可以说是DefaultSqlSessionFactory的优化版，主要负责管理Mybatis的SqlSession，调用Mybatis的sql方法。

然后在类上添加 @MapperScan 注解，在其中添加包扫描，sqlsession、SqlSessionTemplate即可。

@MapperScan是属于 mybatis-spring中的。

当只有一个数据源时，只需在启动类上添加 @mapperScan 注解即可

2、整合Spring data jpa

介绍

JPA是ORM规范，jpa是对Hibernate、TopLink的封装（mybatis是半自动的orm框架，spring data jpa不对其封装），这样的好处是开发者可以面向JPA规范进行持久层的开发，而底层的实现（Hibernate对数据库进行操作）则是可以切换的。Spring Data Jpa则是在JPA之上添加另一层抽象（Repository层的实现），极大地简化持久层开发及ORM框架切换的成本。

Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。Spring Data JPA不需要过多的关心Dao层的实现，只需关注我们继承的接口，按照一定的规则去编写我们的接口即可，spring会按照规范动态生成我们接口的实现类进行注入，并且实现类里包含了一些常规操作的方法实现。如果使用JPA提供的接口来操作ORM框架，可以不写任何实现就能对数据库进行CRUD操作，还可以进行简单的分页，排序操作。

即 jpa 是规范，而 hibernate 是 jpa 的体现

第一步添加依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
        </dependency>

第二步在配置文件中进行数据库配置

spring.datasource.password=123456
spring.datasource.username=root
spring.datasource.url=jdbc:mysql:///springboot?useUnicode=true&characterEncoding=UTF-8

spring.jpa.database=mysql
spring.jpa.show-sql=true
spring.jpa.database-platform=mysql
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect

第三步，创建实体类

@Entity(name = "t_book")
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column(name = "b_name")
    private String name;
    private String author;
}

首先@Entity注解表示这是一个实体类，那么在项目启动时会自动针对该类生成一张表，默认的表名为类名，

@Entity注解的name属性表示自定义生成的表名。@Id注解表示这个字段是一个id，@GeneratedValue注解表示主键的自增长策略，对于类中的其他属性，默认都会根据属性名在表中生成相应的字段，字段名和属性名相同，如果开发者想要对字段进行定制，可以使用@Column注解，去配置字段的名称，长度，是否为空等等。

接下来创建一个 dao，继承 JpaRepository

/**
 * JpaRepository<Book,Long>
 *     第一个泛型：需要处理的实体类
 *     第二个泛型：主键
 */
public interface BookDao extends JpaRepository<Book,Long> {

}

在 JpaRepository类中定义了一些查询、删除、增加等的方法。而其之所以方便是因为其定义了分页操作：

    @Test
    public void test2(){
        PageRequest pageRequest = PageRequest.of(1, 3, Sort.by(Sort.Order.asc("id")));
        Page<Book> page = bookDao.findAll(pageRequest);
        System.out.println("总页数 = " + page.getTotalPages());
        System.out.println("总记录数 = " + page.getTotalElements());
        System.out.println("每页记录数 = " + page.getSize());
        System.out.println("查到的数据 = " + page.getContent());
        System.out.println("是否有下一页 = " + page.hasNext());
        System.out.println("是否有上一页 = " + page.hasPrevious());
        System.out.println("是否首页 = " + page.isFirst());
        System.out.println("是否最后页 = " + page.isLast());
        System.out.println("当前页码 = " + page.getNumber());
        System.out.println("获取当前页的记录数 = " + page.getNumberOfElements());
    }

查询规范；

按照 Spring Data 的规范，查询方法以 find | read | get
涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写

支持关键字查询如下；

为什么写上方法名，JPA就知道你想干嘛了呢？假如创建如下的查询：findByUserDepUuid()，框架在解析该方法时，首先剔除 findBy，然后对剩下的属性进行解析，假设查询实体为Doc：

先判断 userDepUuid （根据 POJO 规范，首字母变为小写）是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，继续第二步；
从右往左截取第一个大写字母开头的字符串(此处为Uuid)，然后检查剩下的字符串是否为查询实体的一个属性，如果是，则表示根据该属性进行查询；如果没有该属性，则重复第二步，继续从右往左截取；最后假设 user 为查询实体的一个属性；
接着处理剩下部分（DepUuid），先判断 user 所对应的类型是否有depUuid属性，如果有，则表示该方法最终是根据 “ Doc.user.depUuid” 的取值进行查询；否则继续按照步骤 2 的规则从右往左截取，最终表示根据 “Doc.user.dep.uuid” 的值进行查询。
可能会存在一种特殊情况，比如 Doc包含一个 user 的属性，也有一个 userDep 属性，此时会存在混淆。可以明确在属性之间加上 “_” 以显式表达意图，比如 “findByUser_DepUuid()” 或者 “findByUserDep_uuid()”
还有一些特殊的参数：例如分页或排序的参数：

有的时候，这里提供的查询关键字并不能满足我们的查询需求，这个时候就可以使用 @Query 关键字，来自定义查询 SQL

@Query("select u from t_user u where id=(select max(id) from t_user)")
User getMaxIdUser();

如果查询有参数的话，参数有两种不同的传递方式:

1.利用下标索引传参，索引参数如下所示，索引值从1开始，查询中 ”?X” 个数需要与方法定义的参数个数相一致，并且顺序也要一致：

@Query("select u from t_user u where id>?1 and username like ?2")
List<User> selectUserByParam(Long id, String name);

2.命名参数（推荐）：这种方式可以定义好参数名，赋值时采用@Param(“参数名”)，而不用管顺序：

@Query("select u from t_user u where id>:id and username like :name")
List<User> selectUserByParam2(@Param("name") String name, @Param("id") Long id);

查询时候，也可以是使用原生的SQL查询，如下：

@Query(value = "select * from t_user",nativeQuery = true)
List<User> selectAll();

@Modifying注解

涉及到数据修改操作，可以使用 @Modifying 注解，@Query 与 @Modifying 这两个 annotation一起声明，可定义个性化更新操作，例如涉及某些字段更新时最为常用，示例如下：

@Modifying
@Query("update t_user set age=:age where id>:id")
int updateUserById(@Param("age") Long age, @Param("id") Long id);

注意：

可以通过自定义的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支持使用 INSERT
方法的返回值应该是 int，表示更新语句所影响的行数
在调用的地方必须加事务，没有事务不能正常执行
默认情况下, Spring Data 的每个方法上有事务, 但都是一个只读事务. 他们不能完成修改操作

说到这里，再来顺便说说Spring Data 中的事务问题：

Spring Data 提供了默认的事务处理方式，即所有的查询均声明为只读事务。
对于自定义的方法，如需改变 Spring Data 提供的事务默认方式，可以在方法上添加 @Transactional 注解。
进行多个 Repository 操作时，也应该使它们在同一个事务中处理，按照分层架构的思想，这部分属于业务逻辑层，因此，需要在Service 层实现对多个 Repository 的调用，并在相应的方法上声明事务。

3、整合 jdbcTemplate

以多数据源来举例。

第一步先加入依赖：

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
 </dependency>
<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.23</version>
</dependency>

第二步则在配置文件中进行配置数据库信息

spring.datasource.one.jdbcUrl=jdbc:mysql:///mybatis?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
spring.datasource.one.username=root
spring.datasource.one.password=123456

spring.datasource.two.jdbcUrl=jdbc:mysql:///waterdb?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
spring.datasource.two.username=root
spring.datasource.two.password=123456

第三步创建数据源配置类，进行根据不同的数据库配置信息，来创建数据源

@Configuration
public class DataSourceConfigur {
    @Bean
    @ConfigurationProperties("spring.datasource.one")
    DataSource dsOne(){
        return new HikariDataSource();
    }
    @Bean
    @ConfigurationProperties("spring.datasource.two")
    DataSource dsTwo(){
        return new HikariDataSource();
    }
}

在类中，通过 @ConfigurationProperties来指定数据库的信息为配置文件中的哪一个\

因为 springboot 中如果没有配置指定数据源的话，他默认为你指定为HikariCP 为数据源。所以这里以 HikariDataSource 来创建数据源

第四步也是通过配置类来配置 jdbcTemplate 的 bean

@Configuration
public class JdbcTemplateConfigur {
    @Bean
    @Primary
    JdbcTemplate jdbcTemplateOne(@Qualifier("dsOne") DataSource ds){
        return new JdbcTemplate(ds);
    }
    @Bean
    JdbcTemplate jdbcTemplateTwo(@Qualifier("dsTwo") DataSource ds){
        return new JdbcTemplate(ds);
    }
}

在类中使用了 @Primary 注解，这是因为 spring 容器中要求注入的 bean 为单例，而当没有 @Primary 注解时，会报错

这时，报错中会建议我们使用其注解 @Primary 注解。当然使用其注解能解决问题。那为什么需要呢？

当我们进入到该注解中，会发现其中注释为我们介绍了该注解的使用。即 spring 容器中只能由一种类型的 bean，如果需要注入同种类型的多个bean时，需要在其中的一个 bean 加上该注解，让其成为最优的，优先级高，优先匹配。

第五步则通过自动装配来获取 jdbcTemplate 的 bean

	@Autowired
    @Qualifier("jdbcTemplateOne")
    JdbcTemplate jdbcTemplateOne;

    @Resource(name = "jdbcTemplateTwo")
    JdbcTemplate jdbcTemplateTwo;

接下来就是正常的使用 jdbcTemplate 即可。

这里就记录使用 jdbcTemplate 使用的两点：

获取自增id

1、首先创建 GeneratedKeyHolder 对象

2、在 PreparedStatement 加入 Statement.RETURN_GENERATED_KEYS 参数

3、将 GeneratedKeyHolder 对象作为参数传入 jdbcTemplate 中 update 方法

public void addUser(User user){
     GeneratedKeyHolder keyHolder = new GeneratedKeyHolder();
     jdbcTemplate.update(new PreparedStatementCreator(){
     @Override
     public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
      PreparedStatement statement = con.prepareStatement("insert into user(name,age) values(?,?)", Statement.RETURN_GENERATED_KEYS);
                //设置参数
                statement.setString(1, user.getName());
                statement.setInt(2, user.getAge());
                return statement;
            }
        }, keyHolder);
    //设置增加的用户的id
    user.setUid(keyHolder.getKey().longValue());
 }

查询为集合

方式一：通过 new RowMapper()

public List<User> getUser(){
        List<User> query = jdbcTemplate.query("select * from user", new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                long uid = rs.getLong("uid");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                User user = new User();
                user.setAge(age);
                user.setUid(uid);
                user.setName(name);
                return user;
            }
        });
        return query;
    }

方式二；通过new BeanPropertyRowMapper<>(T.class)

    public List<User> getUser2(){
        List<User> query = jdbcTemplate.query("select * from user", new BeanPropertyRowMapper<>(User.class));
        return query;
    }

本文参考江南一点雨博主的文档。

标签：持久,springboot,spring,查询,datasource,整合,new,id,user
From： https://www.cnblogs.com/xiarongblogs/p/17485186.html

springboot整合持久层

springboot整合持久层

1、整合mybatis

2、整合Spring data jpa

@Modifying注解

3、整合 jdbcTemplate

相关文章

赞助商

阅读排行