Frühlings-JDBC-Vorlage
Übersicht: Wie wir alle wissen, dass die Federrahmen ein wesentlicher Bestandteil der modernen Java-basierten Anwendungsentwicklung geworden ist. Die Federrahmen hat es geschafft, effektiv die Kontrolle über jede Abteilung in der Java-Entwicklung Welt zu übernehmen. Die JDBC-Schablone der Feder ist in den meisten der Feder Basis JEE-Anwendungen verwendet, um mit der Datenbank zu kommunizieren.
In diesem Artikel werde ich sprechen davon, wie eine relationale Datenbank für den Zugriff auf die JDBC-Vorlage von Feder verwendet.
Einführung: Wir alle kennen die Bedeutung der relationalen Datenbank in Unternehmen Anwendungsentwicklung. Der Frühling ist eine der weit verbreiteten Frameworks in Java-basierte Enterprise-Anwendungsentwicklung. Frühling hat verschiedene Module wie ORM, Sicherheit, Transaktion, JPS, JMS usw. die Notwendigkeit von Enterprise-Anwendungsentwicklung zu unterstützen. Im Frühling leicht verfügbaren Komponenten bietet Plug-in, Der moderne Ansatz für Enterprise-Java-Anwendungsentwicklung nutzt die Features ausgiebig. Als Folge ist die Entwicklung viel schneller und effizienter. Frühling bietet einen einfachen Ansatz Datenbankaktivitäten kennen als Feder JDBC-Vorlage zu handhaben.
Nachteile von Standard-JDBC-API: Standard-JDBC-API hat folgende Nachteile.
- Neben dem Haupt Abfrage ausgeführt, Sie brauchen eine Menge Code zu schreiben, um die Ausführungsumgebung Probleme zu behandeln Verbindung wie das Erstellen, Erklärung, resultset usw..
- Benötigen Sie die Ausnahmebehandlung Code separat zu handhaben.
- Sie benötigen Transaktions Probleme zu behandeln.
Vorteile der Feder JDBC-Vorlage: Frühlings-JDBC-Vorlage bietet folgende Vorteile gegenüber dem normalen Ansatz von Standard-JDBC.
- Reinigung der verwendeten Ressourcen wird automatisch durch Feder JDBC-Vorlage getan. So haben die Entwickler brauchen sich nicht um die Freigabe der Ressourcen zu stören. Daher verhindert es Speicherlecks.
- Frühlings-JDBC-Vorlage behandelt die Ausnahme und Fehler in einer effizienteren Weise. Er wandelt die JDBC SQLExceptions in Runtime, so dass die Entwickler es in flexibler handhaben.
- Die Feder JDBC-Vorlage wandelt auch die herstellerspezifischen Fehler in einer besseren sinnvolle Nachricht. So sind die Handhabungen dieser Fehler sind effizienter.
Anfangen:
In this document, Lassen Sie uns verwenden gradle als Build-Tool unsere Anwendung zu erstellen. Lassen Sie uns mit einer einfachen Anwendung starten zum Speichern und die Details der Mitarbeiter zusammen mit ihren Abteilungen einer Organisation abrufen. In unserem Beispiel, wir werden die folgenden Attribute des Mitarbeiters bezwecken:-
- Angestellten ID
- Mitarbeiter Vorname
- Mitarbeiter Mittelname
- Mitarbeiter Nachname
- Mitarbeiter Abteilung Id
Und die Abteilung Objekt hat folgende Attribute:-
- Abteilungs-ID
- Abteilungsname
Lassen Sie uns nun die Java-Objekte erstellen, die verwendet werden, mit der Datenbank zu kommunizieren. Unsere POJO Klassen für diese beiden Einheiten sind zu finden unter:
Listing1: Beispiel die Employee-Klasse zeigt,
[Code]
package com.home.springjdbc.objects;
Öffentlichkeit Klasse Employee {
// Die Mitarbeiter-ID
Private String EmpID;
// Der Mitarbeiter erste Namens
Private String empFName;
// Der Mitarbeiter zweiter Vorname
Private String empMName;
// Der Mitarbeiter Nachname
Private String empLName;
// Die Mitarbeiter Abteilung Id
Private String empDeptId;
Öffentlichkeit Employee ( String EmpID, String empFName, String empMName,
String empLName, String empDeptId ) {
Super();
Dies.EmpID = EmpID;
Dies.empFName = empFName;
Dies.empMName = empMName;
Dies.empLName = empLName;
Dies.empDeptId = empDeptId;
}
/**
* @Rückkehr die EmpID
*/
Öffentlichkeit String getEmpId () {
return EmpID;
}
/**
* @param EmpID
* die EmpID einstellen
*/
Öffentlichkeit ungültig setEmpId ( String EmpID ) {
Dies.EmpID = EmpID;
}
/**
* @Rückkehr die empFName
*/
Öffentlichkeit String getEmpFName () {
return empFName;
}
/**
* @param empFName
* die empFName einstellen
*/
Öffentlichkeit ungültig setEmpFName ( String empFName ) {
Dies.empFName = empFName;
}
/**
* @Rückkehr die empMName
*/
Öffentlichkeit String getEmpMName () {
return empMName;
}
/**
* @param empMName
* die empMName einstellen
*/
Öffentlichkeit ungültig setEmpMName ( String empMName) {
Dies.empMName = empMName;
}
/**
* @Rückkehr die empLName
*/
Öffentlichkeit String getEmpLName () {
return empLName;
}
/**
* @param empLName
* die empLName einstellen
*/
Öffentlichkeit ungültig setEmpLName ( String empLName) {
Dies.empLName = empLName;
}
/**
* @Rückkehr die empDeptId
*/
Öffentlichkeit String getEmpDeptId () {
return empDeptId;
}
/**
* @param empDeptId
* die empDeptId einstellen
*/
Öffentlichkeit ungültig setEmpDeptId ( String empDeptId ) {
Dies.empDeptId = empDeptId;
}
/*
* ( nicht-Javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Override
Öffentlichkeit String toString () {
return “Employee [ EmpID =” + EmpID + “, empFName=” + empFName
+ “, empMName =” + empMName + “, empLName =” + empLName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Beispiel die Abteilung Klasse zeigt
[Code]
package com.home.springjdbc.objects;
Öffentlichkeit Klasse Abteilung {
// Die Abteilung Id
Private String deptId;
// Die Abteilung Name
Private String DEPTNAME;
Öffentlichkeit Abteilung ( String deptId, String DEPTNAME) {
Super ();
Dies.deptId = deptId;
Dies.DEPTNAME = DEPTNAME;
}
/**
* @Rückkehr die deptId
*/
Öffentlichkeit String getDeptId () {
return deptId;
}
/**
* @param deptId
* die deptId einstellen
*/
Öffentlichkeit ungültig setDeptId ( String deptId ) {
Dies.deptId = deptId;
}
/**
* @Rückkehr die DEPTNAME
*/
Öffentlichkeit String getDeptName () {
return DEPTNAME;
}
/**
* @param DEPTNAME
* die DEPTNAME einstellen
*/
Öffentlichkeit ungültig setDeptName ( String DEPTNAME ) {
Dies.DEPTNAME = DEPTNAME;
}
/*
* (nicht-Javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
Öffentlichkeit String toString () {
return “Abteilung [ deptId =” + deptId + “, DEPTNAME =” + DEPTNAME + “]”;
}
}
[/Code]
Frühling bietet eine Template-Klasse bekannt als JdbcTemplate. Diese Klasse ist verantwortlich für die Kommunikation mit SQL relationalen Datenbanken und JDBC. In dem traditionellen Ansatz ist das Maximum eines JDBC-Code in der Handhabung Verbindungsmanagement besetzt, Ressourcenerfassung, Ausnahmebehandlung, und allgemeine Fehlerprüfung, die im Rahmen von respektlos ist, was wir versuchen zu erreichen,. Die JdbcTemplate kümmert sich um all diese Dinge und als Entwickler sollten wir nur auf die Geschäftslogik konzentrieren. Eine Beispielimplementierung der Template-Klasse wird wie unter gezeigt -
Listing3: Beispiel die Implementierung von JDBC-Vorlage zeigt
[Code]
package com.home.springjdbc.dao;
importieren java.sql.Driver;
importieren java.sql.ResultSet;
importieren java.sql.SQLException;
importieren java.util.List;
importieren org.springframework.jdbc.core.JdbcTemplate;
importieren org.springframework.jdbc.core.RowMapper;
importieren org.springframework.jdbc.datasource.SimpleDriverDataSource;
importieren com.home.springjdbc.objects.Employee;
Öffentlichkeit Klasse EmployeeDAO {
Öffentlichkeit statische ungültig Haupt ( String args[] ) {
// einfache DS für Test (nicht für die Produktion!)
SimpleDriverDataSource datasource = neue SimpleDriverDataSource();
dataSource.setDriverClass((Klasse<? erstreckt Treiber>) org.h2.Driver.Klasse);
dataSource.setUsername( “ihr” );
dataSource.setUrl( “jdbc:h2:Mem” );
dataSource.setPassword( “” );
JdbcTemplate JdbcTemplate = neue JdbcTemplate(Datenquelle);
System.heraus.println( “Erstellen von Tabellen” );
jdbcTemplate.execute( “Tabelle Mitarbeiter fallen, wenn vorhanden” );
jdbcTemplate.execute( “create table Mitarbeiter(”
+ “id varchar(25), first_name varchar(255), middle_name varchar(255), last_name varchar(255), deptId varchar(25))”);
Schnur[] Aufzeichnungen = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirk D66;”.Teilt(“;”);
für ( String singleRecord : Aufzeichnungen ) {
Schnur [] cols = singleRecord.split(” “);
System.heraus.printf( ” Hinzufügen von Mitarbeiterdatensatz für% s% s% s% s% s n”,cols[0], cols[1], cols[2], cols[3], cols[4]);
jdbcTemplate.update(“INSERT INTO Mitarbeiter(Ich würde, Vorname, zweiter Vorname, Familienname, Nachname, deptId) Werte(?,?,?,?,?)”,cols[0], cols[1], cols[2], cols[3], cols[4]);
}
System.heraus.println ( ” Querying for customer records where first_name = ‘Erin’:” );
Liste<Employee> Ergebnisse = jdbcTemplate.query(
“select * von Mitarbeitern, wo first_name = ?”,
neue Objekt[] { “Erin” }, neue RowMapper<Employee>() {
@ Override
Öffentlichkeit Mitarbeiter mapRow(ResultSet rs, int rowNum)
wirft SQLException {
return neue Employee(rs.getString(“Ich würde”),
rs.getString(“Vorname”), rs.getString(“zweiter Vorname”),
rs.getString(“Familienname, Nachname”), rs.getString(“deptId”));
}
});
für (Mitarbeiter Mitarbeiter : Ergebnisse) {
System.heraus.println(Mitarbeiter);
}
}
}
[/Code]
In dem obigen Beispiel, wir setzen eine JDBC-Datenquelle mit dem SimpleDriverDataSource von Frühjahr bis. Wir haben dann diese Datenquelle verwenden, um die JDBCTemplate Instanz zu konstruieren. Sobald die JDBCTemplate Klasse erstellt, wir können ganz einfach starten Sie die Datenbank aufrufen. First, Wir schaffen die Tabelle, die die Methode execute der Vorlage. Dann fügen wir einige Datensätze, die die Update-Methode der Vorlage. Endlich haben wir die Abfrage-Methode verwenden, um die Datensätze unserer Wahl zu holen. In unserem Beispiel haben wir eine einfache Abfrage zu holen den Datensatz aus der Mitarbeitertabelle verwendet. Aber nach unserer Design sehen wir, dass die Mitarbeitertabelle eine Beziehung mit der Abteilungstabelle über die Spalte - deptId. So können wir auch den gleichen Code verwenden, um Datensätze zu holen diese beiden Tabellen Beitritt. Nur müssen wir die Abfrage zu ändern eine Verknüpfung zu setzen. Der obige Code könnte wie unter geändert werden -
Listing4: Beispiel zeigt die geänderte Abfrage
[Code]
Liste<Employee> Ergebnisse = jdbcTemplate.query(
“select emp.first_name, emp.middle _name, emp.last _name, dept.dept_Name von Mitarbeitern emp, abteilung, wo emp.first_name = ?”,
neue Objekt[] { “Erin” }, neue RowMapper<Employee>() {
@ Override
Öffentlichkeit EmployeeDtls mapRow(ResultSet rs, int rowNum)
wirft SQLException {
return neue Employee( rs.getString(“Vorname”),
rs.getString(“zweiter Vorname”),
rs.getString(“Familienname, Nachname”),
rs.getString(“dept_name “));
}
});
für (EmployeeDtls employeeDtl : Ergebnisse) {
System.heraus.println(employeeDtl);
}
[/Code]
Zur Ausführung dieses sollten wir einen anderen POJO Klasse EmployeeDtls wie unter haben -
Listing5: Probe mit der POJO Klasse EmployeeDtls
[Code]
package com.home.springjdbc.objects;
Öffentlichkeit Klasse EmployeeDtls {
// Der Mitarbeiter erste Namens
Private String empFName;
// Der Mitarbeiter zweiter Vorname
Private String empMName;
// Der Mitarbeiter Nachname
Private String empLName;
// Die Abteilung Name
Private String DEPTNAME;
/**
* @param empFName
* @param empMName
* @param empLName
* @param DEPTNAME
*/
Öffentlichkeit EmployeeDtls(String empFName, String empMName, String empLName,
String DEPTNAME) {
Super();
Dies.empFName = empFName;
Dies.empMName = empMName;
Dies.empLName = empLName;
Dies.DEPTNAME = DEPTNAME;
}
/*
* (nicht-Javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
Öffentlichkeit String toString() {
return “EmployeeDtls [empFName=” + empFName + “, empMName =” + empMName
+ “, empLName =” + empLName + “, DEPTNAME =” + DEPTNAME + “]”;
}
/**
* @Rückkehr die empFName
*/
Öffentlichkeit String getEmpFName() {
return empFName;
}
/**
* @param empFName
* die empFName einstellen
*/
Öffentlichkeit ungültig setEmpFName(String empFName) {
Dies.empFName = empFName;
}
/**
* @Rückkehr die empMName
*/
Öffentlichkeit String getEmpMName() {
return empMName;
}
/**
* @param empMName
* die empMName einstellen
*/
Öffentlichkeit ungültig setEmpMName(String empMName) {
Dies.empMName = empMName;
}
/**
* @Rückkehr die empLName
*/
Öffentlichkeit String getEmpLName() {
return empLName;
}
/**
* @param empLName
* die empLName einstellen
*/
Öffentlichkeit ungültig setEmpLName(String empLName) {
Dies.empLName = empLName;
}
/**
* @Rückkehr die DEPTNAME
*/
Öffentlichkeit String getDeptName() {
return DEPTNAME;
}
/**
* @param DEPTNAME
* die DEPTNAME einstellen
*/
Öffentlichkeit ungültig setDeptName(String DEPTNAME) {
Dies.DEPTNAME = DEPTNAME;
}
}
[/Code]
Summary: So in diesem Artikel haben wir gesehen, wie Frühling JDBC Vorlage kann in Java-basierte Standard und Enterprise-Anwendungen verwendet werden,. Wir haben diskutiert auch die Vorteile dieses Ansatzes und wie sie die Entwicklung viel schneller auf den Standard-JDBC-basierte Entwicklung im Vergleich machen.
Lassen Sie uns von folgenden Aufzählungspunkte unserer Diskussion in der Form zusammenfassen -
- Der Frühling ist ein wesentlicher Bestandteil der modernen Java-basierten Enterprise-Anwendungsentwicklungsumgebung werden.
- Frühling hat verschiedene Abschnitte, aus welchen, die JDBC-Vorlage ist ein wichtiger Teil.
- Frühlings-JDBC-Vorlage erleichtert die Entwicklung von der Last der Ressourcenerfassung nehmen, Verbindungsmanagement, Ausnahmebehandlung, und allgemeine Fehlerprüfung. Wir als Entwickler brauchen nur auf dem komplexen Business-Szenario zu konzentrieren.
