java动态执行代码

@Service
public class OrderStratifyNewService {

    @Autowired
    private OrderStratifyApiConfigService orderStratifyApiConfigService;

    @Autowired
    private ExtOrderStratifyNewTagConfigDao extOrderStratifyNewTagConfigDao;

    @Autowired
    private OrderStratifyNewServiceAsync orderStratifyNewServiceAsync;


    public OrderStratifyResponse getOrderStratifyRankNew(OrderStratifyRequest request) {

        OrderStratifyResponse response = new OrderStratifyResponse();
        Map<String, String> logTag = new HashMap<>();
        logTag.put("orderId", request.getOrderId());
        log.info("OrderStratifyNewService.getOrderStratifyRankNew", JacksonJsonSerializer.INSTANCE.serialize(request), logTag);

        try {

            OrderStratifyApiConfigService.OrderStratifyApiConfigEntity config = Optional.ofNullable(orderStratifyApiConfigService.getConfigList()).orElse(new ArrayList<>())
                    .stream().filter(f -> Objects.equals(request.getBusinessLine(), f.getBusinessLine())
                            && Objects.equals(request.getBusinessType(), f.getBusinessType())
                            && Objects.equals(request.getPartnerCode(), f.getPartnerCode())).findFirst().orElse(null);
            if (config == null || StringUtils.isBlank(config.getSoaUrl())) {
                response.setResultCode(0);
                response.setResultMsg("未配置API接口");
                return response;
            }

            Pair<Boolean, Map<String, Object>> mapResult = this.getParamMap(config.getParamList(), request);
            if (!mapResult.getKey()) {
                response.setResultCode(0);
                response.setResultMsg("API接口参数配置异常");
                return response;
            }

            Map<String, Object> paramMap = mapResult.getValue();

            String soaRes = HttpUtils.doPost(config.getSoaUrl(), JacksonJsonSerializer.INSTANCE.serialize(paramMap));
            if (StringUtils.isBlank(soaRes)) {
                response.setResultCode(0);
                response.setResultMsg("API接口调用异常");
                return response;
            }

            ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
            ScriptEngine scriptEngine = scriptEngineManager.getEngineByName("js");

            //checkFlag res 常量
            String script = "var tagCheck=false; var res = " + soaRes + ";";
            scriptEngine.eval(script);

            //校验soa请求是否成功
            if (StringUtils.isNotBlank(config.getRuleScript())) {
                Object soaCheckResult = scriptEngine.eval(config.getRuleScript());
                if (!Objects.equals(soaCheckResult, true)) {
                    response.setResultCode(0);
                    response.setResultMsg("API接口数据校验失败");
                    return response;
                }
            }

            List<OrderStratifyNewTagConfig> tagList = extOrderStratifyNewTagConfigDao.getTagList(request.getBusinessLine(), request.getBusinessType(), request.getPartnerCode());

            List<StratifyTagEntity> resultList = new ArrayList<>();
            for (OrderStratifyNewTagConfig tagConfig : tagList) {
                StratifyTagEntity tag = this.checkStratifyTag(scriptEngine, tagConfig, logTag);
                resultList.add(tag);
            }

            int score = resultList.stream().filter(f -> Objects.equals(f.getCheckResult(), true) && f.getScore() != null && f.getScore() > 0)
                    .mapToInt(StratifyTagEntity::getScore).sum();

            response.setResultMsg(JacksonJsonSerializer.INSTANCE.serialize(resultList));
            response.setScore(score);
            response.setResultCode(1);

            //TODO 记录埋点报表数据
            orderStratifyNewServiceAsync.orderStratifyLogAsync(request,response,resultList);

        } catch (Exception exception) {
            log.error("OrderStratifyNewService.getOrderStratifyRankNew", exception, logTag);
        } finally {
            log.info("OrderStratifyNewService.getOrderStratifyRankNew", JacksonJsonSerializer.INSTANCE.serialize(response), logTag);
        }

        return response;
    }

    private StratifyTagEntity checkStratifyTag(ScriptEngine scriptEngine, OrderStratifyNewTagConfig tagConfig, Map<String, String> logTag) {
        StratifyTagEntity stratifyTagEntity = new StratifyTagEntity();
        stratifyTagEntity.setCheckResult(false);
        stratifyTagEntity.setScore(tagConfig.getScore());
        stratifyTagEntity.setTagName(tagConfig.getTagName());
        if (StringUtils.isBlank(tagConfig.getScriptRule())) {
            stratifyTagEntity.setErrorMessage("规则为空");
            return stratifyTagEntity;
        }

        String script = "tagCheck=false;";
        try {
            Object result = scriptEngine.eval(script + tagConfig.getScriptRule());
            if (Objects.equals(result, true)) {
                stratifyTagEntity.setCheckResult(true);
            }
        } catch (Exception exception) {
            stratifyTagEntity.setCheckResult(false);
            stratifyTagEntity.setErrorMessage(exception.getMessage());
            log.error("OrderStratifyService.checkStratifyTag", exception, logTag);
        }
        return stratifyTagEntity;
    }

    /**
     * 获取soa请求参数
     */
    private Pair<Boolean, Map<String, Object>> getParamMap(List<OrderStratifyApiConfigService.ParamEntity> paramList, OrderStratifyRequest request) {
        Map<String, Object> params = new HashMap<>();
        //无需传参数
        if (paramList == null || paramList.isEmpty()) {
            return new Pair<>(true, params);
        }

        for (OrderStratifyApiConfigService.ParamEntity paramItem : paramList) {
            if (StringUtils.isBlank(paramItem.getPName())
                    || paramItem.getPValue() == null
                    || paramItem.getPType() == null
                    || !Arrays.asList(1, 2).contains(paramItem.getPType())) {
                //参数校验失败
                return new Pair<>(false, params);
            }

            //静态参数处理
            if (paramItem.getPType().equals(1)) {
                params.put(paramItem.getPName(), paramItem.getPValue());
            } else {
                Pair<Boolean, Object> fieldResult = this.getParams(request, paramItem.getPValue().toString());
                if (fieldResult.getKey()) {
                    params.put(paramItem.getPName(), fieldResult.getValue());
                } else {
                    //参数校验失败
                    return new Pair<>(false, params);
                }
            }
        }

        return new Pair<>(true, params);
    }

    //获取动态字段参数
    private Pair<Boolean, Object> getParams(OrderStratifyRequest request, String paramName) {
        Field[] fields = request.getClass().getDeclaredFields();
        for (Field field : fields) {
            if (field.getName().toLowerCase().equals(paramName.toLowerCase())) {
                try {
                    field.setAccessible(true);
                    Object v = field.get(request);//获取字段值
                    if (v != null) {
                        return new Pair<>(true, v);
                    }
                } catch (IllegalAccessException e) {
                    log.error("OrderStratifyService.getParams", e);
                    return new Pair<>(false, "");
                }
            }
        }
        return new Pair<>(false, "");
    }

}