精华内容
下载资源
问答
  • mappedBy reference an unknown target entity property 错误 @ManyToMany(mappedBy @OneToMany(mappedBy
    2020-09-01 01:59:37

    mappedBy reference an unknown target entity property 错误 @ManyToMany(mappedBy = @OneToMany (mappedBy =

    @OneToMany(mapped=“由One的一方指向Many的一方,并且,这个属性应该等于Many的一方中含有One类的属性的属性名,否则会出错”)

    今天使用springboot jpa @ManyToMany 出现如下错误:

    Error starting ApplicationContext. To display the conditions report re-run your application with ‘debug’ enabled.
    2020-09-01 00:51:21.890 ERROR 67575 — [ main] o.s.boot.SpringApplication : Application run failed

    org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘XXXRepository’ defined in com.example.category.repository.CategoryPropertyRepository defined in @EnableJpaRepositories declared on JpaRepositoriesRegistrar.EnableJpaRepositoriesConfiguration: Cannot resolve reference to bean ‘jpaMappingContext’ while setting bean property ‘mappingContext’; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘jpaMappingContext’: Invocation of init method failed; nested exception is org.hibernate.AnnotationException: mappedBy reference an unknown target entity property: com.example.category.entity.FeedCategory.categoryPropertie in com.example.category.entity.CategoryProperty.feedCategories
    at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:342) ~[spring-beans-5.2.8.RELEASE.jar:5.2.8.RELEASE]

    谷歌了一下发现是mappedBy后面写错了,应该对应另一个类的某个变量

    stackoverflow 高赞回答:

    The mappedBy attribute is referencing customer while the property is mCustomer, hence the error message. So either change your mapping into:

    下面展示一些 内联代码片

    /** The collection of stores. */
    @OneToMany(mappedBy = "mCustomer", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Collection<Store> stores;
    Or change the entity property into customer (which is what I would do).
    

    The mappedBy reference indicates "Go look over on the bean property named ‘customer’ on the thing I have a collection of to find the configuration."

    stackoverflow上原问题:

    I am having an issue in setting up a one to many relationship in my annotated object.

    I have the following:
    下面展示一些 内联代码片

    @MappedSuperclass
    public abstract class MappedModel
    {
        @Id
        @GeneratedValue(strategy=GenerationType.AUTO)
        @Column(name="id",nullable=false,unique=true)
        private Long mId;
    

    then this

    @Entity
    @Table(name="customer")
    public class Customer extends MappedModel implements Serializable
    {
    
        /**
       * 
       */
      private static final long serialVersionUID = -2543425088717298236L;
    
    
      /** The collection of stores. */
        @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
      private Collection<Store> stores;
    

    and this

    @Entity
    @Table(name="store")
    public class Store extends MappedModel implements Serializable
    {
    
        /**
     * 
       */
      private static final long serialVersionUID = -9017650847571487336L;
    
      /** many stores have a single customer **/
      @ManyToOne(fetch = FetchType.LAZY)
      @JoinColumn (name="customer_id",referencedColumnName="id",nullable=false,unique=true)
      private Customer mCustomer;
    

    what am i doing incorrect here

    感悟:
    所以还是要多用google,以及先弄清楚某些东西的含义。

    map 绘制…的地图; 了解信息,提供信息(尤指其编排或组织方式);

    map : arrange in detail

    mappedBy

    更多相关内容
  • mappedBy属性:one2many

    2019-04-13 01:35:13
    NULL 博文链接:https://605113068.iteye.com/blog/1727088
  • mappedBy

    千次阅读 2018-07-02 14:39:02
    mappedBy的意思就是“被映射”,即mappedBy这方不用管关联关系,关联关系交给另一方处理1.规律:凡是双向关联,mapped必设,因为根本都没必要在2个表中都存在一个外键关联,在数据库中只要定义一边就可以了a) 只有...




    mappedBy的意思就是“被映射”,即mappedBy这方不用管关联关系,关联关系交给另一方处理

    1.规律:凡是双向关联,mapped必设,因为根本都没必要在2个表中都存在一个外键关联,在数据库中只要定义一边就可以了

    a) 只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性,ManyToOne不存在该属性; 
    b) mappedBy标签一定是定义在the owned side(被拥有方的),他指向the owning side(拥有方);
    c) mappedBy的含义,应该理解为,拥有方能够自动维护 跟被拥有方的关系; 
       当然,如果从被拥有方,通过手工强行来维护拥有方的关系也是可以做到的。

    d) mappedBy跟JoinColumn/JoinTable总是处于互斥的一方,可以理解为正是由于拥有方的关联被拥有方的字段存在,拥有方才拥有了被 拥有方。mappedBy这方定义的JoinColumn/JoinTable总是失效的,不会建立对应的字段或者表

     


    人跟身份证双向关联

    在Person 里面定义的注解:

    @OneToOne(cascade={CascadeType.ALL},optional=true) 
    public IDCard getIdCard() { 
             return idCard; 
    }

    在IDCard 里面定义的注释: 
    @OneToOne(cascade=CascadeType.ALL,mappedBy="idCard" , optional=false) 
    public Person getPerson() { 
           return person; 

    多了一个mappedBy这个方法,它表示什么呢?它表示当前所在表和Person的关系是定义在Person里面的idCard这个成员上面的,它表示此表是一对一关系中的从表,也就是关系是在person表里面维护的 ,这一点很重要 . Person表是关系的维护者,owner side,有主导权,它有个外键指向IDCard。 
    我们也可以让主导权在IDCard上面,也就是让它产生一个指向Person的外键,这也是可以的,但是最好是让Person来维护整个关系,这样更符合我们正常的思维 .

    我们也可以看到在Person里面IDCard是注释是optional=true,也就是说一个人是可以没有身份证的,但是一个身份证不可以没有人,所以在IDCard里面注释person的时候,optional就为false了,这样就可以防止一个空的身份证记录进数据库.

    展开全文
  • mappedby 详解

    2019-09-14 06:39:49
    mappedby=?,后面的这个问号跟拥有方,以下是实例。 Role.java package com.nbg.nuskin.oa.domain; import java.util.HashSet; import java.util.Set; import javax....

    mappedby=?,后面的这个问号跟拥有方,以下是实例。


    Role.java


    package com.nbg.nuskin.oa.domain;
    
    import java.util.HashSet;
    import java.util.Set;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.ManyToMany;
    
    /**
     * 
     * 
     * @author Administrator
     * 
     */
    @Entity
    public class Role {
    	private long id;
    	
    	private Set<Privilege> privileges = new HashSet<Privilege>();
    
    	@Id
    	@GeneratedValue
    	public long getId() {
    		return id;
    	}
    
    	public void setId(long id) {
    		this.id = id;
    	}
    
    	//大家一定要注意这里,没有mappedby,拥有方是属于privilege的
    	@ManyToMany
    	public Set<Privilege> getPrivileges() {
    		return privileges;
    	}
    
    	public void setPrivileges(Set<Privilege> privileges) {
    		this.privileges = privileges;
    	}
    
    }




    Privilege.java


    package com.nbg.nuskin.oa.domain;
    
    import java.util.HashSet;
    import java.util.Set;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToMany;
    import javax.persistence.ManyToOne;
    import javax.persistence.OneToMany;
    import javax.persistence.OrderBy;
    
    @Entity
    public class Privilege {
    	private Long id;
    	private Set<Role> roles = new HashSet<Role>();
    
    	@Id
    	@GeneratedValue
    	public Long getId() {
    		return id;
    	}
    
    	public void setId(Long id) {
    		this.id = id;
    	}
    	//拥有方是Privilege.java
    	@ManyToMany(mappedBy = "privileges")
    	public Set<Role> getRoles() {
    		return roles;
    	}
    
    	public void setRoles(Set<Role> roles) {
    		this.roles = roles;
    	}
    
    }


    下面是RoleAction.java对Role的操作


    package com.nbg.nuskin.oa.action;
    
    import java.util.HashSet;
    import java.util.List;
    
    import javax.annotation.Resource;
    
    import com.nbg.nuskin.oa.domain.Privilege;
    import com.nbg.nuskin.oa.domain.Role;
    import com.nbg.nuskin.oa.service.PrivilegeService;
    import com.nbg.nuskin.oa.service.RoleService;
    import com.opensymphony.xwork2.ActionContext;
    import com.opensymphony.xwork2.ActionSupport;
    import com.opensymphony.xwork2.ModelDriven;
    
    public class RoleAction extends ActionSupport implements ModelDriven<Role> {
    	private RoleService roleService;
    	
    	protected Role model = new Role();
    
    	public RoleService getRoleService() {
    		return roleService;
    	}
    
    	@Resource(name = "roleService")
    	public void setRoleService(RoleService roleService) {
    		this.roleService = roleService;
    	}
    
    	/**
    	 * 设置权限
    	 * 
    	 * @return
    	 */
    	public String setPrivilege() {
    		Role role = roleService.getById(model.getId());
    		System.out.println(role.getName()+";"+role.getDescription());
    		List<Privilege> privileges = privilegeService.getByIds(privilegeIds);
    		
    		role.setPrivileges(new HashSet<Privilege>(privileges));
    		roleService.update(role);
    		return "toList";
    	}
    
    	public Long[] getPrivilegeIds() {
    		return privilegeIds;
    	}
    
    	public void setPrivilegeIds(Long[] privilegeIds) {
    		this.privilegeIds = privilegeIds;
    	}
    
    }
    只有这样设置mappeby,在上面的action中才能够操作相应的privilege


    mappedby原理:被拥有方改变,即拥有方主动关联操作关联关系;拥有方改变,不一定操作相关的关联关系

    上面的mappedby如果设在roles这边,privileges就不会进行sql的update操作。

    版权声明:本文为博主原创文章,未经博主允许不得转载。

    转载于:https://my.oschina.net/u/2325575/blog/496394

    展开全文
  • hibernate 注解方式 属性mappedBy详解

    万次阅读 2018-01-17 17:55:05
    遇到的问题:在hibernate一对多的注解中,由于没有添加mappedBy=“多端的关联属性名”,导致在更新数据时,外键被置空(null),意思是由多的一端来维护关系。(一般由有外键的一方来维护)解决方法:一:Author(作者...

    遇到的问题:

    在hibernate一对多的注解中,由于没有添加mappedBy=“多端的关联属性名”,导致在更新数据时,外键被置空(null),意思是由多的一端来维护关系。(一般由有外键的一方来维护)

    解决方法:

    一:Author(作者)     多:Book(书籍)

    其代码分别如下:
    Author的pojo代码:
    package com.jason.domain;
    
    import java.io.Serializable;
    import java.util.List;
    import java.util.Set;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.OneToMany;
    import javax.persistence.SequenceGenerator;
    import javax.persistence.Table;
    
    import org.hibernate.annotations.Cascade;
    import org.hibernate.annotations.CascadeType;
    
    @Entity  
    @Table(name = "Author")
    public class Author implements Serializable{
    	private Integer id;
    	private String authorName;
    	private Set<Book> bookList;
    	
    	@Id
    	@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="generator")
    	@SequenceGenerator(sequenceName="Author_SEQ",
    		name="generator",initialValue=1,allocationSize=1)
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	
    	@Column(name = "authorName", length = 30)
    	public String getAuthorName() {
    		return authorName;
    	}
    	public void setAuthorName(String authorName) {
    		this.authorName = authorName;
    	}
    	
    	@OneToMany(mappedBy="author")  //添加mappedBy="author"解决,但注意不能与@JoinColumn(name="author_id")共存
    	@Cascade(value= {CascadeType.ALL}) //设定级联关系
    	public Set<Book> getBookList() {
    		return bookList;
    	}
    	public void setBookList(Set<Book> bookList) {
    		this.bookList = bookList;
    	}
    	@Override
    	public String toString() {
    		return "Author [id=" + id + ", authorName=" + authorName + "]";
    	}
    	
    }
    


    Book的pojo代码:
    package com.jason.domain;
    
    import java.io.Serializable;
    
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToOne;
    import javax.persistence.SequenceGenerator;
    import javax.persistence.Table;
    
    import org.hibernate.annotations.Cascade;
    import org.hibernate.annotations.CascadeType;
    
    @Entity  
    @Table(name = "Book")
    public class Book implements Serializable{
    	private Integer id;
    	private String bookName;
    	private Float price;
    	private Author author;
    
    	public Book() {
    	}
    	
    	public Book(String bookName, Float price) {
    		this.bookName = bookName;
    		this.price = price;
    	}
    	
    	@Id
    	@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="generator")
    	@SequenceGenerator(sequenceName="Book_SEQ",
    		name="generator",initialValue=1,allocationSize=1)
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	
    	@Column(name = "bookName", length = 30)
    	public String getBookName() {
    		return bookName;
    	}
    	public void setBookName(String bookName) {
    		this.bookName = bookName;
    	}
    	
    	//scale:小数位数
    	@Column(name = "price",scale = 1)
    	public Float getPrice() {
    		return price;
    	}
    	public void setPrice(Float price) {
    		this.price = price;
    	}
    	
    	@ManyToOne
    	@JoinColumn(name="author_id")
    	@Cascade(CascadeType.ALL)
    	public Author getAuthor() {
    		return author;
    	}
    
    	public void setAuthor(Author author) {
    		this.author = author;
    	}
    
    	@Override
    	public String toString() {
    		return "Book [id=" + id + ", bookName=" + bookName + ", price=" + price + ", author=" + author + "]";
    	}
    
    	
    	
    }
    

    详细知识:

    mappedBy: 
    1、只有@OneToOne,@OneToMany,@ManyToMany上才有mappedBy属性,ManyToOne不存在该属性; 
    2、mappedBy标签一定是定义在被拥有方的(被控方),他指向拥有方; 
    3、mappedBy的含义,应该理解为,拥有方能够自动维护跟被拥有方的关系,当然,如果从被拥有方,通过手工强行来维护拥有方的关系也是可以做到的; 
    4、mappedBy跟joinColumn/JoinTable总是处于互斥的一方,可以理解为正是由于拥有方的关联被拥有方的字段存在,拥有方才拥有了被拥有方。mappedBy这方定义JoinColumn/JoinTable总是失效的,不会建立对应的字段或者表。

    下面是一个例子: 
       人跟身份证双向关联 

       在person里面定义的注释代码:
    @OneToOne(cascade = CascadeTye.ALL,optional = true)  
    public IDCard getIdCard(){  
       return idCard;  
    }
       在idcard里面定义的注释代码:
    @OneToOne(cascade = CascadeType.ALL,mappedBy = "idCard",optional = false)  
    public Person getPerson(){  
       return person;  
    }

    解释:
    多了一个mappedBy这个方法,他表示什么呢?它表示当前所在表和Person的关系是定义在Person里面的idCard这个成员上面的,他表示此表是一对一关系中的从表,也就是关系是在person表中维护的,这是最重要的。Person表是关系的维护者,有主导权,它有个外键指向IDCard。 
    我们也可以让主导权在IDCard上面,也就是让他产生一个指向Person的外键,这也是可以的,但是最好让Person来维护整个关系,这样更符合我们的思维。 
    我们也可以看到在Person里面的IDCard是注释optional=true,也就是说一个人是可以没有身份证的,但是一个身份证是不可以没有人的,所以在IDCard里面注释Person的时候,optional=false了,这样就可以防止一个空的身份证记录进数据库。
     
    展开全文
  • 解决方案 The mappedBy attribute is only necessary for a bidirectional relationship, this element can be omitted on the annotation. It is used on the source entity to point back to a field on the ...
  • mappedBy主要用于需要外键(存在于@OneToOne,@OneToMany,@ManyToMany中)的场景下,帮助我们进行外键管理。 使用@JoinColumn存在的问题 在“一对多”的场景下,如果不使用mappedby,则一般是在“一方”和“多方”...
  • 关于jpa的mappedBy用法

    千次阅读 2019-12-26 18:37:54
    mappedBy reference an unknown target entity property 对于这种错误,因为映射关系处理错误 @Entity @Table(name = "source_data") public class SourceData implements Serializable { /** * 对应table的...
  • mappedBy reference an unknown target entity property mappedBy指向的是要关联的属性,而不是要关联的类 @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, mappedBy = “AutoRepair”) 但实际上没有...
  • mappedBy: 1>只有OneToOne,OneToMany,ManyToMany上才有mappedBy属性,ManyToOne不存在该属性; 2>mappedBy标签一定是定义在被拥有方的,他指向拥有方; 3>mappedBy的含义,应该理解为,拥有方能够自动...
  • JPA JoinColumn vs mappedBy

    2021-05-13 11:31:00
    问题:JPA JoinColumn vs mappedBy 两者的区别是什么呢 @Entity public class Company { @OneToMany(cascade = CascadeType.ALL , fetch = FetchType.LAZY) @JoinColumn(name = "companyIdRef", ...
  • mappedBy用于指定在双向关系中两个实体中被哪个实体是被关联处理的   1、@OneToMany(mapped=“由One的一方指向Many的一方,并且,这个属性应该等于Many的一方中含有One类的属性的属性名,否则会出错啦 ”) 如: ...
  • 本文翻译自:What's the difference between @JoinColumn and mappedBy when using a JPA @OneToMany association What is the difference between: 之间有什么区别? @Entity public class Company { @OneToMany...
  • 实体关系 MySQL 实体模型共有三种关系,一对一,一对多,多对多,多对一是...@JoinColumn @MappedBy 当关系为对一时,两种处理方法分别对应以下方式。以部门(Department)和成员(Employee)为例 额外生成表 // Depa
  • 如果要使用双向关联,在班级类中添加一个容器属性来存放学生,并使用@OneToMany注解进行映射,此时mappedBy属性就非常重要。如果使用XML进行配置,可以用标签的inverse="true"设置来达到同样的效果。
  • mappedBy reference an unknown target entity property解决方法
  • 如果关联关系时双向的,mappedBy属性必须用来标注,在拥有关联关系的实体一方中表示关系的字段名,也就是使用mappedBy属性是不维护关联关系的一方,值是拥有关联关系一方中标识关系的字段名 使用了mappedBy属性后...
  • 在单向关系中没有mappedBy,因此使用@JoinColumn建立外键关联,建立外键的一端即是主控方,主控方相当于拥有指向另一方的外键的一方。 一对一和多对一的@JoinColumn注解的都是在“主控方”,都是本表指向外表的...
  • 报错信息为: mappedBy reference an unknown target entity property: ...这样的问题一般是mappedby ...
  • mappedBy 单向关系不需要设置该属性,双向关系必须设置,避免双方都建立外键字段 mappedBy属性也能避免会多出一张表,这样也能有效减少SQL语句(可设置属性用n的一方来维护关联关系,而1的一方不维护)...
  • @JoinColumn 与mappedBy

    千次阅读 2017-04-05 11:13:09
    观察 当我们只使用 @ManyToOne 和 @OneToMany 修饰实体的关联对象时,那么使用 ...可以用来修饰一的一方,避免建立中间表,当子类的父类属性设置了父类对象时,可以用mappedBy修饰一的一方,避免多余的update属性。
  • * @mappedBy注解的作用:在JPA中,在@OneToMany里加入mappedBy属性可以避免生成一张中间表。 */ /** * 在‘一’的一方,将关系维护交给多的一方,就像一本书出版后,自己去定义自己的图书类型, * 然后...
  • https://www.cnblogs.com/langtianya/p/3793557.html
  • hibernate mappedBy属性详解!

    千次阅读 2017-03-31 11:05:56
    mappedBy的意思就是“被映射”,即mappedBy这方不用管关联关系,关联关系交给另一方处理1.规律:凡是双向关联,mapped必设,因为根本都没必要在2个表中都存在一个外键关联,在数据库中只要定义一边就可以了a) 只有...
  • org.hibernate.AnnotationException: mappedBy reference an unknown target entity property: com…domain.PurchaseBillItem.bill in com…domain.PurchaseBill.items 意思为:org.hibernate.AnnotationException:...
  • Hibernate mappedby
  • hibernate中mappedby的理解

    千次阅读 2016-11-24 20:51:49
    mappedBy的意思就是“被映射”,即mappedBy这方不用管关联关系,关联关系交给另一方处理 1.规律:凡是双向关联,mapped必设,因为根本都没必要在2个表中都存在一个外键关联,在数据库中只要定义一边就可以了 a) ...
  • 在单向关系中没有mappedBy,因此使用@JoinColumn建立外键关联,建立外键的一端即主控端,主控方相当于拥有指向另一方的外键的一方。 1、一对一和多对一的@JoinColumn注解的都是在“主控方”,都是本表指向外表的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 58,396
精华内容 23,358
关键字:

mappedby

友情链接: 222.zip