Hibernate 注解映射

最新推荐文章于 2024-03-28 20:14:41 发布
最新推荐文章于 2024-03-28 20:14:41 发布
阅读量758 收藏
点赞数
分类专栏： JavaWeb 文章标签： hibernate 注解映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starjuly/article/details/52348978
版权
首先要创建要映射的实体类

一对多映射，一个人可以有多个收货地址

User.java

package star.july.b_annotation;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
/**
 * 使用注解映射
 */
/**
 * @author Starjuly
 *
 */
//实体类
@Entity
//表名称
@Table(name="t_user")
public class User {
    @Id
    //自增长
    @GeneratedValue
    @Column
    private int id;
    
    @Column(name="uName")
    private String name;
    
    //一对多连接
    //级联操作：CascadeType.ALL
    //主键维护策略：mappedBy:把关联维护权交给Address的user
    @OneToMany(cascade={CascadeType.ALL},mappedBy="user")
    //加入外键
    //使用mappedBy后就不能使用JoinColumn和JoinTable了
//  @JoinColumn(name="uid")
    private Set<Address> address = new HashSet<Address>();
    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 Set<Address> getAddress() {
        return address;
    }
    public void setAddress(Set<Address> address) {
        this.address = address;
    }
    
    
}



Address.java
package star.july.b_annotation;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@Entity
@Table(name="t_address")
public class Address {
    @Id
    @GeneratedValue
    @Column
    private int id;
    
    @Column(name="adsName")
    private String name;
    
    @Column
    private String address;
    
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    //多对一连接
    @ManyToOne
    @JoinColumn(name="uid")
    private User user = new User();
    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 User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    
    
}

再要hibernate.cfg.xml中配置映射类

<!-- 映射类 -->
           < mapping class = "star.july.b_annotation.User" />           
           < mapping class = "star.july.b_annotation.Course" />

测试类，包括一对多，多对多，一对一

package star.july.b_annotation;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import star.july.util.HibernateUtil;
//测试注解配置
public class TestDemo {
    //一对多连接
    @Test
    public void test(){
        Session session = HibernateUtil.getSession();
        Transaction ts = session.getTransaction();
        try{
            ts.begin();
            
            User u = new User();
            u.setName("徐凤年");
            
            Address ads = new Address();
            ads.setName("姜妮");
            ads.setAddress("北凉龙虎山");
            
            Address ads2 = new Address();
            ads2.setName("婓南苇");
            ads2.setAddress("北凉胭脂郡");
            
            u.getAddress().add(ads);
            u.getAddress().add(ads2);
            ads.setUser(u);
            ads2.setUser(u);
            
            session.save(u);
            
            ts.commit();
        }catch(Exception e ){
            e.printStackTrace();
            ts.rollback();
        }
    }
    
    
    
    //一对多连接
    @Test
    public void test2(){
        Session session = HibernateUtil.getSession();
        Transaction ts = session.getTransaction();
        try{
            ts.begin();
            
            Student s1 = new Student();
            s1.setName("小火");
            Student s2 = new Student();
            s2.setName("小火");
        
            Course c1 = new Course();
            c1.setName("java开发");
            Course c2 = new Course();
            c2.setName("java开发");
            
            s1.getCourse().add(c1);
            s1.getCourse().add(c2);
            s2.getCourse().add(c1);
            
            c1.getStudent().add(s1);
            c1.getStudent().add(s2);
            c2.getStudent().add(s1);
            
            session.save(s1);
            session.save(s2);
            session.save(c1);
            session.save(c2);
            
            ts.commit();
        }catch(Exception e ){
            e.printStackTrace();
            ts.rollback();
        }
    }
    
    
    
    
    
    
    //一对一连接
        @Test
        public void test3(){
            Session session = HibernateUtil.getSession();
            Transaction ts = session.getTransaction();
            try{
                ts.begin();
                
                Person p1 = new Person();
                p1.setName("左莫");
                Person p2 = new Person();
                p2.setName("杨紫");
                
                
                IdCard c1 = new IdCard();
                c1.setName("232443453");
                IdCard c2 = new IdCard();
                c2.setName("5687651543");
                
                p1.setCard(c1);
                p2.setCard(c2);
                c1.setPerson(p1);
                c2.setPerson(p2);
                
                session.save(p1);
                session.save(p2);
                session.save(c1);
                session.save(c2);
                
                ts.commit();
            }catch(Exception e ){
                e.printStackTrace();
                ts.rollback();
            }
        }
}


接下来是多对多的注解映射

Course
package star.july.b_annotation;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
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.Table;
@Entity
@Table(name="t_course")
public class Course {
    @Id
    @GeneratedValue
    @Column
    private int id;
    
    @Column(name="cName")
    private String name;
    
    @ManyToMany(mappedBy="course",cascade={CascadeType.ALL})
    /*@JoinTable(
            //中间表的表名
            name="student_course",
            //当前表的外键
            joinColumns=@JoinColumn(name="cid"),
            //关联表的外键
            inverseJoinColumns=@JoinColumn(name="sid")
            )*/
    private Set<Student> student = new HashSet<Student>();
    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 Set<Student> getStudent() {
        return student;
    }
    public void setStudent(Set<Student> student) {
        this.student = student;
    }
    
    
}


Student..java
package star.july.b_annotation;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Column;
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.Table;
import org.hibernate.annotations.CascadeType;
@Entity
@Table(name="t_student")
public class Student {
    
    @Id
    @GeneratedValue
    @Column
    private int id;
    
    @Column(name="sName")
    private String name;
    
    @ManyToMany
    @JoinTable(
            //中间表的表名
            name="student_course",
            //当前表的外键
            joinColumns=@JoinColumn(name="sid"),
            //关联表的外键
            inverseJoinColumns=@JoinColumn(name="cid")
            )
    private Set<Course> course = new HashSet<Course>();
    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 Set<Course> getCourse() {
        return course;
    }
    public void setCourse(Set<Course> course) {
        this.course = course;
    }
    
    
}



最后是一对一的注解映射
人和身份证
摘取其中最重要的代码片段：
Person.java
@OneToOne (cascade={CascadeType. ALL },mappedBy= "person" )
           private IdCard card ;

IdCard.java
           @OneToOne
           //外键唯一
           @JoinColumn (name= "uid" ,unique= true )
           private Person person ;


starjuly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate 映射关系（基于注解）
qq_26564827的博客
11-28 443
提示：表与表之间的映射关系通过外键或中间表建立联系： 单向外键映射关系：这里主要是指在两个映射表对象类（一对一关系）之间只有一方包含另一方的引用，比如映射对象类A与映射表对象B之间，如果只有A中有一个属性是对B的引用 private B b;那么就称为单向外键关系。 双向外键映射关系；这里指双方都包含一方的引用，但如果是没有中间表，那么就要指定主控方与被控方。 上面所说的单向外键关系与映射外键
Hibernate实体映射
KevinLee的博客
04-15 606
概述 Hibernate通过映射，将实体类与数据库产生联系，通常使用的是XML配置文件方式和@注解方式 在JPA出现之后，推荐使用@注解配置，会少一些配置文件，显得更简洁 通过@注解配置一个实体，一般有id、普通属性、集合属性等，分别对应数据库主键、普通列、外键。 实体 注解@Entity @Table 数据库 id @Id @GeneratedValue 主键
hibernate annotation注解方式来处理映射关系
weixin_34293141的博客
10-17 126
在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，我在试了这两种方式以后，发现使用annotation的方式可以更简介，所以这里就简单记录下通过annotation来配置各种映射关系，在hibernate4以后已经将annotation的jar包集成进来了，如果使用h...
【转】[hibernate]注解的说明
Fighting with Winston Shao
08-11 322
/**  *  * @author liuguangyi  * @content  ejb3注解的API定义在javax.persistence.*包里面。  *  * 注释说明：  * @Entity —— 将一个类声明为一个实体bean(即一个持久化POJO类
Hibernate对象映射
marvin
09-03 257
•@Entity 映射实体类 •@Id 映射生成主键 •@Table 映射表格 •@Column 映射表格列 •@Transient 定义暂态属性 @Entity与@Table • @Entity(name="EntityName") •必须 ,name 为可选 , 对应数据库中一的个表 •@Table(name="") •可选 ,...
Hibernate注解映射联合主键
11-02
在Hibernate中，有三种主要的注解方式来映射联合主键，以下是对这三种方式的详细解释： 1. **使用`@Embeddable`和`@Id`** 在这种映射方式中，联合主键的字段被放在一个单独的类中，这个类需要实现`java.io....
浅谈hibernate之映射文件VS映射注解
08-29
浅谈hibernate之映射文件VS映射注解 在Java开发中，注解是一种非常常用的技术，例如@Override标记重写父类方法或实现接口方法，@Test标记单元测试方法。注解可以简单地理解为一种有特殊含义的标记。在开发过程中，...
hibernate注解处理映射关系共14页.pdf.zip
11-21
《Hibernate注解处理映射关系》是一份深入探讨Hibernate框架中注解应用的教程，共有14页内容，旨在帮助开发者更好地理解和运用Hibernate在数据库映射中的注解技术。Hibernate作为Java领域广泛使用的对象关系映射...
Hibernate一对多关联映射(注解)
06-01
NULL 博文链接：https://profound-accumulation.iteye.com/blog/2243079
Hibernate 注解方式映射视图
fencanluan5712的博客
03-25 3951
最近在做毕设，碰到需要在Hibernate中映射视图，网上很多是基于xml配置的，所以记录一下注解方式的配置。因为视图是没有主键的，所以这里需要用到嵌入主键@EmbeddedId，注入视图中的字段@Entity @Table(name = "articleview", catalog = "englishstudy") public class ArticleView implements Ser...
Hibernate各个注解含义和使用讲解
洛阳泰山的博客
08-30 6373
一。实体Bean 每个持久化POJO类都是一个实体Bean, 通过在类的定义中使用@Entity 注解来进行声明。 声明实体Bean @Entity public class Flight implements Serializable { Long id; @Id public Long getId() { return id; } public void setId(Long id) { this.id = id; } } @Entity 注解将一个类声明为实体Bean, @...
hibernate注解映射属性
weixin_30871293的博客
01-27 405
https://blog.csdn.net/dada678/article/details/51786201 1、普通属性 @Entity：修饰的持久化类的所有属性都会被映射到底层数据库。 @Column:修饰属性 @Transient：修饰不想持久化保存的属性。 @Lob:修饰大数据属性。 当属性为byte[]、Byte[]时数据库对应Blob 当属性为char[]、ch...
Hibernate对视图的映射
我爱编程持之以恒
08-08 6766
在使用hibernate映射数据表,如果设置太多的映射关系,如many-to-one,one-to-many,one-to-one的话则hibernate生成的hql语句太多,造成太多的数据冗余,效率太低,而且太多的字段都用不到,所以可以通过创建数据库视图的方式,在hibernate中通过对视图的映射,读取自己所需要的字段信息来进行信息的查询, 在hibernate中使用视图与普通表不太一样,因
Hibernate注解详解(超全面)，Java开发人员不得不收集的代码
最新发布
m0_60635245的博客
03-28 886
我个人认为，如果你想靠着背面试题来获得心仪的offer，用癞蛤蟆想吃天鹅肉形容完全不过分。想必大家能感受到面试越来越难，想找到心仪的工作也是越来越难，高薪工作羡慕不来，却又对自己目前的薪资不太满意，工作几年甚至连一个应届生的薪资都比不上，终究是错付了，错付了自己没有去提升技术。这些面试题分享给大家的目的，其实是希望大家通过大厂面试题分析自己的技术栈，给自己梳理一个更加明确的学习方向，当你准备好去面试大厂，你心里有底，大概知道面试官会问多广，多深，避免面试的时候一问三不知。
Hibernate的注解映射
youngboby的博客
09-28 330
[TOC] Hibernate的注解映射 1 基本映射 2 多对一单双向映射 3 一对多单双向映射 4 多对多双向映射 5 其他映射 基本映射 1 @Entity 定义在实体类处 Employee； 2 @Table（name=”employee”） 当实体类名与对应的数据库名不一致时定义； 3 @I
5.3.6 复合主键@IdClass
05-09 4593
有时一个实体的主键可能同时为多个，例如同样是之前使用的“CustomerEO”实体，需要通过name和email来查找指定实体，当且仅当name和email的值完全相同时，才认为是相同的实体对象。要配置这样的复合主键，步骤如以下所示。（1）编写一个复合主键的类CustomerPK，代码如下。CustomerPK.javaimport java.io.Serializable
Hibernate中文注解映射指南
首先，文档的前言部分提到，这个文档适用于那些想要使用Hibernate注解进行开发的开发者，它将指导你如何设置系统环境并开始一个注解项目。在系统需求和配置部分，开发者需要了解必要的Java环境和Hibernate库，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值