Conventions de codage personnel Java DSL utilisées dans la construction de routes Apache Camel

Dans Apache Camel, lors de la création d'une "route", écrivez-la dans Original DSL qui connecte simplement les méthodes préparées. Ce DSL prend également en charge le ** branchement conditionnel ** et la ** boucle **.

Cependant, si vous écrivez selon le guide de style Java, les méthodes qui créent un branchement conditionnel et un traitement interne en boucle auront également la même indentation, ce qui rendra très difficile la lecture en tant que DSL. Par conséquent, on considère que ** il est préférable d'ajouter le retrait par vous-même **.

De plus, il existe plusieurs façons d'écrire d'autres parties, mais je souhaite les unifier du côté qui est facile à lire. J'ai donc résumé les normes de codage que j'ai décidées personnellement. Seules les fonctions que j'ai utilisées peuvent être décidées, donc je les ajouterai ou les modifierai au fur et à mesure que mon expérience augmentera à l'avenir.

RouteBuilder A propos de la forme de tout l'itinéraire qui en est la base. Seul le contenu de configure () est affiché.

from("direct:sample").routeId("MySampleRoute")
		// some process
		.to("mock:aaa").id("SamplePartA")
		.log(LoggingLevel.DEBUG,
				"very long text...")

		// another process
		.to("mock:bbb")
;

Fondamentalement ** Méthode 1 ligne 1 ** (1 processus)
Cependant, la même ligne est recommandée pour ceux qui se qualifient immédiatement avant
Par exemple, ʻid () ʻest la même ligne (pensez à XML DSL)
routeId () définit l'ID de la route, donc la même ligne que from (), au moins la ligne suivante
Fournissez une ligne vide si vous souhaitez représenter une unité de traitement de groupe
Ajouter deux retraits (*) pour les lignes continues
Conforme au style Java
Indentez 2 étapes même lorsque l'argument de la méthode est cassé
Si l'argument est trop long, envisagez de le couper en une constante
Inversement, seul le début «from ()» apparaît en deux étapes
** Indentation supplémentaire lors de la structuration avec DSL ** (décrit plus loin)
Ending ; sépare les lignes
Lors de l'ajout du traitement, diff n'apporte pas de modifications inutiles
Retrait 1 étape = 4 espaces (checkstyle) ou 1 tabulation, qui doit être spécifié séparément

Structuré

Ceux qui créent des branches et des boucles conditionnelles sont fondamentalement «xxx ()» à «end ()». Les règles communes sont les suivantes.

** Indentez l'intérieur d'un pas **
Rendre les blocs visuellement reconnaissables
Correspond à la syntaxe de la même fonction de Java
** N'omettez pas ʻend () `**
Lors de l'ajout du traitement à la dernière étape, si vous oubliez ʻend () `, la signification changera.
Ne pas utiliser même si ʻendXxx () ʻ est préparé (est-il utilisé différemment?)
L'option doit être sur la même ligne que xxx () (si elle est plus longue, passez à la ligne suivante et abaissez-la d'un pas)

choice Correspond à une instruction switch (break n'est pas obligatoire). Cependant, puisque l'expression conditionnelle est écrite du côté when, SQL et la * déclaration de cas sans expression * qui peut être faite avec Ruby sont meilleures. C'est pareil.

https://camel.apache.org/components/latest/eips/choice-eip.html

from("direct:sample")
		.choice()
			.when(new MyPredicateA())
				.to("mock:aaa")
			.when(new MyPredicateB())
				.to("mock:bbb")
			.otherwise()
				.to("mock:zzz")
		.end()
;

when () et ʻotherwise () `sont abaissés d'une étape, et le traitement interne est abaissé d'une étape.
Comment écrire selon l'instruction de commutation Java
Au fait, quand est une expression de cas Ruby, quand n'est pas abaissé (car c'est la même chose que elsif)
Ecrire une condition dans l'argument de quand ()
quand (). Simple (...) etc. sont interdits
ʻOtherwise () ʻest omis s'il n'y a pas de traitement

Spécifiez une instance de «Predicate» dans la condition. (Documentation)

Utilisez votre propre classe
Obtenez un booléen directement avec header (name) ou simple (" $ {expr} ") (ValueBuilder)
Dériver un booléen comme header (name) .isEqualTo (value) (PredicateBuilder)

filter Si vous n'avez qu'une seule branche when (), envisagez d'utiliser filter () au lieu de choice (). Le nombre de lignes et de retraits est réduit, ce qui facilite la lecture. Particulièrement utile lors de l'écriture de clauses de garde.

https://camel.apache.org/components/latest/eips/filter-eip.html

`Exemple de clause de garde`


//Difficile à lire sans clause de garde (* Ceci n'est pas limité au chameau)
from("direct:noGuard")
		.choice()
			.when(new MyPredicate())
				.to("mock:doNothing")
			.otherwise()
				.to("mock:doSomething1")
				.to("mock:doSomething2")
				.to("mock:doSomething3")
		.end()
;

//Vous pouvez faire une clause de garde avec choix, mais c'est un peu exagéré
from("direct:guardByChoice")
		.choice()
			.when(new MyPredicate())
				.to("mock:doNothing")
				.stop()
		.end()

		.to("mock:doSomething1")
		.to("mock:doSomething2")
		.to("mock:doSomething3")
;

//Concis avec filtre
from("direct:guardByFilter")
		.filter(new MyPredicate())
			.to("mock:doNothing")
			.stop()
		.end()

		.to("mock:doSomething1")
		.to("mock:doSomething2")
		.to("mock:doSomething3")
;

split Correspond à instruction for extended (for-each instruction) et à la méthode forEach. Les listes et les chaînes de caractères sont séparées et emballées individuellement dans un nouvel échange pour traitement.

https://camel.apache.org/components/latest/eips/split-eip.html

from("direct:sample")
		.split(body()).parallelProcessing()
			.log("content: ${body}")
			.to("mock:abc")
		.end()
;

Ecrivez le split dans l'argument de split ()
split (). body () etc. sont interdits

loop, while Vous pouvez indexer le nombre de boucles (à partir de 0). Utilisez loop () pour spécifier le nombre de fois comme l'instruction for, et loopDoWhile () pour spécifier la condition comme l'instruction while.

https://camel.apache.org/components/latest/eips/loop-eip.html

from("direct:sample")
		.loop(100).copy()
			.log("index: ${exchangeProperty[CamelLoopIndex]}")
			.to("mock:abc")
		.end()
;

try … catch … finally Il existe également une gestion des exceptions.

https://camel.apache.org/manual/latest/try-catch-finally.html

Encore une fois, selon la syntaxe Java, doTry (), doCatch (), doFinally (), ʻend () ʻont le même retrait, et l'intérieur de chacun est abaissé d'une étape.

Exemple: https://github.com/apache/camel/blob/camel-2.25.1/camel-core/src/test/java/org/apache/camel/processor/TryProcessorMultipleExceptionTest.java

`TryProcessorMultipleExceptionTest.java`


from("direct:start")
		.doTry()
			.process(new ProcessorFail())
			.to("mock:result")
		.doCatch(IOException.class, IllegalStateException.class)
			.to("mock:catch")
		.doFinally()
			.to("mock:finally")
		.end()
;

L'argument est-il une chaîne de méthodes?

La méthode suivante consiste à mettre des données en échange.

setHeader()
setProperty()
setBody()

Il existe deux méthodes, "spécifier par argument" et "spécifier par chaîne de méthodes". Dans la convention, ** unifiez à "spécifier par argument" **. Je pense qu'il est plus facile de comprendre si la seule méthode qui compose l'itinéraire est un processus tel qu'il est.

Il est basé sur la même idée que l'argument est spécifié pour «when ()» et «split ()» dans la structuration.

// disliked
from("direct:dislikedSample")
		.setHeader("foo").expression(new MyExpression())
		.setProperty("bar").header("foo")
		.setBody().exchangeProperty("bar")
;

// preferred
from("direct:preferredSample")
		.setHeader("foo", new MyExpression())
		.setProperty("bar", header("foo"))
		.setBody(exchangeProperty("bar"))
;

Spécifiez une instance de ʻExpression` comme argument. (Documentation)

Utilisez votre propre classe
Spécifiez un objet Java directement avec constant (obj)
Obtenez la valeur avec header (name) ou simple (" $ {expr} ")

Exception de règle

Cependant, s'il devient compliqué de spécifier l'argument, utilisez une chaîne de méthodes. Dans ce cas, écrivez autant que possible sur la même ligne.

Par exemple, marshal (). Il existe également une méthode pour passer une chaîne de caractères comme argument, mais si possible, j'aimerais utiliser une constante préparée pour éviter les fautes de frappe. Ensuite, l'argument sera plus long.

from("direct:marshalSample")
		.marshal().json(JsonLibrary.Gson)
		.marshal(new JsonDataFormat(JsonLibrary.Gson))
;

Expression d'expression

Dans la chaîne de caractères de l'argument de log (), la même extension d'expression que simple () (je ne sais pas si elle est appelée ...) peut être écrite.

https://camel.apache.org/components/latest/languages/simple-language.html

from("direct:loggingSample")
		.log("foo :: ${header[foo]}")
		.log("bar :: ${exchangeProperty[bar]}")
		.log("baz :: ${body}")
;

les éléments d'en-tête et de propriété peuvent être référencés par n'importe lequel des éléments .name,: name, [name]
Puisque ce sont des cartes en échange, je pense que «[nom]» est bon comme un tableau associatif.
Ne citez pas les clés sauf si nécessaire
Utilisez la variable header et non headers lors du référencement d'éléments dans l'en-tête
Correspond au nom de la méthode utilisée pour construire la route

Vous pouvez écrire des expressions plus puissantes telles que des appels de méthode, mais les règles détaillées n'ont pas encore été décidées. → https://camel.apache.org/components/latest/languages/ognl-language.html

Sélectionnez en fonction de la situation

Parfois, vous pouvez faire quelque chose de similaire de différentes manières. Il est plus lisible de choisir celui qui convient à l'objectif et celui qui est spécialisé à cet effet.

Sortie de journal

Il existe deux types disponibles. Vous ne devriez pas vous perdre car l'utilisation est différente.

Log EIP ← Messages de sortie pour les humains
Composant de journal ← Informations d'échange de sortie

from("direct:start")
		.log(LoggingLevel.DEBUG, "org.apache.camel.sample", "any message")
		.to("log:org.apache.camel.sample?level=DEBUG&showAll=true&multiline=true")
;

choix ou filtre

Comme expliqué dans la section sur la structuration. Vous pouvez penser que filter () ne peut écrire que la branche d'une instruction if (sans else).

Expression d'expression ou combinaison de méthodes

Simple Expression Language peut créer diverses valeurs et expressions conditionnelles en utilisant ** expansion d'expression ** (?). D'autre part, les valeurs normales (ValueBuilder) Il existe également des méthodes qui peuvent être utilisées. Écrire dans une méthode augmente les chances de remarquer une simple erreur au moment de la compilation, mais sans une bonne méthode, elle a tendance à être longue. Celui qui est le plus facile à lire dépend de la situation, c'est donc à titre indicatif seulement.

from("direct:simpleOrValue")
		// create same strings
		.setHeader("sample1", simple("hoge: ${header[hoge]}"))
		.setHeader("sample2", header("hoge").prepend("hoge: "))

		// check same conditions
		.choice()
			.when(simple("${header[CamelSqlRowCount]} != 1"))
				.log("record not unique!")
			.when(header(SqlConstants.SQL_ROW_COUNT).isNotEqualTo(1))
				.log("record not unique!")
		.end()
;