Personalizar un método simple de implementación del grupo de conexión JDBC

1. ¿Qué es el grupo de conexión JDBC?

En las conexiones JDBC tradicionales, cada vez que obtiene una conexión de conexión, debe cargar un código complicado para obtener, como el siguiente código:

 Public Static Connection getConn () {Connection Conn = NULL; String url = "jdbc: mysql: // localhost: 3306/test"; String user = "root"; Cadena contraseña = "root"; intente {class.forname ("com.mysql.jdbc.driver"); conn = drivermanager.getConnection (url, usuario, contraseña); } catch (ClassNotFoundException e) {E.PrintStackTrace (); } Catch (Sqlexception e) {E.PrintStackTrace (); } return Conn; }

Tales operaciones complicadas son solo para obtener una conexión. Por supuesto, podemos encapsularlo en una clase de herramientas para acceder (la figura anterior encapsula la conexión de la conexión), pero ¿es un desperdicio de rendimiento cargar cada conexión? Para optimizar el rendimiento, aparece un grupo de conexión.

Cuando se inicializa el grupo de conexión, se crean varias conexiones para que lo usemos. Cuando necesitamos conectarnos, solo necesitamos obtener conexiones existentes desde el grupo de conexión. Cuando no hay conexiones inicializadas, se recreará una conexión. Después de usar la conexión, la conexión no será destruida, sino que se devolverá al grupo de conexión para su uso posterior. (Por supuesto, la agrupación de conexión no es solo así de simple, aquí están las presentaciones)

Los grupos de conexión de uso común incluyen DBCP y C3P0. Los más convencionales ahora son el grupo de conexión Druid de Alibaba, y el grupo de conexión JNDI de Tomcat.

2. Personalizar un grupo de conexión simple

Análisis de grupos de conexión personalizados:

1.2. Debido a que es un grupo de conexión, necesitamos implementar la interfaz de plato de datos e implementar los métodos en él. Según nuestra situación, estamos sobre el método getconnection ();

2. Dado que queremos almacenar varios objetos de conexión, utilizamos una colección para almacenarlo. Basado en las operaciones frecuentes de agregar y eliminar, use LinkedList;

3. La destrucción de una conexión no es destruir la conexión, sino devolver la conexión al grupo de conexión.

codificación:

1. Cree una clase MyDataSource e implementa la interfaz de DataSource

Cuando se carga esta clase, necesita tener un contenedor para almacenar la conexión, así que defina una propiedad estática:

 Lista estática privada <Enection> ConnectionList = new LinkedList <> ();

2. Debido a que necesitamos obtener la conexión de la base de datos, encapsulamos un método para obtener la conexión de la base de datos.

 Public Connection getOnEconnection () {Connection conn = null; Pruebe {// Los datos obtenidos aquí se obtienen a través del archivo de propiedades externas, que es más flexible. InputStream in = myDataSource.class.getClassLoader (). getResourceasstream ("JDBC/JDBC.Properties"); Propiedades pro = nuevas propiedades (); pro.load (in); controlador = pro.getProperty ("controlador"); url = pro.getProperty ("url"); username = pro.getProperty ("usuario"); contraseña = pro.getProperty ("contraseña"); Class.forname (controlador); conn = drivermanager.getConnection (url, nombre de usuario, contraseña); } capt (excepción e) {e.getStackTrace (); } return Conn; }

Tenga en cuenta que los datos que obtuve a través del archivo de propiedades se pueden seleccionar de acuerdo con la situación real.

3. Inicialice varias conexiones y colóquelas en el contenedor. Se puede implementar utilizando bloques de código estáticos, pero si no se utiliza esta fuente de datos, causará desechos de recursos, por lo que consideré poner la implementación de inicializar varias conexiones en su constructor, es decir, cuando se necesita este grupo de conexión, creará varias conexiones en consecuencia. como sigue:

 public myDataSource () {for (int i = 0; i <5; i ++) {Connection conn = getOnEconnection (); // Llame al método para crear la ConnectionList.Add (Conn); }}

4. Ahora comience a sobrescribir el método externo para getConnection () para obtener la conexión de este grupo de conexión

 @Override Public Connection getConnection () lanza SQLException {Connection Conn = NULL; if (ConnectionList == NULL || ConnectionList.Size () <= 0) {Conexión Conexión = getConnection (); ConnectionList.Add (conexión); } Conn = ConnectionList.Remove (0); devolver Conn; }

5. Cree un método de retorno de objetos, coloque la conexión usada en el grupo de conexión

 public void BackConnection (Connection Conn) {ConnectionList.Add (Conn); }

Ok, esto completa un grupo de conexión personalizado simple, y el código de prueba es el siguiente:

 public static void main (string [] args) lanza sqlexception {myDataSource dataSource = new myDataSource (); Conexión conn = dataSource.getConnection (); Cadena sql = "Seleccionar * del usuario donde u_id =?"; Preparado PS = NULL; ResultSet rs = null; intente {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 (); } finalmente {dataSource.backConnection (Conn); }}

Porque ignora, no hay otros dos objetos en mi código para cerrar.

Ahora hay un pequeño problema de que nuestra conexión de cierre se logra a través del método del grupo de conexión. Sin embargo, si el usuario llama al método de cierre del objeto de conexión, la conexión se destruye y no se devuelve al grupo de conexión. Luego lo optimizamos para que el usuario no destruya la conexión, sino que devuelva la conexión.

Entre ellos, hay muchas soluciones, y aquí hay un modelo decorativo.

mejoramiento:

1. Cree una nueva clase MyConnection para implementar la interfaz de conexión, donde sus tipos de atributos son Connection Conn y un LIIS <nection>.

 Connectación privada Conns; Lista privada <Enection> Pool; public MyConnection (Connection Conn, List <Enection> Pool) {this.conn = conn; this.pool = Pool; }

2. Luego implementa el método de cierre de la interfaz

 @Override public void Close () lanza SQLException {system.out.println ("reciclaje de conexión"); Pool.add (Conn); }

3. Luego implementa el método para obtener la declaración. Si no se implementa, se producirá un error de puntero nulo al obtener esta declaración. Solo implemento el método para obtener la TEPRESIÓN.

 @Override public PrepareStatement PrepareStatement (String SQL) lanza SQLException {System.out.println ("Get Declary"); return Conn.Preparestatement (SQL); }

4. Luego elimine el método de la Conexión de la clase MyDataSource para devolver la conexión, y modifique el constructor y el método para obtener la conexión de la siguiente manera

 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 () lanza SQLException {Connection Conn = NULL; if (ConnectionList == NULL || ConnectionList.Size () <= 0) {Conexión Conexión = getConnection (); Myconnection myconn = new MyConnection (Connection, ConnectionList); ConnectionList.Add (MyConn); } Conn = ConnectionList.Remove (0); devolver Conn; }

Ok, para que el usuario no destruya la conexión llamando directamente a nuestro método de cierre de conexión y la devuelva al grupo de conexión correctamente. Puede probarlo haciendo una pequeña modificación al código de prueba.

El artículo anterior es el contenido completo que he compartido contigo. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.