-
本版专家分：0结帖率 50% -
前几天刚刚接触 java spring boot 我以前是开发别的语言的。 中间使用了 jpa建表的功能初识 感觉很爽。但是 遇到了个很棘手的问题 居然在jpa的 机制下找不到解决的方法，望大神们赐教。
问题如下:
比如 建立了 2个表 一个学生表 ，一个 科目表 两个实体类 数据库会建立2张表，这时我使用 多对多注解， 数据库会自动生成 一个包含 学生id 和 科目id 的中间表，这时候 我想给 每个学生和科目 录入分数，按照我以往的逻辑 我在中间表里面自己增加了一个字段 或者 建立一个中间表的实体类 里面加 分数的字段。这个时候就出问题了。我能查到 每个学生修习了 哪些科目 但是我无法直接查询到学生科目的分数 也就是说这张 中间表 我没办法进行 分数的增删改查。
我不知道我有没有描述清楚我的 问题 ，网上搜了很多，也有一些解决方案 但是 我按照 网上的解决方案 把多对多的注解 拆开来 变成 一对多的时候 只要想在 学生表里面增加 中间表 的实体类属性 运行就会报错
java.lang.IllegalStateException: ApplicationEventMulticaster not initialized - call 'refresh' before multicasting events via the context: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@17d919b6: startup date [Tue Apr 03 10:45:33 CST 2018]; root of context hierarchy
at org.springframework.context.support.AbstractApplicationContext.getApplicationEventMulticaster(AbstractApplicationContext.java:404)
at org.springframework.context.support.ApplicationListenerDetector.postProcessBeforeDestruction(ApplicationListenerDetector.java:97)
at org.springframework.beans.factory.support.DisposableBeanAdapter.destroy(DisposableBeanAdapter.java:253)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroyBean(DefaultSingletonBeanRegistry.java:578)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroySingleton(DefaultSingletonBeanRegistry.java:554)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.destroySingleton(DefaultListableBeanFactory.java:954)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroySingletons(DefaultSingletonBeanRegistry.java:523)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.destroySingletons(DefaultListableBeanFactory.java:961)
at org.springframework.context.support.AbstractApplicationContext.destroyBeans(AbstractApplicationContext.java:1033)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:555)
at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.refresh(EmbeddedWebApplicationContext.java:122)
at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:761)
at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:371)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:315)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1186)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1175)
at com.sparrow.hadmin.Application.main(Application.java:12)
2018-04-03 10:45:36.431 [main] ERROR o.s.b.factory.support.DefaultListableBeanFactory - Destroy method on bean with name 'org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor' threw an exception
java.lang.IllegalStateException: ApplicationEventMulticaster not initialized - call 'refresh' before multicasting events via the context: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@17d919b6: startup date [Tue Apr 03 10:45:33 CST 2018]; root of context hierarchy
at org.springframework.context.support.AbstractApplicationContext.getApplicationEventMulticaster(AbstractApplicationContext.java:404)
at org.springframework.context.support.ApplicationListenerDetector.postProcessBeforeDestruction(ApplicationListenerDetector.java:97)
at org.springframework.beans.factory.support.DisposableBeanAdapter.destroy(DisposableBeanAdapter.java:253)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroyBean(DefaultSingletonBeanRegistry.java:578)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroySingleton(DefaultSingletonBeanRegistry.java:554)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.destroySingleton(DefaultListableBeanFactory.java:954)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroySingletons(DefaultSingletonBeanRegistry.java:523)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.destroySingletons(DefaultListableBeanFactory.java:961)
at org.springframework.context.support.AbstractApplicationContext.destroyBeans(AbstractApplicationContext.java:1033)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:555)
at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.refresh(EmbeddedWebApplicationContext.java:122)
at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:761)
at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:371)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:315)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1186)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1175)
at com.sparrow.hadmin.Application.main(Application.java:12)
2018-04-03 10:45:36.432 [main] ERROR o.s.b.factory.support.DefaultListableBeanFactory - Destroy method on bean with name 'org.springframework.boot.autoconfigure.internalCachingMetadataReaderFactory' threw an exception
java.lang.IllegalStateException: ApplicationEventMulticaster not initialized - call 'refresh' before multicasting events via the context: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@17d919b6: startup date [Tue Apr 03 10:45:33 CST 2018]; root of context hierarchy
at org.springframework.context.support.AbstractApplicationContext.getApplicationEventMulticaster(AbstractApplicationContext.java:404)
at org.springframework.context.support.ApplicationListenerDetector.postProcessBeforeDestruction(ApplicationListenerDetector.java:97)
at org.springframework.beans.factory.support.DisposableBeanAdapter.destroy(DisposableBeanAdapter.java:253)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroyBean(DefaultSingletonBeanRegistry.java:578)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroySingleton(DefaultSingletonBeanRegistry.java:554)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.destroySingleton(DefaultListableBeanFactory.java:954)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.destroySingletons(DefaultSingletonBeanRegistry.java:523)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.destroySingletons(DefaultListableBeanFactory.java:961)
at org.springframework.context.support.AbstractApplicationContext.destroyBeans(AbstractApplicationContext.java:1033)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:555)
at org.springframework.boot.context.embedded.EmbeddedWebApplicationContext.refresh(EmbeddedWebApplicationContext.java:122)
at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:761)
at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:371)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:315)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1186)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1175)
at com.sparrow.hadmin.Application.main(Application.java:12)
//....此处省略N多字
Caused by: org.hibernate.AnnotationException: mappedBy reference an unknown target entity property: com.sparrow.hadmin.entity.TbMemberCommodity.members in com.sparrow.hadmin.entity.Members.memberCommodityList
at org.hibernate.cfg.annotations.CollectionBinder.bindStarToManySecondPass(CollectionBinder.java:769)
at org.hibernate.cfg.annotations.CollectionBinder$1.secondPass(CollectionBinder.java:719)
at org.hibernate.cfg.CollectionSecondPass.doSecondPass(CollectionSecondPass.java:54)
at org.hibernate.boot.internal.InFlightMetadataCollectorImpl.processSecondPasses(InFlightMetadataCollectorImpl.java:1655)
at org.hibernate.boot.internal.InFlightMetadataCollectorImpl.processSecondPasses(InFlightMetadataCollectorImpl.java:1623)
at org.hibernate.boot.model.process.spi.MetadataBuildingProcess.complete(MetadataBuildingProcess.java:278)
at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.metadata(EntityManagerFactoryBuilderImpl.java:847)
at org.hibernate.jpa.boot.internal.EntityManagerFactoryBuilderImpl.build(EntityManagerFactoryBuilderImpl.java:874)
at org.springframework.orm.jpa.vendor.SpringHibernateJpaPersistenceProvider.createContainerEntityManagerFactory(SpringHibernateJpaPersistenceProvider.java:60)
at org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalContainerEntityManagerFactoryBean.java:353)
at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.buildNativeEntityManagerFactory(AbstractEntityManagerFactoryBean.java:373)
at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:362)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1642)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1579)
... 104 common frames omitted
我也是醉了 ，为什么 jpa对 中间表的操作这么不支持？
问题点数：50分
-
本版专家分：0
-
弱弱的问一句，楼主解决了吗？ 我跟你一样的需求但是报错信息不一样
-
本版专家分：0 -
可以参考这个两种资源：https://vladmihalcea.com/the-best-way-to-map-a-many-to-many-association-with-extra-columns-when-using-jpa-and-hibernate/
https://hellokoding.com/jpa-many-to-many-extra-columns-relationship-mapping-example-with-spring-boot-maven-and-mysql/
- 其他相关推荐
- SpringBoot使用Mybatis注解进行一对多和多对多查询
- SpringBoot使用Mybatis注解进行一对多和多对多查询 GitHub的完整示例项目地址kingboy-springboot-data 一、模拟的业务查询 系统中的用户user都有唯一对应的地址信息address，每个用户可以有多量车car，类似如下结构 |-- user |-- address |-- carList |-- car1
- spring-boot的spring-jpa基本操作以及以及一对多，多对一，多对多
- 一、常用注解详解 1、@Entity+@Table 标注在实体类上，表示是一个实体，并且如果表名和实体类名一样，可以省略table，否则加上@Table(name="表名") 2、@NoRepositoryBean 标注在父类中repository，表示spring不会去实例化它。 3、@Column：标注在属性上，如果字段名与列名相同，则可以省略。 4、 @Id：标...
- Spring Data JPA 之 一对一，一对多，多对多 关系映射
-   一、@OneToOne关系映射 JPA使用@OneToOne来标注一对一的关系。 实体 People ：用户。 实体 Address：家庭住址。 People 和 Address 是一对一的关系。 这里用两种方式描述JPA的一对一关系。 一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键)； 另外一种...
- springboot-data-jpa注解实现一对多查询
- 需求: 根据用户id一次查询出用户信息及其所有订单信息 1. pom.xml中引入依赖 org.springframework.boot spring-boot-starter-parent 1.5.8.RELEASE org.springframework.boot spring-boot-starter-data-jpa 2. 实体类(最小化配置)
- Spring Data JPA 系列 —— 两张表（多对多关联，关联表带扩展字段）
- 这里通过一个完整的例子展示如何通过 JPA 对两张表（多对多关联，关联表带扩展字段）进行增删改查操作。
- Spring data jpa 多表查询（三:多对多关系动态条件查询）
- 上一章说了，一对多关系，动态条件查询，这章开始说多对多关系模型 1.A 和 B （n : n）意思就是多对多，下面开始在模型中，建立关系 @Entity class A { @Column("唯一性标识，主键等等") String id; @Column("name = name") String name; @ManyToMany(mappedBy=
- Spring boot + JPA一对一、一对多、多对多关系
- application.properties配置文件############################################ ## MySQL数据库连接 ############################################ spring.datasource.url = jdbc:mysql://localhost:3306/db?useUnicode=tru...
- Springboot-多表关联的建立（中间表）
- 场景：用户表、项目表、用户和项目中间表 多对多表的实体创建，记得在配置文件中加： spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect MyISAM和InnoDB详解：https://blog.csdn.net/shuaijunlan/article/details/51519702 ...
- jpa配置多对多关系(中间表)
- 两个实体tb_user,tb_role 现在我们再tb_user或者tb_role中任意一个里面进行维护关系，多对对的情况下我们需要创建一个中间表来完成这个关系的映射，我们再tb_user中添加注解@ManyToMany然后再添加一个注解@JoinTable因为我们是要创建中间表所以要使用这个注解。JoinTable注解中我们添加如下例子中的内容，joinColumns当前表中的字段在中间表中的...
- spring-boot ，spring-data-jpa 关系映射，实现一对多，一对一，多对多
- spring-boot ，spring-data-jpa 关系映射关系，实现一对多，多对多，一对一 仅仅展示代码，不需要太多的其他无用字眼 1：多对多 @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; pri...
- Spring boot jpa 多表关联查询
- Spring boot jpa 多表关联查询
- SpringBoot+JPA多对多注解生成UUID错误
- @Entity @Data public class SysRole implements Serializable { @Id /*@GenericGenerator(name = "uuid", strategy = "org.hibernate.id.UUIDGenerator") @GeneratedValue(generator = "uuid")*/ @...
- Spring Data JPA 系列 —— 两张表（多对多关联）
- 这里通过一个完整的例子展示如何通过 JPA 对两张表（多对多关联）进行增删改查操作。
- JPA学习笔记（10）——映射双向多对多关联关系
- 多对多关联比如现在有两个实体类：1. Product（商品）2. Category（类别）一个商品可以有多个类别，一个类别也可以有多个商品，这就形成了多对多的关系Productpackage com.jpa.helloworld2;import java.util.List;import javax.persistence.Column; import javax.persistence.Entit
- jpa hibernate（1） 多对多，用户新增，只增加中间表对应角色关系，不增加角色role
- 用户user 角色role 中间表user_role，用户新增，只增加中间表对应角色关系，不增加角色role 只增加关联关系到中间表中,需要添加CascadeType.MERGEUser实体: @ManyToMany(cascade = {CascadeType.MERGE}) @JsonIgnore @JoinTable(name = "CMSUserRole", joinCol
- JPA 单向一对多关联 中间表生成唯一索引问题
- 目前的需求是这样的： 有A、B两个实体，A对B形成一对多的关联关系，目前我只需要配置单向一对多关联，即只在A中配置一对多，B中不做任何配置，具体如下： public class A implement
- Hibernate多对多中间表有多个字段字段的注解配置方式（二）
- 情况二：如果中间表不仅仅是做关联用的，它里面包含了其他字段信息，仅仅靠多对多的关系是搞不定的。 解决方案：多对多的关系拆分为两个一对多！这时候三张表的Model都需要写。 我们知道，一对多的关系，一般都是在多的一方做配置。具体代码如下： 学生表 @Entity @Table(name = "T_STUDENT") @SequenceGenerator(name = "S
- JPA多对多查询时，自动删除了中间表？？？
- Company类 @JoinTable(name="company_businesstype",joinColumns={@JoinColumn(name="company_id",reference
- 关于使用JPA的@ManyToOne注解的方法及踩过的雷
- 举个例子： 有两张表，员工表(employee)和部门表(department)。这个时候，员工表对于部门表来说，属于ManyToOne的一个关系，对应关系为多个员工对应一个部门。当我们创建表结构时，应在多的一方去维护表关系，也就是说，应将@ManyToOne注解加在员工表中，并且设置为懒加载。员工表： fetch = FetchType.Lazy 懒加载，作用是用到该属性的时候，才会...
- 求教一个spring boot jpa中多个实体类关联查询的问题应该怎么处理--急急
- 大致情况是这样的： 有一个角色表，有一个设备表，有一个角色设备的关联表 我想要查询某一个角色可以使用的设备，但是在spring boot中下面的findById这样的写法不行，求大神指教 packag
- Hibernate 多对多之拆分中间表增加有多个关系字段
- Hibernate多对多关系中间表有其他属性的配置方式 一、需求原因 在我做系统架构时遇到情况是这样：资源菜单实体类(Resource)和角色实体类(Role)是多对多关系，需要各个角色可以个性化自己的资源菜单顺序。 二、设计理念 多对多的关系拆分为两个一对多（以下为关系映射图） 三、具体配置 方式一：XML方式 Role实体 public class Ro
- jpa双向多对多关系
- 现在好多程序员用hibernate一两年有些问题还是弄不明白，这倒也不是什么稀罕事，hibernate东西太多了吃不透也特别正常，看过这篇文章我相信对jpa或hibernate的理解会更进一步。
- Spring Boot JPA 使用以及设置多个主键
- 一、spring data jpa的使用 推荐以下两篇文章 spring data jpa的使用 spring-boot-jpa 使用 @PreUpdate 和@PrePersist 二、设置多个主键（复合主键） 下面介绍两种方法： 第一种：@IdClass来设置多个主键 1、先写一个包含主键的类 @Data public class PrimaryKey implement...
- 多对多关系多表连接查询，同一个字段同时满足多个条件
- 分类表 t_keytype 商品表 t_product 分类商品关联表 t_typeproduct tid(分类ID) name (分类名称) pid(商品ID) name (商品名称) id pid
- spring data jpa 利用@Query进行查询
- 介绍@Query注释之前，先看看怎么利用@NamedQuery进行命名查询1.现在实体类上定义方法已经具体查询语句@Entity @NamedQuery(name = "Task.findByTaskName", query = "select t from Task t where t.taskName = ?1") public class Task{}2.然后我们继承接口之后，就可以直接用
- org.springframework.orm.jpa.JpaSystemException问题记录
- 最近在使用jpa的过程中出现了如下异常： org.springframework.orm.jpa.JpaSystemException: could not execute statement; nested exception is org.hibernate.exception.GenericJDBCException: could not execute statement at
- JPA多表关联多对多的查询
- JPA多表关联多对多的查询 多对多 需求：查询指定OID的用户，同时返回用户对应角色 注意事项 多对多的三个条件 1. 中间表 2. 本实体类对应的表在中间表的外键 3. 关联实体类对应的表在中间表的外键 配置步骤 //通过用户找到角色 //多对多的关系，说明一个用户可以有多个角色，使用集合 @ManyToMany //多对多的三个条件： 中间表，本实体类对应的表...
- jpa实现多对多表保存功能，中间表单的数据被覆盖
- 运行时发现数据库的数据被覆盖了。。 代码如下： //2)角色关联功能权限：持久态的关系 if(permissionIds!=null){ for (Integer permissionId : permissionIds) { // Permission permission = permissionRepository.findOne(permissionId); // //
- 错误：org.springframework.orm.jpa.JpaSystemException: could not deserialize;
- 这个是如果你用的是JPA操作数据库，在两张表进行关联时，要加上注解@ManyToOne，并且该类要实现序列化。
- SpringBoot JPA 表关联查询
- 今天给大家介绍一下如何利用JPA实现表关联查询。今天给大家举一个一对多的关联查询，并且是使用JPA原生的findBy语句实现的。例子中总共有两个实体类，一个是Floor（商品楼层类），另一个是FloorContent（商品楼层内容表）。下面看两张表的源代码：Floor类：package cms.model; import cms.model.base.BaseDomain; import org....
- Spring Data Jpa 复杂查询总结 (多表关联 以及 自定义分页 )
- 只是做一个总结所以就不多说废话了 实体类 @Entity @Table(name = "t_hotel") @Data public class THotel { @Id private int id; private String name; private String address; /** * 城市id */ p...
- JPA 多对多关联 中间表带有属性 两个外键作为中间表的联合主键时 直接操作中间表查询修改的方法
- 因为中间表带有属性，采用的多对多映射方式 两个实体类都使用 @OneToMany( mappedBy="workDateTime") 需求：因为中间表使用两个外键作为联合主键 ，如果需要对中间表的属性进行修改， 1、一般做法 从实体类获取中间表的集合，然后遍历中间表的集合，然后修改。 WorkDateTime.getWorkDateTimeProducts() 2、...
- spring boot jpa多表查询展示实体的方法
- 针对jpa中多表关联查询展示的办法： 1.就是利用hibernate的oneToMany跟ManyToOne的对应关系配置查询，但是这种情况对于数据库的压力较大，一般不采用 2.就是定义Bean，然后repository中配置查询返回实体类，repository中支持Entity的关联查询，查询出的字段赋值new的对象中进行返回处理。 @Data public class Temp
- Springboot JAP 字段自动添加下划线问题
- 数据库中的字段名是loginName，实体中应当这样写 @Column(name = “loginname”) private String loginName; 如果按照数据库中字段loginName,一样注解在实体类@Column(name = “loginName”) 执行sql语句时，会把驼峰字符转化为”_”+ 小写驼峰字符，查询时会变成login_name，所以会报异常...
- JPA关系映射系列五：many-to-many 关联表存在额外字段关系映射
- SpringDataJPA是Spring Data的一个子项目，通过提供基于JPA的Repository极大的减少了JPA作为数据访问方案的代码量，你仅仅需要编写一个接口集成下SpringDataJPA内部定义的接口即可完成简单的CRUD操作。 前言本篇文章引导你通过Spring Boot，Spring Data JPA和MySQL实现many-to-many关联表存在额外字段下关系映射。准备 JD
- springdatajpa多表查询死循环
- 近期在看springdatajpa多表查询的时候，运用注解@ManyToOne()，@ManyToMany的时候，出现死循环， 老是报错Detail formatter error: An exception occurred: java.lang.StackOverflowError 自己死磕了两天才发现问题的解决方法，所以记录下 防止后面再次入坑。 前期有排查spring 前端解析jso
- hibernate多对多之中间表有多个字段
- ame = name; } @Column(name = "sex") public int getSex() { return sex; } public void setSex(int sex) { this.sex = sex; } @OneToMany(mappedBy = "teacher",cascade=CascadeType.ALL) p
- Hibernate 多对多中间表 有其他字段映射
- 在使用hibernate中有时候在中间表中有其他的冗余字段以及排序字段等。。。。 解决方法有几种，最笨的就是多建一个实体对象。 在使用set方法中的一种可以在Hibernate 多对多中间表 有其他字段映射:
- JPA中的多对多和联合主键映射
- 完整版见https://jadyer.github.io/2011/02/11/jpa-composite-pk-mapping/
- SpringBoot-JPA进行多表连接查询
- 通过JPA进行简单的(内)连接查询1.准备1.1开发工具Intellij Idea1.2数据库mysql1.3新建Spring Initializr项目，勾选web,mysql,rest,jpa依赖2.开始2.1项目结构2.2pom.xml内容 http://maven.apache.org/
- JPA 多对多关联查询
- 假设有两张表user和goods,中间表为user_goods. JPA定义User类：@ManytoMany(cascade={CascadeType.PERSIST,CascadeType.REFRESH,CascadeType.MERGE)@JoinTable(name="user_goods", joinColumns={@JoinColumn(name="user_id",referen
- SpringBoot - 使用JPA，遇到MySQL区分大小写的问题
- 文章转载自https://blog.csdn.net/OO570741825/article/details/76020525开发前期我一直使用本机Windows系统建立的数据库，后来将数据库迁到Linux上，使用大写字母建立的表、字段JPA都提示不存在，JPA在后台打印的SQL语句也都是小写的，原来是JPA默认将表名等转换成小写了，研究了下有两种解决方式：改MySQL的cnf 关闭mysql 修...
- SpringBoot JPA 单/多表联合查询时遇见的！坑！
- 1、hibernte criteria 制作投影映射 ProjectionList proList = Projections.projectionList();//设置投影集合 //SELECT * //DISTINCT proList.add(Projections.distinct(Projections.property("userId"...
- ManyToOne凭空多了很多空记录，@OrderColumn的问题
- 今天做一个ManyToOne的查询，Many端数据库里只有11条记录，但是查出来却显示有171条记录！而且前160条都是null，这是怎么回事？ @OneToMany(cascade = CascadeType.ALL,fetch=FetchType.EAGER,mappedBy="notice") @OrderColumn(name = "ID") public List getFi
- Hibernate多对多之中间表只有两个外键做联合主键
- 一般情况下，多对多的关联关系是需要中间表的； 情况一：如果中间表仅仅是做关联用的，它里面仅有2个外键做联合主键，则使用ManyToMany（不用写中间表的Model，只需要写出两张主表的model即可） 学生表 @Entity @Table(name = "T_STUDENT") @SequenceGenerator(name = "SEQ_STUDENT", sequenc
- jpa 的多对多的属性时查询的两种方式
- 第一：采用JPQL方式，使用@Query拼接jpql语句完成多对多的查询;第二：采用specification 方法user中有List属性，多对多的关系； 代码如下： Specification specification = new Specification<>(){ @override public predicate toPredicate
- StringBoot实现多表查询
- 里通过一个完整的例子展示如何通过 JPA 对两张表（多对多关联，关联表带扩展字段）进行增删改查操作。 前提 JDK 8+Maven 3+ 表结构 例子 创建 Maven 项目 pom.xml project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2
- Spring Data JPA 系列 —— 单表
- 这里通过一个完整的例子展示如何通过 JPA 对单表进行增删改查操作。
- 利用中间表做多对多关联的查询
- http://www.iteye.com/problems/70150 select stu.stu_NO,stu.name,cou.cou_no,cou.name from s_c sc left join student stu on stu.id=sc.stu_id left join cource cou on cou.id=sc.cour_id where stu.name...
- JavaEE开发的颠覆者: Spring Boot实战
- JavaEE
- springboot根据表名和字段查询和更新实现动态sql(jpa,mybatis)
- 最近需要做一个根据表名和字段更新表的功能，项目结构是springboot+jpa，记录如下：1.经查阅资料jpa和hibernate自带对原生sql的支持都是不支持该操作的，原因是：jpa和hibernate在进行参数替换的时候是使用占位符的形式，防止了sql的注入，在解析会给参数带上单引号，但是可以通过定义原生的sql进行解决动态sql查询，但无法实现动态sql更新，如果需要更新必须获取到表对应...
- JPA - 双向多对多映射
- 在双向多对多关系中，我们必须指定一个关系维护端(owner side),可以通过 @ManyToMany 注释中指定 mappedBy 属性来标识其为关系维护端。【1】item与Categoryitem:category = N:N 。item类如下：@Table(name="JPA_ITEMS") @Entity public class Item { private Integer id;
- Spring data JPA遇到有大写的不规范的MySQL命名字段
- Spring data JPA遇到有大写的不规范的MySQL命名字段
- spring data jpa 多对一联表查询
- 数据库： 实体类： public class Product { @Id @GeneratedValue private Long id; private String name; private Double price; private String standerd; private String code; private
- 关于一对多的关联关系 spring json出现死循环的问题
- 经过查资料，发现一对多的关联类的json会出现死循环的原因是，转换成json时，从一到多的那端，发现多的那端，又回到了一的那端，如此反复就出现了是循环，这里参考了http://chembo.iteye.com/blog/899703的解释，在这种情况下，你需要把多的一端或者少的一端需要关联的熟悉给忽略就不会出现死循环了。 给忽略的属性的类头部加上：@JsonIgnorePropertie
- JPA的多对多映射
- 实体Player：玩家。 实体Game：游戏。 玩家和游戏是多对多的关系。一个玩家可以玩很多的游戏，一个游戏也可以被很多玩家玩。 JPA中使用 @ManyToMany来注解多对多的关系，由一个关联表来维护。这个关联表的表名默认是：主表名+下划线+从表名。(主表是指关系维护端对应的表,从表指关系被维护端对应的表)。这个关联表只有两个外键字段，分别指向主表ID和从表ID。字段的名称默
- Spring Boot使用JPA多条件查询mysql
- 我们在上一章节已经学习了Spring Boot中使用mysql数据库的读取功能。 Spring Boot中使用mysql数据库 本章节来学习一下使用JPA如何多条件查询mysql。 我们一开始继承的CrudRepository接口支持一些简单的查询，以及在Repository接口中增加一些方法，例如: List&lt;Person&gt; findDistinctPeopleByLas...
- JPA多对多的增删改查
- 以学生和老师为例直接上代码，跟一对多里的操作一样的：//多对多增加 @Test public void testAdd() { Student stu1 = new Student(); stu1.setName("xuesheng1"); Student stu2 = new Student(); stu2.setName("xuesheng2"); Teacher...
- 多对多类型的表ManyToManyField怎样增加额外字段
- https://docs.djangoproject.com/en/2.0/topics/db/models/#extra-fields-on-many-to-many-relationshipsExtra fields on many-to-many relationships¶When you’re only dealing with simple many-to-many relations...
- SpringData Jpa 的JPQL 多表关联查询
- package com.touchhealth.trade.service.afterSale; import com.touchealth.common.page.Pager; import com.touchhealth.trade.bo.afterSale.AfterSaleBo; import com.touchhealth.trade.entity.AfterSaleDo; impo...
- JPA一对多循环引用导致json序列化死循环
- 说是解决，其实不是很完美的解决的，写出来只是想记录一下这个问题或者看一下有没有哪位仁兄会的，能否知道一二。下面说说出现问题：问题是这样的，当我查询一个一对多的实体的时候，工具直接就爆了，差不多我就猜到是哪里死循环了，最后等了好久，查看原因，果然是堆溢出，再然后是jsckson的错误。那么必然是序列化的问题了。这是jackson的错误：at java.security.AccessControlle...
- 当JPA遇上MySQL表名全大写
- 最近在搞一个HRMS，功能不算复杂，先按下不表。这里说一个魂淡的小问题，很纠结，也很烦人。 公司之前有项目是用MySQL的，是我管的。这次这个项目也不大，就继续用那个MySQL吧。我一直知道MySQL在Linux上有字段名表名等的大小写问题，于是为了避免这个问题，选择了全大写的字段名和表名，心说虽然咱用的是JPA，只要使用注解写清楚表名和字段名是大写的，不也没事么。 实际上证明，想象比生活
- spring boot jpa 更新数据的方法 两种方法
- 这里有两种方式：看图或者看下面的代码 第一种是通过@PathVariable("id") 由于第一种的参数比较多，所以我们用第二种的方法 让它传入一个JSON数据。 @PutMapping("/update/{id}") @ResponseBody public void update(@PathVariable("id") Integer id, ...
- JPA中映射关系详细说明(一对多，多对一，一对一、多对多）、@JoinColumn、mappedBy说明
- JPA中的映射关系 jpa中维护one to one ,one to many, many to one ,many to many 四种映射关系。 在每个关系中，双方中的一方在其表中拥有连接列。那么一方称为所有方(owning side) 或者关系的所有者。 不具有连接列的一方称之为非所有方(non-owning)或者反方 所有权对于映射很重要，因为用于定义映射到...
- 解决springboot集成springdataJpa的数据库字段名_问题
- 在yml中加入如 jpa: database: MYSQL show-sql: true hibernate: ddl-auto: update * naming.physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl 这样就可以解决了...
- springMVC返回hibernate多对多对象的json时 出现无限循环
- jackson中的@JsonBackReference和@JsonManagedReference，以及@JsonIgnore均是为了解决对象中存在双向引用导致的无限递归（infinite recursion）问题。这些标注均可用在属性或对应的get、set方法中。 @JsonBackReference和@JsonManagedReference：这两个标注通常配对使用，通常用在父子关系中
- springBoot JPA 查询中出现的问题
- springBoot JPA 问题汇总
- Spring Boot集成JPA的Column注解命名字段无效的问题
- 偶然发现，Spring Boot集成jpa编写实体类的时候，默认使用的命名策略是下划线分隔的字段命名。Spring Boot版本：1.5.4.release数据表：id int, userName varchar(50)那么如下的映射：@Data @Entity @Table(name="t_users") @NoArgsConstructor @AllArgsConstructor @Access
- 源码解析，浅谈spring-data-jpa 中莫名的查询字段不存在问题
- org.springframework.data.mapping.PropertyReferenceException: No property XXX found for type XXXXX! 终究的原因是spring-data-commons版本低导致的，升级到新版本就没问题了，或者在查询时添加的Sort中的Orderby参数 不带下划线就可以了 如果想了解源码的可以继续往下看，让你了解
- Hibernate JAP 字段自动添加下划线问题,
- 数据库中的字段名是productName，实体中应当这样写 @Column(name = "productname") private String productName; 如果按照数据库中字段ProductName,一样注解在实体类@Column(name = "productName") 执行sql语句时，会把驼峰字符转化为"_"+ 小写驼峰字符，查询时会变成pr
- 11.Springboot 之 使用JPA对数据进行排序
- 本文所属【知识林】：http://www.zslin.com/web/article/detail/18 在网站系统的开发过程中经常会用到排序操作，下面就我个人的理解介绍一下使用强大的JPA是如何进行排序的。 基础搭建 pom.xml parent> groupId>org.springframework.bootgroupId> artifactId>spri
- hibernate多对多，中间表无数据问题
- 1.两个实体类：类目，属性 2.关系多对多 3.类目Category类 @ManyToMany(cascade = CascadeType.ALL) @JoinTable( name="category_items",//第三张表名 joinColumns=@JoinColumn(name="cate_id"),//当前类在两张表关系
- Springboot 之 使用JPA做数据筛选
- 本文章来自【知识林】在网站系统开发过程中搜索筛选功能随处可见，在JPA中提供的筛选功能只要简单做下封装将非常好用。在文章《Springboot 之 使用JPA对数据进行排序》和《Springboot 之 使用JPA进行分页操作》中讲述了JPA的排序和分页，在本篇文章中将以前两个测试项目的数据做一下筛选功能的描述及详情的测试。 修改接口对象 筛选功能需要继承于JpaSpecificationExecu
- [增删改查] 最简单的 JPA 一对多/多对一 CRUD 设计
- 一、前言 1、之前写过很多 SpringBoot 使用 JPA 实现 dao 层的 CRUD： [增删改查] SpringBoot+JPA+EasyUI+MySQL 基本 CURD 但基本都是单表的 2、而实际开发中，最常见的就是 一对多/多对一 的关系， 3、实现 JPA 多表的 CRUD 的方式主要有两种： ① 使另一个实体为另一个实体的属性，成对使用注解 @ManyToOn...
- SpringData Jpa自动建表配置以及问题
- 在使用Springboot + JPA的项目中 使用了JPA的自动建表功能 项目的配置方法如下:Maven项目依赖配置在pom.xml文件中引入 mysql mysql-
- Springboot 之 使用JPA对数据进行排序
- 本文章来自【知识林】在网站系统的开发过程中经常会用到排序操作，下面就我个人的理解介绍一下使用强大的JPA是如何进行排序的。基础搭建 pom.xml org.springframework.boot spring-boot-starter-parent 1
- SpringDataJPA class与数据库表出现找不到主键的问题
- 1，检查@Id的包 很多的包里有该注解，主键注解需要import javax.persistence @Id的注解引入包2，@Query 进行删除操作时 返回值必须是int @Query("delete from ServiceProductOrderValidNum vc where vc.month = ?1") @Modifying int deleteByMonth(St
- 注解@ManytoMany 多对多关系 简单使用方法
- import java.util.HashSet; import java.util.Set; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; impo
- SpringBoot第五讲扩展和封装Spring Data JPA(二)_利用Specification封装简单查询
- 上一讲讲解了如何使用Spring Data JPA封装一个自己的BaseRespoistory工厂，这个在实际开发中是非常有必要的，今天我们来进一步封装Spring Data JPA的查询。Spring Data JPA已经帮助我们很大程度上简化了我们的查询操作，我们甚至只要写一个接口，然后单纯的写一些方法就可以完成各式各样的查询，但是对于我们程序设计人员而言，总希望所有的查询变得更加的简单方便，为
- spring data jpa 框架在实体类中添加非数据库字段的属性
- Spring-data-jpa表实体的字段和表的字段是一一对应的。比如，那么，如果我在查询时，想在表字段的基础上添加几个返回的字段，怎么办？ 解：在实体类中添加我们想添加的字段，并加上注解：@Transient，如图所示： @Transient privite String userId; 这样在调用此类返回时，便有了此字段，我们可以给这个字段赋值，进行操作，而且不会在数据库中添加
- Spring Boot学习笔记（三）——使用JPA查询数据库返回需要的数据
- 1.概述 在上一篇中，我们已经学会了如何创建运行一个Spring Boot程序，但是他还远远满足不了一个网站的基本需求，完成这篇的学习后我们就能实现一个简单的雏形。 2.目标 在本篇中，实现的简单的数据库访问，读取数据的功能。 3.详细步骤...
- Spring data jpa查询多个部分字段的方法
- 最近在使用spring data jpa结合hibernate来开发java程序，平常经常使用的实体entity来进行数据的交互，现在场景需要查询部分字段，经过各种踩坑，发现可以使用jpa中的EntityManager来实现，具体如下： 1、创建实体 @Entity @Table(name = "person_t") public class Person {} 2、声明变量
- JPA 通过注解自动生成表，添加 字段名、类型、注释
- JPA对象注解类型 @Table - 映射表名 @Id - 主键 @GeneratedValue(strategy=GenerationType.IDENTITY) - 自动递增生成 @Column(name = “dict_name”,columnDefinition=”varchar(100) COMMENT ‘字典名’”) - 字段名、类型、注释 @UpdateTimestamp ...
- JPA在@OneToMany里加入mappedBy属性避免生成中间表
- JPA在@OneToMany里加入mappedBy属性避免生成中间表
- JPA,HQL多对多的查询语句
- 一个老师教许多学生,一个学生被许多老师教,一个学生有好多书,同一种书被许多同学拥有. 要查询教拥有书"a"的学生的老师! Hql语句： SELECT t FROM Teacher t join t.students s join s.books b where b.name = 'a' 解释：t.students s中s并不是集合的意思,而是t的students对象的表别名,join
我们是很有底线的