Merge branch 'dev'

zhaoxiaohao

2020-11-17 b7265cdd6f3e1fbb0d428c27e5b5e29e34d56953

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package com.kidgrow.common.controller;
 
import com.fasterxml.jackson.databind.ObjectMapper;
import com.kidgrow.common.exception.BeanValidateException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
 
import javax.validation.ConstraintViolation;
import javax.validation.Validator;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
 
/**
 * 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
 *
 * @Description: 基类<br>
 * @Project: <br>
 * @CreateDate: Created in 2020/2/3 17:08 <br>
 * @Author: <a href="4345453@kidgrow.com">liuke</a>
 */
@Slf4j
public class BaseController {
 
    @Autowired(required=false)
    private ModelMapper modelMapper;
 
    @Autowired
    private ObjectMapper objectMapper;
 
    @Autowired(required = false)
    private Validator validator;
 
 
    protected <T> T parseAndValidParams(String str, Class<T> clazz) {
        T dto = null;
        try {
            str = StringUtils.isBlank(str) ? "{}" : str;
            dto = objectMapper.readValue(str, clazz);
        } catch (IOException e) {
            throw new BeanValidateException("解析数据时发生错误");
        }
        if (validator != null) {
            Set<ConstraintViolation<T>> errors = null;
            try {
                errors = validator.validate(dto);
            } catch (Exception e) {
                log.error("参数校验异常", e);
                throw new BeanValidateException("解析数据时发生错误");
            }
            if (CollectionUtils.isNotEmpty(errors)) {
                Set<ConstraintViolation<?>> errorSet = new HashSet<>(errors);
                throw new BeanValidateException("参数不符合要求", errorSet);
            }
        }
        return dto;
    }
 
    protected <T> T parseParams(String str, Class<T> clazz) {
        T dto = null;
        try {
            str = StringUtils.isBlank(str) ? "{}" : str;
            dto = objectMapper.readValue(str, clazz);
        } catch (IOException e) {
            throw new BeanValidateException("解析数据时发生错误");
        }
        return dto;
    }
 
    protected <T> T map(Object data, Class<T> clazz) {
        return modelMapper.map(data, clazz);
    }
 
 
    protected <T> List<T> mapList(List<?> data, Class<T> clazz) {
        if (data == null) {
            return null;
        }
        List<T> result = new ArrayList<>(data.size());
        for (Object item : data) {
            result.add(modelMapper.map(item, clazz));
        }
        return result;
    }
}