Example for One-to-Many Class Jackson JSON Serialization Setup. TbSppd is header/parent table, TbSppdEmployee is child.

TbSppd.java

package com.waruna.xhris.sppdservice.model;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.waruna.xhris.sppdservice.helper.staticdata.DocumentState;
import com.waruna.xhris.sppdservice.helper.staticdata.ImpositionType;
import com.waruna.xhris.sppdservice.model.deserializer.SppdEmpDeserializer;
import com.waruna.xhris.sppdservice.model.deserializer.SppdImpositionDeserializer;
import com.waruna.xhris.sppdservice.model.hris.Tdlookup;
import com.waruna.xhris.sppdservice.model.hris.Tmemp;
import com.waruna.xhris.sppdservice.model.hris.Tmorganization;
import com.waruna.xhris.sppdservice.model.serializer.EmployeeSerializer;
import com.waruna.xhris.sppdservice.model.serializer.SppdCitySerializer;
import com.waruna.xhris.sppdservice.model.serializer.SppdEmployeeLazySerializer;
import com.waruna.xhris.sppdservice.model.serializer.SppdImpositionSerializer;
import com.waruna.xhris.sppdservice.model.serializer.TmorganizationSerializer;
import java.util.Date;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.OptimisticLock;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.hateoas.ResourceSupport;
import com.waruna.xhris.sppdservice.model.generic.SppdDataTrail;
import com.waruna.xhris.sppdservice.model.serializer.ApprovalTypeSerializer;
import javax.persistence.Transient;

/**
 *
 * @author Maikel Chandika <[email protected]>
 */
@Entity
@Data
@NoArgsConstructor
@Table(name = "tb_sppd", catalog = "isis", schema = "sppd")
@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id")
public class TbSppd extends ResourceSupport implements SppdDataTrail {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(generator = "system-uuid")
    @GenericGenerator(name = "system-uuid", strategy = "uuid")
    @JsonProperty("id")
    @Column(name = "id", length = 32)
    private String tid;

    @ManyToOne(fetch = FetchType.EAGER)
    @NotNull(message = "HC Organization can not null.")
    @JoinColumn(name = "hc_organization", referencedColumnName = "id")
    @JsonSerialize(using = TmorganizationSerializer.class)
    private Tmorganization hcOrganization;

    @Column(name = "batch_no", length = 50)
    private String batchNo;

    @Column(name = "request_date")
    @Temporal(javax.persistence.TemporalType.DATE)
    private Date requestDate;

    @Enumerated(EnumType.STRING)
    @NotNull(message = "Imposition Type can not empty.")
    @Column(name = "imposition_type")
    private ImpositionType impositionType;

    @NotNull(message = "Imposition Name can not empty.")
    @NotEmpty(message = "Imposition Name can not empty.")
    @JsonSerialize(using = SppdImpositionSerializer.class)
    @JsonDeserialize(using = SppdImpositionDeserializer.class)
    @Column(name = "imposition")
    private String imposition;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "from_city", referencedColumnName = "id")
    @NotNull(message = "From City can not empty.")
    @JsonSerialize(using = SppdCitySerializer.class)
    private Tdlookup fromCity;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "to_city", referencedColumnName = "id")
    @NotNull(message = "To City can not empty.")
    @JsonSerialize(using = SppdCitySerializer.class)
    private Tdlookup toCity;

    @Size(min = 0, max = 500)
    @Column(name = "remark", length = 500)
    private String remark;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "approval_type", referencedColumnName = "id")
    @NotNull(message = "Approval Type can not empty.")
    @JsonSerialize(using = ApprovalTypeSerializer.class)
    private TbApprovalType approvalType;
    
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "ext_approval", referencedColumnName = "emp_id")
    @JsonSerialize(using = EmployeeSerializer.class)
    @JsonDeserialize(using = SppdEmpDeserializer.class)
    private Tmemp extApproval;

    @Enumerated(EnumType.STRING)
    @Column(name = "document_state")
    @NotNull(message = "Document State can not empty.")
    private DocumentState documentState;
    
    @Transient
    private String impositionName;
    
    @Transient
    private String employeeContent;
       
    @JsonSerialize(using = SppdEmployeeLazySerializer.class)
    @OrderBy(value = "employee")
    @OptimisticLock(excluded = true)
    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true, mappedBy = "sppd")
    private List<TbSppdEmployee> employees;        

    public void addEmployee(TbSppdEmployee emp) {
        employees.add(emp);
        emp.setSppd(this);
    }

    public void removeEmployee(TbSppdEmployee emp) {
        employees.remove(emp);
        emp.setSppd(null);
    }

    @Override
    public String getTrailRemarks() {
        StringBuilder sb = new StringBuilder("HC ORG=");
        sb.append(hcOrganization.getName());
        sb.append(", BATCH NO=");
        sb.append(batchNo);
        sb.append(", DOC.STATE=");
        sb.append(documentState);
        return sb.toString();
    }

    @Override
    public String getApprovalTitle() {
        StringBuilder sb = new StringBuilder("Business Trip Request Batch.");
        sb.append(batchNo);
        return sb.toString();
    }
}

TbSppdEmployee.java

package com.waruna.xhris.sppdservice.model;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.waruna.xhris.sppdservice.helper.staticdata.BusinessTripCostType;
import com.waruna.xhris.sppdservice.model.hris.Tdlookup;
import com.waruna.xhris.sppdservice.model.hris.Tmemp;
import com.waruna.xhris.sppdservice.model.hris.TmofficialSetting;
import com.waruna.xhris.sppdservice.model.serializer.EmployeeSerializer;
import com.waruna.xhris.sppdservice.model.serializer.OfficialSettingSerializer;
import com.waruna.xhris.sppdservice.model.serializer.SppdCitySerializer;
import com.waruna.xhris.sppdservice.model.serializer.SppdExpenseLazySerializer;
import com.waruna.xhris.sppdservice.model.serializer.SppdSerializer;
import com.waruna.xhris.sppdservice.model.validator.ValidDateRange;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.OptimisticLock;
import org.springframework.hateoas.ResourceSupport;
import com.waruna.xhris.sppdservice.model.generic.SppdData;
import javax.persistence.Transient;
import javax.persistence.UniqueConstraint;

/**
 *
 * @author Maikel Chandika <[email protected]>
 */
@Entity
@Data
@NoArgsConstructor
@ValidDateRange(fields = {"fromDate", "toDate"})
@Table(name = "tb_sppd_employee", catalog = "isis", schema = "sppd",
        uniqueConstraints = {
            @UniqueConstraint(columnNames = {"sppd", "employee"})
        })
@JsonIdentityInfo(
        generator = ObjectIdGenerators.PropertyGenerator.class,
        property = "id")
public class TbSppdEmployee extends ResourceSupport implements SppdData, Comparable<TbSppdEmployee> {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue
    @Column(name = "id")
    @JsonProperty("id")
    private Long tid;

    @JsonSerialize(using = SppdSerializer.class)
    @JoinColumn(name = "sppd", referencedColumnName = "id")
    @ManyToOne(cascade = CascadeType.PERSIST, fetch = FetchType.EAGER)
    private TbSppd sppd;

    @JsonSerialize(using = EmployeeSerializer.class)
    @NotNull(message = "Employee can not empty.")
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "employee", referencedColumnName = "emp_id")
    private Tmemp employee;

    @JsonSerialize(using = SppdCitySerializer.class)
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "from_city", referencedColumnName = "id")
    @NotNull(message = "From City can not empty.")
    private Tdlookup fromCity;

    @JsonSerialize(using = SppdCitySerializer.class)
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "to_city", referencedColumnName = "id")
    @NotNull(message = "To City can not empty.")
    private Tdlookup toCity;

    @NotNull(message = "From Date can not empty.")
    @Column(name = "from_date")
    @Temporal(javax.persistence.TemporalType.TIMESTAMP)
    private Date fromDate;

    @NotNull(message = "To Date can not empty.")
    @Column(name = "to_date")
    @Temporal(javax.persistence.TemporalType.TIMESTAMP)
    private Date toDate;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "transportation", referencedColumnName = "id")
    @NotNull(message = "Transportation can not empty.")
    @JsonSerialize(using = OfficialSettingSerializer.class)
    private TmofficialSetting transportation;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "accomodation", referencedColumnName = "id")
    @NotNull(message = "Accomodation can not empty.")
    @JsonSerialize(using = OfficialSettingSerializer.class)
    private TmofficialSetting accomodation;

    @Size(min = 5, max = 500)
    @Column(name = "purpose", length = 500)
    private String purpose;

    @Size(min = 0, max = 500)
    @Column(name = "remark", length = 500)
    private String remark;

    @Enumerated(EnumType.STRING)
    @NotNull(message = "Cost Type can not empty.")
    @Column(name = "cost_type")
    private BusinessTripCostType costType;

    @Transient    
    private BigDecimal total = BigDecimal.ZERO;
    
    @Transient
    @JsonIgnore
    private String employeename;
    
    @Transient
    @JsonIgnore
    private String impositionName;
    
    @Transient
    @JsonIgnore
    private String hcOrganization;

    @Column(name = "sppd_print_no", length = 50)
    private String sppdPrintNo;

    @Column(name = "received_fund")
    private Boolean receivedFund;

    @Column(name = "received_fund_date")
    @Temporal(javax.persistence.TemporalType.TIMESTAMP)
    private Date receivedFundDate;

    @Column(name = "received_fund_total")
    private BigDecimal receivedFundTotal = BigDecimal.ZERO;

    @Size(min = 0, max = 500)
    @Column(name = "received_fund_note", length = 500)
    private String receivedFundNote;

    @JsonSerialize(using = SppdExpenseLazySerializer.class)
    @OptimisticLock(excluded = true)
    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true, mappedBy = "sppdEmployee")
    private List<TbSppdExpense> expenses;

    @Override
    public int compareTo(TbSppdEmployee o) {
        return employee.getName().compareTo(o.getEmployee().getName());
    }

    public void addExpense(TbSppdExpense exp) {
        expenses.add(exp);
        exp.setSppdEmployee(this);
    }

    public void removeExpense(TbSppdExpense exp) {
        expenses.remove(exp);
        exp.setSppdEmployee(null);
    }
}