Post Views: 2.227

ei, amantes do chá!. Você já ouviu falar sobre pool de conexão em JDBC ou HikariCP? Se não, não se preocupe, é disso que se trata este post. Falaremos sobre todas as coisas sobre o pool de conexão JDBC e sua implementação usando HikariCP.

HikariCP é um dos conjuntos de conexão mais rápidos disponíveis no mercado para conexão JDBC. Isso torna o pool de conexões muito fácil. prepare-se para aprender mais sobre esta besta. Mas antes, faça seu chá para saborear e aprender. E para o exemplo usado na postagem, você pode encontrá-lo no GitHub aqui ou no projeto completo aqui.

Facebook, Twitter, Linkedin, Facebook ou Instagramvocê pode me seguir no Social @coderstea no Twitter, Linkedin, Facebook ou Instagram. Também compartilhamos vídeos de alta qualidade sobre programação em nosso canal do Youtube, você também pode publicar sua própria postagem em CodersTea.com, apenas compartilhe seu pensamento em Contacte-nos.

o que é o pool de conexão?

o pool de conexões no JDBC nos permite reutilizar a conexão JDBC em vez de criar a cada vez. Quando chamado, ele retorna a conexão JDBC que não está em uso( ou cria uma nova se sua primeira solicitação ou limite de pool ainda não for atingido). Pense nisso como seu pool de recursos, como impressoras em uma rede compartilhada ou DHCP ou pool de threads, que discutimos em “reciclar os Threads e salvar os recursos com pool de threads”.

Por Que Usar O Pool De Conexão?Criar uma conexão com o banco de dados é um processo caro. Leva tempo para se conectar ao banco de dados. Não é perceptível por algumas vezes, mas fazendo isso por milhares de vezes, a própria frequência de seu aplicativo por precisar chamar os bancos de dados, pode se tornar muito lento. Suponha que esteja levando 5ms para se conectar ao banco de dados e 10 ms para uma consulta, então cerca de 15 ms pela primeira vez. Faça isso por 1000 vezes e você pode sentir a diferença. Mais de 30% do tempo está perdendo na criação da conexão.

outro cenário seria, suponha que a conexão está tomando 5ms, mas a consulta está tomando apenas 4ms, então mais de 60% está indo para a criação. Percebeste a ideia.

mas no pool de conexão, você não está criando uma conexão a cada vez, em vez disso, está reutilizando-a. A reciclagem não só ajuda o meio ambiente, mas também o desempenho do nosso sistema. Por meio dessa sobrecarga de recursos de reciclagem diminui. Você também pode limitar o número de conexões que podem ajudar no controle de tráfego no banco de dados. Existem também outros fatores para melhorar o desempenho. Você pode aprender sobre aqueles em meu outro artigo “Como alcançar a grandeza no desempenho JDBC”;

quando usar o pool de conexão?

Ok, ele tem muitas vantagens, mas pode haver cenários em que não faz sentido usar o pool de conexão. Acho que devemos usá-lo sempre que possível, pois reduz grande parte do trabalho. Como conectar-se automaticamente ao banco de dados em caso de tempo limite. Deve ser sua escolha principal, caso seu aplicativo Chame frequentemente o banco de dados ou seja fortemente dependente do banco de dados.

para um aplicativo simples em que você chama o banco de dados de vez em quando como um dia ou algo assim, provavelmente não precisa dele. Ou você pode apenas definir o limite da piscina para um para que haja apenas uma conexão na piscina. Em um ambiente multithread, se você quiser que todos os threads usem a mesma conexão em vez de cada thread para criar suas próprias conexões de banco de dados, o pool de conexões é o salvador para você.

coisas a ter em mente ao usar o pool de conexão

uma coisa que você precisa ter cuidado ao fechar a conexão. Se você não fechar a conexão depois de usá-la, ela não voltará para a piscina. E outra parte do seu programa pode estar esperando por ele. A melhor abordagem é usar try-with-resources, que você vê em detalhes aqui. E você pode ter que explicar ao seu novo colega / amigo sobre o que, por que e como usar o pool de conexão se ele ou ela não souber. Isso não é uma grande tarefa, pois você pode apenas compartilhar este post com eles por precaução (autopromoção ?).

Explore o Poling de conexão JDBC com HikariCP

neste ponto, espero que você tenha entendido o que é o pool de conexão JDBC, por que e quando usá-lo e suas vantagens e desvantagens. Uma coisa permanece é, como usá-lo. Isso pode ser feito com muita facilidade pelo HikariCP e oferece muito mais desempenho do que qualquer outra biblioteca de pool de conexão. HikariCP é uma biblioteca de pool de conexão Java muito rápida e leve por aí. A API e a base de código geral são relativamente pequenas, ótimas e altamente otimizadas. É muito fácil de configurar e usar.

antes de usá-lo, vamos passar por pré-requisitos.

adicionando HikariCP em seu projeto

existem várias maneiras de carregar o HikariCP em seu projeto.

adicionando manualmente a Biblioteca HikariCP

para o projeto Java simples, você pode baixar o jar do repositório Maven e baixar o ‘HikariCP’mais recente. Também há suporte para versões Java mais antigas, que podem ser facilmente identificadas na página de download.

adicionando HikariCP com estruturas de construção

para estruturas de construção, como Maven ou Gradle, você pode dependências. No momento da criação deste blog, 3.4.1 foi o mais recente. Verifique o mais recente ao usá-lo, que pode ser encontrado no MvnRepository. Ele pode fornecer texto de dependências no formato Maven ou Gradle.

Maven

<!--Java 8 to 11 maven artifact--><dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP</artifactId> <!-- use the latest verion if possible. This was the latest on the birth of this blog --> <version>3.4.1</version></dependency><!-- Java 7 maven artifact (maintenance mode) --><dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP-java7</artifactId> <version>2.4.13</version></dependency><!-- Java 6 maven artifact (maintenance mode) --><dependency> <groupId>com.zaxxer</groupId> <artifactId>HikariCP-java6</artifactId> <version>2.3.13</version></dependency>

Gradle

//Java 8 to 11compile "com.zaxxer:HikariCP:3.4.1"//java 7compile "com.zaxxer:HikariCP-java7:2.4.13"//Java 6compile "com.zaxxer:HikariCP-java6:2.3.13"

Criação de Pool de Conexão JDBC com HikariCP

ao Criar HikariCP objecto de origem de dados, uma interface para o Pool de Conexão fornecidos pela Java, precisamos configurar o pool. Isso inclui URL JDBC, usuário, senha, Tamanho do pool, entre outras coisas. A seguir estão as configurações essenciais e comuns e suas descrições.

Métodos de Descreptions
setJdbcUrl(String) Definir o URL JDBC
setUsername(String) Definir o nome de usuário
setPassword(Seqüência de caracteres) Definir a senha
setDriverClassName(String) Passar o driver de classe do nome: o
setMaximumPoolSize(int) ligação máxima que pode ser criado ou reside na piscina
setConnectionTimeout(longa) Quanto tempo um usuário pode esperar para obtenha uma conexão da piscina. se exceder o limite de tempo, um SQlException será lançado
setMaximumPoolSize (int) o tempo máximo que uma conexão pode ficar ociosa no pool. Se exceder o limite de tempo, ele será removido da piscina. Se você não quiser aposentar as conexões, basta colocar 0.
setPoolName (String) ele define o nome do pool atual. Isso é opcional, você não precisa fazer isso.
configuração HKARI CP

exemplo e código para HikariCP

coloquei os comentários para mostrar exatamente o que está fazendo. Eu escrevi o código na ordem inversa de criar a configuração, passando-o para a fonte de dados, obtendo a conexão da fonte de dados e, finalmente, execute uma consulta. Vejamos como funciona o exemplo.

chamamos o método static getConnection para uma conexão. Que getDataSource() para DataSource objeto. Este objetos getConnection nos dá a conexão do pool.

em getDataSource se dataSource for nulo,static DataSource objeto, criamos um com o createDataSourcee configuramos o pool com getHikariConfig. No main, apenas fazemos algumas consultas simples.

import com.zaxxer.hikari.HikariConfig;import com.zaxxer.hikari.HikariDataSource;import javax.sql.DataSource;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.time.Duration;public class HikariCP { // static global DataSource object. private static DataSource dataSource; public static void main(String args) { String query = "SELECT COUNT(*) FROM employee"; //Using try-with-resources for auto closing connection, pstmt, and rs. try (Connection connection = getConnection(); PreparedStatement pstmt = connection.prepareStatement(query); ResultSet rs = pstmt.executeQuery(); ) { if (rs.next()) { System.out.println("Total employees are " + rs.getInt(1)); } } catch (SQLException e) { e.printStackTrace(); } } //Call the get connection method. static Connection getConnection() throws SQLException { return getDataSource().getConnection(); } //Get the DataSource. If not available create the new one //It is not threadsafe. I didn't wanted to complicate things. private static DataSource getDataSource() { if (null == dataSource) { System.out.println("No DataSource is available. We will create a new one."); createDataSource(); } return dataSource; } //To create a DataSource and assigning it to variable dataSource. private static void createDataSource() { HikariConfig hikariConfig = getHikariConfig(); System.out.println("Configuration is ready."); System.out.println("Creating the HiakriDataSource and assigning it as the global"); HikariDataSource hikariDataSource = new HikariDataSource(hikariConfig); dataSource = hikariDataSource; } //returns HikariConfig containing JDBC connection properties //which will be used by HikariDataSource object. private static HikariConfig getHikariConfig() { System.out.println("Creating the config with HikariConfig with maximum pool size of 5"); HikariConfig hikaConfig = new HikariConfig(); //This is same as passing the Connection info to the DriverManager class. //your jdbc url. in my case it is mysql. hikaConfig.setJdbcUrl("jdbc:mysql://localhost:3306/test"); //username hikaConfig.setUsername("root"); //password hikaConfig.setPassword("IWontTellYouThis ;)"); //driver class name hikaConfig.setDriverClassName("com.mysql.jdbc.Driver"); // Information about the pool //pool name. This is optional you don't have to do it. hikaConfig.setPoolName("MysqlPool-1"); //the maximum connection which can be created by or resides in the pool hikaConfig.setMaximumPoolSize(5); //how much time a user can wait to get a connection from the pool. //if it exceeds the time limit then a SQlException is thrown hikaConfig.setConnectionTimeout(Duration.ofSeconds(30).toMillis()); //The maximum time a connection can sit idle in the pool. // If it exceeds the time limit it is removed form the pool. // If you don't want to retire the connections simply put 0. hikaConfig.setIdleTimeout(Duration.ofMinutes(2).toMillis()); return hikaConfig; }}

criar Pool de Conexão Multi-banco de dados

existem vários motivos pelos quais você precisa acessar vários bancos de dados em um único projeto ou Base de código. O mais comum é migrar os dados de um servidor para outro, ou é um requisito arquitetônico. Seja qual for o motivo, no momento em que você tem que fazer o mesmo trabalho, você tende a copiar e colar o código, e JDBC é em si é uma definição de código clichê.

todos os detalhes sobre a criação de um pool de conexão de vários bancos de dados são descritos neste post: Como criar um Pool de vários bancos de dados no HikariCP

o código de pool HikariCP de vários bancos de dados visa reduzir o código clichê ao mínimo, dando a você um código pequeno e legível.

conclusão

neste post, falamos sobre o que é pool de conexão, por que usá-lo e quando usá-lo. Ele melhora muito o desempenho do aplicativo pesado de banco de dados, mas pode ser melhorado ainda mais com alguns truques em meu outro post “Como alcançar a grandeza no desempenho do JDBC”. Exploramos como usar o pool de conexão com a ajuda do HikariCP, a biblioteca de pool de conexão mais rápida e leve para java no momento em que escrevo este post. Você pode encontrar o código do exemplo no GitHub aqui ou o projeto completo aqui.

Posted on

Deixe uma resposta

O seu endereço de email não será publicado.