hibernate

org.hibernate.Session or javax.persistence.EntityManager

DomesticCat fritz = new DomesticCat();
fritz.setColor( Color.GINGER );
fritz.setSex( 'M' );
fritz.setName( "Fritz" );
session.save( fritz );
DomesticCat fritz = new DomesticCat();
fritz.setColor( Color.GINGER );
fritz.setSex( 'M' );
fritz.setName( "Fritz" );
entityManager.persist( fritz );

session.delete( fritz );

entityManager.remove( fritz );//删除

//Example of obtaining an entity reference without initializing its data lazy load
Book book = new Book();
book.setAuthor( session.byId( Author.class ).getReference( authorId ) );
Book book = new Book();
book.setAuthor( entityManager.getReference( Author.class, authorId ) );

//Example of obtaining an entity reference with its data initialized
session.byId( Author.class ).load( authorId );
entityManager.find( Author.class, authorId );

import java.lang.String;

@Entity
public class User {
    @Id
    @GeneratedValue
    Long id;

    @NaturalId
    String system;

    @NaturalId
    String userName;

    ...
}

// use getReference() to create associations... 获取
Resource aResource = (Resource) session.byId( Resource.class ).getReference( 123 );
User aUser = (User) session.byNaturalId( User.class )
        .using( "system", "prod" )
        .using( "userName", "steve" )
        .getReference();
aResource.assignTo( user );


// use load() to pull initialzed data
return session.byNaturalId( User.class )
        .using( "system", "prod" )
        .using( "userName", "steve" )
        .load();

//Example of refreshing entity state更新

Cat cat = session.get( Cat.class, catId );
...
session.refresh( cat );
Cat cat = entityManager.find( Cat.class, catId );
...
entityManager.refresh( cat );

//Example of modifying managed state修改

Cat cat = session.get( Cat.class, catId );
cat.setName( "Garfield" );
session.flush(); // generally this is not explicitly needed
Cat cat = entityManager.find( Cat.class, catId );
cat.setName( "Garfield" );
entityManager.flush(); // generally this is not explicitly needed

事务

Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();

String hqlInsert = "insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...";
int createdEntities = session.createQuery( hqlInsert )
        .executeUpdate();
tx.commit();
session.close();

hibernate annotation

http://docs.jboss.org/hibernate/annotations/3.4/reference/zh_cn/html_single/ 

@Entity 将一个类声明为一个实体bean(即一个持久化POJO类)
@Id　　声明了该实体bean的标识属性
@Table　　为实体bean映射指定表(table),目录(catalog)和schema的名字. 如果没有定义@Table,那么系统自动使用默认值
@Version　　添加对乐观锁定的支持,乐观锁：数据库增加一个version的字段，读取数据时将version一起读出，更新数据时，1:将version＋1，2:如果更新后的version大于此时数据库version，则更新数据，否则数据过期
@Column 　　注解可将属性映射到列
@Transient, entity manager将忽略这些字段和属性
@Basic　　　可持久化和可获取的，fetch = FetchType.LAZY延迟读取

@embeddable　　　　表示类是嵌入类。
@embedded　　　　表示该属性的类是嵌入类。

@Embeddable
public class Name implements Serializable {
    private String firstName;
    private String lastName;
    // ...
}

public class Person {
    @Embedded
    @AttributeOverrides({
            @AttributeOverride(name = "firstName", column = @Column(name = "first_name")),//person属性name的firstName映射到person对应的table中的first_name列
            @AttributeOverride(name = "lastName", column = @Column(name = "last_name")) })
    public Name getName() {
        return name;
    }
}

@GeneratedValue，这注解里面有一些属性，其中一个是策略strategy，生成主键值的方案
1) AUTO： JPA自动选择合适的策略，是默认选项；
2) IDENTITY：采用数据库ID自增长的方式来生成主键值，Oracle不支持这种方式；
3) SEQUENCE：通过序列产生主键，通过@SequenceGenerator注解指定序列名，MySql不支持这种方式；
4) TABLE：采用表生成方式来生成主键值，那怎么样生成呢？很简单，表里面通常有两个字段，第一个字段是给它一个名称（就是个列名而已），第二个字段专门用来累加用的，就是说没访问一次这个表呢，那么第二个字段就会累加1，不断累加。就是说你们要得到这个主键值的话，访问这个表，然后update这个表的这个字段，把它累加1之后，然后再把这个值取出来作为主键，再给他赋进去，表生成就是这样。

@Id @GeneratedValue(strategy=GenerationType.SEQUENCE, generator="SEQ_STORE")
public Integer getId() { ... }

@OneToOne

@Entity
public class Customer implements Serializable {
    @OneToOne(cascade = CascadeType.ALL)//一对一
    @JoinColumn(name="passport_fk")//Customer 通过Customer 表中名为的passport_fk 外键列和 Passport关联,如果在主体没有声明@JoinColumn,系统自动进行处理： 在主表(owner table)中将创建联接列, 列名为：主体的关联属性名＋下划线＋被关联端的主键列名. 在上面这个例子中是passport_id
    public Passport getPassport() {
        ...
    }

@Entity
public class Passport implements Serializable {
    @OneToOne(mappedBy = "passport")
    public Customer getOwner() {
    ...
}

//第二种
@Entity
public class Body {
    @Id
    public Long getId() { return id; }

    @OneToOne(cascade = CascadeType.ALL)
    @PrimaryKeyJoinColumn//使用注解@PrimaryKeyJoinColumn定义了一对一关联.
    public Heart getHeart() {
        return heart;
    }
    ...
}
         
@Entity
public class Heart {
    @Id
    public Long getId() { ...}
}

//通过关联表

@Entity
public class Customer implements Serializable {
    @OneToOne(cascade = CascadeType.ALL)
    @JoinTable(name = "CustomerPassports",
        joinColumns = @JoinColumn(name="customer_fk"),
        inverseJoinColumns = @JoinColumn(name="passport_fk")
    )
    public Passport getPassport() {
        ...
    }

@Entity
public class Passport implements Serializable {
    @OneToOne(mappedBy = "passport")
    public Customer getOwner() {
    ...
}
    

@manytoone

@Entity()
public class Flight implements Serializable {
    @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE}, targetEntity=CompanyImpl.class )
    @JoinColumn(name="COMP_ID")
    public Company getCompany() {
        return company;
    }
    ...
}

public interface Company {
        @OneToMany(appedBy="Flight", cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
    private List<Flight> lists = new ArrayList();
}

@Enumerated

@Enumerated(EnumType.STRING)
Starred getNote() { ... } //enum persisted as String in database