1. Embedded 内嵌类 - @Embeddable
2. 多个同类型内嵌类
3. 内嵌类中还有内嵌类
4. 类型转换 - 基本类型和数值
5. 类型转换 - 字符类型
6. 类型转换 - 时间类型
7. 类型转换 - 二进制和大数字
8. 类型转换 - 将类转换成一个值
9. 类型转换 - 转换继承体系的类

Embedded 内嵌类

import javax.persistence.Column;
import javax.persistence.Embeddable;
import javax.validation.constraints.NotNull;

//被@Embeddable注解的类, 内部不需要一个@Id注解
@Embeddable
public class Address {

    //验证所用, 创建表格时候不看@NotNull
    @NotNull

    //@Column建表的时候参考这个注解, 这个相当于 not null 约束
    @Column(nullable = false)
    protected String street;

    @NotNull
    //length控制长度, 这里相当于varchar(5), 覆盖了默认的varchar(255)的设定
    @Column(nullable = false, length = 5)
    protected String zipcode;

    @NotNull
    @Column(nullable = false)
    protected String city;

    protected Address() {
    }

    public Address(String street, String zipcode, String city) {
        this.street = street;
        this.zipcode = zipcode;
        this.city = city;
    }

    ......
}

import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
import java.math.BigDecimal;

@Entity
@Table(name = "USERS")
public class User implements Serializable {

    @Id
    @GeneratedValue()
    protected Long id;

    protected String username;

    protected Address homeAddress;

    public User() {
    }

    public Long getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Address getHomeAddress() {
        return homeAddress;
    }

    public void setHomeAddress(Address homeAddress) {
        this.homeAddress = homeAddress;
    }

    ......

}

@Test
public void test() {
    EntityManagerFactory emf =
            Persistence.createEntityManagerFactory("HelloWorldPU");
    EntityManager em = emf.createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();

    //创建Address对象
    Address address = new Address("owlroad", "12345", "Shanghai");

    //创建User对象并设置地址
    User user = new User();
    user.setUsername("cony");
    user.setHomeAddress(address);

    em.persist(user);

    tx.commit();

    //查询
    tx.begin();
    List<User> result = em.createQuery("SELECT u FROM User u",User.class).getResultList();
    System.out.println(result);
    tx.commit();
}

Hibernate:
    create table USERS (
        id int8 not null,
        city varchar(255) not null,
        street varchar(255) not null,
        zipcode varchar(5) not null,
        username varchar(255),
        primary key (id)
    )

insert
    into
        USERS
        (city, street, zipcode, username, id)
    values
        (?, ?, ?, ?, ?)

多个同类型内嵌类

@Entity
@Table(name = "USERS")
public class User implements Serializable {

    ......

    @NotNull
    @AttributeOverrides({
        @AttributeOverride(name = "street",
                column = @Column(name = "BILLING_STREET")),
        @AttributeOverride(name = "zipcode",
                column = @Column(name = "BILLING_ZIPCODE", length = 10)),
        @AttributeOverride(name = "city",
                column = @Column(name = "BILLING_CITY"))
    })
    protected Address billingAddress;

    ......
}

@Test
public void test2() {
    EntityManagerFactory emf =
            Persistence.createEntityManagerFactory("HelloWorldPU");
    EntityManager em = emf.createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();

    //创建Address对象和billingAddress对象
    Address homeAddress = new Address("owlroad", "12345", "Shanghai");
    Address billingAddress = new Address("timberroad", "66666", "Shanghai");

    //创建User对象并设置地址
    User user = new User();
    user.setUsername("cony");
    user.setHomeAddress(homeAddress);
    user.setBillingAddress(billingAddress);

    em.persist(user);

    tx.commit();

    tx.begin();
    List<User> result = em.createQuery("SELECT u FROM User u", User.class).getResultList();

    for (User u : result) {
        System.out.println(u);
    }

    tx.commit();
}

Hibernate:
create table USERS (
   id int8 not null,
    BILLING_CITY varchar(255),
    BILLING_STREET varchar(255),
    BILLING_ZIPCODE varchar(10),
    city varchar(255) not null,
    street varchar(255) not null,
    zipcode varchar(5) not null,
    username varchar(255),
    primary key (id)
)

User{id=40, username='cony', homeAddress=Address{street='owlroad', zipcode='12345', city='Shanghai'},
    billingAddress=Address{street='timberroad', zipcode='66666', city='Shanghai'}}

内嵌类中还有内嵌类

import javax.persistence.Column;
import javax.persistence.Embeddable;
import javax.validation.constraints.NotNull;

@Embeddable
public class City {

    @NotNull
    @Column(nullable = false)
    private String cityName;

    @NotNull
    @Column(length = 5)
    private String zipcode;

    ......

}

@Embeddable
public class Address {

    @NotNull
    @Column(nullable = false)
    protected String street;

    @NotNull
    @AttributeOverrides({
            @AttributeOverride(name = "cityName",
                    column = @Column(name = "addname")),
            @AttributeOverride(name = "zipcode",
                    column = @Column(name = "addzip", length = 10))
    })
    protected City city;

    ......
}

@Test
public void test3() {
    EntityManagerFactory emf =
            Persistence.createEntityManagerFactory("HelloWorldPU");
    EntityManager em = emf.createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();

    City city = new City();
    city.setCityName("shanghai");
    city.setZipcode("66666");

    Address address = new Address();
    address.setStreet("kiwiroad");
    address.setCity(city);

    User user = new User();
    user.setUsername("cony");
    user.setHomeAddress(address);

    em.persist(user);

    tx.commit();
}

类型转换 - 基本类型和数值

类型转换 - 字符类型

1. 纯粹存放字符的话, 一般数据库都有若干种实现, Hibernate是根据长度和方言来确定使用何种字符类型的. Hibernate默认的所有字符串映射是varchar(255), 可以在@Column中设置length.
2. 很多数据库都提供了UTF-8支持, 如果想细粒度的控制, 尤其是NVARCHAR, NCHAR等要求使用UTF-8的类型, 可使用@org.hibernate.annotations.Nationalized. 不过如今一些数据库默认编码就是UTF-8, 也可以不使用该设置.
3. 很多数据库比如PgSQL对于布尔类型可以使用多种方式表示, 结合方言和这里的规则具体使用.

类型转换 - 时间类型

1. java.sql.3种类型可以直接对应具体数据库类型.
2. 一般使用java.util.Date对象也可以, 通过TemporalType.DATE/TIME/TIMESTAMP三种类型指定具体映射关系.
3. java.util.Date类型精确到毫秒, 而java.sql.Timestamp精确到纳秒. Hibernate在将TIMESTAMP转换成Java的Date类型的时候会保留到纳秒的信息, 结果就是不能简单的通过.equals()比较两个时间. 而是要通过取出时间日期属性的时候来比较.

类型转换 - 二进制和大数字

1. 如果一个Java属性是byte[], 会映射到VARBINARY, 但是实际采用的SQL属性还是需要结合方言和数据库决定. 比如在PgSQL中, 是BYTEA类型.
2. 通常情况下String映射到VARCHAR,但是长度太长的时候, 就会映射为text, 从而使用CLOB.
3. 如果想强制byte[]使用CLOB或者BLOB属性, 就采用@Lob注解即可:

       @Entity
           public class Item {
           @Lob
           protected byte[] image;
           @Lob
           protected String description;
           // ...
       }
   

   这会让byte[]变成BLOB, 而对String采用CLOB, 这也是将String映射成为text类型最简单的方法.
4. 对于LOB系列, JDBC会延迟加载, 即在加载对象的时候, LOB类型的属性只是一个占位符, 需要的时候可以采取流的方式读出来, 或者复制到一个输出流中. 比如:

       Item item = em.find(Item.class, ITEM_ID);
       InputStream imageDataStream = item.getImageBlob().getBinaryStream();
       ByteArrayOutputStream outStream = new ByteArrayOutputStream();
       StreamUtils.copy(imageDataStream, outStream);
       byte[] imageBytes = outStream.toByteArray();
   

5. 对于Hibernate来说, 提供了一些辅助工具用于方便的读取流, 比如:

       Session session = em.unwrap(Session.class);
       Blob blob = session.getLobHelper().createBlob(imageInputStream, byteLength);
       someItem.setImageBlob(blob);
       em.persist(someItem);
   

6. Hibernate对于无法映射的二进制类型, 如果是类型是Serializable, 会将其按照序列化之后的二进制, 以VARBINARY类型保存在数据库中. 但是一般来说不要如此使用, 因为这会让Java对象的生存周期超过应用的周期, 将来谁也不知道数据库里存了什么东西.

@Entity
public class Item {
@org.hibernate.annotations.Type(type = "yes_no")
    protected boolean verified = false;
}

类型转换 - 将类转换成一个值

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Currency;

public class MonetaryAmount implements Serializable {

    protected final BigDecimal value;
    protected final Currency currency;

    public MonetaryAmount(BigDecimal value, Currency currency) {
        this.value = value;
        this.currency = currency;
    }

    public BigDecimal getValue() {
        return value;
    }

    public Currency getCurrency() {
        return currency;
    }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof MonetaryAmount)) return false;

        final MonetaryAmount monetaryAmount = (MonetaryAmount) o;

        if (!value.equals(monetaryAmount.value)) return false;
        if (!currency.equals(monetaryAmount.currency)) return false;

        return true;
    }

    public int hashCode() {
        int result;
        result = value.hashCode();
        result = 29 * result + currency.hashCode();
        return result;
    }

    public String toString() {
        return getValue() + " " + getCurrency();
    }

    public static MonetaryAmount fromString(String s) {
        String[] split = s.split(" ");
        return new MonetaryAmount(
            new BigDecimal(split[0]),
            Currency.getInstance(split[1])
        );
    }
}

import javax.persistence.AttributeConverter;
import javax.persistence.Converter;

@Converter(autoApply = true)
public class MoneyConverter implements AttributeConverter<MonetaryAmount, String> {

    @Override
    public String convertToDatabaseColumn(MonetaryAmount monetaryAmount) {
        return monetaryAmount.toString();
    }

    @Override
    public MonetaryAmount convertToEntityAttribute(String s) {
        return MonetaryAmount.fromString(s);
    }
}

import org.junit.Test;

import javax.persistence.*;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.Currency;

@Entity
public class Sr {

    @Id
    @GeneratedValue
    private long id;

    @NotNull
    @Column(name = "PRICE", length = 63)
    @Convert(converter = MoneyConverter.class, disableConversion = false)
    private MonetaryAmount monetaryAmount;


    @Override
    public String toString() {
        return "Sr{" +
                "id=" + id +
                ", monetaryAmount=" + monetaryAmount +
                '}';
    }

    @Test
    public void test() {
        EntityManagerFactory emf =
                Persistence.createEntityManagerFactory("HelloWorldPU");
        EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        tx.begin();

        Sr sr = new Sr();

        MonetaryAmount monetaryAmount = new MonetaryAmount(new BigDecimal("25.00"), Currency.getInstance("CNY"));

        sr.setMonetaryAmount(monetaryAmount);

        em.persist(sr);

        tx.commit();
    }
}

Hibernate:

    create table Sr (
    id int8 not null,
    PRICE varchar(63),
    primary key (id)
)

类型转换 - 转换继承体系的类

@Converter
public class ZipcodeConverter implements AttributeConverter<PostCode, String> {

    @Override
    public String convertToDatabaseColumn(PostCode postcode) {
        return attribute.getValue();
    }

    @Override
    public Zipcode convertToEntityAttribute(String s) {
        if (s.length() == 5)
            return new GermanZipcode(s);
        else if (s.length() == 4)
            return new SwissZipcode(s);
        else
        throw new IllegalArgumentException(
            "Unsupported zipcode in database: " + s
        );
    }
}