Java e C Princípios piscina # conexão de banco de dados e aplicações

princípio pool de conexão Java e C # banco de dados

No desenvolvimento atual da Internet, alta concorrência para o mainstream, e que é a parte mais crítica de operações de banco de dados e acesso, no desenvolvimento atual da Internet, quadro ORM não pobres, tais como: .Net-Core de EFCore, SqlSugar, Dapper. A JAVA Primavera-DataJpa (EntityManager), MyBatis, MybatisPlus etc.

Mas quando se trata de realmente ORM operam essencialmente componentes de acesso a banco de dados de nível mais baixo: Ado.net, Jdbc

Hoje venho para conversar princípio conexão pooling dois acessos do banco de dados

Falando antes Ado.net e conexão JDBC pool de dados, precisamos primeiro entender o que é o pool de conexão de banco de dados

Conecte-se ao servidor de banco de dados normalmente leva muito tempo em várias etapas. canais físicos deve ser estabelecido (como soquetes ou pipes nomeados) deve ser o aperto de mão inicial com o servidor é necessário analisar as informações seqüência de conexão, deve ser autenticado pelo servidor está ligado, para executar uma verificação deve ser registrado na transação atual, e similares.

Na verdade, a maioria dos aplicativos usar somente uma ou algumas configurações de conexão diferentes. Isto significa que durante a execução do aplicativo, muitos dos mesmos conexão será repetidamente aberta e fechada. Este é o custo de Cpu desempenho. A fim de minimizar o custo da ligação aberta, ADO.NET usando técnicas de optimização conhecidos como o agrupamento de ligações. As técnicas de otimização de Java é pool de conexão JDBC.

Em geral, o processo de aplicativos Java que acessam o banco de dados são:

1. Carregar o controlador da base de dados;
2. conexão de dados é estabelecida através de jdbc;
3. O acesso ao banco de dados, executar instruções SQL;
4. Desconectar do banco de dados.

Este é um passo de conexão da base de dados comum Tomcat de conexões de mapeamento e de banco de dados Jdbc

O processo de aplicações .Net Framwork / .Net núcleo que acessam o banco de dados é o núcleo quatro assunto pelo provedor de dados .NET:

1.Connection: conectar ao banco 2.Command: executar banco de dados comandos 3.DataReader: 4.DataAdapter responsável pela leitura de dados a partir de uma fonte de dados: de contacto responsável pela coleta de dados e banco de dados

Esta é a ligação da base de dados de mapeamento Ado.net

Ado.net:

Ado.net passo conexão com o banco:

1.新建一个数据库连接字符串
string conStr = “Data Source=.;Initial Catalog=MySchoolDB;Integrated Security=True”;
2.引入命名空间：
using System.Data.SqlClient;
3.创建SqlConnection对象
SqlConnection conn = new SqlConnection(conStr);
4.打开连接：
conn.Open();
5.关闭连接：
conn.Close();
五、使用Command对象的步骤：
1.创建数据库连接
SqlConnection conn = new SqlConnection(conStr);
2.定义sql语句
string sql = “insert into Admin values(‘值’)”;
3.创建SqlCommand对象
SqlCommand cmd = new SqlCommand(conn,sql);
4.执行命令
cmd.ExecuteScalar();

Nós já sabemos que no momento da conexão, se no caso de um aumento repentino no momento do tráfego, em seguida, o fio vai abrir mais o acesso de banco de dados, que é a ligação básica desta vez tem sido insuficiente para lidar com alta acesso simultâneo dos altos QPS

Desta vez Mircosoft criado um banco de dados fornecido pelo provedor de dados Connection Pooling --Ado.net pool de conexão: ele permite que aplicativos para salvar a conexão usada no pool de conexão para evitar cada vez para completar o estabelecimento / fechamento completo da conexão do processo.

Data Provider concluir o processo de estabelecer uma conexão após o recebimento de uma solicitação de conexão é:

1. O estabelecimento de uma nova conexão com o pool de conexão (ou seja, "conexão lógica"), e o estabelecimento da "conexão lógica" correspondente "conexão física." Estabelecer uma "conexão lógica" deve ser acompanhada do estabelecimento de uma "conexão física."
2. Provedor de dados ligados, completam um procedimento fechado é desligar "conexão lógica" correspondente "de ligação física" e destruído "ligação lógica."
3. Destruction "conexão lógica" deve ser acompanhada de perto "conexão física", SqlConnection.Open () está solicitando um provedor de dados de conexão não necessariamente precisam ser concluídas para estabelecer um processo completo de conexão com o provedor de dados, podem simplesmente removido do pool de conexão disponível você pode;
4. SqlConnection.Close () é um pedido para fechar uma conexão, provedor de dados não necessariamente precisa para completar um curso completo de fechar a conexão, você pode precisar apenas o conector pode ser liberado de volta para o pool de conexão.

Agora eu escrever um código de teste para teste sem o uso de um pool de conexão de efeito de conexões de banco de dados: enquanto eu detectar um consumo de CPU com contadores de desempenho do Windows

class Program
{
    static void Main(string[] args)
    {
        SqlConnection con = new SqlConnection("server=.\\sqlexpress;database=zsw;pooling=true;trusted_connection=true;uid=sa;pwd=zsw158991626ZSW;");
        for (int i = 0; i < 10; i++)
        {
            try
            {
                con.Open();
                Console.WriteLine("开始连接数据库" + System.Threading.Thread.CurrentThread.Name);
                System.Threading.Thread.Sleep(1000);
            }
            catch (Exception e) { Console.WriteLine(e.Message); }
            finally
            {
                con.Close();
                System.Threading.Thread.Sleep(1000);
            }
        }
        Console.Read();
    }
}

Desta vez o meu código está na pool de conexão de banco de dados, e minhas conexões apenas um, mas quando se livrar de Console.ReadKey definição pooling = false neste momento em que a minha conexão de dados ocupa 10, devido ao meu computador testes de desempenho SQLServer não abre, mas depois você pode ir Baidu on-line tentar exibir o número de conexões

Mas! .Net núcleo ligado a um banco de dados parece ser o pool de conexão de dados padrão aberto, que eu encontrar por um longo documento nenhum resultado.

Esta partilha Então o que é?

Sempre que o programa precisa de tempo para ler e escrever para o banco de dados. Connection.Open () usará o ConnectionString para se conectar ao banco de dados, o banco de dados irá estabelecer uma conexão para o programa, e permanece aberto, após o qual o programa pode usar declarações T-SQL para consulta / atualizar o banco de dados. Ao realizar o Connection.Close (), o banco de dados irá fechar a ligação actual. Bem, tudo parece são tão metódica.

Mas se minha necessidade programa não programado para conexões abertas e fechadas (como ASP.Net ou Web Service), por exemplo, quando Http pedido enviado ao servidor ,, precisamos abrir a conexão e, em seguida, usar o Select * from Table retorna uma DataTable / DataSet para o cliente / navegador, e depois fechar a conexão atual. Que cada Open / Close Connection operação tão freqüentes para todo o sistema, sem dúvida, tornar-se um desperdício.

ADO.Net Team irá dar uma melhor métodos de solução. A conexão salva anterior, da próxima vez terá de conexões abertas quando a conexão anterior para a próxima conexão. Este é o pool de conexão.

Bem, este pooling é como trabalhar isso?

Primeiro, quando um programa é executado Connection.open (), ADO.net necessidade de juiz, esta suporta conexão Connection Pool (Pooling padrão é True), se especificar Falso, ADO.net é criado entre o banco de dados e uma conexão (por à confusão evitar, todos conectados ao banco de dados, use a descrição "connect"), em seguida, retorna para o programa. Se você especificar true, ADO.net será baseado ConnectString criar um Connection Pool, e em seguida, preencha Connection para Connection Pool (programa de todas as ligações de .net, use o "Conexão" descrição). Ligação para preencher o número determinado pelo tamanho Min Pool (padrão é 0) propriedades. Por exemplo, se 5 for especificado, o tempo entre ADO.net banco de dados aberto SQL 5 está ligado, em seguida, o Connection 4, armazenado no Connection Pool, uma ligação de retorno.

Quando o programa é executado para Connection.Close () de. O pool de conexões Piscina é colocado Se True, ADO.net atual put Connection e realizada entre o banco de dados de conexão. Ao mesmo tempo, a determinação de ligação ao longo da vida (padrão é 0) propriedades, 0 representa o infinito, se houver tempo excede Ligação Ligação LifeTime, ADO.net conexão vai ser fechado sem ligação à ligação para a base de dados, em vez de guardá-lo novamente para conexão piscina em.

(Este é utilizado principalmente no agrupamento do banco de dados SQL, carregar fins de equilíbrio). Se Pooling designado False, o desconectado diretamente entre banco de dados.

Então da próxima vez Connection.Open () implementação do tempo, ADO.Net Connection irá determinar se o novo ConnectionString ConnectionString previamente armazenada no pool de conexão é consistente. (ADO.Net ConnectionString vai se transformar em um fluxo binário, por assim dizer, o novo ConnectionString deve corresponder exatamente ConnectionString da ligação guardada em Connection Pool in ainda acrescentou uma espaços extras, ou modificar certos atributos na cadeia de conexão a ordem vai fazer ADO.Net que esta é uma nova conexão, e re-criar uma nova conexão, por isso, se você estiver usando um UserID, método de autenticação de senha, modificar a senha levará a uma conexão, se você estiver usando o SQL autenticação integrada, você precisa salvar duas conexões usando o mesmo).

ADO.net então necessário determinar se a conexão atual pool de conexão não podem ser utilizados (não sendo usado por outro programa), se não, é necessário determinar ADO.net Max Piscina configuração Tamanho ConnectionString (o padrão é 100), se o Connection que tudo Piscina conexão não chegar Max Pool Size, ADO.net irá se conectar ao banco de dados novamente para criar uma conexão, e depois voltará para o programa de conexão.

Se você tiver atingido MaxPoolSize, ADO.net novamente não irá criar novas conexões, mas espera Connection Piscina são ocupados por outros programas liberação Connection, este tempo de espera por SqlConnection.ConnectionTimeout (o padrão é 15 segundos) restrições, também isto é, se mais de 15 segundos, SqlConnection vai jogar fora de erro (por isso às vezes se SqlConnection.open () método lança um erro de tempo limite, uma possível razão é que não há tempo hábil Connnection fecho anterior, enquanto o número de Conexão Piscina alcançado o MaxPoolSize.)

Se um é Connection disponíveis, removido da Connection pool de conexão não é diretamente retornado ao programa, ADO.net também precisa verificar a propriedade ConnectionReset ConnectionString (o padrão é True) a necessidade de mais Conexão redefinida tempo. Isto porque, antes de retornar a partir da conexão do programa podem ter sido modificados, por exemplo, a utilização método para modificar a conexão atual, então Connection retornado pode ter sido ligado à ligação atual cadeia não é especificado no banco de dados catálogo inicial SqlConnection.ChangeDatabase. É necessário redefinir a conexão atual. No entanto, devido a todas as verificações extras vai aumentar ADO.net Connection Piscina sobrecarga no sistema.

pool de conexão é criada para cada seqüência de conexão única. Quando você cria uma piscina, uma pluralidade de objeto de conexão é criada e adicionada à piscina, a fim de atender o tamanho do conjunto mínimo. A necessidade de adicionar ao pool está ligado, mas não pode exceder o tamanho máximo do conjunto (o padrão é 100). volta para a piscina liberada quando a conexão é fechada ou aberta.

resumo

Quando pedido objeto SqlConnection, se houver uma conexão disponível a partir da piscina para obter o objeto. Disponível para se conectar, não deve ser utilizado, tendo uma correspondência contexto de transação associado ou qualquer contexto de transação, eo servidor tem uma ligação válida.

Conexão do processo pooling, realocando quando uma conexão é liberado de volta para a piscina, para atender a essas solicitações de conexão. Se o tamanho máximo piscina foi atingido e não há nenhuma conexão disponível, o pedido será enfileirado. Em seguida, o processo de tentar re-estabelecer a piscina qualquer conexão até alcançar o tempo limite (o padrão é 15 segundos). Se a piscina antes de o processo de conexão não pode atender o pedido, uma exceção é lançada.

Bom uso do pool de conexão irá melhorar significativamente o desempenho do seu aplicativo. Pelo contrário, se usados ​​de forma inadequada, então mais danos do que benefícios. Em geral, deve seguir os seguintes princípios:

1. No último pedido de tempo de conexão, a conexão é liberado com a maior brevidade.
2. Desligue a transacção definida pelo utilizador relevante quando a conexão é fechada.
3. Garantir e manter o pool de conexão tem pelo menos uma conexão aberta.
4. Tentar evitar a geração de fragmentos de células. Incluindo restos celulares gerados e piscina detritos segurança integrada gerado pelo uso de muitos bancos de dados.

jdbc:

Ter um Ado.net vir falar JDBC, linguagem Java, porque eu também aprendi recentemente então naturalmente os dois foram comparados

O JDBC pool de conexão banco de dados padrão

O método não fornece um pool de conexão JDBC API. Algumas grandes servidores de aplicações WEB, tais como WebLogic da BEA e do IBM WebSphere fornecem mecanismo pool de conexão, mas deve haver um métodos de classe especial de seu apoio de terceiros para o uso pool de conexão.

JDBC pool de conexão do banco de dados usado para representar javax.sql.DataSource, a fonte de dados única de uma interface que é normalmente fornecido por um servidor implementada (Weblogic, WebSphere, Tomcat), proporciona-se uma série de implementação de código aberto:

　　①DBCP pool de conexão de banco de dados

　　②C3P0 pool de conexão de banco de dados

　　Fonte de dados é geralmente referido como fonte de dados, o pool de conexão e que compreende duas porções de gestão de piscina ligado, os hábitos muitas vezes referida como uma fonte de dados pool de conexão

　　Ligado a diferentes fontes de dados e bases de dados, sem a criação de uma pluralidade de fontes de dados, o qual está conectado à central geradora de banco de dados, a totalidade das necessidades da aplicação a uma única fonte de dados.

　　Após o fim do acesso de banco de dados, o programa ainda é a mesma de antes fechar a conexão de banco de dados: conn.close (); mas, acima de código não fecha a conexão física com o banco de dados, é apenas a liberação de conexão de dados, retornado para o pool de conexão do banco de dados.

JDBC mecanismo de banco de dados do pool de conexão:

pool de conexão do banco de dados é responsável pela distribuição, gestão e liberação de conexões de banco de dados. Banco de dados pool de conexão na inicialização, cria um certo número de ligações para o pool de conexão, o número destes conexão de dados é feita para definir o número mínimo de conexões de banco de dados. Se eles não usaram a conexão com o banco, o pool de conexão será sempre lá, pelo menos tantos número de conexões. O número máximo de pool de conexão do banco de dados limita o número máximo de conexões ocupado pelo pool de conexão, quando o número de conexão solicitações de aplicativos para o pool de conexão é maior do que esse limite, o pedido será adicionado à fila de espera. O número mínimo de conexões e o número máximo de conexões de banco de dados definida para considerar vários fatores:

1) O número mínimo de conexões para a conexão de banco de dados pool de conexões de banco de dados continuará a ser, se quando um aplicativo usa a conexão de banco de dados não é particularmente grande, haverá um grande número de recursos de conexão de banco de dados são desperdiçados;

2) o número máximo de ligações é o número máximo de ligações para a lata aplicação da base de dados, se este número for superior a um pedidos de ligação de base de dados, pedido de ligação da base de dados vão depois ser adicionadas à fila de espera, de modo que este último irá afectar o funcionamento da base de dados;

3) Se o número mínimo de conexões e o número máximo de conexões que muita diferença, então a solicitação de conexão será o primeiro a lucro, depois de mais de um número mínimo de conexões a conexão é equivalente a re-criar uma nova conexão de banco de dados. No entanto, estes maior do que o mínimo número de conexões não está terminado usando a conexão de banco de dados é imediatamente liberado, ele será colocado no pool de conexão depois de esperar para o tempo limite ocioso reutilizados ou liberado.

Agora vamos tentar usar DBCP maneira de se conectar ao banco de dados

1, primeiro criar um projeto Maven e criar uma nova db.properties arquivo em recursos

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mysql?&useSSL=false&serverTimezone=UTC
jdbc.username=root //用户名
jdbc.password=123456 //密码
initSize=10 //初始化连接数
maxTotal=200 //最大连接数
maxIdle=60 //最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。

2, seguido por introdução do perito pacote de dependência

<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.19</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-dbcp2</artifactId>
        <version>2.7.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.7.0</version>
    </dependency>

    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

cópia direta e colar, mas nota por favor padrão que você deve re-jdk versão 8 ou superior!

3, em seguida, uma nova classe JdbcUtil

package com.jdbc.util;    
import org.apache.commons.dbcp2.BasicDataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;

/**
 * DBCP的方式链接数据库
 */
public class JdbcUtil {
    private static String driver;
    private static String url;
    private static String username;
    private static String password;
    private static int initSize;
    private static int maxTotal;
    private static  int maxIdle;
    private static BasicDataSource ds;
    static {
        ds = new BasicDataSource();
        Properties cfg=new Properties();
        try { //读取db.properties文件
            InputStream in = JdbcUtil.class
                    .getClassLoader()
                    .getResourceAsStream("db.properties");
            cfg.load(in);
            //初始化参数
            driver=cfg.getProperty("jdbc.driver");
            url=cfg.getProperty("jdbc.url");
            username=cfg.getProperty("jdbc.username");
            password=cfg.getProperty("jdbc.password");
            initSize=Integer.parseInt(cfg.getProperty("initSize"));
            maxTotal=Integer.parseInt(cfg.getProperty("maxTotal"));
            maxIdle=Integer.parseInt(cfg.getProperty("maxIdle"));
            in.close();
            //初始化连接池
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(username);
            ds.setPassword(password);
            ds.setInitialSize(initSize);
            ds.setMaxTotal(maxTotal);
            ds.setMaxIdle(maxIdle);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    public static Connection getConnection() {//连接数据库封装类
        try {
            /*
             * getConnection()从连接池中获取的重用
             * 连接，如果连接池满了，则等待。
             * 如果有归还的连接线，则获取重用的连接
             */
            Connection conn = ds.getConnection();
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    public static void close(Connection conn) {//关闭数据库的连接方法，封装复杂的关闭过程；
        if(conn!=null) {
            try {
                //将用过的连接归还到连接池
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

4, escrevemos um teste de classe para verificar

package com.jdbc.service;
import com.jdbc.util.JdbcUtil;

import java.sql.Connection;
import java.sql.SQLException;

public class JdbcTest {
    public static void main(String[] args) {
        try {
            for (int i=0;i<1000;i++){
                Thread a= new Thread(new TestThread(),"线程:"+(i+1));
                a.start();
                System.out.println(a.getName()+"已启动");
            }
        }
        catch (Exception ex){
            ex.printStackTrace();
        }
    }
    private static class TestThread implements Runnable{

        private Connection con= JdbcUtil.getConnection();
        @Override
        public void run() {
            try {
                if (con.isClosed()){
                    System.out.println("连接已经关闭");
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            finally {
                //JdbcUtil.close(con);
                //System.out.println("\t"+Thread.currentThread().getName()+"已关闭");
            }
        }
    }
}

Agora, execute o teste e descobriu que a produção

Porto ocupa 200, abriu o trabalho pool de threads, mas eu não liberar a porta de conexão, mas eu mudei um pouco db.properties número máximo de conexões 300, agora vamos olhar para os resultados

Você pode ver a nossa conexão com o banco está sendo dada, é por isso? Porque meu MySQL local da porta de conexão 200 somente quando a porta está conectada mais de 200 entrará em colapso. É também base de dados comum gargalo conectividade

Agora vamos fechar o código descomentada conexão, você pode ver que mesmo que haja 1.000 ligações será realizada rapidamente, e não vai ocupar porta extra

DBCP caminho é o caminho do uso de servidores Tomcat, assim, no tomcat usando um pool de conexão de dados ou necessário, pelo menos na concorrência geral Go On! O pool de conexão do banco de dados pode usar integrado com o servidor de aplicativos, o aplicativo também pode ser usado de forma independente.

resumo

O JDBC Java e Microsoft Ado.net de fato diferença essencial não é grande, assim como para a operação do banco de dados, o maior banco de dados de sua ligação gargalo de desempenho fundamentais é realmente o problema?

Em seguida, o índice do banco de dados, o banco de dados agora sub-biblioteca de sub-mesa, há uma tecnologia de separação de ler e escrever é por causa do que? Portanto, o pool de conexão do banco de dados é um dos otimização de desempenho, otimização de banco de dados e muitos mais no futuro funcionamento de espera para pessoas que exploram

Como o atual Alibaba Druid, é o mais demanda melhores resultados, ORM da Microsoft também abriram cedo são otimizados para o pool de conexões de banco de dados, que marca o futuro da Internet não é um gargalo de desempenho tem sido a situação com um banco de dados relacional tradicional

Futuro NoSQL intervenção popular, de modo que alta concorrência melhor para assumir a tarefa de grandes projetos de Internet!

Na verdade, para Ado.net e jdbc eu não tomar o tempo para comparar o desempenho, eu como C # também como Java, esta é uma excelente linguagem aprender uns com os outros, e então nós escrever o código, como aprender algoritmo, se você começa a entender como escrever Eu acredito que um código de boa, você não está preocupado com as vantagens da linguagem de desempenho.

Este artigo refere-se a:

https://blog.csdn.net/huwei2003/article/details/71459198

https://blog.csdn.net/hliq5399/article/details/73292023

https://blog.csdn.net/weixin_40751299/article/details/81609332

https://www.cnblogs.com/justdoitba/p/8087984.html

https://www.cnblogs.com/albertrui/p/8421791.html

https://blog.csdn.net/L_it123/article/details/88205528

Graças acima figurões do artigo, para que eu possa economizar tempo para escrever este artigo.