Pourquoi ne pas utiliser des méthodes statiques pour les ressources externes?

Question

Je suis un fan des méthodes statiques dans Java pour, par exemple, dans Util-classes. Mais parmi certains collègues, j'ai rencontré certains arguments selon lesquels une méthode statique ne devrait jamais utiliser de ressources externes. Mais personne ne pourrait expliquer pourquoi cela devrait être mauvais ou même dangereux. La seule raison que j'ai trouvée est qu'il peut être difficile de se moquer de cette ressource externe pendant le test. Mais est-ce vraiment la seule raison?

Ci-dessous, j'ai un exemple de méthode statique. J'aimerais comprendre pourquoi il devrait être une mauvaise approche pour l'utiliser avec statique.

public class JmsUtil { 
    public static String sendBytesMessage(byte[] messageBytes) throws JMSException, NamingException { 
     String jmsMessageID = null; 
     Connection connection = null; 
     try { 
      Context context = new InitialContext(); 
      ConnectionFactory connectionFactory = (ConnectionFactory) context.lookup("ourfactory"); 
      Queue queue = (Queue) context.lookup("ourqueue"); 

      connection = connectionFactory.createConnection(); 
      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); 
      MessageProducer messageProducer = session.createProducer(queue); 
      BytesMessage bytesMessage = session.createBytesMessage(); 
      bytesMessage.writeBytes(messageBytes); 

      messageProducer.send(bytesMessage); 
      jmsMessageID = bytesMessage.getJMSMessageID();  
     } finally { 
      if (connection != null) { 
       connection.close(); 
      } 
     } 
     return jmsMessageID; 
    } 
} 

Meilleures salutations

Answer 1

considèrent deux classes

class Foo extends Blob{ 

public void someMethod(){ 
byte[] message = createMessage(); 
JmsUtil.sendBytesMessage(message); 
} 

} 

class Bar extends Blob{ 
Sender sender; 

public void someMethod(){ 
byte[] message = createMessage(); 
sender.sendBytesMessage(message); 
} 

} 

classe Foo utilise classe utilitaire, tandis que la classe Bar utilise la classe qui implémente l'interface Sender. Tout d'abord, comme vous l'avez mentionné dans votre question, il est beaucoup plus facile de simuler l'émetteur à des fins de test. Sinon, vous devez créer une infrastructure pouvant recevoir un message pour valider l'ensemble du processus.

Deuxième chose, vous perdez la possibilité d'abstraire des fonctionnalités. Imaginez la situation où vous devez changer la façon dont vous envoyez un message. Dans le premier cas, vous devez effectuer une modification en classe qui gère la logique de votre système. en second lieu que vous avez résumé le processus d'envoi de message, tout ce que vous devez faire changer dans le module responsable de l'amorçage de votre application. dans certains cas ce changement peut être fait dans votre fichier de configuration et fait sur le système en direct

Answer 2

Le principal problème avec les méthodes statiques est que vous ne pouvez pas facilement changer l'implémentation. Les méthodes statiques ne peuvent pas avoir d'interfaces.

Ceci est mauvais pour de nombreuses raisons mais concentrons-nous sur l'accès aux ressources externes.

Avec des méthodes statiques, la testabilité devient un gros problème. Soit vous avez besoin de la ressource externe pour les tests OU vous testez "autour" de vos méthodes statiques. Si vous aviez une interface MessageSender à la place, vous pourriez facilement vous moquer de lui dans le test et vérifier seulement s'il a été appelé comme prévu.

Ensuite, vous devrez parfois décorer l'accès à des ressources externes. Par exemple, si vous avez un client REST de recherche, vous pouvez décider ultérieurement d'ajouter un cache pour améliorer les performances. C'est beaucoup plus facile avec les interfaces.