Hibernate自动生成实体类注解

⽤MyEclipse⾃动⽣成hibernate映射⽂件和实体类
建web⼯程，使⽤Hibernate的时候，在⼯程⾥⼀个⼀个创建实体类和映射⽂件太⿇烦，特别是⼤项⽬，好⼏百张表，每个表跟每个表的对应关系很负责，⼀张表中可能有超级多的字段，浪费时间，还容易出错！
创建完成后还要将⼀个个的映射⽂件配置到hibernate.cfg.xml中，稍微疏忽就会出错！
现在教⼤家如何⽤MyEclipse⾃动⽣成Hibernate映射⽂件及实体类
感叹⼀句MyEclipse插件的强⼤之处！
⽤到的⼯具：
1、MyEclipse2014
2、MySQL 5.5（oracle10g）
注：MySQL 和oracle的⽅法⼀样，只是在创建数据库连接的地⽅需要注意Connection URL的写法不同，这⾥我以mysql为例！
准备⼯作：（如果你的项⽬中已经有hibernate配置⽂件，并且有数据库连接的话，可以省略准备⼯作直接进⾏第三步）
1.新建⼀个web project ，选中项⽬右击
2.创建⼀个数据库，并且在数据库中添加若⼲表。

准备⼯作做好以后，我来⼿把⼿教接下来的步骤：
第⼀步：
这⾥我们创建了⼀个数据库student，⾥⾯有⼀张学⽣表（student）
第⼆步：创建⼀个数据库连接，如果已经有数据库连接并且已经有hibernate的配置⽂件的话，这⼀步可以省略
第三步：⽣成实体类和映射⽂件
完成后，可以在指定位置找到⽣成的映射⽂件和实体类对象了！。

HibernateTool_自动生成JPA实体开发向导描述修改记录开发向导描述 (1)修改记录 (1)1开发向导概要 (3)1.1向导适用范围 (3)1.2开发涉及的技术 (3)1.3开发使用工具和版本 (3)1.4 开发环境以及操作步骤 (4)1.4.1 安装Hibernate Tools (4)方法1 下载插件后安装Hibernate插件 (4)方法2 自动安装Hibernate插件 (7)1.4.2 新建工程配置及生成实体 (8)1.4.2.1 新建java工程配置相关包 (8)1.4.2.2 创建Hibernate configuration File (11)1.4.2.3 创建Hibernate Console Configuration (13)1.4.2.4 创建Hibernate Reverse Engineering File(reveng.xml) (14)1.4.2.5 创建实体 (16)1.5 将生成的实体用户开发 (23)1.5. 1 复制实体到项目的源目录下 (24)1.5.2 修改实体 (26)1.5.2.1 关注1：实现的接口改变 (26)1.5.2.2 关注2：按照情况可以去掉集合类属性（不是必须） (27)1.5.2.3 关注3：主键生成原则 (27)1.5.2.4 关注4：删掉不必要的构造方法（不是必须） (29)1.5.2.5 关注5：在hibernate.cfg.xml中增加实体的引用，增加后spring将接管实体的生命周期。

(31)1开发向导概要在eclipse3.2种集成hibernateT ools，自动生成JPA实体。

1.1向导适用范围向导适用的人群是项目中Web开发者，以及相关测试和管理人员。

1.2开发涉及的技术采用Java技术进行项目的开发，选择技术框架主要是目前流行的开源的技术架构。

Spring2.5Struts2.12Hibernate3.2或者3.31.3开发使用工具和版本Eclipse3.5 + hibernatetools(eclipse plugin)Tomcat6.0.18Jdk6Postgresql8.3RC1.4 开发环境以及操作步骤准备好eclipse3.2【3.2～3.6均可】，建议使用3.2.1.4.1 安装Hibernate Tools方法1 下载插件后安装Hibernate插件把插件放到eclipse目录下面在eclipse目录下面新建links文件夹新增一个文件hibernatetools.link内容如下：path = E:/eclipse/subeclipse_hibernateTools重启eclipse即可。

∙∙∙∙关注此空间 964zyz2012-01-13 09:31JPA实体注解与hibernate主键生成策略用hibernate注解开发项目，对于主键的生成策略有些模糊，下面是从新浪网里面看到的一篇关于hibernate注解以及主键生成策略的文章，值得一看：1. 实体标志:@Entity@Indexed(index="group")@Table(name="GROUP_LAYMOD")* @Indexed 标识需要进行索引的对象，* 属性 : index 指定索引文件的路径 @DocumentId 用于标示实体类中的唯一的属性保存在索引文件中，是当进行全文检索时可以这个唯一的属性来区分索引中其他实体对象，一般使用实体类中的主键属性* @Field 标注在类的get属性上，标识一个索引的Field属性 : index 指定是否索引，与Lucene相同store 指定是否索引，与Lucene相同name 指定Field的name，默认为类属性的名称analyzer 指定分析器在hibernate注解主键的时候，一般会使用到这两个。

@GeneratedValue的作用是JPA的默认实现自定义主键生成策略@GenericGenerator是hibernate在JPA的基础上增强。

自定义主键生成策略，由@GenericGenerator实现。

hibernate在JPA的基础上进行了扩展，可以用一下方式引入hibernate独有的主键生成策略，就是通过@GenericGenerator加入的。

比如说，JPA标准用法@Id@GeneratedValue(GenerationType.AUTO)就可以用hibernate特有以下用法来实现@GeneratedValue(generator = "paymentableGenerator")@GenericGenerator(name = "paymentableGenerator", strategy = "assigned")@GenericGenerator的定义:@Target({PACKAGE, TYPE, METHOD, FIELD})@Retention(RUNTIME)public @interface GenericGenerator {String name();String strategy();Parameter[] parameters() default {};}name属性指定生成器名称。

在过去几年里，Hibernate不断发展，几乎成为Java数据库持久性的事实标准。

它非常强大、灵活，而且具备了优异的性能。

在本文中，我们将了解如何使用Java 5 注释来简化Hibernate代码，并使持久层的编码过程变得更为轻松。

传统上，Hibernate的配置依赖于外部 XML 文件：数据库映射被定义为一组 XML 映射文件，并且在启动时进行加载。

在最近发布的几个Hibernate版本中，出现了一种基于 Java 5 注释的更为巧妙的新方法。

借助新的 Hibernate Annotation 库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的Java 类中，并提供一种强大及灵活的方法来声明持久性映射。

即利用hibernate注解后，可不用定义持久化类对应的*.hbm.xml文件，直接以注解方式写入在持久化类中来实现。

Hibernate annotation使用了ejb JPA的注解,所以，下面安装配置hibernate annotation环境时，需要导入ejb的包。

许多网上的资料都是jpa hibernate annotation方面的资料。

常用的hibernate annotation标签如下:@Entity --注释声明该类为持久类。

将一个Javabean类声明为一个实体的数据库表映射类,最好实现序列化.此时,默认情况下,所有的类属性都为映射到数据表的持久性字段.若在类中,添加另外属性,而非映射来数据库的, 要用下面的Transient来注解.@Table(name="promotion_info") --持久性映射的表(表名="promotion_info).@Table是类一级的注解,定义在@Entity下,为实体bean映射表,目录和schema的名字,默认为实体bean的类名,不带包名.@Id--注释可以表明哪种属性是该类中的独特标识符(即相当于数据表的主键)。

关于使用maven hibernate Plugin 生成java实体类使用maven hibernate Plugin 主要有6种功能∙hibernate3:hbm2cfgxml: Generates hibernate.cfg.xml∙hibernate3:hbm2ddl: Generates database schema.∙hibernate3:hbm2doc : Generates HTML documentation for database schema∙hibernate3:hbm2hbmxml: Generates a set of hbm.xml files∙hibernate3:hbm2java: Generates Java classes from set of *.hbm.xml files∙hibernate3:hbmtemplate: Renders arbitrary templates against Hibernate Mapping information这里主要介绍hibernate3:hbm2java这个功能如何使用它生成java实体类，使用这个插件的前置条件是首先配置好hibernate.cfg.xml这个文件，配置结果如下所示：<?xml version="1.0"encoding="utf-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><propertyname="hibernate.dialect">org.hibernate.dialect.MySQLInnoDBDialect</pr operty><propertyname="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prope rty><property name="ername">root</property><property name="hibernate.connection.password"></property><propertyname="hibernate.connection.url">jdbc:mysql://localhost/cityhome?useUn icode=true&amp;characterEncoding=GBK&amp;autoReconnect=true</property ><property name="hibernate.connection.shutdown">true</property></session-factory></hibernate-configuration>然后配置pom文件中的信息，如下所示：<build><plugins><plugin><groupId>org.codehaus.mojo</groupId><artifactId>hibernate3-maven-plugin</artifactId><version>2.2</version><dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>3.1.11</version></dependency><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>2.2</version></dependency></dependencies><configuration><components><component><name>hbm2java</name><outputDirectory>src/main/java/</outputDirectory><implementation>jdbcconfiguration</implementation></component></components><componentProperties><configurationfile>src/main/resources/hibernate.cfg.xml</configurationfile><ejb3>true</ejb3><packagename>model</packagename></componentProperties></configuration></plugin></plugins></build>对POM配置文件一些重要配置进行简单的说明：>h ibernate3-maven-plugin这个主要依赖mysql驱动（如果是mysql数据库类型,取决于连接的数据库）和cglib包（主要用于反向控制）<component><name/><component>是maven插件的goal的名称，在maven hibernate插件中主要有hbm2cfgxml、hbm2ddl、hbm2doc、hbm2hbmxml、hbm2java、hbmtemplate 等6种。

idea⾃动⽣成hibernate实体类1. DataBase -> + -> Data Source -> MySQL2. 填写 host、port、URL等信息后 -> TestConection（注：第⼀次测试连接需先安装插件）测试连接：成功 3.4.添加hibernate配置⽂件<?xml version='1.0' encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!-- 主要三部分配置--><!-- 1.配置数据库信息，必须的--><property name="connection.url">jdbc:mysql://192.168.0.108:3306/ecai?serverTimezone=Asia/Shanghai</property> <property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property><property name="ername">root</property><property name="connection.password">root</property><!-- 2.配置hibernate信息，可选的--><!-- 输出底层的sql语句--><property name="hibernate.show_sql">true</property><!-- 对底层sql进⾏格式化--><property name="hibernate.format_sql">true</property><!--配置数据的⽅⾔，如mysql中limitoracle的rownum--><property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property><property name="hibernate.current_session_context_class">thread</property><!-- 3.把映射⽂件配置到核⼼⽂件中，必须的--></session-factory></hibernate-configuration>hibernate.cfg.xml5.　添加hibernate配置⽂件成功后，左下⾓将出现 Persistence窗⼝，右击第⼀⾏的项⽬名6. 7.例：⽣成后的实体类package orm.entity;import javax.persistence.*;import java.math.BigDecimal;/*** <p>** </p>** @author: zeng* @since: 2020-03-26*/@Entity@Table(name = "merchant", schema = "ecai", catalog = "") public class MerchantEntity {private int id;private String code;private String account;private String password;private String nickname;private BigDecimal balance;private int status;private int roleId;private String secretKey;private String registTime;private String loginTime;private String loginIp;private String loginPlat;private String ips;private String phone;private String email;private String qq;private String wechat;@Id@Column(name = "id")public int getId() {return id;}public void setId(int id) {this.id = id;}@Basic@Column(name = "code")public String getCode() {return code;}public void setCode(String code) {this.code = code;}@Basic@Column(name = "account")public String getAccount() {return account;}public void setAccount(String account) {this.account = account;}@Basic@Column(name = "password")public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}@Basic@Column(name = "nickname")public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname = nickname;}@Basic@Column(name = "balance")public BigDecimal getBalance() {return balance;}public void setBalance(BigDecimal balance) {this.balance = balance;}@Column(name = "status")public int getStatus() {return status;}public void setStatus(int status) {this.status = status;}@Basic@Column(name = "role_id")public int getRoleId() {return roleId;}public void setRoleId(int roleId) {this.roleId = roleId;}@Basic@Column(name = "secret_key")public String getSecretKey() {return secretKey;}public void setSecretKey(String secretKey) {this.secretKey = secretKey;}@Basic@Column(name = "regist_time")public String getRegistTime() {return registTime;}public void setRegistTime(String registTime) {this.registTime = registTime;}@Basic@Column(name = "login_time")public String getLoginTime() {return loginTime;}public void setLoginTime(String loginTime) {this.loginTime = loginTime;}@Basic@Column(name = "login_ip")public String getLoginIp() {return loginIp;}public void setLoginIp(String loginIp) {this.loginIp = loginIp;}@Basic@Column(name = "login_plat")public String getLoginPlat() {return loginPlat;}public void setLoginPlat(String loginPlat) {this.loginPlat = loginPlat;}@Basic@Column(name = "ips")public String getIps() {return ips;}public void setIps(String ips) {this.ips = ips;}@Basic@Column(name = "phone")public String getPhone() {return phone;}public void setPhone(String phone) {this.phone = phone;}@Basic@Column(name = "email")public String getEmail() {return email;}public void setEmail(String email) {this.email = email;}@Basic@Column(name = "qq")public String getQq() {return qq;}public void setQq(String qq) {this.qq = qq;}@Basic@Column(name = "wechat")public String getWechat() {return wechat;}public void setWechat(String wechat) {this.wechat = wechat;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;MerchantEntity that = (MerchantEntity) o;if (id != that.id) return false;if (status != that.status) return false;if (roleId != that.roleId) return false;if (code != null ? !code.equals(that.code) : that.code != null) return false;if (account != null ? !account.equals(that.account) : that.account != null) return false;if (password != null ? !password.equals(that.password) : that.password != null) return false;if (nickname != null ? !nickname.equals(that.nickname) : that.nickname != null) return false;if (balance != null ? !balance.equals(that.balance) : that.balance != null) return false;if (secretKey != null ? !secretKey.equals(that.secretKey) : that.secretKey != null) return false;if (registTime != null ? !registTime.equals(that.registTime) : that.registTime != null) return false;if (loginTime != null ? !loginTime.equals(that.loginTime) : that.loginTime != null) return false;if (loginIp != null ? !loginIp.equals(that.loginIp) : that.loginIp != null) return false;if (loginPlat != null ? !loginPlat.equals(that.loginPlat) : that.loginPlat != null) return false;if (ips != null ? !ips.equals(that.ips) : that.ips != null) return false;if (phone != null ? !phone.equals(that.phone) : that.phone != null) return false;if (email != null ? !email.equals(that.email) : that.email != null) return false;if (qq != null ? !qq.equals(that.qq) : that.qq != null) return false;if (wechat != null ? !wechat.equals(that.wechat) : that.wechat != null) return false;return true;}@Overridepublic int hashCode() {int result = id;result = 31 * result + (code != null ? code.hashCode() : 0);result = 31 * result + (account != null ? account.hashCode() : 0);result = 31 * result + (password != null ? password.hashCode() : 0);result = 31 * result + (nickname != null ? nickname.hashCode() : 0);result = 31 * result + (balance != null ? balance.hashCode() : 0);result = 31 * result + status;result = 31 * result + roleId;result = 31 * result + (secretKey != null ? secretKey.hashCode() : 0);result = 31 * result + (registTime != null ? registTime.hashCode() : 0);result = 31 * result + (loginTime != null ? loginTime.hashCode() : 0);result = 31 * result + (loginIp != null ? loginIp.hashCode() : 0);result = 31 * result + (loginPlat != null ? loginPlat.hashCode() : 0);result = 31 * result + (ips != null ? ips.hashCode() : 0);result = 31 * result + (phone != null ? phone.hashCode() : 0);result = 31 * result + (email != null ? email.hashCode() : 0);result = 31 * result + (qq != null ? qq.hashCode() : 0);result = 31 * result + (wechat != null ? wechat.hashCode() : 0);return result;}}Bean。

Hibernate实现（注解方式）注解方式：注解的方式与xml很很多类似：首先是需要加入4个jar包：hibernate-commons-annotations.jar 、 hibernate-annotations.jarejb3-persistence.jar 、 hibernate-jpa-2.0-api-1.0.1.Final.jar下面是不同的地方：（1）：hibernate.hbm.xml 文件中把引用：xxx.hbm.xml改为引用实体类：即把：<mapping resource="com/wsw/hibernate/model/Person.hbm.xml"/>改为：<mapping class="com.wsw.hibernate.model.Teacher" />（2）：获取SessionFactory方式发生了变化：即：由SessionFactory sf = new Configuration().configure().buildSessionFactory()改为：SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory()（3）：注解方式不需要在xxx.hbm.xml把实体类与表进行映射。

而采用在实体类中进行注解。

注意：（1）：如果实体类属性名与表字段名不一致的时候，要么都注解在属性前，要么都注解在get方法前。

不能部分注解在属性前，部分注解在方法前。

（2）：如果实体类属性名与表字段名一致的时候，可以部分注解在属性前，部分注解在方法前。

（3）：如果在实体类中某些属性不注解：（属性和get都不写注解），默认为表字段名与实体类属性名一致。

（4）：如果实体类的某个成员属性不需要存入数据库中，使用@Transient 进行注解就可以了。

JPA（Java Persistence API）是Sun官方提出的java持久化规范，它只是一个规范不是一个产品，Hibernate已经是一个产品了。

使用Hibernate我们的劣势就是和这个框架结合的太机密了。

数据库开发的过程有两种过程的：1.先建表：根据数据库表编写配置文件的实体bean。

2.先编写文件和实体bean。

然后在生成表。

一、个人编写简单生成数据库表创建web project，名称JPAProjectjar包：src目录下创建META-INF文件夹存放持久化文件：persistence.xmlJPA 规范要求，配置文件必须命名为persistence.xml，并存在于类路径下的META-INF 目录中。

该文件通常包含了初始化JPA 引擎所需的全部信息。

<?xml version="1.0"?><persistence xmlns=""xmlns:xsi=""xsi:schemaLocation="" version="1.0"><persistence-unit name="yx"transaction-type="RESOURCE_LOCAL"><!-- 事物的类型,这里的实物类型是本地实物类型 --><provider>org.hibernate.ejb.HibernatePersistence</provider><properties><property name="hibernate.dialect"value="org.hibernate.dialect.MySQL5Dialect"/><!--数据库方言--><property name="hibernate.connection.driver_class"value="com.mysql.jdbc.Driver"/><!--数据库驱动类--><property name="ername"value="root"/><!--数据库用户名--><property name="hibernate.connection.password"value="yx"/><!--密码--><property name="hibernate.connection.url"value="jdbc:mysql://localhost:3306/test"/><!--数据库连接URL--> <property name="hibernate.max_fetch_depth"value="3"/><!--外连接抓取树的最大深度 --><property name="hibernate.hbm2ddl.auto"value="update"/><!-- 自动输出schema创建DDL语句 --><property name="hibernate.jdbc.fetch_size"value="18"/><!-- JDBC 的获取量大小 --><property name="hibernate.jdbc.batch_size"value="10"/><!-- 开启Hibernate使用JDBC2的批量更新功能 --><property name="hibernate.show_sql"value="true"/><!-- 在控制台输出SQL语句 --></properties></persistence-unit><!--Oracle --><!--<persistence-unit name="default" transaction-type="RESOURCE_LOCAL"> <provider>oracle.toplink.essentials.PersistenceProvider</provider><exclude-unlisted-classes>false</exclude-unlisted-classes><properties><property name="toplink.logging.level" value="INFO"/><property name="toplink.jdbc.driver"value="oracle.jdbc.OracleDriver"/><property name="toplink.jdbc.url"value="jdbc:oracle:thin:@myhost:l521:MYSID"/><property name="toplink.jdbc.password" value="tiger"/><property name="er" value="scott"/></properties></persistence-unit>--></persistence>注：hibernate.hbm2ddl.autovalidate加载hibernate时，验证创建数据库表结构create 每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失。

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:⽤于双向关联时使⽤，否则会引起数据不⼀致的问题。

java hibernate注解简单使用前提：这篇对hibernate的注解的一些参数的介绍的不是很不全（通常只是介绍例子中给出的注解解析），要更完整的了解其中一个注解可以再继续查询这个注解。

这篇更多的是我自己学hibernate的总结，然后把注解列举一下，方便查找。

映射实体类例子一般文件类DefaultFile@MappedSuperclass@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) publicclass DefaultFile{// Fields@Id@Column(name = "id", insertable = false, updatable = false) @GeneratedValue(strategy=GenerationType.IDENTITY)privateint id;@Column(name = "name")private String name;@Column(name = "path")private String path;@Column(name = "note")private String note;@Column(name = "uploadDate", insertable = false, updatable = false)private Timestamp uploadDate;/*** 文件内容，不被映射成column*/@TransientFile file;...}图片文件类ImageFile@Entity@Table(name = "imageFile")publicclass ImageFile extends DefaultFile{@OneToMany(cascade = CascadeType.ALL,mappedBy="imagefile", fetch = ZY)private Set<Account> accounts = new HashSet<Account>();...}账户类Account@Entity@Table(name="account")publicclass Account {// Fields@Id@Column(insertable=false,updatable=false)@GeneratedValue(strategy=GenerationType.IDENTITY)private Integer id;@ManyToOne(fetch=FetchType.EAGER,cascade=CascadeType.ALL) @JoinColumn(name="imageID")//头像private ImageFileimagefile;@Columnprivate String name;@Columnprivate String password;@Column(insertable=false,updatable=false)private Timestamp createdDate;...}@Entity作用：标记为实体类，标记后都会被映射到数据表中用法：一般实体类都要加上这个注释@MappedSuperclass作用：表明该类作为父类被其他实体类继承后，其它实体类可以继承该类的属性，并且结合各子类各自映射对应的表，然后改父类不映射到数据库表用法：这个和上面的@Entity可以说二者只能选其一，如果选择@MappedSuperclass则不映射表，如果用@Entity则会映射到表结合例子：例子中DefaultFile被注解为@MappedSuperclass，因此DefaultFile不会被映射到表，而ImageFile继承DefaultFile，因此ImageFile会继承DefaultFile的属性，加上自己的属性，映射到新表@Inheritance作用：定义继承的策略用法：@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)上面的InheritanceType.TABLE_PER_CLASS是指每个子类都成为一个新表，还有以下的继承策略（看名字就大概知道意思了）：@Table作用：用来标记该实体类映射到数据库中的表的表名用法：可添加参数来说明表名@Table(name=”table_name”)@Id作用：说明该属性为主键@GeneratedValue作用：表明该列为自动增长的属性用法：@GeneratedValue(strategy=GenerationType.IDENTITY)其中strategy指自动增长的策略，而这个GenerationType.IDENTITY是指数据库自动增长，相当于MySQL中auto_increment，还有其它属性：@Column作用：指明该列的属性用法：@Column(name = “uploadDate”, insertable = false, updatable = false) name = “column_name”指明列名insertable=false插入操作时忽略该属性updatable=false更新操作时忽略该属性@OneToMany作用：表名一对多的关系，通常用于Set<T>变量用法：@OneToMany(cascade = CascadeType.ALL =CascadeType.ALL,mappedBy=”imagefile”,fetch = ZY) cascade = CascadeType.ALL在所有操作上都进行关联操作mappedBy=”imagefile”如果这个一对多的关系不是通过第三张表来维持，而是多方保存一方的id（多方外键引用一方），则必须要有mappedBy来指明多方中哪个变量来保存一方（外键），值是多方里面保存一方的属性名字，具体可看例子中的使用fetch=FetchType.EAGER加载的策略，有积极和懒惰，积极是指用查询语句获取对象时，马上加载标记为@OneToMany的变量，懒惰则是等到使用时才获取。

Hibernate注解（⼀）：基本注解在Hibernate中使⽤注解，主要是为了替代映射⽂件，完成“类到表，属性到字段”的映射。

JPA提供了⼀套功能强⼤的注解。

Hibernate直接使⽤了JPA的这套注解。

当然，对于JPA中的⼀些不⾜，Hibernate⼜开发了⼀些⾃⼰的注解。

这些注解要么继承⾃JPA，要么是独⽴的注解，作为JPA的补充。

故，我们使⽤的注解，基本是javax.persistence.Transient包中的。

使⽤注解时需注意以下⼏点：（1）使⽤的均为javax.persistence.Transient包中的注解（2）不再需要映射⽂件了（3）在Hibernate主配置⽂件中⽆需指定映射⽂件了，但需要指定注解的实体类。

（springboot这⼀步也省了）注解的具体⽂档在javax.persistence包下的注解类型总结Annotation Type Summry中。

1、Hibernate基本注解根据其标注的位置与完成的功能，Hibernate注解可分为两种：类级注解、属性级注解。

. 类级注解：注解在类的头部。

完成类到表的映射。

. 属性级注解：注解在属性上⾯，或属性的get⽅法上⾯。

完成属性到字段的映射。

第⼀类：类级注解（1）@Entity⽤在POJO类上，表⽰当前类为实体类。

name属性为实体名称。

默认为类的⾮限定性类名。

⼀般使⽤默认值。

（2）@Table与@Entity联合使⽤。

name属性指定映射的表名。

默认与实体名称相同。

@Entity@Table(name="city")public class City {}第⼆类：属性级注解属性级注解根据其注解属性的不同，⼜可分为两类：主键相关注解，与普通属性注解。

主键相关注解（1）@Id⽤在主键id属性上，或其get⽅法上，表⽰当前属性将对应数据库中的主键。

（2）@GeneratedValue指定主键值的来源。

其属性strategy⽤于指定主键的⽣成策略。

IntelliJIDEA下⾃动⽣成Hibernate映射⽂件以及实体类1、构建项⽬并添加项⽬结构配置以及配置初始参数1.1、如图将基本的架⼦搭建好1.2、点击File，弹出的菜单中点击Project Structure；1.3、点击左侧的Modules，再点击“+”号，再在弹出的菜单中选择Hibernate；1.4、在这时，项⽬中多出了⼀个Hibernate，点击Hibernate，再点击“+”号，选择hibernate.hbm.xml；1.5、弹出的窗⼝中选择Hibernate的版本，然后点击OK；1.6、点击OK后在原来1.4步骤的窗⼝中的Apply按妞应⽤到项⽬；1.7、这时项⽬架⼦中多出了⼀个名为hibernate.hbm.xml的配置⽂件；1.8、在hibernate.hbm.xml中配置如下配置；<?xml version='1.0' encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!--数据库连接url配置--><property name="connection.url">jdbc:mysql://localhost:3306/SSHBlog?useUnicode=true&characterEncoding=utf8&useSSL=true&zeroDateTimeBehavior=convertToNull</property> <!--数据库驱动配置--><property name="connection.driver_class">com.mysql.jdbc.Driver</property><!--数据库⽤户名配置--><property name="ername">root</property><!--数据库密码配置--><property name="connection.password"></property><!-- DB schema will be updated if needed --><!-- <property name="hbm2ddl.auto">update</property> --></session-factory></hibernate-configuration>1.9、第⼀步配置完毕。

hibernate entity注解摘要：1.Hibernate 概述2.Hibernate 实体注解的作用3.常用的Hibernate 实体注解4.实体注解的实例解析正文：一、Hibernate 概述Hibernate 是一款流行的Java 对象关系映射（ORM）框架，用于将数据库中的数据与Java 对象之间进行映射。

通过Hibernate，开发者可以更加专注于业务逻辑，而无需关心底层数据库操作。

在Hibernate 中，实体类是用于表示数据库表的Java 类，而实体注解则是用于配置和描述实体类的一种方式。

二、Hibernate 实体注解的作用实体注解主要用于配置实体类的关联、继承、事务管理等属性。

通过使用实体注解，可以简化实体类的配置，提高开发效率。

三、常用的Hibernate 实体注解1.@Entity：表示一个实体类，用于映射数据库中的表。

2.@Table：指定实体类对应的数据库表名。

3.@Id：指定实体类中的主键属性。

4.@GeneratedValue：指定主键生成策略。

5.@Column：指定实体类属性与数据库表字段的映射关系。

6.@ManyToOne：表示一对多关系。

7.@OneToMany：表示多对一关系。

8.@OneToOne：表示一对一关系。

9.@ManyToMany：表示多对多关系。

10.@Lazy：表示延迟加载。

11.@ Cascade：表示级联操作。

12.@Where：表示条件限制。

四、实体注解的实例解析下面通过一个实体类的例子，来解析一下常用的实体注解：```javaimport javax.persistence.*;@Entity@Table(name = "user")public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;@Column(name = "name")private String name;@Column(name = "email")private String email;@ManyToOne(mappedBy = "user")@JoinColumn(name = "group_id")private Group group;@OneToMany(mappedBy = "user")@JoinColumn(name = "user_id")private List<Post> posts;@OneToOne(mappedBy = "user")@JoinColumn(name = "user_id")private Address address;@Lazy@OneToMany(mappedBy = "user")@JoinColumn(name = "user_id")private List<Comment> comments;}```在这个例子中，我们使用@Entity 注解表示该类是一个实体类，@Table 注解指定了实体类对应的数据库表名。

SSH自动生成实体类1、先要在Eclipse上安装Hibernate的相关插件JBoss Tools ，你能够在Eclipse上的Market中下载该插件，点击Help---->Eclipse Marketplace进入，查找该插件进行安装。

如以下图所示，点击install：就能够够进入到如下界面，你能够选择安装所有的插件，也能够只安装Hibernate Tools，如图中所示咱们只勾选了该项，点击Confirm进行安装，安装完成以后重启Eclipse：2、右击项目，选择“New---->Other---->Hibernate---->Hibernate Console Configuration”，如以下图所示，点击“Next>”，进入到第2张图所示的界面：3、点击上图所示红圈1标注的Setup，创建一个属性文件，所有的内容都是默许的；4、点击上图红圈2标注的Setup，创建一个文件，依次进入的界面如以下图所示：其中Default Schema能够不填，但有时不填加载所有的数据库时，数据库与数据库之间可能发生冲突，这是就得加上才可不能报错。

5、点击上上上图红圈所示3标注的New，进入如下界面：添加mysql数据库的jar包，你能够从本地maven库当选择；填写相应的数据库连接信息，点击ok进入以下图界面点击Test Connection测试是不是连接数据库成功展开Database能够看到相应的数据库和表说明成功。

6、点击以下图所示的按钮（若是没有，你得点击左侧菜单栏的Java进入该界面就行），选择“Hibernate Code Generation Configuration..”进入7中界面；7、填写完图中所示的相关信息，点击图中红圈标注的Exporter，进入8中的界面；点击红圈标注的Setup，进入9中的界面；其中产生的实体类或其它文件放到图中Package的位置中。

Hibernate是一个开源的对象关系映射（ORM）框架，使用它可以简化数据库操作，而字段注解是Hibernate中非常重要的一部分，它可以帮助我们定义实体类和数据库字段之间的映射关系。

下面将通过以下几个方面详细介绍Hibernate字段注解的使用方法和注意事项。

一、Id注解在Hibernate中，Id注解用于标识实体类的主键字段。

使用该注解可以告诉Hibernate哪个字段是实体类的主键，如下所示：```javaIdGeneratedValue(strategy=GenerationType.IDENTITY) Column(name="id")private Long id;```在这段代码中，Id注解标识了id字段为实体类的主键，而GeneratedValue注解定义了主键生成策略，这里使用了IDENTITY 策略。

Column注解用于指定数据库中对应的字段名。

二、GeneratedValue注解GeneratedValue注解用于定义主键生成策略，常见的策略包括IDENTITY、SEQUENCE、TABLE等。

在上面的代码中，我们使用了IDENTITY策略，表示主键由数据库自动生成。

三、Column注解Column注解用于映射实体类属性和数据库表字段。

通过该注解，我们可以指定字段名、长度、是否唯一、是否可空等属性，如下所示：```javaColumn(name="username", unique=true, nullable=false, length=20)private String username;```在这段代码中，Column注解指定了username属性映射到数据库表中的username字段，该字段是唯一的，不可为空，长度为20。

四、Basic注解Basic注解用于指定属性的访问类型，有两个取值：LAZY和EAGER。

如果不指定，默认为EAGER，表示立即加载属性；而LAZY表示延迟加载属性，即在访问该属性时才加载。

Hibernate框架学习之注解映射实体类前面的相关文章中，我们已经介绍了使用XML配置文件映射实体类及其各种类型的属性的相关知识。

然而不论是时代的潮流还是臃肿繁杂的配置代码告诉我们，注解配置才是更人性化的设计，于是学习了基本的映射实体类的基本注解，此处做一点总结，后续文章将陆续更新使用注解的方式管理配置各种映射关联关系。

本篇主要涉及以下内容：•使用最基本的注解映射一个实体类•使用注解映射属性•使用注解映射主键•其他特殊类型的属性映射一、使用最基本的注解映射一个实体类@Entity@Table(name = "userInfo")public class UserInfo {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private int id;private String name;//省略getter和setter方法}//在hibernate.cfg.xml中添加实体类//这样hibernate就会根据配置文件去查找该实体类并做映射操作<mapping class="User_erInfo"/>这就是映射一个最简单的实体类所用到的最基本的注解。

其中，•@Entity：指定当前被修饰的类是一个实体类，用于映射到数据库中的表。

•@Table(name = "userInfo")：详细指定了该类映射到数据库中的哪张表，这里映射到userInfo表。

•@Id：指定被修饰的属性将映射到数据表的主键列。

•@GeneratedValue(strategy = GenerationType.IDENTITY)：该注解指定了主键的生成策略，一般不单独出现，这里指定了主键自增的策略。

这里写图片描述二、使用注解映射普通属性对于实体类中属性的映射，一般我们使用@Column进行修饰。