hibernate注解配置
hibernate配置
目录
1 Hibernate概述 2 第一个Hibernate程序 3 Hibernate的配置文件 4 深入理解持久化对象 5 Hibernate的映射文件 6持久化对象 如果PO 实例与Session实例关联起来，且该实例关联到数据库的记录
脱管对象 如果PO实例曾经与Session实例关联过，但是因为Session的关闭等原 因，PO实例脱离了Session 的管理
Hibernate全面解决方案架构解释
事务(Transaction) 代表一次原子操作，它具有数据库事务的概念 但它通过抽象，将应用程序从底层的具体的JDBC、JTA和CORBA 事务中隔离开。 一个Session 之内可能包含多个Transaction对象。 所有的持久化操作都应该在事务管理下进行，即使是只读操作。
管态，对该对象操作无须锁定数据库，不会造成性能的下降。
持久化对象的状态迁移
持久化实体： 1、Serializable save(object obj) 将对象变为持久化状态 2、void persist(object obj) 将对象转化为持久化状态 3、Serializable save(object obj,object pk) 将obj对象转化为持久化状态，该对象保存到数据库，指定主键值 4、void persist(object obj,object pk) 也加了一个设定主键
Hibernate工作原理
Configuration cfg = new Configuration().configure();
开始
启动hibernate
构建Configuration 实例，初始 化该实例中的所有变量
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互斥。
详解hibernatemapping配置
详解hibernatemapping配置详解 hibernate mapping配置每个hibernate只会启动的时候引⼊⼀个⽂件，那就是：hibernate.cfg.xmlmapping需要我们在hibernate中引⼊，<mapping resource="com/hibernate/test/hibernate_IP.xml"/><mapping class="com.hibernate.test.Student"/>代码⽚段:<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.hibernate.test"><class name="IP_List" table="IP_LIST"><id name="ip" column="Ip"><generator class="native"></generator></id><property name="Status" column="Status"></property></class></hibernate-mapping>class标签对应的name为Java实体类 table为表名；id为主键主键⾃增策略：<generator class="native"></generator> native会根据不同数据库采取不同的⾃增策略<property>标签对应数据库中的字段 columnpackage com.hibernate.test;import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name="Student")public class Student {private int id;private String name;/*** id** @return the id* @since CodingExample Ver(编码范例查看) 1.0*/@Id@GeneratedValuepublic int getId() {return id;}/**** @param id* the id to set*/public void setId(int id) {this.id = id;}/*** name** @return the name* @since CodingExample Ver(编码范例查看) 1.0*/@Column(name="name")public String getName() {return name;}/**** @param name* the name to set*/public void setName(String name) { = name;}}实体类添加注解：@Entity 对应的表为@Table主键为@ID ⾃增策略配置：@GeneratedValue@Column 注解对应为数据库中的字段感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。
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:⽤于双向关联时使⽤，否则会引起数据不⼀致的问题。
hibernate配置文件说明
create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行。会导致数据库表数据丢失。
create-drop: 每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。
（2）hibernate.show_sql打印所有的SQL语句到控制台，可以通过设置org.hibernate.SQL类的日志策略到DEBUG级，实现同样的效果。取值 true|false。
（3）hibernate.format_sql 格式化SQL语句在打印到控制台或写入日志文件时。取值true|false。
hibernate.cache.provider_class=org.hibernate.cache.SingletonEhCacheProvider
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
# 二级缓存配置文件
#Batch Size越大，批量操作的向数据库发送sql的次数越少，速度就越快。
hibernate.jdbc.batch_size=50
#设置外连接抓取树的最大深度取值. 建议设置为0到3之间
#hibernate.max_fetch_depth
#是否显示最终执行的SQL(开发环境)
hibernate.show_sql=false
# 格式化显示的SQL
hibernate.format_sql=false
# 如果设置为true，Hiberante将为SQL产生注释，这样更利于调试。默认值为false。取值为true|false。
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 );
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(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>
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{}
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
* @GenericGenerator(name = "paymentableGenerator", strategy = "seqhilo",
* strategy 指定生成的策略（JPA定义的），这是一个GenerationType。默认是GenerationType. AUTO
* GenerationType.AUTO 主键由程序控制
* GenerationType.TABLE 使用一个特定的数据库表格来保存主键
* parameters = { @Parameter(name = "sequence", value = "seq_payablemoney") })
* 8.seqhilo 通过hilo算法实现，但是主键历史保存在Sequence中，适用于支持Sequence的数据库，如Orcale(比较少用）
* GenerationType.IDENTITY 主键由数据库自动生成（主要是自动增长类型）
* GenerationType.SEQUENCE 根据底层数据库的序列来生成主键，条件是数据库支持序列。（这个值要与generator一起使用）
* generator 指定生成主键使用的生成器（可能是orcale中的序列）。
* 2.uuid 采用128位的uuid算法生成主键，uuid被编码为一个32位16进制数字的字符串。占用空间大（字符串类型）。
* 例：@GeneratedValue(generator = "paymentableGenerator")
* @SequenceGenerator —— 注解声明了一个数据库序列。该注解有如下属性
* name 表示该表主键生成策略名称，它被引用在@GeneratedValue中设置的“gernerator”值中
* sequenceName 表示生成策略用到的数据库序列名称。
* updatable 可选，该列是否作为生成的update语句中的一个列（默认值true）
* columnDefinition 可选，为这个特定列覆盖sql ddl片段（这可能导致无法在不同数据库间移植）
* table 可选，定义对应的表（默认为主表）
* 4.assigned 在插入数据的时候主键由程序处理（很常用），这是<generator>元素没有指定时的默认生成策略。等同于JPA中的AUTO。
* 例：@GeneratedValue(generator = "paymentableGenerator")
* name 可选，列名（默认值是属性名）
* unique 可选，是否在该列上设置唯一约束（默认值false）
* nullable 可选，是否设置该列的值可以为空（默认值false）
* insertable 可选，该列是否作为生成的insert语句中的一个列（默认值true）
* 7.sequence 调用谨慎数据库的序列来生成主键，要设定序列名，不然hibernate无法找到。
* 例：@GeneratedValue(generator = "paymentableGenerator")
* @GenericGenerator(name = "paymentableGenerator", strategy = "sequence",
* 例：@GeneratedValue(generator = "paymentableGenerator")
* @GenericGenerator(name = "paymentableGenerator", strategy = "increnment")
* name 指定生成器名称
* strategy 指定具体生成器的类名（指定生成策略）。
* parameters 得到strategy指定的具体生成器所用到的参数。
* 其十三种策略（strategy属性的值）如下：
* 1.native 对于orcale采用Sequence方式，对于MySQL和SQL Server采用identity(处境主键生成机制)，
* @GenericGenerator(name = "paymentableGenerator", strategy = "uuid.hex")
* 13.sequence-identity sequence策略的扩展，采用立即检索策略来获取sequence值，需要JDBC3.0和JDK4以上（含1.4）版本
* parameters = { @Parameter(name = "max_lo", value = "5") })
* 9.increnment 插入数据的时候hibernate会给主键添加一个自增的主键，但是一个hibernate实例就维护一个计数器，所以在多个实例运行的时候不能使用这个方法。
* 例：@GeneratedValue(generator = "paymentableGenerator")
* @GenericGenerator(name = "paymentableGenerator", strategy = "hilo")
* @GenericGenerator(name = "paymentableGenerator", strategy = "assigned")
* 5.identity 使用SQL Server和MySQL的自增字段，这个方法不能放到Oracle中，Oracle不支持自增字段，要设定sequence(MySQL和SQL Server中很常用)。等同于JPA中的IDENTITY
* 例：@GeneratedValue(generator = "paymentableGenerator")
* @GenericGenerator(name = "paymentableGenerator", strategy = "identity")
* @GenericGenerator(name = "paymentableGenerator", strategy = "uuid")
* 3.hilo 要在数据库中建立一张额外的表，默认表名为hibernate_unque_key，默认字段为integer类型，名称是next_hi（比较少用）
/**
*
* @author liuguangyi
* @content ejb3注解的API定义在javax.persistence.*包里面。
*
* 注释说明：
* @Entity —— 将一个类声明为一个实体bean(即一个持久化POJO类)
* parameters = { @Parameter(name = "property", value = "info") })
* Integer id;
* @OneToOne
* EmployeeInfo info;
* 6.select 使用触发器生成主键（主要用于早期的数据库主键生成机制，少用）
* 例：@GeneratedValue(generator = "paymentableGenerator")
* @GenericGenerator(name = "paymentableGenerator", strategy = "select")
* initialValue 表示主键初始值，默认为0.
* allocationSize 每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50.
* @GenericGenerator —— 注解声明了一个hibernate的主键生成策略。支持十三种策略。该注解有如下属性
* @GenericGenerator(name = "paymentableGenerator", strategy = "guid")
* 12.uuid.hex 看uudi,建议用uuid替换
* 例：@GeneratedValue(generator = "paymentableGenerator")
* @Id —— 注解声明了该实体bean的标识属性（对应表中的主键）。
* @Table —— 注解声明了该实体bean映射指定的表（table）,目录（catalog）和schema的名字
* @Column —— 注解声明了属性到列的映射。该注解有如下的属性
* 10.foreign 使用另一个相关的对象的主键。通常和<one-to-one>联合起来使用。
* 例：@Id
* @GeneratedValue(generator = "idGenerator")
* @GenericGenerator(name = "idGenerator", strategy = "foreign",
* length 可选，列长度（默认值255）
* precision 可选，列十进制精度（decimal precision)(默认值0）
* scale 可选，如果列十进制数值范围（decimal scale）可用，在此设置（默认值0）