DTO、VO、Entity、Condition使用习惯，以及对于多映射关系字段的处理

紫宸殇雒

已于 2023-09-06 13:48:55 修改

阅读量1.8k

点赞数 2

分类专栏： Java 文章标签： java 数据库 mybatis

于 2023-04-23 10:39:42 首次发布

本文链接：https://blog.youkuaiyun.com/liaoguangxi/article/details/130313901

版权

Java 专栏收录该内容

5 篇文章

订阅专栏

POJO 的定义是无规则简单的对象，在日常的代码分层中 pojo 会被分为VO、BO、 PO、 DTO。

一、定义和使用情景

Entity：对象实体类，一般就是和数据库表字段一一对应的那个类。

DTO（Data Transfer Object）：数据传输对象，在服务间的调用中，传输的数据对象。-- 个人理解，DTO是可以存在于各层服务中（接口、服务、数据库等等）服务间的交互使用DTO来解耦。就我个人来说，一般习惯把关系比较复杂（比如说需要联表查询）的字段封装在DTO当中，当作Mybatis中的封装对象，而不是直接把Entity实体类作为封装对象，这个类中一般包含多个Entity的属性，具体视业务需求而定。

VO（view object/value object）：前端展示层对象，也就是我们查询出的数据进行封装后返回给前端的那个类，此类中的数据根据前端所需仅显示DTO中的部分属性，而无需将全部的DTO属性返给前端。 -- 个人理解使用场景，接口层服务中，将DTO转成VO，返回给前台。

B0（bussines object）：业务层对象，主要在服务内部使用的业务对象，可以包含多个对象，可以用于对象的聚合操作。-- 个人理解使用场景，在服务层服务中，由DTO转成BO然后进行业务处理后，转成DTO返回到接口层。

PO（persistent object）：持久对象（就是上述的Entity），出现位置为数据库数据，用来存储数据库提取的数据，只存储数据，不包含数据操作。 -- 个人理解使用场景，在数据库层中，获取的数据库数据存储到PO中，然后转为DTO返回到服务层中。

DO（domain object）：领域实体对象，DO 现在主要有两个版本：

阿里巴巴的开发手册中的定义，DO（ Data Object）这个等同于上面的PO。
DDD（Domain-Driven Design）领域驱动设计中，DO（Domain Object）这个等同于上面的BO。

Condition：在传统的业务系统中，我们的查询一般含有多个查询条件，我在开发的时候习惯性的将这些业务相关的查询条件封装到一个Condition对象中接收，然后根据Condition条件进行查询。

二、举例

2.1 数据准备

INSERT INTO `hkt_common_ability`.`capability_servie_matters` (
	`id`,
	`service_name`,
	`service_type_level1`,
	`service_type_level2`,
	`acceptance_conditions`,
	`use_guide`,
	`service_support_platform`,
	`flow_and_accept_time_limit`,
	`assessment_and_evaluation_indicators`,
	`accepting_unit`,
	`internal_organization`,
	`internal_organization_person`,
	`service_institutions`,
	`affiliated_person`,
	`required_information`,
	`related_ability`,
	`service_status`,
	`images`,
	`is_deleted`,
	`tenant_id`,
	`create_id`,
	`create_name`,
	`create_time`,
	`update_id`,
	`update_name`,
	`update_time`
)
VALUES
	(
		'1',
		'区块链1',
		'2',
		'6',
		'资产必须达到一个小目标111111',
		'想怎么用就怎么用',
		'相关管理能力平台',
		'没有流程，不设时限',
		'1、净利润：5000万；2、资产：1亿',
		'1',
		'3',
		'8',
		'1',
		'1,2,3',
		'2,3',
		'8,9',
		'1',
        '[{\"image\":\"图片1\",\"url\":\"https://micro.hkttech.cn/file/oss/hkt/20230414/kjG66y45ZiHjEOvBJKtkh.jpeg\",\"first\":true},{\"image\":\"图片2\",\"url\":\"https://micro.hkttech.cn/file/oss/hkt/20230414/JWp6cco1NrfjR69CQjr5j.jpeg\",\"first\":false}]',
		'0',
		'100000',
		'1',
		'admin',
		NULL,
		'1',
		'admin',
		NULL
	);

如上，service_type_level1、service_type_level2、internal_organization、internal_organization_person、service_institutions、affiliated_person、required_information、related_ability等均为外键，其中service_type_level1、service_type_level2、internal_organization、internal_organization_person、service_institutions与其它表是多对一的关系，affiliated_person、required_information、related_ability是一对多的关系，一对多的关系我选择使用字符串类型来保存其他表的多个id（用逗号隔开）。images中需要保存多张图片，且每张图片需要标注图片名称、图片路径以及是否首图等属性，此处我同样以字符串类型来存储对应的图片属性对象集合。

2.2、各类型对象

2.2.1 实体类封装

package cs.gov.bigdata.ca.ability.manage.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.hkt.core.database.entity.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import io.swagger.v3.oas.annotations.media.Schema;

/**
 * 服务事项管理实体类
 *
 */
@Data
@EqualsAndHashCode(callSuper = true)
@Schema(name = "CapabilityServieMatters对象", description = "服务事项管理")
public class CapabilityServieMatters extends BaseEntity {

	private static final long serialVersionUID = 1L;

	/**
	* 服务名称
	*/
	@Schema(description = "服务名称")
	private String serviceName;
	/**
	* 1级服务类型
	*/
	@Schema(description = "1级服务类型")
	private Long serviceTypeLevel1;
	/**
	* 2级服务类型
	*/
	@Schema(description = "2级服务类型")
	@TableField(updateStrategy = FieldStrategy.IGNORED)
	private Long serviceTypeLevel2;
	/**
	* 受理条件
	*/
	@Schema(description = "受理条件")
	private String acceptanceConditions;
	/**
	* 使用指南
	*/
	@Schema(description = "使用指南")
	private String useGuide;
	/**
	* 服务支撑平台
	*/
	@Schema(description = "服务支撑平台")
	private String serviceSupportPlatform;
	/**
	* 服务流程和受理时限
	*/
	@Schema(description = "服务流程和受理时限")
	private String flowAndAcceptTimeLimit;
	/**
	* 考核和评价指标
	*/
	@Schema(description = "考核和评价指标")
	private String assessmentAndEvaluationIndicators;
	/**
	* 服务受理单位
	*/
	@Schema(description = "服务受理单位")
	private Long acceptingUnit;
	/**
	* 内设机构（处部室）
	*/
	@Schema(description = "内设机构（处部室）")
	private Long internalOrganization;
	/**
	* 内设机构人员
	*/
	@Schema(description = "内设机构人员")
	private Long internalOrganizationPerson;
	/**
	* 服务机构
	*/
	@Schema(description = "服务机构")
	private Long serviceInstitutions;
	/**
	* 关联服务机构人员
	*/
	@Schema(description = "关联服务机构人员")
	private String affiliatedPerson;
	/**
	* 所需材料
	*/
	@Schema(description = "所需材料")
	private String requiredInformation;
	/**
	* 关联能力
	*/
	@Schema(description = "关联能力")
	private String relatedAbility;
	/**
	* 服务状态（0未发布，1已发布）
	*/
	@Schema(description = "服务状态（0未发布，1已发布）")
	private Integer serviceStatus;
	/**
	* 是否已删除（0否，1是）
	*/
	@Schema(description = "是否已删除（0否，1是）")
	@TableLogic(value = "0" ,delval="1")
	private Boolean isDeleted;
	/**
	* 租户id
	*/
	@Schema(description = "租户id")
	private Long tenantId;

    /**
     * 图片
     */
	@Schema(description = "图片")
    private String images;

}

package com.hkt.core.database.entity;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.v3.oas.annotations.media.Schema;
import java.io.Serializable;
import java.time.LocalDateTime;

@Data
public class BaseEntity implements Serializable {
    @JsonSerialize(
        using = ToStringSerializer.class
    )
    @Schema(
        description = "主键id"
    )
    @TableId(
        value = "id",
        type = IdType.AUTO
    )
    private Long id;
    @Schema(
        description = "创建人"
    )
    @JsonSerialize(
        using = ToStringSerializer.class
    )
    @TableField(
        fill = FieldFill.INSERT
    )
    private Long createId;
    @Schema(
        description = "创建人"
    )
    @TableField(
        fill = FieldFill.INSERT
    )
    private String createName;
    @JsonSerialize(
        using = ToStringSerializer.class
    )
    @Schema(
        description = "更新人"
    )
    @TableField(
        fill = FieldFill.INSERT_UPDATE
    )
    private Long updateId;
    @Schema(
        description = "更新人"
    )
    @TableField(
        fill = FieldFill.INSERT_UPDATE
    )
    private String updateName;
    @Schema(
        description = "创建时间"
    )
    @TableField(
        fill = FieldFill.INSERT
    )
    private LocalDateTime createTime;
    @Schema(
        description = "更新时间"
    )
    @TableField(
        fill = FieldFill.INSERT_UPDATE
    )
    private LocalDateTime updateTime;

}

2.2.2 查询条件封装

package cs.gov.bigdata.ca.ability.manage.condition;

import com.hkt.core.database.entity.Search;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import java.util.List;

/**
 * @Description 服务事项管理查询条件
 */
@Data
public class CapabilityServieMattersCondition extends Search {

    /**
     * 1级服务类型
     */
    @Schema(description = "1级服务类型")
    private Integer serviceTypeLevel1;
    /**
     * 2级服务类型
     */
    @Schema(description = "2级服务类型")
    private Integer serviceTypeLevel2;
    /**
     * 服务状态（0未发布，1已发布）
     */
    @Schema(description = "服务状态（0未发布，1已发布）")
    private Integer serviceStatus;
    /**
     * 服务受理单位
     */
    @Schema(description = "服务受理单位")
    private Long acceptingUnit;
    /**
     * 内设机构（处部室）
     */
    @Schema(description = "内设机构（处部室）")
    private Long internalOrganization;
    /**
     * 服务名称
     */
    @Schema(description = "服务名称")
    private String serviceName;
    /**
     * 服务提供单位
     */
    @Schema(description = "服务提供单位")
    private Long serviceInstitutions;
    /**
     * 是否统计所有事项
     */
    @Schema(description = "是否统计所有事项")
    private Boolean countService = false;
    /**
     * 多选id
     */
    @Schema(description = "多选id")
    private String ids;
}

package com.hkt.core.database.entity;

import cn.hutool.core.util.StrUtil;
import io.swagger.v3.oas.annotations.media.Schema;
import java.io.Serializable;

@Schema(
    description = "搜索条件"
)
@Data
public class Search implements Serializable {
    @Schema(
        description = "关键词"
    )
    private String keyword;
    @Schema(
        description = "流程模型分类id"
    )
    private Integer categoryId;
    @Schema(
        description = "租户ID"
    )
    private Integer tenantId;
    @Schema(
        description = "角色类型"
    )
    private String roleType;
    @Schema(
        description = "开始日期"
    )
    private String startDate;
    @Schema(
        description = "结束日期"
    )
    private String endDate;
    @Schema(
        description = "排序属性"
    )
    private String prop;
    @Schema(
        description = "排序方式"
    )
    private String order;
    @Schema(
        description = "状态"
    )
    private Integer status;
    @Schema(
        description = "当前页"
    )
    private Integer current = 1;
    @Schema(
        description = "每页的数量"
    )
    private Integer size = 10;

}

2.2.3 数据传输对象封装

package cs.gov.bigdata.ca.ability.manage.dto;

import com.baomidou.mybatisplus.annotation.FieldStrategy;
import com.baomidou.mybatisplus.annotation.TableField;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 服务事项管理数据传输对象
 */
@Data
@Schema(name = "CapabilityServieMattersDTO对象", description = "服务事项管理")
public class CapabilityServieMattersDTO {

	private static final long serialVersionUID = 1L;
	/**
	 * 服务事项id
	 */
	@Schema(description = "服务事项id")
	private Long id;
	/**
	* 服务名称
	*/
	@Schema(description = "服务名称")
	@NotBlank(message = "服务名称不能为空")
	private String serviceName;
	/**
	* 1级服务类型
	*/
	@Schema(description = "1级服务类型")
	@NotNull(message = "1级服务类型不能为空")
	private Long serviceTypeLevel1;
	/**
	* 1级服务类型名称
	*/
	@Schema(description = "1级服务类型名称")
	private String serviceTypeLevel1Name;
	/**
	* 2级服务类型
	*/
	@Schema(description = "2级服务类型")
	private Long serviceTypeLevel2;
	/**
	* 2级服务类型名称
	*/
	@Schema(description = "2级服务类型名称")
	private String serviceTypeLevel2Name;
	/**
	* 受理条件
	*/
	@Schema(description = "受理条件")
	@NotBlank(message = "受理条件不能为空")
	private String acceptanceConditions;
	/**
	* 使用指南
	*/
	@Schema(description = "使用指南")
	@NotBlank(message = "使用指南不能为空")
	private String useGuide;
	/**
	* 服务支撑平台
	*/
	@Schema(description = "服务支撑平台")
	@NotBlank(message = "服务支撑平台不能为空")
	private String serviceSupportPlatform;
	/**
	* 服务流程和受理时限
	*/
	@Schema(description = "服务流程和受理时限")
	@NotBlank(message = "服务流程和受理时限不能为空")
	@Size(max = 200, min = 1, message = "服务流程和受理时限不能为空，且长度在200字内")
	private String flowAndAcceptTimeLimit;
	/**
	* 考核和评价指标
	*/
	@Schema(description = "考核和评价指标")
	@NotBlank(message = "考核和评价指标不能为空")
	@Size(max = 500, min = 1, message = "考核和评价指标不能为空，且长度在500字内")
	private String assessmentAndEvaluationIndicators;
	/**
	* 服务受理单位
	*/
	@Schema(description = "服务受理单位")
	@NotNull(message = "服务受理单位不能为空")
	private Long acceptingUnit;
	/**
	 * 服务受理单位
	 */
	private String acceptingUnitName;
	/**
	* 内设机构（处部室）
	*/
	@Schema(description = "内设机构（处部室）")
	@NotNull(message = "内设机构（处部室）不能为空")
	private Long internalOrganization;
	/**
	* 内设机构（处部室）
	*/
	private String internalOrganizationName;
	/**
	* 内设机构人员
	*/
	@Schema(description = "内设机构人员")
	@NotNull(message = "内设机构人员不能为空")
	private Long internalOrganizationPerson;
	/**
	* 内设机构人员
	*/
	private String internalOrganizationPersonName;
	/**
	* 内设机构联系方式
	*/
	private String internalOrganizationPhone;
	/**
	* 服务机构
	*/
	@Schema(description = "服务机构")
	@NotNull(message = "服务机构不能为空")
	private Long serviceInstitutions;
	/**
	* 服务机构名称
	*/
	@Schema(description = "服务机构名称")
	private Long serviceInstitutionsName;
	/**
	* 统一社会信用代码
	*/
	private String unifiedSocialCreditCode;
	/**
	* 服务机构地址
	*/
	private String serviceInstitutionsAddr;
	/**
	* 服务机构法人
	*/
	private String serviceInstitutionsLegalPerson;
	/**
	* 服务机构法人联系方式
	*/
	private String legalPersonPhone;
	/**
	* 关联服务机构人员
	*/
	private String affiliatedPerson;
	/**
	* 关联服务机构人员
	*/
	@Schema(description = "关联服务机构人员")
	@NotNull(message = "关联服务机构人员不能为空")
	private List<Long> affiliatedPersonList;
	/**
	 * 关联服务机构人员联系方式
	 */
	private String affiliatedPersonPhone;
	/**
	* 所需材料
	*/
	private String requiredInformation;
	/**
	* 所需材料
	*/
	@Schema(description = "所需材料")
	@NotNull(message = "所需材料不能为空")
	private List<Long> requiredInformationList;
	/**
	* 关联能力
	*/
	private String relatedAbility;
	/**
	* 关联能力
	*/
	@Schema(description = "关联能力")
	@NotNull(message = "关联能力不能为空")
	private List<Long> relatedAbilityList;
	/**
	* 服务状态（0未发布，1已发布）
	*/
	private Integer serviceStatus;
	/**
	* 是否已删除（0否，1是）
	*/
	private Boolean isDeleted;
	/**
	* 租户id
	*/
	private Long tenantId;
	/**
	* 租户id
	*/
	private LocalDateTime createTime;

    /**
     * 图片
     */
    private String images;
    private JSONArray imagesList;


     public void setImages(String images) {
        if(StringUtils.isNotBlank(images)) {
            this.imagesList = JSONArray.parseArray(images);
        }
        this.images = images;
    }

    public void setImagesList(JSONArray imagesList) {
        if(imagesList != null) {
            this.images = imagesList.toString();
        }
        this.imagesList = imagesList;
    }

	public void setAffiliatedPerson(String affiliatedPerson) {
		this.affiliatedPerson = affiliatedPerson;
		this.affiliatedPersonList = StringUtils.isNotBlank(affiliatedPerson)? Arrays.asList(affiliatedPerson.split(",")).stream().map(Long::valueOf).collect(Collectors.toList()):null;
	}

	public void setAffiliatedPersonList(List<Long> affiliatedPersonList) {
		this.affiliatedPersonList = affiliatedPersonList;
		this.affiliatedPerson = CollectionUtils.isEmpty(affiliatedPersonList) ? null : StringUtils.join(affiliatedPersonList.toArray(),",");
	}

	public void setRequiredInformation(String requiredInformation) {
		this.requiredInformation = requiredInformation;
		this.requiredInformationList = StringUtils.isNotBlank(requiredInformation)? Arrays.asList(requiredInformation.split(",")).stream().map(Long::valueOf).collect(Collectors.toList()):null;
	}

	public void setRequiredInformationList(List<Long> requiredInformationList) {
		this.requiredInformationList = requiredInformationList;
		this.requiredInformation = CollectionUtils.isEmpty(requiredInformationList) ? null : StringUtils.join(requiredInformationList.toArray(),",");
	}

	public void setRelatedAbility(String relatedAbility) {
		this.relatedAbility = relatedAbility;
		this.relatedAbilityList = StringUtils.isNotBlank(relatedAbility)? Arrays.asList(relatedAbility.split(",")).stream().map(Long::valueOf).collect(Collectors.toList()):null;
	}

	public void setRelatedAbilityList(List<Long> relatedAbilityList) {
		this.relatedAbilityList = relatedAbilityList;
		this.relatedAbility = CollectionUtils.isEmpty(relatedAbilityList) ? null : StringUtils.join(relatedAbilityList.toArray(),",");
	}
}

2.2.4 视图对象封装

package cs.gov.bigdata.ca.ability.manage.vo;

import cs.gov.bigdata.ca.ability.manage.dto.CapabilityServieMattersDTO;
import cs.gov.bigdata.ca.ability.portal.enums.NoticeStatusEnum;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 服务事项管理列表展示对象
 */
@Data
@Schema(name = "服务事项管理列表展示对象", description = "服务事项管理")
public class CapabilityServieMattersListVO {

	private static final long serialVersionUID = 1L;
	/**
	 * 服务事项id
	 */
	@Schema(description = "服务事项id")
	private Long id;
	/**
	* 服务名称
	*/
	@Schema(description = "服务名称")
	private String serviceName;
	/**
	* 服务类型
	*/
	@Schema(description = "服务类型")
	private String serviceTypeName;
	/**
	* 服务受理单位
	*/
	@Schema(description = "服务受理单位")
	private String acceptingUnitName;
	/**
	* 服务受理单位内设机构（处部室）
	*/
	@Schema(description = "服务受理单位内设机构（处部室）")
	private String internalOrganizationName;
	/**
	* 服务受理单位联系人
	*/
	@Schema(description = "服务受理单位联系人")
	private String internalOrganizationPersonName;
	/**
	* 服务受理单位联系电话
	*/
	private String internalOrganizationPhone;
	/**
	* 服务状态（0未发布，1已发布）
	*/
	private Integer serviceStatus;
	/**
	* 服务状态（0未发布，1已发布）
	*/
	private String serviceStatusName;
    /**
     * 图片
     */
    private JSONArray imagesList;

	public CapabilityServieMattersListVO(CapabilityServieMattersDTO dto){
		if (Objects.nonNull(dto)) {
			this.id = dto.getId();
			this.serviceName = dto.getServiceName();
			this.serviceTypeName = dto.getServiceTypeLevel1Name() + (StringUtils.isNotBlank(dto.getServiceTypeLevel2Name()) ? ("/" + dto.getServiceTypeLevel2Name()) : "");
			this.acceptingUnitName = dto.getAcceptingUnitName();
			this.internalOrganizationName = dto.getInternalOrganizationName();
			this.internalOrganizationPersonName = dto.getInternalOrganizationPersonName();
			this.internalOrganizationPhone = dto.getInternalOrganizationPhone();
			this.serviceStatus = dto.getServiceStatus();
			this.serviceStatusName = NoticeStatusEnum.getValueText(dto.getServiceStatus());
            this.imagesList = dto.getImagesList();
		}
	}
}

package cs.gov.bigdata.ca.ability.manage.vo;

import cs.gov.bigdata.ca.ability.manage.dto.CapabilityServieMattersDTO;
import cs.gov.bigdata.ca.ability.portal.enums.NoticeStatusEnum;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.List;
import java.util.Objects;

/**
 * 服务事项管理详情展示对象
 */
@Data
@Schema(name = "服务事项管理详情展示对象", description = "服务事项管理")
public class CapabilityServieMattersDetailVO {

	private static final long serialVersionUID = 1L;
	/**
	 * 服务事项id
	 */
	@Schema(description = "服务事项id")
	private Long id;
	/**
	 * 服务名称
	 */
	@Schema(description = "服务名称")
	private String serviceName;
	/**
	 * 1级服务类型
	 */
	@Schema(description = "1级服务类型")
	private Long serviceTypeLevel1;
	/**
	 * 2级服务类型
	 */
	@Schema(description = "2级服务类型")
	private Long serviceTypeLevel2;
	/**
	 * 受理条件
	 */
	@Schema(description = "受理条件")
	private String acceptanceConditions;
	/**
	 * 使用指南
	 */
	@Schema(description = "使用指南")
	private String useGuide;
	/**
	 * 服务支撑平台
	 */
	@Schema(description = "服务支撑平台")
	private String serviceSupportPlatform;
	/**
	 * 服务流程和受理时限
	 */
	@Schema(description = "服务流程和受理时限")
	private String flowAndAcceptTimeLimit;
	/**
	 * 考核和评价指标
	 */
	@Schema(description = "考核和评价指标")
	private String assessmentAndEvaluationIndicators;
	/**
	 * 服务受理单位
	 */
	@Schema(description = "服务受理单位")
	private Long acceptingUnit;
	/**
	 * 内设机构（处部室）
	 */
	@Schema(description = "内设机构（处部室）")
	private Long internalOrganization;
	/**
	 * 内设机构人员
	 */
	@Schema(description = "内设机构人员")
	private Long internalOrganizationPerson;
	/**
	 * 服务机构
	 */
	@Schema(description = "服务机构")
	private Long serviceInstitutions;
	/**
	 * 关联服务机构人员列表
	 */
	@Schema(description = "关联服务机构人员列表")
	private List<Long> affiliatedPersonList;
	/**
	 * 所需材料
	 */
	@Schema(description = "所需材料")
	private List<Long> requiredInformationList;
	/**
	 * 关联能力
	 */
	@Schema(description = "关联能力")
	private List<Long> relatedAbilityList;

}

package cs.gov.bigdata.ca.ability.common.vo;

import lombok.*;

import java.util.List;

/**
 * @Description 单位及人员联级下拉展示层
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UnitAndPersonCascadeVO {
    private Long id;
    private String name;
    private String telphone;
    private String email;
    private List<UnitAndPersonCascadeVO> children;
}

2.3 Controller层

package cs.gov.bigdata.ca.ability.manage.controller;

import cn.hutool.core.collection.CollectionUtil;
import com.hkt.core.common.api.Result;
import com.hkt.core.common.util.KeyValue;
import com.hkt.core.database.entity.Search;
import cs.gov.bigdata.ca.ability.common.vo.CommonVO;
import cs.gov.bigdata.ca.ability.config.entity.Company;
import cs.gov.bigdata.ca.ability.config.entity.FileInfo;
import cs.gov.bigdata.ca.ability.config.entity.InteriorOrgan;
import cs.gov.bigdata.ca.ability.config.entity.InteriorOrganPerson;
import cs.gov.bigdata.ca.ability.config.service.*;
import cs.gov.bigdata.ca.ability.manage.condition.CapabilityServieMattersCondition;
import cs.gov.bigdata.ca.ability.manage.dto.CapabilityServieMattersDTO;
import cs.gov.bigdata.ca.ability.manage.entity.CapabilityServieMatters;
import cs.gov.bigdata.ca.ability.manage.service.ICapabilityServerTypeService;
import cs.gov.bigdata.ca.ability.manage.service.ICapabilityServieMattersService;
import cs.gov.bigdata.ca.ability.manage.service.ICapabilityTypeService;
import cs.gov.bigdata.ca.ability.portal.enums.NoticeStatusEnum;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Parameters;
import io.swagger.v3.oas.annotations.enums.ParameterIn;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.web.bind.annotation.*;
import lombok.AllArgsConstructor;

import com.hkt.core.auth.annotation.PreAuth;
import com.hkt.core.log.annotation.Log;

import org.springframework.web.bind.annotation.RestController;
import com.hkt.core.web.controller.BaseController;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 * 服务事项管理 前端控制器
 * </p>
 *
 * @author hkt
 * @since 2023-04-19
 */
@RestController
@AllArgsConstructor
@RequestMapping("/capability-servie-matters")
@Tag(name  = "服务事项管理", description = "服务事项管理接口")
public class CapabilityServieMattersController extends BaseController {

    private final ICapabilityServieMattersService capabilityServieMattersService;
    private final ICapabilityServerTypeService capabilityServerTypeService;
    private final IServeOrganService serveOrganService;
    private final IServePersonService servePersonService;
    private final IFileInfoService fileInfoService;
    private final ICapabilityTypeService capabilityTypeService;

    /**
     * 相关下拉选项
     * @return Result
     */
    @PreAuth
    @Log(value = "服务事项管理相关下拉选", exception = "服务事项管理相关下拉选请求异常")
    @GetMapping("/dropdown/options")
    @Operation(summary = "服务事项管理相关下拉选", description = "相关下拉选")
    public Result<?> dropdownOptions() {
        Map<String,Object> result = new HashMap<>();
        //服务状态
        result.put("serviceStatus", NoticeStatusEnum.keyValues());
        //服务类型
        result.put("serviceType",capabilityServerTypeService.getTree());
        //受理单位
        result.put("acceptingUnit",capabilityServieMattersService.getAcceptingUnitTree());
        //服务机构
        result.put("serviceInstitutions",serveOrganService.list().stream().map(s -> {
            return new KeyValue<>(s.getId(), s);
        }).collect(Collectors.toList()));
        //服务机构人员
        result.put("affiliatedPerson",servePersonService.list().stream().map(s -> {
            return new KeyValue<>(s.getId(), s);
        }).collect(Collectors.toList()));
        //所需材料
        List<FileInfo> requiredInformationList = fileInfoService.list();
        result.put("requiredInformation",requiredInformationList.stream().map(s -> {
            return new CommonVO(s.getId(), s.getFileName(), s.getFilePath());
        }).collect(Collectors.toList()));
        //关联能力
        result.put("relatedAbility",capabilityTypeService.list().stream().map(s -> {
            return new KeyValue<>(s.getId(), s.getName());
        }).collect(Collectors.toList()));
        return Result.data(result);
    }


    /**
     * 分页列表
     *
     * @param condition 查询条件
     * @return Result
     */
    @PreAuth
    @Log(value = "服务事项管理列表", exception = "服务事项管理列表请求异常")
    @GetMapping("/page")
    @Operation(summary = "服务事项管理列表", description = "分页查询")
    @Parameters({
        @Parameter(name = "current", required = true,  description = "当前页", in = ParameterIn.DEFAULT),
        @Parameter(name = "size", required = true,  description = "每页显示数据", in = ParameterIn.DEFAULT),
        @Parameter(name = "keyword", required = true,  description = "模糊查询关键词", in = ParameterIn.DEFAULT),
        @Parameter(name = "startDate", required = true,  description = "创建开始日期", in = ParameterIn.DEFAULT),
        @Parameter(name = "endDate", required = true,  description = "创建结束日期", in = ParameterIn.DEFAULT),
    })
    public Result<?> page(CapabilityServieMattersCondition condition) {
		return Result.data(capabilityServieMattersService.listPage(condition));
    }

    /**
     * 服务事项管理信息
     *
     * @param id Id
     * @return Result
     */
    @PreAuth
    @Log(value = "服务事项管理信息", exception = "服务事项管理信息请求异常")
    @GetMapping("/get")
    @Operation(summary = "服务事项管理信息", description = "根据ID查询")
    @Parameters({
            @Parameter(name = "id", required = true,  description = "ID", in = ParameterIn.DEFAULT),
    })
    public Result<?> get(@RequestParam Long id) {
		return Result.data(capabilityServieMattersService.getDetail(id));
	}

    /**
    * 服务事项管理新增
    *
    * @param dto 数据传输象
    * @return Result
    */
    @PreAuth
    @Log(value = "服务事项管理新增", exception = "服务事项管理新增请求异常")
    @PostMapping("/add")
    @Operation(summary = "服务事项管理新增", description = "服务事项管理新增")
    public Result<?> add(@Valid @RequestBody CapabilityServieMattersDTO dto) {
		return Result.condition(capabilityServieMattersService.add(dto));
    }

    /**
    * 服务事项管理编辑
    *
    * @param dto 数据传输对象
    * @return Result
    */
    @PreAuth
    @Log(value = "服务事项管理编辑", exception = "服务事项管理编辑请求异常")
    @PostMapping("/update")
    @Operation(summary = "服务事项管理编辑", description = "服务事项管理编辑")
    public Result<?> update(@Valid @RequestBody CapabilityServieMattersDTO dto) {
        if(Objects.isNull(dto.getId())){
            return Result.fail("id不能为空！！");
        }
		return Result.condition(capabilityServieMattersService.update(dto));
	}

    /**
     * 发布/停止发布服务事项
     *
     * @param status 服务状态（0停止发布，1发布）
     * @return Result
     */
    @PreAuth
    @Log(value = "发布/停止发布服务事项", exception = "发布/停止发布服务事项请求异常")
    @GetMapping("/setStatus")
    @Operation(summary = "发布/停止发布服务事项", description = "发布/停止发布服务事项")
    public Result<?> setStatus(@RequestParam("id") Long id, @RequestParam("status") Integer status) {
        return Result.condition(capabilityServieMattersService.setStatus(id,status));
    }

    /**
    * 服务事项管理删除
    *
    * @param id 服务事项管理id
    * @return Result
    */
    @PreAuth
    @Log(value = "服务事项管理删除", exception = "服务事项管理删除请求异常")
    @GetMapping("/del")
    @Operation(summary = "服务事项管理删除", description = "服务事项管理删除")
    @Parameters({
            @Parameter(name = "id", required = true,  description = "服务事项管理id", in = ParameterIn.DEFAULT)
    })
    public Result<?> del(@RequestParam Long id) {
		return Result.condition(capabilityServieMattersService.removeById(id));
	}
}

2.4 Service层

package cs.gov.bigdata.ca.ability.manage.service;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import cs.gov.bigdata.ca.ability.common.vo.UnitAndPersonCascadeVO;
import cs.gov.bigdata.ca.ability.manage.condition.CapabilityServieMattersCondition;
import cs.gov.bigdata.ca.ability.manage.dto.CapabilityServieMattersDTO;
import cs.gov.bigdata.ca.ability.manage.entity.CapabilityServieMatters;
import cs.gov.bigdata.ca.ability.manage.vo.CapabilityServieMattersDetailVO;
import cs.gov.bigdata.ca.ability.manage.vo.CapabilityServieMattersListForServiceSupportVO;
import cs.gov.bigdata.ca.ability.manage.vo.CapabilityServieMattersListVO;

import java.util.List;

/**
 * <p>
 * 服务事项管理 服务类
 * </p>
 */
public interface ICapabilityServieMattersService extends IService<CapabilityServieMatters> {

	/**
     * 获取受理单位的联级树
     */
	List<UnitAndPersonCascadeVO> getAcceptingUnitTree();

	/**
     * 分页业务方法
     * @param condition　搜索参数
     * @return IPage
     */
	IPage<CapabilityServieMattersListVO> listPage(CapabilityServieMattersCondition condition);

	/**
     * 新增
     * @param dto 参数
     * @return IPage
     */
	Boolean add(CapabilityServieMattersDTO dto);

	/**
     * 修改
     * @param dto　参数
     * @return IPage
     */
	Boolean update(CapabilityServieMattersDTO dto);

	/**
     * 发布/停止发布
     * @param id　id
     * @param status　服务状态（0停止发布，1发布）
     * @return IPage
     */
	Boolean setStatus(Long id, Integer status);

	/**
     * 获取详情
     * @param id　id
     * @return IPage
     */
	CapabilityServieMattersDetailVO getDetail(Long id);

}

package cs.gov.bigdata.ca.ability.manage.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hkt.core.database.util.PageUtil;
import cs.gov.bigdata.ca.ability.common.vo.UnitAndPersonCascadeVO;
import cs.gov.bigdata.ca.ability.config.service.CompanyService;
import cs.gov.bigdata.ca.ability.config.service.IInteriorOrganPersonService;
import cs.gov.bigdata.ca.ability.config.service.IInteriorOrganService;
import cs.gov.bigdata.ca.ability.manage.condition.CapabilityServieMattersCondition;
import cs.gov.bigdata.ca.ability.manage.dto.CapabilityServieMattersDTO;
import cs.gov.bigdata.ca.ability.manage.entity.CapabilityServieMatters;
import cs.gov.bigdata.ca.ability.manage.mapper.CapabilityServieMattersMapper;
import cs.gov.bigdata.ca.ability.manage.service.ICapabilityServieMattersService;
import cs.gov.bigdata.ca.ability.manage.vo.CapabilityServieMattersDetailVO;
import cs.gov.bigdata.ca.ability.manage.vo.CapabilityServieMattersListForServiceSupportVO;
import cs.gov.bigdata.ca.ability.manage.vo.CapabilityServieMattersListVO;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 服务事项管理 服务实现类
 * </p>
 */
@Service
public class CapabilityServieMattersServiceImpl extends ServiceImpl<CapabilityServieMattersMapper, CapabilityServieMatters> implements ICapabilityServieMattersService {

	@Resource
	private CapabilityServieMattersMapper capabilityServieMattersMapper;
	@Resource
	private CompanyService companyService;
	@Resource
	private IInteriorOrganService interiorOrganService;
	@Resource
	private IInteriorOrganPersonService interiorOrganPersonService;

	@Override
	public List<UnitAndPersonCascadeVO> getAcceptingUnitTree() {
        //方法1 使用数据库进行联级封装
		return capabilityServieMattersMapper.getAcceptingUnitTree();

        //方法2 使用java代码遍历进行联级封装
//		//内设机构人员
//		List<InteriorOrganPerson> interiorOrganPersonList = interiorOrganPersonService.list();
//		//内设机构
//		List<InteriorOrgan> interiorOrganList = interiorOrganService.list();
//		//服务单位
//		List<Company> acceptingUnitList = companyService.list();
//		//封装结果
//		List<CascadeDropdownVO> result = new ArrayList<>();
//		for(Company l1 : acceptingUnitList){
//			CascadeDropdownVO vo1 = new CascadeDropdownVO();
//			vo1.setKey(l1.getId());
//			vo1.setValue(l1.getCompanyName());
//			List<CascadeDropdownVO> children1 = new ArrayList<>();
//			for(InteriorOrgan l2: interiorOrganList){
//				CascadeDropdownVO vo2 = new CascadeDropdownVO();
//				vo2.setKey(l2.getId());
//				vo2.setValue(l2.getInteriorOrganName());
//				List<CascadeDropdownVO> children2 = new ArrayList<>();
//				for(InteriorOrganPerson l3: interiorOrganPersonList){
//					CascadeDropdownVO vo3 = new CascadeDropdownVO();
//					vo3.setKey(l3.getId());
//					vo3.setValue(l3);
//					if(l2.getId().equals(l3.getInteriorOrganId())){
//						children2.add(vo3);
//					}
//				}
//				vo2.setChildren(children2);
//				if(l1.getId().equals(l2.getCompanyId())){
//					children1.add(vo2);
//				}
//			}
//			vo1.setChildren(children1);
//			result.add(vo1);
//		}
//		return result;
	}

	@Override
	public IPage<CapabilityServieMattersListVO> listPage(CapabilityServieMattersCondition condition) {
		IPage<CapabilityServieMattersDTO> dtoPage = capabilityServieMattersMapper.listPage(PageUtil.getPage(condition), condition);
		IPage<CapabilityServieMattersListVO> result = new Page<>(dtoPage.getCurrent(), dtoPage.getSize(),dtoPage.getTotal());
		List<CapabilityServieMattersDTO> dtoList = dtoPage.getRecords();
		if(CollectionUtil.isEmpty(dtoList)){
			return result;
		}
		List<CapabilityServieMattersListVO> voList = dtoList.stream().map(dto -> {
			return new CapabilityServieMattersListVO(dto);
		}).collect(Collectors.toList());
		result.setRecords(voList);
		return result;
	}

	@Override
	public Boolean add(CapabilityServieMattersDTO dto) {
		CapabilityServieMatters capabilityServieMatters = new CapabilityServieMatters();
		BeanUtils.copyProperties(dto,capabilityServieMatters);
		return this.save(capabilityServieMatters);
	}

	@Override
	public Boolean update(CapabilityServieMattersDTO dto) {
		CapabilityServieMatters capabilityServieMatters = new CapabilityServieMatters();
		BeanUtils.copyProperties(dto,capabilityServieMatters);
		return this.updateById(capabilityServieMatters);
	}

	@Override
	public Boolean setStatus(Long id, Integer status) {
		CapabilityServieMatters capabilityServieMatters = new CapabilityServieMatters();
		capabilityServieMatters.setId(id);
		capabilityServieMatters.setServiceStatus(status);
		return this.updateById(capabilityServieMatters);
	}

	@Override
	public CapabilityServieMattersDetailVO getDetail(Long id) {
		CapabilityServieMatters byId = this.getById(id);
		CapabilityServieMattersDTO dto = new CapabilityServieMattersDTO();
		BeanUtils.copyProperties(byId,dto);
		CapabilityServieMattersDetailVO vo = new CapabilityServieMattersDetailVO();
		BeanUtils.copyProperties(dto,vo);
		return vo;
	}

}

2.5 Dao层

package cs.gov.bigdata.ca.ability.manage.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import cs.gov.bigdata.ca.ability.common.vo.UnitAndPersonCascadeVO;
import cs.gov.bigdata.ca.ability.manage.condition.CapabilityServieMattersCondition;
import cs.gov.bigdata.ca.ability.manage.dto.CapabilityServieMattersDTO;
import cs.gov.bigdata.ca.ability.manage.entity.CapabilityServieMatters;
import cs.gov.bigdata.ca.ability.manage.vo.CapabilityServieMattersListForServiceSupportVO;
import cs.gov.bigdata.ca.ability.portal.dto.ServieHandlingDTO;
import cs.gov.bigdata.ca.ability.portal.vo.ServieHandlingDetailVO;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * <p>
 * 服务事项管理 Mapper 接口
 * </p>
 */
public interface CapabilityServieMattersMapper extends BaseMapper<CapabilityServieMatters> {


    List<UnitAndPersonCascadeVO> getAcceptingUnitTree();

    /**
     * 服务事项分页查询
     * @param page
     * @param condition
     * @return
     */
    IPage<CapabilityServieMattersDTO> listPage(@Param("page") IPage page, @Param("condition") CapabilityServieMattersCondition condition);

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cs.gov.bigdata.ca.ability.manage.mapper.CapabilityServieMattersMapper">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="cs.gov.bigdata.ca.ability.manage.dto.CapabilityServieMattersDTO">
        <result column="id" property="id" />
        <result column="service_name" property="serviceName" />
        <result column="service_type_level1" property="serviceTypeLevel1" />
        <result column="service_type_level1_name" property="serviceTypeLevel1Name" />
        <result column="service_type_level2" property="serviceTypeLevel2" />
        <result column="service_type_level2_name" property="serviceTypeLevel2Name" />
        <result column="acceptance_conditions" property="acceptanceConditions" />
        <result column="use_guide" property="useGuide" />
        <result column="service_support_platform" property="serviceSupportPlatform" />
        <result column="flow_and_accept_time_limit" property="flowAndAcceptTimeLimit" />
        <result column="assessment_and_evaluation_indicators" property="assessmentAndEvaluationIndicators" />
        <result column="accepting_unit" property="acceptingUnit" />
        <result column="accepting_unit_name" property="acceptingUnitName" />
        <result column="internal_organization" property="internalOrganization" />
        <result column="internal_organization_name" property="internalOrganizationName" />
        <result column="internal_organization_person" property="internalOrganizationPerson" />
        <result column="internal_organization_person_name" property="internalOrganizationPersonName" />
        <result column="internal_organization_phone" property="internalOrganizationPhone" />
        <result column="service_institutions" property="serviceInstitutions" />
        <result column="service_institutions_name" property="serviceInstitutionsName" />
        <result column="unified_social_credit_code" property="unifiedSocialCreditCode" />
        <result column="service_institutions_addr" property="serviceInstitutionsAddr" />
        <result column="service_institutions_legal_person" property="serviceInstitutionsLegalPerson" />
        <result column="legal_person_phone" property="legalPersonPhone" />
        <result column="affiliated_person" property="affiliatedPerson" />
        <result column="required_information" property="requiredInformation" />
        <result column="related_ability" property="relatedAbility" />
        <result column="service_status" property="serviceStatus" />
        <result column="images" property="images" />
        <result column="is_deleted" property="isDeleted" />
        <result column="tenant_id" property="tenantId" />
        <result column="create_time" property="createTime" />
    </resultMap>

    <!-- 受理单位联级查询映射结果 -->
    <resultMap id="CascadeResultMap" type="cs.gov.bigdata.ca.ability.common.vo.UnitAndPersonCascadeVO">
        <result column="company_id" property="id" />
        <result column="company_name" property="name" />
        <collection property="children" javaType="java.util.List" ofType="cs.gov.bigdata.ca.ability.common.vo.UnitAndPersonCascadeVO">
            <result column="organ_id" property="id" />
            <result column="organ_name" property="name" />
            <collection property="children" javaType="java.util.List" ofType="cs.gov.bigdata.ca.ability.common.vo.UnitAndPersonCascadeVO">
                <result column="person_id" property="id" />
                <result column="person_name" property="name" />
                <result column="person_phone" property="telphone" />
            </collection>
        </collection>
    </resultMap>

    <!-- 通用查询结果列 -->
    <sql id="Base_Column_List">
            create_time,
            id, service_name, service_type, acceptance_conditions, use_guide, service_support_platform, flow_and_accept_time_limit, assessment_and_evaluation_indicators, accepting_unit, internal_organization, internal_organization_person, internal_organization_phone, service_institutions, unified_social_credit_code, service_institutions_addr, service_institutions_legal_person, legal_person_phone, affiliated_person, required_information, related_ability, service_status, is_deleted, tenant_id
    </sql>

    <!-- 服务事项 - 分页查询 -->
    <select id="listPage" resultMap="BaseResultMap">
        select
            csm.id, csm.service_name,csm.service_status,csm.create_time,
            cst.type_name as service_type_level1_name,
            csct.child_type_name as service_type_level2_name,
            cc.company_name as accepting_unit_name,
            cio.interior_organ_name as internal_organization_name,
            ciop.server_name as internal_organization_person_name,
            ciop.mobile_phone as internal_organization_phone,
            csm.images
        from capability_servie_matters csm 
        left join config_company cc on cc.id = csm.accepting_unit and cc.is_deleted = 0
        left join config_interior_organ cio on cio.id = csm.internal_organization and cio.is_deleted = 0
        left join config_interior_organ_person ciop on ciop.id = csm.internal_organization_person and ciop.is_deleted = 0
        left join capability_server_type cst on cst.id = csm.service_type_level1 and cst.is_deleted = 0
        left join capability_server_child_type csct on csct.id = csm.service_type_level2 and csct.is_deleted = 0
        <where>
            csm.is_deleted = 0
            <if test="condition.serviceTypeLevel1 != null">and csm.service_type_level1 = #{condition.serviceTypeLevel1}</if>
            <if test="condition.serviceTypeLevel2 != null">and csm.service_type_level2 = #{condition.serviceTypeLevel2}</if>
            <if test="condition.serviceStatus != null">and csm.service_status = #{condition.serviceStatus}</if>
            <if test="condition.acceptingUnit != null">and csm.accepting_unit = #{condition.acceptingUnit}</if>
            <if test="condition.internalOrganization != null">and csm.internal_organization = #{condition.internalOrganization}</if>
            <if test="condition.serviceName != null and condition.serviceName != ''">and csm.service_name like concat('%',#{condition.serviceName},'%')</if>
        </where>
        order by create_time desc
    </select>

    <!-- 获取受理单位联级数据 -->
    <select id="getAcceptingUnitTree" resultMap="CascadeResultMap">
        SELECT
            l1.id AS company_id,
            l1.company_name AS company_name,
            l2.id AS organ_id,
            l2.interior_organ_name AS organ_name,
            l3.id AS person_id,
            l3.server_name AS person_name,
            l3.mobile_phone AS person_phone
        FROM
            config_company l1
            INNER JOIN config_interior_organ l2 ON l2.company_id = l1.id
            INNER JOIN config_interior_organ_person l3 ON l3.interior_organ_id = l2.id
    </select>

</mapper>