Spring JDBC template
Overzicht: Zoals we allemaal weten dat de veer kader een essentieel onderdeel van de moderne Java-gebaseerde applicatie-ontwikkeling is geworden. De veer kader is effectief beheerd om de controle van elke afdeling te nemen aan de Java-ontwikkeling wereld. De JDBC model van veer wordt gebruikt in de meeste van de veer gebaseerde JEE applicaties communiceren met de database.
In dit artikel zal ik het hebben over hoe u een relationele database met behulp van de JDBC template van de lente.
Introductie: We kennen allemaal het belang van een relationele database in enterprise applicatie-ontwikkeling. De lente is een van de meest gebruikte kaders op Java gebaseerde enterprise applicatie-ontwikkeling. Spring heeft verschillende modules zoals ORM, veiligheid, transactie, JPS, JMS etc aan de behoefte van de enterprise applicatie-ontwikkeling te ondersteunen. Als de lente biedt direct beschikbaar componenten om plug-in, de moderne aanpak voor enterprise Java-applicatie-ontwikkeling maakt gebruik van de mogelijkheden uitgebreid. Hierdoor is de ontwikkeling veel sneller en efficiënter. Spring biedt een eenvoudige benadering te hanteren databaseactiviteiten kennen als de lente JDBC template.
Nadelen van de standaard JDBC API: Standaard JDBC API heeft de volgende nadelen.
- Naast het uitvoeren van de hoofdquery, je nodig hebt om een veel code te schrijven voor de uitvoering milieukwesties zoals het maken van verbinding te behandelen, verklaring, resultset etc.
- Behoefte om exception handling code apart te behandelen.
- Behoefte om transactionele kwesties aan te pakken.
Voordelen van de lente JDBC template: Spring JDBC template heeft de volgende voordelen ten opzichte van de normale benadering van de standaard JDBC.
- Reiniging van gebruikte middelen gebeurt automatisch door een veer JDBC template. Dus de ontwikkelaars niet hoeft te bekommeren over de middelen vrijgeven. Vandaar dat het voorkomt geheugenlekken.
- Spring JDBC template verzorgt de uitzondering en fouten in een efficiëntere manier. Het zet de JDBC-SQL- uitzonderingen in RuntimeExceptions, zodat de ontwikkelaars kunnen omgaan in meer flexibele manier.
- De veer JDBC template zet ook de leverancier specifieke fouten in een betere zinvolle boodschap. Zodat de handelingen van die fouten efficiënter.
Ermee beginnen:
In this document, laten we gebruik maken gradle als een build tool om onze applicatie te bouwen. Laten we beginnen met een eenvoudige toepassing gebruikt om de gegevens van werknemers opslaan en ophalen met hun diensten van een organisatie. In ons voorbeeld, zullen we de volgende kenmerken van de werknemer tot doel hebben:-
- Werknemer's ID
- Werknemer Voornaam
- Werknemer Middle Name
- Werknemer Achternaam
- Medewerker Afdeling Id
En de afdeling object heeft de volgende kenmerken:-
- afdeling Id
- Afdelingsnaam
Laten we nu de JAVA voorwerpen die worden gebruikt voor communicatie met de database. Onze POJO klassen voor deze twee entiteiten zijn opgenomen, zoals onder:
Listing1: Monster met de Employee Class
[Code]
package com.home.springjdbc.objects;
publiek klasse Employee {
// De werknemer Id
prive- String EmpId;
// De werknemer eerste Naam
prive- String empFName;
// De werknemer middelste naam
prive- String empMName;
// De werknemer laatste Name
prive- String empLName;
// De werknemer afdeling Id
prive- String empDeptId;
publiek Employee ( String EmpId, String empFName, String empMName,
String empLName, String empDeptId ) {
super();
deze.EmpID = EmpID;
deze.Rec Rec name = naam;
deze.empMName = empMName;
deze.empLName = empLName;
deze.empDeptId = empDeptId;
}
/**
* @return de EmpId
*/
publiek String getEmpId () {
return EmpID;
}
/**
* @param EmpID
* de EmpId te stellen
*/
publiek vervallen setEmpId ( String EmpId ) {
deze.EmpID = EmpID;
}
/**
* @return de empFName
*/
publiek String getEmpFName () {
return Rec naam;
}
/**
* @param Rec naam
* de empFName om
*/
publiek vervallen setEmpFName ( String empFName ) {
deze.Rec Rec name = naam;
}
/**
* @return de empMName
*/
publiek String getEmpMName () {
return empMName;
}
/**
* @param empMName
* de empMName om
*/
publiek vervallen setEmpMName ( String empMName) {
deze.empMName = empMName;
}
/**
* @return de empLName
*/
publiek String getEmpLName () {
return empLName;
}
/**
* @param empLName
* de empLName om
*/
publiek vervallen setEmpLName ( String empLName) {
deze.empLName = empLName;
}
/**
* @return de empDeptId
*/
publiek String getEmpDeptId () {
return empDeptId;
}
/**
* @param empDeptId
* de empDeptId om
*/
publiek vervallen setEmpDeptId ( String empDeptId ) {
deze.empDeptId = empDeptId;
}
/*
* ( niet-javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Override
publiek String toString () {
return “Employee [ EmpID =” + EmpID + “, Rec name =” + Rec naam
+ “, empMName =” + empMName + “, empLName =” + empLName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Monster met de afdeling Class
[Code]
package com.home.springjdbc.objects;
publiek klasse afdeling {
// De afdeling Id
prive- String deptId;
// De afdeling Naam
prive- String deptName;
publiek afdeling ( String deptId, String deptName) {
super ();
deze.deptId = deptId;
deze.deptName = deptName;
}
/**
* @return de deptId
*/
publiek String getDeptId () {
return deptId;
}
/**
* @param deptId
* de deptId om
*/
publiek vervallen setDeptId ( String deptId ) {
deze.deptId = deptId;
}
/**
* @return de deptName
*/
publiek String getDeptName () {
return deptName;
}
/**
* @param deptName
* de deptName om
*/
publiek vervallen setDeptName ( String deptName ) {
deze.deptName = deptName;
}
/*
* (niet-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
publiek String toString () {
return “afdeling [ deptId =” + deptId + “, deptName =” + deptName + “]”;
}
}
[/Code]
Spring heeft een template klasse bekend als JdbcTemplate. Deze klasse is verantwoordelijk voor de communicatie met SQL relationele databases en JDBC. In de traditionele benadering het maximum van een JDBC-code is bezet in de afhandeling connection management, overname resource, exception handling, en algemene foutcontrole die oneerbiedig in de context van wat wij proberen te bereiken. De JdbcTemplate verzorgt al deze dingen en als ontwikkelaar moeten we alleen richten op de business logica. Een voorbeeld implementatie van de sjabloonklasse wordt getoond als kader -
Listing3: Monster met de uitvoering van de JDBC template
[Code]
package com.home.springjdbc.dao;
importeren java.sql.Driver;
importeren java.sql.ResultSet;
importeren java.sql.SQLException;
importeren java.util.List;
importeren org.springframework.jdbc.core.JdbcTemplate;
importeren org.springframework.jdbc.core.RowMapper;
importeren org.springframework.jdbc.datasource.SimpleDriverDataSource;
importeren com.home.springjdbc.objects.Employee;
publiek klasse EmployeeDAO {
publiek statisch vervallen hoofd- ( String args[] ) {
// eenvoudige DS voor de test (niet te productie!)
SimpleDriverDataSource dataSource = nieuw SimpleDriverDataSource();
dataSource.setDriverClass((Klasse<? verlengt Bestuurder>) org.h2.Driver.klasse);
dataSource.setUsername( “haar” );
dataSource.setUrl( “jdbc:h2:Mem” );
dataSource.setPassword( “” );
JdbcTemplate JdbcTemplate = nieuw JdbcTemplate(databron);
Systeem.uit.println( “tabellen maken” );
jdbcTemplate.execute( “laten vallen tafel werknemers als deze bestaat” );
jdbcTemplate.execute( “create table werknemers(”
+ “id varchar(25), first_name varchar(255), middle_name varchar(255), last_name varchar(255), deptId varchar(25))”);
Snaar[] registers = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland D66;”.spleet(“;”);
voor ( String singleRecord : archief ) {
Snaar [] cols = singleRecord.split(” “);
Systeem.uit.printf( ” werknemer verslag toe te voegen voor% s% s% s% s% s n”,cols[0], cols[1], cols[2], cols[3], cols[4]);
jdbcTemplate.update(“werknemers INSERT INTO(id, Voornaam, Midden-naam, achternaam, deptId) waarden(?,?,?,?,?)”,cols[0], cols[1], cols[2], cols[3], cols[4]);
}
Systeem.uit.println ( ” Querying for customer records where first_name = ‘Erin’:” );
Lijst<Employee> resulteert = jdbcTemplate.query(
“select * van werknemers waarbij first_name = ?”,
nieuw Voorwerp[] { “Erin” }, nieuw RowMapper<Employee>() {
@ Override
publiek werknemer mapRow(ResultSet rs, int rownum)
worpen SQLException {
return nieuw Employee(rs.getString(“id”),
rs.getString(“Voornaam”), rs.getString(“Midden-naam”),
rs.getString(“achternaam”), rs.getString(“deptId”));
}
});
voor (werknemer werknemer : uitslagen) {
Systeem.uit.println(werknemer);
}
}
}
[/Code]
In het bovenstaande voorbeeld, we het opzetten van een JDBC-gegevensbron met behulp van de SimpleDriverDataSource van de lente. We gebruiken dan is deze gegevensbron om de JdbcTemplate instantie te construeren. Zodra de JdbcTemplate klasse wordt gemaakt, kunnen we eenvoudig beginnen met het aanroepen van de databank. First, We maken de tafel met behulp van de werkwijze uit te voeren van de template. Dan steek we enkele platen met behulp van de methode-update van de template. Tot slot maken we gebruik van de query methode om de verslagen van onze keuze te halen. In ons voorbeeld hebben we een eenvoudige query wordt gebruikt om het record te halen uit de werknemer tafel. Maar volgens ons ontwerp zien we dat de werknemer tafel heeft een relatie met de afdeling tafel via de kolom - deptId. Dus we kunnen ook dezelfde code gebruiken om records te verbinden deze twee tafels te halen. Alleen dat we nodig hebben om de vraag te veranderen om te zetten een join. Bovenstaande code kan worden gemodificeerd onder -
Listing4: Monster met de gewijzigde vraag
[Code]
Lijst<Employee> resulteert = jdbcTemplate.query(
“select emp.first_name, emp.middle _name, emp.last _name, dept.dept_Name van werknemers emp, afd afdeling waarbij emp.first_name = ?”,
nieuw Voorwerp[] { “Erin” }, nieuw RowMapper<Employee>() {
@ Override
publiek EmployeeDtls mapRow(ResultSet rs, int rownum)
worpen SQLException {
return nieuw Employee( rs.getString(“Voornaam”),
rs.getString(“Midden-naam”),
rs.getString(“achternaam”),
rs.getString(“dept_Name “));
}
});
voor (EmployeeDtls employeeDtl : uitslagen) {
Systeem.uit.println(employeeDtl);
}
[/Code]
Om dit uit te voeren we een andere POJO klasse EmployeeDtls zou moeten hebben als onder -
Listing5: Monster met de POJO klasse EmployeeDtls
[Code]
package com.home.springjdbc.objects;
publiek klasse EmployeeDtls {
// De werknemer eerste Naam
prive- String empFName;
// De werknemer middelste naam
prive- String empMName;
// De werknemer laatste Name
prive- String empLName;
// De afdeling Naam
prive- String deptName;
/**
* @param Rec naam
* @param empMName
* @param empLName
* @param deptName
*/
publiek EmployeeDtls(String empFName, String empMName, String empLName,
String deptName) {
super();
deze.Rec Rec name = naam;
deze.empMName = empMName;
deze.empLName = empLName;
deze.deptName = deptName;
}
/*
* (niet-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
publiek String toString() {
return “EmployeeDtls [Rec name =” + Rec naam + “, empMName =” + empMName
+ “, empLName =” + empLName + “, deptName =” + deptName + “]”;
}
/**
* @return de empFName
*/
publiek String getEmpFName() {
return Rec naam;
}
/**
* @param Rec naam
* de empFName om
*/
publiek vervallen setEmpFName(String empFName) {
deze.Rec Rec name = naam;
}
/**
* @return de empMName
*/
publiek String getEmpMName() {
return empMName;
}
/**
* @param empMName
* de empMName om
*/
publiek vervallen setEmpMName(String empMName) {
deze.empMName = empMName;
}
/**
* @return de empLName
*/
publiek String getEmpLName() {
return empLName;
}
/**
* @param empLName
* de empLName om
*/
publiek vervallen setEmpLName(String empLName) {
deze.empLName = empLName;
}
/**
* @return de deptName
*/
publiek String getDeptName() {
return deptName;
}
/**
* @param deptName
* de deptName om
*/
publiek vervallen setDeptName(String deptName) {
deze.deptName = deptName;
}
}
[/Code]
Summary: Dus in dit artikel hebben we gezien hoe de lente JDBC sjabloon kan worden gebruikt in Java gebaseerde standaard en enterprise applicaties. We hebben ook gesproken over de voordelen van deze aanpak en hoe het kan de ontwikkeling veel sneller in vergelijking met de standaard JDBC gebaseerde ontwikkeling.
Laat ons samen te vatten onze discussie in de vorm van volgende bullet points -
- De lente is uitgegroeid tot een essentieel onderdeel van de moderne Java gebaseerde enterprise applicatie-ontwikkelomgeving.
- Spring heeft verschillende secties, waarvan, de JDBC template is een belangrijk onderdeel.
- Spring JDBC sjabloon vergemakkelijkt de ontwikkeling door het nemen van de belasting van resource overname, connection management, exception handling, en algemene foutcontrole. Wij als een ontwikkelaar hoeft alleen maar te concentreren op de complexe zakelijke scenario.
