Combien de connexions JDBC en Java?

J’ai un programme Java composé d’environ 15 méthodes. Et, ces méthodes sont très fréquemment invoquées pendant l’exécution du programme. Pour le moment, je crée une nouvelle connexion dans chaque méthode et y invoque des instructions (la firebase database est configurée sur une autre machine du réseau).

Ce que j’aimerais savoir, c’est: Devrais-je créer une seule connexion dans la méthode principale et le transmettre en tant qu’argument à toutes les méthodes nécessitant un object de connexion, car cela réduirait considérablement le nombre d’objects de connexion dans le programme, au lieu de créer et la fermeture des connexions très fréquemment dans chaque méthode.

J’imagine que je n’utilise pas les ressources de manière très efficace avec la conception actuelle et que des améliorations sont encore possibles, étant donné que ce programme pourrait se développer considérablement à l’avenir.

    Oui, vous devriez envisager de réutiliser les connexions plutôt que d’en créer une à chaque fois. La procédure habituelle est la suivante:

    • devinez combien de connexions simultanées votre firebase database peut raisonnablement gérer (par exemple, commencez avec 2 ou 3 par CPU sur la machine de firebase database jusqu’à ce que vous découvriez que c’est trop peu ou trop – ça va avoir tendance à dépendre de la façon dont le disque -bound vos requêtes sont)
    • créer un pool de ce nombre de connexions: essentiellement une classe dans laquelle vous pouvez demander “la prochaine connexion libre” au début de chaque méthode, puis “repasser” au pool à la fin de chaque méthode
    • votre méthode getFreeConnection () doit renvoyer une connexion libre, le cas échéant, sinon (1) créez-en une nouvelle, jusqu’au nombre maximal de connexions que vous avez décidé d’autoriser, ou (2) si le nombre maximal est déjà créé. , attendez qu’il devienne libre
    • Je recommande la classe Semaphore pour gérer les connexions; J’ai en fait un court article sur mon site Web sur la gestion d’un pool de ressources avec un sémaphore avec un exemple que je pense que vous pourriez adapter à votre objective.

    Quelques considérations pratiques:

    • Pour des performances optimales, vous devez faire attention à ne pas “coïncider” une connexion lorsque vous ne l’utilisez pas pour exécuter une requête . Si vous établissez une connexion à partir du pool une fois, puis que vous la transmettez à diverses méthodes, vous devez vous assurer que vous ne le faites pas par inadvertance.
    • N’oubliez pas de retourner vos connexions à la piscine! (essayez / est enfin votre ami ici …)
    • Sur de nombreux systèmes, vous ne pouvez pas garder les connexions ouvertes «pour toujours» : le système d’exploitation les fermera au bout d’un certain temps. Ainsi, dans votre méthode «renvoyer une connexion au pool», vous devrez penser à «supprimer» les connexions qui existent depuis longtemps (intégrez un mécanisme de mémorisation, par exemple, en disposant un object wrapper autour d’un JDBC réel. Objet de connexion que vous pouvez utiliser pour stocker des mesures telles que celle-ci)
    • Vous voudrez peut-être envisager d’utiliser des instructions préparées.
    • Au fil du temps, vous devrez probablement modifier la taille du pool de connexions

    Vous pouvez passer la connexion ou, mieux, utiliser quelque chose comme le regroupement de bases de données Jakarta. http://commons.apache.org/dbcp/

    Vous devriez utiliser un pool de connexion pour cela.

    De cette façon, vous pouvez demander la connexion et la libérer lorsque vous avez terminé et la renvoyer à la piscine.

    Si un autre thread souhaite une nouvelle connexion et que celle-ci est en cours d’utilisation, une nouvelle connexion peut être créée. Si aucun autre thread n’utilise une connexion, la même chose pourrait être réutilisée.

    De cette façon, vous pouvez laisser votre application telle qu’elle est (et ne pas passer la connexion tout autour) et continuer à utiliser les ressources correctement.

    Malheureusement, les ConnectionPools de première classe ne sont pas très faciles à utiliser dans les applications autonomes (ce sont les serveurs d’applications par défaut). Un microconteneur (tel que Sping) ou un bon framework (tel que Hibernate) pourrait probablement vous permettre de l’utiliser.

    Cependant, ils ne sont pas trop difficiles à coder.

    🙂

    Cette recherche google vous aidera à en savoir plus sur l’utilisation de celui-ci.

    Parcourir

    De nombreux pilotes JDBC font de la mise en pool de connexions pour vous, il est donc peu avantageux de regrouper des ressources supplémentaires dans ce cas. Je vous suggère de consulter la documentation de votre pilote JDBC.

    Une autre approche des pools de connexion consiste à

    • Avoir une connexion pour tous les access à la firebase database avec un access synchronisé. Cela ne permet pas la simultanéité mais est très simple.
    • Stocker les connexions dans une variable ThreadLocal (override initialValue ()) Cela fonctionne bien s’il y a un petit nombre fixe de threads.

    Sinon, je suggère d’utiliser un pool de connexion.

    Si votre application est à thread unique ou effectue toutes ses opérations de firebase database à partir d’un seul thread, vous pouvez utiliser une seule connexion. En supposant que vous n’ayez pas besoin de plusieurs connexions pour une autre raison, ce serait de loin l’implémentation la plus simple.

    En fonction de votre pilote, il peut également être possible de partager une connexion entre les threads. Ce serait également correct si vous ne faisiez pas confiance à votre pilote pour ne pas mentir au sujet de la sécurité de son thread. Consultez la documentation de votre pilote pour plus d’informations.

    En règle générale, les objects situés sous “Connexion” ne peuvent pas être utilisés en toute sécurité à partir de plusieurs threads. Il est donc déconseillé de partager les objects ResultSet, Statement, etc. entre les threads – de loin la meilleure politique consiste à les utiliser dans le même thread de création. Ceci est normalement facile car ces objects ne sont généralement pas conservés trop longtemps.