1. Qu'est-ce que le pool de connexions JDBC?
Dans les connexions JDBC traditionnelles, chaque fois que vous obtenez une connexion de connexion, vous devez charger un code compliqué à obtenir, comme le code suivant:
Connexion statique publique getConn () {connexion conn = null; String url = "jdbc: mysql: // localhost: 3306 / test"; String user = "root"; Chaîne mot de passe = "root"; essayez {class.forname ("com.mysql.jdbc.driver"); Conn = driverManager.getConnection (URL, utilisateur, mot de passe); } catch (classNotFoundException e) {e.printStackTrace (); } catch (sqlexception e) {e.printStackTrace (); } return conn; }Ces opérations compliquées sont uniquement pour obtenir une connexion. Bien sûr, nous pouvons le résumer dans une classe d'outils pour accéder (la figure ci-dessus résume la connexion de la connexion), mais est-ce un gaspillage de performances pour charger chaque connexion? Afin d'optimiser les performances, un pool de connexion apparaît.
Lorsque le pool de connexions est initialisé, plusieurs connexions sont créées pour que nous puissions utiliser. Lorsque nous devons nous connecter, nous avons seulement besoin d'obtenir des connexions existantes à partir du pool de connexions. Lorsqu'il n'y a pas de connexions initialisées, une connexion sera recréée. Après avoir utilisé la connexion, la connexion ne sera pas détruite, mais sera retournée au pool de connexion pour une utilisation ultérieure. (Bien sûr, la mise en commun des connexions n'est pas seulement aussi simple, voici les introductions)
Les pools de connexion couramment utilisés comprennent DBCP et C3P0. Les plus grand public sont maintenant le pool de connexions Druid d'Alibaba et le propre pool de connexions JNDI de Tomcat.
2. Personnalisez un pool de connexion simple
Analyse des pools de connexion personnalisés:
1.2. Parce qu'il s'agit d'un pool de connexions, nous devons implémenter l'interface de source de données et implémenter les méthodes. Sur la base de notre situation, nous sommes sur la méthode getConnection ();
2. Puisque nous voulons stocker plusieurs objets de connexion, nous utilisons une collection pour la stocker. Sur la base des opérations fréquentes de l'ajout et de la suppression, puis utilisez LinkedList;
3. La destruction d'une connexion n'est pas de détruire la connexion, mais de retourner la connexion au pool de connexion.
codage:
1. Créez une classe MyDataSource et implémentez l'interface DataSource
Lorsque cette classe est chargée, elle doit avoir un conteneur pour stocker la connexion, alors définissez une propriété statique:
Liste statique privée <Connexion> ConnectionList = new LinkedList <> ();
2. Parce que nous devons obtenir la connexion de la base de données, nous encapsulons une méthode pour obtenir la connexion de la base de données.
Connexion publique getOneConnection () {connexion conn = null; Essayez {// Les données obtenues ici sont obtenues via le fichier de propriétés externes, qui est plus flexible. InputStream dans = MyDataSource.class.getClassloader (). getResourCeasStream ("jdbc / jdbc.properties"); Properties pro = nouvelles propriétés (); pro.load (in); driver = pro.getProperty ("driver"); url = pro.getProperty ("url"); userName = pro.getProperty ("utilisateur"); mot de passe = pro.getProperty ("mot de passe"); Class.forname (pilote); Conn = driverManager.getConnection (URL, nom d'utilisateur, mot de passe); } catch (exception e) {e.getStackTrace (); } return conn; }Notez que les données que j'ai obtenues via le fichier de propriété peuvent être sélectionnées en fonction de la situation réelle.
3. Initialisez plusieurs connexions et placez-les dans le récipient. Il peut être implémenté à l'aide de blocs de code statique, mais si cette source de données n'est pas utilisée, elle provoquera des déchets de ressources, donc j'ai envisagé de mettre la mise en œuvre de l'initialisation de plusieurs connexions dans son constructeur, c'est-à-dire lorsque ce pool de connexions sera nécessaire, il créera plusieurs connexions en conséquence. comme suit:
public myDataSource () {for (int i = 0; i <5; i ++) {connection Conn = getOnEConnection (); // Appelez la méthode pour créer le connexionList.add (Conn); }}4. Commencez maintenant à écraser la méthode externe pour getConnection () pour obtenir la connexion à partir de ce pool de connexion
@Override Public Connection getConnection () lève sqlexception {connexion conn = null; if (connectionList == null || connectionList.size () <= 0) {connexion connection = getConnection (); connectionList.add (connexion); } conn = connectionList.Remove (0); Retourne Conn; }5. Créez une méthode de retour d'objet, placez la connexion utilisée dans le pool de connexion
public void backconnection (connexion Conn) {ConnectionList.add (Conn); }Ok, cela complète un pool de connexion personnalisé simple, et le code de test est le suivant:
public static void main (String [] args) lève sqlexception {myDataSource dataSource = new MyDataSource (); Connexion conn = dataSource.getConnection (); String sql = "SELECT * FROM User Where u_id =?"; PréparedStatement PS = null; ResultSet rs = null; essayez {ps = conn.preparestatement (sql); Ps.SetInt (1, 1); rs = ps.ExecuteQuery (); while (Rs.Next ()) {System.out.println ("id =" + rs.getInt (1)); System.out.println ("username =" + rs.getString (2)); System.out.println ("Password =" + Rs.GetString (3)); }} catch (sqlexception e) {e.printStackTrace (); } enfin {dataSource.backConnection (Conn); }}Parce qu'ignore, il n'y a pas d'autres objets dans mon code à fermer.
Maintenant, il y a un petit problème que notre connexion de clôture est réalisée via la méthode du pool de connexion. Cependant, si l'utilisateur appelle la méthode étroite de l'objet de connexion, la connexion est détruite et non retournée au pool de connexion. Ensuite, nous l'optimions afin que l'utilisateur ne détruise pas la connexion, mais renvoie la connexion.
Parmi eux, il existe de nombreuses solutions, et voici un modèle décoratif.
optimisation:
1. Créez une nouvelle classe MyConnection pour implémenter l'interface de connexion, où ses types d'attributs sont Connection Conn et un liis <Connexion>.
connexion privée conn; Liste privée <Connexion> Pool; MyConnection publique (connexion Conn, list <Connection> pool) {this.conn = conn; this.pool = pool; }2. Puis implémentez la méthode étroite de l'interface
@Override public void close () lève sqlexception {System.out.println ("Recycler la connexion"); Pool.Add (Conn); }3. Puis implémentez la méthode d'obtention de l'instruction. S'il n'est pas implémenté, une erreur de pointeur nul se produira lors de l'obtention de cette instruction. Je n'implémente que la méthode d'obtention du statement préparé.
@Override Public préparé Préparestatement (String SQL) lève SQLEXception {System.out.println ("Get Instruction"); return Conn.PrepareStatement (SQL); }4. Ensuite, supprimez la méthode Backconnection de la classe MyDatasource pour renvoyer la connexion et modifiez le constructeur et la méthode pour obtenir la connexion comme suit
public myDataSource2 () {for (int i = 0; i <5; i ++) {connection conn = getOneconnection (); MyConnection myConn = new MyConnection (Conn, ConnectionList); ConnectionList.add (MyConn); }} @Override Public Connection getConnection () lève sqlexception {connexion conn = null; if (connectionList == null || connectionList.size () <= 0) {connexion connection = getConnection (); MyConnection myConn = new MyConnection (Connection, ConnectionList); ConnectionList.add (MyConn); } conn = connectionList.Remove (0); Retourne Conn; }OK, afin que l'utilisateur ne détruise pas la connexion en appelant directement notre méthode de clôture de connexion et le renvoie correctement au pool de connexion. Vous pouvez le tester en apportant une petite modification du code de test.
L'article ci-dessus est le contenu entier que j'ai partagé avec vous. J'espère que cela pourra vous donner une référence et j'espère que vous pourrez soutenir Wulin.com plus.