package com.dy.common.mw.protocol;
|
|
import java.util.Collection;
|
import java.util.HashMap;
|
import java.util.Set;
|
|
import com.dy.common.util.NumUtil;
|
import org.apache.logging.log4j.LogManager;
|
import org.apache.logging.log4j.Logger;
|
import org.reflections.Reflections;
|
|
/**
|
* 扫描：
|
* 协议驱动类
|
* 上行数据完整性检查类（断包粘包检查）
|
* 上线数据（连接后第一包数据）处理类（识别协议及终端地址）
|
* @author Administrator
|
*
|
*/
|
@SuppressWarnings("unused")
|
public class AnnotationScan {
|
|
private static final Logger log = LogManager.getLogger(AnnotationScan.class);
|
|
private static String scanRootPackage = "com.dy.common.mw.protocol" ;
|
|
private static AnnotationScan instance ;
|
|
private AnnotationScan(){
|
}
|
|
/**
|
* 得到唯一实例，
|
* 并在生成唯一实例时，扫描注解类
|
* @return AnnotationScan
|
* @throws Exception 异常
|
*/
|
public static AnnotationScan getIntance()throws Exception{
|
if(instance == null){
|
instance = new AnnotationScan() ;
|
instance.scanEndpointAnnotations();
|
}
|
return instance ;
|
}
|
|
/**
|
* 扫描出注解的类
|
* @throws ClassNotFoundException 异常
|
* @throws Exception 异常
|
*/
|
private void scanEndpointAnnotations() throws Exception {
|
Reflections reflections = new Reflections(scanRootPackage); // 指定包名
|
Set<Class<?>> driverClasses = reflections.getTypesAnnotatedWith(AnnotationDriver.class);
|
if (driverClasses != null && driverClasses.size() > 0) {
|
String protocolName;
|
int priority;
|
int onLineDataMinLength;
|
int headMinLength;
|
|
HashMap<String, AnnotationDriverVo> driverMap = ProtocolCache.getDriverMap();
|
HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap = ProtocolCache.getPrefixedDataAvailableMap();
|
HashMap<String, AnnotationOnLineVo> onLineMap = ProtocolCache.getOnLineMap();
|
|
for (Class<?> clazz : driverClasses) {
|
AnnotationDriver ann = clazz.getAnnotation(AnnotationDriver.class);
|
if (ann != null) {
|
if (ann.enable()) {
|
protocolName = ann.name();
|
if (!(protocolName.trim().equals(""))) {
|
if (driverMap.containsKey(protocolName)) {
|
throw new Exception("严重错误，协议驱动(名称)" + protocolName + "出现了重复注解！");
|
}
|
driverMap.put(protocolName, new AnnotationDriverVo(clazz));
|
} else {
|
throw new Exception("严重错误，协议驱动名称注解值为空字符串");
|
}
|
}
|
}
|
}
|
|
Set<Class<?>> prefixedClass = reflections.getTypesAnnotatedWith(AnnotationPrefixedDataAvailable.class);
|
for (Class<?> clazz : prefixedClass) {
|
AnnotationPrefixedDataAvailable ann = clazz.getAnnotation(AnnotationPrefixedDataAvailable.class);
|
if (ann != null) {
|
if (ann.enable()) {
|
protocolName = ann.protocolName();
|
if (!(protocolName.trim().equals(""))) {
|
if (prefixedDataAvailableMap.containsKey(protocolName)) {
|
throw new Exception("严重错误， 上行数据完整性检查所配协议驱动" + protocolName + "出现了重复注解！");
|
}
|
} else {
|
throw new Exception("严重错误，上行数据完整性检查所配协议驱动注解值为空字符串");
|
}
|
|
priority = ann.priority();
|
if (priority == 0) {
|
throw new Exception("严重错误， 上行数据完整性检查所配优先级注解不能为0");
|
}
|
if (isRepeatPrefixedDataAvailablePriority(priority, prefixedDataAvailableMap)) {
|
throw new Exception("严重错误， 上行数据完整性检查所配优先级注解(priority)数值" + priority + "重复");
|
}
|
|
onLineDataMinLength = ann.onLineDataMinLength();
|
/*气象协议为0
|
if(onLineDataMinLength == 0){
|
throw new Exception("严重错误， 上行数据完整性检查所配上线数据最小长度注解不能为0") ;
|
}
|
*/
|
headMinLength = ann.headMinLength();
|
/*气象协议为0
|
if(headMinLength == 0){
|
throw new Exception("严重错误， 上行数据完整性检查所配上报数据的头部最小长度注解不能为0") ;
|
}
|
*/
|
prefixedDataAvailableMap.put(protocolName, new AnnotationPrefixedDataAvailableVo(clazz, protocolName, priority, onLineDataMinLength, headMinLength, ProtocolConstant.errorMaxLength));
|
}
|
}
|
}
|
|
Set<Class<?>> onLineClass = reflections.getTypesAnnotatedWith(AnnotationOnLine.class);
|
for (Class<?> clazz : onLineClass) {
|
AnnotationOnLine ann = clazz.getAnnotation(AnnotationOnLine.class);
|
if (ann != null) {
|
if (ann.enable()) {
|
protocolName = ann.protocolName();
|
if (!(protocolName.trim().equals(""))) {
|
if (onLineMap.containsKey(protocolName)) {
|
throw new Exception("严重错误， 上线数据分析所配协议驱动" + protocolName + "出现了重复注解！");
|
}
|
} else {
|
throw new Exception("严重错误，上线数据分析所配协议驱动注解值为空字符串");
|
}
|
|
priority = ann.priority();
|
if (priority == 0) {
|
throw new Exception("严重错误， 上线数据分析所配优先级注解不能为0");
|
}
|
if (isRepeatOnLinePriority(priority, onLineMap)) {
|
throw new Exception("严重错误， 上线数据分析所配优先级注解(priority)数值" + priority + "重复");
|
}
|
|
onLineMap.put(protocolName, new AnnotationOnLineVo(clazz, protocolName, priority));
|
}
|
}
|
}
|
|
//进行验证
|
String error = this.hasErrorInDriver(driverMap);
|
if (error != null) {
|
throw new Exception(error);
|
} else {
|
error = this.hasErrorInPrefixedDataAvailable(driverMap, prefixedDataAvailableMap);
|
if (error != null) {
|
throw new Exception(error);
|
} else {
|
error = this.hasErrorInOnLine(driverMap, onLineMap);
|
if (error != null) {
|
throw new Exception(error);
|
}
|
}
|
}
|
} else {
|
throw new Exception("严重错误， 扫描协议相关注解所得到类型集合为空，扫描根路径是" + scanRootPackage);
|
}
|
}
|
|
/**
|
* 检查优先级重复
|
* @param priority 优先级
|
* @return 结果
|
*/
|
private boolean isRepeatPrefixedDataAvailablePriority(int priority, HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap){
|
Collection<AnnotationPrefixedDataAvailableVo> col = prefixedDataAvailableMap.values();
|
for(AnnotationPrefixedDataAvailableVo vo : col){
|
if(vo.priority == priority){
|
return true ;
|
}
|
}
|
return false ;
|
}
|
/**
|
* 检查优先级重复
|
* @param priority 优先级
|
* @return 结果
|
*/
|
private boolean isRepeatOnLinePriority(int priority, HashMap<String, AnnotationOnLineVo> onLineMap){
|
Collection<AnnotationOnLineVo> col = onLineMap.values();
|
for(AnnotationOnLineVo vo : col){
|
if(vo.priority == priority){
|
return true ;
|
}
|
}
|
return false ;
|
}
|
|
private String hasErrorInDriver(HashMap<String, AnnotationDriverVo> driverMap){
|
if(driverMap.size() == 0){
|
return "严重错误，未注解任何协议驱动" ;
|
}
|
return null ;
|
}
|
|
private String hasErrorInPrefixedDataAvailable(HashMap<String, AnnotationDriverVo> driverMap,
|
HashMap<String, AnnotationPrefixedDataAvailableVo> prefixedDataAvailableMap){
|
Collection<AnnotationPrefixedDataAvailableVo> col = prefixedDataAvailableMap.values();
|
for(AnnotationPrefixedDataAvailableVo vo : col){
|
if(!driverMap.containsKey(vo.protocolName)){
|
return "严重错误，上行数据完整性检查所配驱动名称(" + vo.protocolName + ")在协议驱动中未配置" ;
|
}
|
}
|
|
int[] prioritys = new int[prefixedDataAvailableMap.size()] ;
|
int count = 0 ;
|
col = prefixedDataAvailableMap.values();
|
for(AnnotationPrefixedDataAvailableVo vo : col){
|
prioritys[count++] = vo.priority ;
|
}
|
NumUtil.sort(prioritys, true) ;
|
|
int firstPriority = prioritys[0] ;
|
if(ProtocolConstant.firstPriority != firstPriority){
|
return "严重错误，上行数据完整性检查所配优先级必须从 " + ProtocolConstant.firstPriority + " 开始" ;
|
}
|
int prePriority = prioritys[0] ;
|
int nextPriority;
|
if(prioritys.length > 1){
|
for(int i = 1 ; i < prioritys.length; i++){
|
nextPriority = prioritys[i] ;
|
if(nextPriority - prePriority != 1){
|
return "严重错误，上行数据完整性检查所配各个优先级必须相差1" ;
|
}else{
|
prePriority = nextPriority ;
|
}
|
}
|
}
|
return null ;
|
}
|
|
private String hasErrorInOnLine(HashMap<String, AnnotationDriverVo> driverMap,
|
HashMap<String, AnnotationOnLineVo> onLineMap){
|
Collection<AnnotationOnLineVo> col = onLineMap.values();
|
for(AnnotationOnLineVo vo : col){
|
if(!driverMap.containsKey(vo.protocolName)){
|
return "严重错误，上线数据分析所配驱动名称(" + vo.protocolName + ")在协议驱动中未配置" ;
|
}
|
}
|
|
int[] prioritys = new int[onLineMap.size()] ;
|
int count = 0 ;
|
col = onLineMap.values();
|
for(AnnotationOnLineVo vo : col){
|
prioritys[count++] = vo.priority ;
|
}
|
NumUtil.sort(prioritys, true) ;
|
|
int firstPriority = prioritys[0] ;
|
if(ProtocolConstant.firstPriority != firstPriority){
|
return "严重错误，上线数据分析所配优先级必须从 " + ProtocolConstant.firstPriority + " 开始" ;
|
}
|
int prePriority = prioritys[0] ;
|
int nextPriority;
|
if(prioritys.length > 1){
|
for(int i = 1 ; i < prioritys.length; i++){
|
nextPriority = prioritys[i] ;
|
if(nextPriority - prePriority != 1){
|
return "严重错误，上线数据分析所配各个优先级必须相差1" ;
|
}else{
|
prePriority = nextPriority ;
|
}
|
}
|
}
|
return null ;
|
}
|
}
|
