Méthode traditionnelle et méthode de regroupement de connexions
Étapes de la méthode traditionnelle
Utiliser la méthode traditionnelle dans JDBC est utilisé en Java pour se connecter à la base de données et effectuer une opération de base de données. Généralement, il y a les étapes suivantes :
1.
2. Établissez la connexion.
3. Exécutez l'instruction SQL.
4. Libérez la connexion.
5. Inconvénients de la méthode traditionnelle
Chaque opération sur la base de données nécessite l'établissement d'une connexion, et l'objet Connection résultant sera chargé en mémoire, ce qui consomme beaucoup de mémoire et de temps. . Si de nombreuses opérations nécessitent l'établissement d'une connexion dans un court laps de temps, cela occupera beaucoup de ressources système et provoquera même un crash du serveur.
Correspondant à l'établissement d'une connexion, vous devez libérer manuellement la connexion à chaque fois que vous l'utilisez. Si vous oubliez de libérer la connexion ou si le programme ne parvient pas à la libérer en raison d'une exception, cela provoquera une fuite de mémoire. .
De plus, la méthode traditionnelle ne peut pas contrôler le nombre de connexions. Si trop de personnes sont connectées, un nombre illimité d'objets de connexion seront créés, entraînant une surcharge de mémoire excessive et un crash du serveur.
(Vidéo recommandée : Tutoriel vidéo Java)
Étapes du pool de connexion
Créez un pool de connexions et configurez-le. la propriété de connexion.
2. Utilisez un pool de connexion pour obtenir une connexion.
Avantages du pool de connexions
Chaque fois que vous devez vous connecter à la base de données, vous n'avez pas besoin d'établir une connexion, mais de l'obtenir via le pool de connexions, qui assure la connexion.
Après avoir utilisé la connexion, vous n'avez pas besoin de libérer manuellement la connexion, mais laissez le pool de connexions libérer la connexion.
Le nombre de connexions peut être contrôlé via le pool de connexions. Les connexions du pool de connexions peuvent être réutilisées plusieurs fois, évitant ainsi le problème de la création de connexions illimitées.
Utiliser le pool de connexions
Utiliser le pool de connexions à la base de données C3P0
Importer le package jar :
c3p0-0.9.5.2.jar
Dans le répertoire racine du code du projet en cours Créez un nouveau fichier de configuration nommé c3p0-config.xml sous src Notez que le nom du fichier ne peut pas être modifié. Le contenu est le suivant :
<c3p0-config>
<!-- 连接名称 -->
<named-config name="mysql">
<!-- 接数据库的驱动类名 -->
<property name="driverClass">com.mysql.jdbc.Driver</property>
<!-- 连接属性 -->
<property name="jdbcUrl">jdbc:mysql://192.168.35.128:3306/demo</property>
<property name="user">root</property>
<property name="password">123456</property>
<!-- 当连接池用完时等待获取新连接的时间，超时后将抛出SQLException，单位毫秒，如设为0则无限期等待。默认为0。 -->
<property name="checkoutTimeout">5000</property>
<!-- 当连接用尽后，一次获取的连接个数 -->
<property name="acquireIncrement">2</property>
<!-- 初始连接数 -->
<property name="initialPoolSize">1</property>
<!-- 最小连接数 -->
<property name="minPoolSize">3</property>
<!-- 最大连接数 -->
<property name="maxPoolSize">5</property>
</named-config>
</c3p0-config>Code du programme :
public class TestDataPool {
// 根据配置文件里的名称创建连接池
public static ComboPooledDataSource cpds = new ComboPooledDataSource("mysql");
/**
* 主程序
*/
public static void main(String[] args) {
// 模拟多次对数据库的查询操作
for (int i = 0; i < 6; i++) {
new Thread(new Runnable() {
@Override
public void run() {
select();
}
}, "线程" + i).start();
}
}
/**
* 查询程序
*/
public static void select() {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
// 获取连接并执行SQL
try {
conn = cpds.getConnection();
pstmt = conn.prepareStatement("select * from student where id = 906");
rs = pstmt.executeQuery();
while (rs.next()) {
System.out.println(Thread.currentThread().getName() + "\t" + rs.getString(1) + "\t" + rs.getString(2) + "\t" + rs.getString("address"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 释放资源
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}Utiliser DBCP. pool de connexion à la base de données
Importez le package jar :
commons-dbcp-1.4.jar2 commons-pool-1.5.5.jar
Créez un nouveau fichier de configuration nommé dbcp.properties sous le répertoire racine du code src du projet en cours. Le nom du fichier doit être le même que celui. le nom du fichier référencé dans le code. Le contenu est le suivant :
# 接数据库的驱动类名 driverClassName=com.mysql.jdbc.Driver # 连接属性 url=jdbc:mysql://192.168.35.128:3306/demo username=root password=123456 # 初始化连接数 initialSize=10 # 最大连接数 maxActive=15
Code du programme :
public class TestDBCP {
// 根据配置文件里的名称创建连接池
private static DataSource source = null;
static {
Properties pros = new Properties();
InputStream is = TestDBCP.class.getClassLoader().getResourceAsStream("dbcp.properties");
try {
pros.load(is);
source = BasicDataSourceFactory.createDataSource(pros);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 主程序
*/
public static void main(String[] args) {
// 模拟多次对数据库的查询操作
for (int i = 0; i < 6; i++) {
new Thread(new Runnable() {
@Override
public void run() {
select();
}
}, "线程" + i).start();
}
}
/**
* 查询程序
*/
public static void select() {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
// 获取连接并执行SQL
try {
conn = source.getConnection();
pstmt = conn.prepareStatement("select * from student where id = 906");
rs = pstmt.executeQuery();
while (rs.next()) {
System.out.println(Thread.currentThread().getName() + "\t" + rs.getString(1) + "\t" + rs.getString(2) + "\t" + rs.getString("address"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 释放资源
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
pstmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}.Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!