标签：name JPA 基础 private Column Hibernate03 new GenerationType id

Hibernate03-基础-JPA

1.hibernate和JPA的关系

1. jpa中定义了操作数据库的接口，hibernate是JPA的一种实现。
2. JPA的其他两种实现TopLink和OpenJPA。

2.JPA注解开发

1. 实体类。

@Data
@Entity
@Table(name = "tb_customer")
public class Customer {

    @Id
    @Column(name = "id")
    // GenerationType.IDENTITY，使用数据库的底层策略。
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name")
    private String name;
}

2. hibernate.cfg.xml配置。

<mapping class="com.my.jpa.test.Customer" />

3. 测试。

@Test
public void test01() {
    Customer customer = new Customer();
    customer.setName("jpa");
    session.save(customer);
}

4. @Transient，指定字段为临时字段，不需要映射到数据库。

// @Transient，临时字段，不需要映射到数据库。
// 如果没有加@Transient，会在启动时为表添加address临时字段。
@Transient
@Column(name = "address")
private String address;

3.JPA的四种主键策略

1. GenerationType.IDENTITY，利用数据库的自增长，适用于MySQL数据库。
2. GenerationType.SEQUENCE，利用数据库的序列机制，适合Oracle。
3. GenerationType.TABLE，利用JPA生成hibernate_sequences表维护主键值。
4. GenerationType.AUTO，自动选择策略，会利用JPA生成hibernate_sequences表维护主键值。

4.JPA对象关系映射-一对多

1. 实体类，一个Person多个Order。

@Data
@Setter
@Entity
@Table(name = "tb_person")
public class Person {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name")
    private String name;

    /**
     * mappedBy = "order"，Order中保存Person属性的字段名称
     */
    @OneToMany(targetEntity = Order.class, mappedBy = "person")
    private Set<Order> orders = new HashSet<>();
}

@Data
@Setter
@Entity
@Table(name = "tb_order")
public class Order {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "orderNo")
    private String orderNo;

    /**
     * @JoinColumn(name = "person_id")，多方表中外键字段。
     */
    @JoinColumn(name = "person_id")
    @ManyToOne(targetEntity = Person.class)
    private Person person;
}

2. 测试insert。

@Test
public void test01() {
    Person person01 = new Person();
    person01.setName("tom");

    Person person02 = new Person();
    person02.setName("alice");

    Order o01 = new Order();
    o01.setOrderNo("AA01");

    Order o02 = new Order();
    o02.setOrderNo("BB02");

    o01.setPerson(person01);
    o02.setPerson(person01);

    session.save(person01);
    session.save(person02);
    session.save(o01);
    session.save(o02);
}

5.JPA对象关系映射-多对多

1. Java实体类，User和Role。

@Getter
@Setter
@Entity
@Table(name = "tb_user")
public class User {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "name")
    private String name;

    @ManyToMany(targetEntity = Role.class)
    // name = "tb_user_role"，中间表为tb_user_role
    // joinColumns，当前方关联的列。
    // inverseJoinColumns，对方关联的列。
    @JoinTable(name = "tb_user_role",
            joinColumns = @JoinColumn(name = "user_id"),
            inverseJoinColumns = @JoinColumn(name = "role_id"))
    private Set<Role> roles = new HashSet<>();
}

@Getter
@Setter
@Entity
@Table(name = "tb_role")
public class Role {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "name")
    private String name;

    @ManyToMany(targetEntity = User.class, mappedBy = "roles")
    private Set<User> users = new HashSet<>();
}

2. 测试代码。

@Test
public void test01() {
    User user01 = new User();
    user01.setName("tom");

    User user02 = new User();
    user02.setName("alice");

    Role role01 = new Role();
    role01.setName("A");

    Role role02 = new Role();
    role02.setName("B");

    // 只在User方维护关系即可
    user01.getRoles().add(role01);
    //role01.getUsers().add(user01);

    user02.getRoles().add(role01);
    //role02.getUsers().add(user02);


    session.save(user01);
    session.save(user02);
    session.save(role01);
    session.save(role02);
}

6.JAP对象映射-一对一

1. Java实体类。

@Getter
@Setter
@Entity
@Table(name = "tb_student")
public class Student {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name")
    private String name;

    @OneToOne(mappedBy = "student")
    private Card card;
}

@Getter
@Setter
@Entity
@Table(name = "tb_card")
public class Card {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "card_no")
    private String cardNo;

    @OneToOne
    // 会在tb_card表中创建student_id列，用户映射tb_student的id，所以由Card维护外键关系。
    @JoinColumn(name = "student_id")
    private Student student;
}

2. 测试类。

@Test
public void test01() {
    Student student = new Student();
    student.setName("tom");

    Card card = new Card();
    card.setCardNo("A001");

    //
    card.setStudent(student);

    session.save(student);
    session.save(card);
}

标签：name,JPA,基础,private,Column,Hibernate03,new,GenerationType,id
来源： https://www.cnblogs.com/godistance/p/16124701.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。