Einführung in die Methoden der JDBC-Datenbank im Frühjahr

Dieser Artikel stellt hauptsächlich den Aufbau des grundlegenden JDBC-Frameworks basierend auf Spring vor; das Hinzufügen, Löschen, Ändern und Abfragen von JDBC basierend auf dem Lesen der Daten in der Konfigurationsdatei usw. hat einen sehr guten Referenzwert . Schauen wir es uns mit dem folgenden Editor an

Datenbankverbindungspool

Für eine einfache Datenbankanwendung ist dies möglich, da der Zugriff auf die Datenbank nicht sehr häufig erfolgt Wenn Sie auf die Datenbank zugreifen müssen, erstellen Sie einfach eine neue Verbindung und schließen sie, wenn Sie fertig sind. Dadurch entsteht kein Leistungsaufwand. Bei einer komplexen Datenbankanwendung ist die Situation jedoch völlig anders. Häufiges Herstellen und Schließen von Verbindungen verringert die Leistung des Systems erheblich, da die Verwendung von Verbindungen zu einem Engpass der Systemleistung geworden ist.

Durch die Einrichtung eines Datenbankverbindungspools und einer Reihe von Richtlinien zur Verbindungsnutzungsverwaltung kann der Effekt der Wiederverwendung von Verbindungen erzielt werden, sodass eine Datenbankverbindung sicher und effizient wiederverwendet werden kann, wodurch vermieden wird Datenbankbedarf Der Aufwand für häufiges Herstellen und Schließen von Verbindungen. Das Grundprinzip des

Datenbankverbindungspools besteht darin, eine bestimmte Anzahl von Datenbankverbindungen im internen Objektpool beizubehalten und die Methoden zum Erwerb und zur Rückgabe der Datenbankverbindung nach außen zugänglich zu machen. Beispiel: Externe Benutzer können die Verbindung über die Methode getConnection abrufen und sie nach der Verwendung über die Methode releaseConnection zurückgeben. Beachten Sie, dass die Verbindung zu diesem Zeitpunkt nicht geschlossen ist, sondern vom Verbindungspool-Manager recycelt und für die nächste vorbereitet wird verwenden.

Vorteile der Datenbankverbindungspool-Technologie:

1. Ressourcenwiederverwendung

Aufgrund von Datenbankverbindungen werden wiederverwendet, wodurch ein großer Leistungsaufwand durch häufiges Erstellen und Freigeben von Links vermieden wird. Aufgrund der Reduzierung des Systemverbrauchs wird andererseits auch die Stabilität der Systembetriebsumgebung verbessert (reduziert Speicherfragmentierung und temporäre Datenbankverarbeitung/Anzahl von Threads)

2. Schnellere Reaktionsgeschwindigkeit des Systems

Während des Initialisierungsprozesses des Datenbankverbindungspools werden häufig mehrere Datenbankverbindungspools erstellt und zur Sicherung im Pool abgelegt. Zu diesem Zeitpunkt ist die Initialisierung der Verbindung abgeschlossen. Für die Verarbeitung von Geschäftsanforderungen werden vorhandene verfügbare Verbindungen direkt verwendet, um den Zeitaufwand für die Initialisierung und Freigabe der Datenbankverbindung zu vermeiden und dadurch die Gesamtantwortzeit des Systems zu reduzieren

3. Einheitliche Verbindungsverwaltung zur Vermeidung von DatenbankverbindungsverlustenIn einer relativ vollständigen Datenbankverbindungspoolimplementierung kann die erzwungene Wiederherstellung auf der voreingestellten Zeitüberschreitungseinstellung für die Verbindungsbelegung basieren. Die belegte Verbindung vermeidet somit Ressourcenverluste, die bei regulären Datenbankverbindungsvorgängen auftreten können.

Derzeit gibt es viele Datenbankverbindungspoolprodukte, hauptsächlich darunter:

1, dbcpdbcp, der von Apache erstellte Datenbankverbindungspool, wird vom Spring-Entwicklungsteam empfohlen. Er wird aktiv weiterentwickelt und ist ein äußerst weit verbreitetes Datenbankverbindungspoolprodukt. Aus dem Internet

2, c3p0 wird jedoch der vom Hibernate-Entwicklungsteam empfohlene Datenbankverbindungspool verwendet, der die Bindung von Datenquellen implementiert und JNDI

3. ProxoolProxool hat einen guten Ruf und es gibt keine negativen Kommentare (zum Beispiel wird dbcp von Hibernate nicht verwendet). weil Hibernate der Meinung ist, dass es zu viele Fehler gibt (empfohlen) ist auch der vom Hibernate-Entwicklungsteam empfohlene Datenbankverbindungspool, aber es gibt nicht viele Benutzer und die Entwicklung ist nicht aktiv genug. Dieser Verbindungspool bietet die Funktion der Verbindungspoolüberwachung, die bequem und einfach zu verwenden ist und die Erkennung von Verbindungspoollecks erleichtert

Aufbau des JDBC-Grundgerüsts basierend auf Spring

Lassen Sie uns zuerst darüber sprechen. Der vom Spring-Entwicklungsteam empfohlene Datenbankverbindungspool erfordert drei JAR-Pakete:

1 .jar. Es ist auf der offiziellen Website verfügbar. Klicken Sie hier, um

2 herunterzuladen. commons.collections4-4.0.jar, das auf der offiziellen Website verfügbar ist

Nachdem Sie diese drei JAR-Pakete heruntergeladen haben, importieren Sie sie bitte in Ihr eigenes Projekt (Hinweis: Vergessen Sie nicht,

MySql Paket). Obwohl sowohl dbcp als auch pool2-Versionen vorhanden sind, können sie auf der offiziellen Apache-Website heruntergeladen werden. Die Versions-Download-Adressen von dbcp1 und pool1 werden jedoch hier angegeben pool2 kann nur in JDK1.7 und höher ausgeführt werden, während dbcp1 und pool1 in JDK1.6 ausgeführt werden können. Beachten Sie, dass die Standard-JRE, die mit My

Eclipse

10 geliefert wird, Version 1.6 ist. Laden Sie daher dbcp1 herunter und verwenden Sie es und pool1 hier. Wenn Sie dbcp2 und pool2 möchten, können Sie diese von der offiziellen Apache-Website herunterladen. Beachten Sie jedoch, dass dbcp2 mit pool2 und dbcp1 mit pool1 gekoppelt werden muss. Sie können nicht austauschbar verwendet werden.

JDBC, ich habe bereits einen Artikel geschrieben, der alle im Originalartikel verwendet wird. Hier verschiebe ich einfach den nativen JDBC auf Spring JDBC . Weitere Funktionen hinzufügen, die Kategorie Studentenverwaltung ist:

public class StudentManager
{
 private JdbcTemplate jdbcTemplate;

 private static StudentManager instance = new StudentManager();

 public static StudentManager getInstance()
 {
 return instance;
 }

 public JdbcTemplate getJdbcTemplate()
 {
 return jdbcTemplate;
 }
 public void setJdbcTemplate(JdbcTemplate jdbcTemplate)
 {
 this.jdbcTemplate = jdbcTemplate;
 }
}

Springs XML-Konfigurationsdatei heißt jdbc.xml. Die Schreibweise von jdbc.xml lautet:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-4.2.xsd">

 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
 <!-- 驱动包名 -->
 <property name="driverClassName" value="com.mysql.jdbc.Driver" />
 <!-- 数据库地址 -->
 <property name="url" value="jdbc:mysql://localhost:3306/school?useUnicode=true&characterEncoding=utf8;" />
 <!-- 用户名 -->
 <property name="username" value="root" />
 <!-- 密码 -->
 <property name="password" value="root" />
 <!-- 最大连接数量 -->
 <property name="maxActive" value="150" />
 <!-- 最小空闲连接 -->
 <property name="minIdle" value="5" />
 <!-- 最大空闲连接 -->
 <property name="maxIdle" value="20" />
 <!-- 初始化连接数量 -->
 <property name="initialSize" value="30" />
 <!-- 连接被泄露时是否打印 -->
 <property name="logAbandoned" value="true" />
 <!-- 是否自动回收超时连接 -->
 <property name="removeAbandoned" value="true" />
 <!-- 超时等待时间(以秒为单位) -->
 <property name="removeAbandonedTimeout" value="10" />
 </bean>

 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <property name="dataSource" ref="dataSource" />
 </bean>
 <bean id="studentManager" class="com.xrq.jdbc.StudentManager" factory-method="getInstance"> 
 <property name="jdbcTemplate" ref="jdbcTemplate" />
 </bean>
</beans>

Hauptfunktion ist:

public static void main(String[] args)
{ 
 ApplicationContext ac = 
  new ClassPathXmlApplicationContext("jdbc.xml");
 System.out.println(StudentManager.getInstance());
 System.out.println(StudentManager.getInstance().getJdbcTemplate());
}

läuft ohne Probleme. Ich erhalte die Referenz--Adresse von StudentManager und die Referenzadresse des -Attributs jdbcTemplate in StudentManager dass der gesamte Anschluss und die Einspritzung kein Problem darstellen.

JDBCTemple ist die grundlegendste JDBC-Vorlage in Spring, die JDBC und einfache IndexParameterAbfrage verwendet, um einen einfachen Zugriff auf die Datenbank zu ermöglichen. Zusätzlich zu JDBCTemplate bietet Spring auch zwei Klassen: NamedParameterJdbcTemplate und SimpleJdbcTemplate. Erstere kann beim Ausführen von Abfragen Werte an benannte Parameter binden, anstatt Indizes zu verwenden 🎜>Variablenparameter Liste zur Vereinfachung der Verwendung von JDBC-Vorlagen. Welches verwendet wird, hängt von den persönlichen Vorlieben ab. Hier wird JdbcTemplate zur Studentenverwaltungsklasse hinzugefügt.

Außerdem:

1. dbcp stellt viele Parameter für die Benutzerkonfiguration bereit. Die Bedeutung jedes Parameters ist im . angegeben >

2. Achten Sie auf die Attribut-URL von dbcp. Die URL bezieht sich auf die Datenbankverbindungsadresse muss konvertiert werden, wenn

Sonderzeichen

Bedeutung , sodass das „&“ hier zu „&“ wird, andernfalls wird ein Fehler gemeldet JDBC basierend auf Spring hinzufügen, löschen, ändern und prüfen

Above Part Schauen wir uns an, wie der Java-Code CRUD implementiert. In diesem Prozess muss jdbc.xml nicht geändert werden.

1. Fügen Sie Studenteninformationen hinzu, der Code lautet:

2. Löschen Sie die

angegebenen Studenteninformationen basierend auf der ID

, der Code lautet:

// 添加学生信息
public boolean addStudent(Student student)
{
 try
 {
 jdbcTemplate.update("insert into student values(null,?,?,?)", 
  new Object[]{student.getStudentName(), student.getStudentAge(), student.getStudentPhone()},
  new int[]{Types.VARCHAR, Types.INTEGER, Types.VARCHAR});
 return true;
 }
 catch (Exception e)
 {
 return false;
 }
}

3. Aktualisieren Sie Schülerinformationen basierend auf der ID , der Code lautet:

// 根据Id删除单个学生信息
public boolean deleteStudent(int id)
{
 try
 {
 jdbcTemplate.update("delete from student where studentId = ?", new Object[]{id}, new int[]{Types.INTEGER});
 return true;
 }
 catch (Exception e)
 {
 return false;
 }
}

4. Fragen Sie Studenteninformationen basierend auf der ID ab, der Code lautet:

5. Um alle Schülerinformationen abzufragen, lautet der Code:

// 根据Id更新指定学生信息
public boolean updateStudent(int Id, Student student)
{
 try
 {
 jdbcTemplate.update("update student set studentName = ?, studentAge = ?, studentPhone = ? where studentId = ?", 
  new Object[]{student.getStudentName(), student.getStudentAge(), student.getStudentPhone(), Id},
  new int[]{Types.VARCHAR, Types.INTEGER, Types.VARCHAR, Types.INTEGER});
 return true;
 }
 catch (Exception e)
 {
 return false;
 }
}

Dies ist eine einfache CRUD-Operation. Auf dieser Grundlage kann der Rest erweitert werden Diese 5, daher werde ich nicht weiter im Detail schreiben, lassen Sie mich auf einige Punkte eingehen, die Sie beachten sollten:

// 根据学生Id查询单个学生信息
public Student getStudent(int id)
{
 try
 {
 return (Student)jdbcTemplate.queryForObject("select * from student where studentId = ?", 
  new Object[]{id}, new int[]{Types.INTEGER}, new RowMapper<Student>(){
  public Student mapRow(ResultSet rs, int arg1) throws SQLException
  {
  Student student = new Student(rs.getInt(1), rs.getString(2), rs.getInt(3), rs.getString(4));
  return student;
  }
 });
 }
 // 根据Id查询学生信息抛异常, 不管什么原因, 认为查询不到该学生信息, 返回null
 catch (DataAccessException e)
 {
 return null;
 }
}

1. Aus persönlicher Erfahrung wird empfohlen, es zu versuchen. ..catch... blockiert die anderen, denn wenn die Operation fehlschlägt, wird eine Ausnahme

ausgelöst. Wenn Sie sie abfangen, wissen Sie, dass die Operation fehlgeschlagen ist , und Sie werden nicht wissen, ob der Vorgang erfolgreich war oder fehlgeschlagen

// 查询所有学生信息
public List<Student> getStudents()
{
 List<Map<String, Object>> resultList = jdbcTemplate.queryForList("select * from student");
 List<Student> studentList = null;
 if (resultList != null && !resultList.isEmpty())
 {
 studentList = new ArrayList<Student>();
 Map<String, Object> map = null;
 for (int i = 0; i < resultList.size(); i++)
 {
  map = resultList.get(i);
  Student student = new Student(
  (Integer)map.get("studentId"), (String)map.get("studentName"),
  (Integer)map.get("studentAge"), (String)map.get("studentPhone")
  );
  studentList.add(student);
  }
 }
 return studentList;
}

2. Beim Hinzufügen oder Aktualisieren von Informationen wird nicht empfohlen, jedes zu bedienende Feld als formalen Parameter zu verwenden Dies entspricht eher den

objektorientierten

Designprinzipien, zweitens gibt es viele Felder in der formalen Parameterliste, die leicht zu Fehlern führen können

3. Wenn für Aktualisierungs- und Abfragemethoden Platzhalter vorhanden sind, wird empfohlen, die Methode „Überladen mit Parametertypen“ zu wählen und den Feldtyp jedes Platzhalters anzugeben, genau wie ich es geschrieben habe Der obige Code Abschließend geht es hier um die grundlegende Verwendung von jdbcTemplate. Es gibt viele Methoden in jdbcTemplate, ich werde nicht einzeln auf Details eingehen Probieren Sie es selbst aus oder schauen Sie sich die Spring

API

-Dokumentation an.

Lesen Sie die Daten in der Konfigurationsdatei

Zuvor haben wir einige Eigenschaften der Datenbankverbindung in db.properties konfiguriert, was das Ändern erleichtert, aber hier ist es Es ist in jdbc.xml fest codiert, daher müssen wir uns eine Möglichkeit überlegen, die Konfiguration aus db.properties zu lesen. Schauen Sie sich an, wie jdbc.xml geschrieben ist > 【Verwandte Empfehlungen】

1.

Kostenloses Java-Video-Tutorial

2.

JAVA-Tutorial-Handbuch

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-4.2.xsd">

 <context:property-placeholder location="classpath:db.properties"/>

 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
 <!-- 驱动包名 -->
 <property name="driverClassName" value="${mysqlpackage}" />
 <!-- 数据库地址 -->
 <property name="url" value="${mysqlurl}" />
 <!-- 用户名 -->
 <property name="username" value="${mysqlname}" />
 <!-- 密码 -->
 <property name="password" value="${mysqlpassword}" />
 <!-- 最大连接数量 -->
 <property name="maxActive" value="150" />
 <!-- 最小空闲连接 -->
 <property name="minIdle" value="5" />
 <!-- 最大空闲连接 -->
 <property name="maxIdle" value="20" />
 <!-- 初始化连接数量 -->
 <property name="initialSize" value="30" />
 <!-- 连接被泄露时是否打印 -->
 <property name="logAbandoned" value="true" />
 <!-- 是否自动回收超时连接 -->
 <property name="removeAbandoned" value="true" />
 <!-- 超时等待时间(以秒为单位) -->
 <property name="removeAbandonedTimeout" value="10" />
 </bean>

 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <property name="dataSource" ref="dataSource" />
 </bean>
 <bean id="studentManager" class="com.xrq.jdbc.StudentManager" factory-method="getInstance"> 
 <property name="jdbcTemplate" ref="jdbcTemplate" />
 </bean>
</beans>

3 .

Umfassende Analyse von Java-Annotationen

Das obige ist der detaillierte Inhalt vonEinführung in die Methoden der JDBC-Datenbank im Frühjahr. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!