wxl
/
cloud-server
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat:引擎配置 规则维护

master
Wang XinLong 2024-05-05 16:01:10 +08:00
parent db4ccef58e
commit a3fdadf23c
41 changed files with 1390 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/domain/req/EngineMaintenanceEditReq.java
View File

@ -1,54 +0,0 @@
package com.muyu.engine.domain.req;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.experimental.SuperBuilder;
import io.swagger.annotations.*;
import com.muyu.common.core.web.domain.BaseEntity;
/**
* 引擎维护对象 engine_maintenance
*
* @author muyu
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineMaintenanceEditReq", description = "引擎维护")
public class EngineMaintenanceEditReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 规则名称 */
@ApiModelProperty(name = "规则名称", value = "规则名称")
private String name;
/** 规则类型 1-规则模板 2-自定义模板 */
@ApiModelProperty(name = "规则类型 1-规则模板 2-自定义模板", value = "规则类型 1-规则模板 2-自定义模板")
private String type;
/** 规则级别 1-数据集 2-记录 3-数据字段 */
@ApiModelProperty(name = "规则级别 1-数据集 2-记录 3-数据字段", value = "规则级别 1-数据集 2-记录 3-数据字段")
private String level;
/** 引擎编码 */
@ApiModelProperty(name = "引擎编码", value = "引擎编码")
private String code;
/** 是否激活 0-未激活 1-已激活 */
@ApiModelProperty(name = "是否激活 0-未激活 1-已激活", value = "是否激活 0-未激活 1-已激活")
private String isActivate;
/** 规则状态 0-正常 1-停用 */
@ApiModelProperty(name = "规则状态 0-正常 1-停用", value = "规则状态 0-正常 1-停用")
private String status;
/** 规则描述 */
@ApiModelProperty(name = "规则描述", value = "规则描述")
private String description;
}

34
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/domain/req/EngineMaintenanceQueryReq.java
View File

@ -1,34 +0,0 @@
package com.muyu.engine.domain.req;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.experimental.SuperBuilder;
import io.swagger.annotations.*;
import com.muyu.common.core.web.domain.BaseEntity;
/**
* 引擎维护对象 engine_maintenance
*
* @author muyu
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineMaintenanceQueryReq", description = "引擎维护")
public class EngineMaintenanceQueryReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 规则名称 */
@ApiModelProperty(name = "规则名称", value = "规则名称")
private String name;
/** 规则类型 1-规则模板 2-自定义模板 */
@ApiModelProperty(name = "规则类型 1-规则模板 2-自定义模板", value = "规则类型 1-规则模板 2-自定义模板")
private String type;
}

66
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/domain/req/EngineMaintenanceSaveReq.java
View File

@ -1,66 +0,0 @@
package com.muyu.engine.domain.req;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.experimental.SuperBuilder;
import io.swagger.annotations.*;
import com.muyu.common.core.web.domain.BaseEntity;
/**
* 引擎维护对象 engine_maintenance
*
* @author muyu
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineMaintenanceSaveReq", description = "引擎维护")
public class EngineMaintenanceSaveReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 主键 */
@ApiModelProperty(name = "主键", value = "主键")
private Long id;
/** 规则名称 */
@ApiModelProperty(name = "规则名称", value = "规则名称")
private String name;
/** 规则类型 1-规则模板 2-自定义模板 */
@ApiModelProperty(name = "规则类型 1-规则模板 2-自定义模板", value = "规则类型 1-规则模板 2-自定义模板")
private String type;
/** 规则级别 1-数据集 2-记录 3-数据字段 */
@ApiModelProperty(name = "规则级别 1-数据集 2-记录 3-数据字段", value = "规则级别 1-数据集 2-记录 3-数据字段")
private String level;
/** 引擎编码 */
@ApiModelProperty(name = "引擎编码", value = "引擎编码")
private String code;
/** 是否激活 0-未激活 1-已激活 */
@ApiModelProperty(name = "是否激活 0-未激活 1-已激活", value = "是否激活 0-未激活 1-已激活")
private String isActivate;
/** 规则状态 0-正常 1-停用 */
@ApiModelProperty(name = "规则状态 0-正常 1-停用", value = "规则状态 0-正常 1-停用")
private String status;
/** 规则描述 */
@ApiModelProperty(name = "规则描述", value = "规则描述")
private String description;
}

22
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/service/EngineMaintenanceService.java
View File

@ -1,22 +0,0 @@
package com.muyu.engine.service;
import java.util.List;
import com.muyu.engine.domain.EngineMaintenance;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* 引擎维护Service接口
*
* @author muyu
* @date 2024-05-02
*/
public interface EngineMaintenanceService extends IService<EngineMaintenance> {
/**
* 查询引擎维护列表
*
* @param engineMaintenance 引擎维护
* @return 引擎维护集合
*/
public List<EngineMaintenance> list(EngineMaintenance engineMaintenance);
}

54
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/service/impl/EngineMaintenanceServiceImpl.java
View File

@ -1,54 +0,0 @@
package com.muyu.engine.service.impl;
import java.util.List;
import com.muyu.common.core.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import com.muyu.engine.mapper.EngineMaintenanceMapper;
import com.muyu.engine.domain.EngineMaintenance;
import com.muyu.engine.service.EngineMaintenanceService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
/**
* 引擎维护Service业务层处理
*
* @author muyu
* @date 2024-05-02
*/
@Slf4j
@Service
public class EngineMaintenanceServiceImpl extends ServiceImpl<EngineMaintenanceMapper, EngineMaintenance> implements EngineMaintenanceService {
/**
* 查询引擎维护列表
*
* @param engineMaintenance 引擎维护
* @return 引擎维护
*/
@Override
public List<EngineMaintenance> list(EngineMaintenance engineMaintenance) {
LambdaQueryWrapper<EngineMaintenance> queryWrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotEmpty(engineMaintenance.getName())){
queryWrapper.like(EngineMaintenance::getName, engineMaintenance.getName());
}
if (StringUtils.isNotEmpty(engineMaintenance.getType())){
queryWrapper.eq(EngineMaintenance::getType, engineMaintenance.getType());
}
return list(queryWrapper);
}
}

2
muyu-modules/muyu-engine/src/main/resources/banner.txt
View File

@ -1,2 +0,0 @@
Spring Boot Version: ${spring-boot.version}
Spring Application Name: ${spring.application.name}

26
muyu-modules/muyu-engine/src/main/resources/mapper/engine/EngineMaintenanceMapper.xml
View File

@ -1,26 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.muyu.engine.mapper.EngineMaintenanceMapper">
<resultMap type="com.muyu.engine.domain.EngineMaintenance" id="EngineMaintenanceResult">
<result property="id" column="id" />
<result property="name" column="name" />
<result property="type" column="type" />
<result property="level" column="level" />
<result property="code" column="code" />
<result property="isActivate" column="is_activate" />
<result property="status" column="status" />
<result property="description" column="description" />
<result property="remark" column="remark" />
<result property="createBy" column="create_by" />
<result property="createTime" column="create_time" />
<result property="updateBy" column="update_by" />
<result property="updateTime" column="update_time" />
</resultMap>
<sql id="selectEngineMaintenanceVo">
select id, name, type, level, code, is_activate, status, description, remark, create_by, create_time, update_by, update_time from engine_maintenance
</sql>
</mapper>

29
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/pom.xml 100644
View File

@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>muyu-rule_engine</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>muyu-rule_engine-common</artifactId>
<description>
ruoyi-rule_engine-common规则引擎公共模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- MuYu Common Core-->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>muyu-common-core</artifactId>
</dependency>
</dependencies>
</project>

99
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/EngineConfig.java 100644
View File

@ -0,0 +1,99 @@
package com.muyu.ruleEngine.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.muyu.common.core.annotation.Excel;
import com.muyu.common.core.web.domain.BaseEntity;
import com.muyu.ruleEngine.domain.req.EngineConfigEditReq;
import com.muyu.ruleEngine.domain.req.EngineConfigQueryReq;
import com.muyu.ruleEngine.domain.req.EngineConfigSaveReq;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.Date;
import java.util.function.Supplier;
/**
* 引擎规则配置对象 engine_config
*
* @author CHX
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@TableName("engine_config")
@EqualsAndHashCode(callSuper = true)
@ApiModel(value = "EngineConfig", description = "引擎规则配置")
public class EngineConfig extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 编号 */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(name = "编号", value = "编号")
private Long id;
/** 版本编码 */
@Excel(name = "版本编码")
@ApiModelProperty(name = "版本编码", value = "版本编码", required = true)
private String versionCode;
/** 规则内容 */
@Excel(name = "规则内容")
@ApiModelProperty(name = "规则内容", value = "规则内容", required = true)
private String ruleContent;
/** 引擎维护编号 */
@Excel(name = "引擎维护编号")
@ApiModelProperty(name = "引擎维护编号", value = "引擎维护编号", required = true)
private Long engineMaintenanceId;
/**
* 查询构造器
*/
public static EngineConfig queryBuild( EngineConfigQueryReq engineConfigQueryReq){
return EngineConfig.builder()
.versionCode(engineConfigQueryReq.getVersionCode())
.ruleContent(engineConfigQueryReq.getRuleContent())
.engineMaintenanceId(engineConfigQueryReq.getEngineMaintenanceId())
.build();
}
/**
* 添加构造器
*/
public static EngineConfig saveBuild(EngineConfigSaveReq engineConfigSaveReq,Supplier<String> createBy){
return EngineConfig.builder()
.versionCode(engineConfigSaveReq.getVersionCode())
.ruleContent(engineConfigSaveReq.getRuleContent())
.engineMaintenanceId(engineConfigSaveReq.getEngineMaintenanceId())
.remark(engineConfigSaveReq.getRemark())
.createBy(createBy.get())
.createTime(new Date())
.build();
}
/**
* 修改构造器
*/
public static EngineConfig editBuild(Long id, EngineConfigEditReq engineConfigEditReq, Supplier<String> updateBy){
return EngineConfig.builder()
.id(id)
.versionCode(engineConfigEditReq.getVersionCode())
.ruleContent(engineConfigEditReq.getRuleContent())
.engineMaintenanceId(engineConfigEditReq.getEngineMaintenanceId())
.remark(engineConfigEditReq.getRemark())
.updateBy(updateBy.get())
.updateTime(new Date())
.build();
}
}

91
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/domain/EngineMaintenance.java → muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/EngineMaintenance.java
View File

@ -1,24 +1,28 @@
package com.muyu.engine.domain;
package com.muyu.ruleEngine.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.muyu.common.core.annotation.Excel;
import com.muyu.common.core.web.domain.BaseEntity;
import com.muyu.ruleEngine.domain.req.EngineMaintenanceEditReq;
import com.muyu.ruleEngine.domain.req.EngineMaintenanceQueryReq;
import com.muyu.ruleEngine.domain.req.EngineMaintenanceSaveReq;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;
import lombok.experimental.SuperBuilder;
import io.swagger.annotations.*;
import com.muyu.common.core.annotation.Excel;
import com.muyu.engine.domain.req.EngineMaintenanceQueryReq;
import com.muyu.engine.domain.req.EngineMaintenanceSaveReq;
import com.muyu.engine.domain.req.EngineMaintenanceEditReq;
import com.muyu.common.core.web.domain.BaseEntity;
import java.util.Date;
import java.util.function.Supplier;
/**
* 引擎维护对象 engine_maintenance
*
* @author muyu
* @author CHX
* @date 2024-05-02
*/
@Data
@ -32,46 +36,41 @@ public class EngineMaintenance extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 主键 */
/** 编号 */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(name = "主键", value = "主键")
@ApiModelProperty(name = "编号", value = "编号")
private Long id;
/** 规则名称 */
@Excel(name = "规则名称")
@ApiModelProperty(name = "规则名称", value = "规则名称")
/** 名称 */
@Excel(name = "名称")
@ApiModelProperty(name = "名称", value = "名称")
private String name;
/** 规则类型 1-规则模板 2-自定义模板 */
@Excel(name = "规则类型")
@ApiModelProperty(name = "规则类型 1-规则模板 2-自定义模板", value = "规则类型 1-规则模板 2-自定义模板")
private String type;
/** 类型 */
@Excel(name = "类型")
@ApiModelProperty(name = "类型", value = "类型")
private Long type;
/** 规则级别 1-数据集 2-记录 3-数据字段 */
@Excel(name = "规则级别")
@ApiModelProperty(name = "规则级别 1-数据集 2-记录 3-数据字段", value = "规则级别 1-数据集 2-记录 3-数据字段")
private String level;
/** 作用域 */
@Excel(name = "作用域")
@ApiModelProperty(name = "作用域", value = "作用域")
private Integer scope;
/** 引擎编码 */
@Excel(name = "引擎编码")
@ApiModelProperty(name = "引擎编码", value = "引擎编码")
private String code;
private String engineCode;
/** 是否激活 0-未激活 1-已激活 */
/** 是否激活 */
@Excel(name = "是否激活")
@ApiModelProperty(name = "是否激活 0-未激活 1-已激活", value = "是否激活 0-未激活 1-已激活")
@ApiModelProperty(name = "是否激活", value = "是否激活")
private String isActivate;
/** 规则状态 0-正常 1-停用 */
@Excel(name = "规则状态")
@ApiModelProperty(name = "规则状态 0-正常 1-停用", value = "规则状态 0-正常 1-停用")
/** 状态 */
@Excel(name = "状态")
@ApiModelProperty(name = "状态", value = "状态")
private String status;
/** 规则描述 */
@Excel(name = "规则描述")
@ApiModelProperty(name = "规则描述", value = "规则描述")
private String description;
/**
* 查询构造器
*/
@ -79,38 +78,44 @@ public class EngineMaintenance extends BaseEntity {
return EngineMaintenance.builder()
.name(engineMaintenanceQueryReq.getName())
.type(engineMaintenanceQueryReq.getType())
.scope(engineMaintenanceQueryReq.getScope())
.engineCode(engineMaintenanceQueryReq.getEngineCode())
.isActivate(engineMaintenanceQueryReq.getIsActivate())
.status(engineMaintenanceQueryReq.getStatus())
.build();
}
/**
* 添加构造器
*/
public static EngineMaintenance saveBuild(EngineMaintenanceSaveReq engineMaintenanceSaveReq){
public static EngineMaintenance saveBuild(EngineMaintenanceSaveReq engineMaintenanceSaveReq,Supplier<String> createBy){
return EngineMaintenance.builder()
.name(engineMaintenanceSaveReq.getName())
.type(engineMaintenanceSaveReq.getType())
.level(engineMaintenanceSaveReq.getLevel())
.code(engineMaintenanceSaveReq.getCode())
.scope(engineMaintenanceSaveReq.getScope())
.engineCode(engineMaintenanceSaveReq.getEngineCode())
.isActivate(engineMaintenanceSaveReq.getIsActivate())
.status(engineMaintenanceSaveReq.getStatus())
.description(engineMaintenanceSaveReq.getDescription())
.build();
.createBy(createBy.get())
.createTime(new Date())
.build();
}
/**
* 修改构造器
*/
public static EngineMaintenance editBuild(Long id, EngineMaintenanceEditReq engineMaintenanceEditReq){
public static EngineMaintenance editBuild(Long id, EngineMaintenanceEditReq engineMaintenanceEditReq, Supplier<String> updateBy){
return EngineMaintenance.builder()
.id(id)
.name(engineMaintenanceEditReq.getName())
.type(engineMaintenanceEditReq.getType())
.level(engineMaintenanceEditReq.getLevel())
.code(engineMaintenanceEditReq.getCode())
.scope(engineMaintenanceEditReq.getScope())
.engineCode(engineMaintenanceEditReq.getEngineCode())
.isActivate(engineMaintenanceEditReq.getIsActivate())
.status(engineMaintenanceEditReq.getStatus())
.description(engineMaintenanceEditReq.getDescription())
.build();
.updateBy(updateBy.get())
.updateTime(new Date())
.build();
}
}

23
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/model/TestData.java 100644
View File

@ -0,0 +1,23 @@
package com.muyu.ruleEngine.domain.model;
import lombok.Data;
import java.util.List;
/**
* 测试数据
* @ClassName TestData
* @author CHX
* @Date 2024/5/3 16:13
*/
@Data
public class TestData {
/**
* 引擎配置编号
*/
private Long id;
/**
* 测试数据集合
*/
private List<String> list;
}

38
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/req/EngineConfigEditReq.java 100644
View File

@ -0,0 +1,38 @@
package com.muyu.ruleEngine.domain.req;
import com.muyu.common.core.web.domain.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 引擎规则配置对象 engine_config
*
* @author CHX
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineConfigEditReq", description = "引擎规则配置")
public class EngineConfigEditReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 版本编码 */
@ApiModelProperty(name = "版本编码", value = "版本编码", required = true)
private String versionCode;
/** 规则内容 */
@ApiModelProperty(name = "规则内容", value = "规则内容", required = true)
private String ruleContent;
/** 引擎维护编号 */
@ApiModelProperty(name = "引擎维护编号", value = "引擎维护编号", required = true)
private Long engineMaintenanceId;
}

38
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/req/EngineConfigQueryReq.java 100644
View File

@ -0,0 +1,38 @@
package com.muyu.ruleEngine.domain.req;
import com.muyu.common.core.web.domain.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 引擎规则配置对象 engine_config
*
* @author CHX
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineConfigQueryReq", description = "引擎规则配置")
public class EngineConfigQueryReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 版本编码 */
@ApiModelProperty(name = "版本编码", value = "版本编码")
private String versionCode;
/** 规则内容 */
@ApiModelProperty(name = "规则内容", value = "规则内容")
private String ruleContent;
/** 引擎维护编号 */
@ApiModelProperty(name = "引擎维护编号", value = "引擎维护编号")
private Long engineMaintenanceId;
}

46
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/req/EngineConfigSaveReq.java 100644
View File

@ -0,0 +1,46 @@
package com.muyu.ruleEngine.domain.req;
import com.muyu.common.core.web.domain.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 引擎规则配置对象 engine_config
*
* @author CHX
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineConfigSaveReq", description = "引擎规则配置")
public class EngineConfigSaveReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 编号 */
@ApiModelProperty(name = "编号", value = "编号")
private Long id;
/** 版本编码 */
@ApiModelProperty(name = "版本编码", value = "版本编码", required = true)
private String versionCode;
/** 规则内容 */
@ApiModelProperty(name = "规则内容", value = "规则内容", required = true)
private String ruleContent;
/** 引擎维护编号 */
@ApiModelProperty(name = "引擎维护编号", value = "引擎维护编号", required = true)
private Long engineMaintenanceId;
}

50
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/req/EngineMaintenanceEditReq.java 100644
View File

@ -0,0 +1,50 @@
package com.muyu.ruleEngine.domain.req;
import com.muyu.common.core.web.domain.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 引擎维护对象 engine_maintenance
*
* @author CHX
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineMaintenanceEditReq", description = "引擎维护")
public class EngineMaintenanceEditReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 名称 */
@ApiModelProperty(name = "名称", value = "名称")
private String name;
/** 类型 */
@ApiModelProperty(name = "类型", value = "类型")
private Long type;
/** 作用域 */
@ApiModelProperty(name = "作用域", value = "作用域")
private Integer scope;
/** 引擎编码 */
@ApiModelProperty(name = "引擎编码", value = "引擎编码")
private String engineCode;
/** 是否激活 */
@ApiModelProperty(name = "是否激活", value = "是否激活")
private String isActivate;
/** 状态 */
@ApiModelProperty(name = "状态", value = "状态")
private String status;
}

50
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/req/EngineMaintenanceQueryReq.java 100644
View File

@ -0,0 +1,50 @@
package com.muyu.ruleEngine.domain.req;
import com.muyu.common.core.web.domain.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 引擎维护对象 engine_maintenance
*
* @author CHX
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineMaintenanceQueryReq", description = "引擎维护")
public class EngineMaintenanceQueryReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 名称 */
@ApiModelProperty(name = "名称", value = "名称")
private String name;
/** 类型 */
@ApiModelProperty(name = "类型", value = "类型")
private Long type;
/** 作用域 */
@ApiModelProperty(name = "作用域", value = "作用域")
private Integer scope;
/** 引擎编码 */
@ApiModelProperty(name = "引擎编码", value = "引擎编码")
private String engineCode;
/** 是否激活 */
@ApiModelProperty(name = "是否激活", value = "是否激活")
private String isActivate;
/** 状态 */
@ApiModelProperty(name = "状态", value = "状态")
private String status;
}

61
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/req/EngineMaintenanceSaveReq.java 100644
View File

@ -0,0 +1,61 @@
package com.muyu.ruleEngine.domain.req;
import com.muyu.common.core.web.domain.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 引擎维护对象 engine_maintenance
*
* @author CHX
* @date 2024-05-02
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@ApiModel(value = "EngineMaintenanceSaveReq", description = "引擎维护")
public class EngineMaintenanceSaveReq extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 编号 */
@ApiModelProperty(name = "编号", value = "编号")
private Long id;
/** 名称 */
@ApiModelProperty(name = "名称", value = "名称")
private String name;
/** 类型 */
@ApiModelProperty(name = "类型", value = "类型")
private Long type;
/** 作用域 */
@ApiModelProperty(name = "作用域", value = "作用域")
private Integer scope;
/** 引擎编码 */
@ApiModelProperty(name = "引擎编码", value = "引擎编码")
private String engineCode;
/** 是否激活 */
@ApiModelProperty(name = "是否激活", value = "是否激活")
private String isActivate;
/** 状态 */
@ApiModelProperty(name = "状态", value = "状态")
private String status;
}

27
muyu-modules/muyu-rule_engine/muyu-rule_engine-common/src/main/java/com/muyu/ruleEngine/domain/resp/EngineConfigScopeResp.java 100644
View File

@ -0,0 +1,27 @@
package com.muyu.ruleEngine.domain.resp;
import lombok.Data;
import lombok.experimental.SuperBuilder;
import java.io.Serializable;
/**
* 规则引擎作用域
* @ClassName RuleEngineScopeResp
* @author CHX
* @Date 2024/5/2 15:05
*/
@Data
@SuperBuilder
public class EngineConfigScopeResp implements Serializable {
private static final long serialVersionUID = 1L;
/** 类型 */
private String type;
/** 名称 */
private String name;
/** 代码 */
private String code;
}

22
muyu-modules/muyu-rule_engine/muyu-rule_engine-remote/pom.xml 100644
View File

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>muyu-rule_engine</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>muyu-rule_engine-remote</artifactId>
<description>
ruoyi-rule_engine-remote规则引擎远调模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>

37
muyu-modules/muyu-engine/pom.xml → muyu-modules/muyu-rule_engine/muyu-rule_engine-server/pom.xml
View File

@ -5,11 +5,14 @@
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>muyu-modules</artifactId>
<artifactId>muyu-rule_engine</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>muyu-engine</artifactId>
<artifactId>muyu-rule_engine-server</artifactId>
<description>
ruoyi-rule_engine-server规则引擎服务模块
</description>
<properties>
<maven.compiler.source>17</maven.compiler.source>
@ -18,13 +21,17 @@
</properties>
<dependencies>
<!-- ruoyi-rule_engine-common 规则引擎公共模块 -->
<dependency>
<groupId>com.muyu</groupId>
<artifactId>muyu-rule_engine-common</artifactId>
<version>3.6.3</version>
</dependency>
<!-- SpringCloud Alibaba Nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- SpringCloud Alibaba Nacos Config -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
@ -80,18 +87,12 @@
<artifactId>muyu-common-swagger</artifactId>
</dependency>
<!-- Sql Server 驱动 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>9.4.0.jre8</version>
</dependency>
<!-- 添加 PostgreSQL JDBC 驱动 -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
</dependencies>
<build>
@ -116,7 +117,13 @@
<skip>true</skip>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<mainClass>com.ruoyi.ruleEngine.GtlRuleEngineApplication</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>

11
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/MuYuEngineApplication.java → muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/MuYuRuleEngineApplication.java
View File

@ -1,4 +1,4 @@
package com.muyu.engine;
package com.muyu.ruleEngine;
import com.muyu.common.security.annotation.EnableCustomConfig;
import com.muyu.common.security.annotation.EnableMyFeignClients;
@ -6,12 +6,17 @@ import com.muyu.common.swagger.annotation.EnableCustomSwagger2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* rule_engine服务模块
*
* @author CHX
*/
@EnableCustomConfig
@EnableCustomSwagger2
@EnableMyFeignClients
@SpringBootApplication
public class MuYuEngineApplication {
public class MuYuRuleEngineApplication {
public static void main(String[] args) {
SpringApplication.run(MuYuEngineApplication.class, args);
SpringApplication.run(MuYuRuleEngineApplication.class,args);
}
}

112
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/controller/EngineConfigController.java 100644
View File

@ -0,0 +1,112 @@
package com.muyu.ruleEngine.controller;
import com.muyu.common.core.domain.Result;
import com.muyu.common.core.web.controller.BaseController;
import com.muyu.common.log.annotation.Log;
import com.muyu.common.log.enums.BusinessType;
import com.muyu.common.security.annotation.RequiresPermissions;
import com.muyu.common.security.utils.SecurityUtils;
import com.muyu.ruleEngine.domain.EngineConfig;
import com.muyu.ruleEngine.domain.model.TestData;
import com.muyu.ruleEngine.domain.req.EngineConfigEditReq;
import com.muyu.ruleEngine.domain.req.EngineConfigQueryReq;
import com.muyu.ruleEngine.domain.req.EngineConfigSaveReq;
import com.muyu.ruleEngine.domain.resp.EngineConfigScopeResp;
import com.muyu.ruleEngine.service.EngineConfigService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 引擎配置Controller
*
* @author CHX
* @date 2024-05-02
*/
@Api(tags = "引擎配置")
@RestController
@RequestMapping("/config")
public class EngineConfigController extends BaseController {
@Autowired
private EngineConfigService engineConfigService;
/**
* 获取引擎配置作用域列表
*/
@ApiOperation("获取引擎配置作用域列表")
@RequiresPermissions("rule_engine:config:list")
@GetMapping("/getScopeList")
public Result<List<EngineConfigScopeResp>> getScopeList() {
return Result.success(engineConfigService.getScopeList());
}
/**
* 通过引擎作用域编号获取引擎配置作用域信息
*/
@ApiOperation("通过引擎作用域编号获取引擎配置作用域信息")
@RequiresPermissions("rule_engine:config:list")
@GetMapping("/getScopeInfo/{id}")
public Result<EngineConfigScopeResp> getScopeInfoById(@PathVariable Integer id) {
return Result.success(engineConfigService.getScopeInfoById(id));
}
/**
* 查询引擎规则配置列表
*/
@ApiOperation("获取引擎规则配置列表")
@RequiresPermissions("ruleEngine:config:list")
@GetMapping("/list")
public Result<List<EngineConfig>> list(EngineConfigQueryReq engineConfigQueryReq) {
return Result.success(engineConfigService.list(EngineConfig.queryBuild(engineConfigQueryReq)));
}
/**
* 测试引擎规则配置
*/
@ApiOperation("测试引擎规则配置")
@RequiresPermissions("ruleEngine:config:add")
@PostMapping(value = "/test")
public Result<Object> ruleTest(@RequestBody TestData testData) {
return Result.success(engineConfigService.ruleTest(testData));
}
/**
* 新增引擎规则配置
*/
@RequiresPermissions("ruleEngine:config:add")
@Log(title = "引擎规则配置", businessType = BusinessType.INSERT)
@PostMapping
@ApiOperation("新增引擎规则配置")
public Result<String> add(@RequestBody EngineConfigSaveReq engineConfigSaveReq) {
return toAjax(engineConfigService.save(EngineConfig.saveBuild(engineConfigSaveReq, SecurityUtils::getUsername)));
}
/**
* 修改引擎规则配置
*/
@RequiresPermissions("ruleEngine:config:edit")
@Log(title = "引擎规则配置", businessType = BusinessType.UPDATE)
@PutMapping("/{id}")
@ApiOperation("修改引擎规则配置")
public Result<String> edit(@PathVariable Long id, @RequestBody EngineConfigEditReq engineConfigEditReq) {
return toAjax(engineConfigService.updateById(EngineConfig.editBuild(id,engineConfigEditReq, SecurityUtils::getUsername)));
}
/**
* 删除引擎规则配置
*/
@RequiresPermissions("ruleEngine:config:remove")
@Log(title = "引擎规则配置", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
@ApiOperation("删除引擎规则配置")
@ApiImplicitParam(name = "id", value = "id", required = true, dataType = "Long", paramType = "path", dataTypeClass = String.class, example = "1,2,3,4")
public Result<String> remove(@PathVariable List<Long> ids) {
return toAjax(engineConfigService.removeBatchByIds(ids));
}
}

59
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/controller/EngineMaintenanceController.java → muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/controller/EngineMaintenanceController.java
View File

@ -1,40 +1,37 @@
package com.muyu.engine.controller;
package com.muyu.ruleEngine.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.muyu.common.core.domain.Result;
import com.muyu.common.core.utils.poi.ExcelUtil;
import com.muyu.common.core.web.controller.BaseController;
import com.muyu.common.core.web.page.TableDataInfo;
import com.muyu.common.log.annotation.Log;
import com.muyu.common.log.enums.BusinessType;
import com.muyu.common.security.annotation.RequiresPermissions;
import com.muyu.engine.domain.EngineMaintenance;
import com.muyu.engine.domain.req.EngineMaintenanceQueryReq;
import com.muyu.engine.domain.req.EngineMaintenanceSaveReq;
import com.muyu.engine.domain.req.EngineMaintenanceEditReq;
import com.muyu.engine.service.EngineMaintenanceService;
import com.muyu.common.core.web.page.TableDataInfo;
import com.muyu.common.security.utils.SecurityUtils;
import com.muyu.ruleEngine.domain.EngineMaintenance;
import com.muyu.ruleEngine.domain.req.EngineMaintenanceEditReq;
import com.muyu.ruleEngine.domain.req.EngineMaintenanceQueryReq;
import com.muyu.ruleEngine.domain.req.EngineMaintenanceSaveReq;
import com.muyu.ruleEngine.service.EngineMaintenanceService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
/**
* 引擎维护Controller
*
* @author muyu
* @author CHX
* @date 2024-05-02
*/
@Api(tags = "引擎维护")
@RestController
@RequestMapping("/engineMaintenance")
@RequestMapping("/maintenance")
public class EngineMaintenanceController extends BaseController {
@Autowired
private EngineMaintenanceService engineMaintenanceService;
@ -43,7 +40,7 @@ public class EngineMaintenanceController extends BaseController {
* 查询引擎维护列表
*/
@ApiOperation("获取引擎维护列表")
@RequiresPermissions("engine:engineMaintenance:list")
@RequiresPermissions("rule_engine:maintenance:list")
@GetMapping("/list")
public Result<TableDataInfo<EngineMaintenance>> list(EngineMaintenanceQueryReq engineMaintenanceQueryReq) {
startPage();
@ -55,7 +52,7 @@ public class EngineMaintenanceController extends BaseController {
* 导出引擎维护列表
*/
@ApiOperation("导出引擎维护列表")
@RequiresPermissions("engine:engineMaintenance:export")
@RequiresPermissions("rule_engine:maintenance:export")
@Log(title = "引擎维护", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, EngineMaintenance engineMaintenance) {
@ -68,7 +65,7 @@ public class EngineMaintenanceController extends BaseController {
* 获取引擎维护详细信息
*/
@ApiOperation("获取引擎维护详细信息")
@RequiresPermissions("engine:engineMaintenance:query")
@RequiresPermissions("rule_engine:maintenance:query")
@GetMapping(value = "/{id}")
@ApiImplicitParam(name = "id", value = "id", required = true, dataType = "Long", paramType = "path", dataTypeClass = Long.class)
public Result<EngineMaintenance> getInfo(@PathVariable("id") Long id) {
@ -78,34 +75,34 @@ public class EngineMaintenanceController extends BaseController {
/**
* 新增引擎维护
*/
@RequiresPermissions("engine:engineMaintenance:add")
@RequiresPermissions("rule_engine:maintenance:add")
@Log(title = "引擎维护", businessType = BusinessType.INSERT)
@PostMapping
@ApiOperation("新增引擎维护")
public Result<String> add(@RequestBody EngineMaintenanceSaveReq engineMaintenanceSaveReq) {
return toAjax(engineMaintenanceService.save(EngineMaintenance.saveBuild(engineMaintenanceSaveReq)));
return toAjax(engineMaintenanceService.saveEngineMaintenance(EngineMaintenance.saveBuild(engineMaintenanceSaveReq, SecurityUtils::getUsername)));
}
/**
* 修改引擎维护
*/
@RequiresPermissions("engine:engineMaintenance:edit")
@RequiresPermissions("rule_engine:maintenance:edit")
@Log(title = "引擎维护", businessType = BusinessType.UPDATE)
@PutMapping("/{id}")
@ApiOperation("修改引擎维护")
public Result<String> edit(@PathVariable Long id, @RequestBody EngineMaintenanceEditReq engineMaintenanceEditReq) {
return toAjax(engineMaintenanceService.updateById(EngineMaintenance.editBuild(id,engineMaintenanceEditReq)));
return toAjax(engineMaintenanceService.updateById(EngineMaintenance.editBuild(id,engineMaintenanceEditReq, SecurityUtils::getUsername)));
}
/**
* 删除引擎维护
*/
@RequiresPermissions("engine:engineMaintenance:remove")
@RequiresPermissions("rule_engine:maintenance:remove")
@Log(title = "引擎维护", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
@ApiOperation("删除引擎维护")
@ApiImplicitParam(name = "id", value = "id", required = true, dataType = "Long", paramType = "path", dataTypeClass = String.class, example = "1,2,3,4")
public Result<String> remove(@PathVariable List<Long> ids) {
return toAjax(engineMaintenanceService.removeBatchByIds(ids));
return toAjax(engineMaintenanceService.removeBatchEngineMaintenanceByIds(ids));
}
}

78
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/dynamicLoad/DynamicLoader.java 100644
View File

@ -0,0 +1,78 @@
package com.muyu.ruleEngine.dynamicLoad;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* @ClassName DynamicLoader
* @author CHX
* @Date 2024/5/1 20:37
*/
public class DynamicLoader {
/**
* 通过类名和其代码（Java代码字符串），编译得到字节码，返回类名及其对应类的字节码，封装于Map中，值得注意的是，
* 平常类中就编译出来的字节码只有一个类，但是考虑到内部类的情况， 会出现很多个类名及其字节码，所以用Map封装方便。
*
* @param javaName 类名
* @param javaSrc Java源码
* @return map
*/
public static Map<String, byte[]> compile(String javaName, String javaSrc) {
// 调用java编译器接口
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager stdManager = compiler
.getStandardFileManager(null, null, null);
try (MemoryJavaFileManager manager = new MemoryJavaFileManager(
stdManager)) {
@SuppressWarnings("static-access")
JavaFileObject javaFileObject = manager.makeStringSource(javaName,
javaSrc);
JavaCompiler.CompilationTask task = compiler.getTask(null, manager,
null, null, null, Arrays.asList(javaFileObject));
if (task.call()) {
return manager.getClassBytes();
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 先根据类名在内存中查找是否已存在该类，若不存在则调用 URLClassLoader的 defineClass方法加载该类
* URLClassLoader的具体作用就是将class文件加载到jvm虚拟机中去
*
* @author Administrator
*
*/
public static class MemoryClassLoader extends URLClassLoader {
Map<String, byte[]> classBytes = new HashMap<String, byte[]>();
public MemoryClassLoader(Map<String, byte[]> classBytes) {
super(new URL[0], MemoryClassLoader.class.getClassLoader());
this.classBytes.putAll(classBytes);
}
@Override
protected Class<?> findClass(String name)
throws ClassNotFoundException {
byte[] buf = classBytes.get(name);
if (buf == null) {
return super.findClass(name);
}
classBytes.remove(name);
return defineClass(name, buf, 0, buf.length);
}
}
}

134
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/dynamicLoad/MemoryJavaFileManager.java 100644
View File

@ -0,0 +1,134 @@
package com.muyu.ruleEngine.dynamicLoad;
import javax.tools.*;
import java.io.*;
import java.net.URI;
import java.nio.CharBuffer;
import java.util.HashMap;
import java.util.Map;
/**
* 将编译好的.class文件保存到内存当中，这里的内存也就是map映射当中
* @ClassName MemoryJavaFileManager
* @author CHX
* @Date 2024/5/1 20:38
*/
@SuppressWarnings("rawtypes")
public final class MemoryJavaFileManager extends ForwardingJavaFileManager {
private final static String EXT = ".java";// Java源文件的扩展名
private Map<String, byte[]> classBytes;// 用于存放.class文件的内存
@SuppressWarnings("unchecked")
public MemoryJavaFileManager(JavaFileManager fileManager) {
super(fileManager);
classBytes = new HashMap<String, byte[]>();
}
public Map<String, byte[]> getClassBytes() {
return classBytes;
}
@Override
public void close() throws IOException {
classBytes = new HashMap<String, byte[]>();
}
@Override
public void flush() throws IOException {
}
/**
* 一个文件对象，用来表示从string中获取到的source，一下类容是按照jkd给出的例子写的
*/
private static class StringInputBuffer extends SimpleJavaFileObject {
// The source code of this "file".
final String code;
/**
* Constructs a new JavaSourceFromString.
*
* @param name 此文件对象表示的编译单元的name
* @param code 此文件对象表示的编译单元source的code
*/
StringInputBuffer(String name, String code) {
super(toURI(name), Kind.SOURCE);
this.code = code;
}
@Override
public CharBuffer getCharContent(boolean ignoreEncodingErrors) {
return CharBuffer.wrap(code);
}
@SuppressWarnings("unused")
public Reader openReader() {
return new StringReader(code);
}
}
/**
* 将Java字节码存储到classBytes映射中的文件对象
*/
private class ClassOutputBuffer extends SimpleJavaFileObject {
private String name;
/**
* @param name className
*/
ClassOutputBuffer(String name) {
super(toURI(name), Kind.CLASS);
this.name = name;
}
@Override
public OutputStream openOutputStream() {
return new FilterOutputStream(new ByteArrayOutputStream()) {
@Override
public void close() throws IOException {
out.close();
ByteArrayOutputStream bos = (ByteArrayOutputStream) out;
// 这里需要修改
classBytes.put(name, bos.toByteArray());
}
};
}
}
@Override
public JavaFileObject getJavaFileForOutput(
Location location, String className,
JavaFileObject.Kind kind, FileObject sibling) throws IOException {
if (kind == JavaFileObject.Kind.CLASS) {
return new ClassOutputBuffer(className);
} else {
return super.getJavaFileForOutput(location, className, kind,
sibling);
}
}
static JavaFileObject makeStringSource(String name, String code) {
return new StringInputBuffer(name, code);
}
static URI toURI(String name) {
File file = new File(name);
if (file.exists()) {// 如果文件存在，返回他的URI
return file.toURI();
} else {
try {
final StringBuilder newUri = new StringBuilder();
newUri.append("mfm:///");
newUri.append(name.replace('.', '/'));
if (name.endsWith(EXT)) {
newUri.replace(newUri.length() - EXT.length(),
newUri.length(), EXT);
}
return URI.create(newUri.toString());
} catch (Exception exp) {
return URI.create("mfm:///com/sun/script/java/java_source");
}
}
}
}

14
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/mapper/EngineConfigMapper.java 100644
View File

@ -0,0 +1,14 @@
package com.muyu.ruleEngine.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.muyu.ruleEngine.domain.EngineConfig;
/**
* 引擎规则配置Mapper接口
*
* @author CHX
* @date 2024-05-02
*/
public interface EngineConfigMapper extends BaseMapper<EngineConfig> {
}

7
muyu-modules/muyu-engine/src/main/java/com/muyu/engine/mapper/EngineMaintenanceMapper.java → muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/mapper/EngineMaintenanceMapper.java
View File

@ -1,13 +1,12 @@
package com.muyu.engine.mapper;
package com.muyu.ruleEngine.mapper;
import java.util.List;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.muyu.engine.domain.EngineMaintenance;
import com.muyu.ruleEngine.domain.EngineMaintenance;
/**
* 引擎维护Mapper接口
*
* @author muyu
* @author CHX
* @date 2024-05-02
*/
public interface EngineMaintenanceMapper extends BaseMapper<EngineMaintenance> {

19
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/scope/DataModelContextHolder.java 100644
View File

@ -0,0 +1,19 @@
package com.muyu.ruleEngine.scope;
import lombok.Data;
/**
* 数据模型上下文
* @ClassName DataModelContextHolder
* @Author CHX
* @Version: 1.0
*/
@Data
public class DataModelContextHolder {
private final RecordContextHolder recordContextHolder;
public static DataModelContextHolder build(RecordContextHolder recordContextHolder){
return new DataModelContextHolder(recordContextHolder);
}
}

19
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/scope/DataSetContextHolder.java 100644
View File

@ -0,0 +1,19 @@
package com.muyu.ruleEngine.scope;
import lombok.Data;
/**
* 数据集上下文
* @ClassName DataSetContextHolder
* @Author CHX
* @Version: 1.0
*/
@Data
public class DataSetContextHolder {
private final TaskContextHolder taskContextHolder;
public static DataSetContextHolder build(TaskContextHolder taskContextHolder){
return new DataSetContextHolder(taskContextHolder);
}
}

19
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/scope/RecordContextHolder.java 100644
View File

@ -0,0 +1,19 @@
package com.muyu.ruleEngine.scope;
import lombok.Data;
/**
* 记录上下文
* @ClassName RecordContextHolder
* @Author CHX
* @Version: 1.0
*/
@Data
public class RecordContextHolder {
private final DataSetContextHolder dataSetContextHolder;
public static RecordContextHolder build(DataSetContextHolder dataSetContextHolder){
return new RecordContextHolder(dataSetContextHolder);
}
}

14
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/scope/TaskContextHolder.java 100644
View File

@ -0,0 +1,14 @@
package com.muyu.ruleEngine.scope;
/**
* 任务上下文
* @ClassName TaskContextHolder
* @Author CHX
* @Version: 1.0
*/
public class TaskContextHolder {
public static TaskContextHolder build(){
return new TaskContextHolder();
}
}

10
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/scope/TestClass.txt 100644
View File

@ -0,0 +1,10 @@
import java.util.List;
/**
* @author CHX
*/
public class TestClass {
public static String ruleTest(List<String> list) {
}
}

44
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/service/EngineConfigService.java 100644
View File

@ -0,0 +1,44 @@
package com.muyu.ruleEngine.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.muyu.ruleEngine.domain.EngineConfig;
import com.muyu.ruleEngine.domain.model.TestData;
import com.muyu.ruleEngine.domain.resp.EngineConfigScopeResp;
import java.util.List;
/**
* 引擎配置Service接口
*
* @author CHX
* @date 2024-05-02
*/
public interface EngineConfigService extends IService<EngineConfig> {
/**
* 查询引擎配置作用域列表
*
* @return 引擎规则作用域集合
*/
public List<EngineConfigScopeResp> getScopeList();
/**
* 查询引擎规则配置列表
*
* @param engineConfig 引擎规则配置
* @return 引擎规则配置集合
*/
public List<EngineConfig> list(EngineConfig engineConfig);
/**
* 通过引擎作用域编号获取引擎配置作用域信息
* @param id 引擎作用域编号
* @return 引擎配置作用域信息
*/
EngineConfigScopeResp getScopeInfoById(Integer id);
/**
* 规则测试
* @param testData 规则配置版本编号
*/
Object ruleTest(TestData testData);
}

36
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/service/EngineMaintenanceService.java 100644
View File

@ -0,0 +1,36 @@
package com.muyu.ruleEngine.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.muyu.ruleEngine.domain.EngineMaintenance;
import java.util.List;
/**
* 引擎维护Service接口
*
* @author CHX
* @date 2024-05-02
*/
public interface EngineMaintenanceService extends IService<EngineMaintenance> {
/**
* 查询引擎维护列表
*
* @param engineMaintenance 引擎维护
* @return 引擎维护集合
*/
public List<EngineMaintenance> list(EngineMaintenance engineMaintenance);
/**
* 新增引擎维护
* @param engineMaintenance 引擎维护对象
* @return 是否
*/
boolean saveEngineMaintenance(EngineMaintenance engineMaintenance);
/**
* 批量删除引擎维护
* @param ids 引擎维护编号集合
* @return 是否
*/
boolean removeBatchEngineMaintenanceByIds(List<Long> ids);
}

158
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/service/impl/EngineConfigServiceImpl.java 100644
View File

@ -0,0 +1,158 @@
package com.muyu.ruleEngine.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.muyu.common.core.exception.ServiceException;
import com.muyu.common.core.utils.StringUtils;
import com.muyu.ruleEngine.domain.EngineConfig;
import com.muyu.ruleEngine.domain.model.TestData;
import com.muyu.ruleEngine.domain.resp.EngineConfigScopeResp;
import com.muyu.ruleEngine.dynamicLoad.DynamicLoader;
import com.muyu.ruleEngine.mapper.EngineConfigMapper;
import com.muyu.ruleEngine.service.EngineConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 引擎配置Service业务层处理
*
* @author CHX
* @date 2024-05-02
*/
@Slf4j
@Service
public class EngineConfigServiceImpl extends ServiceImpl<EngineConfigMapper, EngineConfig> implements EngineConfigService {
/**
* 查询引擎配置作用域列表
*
* @return 引擎规则作用域集合
*/
@Override
public List<EngineConfigScopeResp> getScopeList() {
List<EngineConfigScopeResp> list=new ArrayList<>();
List<String> scopeName=List.of("TaskContextHolder","DataSetContextHolder","RecordContextHolder","DataModelContextHolder");
try {
for (String scope : scopeName) {
String path="D:/work/cloud-server/muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/scope/"+scope+".java";
String code = Files.readString(Paths.get(path));
String type=null;
if(scope.contains("Task")){
type="任务";
}else if(scope.contains("DataSet")){
type="数据集";
}else if(scope.contains("Record")){
type="资产记录";
}else{
type="资产模型";
}
list.add(EngineConfigScopeResp.builder().type(type).name(scope).code(code).build());
}
} catch (IOException e) {
throw new RuntimeException(e);
}
return list;
}
/**
* 查询引擎规则配置列表
*
* @param engineConfig 引擎规则配置
* @return 引擎规则配置
*/
@Override
public List<EngineConfig> list(EngineConfig engineConfig) {
LambdaQueryWrapper<EngineConfig> queryWrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotNull(engineConfig.getVersionCode())){
queryWrapper.eq(EngineConfig::getVersionCode, engineConfig.getVersionCode());
}
if (StringUtils.isNotNull(engineConfig.getRuleContent())){
queryWrapper.eq(EngineConfig::getRuleContent, engineConfig.getRuleContent());
}
if (StringUtils.isNotNull(engineConfig.getEngineMaintenanceId())){
queryWrapper.eq(EngineConfig::getEngineMaintenanceId, engineConfig.getEngineMaintenanceId());
}
return list(queryWrapper);
}
/**
* 通过引擎作用域编号获取引擎配置作用域信息
* @param id 引擎作用域编号
* @return 引擎配置作用域信息
*/
@Override
public EngineConfigScopeResp getScopeInfoById(Integer id) {
String scope=null;
String type=null;
if(id==0){
type="测试模版";
scope="TestClass.txt";
}else if(id==1){
type="任务";
scope="TaskContextHolder.java";
}else if(id==2){
type="数据集";
scope="DataSetContextHolder.java";
}else if(id==3){
type="资产记录";
scope="RecordContextHolder.java";
}else{
type="资产模型";
scope="DataModelContextHolder.java";
}
String path="D:/work/cloud-server/muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/scope/"+scope;
String code = null;
try {
code = Files.readString(Paths.get(path));
} catch (IOException e) {
throw new RuntimeException(e);
}
return EngineConfigScopeResp.builder().type(type).name(scope).code(code).build();
}
/**
* 规则测试
* @param testData 规则配置版本编号
*/
@Override
public Object ruleTest(TestData testData) {
Object invoke=null;
try {
String className="TestClass";
final String SUFFIX = ".java";// 类名后面要跟的后缀
EngineConfig config = this.getById(testData.getId());
String content = config.getRuleContent().replaceAll("\r\n", "");
// 对source进行编译生成class文件存放在Map中，这里用bytecode接收
Map<String, byte[]> bytecode = DynamicLoader.compile(className + SUFFIX,content );
// 加载class文件到虚拟机中，然后通过反射执行
@SuppressWarnings("resource")
DynamicLoader.MemoryClassLoader classLoader = new DynamicLoader.MemoryClassLoader(
bytecode);
Class<?> clazz = classLoader.loadClass(className);
// 调用ruleTest方法
Method mainMethod = clazz.getDeclaredMethod("ruleTest", List.class);
invoke = mainMethod.invoke(null, testData.getList());
} catch (ClassNotFoundException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
e.printStackTrace();
throw new ServiceException("测试失败");
}
return invoke;
}
}

102
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/java/com/muyu/ruleEngine/service/impl/EngineMaintenanceServiceImpl.java 100644
View File

@ -0,0 +1,102 @@
package com.muyu.ruleEngine.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.muyu.common.core.utils.StringUtils;
import com.muyu.ruleEngine.domain.EngineConfig;
import com.muyu.ruleEngine.domain.EngineMaintenance;
import com.muyu.ruleEngine.domain.resp.EngineConfigScopeResp;
import com.muyu.ruleEngine.mapper.EngineMaintenanceMapper;
import com.muyu.ruleEngine.service.EngineConfigService;
import com.muyu.ruleEngine.service.EngineMaintenanceService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 引擎维护Service业务层处理
*
* @author CHX
* @date 2024-05-02
*/
@Slf4j
@Service
public class EngineMaintenanceServiceImpl extends ServiceImpl<EngineMaintenanceMapper, EngineMaintenance> implements EngineMaintenanceService {
@Autowired
private EngineConfigService engineConfigService;
/**
* 查询引擎维护列表
*
* @param engineMaintenance 引擎维护
* @return 引擎维护
*/
@Override
public List<EngineMaintenance> list(EngineMaintenance engineMaintenance) {
LambdaQueryWrapper<EngineMaintenance> queryWrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotNull(engineMaintenance.getName())){
queryWrapper.like(EngineMaintenance::getName, engineMaintenance.getName());
}
if (StringUtils.isNotNull(engineMaintenance.getType())){
queryWrapper.eq(EngineMaintenance::getType, engineMaintenance.getType());
}
if (StringUtils.isNotNull(engineMaintenance.getScope())){
queryWrapper.eq(EngineMaintenance::getScope, engineMaintenance.getScope());
}
if (StringUtils.isNotNull(engineMaintenance.getEngineCode())){
queryWrapper.eq(EngineMaintenance::getEngineCode, engineMaintenance.getEngineCode());
}
if (StringUtils.isNotNull(engineMaintenance.getIsActivate())){
queryWrapper.eq(EngineMaintenance::getIsActivate, engineMaintenance.getIsActivate());
}
if (StringUtils.isNotNull(engineMaintenance.getStatus())){
queryWrapper.eq(EngineMaintenance::getStatus, engineMaintenance.getStatus());
}
return list(queryWrapper);
}
/**
* 新增引擎维护
* @param engineMaintenance 引擎维护对象
* @return 是否
*/
@Override
@Transactional
public boolean saveEngineMaintenance(EngineMaintenance engineMaintenance) {
boolean save = this.save(engineMaintenance);
EngineConfigScopeResp scopeInfo = engineConfigService.getScopeInfoById(engineMaintenance.getScope());
engineConfigService.save(EngineConfig.builder().versionCode("1.0").ruleContent(scopeInfo.getCode()).build());
return save;
}
/**
* 批量删除引擎维护
* @param ids 引擎维护编号集合
* @return 是否
*/
@Override
@Transactional
public boolean removeBatchEngineMaintenanceByIds(List<Long> ids) {
boolean removed = this.removeBatchByIds(ids);
List<EngineConfig> engineConfigs = engineConfigService.list(new LambdaQueryWrapper<EngineConfig>()
.in(EngineConfig::getEngineMaintenanceId, ids));
if(!engineConfigs.isEmpty()){
engineConfigService.removeBatchByIds(engineConfigs.stream().map(EngineConfig::getId).toList());
}
return removed;
}
}

8
muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/resources/banner.txt 100644
View File

@ -0,0 +1,8 @@
Spring Boot Version: ${spring-boot.version}
Spring Application Name: ${spring.application.name}
__ .__ .__
____ _/ |_ | | _______ __ __ ____ ___.__.|__|
/ ___\ \ __\| | ______ \_ __ \| | \ / _ \ < | || |
/ /_/ > | | | |__ /_____/ | | \/| | /( <_> ) \___ || |
\___ / |__| |____/ |__| |____/ \____/ / ____||__|
/_____/ \/

4
muyu-modules/muyu-engine/src/main/resources/bootstrap.yml → muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/resources/bootstrap.yml
View File

@ -6,7 +6,7 @@ server:
spring:
application:
# 应用名称
name: muyu-engine
name: muyu-rule-engine
profiles:
# 环境配置
active: dev
@ -26,4 +26,4 @@ spring:
- application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
logging:
level:
com.muyu.system.mapper: DEBUG
com.ruoyi.ruleEngine.mapper: DEBUG

4
muyu-modules/muyu-engine/src/main/resources/logback.xml → muyu-modules/muyu-rule_engine/muyu-rule_engine-server/src/main/resources/logback.xml
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
<!-- 日志存放路径 -->
<property name="log.path" value="logs/muyu-system"/>
<property name="log.path" value="logs/muyu-ruleEngine"/>
<!-- 日志输出格式 -->
<property name="log.pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{20} - [%method,%line] - %msg%n"/>
@ -58,7 +58,7 @@
</appender>
<!-- 系统模块日志级别控制 -->
<logger name="com.muyu" level="info"/>
<logger name="com.ruoyi" level="info"/>
<!-- Spring日志级别控制 -->
<logger name="org.springframework" level="warn"/>

26
muyu-modules/muyu-rule_engine/pom.xml 100644
View File

@ -0,0 +1,26 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.muyu</groupId>
<artifactId>muyu-modules</artifactId>
<version>3.6.3</version>
</parent>
<artifactId>muyu-rule_engine</artifactId>
<packaging>pom</packaging>
<modules>
<module>muyu-rule_engine-common</module>
<module>muyu-rule_engine-remote</module>
<module>muyu-rule_engine-server</module>
</modules>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>

2
muyu-modules/pom.xml
View File

@ -14,7 +14,7 @@
<module>muyu-job</module>
<module>muyu-file</module>
<module>muyu-source</module>
<module>muyu-engine</module>
<module>muyu-rule_engine</module>
</modules>
<artifactId>muyu-modules</artifactId>