Comment implémenter un framework d'orchestration de processus en Java

Enregistrement du processus

Nous avons mentionné précédemment que nous devons prendre en charge le modèle de processus d'enregistrement sous la forme de yml, de propriétés, de XML, de json et d'interfaces. Afin de refléter le principe de responsabilité unique, nous devons traiter la logique de. un format analysé indépendamment Afin de refléter le bon développement étendu, concernant le principe de fermeture des modifications, nous définissons d'abord un ensemble d'interfaces, puis fournissons la logique d'implémentation correspondante via le modèle d'usine ; , et l'implémentation spécifique est appelée via l'interface, et l'implémentation ici est le fournisseur, et est un ensemble de modes de stratégie.

Chargement du processus

Nous devons connaître plusieurs autres exigences fonctionnelles pour le chargement du processus : 1. Fournir une interface d'accès externe unifiée ; 2. Fournir des enregistrements d'exécution et un temps d'exécution 3. Différents nœuds de processus doivent définir différents analyseurs ; ; 4. Créer un type d'analyse via l'usine ; 5. Les nœuds de processus sont exécutés dans l'ordre.

Exécuter différentes méthodes d'analyse via différents types de nœuds Il est évident que nous devons utiliser le mode usine pour créer des classes d'analyse, et nous devons ouvrir le développement et la modification d'extensions externes, et ajouter des nœuds sans toucher aux autres. Code.Logique, ajoutez simplement un analyseur de nœud dans la fonction factory ; en même temps, nous définissons ici une collection Map pour créer l'objet d'analyse lors du chargement de la fonction factory, au lieu de créer un analyseur à chaque fois qu'il est analysé, ce qui réduit les inutiles. Le code de la mémoire

est le suivant :

<code>public class NodeComponentFactory {<br><br>    private final static Map<string> cacheParser = new HashMap();<br><br>    static {<br>        cacheParser.put(NodeParserEnum.method.name(),new MethodNodeComponent());<br>        cacheParser.put(NodeParserEnum.bean.name(),new BeanNodeComponent());<br>        cacheParser.put(NodeParserEnum.condition.name(),new ConditionNodeComponent());<br>        cacheParser.put(NodeParserEnum.service.name(),new ServiceNodeComponent());<br>        cacheParser.put(NodeParserEnum.subflow.name(),new SubFlowNodeComponent());<br>    }<br><br>    public static NodeParser getNodeInstance(String nodeName){<br>        return cacheParser.get(nodeName);<br>    }<br>}<br></string></code>

Lorsque nous constatons que chaque type d'analyse de nœud doit implémenter l'interface de l'analyseur et que chaque nœud a des étapes similaires, alors nous devons envisager d'utiliser ici une usine abstraite, qui est également conforme à un Le Le principe de conception de l'inversion des dépendances est que le module supérieur est accessible via l'interface de dépendance. Le module suivant hérite de la classe abstraite et utilise également le modèle de stratégie pour effectuer des appels d'interface dans le processus logique d'implémentation, nous constaterons que beaucoup ; les étapes sont répétées, telles que l'initialisation. En saisissant les paramètres et en exécutant les enregistrements, nous mettons tout le contenu répété dans des classes abstraites et utilisons le mode modèle pour laisser les nœuds de processus se concentrer uniquement sur le niveau d'analyse

<code>public abstract class AbstractNodeComponent implements NodeParser{<br><br>    public Map<string node> nodeMap;<br><br><br>    /**<br>     * 初始化参数<br>     * @param inputUrl<br>     * @param baseInput<br>     * @return<br>     */<br>    public BaseInput initInput(String inputUrl, BaseInput baseInput){<br>        BaseInput baseInputTarget = ClassUtil.newInstance(inputUrl, BaseInput.class);<br>        BeanUtils.copyProperties(baseInput,baseInputTarget);<br>        return baseInputTarget;<br>    }<br><br><br>    /**<br>     * 解析节点信息<br>     * @param node 节点信息<br>     * @param baseInput 请求参数<br>     * @param baseTemp 临时上下文<br>     * @return<br>     */<br>    public BaseOutput parserNode(Node node, BaseInput baseInput, BaseTemp baseTemp){<br>        baseTemp.setFlowRecord(baseTemp.getFlowRecord().append(FlowConstants.NODEKEY+FlowConstants.NODE+FlowConstants.COLON+node.getId()));<br>        BaseOutput baseOutput = parser(node, baseInput, baseTemp);<br>        return baseOutput;<br>    };<br><br>    @Override<br>    public void setNodeMap(Map<string node> nodeMap) {<br>        this.nodeMap = nodeMap;<br>    }<br><br>    @Override<br>    public abstract BaseOutput parser(Node node, BaseInput baseInput, BaseTemp baseTemp);<br><br>}</string></string></code>

Ordre de chargement du processus

 ; Pour l'exécution du processus, nous devons diviser les composants en plusieurs parties. Finement, il est préférable de diviser la classe qui implémente indépendamment une fonction en un composant, qui incarne le principe de responsabilité unique. Ce n'est qu'en divisant très finement la fonction d'exécution que cela peut être fait. combiné de manière flexible dans chaque processus d'exécution de processus ; dans l'organigramme ci-dessous, vous pouvez voir plusieurs composants, le premier est l'entrée pour une exécution unifiée du processus. Il sera utilisé à deux endroits. , et le deuxième est l'entrée pour l'exécution du sous-processus ; le deuxième composant est le nœud qui charge le composant de gestion de manière unifiée, qui est la classe d'usine mentionnée ci-dessus ; le troisième est le propre analyseur de chaque composant, qui est utilisé pour ; mettre en œuvre le fonctionnement de différents types de nœuds ; dans le processus de conception, vous devez connaître la relation entre le processus, la gestion et les nœuds. Les limites entre les composants réduisent le couplage, afin que les différents composants puissent être composés de manière flexible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!