`

hibernate4父子之间映射

阅读更多

开发环境:Struts2+Hibernate4+Spring4+MySQL5+Tomcat7+JDK1.8+Maven

在实现关系映射的时候,我采用的是注解形式实现的,但是,我想在写json数据的时候忽略某些映射出来的数据,完整的代码如下:

 

package com.value.yun.modules.entity;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.value.yun.common.base.BaseDataEntity;
import org.hibernate.annotations.*;
import org.hibernate.annotations.Cache;

import javax.persistence.*;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.util.Date;
import java.util.List;

/**
 * Created by 丽 on 2015/4/14.
 */
@Entity
@Table(name = "user")
@DynamicInsert
@DynamicUpdate
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
@JsonIgnoreProperties(value ={"role","menuList"})
public class User extends BaseDataEntity<User>{
    /**
     * 密码
     */
    private String password;
    /**
     * 工号、学号
     */
    private String number;
    /**
     * 真实姓名
     */
    private String realName;
    /**
     * 手机
     */
    private String mobile;
    /**
     * 邮箱
     */
    private String email;
    /**
     * qq
     */
    private String qq;
    /**
     * 登陆的ip
     */
    private String loginIp;
    /**
     * 登录时间
     */
    private Date loginTime;
    /**
     * 登陆名
     */
    private String loginName;
    /**
     * 角色、类型
     */
    @JsonManagedReference
    private Role role;
	 @JsonManagedReference
    private List<Menu> menuList;
    /**
     * 验证码
     */
    @Transient
    private String verification;

    public User() {
    }

    public User(String id, String remark, int delFlag, Date createDate, Date updateDate, User createBy, User updateBy,
                String password, String number, String realName, String mobile, String email, String qq, String loginIp,
                Date loginTime, String loginName, Role role) {
        super(id, remark, delFlag, createDate, updateDate, createBy, updateBy);
        this.password = password;
        this.number = number;
        this.realName = realName;
        this.mobile = mobile;
        this.email = email;
        this.qq = qq;
        this.loginIp = loginIp;
        this.loginTime = loginTime;
        this.loginName = loginName;
        this.role = role;
    }
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }
    @Column(name = "real_name")
    public String getRealName() {
        return realName;
    }

    public void setRealName(String realName) {
        this.realName = realName;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getQq() {
        return qq;
    }

    public void setQq(String qq) {
        this.qq = qq;
    }
    @Column(name = "login_ip")
    public String getLoginIp() {
        return loginIp;
    }

    public void setLoginIp(String loginIp) {
        this.loginIp = loginIp;
    }
    @Column(name = "login_time")
    public Date getLoginTime() {
        return loginTime;
    }

    public void setLoginTime(Date loginTime) {
        this.loginTime = loginTime;
    }
    @Column(name = "login_name")
    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    @ManyToOne(fetch = FetchType.EAGER)
    @NotFound(action = NotFoundAction.IGNORE)
    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
    public Role getRole() {
        return role;
    }

    public void setRole(Role role) {
        this.role = role;
    }

    @ManyToMany(fetch = FetchType.EAGER)
    @Fetch(value=FetchMode.SUBSELECT)
    @NotFound(action = NotFoundAction.IGNORE)
//    @JsonIgnore
    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
    @JoinTable(name = "user_menu",joinColumns = {@JoinColumn(name = "user_id")},
            inverseJoinColumns = {@JoinColumn(name = "menu_id")})
    public List<Menu> getMenuList() {
        return menuList;
    }

    public void setMenuList(List<Menu> menuList) {
        this.menuList = menuList;
    }

    @Transient
    public boolean isAdmin(){
        return isAdmin(this.id);
    }

    @Override
    public String toString() {
        return "User{" +
                "password='" + password + '\'' +
                ", number='" + number + '\'' +
                ", realName='" + realName + '\'' +
                ", mobile='" + mobile + '\'' +
                ", email='" + email + '\'' +
                ", qq='" + qq + '\'' +
                ", loginIp='" + loginIp + '\'' +
                ", loginTime=" + loginTime +
                ", loginName='" + loginName + '\'' +
                '}';
    }

    @Transient
    public static boolean isAdmin(String id){
        return id != null && id.equals("1");
    }
    @Transient
    public String getVerification() {
        return verification;
    }
    @Transient
    public void setVerification(String verification) {
        this.verification = verification;
    }
}

 

 在上面的代码中,对于json需要忽略的属性,必须要在@JsonIgnoreProperties中指定,否则不会有有效果;

关于另外两个注解@JsonManagedReference、@JsonBackReference,具体作用如下:

(see Jira entry JACKSON-235 for more details)

Before Jackson 1.5, back references such as "parent" links from child objects, previous sibling for doubly-linked lists, and general bi-directional references for ORM-managed beans (iBatis, Hibernate) would cause serialization to failure since they are cyclic dependencies.

In Jackson 1.6 there are 2 new annotations that allow specifying relationship between 2 properties that form such bi-directional dependency so that Jackson can properly omit cycle during serialization, and re-construct during serialization.

 

New annotations

Annotations are:

  • @JsonManagedReference is the "forward" part of reference: one that gets serialized normally, and handling of which triggers back-linkage for the other reference

    • Annotated property can be a bean, array, Collection (List, Set) or Map type, and it must be a bean property (handled by a property of type serialized using BeanSerializer

  • @JsonBackReference is the "back" part of reference: it will be omitted from serialization, and re-constructed during deserialization of forward reference.

    • Annotated property must be of bean type

These annotations can be used for:

* Methods (getters and setters) * Fields

but not for types (classes) or constructor arguments.

 

Annotations take optional "name" parameter; if omitted default name is used. Name is needed to allow multiple reference pairs for one bean type.

 

上面的这段话说明,@JsonManagedReference、@JsonBackReference这两个注解是JDK1.6开始才有的,而且是针对于父子关系映射的,当然非父子关系,即普通属性也行的,但是,有这两个注解的属性,必须要在@JsonIgnoreProperties中指定才会有效。

@JsonManagedReference只适合bean 类型的属性;

@JsonManagedReference的适用范围较广:bean, array, Collection (List, Set) or Map 类型,但是,集合中的实体对象必须是实现了序列化接口的。

 @JsonManagedReference、@JsonBackReference这两个注解可以用在getters和setters方法上,也可以用在某个属性上,但是不能用在某个类上或者某个构造方法上。

1
0
分享到:
评论
1 楼 xqf222 2019-07-01  

相关推荐

    Hibernate映射树形结构

    在Hibernate中,映射这种结构的关键在于理解实体之间的关联和嵌套关系。标题“Hibernate映射树形结构”指的是如何用Hibernate来存储和操作具有层级关系的数据。 1. **单表映射策略**: Hibernate可以使用单个表来...

    hibernate 一对多映射

    本文将深入探讨 Hibernate 的简单搭建以及其中的一对多映射关系。 ## Hibernate 搭建 1. **环境配置**:首先,你需要在项目中引入Hibernate的依赖库,这通常通过Maven或Gradle来完成。添加相应的依赖项到pom.xml或...

    java私塾独家首发最新Hibernate4教程

    Hibernate4是一款开源的对象关系映射(Object Relational Mapping, ORM)框架,它简化了Java应用程序与数据库之间的交互过程。通过使用Hibernate,开发者可以避免编写大量的SQL代码,并能够更加专注于业务逻辑的实现...

    hibernate中文参考文档

    4. 持久化类:介绍如何设计符合Hibernate映射规则的Java类,使得这些类的实例能够被映射到数据库表中。 5. O/R Mapping基础:对象/关系映射是ORM框架的核心功能,这部分内容将介绍对象与数据库表之间的映射原理和...

    hibernate父亲与孩子

    通过`@Tree`,我们可以轻松地处理节点之间的父子关系。例如,我们可能有一个Organization类,其中包含一个`@ManyToOne`到自身的引用,表示父节点。使用`@Tree`,Hibernate将自动处理递归查询和关联的维护。 4. **树...

    Hibernate one-to-many / many-to-one关系映射

    在Java的持久化框架Hibernate中,关系映射是数据库对象之间的关联方式,它允许我们将复杂的数据库结构映射到Java对象上。"Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型,用于表示实体间的关联...

    Hibernate一对多单向关联映射

    本文将深入探讨Hibernate中的一对多单向关联映射,这是数据库表之间常见的一种关系类型。 **一、Hibernate基础** Hibernate是一个基于Java的持久化框架,它通过XML或注解方式定义对象和数据库表之间的映射关系,...

    struts+hibernate+单表的增删改查

    而Hibernate则是一个全功能的对象关系映射(ORM)解决方案,它极大地简化了数据库操作的复杂度。将Struts2与Hibernate结合使用,可以构建出高效、灵活的应用系统。本文将详细介绍如何利用Struts2和Hibernate实现对单...

    精通 Hibernate:Java 对象持久化技术详解(第2版).part2

     2.4.3 Hibernate映射类型接口  2.4.4 可供扩展的接口  2.5 小结  2.6 思考题 第3章 第一个Hibernate应用  3.1 创建Hibernate的配置文件  3.2 创建持久化类  3.3 创建数据库Schema  3.4 创建对象-关系映射...

    Hibernate+中文文档

    22.2. Hibernate 映射 22.3. Hibernate 代码 23. 示例:复杂映射实例 23.1. Employer(雇主)/Employee(雇员) 23.2. Author(作家)/Work(作品) 23.3. Customer(客户)/Order(订单)/Product(产品) 23.4. 杂例 ...

    Struts_Spring_Hibernate_CRUD操作案例_-分页查询

    - **Struts配置**:XML配置文件定义了Action与ActionForm、结果页面之间的映射关系。 - **Interceptor拦截器**:用于在Action执行前后进行预处理和后处理,例如权限验证和日志记录。 2. **Spring框架**: - **...

    hibernate3.2中文文档(chm格式)

    22.2. Hibernate 映射 22.3. Hibernate 代码 23. 示例:复杂映射实例 23.1. Employer(雇主)/Employee(雇员) 23.2. Author(作家)/Work(作品) 23.3. Customer(客户)/Order(订单)/Product(产品) 23.4. 杂例 ...

    HibernateAPI中文版.chm

    22.2. Hibernate 映射 22.3. Hibernate 代码 23. 示例:复杂映射实例 23.1. Employer(雇主)/Employee(雇员) 23.2. Author(作家)/Work(作品) 23.3. Customer(客户)/Order(订单)/Product(产品) 23.4. 杂例 ...

    精通 Hibernate:Java 对象持久化技术详解(第2版).part4

     2.4.3 Hibernate映射类型接口  2.4.4 可供扩展的接口  2.5 小结  2.6 思考题 第3章 第一个Hibernate应用  3.1 创建Hibernate的配置文件  3.2 创建持久化类  3.3 创建数据库Schema  3.4 创建对象-关系映射...

    spring+hibernate代码实例集

    1.1 父子关系映射:在数据库中,表与表之间可能存在一对多、多对一或者一对一的关系。通过Hibernate的注解或XML配置,我们可以定义实体类之间的关联。Spring则可以协助管理这些关联对象,例如通过@Autowired注解自动...

    hibernate3.2中文教程

    7. **一对多、多对一、多对多关系**:Hibernate支持多种关系映射,如实体类间的父子关系、一对多关系、多对一关系和多对多关系,通过配置文件或注解设定。 8. **缓存机制**:为了提高性能,Hibernate提供了缓存机制...

    Hibernate框架参考文档

    4. 持久化类(Persistent Classes); 5. 对象/关系数据库映射基础(Basic O/R Mapping); 6. 集合类(Collections)映射; 7. 关联关系映射; 8. 组件(Component)映射; 9. 继承映射(Inheritance Mappings); 10. 与对象共事...

    Hibernate原理简介的Java项目

    Hibernate支持各种复杂的关联关系,如实体之间的父子关系、引用关系等。这些关系通过注解或XML配置来定义。 10. **懒加载和立即加载** Hibernate提供了懒加载机制,只有当实际需要时才会加载关联的对象,从而避免...

Global site tag (gtag.js) - Google Analytics