Le JDBC (b) - Utiliser la connexion de base de données IDEA, un pool de connexion de base de données

1. connexion de base de données IDEA

(1) Cliquez sur le côté droit de la base de données d'interface IDEA

(2) Cliquez sur +, puis cliquez sur la source de données, et enfin cliquez sur MySQL

(3) Remplissez le nom d' utilisateur et mot de passe, testez la connexion

écran est affiché (4) connexion réussie

(5) Sélectionnez cette option pour se connecter base de données de connexion jdbcstudy par exemple


après l'interface (6) base de données jdbcstudy connexion réussie

(7) Double-cliquez sur les utilisateurs nom de la table, table ouverte

(8) de mettre à jour les données modifiées

(9) à écrire du code SQL

(10) , la connexion a échoué, pourquoi

2. Transaction

Soit tout réussir ou échouer

• Application du Code
  ① transaction ouverte conn.setAutoCommit (false)
  ② un ensemble de l' entreprise est terminée, valider la transaction
  ROLLBACK définie ③ peut être affiché dans une instruction catch, mais le défaut échouera rollback

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class TestTransaction2 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        
        try {
            conn = JdbcUtils.getConnection();
            // 关闭数据库的自动提交，自动会开启事务
            conn.setAutoCommit(false); // 开启事务

            String sql1 = "update account set money = money-100 where name = 'A'";
            st = conn.prepareStatement(sql1);
            st.executeUpdate();

            int x = 1/0; // 报错

            String sql2 = "update account set money = money+100 where name = 'B'";
            st = conn.prepareStatement(sql2);
            st.executeUpdate();

            //业务完毕，提交事务
            conn.commit();
            System.out.println("成功！");

        } catch (SQLException e) {
            // 若果失败，则默认回滚
//            try {
//                conn.rollback();  // 如果失败则回滚事务
//            } catch (SQLException e1) {
//                e1.printStackTrace();
//            }
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn,st,rs);
        }
    }
}

3. pool de connexion de base de données

Base de données de connexion - sortie - fini
connexion - la libération est un gaspillage de ressources du système, la
technique mise en commun: des ressources pré-préparation, viennent sur la connexion pré-préparés

• Ouvrir la mise en œuvre de la source de données source (apporté)
  DBCP
  C3P0
  Druide: Alibaba

Après avoir utilisé le pool de connexions de base de données, nous ne devons écrire du code pour se connecter à la base de données dans le développement du projet!

• Pour DBCP, par exemple
  la nécessité d'utiliser le paquet pot: commons-dbcp-1.4, communes -POOL-1.6

Le répertoire lib Ass une bibliothèque, écrit dans le dbcpconfig.properties fichier de projet

• Lors de l'utilisation des paramètres de mise en commun de connexion pour configurer l'apparence

Nombre minimum de connexions: un pool de connexions de base de données est maintenue, si le montant de l'application à la base de données n'est pas connecté, il y aura un grand nombre de ressources de connexion de base de données sont gaspillés.
Nombre maximum de connexions: est le nombre maximum de pools de connexion peut appliquer, si les demandes de connexion de base de données dépassant le nombre de fois, la demande de connexion de base de données plus tard à ajouter à la file d'attente, ce qui aura une incidence sur le fonctionnement de base de données après
le temps d' inactivité au maximum l'
obtention d' un délai d' attente connexion
délai de retransmission temps de connexion de test

#连接设置  这里面的名字，是DBCP数据源中定义好的
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy?useUnicode=true&characterEncoding=utf8&useSSL=true
username=root
password=123456

#<!-- 初始化连接 -->
initialSize=10

#最大连接数量
maxActive=50

#<!-- 最大空闲连接 -->
maxIdle=20

#<!-- 最小空闲连接 -->
minIdle=5

#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000

#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8

#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true

#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=

#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

• Ensuite, écrire un Outils DBCP

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JdbcUtils_DBCP {

    private static DataSource dataSource = null;

    static {
        try{
            InputStream in =  JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties properties = new Properties();
            properties.load(in);

            //创建数据源 工厂模式 --> 创建
            dataSource = BasicDataSourceFactory.createDataSource(properties);

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

    //获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection(); //从数据源中获取连接
    }

    //释放连接资源
    public static void release(Connection conn, Statement st, ResultSet rs){
        if (rs!=null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (st!=null){
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn!=null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

• examiné

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Date;

public class TestDBCP {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement st = null;

        try {
            conn = JdbcUtils_DBCP.getConnection();
            // 区别
            // 使用？ 占位符代替参数
            String sql = "insert into users(id,`NAME`,`PASSWORD`,`email`,`birthday`) values(?,?,?,?,?)";

            st = conn.prepareStatement(sql); //预编译SQL，先写sql，然后不执行

            // 手动给参数赋值
            st.setInt(1,4); //id
            st.setString(2,"qinjiang");
            st.setString(3,"1232112");
            st.setString(4,"[email protected]");
            // 注意点： sql.Date   数据库   java.sql.Date()
            //          util.Date  Java     new Date().getTime() 获得时间戳
            st.setDate(5,new java.sql.Date(new Date().getTime()));

            //执行
            int i = st.executeUpdate();
            if (i>0){
                System.out.println("插入成功！");
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils_DBCP.release(conn,st,null);
        }
    }
}

• DBCP et C3P0 en utilisant des méthodes similaires, paquet jar nécessaire: c3p0-0.9.5.5, mchange-commons-java-0.2.19

• Conclusion
  Peu importe quelle source de données, l'essence est toujours le même, l' interface DataSource ne changera pas, la méthode ne deviendra pas