MapStruct java类型转换工具使用

一 导入依赖到maven

        <!-- vo entity转换用开始-->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>1.3.1.Final</version>
        </dependency>

        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
            <version>1.3.1.Final</version>
            <!-- IntelliJ does not pick up the processor if it is not in the dependencies.
             There is already an open issue for IntelliJ see https://youtrack.jetbrains.com/issue/IDEA-150621
            -->
            <scope>provided</scope>
        </dependency>
        <!-- vo entity转换用结束-->

SysUserVoConverter

/*
 * Copyright 2019 Wicrenet, Inc. All rights reserved.
 */
package com.xxx.producer.controller.converter;

import com.xxx.producer.controller.model.SysUserVo;
import com.xxx.producer.entity.SysUser;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;

/**
 * 【转换帮助类】
 *
 * @author YJX
 * Created on 2019/11/09 10:25
 */
@Mapper(uses = {UserOrderVoConverter.class, OrderVoConverter.class})
public interface SysUserVoConverter {

    SysUserVoConverter MAPPER = Mappers.getMapper(SysUserVoConverter.class);

//    @Mapping(source = "userOrderVo", target = "userOrder")
    @Mapping(source = "userOrderVos", target = "userOrders")
    @Mapping(source = "orderVos", target = "orders") 
    @Mapping(source = "storeId",target = "store.id")
    @Mapping(source = "storeName",target = "store.name")
    SysUser toEntity(SysUserVo sysUserVo);

    @InheritInverseConfiguration
    SysUserVo toVo(SysUser sysUser);

    @Mapping(source = "userOrders", target = "userOrderVos")
    @Mapping(source = "orders", target = "orderVos")
    @Mapping(source = "storeId",target = "storeId")
    @Mapping(source = "createTime",target = "createTime")
    SysUserVo toVoPlus(SysUser sysUser);
}

OrderVoConverter

package com.xxx.producer.controller.converter;

import com.xxx.producer.entity.Order;
import com.xxx.producer.controller.model.OrderVo;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

/**
 * (RUserOrder)表实体类转换工具类
 *
 * @author YJX
 * @since 2019-11-09 13:43:07
 */
@Mapper
public interface OrderVoConverter {

    OrderVoConverter MAPPER = Mappers.getMapper(OrderVoConverter.class);

    Order toEntity(OrderVo vo);

    @InheritInverseConfiguration
    OrderVo toVo(Order entity);

}

UserOrderVoConverter

package com.xxx.producer.controller.converter;

import com.xxx.producer.entity.UserOrder;
import com.xxx.producer.controller.model.UserOrderVo;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

/**
 * (RUserOrder)表实体类转换工具类
 *
 * @author YJX
 * @since 2019-11-09 13:43:07
 */
@Mapper
public interface UserOrderVoConverter {

    UserOrderVoConverter MAPPER = Mappers.getMapper(UserOrderVoConverter.class);

    UserOrder toEntity(UserOrderVo vo);

    @InheritInverseConfiguration
    UserOrderVo toVo(UserOrder entity);

}

SysUserMapper.xml

<?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="com.xxx.producer.dao.SysUserMapper">

    <resultMap type="com.xxx.producer.entity.SysUser" id="mapper">
        <result property="id" column="id"/>
        <result property="parentId" column="parent_id"/>
        <result property="createTime" column="create_time"/>
        <result property="storeId" column="store_id"/>
        <result property="hierarchy" column="hierarchy"/>
        <result property="name" column="name"/>
        <result property="password" column="password"/>
        <result property="enabled" column="enabled"/>
        <result property="phone" column="phone"/>
        <result property="deleted" column="deleted"/>
        <result property="userTypeEnums" column="user_type_enums"/>
    </resultMap>

    <resultMap type="com.xxx.producer.entity.SysUser" id="cascadeMapper">
        <result property="id" column="id"/>
        <result property="parentId" column="parent_id"/>
        <result property="hierarchy" column="hierarchy"/>
        <result property="name" column="name"/>
        <result property="password" column="password"/>
        <result property="enabled" column="enabled"/>
        <result property="phone" column="phone"/>
        <result property="createTime" column="create_time"/>
        <result property="deleted" column="deleted"/>
        <result property="userTypeEnums" column="user_type_enums"/>
        <association property="store" javaType="com.xxx.producer.entity.Store" columnPrefix="store_"
                     resultMap="com.xxx.producer.dao.StoreMapper.mapper"/>
        <collection property="userOrders" ofType="com.xxx.producer.entity.UserOrder">
            <result property="id" column="userOrder_id"/>
            <result property="orderId" column="userOrder_order_id"/>
            <result property="userId" column="userOrder_user_id"/>
        </collection>
    </resultMap>


    <select id="cascade1" resultMap="cascadeMapper" parameterType="com.xxx.producer.entity.SysUser">
        SELECT
            su.*,
            ts.id           AS store_id,
            ts.name         AS store_name,
            ts.create_time  AS store_create_time,
            ts.update_time  AS store_update_time,
            ruo.id          AS userOrder_id,
            ruo.order_id    AS userOrder_order_id,
            ruo.user_id     AS userOrder_user_id
        FROM sys_user su
        LEFT JOIN r_user_order ruo ON su.id = ruo.user_id
        LEFT JOIN t_store ts ON su.store_id = ts.id
        where su.password = #{user.password}
    </select>

    <select id="cascadeList" resultMap="cascadeMapper" parameterType="com.xxx.producer.entity.SysUser">
        SELECT
        su.*,
        ts.id           AS store_id,
        ts.name         AS store_name,
        ts.create_time  AS store_create_time,
        ts.update_time  AS store_update_time,
        ruo.id          AS userOrder_id,
        ruo.order_id    AS userOrder_order_id,
        ruo.user_id     AS userOrder_user_id
        FROM sys_user su
        LEFT JOIN r_user_order ruo ON su.id = ruo.user_id
        LEFT JOIN t_store ts ON su.store_id = ts.id
        where su.name = #{user.name}
    </select>

    <delete id="isDeleted">

    </delete>

</mapper>

StoreMapper.xml

<?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="com.xxx.producer.dao.StoreMapper">
    <resultMap type="com.xxx.producer.entity.Store" id="mapper">
        <result property="id" column="id"/>
        <result property="name" column="name" jdbcType="VARCHAR"/>
        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
        <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
    </resultMap>

</mapper>

UserOrderMapper.xml

<?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="com.xxx.producer.dao.OrderMapper">
    <resultMap type="com.xxx.producer.entity.UserOrder" id="mapper">
        <result property="id" column="id"/>
        <result property="userId" column="user_id"/>
        <result property="orderId" column="order_id"/>
    </resultMap>

</mapper>

使用方法

package com.xxx.producer.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xxx.producer.aspect.PerformanceLog;
import com.xxx.producer.controller.converter.SysUserVoConverter;
import com.xxx.producer.controller.model.SysUserVo;
import com.xxx.producer.dict.DeletedEnum;
import com.xxx.producer.dict.UserTypeEnum;
import com.xxx.producer.entity.SysUser;
import com.xxx.producer.exception.SZException;
import com.xxx.producer.msg.PagingVO;
import com.xxx.producer.msg.Result;
import com.xxx.producer.service.SysUserService;
import com.xxx.producer.service.help.SysUserVoRecursionHelper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * (SysUser)表控制层
 *
 * @author yangjunxiong
 * @since 2019-11-12 12:18:09
 */
@RestController
@RequestMapping("/sysUser")
public class SysUserController {

    @Autowired
    private SysUserService sysUserService;

    /**
     * 条件分页查询数据
     *
     * @param pagingVO 分页参数
     * @param vo       查询实体
     * @return 分页数据
     */
    @GetMapping(value = "/paging")
    public Result selectPage(PagingVO pagingVO, SysUserVo vo) {
        // 一 多表分页
//        long total = this.logBackDao.selectCount(beginTimeStamp, endTimeStamp, logName, levelStr);
//        long offset = PayingUtils.getOffset(pagingVO.getPageNo(), pagingVO.getPageSize(), total);
//        List<LogBackEvent> data = this.logBackDao.selectPaging(beginTimeStamp, endTimeStamp, logName, levelStr, offset);
//        pagingVO.setTotal(data.size());
//        pagingVO.setRows(data);
//        if (CollectionUtils.isNotEmpty(data)) {
//            return Result.ok().put("data",pagingVO);
//        }

        ArrayList<UserTypeEnum> userTypeEnums = new ArrayList<>();
        userTypeEnums.add(UserTypeEnum.STUDENT);
        userTypeEnums.add(UserTypeEnum.TEACHER);

        // 单表分页
        IPage<SysUser> page = this.sysUserService.page(new Page<>(pagingVO.getPage(), pagingVO.getLimit()), new LambdaQueryWrapper<SysUser>()
//                .in(CollectionUtils.isNotEmpty(userTypeEnums), SysUser::getUserTypeEnums, UserTypeEnum.toMark(userTypeEnums))
                        .likeRight(StringUtils.isNotEmpty(vo.getHierarchy()), SysUser::getHierarchy, vo.getHierarchy() + vo.getId())//查询子节点需要加根节点的id
        );
        List<SysUserVo> collect = page.getRecords().stream().map(SysUserVoConverter.MAPPER::toVoPlus).collect(Collectors.toList());
        return Result.ok().put("data", collect).put("count", page.getPages());
    }


    /**
     * 通过主键查询单条数据
     *
     * @param id 主键
     * @return 单条数据
     */
    @GetMapping("/{id}")
    public Result selectOne(@PathVariable Serializable id) {
        SysUser byId = this.sysUserService.getById(id);
        return Result.ok().put("data", SysUserVoConverter.MAPPER.toVoPlus(byId));
    }

    /**
     * 新增数据
     *
     * @param vo 实体对象
     * @return 新增结果
     */
    @PostMapping
    public Result insert(@RequestBody SysUserVo vo) {
        Optional<String> verify = vo.verify();
        if (verify.isPresent()) {
            return Result.error(verify.get());
        }
        int count = this.sysUserService.count(new LambdaQueryWrapper<SysUser>().eq(StringUtils.isNotEmpty(vo.getPassword()), SysUser::getPassword, vo.getPassword()));
        if (count >= 1) {
            return Result.error("该数据已存在");
        }
        SysUser byId = this.sysUserService.getById(vo.getParentId());
        if (Objects.isNull(byId)) {
            return Result.error("父节点不存在!");
        }
        int hierarchyDeep = getHierarchyDeep(byId.getHierarchy());
        if (hierarchyDeep == 10) {
            return Result.error("最多挂载10层,无法继续挂载子节点");
        }

        SysUser sysUser = SysUserVoConverter.MAPPER.toEntity(vo);
        return this.sysUserService.save(sysUser) ? Result.ok().put("id", sysUser.getId()) : Result.error("保存失败");

    }

    /**
     * 根据树路径获取层级
     *
     * @return 层级
     */
    private int getHierarchyDeep(String hierarchy) {
        return (int) (Arrays.stream(hierarchy.split("/")).filter(StringUtils::isNotBlank).count() + 1);
    }



    /**
     * 修改数据
     *
     * @param vo 实体对象
     * @return 修改结果
     */
    @PutMapping
    public Result update(@RequestBody SysUserVo vo) {
        vo.verify(false, "password");
        SysUser byId = this.sysUserService.getById(vo.getId());
        if (Objects.isNull(byId)) {
            return Result.error("修改的数据不存在");
        }
        SysUser byId1 = this.sysUserService.getById(byId.getParentId());
        SysUser sysUser = SysUserVoConverter.MAPPER.toEntity(vo);
        sysUser.setHierarchy(byId1.getHierarchy() + byId.getParentId() + "/");
        boolean b = this.sysUserService.updateById(sysUser);
        return b ? Result.ok().put("id", sysUser.getId()) : Result.error("修改失败");
    }

    /**
     * 修改挂载节点
     * @author YJX
     * @date 2019/11/24 11:55
     * @param id
     * @param newParentId
     **/
    @PutMapping(value = "update_hierarchy")
    public Result updateHierarchy(Long id,Long newParentId) {
        SysUser byId = this.sysUserService.getById(id);
        if (Objects.isNull(byId)) {
            throw new SZException("修改的数据不存在!");
        }
        SysUser newParent = this.sysUserService.getById(newParentId);
        if (0 != newParentId) {
            if (Objects.isNull(newParent)) {
                throw new SZException("挂载的父节点不存在");
            }
        }
        //维护层级字段
        if (!byId.getParentId().equals(newParentId)) {
//            改变了父节点  所有子节点的层级字段需要维护
            this.sysUserService.updateHierarchy(id,newParentId);
        }
        return Result.ok();
    }


    /**
     * 删除数据
     *
     * @param ids 主键结合
     * @return 删除结果
     */
    @DeleteMapping
    public Result delete(@RequestParam("ids") List<Long> ids) {
        return this.sysUserService.removeByIds(ids) ? Result.ok() : Result.error("删除失败");
    }


    /*
     * 【 递归查询 】
     *
     * @author yangjunxiong
     * @date 2019/11/12 15:03
     * @param id
     * @return com.xxx.producer.msg.Result
     **/
    @GetMapping("/recursion/{id}")
    @ResponseBody
    public Result recursion(@PathVariable Long id) {
        System.out.println("id = " + id);
        SysUser one = this.sysUserService.getOne(new QueryWrapper<SysUser>().lambda().eq(SysUser::getId, id));
        if (Objects.isNull(one)) {
            return Result.error("该节点不存在");
        }

        //查询one节点
        List<SysUser> userList = this.sysUserService.list(new LambdaQueryWrapper<SysUser>().likeRight(SysUser::getHierarchy,one.getHierarchy()));

        //转成Vo
        List<SysUserVo> sysUserVoList = userList.stream().map(SysUserVoConverter.MAPPER::toVoPlus).collect(Collectors.toList());

        //找出父节点
        List<SysUserVo> parentNode = sysUserVoList.stream().filter(model -> Objects.equals(model.getParentId(), one.getParentId())).collect(Collectors.toList());

        //递归成树
        List<SysUserVo> sysUserVos = SysUserVoRecursionHelper.toTree(parentNode.get(0).getParentId(), sysUserVoList);

        return Result.ok().put("data", sysUserVos);
    }

    /*
     * 【 级联查询 】
     *
     * @author yangjunxiong
     * @date 2019/11/12 14:57
     * @param sysUserVo
     * @param pagingVO
     * @return com.xxx.producer.msg.Result
     **/
    @GetMapping("/lambda_cascade")
    @ResponseBody
    @PerformanceLog(title = "lambda_cascade测试", maxTime = 1)
    public Result cascade(@RequestBody SysUserVo sysUserVo) {
        //校验全部参数
//        Optional<String> verify = sysUserVo.verify();
        //校验指定参数
        sysUserVo.verify("name");
        //校验 未排除校验参数
//        Optional<String> verify = sysUserVo.verify(false, "name");


        Optional<SysUserVo> optional = this.sysUserService.cascade1(SysUserVoConverter.MAPPER.toEntity(sysUserVo)).map(SysUserVoConverter.MAPPER::toVo);

        return Result.ok().put("data", optional.orElseGet(SysUserVo::new));
    }

    /*
     * 【 级联查询 】
     *
     * @author yangjunxiong
     * @date 2019/11/12 14:57
     * @param sysUserVo
     * @param pagingVO
     * @return com.xxx.producer.msg.Result
     **/
    @GetMapping("/lambda_cascade_list")
    @ResponseBody
    @PerformanceLog(title = "lambda_cascade测试", maxTime = 1)
    public Result cascadeList(@RequestBody SysUserVo sysUserVo) {
        //校验全部参数
//        Optional<String> verify = sysUserVo.verify();
        //校验指定参数
        sysUserVo.verify("name");
        //校验 未排除校验参数
//        Optional<String> verify = sysUserVo.verify(false, "name");

        ArrayList<SysUserVo> sysUserVos = new ArrayList<>();
        this.sysUserService.cascadeList(SysUserVoConverter.MAPPER.toEntity(sysUserVo)).forEach(sysUser -> sysUserVos.add(SysUserVoConverter.MAPPER.toVo(sysUser)));

        return Result.ok().put("data", sysUserVos);
    }


    /*
     * 【 是否逻辑删除 】
     * @param ids
     **/
    @DeleteMapping("/delFlag/{ids}")
    public Result delFlag(@PathVariable("ids") List<Long> ids) {
        return this.sysUserService.delFlag(ids, DeletedEnum.IS_DELETE) ? Result.ok("操作成功!") : Result.error("操作失败!");
    }

}