hibernate基于jpa注解说明

合集下载

关闭数据库的注解

关闭数据库的注解
关闭数据库的注解取决于你使用的数据库和框架。

以下是一些常见的数据库和框架及其关闭数据库的注解：
1.Spring Boot with JPA (Hibernate):
1.在配置文件中设置spring.jpa.hibernate.ddl-auto=none来关闭DDL自动
创建。

2.使用@EnableTransactionManagement(proxyMode=ProxyMode.NONE)
注解关闭事务代理。

2.MyBatis:
1.在MyBatis配置文件中，可以设置<settings>标签内的autoCommit=true
来关闭自动提交。

3.Spring Boot with JDBC:
1.如果你使用Spring Boot的JdbcTemplate，那么Spring Boot会在应用关
闭时自动关闭数据源。

但为了确保资源被正确释放，你可以使用
@PreDestroy注解在资源持有者类上，并在其中关闭数据源。

4.Java Persistence API (JPA):
1.如果你使用JPA，通常不需要手动关闭数据库连接，因为它是通过
EntityManager管理的。

但如果你想在某个时间点关闭EntityManager，
可以使用entityManager.close()。

5.Hibernate:
1.Hibernate SessionFactory的生命周期通常与应用的生命周期相同，因此
通常不需要显式关闭它。

但如果你想在某个时间点关闭SessionFactory，
可以使用sessionFactory.close()。

JPA 与 Hibernate 的关系

JPA 与Hibernate 的关系什么是JPAJavaEE5.0 的平台的ORM 标准规范。

为应用程序访问持久层提供统一的方式。

JPA 是规范，Hibernate 是实现。

从功能上来讲，JPA 是Hibernate 的一个子集。

Hibernate 只是JPA 的一个提供商。

类似于JDBC 和JDBC驱动提供商。

JPA 的优点JPA 提供了更加简洁的，基于注解的方式来进行映射。

JPA 配置文件要求必须配置在META-INF 目录下，且配置名字是固定的persistence.xml。

顶级节点为<persistence> ，次级节点为<persistence-unit>，JPA 的绝大部分信息配置在<persistence> 节点内。

<persistence-unit> 节点name 属性：用来指定这个persistence单元的名称<persistence-unit> 节点transaction-type 属性：指定JPA 的事务处理策略，默认为RESOURCE_LOCAL,数据库级别的事务，只能针对一种数据库，不支持分布式事务。

若需要支持分布式事务，使用JTA，即：transaction-type="JTA"。

如果JPA 的提供者存在多个的时候，需要在<provider> 节点配置具体使用哪个提供者。

需要是javax.persistence.spi.PersistenceProvider 的实现类。

在<properties> 节点内通过<property> 节点配置数据库连接信息。

在<properties> 节点内通过<property> 节点配置属于具体实现的特性信息。

通过<class> 节点来配置映射的实体类。

举例<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="/xml/ns/persistence" version="2.0"><persistence-unit name="jpa_01" transaction-type="RESOURCE_LOCAL"><provider>org.hibernate.ejb.HibernatePersistence</provider><class>com.solverpeng.jpa.Customer</class><class>com.solverpeng.jpa.Orders</class><class>com.solverpeng.jpa.Clazz</class><class>com.solverpeng.jpa.Student</class><properties><property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/><property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/jpa"/><property name="ername" value="root"/><property name="hibernate.connection.password" value="123456"/><property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect"/><property name="hibernate.format_sql" value="true"/><property name="hibernate.show_sql" value="true"/><property name="hibernate.hbm2ddl.auto" value="update"/></properties></persistence-unit></persistence>注意事项指定JPA 实现后，在配置数据库驱动、连接、用户名和密码的时候，需要指定前缀。

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 异常。

解决JPA懒加载典型的N+1问题-注解@NamedEntityGraph

解决JPA懒加载典型的N+1问题-注解@NamedEntityGraph因为在设计⼀个树形结构的实体中⽤到了多对⼀，⼀对多的映射关系，在加载其关联对象的时候，为了性能考虑，很⾃然的想到了懒加载。

也由此遇到了N+1的典型问题 : 通常1的这⽅，通过1条SQL查找得到1个对象，⽽JPA基于Hibernate，fetch策略默认为select(并⾮联表查询)，由于关联的存在，⼜需要将这个对象关联的集合取出，集合数量是N，则要发出N条SQL，于是本来的1条联表查询SQL可解决的问题变成了N+1条SQL我采取的解决⽅法是 : 不修改懒加载策略，JPA也不写native SQL，通过联表查询进⾏解决。

场景如下 : 我设计了⼀个典型的⼆叉树结构实体叫做Area，代表的含义是区域 (省、市、区)。

省是树的⼀级根节点，市是省的⼦节点，区是市的⼦节点。

如 :⼴东省，⼴州市，天河区 1 . Area实体设计采⽤⾃关联，关联的⼦集fetch策略为懒加载。

package name.ealen.entity;import com.fasterxml.jackson.annotation.JsonIgnore;import org.hibernate.annotations.GenericGenerator;import javax.persistence.*;import java.util.List;/*** Created by EalenXie on 2018/10/16 16:49.* 典型的多层级区域关系*/@Entity@Table(name = "jpa_area")public class Area {/*** Id 使⽤UUID⽣成策略*/@Id@GeneratedValue(generator = "UUID")@GenericGenerator(name = "UUID", strategy = "org.hibernate.id.UUIDGenerator")private String id;/*** 区域名*/private String name;/*** ⼀个区域信息下⾯很多⼦区域(多级) ⽐如 : ⼴东省 (⼦)区域 : ⼴州市 (孙)⼦区域 : 天河区*/@ManyToOne(fetch = ZY)@JoinColumn(name = "parent_id")@JsonIgnoreprivate Area parent;@OneToMany(mappedBy = "parent", fetch = ZY)private List<Area> children;public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Area getParent() {return parent;}public void setParent(Area parent) {this.parent = parent;}public List<Area> getChildren() {return children;}public void setChildren(List<Area> children) {this.children = children;}} 2 . 为Area写⼀个简单的dao进⾏数据库访问：AreaRepositorypackage name.ealen.dao;import name.ealen.entity.Area;import org.springframework.data.jpa.repository.JpaRepository;/*** Created by EalenXie on 2018/10/16 16:56.*/public interface AreaRepository extends JpaRepository<Area, String> {} 3. 现在来进⾏⼀波关键性的测试 : ⾸先我们插⼊数据测试 :@Autowiredprivate AreaRepository areaRepository;/*** 新增区域测试*/@Testpublic void addArea() {// ⼴东省 (顶级区域)Area guangdong = new Area();guangdong.setName("⼴东省");areaRepository.save(guangdong);//⼴东省下⾯的⼴州市(⼆级区域)Area guangzhou = new Area();guangzhou.setName("⼴州市");guangzhou.setParent(guangdong);areaRepository.save(guangzhou);//⼴州市下⾯的天河区(三级区域)Area tianhe = new Area();tianhe.setName("天河区");tianhe.setParent(guangzhou);areaRepository.save(tianhe);//⼴东省下⾯的湛江市(⼆级区域)Area zhanjiang = new Area();zhanjiang.setName("湛江市");zhanjiang.setParent(guangdong);areaRepository.save(zhanjiang);//湛江市下⾯的霞⼭区(三级区域)Area xiashan = new Area();xiashan.setName("霞⼭区");xiashan.setParent(zhanjiang);areaRepository.save(xiashan);} 4 . 进⾏查询，并触发懒加载 :/*** 触发懒加载查询典型的 N+1 现象*/@Test@Transactionalpublic void findAllArea() {List<Area> areas = areaRepository.findAll();System.out.println(JSONArray.toJSONString(areas.get(0)));} 此时，我们可以在控制台中看到，触发了懒加载，导致了N+1的问题。

在Java中使用JPA进行数据库操作

在Java使用JPA行数据库操作Java Persistence API (JPA) 是Java EE 平台中用于ORM的标准API。

使用JPA，你可以将Java 对象映射到数据库表中，并可以轻松地进行查询和更新操作。

以下是在Java 中使用JPA 进行数据库操作的基本步骤：1.添加依赖：首先，你需要在项目中添加JPA 的依赖。

如果你使用Maven，可以在pom.xml文件中添加如下依赖：xml复制代码<dependency><groupId>org.hibernate</groupId><artifactId>hibernate-core</artifactId><version>5.4.31.Final</version></dependency>2.配置数据源：在项目中配置数据源。

如果你使用Maven，可以在pom.xml文件中添加如下依赖：xml复制代码<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.23</version></dependency>然后在src/main/resources目录下创建persistence.xml文件，内容如下：xml复制代码<persistence-unit name="myPersistenceUnit" transaction-type="RESOURCE_LOCAL"><properties><property name="hibernate.connection.driver_class"value="com.mysql.cj.jdbc.Driver" /><property name="hibernate.connection.url"value="jdbc:mysql://localhost:3306/mydatabase" /><property name="ername"value="username" /><property name="hibernate.connection.password"value="password" /></properties></persistence-unit>3.创建实体类：创建一个实体类，并通过注解来定义它与数据库表之间的映射关系。

数据层对象的注解

数据层对象的注解在软件开发中，数据层对象通常与数据库交互，用于表示数据库中的表结构。

在许多现代编程语言和框架中，使用注解（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。

@MappedSuperclass注解的使用说明

@MappedSuperclass注解的使⽤说明基于代码复⽤和模型分离的思想，在项⽬开发中使⽤JPA的@MappedSuperclass注解将实体类的多个属性分别封装到不同的⾮实体类中。

1.@MappedSuperclass注解仅仅能标准在类上：@Target({ng.annotation.ElementType.TYPE})2.标注为@MappedSuperclass的类将不是⼀个完整的实体类，他将不会映射到数据库表，可是他的属性都将映射到其⼦类的数据库字段中。

3.标注为@MappedSuperclass的类不能再标注@Entity或@Table注解，也⽆需实现序列化接⼝。

可是假设⼀个标注为@MappedSuperclass的类继承了另外⼀个实体类或者另外⼀个相同标注了@MappedSuperclass的类的话。

他将能够使⽤@AttributeOverride或@AttributeOverrides注解重定义其⽗类(不管是否是实体类)的属性映射到数据库表中的字段。

⽐⽅能够重定义字段名或长度等属性。

使⽤@AttributeOverride中的⼦属性@Column进⾏详细的定义。

注意：对于其⽗类中标注@Lob注解的属性将不能重载，⽽且@AttributeOverride⾥的@Column设置都将不起作⽤。

JPA规范中对@Lob注解并没有说明不能同⼀时候标注@Column注解。

可是在实际使⽤中Hibernate JPA不⽀持这中标注⽅式。

4.此外，这种类还能够直接标注@EntityListeners实体监听器，他的作⽤范围仅在其全部继承类中。

⽽且实体监听器相同能够保被其⼦类继承或重载。

5.标注为@MappedSuperclass的类其属性最好设置为protected或default类型的，以保证其同⼀个包下的⼦类能够直接调⽤它的属性。

便于实体监听器或带參数构造函数的操作。

6.因为标注为@MappedSuperclass的类将不是⼀个完整的实体类，因此其不能标注@Table，⽽且⽆法使⽤@UniqueConstraint设置字段的Unique属性，这⼀点以及对属性类型重载(如重载标注为@Lob的属性)的⽀持ＪＰＡ规范还有待改进。

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)--用于指定持久属性或字段的映射列。

JPA常用注解

(1)Entity@javax.persistence.Entity(name="xxx")name指定实体Bean的名称,默认值为bean class 的非限定类名(不带包的短类名)(2)Table@javax.persistence.Table(catalog="xx",name="xx",schema="xx",uniqueConstraints={ @ UniqueConstraint(columnNames={"xx","xx"})})name:指定表的名称catalog:指定数据库名称schema:指定数据库的用户名uniqueConstraints:指定唯一性字段约束(字段值唯一不重复)如为personid和name 字段指定唯一性约束：uniqueConstraints={ @UniqueConstraint(columnNames={"personid", "name"})}(3)Id@javax.persistence.Id()映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.(4)GeneratedValue@javax.persistence.GeneratedValue(generator="xxx",strategy=GenerationType.AUTO) strategy:表示主键生成策略,有方式一：@GeneratedValue(strategy=GenerationType.AUTO) 默认策略，生成方式取决于底层的数据库。

方式二：@GeneratedValue(strategy = GenerationType.IDENTITY)指定“自动增长”策略，适用于MySQL。

springboot中使用jpa下hibernate的ddl-auto方式

springboot中使⽤jpa下hibernate的ddl-auto⽅式⽬录使⽤jpa下hibernate的ddl-autoddl-auto的配置spring.jpa.hibernate.ddl-auto的配置具体的关系见下使⽤jpa下hibernate的ddl-auto今天做⼀个报表的功能，发现⼀个表中的shopProductId都为null，但在程序中判断⽤的是shopProductId,⽽且表中有productId 不为null，在查找原因的途中，才得知是有⼈将productId改为了shopProductId，但是数据没有更新过去。

遇到这种情况，我们怎么能查看到某些字段被改变了呢？由于我们⽤的框架是springBoot+jap-hibernate，然后在jpa下的hibernate,在application配置⽂件中，有ddl-auto的配置ddl-auto:create每次运⾏该程序，没有表格会新建表格，表内有数据会清空ddl-auto:create-drop每次程序结束的时候会清空表ddl-auto:update每次运⾏程序，没有表格会新建表格，表内有数据不会清空，只会更新ddl-auto:validate运⾏程序会校验数据与数据库的字段类型是否相同，不同会报错把ddl-auto改为validate时，我们启动项⽬时，会提⽰哪⼀个字段被更改，这样我们在发布上线时，会及时发现，不⾄于出现错误。

⽽正常运⾏的时候，⼀般设置为update属性。

spring.jpa.hibernate.ddl-auto的配置spring.jpa.hibernate.ddl-auto 可以显式设置 spring.jpa.hibernate.ddl-auto ，标准的Hibernate属性值有 none，validate，update，create，create-drop。

Spring Boot 会根据数据库是否是内嵌类型，选择⼀个默认值。

理解JPA注解@GeneratedValue的使用方法

理解JPA注解@GeneratedValue的使⽤⽅法⼀、JPA通⽤策略⽣成器通过annotation来映射hibernate实体的,基于annotation的hibernate主键标识为@Id,其⽣成规则由@GeneratedValue设定的.这⾥的@id和@GeneratedValue都是JPA的标准⽤法,JPA提供四种标准⽤法,由@GeneratedValue的源代码可以明显看出.Target({METHOD,FIELD})@Retention(RUNTIME)public @interface GeneratedValue{GenerationType strategy() default AUTO;String generator() default "";}其中GenerationType:public enum GenerationType{TABLE,SEQUENCE,IDENTITY,AUTO}JPA提供的四种标准⽤法为TABLE,SEQUENCE,IDENTITY,AUTO.TABLE：使⽤⼀个特定的数据库表格来保存主键。

SEQUENCE：根据底层数据库的序列来⽣成主键，条件是数据库⽀持序列。

IDENTITY：主键由数据库⾃动⽣成（主要是⾃动增长型）AUTO：主键由程序控制。

TABLE⽐较复杂，这⾥不讲解。

分别介绍其他三个:1.SEQUENCE实体类中的注解@Id@GeneratedValue(strategy =GenerationType.SEQUENCE,generator="aaa")@SequenceGenerator(name="aaa", sequenceName="seq_payment")@SequenceGenerator定义@Target({TYPE, METHOD, FIELD})@Retention(RUNTIME)public @interface SequenceGenerator {String name();String sequenceName() default "";int initialValue() default 0;int allocationSize() default 50;}name属性表⽰该表主键⽣成策略的名称，它被引⽤在@GeneratedValue中设置的“generator”值中。

【java框架】JPA（1）--JPA入门

【java框架】JPA（1）--JPA⼊门1. JPA认识JPA是Java Persistence API的简称，它是Sun公司在充分吸收现有ORM框架（Hibernate）的基础上，开发⽽来的⼀个Java EE 5.0平台标准的开源的对象关系映射（ORM）规范。

Hibernate与JPA的关系：Hibernate是⼀个开放源代码的对象关系映射（ORM）框架，它对JDBC进⾏了⾮常轻量级的对象封装，将POJO与数据库表建⽴映射关系，是⼀个全⾃动的ORM框架，Hibernate可以⾃动⽣成SQL语句，⾃动执⾏，使Java程序员可以随⼼所欲地使⽤⾯向对象思维来操纵数据库。

⽽JPA是Sun官⽅提出的Java持久化规范，⽽JPA是在充分吸收Hibernate、TopLink等ORM框架的基础上发展⽽来的。

总结⼀句话就是：JPA是持久化的关系映射规范、接⼝API，⽽Hibernate是其实现。

1.1. JPA的优缺点优点：①操作代码很简单，插⼊—persist、修改—merge、查询—find、删除—remove；②直接⾯向持久化对象操作；③提供了世界级的数据缓存：包括⼀级缓存、⼆级缓存、查询缓存；④切换数据库移植性强，对应各种数据库抽取了⼀个⽅⾔配置接⼝，换数据库只需修改⽅⾔配置、驱动jar包、数据库连接4个信息即可。

缺点：①不能⼲预SQL语句的⽣成；②对于SQL优化效率要求较⾼的项⽬，不适合使⽤JPA；③对于数据量上亿级别的⼤型项⽬，也不适合使⽤JPA。

2. ⼿动创建⼀个Hello World的JPA项⽬2.1. 导⼊JPA项⽬所需jar包这⾥作为学习使⽤Hibernate 4.3.8的版本jar包，即JPA2.1版本为例进⾏项⽬jar包的构建：导⼊项⽬所需要的Hibernate的jar包分为三类：① Hibernate所必需的jar包：⽬录路径位置：\hibernate-release-4.3.8.Final\lib\required导⼊如下图所⽰jar包集合：②还需要导⼊JPA⽀持的jar包，⽬录路径：\hibernate-release-4.3.8.Final\lib\jpa与数据库Mysql连接驱动jar包；2.2. 配置核⼼配置⽂件persistence.xml配置⽂件必需放在项⽬的classpath⽬录的资源⽂件resources\META-INF⽬录下（JPA规范要求）；persistence.xml⽂件具体配置如下：<persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence /xml/ns/persistence/persistence_2_0.xsd"version="2.0"><persistence-unit name="cn.yif.jpa01" transaction-type="RESOURCE_LOCAL"><properties><property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver"/><property name="hibernate.connection.url" value="jdbc:mysql:///jpa01_0307"/><property name="ername" value="root"/><property name="hibernate.connection.password" value="admin"/><property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/> <property name="hibernate.hbm2ddl.auto" value="create"/><property name="hibernate.show_sql" value="true"/><property name="hibernate.format_sql" value="true"/></properties></persistence-unit></persistence>2.3.创建持久化Domain类Employeepackage cn.yif.domain;import javax.persistence.*;//@Entity表⽰该类是由jpa管理的持久化对象，对应数据库中的⼀张表@Entity//@Table表⽰对应数据库的表名@Table(name = "t_employee")public class Employee {//@Id是必须的注解，表⽰对应数据库的主键@Id//@GeneratedValue表⽰主键的⽣成策略,多数都是使⽤AUTO//@GeneratedValue默认不配置也是AUTO@GeneratedValue(strategy = GenerationType.AUTO)private Integer id;//@Column表⽰如果数据库列名与属性名不⼀致，需要配置@Column(name = "e_name")private String name;@Column(name = "e_age")private Integer age;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Employee{" +"id=" + id +", name='" + name + '\'' +", age=" + age +'}';}}2.4.创建Junit4测试类代码import cn.yif.domain.Employee;import org.junit.Test;import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.EntityTransaction;import javax.persistence.Persistence;public class JPAHelloTest {@Testpublic void testInsertEmpByJPA(){Employee employee = new Employee();employee.setName("⾼伟翔");employee.setAge(34);// 对应配置⽂件⾥⾯的persistence-unit name="cn.yif.jpa01"// 通过持久化类创建⼀个实体类管理⼯⼚EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("cn.yif.jpa01");//创建⼀个实体管理类，可以实现CRUDEntityManager entityManager = entityManagerFactory.createEntityManager();//由entityManager来开启事务EntityTransaction transaction = entityManager.getTransaction();transaction.begin();//持久操作CRUD 写⼊persistentityManager.persist(employee);// 提交事务mit();//关闭资源entityManager.close();entityManagerFactory.close();}}通过以上的步骤，就可以在创建的jpa01_0307数据库⾥⾯由JPA⾃动创建⼀张t_employee表并插⼊⼀条数据：3. 实现完整的JPA CRUD流程3.1.抽取JPAUtil类package cn.yif.utils;import javax.persistence.EntityManager;import javax.persistence.EntityManagerFactory;import javax.persistence.Persistence;/*** ⼯具类:单例模式/静态单例模式静态⽅法*/public class JPAUtil {// 私有化这个构造器,不让其它⼈创建这个类private JPAUtil(){}// 实体管理⼯⼚// 注意:EntityManagerFactory这个类是线程安全private static EntityManagerFactory entityManagerFactory;/*** 静态代码块，类加载的时候就会执⾏⾥⾯的代码，只会执⾏⼀次*/static{try {entityManagerFactory = Persistence.createEntityManagerFactory("cn.yif.jpa01");} catch (Exception e) {e.printStackTrace();throw new RuntimeException("拿到EntityManagerFactory运⾏时出错："+e.getMessage());}}// 拿到⼀个EntityManager对象// 每次拿EntityManager都需要重新创建(EntityManager不是线程安全的对象，每次使⽤都重新创建⼀次)public static EntityManager getEntityManager(){return entityManagerFactory.createEntityManager();}public static void close(EntityManager entityManager){//关闭资源entityManager.close();entityManagerFactory.close();}}4. persitence.xml中hibernate.hbm2ddl.auto属性值配置如上，hibernate.hbm2ddl.auto属性的value值⼀共有4种配置：create-drop、create、update、validate。

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>78<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>1415<property name="hbm2ddl.auto">update</property>161718<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 同上。

JPA配置详解之jpaProperties用法

JPA配置详解之jpaProperties⽤法⽬录JPA配置之jpaPropertiesSpingDataJpa配置问题spring.jpa.properties.hibernate.hbm2ddl.auto=updateJPA配置之jpaProperties<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:jpa="/schema/data/jpa"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/aop /schema/aop/spring-aop-4.1.xsd /schema/beans /schema/beans/spring-beans.xsd/schema/data/jpa /schema/data/jpa/spring-jpa-1.3.xsd/schema/tx /schema/tx/spring-tx-3.2.xsd/schema/context /schema/context/spring-context-4.1.xsd"><context:property-placeholder location="classpath*:/application.properties"/><context:component-scan base-package="com.shiroweb"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/><context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/></context:component-scan><bean id="dataSource" class="boPooledDataSource"><property name="driverClass" value="${jdbc.driver}"/><property name="jdbcUrl" value="${jdbc.url}" /><property name="user" value="${ername}"/><property name="password" value="${jdbc.password}"/></bean><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"><property name="dataSource" ref="dataSource"/><property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter"/><property name="packagesToScan" value="com.shiroweb"/><property name="jpaProperties"><props><prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props></property></bean><bean id="hibernateJpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"><property name="database" value="MYSQL" /><property name="showSql" value="true" /></bean><jpa:repositories base-package="com.shiroweb" transaction-manager-ref="transactionManager" entity-manager-factory-ref="entityManagerFactory"/> <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"><property name="entityManagerFactory" ref="entityManagerFactory"/></bean><tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" /></beans>其中jpaProperties是这是jpa的⼀些属性的<property name="jpaProperties"><props><prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props></property>这⾥有个属性为<prop key="hibernate.hbm2ddl.auto">update</prop>这是⼀个有⽤的设置其实这个hibernate.hbm2ddl.auto参数的作⽤主要⽤于：⾃动创建|更新|验证数据库表结构。

hibernate注解简介

在最近发布的几个Hibernate版本中，出现了一种基于 Java 5 注释的更为巧妙的新方法。借助新的 Hibernate Annotation 库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的 Java 类中，并提供一种强大及灵活的方法来声明持久性映射。籍由自动代码完成和语法突出显示功能，最近发布的Java IDE也为其提供了有力的支持。
@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>

jpa中使用的注释

jpa中使用的注释
在JPA（Java Persistence API）中，有多种注释用于映射实
体类与数据库表之间的关系，以及定义持久化属性。

以下是一些常
用的JPA注释：
1. @Entity，用于标识一个Java类是一个JPA实体，将其映射
到数据库表中。

2. @Table，指定实体与数据库表的映射关系，可以指定表名、schema等属性。

3. @Id，用于标识实体的主键属性。

4. @GeneratedValue，指定主键的生成策略，如自增、序列等。

5. @Column，用于指定实体属性与数据库表列的映射关系，可
以指定列名、长度、是否可空等属性。

6. @Transient，标识一个属性不需要持久化到数据库中。

7. @OneToOne，定义一对一关联关系。

8. @OneToMany，定义一对多关联关系。

9. @ManyToOne，定义多对一关联关系。

10. @ManyToMany，定义多对多关联关系。

11. @JoinColumn，用于指定关联关系中的外键列。

这些注释可以帮助开发人员在实体类中定义与数据库表之间的
映射关系，以及定义实体属性的持久化方式。

通过合理使用这些注释，可以更好地实现对象与关系数据库之间的映射，提高开发效率
并减少重复的代码编写。

同时，这些注释也提供了灵活的配置选项，可以满足不同场景下的需求。

通过JPA注解映射视图的实体类jpa视图无主键@Query注解的用法（SpringData。。。

通过JPA注解映射视图的实体类jpa视图⽆主键@Query注解的⽤法（SpringData。

这⾥主要说⼀下怎么⽤jpa映射⼀个视图的实体类，其实跟表映射⼀样，就是需要添加⼀个空的主键id标识package com.cf.bus.core.rs.template.domain;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name = "v_sc_template") // 这个是视图名称public class SupplyChainTemplate {@Id // 添加⼀个空的id标识，因为jpa在映射实体是需要⼀个id，这个必须@Column(name = "name")private String name;@Column(name = "industry")private String industry;@Column(name = "com_type")private String comType;@Column(name = "remarks")private String remarks;public String getName() {return name;}public void setName(String name) { = name;}public String getIndustry() {return industry;}public void setIndustry(String industry) {this.industry = industry;}public String getComType() {return comType;}public void setComType(String comType) {Type = comType;}public String getRemarks() {return remarks;}public void setRemarks(String remarks) {this.remarks = remarks;}}@id⼀定要有，否则会报构建entityManagerFactory异常。

JPA使用指南javax.persistence的注解配置

JPA使用指南javax.persistence的注解配置JPA使用指南 javax.persistence的注解配置文章分类:Java编程JPA注解持久化类很方便，需要jar包：ejb3-persistence.jar。

我用以下三个类来说明用法。

sh原创转载请注明：Java代码1.@SuppressWarnings("serial")2.@Entity3.@Table(name="T_X")4.public class X implements Serializable5.{6.@Id7.@GeneratedValue(strategy = GenerationType.AUTO)8.private int id;9.10.@Column(length=32)11.private String name;12.13.@Transient//表示此数据不在数据库表里建立属性14.private String temp;15.16.@Temporal(TemporalType.TIMESTAMP) //这个是带时分秒的类型17.private Date date;18.19.@OneT oOne(cascade = CascadeType.ALL, mappedBy = "x")20.private A a;22.@SuppressWarnings("serial")23.@Entity24.@Table(name="T_A")25.public class A implements Serializable26.{27.@Id28.@GeneratedValue(strategy = GenerationType.AUTO)29.private int id;30.31.@OneT oMany(cascade = CascadeType.ALL, mappedBy = "a", fetch = FetchType.EAGER)32.private List<B> b = new ArrayList<B>();33.34.@OneT oOne()35.@JoinColumn(name = "x_Id") //加这句后就会双方共同维护关系36.private X x;37.}38.39.@SuppressWarnings("serial")40.@Entity41.public class B implements Serializable{42.@Id43.@GeneratedValue(strategy = GenerationType.AUTO)44.protected int id;45.46.@ManyToOne()47.@JoinColumn(name = "a_id")48.protected A a;要注意的是：fetch = FetchType.EAGER这句话在一个类里面只能出现一次，出现两次就会报错“cannot simultaneously fetch multiple bags”，要把其他的改为fetch = ZY延迟加载就可以了。

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{}