FlinkConfig配置类

import cn.hutool.cache.CacheUtil;
import cn.hutool.cache.impl.TimedCache;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.flinkRisk.Main;
import com.flinkRisk.cache.AlarmTypeCache;
import com.flinkRisk.cache.GroupCache;
import com.flinkRisk.handler.impl.NoTrafficAtNightAlarmHandler;
import com.flinkRisk.handler.impl.speedLimit.SpeedLimitAnalysis;
import com.flinkRisk.handler.impl.speedLimit.SpeedLimitAnalysisYb;
import com.flinkRisk.manager.HandlerManager;
import com.flinkRisk.model.PointInfo;
import com.flinkRisk.model.RiskRule;
import com.flinkRisk.model.VehicleGroup;
import com.flinkRisk.process.BaseBroadcastProcessFunction;
import com.flinkRisk.rule.*;
import com.flinkRisk.utils.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.flink.api.java.utils.ParameterTool;
import org.apache.flink.streaming.api.functions.source.SourceFunction;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.math.BigDecimal;
import java.sql.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 配置类
 *
 * @author
 */
@Slf4j
public class FlinkConfig {
	private static ParameterTool parameterTool;
    // 缓存区域编号
    public static TimedCache<Long, String> areaMap = CacheUtil.newTimedCache(60 * 60 * 1000);

    /**
     * 缓存粤标普通规则
     */
    public static Map<String,GeneralRule> generalRuleMap = new ConcurrentHashMap<>();

    /**
     * 疲劳规则类型
     */
    public static final String faType = "15";
    /**
     * 夜间禁行规则类型
     */
    public static final String niType= "3";
    /**
     * 平台超速规则类型
     */
    public static final String ovType = "26";

    /**
     * 是否启用风险规则
     */
    public static final String isStarRisk = "isStartRisk";
	
	 /**
     * 1、初始化 alarmDefine 缓存 2、初始化配置缓存 3、初始化redis
     *
     * @param pt
     */
    public static void init(ParameterTool pt) {
		parameterTool = pt;
        //初始化配置库连接
        String url = parameterTool.getRequired("mysql.url");
        String user = parameterTool.getRequired("mysql.user");
        String passwd = parameterTool.getRequired("mysql.password");
        Connection connection = getConnection(url, user, passwd);
        //获取报警定义
        initAlarmDefine(connection);

        /**
         * 初始化车组缓存
         */
        initGroupCache(true,parameterTool,null);

        //初始化道路等级限速车辆类型
//        String vehicleType = null;
        // 初始化粤标车辆类型
        String vehicleTypeYb = null;
         try {
//            vehicleType = new String(FlinkConfig.getStr("vehicleType").getBytes("ISO-8859-1"),"utf-8");
            vehicleTypeYb = new String(FlinkConfig.getStr("vehicleTypeYb").getBytes("ISO-8859-1"),"utf-8");

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        log.info("vehicleTypeYb：{}",vehicleTypeYb);
        SpeedLimitAnalysisYb.initCarTypeMapYb(vehicleTypeYb);

        NoTrafficAtNightAlarmHandler.initCarTypeMapNoTraffic(vehicleTypeYb);

        // 初始化三个地址接口
		SpeedLimitAnalysisYb.initMapApi(FlinkConfig.getStr("userFromAddr"));
        // 初始化报警类型对应的十六进制
        EnglishAlarmToHexUtil.initAlarmtypeToHex();
        //处理器配置
        try {
            if (!Main.localMode) {
                HandlerManager.initHandlers(FlinkConfig.getStr("handlers"));
            } else {
                HandlerManager.initHandlers(Main.biz);
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
        try {
            connection.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
	}
	private static void initAlarmDefine(Connection connection) {
        //获取报警定义信息，只获取一次
        log.info("获取报警定义");
        try {
            PreparedStatement ps = connection.prepareStatement("select * from  tbl_alarmdefine");
            ResultSet rs = ps.executeQuery();
            //初始化配置信息
            AlarmTypeCache.init(rs);
            rs.close();
            ps.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     public static String getStr(String key) {

        return parameterTool.get(key);
    }

    public static Integer getInt(String key) {
        return parameterTool.getInt(key);
    }
    /**
     * 保证在处理数据之前规则优先加载
     *
     * @param parameterTool
     * @param vehicleRule
     * @param groupRule
     */
     public static void initRule(ParameterTool parameterTool, Map<Long, Set<BaseRule>> vehicleRule, Map<Long, Set<BaseRule>> groupRule) {
		String url = parameterTool.getRequired("mysql.url");
        String user = parameterTool.getRequired("mysql.user");
        String passwd = parameterTool.getRequired("mysql.password");
        Connection connection = getConnection(url, user, passwd);

        //更新普通规则
        FlinkConfig.updateGeneralRule(connection, null, vehicleRule, groupRule);
        //更新线路和区域规则
        FlinkConfig.updatePathAndAreaRule(connection, null, vehicleRule, groupRule);
        //更新道路规则
        FlinkConfig.updateRoadRule(connection, null, vehicleRule, groupRule);	
        try {
            connection.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
       
	}
	/**
     * 更新车组缓存
     * @param openInit true算子open时的初始化 false规则流更新
     */
    public static void initGroupCache(Boolean openInit, ParameterTool parameterTool, SourceFunction.SourceContext<BaseRule> ctx) {
    	String url = parameterTool.getRequired("mysql.url");
        String user = parameterTool.getRequired("mysql.user");
        String passwd = parameterTool.getRequired("mysql.password");
        Connection connection = getConnection(url, user, passwd);
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
        	ps = connection.prepareStatement("SQL语句");
            rs = ps.executeQuery();
            VehicleGroup group = null;
            while (rs.next()) {
				group = new VehicleGroup();
                group.setGroupId(rs.getLong("groupId"));
                group.setArea(rs.getString("readdress"));
                group.setParentGroupId(rs.getLong("parentId"));
                group.setGrouptype(rs.getInt("groupAttribute"));
                group.setRuleTheme(888);
                if(ctx!=null){
                    if (group.getGrouptype() ==2) {
                        areaMap.put(group.getGroupId(),group.getArea());
                    }
                    ctx.collect(group);
                }
                if(openInit){
                    if (group.getGrouptype() ==2) {
                        areaMap.put(group.getGroupId(),group.getArea());
                    }
                    GroupCache.addGroupMap(group.getGroupId(), group);
                }
			  }
			  if(openInit){
                GroupCache.buildCompanyGroupMap();
            	}
        	}catch{
        		throwables.printStackTrace();
        	}finally {
            try {
                if(rs!=null){
                    rs.close();
                }
                if(ps!=null){
                    ps.close();
                }
                if(connection!=null){
                    connection.close();
                }
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
     /**
     * 将规则添加进集合
     *
     * @param rule
     * @param vehicleRule
     * @param groupRule
     */
     public static void addRuleMap(BaseRule rule, Map<Long, Set<BaseRule>> vehicleRule, Map<Long, Set<BaseRule>> groupRule) {
        //更新车辆规则
        if ("VEHICLE".equals(rule.getType())) {
            Set<BaseRule> rules = vehicleRule.computeIfAbsent(rule.getGvId(), k -> new HashSet<>());
            rules.add(rule);
        }
        //更新车组规则
        if ("GROUP".equals(rule.getType())) {
            Set<BaseRule> rules = groupRule.computeIfAbsent(rule.getGvId(), k -> new HashSet<>());
            rules.add(rule);
        }
    }
  
}