Hibernate使用总结

一、什么是注解？

　　解析：来源：Hibernate提供了Hibernate Annotations扩展包，它可以替换复杂的hbm.xml文件（ Annotations扩展包是hibernate-annotation-3.4.0GA.zip）

　　　　　作用：使得Hibernate程序的开发大大的简化。利用注解后，可不用定义持久化类对应的*.hbm.xml,而直接以注解方式写入持久化类的实现中。

二、注解配置持久化类常用注解。

【hibernate】常用注解

转载：https://www.cnblogs.com/yangchongxing/p/10357118.html

目录

========================================================

1、@Entity 实体

2、@Table 表

3、@Id 和 @GeneratedValue 主键及生成策略

4、@Column 列

5、@DynamicInsert 和 @DynamicUpdate 动态字段

6、@Immutable 不变实体

7、@Basic 非空约束

8、@NotNull 非空检查

9、@Access 属性访问

10、@Formula 派生属性

11、@ColumnTransformer 转换列值

12、@Generated 默认值

13、@Temporal 时序属性

14、@CreationTimestamp和@UpdateTimestamp 创建时间戳和更新时间戳

15、@Enumerated 枚举类型

16、@Embeddable 可嵌入组件

17、@Lob 大数据类型

18、@Type 类型适配器

19、@Convert 转换器

20、@MappedSuperclass 不持久化超类属性

21、@AttributeOverrides 和 @AttributeOverride 重写属性

22、@Inheritance 继承策略

========================================================

1、@Entity 实体

声明持久化实体，不带 name 参数时表明和实体名相同，带参数重写表明 @Entity(name="ycx_user")

2、@Table 表

重写表名 @Table(name="ycx_user")

3、@Id 和 @GeneratedValue 主键及生成策略

主键和主键生成策略 @GeneratedValue(generator="id_generator") 或者 @GeneratedValue(strategy=GenerationType.SEQUENCE)

4、@Column 列

name="列名"

table=“列属表名”

nullable=false 不能为空，生成非空约束

length=3 字段长度

insertable=false 不包含 INSERT

updatable=false 不包含 UPDATE

列声明 @Column(name="表明", nullable=false)，nullable=false 声明数据库非空约束

5、@DynamicInsert 和 @DynamicUpdate 动态字段

动态 SQL 生成，@DynamicInsert 和 @DynamicUpdate，通过启用动态插入和更新，就可以告知 hibernate 在需要时生成 SQL 字符串

6、@Immutable 不变实体

让实体不可变，这样 hibernate 永远不会执行 update 语句，同时可以进行一些优化，比如对不可变类不进行脏检查。

7、@Basic 非空约束

@Basic(optional=false) 声明数据库非空约束

8、@NotNull 非空检查

@NotNull(message="消息内容")，实体非空注解，但是这个在生成数据库结构时会被忽略，在实体保存校验时起作用。

要想在数据库中生成非空约束，必须结合 @Column(nullable=false) 或者 @Basic(optional=false)

9、@Access 属性访问

重写默认的访问行为，字段访问或者属性访问，已经注解过的实体会从强制的 @Id 注解位置继承访问行为，@Id 在字段上则继承字段访问，在 getter 方法上则继承属性访问。

@Access(AccessType.FIELD) 字段访问

@Access(AccessType.PROPERTY) 属性访问

当 @Access 在实体级别设置则会影响实体的所有访问策略，同样 @Access 也可以重写单个属性的访问策略

若默认是字段访问，在字段上添加 @Access(AccessType.PROPERTY) 则被修改为属性访问

若默认是属性访问，在 getter 方法上添加 @Access(AccessType.FIELD) 则被修改为字段访问

10、@Formula 派生属性

运行时通过 @Formula 估算出来，不会出现在 UPDATE 和 INSERT 中，只会出现在 SELECT 中，可以包含 SQL 函数和子查询。

例如 数据库中没有全名而实体中有 @Formula("concat(firstname,‘-‘,lastname)")

11、@ColumnTransformer 转换列值

数据库中存储重量 weight 单位是克，实体中使用千克

@Column(name="weight")
    @org.hibernate.annotations.ColumnTransformer(read="weight / 1000",write="? * 1000")
    protected int kilogramWeight;

12、@Generated 默认值

自动刷新数据库生成的值，如触发器在每次插入和更新后更新的值。使用 @Generated 注解在每次执行 INSERT 和 UPDATE 后委托给 Hibernate 自动查询。

比如插入用户后给一个默认国籍

触发器

BEGIN
set new.nationality = ‘CN‘;
END

java

    @Column(insertable=false,updatable=false)
    @org.hibernate.annotations.ColumnDefault("‘CN‘") //在 Hibernate 导出 SQL 架构 DDL 时设置列的默认值
    @org.hibernate.annotations.Generated(org.hibernate.annotations.GenerationTime.INSERT)
    protected String nationality;

测试

    @Test
    public void testInsert() {
        this.session.beginTransaction();
        User u = new User();
        u.setUsername("admin");
        u.setFirstname("Tom");
        u.setLastname("Green");
        u.setKilogramWeight(62);
        this.session.persist(u);
        this.session.getTransaction().commit(); //事务提交后才能得到最新的值
        System.out.println(u.getId() + " Hibernate 自动刷新数据库触发器生成的值：" + u.getNationality());
        assertTrue( true );
    }

 13、@Temporal 时序属性

JPA 规范要求使用 @Temporal 注解时序属性，以声明所映射列的准确 SQL 数据库类型。当没有提供时 Hibernate 会默认使用 TemporalType.TIMESTAMP。

Java时序类型 java.util.Date;、java.util.Calendar;、java.sql.Date;、java.sql.Time;、java.sql.Timestamp;

TemporalType 选项 DATE、TIME、TIMESTAMP

14、@CreationTimestamp和@UpdateTimestamp 创建时间戳和更新时间戳

当没有提供 @Temporal 时 Hibernate 会默认使用 TemporalType.TIMESTAMP

    @Temporal(TemporalType.TIMESTAMP)
    @Column(updatable=false)
    @org.hibernate.annotations.CreationTimestamp
    protected Date createOn;
    @Temporal(TemporalType.TIMESTAMP)
    @Column(insertable=false)
    @org.hibernate.annotations.UpdateTimestamp
    protected Date updateOn;

 当执行插入时 Hibernate 自动给 createOn 赋值，当执行更新时 Hibernate 自动给 updateOn 赋值。

15、@Enumerated 枚举类型

默认 Hibernate 会存储 EnumType.ORDINAL 位置，这种很脆弱。EnumType.STRING 存储枚举值的标签，这样变更不会影响

    @Enumerated(EnumType.STRING)
    private Sex sex;

 16、@Embeddable 可嵌入组件

@Embeddable
public class Address {
    @NotNull
    @Column(nullable=false)
    protected String street;
    
    @NotNull
    @Column(nullable=false)
    protected String zipcode;
    
    @NotNull
    @Column(nullable=false)
    protected String city;
    
    public Address() {}
    public Address(String street,String zipcode,String city) {
        this.street = street;
        this.zipcode = zipcode;
        this.city = city;
    }
    @Override
    public String toString() {
        return "Address [street=" + street + ", zipcode=" + zipcode + ", city=" + city + "]";
    }
}

嵌入式组件

    protected Address address;

重写嵌入式组件

    @AttributeOverrides({
        @AttributeOverride(name="street",column=@Column(name="billing_street")),
        @AttributeOverride(name="zipcode",column=@Column(name="billing_zipcode")),
        @AttributeOverride(name="city",column=@Column(name="billing_city"))
    })
    protected Address billingAddress;

 17、@Lob

二进制数据和大数据

18、@Type 类型适配器

    @org.hibernate.annotations.Type(type="yes_no")
    protected boolean verify;

    @org.hibernate.annotations.Type(type="true_false")
    protected boolean verify;

 19、@Convert 转换器

    @Convert(converter = MoneyConverter.class,disableConversion=false)
    protected Money money;

 20、@MappedSuperclass 不持久化超类属性

使用 @Entity 映射具体类，要想超类的属性被忽略并且不持久化，则必须使用  @MappedSuperclass

21、@AttributeOverrides 和 @AttributeOverride 重写属性

子类重写从父类继承的字段和属性

类重写嵌入式字段和属性

 22、@Inheritance 继承策略

@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) 每个带有联合的具体类使用一个表

@Inheritance(strategy=InheritanceType.SINGLE_TABLE) 每个类层次结构使用一个表

@Inheritance(strategy=InheritanceType.JOINED)

=====================================================================================================

Hibernate常用查询方式

hibernate的查询方式常见的主要分为三种: HQL, QBC（命名查询）, 以及使用原生SQL查询（SqlQuery）

一、HQL查询

• HQL（Hibernate Query Language）提供了丰富灵活的查询方式，使用HQL进行查询也是Hibernate官方推荐使用的查询方式。

• HQL在语法结构上和SQL语句十分的相同，所以可以很快的上手进行使用。使用HQL需要用到Hibernate中的Query对象，该对象专门执行HQL方式的操作。

查询所有示例

1.  
   session.beginTransaction();
2.  
   String hql = "from User"; // from 后跟的是要查询的对象，而不是表
3.  
   Query query = session.createQuery(hql);
4.  
   List<User> userList = query.list();
5.  
   for(User user:userList){
6.  
   System.out.println(user.getUserName());
7.  
   }
8.  
   session.getTransaction().commit();

带where的查询示例

1.  
   session.beginTransaction();
2.  
   String hql = "from User where userName = ‘James‘";
3.  
   Query query = session.createQuery(hql);
4.  
   List<User> userList = query.list();
5.  
   for(User user:userList){
6.  
   System.out.println(user.getUserName());
7.  
   }
8.  
   session.getTransaction().commit();
9.  
   /*
10.  
    在HQL中where语句中使用的是持久化对象的属性名，如上面示例中的userName。当然在HQL中也可以使用别名
11.  
    */
12.  
    String hql = "from User as u where u.userName = ‘James‘";
13.  
    /*
14.  
    过滤条件
15.  
    在where语句中还可以使用各种过滤条件，如：=、<>、<、>、>=、<=、between、not between、
16.  
    in、not in、is、like、and、or等
17.  
    */

获取一个不完整的对象

1.  
   session.beginTransaction();
2.  
   String hql = "select userName from User";
3.  
   Query query = session.createQuery(hql);
4.  
   List<Object> nameList = query.list();
5.  
   for(Object obj:nameList){
6.  
   　　 String name=(String)obj;
7.  
   　　 System.out.println(name);
8.  
   }
9.  
   session.getTransaction().commit();
10.  
    // 多个属性的话，需要用object[]接收
11.  
    session.beginTransaction();
12.  
    String hql = "select userName,userPwd from User";
13.  
    Query query = session.createQuery(hql);
14.  
    List nameList = query.list();
15.  
    for(Object obj:nameList){
16.  
    Object[] array = (Object[]) obj; // 转成object[]
17.  
    System.out.println("name:" + array[0]);
18.  
    System.out.println("pwd:" + array[1]);
19.  
    }
20.  
    session.getTransaction().commit();

统计和分组查询

1.  
   session.beginTransaction();
2.  
   String hql = "select count(*),max(id) from User";
3.  
   Query query = session.createQuery(hql);
4.  
   List nameList = query.list();
5.  
   for(Object obj:nameList){
6.  
   Object[] array = (Object[]) obj;
7.  
   System.out.println("count:" + array[0]);
8.  
   System.out.println("max:" + array[1]);
9.  
   }
10.  
    session.getTransaction().commit();
11.  
    /*
12.  
    该条sql语句返回的是单条数据，所以还可以这样写
13.  
    单列数据用Object，多列数据用Object[]
14.  
    */
15.  
    Object[] object = (Object[]) query.uniqueResult();
16.  
    System.out.println("count:" + object[0]);
17.  
    System.out.println("max:" + object[1]);

更多写法

1.  
   select distinct name from Student;
2.  
   select max(age) from Student;
3.  
   select count(age),age from Student group by age;
4.  
   from Student order by age;

HQL占位符

1.  
   session.beginTransaction();
2.  
   String hql = "from User where userName = ?";
3.  
   Query query = session.createQuery(hql);
4.  
   // 索引从0开始
5.  
   query.setString(0, "James");
6.  
   List<User> userList = query.list();
7.  
   for(User user:userList){
8.  
   System.out.println(user.getUserName());
9.  
   }
10.  
    session.getTransaction().commit();

HQL引用占位符

1.  
    
2.  
   session.beginTransaction();
3.  
   String hql = "from User where userName = :name";
4.  
   Query query = session.createQuery(hql);
5.  
   query.setParameter("name", "James");
6.  
   List<User> userList = query.list();
7.  
   for(User user:userList){
8.  
   System.out.println(user.getUserName());
9.  
   }
10.  
    session.getTransaction().commit();

HQL分页

1.  
   session.beginTransaction();
2.  
   String hql = "from User";
3.  
   Query query = session.createQuery(hql);
4.  
   query.setFirstResult(0);
5.  
   query.setMaxResults(2);
6.  
   List<User> userList = query.list();
7.  
   for(User user:userList){
8.  
   System.out.println(user.getUserName());
9.  
   }
10.  
    session.getTransaction().commit();

二、QBC（Query By Criteria）查询

• Criteria对象提供了一种面向对象的方式查询数据库。Criteria对象需要使用Session对象来获得。

• 一个Criteria对象表示对一个持久化类的查询。

查询所有

1.  
   session.beginTransaction();
2.  
   Criteria c = session.createCriteria(User.class);
3.  
   List<User> userList = c.list();
4.  
   for(User user:userList){
5.  
   System.out.println(user.getUserName());
6.  
   }
7.  
   session.getTransaction().commit();

where

1.  
   session.beginTransaction();
2.  
   Criteria c = session.createCriteria(User.class);
3.  
   c.add(Restrictions.eq("userName", "James"));
4.  
   List<User> userList = c.list();
5.  
   for(User user:userList){
6.  
   System.out.println(user.getUserName());
7.  
   }
8.  
   session.getTransaction().commit();

Restrictions对象

1.  
   方法名称 对应SQL中的表达式
2.  
   ----------------------------------------------------------
3.  
   Restrictions.eq field = value
4.  
   Restrictions.gt field > value
5.  
   Restrictions.lt field < value
6.  
   Restrictions.ge field >= value
7.  
   Restrictions.le field <= value
8.  
   Restrictions.between field between value1 and value2
9.  
   Restrictions.in field in(…)
10.  
    Restrictions.and and
11.  
    Restrictions.or or
12.  
    Restrictions.like field like value
13.  
     

示例

1.  
   Criteria c = session.createCriteria(User.class);
2.  
   c.add(Restrictions.like("userName", "J"));
3.  
   c.add(Restrictions.eq("id", 120));
4.  
   c.add(Restrictions.or(Restrictions.eq("userName", "James"),
5.  
   Restrictions.eq("userName", "Alex")));

获取唯一记录

1.  
   session.beginTransaction();
2.  
   Criteria c = session.createCriteria(User.class);
3.  
   c.add(Restrictions.eq("id", 120));
4.  
   User user = (User) c.uniqueResult();
5.  
   System.out.println(user.getUserName());
6.  
   session.getTransaction().commit();

分页

1.  
   Criteria c = session.createCriteria(User.class);
2.  
   c.setFirstResult(0);
3.  
   c.setMaxResults(5);

分组与统计

1.  
   session.beginTransaction();
2.  
   Criteria c = session.createCriteria(User.class);
3.  
   c.setProjection(Projections.sum("id"));
4.  
   Object obj = c.uniqueResult();
5.  
   System.out.println(obj);
6.  
   session.getTransaction().commit();

Projections对象

1.  
   方法名称 描述
2.  
   -------------------------------------------------------
3.  
   Projections.sum 等于SQL中聚合函数sum
4.  
   Projections.avg 等于SQL中聚合函数avg
5.  
   Projections.count 等于SQL中聚合函数count
6.  
   Projections .distinct 去除重复记录
7.  
   Projections.max 等于SQL中聚合函数max
8.  
   Projections.min 等于SQL中聚合函数min
9.  
   Projections .groupProperty 对指定的属性进行分组查询

多个统计与分组

1.  
   session.beginTransaction();
2.  
   Criteria c = session.createCriteria(User.class);
3.  
   ProjectionList projectionList = Projections.projectionList();
4.  
   projectionList.add(Projections.sum("id"));
5.  
   projectionList.add(Projections.min("id"));
6.  
   c.setProjection(projectionList);
7.  
   // 和HQL一样，单列用Object，多列用Object[]
8.  
   Object[] obj = (Object[]) c.uniqueResult();
9.  
   System.out.println("sum:" + obj[0]);
10.  
    System.out.println("min:" + obj[1]);

排序

1.  
   Criteria c = session.createCriteria(User.class);
2.  
   c.addOrder(Order.desc("id"));

三、原生SQL查询：

示例

1.  
   session.beginTransaction();
2.  
   String sql = "select id,username,userpwd from t_user";
3.  
   List list = session.createSQLQuery(sql).list();
4.  
   for(Object item : list){
5.  
   Object[] rows = (Object[]) item;
6.  
   System.out.println("id:" + rows[0] + "username:"
7.  
   + rows[1] + "userpwd:" + rows[2]);
8.  
   }
9.  
   session.getTransaction().commit();

addEntity()示例

1.  
   session.beginTransaction();
2.  
   String sql = "select id,username,userpwd from t_user";
3.  
   // addEntity()可以告诉Hibernate你想要封装成对象的类型，然后自动为你封装
4.  
   SQLQuery query = session.createSQLQuery(sql).addEntity(User.class);
5.  
   List<User> list = query.list();
6.  
   for(User user : list){
7.  
   System.out.println(user.getUserName());
8.  
   }
9.  
   session.getTransaction().commit();

uniqueResult示例

1.  
   session.beginTransaction();
2.  
   String sql = "select id,username,userpwd from t_user where id = 2";
3.  
   SQLQuery query = session.createSQLQuery(sql).addEntity(User.class);
4.  
   User user = (User) query.uniqueResult();
5.  
   System.out.println(user.getUserName());
6.  
   session.getTransaction().commit();

转载地址：https://blog.csdn.net/u010963948/article/details/16818043