前に書いてある
ここでは、liteflow の簡単な基本的な使用法と、liteflow の視覚的拡張に関する著者による関連説明のみを紹介します。
1. 背景と意義
背景: 複雑なビジネス ロジックを備えたシステムには、内部ロジック操作、キャッシュ操作、永続化操作、外部リソース呼び出し、他の内部システムからの RPC 呼び出しなどが含まれるコア ビジネス ロジックが組み込まれています。プロジェクトの担当者が何度も変わると、メンテナンスのコストがますます高くなります。各種ハードコード判定の分岐条件が増えています。コードの抽象化、再利用率はますます低くなり、さまざまなモジュール間の結合は非常に高くなります。ロジックの小さな変更は他のモジュールに影響を与えるため、それを検証するには完全な回帰テストが必要です。業務プロセスの順序を柔軟に変更したい場合は、コードを大幅に変更してメソッドを抽象化して書き直す必要があります。ビジネスプロセスのリアルタイムのホットチェンジを実現するのはほぼ困難
重要性: 論理的な分離、拡張性の向上、メンテナンスコストの削減、機能の完全な再利用、および柔軟なプロセス配置
2. 共通のプロセス オーケストレーション フレームワーク
| ライトフロー (オープンソース) | asyncTool (オープンソース) | JDEasyFlow (オープンソース) | 破壊者 | |
|---|---|---|---|---|
| 導入 | LiteFlow は、オーケストレーション機能とルール エンジンのすべての機能を組み合わせた、非常に強力で最新のルール エンジン フレームワークです。複雑なビジネス ロジックを書き換えたりリファクタリングしたい場合は、LiteFlow が最適です。これは、オーケストレーション スタイルのルール エンジン フレームワークであるコンポーネント オーケストレーションであり、ビジネス コードを分離し、各ビジネス セグメントをコンポーネントにするのに役立ちます。 | 任意のマルチスレッド並列、シリアル、ブロッキング、依存関係、およびコールバック同時実行フレームワークを解決し、完全なリンク コールバックとタイムアウト制御を使用して、各スレッドの実行順序を任意に組み合わせることができます。 | 一般的なプロセス オーケストレーション テクノロジ コンポーネント。サービス オーケストレーション、ワークフロー、承認フローなどのシナリオに適用できます。 | |
| 住所 | https://liteflow.yomahub.com/ | https://gitee.com/jd-platform-opensource/asyncTool | https://developer.jdcloud.com/article/2604?mid=30 | |
| アドバンテージ | 複雑なビジネスプロセスのオーケストレーション、成熟したアクティブなコミュニティ | jdk8 CompletableFuture ベース、軽量 | シンプル、柔軟、拡張が簡単 | 生産消費型モデルに基づいたロックフリー設計 |
| 欠点がある | オープンソース フレームワークは重く、一定の学習コストがかかります | 新しいフレームワークの安定性を検証する必要がある | ビジネス シナリオでは、比較的低レベルの二次パッケージングが必要です | |
| 例 | https://gitee.com/bryan31/liteflow-example |
3. Liteflowの基本的な使い方
1. 依存するjarパッケージを追加する
<dependency>
<groupId>com.yomahub</groupId>
<artifactId>liteflow-spring</artifactId>
<version>2.10.4</version>
</dependency>
2. コンポーネントを定義する
コンポーネントを定義し、いくつかのコンポーネントを実装し、コンテキストに登録します
@Component("a")
public class ACmp extends NodeComponent {
@Override
public void process() {
//do your business
}
}
3. 構成
対応する構成クラスと構成ファイルを追加します
Spring XMLでの設定
<context:component-scan base-package="com.yomahub.flowtest.components" />
<bean id="springAware" class="com.yomahub.liteflow.spi.spring.SpringAware"/>
<bean class="com.yomahub.liteflow.spring.ComponentScanner"/>
<bean id="liteflowConfig" class="com.yomahub.liteflow.property.LiteflowConfig">
<property name="ruleSource" value="config/flow.el.xml"/>
</bean>
<bean id="flowExecutor" class="com.yomahub.liteflow.core.FlowExecutor">
<property name="liteflowConfig" ref="liteflowConfig"/>
</bean>
<!-- 如果上述enableLog为false，下面这段也可以省略 -->
<bean class="com.yomahub.liteflow.monitor.MonitorBus">
<property name="liteflowConfig" ref="liteflowConfig"/>
</bean>
4. ルールファイルの定義
-- プロセスの定義 (liteflowConfig は手順 3 でルール ファイルを config/flow.xml として指定します)。そのため、リソースの下に新しいフォルダー config を作成し、新しい flow.xml ファイルを作成して、定義するプロセスを構成する必要があります。
<?xml version="1.0" encoding="UTF-8"?>
<flow>
<chain name="chain1">
THEN(a, b, c)
</chain>
</flow>
5. 実行
オーケストレーションされたプロセスの後、実行する必要がある場所に FlowExecutor を挿入し、execute2Resp を実行します。
@Component
public class YourClass{
@Resource
private FlowExecutor flowExecutor;
@Test
public void testConfig(){
LiteflowResponse response = flowExecutor.execute2Resp("chain1", "arg");
}
}
4. Liteflowの実際の適用
ここでの弱体化の背後にある実際のビジネスは、著者の実際の適用事例のみを示しています
1. 依存するjarパッケージを追加する
<properties>
<liteflow-spring.version>2.8.0</liteflow-spring.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.yomahub</groupId>
<artifactId>liteflow-spring</artifactId>
<version>${liteflow-spring.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
2. コンポーネントを定義する
コンポーネントを定義し、いくつかのコンポーネントを実装し、コンテキストに登録します
@LiteflowComponent("checkRealNameAuthCmp")
@LiteflowCmpDefine
public class CheckRealNameAuthCmp {
private static final Logger log = LoggerFactory.getLogger(CheckRealNameAuthCmp.class);
@LiteflowMethod(LiteFlowMethodEnum.PROCESS)
public void process(NodeComponent nodeComponent) throws Exception {
// 获取请求参数
GeneratePolicyRightsParam generatePolicyRightsParam = nodeComponent.getSlot().getRequestData();
// 如果pin为空则结束流程
if (generatePolicyRightsParam == null || StringUtil.isEmpty(generatePolicyRightsParam.getUserPin())) {
log.info("CheckRealNameAuthCmp -> process end, nodeComponent={},pin is null.", JsonUtil.toJSONString(nodeComponent));
nodeComponent.setIsEnd(true);
}
//封装设置流程编排上下文信息
GenerateRightsContext generateRightsContext = nodeComponent.getContextBean(GenerateRightsContext.class);
generateRightsContext.setGeneratePolicyRightsParam(generatePolicyRightsParam);
}
}
Liteflowコンポーネント：https://liteflow.yomahub.com/pages/v2.8.X/8486fb/
LiteflowCmpDefine：https://liteflow.yomahub.com/pages/v2.8.X/f33919/
3. 構成
対応する構成クラスと構成ファイルを追加します
Spring XMLでの設定
spring-config.xml
<import resource="classpath*:spring/spring-config-liteflow.xml"/>
spring-config-liteflow.xml
<bean id="springAware" class="com.yomahub.liteflow.spi.spring.SpringAware"/>
<bean id="springComponentScaner" class="com.yomahub.liteflow.spring.ComponentScanner"/>
<!-- 注入liteflow的配置文件 -->
<bean id="liteflowConfig" class="com.yomahub.liteflow.property.LiteflowConfig">
<property name="ruleSource" value="liteflow/flow.xml"/>
</bean>
<!-- 注入liteflow的执行引擎 -->
<bean id="flowExecutor" class="com.yomahub.liteflow.core.FlowExecutor">
<property name="liteflowConfig" ref="liteflowConfig"/>
</bean>
<!-- 注入liteflow的MonitorBus-->
<bean class="com.yomahub.liteflow.monitor.MonitorBus">
<constructor-arg ref="liteflowConfig"/>
<property name="liteflowConfig" ref="liteflowConfig"/>
</bean>
4. ルールファイルの定義
-- プロセスの定義 (ステップ 3 で、liteflowConfig はルール ファイルを liteflow/flow.xml として指定します)。そのため、リソースの下に新しいフォルダー liteflow を作成し、新しい flow.xml ファイルを作成して、定義するプロセスを構成する必要があります。
フロー.xml
<?xml version="1.0" encoding="UTF-8"?>
<flow>
<!-- liteflow流程编排：生成(发放)保单权益-->
<chain name="sendPolicyRightsChain">
<when value="checkRealNameAuthCmp"/>
<then value="checkNewPolicyRightsCmp"/>
<then value="getPolicyInfoCmp"/>
<then value="policyMatchServiceRuleCmp"/>
<then value="initPolicyRightsDataCmp"/>
<then value="creatPlanGantRightsDataCmp"/>
<then value="asyncFullFillCmp"/>
</chain>
</flow>
5. 実行
オーケストレーションされたプロセスを実行し、実行する必要がある場所に FlowExecutor を挿入して、execute2Resp を実行します。
@Resource
private FlowExecutor flowExecutor;
public Boolean sendPolicyRights(GeneratePolicyRightsParam generatePolicyRightsParam) {
//todo 入参和上下文不能混用，通用信息用map
LiteflowResponse response = flowExecutor.execute2Resp("sendPolicyRightsChain", generatePolicyRightsParam, GenerateRightsContext.class,GenerateRightsContext.class);
}
5. Liteflowの機能拡張（可視化）
Liteflowt はプロセス オーケストレーションの機能を提供します。この内部プロセス オーケストレーションの意味を理解できるのは研究開発担当者だけです。他の製品やビジネスにとっては、現在のビジネス プロセスを直観的に理解することができず、視覚化は不親切です。現時点で現在のプロセスをどのように視覚化すればよいでしょうか? 設定ファイル flow.xml を直接読み込んで表示するページを作成しても意味がありません。意味があるのは、コンポーネントを視覚化し、プロセスを視覚化し、プロセス オーケストレーションを視覚化できることです。
1. 思考
新しい jar パッケージを提供し、ビジネス システムの有名なコンポーネントとプロセスを取得し、プロセスとコンポーネントを表示し、オーケストレーション機能を提供します。
例証します:
1. Small Tool jar パッケージは、視覚的にプロセスを配置するための小型ツールであり、主に業務システム宣言の取得、プロセスの保存、プロセスの視覚的表示、プロセス配置の可視化のためのコンポーネントを提供し、liteflow-util ロゴを使用して業務システムと区別します。
2. ビジネス システムは、liteflow-test ロゴを使用したコンポーネント宣言、プロセス実行、およびビジネス ロジック システムです。
2. 実現する
2.1 特定のクラスまたはメソッドを取得する
liteflow-test で宣言されたコンポーネントを liteflow-util から取得する方法
2.1.1 コンテキストを取得する
アプリケーションコンテキスト認識
Bean のプロパティが初期化されると、setApplicationContext をコールバックしてアプリケーション コンテキストを設定します。
public interface ApplicationContextAware extends Aware {
/**
* Set the ApplicationContext that this object runs in.
* Normally this call will be used to initialize the object.
*
Invoked after population of normal bean properties but before an init callback such
* as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}
* or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},
* {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and
* {@link MessageSourceAware}, if applicable.
* @param applicationContext the ApplicationContext object to be used by this object
* @throws ApplicationContextException in case of context initialization errors
* @throws BeansException if thrown by application context methods
* @see org.springframework.beans.factory.BeanInitializationException
*/
void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
}
liteflow-test のコンテキスト (現在の jar パッケージに依存するアプリケーション) を取得するために、liteflow-util のクラスを使用して ApplicationContextAware を実装します。
@Configuration
public class LiteFlowApplicationContext implements ApplicationContextAware {
private static ApplicationContext controllerApplicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("applicationContext = " + applicationContext);
LiteFlowApplicationContext.controllerApplicationContext=applicationContext;
}
public static ApplicationContext getControllerApplicationContext() {
return controllerApplicationContext;
}
}
2.1.2 コンテキストからクラスを取得する
liteflow-util のコンテキストに従ってコンポーネント クラスを取得します。 ここでの焦点は Map<String, Object> mvcObjects = context.getBeansWithAnnotation(Service.class); です。
@Slf4j
public class ReferenceManager {
private static Map<Class<?>, Object> interfaceMapRef = new ConcurrentHashMap<Class<?>, Object>();
private static ReferenceManager instance;
private ReferenceManager() {
}
public synchronized static ReferenceManager getInstance() {
if (null != instance) {
return instance;
}
instance = new ReferenceManager();
ApplicationContext controllerContext = LiteFlowApplicationContext.getControllerApplicationContext();
interfaceMapInit(controllerContext);
return instance;
}
private static void interfaceMapInit(ApplicationContext context) {
try {
Map<String, Object> objects = Maps.newHashMapWithExpectedSize(64);
//优化 允许 ServiceBean 被MVC容器扫描
Map<String, Object> mvcObjects = context.getBeansWithAnnotation(Service.class);
objects.putAll(mvcObjects);
if (objects == null || objects.size() == 0) {
return;
}
for (Entry<String, Object> entry : objects.entrySet()) {
/**
* 获取代理对象的原对象
* 因为 jdk 动态代理通过接口
*/
Object objectImplProxy = entry.getValue();
Object objectImpl = AopTargetUtils.getTarget(objectImplProxy);
Class objectImplClass = objectImpl.getClass();
if (objectImplClass.getInterfaces().length > 0) {
/**
* 规定 每个interface 只对应 一个实现类
* 如果 多个类实现了该接口 接口列表中只 显示第一个实现类
*/
Class interfaceClass = objectImplClass.getInterfaces()[0];
Object object = interfaceMapRef.get(interfaceClass);
if (object == null) {
interfaceMapRef.put(interfaceClass, objectImpl);
} else {
}
} else {
}
}
} catch (Exception e) {
}
}
public Map<Class<?>, Object> getInterfaceMapRef() {
return interfaceMapRef;
}
}
@Component
public class ServiceScanner {
public Set<Class<?>> classes() {
return interfaceMapRef().keySet();
}
public Map<Class<?>, Object> interfaceMapRef() {
return ReferenceManager.getInstance().getInterfaceMapRef();
}
}
public class AopTargetUtils {
/**
* 获取 目标对象
* @param proxy 代理对象
* @return
* @throws Exception
*/
public static Object getTarget(Object proxy) throws Exception {
if(!AopUtils.isAopProxy(proxy)) {
return proxy;//不是代理对象
}
if(AopUtils.isJdkDynamicProxy(proxy)) {
return getJdkDynamicProxyTargetObject(proxy);
} else { //cglib
return getCglibProxyTargetObject(proxy);
}
}
private static Object getCglibProxyTargetObject(Object proxy) {
try{
Field h = proxy.getClass().getDeclaredField("CGLIB$CALLBACK_0");
h.setAccessible(true);
Object dynamicAdvisedInterceptor = h.get(proxy);
Field advised = dynamicAdvisedInterceptor.getClass().getDeclaredField("advised");
advised.setAccessible(true);
Object target = ((AdvisedSupport) advised.get(dynamicAdvisedInterceptor)).getTargetSource().getTarget();
return target;
} catch(Exception e){
e.printStackTrace();
return null;
}
}
private static Object getJdkDynamicProxyTargetObject(Object proxy) {
try{
Field h = proxy.getClass().getSuperclass().getDeclaredField("h");
h.setAccessible(true);
AopProxy aopProxy = (AopProxy) h.get(proxy);
Field advised = aopProxy.getClass().getDeclaredField("advised");
advised.setAccessible(true);
Object target = ((AdvisedSupport) advised.get(aopProxy)).getTargetSource().getTarget();
return target;
} catch(Exception e){
e.printStackTrace();
return null;
}
}
}
2.2 liteflow-util ページにアクセスします。
liteflow-test で liteflow-util パッケージのページにアクセスして表示する方法
(1) liteflow-utilでServletクラスを記述し、HttpServletを直接継承し、doGetメソッドまたはdoPostメソッドを書き換える
(2) liteflow-utilのweb.xmlにServletクラスを設定する
(3) liteflow-utilでフロントエンドページ（フォームフォーム、ボタンインタラクション）を準備する
(4) liteflow-testに依存関係を導入し、liteflow-testを起動する
2.2.1HTTPサーブレット
public class HandServlet extends HttpServlet {
private static final Logger log = LoggerFactory.getLogger(HandServlet.class);
private String username = null;
private String password = null;
private ServletContext servletContext;
public HandServlet() {
}
@Override
public void init(ServletConfig config) {
log.info("HandServlet->init,start");
this.username = config.getInitParameter("loginUsername");
this.password = config.getInitParameter("loginPassword");
this.servletContext = config.getServletContext();
log.info("HandServlet->init finish");
}
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws IOException {
String contextPath = request.getContextPath();
String servletPath = request.getServletPath();
String requestURI = request.getRequestURI();
response.setCharacterEncoding("utf-8");
if (contextPath == null) {
contextPath = "";
}
String uri = contextPath + servletPath;
String path = requestURI.substring(contextPath.length() + servletPath.length());
String usernameParam;
if (!Objects.equals("/submitLogin", path)) {
if (this.needLogin(request, path)) {
this.redirect(request, response);
} else {
Result result;
try {
result = this.requestHandler(path, request);
} catch (Throwable var11) {
log.error("HandServlet->service,requestHandler error", var11);
result = Result.buildFail(var11.getMessage());
}
if (null != result) {
response.getWriter().print(JSON.toJSONString(result));
} else {
this.returnResourceFile(path, uri, response);
}
}
} else {
usernameParam = request.getParameter("loginUsername");
String passwordParam = request.getParameter("loginPassword");
System.out.println("usernameParam = " + usernameParam);
System.out.println("passwordParam = " + passwordParam);
// if (this.username.equals(usernameParam) && this.password.equals(passwordParam)) {
HttpSession session = request.getSession();
session.setAttribute("lite-flow", this.username);
session.setMaxInactiveInterval(300);
response.getWriter().print(JSON.toJSONString(Result.buildSuccess("success")));
// } else {
// response.getWriter().print(JSON.toJSONString(Result.buildFail("用户名或密码错误")));
// }
}
}
private void redirect(HttpServletRequest request, HttpServletResponse response) throws IOException {
if (request.getHeader("X-Requested-With") != null && "XMLHttpRequest".equals(request.getHeader("X-Requested-With"))) {
response.getWriter().print(JSON.toJSONString(Result.buildReLogin()));
} else if (request.getHeader("Accept") != null && request.getHeader("Accept").contains("application/json")) {
response.getWriter().print(JSON.toJSONString(Result.buildReLogin()));
} else {
response.sendRedirect("/lite-flow/login.html");
}
}
private Result requestHandler(String path, HttpServletRequest request) {
System.out.println("path = " + path);
System.out.println("request = " + request);
String initMenu = "/initMenu";
String liteflow = "/liteflow";
if (initMenu.equals(path)) {
Map<String, Object> map = new HashMap(2);
List<String> classObjectMap = getClassObjectMap();
classObjectMap.forEach(item -> {
int i = item.lastIndexOf(".");
String substring = item.substring(i+1);
System.out.println("substring = " + substring);
LiteFlowNodeBuilder.createCommonNode().setId(substring).setName(substring).setClazz(item).build();
});
map.put("interfaceMapRef", classObjectMap);
return Result.buildSuccess(map);
} else if (liteflow.equals(path)) {
try {
try {
String postData = this.getPostData(request);
log.info("HandServlet -> requestHandler start, postData={}", postData);
JSONObject jsonObject = JSONObject.parseObject(postData);
JSONArray checkList = jsonObject.getJSONArray("checkList");
String chainId = (String) jsonObject.get("chainId");
log.info("HandServlet -> requestHandler start, path={},checkList={}", path, checkList);
ArrayList arrayList = new ArrayList();
checkList.forEach(item -> {
String itemStr = (String) item;
int i = itemStr.lastIndexOf(".");
String substring = itemStr.substring(i+1);
arrayList.add(substring);
});
String str = StringUtils.join(arrayList, ",");
log.info("HandServlet -> requestHandler start, str={}", str);
// String elss = "THEN(" + str + ")";
// log.info("HandServlet -> requestHandler start, elss={}", elss);
Condition condition = LiteFlowConditionBuilder.createCondition(ConditionTypeEnum.TYPE_THEN).setValue(str).build();
log.info("HandServlet -> requestHandler start, condition={}", condition);
LiteFlowChainBuilder.createChain().setChainName(chainId).setCondition(condition).build();
} catch (Throwable var3) {
log.error("HandServlet -> requestHandler exception 未知异常, var3={}", var3);
}
} catch (Throwable var3) {
log.info("MqUtil->haveProducer,error", var3);
}
return Result.buildSuccess(false);
} else {
return null;
}
}
public String getPostData(HttpServletRequest request) {
StringBuilder data = new StringBuilder();
String line;
BufferedReader reader;
try {
reader = request.getReader();
while (null != (line = reader.readLine())) {
data.append(line);
}
} catch (IOException e) {
return null;
}
return data.toString();
}
private List<String> getClassObjectMap() {
List<String> result = new ArrayList<>();
WebApplicationContext webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
Map<String, ServiceScanner> serviceScannerMap = webApplicationContext.getBeansOfType(ServiceScanner.class);
ServiceScanner serviceScanner = serviceScannerMap.get("serviceScanner");
Map<Class<?>, Object> interfaceMapRef = serviceScanner.interfaceMapRef();
if (null != interfaceMapRef) {
//排序 所有接口
List<Map.Entry<Class<?>, Object>> arrayList = new ArrayList<Map.Entry<Class<?>, Object>>(interfaceMapRef.entrySet());
Collections.sort(arrayList, new Comparator<Map.Entry<Class<?>, Object>>() {
@Override
public int compare(Map.Entry<Class<?>, Object> o1, Map.Entry<Class<?>, Object> o2) {
return o1.getKey().getSimpleName().compareTo(o2.getKey().getSimpleName());
}
});
//遍历 所有接口
for (Map.Entry<Class<?>, Object> entry : arrayList) {
String className = entry.getValue().getClass().getName();
System.out.println("class = " + className);
result.add(className);
// List<Method> interfaceMethodList = Arrays.asList(entry.getKey().getDeclaredMethods());
// //方法列表排序
// Collections.sort(interfaceMethodList, new Comparator<Method>() {
// @Override
// public int compare(Method o1, Method o2) {
// return o1.getName().compareTo(o2.getName());
// }
// });
// for (Method method : interfaceMethodList) {
// System.out.println("method = " + method);
// System.out.println("methodName = " + method.getName());
// System.out.println("methodParameterTypes = " + method.getParameterTypes());
// System.out.println("methodReturn = " + method.getReturnType());
// }
}
}
System.out.println("result = " + result);
return result;
}
private boolean needLogin(HttpServletRequest request, String path) {
return this.isRequireAuth() && !this.alreadyLogin(request) && !this.checkLoginParam(request) && !"/login.html".equals(path) && !path.startsWith("/css") && !path.startsWith("/js") && !path.startsWith("/img");
}
private boolean checkLoginParam(HttpServletRequest request) {
String usernameParam = request.getParameter("loginUsername");
String passwordParam = request.getParameter("loginPassword");
if (null != this.username && null != this.password) {
return this.username.equals(usernameParam) && this.password.equals(passwordParam);
} else {
return false;
}
}
private boolean isRequireAuth() {
return this.username != null;
}
private boolean alreadyLogin(HttpServletRequest request) {
HttpSession session = request.getSession(false);
return session != null && session.getAttribute("lite-flow") != null;
}
private void returnResourceFile(String fileName, String uri, HttpServletResponse response) throws IOException {
String filePath = this.getFilePath(fileName);
if (filePath.endsWith(".html")) {
response.setContentType("text/html; charset=utf-8");
}
if (fileName.endsWith(".jpg")) {
byte[] bytes = Utils.readByteArrayFromResource(filePath);
if (bytes != null) {
response.getOutputStream().write(bytes);
}
} else {
String text = Utils.readFromResource(filePath);
if (text == null) {
response.sendRedirect(uri + "/login.html");
} else {
if (fileName.endsWith(".css")) {
response.setContentType("text/css;charset=utf-8");
} else if (fileName.endsWith(".js")) {
response.setContentType("text/javascript;charset=utf-8");
}
response.getWriter().write(text);
}
}
}
private String getFilePath(String fileName) {
return "view" + fileName;
}
2.2.2 web.xmlの構成
liteflow-util の web.xml でカスタム サーブレットを構成する
<servlet>
<servlet-name>handOfLite</servlet-name>
<servlet-class>com.xx.utils.liteflow.handler.HandServlet</servlet-class>
<init-param>
<param-name>loginUsername</param-name>
<param-value>Username</param-value>
</init-param>
<init-param>
<param-name>loginPassword</param-name>
<param-value>Password</param-value>
</init-param>
<load-on-startup>5</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>handOfLite</servlet-name>
<url-pattern>/hand-of-lite/*</url-pattern>
</servlet-mapping>
2.2.3 ページの準備
liteflow-util 内のコンポーネントを表示するページを準備する
2.2.4 ページにアクセスする
liteflow-test に liteflow-util 依存関係を追加
<dependency>
<groupId>com.xx.utils</groupId>
<artifactId>liteflow</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
liteflow-test プロジェクトを開始し、対応するパスにアクセスします。2.2.3 で準備されたページを参照してください。
2.3 コンポーネントを取得してエコーする
2.3.1 カスタム注釈
liteflow-util のアノテーションをカスタマイズして、必要なリソース クラスと構成をアセンブルおよびインポートする
@Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
@Target(value = { java.lang.annotation.ElementType.TYPE })
@Documented
@Import({LiteFlowApplicationContext.class, FlowExecutor.class, LiteflowConfig.class, IdGeneratorHolder.class})
@ComponentScan(
basePackages = {"com.xx.utils", "com.xx.utils.liteflow"}
)
public @interface EnableLiteFlow {
}
2.3.2 jar パッケージの依存関係の導入
liteflow-util に lite-flow コアの依存関係を導入する
<dependency>
<groupId>com.yomahub</groupId>
<artifactId>liteflow-spring</artifactId>
<version>2.8.3</version>
</dependency>
liteflow-test に liteflow-util 依存関係を導入する
<dependency>
<groupId>com.xx.utils</groupId>
<artifactId>liteflow</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
2.3.3 liteflow-util の設定
カスタム アノテーションを使用して必要な構成を liteflow-test にインポートする
@Configuration
@EnableLiteFlow
public class LiteFlowConfig {
}
2.3.4 表示コンポーネントクラス
liteflow-test を再起動すると、アクセス ページに取得したコンポーネント コレクションが表示されます
2.4 新しいコンポーネントの作成
liteflow-util はノードを作成および保存するための RequestMapping を提供します
@RestController
@RequestMapping("/node")
public class NodeController {
private static final Logger log = LoggerFactory.getLogger(NodeController.class);
/**
* 构建一个普通组件
*/
@RequestMapping("/createCommonNode")
@ResponseBody
public Boolean createCommonNode(@RequestBody NodeParam nodeParam) {
log.info("NodeController -> createCommonNode start, nodeParam={}", nodeParam.toString());
try {
//构建一个普通组件
LiteFlowNodeBuilder.createCommonNode().setId(nodeParam.getId()).setName(nodeParam.getName()).setClazz(nodeParam.getClazz()).build();
return Boolean.TRUE;
} catch (Exception e) {
return Boolean.FALSE;
}
}
/**
* 构建一个普通条件组件
*/
@RequestMapping("/createSwitchNode")
@ResponseBody
public Boolean createSwitchNode(@RequestBody NodeParam nodeParam) {
try {
LiteFlowNodeBuilder.createSwitchNode().setId(nodeParam.getId()).setName(nodeParam.getName()).setClazz(nodeParam.getClazz()).build();
return Boolean.TRUE;
} catch (Exception e) {
return Boolean.FALSE;
}
}
}
2.5 新しいプロセスの作成
https://liteflow.yomahub.com/pages/v2.8.X/9aa85a/
LiteFlowChainELBuilder.createChain().setChainName("chain2").setEL(
"THEN(a, b, WHEN(c, d))"
).build();
3. 全体のまとめ
実際、全体的な考え方としては、jar パッケージを提供することであり、この jar パッケージから、依存プロジェクト内のクラスの対応するコンポーネント、作成プロセス、保存プロセス、エコープロセス、実行プロセスなどを取得できます。これには、Springbean ライフサイクル、コンテキスト環境、httpsservlet、カスタム アノテーション、リフレクション、フロントエンド ページなどの関連知識の統合と適用が含まれます。
RustDesk 1.2: Flutterを使用してデスクトップ版を書き換え、 deepinで告発されたWaylandをサポート V23は2023年に最も需要の多いWSL 8プログラミング言語への適応に成功: PHPは好調、C/C++需要は鈍化 ReactはAngular.jsの瞬間を経験している? CentOS プロジェクトは「誰にでもオープン」であると主張 MySQL 8.1 および MySQL 8.0.34 が正式にリリース Rust 1.71.0 安定版 がリリース著者: JD Health Ma Renxi
出典: JD Cloud 開発者コミュニティ
{{名前}}
{{名前}}