Depuis que j'ai commencé à utiliser Java 8 pour les entreprises, j'ai cherché des moyens d'écrire un code un peu plus fluide à l'aide d'expressions lambda. J'ai enfin écrit un bon code ces derniers temps, alors j'aimerais le partager avec les ingénieurs Java, donc j'écris un article sur Qiita pour la première fois.
Cette fois, je voudrais décrire uniquement l'échantillon et présenter le mécanisme derrière celui-ci séparément.
https://github.com/mt-village/nagare
L'échantillon est un programme qui imite la procédure de préparation du café.
python
public void easygoing() {
WholeCoffeeBeans wholeBeans = WholeCoffeeBeans.inGrams(50);
GroundCoffeeBeans groundBeans = Mill.grind(wholeBeans);
Water water = Water.inMilliliters(500);
HotWater hotWater = Kettle.boil(water);
Coffee coffee = Dripper.drip(groundBeans, hotWater);
CoffeeAddict saya = new CoffeeAddict();
saya.drink(coffee);
}
Écrit en japonais, c'est quand Saya boit du café extrait avec un goutteur après avoir moulu des grains de café avec un moulin et de l'eau bouillante avec un yakan. Je l'écris volontairement soigneusement sans imbriquer, mais c'est assez gênant car je dois écrire le moule un par un.
Vous pouvez écrire le même processus comme suit
python
public void impatient() {
new CoffeeAddict().drink(Dripper.drip(
Mill.grind(WholeCoffeeBeans.inGrams(50)), Kettle.boil(Water.inMilliliters(500))));
}
C'est beaucoup plus court, mais c'est un peu dur pour le cerveau humain car il a une structure double imbriquée et doit être interprété dans l'ordre de l'intérieur vers l'extérieur.
En utilisant les 8 classes ajoutées par nagare, la description suivante est possible.
python
public void nagare_prepositive() {
CoffeeAddict saya = new CoffeeAddict();
Do.when(WholeCoffeeBeans.inGrams(50), Water.inMilliliters(500))
.then(Do.first(Mill::grind).and(Kettle::boil))
.then(Dripper::drip)
.done(saya::drink);
}
python
public void nagare_postpositive() {
CoffeeAddict saya = new CoffeeAddict();
Do.first(Mill::grind).and(Kettle::boil)
.then(Dripper::drip)
.done(saya::drink)
.by(WholeCoffeeBeans.inGrams(50), Water.inMilliliters(500));
}
python
public void nagare_logic_and_exec() {
Saver<Coffee> brewCoffee = Do.when(WholeCoffeeBeans.inGrams(50), Water.inMilliliters(500))
.then(Do.first(Mill::grind).and(Kettle::boil))
.then(Dripper::drip);
CoffeeAddict saya = new CoffeeAddict();
saya.drink(brewCoffee.let());
}
L'idée de base est similaire à Stream ajouté dans Java 8. La première est la méthode d'écriture qui donne l'argument en premier, la seconde est la méthode d'écriture qui donne l'argument à la fin, et la troisième est la méthode d'écriture qui sépare la logique et l'exécution.
Vous pouvez écrire une série de processus dans l'ordre de gauche à droite (de haut en bas), donc une fois que vous vous y serez habitué, vos pensées et votre code correspondront et ce sera assez amusant. Essayez-le avec le code que vous écrivez comme passe-temps. (Je ne sais pas si quelqu'un écrit Java comme passe-temps)
Des échantillons sont également inclus en tant que test unitaire, donc si vous souhaitez le combiner avec le mécanisme qui le sous-tend, veuillez jeter un coup d'œil. https://github.com/mt-village/nagare
Recommended Posts