Lente JDBC sjabloon
Oorsig: Soos ons almal weet dat die lente raamwerk 'n noodsaaklike deel van die moderne Java-gebaseerde program ontwikkeling geword het. Die lente raamwerk doeltreffend daarin geslaag om beheer van elke departement in die Java ontwikkeling wêreld. Die JDBC sjabloon van die lente is in die meeste van die lente gebaseer JEE aansoeke om te kommunikeer met die databasis.
In hierdie artikel sal ek praat oor hoe om toegang te verkry tot 'n relasionele databasis met behulp van die JDBC sjabloon van die lente.
Inleiding: Ons weet almal hoe belangrik dit relasionele databasis in 'n onderneming aansoek ontwikkeling. Lente is een van die mees gebruikte raamwerke in Java gebaseer onderneming aansoek ontwikkeling. Lente het verskillende modules soos ORM, sekuriteit, transaksie, JPS, JMS ens om die behoefte van die onderneming aansoek ontwikkeling te ondersteun. As die lente bied geredelik beskikbaar komponente te prop-in, die moderne benadering vir die onderneming se Java program ontwikkeling gebruik die eienskappe breedvoerig. As gevolg van die ontwikkeling is baie vinniger en doeltreffende. Lente bied 'n eenvoudige benadering te hanteer databasis aktiwiteite bekend as die lente JDBC sjabloon.
Nadele van standaard JDBC API: Standard JDBC API het die volgende nadele.
- Afgesien van die uitvoering van die belangrikste navraag, wat jy nodig het om 'n baie van die kode te skryf om die uitvoering omgewing kwessies soos die skep verband hanteer, verklaring, resultset ens.
- Nodig het om uitsonderings te hanteer kode afsonderlik hanteer.
- Nodig het om transaksionele kwessies te hanteer.
Voordele van die lente JDBC sjabloon: Lente JDBC sjabloon het die volgende voordele in vergelyking met die normale benadering van standaard JDBC.
- Skoonmaak van gebruik hulpbronne word outomaties gedoen deur die lente JDBC sjabloon. So het die ontwikkelaars hoef nie te pla oor die hulpbronne vry. Daarom is dit verhoed geheue lekkasies.
- Lente JDBC sjabloon hanteer die uitsondering en foute in 'n meer doeltreffende manier. Dit vat die JDBC SQLExceptions in RuntimeExceptions, sodat die ontwikkelaars kan dit hanteer in meer buigsame manier.
- Die lente JDBC sjabloon vat ook die verkoper spesifieke foute in 'n beter betekenisvolle boodskap. So het die hanterings van die foute is meer doeltreffend.
Aan die gang kom:
In this document, Kom ons gebruik gradle as 'n bou hulpmiddel om ons aansoek te bou. Kom ons begin met 'n eenvoudige program wat gebruik word om die besonderhede van werknemers te stoor en te herwin saam met hul departemente van 'n organisasie. In ons voorbeeld, Ons sal die volgende eienskappe van die werknemer voorwerp het:-
- werknemer ID
- Werknemer Voornaam
- Werknemer Midde Naam
- Werknemer Laaste Naam
- Werknemer Departement id
En die departement voorwerp het die volgende kenmerke:-
- Departement id
- Departement Naam
Kom ons skep die Java voorwerpe wat gebruik sal word om te kommunikeer met die databasis. Ons POJO klasse vir hierdie twee entiteite is gelys as onder:
Listing1: Monster wat die Werknemer Klas
[Code]
package com.home.springjdbc.objects;
openbare klas werknemer {
// Die werknemer ID
private string empId;
// Die werknemer voornaam
private string empFName;
// Die werknemer middel naam
private string empMName;
// Die werknemer laaste naam
private string empLName;
// Die werknemer departement id
private string empDeptId;
openbare werknemer ( string empId, string empFName, string empMName,
string empLName, string empDeptId ) {
super();
this.EmpID = EmpID;
this.Rec Rec name = Naam;
this.empMName = empMName;
this.empLName = empLName;
this.empDeptId = empDeptId;
}
/**
* @return die empId
*/
openbare string getEmpId () {
return EmpID;
}
/**
* param EmpID
* die empId te stel
*/
openbare nietig setEmpId ( string empId ) {
this.EmpID = EmpID;
}
/**
* @return die empFName
*/
openbare string getEmpFName () {
return rec naam;
}
/**
* param rec naam
* die empFName te stel
*/
openbare nietig setEmpFName ( string empFName ) {
this.Rec Rec name = Naam;
}
/**
* @return die empMName
*/
openbare string getEmpMName () {
return empMName;
}
/**
* param empMName
* die empMName te stel
*/
openbare nietig setEmpMName ( string empMName) {
this.empMName = empMName;
}
/**
* @return die empLName
*/
openbare string getEmpLName () {
return empLName;
}
/**
* param empLName
* die empLName te stel
*/
openbare nietig setEmpLName ( string empLName) {
this.empLName = empLName;
}
/**
* @return die empDeptId
*/
openbare string getEmpDeptId () {
return empDeptId;
}
/**
* param empDeptId
* die empDeptId te stel
*/
openbare nietig setEmpDeptId ( string empDeptId ) {
this.empDeptId = empDeptId;
}
/*
* ( nie-javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Ignoreer
openbare string toString () {
return “werknemer [ EmpID =” + EmpID + “, Rec name =” + rec naam
+ “, empMName =” + empMName + “, empLName =” + empLName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Monster wat die Departement Klas
[Code]
package com.home.springjdbc.objects;
openbare klas Departement {
// Die departement id
private string deptId;
// Die departement Naam
private string deptName;
openbare Departement ( string deptId, string deptName) {
super ();
this.deptId = deptId;
this.deptName = deptName;
}
/**
* @return die deptId
*/
openbare string getDeptId () {
return deptId;
}
/**
* param deptId
* die deptId te stel
*/
openbare nietig setDeptId ( string deptId ) {
this.deptId = deptId;
}
/**
* @return die deptName
*/
openbare string getDeptName () {
return deptName;
}
/**
* param deptName
* die deptName te stel
*/
openbare nietig setDeptName ( string deptName ) {
this.deptName = deptName;
}
/*
* (nie-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Ignoreer
openbare string toString () {
return “Departement [ deptId =” + deptId + “, deptName =” + deptName + “]”;
}
}
[/Code]
Lente bied 'n sjabloon klas bekend as JdbcTemplate. Hierdie klas is verantwoordelik vir kommunikasie met SQL relasionele databasisse en JDBC. In die tradisionele benadering die maksimum van 'n JDBC-kode beset in die hantering verband bestuur, verkryging van hulpbronne, hantering van uitsonderings, en algemene foutopsporing wat oneerbiedig in die konteks van wat ons probeer om te bereik. Die JdbcTemplate sorg vir al hierdie dinge en as 'n ontwikkelaar moet daar slegs gefokus op die besigheid logika. 'N Monster implementering van die sjabloon klas gewys as onder -
Listing3: Monster wat die implementering van JDBC sjabloon
[Code]
package com.home.springjdbc.dao;
voer java.sql.Driver;
voer java.sql.ResultSet;
voer java.sql.SQLException;
voer java.util.List;
voer org.springframework.jdbc.core.JdbcTemplate;
voer org.springframework.jdbc.core.RowMapper;
voer org.springframework.jdbc.datasource.SimpleDriverDataSource;
voer com.home.springjdbc.objects.Employee;
openbare klas EmployeeDAO {
openbare statiese nietig hoof ( string args[] ) {
// eenvoudige DS vir toets (nie vir produksie!)
SimpleDriverDataSource data bron = nuwe SimpleDriverDataSource();
dataSource.setDriverClass((Class<? strek bestuurder>) org.h2.Driver.klas);
dataSource.setUsername( “haar” );
dataSource.setUrl( “JDBC:h2:Mem” );
dataSource.setPassword( “” );
JdbcTemplate JdbcTemplate = nuwe JdbcTemplate(data bron);
Stelsel.uit.println( “Die skep van tabelle” );
jdbcTemplate.execute( “drop tafel werknemers as bestaan” );
jdbcTemplate.execute( “skep tafel werknemers(”
+ “ID varchar(25), first_name varchar(255), middle_name varchar(255), LAST_NAME varchar(255), deptId varchar(25))”);
String[] rekords = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland D66;”.verdeel(“;”);
vir ( string singleRecord : rekords ) {
String [] cols = singleRecord.split(” “);
Stelsel.uit.printf( ” werknemer rekord toevoeging van vir% s% s% s% s% s n”,cols[0], cols[1], cols[2], cols[3], cols[4]);
jdbcTemplate.update(“werknemers te voeg in(id, eerste naam, middelnaam, van, deptId) waardes(?,?,?,?,?)”,cols[0], cols[1], cols[2], cols[3], cols[4]);
}
Stelsel.uit.println ( ” Querying for customer records where first_name = ‘Erin’:” );
lys<werknemer> gevolg = jdbcTemplate.query(
“select * van werknemers waar first_name = ?”,
nuwe voorwerp[] { “Erin” }, nuwe RowMapper<werknemer>() {
@ Ignoreer
openbare werknemer mapRow(ResultSet rs, int ROWNUM)
gooi SQLException {
return nuwe werknemer(rs.getString(“id”),
rs.getString(“eerste naam”), rs.getString(“middelnaam”),
rs.getString(“van”), rs.getString(“deptId”));
}
});
vir (werknemer werknemer : resultate) {
Stelsel.uit.println(werknemer);
}
}
}
[/Code]
In die bogenoemde voorbeeld, ons 'n JDBC databron gebruik van die SimpleDriverDataSource van die lente. Ons gebruik dan hierdie data bron om die JDBCTemplate byvoorbeeld bou. Sodra die JDBCTemplate klas geskep word, kan ons maklik begin bel die databasis. First, Ons skep die tafel met behulp van die metode uit te voer van die sjabloon. Dan voeg ons n paar rekords met behulp van die metode werk van die sjabloon. Laastens gebruik ons die navraag metode om die rekords van ons keuse te gaan haal. In ons voorbeeld het ons 'n eenvoudige navraag gebruik word om die rekord gaan haal uit die werknemer tafel. Maar soos per ons ontwerp sien ons dat die werknemer tafel het 'n verhouding met die departement tafel via die kolom - deptId. So kan ons ook dieselfde kode gebruik om rekords by hierdie twee tafels haal. Net wat ons nodig het om die navraag te verander om te sit 'n deel. Bogenoemde kode kan verander word as onder -
Listing4: Monster wat die gewysigde navraag
[Code]
lys<werknemer> gevolg = jdbcTemplate.query(
“Kies emp.first_name, emp.middle _name, emp.last _name, dept.dept_Name van werknemers OBP, departement dept waar emp.first_name = ?”,
nuwe voorwerp[] { “Erin” }, nuwe RowMapper<werknemer>() {
@ Ignoreer
openbare EmployeeDtls mapRow(ResultSet rs, int ROWNUM)
gooi SQLException {
return nuwe werknemer( rs.getString(“eerste naam”),
rs.getString(“middelnaam”),
rs.getString(“van”),
rs.getString(“dept_Name “));
}
});
vir (EmployeeDtls employeeDtl : resultate) {
Stelsel.uit.println(employeeDtl);
}
[/Code]
Om dit te kan uitvoer ons 'n ander POJO klas EmployeeDtls moet hê as onder -
Listing5: Monster wat die POJO klas EmployeeDtls
[Code]
package com.home.springjdbc.objects;
openbare klas EmployeeDtls {
// Die werknemer voornaam
private string empFName;
// Die werknemer middel naam
private string empMName;
// Die werknemer laaste naam
private string empLName;
// Die departement Naam
private string deptName;
/**
* param rec naam
* param empMName
* param empLName
* param deptName
*/
openbare EmployeeDtls(string empFName, string empMName, string empLName,
string deptName) {
super();
this.Rec Rec name = Naam;
this.empMName = empMName;
this.empLName = empLName;
this.deptName = deptName;
}
/*
* (nie-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Ignoreer
openbare string toString() {
return “EmployeeDtls [Rec name =” + rec naam + “, empMName =” + empMName
+ “, empLName =” + empLName + “, deptName =” + deptName + “]”;
}
/**
* @return die empFName
*/
openbare string getEmpFName() {
return rec naam;
}
/**
* param rec naam
* die empFName te stel
*/
openbare nietig setEmpFName(string empFName) {
this.Rec Rec name = Naam;
}
/**
* @return die empMName
*/
openbare string getEmpMName() {
return empMName;
}
/**
* param empMName
* die empMName te stel
*/
openbare nietig setEmpMName(string empMName) {
this.empMName = empMName;
}
/**
* @return die empLName
*/
openbare string getEmpLName() {
return empLName;
}
/**
* param empLName
* die empLName te stel
*/
openbare nietig setEmpLName(string empLName) {
this.empLName = empLName;
}
/**
* @return die deptName
*/
openbare string getDeptName() {
return deptName;
}
/**
* param deptName
* die deptName te stel
*/
openbare nietig setDeptName(string deptName) {
this.deptName = deptName;
}
}
[/Code]
Summary: So in hierdie artikel het ons gesien hoe die lente JDBC sjabloon kan gebruik word in Java gebaseer standaard en korporatiewe toepassings. Ons het ook gepraat oor die voordele van hierdie benadering en hoe dit kan maak die ontwikkeling baie vinniger in vergelyking met die standaard JDBC-gebaseerde ontwikkeling.
Kom ons som ons bespreking in die vorm van volgende koeël punte -
- Lente het 'n noodsaaklike deel van die moderne Java gebaseer onderneming aansoek ontwikkeling omgewing.
- Lente het verskillende afdelings, waaruit, die JDBC sjabloon is 'n belangrike deel.
- Lente JDBC sjabloon vergemaklik die ontwikkeling deur die neem van die las van hulpbron verkryging, verband bestuur, hantering van uitsonderings, en algemene fout nagaan. Ons as 'n ontwikkelaar moet net konsentreer op die komplekse besigheid scenario.
