hibernate关联注解
Hibernate关联关系注解配置简单理解
Hibernate关联关系注解配置简单理解Hibernate关联关系注解配置什么是关联关系?关联关系有哪⼏种?关联关系指实体之间的关系,也就是表与表之间的关系。
⼀个关系⽤两个属性来描述,数量性和⽅向性。
从数量上来看,表与表之间主要有三种关系,⼀对⼀,⼀对多,多对多。
加上关系的⽅向,还有⼀个多对⼀。
hibernate中关联关系的维护在实际的业务开发中,对于两个有关联的数据库实体,⽐如学⽣对教室,我们通常还需要在操作⼀⽅时,维护两⽅彼此之间的关系。
关系的维护分为两类:1.级联Cascade,在操作⼀⽅时,是否对另⼀⽅也执⾏同样的操作。
2.外键的维护inverse,在操作⼀⽅时,是否⾃动维护外键关系。
⽐如如果将多⽅的对象添加给以⼀的⼀⽅,因为外键由多⽅维护,hibernate 为了保证添加的这个多⽅对象的外键是正确的,会⾃动给这个多⽅的外键设置值(也就是⼀的⼀⽅的主键)外键维护,在xml配置中使⽤inverse属性,在注解中使⽤mappedBy注解来声明。
cascade与inverse1.cascade,指把对当前对象的操作级联到关联对象上。
⼀般在one to one ,one to many设置级联。
配置了这个属性后,当对当前对象执⾏如save等更新数据库的操作时,当前实体所关联的实体也会执⾏相应的操作。
2.inverse默认值为true, 表⽰让对⽅来维护关系。
设为false,⾃⼰维护关系。
inverse主要有两个作⽤:1)维护外键主控⽅保存时,是否⾃动update被控⽅的外键字段。
外键字段指向的就是当前保存的实体。
2)维护级联决定当前设置的级联是否有⽤,⾃⼰维护关系时,对⽅设置的级联就不会⽣效,对⽅保存时不会让本⽅也保存。
⽽对⽅维护关系,则与此相反。
@mappedBy注解1)mappedBy(name="对⽅标准代表当前实体的属性“)2)只存在于OneToOne,OneToMany,ManyToMany, 不能在ManyToOne中3)与joincolumn或jointable互斥。
hibernate-validator常用注解
hibernate-validator常用注解Hibernate-Validator 是一个用来验证 bean 属性的开源框架,它通过使用 Java 语言编写的注释来校验 bean 属性的值是否有效,也可以用于开发高质量 Java 应用程序。
Hibernate-Validator 提供了大量的注解,可以在简单的方式对 bean 属性值进行校验,以确保属性值的有效性。
1. @NotNull:该注解用于校验 bean 属性值不能为 null,null 时会抛出 ConstraintViolationException 异常;2. @Null:该注解用于校验 bean 属性值必须为 null,不为null 时会抛出 ConstraintViolationException 异常;3. @AssertTrue:该注解用于校验 bean 属性值必须为 true,为false 时会抛出 ConstraintViolationException 异常;4. @AssertFalse:该注解用于校验 bean 属性值必须为 false,为 true 时会抛出 ConstraintViolationException 异常;5. @Min:该注解用于校验 bean 属性的数值必须大于等于@Min 指定的值,小于指定值时会抛出 ConstraintViolationException 异常;6. @Max:该注解用于校验 bean 属性的数值必须小于等于@Max 指定的值,大于指定值时会抛出 ConstraintViolationException 异常;7. @DecimalMin:该注解用于校验 bean 属性的数值必须大于等于@DecimalMin 指定的值,小于指定值时会抛出ConstraintViolationException 异常;8. @DecimalMax:该注解用于校验 bean 属性的数值必须小于等于@DecimalMax 指定的值,大于指定值时会抛出ConstraintViolationException 异常;9. @Size:该注解用于校验 bean 属性值的长度,当属性值的长度不符合@Size 指定的范围时会抛出 ConstraintViolationException 异常;10. @Digits:该注解用于校验 bean 属性值的数字格式,不符合数字格式时会抛出 ConstraintViolationException 异常;11. @Past:该注解用于校验 bean 属性值是一个过去的日期,不是过去的日期时会抛出 ConstraintViolationException 异常;12. @Future:该注解用于校验 bean 属性值是一个未来的日期,不是未来的日期时会抛出 ConstraintViolationException 异常;13. @Pattern:该注解用于校验 bean 属性值是否符合指定的正则表达式,不符合时会抛出 ConstraintViolationException 异常;14. @Email:该注解用于校验 bean 属性值是否为邮件地址,不是邮件地址时会抛出 ConstraintViolationException 异常;15. @Length:该注解用于校验 bean 属性值的长度,不符合长度范围会抛出 ConstraintViolationException 异常;16. @NotBlank:该注解用于校验 bean 属性字符串不能为 null 和空字符串,null 或空字符串时会抛出ConstraintViolationException 异常;17. @NotEmpty:该注解用于校验 bean 属性值不能为 null 或者为空集合,null 或空集合时会抛出 ConstraintViolationException 异常;18. @Range:该注解用于校验 bean 属性的数值或字符串的长度在指定的范围内,不在指定范围时会抛出ConstraintViolationException 异常;19. @CreditCardNumber:该注解用于校验 bean 属性值是否为信用卡号,不是信用卡号时会抛出 ConstraintViolationException 异常;20. @ScriptAssert:该注解用于校验 bean 属性值是否满足一个脚本表达式,不满足时会抛出 ConstraintViolationException 异常。
hibernate核心,一对多,多对多映射讲解,看了就完全搞明白了
在many一方删除数据1
• 删除“五四大道”
inverse设为true,由many一方删除 从one一方去“删除”, Hibernate只是执行了 问题出在配置文件上 update语句。还是未删 没有配置set节点的inverse属性 除成功! 根本没有执行 Delete语句,数据 没有被删除!
– 配置Hibernate多对多关联,实现某OA系统项 目和人员对照关系的管理
本章目标
• 掌握单向many-to-one关联 • 掌握双向one-to-many关联 • 掌握many-to-many关联
实体间的关联
• 单向多对一
tblJd.getQx().getQxname();
• 单向一对多
TblJd jd = (TblJd)tblQx.getJds().get(0); jd.getJdname(); tblQx.getJds.add(jd);
小结
• 在租房系统中,房屋信息(Fwxx)与用户 (User)间也是多对一关系。如何配置映 射文件,使之可以通过下面的代码输出房 屋信息和发布该信息的用户名称? Fwxx fwxx = (Fwxx)super.get(Fwxx.class,1);
System.out.println( fwxx.getTitle() + "," + fwxx.getUser.getUname());
inverse是“反转”的意思,表示关联关系的控制权。 为true,表示由对方负责关联关系的添加和删除; 执行了delete语句, 为false,表示由自己负责维护关联关系。 删除成功
• 在many一方删除数据的正确做法:
联合主键三种实现方式
联合主键三种实现⽅式联合主键可以通过Hibernate注解进⾏映射,下⾯为⼤家展⽰三种实现⽅式:⼀、⽅法⼀(本⼈喜欢使⽤这种⽅式,使⽤主键类字段时可以当做正常字段⼀样使⽤)1.将联合主键的字段单独放在⼀个类中,该类需要重写equals和hashcode⽅法。
2.在主类中(该类包含联合主键类中的字段)将联合主键字段都注解为@Id。
3.最后在该类上加上注解:@IdClass(联合主键类.class),⽤来关联主键类代码⽰例:1/**2 *3*/4package kklazy.acqinstmanagement.model;5import javax.persistence.Column;6import kklazy.persistence.model.SupportModel;78/**9 * @author10 * 主键类11*/12public class RouteProfitPK extends SupportModel{13/**14 *15*/16private static final long serialVersionUID = -4243768063352460725L;17/*复合主键值*/18private String orgcode;//机构号19private String transType;//交易类型(前端)2021/**22 * ⽆参数的public构造⽅法,必须要有23*/24public RouteProfitPK() {2526 }27/**28 * @return the orgcode29*/30 @Column(name="ORGCODE")31public String getOrgcode() {32return orgcode;33 }34/**35 * @param orgcode the orgcode to set36*/37public void setOrgcode(String orgcode) {code = orgcode;39 }4041/**42 * @return the transType43*/44 @Column(name="TRANSTYPE")45public String getTransType() {46return transType;47 }48/**49 * @param transType the transType to set50*/51public void setTransType(String transType) {52this.transType = transType;53 }54/* (non-Javadoc)55 * @see ng.Object#hashCode()56*/57 @Override58public int hashCode() {59final int prime = 31;60int result = 1;61 result = prime * result + ((orgcode == null) ? 0 : orgcode.hashCode());62 result = prime * result + ((transType == null) ? 0 : transType.hashCode());63return result;64 }65/* (non-Javadoc)66 * @see ng.Object#equals(ng.Object)67*/68 @Override69public boolean equals(Object obj) {70if (this == obj)71return true;72if (obj == null)73return false;74if (getClass() != obj.getClass())75return false;76 RouteProfitPK other = (RouteProfitPK) obj;77if (orgcode == null) {78if (code != null)79return false;80 } else if (!orgcode.equals(code))81return false;82if (transType == null) {83if (other.transType != null)84return false;85 } else if (!transType.equals(other.transType))86return false;87return true;88 }89909192 }1package kklazy.acqinstmanagement.model;2import java.util.Date;3import javax.persistence.Column;4import javax.persistence.Entity;5import javax.persistence.Id;6import javax.persistence.IdClass;7import javax.persistence.Table;8import javax.persistence.Transient;9import kklazy.persistence.model.SupportModel;1011/**12 * @author13 * 主表14*/15 @Entity16 @Table(name="ROUTE_PROFIT")17 @IdClass(RouteProfitPK.class)18public class RouteProfit extends SupportModel{19private String orgcode;//机构号20private String profitName;//分润名称21private String transType;//交易类型(前端)22private String payPeriod;//分润周期【00-⽇,01-周(1-7),02-⽉XX号(1-28)】格式为:00| (⽇)01|4 (每周4)02|12 (每⽉12⽇) 23private String profitId;//分润⽅ID24private String status;//状态(00_正常01_禁⽤)25private Date entDate;//建⽴⽇期26private String operaName;//操作员27private String auditing;//审核(操作员28private String memo;//备注2930private String transTypeName;//交易类型名称(页⾯显⽰)31/**32 * @return the orgcode33*/34 @Column(name="ORGCODE")35 @Id36public String getOrgcode() {37return orgcode;38 }39/**40 * @param orgcode the orgcode to set41*/42public void setOrgcode(String orgcode) {code = orgcode;44 }45/**46 * @return the profitName47*/48 @Column(name="PROFIT_NAME")49public String getProfitName() {50return profitName;51 }52/**53 * @param profitName the profitName to set54*/55public void setProfitName(String profitName) {56this.profitName = profitName;57 }58/**59 * @return the transType61 @Column(name="TRANSTYPE")62 @Id63public String getTransType() {64return transType;65 }66/**67 * @param transType the transType to set68*/69public void setTransType(String transType) { 70this.transType = transType;71 }72/**73 * @return the payPeriod74*/75 @Column(name="PAYPERIOD")76public String getPayPeriod() {77return payPeriod;78 }79/**80 * @param payPeriod the payPeriod to set81*/82public void setPayPeriod(String payPeriod) {83this.payPeriod = payPeriod;84 }85/**86 * @return the profitId87*/88 @Column(name="PROFIT_ID")89public String getProfitId() {90return profitId;91 }92/**93 * @param profitId the profitId to set94*/95public void setProfitId(String profitId) {96this.profitId = profitId;97 }98/**99 * @return the status100*/101 @Column(name="STATUS")102public String getStatus() {103return status;104 }105/**106 * @param status the status to set107*/108public void setStatus(String status) {109this.status = status;110 }111/**112 * @return the entDate113*/114 @Column(name="ENTDATE")115public Date getEntDate() {116return entDate;117 }118/**119 * @param entDate the entDate to set120*/121public void setEntDate(Date entDate) {122this.entDate = entDate;123 }124/**125 * @return the operaName126*/127 @Column(name="OPERANAME")128public String getOperaName() {129return operaName;130 }131/**132 * @param operaName the operaName to set 133*/134public void setOperaName(String operaName) { 135this.operaName = operaName;136 }137/**138 * @return the auditing139*/140 @Column(name="AUDITING")141public String getAuditing() {142return auditing;143 }145 * @param auditing the auditing to set146*/147public void setAuditing(String auditing) {148this.auditing = auditing;149 }150/**151 * @return the memo152*/153 @Column(name="MEMO")154public String getMemo() {155return memo;156 }157/**158 * @param memo the memo to set159*/160public void setMemo(String memo) {161this.memo = memo;162 }163/**164 * @return the transTypeName165*/166 @Transient167public String getTransTypeName() {168return transTypeName;169 }170/**171 * @param transTypeName the transTypeName to set172*/173public void setTransTypeName(String transTypeName) {174this.transTypeName = transTypeName;175 }176177178179180 }⼆、⽅法⼆1.将联合主键的字段单独放在⼀个类中,该类需要重写equals和hascode⽅法。
hibernate注解之@Onetomany、@Manytoone、@JoinColumn
hibernate注解之@Onetomany、@Manytoone、@JoinColumn @Onetomany⽤于实体类与数据库表映射中少的⼀⽅,请看下⾯的例⼦。
假设⼀个⽤户只有⼀种⾓⾊,⽤户和⾓⾊是onetomany的关系⽤户实体@Entity@Table(name="user")public class UserEntity implements Serializable{@Id@GenericGenerator(name="generator",strategy="uuid")@GeneratedValue(generator="generator")@Column(name="id")private String id;@Column(name="userName")private String userName;@Column(name="password")private String password;@Temporal(value=TemporalType.TIMESTAMP)private Date createDate; ......⾓⾊实体@Entity@Table(name="role")public class RoleEntity implements Serializable{@Id@GenericGenerator(name="generator",strategy="uuid")@GeneratedValue(generator="generator")@Column(name="id")private String id;@Column(name="name")private String name;@OneToMany(fetch=ZY,cascade=CascadeType.PERSIST)private Set<UserEntity> user;同时设置配置⽂件为<prop key="hibernate.hbm2ddl.auto">update</prop>那么在项⽬启动后会⾃动⽣成三张表,分别是⾓⾊表⽤户表⾓⾊⽤户表@Onetomany 的参数:mappedBy:⽤于双向关联时使⽤,否则会引起数据不⼀致的问题。
Hibernate中leftjoin、innerjoin以及leftjoinfetch区别
Hibernate中leftjoin、innerjoin以及leftjoinfetch区别⼀:内连接查询(显⽰和隐式)内连接查询:内连接,⾃连接。
显⽰内连接(推荐写法):.SELECT <selectList>FROM A [INNER] JOIN B ON A.列 = B.列隐式内连接:SELECT <selectList>FROM A ,B WHERE A.列 = B.列②⾃连接把⼀张表看成两张来做查询.⼀定要取别名⼆者效果⼀样,写法不同。
⼆:外连接(左外连接,右外连接,全连接(mysql不⽀持)语法格式SELECT <selectList>FROM A LEFT/RIGHT [OUTER] JOIN BON (A.column_name = B.column_name)];三:join fetch⼀个"fetch"连接允许仅仅使⽤⼀个选择语句就将相关联的对象或⼀组值的集合随着他们的⽗对象的初始化⽽被初始化。
四:XmlRootElement将类或枚举类型映射到 XML 元素。
JAXB中的注解,⽤来根据java类⽣成xml内容。
五:hibernate 注释唯⼀键约束 uniqueConstraints@Table 注解包含⼀个schema和⼀个catelog 属性,使⽤@UniqueConstraints 可以定义表的唯⼀约束。
如果是联合约束就⽤下⾯这种@Table(name="tbl_sky",uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})})如果是单⼀字段约束可以⽤@Table(name="tbl_sky",uniqueConstraints = {@UniqueConstraint(columnNames="month")})六:@Transient该注解,是hibernate、morphia等框架的注解。
Hibernate@OneToMany等注解设置查询过滤条件等
Hibernate@OneToMany等注解设置查询过滤条件等1、如实体PdOrg对象中有users对象,数据库user表有字段DEL_FLAG(0:删除;1:未删除):private List<User> users= new ArrayList<User>();⽣成get、set⽅法:@OneToMany(fetch=ZY, mappedBy="user")@BatchSize(size=10)@Where(clause="DEL_FLAG=1")@OrderBy(clause="CREATED_DATE asc")public List<User> getUsers() { return er;}public void setUsers(List<User> user) { er= user;}@BatchSize(size=10) //缓存数据⼤⼩:10条数据@Where(clause="DEL_FLAG=1") //代表只取未删除的数据;@OrderBy(clause="CREATED_DATE asc") //代表按创建时间正序排列2、⽤⼀个列关联多个实体属性,⽐如举报维权,举报的对象可能是⽤户,悬赏,商品,订单//举报对象(⽤户)@OneToOne(cascade = { CascadeType.REFRESH}, fetch = FetchType.EAGER)@JoinColumn(name ="gid", insertable =false, updatable =false)@NotFound(action=NotFoundAction.IGNORE)private UserInfo reporteder;//举报对象(悬赏)@OneToOne(cascade = { CascadeType.REFRESH}, fetch = FetchType.EAGER)@JoinColumn(name ="gid", insertable =false, updatable =false)@NotFound(action=NotFoundAction.IGNORE)private Reward reward;//举报对象(商品)@OneToOne(cascade = { CascadeType.REFRESH}, fetch = FetchType.EAGER)@JoinColumn(name ="gid", insertable =false, updatable =false)@NotFound(action=NotFoundAction.IGNORE)private Product product;//举报对象(订单)@OneToOne(cascade = { CascadeType.REFRESH}, fetch = FetchType.EAGER)@JoinColumn(name ="gid", insertable =false, updatable =false)@NotFound(action=NotFoundAction.IGNORE)private Order order;。
Hibernate注解
Hibernate注解常用的hibernate annotation标签如下:@Entity--注释声明该类为持久类。
@Table(name="promotion_info")--持久性映射的表(表名="promotion_info)。
@Column(name=”DESC”,nullable=false,length=512)--用于指定持久属性或字段的映射列。
@Id--注释可以表明哪种属性是该类中的独特标识符(即相当于数据表的主键)。
@GeneratedValue--定义自动增长的主键的生成策略。
@Transient--将忽略这些字段和属性,不用持久化到数据库。
@Temporal(TemporalType.TIMESTAMP)--声明时间格式。
@Enumerated--声明枚举@Version--声明添加对乐观锁定的支持@OneToOne--可以建立实体bean之间的一对一的关联@OneToMany--可以建立实体bean之间的一对多的关联@ManyToOne--可以建立实体bean之间的多对一的关联@ManyToMany--可以建立实体bean之间的多对多的关联@Formula--一个SQL表达式,这种属性是只读的,不在数据库生成属性(可以使用sum、average、max等)@OrderBy--Many端某个字段排序(List)下面是对以上常用Hibernate注解标签的详细介绍与举例:@Entity--注释声明该类为持久类。
将一个Javabean类声明为一个实体的数据库表映射类,最好实现序列化.此时,默认情况下,所有的类属性都为映射到数据表的持久性字段.若在类中,添加另外属性,而非映射来数据库的, 要用下面的Transient来注解.@Table(name="promotion_info")--持久性映射的表(表名="promotion_info).@T able是类一级的注解,定义在@Entity下,为实体bean映射表,目录和schema的名字,默认为实体bean的类名,不带包名.示例:@Entity@T able(name="CUST", schema="RECORDS")public class Customer { ... }@Column(name=”DESC”,nullable=false,length=512)--用于指定持久属性或字段的映射列。
hibernate validator 多注解顺序
hibernate validator 多注解顺序Hibernate Validator是一个用于Java Bean验证的开源框架,它提供了一系列的注解来验证数据的合法性。
在实际开发中,我们经常需要对一个属性进行多个验证,这就涉及到了多个注解的使用顺序的问题。
本文将详细介绍Hibernate Validator多注解的顺序问题,并给出一步一步的解答。
第一步:了解Hibernate Validator多注解的顺序问题在Hibernate Validator中,每个注解都有其特定的验证逻辑。
在使用多个注解进行验证时,验证的顺序将直接影响验证的结果。
因此,正确的注解顺序是至关重要的。
第二步:分析Hibernate Validator多注解的验证逻辑Hibernate Validator中的每个注解都有其验证逻辑,它们可以分为两大类:基本约束注解和组合约束注解。
基本约束注解是直接对属性进行验证的注解,例如@NotNull、@NotEmpty和@Pattern等。
它们可以独立使用,即单个注解就可以完成验证。
组合约束注解是对一组注解进行组合,形成一个复合注解来完成验证,例如@Email、@CreditCardNumber和@Size等。
这类注解的验证逻辑比较复杂,需要按照特定的顺序依次执行。
第三步:确定多注解的顺序要求在实际开发中,我们通常需要对一个属性进行多个验证,这就需要确定多个注解的顺序要求。
一般情况下,基本约束注解应该放在组合约束注解之前,以保证基本约束的验证先于组合约束的验证。
第四步:示例演示为了更好地理解Hibernate Validator多注解的顺序问题,我们将通过一个示例演示。
假设我们要对用户的密码进行验证,要求密码不能为空、长度在6到20之间,并且只能包含字母和数字。
首先,我们需要使用@NotBlank注解来验证密码不能为空:java@NotBlank(message = "密码不能为空")private String password;然后,我们需要使用@Size注解来验证密码的长度是否在6到20之间:java@Size(min = 6, max = 20, message = "密码长度必须在6到20之间") private String password;最后,我们需要使用@Pattern注解来验证密码只能包含字母和数字:java@Pattern(regexp = "^[azAZ09]+", message = "密码只能包含字母和数字") private String password;根据之前的分析,我们知道基本约束注解应该放在组合约束注解之前,所以正确的顺序应该是@NotBlank、@Size、@Pattern。
Hibernate注释大全
)
public Set<Monkey> getTrainedMonkeys() {
...
}
@Entity
public class Monkey {
... //no bidir
用 cascading 实现传播持久化(Transitive persistence)
cascade 属性接受值为 CascadeType 数组,其类型如下:
? CascadeType.PERSIST: cascades the persist (create) operation to associated entities persist() is called or if the entity is managed 如果一个实体是受管状态,或者当 persist() 函数被调用时,触发级联创建(create)操作。
@SecondaryTable(name="Cat2", uniqueConstraints={
@UniqueConstraint(columnNames={"storyPart2"})})
})
public class Cat implements Serializable {
...
}
public class MyDao {
doStuff() {
Query q = s.getNamedQuery("night.moreRecentThan");
q.setDate( "date", aMonthAgo );
列举5个三大框架中用到的注解及其作用
列举5个三大框架中用到的注解及其作用在现代化的Java编程中,常常使用三大框架,分别是Spring、Hibernate和Struts。
这些框架目的在于开发高质量和不易出错的应用程序。
而注解就是这些框架之一,其中包括许多重要的注解。
本文将会列举5个三大框架中用到的注解及其作用。
一、@Autowired@Autowired是Spring框架中用到的一个注解,它作用是自动装配。
被它所标注的类,Spring会自动在容器中查找匹配类型的对象,并且自动注入到这个类的Field中(即根据类型注入)。
如果这样的对象有多个的话,就会根据name属性来进行匹配。
@Autowired注解的作用类似于XML配置文件中的<bean/>元素配置中的<property/>元素。
使用这个注解可以省略掉XML中对象关系的配置,更加方便。
二、@Entity@Entity注解是Hibernate框架中用到的一个注解,它作用是实体映射,这个注解往往和@Table注解一起使用。
这个注解用于指定一个作为Hibernate映射的持久化实体类型。
通过这个注解统计内部信息后可以将它们映射到数据库中的表结构。
三、@RequestMapping一个控制器有很多的方法,而且这些方法应该是有不同的请求方式的(GET、POST等),在Struts框架中需要使用根据方法名来判定请求方式,而在Spring MVC中使用的则是@RequestMapping注解。
这个注解作用是将一个HTTP请求映射到一个特定的处理方法上(即根据请求路径匹配)。
这个注解同样有很多的属性可以配置,如路径、请求方式等。
四、@Transactional像封装JDBC的框架,往往需要处理事务。
用常规的JDBC我们可以这样做,但是Spring提供了更加便利和灵活的机制。
@Transactional注解用于事务处理。
当我们在Java方法上使用这个注解时,就会自动拦截这个方法,然后在@Transactional注解中对事务进行了定义。
Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结
Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结引言简要介绍Hibernate框架以及关联关系映射在数据库设计中的重要性。
Hibernate关联关系映射概述关联关系的重要性讨论在现实世界中对象间关系的重要性以及如何在数据库中表示这些关系。
Hibernate关联关系类型列举Hibernate支持的关联关系类型,包括一对一、一对多、多对一和多对多。
一对多关联关系映射概念解释解释一对多关联关系的概念,例如一个部门拥有多个员工。
XML映射方式详细描述如何在XML映射文件中配置一对多关联关系。
实体类定义展示一对多关系中实体类的Java代码示例。
XML映射文件提供一对多关系映射的XML配置示例。
注解映射方式详细描述如何使用注解配置一对多关联关系。
实体类定义展示使用注解的一对多关系中实体类的Java代码示例。
注解配置提供一对多关系映射的注解配置示例。
多对多关联关系映射概念解释解释多对多关联关系的概念,例如学生和课程之间的关联。
XML映射方式详细描述如何在XML映射文件中配置多对多关联关系。
实体类定义展示多对多关系中实体类的Java代码示例。
XML映射文件提供多对多关系映射的XML配置示例。
注解映射方式详细描述如何使用注解配置多对多关联关系。
实体类定义展示使用注解的多对多关系中实体类的Java代码示例。
注解配置提供多对多关系映射的注解配置示例。
关联关系映射的高级特性级联操作讨论级联保存、更新和删除的概念及其配置。
双向关系管理解释如何管理双向关联关系,确保数据的一致性。
延迟加载与即时加载讨论延迟加载和即时加载的概念及其在关联关系中的应用。
实践案例分析一对多关联关系案例通过一个具体的一对多关联关系案例,展示映射配置和数据操作。
多对多关联关系案例通过一个具体的多对多关联关系案例,展示映射配置和数据操作。
常见问题与解决方案一对多关联关系常见问题列举一对多关联关系映射中可能遇到的问题及其解决方案。
Hibernate_@注解和xml配置介绍
1.show_sql和format_sql
在hibernate.cfg.xml配置文件中添加如下的配置:
<property name="format_sq">true</property>,将sql语句格式化一下
2.类名与数据库表名不一致
在类名上方添加注解:@Table(name="XXX")
3.字段名和属性名不一致
在对应字段的getXXX方法上面上方添加注解:@Column(name="XXX")
4.取消字段的持久化
在对应字段的getXXX方法上面上方添加注解:@Transient
5.指定Date存储的格式:
在时间对应的getXXX方法上面添加注解:
@Temporal(TemporalType.TIME)只存储时间: hh:mm:ss
@Temporal(TemporalType.DATE)只存储日期: yyyy-MM-dd
@Temporal(TemporalType.DATETIME) 时间日期一起存储:yyyy-MM-dd hh:mm:ss
6.ID生成策略:
∙Id的get方法上方添加@GeneratedValue ,mysql默认是auto_increment,Oracle中默认是hibernate_sequence(名称固定)
∙联合主键:如图:
★:在主键类属性的get方法上方添加@EmbeddedId,设定联合主键!在主键类中写联合属性的get和set方法!
★:这个主键类必须重写public boolean equals()和public int hashCode()方法!实现Serializable接口。
hibernate annotation 双向 one-to-one 注解
环境:Hibernate 3.3.1Maven 3.0.4MySQL 5.5.13Myeclipse 8.6.1建表语句:DROP TABLE IF EXISTS `t_card`;CREATE TABLE `t_card` (`cardId` int(10) unsigned NOT NULL AUTO_INCREMENT,`cardNumber` char(18) NOT NULL,PRIMARY KEY (`cardId`)) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_card` VALUES ('1', '440911************');DROP TABLE IF EXISTS `t_person`;CREATE TABLE `t_person` (`personId` int(10) unsigned NOT NULL AUTO_INCREMENT,`personName` varchar(15) NOT NULL,`cid` int(10) unsigned NOT NULL,PRIMARY KEY (`personId`)) ENGINE=InnoDB AUTO_INCREMENT=2DEFAULT CHARSET=gb2312; INSERT INTO `t_person` VALUES ('1', 'fancy', '1');Person.javapackage com.fancy.po;import javax.persistence.CascadeType;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.OneToOne;import javax.persistence.Table;/*** -----------------------------------------* @文件: Person.java* @作者: fancy* @邮箱: fancyzero@* @时间: 2012-6-10* @描述: 实体类* -----------------------------------------*//*** @Entity 声明一个类为实体Bean* @Table(name = "xx")指定实体类映射的表,如果表名和实体类名一致,可以不指定*/@Entity@Table(name = "t_person")public class Person {private Integer personId;private String personName;private Card card;/*** @Id 映射主键属性,这里采用uuid的主键生成策略* @GeneratedValue ——注解声明了主键的生成策略。
Hibernate注解用法总结
1.类级别注解@Entity 映射实体类@Table 映射数句库表@Entity(name="tableName") - 必须,注解将一个类声明为一个实体bean。
属性:name - 可选,对应数据库中的一个表。
若表名与实体类名相同,则可以省略。
@Table(name="",catalog="",schema="") - 可选,通常和@Entity配合使用,只能标注在实体的class 定义处,表示实体对应的数据库表的信息。
属性:name - 可选,表示表的名称,默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名catalog - 可选,表示Catalog名称,默认为Catalog("").schema- 可选, 表示Schema 名称, 默认为Schema("").2.属性级别注解@Id 映射生成主键@Version 定义乐观锁@Column 映射表的列@Transient 定义暂态属性2.1 与主键相关注解@Id - 必须,定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键,置于getXxxx() 前。
@GeneratedV alue(strategy=GenerationType,generator="") - 可选,用于定义主键生成策略。
属性:Strategy - 表示主键生成策略,取值有:GenerationType.AUTO- 根据底层数据库自动选择(默认),若数据库支持自动增长类型,则为自动增长。
GenerationType.I NDENTITY- 根据数据库的Identity字段生成,支持DB2、MySQL、MS、SQL Server、SyBase与HyperanoicSQL数据库的Identity类型主键。
GenerationType.SEQUENCE -使用Sequence来决定主键的取值,适合Oracle、DB2等支持Sequence的数据库,一般结合@SequenceGenerator使用。
Hibernate,JPA注解@DynamicInsert和@DynamicUpdate,。。。
Hibernate,JPA注解@DynamicInsert和@DynamicUpdate,。
@DynamicInsert属性:设置为true,设置为true,表⽰insert对象的时候,⽣成动态的insert语句,如果这个字段的值是null就不会加⼊到insert语句当中.默认false。
⽐如希望数据库插⼊⽇期或时间戳字段时,在对象字段为空的情况下,表字段能⾃动填写当前的sysdate。
@DynamicUpdate属性:设置为true,设置为true,表⽰update对象的时候,⽣成动态的update语句,如果这个字段的值是null就不会被加⼊到update语句中,默认false。
⽐如只想更新某个属性,但是却把整个对象的属性都更新了,这并不是我们希望的结果,我们希望的结果是:我更改了哪些字段,只要更新我修改的字段就够了。
@DynamicInsert⽤例代码如下:数据库DDL语句:1create table CAT2 (3 id VARCHAR2(32CHAR) not null,4 create_time TIMESTAMP(6) default sysdate,5 update_time TIMESTAMP(6),6 cat_name VARCHAR2(255CHAR)7 )hibernate.cfg.xml1<?xml version="1.0" encoding="utf-8" ?>2<!DOCTYPE hibernate-configuration3 PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"4 "/hibernate-configuration-3.0.dtd">5<hibernate-configuration>6<session-factory>7<!-- 数据库驱动配置 -->8<property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>9<property name="connection.driver_class">oracle.jdbc.OracleDriver</property>10<property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orcl</property>11<property name="ername">wxuatuser</property>12<property name="connection.password">xlh</property>13<property name="show_sql">true</property>14<!-- ⾃动执⾏DDL属性是update,不是true -->15<property name="hbm2ddl.auto">update</property>16<!-- hibernate实体类 -->1718<mapping class="a2_DynamicInsert_Update.Cat"/>1920</session-factory>21</hibernate-configuration>java类实体类 - 基类1package model;23import java.io.Serializable;4import java.util.Date;5import javax.persistence.Column;6import javax.persistence.GeneratedValue;7import javax.persistence.Id;8import javax.persistence.MappedSuperclass;9import org.hibernate.annotations.GenericGenerator;1011/**12 * 实体类 - 基类13*/14 @MappedSuperclass15public class BaseEntity implements Serializable {1617private static final long serialVersionUID = -6718838800112233445L;1819private String id;// ID20private Date create_time;// 创建⽇期21private Date update_time;// 修改⽇期22 @Id23 @Column(length = 32, nullable = true)24 @GeneratedValue(generator = "uuid")25 @GenericGenerator(name = "uuid", strategy = "uuid")26public String getId() {27return id;28 }2930public void setId(String id) {31this.id = id;32 }3334 @Column(updatable = false)35public Date getCreate_time() {36return create_time;37 }40public void setCreate_time(Date create_time) {41this.create_time = create_time;42 }4344public Date getUpdate_time() {45return update_time;46 }4748public void setUpdate_time(Date update_time) {49this.update_time = update_time;50 }5152 @Override53public int hashCode() {54return id == null ? System.identityHashCode(this) : id.hashCode();55 }5658 @Override59public boolean equals(Object obj) {60if (this == obj) {61return true;62 }63if (obj == null) {64return false;65 }66if (getClass().getPackage() != obj.getClass().getPackage()) {67return false;68 }69final BaseEntity other = (BaseEntity) obj;70if (id == null) {71if (other.getId() != null) {72return false;73 }74 } else if (!id.equals(other.getId())) {75return false;76 }77return true;78 }79 }实体类1package a2_DynamicInsert_Update;2import javax.persistence.Entity;3import model.BaseEntity;4import org.hibernate.annotations.DynamicInsert;5import org.hibernate.annotations.DynamicUpdate;67 @Entity8 @DynamicInsert9 @DynamicUpdate10public class Cat extends BaseEntity{11/**12 * 实体类13*/14private static final long serialVersionUID = -2776330321385582872L; 1516private String cat_name;1718public String getCat_name() {19return cat_name;20 }2122public void setCat_name(String cat_name) {23this.cat_name = cat_name;24 }Dao1package daoUtil;23import org.hibernate.HibernateException;4import org.hibernate.Session;5import org.hibernate.SessionFactory;6import org.hibernate.Transaction;7import org.hibernate.cfg.Configuration;8import org.hibernate.service.ServiceRegistry;9import org.hibernate.service.ServiceRegistryBuilder;1011public class HibernateUtil {1213private static final SessionFactory sessionFactory;1415static {16try {17 Configuration cfg = new Configuration().configure();18 ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()19 .applySettings(cfg.getProperties()).buildServiceRegistry();20 sessionFactory = cfg.buildSessionFactory(serviceRegistry);21 } catch (Throwable ex) {22// Log exception!23throw new ExceptionInInitializerError(ex);24 }25 }2627public static Session getSession() throws HibernateException {28return sessionFactory.openSession();29 }3031public static Object save(Object obj){32 Session session = HibernateUtil.getSession();33 Transaction tx = null;34try {35 tx = session.beginTransaction();36 session.save(obj);37 mit();38 } catch (RuntimeException e) {39if (tx != null) {40 tx.rollback();41 }42throw e;43 } finally {44 session.close();45 }46return obj;47 }4849public static void delete(Class<?> clazz,String id){50 Session session = HibernateUtil.getSession();51 Transaction tx = null;52try {53 tx = session.beginTransaction();54 Object obj = session.get(clazz,id);55 session.delete(obj);56 mit();57 } catch (RuntimeException e) {58if (tx != null) {59 tx.rollback();60 }61throw e;62 } finally {63 session.close();64 }65 }66 }main1package a2_DynamicInsert_Update;2import a2_DynamicInsert_Update.Cat;3import daoUtil.HibernateUtil;45public class Test_DynamicInsert {67public static void main(String[] args) {8 Cat cat = new Cat();9 cat.setCat_name("test2@DynamicInsert");10 HibernateUtil.save(cat);11 }@DynamicInsert注解下Hibernate⽇志打印SQL:Hibernate: insert into Cat (cat_name, id) values (?, ?)反之Hibernate: insert into Cat (create_time, update_time, cat_name, id) values (?, ?, ?, ?)@DynamicUpdate写了个main程序测试:代码如下:数据库DML语句:insert into CAT (ID, CAT_NAME, CREATE_TIME, UPDATE_TIME)values ('8a6cc5a34c456829014c45682a860000', 'test@555', SYSDATE, SYSDATE);hibernate.cfg.xml 同上java类实体类,Dao 同上。
hibernate注解简介
@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
private Long id;
private String name;
@Id
@Column(name="PLANE_ID")
传统上,Hibernate的配置依赖于外部 XML 文件:数据库映射被定义为一组 XML 映射文件,并且在启动时进行加载。创建这些映射有很多方法,可以从已有数据库模式或Java类模型中自动创建,也可以手工创建。无论如何,您最终将获得大量的 Hibernate 映射文件。此外,还可以使用工具,通过javadoc样式的注释生成映射文件,尽管这样会给您的构建过程增加一个步骤。
...
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>3.2.1.ga</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
Hibernate 实体类 注解 大全
@Column(name="BIRTH",nullable="false",columnDefinition="DATE")
public String getBithday() {
return birthday;
}
7、@Transient
public User getUser() {
return user;
}
9、@JoinColumn
可选
@JoinColumn和@Column类似,介量描述的不是一个简单字段,而一一个关联字段,例如.描述一个@ManyToOne的字段.
name:该字段的名称.由于@JoinColumn描述的是一个关联字段,如ManyToOne,则默认的名称由其关联的实体决定.
catalog:可选,表示Catalog名称,默认为Catalog("").
schema:可选,表示Schema名称,默认为Schema("").
3、@id
必须
@id定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.置于getXxxx()前.
4、@GeneratedValue(strategy=GenerationType,generator="")
@Entity
//继承策略。另一个类继承本类,那么本类里的属性应用到另一个类中
@Inheritance(strategy = InheritanceType.JOINED )
@Table(name="INFOM_TESTRESULT")
public class TestResult extends IdEntity{}
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
说明:本文对hibernate的一对多、多对一、多对多的关联示例代码是Order类和OrderItem类的一对多的关系1.一对多1.1注解方式:@OneToMany 代码示例如下:双向关联,维护端在“多”的一端Public class Order implements Serializable {Private Set <OrderItem> orderItems = new HashSet<OrderItem>();@OneToMany(mappedBy="order"(有了mappedby不能也不该在此再定义@joincolumn),cascade = CascadeType.ALL, fetch = ZY)@OrderBy(value= "id ASC")public Set<OrderItem> getOrderItems() {return orderItems;}}单向关联,维护端在此端Public class Order implements Serializable {private Set<OrderItem> orderItems = new HashSet<OrderItem>();@OneToMany(cascade = CascadeType.ALL, fetch = ZY)@JoinColumn(name=”order_id”)@OrderBy(value= "id ASC")public Set<OrderItem> getOrderItems() {return orderItems;}}1.2维护端和级联问题维护端的意思是对外键进行维护,维护端有对外键进行插入和更新的权利。
下面分情况介绍hibernate的级联操作:1.2.1单向关联对“一”表进行插入一条记录的操作:1)级联类型:CascadeType.ALL执行语句:1.insert into category (description, name, id) values(?, ?, ?)如果在关联表中没有该记录,执行2.insert into product (descripton, name, price, id)values (?, ?, ?, ?)3.update product set category_id=? Where id=?同时对外键值进行了写入。
2)关联类型:CascadeType.PERSIST/MERGE执行语句:1.Insert into category (description, name, id) values(?, ?, ?)如果关联表中数据有更新,执行:2.update product set category_id=? Where id=?如果关联表中没有记录,则会报错。
1.2.2双向关联(维护端在“多”端)对“一”表进行插入一条记录的操作:1)级联类型:CascadeType.ALL执行语句:1.insert into category (description, name, id) values(?, ?, ?)如果关联表总没有该记录,执行2.insert into product(category_id, descripton, name, price, id) values(?, ?, ?, ?, ?)注意:关联表中的外键值为空,及外键由维护端进行维护。
2)关联类型:CascadeType.PERSIST/MERGE执行语句:insert into category (description, name, id) values (?, ?, ?)2.多对一2.1注解方式:@ManyToOne(cascade=CascadeType.REFRESH,optional=false)@JoinColumn(name = "order_id")例如:Public class OrderItem implements Serializable {private Order order;@ManyToOne (cascade=CascadeType.REFRESH,optional=false)@JoinColumn(name = "order_id")public Order getOrder() {return order;}}2.2维护端的级联问题“多端”维护外键,及对外键有更新插入的权利。
在面是在多端执行插入记录所执行的SQL语句。
2.2.1单向关联1)在“多”端插入一条记录,级联类型为CascadeType.ALL,执行的SQL语句为:A.当关联方记录存在:insert into product(category_id, descripton, name, price, id) values (?, ?, ?, ?, ?)如果“一”端有更新则执行:Update category set description=?,name=?Where id=?B.当关联方记录不存在:insert into category (description, name, id)values (?, ?, ?)insert into product(category_id, descripton, name, price, id) values(?, ?, ?, ?, ?)2)在“多”端插入一条记录,级联类型为CascadeType.PERSIST/MERGE/,执行SQL语句为:A.一端记录存在:insert into product(category_id, descripton, name, price, id) values (?, ?, ?, ?, ?)如果有更新则执行:Update category set description=?,name=? where id=?注意:更新“一”端主键会报错B.一端记录不存在:运行报错2.2.2双向关联(多端为维护端)1)在“多”端插入一条记录,级联类型为CascadeType.ALL/PERSIST/MERGE,执行SQL语句为:A关联端存在记录:insert into product (category_id, descripton, name, price, id) values (?, ?, ?, ?, ?) 如果“一”端的数据有更新Update category set description=?,name=? where id=?注意:更改“一”端主键会报错B关联端不存在记录:运行报错推荐博客:/liangoo7/article/details/8070211注意:在做关联的时候:单向关联无需维护端,双向关联则需要多的一端维护。
一对多:多对一:@ManyToOne(cascade=CascadeType.REFRESH,optional=false)@JoinColumn(name = "order_id")例如:Public class OrderItem implements Serializable {private Order order;。
@ManyToOne(cascade=CascadeType.REFRESH,optional=false)@JoinColumn(name = "order_id")public Order getOrder() {return order;}}多对多:/** @ManyToMany 注释表示Teacher 是多对多关系的一端。
* @JoinTable 描述了多对多关系的数据表关系,name属性指定中间表名称。
* joinColumns 定义中间表与Teacher 表的外键关系,中间表Teacher_Student的Teacher_ID 列是Teacher 表的主键列对应的外键列。
* inverseJoinColumns 属性定义了中间表与另外一端(Student)的外键关系。
*/@ManyToMany(cascade = CascadeType.PERSIST, fetch = ZY)@JoinTable(name = "Teacher_Student",joinColumns ={@JoinColumn(name = "teacher_ID", referencedColumnName = "teacherid") },inverseJoinColumns = { @JoinColumn(name = "student_ID", referencedColumnName = "studentid")})public Set<Student> getStudents() {return students;}相关属性:fatch可选择项包括:FetchType.EAGER和ZY。
前者表示关系类(本例是OrderItem 类)在主类(本例是Order类)加载的时候同时加载,后者表示关系类在被访问时才加载。
Cascade四个值:的值只能从CascadeType.PERSIST(级联新建)、CascadeType.REMOVE(级联删除)、CascadeType.REFRESH(级联刷新)、CascadeType.MERGE(级联更新)中选择一个或多个。
还有一个选择是使用CascadeType.ALL,表示选择全部四项。
@ManyToMany(book为维护端、category为被维护端)1)被维护端1.1被维护端插入一条记录,级联类型:CascadeType.ALL,执行语句:Hibernate:insertintocategory(description, name, id)values(?, ?, ?)Hibernate:insertintobook(author, price, id)values(?, ?, ?)1.2被维护端插入一条记录,级联类型:CascadeType.PERSIST/MERGE,执行语句:Hibernate:insertintocategory(description, name, id)values(?, ?, ?)2)2.1.维护端插入一条语句,级联类型:CascadeTye.ALL,执行语句:Hibernate:insertintobook(author, price, id)values(?, ?, ?)如果被维护端没有数据则执行以下数据。