manyToMany，设置了“CascadeType.PERSIST”，无法级联存储

最新推荐文章于 2021-02-13 01:38:49 发布
转载 最新推荐文章于 2021-02-13 01:38:49 发布 · 6k 阅读 · 0
文章标签：

#jpa #spring

本文探讨了在Hibernate中如何正确配置级联操作以实现学生和课程对象的自动存储。通过对比不同级联类型的使用场景及调整注解形式，解决了仅在特定条件下生效的问题，并给出了代码示例。

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

学生、课程，多对多的关系，学生是关系维护端。
我在学生类里的课程集合上设置了CascadeType.PERSIST，但存储学生对象时无法自动存储级联的课程对象，
除非将CascadeType.PERSIST改成CascadeType.ALL，但ALL里面包含了REMOVE操作，我又不想要这个REMOVE操作。

（我舍去注解的形式采用hbm配置文件重新配置了一遍，在Student.hbm.xml文件里的课程集合上配置了cascade="save-update"，然后存储学生对象时就能自动存储级联的课程对象，为什么配置文件形式就可以，而注解形式就不行？）


为了表述的更加清楚，请看以下代码：
学生类：
Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package  my.bean;
 
import  java.util.Set;
 
import  javax.persistence.CascadeType;
import  javax.persistence.Entity;
import  javax.persistence.GeneratedValue;
import  javax.persistence.Id;
import  javax.persistence.JoinColumn;
import  javax.persistence.JoinTable;
import  javax.persistence.ManyToMany;
import  javax.persistence.SequenceGenerator;
 
@Entity
public  class  Student {
     private  int  id;
     private  String sname;
     
     private  Set<Course> courses;
     
     @Id
     @SequenceGenerator (name= "idGenerator" , sequenceName= "seq_student_id" )
     @GeneratedValue (generator= "idGenerator" )
     public  int  getId() {
         return  id;
     }
 
     public  void  setId( int  id) {
         this .id = id;
     }
 
     public  String getSname() {
         return  sname;
     }
 
     public  void  setSname(String sname) {
         this .sname = sname;
     }
     
     @ManyToMany (cascade={CascadeType.PERSIST, CascadeType.MERGE, 
             CascadeType.REFRESH})
     @JoinTable (name= "student_course" ,
             joinColumns={ @JoinColumn (name= "student_id" )},
             inverseJoinColumns={ @JoinColumn (name= "course_id" )})
     public  Set<Course> getCourses() {
         return  courses;
     }
 
     public  void  setCourses(Set<Course> courses) {
         this .courses = courses;
     }
}


课程类：
Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package  my.bean;
 
import  java.util.Set;
 
import  javax.persistence.CascadeType;
import  javax.persistence.Entity;
import  javax.persistence.GeneratedValue;
import  javax.persistence.Id;
import  javax.persistence.ManyToMany;
import  javax.persistence.SequenceGenerator;
 
@Entity
public  class  Course {
     private  int  id;
     private  String cname;
     
     private  Set<Student> students;
     
     @Id
     @SequenceGenerator (name= "idGenerator" , sequenceName= "seq_course_id" )
     @GeneratedValue (generator= "idGenerator" )
     public  int  getId() {
         return  id;
     }
 
     public  void  setId( int  id) {
         this .id = id;
     }
 
     public  String getCname() {
         return  cname;
     }
 
     public  void  setCname(String cname) {
         this .cname = cname;
     }
     
     @ManyToMany (cascade={CascadeType.PERSIST, CascadeType.MERGE, 
             CascadeType.REFRESH}, mappedBy= "courses" )
     public  Set<Student> getStudents() {
         return  students;
     }
 
     public  void  setStudents(Set<Student> students) {
         this .students = students;
     }
}


测试类：
Java code
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package  my.test;
 
import  java.util.HashSet;
import  java.util.Set;
 
import  my.bean.Course;
import  my.bean.Student;
import  my.util.HibernateSessionFactory;
 
import  org.hibernate.HibernateException;
import  org.hibernate.Session;
import  org.hibernate.Transaction;
import  org.hibernate.cfg.Configuration;
import  org.hibernate.tool.hbm2ddl.SchemaExport;
 
 
public  class  Test {
 
     public  static  void  main(String[] args) {
         
         cascadeSave();
     }
         
     public  static  void  cascadeSave() {
         Student s1 =  new  Student();
         s1.setSname( "zhangsan" );
         s1.setCourses( new  HashSet<Course>());
                 
         Course c1 =  new  Course();
         c1.setCname( "c++" );
         c1.setStudents( new  HashSet<Student>());
         
         Course c2 =  new  Course();
         c2.setCname( "java" );
         c2.setStudents( new  HashSet<Student>());
                 
         Session session =  null ;
         Transaction transaction =  null ;
         try  {
             session = HibernateSessionFactory.getSession();
             transaction = session.beginTransaction();
             
             s1.getCourses().add(c1);
             s1.getCourses().add(c2);
             
             session.save(s1);  //存储student对象时，无法自动存储级联的course对象，why？
 
             transaction.commit();
         }  catch (HibernateException e) {
             e.printStackTrace();
             if (transaction !=  null ) transaction.rollback();
         }  finally  {
             if (session !=  null ) session.close();
         }
     }
     
             
}

解：@OneToMany(cascade = {CascadeType.PERSIST}），发现级联不起作用，如果更改为Hibernate的注解 @Cascade({org.hibernate.annotations.CascadeType.PERSIST})，依然不起作用，但改为 @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE})之后，注解生效。
原因如下：
如果使用javax.persistence.*里面的注解，只有调用相应的方法才生效，如PERSIST，只有调用persist方法才生效，Hibernate的注解也是如此。
查看我的代码，我保存对象用的是save方法，因此要用SAVE_UPDATE，级联才能生效。

2、使用方法
如果在ManyToOne的一端使用，如下（Vote类）：
@ManyToOne
    @Cascade({CascadeType.SAVE_UPDATE})
    private VoteSubject voteSubject;

那么在保存该Vote对象时，如果对象的voteSubject属性是一个新对象，则会在保存Vote对象时，顺便把voteSubject对象保存；反之，如果one2Many的一端如果没有设置关联，则one的一端保存时，不会保存集合中的新对象。

也就是说在哪个对象中的相应属性中设置了级联，那么在操作该对象时级联生效。
如果想让有关系的双方同时级联生效，那么级联要在两个对象中同时设置。

@ManyToOne(cascade = { CascadeType.PERSIST,CascadeType.MERGE}) 
@JoinColumn(name = "HOSPITAL_ID") 

改为： 
@ManyToOne() 
@Cascade(value={CascadeType.SAVE_UPDATE}) 
@JoinColumn(name = "HOSPITAL_ID") 

并把 
import javax.persistence.CascadeType; 
import javax.persistence.Cascade; 
改成 
import org.hibernate.annotations.Cascade; 
import org.hibernate.annotations.CascadeType; 







I have three entities (taken from the Spring Data REST Exporter Example): Person, Address and Profile. A Person can have addresses and profiles.

@Entity
public class Person {

    @Id
    @GeneratedValue
    private Long id;
    private String name;
    @Version
    private Long version;
    @OneToMany
    private List<Address> addresses;
    @OneToMany
    private Map<String, Profile> profiles;

    // getters and setters
}

In the client side I use Spring's RestTemplate. I added the Jackson2HalModule to the ObjectMapper used by the MappingJackson2HttpMessageConverter used by my RestTemplate.

Since Address and Profile do not have references to other entities I can POST them to my Spring Data REST server, and they are successfully saved:

final ResponseEntity<Resource<Address>> response = restTemplate.postForEntity("http://localhost:8080/addresses",
                addressInstance, AddressResource.class);

where AddressResource extends org.springframework.hateoas.Resource<Address>.

But when I try to POST a Person instance

final ResponseEntity<Resource<Person>> response = restTemplate.postForEntity("http://localhost:8080/people",
                personInstance, PersonResource.class);

I get a org.springframework.web.client.HttpClientErrorException: 400 Bad Request and I think the cause is the associated Addresses and Profiles are serialized as normal POJOs instead as their resource URIs.

Here is the actual body of the POST request:

{
   "id":null,
   "name":"Jongjin Han",
   "version":null,
   "addresses":[
      {
         "id":1,
         "lines":[
            "1111",
            "coder's street"
         ],
         "city":"San Diego",
         "province":"California",
         "postalCode":"60707"
      },
      {
         "id":2,
         "lines":[
            "1111",
            "coder's street"
         ],
         "city":"San Diego",
         "province":"California",
         "postalCode":"60707"
      }
   ],
   "profiles":{
      "key1":{
         "type":"a type of profile",
         "url":"http://www.profileurl.com"
      },
      "key2":{
         "type":"a type of profile",
         "url":"http://www.profileurl.com"
      }
   }
}

I think it should be --> EDIT: It should be

{
   "id":null,
   "name":"Jongjin Han",
   "version":null,
   "addresses":[
      "http://localhost:8080/addresses/1",
      "http://localhost:8080/addresses/2"
   ],
   "profiles":{
      "key1":"http://localhost:8080/profiles/1",
      "key2":"http://localhost:8080/profiles/2"
   }
}

in fact the response body from the server is

{
  "cause" : {
    "cause" : {
      "cause" : {
        "cause" : null,
        "message" : "Cannot resolve URI id. Is it local or remote? Only local URIs are resolvable."
      },
      "message" : "Failed to convert from type java.net.URI to type org.springframework.data.rest.example.model.Address for value 'id'; nested exception is java.lang.IllegalArgumentException: Cannot resolve URI id. Is it local or remote? Only local URIs are resolvable."
    },
    "message" : "Failed to convert from type java.net.URI to type org.springframework.data.rest.example.model.Address for value 'id'; nested exception is java.lang.IllegalArgumentException: Cannot resolve URI id. Is it local or remote? Only local URIs are resolvable. (through reference chain: org.springframework.data.rest.example.model.Person[\"addresses\"]->java.util.ArrayList[1])"
  },
  "message" : "Could not read document: Failed to convert from type java.net.URI to type org.springframework.data.rest.example.model.Address for value 'id'; nested exception is java.lang.IllegalArgumentException: Cannot resolve URI id. Is it local or remote? Only local URIs are resolvable. (through reference chain: org.springframework.data.rest.example.model.Person[\"addresses\"]->java.util.ArrayList[1]); nested exception is com.fasterxml.jackson.databind.JsonMappingException: Failed to convert from type java.net.URI to type org.springframework.data.rest.example.model.Address for value 'id'; nested exception is java.lang.IllegalArgumentException: Cannot resolve URI id. Is it local or remote? Only local URIs are resolvable. (through reference chain: org.springframework.data.rest.example.model.Person[\"addresses\"]->java.util.ArrayList[1])"
}

The possible solution I'd like to implement

Since I can access the REST repositories from the client side I am looking for a way to customize the Jackson Json Serializer in order to:

  • check if the object I am serializing is a REST exported entity (easy with reflection, if only I could know where to put the code) and
  • If I am serializing an entity, serialize the non-association fields as usual (e.g. person's name) and the association fields as their Resource URI (e.g. person's addresses) (with reflection it should be easy to convert from an entity to its resource URI, but I do not know where to put the code once again)

I tried with Jackson's JsonSerializer and PropertyFilters for Address and Profile, but I want a serializer which serialize them as resource URI only when they are in an association.

Any hint or aternative solution will be helpful.


Hibernate注解中的manytomany级联与不级联删除问题的解决
逍遥飞鹤的专栏
08-31 9936
两个类用户信息和用户Tag类型  多对多的关系 1.用户信息类 package com.yunmiao.bean.player; import java.util.Date; import java.util.HashSet; import java.util.Set; import javax.persistence.CascadeType; import javax.persisten
SpringData Jpa(2)SpringDataJpa进阶，级联关系、注解属性介绍
清茶与浊酒
07-18 735
一、简介 本章我们学习springData Jpa 进阶操作，,项目我们还是用的上篇的项目开始 传送门 二、实体关系映射 多对多、一对多、多对一、一对一关系的深度实例解析 1.作用简化编程操作。把冗余的操作交给底层框架来处理。 例如，如果我要给一位新入学的学生添加一位新的老师。而这个老师又是新来的，在学生数据库与教师数据库中均不存在对应的数据。那么我需要先在教师数据库中保存新来的老师的数据，同时在学生数据库中保存新学生的数据，然后再给两者建立关联。 而如果我们使用了实体关系映射，我们只需要将该新教师实体
Spring Jpa ManyToMany（多对多）关系中的cascade={CascadeType.X} 的配置与总结
梅花14的博客
01-13 3395
角色表 用户表 中间表 CascadeType.MERGE 新增账户并添加不存在的角色，Jpa执行的语句 可以看到首先对role角色表进行了查询，不存在就添加一个角色。 Hibernate: select role0_.role_id as role_id1_4_0_, role0_.role_name as role_nam2_4_0_ from role role0_ where rol...
0.1、级联保存CascadeType.PERSIST
weixin_33714884的博客
06-16 254
2019独角兽企业重金招聘Python工程师标准>>> ...
3 OneToMany ManyToMany MappedBy Cascade
惟愿无事
02-25 4367
1 双向1-N关联 对于1-N关联，Hibernate推荐使用双向关联，而且不要让1的一方控制关联关系，而使用多的一方控制关联关系。 a. 一的一方  表示班级 @Entity @Table(name="team_1") public class Team { @Id @GeneratedValue(strategy=GenerationType.IDENTITY) @Column
Hibernate many-to-one cascade
小欣儿的专栏
10-26 1802
元素的cascade属性表明操作是否从父对象级联到被关联的对象， 它的取得可以是以下几种： none：在保存，删除或修改当前对象时，不对其附属对象（关联对象）进行级联操作，它是默认值。 save-update：在保存，更新当前对象时，级联保存，更新附属对象（临时对象、游离对象）。 delete：在删除当前对象时，级联删除附属对象。 all：所有情况下均进行级联操作，即包含save
二、表设计与实体映射中@Entity @Data@Id @GeneratedValue@ManyToMany(cascade = CascadeType.PERSIST) @JoinTable这种
05-10
用户可能混淆的地方包括：@Data的使用是否必要，@GeneratedValue的策略选择，@ManyToMany中mappedBy的正确应用，以及@JoinTable的参数设置。例如，在引用[1]中，Tag类的@ManyToMany注解使用了mappedBy=...
hibernate的_CascadeType属性说明
03-13
在 Hibernate 中，CascadeType属性通常用于@OneToMany、@ManyToOne和@ManyToMany注解中，用于定义实体之间的级联操作。例如，在订单系统中，订单和订单项之间的关系可以使用@OneToMany注解，并设置CascadeType为ALL...
package com.kucun.data.entity; import java.util.List; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; /** * 板材材质 * @author Administrator * */ @Entity @Table(name="caizhi") @JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) public class Caizhi { @Id private int id ; private String name; @OneToMany(mappedBy="caizhi") @JsonIgnore private List<Bancai> bancais; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "{id:" + id + ", name:" + name + "}"; } public Caizhi(int id, String name) { super(); this.id = id; this.name = name; } public Caizhi() { super(); } // 添加反向关联维护方法 public void addBancai(Bancai bancai) { bancais.add(bancai); bancai.setCaizhi(this); } // 添加移除方法 public void removeBancai(Bancai bancai) { bancais.remove(bancai); bancai.setCaizhi(null); } } package com.kucun.data.entity; import java.util.List; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.OneToMany; import javax.persistence.Table; import javax.persistence.UniqueConstraint; /** * 产品类 * @author Administrator * */ @Entity @Table(name="chanpin", uniqueConstraints = { @UniqueConstraint(columnNames = "bianhao") }) public class Chanpin { @Id private Integer id; @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private List<Dingdan_chanpin> dingdians; private String bianhao; @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private List<Chanpin_zujian> zujians; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public List<Dingdan_chanpin> getDingdians() { return dingdians; } public void setDingdians(List<Dingdan_chanpin> dingdians) { this.dingdians = dingdians; } public String getBianhao() { return bianhao; } public void setBianhao(String bianhao) { this.bianhao = bianhao; } public List<Chanpin_zujian> getZujians() { return zujians; } public void setZujians(List<Chanpin_zujian> zujians) { this.zujians = zujians; } public Chanpin(Integer id, List<Dingdan_chanpin> dingdians, String bianhao, List<Chanpin_zujian> zujians) { super(); this.id = id; this.dingdians = dingdians; this.bianhao = bianhao; this.zujians = zujians; } public Chanpin() { super(); // TODO Auto-generated constructor stub } } package com.kucun.data.entity; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.ManyToOne; import javax.persistence.OneToMany; import javax.persistence.OneToOne; /** * 产品组件关联类 * @author Administrator * */ @Entity public class Chanpin_zujian { @Id private Integer id; @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Chanpin chanpins; @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Zujian zujian; @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Bancai bancai; private Double one_howmany; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public Chanpin getChanpins() { return chanpins; } public void setChanpins(Chanpin chanpins) { this.chanpins = chanpins; } public Zujian getZujian() { return zujian; } public void setZujian(Zujian zujian) { this.zujian = zujian; } public Bancai getBancai() { return bancai; } public void setBancai(Bancai bancai) { this.bancai = bancai; } public Double getOne_howmany() { return one_howmany; } public void setOne_howmany(Double one_howmany) { this.one_howmany = one_howmany; } public Chanpin_zujian() { super(); // TODO Auto-generated constructor stub } } package com.kucun.data.entity; import java.util.List; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.ManyToMany; import javax.persistence.OneToMany; import javax.persistence.Table; import javax.persistence.UniqueConstraint; /** * 订单 * @author Administrator * */ @Entity @Table(name="dingdan", uniqueConstraints = { @UniqueConstraint(columnNames = "numder") }) public class Dingdan { @Id private Integer id; //订单号 private String number; @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private List<Dingdan_chanpin> dingdan_chanpins; @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private List<Dingdan_chanpin_zujian> dingdan_chanpins_zujians; @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private List<Chanpin> chanpins; public List<Dingdan_chanpin_zujian> getDingdan_chanpins_zujians() { return dingdan_chanpins_zujians; } public void setDingdan_chanpins_zujians(List<Dingdan_chanpin_zujian> dingdan_chanpins_zujians) { this.dingdan_chanpins_zujians = dingdan_chanpins_zujians; } public List<Chanpin> getChanpins() { return chanpins; } public void setChanpins(List<Chanpin> chanpins) { this.chanpins = chanpins; } public List<Dingdan_chanpin> getDingdan_chanpins() { return dingdan_chanpins; } public void setDingdan_chanpins(List<Dingdan_chanpin> dingdan_chanpins) { this.dingdan_chanpins = dingdan_chanpins; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getNumber() { return number; } public void setNumber(String number) { this.number = number; } public Dingdan(Integer id, String number) { super(); this.id = id; this.number = number; } public Dingdan() { super(); // TODO Auto-generated constructor stub } } package com.kucun.data.entity; import javax.persistence.CascadeType; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.ManyToOne; /** * 订单和产品关联 * @author Administrator * */ @Entity public class Dingdan_chanpin { @Id private Integer id; //产品信息 @ManyToOne (cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Dingdan dingdan; //产品数量 @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Chanpin chanpin; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public Dingdan getDingdan() { return dingdan; } public void setDingdan(Dingdan dingdan) { this.dingdan = dingdan; } public Chanpin getChanping() { return chanpin; } public void setChanping(Chanpin chanping) { this.chanpin = chanping; } } package com.kucun.data.entity; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.ManyToOne; /** * 一个订单中的产品组件订购板材数量 * @author Administrator * */ @Entity public class Dingdan_chanpin_zujian { @Id private Integer id; //订单 @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Dingdan dingdan; //板材 @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Bancai bancai; //产品组件 @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) private Chanpin_zujian zujians; //订购数 private Integer shuliang ; public Dingdan_chanpin_zujian() { super(); // TODO Auto-generated constructor stub } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public Dingdan getDingdan() { return dingdan; } public void setDingdan(Dingdan dingdan) { this.dingdan = dingdan; } public Bancai getBancai() { return bancai; } public void setBancai(Bancai bancai) { this.bancai = bancai; } public Chanpin_zujian getZujians() { return zujians; } public void setZujians(Chanpin_zujian zujians) { this.zujians = zujians; } public Integer getShuliang() { return shuliang; } public void setShuliang(Integer shuliang) { this.shuliang = shuliang; } } package com.kucun.data.entity; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; /** * 通信类 * @author Administrator * */ public class Information { private static final ObjectMapper mapper = new ObjectMapper(); private Integer Status ; private String text; private Object data; public Integer getStatus() { return Status; } public void setStatus(Integer status) { Status = status; } public String getText() { return text; } public void setText(String text) { this.text = text; } public Object getData() { return data; } public void setData(Object data) { this.data = data; } public Information(Integer status, String text, Object data) { super(); Status = status; this.text = text; this.data = data; } @SuppressWarnings({"unchecked","rawtypes"}) public Information(Integer status, String text, String data, Class T) throws Exception { super(); Status = status; this.text = text; this.data = fromJson(data,T); } public Information() { super(); // TODO Auto-generated constructor stub } public String DataJson() throws JsonProcessingException { // Java对象转JSON return mapper.writeValueAsString(this); } @SuppressWarnings("unchecked") public <T> T fromJson(String json, Class<T> clazz) throws Exception { data= mapper.readValue(json, clazz); return (T) data; } public static Information NewSuccess(Object data) { return new Information(200, "success", data); } public static Information NewSuccess(String data) { return new Information(200, "success", data); } public static Information Newfail(Integer status,String text,Object data) { return new Information(status, "success", data); } } package com.kucun.data.entity; import java.util.Date; import javax.persistence.Entity; import javax.persistence.Id; @Entity public class Jinhuo { @Id private Integer id; private Dingdan dingdan; private Chanpin chanpin; private Zujian zujian; private Bancai bancai; private Integer shuliang; private Date date; private User user; public Jinhuo(Integer id, Dingdan dingdan, Chanpin chanpin, Zujian zujian, Bancai bancai, Integer shuliang, Date date, User user) { super(); this.id = id; this.dingdan = dingdan; this.chanpin = chanpin; this.zujian = zujian; this.bancai = bancai; this.shuliang = shuliang; this.date = date; this.user = user; } public Jinhuo() { super(); // TODO Auto-generated constructor stub } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public Dingdan getDingdan() { return dingdan; } public void setDingdan(Dingdan dingdan) { this.dingdan = dingdan; } public Chanpin getChanpin() { return chanpin; } public void setChanpin(Chanpin chanpin) { this.chanpin = chanpin; } public Zujian getZujian() { return zujian; } public void setZujian(Zujian zujian) { this.zujian = zujian; } public Bancai getBancai() { return bancai; } public void setBancai(Bancai bancai) { this.bancai = bancai; } public Integer getShuliang() { return shuliang; } public void setShuliang(Integer shuliang) { this.shuliang = shuliang; } public Date getDate() { return date; } public void setDate(Date date) { this.date = date; } public User getUser() { return user; } public void setUser(User user) { this.user = user; } } package com.kucun.data.entity; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.OneToOne; /** * 库存 * @author Administrator * */ @Entity public class Kucun { @Id private Integer id; private Long shuliang; @OneToOne(fetch = FetchType.LAZY) // 正确映射 Bancai 实体 @JoinColumn(name = "bancai_id", referencedColumnName = "id") private Bancai bancai; public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public Bancai getBancai() { return bancai; } public void setBancai(Bancai bancai) { this.bancai = bancai; } public Long getShuliang() { return shuliang; } public void setShuliang(Long shuliang) { this.shuliang = shuliang; } public Kucun(Integer id, Bancai bancai, Long shuliang) { super(); this.id = id; this.bancai = bancai; this.shuliang = shuliang; } public Kucun() { super(); // TODO Auto-generated constructor stub } } package com.kucun.data.entity; import java.util.List; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.ManyToMany; import javax.persistence.OneToMany; import javax.persistence.Table; import javax.persistence.UniqueConstraint; import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; /** * 木皮 * @author Administrator * */ @Entity @Table(name="caizhi", uniqueConstraints = { @UniqueConstraint(columnNames = "name") }) @JsonIgnoreProperties({"hibernateLazyInitializer", "handler"}) public class Mupi { @Id private int id; private String name; /** * 是否有油漆 */ private Boolean you; // 添加 OneToMany 映射 @OneToMany(mappedBy = "mupi1") // 指向 Bancai 中的 mupi1 字段 @JsonIgnore private List<Bancai> bancaisForMupi1; @OneToMany(mappedBy = "mupi2") // 指向 Bancai 中的 mupi2 字段 @JsonIgnore private List<Bancai> bancaisForMupi2; public Mupi(int id, String name, List<Bancai> bancaisForMupi1, List<Bancai> bancaisForMupi2) { super(); this.id = id; this.name = name; this.bancaisForMupi1 = bancaisForMupi1; this.bancaisForMupi2 = bancaisForMupi2; } public List<Bancai> getBancaisForMupi1() { return bancaisForMupi1; } public void setBancaisForMupi1(List<Bancai> bancaisForMupi1) { this.bancaisForMupi1 = bancaisForMupi1; } public List<Bancai> getBancaisForMupi2() { return bancaisForMupi2; } public void setBancaisForMupi2(List<Bancai> bancaisForMupi2) { this.bancaisForMupi2 = bancaisForMupi2; } @Override public String toString() { return "{id:" + id + ", name:" + name + "}"; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Mupi(int id, String name) { super(); this.id = id; this.name = name; } public Mupi() { super(); } public Boolean getYou() { return you; } public void setYou(Boolean you) { this.you = you; } } package com.kucun.data.entity; import java.util.Objects; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; import com.fasterxml.jackson.databind.ObjectMapper; /** * 用户 * @author Administrator * */ @Entity @Table(name="user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; /** * 名字 */ @Column(nullable=false) private String name; /** * 账号 */ @Column(nullable=false) private String andy; /** * 密码 */ @Column(nullable=false) private String pass; /** * 权限 */ @Column(nullable=false) private int role; public User() { super(); } public User(int id, String name, String andy, String pass) { super(); this.id = id; this.name = name; this.andy = andy; this.pass = pass; } public Integer getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getAndy() { return andy; } public void setAndy(String andy) { this.andy = andy; } public String getPass() { return pass; } public void setPass(String pass) { this.pass = pass; } public int getRole() { System.out.println(role); return role; } public void setRole(int role) { this.role = role; } @Override public String toString() { return "{id:" + id + ", name:" + name + ", andy:" + andy + ", pass:" + pass + ", role:" + role + "}"; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; User user = (User) o; return Objects.equals(id, user.id) && Objects.equals(name, user.name) && Objects.equals(andy, user.andy)&& Objects.equals(role, user.role); //添加所有属性比较 } @Override public int hashCode() { return Objects.hash(id, name, andy,pass,role); } } package com.kucun.data.entity; import java.util.List; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.ManyToOne; import javax.persistence.OneToMany; @Entity public class Zujian { @Id private Integer id; private String name; @OneToMany private List<Chanpin_zujian> chanpins; public Zujian(Integer id, String name, List<Chanpin_zujian> chanpins) { super(); this.id = id; this.name = name; this.chanpins = chanpins; } public List<Chanpin_zujian> getChanpins() { return chanpins; } public void setChanpins(List<Chanpin_zujian> chanpins) { this.chanpins = chanpins; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } package com.kucun.data.entity; import javax.persistence.CascadeType; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.OneToOne; import javax.persistence.Table; import com.fasterxml.jackson.annotation.JsonBackReference; import com.fasterxml.jackson.annotation.JsonManagedReference; /** * 板材 * @author Administrator * */ @Entity @Table(name="bancai") public class Bancai { @Id private int id; @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) @JoinColumn(name = "caizhi_id") // @JsonManagedReference // 标记为“主”关联方 private Caizhi caizhi; @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) @JoinColumn(name = "mupi1_id") private Mupi mupi1; @ManyToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) @JoinColumn(name = "mupi2_id") private Mupi mupi2; private Double houdu; @OneToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) @JoinColumn(name = "kucun_id", referencedColumnName = "id") private Kucun kucun; public Kucun getKucun() { return kucun; } public void setKucun(Kucun kucun) { this.kucun = kucun; } public int getId() { return id; } public void setId(int id) { this.id = id; } public Caizhi getCaizhi() { return caizhi; } public void setCaizhi(Caizhi caizhi) { this.caizhi = caizhi; } public Mupi getMupi1() { return mupi1; } public void setMupi1(Mupi mupi1) { this.mupi1 = mupi1; } public Mupi getMupi2() { return mupi2; } public void setMupi2(Mupi mupi2) { this.mupi2 = mupi2; } public Double getHoudu() { return houdu; } public void setHoudu(Double houdu) { this.houdu = houdu; } public Bancai(int id, Caizhi caizhi, Mupi mupi1, Mupi mupi2, Double houdu) { super(); this.id = id; this.caizhi = caizhi; this.mupi1 = mupi1; this.mupi2 = mupi2; this.houdu = houdu; } public Bancai() { super(); } } 关联注解如何写
最新发布
06-08
3.**级联操作优化**：根据业务需求，设置了合适的级联操作（如`CascadeType.ALL`或部分级联）和`orphanRemoval`。4.**中间实体使用**：订单与产品的关联通过中间实体`Dingdan_chanpin`实现，而不是直接的多对多。5.*...
【简单易懂】JPA概念解析：CascadeType（各种级联操作）详解
weixin_33744854的博客
09-30 1731
https://www.jianshu.com/p/e8caafce5445 【在一切开始之前，我要先告诉大家：慎用级联关系，不要随便给all权限操作。应该根据业务需求选择所需的级联关系。否则可能酿成大祸。切记】 CascadeType.PERSIST 官方文档的说明：Cascade persist operation 看到网上很多博客对这一枚举值的解释是：级联持久化（保存）操作（持久保存拥...
jpa级联操作详解1-级联保存(CascadeType.PERSIST)
sefcertyu
09-23 482
不论是对于jpa或者是hibernate来说字段的数据库映射都不是难点，而是很多初学者都对jpa级联操作等一系列的东西不大明白，在这一系列的文章中我通过简单的java实体对象来与大家共同理解jpa（hibernate做实现产品）的级联操作等难点知识，希望能够共同提高。为了保证简单易懂，本系列文章避免光讲理论知识，而忽视实际动手，在下面的例子中都有简单易懂的例子，为了加深理解大家也可以在自己的机...
hibernate 配置@ManyToOne 等关联关系注解中 cascade属性设置不起作用问题
09-24 705
@ManyToOne(fetch = FetchType.EAGER,cascade = CascadeType.ALL) 关联关系注解属性cascade，在使用hibernate时，只有CascadeType.ALL，其它类型不起作用，如果只想级联保存，不级联删除，就无法实现。 解决办...
CascadeType.PERSIST不起作用的原因
zj972535075的专栏
12-10 1653
@OneToMany(cascade = {CascadeType.PERSIST}），发现级联不起作用，如果更改为Hibernate的注解 @Cascade({org.hibernate.annotations.CascadeType.PERSIST})，依然不起作用，但改为 @Cascade({org.hibernate.annotations.CascadeType.SAVE_UPDATE}
注解cascade = CascadeType.PERSIST 与cascade = CascadeType.all
bai30818的专栏
06-11 418
cascade = CascadeType.all 保存时候会提示sessionid地址唯一。nzjg的奶办和条款都用了cascade = CascadeType.PERSIST 转载于:https://www.cnblogs.com/zshboke-2015/p/4568862.html...
CascadeType.PERSIST无法级联保存
月光散
03-25 3400
CascadeType.PERSIST无法级联保存
jpa manytoone cascade MERGE和PERSIST
宋大王的博客
04-05 463
jpa manytoone cascade MERGE和PERSIST mergepersist merge 当不传入id和外键id时 {“title”:"",“article”:"## markdown text"} 数据库插入一条没有外键的数据 sql Hibernate: select next_val as id_val from hibernate_sequence for ...
cascade在java_java – 带有cascade的@ManyToMany = CascadeType.REM...
weixin_32536777的博客
02-13 198
我有2个实体：Group和Grouped,有1个ManyToMany关联.在数据库中,Association表在Group和Grouped上都有一个NOT NULL FK.我希望Hibernate在删除所有分组时删除关联,但不删除组.删除Grouped实体的代码：@Autowiredprivate final GroupedRepository groupedRepository;public v...
@ManyToMany
weixin_43849519的博客
12-23 1608
@ManyToMany( cascade = { CascadeType.PERSIST, CascadeType.MERGE }) @JoinTable(name = "TEACHER_TO_STUDENT", joinColumns = { @JoinColumn(name = "TEACHER_ID") }, inverseJoinColumns = { @JoinColumn(name...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值