PackageScanner
package com.cmb.cox.utils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;
import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.JarURLConnection;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.*;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public abstract class PackageScanner {
static final String Y = "Y";
static final String N = "N";
static final Set<String> Alphabet = new HashSet() {{
add("A");
add("B");
add("C");
add("D");
add("E");
add("F");
add("G");
add("H");
add("I");
add("J");
add("K");
add("L");
add("M");
add("N");
add("O");
add("P");
add("Q");
add("R");
add("S");
add("T");
add("U");
add("V");
add("W");
add("X");
add("Y");
add("Y");
}};
public PackageScanner() {
}
public abstract void dealClass(Class<?> klass);
private void dealClassFile(String rootPackage, File curFile) {
// 以下为我自己的处理.class方式
String fileName = curFile.getName();
if (fileName.endsWith(".class")) {
fileName = fileName.replaceAll(".class", "");
try {
System.out.println("... " + rootPackage + "." + fileName);
Class<?> klass = Class.forName(rootPackage + "." + fileName);
dealClass(klass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
private void dealDirectory(String rootPackage, File curFile) {
// 若为目录则继续处理目录下面的目录和.class文件
File[] fileList = curFile.listFiles();
for (File file : fileList) {
if (file.isDirectory()) {
rootPackage = rootPackage + '.' + file.getName();
System.out.println("00 " + rootPackage);
//按照文件处理
dealDirectory(rootPackage, file);
} else if (file.isFile()) {
//按照.class处理
dealClassFile(rootPackage, file);
}
}
}
private void dealJarPackage(URL url) {
try {
// 得到路径
JarURLConnection connection = (JarURLConnection) url.openConnection();
JarFile jarFile = connection.getJarFile();
// 循环执行看是否有实体的存在
Enumeration<JarEntry> jarEntries = jarFile.entries();
while (jarEntries.hasMoreElements()) {
JarEntry jar = jarEntries.nextElement();
// 若不是.class文件或者是目录则不处理
if (jar.isDirectory() || !jar.getName().endsWith(".class")) {
continue;
}
// 此处为处理
String jarName = jar.getName();
jarName = jarName.replace(".class", "");
jarName = jarName.replace("/", ".");
try {
System.out.println(jarName);
Class klass = Class.forName(jarName);
dealClass(klass);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void packageScanner(String packageName) {
String rootPacksge = packageName;
System.out.println("packageName : " + packageName);
packageName = packageName.replace(".", "/");
// System.out.println("packageName : " + packageName);
URL url = Thread.currentThread().getContextClassLoader().getResource(packageName);
System.out.println("URL : " + url);
//判断协议名称是不是file,如果是file 则按照文件路径处理否则按照jar处理
if (url.getProtocol().equals("file")) {
URI uri;
try {
uri = url.toURI();
File root = new File(uri);
dealDirectory(rootPacksge, root);
} catch (URISyntaxException e) {
e.printStackTrace();
}
} else {
dealJarPackage(url);
}
}
public static void main(String[] args) throws Exception {
boolean basicType = isBasicType(new Integer(1));
new PackageScanner() {
@Override
public void dealClass(Class klass) {
try {
parseControler(klass);
} catch (Exception e) {
e.printStackTrace();
}
}
}.packageScanner("com.cmb.cox.controller.test");
}
public static void parseControler(Class klass) throws Exception {
List<Map<String, Object>> apiList = new ArrayList<>();
if (isController(klass)) {
Method[] methods = klass.getMethods();
for (Method method : methods) {
Annotation[] annotations = method.getAnnotations();
Map<String, Object> apiInfo = new HashMap();
for (Annotation annotation : annotations) {
//获取接口ID
if (annotation instanceof RequestMapping) {
getApiId(apiInfo, ((RequestMapping) annotation).value());
} else if (annotation instanceof PostMapping) {
getApiId(apiInfo, ((PostMapping) annotation).value());
}else if (annotation instanceof GetMapping) {
getApiId(apiInfo, ((GetMapping) annotation).value());
}
//获取接口中文名和描述
if (annotation instanceof ApiOperation) {
getApiCnName(apiInfo, (ApiOperation) annotation);
}else {
apiInfo.put("chApiName", "");
apiInfo.put("apiNote", "");
}
}
//增加接口信息
if (!CollectionUtils.isEmpty(apiInfo)) {
//获取入参信息
Parameter[] parameters = method.getParameters();
//获取出参信息
AnnotatedType annotatedReturnType = method.getAnnotatedReturnType();
Type genericReturnType = method.getGenericReturnType();
List<Map<String, Object>> fieldList = new ArrayList<>();
apiInfo.put("fieldList", fieldList);
searchTypeField(fieldList,annotatedReturnType,new HashMap());
// getReturnTypeFirst(fieldList, annotatedReturnType, true);
// getReturnType(fieldList, annotatedReturnType);
// System.out.println(fieldList);
apiInfo.put("returnType",getRuturnType(fieldList));
apiList.add(apiInfo);
}
}
}
apiList.stream().forEach((info)-> System.out.println(JSON.toJSONString(info)));
}
//获取字段信息中的返回类型信息
static Map<String,Object> getRuturnType(List<Map<String,Object>> list){
if (CollectionUtils.isEmpty(list))
return new HashMap<>();
int index = -1;
for (int i = 0; i < list.size(); i++) {
Map<String, Object> fieldInfo = list.get(i);
if ("".equals(fieldInfo.get("fieldName"))){
index = i;
break;
}
}
if (index<0)
return new HashMap<>();
Map<String, Object> returnTypeInfo = list.get(index);
list.remove(index);
return returnTypeInfo;
}
/**
* 判断是否为Controller类
*
* @param klass
* @return
*/
static boolean isController(Class klass) {
Annotation[] Annotations = klass.getAnnotations();
for (Annotation annotation : Annotations) {
if (annotation instanceof RestController) {
return true;
}
}
return false;
}
/**
* 获取接口Id
*
* @param apiMap
* @param value
*/
static void getApiId(Map<String, Object> apiMap, String[] value) {
if (value == null || value.length == 0)
apiMap.put("apiId", "");
else
apiMap.put("apiId", value[0]);
}
/**
* 获取接口中文名和描述
*
* @param apiMap
* @param apiOperation
*/
static void getApiCnName(Map<String, Object> apiMap, ApiOperation apiOperation) {
apiMap.put("chApiName", apiOperation.value() == null ? "" : apiOperation.value());
apiMap.put("apiNote", apiOperation.notes() == null ? "" : apiOperation.notes());
}
/**
* 首次判断返回类型，需获取返回类型是否有父类，有则获取父类返回值加入同级list
*
* @param fieldList
* @param annotatedType
* @throws Exception
*/
static void getReturnTypeFirst(List<Map<String, Object>> fieldList, AnnotatedType annotatedType, boolean isFirst) throws Exception {
//仅第一层时获取父类参数
if (isFirst) {
//获取返回类型父类字段
getFatherField(fieldList, annotatedType);
}
//判断是否为基础类型
if (isBasicType(annotatedType.getType())) {
System.out.println("基础类型..");
}
//判断是否有泛型，ParameterizedType为泛型类型
if (annotatedType.getType() instanceof ParameterizedType) {
((ParameterizedType) annotatedType.getType()).getActualTypeArguments();
} else {
//不包含泛型，直接加入同级list
Field[] declaredFields = new Field[0];
try {
declaredFields = Class.forName(annotatedType.getType().getTypeName()).getDeclaredFields();
} catch (ClassNotFoundException e) {
// 基础类型找不到类时发生异常
addField(fieldList, annotatedType);
}
if (declaredFields != null) {
for (Field declaredField : declaredFields) {
//加入同级list
addField(fieldList, declaredField);
// AnnotatedType fieldAnnoType = declaredField.getAnnotatedType();
//如果不是基础类型
// if (!isBasicType(fieldAnnoType)){
// //判断是否包含泛型，若包含
// if (fieldAnnoType instanceof ParameterizedType) {
//
// }else{
// //不包含泛型,加入递归子级
//
// }
// }
}
}
}
}
/**
* 增加同级字段信息，如果不是基础类型则递归增加
*
* @param fieldList
* @param declaredField
*/
static void addField(List<Map<String, Object>> fieldList, Field declaredField) throws Exception {
if (declaredField == null)
return;
ApiModelProperty annotatin = declaredField.getAnnotation(ApiModelProperty.class);
// fieldMap.put("id", UUID.randomUUID());
Map<String, Object> fieldMap = generaFieldInfo(declaredField.getName(), annotatin != null ? annotatin.value() : "", declaredField.getType().getSimpleName(), "Y", annotatin != null ? annotatin.example() : "");
fieldList.add(fieldMap);
Type fieldAnnoType = declaredField.getType();
//如果不是基础类型
if (!isBasicType(fieldAnnoType)) {
//判断是否包含泛型，若包含
if (fieldAnnoType instanceof ParameterizedType) {
//递归解析泛型数量为1的类型
if (((ParameterizedType) fieldAnnoType).getActualTypeArguments().length == 1) {
List<Map<String, Object>> subFieldList = new ArrayList<>();
fieldMap.put("children", subFieldList);
Type actualTypeArgument = ((ParameterizedType) fieldAnnoType).getActualTypeArguments()[0];
getReturnTypeFirst(subFieldList, null, false);
}
} else {
//不包含泛型,加入递归子级
List<Map<String, Object>> subFieldList = new ArrayList<>();
fieldMap.put("children", subFieldList);
getReturnTypeFirst(subFieldList, declaredField.getAnnotatedType(), false);
}
}
}
static void addField(List<Map<String, Object>> fieldList, AnnotatedType annotatedType) throws Exception {
if (annotatedType == null)
return;
Map<String, Object> fieldMap = new HashMap();
ApiModelProperty annotatin = annotatedType.getAnnotation(ApiModelProperty.class);
// fieldMap.put("id", UUID.randomUUID());
fieldMap.put("id", "id2");
fieldMap.put("desc", annotatin != null ? annotatin.value() : "");
// fieldMap.put("fieldName",((Field) ((AnnotatedTypeFactory.AnnotatedTypeBaseImpl) annotatedType).decl).name);
fieldMap.put("fieldType", annotatedType.getType().getTypeName());
fieldList.add(fieldMap);
}
/**
* 仅增加第一层父类,没有深入递归的必要
*
* @param fieldList
* @param annotatedType
*/
static void getFatherField(List<Map<String, Object>> fieldList, AnnotatedType annotatedType) throws Exception {
//判断是否有泛型，ParameterizedType为泛型类型
if (annotatedType.getType() instanceof ParameterizedType) {
//判断是否有父类，仅查找第一层父类
if (Class.forName(((ParameterizedType) annotatedType.getType()).getRawType().getTypeName()).getSuperclass() != null) {
Field[] declaredFields = Class.forName(((ParameterizedType) annotatedType.getType()).getRawType().getTypeName()).getSuperclass().getDeclaredFields();
if (declaredFields != null) {
for (Field declaredField : declaredFields) {
//增加父类成员到同级list
addField(fieldList, declaredField);
}
}
}
} else {
//判断是否有父类，仅查找第一层父类
if (Class.forName(annotatedType.getType().getTypeName()).getSuperclass() != null) {
Field[] declaredFields = Class.forName(annotatedType.getType().getTypeName()).getSuperclass().getDeclaredFields();
if (declaredFields != null) {
for (Field declaredField : declaredFields) {
//增加父类成员到同级list
addField(fieldList, declaredField);
}
}
}
}
}
// /**
// * 获取返回类型及描述
// *
// * @param fieldList
// * @param annotatedType
// */
// static void getReturnType(List<Map<String, Object>> fieldList, AnnotatedType annotatedType) throws Exception {
// if (annotatedType.getType() instanceof ParameterizedType) {
// ParameterizedType type = (ParameterizedType) annotatedType.getType();
// String typeName1 = type.getTypeName();
// Type rawType = type.getRawType();
// String typeName = rawType.getTypeName();
// Type[] actualTypeArguments = type.getActualTypeArguments();
// boolean entity = isEntity(actualTypeArguments[0]);
// System.out.println(entity);
// if (entity) {
// Class<?> responClass = Class.forName(actualTypeArguments[0].getTypeName());
// Field[] declaredFields = responClass.getDeclaredFields();
// if (declaredFields.length > 0) {
// for (Field declaredField : declaredFields) {
// Map<String, Object> fieldMap = new HashMap();
// ApiModelProperty annotatin = declaredField.getAnnotation(ApiModelProperty.class);
//// fieldMap.put("id", UUID.randomUUID());
// fieldMap.put("id", "id");
// String desc = "";
// if (annotatin != null) {
// desc = annotatin.value();
// }
// fieldMap.put("desc", desc);
// fieldMap.put("fieldName", declaredField.getName());
// fieldMap.put("fieldType", declaredField.getType().getSimpleName());
// fieldList.add(fieldMap);
// //如果为List类型则加入子集
//// if (declaredFie)
// //判断是否为Entity,如果为Entity则递归加入子集
// if ((!isBasicType(declaredField.getType()) && isEntity(declaredField.getType()))) {
// List<Map<String, Object>> subFieldList = new ArrayList<>();
// fieldMap.put("children", subFieldList);
// getReturnType(subFieldList, declaredField.getAnnotatedType());
// }
// }
// }
// System.out.println(declaredFields);
//
// } else {
// fieldList.add(new HashMap() {{
// put("id", UUID.randomUUID());
// put("fieldName", "result");
// put("fieldType", "Map<String,Object>");
// }});
// }
//
// } else {
// Type type = annotatedType.getType();
// String typeName = type.getTypeName();
//
// boolean entity = isEntity(type);
// if (entity) {
// Class<?> responClass = Class.forName(type.getTypeName());
// Field[] declaredFields = responClass.getDeclaredFields();
// if (declaredFields.length > 0) {
// for (Field declaredField : declaredFields) {
// Map<String, Object> fieldMap = new HashMap();
// ApiModelProperty annotatin = declaredField.getAnnotation(ApiModelProperty.class);
//// fieldMap.put("id", UUID.randomUUID());
// fieldMap.put("id", "id");
// String desc = "";
// if (annotatin != null) {
// desc = annotatin.value();
// }
// fieldMap.put("desc", desc);
// fieldMap.put("fieldName", declaredField.getName());
// fieldMap.put("fieldType", declaredField.getType().getSimpleName());
// fieldList.add(fieldMap);
// //判断是否为Entity,如果为Entity则递归加入子集
// if (!isBasicType(declaredField.getType()) && isEntity(declaredField.getType())) {
// List<Map<String, Object>> subFieldList = new ArrayList<>();
// fieldMap.put("children", subFieldList);
// getReturnType(subFieldList, declaredField.getAnnotatedType());
// }
// }
// }
// System.out.println(declaredFields);
//
// } else {
// fieldList.add(new HashMap() {{
// put("id", UUID.randomUUID());
// put("fieldName", "result");
// put("fieldType", "Map<String,Object>");
// }});
// }
// }
// System.out.println();
// }
/**
* 非基础类型，非Map、List皆判断为实体类
* @param returnType
* @return
*/
static boolean isEntity(Type returnType) {
if (returnType == null)
return false;
if (isBasicType(returnType))
return false;
if (returnType.getTypeName().contains("Object") || returnType.getTypeName().contains("java.util.Map") || returnType.getTypeName().contains("java.util.Set"))
return false;
Object o = null;
try {
o = Class.forName(((Class) returnType).getName()).newInstance();
} catch (Exception e) {
return true;
}
if (o instanceof Map || returnType.getTypeName().contains("Object"))
return false;
else return true;
}
static boolean isBasicType(Object obj) {
if (obj == null)
return true;
if (obj instanceof Type || obj instanceof AnnotatedType) {
String typeName = "";
if (obj instanceof Type)
typeName = ((Type) obj).getTypeName();
else
typeName = ((AnnotatedType) obj).getType().getTypeName();
if (typeName.equals(Integer.TYPE)
|| typeName.equals(String.class.getTypeName())
|| typeName.equals(Date.class.getTypeName())
|| typeName.equals(BigDecimal.class.getTypeName())
|| typeName.equals(BigInteger.class.getTypeName())
|| typeName.equals(JSONObject.class.getTypeName())
|| typeName.equals(Object.class.getTypeName())
|| typeName.equals(Character.class.getTypeName())
|| typeName.equals(Long.TYPE)
|| typeName.equals(Double.TYPE)
|| typeName.equals(Float.TYPE)
|| typeName.equals(Character.TYPE)
|| typeName.equals(Short.TYPE)
|| typeName.equals(Boolean.TYPE)
) {
return true;
}
}
if (obj instanceof Integer
|| obj instanceof Long
|| obj instanceof String
|| obj instanceof Double
|| obj instanceof Float
|| obj instanceof Character
|| obj instanceof JSONObject
|| obj instanceof Short
|| obj instanceof Boolean
|| obj instanceof BigDecimal
|| obj instanceof BigInteger
|| obj instanceof Date
|| obj.getClass().getTypeName().contains("java.lang.Object")
) {
return true;
}
return false;
}
/**
* 首次判断返回类型，需获取返回类型是否有父类，有则获取父类返回值加入同级list
*
* @param fieldList
* @param annotatedType
* @throws Exception
*/
static void searchTypeField(List<Map<String, Object>> fieldList, AnnotatedType annotatedType, Map<String, Object> genericsInfo) throws Exception {
Type calssType = annotatedType.getType();
getTypeAllField(fieldList,calssType,genericsInfo);
//类型是否为空
if (calssType.getTypeName().equals("void") || annotatedType == null){
fieldList.add(generaFieldInfo("","接口返回类型","void 此接口无任何返回",Y,""));
return;
}
//是否为基础类型
if (isBasicType(calssType) || isBasicType(annotatedType)) {
fieldList.add(generaFieldInfo("","接口返回类型",((Class) calssType).getSimpleName(),Y,""));
return;
}
//是否为数组
if (calssType.getTypeName().contains("[")) {
fieldList.add(generaFieldInfo("","接口返回类型",((Class) calssType).getSimpleName(),Y,""));
//基础类型数组不需要再解析
if (isBasicType(calssType))
return;
//非基础类型数组需递归获取所成员变量
}
//是否包含泛型
if (calssType instanceof ParameterizedType) {
fieldList.add(generaFieldInfo("","接口返回类型",calssType.getTypeName(),Y,""));
genericsInfo.put("typeName", ((ParameterizedType) calssType).getActualTypeArguments()[0].getTypeName());
//泛型为Map类型
if (isMapGenerics(annotatedType)) {
//判断是否有Map第二泛型
if (((ParameterizedType) calssType).getActualTypeArguments()[0] instanceof ParameterizedType) {
//判断Map的第二泛型是否为实体类（不是实体类不用解析当Object处理）
}
}
//泛型为List类型
if (isListGenerics(annotatedType)) {
//是否为泛型List
if (((ParameterizedType) calssType).getActualTypeArguments()[0] instanceof ParameterizedType) {
//判断Map的第二泛型是否为实体类（不是实体类不用解析当Object处理）
}
}
//泛型为实体类
//泛型为其他类型，无法识别当做Object处理
}else {
//非泛型
//有父类先获取父类信息
if (haveFatherClass(calssType)){
getFatherClassFields(fieldList,calssType,new HashMap<>());
}
//获取自身信息
fieldList.add(generaFieldInfo("","接口返回类型",((Class) calssType).getSimpleName(),Y,""));
//判断是否为实体类，若为实体类则地柜获取实体类信息
if (isEntity(calssType)){
Field[] declaredFields = Class.forName(calssType.getTypeName()).getDeclaredFields();
for (Field declaredField : declaredFields) {
addField(fieldList,declaredField);
}
}
}
//是否为泛型类型,如果为泛型类型，先递归扫描泛型实体类，再将实体类传入泛型类实际成员
// if (ann)
//是否包含父类,父类非空且不为Object
if (calssType.getClass().getSuperclass() != null && !"java.lang.Object".equals(calssType.getClass().getSuperclass().getCanonicalName())) {
//查询父类所有字段并加入字段集合
}
//是否为实体类且不包含泛型
}
static void getTypeAllField(List<Map<String, Object>> fieldList, Type classType, Map<String, Object> genericsInfo){
if (classType.getTypeName().equals("void") || classType == null)
return;
//有父类递归获取父类全部字段
if (haveFatherClass(classType)){
getFatherClassFields(fieldList,classType,genericsInfo);
}
//泛型（泛型类不填泛型也会是false）
if (classType instanceof ParameterizedType){
//如果实体类为泛型类则不解析
if (((ParameterizedTypeImpl) classType).getActualTypeArguments()[0] instanceof ParameterizedType){
genericsInfo.put("type",((ParameterizedTypeImpl) classType).getActualTypeArguments()[0].getTypeName());
} else {
//解析实体类
Type entityType = ((ParameterizedTypeImpl) classType).getActualTypeArguments()[0];
try {
Field[] declaredFields = Class.forName(entityType.getTypeName()).getDeclaredFields();
// declaredFields
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
((ParameterizedType) classType).getActualTypeArguments();
}
//获取当前类型的所有字段
//非基础类型/MAP/LIST则认定为实体类
//数组
//普通类型
}
/**
* 判断是否为Map类型泛型
*/
static boolean isMapGenerics(AnnotatedType annotatedType) {
try {
if (((ParameterizedType) annotatedType.getType()).getActualTypeArguments()[0].getTypeName().contains("java.util.Map")) {
return true;
}
} catch (Exception e) {
return false;
}
return false;
}
/**
* 判断是否为Map类型泛型
*/
static boolean isListGenerics(AnnotatedType annotatedType) {
try {
if (((ParameterizedType) annotatedType.getType()).getActualTypeArguments()[0].getTypeName().contains("java.util.List")) {
return true;
}
} catch (Exception e) {
return false;
}
return false;
}
static void getFatherClassFields(List<Map<String, Object>> fieldList, Type classType, Map<String, Object> genericsInfo){
if (classType instanceof ParameterizedType){
try {
Class<?> superclass = Class.forName(((ParameterizedTypeImpl) classType).getRawType().getTypeName()).getSuperclass();
Field[] declaredFields = superclass.getDeclaredFields();
addFatherFields(fieldList,declaredFields,genericsInfo);
} catch (ClassNotFoundException e) {
System.out.println("获取类对象失败");
return;
}
}else {
try {
Class<?> superclass = Class.forName(classType.getTypeName()).getSuperclass();
Field[] declaredFields = superclass.getDeclaredFields();
addFatherFields(fieldList,declaredFields,genericsInfo);
} catch (ClassNotFoundException e) {
System.out.println("获取类对象失败");
return;
}
}
}
static void addEntityFields(List<Map<String, Object>> fieldList, Field[] declaredFields, Map<String, Object> genericsInfo){
}
static int addFatherFields(List<Map<String, Object>> fieldList, Field[] declaredFields, Map<String, Object> genericsInfo){
int count = 0;
for (Field declaredField : declaredFields) {
//添加栏位信息
ApiModelProperty annotatin = declaredField.getAnnotation(ApiModelProperty.class);
String desc = "";
String example = "";
if (annotatin != null) {
desc = annotatin.value();
example = annotatin.example();
}
Map<String, Object> fieldMap = generaFieldInfo(declaredField.getName(), desc, declaredField.getType().getSimpleName(), "Y", example);
fieldList.add(fieldMap);
count++;
if (haveFatherClass(declaredField.getType())){
getFatherClassFields(fieldList,declaredField.getType(),genericsInfo);
}
}
return count;
}
static void scanType(List<Map<String, Object>> fieldList, Type type, Map<String, Object> genericsInfo){
//有父类先添加父类字段
if (haveFatherClass(type)){
//扫描父类信息加入同级栏位
}
}
/**
* 判断字符串是否为纯大写字符
* @param str
* @return
*/
static boolean isUpperAlphabet(String str){
if (StringUtils.isEmpty(str))
return false;
for (char c : str.toCharArray()) {
if (c >= 'A' && c <= 'Z'){
return false;
}
}
return true;
}
/**
* 类型是否有父类
* @param type
* @return
*/
static boolean haveFatherClass(Type type){
if (type == null)
return false;
if (type instanceof ParameterizedType){
try {
if (Class.forName(((ParameterizedTypeImpl) type).getRawType().getTypeName()).getSuperclass() !=null && !"java.lang.Object".equals(Class.forName(((ParameterizedTypeImpl) type).getRawType().getTypeName()).getSuperclass().getCanonicalName())){
return true;
}
} catch (ClassNotFoundException e) {
return false;
}
}
try {
if (Class.forName(type.getTypeName()).getSuperclass() != null && !"java.lang.Object".equals(Class.forName(type.getTypeName()).getSuperclass().getCanonicalName())){
return true;
}
} catch (ClassNotFoundException e) {
return false;
}
return false;
}
static Map<String,Object> generaFieldInfo(String name,String desc,String type,String require,String example){
Map<String,Object> resultMap = new HashMap();
resultMap.put("desc", desc);
resultMap.put("fieldName", name);
resultMap.put("fieldType", type);
resultMap.put("example", example);
// resultMap.put("require", Y.equals(require) ? Y:N);
return resultMap;
}
//是否是基础类型数组
static boolean isBasicArrType(Type arrType){
if (arrType.getTypeName().contains("int")
|| arrType.getTypeName().contains("long")
|| arrType.getTypeName().contains("char")
|| arrType.getTypeName().contains("short")
|| arrType.getTypeName().contains("float")
|| arrType.getTypeName().contains("double")
|| arrType.getTypeName().contains("boolean")
|| arrType.getTypeName().contains("JSON")
|| arrType.getTypeName().contains("JSONObject")
|| arrType.getTypeName().contains("java.lang")
)
return true;
return false;
}
}
PackageScanner的更多相关文章
- [编织消息框架][JAVA核心技术]动态代理应用9-扫描class
之前介绍的annotationProcessor能在编译时生成自定义class,但有个缺点,只能每次添加/删除java文件才会执行,那天换了个人不清楚就坑大了 还记得之前介绍的编译时处理,懒处理,还有 ...
- [编织消息框架][JAVA核心技术]动态代理应用11-水平扩展实现
由于示例,远程服务地址配置在properties文件,通过QMConfig类加载,最优方式是上节介绍过,放在共享内存上,只需要维护一份数据即可,如放在redis上 /** 服务地址<servic ...
- SpringBoot+Mybatis集成搭建
本博客介绍一下SpringBoot集成Mybatis,数据库连接池使用alibaba的druid,使用SpringBoot微框架虽然集成Mybatis之后可以不使用xml的方式来写sql,但是用惯了x ...
- Mybatis自定义SQL拦截器
本博客介绍的是继承Mybatis提供的Interface接口,自定义拦截器,然后将项目中的sql拦截一下,打印到控制台. 先自定义一个拦截器 package com.muses.taoshop.com ...
- Mybatis3.2不支持Ant通配符TypeAliasesPackage扫描的解决方案
业务场景 业务场景:首先项目进行分布式拆分之后,按照模块再分为为api层和service层,web层. 其中订单业务的实体类放在com.muses.taoshop.item.entity,而用户相关的 ...
- 【Java】模拟Sping，实现其IOC和AOP核心（二）
接着上一篇,在上一篇完成了有关IOC的注解实现,这一篇用XML的方式实现IOC,并且完成AOP. 简易的IOC框图 注解的方式实现了左边的分支,那么就剩下右边的XML分支: XmlContext:这个 ...
- 【Java】模拟Sping，实现其IOC和AOP核心（一）
在这里我要实现的是Spring的IOC和AOP的核心,而且有关IOC的实现,注解+XML能混合使用! 参考资料: IOC:控制反转(Inversion of Control,缩写为IoC),是面向对象 ...
- 【Java】用注解实现分发器
在C/S中,客户端会向服务器发出各种请求,而服务器就要根据请求做出对应的响应.实际上就是客户机上执行某一个方法,将方法返回值,通过字节流的方式传输给服务器,服务器找到该请求对应的响应方法,并执行,将结 ...
- 【Java】包，jar包的扫描
包扫描在框架中应用很广泛,在spring中,通过给自己的类加注解的方式,利用spring的包扫描,完成依赖注入. package com.test.package_scanner.core; impo ...
- Java中的包扫描（工具）
在现在好多应用场景中,我们需要得到某个包名下面所有的类, 包括我们自己在src里写的java类和一些第三方提供的jar包里的类,那么怎么来实现呢? 今天带大家来完成这件事. 先分享代码: 1.这个类是 ...
随机推荐
- [ML] 详解 ChatGLM-webui 的启动使用与 ChatGLM-6B 常见问题
1. ChatGLM-webui 总共支持以下几个命令选项: 2. 以 windows 为例,在 PowerShell 里运行命令: # 安装依赖 pip install torch==1.13. ...
- [Go] 选择 Beego 的三个理由
1. 项目支持角度较其它框架考虑的多一些,比如:目录结构的简单约定,内置项目配置读取,内置bee脚手架,热重载特性 等. (实际这些 feature 都可以找到 golang 专精的组件引入起来,效果 ...
- dotnet 写一个支持层层继承属性的对象
我最近在造一个比 Excel 差得多的表格控件,其中一个需求是属性的继承.大家都知道,表格里面有单元格,单元格里面允许放文本,文本可以放多段文本.本文的主角就是文本段落的样式属性,包括文本字体字号颜色 ...
- ChatGPT 眼中的程序员
1 你如何看待程序员这个行业 程序员这个行业在现代社会扮演着非常重要的角色.作为一个技术驱动的职业,程序员们负责开发.设计和维护软件和应用程序,这些技术改变了我们的生活方式.商业模式和社会互动方式. ...
- SpringBoot的@Resource和@Autowired+@Qualifier使用
1.区别 参考: https://blog.csdn.net/xhbzl/article/details/126765893 https://blog.csdn.net/qq_40263124/art ...
- Java 泛型，这次面试我表现很棒！
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryBy ...
- 再聊解除HiddenApi限制
炒冷饭,再聊聊大家都知晓的隐藏接口的限制解除. 说明 由于我们容器产品的特性,需要将应用完整的运行起来,所以必须涉及一些隐藏接口的反射调用,而突破反射限制则成为我们实现的基础.现将我们的解决方案分享给 ...
- Java 集合类 List 的那些坑
现在的一些高级编程语言都会提供各种开箱即用的数据结构的实现,像 Java 编程语言的集合框架中就提供了各种实现,集合类包含 Map 和 Collection 两个大类,其中 Collection 下面 ...
- [2]自定义Lua解析方式
[2]自定义Lua解析方式 在上文中我们学会学会更改加载路径,加载对应文件夹下的Lua脚本. 默认解析加载的lua脚本存在的文件位置非AB包或者Resources文件夹下往往不能随包体更新,这显然不符 ...
- XTuner 微调 LLM实操-书生浦语大模型实战营第二期第4节作业
这一作业中提及的解释比较少,更多的只是一些步骤截图.这是因为教程中已经提及了几乎所有的细节信息,没有什么需要补充的.这个页面相较于官方教程的部分解释得过于详细的内容甚至是有所删减的.比如关于文件路径可 ...