一个电视台(Station)有一个频道(Channel),并且电视台(Station)是主表,频道(Channel)是从表,主表拥有从表的外键
主表配置如下:
package cn.nagasoft.cms.entities.po;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
/**
* @author chenmingming
* @date 2012-8-6
* @version 1.0
*/
@Entity
@Table(name = "station")
public class Station extends AuditEntity {
/**
*
*/
private static final long serialVersionUID = 1L;
@Id
@Column(name = "STATION_ID")
@GeneratedValue(strategy = GenerationType.AUTO)
private int stationId;
@Column(name = "STATION_NAME", length = 40)
private String stationName;
@Column(name = "STATION_LOGO", length = 50)
private String stationLogo;
@Column(name = "STATION_COMMENT", length = 500)
private String stationComment;
@Column(name = "STATION_TYPE")
private int stationType;
@Column(name = "STATION_HIT")
private int stationHit;
@Column(name = "STATION_NEEDHIT1")
private int stationNeedhit1;
@Column(name = "STATION_NEEDHIT2")
private int stationNeedhit2;
@OneToOne(fetch=FetchType.EAGER,optional=true)
@JoinColumn(name="CHANNEL_ID",insertable=true,unique=true)
private Channel channel;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "playStation", cascade = CascadeType.ALL, orphanRemoval = true)
private Set<PlayList> playLists = new HashSet<PlayList>();
@ManyToOne(fetch = FetchType.EAGER, optional = true, cascade = CascadeType.MERGE)
@JoinColumn(name = "SCHOOL_ID")
private School school;
/**
* 获取电视台ID
*
* @return
*/
public int getStationId() {
return stationId;
}
/**
* 设置电视台ID
*
* @param stationId
*/
public void setStationId(int stationId) {
this.stationId = stationId;
}
/**
* 获取电视台名称
*
* @return
*/
public String getStationName() {
return stationName;
}
/**
* 设置电视台名称
*
* @param stationName
*/
public void setStationName(String stationName) {
this.stationName = stationName;
}
/**
* 获取电视台logo
*
* @return
*/
public String getStationLogo() {
return stationLogo;
}
/**
* 设置电视台logo
*
* @param stationLogo
*/
public void setStationLogo(String stationLogo) {
this.stationLogo = stationLogo;
}
/**
* 获取电视台简介
*
* @return
*/
public String getStationComment() {
return stationComment;
}
/**
* 设置电视台简介
*
* @param stationComment
*/
public void setStationComment(String stationComment) {
this.stationComment = stationComment;
}
/**
* 获取电视台标志(类型)
*
* @return
*/
public int getStationType() {
return stationType;
}
/**
* 设置电视台标志(类型)
*
* @param stationType
*/
public void setStationType(int stationType) {
this.stationType = stationType;
}
/**
* 获取电视台点击率
*
* @return
*/
public int getStationHit() {
return stationHit;
}
/**
* 设置电视台点击率
*
* @param stationHit
*/
public void setStationHit(int stationHit) {
this.stationHit = stationHit;
}
/**
* 获取扩展点击率1
*
* @return
*/
public int getStationNeedhit1() {
return stationNeedhit1;
}
/**
* 设置扩展点击率1
*
* @param stationNeedhit1
*/
public void setStationNeedhit1(int stationNeedhit1) {
this.stationNeedhit1 = stationNeedhit1;
}
/**
* 获取扩展点击率2
*
* @return
*/
public int getStationNeedhit2() {
return stationNeedhit2;
}
/**
* 设置扩展点击率2
*
* @param stationNeedhit2
*/
public void setStationNeedhit2(int stationNeedhit2) {
this.stationNeedhit2 = stationNeedhit2;
}
/**
* 获取频道所有信息
*
* @return
*/
public Channel getChannel() {
return channel;
}
/**
* 设置频道所有信息
*
* @param channels
*/
public void setChannel(Channel channel) {
this.channel = channel;
}
/**
* 获取学校所有信息
*
* @return
*/
public School getSchool() {
return school;
}
/**
* 设置学校所有信息
*
* @param schools
*/
public void setSchool(School school) {
this.school = school;
}
/**
* 获取节目的集合
*
* @return the playLists
*/
public Set<PlayList> getPlayLists() {
return playLists;
}
/**
* 设置节目的集合
*
* @param playLists
* the playLists to set
*/
public void setPlayLists(Set<PlayList> playLists) {
this.playLists = playLists;
}
}
从表配置如下:
package cn.nagasoft.cms.entities.po;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
/**
* @author wangxingzong
* @date 2012-8-3
* @version 1.0
*/
@Entity
@Table(name = "channel")
public class Channel extends AuditEntity {
/**
*
*/
private static final long serialVersionUID = -9010605838714842142L;
@Id
@Column(name = "CHANNEL_ID")
@GeneratedValue(strategy = GenerationType.AUTO)
private int channelId;
@Column(name = "CHANNEL_NAME", length = 30)
private String channelName;
@Column(name = "SOURCE_CHANNEL")
private int sourceChannelId;
@Column(name = "CHANNEL_STREAM", length = 30)
private String channelStream;
@Column(name = "CHANNEL_STATE")
private int channelState;
@Column(name = "VERSION")
private int version;
@ManyToOne(cascade = CascadeType.MERGE, fetch = FetchType.EAGER)
@JoinColumn(name = "SERVER_ID")
private Server channelServer;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "channel")
private Set<Record> record = new HashSet<Record>();
@OneToOne(cascade = CascadeType.MERGE, fetch = FetchType.EAGER, optional = true, mappedBy = "channel")
private Station station;
/**
* 获取直播频道 ID
*/
public int getChannelId() {
return channelId;
}
/**
* 设置直播频道 ID
*/
public void setChannelId(int channelId) {
this.channelId = channelId;
}
/**
* 获取直播频道名称
*/
public String getChannelName() {
return channelName;
}
/**
* 设置直播频道名称
*/
public void setChannelName(String channelName) {
this.channelName = channelName;
}
/**
* 获取播服务器
*/
public Server getChannelServer() {
return channelServer;
}
/**
* 设置播服务器
*/
public void setChannelServer(Server channelServer) {
this.channelServer = channelServer;
}
/**
* 获取直播频道流
*/
public String getChannelStream() {
return channelStream;
}
/**
* 设置直播频道流
*/
public void setChannelStream(String channelStream) {
this.channelStream = channelStream;
}
/**
* 获取直播频道状态
*/
public int getChannelState() {
return channelState;
}
/**
* 设置直播频道状态
*/
public void setChannelState(int channelState) {
this.channelState = channelState;
}
/**
* 获取源频道的频道ID
*
* @return the channelSourceId
*/
public int getSourceChannelId() {
return sourceChannelId;
}
/**
* 设置源频道的频道ID
*
* @param channelSourceId
* the channelSourceId to set
*/
public void setSourceChannelId(int sourceChannelId) {
this.sourceChannelId = sourceChannelId;
}
/**
* 获取电视台信息
*
* @return the station
*/
public Station getStation() {
return station;
}
/**
* 设置电视台信息
*
* @param station
* the station to set
*/
public void setStation(Station station) {
this.station = station;
}
/**
* 获取录制集合
*
* @return
*/
public Set<Record> getRecord() {
return record;
}
/**
* 设置录制集合
*
* @param record
*/
public void setRecord(Set<Record> record) {
this.record = record;
}
/**
* 获得课件版本
*
* @return the version
*/
public int getVersion() {
return version;
}
/**
* 设置课件版本
*
* @param version
* the version to set
*/
public void setVersion(int version) {
this.version = version;
}
}
分享到:
相关推荐
本主题聚焦于“Hibernate双向一对一关联映射”的注解实现,这是一种高级的数据库设计模式,用于处理两个实体之间一对一的关系。 在Hibernate中,一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...
本篇文章将深入探讨Hibernate中注解的一对多、多对多和一对一关系映射。 ### 一对多关系 在现实生活中,例如一个班级有一个班主任,而班主任可以管理多个学生,这就是典型的“一对多”关系。在Hibernate中,我们...
### Hibernate一对一关联映射原理 一对一关联映射是指在数据库中两个表之间存在一对一的关系,例如,一个人只有一个身份证,一个身份证也只属于一个人。在Hibernate中,我们可以通过@OneToOne注解来实现这种映射。 ...
总结一下,Hibernate的一对多关联映射通过注解方式定义了对象间的关联关系,使得我们在编程时能够以面向对象的方式操作数据,而底层数据库的操作则由Hibernate自动完成。这种方式大大提高了开发效率,同时也降低了...
在Hibernate中,一对一关联可以通过`@OneToOne`注解实现。下面我们将通过一个简单的例子来说明: 假设我们有两个实体类,一个是`Person`,表示人,另一个是`DriverLicense`,表示驾照。一个人只有一个驾照,而一个...
在Java世界中,Hibernate是一个非常...通过以上介绍,你应该对Hibernate中的多对一注解映射有了清晰的理解,能够熟练地在实际项目中应用。在实践中,不断优化和调整,才能更好地利用Hibernate提升开发效率和应用性能。
本文将深入探讨Hibernate中的一对多、多对一、一对一以及多对多四种关系映射的配置实例,帮助开发者更好地理解和运用这些关系。 ### 一对多关系(One-to-Many) 在数据库设计中,一对多关系是最常见的一种关联,...
以上代码展示了如何通过注解配置一个简单的“学生-课程”一对一关系。在实际的“学生管理系统”项目中,你可能还需要处理更复杂的关联关系,如多对多关系,这可能涉及到中间表的创建和维护。 此外,使用Hibernate的...
- `@OneToMany`、`@ManyToOne`、`@OneToOne`、`@ManyToMany`:表示不同类型的关联关系,例如一对多、多对一、一对一和多对多。 3. **配置自动建表**: - 在Hibernate的配置文件(hibernate.cfg.xml)中,可以通过...
要让Hibernate同时支持XML和注解映射,我们可以创建一个新的配置类,该类扩展`AnnotationSessionFactoryBean`,并在需要时调用其父类`LocalSessionFactoryBean`的方法来处理XML映射。这样,我们就可以拥有一个单一的...
在Java持久化框架Hibernate中,一对一(One-to-One)关系是一种常见的对象关系映射(ORM)配置,它用于表示两个实体之间的一种特殊关联,其中每个实体最多只能与另一个实体的一个实例相关联。这种关系在数据库层面...
在实际开发中,我们通常会使用IDEA等开发工具,它们内置了对Hibernate的支持,能够自动生成关联的getter和setter方法,以及JPA注解,大大简化了一对一关联的配置过程。 ### 总结 通过主键关联和外键关联,...
本知识点主要讲解的是使用Hibernate实现一对一主键关联(Primary Key Join)的方式,通过注解进行配置。 一对一的关联在数据库设计中并不常见,但当两个实体之间确实存在一对一的关系时,如用户和其个人资料,这种...
1. **@OneToOne**: 一对一关联,可以使用`@PrimaryKeyJoinColumn`指定关联的主键。 2. **@OneToMany**: 一对多关联,可以指定`mappedBy`属性,表明在另一方实体类中有引用。 3. **@ManyToOne**: 多对一关联,通常与`...
在这个“Spring + struts + hibernate(SSHAnnotation) 全注解”项目中,开发者使用了这些框架的注解版本,以减少XML配置文件的使用,提高代码的可读性和开发效率。 **Struts2** 是一个基于MVC(Model-View-...
在这个注解版的实现中,我们将深入探讨如何使用Hibernate的注解配置来设置这种关联。 首先,我们需要了解一对多关联的基本概念。在数据库设计中,一对多关系意味着一个表(父表)的记录可以与多个其他表(子表)的...
在这个“hibernate双向多对多关联映射(注解版)”的主题中,我们将深入探讨如何使用Hibernate的注解配置来处理数据库中的双向多对多关联关系。 首先,多对多关联在数据库设计中是指两个实体之间存在多个对应关系,...
一、Hibernate一对一关联类型 一对一关联在现实世界中很常见,例如一个人只有一个身份证,一个身份证也只能属于一个人。在数据库设计中,这种关系通常通过主键和外键的方式实现,其中一方的主键作为另一方的外键,...
在Hibernate中,一对一(One-to-One)映射是一种常见的关联关系,它表示两个实体之间存在一对一的对应关系。本篇文章将深入探讨Hibernate中的一对一外键单向关联。 首先,一对一外键关联指的是一个实体通过外键直接...
**标题:“Hibernate一对一”** **描述:** 这篇文章主要探讨了Hibernate框架中的一对一关系映射,这是一种在数据库设计中常见的关联方式。作者通过在博客中分享,详细讲解了如何在Java应用程序中使用Hibernate实现...