jpa

JPA

简介

JPA 是 Java Persistence API 的简称，是一套 Sun 公司 Java 官方制定的 ORM（Object Relational Mapping）方案，是规范、是标准，Sun 公司自己并没有实现；
市场上的主流的 JPA 框架有：Hibernate （JBoos）、EclipseTop（Eclipse社区）、OpenJPA （Apache基金会），Hibernate 是众多实现者之中，性能最好的，我们引入的 JPA 框架，采用 Hibernate 实现，需要注意的是，引用是 javax.persistence 这个“标准”包，和 org.hibernate 实现包；
JPA 想要做的就是尽量让你少写 Sql，甚至不写 Sql，基于这种思想，JPA 实现了它自己的一套语法、注解规则，JPA 要用各种注解配合来实现数据实体间一对多、多对多等关联关系，正因为这样，个人觉得实体变得不那么单纯，掺杂了逻辑在里面，这增加了实体的复杂度，对于比较复杂的业务来说，很容易造成实体间直接或间接的循环引用；
在此，我们引入将引入 Spring Data Jpa，在 JPA 之上添加另一层抽象（Repository 层的实现），极大地简化持久层开发；
Hibernate、JPA、Spring Data Jpa 之间的关系如下：

引入 Jar

spring-context
spring-orm
mysql-connector-java
c3p0
hibernate-core
spring-data-jpa
---------------- 已经引入的部分忽略 ----------------

<wiz_code_mirror>

 
<!-- Spring data jpa -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <version>2.3.4.RELEASE</version>
</dependency>

配置

配置结构

applicationContext.xml ---- 全局配置，为了避免该文件杂乱，我们按功能拆分为子配置文件；

引入 jdbcParms.properties ---- Jdbc 配置信息；
引入 hibernateParms.properties ---- Hibernate 配置属性信息；
引入 springJpa.xml ---- JPA 注入 Spring 配置；

applicationContext.xml

<wiz_code_mirror>

 
 
 
 
<!-- 加载属性文件 -->
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
       <list>
          <value>classpath:config/properties/jdbcParms.properties</value>
          <value>classpath:config/properties/hibernateParms.properties</value>
        </list>
    </property>
</bean>
<!-- 引入别的配置文件 -->
<import resource="springJpa.xml"/>
 
 

hibernateParms.properties

参见 Hibernate 相关配置；

springJpa.xml

配置链

dataSource ---- entityManagerFactory ---- transactionManager ---- jpa:repositories；

<wiz_code_mirror>

 
 
 
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd 
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
        http://www.springframework.org/schema/data/jpa 
        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd" >
    <!-- 数据源，spring jdbc || c3p0 jdbc -->
    <!-- <bean id="dataSourceForJpa" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean> -->
    <!-- 配置 c3p0 数据源 -->
    <bean id="dataSourceForJpa" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClassName}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" /> 
        <!-- 连接池中连接用完时，c3p0 一次性创建的连接数 -->
        <property name="acquireIncrement" value="${pool.acquireIncrement}" />
        <!-- 初始化连接数，在 minPoolSize 和 maxPoolSize 之间 -->
        <property name="initialPoolSize" value="${pool.initialPoolSize}" />
        <property name="minPoolSize" value="${pool.minPoolSize}" />
        <property name="maxPoolSize" value="${pool.maxPoolSize}" />
        <!-- 连接关闭时默认将所有未提交的操作回滚,默认为 false -->
        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>
    </bean>
    <!-- 配置 entityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!-- 设置数据源 -->
        <property name="dataSource" ref="dataSourceForJpa" />
        <!-- 扫描 Entity 包 -->
        <property name="packagesToScan" value="com.sfac.springMvc.module.*.entity" />
        <!-- 指定 JPA 实现厂商 -->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />
        </property>
        <!-- 指定 JPA 供应商适配器 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
        </property>
        <!-- 配置 JPA 属性 -->
        <property name="jpaProperties">
            <props>
                <!-- 动态生成表策略 -->
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <!-- 命名规则隐式策略 -->
                <prop key="hibernate.implicit_naming_strategy">${hibernate.implicit_naming_strategy}</prop>
                <!-- 数据库方言 -->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
            </props>
        </property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    <!-- 开启事务注解 -->
    <tx:annotation-driven transaction-manager="jpaTransactionManager"/>
    <!-- 配置 repository -->
    <jpa:repositories base-package="com.sfac.springMvc.module.*.repository" 
        transaction-manager-ref="jpaTransactionManager" 
        entity-manager-factory-ref="entityManagerFactory" />
</beans>
 
 

应用

主要接口和实现类

Repository

属性查询

接口方法命名：

findBy + 属性 + 关键字 + 属性（option）；
find + Top || First（option） + By + 属性 + 关键字 + 属性（option）；

查询关键字列表

And ---- findByLastnameAndFirstname ---- … where x.lastname = ?1 and x.firstname = ?2；
Or ---- findByLastnameOrFirstname ---- … where x.lastname = ?1 or x.firstname = ?2；
Is,Equals ---- findByFirstname,findByFirstnameIs,findByFirstnameEquals ---- … where x.firstname = ?1；
Between ---- findByStartDateBetween ---- … where x.startDate between ?1 and ?2；
LessThan ---- findByAgeLessThan ---- … where x.age < ?1；
LessThanEqual ---- findByAgeLessThanEqual ---- … where x.age <= ?1；
GreaterThan ---- findByAgeGreaterThan ---- … where x.age > ?1；
GreaterThanEqual ---- findByAgeGreaterThanEqual ---- … where x.age >= ?1；
After ---- findByStartDateAfter ---- … where x.startDate > ?1；
Before ---- findByStartDateBefore ---- … where x.startDate < ?1；
IsNull ---- findByAgeIsNull ---- … where x.age is null；
IsNotNull,NotNull ---- findByAge(Is)NotNull ---- … where x.age not null；
Like ---- findByFirstnameLike ---- … where x.firstname like ?1；
NotLike ---- findByFirstnameNotLike ---- … where x.firstname not like ?1；
StartingWith ---- findByFirstnameStartingWith ---- … where x.firstname like ?1 (parameter bound with appended %)；
EndingWith ---- findByFirstnameEndingWith ---- … where x.firstname like ?1 (parameter bound with prepended %)；
Containing ---- findByFirstnameContaining ---- … where x.firstname like ?1 (parameter bound wrapped in %)；
OrderBy ---- findByAgeOrderByLastnameDesc ---- … where x.age = ?1 order by x.lastname desc；
Not ---- findByLastnameNot ---- … where x.lastname <> ?1；
In ---- findByAgeIn(Collection<Age> ages) ---- … where x.age in ?1；
NotIn ---- findByAgeNotIn(Collection<Age> ages) ---- … where x.age not in ?1；
True ---- findByActiveTrue() ---- … where x.active = true；
False ---- findByActiveFalse() ---- … where x.active = false；
IgnoreCase ---- findByFirstnameIgnoreCase ---- … where UPPER(x.firstame) = UPPER(?1)；

@Query 注解查询；

查询语言

SQL 语言

关系型数据库查询语言；
select name, age, user_id from t_user;
JPA 中使用 Sql 语句，只需注解中添加参数 nativeQuery = true 即可；

HQL 语言

Hibernate 造出来的对象语言，只有 Hibernate 框架能够解析，并将其通过一系列的映射转换，拼凑成 SQL 语言；
使用 “类名” 取代 “表名”，用 “类名.属性名” 取代 “表名.列名”，类名建议不要省略；
没有 * 查询，使用 from 类名代替；
查询操作使用 @Query 注解
删除修改操作使用 @Modifying + @Transactional + @Query 注解，@Transactional 可加在 service 层；

JPQL 语言

EJB3.0 中的 JPA 造出来的对象查询语言，其原型类似于 HQL，Sun 看到 Hibernate 做的 ORM 技术做的非常好，成为行业内领导 ORM 框架的主流产品，故 Sun 将其吸收进 EJB3 中，制定了一套 ORM 的 JAVA API 标准；

传参方式

select name,age,userId from User where userName = ?1; ---- ?加数字表示占位符，从 1 开始；
select name,age,userId from User where userName=:userName; ---- :加上变量名，这里是与方法参数中有 @PARAM 的值匹配；

CrudRepository

添加了对数据的增删改查的方法；

PagingAndSortingRepository

添加了对数据的分页和排序方法；

QueryByExampleExecutor

Example 条件查询；

JpaRepository

对继承父接口中方法的返回值进行了适配，在父类接口中通常都返回迭代器，需要我们自己进行强制类型转化，而在 JpaRepository 中，直接返回了 List；

JpaSpecificationExecutor

主要提供了多条件查询的支持，并且可以在查询中添加分页和排序，因为这个接口单独存在，因此需要配合以上说的接口使用；

QueryDslPredicateExecutor
SimpleJpaRepository ---- 实现类；
QueryDslJpaRepository ---- 实现类；

新增接口

针对每个 Bean 书写一个持久层接口，继承 JpaRepository<T, ID> 接口（其中 T 是实体 bean， ID 是主键），添加 @Repository 注解，到此，我们一行代码都不用写，即可调用父接口实现功能；
StudentRepository.java

<wiz_code_mirror>

 
@Repository
public interface StudentRepository extends JpaRepository<Student, Integer> {
}

StudentServiceImpl.java

<wiz_code_mirror>

 
@Autowired
private StudentRepository studentRepository;
@Override
@Transactional("jpaTransactionManager")
public ResultEntity<Student> insertStudentForJpa(Student student) {
    studentRepository.saveAndFlush(student);
    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Insert success.", student);
}

StudentController.java

<wiz_code_mirror>

 
 
 
 
/**
 * 127.0.0.1/api/jpa/student ---- post
 * {"studentName":"HymanHu"}
 * {"studentName":"HymanHu", "studentCard":{"cardNo":"studentCard001"}}
 */
@PostMapping(value = "/jpa/student", consumes = "application/json")
public ResultEntity<Student> insertStudentForJpa(@RequestBody Student student) {
    return studentService.insertStudentForJpa(student);
}
 
 

修改接口

StudentServiceImpl.java

<wiz_code_mirror>

 
@Override
@Transactional("jpaTransactionManager")
public ResultEntity<Student> updateStudentForJpa(Student student) {
    studentRepository.saveAndFlush(student);
//  int i = 1 / 0;
    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Update success.", student);
}

StudentController.java

<wiz_code_mirror>

 
 
 
 
/**
 * 127.0.0.1/api/jpa/student ---- put
 * {"id":"2","studentName":"HymanHu1"}
 * {"id":"2","studentName":"HymanHu1","studentCard":{"id":"1","cardNo":"studentCard002"}}
 */
@PutMapping(value = "/jpa/student", consumes = "application/json")
public ResultEntity<Student> updateStudentForJpa(@RequestBody Student student) {
    return studentService.updateStudentForJpa(student);
}
 
 

删除接口

StudentServiceImpl.java

<wiz_code_mirror>

 
@Override
public ResultEntity<Object> deleteStudentForJpa(Integer id) {
    studentRepository.deleteById(id);
    return new ResultEntity<Object>(ResultStatus.SUCCESS.status, "Delete success.");
}

StudentController.java

<wiz_code_mirror>

 
/**
 * 127.0.0.1/api/jpa/student/2 ---- delete
 */
@DeleteMapping("/jpa/student/{id}")
public ResultEntity<Object> deleteStudentForJpa(@PathVariable Integer id) {
    return studentService.deleteStudentForJpa(id);
}

父接口查询

StudentServiceImpl.java

<wiz_code_mirror>

 
@Override
public Student getStudentByIdForJpa(Integer id) {
    return studentRepository.findById(id).orElse(null);
}
@Override
public List<Student> getStudentsForJpa() {
    return studentRepository.findAll();
}

StudentController.java

<wiz_code_mirror>

 
 
 
 
/**
 * 127.0.0.1/api/jpa/student/9 ---- get
 */
@GetMapping("/jpa/student/{id}")
public Student getStudentByIdForJpa(@PathVariable Integer id) {
    return studentService.getStudentByIdForJpa(id);
}
/**
 * 127.0.0.1/api/jpa/students ---- get
 */
@GetMapping("/jpa/students")
public List<Student> getStudentsForJpa(@RequestParam(required = false) String studentName) {
    return studentService.getStudentsForJpa();
}
 
 

Example && Criteria 查询

JpaRepository：<S extends T> Page<S> findAll(Example<S> example, Pageable pageable);

Example：动态条件查询样本 ----static <T> Example<T> of(T probe, ExampleMatcher matcher)；

T：实体 bean；
ExampleMatcher：查询匹配器；

ExampleMatcher.matchingAny() ---- 匹配条件是 or 的关系；
ExampleMatcher.matching() ---- 匹配条件是 and 的关系；
withMatcher("studentName", match -> match.contains()) ---- 模糊查询，即 %studentName%；
withIgnorePaths("studentId", "createDate"); ---- 忽略字段，可以自动忽略空值的字段，但 id 是基本数据类型，默认值为 0，必须忽略；

Pageable：分页组件 ---- public static PageRequest of(int page, int size, Sort sort)；

page：当前页，从 0 开始；
size：每页大小；
sort：排序对象 ---- new Sort(direction, orderBy)；

direction：排序方向，Sort.Direction.ASC；
orderBy：排序字段；

Page：返回分页对象；

JpaSpecificationExecutor：Page findAll(@Nullable Specification<T> spec, Pageable pageable);

Specification：Criteria 多条件查询，支持时间比较、数字比较等；
Pageable
Page

StudentRepository.java

<wiz_code_mirror>

 
@Repository
public interface StudentRepository extends JpaRepository<Student, Integer>, JpaSpecificationExecutor<Student> {
}

StudentServiceImpl.java

<wiz_code_mirror>

 
 
 
 
@Override
public Page<Student> getStudentsBySearchBeanForJpa(SearchBean searchBean) {
    searchBean.initSearchBean();
//      Page<Student> page = exampleAndPage(searchBean);
    Page<Student> page = criteriaAndPage(searchBean);
    return page;
}
/**
 * -实现方式一：Example + Page 查询
 */
public Page<Student> exampleAndPage(SearchBean searchBean) {
    // 创建 Pageable 对象
    String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();
    Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) || 
            searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;
    Sort sort = new Sort(direction, orderBy);
    // 当前页起始为 0
    Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);
    // 创建 Example 对象
    Student student = new Student();
    student.setStudentName(searchBean.getKeyWord());
    student.setCreateDate(LocalDateTime.of(2021, 1, 19, 0, 0));
    // matchingAny 相当于 or 连接查询条件，matching 相当于 and 连接查询条件
    ExampleMatcher exampleMatcher = ExampleMatcher.matchingAny()
            // 模糊查询，即 %{studentName} %
            .withMatcher("studentName", match -> match.contains())
            // 时间类型不支持模糊查询，生成的语句为createDate=?，同时也不支持 id > startId && id < endId 这样的操作
            .withMatcher("createDate", match -> match.contains())
            // 忽略基本数据类型字段，如果使用包装类则无需忽略
            .withIgnorePaths("id");
    Example<Student> example = Example.of(student, exampleMatcher);
    return studentRepository.findAll(example, pageable);
}
/**
 * -实现方式：Criteria + Page
 */
public Page<Student> criteriaAndPage(SearchBean searchBean) {
    // 创建 Pageable 对象
    String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();
    Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) || 
            searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;
    Sort sort = new Sort(direction, orderBy);
    // 当前页起始为 0
    Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);
    // 创建 Specification 对象
    Specification<Student> specification = new Specification<Student>() {
        private static final long serialVersionUID = 1L;
        /**
         * -构造语句 select * from test_student where createDate>=? and 
         * (studentName like ? or id between 10 and 20) order by id desc limit ?
         */
        @Override
        public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, 
                CriteriaBuilder criteriaBuilder) {
            return criteriaBuilder.and(
                criteriaBuilder.greaterThanOrEqualTo(
                    root.get("createDate").as(LocalDateTime.class), 
                    LocalDateTime.of(2021, 1, 20, 0, 0)),
                criteriaBuilder.or(
                    criteriaBuilder.like(root.get("studentName").as(String.class), 
                            String.format("%%%s%%", searchBean.getKeyWord())),
                    criteriaBuilder.between(root.get("id"), 10, 20)
                )
            );
        }
    };
    return studentRepository.findAll(specification, pageable);
}
 
 

StudentController.java

<wiz_code_mirror>

 
 
 
 
/**
 * 127.0.0.1/api/jpa/students ---- post
 * {"currentPage":1, "pageSize":5, "keyWord":"hy", "orderBy":"id", "direction":"desc"}
 * {"currentPage":1, "pageSize":5, "keyWord":"hu", "orderBy":"studentName", "direction":"asc"}
 * -注意：排序字段不能使用下划线
 * 
 */
@PostMapping(value = "/jpa/students", consumes = "application/json")
public Page<Student> getStudentsBySearchBeanForJpa(@RequestBody SearchBean searchBean) {
    return studentService.getStudentsBySearchBeanForJpa(searchBean);
}
 
 

属性查询

StudentRepository.java

<wiz_code_mirror>

 
List<Student> findByStudentName(String studentName);

StudentServiceImpl.java

<wiz_code_mirror>

 
@Override
public Student getStudentByNameForJpa(String studentName) {
    List<Student> students = Optional.ofNullable(studentRepository.findByStudentName(studentName))
            .orElse(Collections.emptyList());
    return students.isEmpty() ? null : students.get(0);
}

StudentController.java

<wiz_code_mirror>

 
/**
 * 127.0.0.1/api/jpa/student?studentName=HymanHu ---- get
 */
@GetMapping("/jpa/student")
public Student getStudentByNameForJpa(@RequestParam String studentName) {
    return studentService.getStudentByNameForJpa(studentName);
}

Sql && Hql 查询

StudentRepository.java

<wiz_code_mirror>

 
 
 
 
//@Query(nativeQuery = true, value = "select * from test_student where id = :id")
@Query(value = "from Student where id = :id")
Student getStudentById(@Param("id") Integer id);
@Modifying
//@Query(nativeQuery = true, value = "update test_student set student_name = :studentName where id = :id")
@Query(value = "update Student set studentName = :studentName where id = :id")
void updateStudentName(@Param("studentName") String studentName, @Param("id") Integer id);
@Modifying
@Query(nativeQuery = true, value = "update test_student " +
        "set student_name = :#{#student.studentName} where id = :#{#student.id}")
void updateStudent(@Param("student") Student student);
 
 

StudentServiceImpl.java

<wiz_code_mirror>

 
 
 
 
@Override
public Student getStudentByIdV2ForJpa(Integer id) {
    return studentRepository.getStudentById(id);
}
@Override
@Transactional("jpaTransactionManager")
public ResultEntity<Student> updateStudentNameForJpa(Student student) {
    studentRepository.updateStudentName(student.getStudentName(), student.getId());
    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Update success.", student);
}
 
 

StudentController.java

<wiz_code_mirror>

 
 
 
 
/**
 * 127.0.0.1/api/jpa/student/2/v2 ---- get
 */
@GetMapping("/jpa/student/{id}/v2")
public Student getStudentByIdV2ForJpa(@PathVariable Integer id) {
    return studentService.getStudentByIdV2ForJpa(id);
}
/**
 * 127.0.0.1/api/jpa/student/v2 ---- put
 * {"id":"1","studentName":"HymanHu1"}
 */
@PutMapping(value = "/jpa/student/v2",consumes = "application/json")
public ResultEntity<Student> updateStudentNameForJpa(@RequestBody Student student) {
    return studentService.updateStudentNameForJpa(student);
}
 
 

批量接口

思路

方式一：父接口中有 saveAll、deleteInBatch 方法，可完成批量增删改操作，在此不做赘述；
方式二：引入 @persistencecontext 注解和 EntityManager 类，属于 Jpa 包，用途是将 Entity 在内存操作，处理完成之后再一次性同步到数据库，效率要比第一种方式高；

StudentServiceImpl.java

<wiz_code_mirror>

 
 
 
 
@PersistenceContext
private EntityManager entityManager;
@Override
@Transactional
public ResultEntity<List<Student>> batchInsertStudentsForJpa(List<Student> students) {
    // 方式一，调用父接口完成批量操作
//      studentRepository.saveAll(students);
//      studentRepository.flush();
    // 方式二，引入 entityManager 进行批量操作，效率高于第一种方式
    students.stream().forEach(item -> {
        entityManager.persist(item);
    });
    entityManager.flush();
    entityManager.clear();
    return new ResultEntity<List<Student>>(ResultStatus.SUCCESS.status, "Update success.", students);
}
 
 

StudentController.java

<wiz_code_mirror>

 
/**
 * 127.0.0.1/api/jpa/students/v2 ---- post
 * [{"studentName":"aa1"},{"studentName":"aa2"}]
 */
@PostMapping(value = "/jpa/students/v2", consumes = "application/json")
public ResultEntity<List<Student>> batchInsertStudentsForJpa(@RequestBody List<Student> students) {
    return studentService.batchInsertStudentsForJpa(students);
}

练习

创建 User、Role、UserRole、Resource、RoleResource 五个 Bean，使用 Jpa 自动生成表（中间表不要外键关系），使用 Mybatis Or Jpa 实现 User、 Role、Resource 的增删改查接口；

posted @ 2021-09-15 09:44 无名小萃阅读(117) 评论(0) 收藏举报

刷新页面返回顶部

无名小萃

加油 ! 奥利给！

jpa

公告

无名小萃

加油 ! 奥利给 ！

jpa

公告

加油 ! 奥利给！