package com.vci.web.util;
|
|
import com.vci.starter.web.annotation.*;
|
import com.vci.starter.web.enumpck.BaseEnum;
|
import com.vci.starter.web.enumpck.BaseEnumInt;
|
import com.vci.starter.web.enumpck.VciFieldTypeEnum;
|
import com.vci.starter.web.exception.VciBaseException;
|
import com.vci.starter.web.util.ApplicationContextProvider;
|
import com.vci.starter.web.util.VciBaseUtil;
|
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
|
import com.vci.web.bo.BtmOrLinkProcessAttributeInfo;
|
import com.vci.web.constant.FieldConstant;
|
import com.vci.web.dto.*;
|
import com.vci.web.service.WebBtmIOServiceI;
|
import org.apache.commons.lang3.StringUtils;
|
import org.reflections.Reflections;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
import org.springframework.util.CollectionUtils;
|
|
import java.lang.reflect.Field;
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.security.Timestamp;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 扫描注解工具--我们参考的是平台2021版本中的扫描工具，
|
* 将扫描包含了生命周期，枚举，业务类型，链接类型的对象。并保存到对象服务中
|
* @author weidy
|
* @date 2019/10/31 8:49 AM
|
*/
|
@Component
|
public class OsScanAnnotationTool {
|
|
|
/**
|
* 导入的服务
|
*/
|
@Autowired
|
private WebBtmIOServiceI btmIOService;
|
|
/**
|
* 日志
|
*/
|
private Logger logger = LoggerFactory.getLogger(getClass());
|
|
/**
|
* 是否检查数据库表的参数名字
|
*/
|
public static final String CHECK_TABLE_EXIST = "check-table-exist";
|
|
|
/**
|
* 扫描对象注解后到对象服务中
|
* @param packageName 包名，如果为空则自动找VciPlatformScan注解里的内容，如果没有则抛出异常
|
* @throws VciBaseException 注解的内容或者参数有错误的时候抛出异常
|
*/
|
public void scanAnnotation2OSServer(String packageName) throws VciBaseException {
|
doScanAnnotation2OSServer(VciBaseUtil.str2List(packageName),null,null);
|
}
|
|
/**
|
* 扫描对象注解后到对象服务中
|
* @param packageName 包名，如果为空则自动找VciPlatformScan注解里的内容，如果没有则抛出异常
|
* @param entityNames 指定实体类名,必须全路径
|
* @throws VciBaseException 注解的内容或者参数有错误的时候抛出异常
|
*/
|
public void scanAnnotation2OSServer(String packageName, String entityNames) throws VciBaseException{
|
doScanAnnotation2OSServer(VciBaseUtil.str2List(packageName),VciBaseUtil.str2List(entityNames),null);
|
}
|
|
/**
|
* 扫描对象注解后到对象服务中
|
* @param packageName 包名，如果为空则自动找VciPlatformScan注解里的内容，如果没有则抛出异常
|
* @param entityNames 指定实体类名,必须全路径
|
* @param unScanEntityNames 不扫描的实体类名，必须是全路径
|
* @throws VciBaseException 注解的内容或者参数有错误的时候抛出异常
|
*/
|
public void scanAnnotation2OSServer(String packageName, String entityNames, String unScanEntityNames) throws VciBaseException{
|
doScanAnnotation2OSServer(VciBaseUtil.str2List(packageName),VciBaseUtil.str2List(entityNames),VciBaseUtil.str2List(unScanEntityNames));
|
}
|
|
/**
|
* 根据包名获取其中所有的对象
|
* @param lifeCycleClassList 生命周期类列表
|
* @param enumClassList 枚举类列表
|
* @param btmTypeClassList 业务类型类列表
|
* @param linkTypeClassList 链接类型类 列表
|
* @param packageNameList 包全路径,如果没有设置时自动获取VciPlatformScan注解
|
*/
|
private void scanClassForPackage(List<Class<?>> lifeCycleClassList, List<Class<?>> enumClassList, List<Class<?>> btmTypeClassList, List<Class<?>> linkTypeClassList, Collection<String> packageNameList){
|
//为了不重复造轮子，采用了org.reflections:reflections
|
if(CollectionUtils.isEmpty(packageNameList)){
|
List<String> tempPackageList = new ArrayList<String>();
|
//从spring里获取包含了VciPlatformScan的bean
|
Map<String, Object> withBeanMap = ApplicationContextProvider.getApplicationContext().getBeansWithAnnotation(VciPlatformScan.class);
|
if(!CollectionUtils.isEmpty(withBeanMap)){
|
for(String beanName : withBeanMap.keySet()){
|
Object bean = withBeanMap.get(beanName);
|
if(bean.getClass().isAnnotationPresent(VciPlatformScan.class)){
|
VciPlatformScan vciPlatformScan = bean.getClass().getAnnotation(VciPlatformScan.class);
|
String[] values = vciPlatformScan.value();
|
if(values !=null && values.length>0){
|
for(String p : values){
|
tempPackageList.add(p);
|
}
|
}
|
}
|
}
|
}
|
packageNameList = tempPackageList;
|
}
|
for(String packName:packageNameList){
|
Reflections reflections=new Reflections(packName);
|
//生命周期相关
|
Set<Class<?>> vciLifeCycleSet = reflections.getTypesAnnotatedWith(VciLifeCycle.class);
|
if(!CollectionUtils.isEmpty(vciLifeCycleSet)){
|
vciLifeCycleSet.stream().forEach(classObj->{
|
if(!classObj.isAnnotationPresent(Transient.class)){
|
lifeCycleClassList.add(classObj);
|
}
|
});
|
}
|
//枚举相关
|
Set<Class<?>> vciEnumSet = reflections.getTypesAnnotatedWith(VciEnum.class);
|
if(!CollectionUtils.isEmpty(vciEnumSet)){
|
vciEnumSet.stream().forEach(classObj->{
|
if(!classObj.isAnnotationPresent(Transient.class)){
|
enumClassList.add(classObj);
|
}
|
});
|
}
|
//业务类型相关
|
Set<Class<?>> vciBtmTypeSet = reflections.getTypesAnnotatedWith(VciBtmType.class);
|
if(!CollectionUtils.isEmpty(vciBtmTypeSet)){
|
//需要看看这些业务类型是否添加了@Transient注解，因为这种说明是平台的原本的业务类型
|
vciBtmTypeSet.stream().forEach(classObj ->{
|
if(!classObj.isAnnotationPresent(Transient.class)){
|
btmTypeClassList.add(classObj);
|
}
|
});
|
}
|
//链接类型相关
|
Set<Class<?>> vciLinkTypeSet = reflections.getTypesAnnotatedWith(VciLinkType.class);
|
if(!CollectionUtils.isEmpty(vciLinkTypeSet)){
|
vciLinkTypeSet.stream().forEach(classObj->{
|
if(!classObj.isAnnotationPresent(Transient.class)){
|
linkTypeClassList.add(classObj);
|
}
|
});
|
}
|
}
|
}
|
|
/**
|
* 根据实体类的名称获取对应的class。注意实体类名称必须是全路径
|
* @param lifeCycleClassList 生命周期类列表
|
* @param enumClassList 枚举类列表
|
* @param btmTypeClassList 业务类型类列表
|
* @param linkTypeClassList 链接类型类 列表
|
* @param entityNameList 实体类全路径
|
*/
|
private void scanClassForEntity(List<Class<?>> lifeCycleClassList, List<Class<?>> enumClassList, List<Class<?>> btmTypeClassList, List<Class<?>> linkTypeClassList, Collection<String> entityNameList) throws VciBaseException{
|
if(!CollectionUtils.isEmpty(entityNameList)){
|
for(String entityName:entityNameList){
|
try {
|
Class entityClass = Class.forName(entityName);
|
if(entityClass.isAnnotationPresent(VciBtmType.class) && !entityClass.isAnnotationPresent(Transient.class)){
|
btmTypeClassList.add(entityClass);
|
}
|
if(entityClass.isAnnotationPresent(VciLifeCycle.class)){
|
lifeCycleClassList.add(entityClass);
|
}
|
if(entityClass.isAnnotationPresent(VciEnum.class)){
|
enumClassList.add(entityClass);
|
}
|
if(entityClass.isAnnotationPresent(VciLinkType.class)){
|
linkTypeClassList.add(entityClass);
|
}
|
} catch (ClassNotFoundException e) {
|
if(logger.isErrorEnabled()){
|
logger.error("扫描业务类型相关内容出现了错误",e);
|
}
|
throw new VciBaseException("扫描业务类型相关内容的时候发现实体类{0}不存在",new String[]{entityName},e);
|
}
|
}
|
}
|
}
|
|
/**
|
* 执行扫描业务类型相关内容
|
* @param packageNameCollection 包名集合
|
* @param entityCollection 实体类集合
|
* @throws VciBaseException 扫描类不存在，或者注解不规范都会出现异常
|
*/
|
public void doScanAnnotation2OSServer(Collection<String> packageNameCollection, Collection<String> entityCollection) throws VciBaseException {
|
doScanAnnotation2OSServer(packageNameCollection,entityCollection,null);
|
}
|
|
/**
|
* 执行扫描业务类型相关内容
|
* @param packageNameCollection 包名集合
|
* @param entityCollection 实体类集合
|
* @param unScanEntityCollection 不扫描的实体类集合
|
* @throws VciBaseException 扫描类不存在，或者注解不规范都会出现异常
|
*/
|
public void doScanAnnotation2OSServer(Collection<String> packageNameCollection, Collection<String> entityCollection, Collection<String> unScanEntityCollection) throws VciBaseException{
|
logger.info("执行扫描平台中的相关对象");
|
Map<String, OsStatusDTO> statusDTOMap = new HashMap<String, OsStatusDTO>();
|
Map<String, OsLifeCycleDTO> lifeCycleDTOMap = new HashMap<String, OsLifeCycleDTO>();
|
Map<String, OsEnumDTO> enumDTOMap = new HashMap<String, OsEnumDTO>();
|
Map<String, OsAttributeDTO> attributeDTOMap = new HashMap<String, OsAttributeDTO>();
|
Map<String,OsBtmTypeDTO> btmTypeDTOMap = new HashMap<String,OsBtmTypeDTO>();
|
Map<String,OsLinkTypeDTO> linkTypeDTOMap = new HashMap<String,OsLinkTypeDTO>();
|
|
List<Class<?>> lifeCycleClassList = new ArrayList<Class<?>>();
|
List<Class<?>> enumClassList = new ArrayList<Class<?>>();
|
List<Class<?>> btmTypeClassList = new ArrayList<Class<?>>();
|
List<Class<?>> linkTypeClassList = new ArrayList<Class<?>>();
|
//先看包下面
|
scanClassForPackage(lifeCycleClassList,enumClassList,btmTypeClassList,linkTypeClassList,packageNameCollection);
|
//再看指定的，比如文件不是当前项目下的
|
scanClassForEntity(lifeCycleClassList,enumClassList,btmTypeClassList,linkTypeClassList,entityCollection);
|
|
if(!CollectionUtils.isEmpty(unScanEntityCollection)){
|
lifeCycleClassList = removeUnScanClass(lifeCycleClassList,unScanEntityCollection);
|
enumClassList = removeUnScanClass(enumClassList,unScanEntityCollection);
|
btmTypeClassList = removeUnScanClass(btmTypeClassList,unScanEntityCollection);
|
linkTypeClassList = removeUnScanClass(linkTypeClassList,unScanEntityCollection);
|
}
|
|
if(!CollectionUtils.isEmpty(lifeCycleClassList)){
|
List<Class<?>> scanedClassList = new ArrayList<Class<?>>();
|
for(int i = 0 ; i < lifeCycleClassList.size(); i ++){
|
Class<?> lifeClass = lifeCycleClassList.get(i);
|
if(!scanedClassList.contains(lifeClass)){
|
scanStatusAndLifeCycle(lifeClass,statusDTOMap,lifeCycleDTOMap);
|
scanedClassList.add(lifeClass);
|
}
|
}
|
}
|
|
if(!CollectionUtils.isEmpty(enumClassList)){
|
List<Class<?>> scanedClassList = new ArrayList<Class<?>>();
|
for(int i = 0 ; i < enumClassList.size(); i ++){
|
Class<?> enumClass = enumClassList.get(i);
|
if(!scanedClassList.contains(enumClass)){
|
scanEnum(enumClass,enumDTOMap);
|
scanedClassList.add(enumClass);
|
}
|
}
|
}
|
|
if(!CollectionUtils.isEmpty(btmTypeClassList)){
|
List<Class<?>> scanedClassList = new ArrayList<Class<?>>();
|
for(int i = 0 ; i < btmTypeClassList.size(); i ++){
|
Class<?> btmTypeClass = btmTypeClassList.get(i);
|
if(!scanedClassList.contains(btmTypeClass)){
|
scanAttributeAndBtmType(btmTypeClass,attributeDTOMap,btmTypeDTOMap);
|
scanedClassList.add(btmTypeClass);
|
}
|
}
|
}
|
|
if(!CollectionUtils.isEmpty(linkTypeClassList)){
|
List<Class<?>> scanedClassList = new ArrayList<Class<?>>();
|
for(int i = 0 ; i < linkTypeClassList.size(); i ++){
|
Class<?> linkTypeClass = linkTypeClassList.get(i);
|
if(!scanedClassList.contains(linkTypeClass)){
|
scanAttributeAndLinkType(linkTypeClass,attributeDTOMap,linkTypeDTOMap);
|
scanedClassList.add(linkTypeClass);
|
}
|
}
|
}
|
|
//ok.准备传递数据
|
|
OsBtmTypeExportDTO btmTypeExportDTO = new OsBtmTypeExportDTO();
|
//属性的数据传输对象
|
btmTypeExportDTO.setAttributeDTOList(attributeDTOMap.values());
|
//生命周期的数据传输对象
|
btmTypeExportDTO.setLifeCycleDTOList(lifeCycleDTOMap.values());
|
//状态
|
btmTypeExportDTO.setStatusDTOList(statusDTOMap.values());
|
//枚举
|
btmTypeExportDTO.setEnumDTOList(enumDTOMap.values());
|
//业务类型
|
btmTypeExportDTO.setBtmTypeDTOList(btmTypeDTOMap.values());
|
//链接类型
|
btmTypeExportDTO.setLinkTypeDTOList(linkTypeDTOMap.values());
|
//执行导入的
|
btmIOService.importBtmTypes(btmTypeExportDTO);
|
}
|
|
/**
|
* 去除重复的类
|
* @param beanList 类列表
|
* @param unScanEntityCollection 不扫描的类名
|
*/
|
private List<Class<?>> removeUnScanClass(Collection<Class<?>> beanList,Collection<String> unScanEntityCollection){
|
List<Class<?>> needScanClassList = new ArrayList<Class<?>>();
|
if(!CollectionUtils.isEmpty(beanList)) {
|
for(Class<?> cl:beanList){
|
if(!unScanEntityCollection.contains(cl.getName())){
|
needScanClassList.add(cl);
|
}
|
}
|
}
|
return needScanClassList;
|
}
|
|
/**
|
* 扫描链接类型的对象
|
* @param linkTypeClass 链接类型类的对象
|
* @param attributeDTOMap 属性的映射
|
* @param linkTypeDTOMap 链接类型的映射
|
*/
|
private void scanAttributeAndLinkType(Class<?> linkTypeClass, Map<String,OsAttributeDTO> attributeDTOMap, Map<String,OsLinkTypeDTO> linkTypeDTOMap) {
|
String className = linkTypeClass.getName();
|
logger.info("链接类型的类==" + className);
|
OsLinkTypeDTO linkTypeDTO = new OsLinkTypeDTO();
|
if(linkTypeClass.isAnnotationPresent(VciLinkType.class)){
|
VciLinkType linkType = linkTypeClass.getAnnotation(VciLinkType.class);
|
linkTypeDTO.setId(linkType.name());
|
linkTypeDTO.setName(linkType.text());
|
linkTypeDTO.setFromBtmType(arrays2String(linkType.fromBtmTypes()));
|
linkTypeDTO.setToBtmType(arrays2String(linkType.toBtmTypes()));
|
}else{
|
throw new VciBaseException("链接类型类必须要添加VciLinkType",
|
new Object[]{className});
|
}
|
if(StringUtils.isBlank(linkTypeDTO.getId())){
|
linkTypeDTO.setId(VciBaseUtil.toLowForFirst(linkTypeClass.getSimpleName()));
|
if(linkTypeDTO.getId().endsWith("DO")){
|
linkTypeDTO.setId(linkTypeDTO.getId().substring(0,linkTypeDTO.getId().length()-2));
|
}
|
}
|
|
//找是否已经存在
|
if(linkTypeDTOMap.containsKey(linkTypeDTO.getId().toLowerCase())){
|
throw new VciBaseException("链接类型{0}[{1}]在系统中已经存在，请不要重复添加；与之相同名称的链接类型类路径为{2}",
|
new Object[]{linkTypeDTO.getId(),linkTypeDTO.getName(),linkTypeDTOMap.get(linkTypeDTO.getId().toLowerCase().trim()).getClassFullName()});
|
}
|
|
//找属性
|
List<Field> fields = new ArrayList<Field>();
|
Collections.addAll(fields,linkTypeClass.getDeclaredFields());
|
List<OsBtmTypeLinkAttributesDTO> linkTypeAttributeVOList = new ArrayList<OsBtmTypeLinkAttributesDTO>();
|
BtmOrLinkProcessAttributeInfo processAttributeInfo = new BtmOrLinkProcessAttributeInfo();
|
processAttributeInfo.setId(linkTypeClass.getName());
|
processAttributeInfo.setName(linkTypeDTO.getName());
|
processAttributeInfo.setLinkType(true);
|
scanAttributes(fields,attributeDTOMap,linkTypeAttributeVOList,processAttributeInfo);
|
linkTypeDTO.setAttributesDTOList(linkTypeAttributeVOList);
|
linkTypeDTOMap.put(linkTypeDTO.getId().toLowerCase().trim(),linkTypeDTO);
|
}
|
|
/**
|
* 数组转换为逗号分隔的字符串
|
* @param arrays 数组
|
* @return 逗号分隔的字符串
|
*/
|
private String arrays2String(String[] arrays){
|
return VciBaseUtil.array2String(arrays);
|
}
|
|
/**
|
* 序列化的属性名称
|
*/
|
private static final String SERIALVERSION_FIELD_NAME = "serialVersionUID";
|
|
/**
|
* 扫描属性
|
* @param fields 属性字段数组
|
* @param attributeDTOMap 属性的传输映射
|
* @param useAttributeVOList 使用的属性
|
* @param processAttributeInfo 业务类型或者链接类型
|
*/
|
private void scanAttributes(List<Field> fields, Map<String,OsAttributeDTO> attributeDTOMap, List<OsBtmTypeLinkAttributesDTO> useAttributeVOList, BtmOrLinkProcessAttributeInfo processAttributeInfo){
|
for(Field field: fields){
|
field.setAccessible(true);
|
OsAttributeDTO attributeDTO = new OsAttributeDTO();
|
scanField2Attribute(field,attributeDTO,attributeDTOMap,processAttributeInfo);
|
if(StringUtils.isNotBlank(attributeDTO.getAttributeDataType())) {
|
OsBtmTypeLinkAttributesDTO linkAttributesDTO = new OsBtmTypeLinkAttributesDTO();
|
copyAttribute2BtmTypeLink(linkAttributesDTO, attributeDTO);
|
useAttributeVOList.add(linkAttributesDTO);
|
}
|
}
|
}
|
|
/**
|
* 扫描属性和业务类型
|
* @param btmTypeClass 业务类型的类
|
* @param attributeDTOMap 属性的数据传输对象映射，key是属性的英文名称小写
|
* @param btmTypeDTOMap 业务类型的数据传输对象映射，key是业务类型的英文名称小写
|
*/
|
private void scanAttributeAndBtmType(Class<?> btmTypeClass, Map<String,OsAttributeDTO> attributeDTOMap, Map<String,OsBtmTypeDTO> btmTypeDTOMap) {
|
String className = btmTypeClass.getName();
|
logger.info("业务类型的类==" + className);
|
OsBtmTypeDTO btmTypeDTO = new OsBtmTypeDTO();
|
if(btmTypeClass.isAnnotationPresent(VciBtmType.class)){
|
VciBtmType vciBtmType = btmTypeClass.getAnnotation(VciBtmType.class);
|
btmTypeDTO.setId(vciBtmType.name());
|
btmTypeDTO.setName(vciBtmType.text());
|
// btmTypeDTO.setTableName(StringUtils.isBlank(vciBtmType.tableName())?VciBaseUtil.getTableName(btmTypeDTO.getName()):vciBtmType.tableName());
|
//btmTypeDTO.setSecretFlag(vciBtmType.secretAble());
|
btmTypeDTO.setDescription(vciBtmType.description());
|
btmTypeDTO.setLifeCycleId(vciBtmType.lifeCycle());
|
String[] subLifeCycles = vciBtmType.subLifeCycle();
|
if(subLifeCycles!=null&& subLifeCycles.length > 0){
|
btmTypeDTO.setSubLifeCycleId(arrays2String(subLifeCycles));
|
}
|
btmTypeDTO.setInputRevisionFlag(vciBtmType.revisionRuleInput());
|
btmTypeDTO.setRevisionRuleId(vciBtmType.revisionRule());
|
btmTypeDTO.setVersionRule(vciBtmType.versionRule().getValue());
|
}else{
|
btmTypeDTO.setSecretFlag(false);
|
btmTypeDTO.setLifeCycleId("");
|
btmTypeDTO.setInputRevisionFlag(false);
|
}
|
if(StringUtils.isBlank(btmTypeDTO.getId())){
|
btmTypeDTO.setId(VciBaseUtil.toLowForFirst(btmTypeClass.getSimpleName()));
|
if(btmTypeDTO.getId().endsWith("DO")){
|
btmTypeDTO.setId(btmTypeDTO.getId().substring(0,btmTypeDTO.getId().length()-2));
|
}
|
}
|
if(btmTypeDTO.getId().length()>18){
|
throw new VciBaseException("业务类型[{0}]名称的长度不能超过18位，当前为{1}",new String[]{btmTypeDTO.getName(),btmTypeDTO.getId()});
|
}
|
if(StringUtils.isBlank(btmTypeDTO.getLifeCycleId())){
|
btmTypeDTO.setLifeCycleFlag(false);
|
}else{
|
btmTypeDTO.setLifeCycleFlag(true);
|
}
|
|
btmTypeDTO.setClassFullName(className);
|
btmTypeDTO.setImplClass(className);
|
if(StringUtils.isNotBlank(btmTypeDTO.getRevisionRuleId()) || btmTypeDTO.isInputRevisionFlag()){
|
btmTypeDTO.setRevisionFlag(true);
|
}else{
|
btmTypeDTO.setRevisionFlag(false);
|
}
|
//从注释里获取名称
|
|
//找是否已经存在
|
if(btmTypeDTOMap.containsKey(btmTypeDTO.getId().toLowerCase())){
|
throw new VciBaseException("业务类型{0}[{1}]在系统中已经存在，请不要重复添加；与之相同名称的业务类型类路径为{2}",
|
new Object[]{btmTypeDTO.getId(),btmTypeDTO.getName(),btmTypeDTOMap.get(btmTypeDTO.getId().toLowerCase().trim()).getClassFullName()});
|
}
|
|
BtmOrLinkProcessAttributeInfo processAttributeInfo = new BtmOrLinkProcessAttributeInfo();
|
processAttributeInfo.setId(className);
|
processAttributeInfo.setName(btmTypeDTO.getName());
|
processAttributeInfo.setSecret(btmTypeDTO.isSecretFlag());
|
processAttributeInfo.setRevision(btmTypeDTO.isRevisionFlag());
|
processAttributeInfo.setLinkType(false);
|
processAttributeInfo.setLifeCycle(btmTypeDTO.isLifeCycleFlag());
|
|
//处理属性
|
List<Field> fields =new ArrayList<Field>();
|
Collections.addAll(fields,btmTypeClass.getDeclaredFields());
|
List<OsBtmTypeLinkAttributesDTO> btmTypeLinkAttributesDTOList = new ArrayList<OsBtmTypeLinkAttributesDTO>();
|
scanAttributes(fields,attributeDTOMap,btmTypeLinkAttributesDTOList,processAttributeInfo);
|
btmTypeDTO.setAttributesDTOList(btmTypeLinkAttributesDTOList);
|
btmTypeDTOMap.put(btmTypeDTO.getId().toLowerCase().trim(),btmTypeDTO);
|
}
|
|
/**
|
* 从类的属性字段上获取注解并拷贝到属性对象中
|
* @param field 属性字段
|
* @param attributeDTO 属性对象
|
* @param attributeDTOMap 属性的映射，key是属性的英文名称大写
|
* @param processAttributeInfo 业务类型或者链接类型的基本信息
|
*/
|
private void scanField2Attribute(Field field, OsAttributeDTO attributeDTO, Map<String,OsAttributeDTO> attributeDTOMap, BtmOrLinkProcessAttributeInfo processAttributeInfo){
|
//找基本的信息
|
if(field.isAnnotationPresent(Transient.class) || "serialversionuid".equalsIgnoreCase(field.getName())){
|
//加了这个注解的属性也是不持久化的
|
return;
|
}
|
if(field.isAnnotationPresent(Column.class)){
|
Column column = field.getAnnotation(Column.class);
|
attributeDTO.setId(column.name());
|
if(StringUtils.isBlank(attributeDTO.getId())){
|
attributeDTO.setId(field.getName());
|
}
|
attributeDTO.setName(column.columnDefinition());
|
attributeDTO.setNullableFlag(column.nullable());
|
attributeDTO.setDefaultValue(column.defaultValue());
|
attributeDTO.setEnumId(column.useEnum());
|
attributeDTO.setBtmTypeId(column.useRefer());
|
attributeDTO.setAttrLength(column.length());
|
attributeDTO.setPrecisionLength(column.precision());
|
attributeDTO.setScaleLength(column.scale());
|
String[] ranges = column.range();
|
if(ranges!=null&& ranges.length > 0){
|
attributeDTO.setRange(VciBaseUtil.array2String(ranges));
|
}
|
}else{
|
attributeDTO.setNullableFlag(true);
|
attributeDTO.setId(field.getName());
|
}
|
String attrLowId = attributeDTO.getId().toLowerCase(Locale.ROOT);
|
if(FieldConstant.REVISION_MANAGE_FIELD_MAP.containsKey(attrLowId)
|
||FieldConstant.BASIC_FIELD_MAP.containsKey(attrLowId)
|
||FieldConstant.BASE_MODEL_COMPATIBILITY_MAP.containsKey(attrLowId)
|
||FieldConstant.LIFECYCLE_MANAGE_FIELD_MAP.containsKey(attrLowId)
|
||FieldConstant.LINK_TYPE_FIELD_MAP.containsKey(attrLowId)){
|
//基础的属性
|
return;
|
}
|
if(StringUtils.isBlank(attributeDTO.getId())){
|
attributeDTO.setId(field.getName());
|
}
|
if(StringUtils.isBlank(attributeDTO.getName())){
|
attributeDTO.setName(attributeDTO.getId());
|
}
|
String attributeLowerId = attributeDTO.getId().toLowerCase();
|
//找类型配置的信息
|
Class<?> fieldType = field.getType();
|
if (field.isAnnotationPresent(VciFieldType.class)) {
|
VciFieldType vciFieldType = field.getAnnotation(VciFieldType.class);
|
VciFieldTypeEnum fieldTypeEnum = vciFieldType.value();
|
if(fieldTypeEnum == null){
|
attributeDTO.setAttributeDataType(VciFieldTypeEnum.VTString.name());
|
}else {
|
if (fieldTypeEnum.equals(VciFieldTypeEnum.VTBoolean)) {
|
attributeDTO.setAttrLength(5);
|
}
|
if (fieldTypeEnum.equals(VciFieldTypeEnum.VTFilePath)) {
|
attributeDTO.setAttrLength(50);
|
}
|
attributeDTO.setAttributeDataType(fieldTypeEnum.name());
|
}
|
} else {
|
if (fieldType.equals(Integer.class) || fieldType.equals(int.class)
|
|| fieldType.equals(Short.class)
|
|| fieldType.equals(short.class)) {
|
attributeDTO.setAttributeDataType(VciFieldTypeEnum.VTInteger.name());
|
} else if (fieldType.equals(Long.class) || fieldType.equals(long.class)) {
|
attributeDTO.setAttributeDataType(VciFieldTypeEnum.VTLong.name());
|
} else if (fieldType.equals(Double.class) || fieldType.equals(double.class)
|
|| fieldType.equals(Float.class) || fieldType.equals(float.class)
|
|| fieldType.equals(BigDecimal.class) || fieldType.equals(BigInteger.class)) {
|
attributeDTO.setAttributeDataType(VciFieldTypeEnum.VTDouble.name());
|
} else if (fieldType.equals(Date.class) || fieldType.equals(Timestamp.class)) {
|
attributeDTO.setAttributeDataType(VciFieldTypeEnum.VTDateTime.name());
|
} else {
|
attributeDTO.setAttributeDataType(VciFieldTypeEnum.VTString.name());
|
}
|
}
|
if (attributeDTO.getAttrLength() == null) {
|
attributeDTO.setAttrLength(0);
|
}
|
if (attributeDTO.getAttrLength() == 0 &&
|
(VciFieldTypeEnum.VTDouble.name().equals(attributeDTO.getAttributeDataType()) || fieldType.equals(Double.class) || fieldType.equals(double.class)
|
|| fieldType.equals(Float.class) || fieldType.equals(float.class)
|
|| fieldType.equals(BigDecimal.class) || fieldType.equals(BigInteger.class))) {
|
attributeDTO.setAttrLength(8);
|
}
|
if (StringUtils.isBlank(attributeDTO.getBtmTypeId())
|
&& field.isAnnotationPresent(VciUseRefer.class)) {
|
VciUseRefer refer = field.getAnnotation(VciUseRefer.class);
|
attributeDTO.setBtmTypeId(refer.value());
|
}
|
if (StringUtils.isBlank(attributeDTO.getEnumId())
|
&& field.isAnnotationPresent(VciUseEnum.class)) {
|
VciUseEnum useEnum = field.getAnnotation(VciUseEnum.class);
|
attributeDTO.setEnumId(useEnum.value());
|
}
|
if (attributeDTO.getAttrLength() == 0 &&
|
VciFieldTypeEnum.VTString.name().equals(attributeDTO.getAttributeDataType())){
|
if(StringUtils.isNotBlank(attributeDTO.getBtmTypeId())
|
|| StringUtils.isNotBlank(attributeDTO.getEnumId())){
|
attributeDTO.setAttrLength(50);
|
}else {
|
attributeDTO.setAttrLength(150);
|
}
|
}
|
if (attributeDTOMap.containsKey(attributeLowerId)) {
|
OsAttributeDTO existAttributeDTO = attributeDTOMap.get(attributeLowerId);
|
if (existAttributeDTO.getAttrLength() < attributeDTO.getAttrLength()) {
|
existAttributeDTO.setAttrLength(attributeDTO.getAttrLength());
|
}
|
} else {
|
attributeDTOMap.put(attributeDTO.getId().trim().toLowerCase(), attributeDTO);
|
}
|
}
|
|
|
/**
|
* 拷贝属性的内容到业务类型关联属性
|
* @param linkAttributesDTO 业务类型关联属性的对象
|
* @param attributeDTO 属性对象
|
*/
|
private void copyAttribute2BtmTypeLink(OsBtmTypeLinkAttributesDTO linkAttributesDTO,OsAttributeDTO attributeDTO){
|
linkAttributesDTO.setName(attributeDTO.getName());
|
linkAttributesDTO.setAttrDataType(attributeDTO.getAttributeDataType());
|
linkAttributesDTO.setId(attributeDTO.getId());
|
linkAttributesDTO.setAttributeLength(attributeDTO.getAttrLength());
|
linkAttributesDTO.setDefaultValue(attributeDTO.getDefaultValue());
|
linkAttributesDTO.setNullableFlag(attributeDTO.isNullableFlag());
|
linkAttributesDTO.setPrecisionLength(attributeDTO.getPrecisionLength());
|
linkAttributesDTO.setEnumId(attributeDTO.getEnumId());
|
linkAttributesDTO.setReferBtmTypeId(attributeDTO.getBtmTypeId());
|
linkAttributesDTO.setDescription(attributeDTO.getDescription());
|
}
|
|
/**
|
* 扫描枚举
|
* @param enumClass 枚举类
|
* @param enumDTOMap 枚举的映射，key是枚举的英文名称小写，value是枚举的显示对象
|
*/
|
private void scanEnum(Class<?> enumClass, Map<String,OsEnumDTO> enumDTOMap) {
|
String className = enumClass.getName();
|
logger.info("枚举的类==" + className);
|
if(!enumClass.isEnum()){
|
throw new VciBaseException("类{0}不是枚举类",
|
new Object[]{className});
|
}
|
Object[] enumObjs = enumClass.getEnumConstants();
|
OsEnumDTO enumDTO = new OsEnumDTO();
|
if(enumClass.isAnnotationPresent(VciEnum.class)){
|
VciEnum vciEnum = enumClass.getAnnotation(VciEnum.class);
|
enumDTO.setId(vciEnum.name());
|
enumDTO.setName(vciEnum.text());
|
enumDTO.setLength(50);
|
enumDTO.setDescription(vciEnum.description());
|
}
|
//如果没有添加VciEnum注解，则取类的名称小写
|
if(StringUtils.isBlank(enumDTO.getId())){
|
enumDTO.setId(VciBaseUtil.toLowForFirst(enumClass.getSimpleName()));
|
}
|
if(StringUtils.isBlank(enumDTO.getName())){
|
enumDTO.setName(enumDTO.getId());
|
}
|
if(enumDTOMap.containsKey(enumDTO.getId().trim().toLowerCase())){
|
throw new VciBaseException("枚举{0}[{1}]在系统中已经存在，请不要重复添加；与之相同名称的枚举类路径为{2}",
|
new Object[]{enumDTO.getId(),enumDTO.getName(),enumDTOMap.get(enumDTO.getId().toLowerCase().trim()).getClassFullName()});
|
}
|
|
Map<String,String> itemMap = new HashMap<String,String>();
|
for(Object obj : enumObjs){
|
Class<?>[] objInterfaces = obj.getClass().getInterfaces();
|
if(VciBaseUtil.inArray(objInterfaces, BaseEnum.class)){
|
BaseEnum baseEnum = (BaseEnum)obj;
|
enumDTO.setEnumValueDataType("string");
|
itemMap.put(baseEnum.getValue(),baseEnum.getText());
|
}else if(VciBaseUtil.inArray(objInterfaces, BaseEnumInt.class)){
|
BaseEnumInt baseEnum = (BaseEnumInt)obj;
|
enumDTO.setEnumValueDataType("int");
|
itemMap.put(baseEnum.getValue() + "",baseEnum.getText());
|
}else{
|
throw new VciBaseException("枚举所属的类{0}没有实现BaseEnum或者BaseEnumInt的接口，请开发人员改正",new Object[]{className});
|
}
|
}
|
enumDTO.setClassFullName(className);
|
enumDTO.setItemMaps(itemMap);
|
enumDTOMap.put(enumDTO.getId().trim().toLowerCase(),enumDTO);
|
}
|
|
/**
|
* 扫描状态和生命周期
|
* @param lifeCycleClass 生命周期的类
|
* @param statusDTOMap 状态的传输对象映射
|
* @param lifeCycleDTOMap 生命周期的对象映射
|
* @throws VciBaseException 注解的内容有错误的时候会抛出异常
|
*/
|
private void scanStatusAndLifeCycle(Class<?> lifeCycleClass, Map<String, OsStatusDTO> statusDTOMap, Map<String, OsLifeCycleDTO> lifeCycleDTOMap) throws VciBaseException{
|
logger.info("生命周期的类==" + lifeCycleClass.getName());
|
if(!lifeCycleClass.isEnum()){
|
throw new VciBaseException("@VciLifeCycle这个注解只能使用在枚举类上,{0}",new Object[]{lifeCycleClass.getSimpleName()});
|
}
|
if(lifeCycleClass.isAnnotationPresent(VciLifeCycle.class)){
|
VciLifeCycle vciLifeCycle = lifeCycleClass.getAnnotation(VciLifeCycle.class);
|
String id = vciLifeCycle.name();
|
if(StringUtils.isBlank(id)){
|
//可能注解没有写值
|
id=VciBaseUtil.toLowForFirst(lifeCycleClass.getSimpleName());
|
}
|
String name = vciLifeCycle.text();
|
if(StringUtils.isBlank(name)){
|
name = id;
|
}
|
if(lifeCycleDTOMap.containsKey(id.toLowerCase().trim())){
|
throw new VciBaseException("生命周期{0}[{1}]在系统中已经存在，请不要重复添加；与之相同的生命周期的类路径为{2}",new Object[]{id,name,lifeCycleDTOMap.get(id.toLowerCase().trim()).getClassFullName()});
|
}
|
String className = lifeCycleClass.getName();
|
OsLifeCycleDTO lifeCycleDTO = new OsLifeCycleDTO();
|
lifeCycleDTO.setId(id);
|
lifeCycleDTO.setName(name);
|
lifeCycleDTO.setStartStatus(vciLifeCycle.startStatus());
|
//找里面所有的状态
|
Object[] enumObjs = lifeCycleClass.getEnumConstants();
|
Map<String,String> statusMapInThisLifeCycle = new HashMap<String,String>();
|
for(int i = 0 ; i < enumObjs.length; i ++ ){
|
Object obj =enumObjs[i];
|
Class<?>[] objInterfaces = obj.getClass().getInterfaces();
|
if(VciBaseUtil.inArray(objInterfaces, BaseEnum.class)){
|
BaseEnum baseEnum = (BaseEnum)obj;
|
statusMapInThisLifeCycle.put(baseEnum.getValue(),baseEnum.getText());
|
}else if(VciBaseUtil.inArray(objInterfaces,BaseEnumInt.class)){
|
BaseEnumInt baseEnum = (BaseEnumInt)obj;
|
statusMapInThisLifeCycle.put(String.valueOf(baseEnum.getValue()),baseEnum.getText());
|
}else{
|
throw new VciBaseException("生命周期所属的类{0}没有实现BaseEnum或者BaseEnumInt的接口，请开发人员改正",new Object[]{className});
|
}
|
}
|
Map<String,String> statusMapInThisLifeCycleLower = new HashMap<String,String>();
|
if(CollectionUtils.isEmpty(statusMapInThisLifeCycle)){
|
throw new VciBaseException("生命周期{0}没有包含任何的状态",new Object[]{className});
|
}
|
for(String statusId : statusMapInThisLifeCycle.keySet()){
|
String statusIdLower = statusId.toLowerCase().trim();
|
String statusText = statusMapInThisLifeCycle.get(statusId);
|
if(!statusDTOMap.containsKey(statusIdLower)){
|
OsStatusDTO statusDTO = new OsStatusDTO();
|
statusDTO.setId(statusId);
|
statusDTO.setName(statusText);
|
statusDTOMap.put(statusIdLower,statusDTO);
|
}
|
statusMapInThisLifeCycleLower.put(statusIdLower,statusText);
|
}
|
if(StringUtils.isBlank(lifeCycleDTO.getStartStatus())){
|
logger.info("因为没有设置生命周期的起始状态，默认第一个状态[{0}]为起始状态,在类{1}中");
|
throw new VciBaseException("没有设置起始状态",new Object[]{});
|
}
|
if(!statusMapInThisLifeCycleLower.containsKey(lifeCycleDTO.getStartStatus().toLowerCase().trim())){
|
throw new VciBaseException("生命周期中的起始状态{0}，在类{1}中不存在",new Object[]{lifeCycleDTO.getStartStatus(),className});
|
}
|
lifeCycleDTO.setStartStatusName(statusMapInThisLifeCycleLower.get(lifeCycleDTO.getStartStatus().toLowerCase().trim()));
|
List<OsLifeCycleLineDTO> lineDTOList = new ArrayList<OsLifeCycleLineDTO>();
|
VciLifeCycleTrans[] translations = vciLifeCycle.translations();
|
if(translations != null && translations.length > 0){
|
int lineCount = 1;
|
for(VciLifeCycleTrans line: translations){
|
if(StringUtils.isNotBlank(line.source()) && StringUtils.isNotBlank(line.target())) {
|
VciLifeCycleTranEvent[] listeners = line.listeners();
|
OsLifeCycleLineDTO lineDTO = new OsLifeCycleLineDTO();
|
lineDTO.setSourceLifeStatus(line.source());
|
if(!statusMapInThisLifeCycleLower.containsKey(lineDTO.getSourceLifeStatus().trim().toLowerCase())){
|
throw new VciBaseException("生命周期中连接线的状态{0}，在类{1}中不存在",new Object[]{lineDTO.getSourceLifeStatus(),className});
|
}
|
lineDTO.setSourceLifeStatusName(statusMapInThisLifeCycleLower.get(lineDTO.getSourceLifeStatus().trim().toLowerCase()));
|
|
lineDTO.setTargetLifeStatus(line.target());
|
if(!statusMapInThisLifeCycleLower.containsKey(lineDTO.getTargetLifeStatus().trim().toLowerCase())){
|
throw new VciBaseException("生命周期中连接线的状态{0}，在类{1}中不存在",new Object[]{lineDTO.getTargetLifeStatus(),className});
|
}
|
lineDTO.setTargetLifeStatusName(statusMapInThisLifeCycleLower.get(lineDTO.getTargetLifeStatus().trim().toLowerCase()));
|
lineDTO.setName(line.name());
|
if(StringUtils.isBlank(lineDTO.getName())){
|
lineDTO.setName("连接线" + lineCount);
|
}
|
if(listeners!=null) {
|
lineDTO.setEventDTOList(Arrays.asList(listeners).stream().map(VciLifeCycleTranEvent::classFullName).collect(Collectors.toList()));
|
}else{
|
lineDTO.setEventDTOList(new ArrayList<String>());
|
}
|
lineCount ++;
|
lineDTOList.add(lineDTO);
|
}
|
}
|
}
|
lifeCycleDTO.setLineDTOList(lineDTOList);
|
lifeCycleDTO.setClassFullName(className);
|
lifeCycleDTOMap.put(lifeCycleDTO.getId().toLowerCase().trim(),lifeCycleDTO);
|
}
|
}
|
|
|
}
|
