Spring-Data-Jpa 中的实体管理器和映射

实体管理器

实体状态

• 临时状态:

对象刚创建出来的状态，实际上就是new了一个普通的实体。

• 托管状态

临时状态的实体在调用persist()方法后，实体状态改变为托管状态，该实体的任何属性改动都会导致数据库记录的改动。

• 持久化状态

托管状态的实体被管理器flush了，那么就在极短暂的时间进入了持久化状态，事务提交之后，立刻变为了游离状态。

您可以把持久化状态当做实实在在的数据库记录。

• 游离状态

持久化状态的实体被commit到数据库后，实体状态变为游离态，因为事务已经提交了，此时实体的属性任你如何改变，也不会同步到数据库，此时实体不在持久化上下文中。

• 销毁状态

一般要删除一个持久化对象的时候都是先find出来，之后调用remove方法删除，此时这个对象就是销毁状态。

实体状态和转换

建立实现类来使用EntityManager自定义方法

首先创建一个User实体类，然后创建UserRepository，自己创建一个相对应的实现类UserRepositoryImpl，注意命名规范。

User.java

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;

    private Integer departmentId;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public Integer getDepartmentId() {
        return departmentId;
    }

    public void setDepartmentId(Integer departmentId) {
        this.departmentId = departmentId;
    }
}

UserRepository.java

public interface UserRepository extends JpaRepository<User, Integer> {
    void add(User user);
    User update(User user);
    User addOrUpdate(User user);
    void delete(User user);
    User findOne(Integer id);
    @Override
    List<User> findAll();
}

UserRepositoryImpl.java

public class UserRepositoryImpl {
    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void add(User user){
        entityManager.persist(user);
    }
    @Transactional
    public User update(User user){
        User userUpdate = entityManager.find(User.class, user);
        userUpdate.setId(user.getId());
        userUpdate.setDepartmentId(user.getDepartmentId());
        userUpdate.setName(user.getName());
        return userUpdate;
    }
    @Transactional
    public User addOrUpdate(User user){
        return entityManager.merge(user);
    }
    @Transactional
    public void delete(User user){
        entityManager.remove(user);
    }
    @Transactional
    public User findOne(Integer id){
        return entityManager.find(User.class, id);
    }
    @Transactional
    public List<User> findAll(){
        String queryString = "select u from User u";
        Query query = entityManager.createQuery(queryString);
        return query.getResultList();
    }
}

映射

@Entity

标识这个实体类是一个JPA实体，告诉JPA在程序运行的时候记得生成这个实体类所对应的表~！

@Table（name = "自定义的表名"）

自定义设置这个实体类在数据库所对应的表名！

@Id

把这个类里面所在的变量设置为主键Id。

@GeneratedValue

设置主键的生成策略，这种方式依赖于具体的数据库，如果数据库不支持自增主键，那么这个类型是没法用的。

@Basic

表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的getXxxx()方法,默认 即为 @Basic fetch: 表示该属性的读取策略,有EAGER和LAZY两种,分别表示主支抓取和延迟加载,默认为EAGER.

@Column（name = "自定义字段名"，length = "自定义长度"，nullable = "是否可以空"，unique = "是否唯一"，columnDefinition = "自定义该字段的类型和长度"）

表示对这个变量所对应的字段名进行一些个性化的设置，例如字段的名字，字段的长度，是否为空和是否唯一等等设置。

@Transient

表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性. 如果一个属性并非数据库表的字段映射,就务必将其标示为 @Transient ,否则,ORM框架默认其注解为 @Basic。

@Temporal

当我们使用到java.util包中的时间日期类型，则需要@Temporal注释来说明转化成java.util包中的类型。其中包含三种转化类型分别是： java.sql.Date日期型，精确到年月日，例如“2008-08-08” java.sql.Time时间型，精确到时分秒，例如“20:00:00” java.sql.Timestamp时间戳，精确到纳秒，例如“2008-08-08 20:00:00.000000001”

@Enumerated（"需要定义存入数据库的类型”)

使用@Enumerated映射枚举字段，以String类型存入数据库。

@Embedded和@Embeddable

当一个实体类要在多个不同的实体类中进行使用，而本身又不需要独立生成一个数据库表，这就是需要使用@Embedded、@Embeddable的时候了。当被引用的对象和主对象拥有相同的生命周期的时候才考虑使用@Embedded和@Embeddable。

@ElementCollection

集合映射，当实体类包含多个相同类型的变量的时候就可以使用@ElementCollection来声明这个变量，而JPA会为此生成两个关联的表。例如一个人有家庭住址，也有单位地址；但是“地址”并不能失去人的存在而存在，所以是一个失去独立性的实体类；所以地址不能映射为一个实体，这时就需要映射为组件，及人的信息里边包含地址。是整体与部分的关系。但由于这个地址可能有多个。比如公司地址、出生地址、家庭地址等。

@OneToOne

JPA使用@OneToOne来标注一对一的关系。

实体 People ：用户。

实体 Address：家庭住址。

People 和 Address 是一对一的关系。

这里用两种方式描述JPA的一对一关系。

一种是通过外键的方式(一个实体通过外键关联到另一个实体的主键)；

另外一种是通过一张关联表来保存两个实体一对一的关系。

1、通过外键的方式

people 表（id，name，sex，birthday，address_id）

address 表（id，phone，zipcode，address）

People.java

@Entity
public class People {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;//id
    @Column(name = "name", nullable = true, length = 20)
    private String name;//姓名
    @Column(name = "sex", nullable = true, length = 1)
    private String sex;//性别
    @Column(name = "birthday", nullable = true)
    private Timestamp birthday;//出生日期
    @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端，当删除 people，会级联删除 address
    @JoinColumn(name = "address_id", referencedColumnName = "id")//people中的address_id字段参考address表中的id字段
    private Address address;//地址
}

关联的实体的主键一般是用来做外键的。但如果此时不想主键作为外键，则需要设置referencedColumnName属性。当然这里关联实体(Address)的主键 id 是用来做主键，所以这里第20行的 referencedColumnName = "id" 实际可以省略。

Address.java

@Entity
public class Address {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;//id
    @Column(name = "phone", nullable = true, length = 11)
    private String phone;//手机
    @Column(name = "zipcode", nullable = true, length = 6)
    private String zipcode;//邮政编码
    @Column(name = "address", nullable = true, length = 100)
    private String address;//地址
    //如果不需要根据Address级联查询People，可以注释掉
//    @OneToOne(mappedBy = "address", cascade = {CascadeType.MERGE, CascadeType.REFRESH}, optional = false)
//    private People people;
}

2、通过关联表的方式来保存一对一的关系。

people 表（id，name，sex，birthday）

address 表 (id，phone，zipcode，address）

people_address (people_id，address_id)

只需要创建 People 和 Address 两个实体

People.java

@Entity
public class People {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Long id;//id
    @Column(name = "name", nullable = true, length = 20)
    private String name;//姓名
    @Column(name = "sex", nullable = true, length = 1)
    private String sex;//性别
    @Column(name = "birthday", nullable = true)
    private Timestamp birthday;//出生日期
    @OneToOne(cascade=CascadeType.ALL)//People是关系的维护端
    @JoinTable(name = "people_address",
            joinColumns = @JoinColumn(name="people_id"),
            inverseJoinColumns = @JoinColumn(name = "address_id"))//通过关联表保存一对一的关系
    private Address address;//地址
}

Address.java

不变

@OneToMany 和 @ManyToOne

实体 Author：作者。

实体 Article：文章。

Author 和 Article 是一对多关系(双向)。那么在JPA中，如何表示一对多的双向关联呢？

JPA使用@OneToMany和@ManyToOne来标识一对多的双向关联。一端(Author)使用@OneToMany,多端(Article)使用@ManyToOne。

在JPA规范中，一对多的双向关系由多端(Article)来维护。就是说多端(Article)为关系维护端，负责关系的增删改查。一端(Author)则为关系被维护端，不能维护关系。

一端(Author)使用@OneToMany注释的mappedBy="author"属性表明Author是关系被维护端。

多端(Article)使用@ManyToOne和@JoinColumn来注释属性 author,@ManyToOne表明Article是多端，@JoinColumn设置在article表中的关联字段(外键)。

Author.java

@Entity
public class Author {
    @Id // 主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
    private Long id; //id
    @NotEmpty(message = "姓名不能为空")
    @Size(min=2, max=20)
    @Column(nullable = false, length = 20)
    private String name;//姓名
    @OneToMany(mappedBy = "author",cascade=CascadeType.ALL,fetch=FetchType.LAZY)
    //级联保存、更新、删除、刷新;延迟加载。当删除用户，会级联删除该用户的所有文章
    //拥有mappedBy注解的实体类为关系被维护端
     //mappedBy="author"中的author是Article中的author属性
    private List<Article> articleList;//文章列表
}

Article.java

@Entity
public class Article {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
    @Column(name = "id", nullable = false)
    private Long id;
    @NotEmpty(message = "标题不能为空")
    @Size(min = 2, max = 50)
    @Column(nullable = false, length = 50) // 映射为字段，值不能为空
    private String title;
    @Lob  // 大对象，映射 MySQL 的 Long Text 类型
    @Basic(fetch = FetchType.LAZY) // 懒加载
    @NotEmpty(message = "内容不能为空")
    @Size(min = 2)
    @Column(nullable = false) // 映射为字段，值不能为空
    private String content;//文章全文内容
    @ManyToOne(cascade={CascadeType.MERGE,CascadeType.REFRESH},optional=false)//可选属性optional=false,表示author不能为空。删除文章，不影响用户
    @JoinColumn(name="author_id")//设置在article表中的关联字段(外键)
    private Author author;//所属作者
}

最终生成的表结构

article 表(id，title，conten，author_id)

author 表(id，name)

@ManyToMany

实体 User：用户。

实体 Authority：权限。

用户和权限是多对多的关系。一个用户可以有多个权限，一个权限也可以被很多用户拥有。

JPA中使用@ManyToMany来注解多对多的关系，由一个关联表来维护。这个关联表的表名默认是：主表名+下划线+从表名。(主表是指关系维护端对应的表,从表指关系被维护端对应的表)。这个关联表只有两个外键字段，分别指向主表ID和从表ID。字段的名称默认为：主表名+下划线+主表中的主键列名，从表名+下划线+从表中的主键列名。

需要注意的：

1、多对多关系中一般不设置级联保存、级联删除、级联更新等操作。

2、可以随意指定一方为关系维护端，在这个例子中，我指定 User 为关系维护端，所以生成的关联表名称为： user_authority，关联表的字段为：user_id 和 authority_id。

3、多对多关系的绑定由关系维护端来完成，即由 User.setAuthorities(authorities) 来绑定多对多的关系。关系被维护端不能绑定关系，即Game不能绑定关系。

4、多对多关系的解除由关系维护端来完成，即由Player.getGames().remove(game)来解除多对多的关系。关系被维护端不能解除关系，即Game不能解除关系。

5、如果 User 和 Authority 已经绑定了多对多的关系，那么不能直接删除 Authority，需要由 User 解除关系后，才能删除 Authority。但是可以直接删除 User，因为 User 是关系维护端，删除 User 时，会先解除 User 和 Authority 的关系，再删除 Authority。

User.java

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @NotEmpty(message = "账号不能为空")
    @Size(min=3, max=20)
    @Column(nullable = false, length = 20, unique = true)
    private String username; // 用户账号，用户登录时的唯一标识
    @NotEmpty(message = "密码不能为空")
    @Size(max=100)
    @Column(length = 100)
    private String password; // 登录时密码
    @ManyToMany
    @JoinTable(name = "user_authority",joinColumns = @JoinColumn(name = "user_id"),
    inverseJoinColumns = @JoinColumn(name = "authority_id"))
    //1、关系维护端，负责多对多关系的绑定和解除
    //2、@JoinTable注解的name属性指定关联表的名字，joinColumns指定外键的名字，关联到关系维护端(User)
    //3、inverseJoinColumns指定外键的名字，要关联的关系被维护端(Authority)
    //4、其实可以不使用@JoinTable注解，默认生成的关联表名称为主表表名+下划线+从表表名，
    //即表名为user_authority
    //关联到主表的外键名：主表名+下划线+主表中的主键列名,即user_id
    //关联到从表的外键名：主表中用于关联的属性名+下划线+从表的主键列名,即authority_id
    //主表就是关系维护端对应的表，从表就是关系被维护端对应的表
    private List<Authority> authorityList;
}

注意：如注释中所言，上面的第20-21行的@JoinTable可以省略，默认可以生成

Authority.java

@Entity
public class Authority {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column(nullable = false)
    private String name; //权限名
    @ManyToMany(mappedBy = "authorityList")
    private List<User> userList;
}

测试 添加

@SpringBootTest
@RunWith(SpringRunner.class)
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private AuthorityRepository authorityRepository;
    @Test
    public void saveAuthority() {
        Authority authority = new Authority();
        authority.setId(1);
        authority.setName("ROLE_ADMIN");
        authorityRepository.save(authority);
    }
    @Test
    public void saveUser() {
        User user = new User();
        user.setUsername("admin");
        user.setPassword("123456");
        Authority authority = authorityRepository.findById(1).get();
        List<Authority> authorityList = new ArrayList<>();
        authorityList.add(authority);
        user.setAuthorList(authorityList);
        userRepository.save(user);
    }
}

先运行 saveAuthority 添加一条权限记录，

然后运行 saveUser 添加一条用户记录，与此同时，user_authority 表中也自动插入了一条记录

测试 删除

删除用户

@SpringBootTest
@RunWith(SpringRunner.class)
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;
    @Test
    public void deleteUser() {
        userRepository.deleteById(1L);
    }
}

user 表中删除一条记录，同时 user_authority 能够级联删除一条记录

参考说明

由于作者懒得写那么多例子，@OneToOne, @OneToMany, @ManyToOne, @ManyToMany部分内容引用自 https://liuyanzhao.com/7913.html