MapStruct java类型转换工具使用

本是古典何须时尚 2023-06-15 11:24 21阅读 0赞

# 一 导入依赖到maven #

<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>
                
                <scope>provided</scope>
            </dependency>

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

UserOrderMapper.xml

使用方法

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("操作失败!");
        }
    
    }