SpringBoot整合JPA

最新推荐文章于 2025-07-01 17:22:03 发布
原创 最新推荐文章于 2025-07-01 17:22:03 发布 · 594 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#springBoot #JPA

本文详细介绍了Java Persistence API (JPA) 的基本使用方法及如何进行扩展。从配置数据源开始，逐步展示实体定义、关系映射、自定义查询等核心功能。并通过具体示例演示了如何创建实体类、Repository接口以及控制器来实现CRUD操作。此外，文章还介绍了如何通过自定义接口和实现类来扩展JPA的功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JPA 规范

 

JPA 1.0整合查询语言（Query）和对象关系映射（ORM）元数据定义

JPA 2.0在1.0的基础上，增加Criteria查询，元数据API以及校验支持

 

实体（Entities）

约束：

a 实体类必须使用@Entity标注或者XML描述

b 实体类至少包含一个默认构造器，并且构造器必须是public 或者 protected

c 实体必须是顶级类，不能是枚举或者接口

d 实体类禁止是final类

c 实体支持继承，多态关联 以及多态查询

 

实体持久字段和属性

实体持久状态由字段(Fields)或者（Properties）,字段即实例的属性或变量，属性则是JavaBeans实例的setter或getter方法

实例字段的访问级别必须是private，protected 或者 包可见，属性（getter, setter）的可见性必须是public或者protected

字段和属性可能是单一类型值或集合类型值

 

字段和属性访问类型（Access Type）是通过字段访问 还是 通过属性 访问

默认访问类型 （不需要持久化）

非transient 或者 @Transient 字段

非 @Transient属性

显示访问类型

注解类型

a 实体类

b 映射超类

c 嵌套类

 

注解

a @Access(AccessType.FIELD)字段

b @Access(AccessType.PROPERTY)属性

 

 

实体主键（Primary Key）

每个实体必须存在主键，主机必须定义在实体类

a 简单主键 @Id

b 复合主键 @EmbeddedId @IdClass

 

 

实体关系

实体关系可能一对一，一对多，多对一 或 多对多，这些关系是多态性的，可以是单向或者双向

 

注解表述方式

@OneToOne

@OneToMany

@ManyToOne

@ManyToMany

 

XML表述方式

@Embeddedle

@IdClass

 

版本 springboot 1.5.9

 

基本使用

第一步 配置数据源

datasource:

driver-class-name: com.mysql.jdbc.Driver

url: jdbc:mysql://localhost:3306/dbgirl

username: root

password: root

type: com.alibaba.druid.pool.DruidDataSource

initialSize: 5

minIdle: 5

maxActive: 20

maxWait: 60000

timeBetweenEvictionRunsMillis: 60000

minEvictableIdleTimeMillis: 300000

validationQuery: SELECT 1 FROM DUAL

testWhileIdle: true

testOnBorrow: false

testOnReturn: false

maxPoolPreparedStatementPerConnectionSize: 20

# 打开PSCache ，并且指定每个连接上PSCache的大小

poolPreparedStatements: true

# 配置监控统计拦截的filters,去掉后监控界面sql将无法统计,'wall'用于防火墙

filters: stat,wall,log4j

# 通过connectionProperties属性来打开mergeSql 功能,慢SQL 记录

connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

jpa:

hibernate:

ddl-auto: update

show-sql: true

 

application

package cn.sd.girl;

 

import cn.sd.girl.girl.interceptor.DefaultInterceptor;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.boot.web.servlet.ErrorPage;

import org.springframework.boot.web.servlet.ErrorPageRegistrar;

import org.springframework.boot.web.servlet.ErrorPageRegistry;

import org.springframework.http.HttpStatus;

import org.springframework.web.servlet.config.annotation.InterceptorRegistry;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

 

 

@SpringBootApplication

public class GirlApplication extends WebMvcConfigurerAdapter implements ErrorPageRegistrar{

 

public static void main(String[] args) {

 

SpringApplication.run(GirlApplication.class, args);

}

 

}

 

 

编写 doMain

 

package cn.sd.girl.jpa.doMain;

 

import javax.persistence.*;

import java.io.Serializable;

 

@Entity

@Table(name = "deparment")

public class Deparment implements Serializable{

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String name;

 

public Deparment(){}

 

@Override

public String toString() {

return "Deparment{" +

"id=" + id +

", name='" + name + '\'' +

'}';

}

 

public Long getId() {

return id;

}

 

public void setId(Long id) {

this.id = id;

}

 

public String getName() {

return name;

}

 

public void setName(String name) {

this.name = name;

}

}

package cn.sd.girl.jpa.doMain;

 

import javax.persistence.*;

import java.io.Serializable;

 

@Entity

@Table(name="role")

public class Role implements Serializable{

 

public Role() {

}

 

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String name;

 

public Long getId() {

return id;

}

 

public void setId(Long id) {

this.id = id;

}

 

public String getName() {

 

return name;

}

 

public void setName(String name) {

this.name = name;

}

 

@Override

public String toString() {

return "Role{" +

"id=" + id +

", name='" + name + '\'' +

'}';

}

}

package cn.sd.girl.jpa.doMain;

 

import com.fasterxml.jackson.annotation.JsonBackReference;

import org.springframework.format.annotation.DateTimeFormat;

 

import javax.persistence.*;

import java.io.Serializable;

import java.util.Date;

import java.util.List;

 

@Entity

@Table(name = "user")

public class User implements Serializable{

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

private Long id;

private String name;

@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")

private Date createDate;

@ManyToOne

@JoinColumn(name = "did")

@JsonBackReference //防止关系对象的递归访问

private Deparment deparment;

 

/*

cascade 默认被级联,

eager 非懒加载

*/

@ManyToMany(cascade = {},fetch = FetchType.EAGER)

@JoinTable(name = "user_role",joinColumns = {@JoinColumn(name = "user_id")},

inverseJoinColumns = {@JoinColumn(name = "roles_id")}) // 外键

private List<Role> roles;

 

 

@Override

public String toString() {

return "User{" +

"id=" + id +

", name='" + name + '\'' +

", createDate=" + createDate +

", deparment=" + deparment +

", roles=" + roles +

'}';

}

 

public Long getId() {

return id;

}

 

public void setId(Long id) {

this.id = id;

}

 

public String getName() {

return name;

}

 

public void setName(String name) {

this.name = name;

}

 

public Date getCreateDate() {

return createDate;

}

 

public void setCreateDate(Date createDate) {

this.createDate = createDate;

}

 

public Deparment getDeparment() {

return deparment;

}

 

public void setDeparment(Deparment deparment) {

this.deparment = deparment;

}

 

public List<Role> getRoles() {

return roles;

}

 

public void setRoles(List<Role> roles) {

this.roles = roles;

}

 

public User() {

}

}

 

 

编写 repository

package cn.sd.girl.jpa.repository;

 

import cn.sd.girl.jpa.doMain.Deparment;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

 

@Repository

public interface DepartmentRepository extends JpaRepository<Deparment,Long>{

}

package cn.sd.girl.jpa.repository;

import cn.sd.girl.jpa.doMain.Role;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

 

@Repository

public interface RoleRepository extends JpaRepository<Role,Long>{

}

package cn.sd.girl.jpa.repository;

 

import cn.sd.girl.jpa.doMain.User;

import org.springframework.data.domain.Page;

import org.springframework.data.domain.Pageable;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.Query;

import org.springframework.data.repository.query.Param;

import org.springframework.stereotype.Repository;

/*

JPA 还提供了一些自定义方法的规章,例如,在接口中使用关键字findBy

,readBy,getBy作为方法名的前缀,拼接实体类中的属性字段(首个字母大写),

并可选择拼接一些SQL查询关键字组合成一个查询方法

*/

@Repository

public interface UserRepository extends JpaRepository<User,Long>{

// And

User findByIdAndName(Long id, String name);

 

 

/*

@Query 来定义一些简单的查询语句

*/

@Query("select t from User t where t.name like :name")

Page<User> findByName(@Param("name") String name, Pageable pageable);

 

 

}

 

 

 

 

编写 controller

package cn.sd.girl.jpa.controller;

 

import cn.sd.girl.girl.ExceptionEnum;

import cn.sd.girl.girl.domain.Girl;

import cn.sd.girl.girl.exception.GirlException;

import cn.sd.girl.girl.repository.GirlRepository;

import cn.sd.girl.jpa.doMain.Deparment;

import cn.sd.girl.jpa.doMain.Role;

import cn.sd.girl.jpa.doMain.User;

import cn.sd.girl.jpa.repository.DepartmentRepository;

import cn.sd.girl.jpa.repository.RoleRepository;

import cn.sd.girl.jpa.repository.UserRepository;

import com.alibaba.druid.pool.DruidDataSource;

import com.alibaba.druid.support.jconsole.DruidDataSourcePanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.domain.Page;

import org.springframework.data.domain.PageRequest;

import org.springframework.data.domain.Pageable;

import org.springframework.data.domain.Sort;

import org.springframework.util.Assert;

import org.springframework.validation.BindingResult;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

 

import javax.validation.Valid;

import java.util.Date;

import java.util.List;

 

@RestController

public class JpaController {

 

private static Logger logger = LoggerFactory.getLogger(JpaController.class);

@Autowired

UserRepository userRepository;

@Autowired

DepartmentRepository departmentRepository;

@Autowired

RoleRepository roleRepository;

 

 

@RequestMapping(value = "befor")

public void befor(){

userRepository.deleteAll();

roleRepository.deleteAll();

departmentRepository.deleteAll();

 

Deparment deparment = new Deparment();

deparment.setName("开发部");

departmentRepository.save(deparment);

Assert.notNull(deparment.getId());

Role role = new Role();

role.setName("admin");

roleRepository.save(role);

Assert.notNull(role.getId());

 

User user = new User();

user.setName("user");

user.setCreateDate(new Date());

user.setDeparment(deparment);

 

List<Role> roles = roleRepository.findAll();

Assert.notNull(roles);

user.setRoles(roles);

 

 

userRepository.save(user);

Assert.notNull(user.getId());

}

 

@RequestMapping(value = "findPage")

public void findPage(){

 

Pageable pageable = new PageRequest(0,10,new Sort(Sort.Direction.ASC,"id"));

 

Page<User> page = userRepository.findAll(pageable);

 

Assert.notNull(page);

 

User u = userRepository.findByIdAndName(new Long(1),"user");

 

Page<User> user1 = userRepository.findByName("user", pageable);

 

 

logger.info("u:"+u);

 

for(User user : user1.getContent()){

logger.info("==============user=======user name:{},department name:{},role name:{}",

user.getName(),user.getDeparment(),user.getRoles());

}

}

 

}

 

 

 

 

 

 

 

 

 

 

运行结果

2018-07-23 10:49:38.127 INFO 4368 --- [nio-8081-exec-1] cn.sd.girl.jpa.controller.JpaController : u:User{id=1, name='user', createDate=null, deparment=Deparment{id=1, name='开发部'}, roles=[Role{id=1, name='admin'}]}

2018-07-23 10:49:38.127 INFO 4368 --- [nio-8081-exec-1] cn.sd.girl.jpa.controller.JpaController : ==============user=======user name:user,department name:Deparment{id=1, name='开发部'},role name:[Role{id=1, name='admin'}]

2018-07-23 10:49:38.127 INFO 4368 --- [nio-8081-exec-1] cn.sd.girl.jpa.controller.JpaController : ==============user=======user name:user,department name:Deparment{id=1, name='开发部'},role name:[Role{id=1, name='admin'}, Role{id=3, name='普通用户'}, Role{id=4, name='admin'}]

扩展JPA

第一部 编写 扩展类 接口

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.repository.NoRepositoryBean;

 

import java.io.Serializable;

@NoRepositoryBean

public interface ExpandJpaRepository<T, ID extends Serializable> extends JpaRepository<T,ID> {

 

T findOne(String sql, Object... objects);

}

 

 

编写扩展类实现

import org.springframework.data.jpa.repository.query.QueryUtils;

import org.springframework.data.jpa.repository.support.JpaEntityInformation;

import org.springframework.data.jpa.repository.support.SimpleJpaRepository;

 

import javax.persistence.EntityManager;

import javax.persistence.Query;

import java.io.Serializable;

import java.util.Iterator;

 

public class ExpandJpaRepositoryImpl<T,ID extends Serializable>

extends SimpleJpaRepository<T,ID> implements ExpandJpaRepository<T,ID> {

 

 

private final EntityManager entityManager;

private final JpaEntityInformation<T, ?> entityInformation;

 

public ExpandJpaRepositoryImpl(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {

super(entityInformation, entityManager);

this.entityManager = entityManager;

this.entityInformation = entityInformation;

}

 

private void applyQueryParameter(Query query,Object... objects){

if(objects!=null){

int i = 0;

for(Object value:objects){

i++;

query.setParameter(i,value);

}

}

}

 

@Override

public T findOne(String sql, Object... objects) {

Query query = entityManager.createQuery(sql);

 

applyQueryParameter(query,objects);

 

 

 

 

 

T result = (T)query.getSingleResult();

return result;

}

 

 

}

 

 

编写装配类 getTargetRepository 就是返回 ExpandJpaRepositoryImpl

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.data.jpa.repository.support.JpaEntityInformation;

import org.springframework.data.jpa.repository.support.JpaRepositoryFactory;

import org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean;

import org.springframework.data.repository.core.RepositoryMetadata;

import org.springframework.data.repository.core.support.RepositoryFactorySupport;

 

import javax.persistence.EntityManager;

import java.io.Serializable;

 

public class ExpandJpaRepositoryFactoryBean<R extends JpaRepository<T, ID>, T, ID extends Serializable>

extends JpaRepositoryFactoryBean<R, T, ID> {

 

public ExpandJpaRepositoryFactoryBean(Class<? extends R> repositoryInterface) {

super(repositoryInterface);

}

 

protected RepositoryFactorySupport createRepositoryFactory(

EntityManager entityManager) {

return new ExpandJpaRepositoryFactory<T, ID>(entityManager);

}

 

private static class ExpandJpaRepositoryFactory<T, ID extends Serializable>

extends JpaRepositoryFactory {

 

private final EntityManager entityManager;

 

public ExpandJpaRepositoryFactory(EntityManager entityManager) {

 

super(entityManager);

this.entityManager = entityManager;

}

 

protected Object getTargetRepository(RepositoryMetadata metadata) {

JpaEntityInformation<T, Serializable> entityInformation = (JpaEntityInformation<T, Serializable>) getEntityInformation(metadata.getDomainType());

return new ExpandJpaRepositoryImpl<T, ID>(entityInformation, entityManager);

}

 

protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {

return ExpandJpaRepositoryImpl.class;

}

}

}

 

 

编写 配置类，加载自定义装配 类

import cn.sd.girl.jpa.repository.ExpandJpaRepositoryFactoryBean;

import org.springframework.boot.autoconfigure.domain.EntityScan;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.Ordered;

import org.springframework.core.annotation.Order;

import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;

import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

import org.springframework.transaction.annotation.EnableTransactionManagement;

 

@Order(Ordered.HIGHEST_PRECEDENCE)

@Configuration

@EnableTransactionManagement(proxyTargetClass = true)

@EnableJpaRepositories(basePackages = "cn.sd.girl.jpa.repository",repositoryFactoryBeanClass = ExpandJpaRepositoryFactoryBean.class)

@EntityScan(basePackages = "cn.sd.girl.jpa.doMain")

public class JpaConfiguration {

@Bean

PersistenceExceptionTranslationPostProcessor persistenceExceptionTranslationPostProcessor(){

return new PersistenceExceptionTranslationPostProcessor();

}

}

 

 

UserRepository 继承的就是 前面定义的接口ExpandJpaRepositoy,使用JPA 扩展接口与使用原来的JPA接口一样，调用方法基本相同，可以使用 扩展接口 抽象一些通用的方法，能使用 更灵活

@Repository

public interface UserRepository extends ExpandJpaRepository<User,Long>{

// And

User findByIdAndName(Long id, String name);

 

 

/*

@Query 来定义一些简单的查询语句

*/

@Query("select t from User t where t.name like :name")

Page<User> findByName(@Param("name") String name, Pageable pageable);

 

 

}

 

 

使用 接口

 

package cn.sd.girl.jpa.controller;

 

import cn.sd.girl.girl.ExceptionEnum;

import cn.sd.girl.girl.domain.Girl;

import cn.sd.girl.girl.exception.GirlException;

import cn.sd.girl.girl.repository.GirlRepository;

import cn.sd.girl.jpa.doMain.Deparment;

import cn.sd.girl.jpa.doMain.Role;

import cn.sd.girl.jpa.doMain.User;

import cn.sd.girl.jpa.repository.DepartmentRepository;

import cn.sd.girl.jpa.repository.RoleRepository;

import cn.sd.girl.jpa.repository.UserRepository;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.domain.Page;

import org.springframework.data.domain.PageRequest;

import org.springframework.data.domain.Pageable;

import org.springframework.data.domain.Sort;

import org.springframework.util.Assert;

import org.springframework.validation.BindingResult;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

 

import javax.validation.Valid;

import java.util.Date;

import java.util.List;

 

@RestController

public class JpaController {

 

private static Logger logger = LoggerFactory.getLogger(JpaController.class);

@Autowired

UserRepository userRepository;

 

@RequestMapping(value = "findOne")

public void findOne(){

String sql = "select t from User t where t.id = ?1";

User one = userRepository.findOne(sql, new Object[]{Long.valueOf(1)});

System.out.println("one:"+one);

}

 

}

 

 

 

 

Springboot整合JPA
wdy00000的博客
03-19 1384
文章目录JPA技术Springboot整合JPA引入JPA配置启动类实体类定义接口和数据库交互(dao) JPA技术 Java Persistence Api – ORM 全自动化框架 Springboot整合JPA 引入JPA <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artif
spring boot 集成JPA
09-22
Spring Boot 集成 JPASpring Boot 集成 JPASpring Boot 集成 JPASpring Boot 集成 JPASpring Boot 集成 JPASpring Boot 集成 JPA
Spring Boot(五)：Spring Boot Jpa 的使用
weixin_33843947的博客
09-21 693
在上篇文章Spring Boot(二)：Web 综合开发中简单介绍了一下 Spring Boot Jpa 的基础性使用，这篇文章将更加全面的介绍 Spring Boot Jpa 常见用法以及注意事项。 使用 Spring Boot Jpa 开发时，发现国内对 Spring Boot Jpa 全面介绍的文章比较少案例也比较零碎，因此写文章总结一下。本人也正在翻译Spring Data JPA 参考指...
快速上手SpringBoot整合JPA
最新发布
2404_87285359的博客
07-01 1299
Spring 的一个子项目。用于简化数据库访问，支持NoSQL和关系数据库存储。目标是使数据库操作变得简单便捷.JPA: Java Persistence API 叫做java持久化接口规范, 定义了java操作数据库的模式.: 是Spring Data项目的一部分, 基于JPA规范标准, 提供了一套简洁的API和注解, 用于与关系型数据库进行交互, 使我们可以通过简单的Java对象来表示数据库表, 并且通过继承提供的框架类来执行通用的CRUD操作.
springboot-jpa
muum的博客
07-05 393
工程配置，添加maven的依赖，jpa的依赖有如下，简单的就是一个jpa和mysql：        &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-jpa&lt;...
SpringBoot与JPA
菜鸟清风http://www.hphblog.cn/
04-09 5992
SpringBoot与JPA集成： 简介JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 准备 MavenMaven的依赖关系 目录结构 12345678package com.hph.springboo...
springboot 之 JPA
mazhongjia的博客
08-07 489
一、说明 JPA提供了操作数据库的接口，在开发过程中继承和使用这些接口，可简化现有的持久化开发的工作。 二、JPA提供的接口 1、JpaRepository JpaRepository继承自PagingAndSortingRepository
springboot整合jpa
04-26
SpringBoot 整合 JPA（Java Persistence API）是现代Java应用中常见的数据访问技术栈，它简化了数据库操作，提供了ORM（对象关系映射）功能，使得开发者可以用面向对象的方式来处理数据库事务。以下是对这个主题的...
Springboot整合JPA和Mybatis的最佳实践源码
04-03
在本项目中，"Springboot整合JPA和Mybatis的最佳实践源码" 是一个旨在展示如何优雅地将Spring Boot与JPA（Java Persistence API）和Mybatis两大持久层框架结合的示例。该项目的主要目标是提供一个高效、可扩展且易于...
springBoot整合Jpa的框架
10-16
SpringBoot整合JPA框架是现代Java开发中常用的技术栈，它极大地简化了数据库操作和项目的构建过程。SpringBoot以其约定优于配置的理念，使得开发者能够快速搭建应用，而JPA（Java Persistence API）作为ORM（对象...
SpringBoot整合JPA实现自动创建数据库表自动建表，JPA逆向生成数据库表.zip
11-10
SpringBoot整合JPA实现自动创建数据库表自动建表，JPA逆向生成数据库表 运行环境 jdk8+tomcat9+mysql+IntelliJ IDEA+maven 项目技术(必填) springboot+jpa 数据库文件(可选) 新建一个test的数据库即可，表在...
SpringBoot---SpringBoot-JPA
yztezhl的专栏
02-27 1万+
JPA 应该都熟悉了，我就不多说了什么是JPA了。目前JPA主要实现由hibernate和openJPA等。Spring Data JPA 是Spring Data 的一个子项目，它通过提供基于JPA的Repository极大了减少了操作JPA的代码。笔者觉得这个由SpringBoot 提供的JPARepository真的是非常爽。基本上大部分的业务都可以满足了。在Spring环境中需要配置大量了...
Spring Boot-整合JPA
暗度的博客
05-06 319
目录一、SpringData二、依赖实体类四、配置文件 一、SpringData 二、依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-...
SpringBoot-整合JPA
上海一九四三
09-13 1549
一 JPA是什么 JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。他的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，JPA是在充分吸收了现有Hibernate，TopLink，...
springboot之jpa支持
men_ma的博客
12-02 406
转载请标明出处：https://blog.youkuaiyun.com/men_ma/article/details/106847165. 本文出自 不怕报错 就怕不报错的小猿猿 的博客 springboot之jpa支持小结 导入相关pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-s.
SpringBoot JPA
siriusol的博客
06-01 347
添加依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <group
springboot jpa
热门推荐
zhangpan_soft的博客
08-27 1万+
前面有一篇博客说,springboot 2.0.3 jpa是存在问题的,后用springboot jpa 2.0.4 发现此问题已解决.springboot 2.0.4的jpa的sql看起来也比较容易理解,不再是日志中不再是hsql语句,而是传统sql,所以springboot jpa 2.0.4 用起来比之前版本好用的多,日志也好看懂的多,真的是开箱即用,另外,感觉springboot 2.0....
SpringBoot JPA
L-李俊漩的博客
06-28 5328
一、创建步骤
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值