程序博客网 > 网络bng什么意思

Hibernate中使用多对多映射注解

来源：互联网 发布：网络bng什么意思 编辑：程序博客网 时间：2024/05/25 21:37

hibernateannotation注解方式来处理映射关系

在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，我在试了这两种方式以后，发现使用annotation的方式可以更简介，所以这里就简单记录下通过annotation来配置各种映射关系，在hibernate4以后已经将annotation的jar包集成进来了，如果使用hibernate3的版本就需要引入annotation的jar包。

一、单对象操作

@Entity　　--->如果我们当前这个bean要设置成实体对象，就需要加上Entity这个注解
@Table(name="t_user")　　---->设置数据库的表名
public class User
{
    private int id;
    private String username;
    private String password;
    private Date born;
    private Date registerDate;

@Column(name="register_date")　　--->Column中的name属性对应了数据库的该字段名字，里面还有其他属性，例如length，nullable等等
    public DategetRegisterDate()
    {
        return registerDate;
    }
    public void setRegisterDate(DateregisterDate)
    {
        this.registerDate =registerDate;
    }

@Id　　--->定义为数据库的主键ID　　(建议不要在属性上引入注解，因为属性是private的，如果引入注解会破坏其封装特性，所以建议在getter方法上加入注解)
    @GeneratedValue　　---->ID的生成策略为自动生成
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
 ............
}

最后只需要在hibernate.cfg.xml文件里面将该实体类加进去即可：

<!-- 基于annotation的配置 -->
        <mappingclass="com.xiaoluo.bean.User"/>
<!-- 基于hbm.xml配置文件 -->
        <mappingresource="com/xiaoluo/bean/User.hbm.xml"/>

这样我们就可以写测试类来进行我们的CRUD操作了。

二、一对多的映射(one-to-many)

这里我们定义了两个实体类，一个是ClassRoom，一个是Student，这两者是一对多的关联关系。

ClassRoom类：

@Entity
@Table(name="t_classroom")
public class ClassRoom
{
    private int id;
    private String className;
    private Set<Student>students;
   
    public ClassRoom()
    {
        students = newHashSet<Student>();
    }
   
    public void addStudent(Studentstudent)
    {
        students.add(student);
    }

@Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }

publicvoid setId(int id)
    {
        this.id = id;
    }

publicString getClassName()
    {
        return className;
    }

publicvoid setClassName(String className)
    {
        this.className =className;
    }

@OneToMany(mappedBy="room")　　--->OneToMany指定了一对多的关系，mappedBy="room"指定了由多的那一方来维护关联关系，mappedBy指的是多的一方对1的这一方的依赖的属性，(注意：如果没有指定由谁来维护关联关系，则系统会给我们创建一张中间表)
    @LazyCollection(LazyCollectionOption.EXTRA)　　--->LazyCollection属性设置成EXTRA指定了当如果查询数据的个数时候，只会发出一条 count(*)的语句，提高性能
    public Set<Student>getStudents()
    {
        return students;
    }

publicvoid setStudents(Set<Student> students)
    {
        this.students =students;
    }
   
}

Student类：

@Entity
@Table(name="t_student")
public class Student
{
    private int id;
    private String name;
    private int age;
    private ClassRoom room;
   
    @ManyToOne(fetch=FetchType.LAZY)　　--->ManyToOne指定了多对一的关系，fetch=FetchType.LAZY属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
    @JoinColumn(name="rid")　　--->通过JoinColumn 的name属性指定了外键的名称 rid　(注意：如果我们不通过JoinColum来指定外键的名称，系统会给我们声明一个名称)
    public ClassRoom getRoom()
    {
        return room;
    }
    public void setRoom(ClassRoomroom)
    {
        this.room = room;
    }
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getName()
    {
        return name;
    }
    public void setName(Stringname)
    {
        this.name = name;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(intage)
    {
        this.age = age;
    }
   
}

三、一对一映射(One-to-One)

一对一关系这里定义了一个Person对象以及一个IDCard对象

Person类：

@Entity
@Table(name="t_person")
public class Person
{
    private int id;
    private String name;
    private IDCard card;
   
    @OneToOne(mappedBy="person")　　--->指定了OneToOne的关联关系，mappedBy同样指定由对方来进行维护关联关系
    public IDCard getCard()
    {
        return card;
    }
    public void setCard(IDCardcard)
    {
        this.card = card;
    }
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getName()
    {
        return name;
    }
    public void setName(Stringname)
    {
        this.name = name;
    }
   
}

IDCard类：

@Entity
@Table(name="t_id_card")
public class IDCard
{
    private int id;
    private String no;
    private Person person;
   
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getNo()
    {
        return no;
    }
    public void setNo(String no)
    {
        this.no = no;
    }
    @OneToOne　　--->OnetoOne指定了一对一的关联关系，一对一中随便指定一方来维护映射关系，这里选择IDCard来进行维护
    @JoinColumn(name="pid")　　--->指定外键的名字pid
    public Person getPerson()
    {
        return person;
    }
    public void setPerson(Personperson)
    {
        this.person = person;
    }
}

注意:在判断到底是谁维护关联关系时，可以通过查看外键，哪个实体类定义了外键，哪个类就负责维护关联关系。

四、Many-to-Many映射(多对多映射关系)

多对多这里通常有两种处理方式，一种是通过建立一张中间表，然后由任一一个多的一方来维护关联关系，另一种就是将多对多拆分成两个一对多的关联关系

1.通过中间表由任一一个多的一方来维护关联关系

Teacher类：

@Entity
@Table(name="t_teacher")
public class Teacher
{
    private int id;
    private String name;
    private Set<Course>courses;
   
    public Teacher()
    {
        courses = newHashSet<Course>();
    }
    public void addCourse(Coursecourse)
    {
        courses.add(course);
    }
   
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getName()
    {
        return name;
    }
    public void setName(Stringname)
    {
        this.name = name;
    }
    @ManyToMany(mappedBy="teachers")　　--->表示由Course那一方来进行维护
    public Set<Course>getCourses()
    {
        return courses;
    }
    public voidsetCourses(Set<Course> courses)
    {
        this.courses = courses;
    }
   
}

Course类：

@Entity
@Table(name="t_course")
public class Course
{
    private int id;
    private String name;
    private Set<Teacher>teachers;
   
    public Course()
    {
        teachers = newHashSet<Teacher>();
    }
    public void addTeacher(Teacherteacher)
    {
        teachers.add(teacher);
    }
    @ManyToMany　　　--->ManyToMany指定多对多的关联关系
    @JoinTable(name="t_teacher_course",joinColumns={ @JoinColumn(name="cid")},
    inverseJoinColumns={ @JoinColumn(name= "tid") })　　--->因为多对多之间会通过一张中间表来维护两表直接的关系，所以通过 JoinTable这个注解来声明，name就是指定了中间表的名字，JoinColumns是一个 @JoinColumn类型的数组，表示的是我这方在对方中的外键名称，我方是Course，所以在对方外键的名称就是 rid，inverseJoinColumns也是一个@JoinColumn类型的数组，表示的是对方在我这放中的外键名称，对方是Teacher，所以在我方外键的名称就是 tid
    publicSet<Teacher> getTeachers()
    {
        return teachers;
    }

publicvoid setTeachers(Set<Teacher> teachers)
    {
        this.teachers =teachers;
    }

@Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }

publicvoid setId(int id)
    {
        this.id = id;
    }

publicString getName()
    {
        return name;
    }

publicvoid setName(String name)
    {
        this.name = name;
    }

}

2.将Many-to-Many拆分成两个One-to-Many的映射(Admin、Role、AdminRole)

Admin类：

@Entity
@Table(name="t_admin")
public class Admin
{
    private int id;
    private String name;
    private Set<AdminRole>ars;
    public Admin()
    {
        ars = newHashSet<AdminRole>();
    }
    public void add(AdminRolear)
    {
        ars.add(ar);
    }
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getName()
    {
        return name;
    }
    public void setName(Stringname)
    {
        this.name = name;
    }
   @OneToMany(mappedBy="admin")　　--->OneToMany关联到了AdminRole这个类，由AdminRole这个类来维护多对一的关系，mappedBy="admin"
   @LazyCollection(LazyCollectionOption.EXTRA)
    public Set<AdminRole>getArs()
    {
        return ars;
    }
    public voidsetArs(Set<AdminRole> ars)
    {
        this.ars = ars;
    }
}

Role类：

@Entity
@Table(name="t_role")
public class Role
{
    private int id;
    private String name;
    private Set<AdminRole>ars;
    public Role()
    {
        ars = newHashSet<AdminRole>();
    }
    public void add(AdminRolear)
    {
        ars.add(ar);
    }
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getName()
    {
        return name;
    }
    public void setName(Stringname)
    {
        this.name = name;
    }
    @OneToMany(mappedBy="role")　　--->OneToMany指定了由AdminRole这个类来维护多对一的关联关系，mappedBy="role"
   @LazyCollection(LazyCollectionOption.EXTRA)
    public Set<AdminRole>getArs()
    {
        return ars;
    }
    public voidsetArs(Set<AdminRole> ars)
    {
        this.ars = ars;
    }
}

AdminRole类：

@Entity
@Table(name="t_admin_role")
public class AdminRole
{
    private int id;
    private String name;
    private Admin admin;
    private Role role;
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getName()
    {
        return name;
    }
    public void setName(Stringname)
    {
        this.name = name;
    }
    @ManyToOne　　--->ManyToOne关联到Admin
   @JoinColumn(name="aid")
    public Admin getAdmin()
    {
        return admin;
    }
    public void setAdmin(Adminadmin)
    {
        this.admin = admin;
    }
    @ManyToOne　　--->
   @JoinColumn(name="rid")
    public Role getRole()
    {
        return role;
    }
    public void setRole(Rolerole)
    {
        this.role = role;
    }
}

小技巧:通过hibernate来进行插入操作的时候，不管是一对多、一对一还是多对多，都只需要记住一点，在哪个实体类声明了外键，就由哪个类来维护关系，在保存数据时，总是先保存的是没有维护关联关系的那一方的数据，后保存维护了关联关系的那一方的数据，如：

Personp = new Person();
           p.setName("xiaoluo");
            session.save(p);
           
            IDCard card = newIDCard();
           card.setNo("1111111111");
            card.setPerson(p);
            session.save(card);

以上就是对hibernateannotation注解方式来配置映射关系的一些总结。


PS:注解要么全部写在字段上，

要么全部写在getter方法上


如果在API中需要JSON化对象，则应该

在get/set方法中加入@JsonIgnore 以防止

无限递归造成的程序报错

如：

@Entity
@Table(name="t_teacher")
public class Teacher
{
    private int id;
    private String name;
    private Set<Course>courses;
   
    public Teacher()
    {
        courses = newHashSet<Course>();
    }
    public void addCourse(Coursecourse)
    {
        courses.add(course);
    }
   
    @Id
    @GeneratedValue
    public int getId()
    {
        return id;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public String getName()
    {
        return name;
    }
    public void setName(Stringname)
    {
        this.name = name;
    }

@JsonIgnore

    @ManyToMany(mappedBy="teachers")　　--->表示由Course那一方来进行维护
    public Set<Course>getCourses()
    {
        return courses;
    }

@JsonIgnore

    public void setCourses(Set<Course>courses)
    {
        this.courses =courses;
    }
   
}



来自 <http://www.cnblogs.com/xiaoluo501395377/p/3374955.html>

0 0
网络bng什么意思 网络bng什么意思
原创粉丝点击
热门IT博客
房产销售软件有那些房产销售软件有那些
数据精灵授权码数据精灵授权码
老款奔驰e260轮毂数据
2016十大网络神曲视频
软件授权协议书模板
淘宝修手机靠谱吗
企鹅网络直播
手机数据清除怎么恢复
汽车 蒸发器 设计软件
网站seo怎么优化
mac双色修容粉多少钱
精华 知乎
长虹55寸网络电视价格
如何编写iphone软件
淘宝网访客和购买比例
做淘宝推广工资怎么样
b站mac版
淘宝商城晾衣架
发视频就网络连接失败
剑灵初音未来捏脸数据
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 公交吧 新乡公交 南京公交 抚顺公交 公交上 公交线路图 公交公交 公交e出行 肇庆公交 重庆公交 608公交路线 西安公交 北京市公交 青岛公交 南宁公交 公交站牌 公交202路公交车路线 公交来了 605公交路线 137公交路线 公交信息 广州公交 公交8684 实时公交 海口公交 潍坊公交 公交报站 铜陵公交 公交上被 城市公交 上公交 399公交 网上公交 206公交 114公交 973公交 605公交 365公交路线 城镇公交 挤公交 399公交路线

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里