Traitement de la complexité cyclomatique dans le code Java

Traitement de la complexité cyclomatique dans le code Java Présentation de Debadatta MishraVous avez peut-être entendu le terme gestion de code en java. Il fait référence à la façon de gérer votre code source afin qu'il soit plus facile dans une certaine mesure de le gérer au moment de la maintenance. Il est toujours vrai que les exigences changent de temps en temps et que le code source subit un changement dans une certaine mesure. Vous avez peut-être vu un module particulier qui semble très risqué à toucher. Certaines personnes disent que ce module fonctionne bien mais que le code est ingérable. Cela se produit dans la plupart des industries informatiques, il peut y avoir plusieurs raisons. Cependant, je peux dire que l'écriture de code est un art. Certains développeurs prennent cette question très au sérieux. Vous pouvez trouver l'occasion de la revue de code et de l'audit de code dans l'organisation. Comment écrire le meilleur code dépasse le cadre de cet article.Dans cet article, je voudrais me concentrer sur la complexité cyclomatique qui est beaucoup plus répandue dans le code source. Il est également vrai que vous pouvez vous tenir à l'écart de ce concept. La note clé est de savoir comment gérer la complexité du code.

Techniques

La complexité cyclomatique est un concept métrique qui a été inventé par Thomas McCabe. Il donne la notion de complexité structurelle d'une méthode ou d'un code source. Fondamentalement, il traite des différents cas décisionnels et conditionnels. Si vous écrivez un morceau de code qui inclut plusieurs décisions et conditions logiques, vous devez prendre soin de ce morceau de code, sinon vous risquez de vous retrouver dans des conditions décroissantes. La principale raison pour laquelle je peux dire que cela se produit en raison de la correction de bogues et de quelques modifications mineures des exigences. Si un développeur oublie certains des cas fonctionnels, il peut corriger un bogue en ajoutant une ou plusieurs conditions logiques en écrivant if ou imbriquées if conditions. En général, la complexité cyclomatique peut être calculée des manières suivantes.

Complexité cyclocmatique = Nombre de points de décision + 1 Les points de décision peuvent être vos instructions conditionnelles comme if, if… else, switch, for loop, while loop etc.

Veuillez vous référer à l'exemple suivant String str = "someString"; if (str.equals (case1)) faire quelque chose; if (str.equals (case2)) faire quelque chose; sinon faites la chose par défaut;

Ici, la complexité cyclomatique sera la suivante Complexité cyclomatique = si pour cas1 + si pour cas2 + sinon + 1 = 4 La complexité cyclomatique a plus d'importance dans le domaine des tests et de la maintenabilité. Si vous écrivez des cas de test, vous devez garder un œil sur la complexité cyclomatique. Si la complexité cyclomatique est de 3, vous devez écrire au moins e cas de test valides. Le tableau suivant décrit le type d'application. La complexité cyclomatique se situe entre 1 - 10  À considérer Application normale La complexité cyclomatique se situe entre 11 et 20  Application modérée La complexité cyclomatique se situe entre 21 et 50  Application risquée La complexité cyclomatique est supérieure à 50  Application instable Outre les opérateurs logiques comme «&&», «|| " s'ajoutent également à la complexité cyclomatique. Si vous écrivez le programme comme suit If (name.equals (name1) || name.égal à (nom2) || name.equals (name3) && age! = 23) {do something} Ici, la complexité cyclomatique peut être calculée comme suit: Nombre de points de décion + nombre d'opérateurs logiques + 1 qui est égal à If + || + || + && + 1 = 5 Il est également vrai que cela aura un impact sur les performances de l'application. Cependant, vous pouvez le voir dans une certaine conception, il peut y avoir plusieurs cas et chaque cas doit être traité d'une manière complètement différente, certains développeurs écrivent en utilisant la conception d'usine. Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.equals (name3) && age! = 23) {do something} Ici, la complexité cyclomatique peut être calculée comme suit Nombre de points de décion + nombre d'opérateurs logiques + 1 qui est égal à If + || + || + && + 1 = 5 It est également vrai que cela aura un impact sur les performances de l'application. Cependant, vous pouvez le voir dans une certaine conception, il peut y avoir plusieurs cas et chaque cas doit être traité d'une manière complètement différente, certains développeurs écrivent en utilisant la conception d'usine. Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.equals (name3) && age! = 23) {do something} Ici, la complexité cyclomatique peut être calculée comme suit Nombre de points de décion + nombre d'opérateurs logiques + 1 qui est égal à If + || + || + && + 1 = 5 It est également vrai que cela aura un impact sur les performances de l'application. Cependant, vous pouvez le voir dans une certaine conception, il peut y avoir plusieurs cas et chaque cas doit être traité d'une manière complètement différente, certains développeurs écrivent en utilisant la conception d'usine. Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.= 23) {faire quelque chose} Ici, la complexité cyclomatique peut être calculée comme suit: Nombre de points de décion + nombre d'opérateurs logiques + 1 qui est égal à If + || + || + && + 1 = 5 Il est également vrai qu'il aura impact sur les performances de l'application. Cependant, vous pouvez le voir dans une certaine conception, il peut y avoir plusieurs cas et chaque cas doit être traité d'une manière complètement différente, certains développeurs écrivent en utilisant la conception d'usine. Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.= 23) {faire quelque chose} Ici, la complexité cyclomatique peut être calculée comme suit: Nombre de points de décion + nombre d'opérateurs logiques + 1 qui est égal à If + || + || + && + 1 = 5 Il est également vrai qu'il aura impact sur les performances de l'application. Cependant, vous pouvez le voir dans une certaine conception, il peut y avoir plusieurs cas et chaque cas doit être traité d'une manière complètement différente, certains développeurs écrivent en utilisant la conception d'usine. Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.+1 = 5 Il est également vrai que cela aura un impact sur les performances de l'application. Cependant, vous pouvez le voir dans une certaine conception, il peut y avoir plusieurs cas et chaque cas doit être traité d'une manière complètement différente, certains développeurs écrivent en utilisant la conception d'usine. Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.+1 = 5 Il est également vrai que cela aura un impact sur les performances de l'application. Cependant, vous pouvez le voir dans une certaine conception, il peut y avoir plusieurs cas et chaque cas doit être traité d'une manière complètement différente, certains développeurs écrivent en utilisant la conception d'usine. Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.Dans cette conception d'usine, il peut y avoir un boîtier de commutation ou plusieurs conditions sinon. Laissez-moi vous donner un exemple. Considérons un gestionnaire qui gère complètement différent en fonction de l'entrée. Si le cas est «A», il doit être traité d'une manière particulière, s'il s'agit du cas «B», il doit être traité d'une autre manière. Examinons le morceau de code suivant.

 Interface Handler package com.core.cc.handler; /** * @author Debadatta Mishra(PIKU) * */ public interface Handler { public void handle(); } 
Classe AHandler
 package com.core.cc.handler; /**This class implements Handler * @author Debadatta Mishra(PIKU) * */ public class AHandler implements Handler { public void handle() { System.out.println("A handler"); } } 
Classe BHandler
 package com.core.cc.handler; /**This class implements Handler Interface * @author Debadatta Mishra(PIKU) * */ public class BHandler implements Handler { public void handle() { System.out.println("B handler"); } } 
classe AbstractHandler
 package com.core.cc.handler; /**This class is used as a Factory class. * @author Debadatta Mishra(PIKU) * */ public class AbstractHandler { /**This is a very traditional method, you * can obtain the dynamic object by using * several if conditions. * @param handlerName * @return an object of type {@link Handler} */ public static Handler getHandler( String handlerName ) { Handler handler = null; try { if( handlerName.equals("A")) handler = new AHandler(); if( handlerName.equals("B") ) handler = new BHandler(); } catch( Exception e ) { System.out.println("There is no specific handler"); } return handler; } } 
classe TestDynamicHandler
 import com.core.cc.handler.AbstractHandler; import com.core.cc.handler.Handler; /**This is a testharness class. * @author Debadatta Mishra(PIKU) * */ public class TestDynamicHandler { public static void main(String[] args) { Handler handler = AbstractHandler.getHandler("B"); handler.handle(); } } 

Dans les exemples ci-dessus, il n'y a rien de mal à écrire le code ceci, mais le compilateur peut prendre un certain temps lorsque vos cas augmentent. Pour chaque nouveau cas, vous devez écrire une nouvelle classe et vous devez ajouter une ou plusieurs clauses if dans la classe «AbstractHandler». Vous pouvez modifier la classe «AbstractHandler» de la manière suivante pour qu'elle paraisse très sophistiquée et ainsi il n'y a pas besoin de mettre à jour la classe «AbstractHandler».

 package com.core.cc.handler; /**This class is used as a Factory class. * @author Debadatta Mishra(PIKU) * */ public class AbstractHandler { /**This method is used to obtain the dynamic * object of the type Handler * @param handlerName * @return an object of type {@link Handler} */ public static Handler getHandler( String handlerName ) { Handler handler = null; try { handler = (Handler) Class.forName( "com.core.cc.handler." + handlerName + "Handler") .newInstance(); } catch( Exception e ) { System.out.println("There is no specific handler"); } return handler; } } 

The above code simplifies your programming and provides the flexibility to add your cases without bringing major changes. After all this is the beauty of the Java Factory Design. In this regard you can make an argument that , reflection is slower from the point of performance, I can say that it will be faster as compared to many if … else clause. However there are several ways you can write beautiful code to avoid major cyclomatic complexity.

Conclusion

I hope that you will enjoy my article. If you find any problems or errors, please feel free to send me a mail in the address

[email protected]

. This article is only meant for those who are new to java development. This article does not bear any commercial significance. Please provide me the feedback about this article.

Cette histoire, "Gérer la complexité cyclomatique dans le code Java" a été publiée à l'origine par JavaWorld.