Compreendendo o agrupamento de conexões

JDBC
 19 de maio de 2017
 Por Manoj Debnath
 Enviar email "
 Mais artigos »
Tweet

O pool de conexão é um mecanismo para criar e manter uma coleção de objetos de conexão
JDBC. O principal objetivo de manter o pool de objetos de conexão é aproveitar a
reutilização. Um novo objeto de conexão é criado somente quando não há objetos de conexão
disponíveis para reutilização. Esta técnica pode melhorar o desempenho geral da
aplicação. Este artigo tentará mostrar como este mecanismo de agrupamento pode ser
aplicado a um aplicativo Java .

Por que precisamos de agrupamento de conexão?

Estabelecer uma conexão de banco de dados é um processo muito intensivo em recursos e
envolve muitas despesas gerais. Além disso, em um ambiente multi-threaded, abrir e fechar
uma conexão pode piorar bastante a situação. Para obter um vislumbre do que realmente pode
acontecer com cada solicitação para criar uma nova conexão de banco de dados, considere os
seguintes pontos. As conexões de banco de dados são estabelecidas
usando DriverManager de objetos DataSource .

 Uma aplicação invoca o método getConnection () .

 O driver JDBC solicita um soquete JVM.
 A JVM deve garantir que a chamada não viole os aspectos de segurança (como o caso
pode ser com os applets).
 A invocação pode ter que percolar através de um firewall antes de entrar na nuvem de
rede.
 Ao chegar ao host, o servidor processa a solicitação de conexão.
 O servidor de banco de dados inicializa o objeto de conexão e retorna ao cliente JDBC
(novamente, passando pelo mesmo processo).
 E, finalmente, obtemos um objeto de conexão.
Esta é apenas uma visão geral do que realmente acontece nos bastidores. Tenha certeza, o
processo atual é mais complicado e elaborado do que isso. Em um ambiente controlado de um
único segmento, as transações de banco de dados são principalmente lineares, como abrir
uma conexão, fazer transações de banco de dados e fechar a conexão quando terminar. As
aplicações da vida real são mais complexas; o mecanismo de pool de conexão pode adicionar
ao desempenho, embora existam muitas outras propriedades que são críticas para o
desempenho geral da aplicação.

Sucesso de recuperação em nuvem: um guia técnico DRaaS

Baixe Agora

A complexidade do conceito de pool de conexão fica mais desagradável quando mergulhamos

profundamente nela. Mas, obrigado, vá para as pessoas que trabalham para produzir
bibliotecas especificamente para a causa do pool de conexão. Essas bibliotecas aderem às
normas do JDBC e fornecem APIs mais simples para realmente implementá-las em um
aplicativo Java.

O que realmente acontece com o pool de conexão?

  Publicar um comentário
 Artigo de email
 Artigo de impressão
 Compartilhe artigos
O pooling de conexão trabalha nos bastidores e não afeta a forma como um aplicativo é
codificado. Isso significa que uma vez que as propriedades estão definidas, o desenvolvedor
quase pode esquecer sobre isso e se concentrar no código, assim como qualquer outro
aplicativo JDBC. Mas, o aplicativo deve usar um objeto DataSource para obter conexão em vez
de usar a classe DriverManager . Isso, no entanto, não significa que, se estamos usando
um objeto DataSource , estamos usando pooling de conexão. O que o objeto DataSource faz é
registrar com o serviço de nomeação JNDI de uma maneira padrão. Por exemplo:

Contexto context = new InitialContext ();

DataSource dataSource = (DataSource)
context.lookup ("jdbc / library_jndi");

Mas, quando o DataSource usa pooling de conexão, a pesquisa retorna uma conexão do pool
de objetos de conexão disponíveis. Se não houver conexão disponível, a pesquisa cria uma
nova conexão. O aplicativo estabelece uma conexão ao banco de dados e acessa os dados da
maneira usual.

Conexão conexão = dataSource.getConnection

("raiz", "senha");
// ...
connection.close ();

Artigos relacionados
 Novos recursos principais no Java 8
 Comece Usando Java Lambda Expressions
 Como contratar um desenvolvedor Java
Uma vez que o aplicativo é feito com a atividade do banco de dados, ele fecha explicitamente a
conexão. Isso torna a conexão liberada novamente disponível para reutilização. O evento de
encerramento da conexão agrupada sinaliza o módulo de pool para restaurar novamente para
o pool de conexão. Como a reutilização do objeto de conexão não requer alterações de código,
é mais rápido que criando uma nova conexão.

A API JDBC 3.0 fornece a estrutura geral para o agrupamento de conexões. Vários
fornecedores terceirizados foram construídos com base nessa estrutura, implementando seus
próprios algoritmos de armazenamento em cache ou de pool. A estrutura geral da API JDBC
fornece três ganchos sob a forma de interfaces, sobre os quais vários fornecedores
terceirizados implementaram sua biblioteca de pool de conexão. Eles são:

 PooledConnection
 ConnectionPooledDataSource
 ConnectionEventListener
Consulte a documentação da API Java para obter uma descrição elaborada nessas
interfaces. Não vamos entrar nos detalhes aqui; Em vez disso, vamos nos concentrar em como
implementar um mecanismo de pool de conexão em um aplicativo Java. Como mencionado
anteriormente, existem muitas bibliotecas de terceiros disponíveis,
como C3P0 , UCP , BoneCP , H2 , DBCP e assim por diante. Aqui, nos concentramos em
apenas um deles.
O que precisamos para os seguintes exemplos
O seguinte exemplo será um aplicativo Java autônomo mínimo. O banco de dados que
usaremos é o MySQL. Portanto, precisamos

 Eclipse IDE (opcional)

 Driver JDBC do MySQL
A instrução DDL para a tabela de banco de dados em que trabalhamos é a seguinte:

criar livros de mesa

(
isbn varchar (20) chave primária,
título varchar (50),
edição varchar (20),
preço flutuante (10,2)
);

Pool de conexão com a biblioteca c3p0

c3p0 é uma biblioteca de pool de conexão de terceiros, disponibilizada nos termos da LGPL ou
EPL. O site c3p0 oficial afirma:

c3p0 é uma biblioteca fácil de usar para fazer drivers JDBC tradicionais "prontos para
empresas", aumentando-os com a funcionalidade definida pela especificação jdbc3 e as
extensões opcionais para jdbc2. A partir da versão 0.9.5, o c3p0 suporta totalmente a
especificação jdbc4.

Em particular, o c3p0 fornece vários serviços úteis:

 Uma classe que adapta drivers tradicionais JDBC baseados no DriverManager para o
novo esquema javax.sql.DataSource para adquirir conexões de banco de dados.
 Armazenamento transparente de conexões e declarações preparadas por trás de
DataSources que podem "envolver" em torno de drivers tradicionais ou fontes de
dados arbitrárias e não colocadas.
Ele é projetado para ser simples e só precisa de dois arquivos de jar:

 c3p0.xxxxjar
 mchange-commons-java-xxxjar
Esses jarros precisam estar no CLASSPATH, além do driver MySQL JDBC.

package org.mano.example;

importar java.beans.PropertyVetoException;
importar java.sql.Connection;
importar java.sql.SQLException;
importar com.mchange.v2.c3p0.ComboPooledDataSource;

classe pública C3P0DataSource {

private static C3P0DataSource dataSource ;
ComboPooledDataSource privado comboPooledDataSource;

private C3P0DataSource () {
try {
comboPooledDataSource = novo ComboPooledDataSource ();
comboPooledDataSource
.setDriverClass ("com.mysql.jdbc.Driver");
comboPooledDataSource
.setJdbcUrl ("jdbc: mysql: // localhost: 3306 / testdb");
comboPooledDataSource.setUser ("root");
comboPooledDataSource.setPassword ("segredo");
catch (PropertyVetoException ex1) {
ex1.printStackTrace ();
}
}

public static C3P0DataSource getInstance () {

if ( dataSource == null )
dataSource = new C3P0DataSource ();
retornar dataSource ;
}

público Conexão getConnection () {

Connection con = null ;
tente {
con = comboPooledDataSource.getConnection ();
} catch (SQLException e) {
e.printStackTrace ();
}
retorno con;
}
}

package org.mano.example;

importar java.sql.Connection;
importar java.sql.PreparedStatement;
importar java.sql.ResultSet;
importar java.sql.ResultSetMetaData;
importar java.sql.SQLException;
importar java.sql.Statement;

classe pública MainApp {

public static void insertOrUpdate (String isbn, String title,

Edição String, flutuador preço) {
tente (Connection con = C3P0DataSource. GetInstance ()
.getConnection ()) {
PreparedStatement pstmt = null ;
se ( isIsbnExists (isbn)) {
pstmt = con.prepareStatement ("UPDATE books"
+ "SET title = ?, edition = ?,"
+ "price =? WHERE isbn LIKE?");
pstmt.setString (1, título);
pstmt.setString (2, edição);
pstmt.setFloat (3, preço);
pstmt.setString (4, isbn);
} else {
pstmt = con.prepareStatement ("INSERT INTO"
+ "livros (isbn, título,"
+ "edição, preço) VALORES (?,?,?,?)");
pstmt.setString (1, isbn);
pstmt.setString (2, título);
pstmt.setString (3, edição);
pstmt.setFloat (4, preço);
}
 pstmt.executeUpdate ();
} catch (SQLException e) {
e.printStackTrace ();
}
}

public static void isIsbnExists (String isbn) {

Boolean flag = false ;
tente (Connection con = C3P0DataSource. getInstance ()
.getConnection ()) {
Declaração stmt = con.createStatement ();
ResultSet rs = stmt.executeQuery ("SELECT isbn"
+ "FROM books WHERE"
+ "isbn LIKE '" + isbn + "'");
flag = rs.next ();
} catch (SQLException e) {
e.printStackTrace ();
}
bandeira de retorno ;
}

public static void delete (String isbn) {

try (Connection con = C3P0DataSource. getInstance ()
.getConnection ()) {
PreparedStatement pstmt = null ;
se ( isIsbnExists (isbn)) {
pstmt = con.prepareStatement ("DELETE FROM"
+ "livros"
+ "ONDE isbn COMO?");
pstmt.setString (1, isbn);
pstmt.executeUpdate ();
}
} catch (SQLException e) {
e.printStackTrace ();
}
 }

public static void showAll () {

try (Connection con = C3P0DataSource. getInstance ()
.getConnection ()) {
Declaração stmt = con.createStatement ();
ResultSet rs = stmt.executeQuery ("SELECT * FROM books");
ResultSetMetaData metadata = rs.getMetaData ();
int cols = metadata.getColumnCount ();
Sistema. out .println ("\ n -----------------------------"
+ "--------------------------------");
para ( int i = 0; i <cols; i ++) {
Sistema. out .printf ("% - 20s \ t",
metadata.getColumnName (i + 1) .toUpperCase ());
}
Sistema. out .println ("\ n -----------------------------"
+ "--------------------------------");
enquanto (rs.next ()) {
for ( int i = 0; i <cols; i ++)
Sistema. out .printf ("% - 20s \ t", rs.getObject (i +
1));
Sistema. out .println ();
}
Sistema. out .println ("-------------------------------"
+ "--------------------------------");

catch (SQLException e) {
e.printStackTrace ();
}
}

public static void main (String [] args) {

showAll ();
insertOrUpdate (" 111111 ", "Números complexos",
"Segundo", 56.78f);
showAll ();
 insertOrUpdate (" 111111 ", "Números complexos",
"Quarto", 87.50f);
showAll ();
apagar ("111111");
showAll ();
}
}

Saída
-------------------------------------------------- --------------
ISBN TÍTULO EDIÇÃO PREÇO
-------------------------------------------------- --------------
456789 Gráfico Teoria Segundo 33.8
567890 Set Theory Fourth 34.89
-------------------------------------------------- --------------

-------------------------------------------------- --------------
ISBN TÍTULO EDIÇÃO PREÇO
-------------------------------------------------- --------------
111111 Números complexos segundo 56,78
456789 Gráfico Teoria Segundo 33.8
567890 Set Theory Fourth 34.89
-------------------------------------------------- --------------

-------------------------------------------------- --------------
ISBN TÍTULO EDIÇÃO PREÇO
-------------------------------------------------- --------------
111111 Números complexos quarto 87.5
456789 Gráfico Teoria Segundo 33.8
567890 Set Theory Fourth 34.89
-------------------------------------------------- --------------

-------------------------------------------------- --------------
ISBN TÍTULO EDIÇÃO PREÇO
-------------------------------------------------- --------------
456789 Gráfico Teoria Segundo 33.8
567890 Set Theory Fourth 34.89
-------------------------------------------------- --------------

Conclusão
O pool de conexão é particularmente adequado para otimizar o desempenho em um ambiente
de alta carga onde um pedido de conexão é descartado ou atrasado. Este tipo de situação tem
um impacto adverso no desempenho geral da aplicação. Na verdade, ao criar um aplicativo
JDBC Web ou empresarial, é sempre uma prática usar pools de conexão por todos os motivos
práticos. As bibliotecas de terceiros são praticamente estáveis e capazes de fornecer o que
reivindicam. Compreender o conceito de conexão de pool e ser capaz de implementá-los é uma
obrigação para todos os programadores JDBC.