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 异常。
数据层对象的注解
数据层对象的注解在软件开发中，数据层对象通常与数据库交互，用于表示数据库中的表结构。
在许多现代编程语言和框架中，使用注解（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_@注解和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-validator原理
hibernate-validator原理
Hibernate Validator是一种基于Java Bean Validation标准的数
据验证框架。
它使用注解为Java Bean提供验证规则，并提供了一组内置
验证注解和自定义验证注解的支持。
Hibernate Validator的工作原理如下：
1. 应用程序使用Hibernate Validator的API将Bean传递给它。
2. Hibernate Validator通过Java反射找到Bean上的验证注解，
并解析这些注解。
3. 解析后，Hibernate Validator使用规则引擎来验证Bean属性的
值是否满足其所需的验证规则。
4. 如果属性值不符合规则，Hibernate Validator会将验证错误信
息存储在一个集合中。
5.应用程序可以通过API访问此集合以获取验证错误信息并针对其进
行处理。
该框架还提供了MessageInterpolator和ConstraintValidator等实
用工具，以解决验证结果消息的本地化、格式化和自定义验证规则的问题。
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{}
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注解@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不仅能够定义⼀对多的关联，也可以定义多对多表的关联。
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")注解可以让编译器不再给出这个警告。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Hibernate4注解整理：QQ835822125一、准备工作在Hibernate中使用Annotation，跟以前xml配置的方式相比：1：仍然需要cfg.xml2：在cfg.xml中需要配置要通过注解来配置的类，例如：<mapping package="test.animals"/><mapping class="test.Flight"/>3：程序里面，原来的new Configuration()的地方，可以变成：new AnnotationConfiguration()，也可以不用改。
4：可以通过编程的方式来添加要映射的类，例如：new AnnotationConfiguration().addPackage("test.animals").addAnnotatedClass(Flight.class)二、Hibernate注解简介传统上，Hibernate的配置依赖于外部*.hbm.xml文件：数据库映射被定义为一组XML 映射文件，并且在启动时进行加载。
借助新的Hibernate Annotation 库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注解直接嵌入到您的Java 类中，并提供一种强大及灵活的方法来声明持久性映射。
籍由自动代码完成和语法突出显示功能，最近发布的Java IDE也为其提供了有力的支持。
Hibernate Annotation还支持新的EJB 3 持久性规范。
这些规范旨在提供一种标准化的Java 持久性机制。
由于Hibernate 3 还提供了一些扩展，因此您可以十分轻松地遵从这些标准，并使用EJB 3 编程模型来对Hibernate 持久层进行编码。
三、映射实体@Entity，注册在类头上，将一个类声明为一个实体bean(即一个持久化POJO类) 。
@Table，注册在类头上，注解声明了该实体bean映射指定的表table）。
四、映射属性—概述@Id用来注册主属性;@GeneratedValue用来注册主属性的生成策略;@Column用来注册属性;@Version用来注册乐观锁;@Transient用来注册不是属性。
以上的@Id、@GeneratedValue、@Column 、@Version，可以用来注册属性，既可以写在Java类的属性上，也可以注册在属性对应的getter上。
@Transient注册在多余的属性或多余的getter上，但是必须与以上的@Column等对应。
五、映射属性—非主属性@Column标识属性对应的字段，示例：@Column(name=“userName")@Column(1name="columnName"; (1)boolean unique() default false; (2)boolean nullable() default true; (3)boolean insertable() default true; (4)boolean updatable() default true; (5)String columnDefinition() default ""; (6)String table() default ""; (7)int length() default 255; (8)int precision() default 0; // decimal precision (9)int scale() default 0; // decimal scale (10)(1) name 可选,列名(默认值是属性名)(2) unique 可选,是否在该列上设置唯一约束(默认值false)(3) nullable 可选,是否设置该列的值可以为空(默认值false)(4) insertable 可选,该列是否作为生成的insert语句中的一个列(默认值true)(5) updatable 可选,该列是否作为生成的update语句中的一个列(默认值true)(6) columnDefinition 可选: 为这个特定列覆盖SQL DDL片段(这可能导致无法在不同数据库间移植)(7) table 可选,定义对应的表(默认为主表)(8) length 可选,列长度(默认值255)(8) precision 可选,列十进制精度(decimal precision)(默认值0)(10) scale 可选,如果列十进制数值范围(decimal scale)可用,在此设置(默认值0)六、映射属性—主属性@Id标识这个属性是实体类的唯一识别的值。
注意：这个注解只能标注单一列构成的主键，如tbl_grade那种有两个字段组成的联合主键由其他注解标识。
回忆*.hbm.xml：<id name="uuid"><generator class="assigned"/></id>@Id，只是标识这个属性是主键，但是并没有指出其生成策略，如上例中的assigned就是由程序员指定的生成策略。
如果仅仅写出@Id，即是使用assigned生成略，如：@Id@Columnprivate int uuid;如果想使用Oracle支持的sequence取主键，必须通过@GeneratedValue来指定生成策略，而由@SequenceGenerator指定如何使用sequence。
@Id@Column@GeneratedValue(strategy = GenerationType.SEQUENCE,//使用sequence生成主键generator =“generator“//引用下面名为gernator的生成策略)@SequenceGenerator(name = “generator”,//定义名为generator的生成策略allocationSize = 1，//每次sequence加1name=“seq_a”//引用名为seq_a的sequence)private int uuid;七、映射属性—乐观锁和不用持久化⏹@Version标识这个属性用来映射乐观锁的version⏹@Transient标识这个属性不用持久化八、八、映射属性—复合属性—组件映射⏹@Embeddable【小对象的头上】标识实体中可以定义一个嵌入式组件(embedded component)。
组件类必须在类一级定义@Embeddable注解。
⏹@Embedded【大对象的属性头上】引用定义的小对象九、映射属性—复合属性—复合主键⏹ @Embeddable【小对象的头上】标识实体中可以定义一个嵌入式组件(embedded component)。
组件类必须在类一级定义@Embeddable注解。
注意：如果这个小对象作为复合主键，一定要实现Serializable接口。
这并不是注解决定的，而是Hibernate的主键都需要实现Serializable接口。
⏹ @EmbeddedId 【大对象的属性头上】引用定义的小对象作为主键。
注意：不需要再使用@Id注解。
十、关联关系映射—简介在hibernate中，支持对象之间的关联关系映射，这样可以减少我们的dao操作，操作一个对象的时候，就可以顺带操作它的关联对象。
我们知道，hibernate支持三种关联关系，1:1，1:M，M:N。
但，这只是对象之间的关系。
数据库的设计当然也支持1:1，1:M，M:N三种关系。
比如，我们经常说的1:M，就是把1这张表的主键拿到多那边做外键。
但是，很多同学经常迷惑，为什么网上介绍的1:M，比我们讲的还要复杂的多？我们只需要<set>和<many-to-one>，但是网上介绍的还有一种使用<set>和<join>的？这里我们就不得不提出“数据库设计的降级使用”这个概念了。
十一、关联关系映射—数据库降级使用⏹ 标准的1:M⏹ 标准的M:N⏹ 将M: N 的数据库设计降级为1: M 使用十二、十二、关联关系映射—1:1—共享主键⏹ 标准的1:1⏹ XML 的配置主1【tbl_product 】：<one-to-one name="info" cascade="all"/> 从1【tbl_product_info 】： <id name="uuid"><generator class=“foreign 【写死，使用外来生成策略】"><param name=“property ”>product 【引用自己的Java 属性名】</param> </generator> </id><one-to-one name="product"/>tbl_parent uuid<PK>tbl_child uuid<PK> puuid<FK>tbl_student uuid<PK> tbl_grade suuid<PK><FK> cuuid<PK><FK>tbl_course cuuid<PK>tbl_parentuuid<PK>tbl_parent_child Puuid<PK><FK> Cuuid<PK><FK><UNIQUE> tbl_child uuid<PK>tbl_product uuid<PK> tbl_product_info uuid<PK><FK>⏹ 注解的配置主1【tbl_product 】：@OneToOne(cascade=CascadeType.ALL) @PrimaryKeyJoinColumnprivate ProductInfoModel info;从1【tbl_product_info 】： @Id@Column@GeneratedValue(genera tor=“copy 【引用生成策略】")@GenericGenerator(name=“copy 【定义生成策略】”,strategy=“foreign 【写死，使用外来策略】”,parameters=@Parameter(name=“property”,value=“product 【引用自己的Java 属性】"))@OneToOne(mappedBy=“info 【引用对方的Java 属性】") private ProductModel product;十三、关联关系映射—1:M —外键⏹ 标准的1:M⏹ XML 的配置1【tbl_parent 】：<set name="children"><key column=“puuid 【对方的数据库外键列名】"/><one-to-many class=“cn.javass.model.c.ChildModel 【对方的Java 类名】"/> </set>多【tbl_child 】：<many-to-one name=“parent ” column=“puuid 【自己的数据库外键列名】"/>十四、关联关系映射—1:M —外键⏹ 注解的配置1【tbl_parent 】： @OneToMany@JoinColumn(name="puuid 【对方的数据库外键列名】")private Set<ChildModel> children = new HashSet<ChildModel>();多【tbl_child 】： @ManyToOne@JoinColumn(name="puuid 【自己的数据库外键列名】")tbl_parent uuid<PK> tbl_child uuid<PK> puuid<FK>private ParentModel parent;十五、关联关系映射—M:N —联接表⏹ 标准的1:M⏹ XML 的配置<set name=“courses ” table=“tbl_grade 【联接表】"><key column=“suuid 【联接表里代表自己的数据库字段名】"/><many-to-many column=“cuuid 【联接表里代表对方的数据库字段名】” class=“cn.javass.model.e.CourseMode 【对方的类名】l "/> </set>⏹ 注解的配置@ManyToMany @JoinTable(name=“tbl_grade 【联接表】",joinColumns=@JoinColumn(name="suuid 【联接表里代表自己的数据库字段名】"), inverseJoinColumns=@JoinColumn(name="cuuid 【联接表里代表对方的数据库字段名】” ))private Set<CourseModel> courses = new HashSet<CourseModel>();十六、关联关系映射—1:1—引用外键⏹ 标准的1:M⏹ XML 的配置主1【tbl_product 】： <one-to-one name=info foreign-key=puuid 【对方的数据库外键列名】" cascade ="all"/>从1【tbl_product_info 】： <many-to-one name=product column=puuid【自己的数据库外键列名】unique=true 【写死】"/>tbl_student uuid<PK> tbl_grade suuid<PK><FK> cuuid<PK><FK>tbl_course cuuid<PK>tbl_product uuid<PK> tbl_product_info uuid<PK>puuid<FK><UNIQUE>⏹ 注解的配置主1【tbl_product 】：@OneToOne(cascade=CascadeType.ALL,mappedBy=product 【对方的Java 类属 性名】")private ProductInfoModel info;从1【tbl_product_info 】： @OneToOne@JoinColumn(name=“puuid 【自己的数据库外键列名】") private ProductModel product;十七、关联关系映射—1:M —联接表⏹ 标准的1:M⏹ XML 的配置1【tbl_parent 】：<set name=children table=tbl_parent_child 【联接表】"> <key column=puuid 【联接表里代表自己的数据库列名】"/><many-to-many column=cuuid 【联接表里代表对方的数据库列名】 unique=true 【写死】class=cn.javass.model.d.ChildModel 【对方的Java 类名】"/></set><join table=tbl_parent_child 【联接表】"><key column="cuuid 【联接表里代表自己的数据库列名】"/><many-to-one name="parent" column="puuid 【联接表里代表对方的数据库列名】" unique="true 【写死】"/></join>⏹ 注解的配置1【tbl_parent 】：@OneToMany(mappedBy="parent 【对方的Java 类属性名】")private Set<ChildModel> children = new HashSet<ChildModel>();多【tbl_child 】： @ManyToOne @JoinTable(name=“tbl_parent_child 【联接表】",joinColumns=@JoinColumn(name="cuuid 【联接表里代表自己的数据库字段名】"), inverseJoinColumns=@JoinColumn(name="puuid 【联接表里代表对方的数据库字段tbl_parent uuid<PK> tbl_parent_child puuid<PK><FK>cuuid<PK><FK><UNIQUE>tbl_child uuid<PK>名】"))private ParentModel parent;十八、 关联关系映射—1:1—联接表⏹ 标准的1:M⏹ XML 的配置1【tbl_product 】：<join table=tbl_product_relation 【联接表】"><key column=puuid 【联接表里代表自己的列名】"/> <many-to-one name=course 【自己的Java 属性名】column=cuuid 【联接表里代表对方的列名】unique=true 【写死】"/></join>⏹ 注解的配置1【tbl_product 】： @ManyToOne @JoinTable(name=" tbl_product_relation 【联接表】",joinColumns=@JoinColumn(name="suuid 【联接表里代表自己的列名】"),inverseJoinColumns=@JoinColumn(name="cuuid 【联接表里代表对方的列名】",unique=true 【写死】))private CourseModel course;十九、 二级缓存⏹ @Cache 示例定义在实体类上，示例如下： @Entity@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE) public class Forest { ... }二十、 各注解用法1. @TableTable 用来定义entity 主表的name ，catalog ，schema 等属性。