package com.zt.core.db.annotation;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.exceptions.UtilException;
|
import cn.hutool.core.util.ReflectUtil;
|
import com.google.common.base.Predicates;
|
import com.zt.common.annotation.DataFilter;
|
import com.zt.common.annotation.DataFilters;
|
import com.zt.common.constant.Constant;
|
import com.zt.common.utils.SpringContextUtils;
|
import com.zt.core.db.model.DataFilterField;
|
import com.zt.core.db.model.DataFilterMethod;
|
import io.swagger.annotations.Api;
|
import io.swagger.annotations.ApiOperation;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.core.io.Resource;
|
import org.springframework.core.io.ResourceLoader;
|
import org.springframework.core.io.support.ResourcePatternResolver;
|
import org.springframework.core.io.support.ResourcePatternUtils;
|
import org.springframework.core.type.AnnotationMetadata;
|
import org.springframework.core.type.MethodMetadata;
|
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
|
import org.springframework.core.type.classreading.MetadataReader;
|
import org.springframework.core.type.classreading.MetadataReaderFactory;
|
import org.springframework.stereotype.Component;
|
import org.springframework.web.bind.annotation.*;
|
import springfox.documentation.builders.RequestHandlerSelectors;
|
import springfox.documentation.spi.service.contexts.ApiSelector;
|
import springfox.documentation.spring.web.plugins.Docket;
|
|
import java.util.*;
|
|
@Component("dataFilterParser")
|
public class DataFilterParser {
|
|
@Autowired
|
private ResourceLoader resourceLoader;
|
|
private static final String VALUE = "value";
|
|
/**
|
* 获取指定包下所有添加了执行注解的方法信息
|
*
|
* @return
|
* @throws Exception
|
*/
|
public List<DataFilterMethod> getFilteredMethods() throws Exception {
|
List<DataFilterMethod> methods = new ArrayList<>();
|
|
ResourcePatternResolver resolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
|
MetadataReaderFactory metaReader = new CachingMetadataReaderFactory(resourceLoader);
|
Resource[] resources = resolver.getResources("classpath*:com/zt/**/*.class");
|
|
for (org.springframework.core.io.Resource r : resources) {
|
MetadataReader reader = metaReader.getMetadataReader(r);
|
methods.addAll(resolveClass(reader));
|
}
|
Map<String, String> docetGroupMap = new HashMap<>();
|
try {
|
Map<String, Docket> docketMap = SpringContextUtils.getImplInstance(Docket.class);
|
for (Docket docket : docketMap.values()) {
|
ApiSelector apiSelector = (ApiSelector) ReflectUtil.getFieldValue(docket, "apiSelector");
|
List component1s = (List) ReflectUtil.getFieldValue(apiSelector.getRequestHandlerSelector(),
|
"components");
|
for (Object component1 : component1s) {
|
if (component1.getClass().getName().startsWith(Predicates.class.getName())) {
|
List component2s = (List) ReflectUtil.getFieldValue(component1, "components");
|
for (Object component2 : component2s) {
|
if (component2.getClass().getName().startsWith(RequestHandlerSelectors.class.getName())) {
|
Object[] values = ReflectUtil.getFieldsValue(component2);
|
if (values != null && values.length == 1) {
|
docetGroupMap.put((String) values[0], docket.getGroupName());
|
}
|
}
|
}
|
}
|
}
|
}
|
} catch (UtilException e) {
|
e.printStackTrace();
|
}
|
for (DataFilterMethod method : methods) {
|
for (String classPath : docetGroupMap.keySet()) {
|
if (method.getClassPath().startsWith(classPath)) {
|
method.setSwagger(docetGroupMap.get(classPath));
|
break;
|
}
|
}
|
}
|
|
return methods;
|
}
|
|
private List<DataFilterMethod> resolveClass(MetadataReader reader) {
|
List<DataFilterMethod> methods = new ArrayList<>();
|
// 获取注解元数据
|
AnnotationMetadata metadata = reader.getAnnotationMetadata();
|
// 获取类中RequestMapping注解的value属性
|
String classMapping = getAttr(metadata.getAnnotationAttributes(RequestMapping.class.getCanonicalName()), VALUE);
|
if (classMapping == null) {
|
return methods;
|
}
|
// 获取DataFilters和单独DataFilter注解的方法
|
Set<MethodMetadata> methodMetadatas = new HashSet<>();
|
methodMetadatas.addAll(metadata.getAnnotatedMethods(DataFilters.class.getCanonicalName()));
|
methodMetadatas.addAll(metadata.getAnnotatedMethods(DataFilter.class.getCanonicalName()));
|
|
if (CollectionUtil.isNotEmpty(methodMetadatas)) {
|
// 获取类中Api注解的tags属性
|
Map<String, Object> apiAttributes = metadata.getAnnotationAttributes(Api.class.getCanonicalName());
|
String apiTags = this.getAttr(apiAttributes, "tags");
|
|
for (MethodMetadata annotatedMethod : methodMetadatas) {
|
// 获取方法的mapping
|
String methodMapping = getAttr(
|
annotatedMethod.getAnnotationAttributes(GetMapping.class.getCanonicalName()), VALUE);
|
if (StringUtils.isBlank(methodMapping)) {
|
continue;
|
}
|
String url = classMapping + "/" + methodMapping;
|
|
String methodName = getAttr(
|
annotatedMethod.getAnnotationAttributes(ApiOperation.class.getCanonicalName()), VALUE);
|
|
DataFilterMethod method = new DataFilterMethod(metadata.getClassName(), url, "", apiTags, methodName);
|
|
Map<String, Object> dataFilterAttributes = annotatedMethod.getAnnotationAttributes(DataFilter.class
|
.getCanonicalName());
|
if (dataFilterAttributes != null) {// DataFilter注解
|
method.addField(this.getField(dataFilterAttributes));
|
} else {// DataFilters注解
|
Map<String, Object> dataFiltersAttributes = annotatedMethod
|
.getAnnotationAttributes(DataFilters.class.getCanonicalName());
|
if (dataFiltersAttributes != null) {
|
Map<String, Object>[] dataFilterArray = (Map<String, Object>[]) dataFiltersAttributes
|
.get(VALUE);
|
for (Map<String, Object> attributes : dataFilterArray) {
|
method.addField(this.getField(attributes));
|
}
|
}
|
}
|
|
methods.add(method);
|
}
|
|
}
|
|
return methods;
|
}
|
|
private DataFilterField getField(Map<String, Object> attributes) {
|
String field = getAttr(attributes, "field"), name = getAttr(attributes, "name");
|
if (Constant.Field.TENANT.equals(field)) {
|
name = "租户";
|
} else if (Constant.Field.COMPANY.equals(field)) {
|
name = "公司";
|
} else if (Constant.Field.DEPT.equals(field)) {
|
name = "部门";
|
}
|
return new DataFilterField(name, field, getAttr(attributes, "accept"), getAttr(attributes, "dict"), getAttr(
|
attributes, "op"), getAttr(attributes, "defaul"));
|
}
|
|
/**
|
* 获取注解的属性
|
*
|
* @param attributes
|
* @param key
|
* @return
|
*/
|
private String getAttr(Map<String, Object> attributes, String key) {
|
// 若类无注解
|
if (attributes == null || attributes.get(key) == null) {
|
return null;
|
}
|
// 获取注解的属性值
|
Object value = attributes.get(key);
|
if (value instanceof String) {
|
return (String) value;
|
} else if (value instanceof String[]) {
|
String[] values = (String[]) attributes.get(key);
|
if (0 == values.length) {
|
return null;
|
}
|
return values[0];
|
}
|
return null;
|
}
|
|
private Map<String, Object> getPathByMethod(MethodMetadata annotatedMethod) {
|
Map<String, Object> annotationAttributes = annotatedMethod.getAnnotationAttributes(GetMapping.class
|
.getCanonicalName());
|
if (annotationAttributes != null && annotationAttributes.get(VALUE) != null) {
|
return annotationAttributes;
|
}
|
annotationAttributes = annotatedMethod.getAnnotationAttributes(PostMapping.class.getCanonicalName());
|
if (annotationAttributes != null && annotationAttributes.get(VALUE) != null) {
|
return annotationAttributes;
|
}
|
|
annotationAttributes = annotatedMethod.getAnnotationAttributes(DeleteMapping.class.getCanonicalName());
|
if (annotationAttributes != null && annotationAttributes.get(VALUE) != null) {
|
return annotationAttributes;
|
}
|
|
annotationAttributes = annotatedMethod.getAnnotationAttributes(PutMapping.class.getCanonicalName());
|
if (annotationAttributes != null && annotationAttributes.get(VALUE) != null) {
|
return annotationAttributes;
|
}
|
annotationAttributes = annotatedMethod.getAnnotationAttributes(RequestMapping.class.getCanonicalName());
|
return annotationAttributes;
|
}
|
}
|
