hibernate注解
Hibernate注解中CascadeType用法汇总
Hibernate注解中CascadeType用法汇总在Hibernate中,CascadeType注解用来配置实体之间的级联操作。
级联操作是指在对一个实体进行持久化、更新、删除等操作时,同时也对关联的其他实体进行相应的操作。
CascadeType注解常用于一对一、一对多、多对多等关联关系中。
CascadeType注解的常用取值有以下几种:1. CascadeType.ALL:表示所有的级联操作,包括持久化、更新、删除等。
2. CascadeType.PERSIST:表示级联持久化操作,即当实体被持久化时,关联的其他实体也会被持久化。
3. CascadeType.MERGE:表示级联更新操作,即当实体被更新时,关联的其他实体也会被更新。
4. CascadeType.REMOVE:表示级联删除操作,即当实体被删除时,关联的其他实体也会被删除。
5. CascadeType.REFRESH:表示级联刷新操作,即当实体被刷新时,关联的其他实体也会被刷新。
6. CascadeType.DETACH:表示级联脱管操作,即当实体脱管时,关联的其他实体也会被脱管。
7. CascadeType.ALL_DELETE_ORPHAN:表示级联删除操作,并且会删除所有孤儿实体。
下面是对CascadeType注解的使用方法进行汇总:1.一对一关联关系:```private Address address;```上述代码表示当保存、更新或删除一个实体对象时,操作对应的address实体也会被保存、更新或删除。
2.一对多关联关系:```private List<Order> orders;```上述代码表示当保存、更新或删除一个用户对象时,操作对应的所有订单对象也会被保存、更新或删除。
3.多对多关联关系:```private List<Role> roles;```上述代码表示当保存、更新或删除一个用户对象时,操作对应的所有角色对象也会被保存、更新或删除。
Hibernate入门之注解@Enumerated详解
Hibernate⼊门之注解@Enumerated详解前⾔我们知道对于枚举既可以存储字符串也可以存储数字,那我们看看在JPA中到底应该如何正确的配置呢,⽂中若有错误之处,还望指正。
@Enumerated注解在JPA中,必须⽤@Enumerated注解标记Enum类型,配置枚举类型有ORDINAL和STRING两种。
接下来我们定义⼀个Order对象,如下:@Entity@Table(name = "orders")public class Order {@Id@GeneratedValuepublic long id;@Enumeratedprivate Status status;}此时将映射为int类型,这也是默认映射的类型即ORDINAL,将枚举映射到表中的列类型为tinyint、enum应该是我们常见的⽅案,接下来我们来看看映射为varchar,如下:@Entity@Table(name = "orders")public class Order {@Id@GeneratedValuepublic long id;@Enumerated(EnumType.STRING)@Column(length = 8)private Status status;}如我们预期的结果,枚举类型为String表⽰来填充关联的数据库列值,对于我们开发⼈员⽽⾔,此列虽可读性强,但是明显将占⽤⼤量的空间,在这种情况下,状态列占⽤8个字节,如果我们要存储1亿条记录,仅status列将占⽤800 MB,所以我们都不会将枚举类型映射为varchar。
我们可以将java中的枚举类型映射为数据库表中的列映射为enum,进⾏如下配置:@Enumerated(EnumType.STRING)@Column(columnDefinition = "enum('PENDING','SUCCESS', 'FAILED', 'CANCEL', 'CLOSED')")private Status status;将枚举类型映射为enum在⽹上存在较⼤的争议,这不是我们关注的点,其实我们也可以映射为tinyint、smallint类型,不过对于枚举类型利⽤tinyint已⾜够,我们进⾏如下配置:@Enumerated@Column(columnDefinition = "tinyint")private Status status;我个⼈认为将枚举映射为tinyint是最合适的,因为它效率更⾼,但可读性却不强,我们并不知道具体数字代表什么含义,对开发⼈员并不友好,其实在这种情况下,我们完全可以再创建⼀个表对状态的描述。
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注解之@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:⽤于双向关联时使⽤,否则会引起数据不⼀致的问题。
数据层对象的注解
数据层对象的注解在软件开发中,数据层对象通常与数据库交互,用于表示数据库中的表结构。
在许多现代编程语言和框架中,使用注解(Annotation)是一种常见的方式来为数据层对象添加元数据信息,这些元数据信息可以用于配置对象的行为、映射数据库表、进行验证等。
以下是几个常见的数据层对象注解的例子:1. Java 中的JPA 注解(Java Persistence API):在Java 中,使用JPA 注解可以将Java 对象映射到数据库表。
以下是一些常见的JPA 注解:```java@Entity@Table(name = "employee")public class Employee {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;@Column(name = "first_name")private String firstName;@Column(name = "last_name")private String lastName;// 其他属性和方法}```- `@Entity`: 用于指示该类是一个JPA 实体,将被持久化到数据库。
- `@Table`: 指定数据库表的名称。
- `@Id`: 标识该属性为主键。
- `@GeneratedValue`: 指定主键的生成策略。
- `@Column`: 映射属性与数据库表列的关系。
2. Hibernate Validator 注解:在Java 中,Hibernate Validator 是一种用于验证对象的框架,它使用注解来定义验证规则。
以下是一些Hibernate Validator 注解的例子:```javapublic class Person {@NotNull@Size(min = 2, max = 50)private String name;@Emailprivate String email;// 其他属性和方法}```- `@NotNull`: 表示被注解的元素不能为null。
manytoone注解
manytoone注解在Java开发中,我们经常会遇到需要处理多对一关系的情况。
为了简化开发过程,Hibernate框架提供了一个非常有用的注解——@ManyToOne。
这个注解可以帮助我们轻松地处理多对一关系,使得代码更加简洁和易于维护。
@ManyToOne注解的作用是将一个实体类与另一个实体类建立多对一的关系。
在数据库中,这种关系通常通过外键来实现。
通过使用@ManyToOne注解,我们可以在实体类中指定多对一关系的属性,并且告诉Hibernate框架如何映射到数据库中。
在使用@ManyToOne注解时,我们需要注意一些细节。
首先,我们需要在多对一关系的属性上添加@ManyToOne注解。
这个注解需要指定一个targetEntity属性,用于指定关联的实体类。
例如,如果我们有一个Order实体类和一个Customer实体类,我们可以在Order实体类中的customer属性上添加@ManyToOne注解,并指定targetEntity属性为Customer.class。
其次,我们需要在多对一关系的属性上添加@JoinColumn注解。
这个注解用于指定外键的名称和其他相关属性。
例如,我们可以使用@JoinColumn注解来指定外键的名称、是否可为空、是否唯一等。
除了@ManyToOne注解,Hibernate还提供了其他一些注解来帮助我们处理多对一关系。
例如,@JoinColumn注解可以用于指定外键的名称和其他相关属性。
@Fetch注解可以用于指定关联实体的加载策略。
@Cascade注解可以用于指定级联操作的行为。
使用@ManyToOne注解可以使我们的代码更加简洁和易于维护。
通过使用这个注解,我们可以将多对一关系的处理逻辑集中在实体类中,而不是分散在各个地方。
这样一来,我们可以更加方便地修改和扩展代码。
然而,尽管@ManyToOne注解非常有用,但我们在使用它时还是需要注意一些问题。
首先,我们需要确保多对一关系的属性在数据库中有对应的外键。
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注解
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注释大全
)
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 );
Hibernate基础知识详解
Hibernate基础知识详解<hibernate-mapping><class name="*.*.*" table="t_customer" catalog="***"><id name="id" column="c_id"><generator class="identity"/></id><property name="name" column="c_name" length="20"/><set name="orders" inverse="false" cascade="save-update"><key column="c_customer_id"/></set></class></hibernate-mapping>(1)统⼀声明包名,这样在<class>中就不需要写类的全名。
(2)关于<class>标签配置name 属性:类的全名称table 表的名称,可以省略,这时表的名称就与类名⼀致catalog 属性:数据库名称可以省略.如果省略,参考核⼼配置⽂件中 url 路径中的库名称(3)关于<id>标签,<id>是⽤于建⽴类中的属性与表中的主键映射。
name 类中的属性名称column 表中的主键名称 column 它也可以省略,这时列名就与类中属性名称⼀致length 字段长度type 属性指定类型<generator>它主要是描述主键⽣成策略。
idea中annotations
idea中annotationsIdea中Annotations在软件开发中,注解(Annotations)是一种用于为代码提供额外信息的工具。
它们可以用于各种目的,如给代码添加元数据、配置和生成文档等。
在本文中,我们将介绍一些常见的注解类型和它们的用途。
1. @Override:这是一个非常常见的注解,它用于告诉编译器某个方法是被重写的。
当我们在子类中重写父类的方法时,使用这个注解可以确保我们的重写是正确的,如果父类中并没有这个方法,编译器会报错。
2. @Deprecated:这个注解用于标记一个已经过时的方法或类。
当我们调用被标记为过时的方法时,编译器会给出警告,建议我们使用替代方法。
3. @SuppressWarnings:有时候我们会在代码中使用一些不符合规范的方法或变量,这个注解可以用来抑制编译器的警告信息。
比如,我们可能会使用未检查的类型转换,或者使用已经被弃用的方法,这时使用@SuppressWarnings注解可以让编译器不再给出警告。
4. @FunctionalInterface:这个注解用于标记一个接口是一个函数式接口,即只包含一个抽象方法的接口。
在Java 8之后,函数式接口可以使用Lambda表达式来创建实例,这个注解可以确保接口的设计符合函数式编程的要求。
5. @NonNull:在很多情况下,我们会希望某个参数或返回值不能为空。
使用@NonNull注解可以告诉编译器,如果参数或返回值为空,应该给出警告。
6. @Nullable:与@NonNull相反,@Nullable注解表示某个参数或返回值可以为空。
使用这个注解可以帮助我们更好地理解代码的含义,并减少潜在的空指针异常。
7. @SuppressWarnings("unchecked"):这个注解用于抑制未经检查的警告。
在使用泛型时,如果我们使用了未经检查的转换操作,编译器会给出警告。
使用@SuppressWarnings("unchecked")注解可以让编译器不再给出这个警告。
creationtimestamp注解
creationtimestamp注解CreationTimestamp注解是Hibernate框架中的一个注解,它用于指定实体类中的时间戳字段。
该注解可以自动将当前时间戳赋值给指定的字段,从而方便地记录实体类的创建时间。
使用CreationTimestamp注解的步骤如下:1. 在实体类中定义一个时间戳字段,例如:```@Column(name = "create_time")@CreationTimestampprivate Timestamp createTime;```2. 在该字段上添加CreationTimestamp注解,指定该字段为时间戳字段。
3. 在Hibernate配置文件中启用自动更新时间戳功能,例如:```<property name="hibernate.ejb.interceptor"value="org.hibernate.interceptor.EntityInterceptor" />```4. 在保存实体类时,Hibernate会自动将当前时间戳赋值给createTime字段。
使用CreationTimestamp注解可以方便地记录实体类的创建时间,避免手动设置时间戳的麻烦。
同时,该注解还可以与其他注解一起使用,例如@Temporal注解,指定时间戳字段的数据类型。
需要注意的是,CreationTimestamp注解只能用于实体类中的时间戳字段,不能用于其他类型的字段。
此外,该注解只能在Hibernate框架中使用,不能在其他ORM框架中使用。
总之,CreationTimestamp注解是Hibernate框架中非常实用的一个注解,可以方便地记录实体类的创建时间,提高开发效率。
在实际开发中,我们可以根据需要灵活使用该注解,从而更好地完成项目开发任务。
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,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>
hibernatevalidator参数校验自定义校验注解
hibernatevalidator参数校验⾃定义校验注解参数校验:简单的就逐个⼿动写代码校验,推荐⽤Valid,使⽤hibernate-validator提供的,如果参数不能通过校验,报400错误,请求格式不正确:步骤1:在参数对象的属性上添加校验注解如@NotBlank步骤2:⽤@Valid注解controller⽅法的参数对象常⽤校验注解(通过注解的message属性⾃定义校验错误的信息):@NotNull值不能为空@Null值必须为空@Pattern(regx=)字符串必须匹配正则表达式@Size(min=,max=)集合元素数量必须在min和max之间@CreditCardNumber(ignoreNonDigitCharacters=)字符串必须是信⽤卡号(按美国的标准校验)@Email字符串必须是email地址@Length(min=,max=)字符串长度@NotBlank字符串必须有字符@NotEmpty字符串不为null,集合有元素@Range(min=,max=)数字范围@SafeHtml字符串必须是安全的html@URL字符串是合法的URL@AssertFalse值必须是false@AssertTrue值必须是true@DecimalMax(value=,inclusive=)值必须⼩于等于(inclusive=true)/⼩于(inclusive=false)value指定的值,可以注解在字符串类型属性上@DecimalMin(value=,inclusive=)值必须⼤于等于(inclusive=true)/⼤于(inclusive=false)value指定的值,可以注解在字符串类型属性上@Digits(integer=,fraction=)数字格式检查,integer指定整数部分最⼤长度,fraction指定⼩数部分最⼤长度@Future值必须是未来的⽇期@Past值必须是过去的⽇期@Max(value=)值必须⼩于等于value指定的值,不能注解在字符串类型属性上@Min(value=)值必须⼤于等于value指定的值,不能注解在字符串类型属性上当参数校验未通过,controller不会进⼊,某些场景,如参数校验出错,需要记录业务⽇志,可在controller⽅法添加BindingResult参数,即可携带错误信息进⼊controller⽅法BindingResult对象封装了参数校验的错误信息,其hasErrors⽅法表⽰有错误,使⽤getAllErrors然后stream流化遍历获取单条错误信息(错误信息可以定制):例如:import lombok.Data;import javax.validation.constraints.NotBlank;@Datapublic class User {@NotBlank(message="⽤户名不能为空")private String username;}@GetMapping("/user")public User user(@Valid User user,BindingResult errors) {if(errors.hasErrors()) {errors.getAllErrors().stream().forEach(// error -> System.out.println(error.getDefaultMessage())error -> {FieldError fieldError = (FieldError)error; //Error是Object类型,转换成FieldError可以获取校验错误的属性字段System.out.println(fieldError.getField() +" : "+ error.getDefaultMessage());});}return user;}复杂的业务场景⽐如校验传⼊的username是否已经在数据库中存在,需要⾃定义校验逻辑,步骤(其实就是⾃定义校验注解及其校验逻辑):1.写校验类2.写校验注解3.在属性上使⽤(使⽤同系统提供的注解如@NotNull)校验类:package com.example.security.valid;import javax.validation.ConstraintValidator;import javax.validation.ConstraintValidatorContext;/*** ⾃定义校验类,实现ConstraintValidator接⼝,两个泛型分别是⾃定义的校验注解MyConstraint和注解⽣效的属性类型* Object可以放在任何类型的属性上,String只能校验String类型的属性,如此* initialize⽅法是校验器初始化执⾏,isValid是校验逻辑,value是属性值,context校验上下⽂,⾥⾯包含校验注解⾥⾯的信息* 返回true校验通过,false校验失败,是javax.validation包提供的** 该类⾥⾯可以通过@Autowire注⼊spring管理的bean。
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{}
hibernate注解@JoinTable说明
hibernate注解@JoinTable说明
表关联(@JoinTable)注解说明:
@Target({METHOD, FIELD})
public @interface JoinTable{
String name() default "";
String catalog() default "";
String schema() default "";
JoinColumn[] joinColumns() default {};
JoinColumn[] inverseJoinColumns() default {};
UniqueConstraint[] uniqueConstraints default {};
}
# name属性为连接两个表的表名称。
若不指定,则使⽤默认的表名称,格式如下:
"表名1" + "_" + "表名2"
# joinColumn属性表⽰,在保存关系的表中,所保存关联关系的外键的字段,并配合@JoinColumn标记使⽤;
# inverseJoinColumn属性与joinColumn类似,它保存的是保存关系的另外⼀个外键字段;
# catalog和schema属性表⽰实体指定点⽬录名称或数据库名称;
# uniqueConstraints属性表⽰该实体所关联的唯⼀约束条件,⼀个实体可以有多个唯⼀约束条件,默认没有约束;注意:@JoinTable不仅能够定义⼀对多的关联,也可以定义多对多表的关联。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
使用: Hibernate ;始于: EJB; API: javax.persistence.*Document file and example: Hibernate, JBoss etc.一、实体 Bean每个持久化POJO类都是一个实体Bean, 通过在类的定义中使用@Entity 注解来进行声明。
声明实体Bean@Entitypublic class Flight implements Serializable {Long id;@Idpublic Long getId() { return id; }public void setId(Long id) { this.id = id; }}@Entity注解将一个类声明为实体 Bean, @Id 注解声明了该实体Bean的标识属性。
Hibernate 可以对类的属性或者方法进行注解。
属性对应field类别,方法的getXxx()对应property类别。
定义表通过@Table 为实体Bean指定对应数据库表,目录和schema的名字。
@Entity@Table(name="tbl_sky")public class Sky implements Serializable {...@Table 注解包含一个schema和一个catelog 属性,使用@UniqueConstraints 可以定义表的唯一约束。
@Table(name="tbl_sky",uniqueConstraints = {@UniqueConstraint(columnNames={"month", "day"})} )上述代码在 "month" 和 "day" 两个 field 上加上 unique constrainst.@Version 注解用于支持乐观锁版本控制。
@Entitypublic class Flight implements Serializable {...@Version@Column(name="OPTLOCK")public Integer getVersion() { ... }}version属性映射到 "OPTLOCK" 列,entity manager 使用这个字段来检测冲突。
一般可以用数字或者 timestamp 类型来支持 version.实体Bean中所有非static 非 transient 属性都可以被持久化,除非用@Transient注解。
默认情况下,所有属性都用@Basic 注解。
public transient int counter; //transient propertyprivate String firstname; //persistent property@TransientString getLengthInMeter() { ... } //transient propertyString getName() {... } // persistent property@Basicint getLength() { ... } // persistent property@Basic(fetch = ZY)String getDetailedComment() { ... } // persistent property@Temporal(TemporalType.TIME)java.util.Date getDepartureTime() { ... } // persistent property@Enumerated(EnumType.STRING)Starred getNote() { ... } //enum persisted as String in database上述代码中 counter, lengthInMeter 属性将忽略不被持久化,而 firstname, name, length 被定义为可持久化和可获取的。
@TemporalType.(DATE,TIME,TIMESTAMP)分别Map java.sql.(Date, Time, Timestamp).@Lob注解属性将被持久化为 Blog 或 Clob 类型。
具体的java.sql.Clob, Character[], char[] 和 ng.String 将被持久化为 Clob 类型. java.sql.Blob, Byte[], byte[] 和 serializable type 将被持久化为 Blob 类型。
@Lobpublic String getFullText() {return fullText; // clob type}@Lobpublic byte[] getFullCode() {return fullCode; // blog type}@Column 注解将属性映射到列。
@Entitypublic class Flight implements Serializable {...@Column(updatable = false, name = "flight_name", nullable = false, length=50)public String getName() { ... }定义 name 属性映射到 flight_name column, not null, can't update, length equal 50@Column(name="columnName"; (1) 列名boolean unique() default false; (2) 是否在该列上设置唯一约束boolean nullable() default true; (3) 列可空?boolean insertable() default true; (4) 该列是否作为生成 insert语句的一个列boolean updatable() default true; (5) 该列是否作为生成 update语句的一个列String columnDefinition() default ""; (6) 默认值String table() default ""; (7) 定义对应的表(deault 是主表)int length() default 255; (8) 列长度int precision() default 0; // decimal precision (9) decimal精度int scale() default 0; // decimal scale (10) decimal长度嵌入式对象(又称组件)也就是别的对象定义的属性组件类必须在类一级定义@Embeddable 注解。
在特定的实体关联属性上使用@Embeddable 和 @AttributeOverride 注解可以覆盖该属性对应的嵌入式对象的列映射。
@Entitypublic class Person implements Serializable {// Persistent component using defaultsAddress homeAddress;@Embedded@AttributeOverrides( {@AttributeOverride(name="iso2", column =@Column(name="bornIso2") ),@AttributeOverride(name="name", column =@Column(name="bornCountryName") )} )Country bornIn;...}@Embeddablepublic class Address implements Serializable {String city;Country nationality; //no overriding here}@Embeddablepublic class Country implements Serializable {private String iso2;@Column(name="countryName") private String name;public String getIso2() { return iso2; }public void setIso2(String iso2) { this.iso2 = iso2; }public String getName() { return name; }public void setName(String name) { = name; }...}Person 类定义了 Address 和 Country 对象,具体两个类实现见上。
无注解属性默认值:• 属性为简单类型,则映射为 @Basic• 属性对应的类型定义了 @Embeddable 注解,则映射为 @Embedded• 属性对应的类型实现了Serializable,则属性被映射为@Basic并在一个列中保存该对象的serialized版本。
• 属性的类型为 java.sql.Clob or java.sql.Blob, 则映射到 @Lob 对应的类型。
映射主键属性@Id 注解可将实体Bean中某个属性定义为主键,使用@GenerateValue注解可以定义该标识符的生成策略。
• AUTO - 可以是 identity column, sequence 或者 table 类型,取决于不同底层的数据库• TABLE - 使用table保存id值• IDENTITY - identity column• SEQUENCE - sequence@Id @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="SEQ_STORE")public Integer getId() { ... }@Id @GeneratedValue(strategy=GenerationType.IDENTITY)public Long getId() { ... }AUTO 生成器,适用与可移值的应用,多个@Id可以共享同一个 identifier生成器,只要把generator属性设成相同的值就可以。