idea中注解配置一对多,多对一,双向多对一映射(不详细)

一对多

package cn.pojo;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Set;

@Entity //声明这是一个实体类 必写
public class District implements Serializable {
    private static final long serialVersionUID = 8009273978191878070L;
    //编号
    @Id //标识属性 相当于数据库中的主键
    @GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "seq_dis")   //strategy设置标识的生成策略
    @SequenceGenerator(name = "seq_dis",sequenceName = "seq_dis_id", //声明序列 自动增长唯1 从1开始自增
            allocationSize = 1,initialValue = 1)
    private Integer id;
    //区县名称
    @Column(name = "name")  //将属性映射到数据库中 填写列名不区分大小写
    private String name;
    //街道
    @OneToMany(cascade = {CascadeType.ALL}) //一对多,不需要指定类型,cascade是为了指定级联操作。
    @JoinColumn(name = "district_Id")  //另一个表的外键 填写列名 有了@joincolumn注解 就不能有mappedBy属性否则会出兼容问题这个跟hibernate版本有关.我的是5
    private Set<Street> streetSet;

    public Set<Street> getStreetSet() {
        return streetSet;
    }

    public void setStreetSet(Set<Street> streetSet) {
        this.streetSet = streetSet;
    }

    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;
    }

    public District(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    public District(){}
}

多对一  

package cn.pojo;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Set;

@Entity //声明这是一个实体类 必写
public class Street implements Serializable {
    private static final long serialVersionUID = 2465299058773906791L;
    //编号
    @Id //标识属性
    @GeneratedValue(strategy = GenerationType.IDENTITY) //设置生成策略
    private Integer id;
    //街道名称
    @Column(name = "name")   //将属性映射到数据库中 填写列名 不区分大小写
    private String name;
    //所属区县
    @ManyToOne  //多对一
    @JoinColumn(name = "district_Id")   //指向另一个表的外键 填写列名
    private District district;

    @OneToMany
    @JoinColumn(name = "street_id")
    private Set<House> houses;

    public District getDistrict() {
        return district;
    }

    public void setDistrict(District district) {
        this.district = district;
    }

    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;
    }

    public Street(){}
}

多对多

  

package entity;

import javax.persistence.*;
import java.util.Objects;
import java.util.Set;

@Entity
public class EmployeeEntity {
    private long empid;
    //员工名
    private String empname;
    //开发过的项目
    private Set<ProjectEntity> projects;

    @ManyToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
    @JoinTable(name = "proemp"  //中间表的名字
            ,joinColumns ={@JoinColumn(name = "rempid")}    //与当前id有关的外键
            ,inverseJoinColumns = {@JoinColumn(name = "rproid")})   //另一个表有关的外键,也就是跟Project
    public Set<ProjectEntity> getProjects() {
        return projects;
    }

    public void setProjects(Set<ProjectEntity> projects) {
        this.projects = projects;
    }

    @Id
    public long getEmpid() {
        return empid;
    }

    public void setEmpid(long empid) {
        this.empid = empid;
    }

    @Column(name = "EMPNAME")
    public String getEmpname() {
        return empname;
    }

    public void setEmpname(String empname) {
        this.empname = empname;
    }
}
package entity;

import javax.persistence.*;
import java.util.Objects;
import java.util.Set;

@Entity
public class ProjectEntity {
    private long proid;
    //项目名称
    private String proname;
    //工作人员
    private Set<EmployeeEntity> employees;

    @ManyToMany
    @JoinTable(name = "proemp"  //如上
            ,joinColumns ={@JoinColumn(name = "rproid")} //如上
            ,inverseJoinColumns = {@JoinColumn(name = "rempid")}) //如上
    public Set<EmployeeEntity> getEmployees() {
        return employees;
    }

    public void setEmployees(Set<EmployeeEntity> employees) {
        this.employees = employees;
    }

    @Id
    @Column(name = "PROID")
    public long getProid() {
        return proid;
    }

    public void setProid(long proid) {
        this.proid = proid;
    }

    @Column(name = "PRONAME")
    public String getProname() {
        return proname;
    }

    public void setProname(String proname) {
        this.proname = proname;
    }
}

多对多测试的时候出现了一个问题如下

An AnnotationConfiguration instance is required to use <mapping class="entity.ProjectEntity"/>

 意思是,用了注解了,自然要用注解类生成SessionFactory,刚出现的时候很懵逼,因为说hibernate4以上的版本是不会出现这种问题的,于是找了半天.

最后发现就是这个问题如下

configuration=new AnnotationConfiguration();
//configuration = new Configuration().configure(); 注释这一段加上 上面一段 下面再多点下configure();
//获取session对象
sessionFactory =configuration.configure().buildSessionFactory();

因为自动生成的注解是在get上面的所以就没改了.

使用idea自动生成实体类注解和实体类

没有hibernate配置点击加号自动生成一个

第二步

第三步

确保这个连接成功之后第四步

之后会进入如下界面

最后确定即可

原文地址:https://www.cnblogs.com/hfx123/p/10021835.html

时间: 2024-07-31 19:17:21

idea中注解配置一对多,多对一,双向多对一映射(不详细)的相关文章

Hibernate中用注解配置一对多双向关联和多对一单向关联

Hibernate中用注解配置一对多双向关联和多对一单向关联 Hibernate提供了Hibernate Annotations扩展包,使用注解完成映射.在Hibernate3.3之前,需单独下载注解开发包 配置持久化类 配置关联关系 下面我们先从多对一单向关联关系讲起,多对一单向关联就是在多的一方植入一的一方的主键作为外键,下面我们先进行初始配置, 在配置的过程中我们会遇到一个问题  就是无论用load还是get都不会出现延迟加载,那么我们应该如何设置为要延迟加载,这样做的好处是可以在用的时候

Hibernate关联关系配置(一对多、一对一和多对多)

第一种关联关系:一对多(多对一) "一对多"是最普遍的映射关系,简单来讲就如消费者与订单的关系. 一对多:从消费者角的度来说一个消费者可以有多个订单,即为一对多. 多对一:从订单的角度来说多个订单可以对应一个消费者,即为多对一. 一对多关系在hbm文件中的配置信息: 消费者(一方): <?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-mapping PUBLIC

关于spring中注解配置的问题

今天写spring的时候,想用注解配置,但不巧的是用Junit工具测试的时候出错了,检查了很久的代码,发现并不是代码的问题,那就有些奇怪了. 后来去百度,回答的奇奇怪怪,和我的问题沾边的不多,最后还是FQ找到的答案,废话不多说,先贴出错误提示: org.springframework.beans.factory.BeanDefinitionStoreException: Unexpected exception parsing XML document from class path resou

hibernate(jpa)中注解配置字段为主键

http://www.blogjava.net/ITdavid/archive/2009/02/25/256605.html 注解方式的主键配置 非自增字段为主键,注解annotation表示 以N_LOG_ID字段为例: @Id @Column(name = "N_LOG_ID", unique = true, nullable = false) 自增字段为主键,注解annotation表示 以N_LOG_ID字段为例: Oracle数据库 @Id @SequenceGenerato

Hibernate一对多单向(双向)关联映射

(1).编写配置文件 Hibernate通过读写默认的XML配置文件hibernate.cfg.xml加载数据库配置信息.代码如下: <hibernate-configuration> <session-factory> <!-- 数据库驱动 --> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <!-- 数据库连接的U

Hibernate注解配置

1.注解方式: 注解的方式与xml很很多类似: 首先是需要在pom文件中加入4个jar包: 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 2 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apach

8、双向一对多的关联关系(等同于双向多对一。1的一方有对n的一方的集合的引用,同时n的一方有对1的一方的引用)

双向一对多关联关系 ”双向一对多关联关系“等同于”双向多对一关联关系“:1的一方有对n的一方的集合的引用,同时n的一方有对1的一方的引用. 还是用客户Customer和订单Order来解释: ”一对多“的物理意义:一个客户可以有多个订单,某个订单只能归宿于一个客户. ”双向“的物理意义:客户知道自己有哪些订单,订单也知道自己归宿于哪个客户.也就是说,通过客户对象可以检索到其拥有哪些订单:同时,通过订单也可以查找到其对应的客户信息.这是符合我们业务逻辑需求. 到现在为止(结合前面两节的阐述)我们可

play framework框架中多对多的实体类的注解配置

假如是用户表与权限表的多对多,其中用户表中的注解配置: // 权限    @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)    @JoinTable(name = "user_permission", joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "per

hibernate中多对多的注解配置

hibernate多对多的注解配置中的自动生成中间表的配置: @Entity@Table(name="test_student")public class Students { @Id @SequenceGenerator(name="seqStudents",sequenceName="seq_test_student") @GeneratedValue(generator="seqStudents") private In