Proljeće JDBC predložak
Pregled: Kao što svi znamo da je proljeće okvir postao bitan dio modernog Java temeljen aplikacija razvoj. Proljeće okvir učinkovito je uspio preuzeti kontrolu nad svakom odjelu u Java razvoj svijeta. JDBC predložak proljeća se koristi u većini proljeće temelje Jee aplikacija za komunikaciju s bazom podataka.
U ovom članku ću govoriti o tome kako pristupiti relacijske baze podataka pomoću JDBC predložak proljeća.
Uvođenje: Svi znamo važnost relacijske baze u razvoju poslovnih aplikacija. Proljeće je jedan od široko korištenih okvira u Java temeljen razvoj poslovnih aplikacija. Spring ima različite module kao ORM, sigurnosti, transakcija, JPS, JMS itd podržati potrebu razvoja poslovnih aplikacija. Kao proljeće osigurava lako dostupne komponente za plug-in, Suvremeni pristup razvoju poduzeća Java aplikacija koristi značajke opsežno. Kao rezultat razvoja je puno brže i učinkovitije. Spring omogućuje jednostavan pristup za obradu baza podataka aktivnosti znaju kao proljetni JDBC predloška.
Nedostaci standardnih JDBC API-ja: Standardna JDBC API ima sljedeće nedostatke.
- Osim izvođenja glavni upit, trebate napisati puno koda za rukovanje pitanja Execution Environment kao što su stvaranje veze, izjava, ResultSet itd.
- Trebate se nositi iznimka kod rukovanja odvojeno.
- Trebate nositi transakcijske pitanja.
Prednosti proljeće JDBC predloška: Proljeće JDBC predložak ima slijedeće prednosti u odnosu na normalan pristup standardne JDBC.
- Čišćenje korištenih sredstava obavlja se automatski proljeće JDBC predloška. Dakle, programeri ne moraju gnjaviti o objavljivanju resurse. Stoga se sprečava curenje memorije.
- Proljeće JDBC predložak ručke iznimku i pogreške na učinkovitiji način. Ona pretvara JDBC SQLExceptions u RuntimeExceptions, tako da programeri mogu to podnijeti na fleksibilniji način.
- Opruga JDBC predložak također pretvara određene pogreške dobavljača u boljem smislenu poruku. Dakle, rukovanja tih pogrešaka su učinkovitije.
Početak:
In this document, neka je koristiti gradle kao graditi alat za izgradnju naše aplikacije. Počnimo s jednostavnim aplikacija koja se koristi za dohvaćanje poruka detalje zaposlenih zajedno sa svojim odjelima organizacije. U našem primjeru, ćemo imati sljedeće atribute objekta zaposlenika:-
- ID zaposlenika
- Radnik Ime
- Ime zaposlenika Srednji
- Zaposlenik prezime
- Id Odjel zaposlenika
I Odjel objekt ima sljedeće atribute:-
- Id Odjel
- Naziv Odjel
Sada će nam stvoriti Java objekte koji će se koristiti za komunikaciju s bazom podataka. Naši POJO klase za ova dva entiteta su navedeni kao pod:
Listing1: Uzorak pokazuje klasa zaposlenika
[Code]
package com.home.springjdbc.objects;
javni razred Employee {
// Zaposlenik ID
privatan string empId;
// Radnik Ime
privatan string empFName;
// Srednji ime zaposlenika
privatan string empMName;
// Posljednji ime zaposlenika
privatan string empLName;
// Odjel zaposlenik Id
privatan string empDeptId;
javni Employee ( string empId, string empFName, string empMName,
string empLName, string empDeptId ) {
super();
ovo.EmpID = EmpID;
ovo.Rec Rec name = Naziv;
ovo.empMName = empMName;
ovo.empLName = empLName;
ovo.empDeptId = empDeptId;
}
/**
* @povratak empId
*/
javni niz getEmpId () {
return EmpID;
}
/**
* param EmpID
* empId za postavljanje
*/
javni poništiti setEmpId ( string empId ) {
ovo.EmpID = EmpID;
}
/**
* @povratak empFName
*/
javni niz getEmpFName () {
return Rec ime;
}
/**
* param Rec ime
* empFName za postavljanje
*/
javni poništiti setEmpFName ( string empFName ) {
ovo.Rec Rec name = Naziv;
}
/**
* @povratak empMName
*/
javni niz getEmpMName () {
return empMName;
}
/**
* param empMName
* empMName za postavljanje
*/
javni poništiti setEmpMName ( string empMName) {
ovo.empMName = empMName;
}
/**
* @povratak empLName
*/
javni niz getEmpLName () {
return empLName;
}
/**
* param empLName
* empLName za postavljanje
*/
javni poništiti setEmpLName ( string empLName) {
ovo.empLName = empLName;
}
/**
* @povratak empDeptId
*/
javni niz getEmpDeptId () {
return empDeptId;
}
/**
* param empDeptId
* empDeptId za postavljanje
*/
javni poništiti setEmpDeptId ( string empDeptId ) {
ovo.empDeptId = empDeptId;
}
/*
* ( ne-Javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Override
javni string toString () {
return “Employee [ EmpID =” + EmpID + “, Rec name =” + Rec ime
+ “, empMName =” + empMName + “, empLName =” + empLName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Uzorak pokazuje Odjela klasa
[Code]
package com.home.springjdbc.objects;
javni razred odjel {
// Odjel Id
privatan string deptId;
// Odjel ime
privatan string deptName;
javni odjel ( string deptId, string deptName) {
super ();
ovo.deptId = deptId;
ovo.deptName = deptName;
}
/**
* @povratak deptId
*/
javni string getDeptId () {
return deptId;
}
/**
* param deptId
* deptId za postavljanje
*/
javni poništiti setDeptId ( string deptId ) {
ovo.deptId = deptId;
}
/**
* @povratak deptName
*/
javni string getDeptName () {
return deptName;
}
/**
* param deptName
* deptName za postavljanje
*/
javni poništiti setDeptName ( string deptName ) {
ovo.deptName = deptName;
}
/*
* (ne-Javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
javni string toString () {
return “odjel [ deptId =” + deptId + “, deptName =” + deptName + “]”;
}
}
[/Code]
Proljeće daje klasu predložak poznat kao JdbcTemplate. Ova klasa je odgovoran za komunikaciju sa SQL relacijskim bazama podataka i JDBC. U tradicionalnom pristupu maksimum od JDBC kod bavi se upravljanjem rukovanje priključak, stjecanje resursa, rukovanje iznimka, i provjera opća pogreška koja je poštovanja u kontekstu onoga što se pokušava postići. JdbcTemplate vodi brigu o svim tim stvarima i kao programer trebao ćemo se usredotočiti samo na poslovne logike. Implementacija Uzorak klase predloška je prikazan kao pod -
Listing3: Uzorak pokazuje provedbu JDBC predloška
[Code]
package com.home.springjdbc.dao;
uvoz java.sql.Driver;
uvoz java.sql.ResultSet;
uvoz java.sql.SQLException;
uvoz java.util.List;
uvoz org.springframework.jdbc.core.JdbcTemplate;
uvoz org.springframework.jdbc.core.RowMapper;
uvoz org.springframework.jdbc.datasource.SimpleDriverDataSource;
uvoz com.home.springjdbc.objects.Employee;
javni razred EmployeeDAO {
javni statički poništiti glavni ( string args[] ) {
// jednostavni DS za ispitivanje (ne za proizvodnju!)
SimpleDriverDataSource izvoru podataka = novi SimpleDriverDataSource();
dataSource.setDriverClass((Klasa<? proteže Vozač>) org.h2.Driver.razred);
dataSource.setUsername( “nju” );
dataSource.setUrl( “JDBC:H2:Mem” );
dataSource.setPassword( “” );
JdbcTemplate JdbcTemplate = novi JdbcTemplate(izvor podataka);
Sistem.van.println( “Stvaranje tablice” );
jdbcTemplate.execute( “drop zaposlenika stol, ako postoji” );
jdbcTemplate.execute( “stvoriti zaposlenika stol(”
+ “id varchar(25), first_name varchar(255), middle_name varchar(255), LAST_NAME varchar(255), deptId varchar(25))”);
Gudački[] zapisi = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland D66;”.Split(“;”);
za ( string singleRecord : snimke ) {
Gudački [] stupaca = singleRecord.split(” “);
Sistem.van.printf( ” Dodavanje zapisa zaposlenika za% s% s% s% s% s n”,Stupci[0], Stupci[1], Stupci[2], Stupci[3], Stupci[4]);
jdbcTemplate.update(“Zaposlenici umetnuti u(iskaznica, ime, srednje ime, prezime, deptId) vrijednosti(?,?,?,?,?)”,Stupci[0], Stupci[1], Stupci[2], Stupci[3], Stupci[4]);
}
Sistem.van.println ( ” Querying for customer records where first_name = ‘Erin’:” );
Popis<Employee> Rezultat = jdbcTemplate.query(
“select * od zaposlenika gdje first_name = ?”,
novi Objekt[] { “irska” }, novi RowMapper<Employee>() {
@ Override
javni mapRow zaposlenika(ResultSet rs, int ROWNUM)
baca SQLException {
return novi Employee(rs.getString(“iskaznica”),
rs.getString(“ime”), rs.getString(“srednje ime”),
rs.getString(“prezime”), rs.getString(“deptId”));
}
});
za (zaposlenik : rezultati) {
Sistem.van.println(zaposlenik);
}
}
}
[/Code]
U gornjem primjeru, smo postavili JDBC izvora podataka pomoću SimpleDriverDataSource od proljeća. Mi smo tada koristiti ovaj izvor podataka za izgradnju JDBCTemplate instancu. Nakon što je JDBCTemplate razred je stvoren, lako možemo početi zvati baze podataka. First, smo stvorili tablicu pomoću izvrši metodu predloška. Onda smo umetnuli nekoliko zapise pomoću metode ažuriranja predloška. Na kraju ćemo koristiti metodu upita dohvatiti podatke o našem izboru. U našem primjeru smo koristili jednostavan upit da donese zapisnik sa stola zaposlenika. No, kao i po našem dizajnu vidimo da je stol zaposlenik ima odnos sa stola odjel preko kolone - deptId. Dakle, mi također možemo koristiti isti kod dohvatiti zapise spajanja ove dvije tablice. Samo trebamo promijeniti upit staviti pridružite. Gore kod može se modificirati u okviru -
Listing4: Uzorak prikazuje modificiranu upit
[Code]
Popis<Employee> Rezultat = jdbcTemplate.query(
“odaberite emp.first_name, emp.middle _name, emp.last _name, dept.dept_Name od zaposlenika EMP, Odjel odjelu gdje emp.first_name = ?”,
novi Objekt[] { “irska” }, novi RowMapper<Employee>() {
@ Override
javni EmployeeDtls mapRow(ResultSet rs, int ROWNUM)
baca SQLException {
return novi Employee( rs.getString(“ime”),
rs.getString(“srednje ime”),
rs.getString(“prezime”),
rs.getString(“dept_Name “));
}
});
za (EmployeeDtls employeeDtl : rezultati) {
Sistem.van.println(employeeDtl);
}
[/Code]
Za provođenje ovog trebamo imati još POJO klase EmployeeDtls kao pod -
Listing5: Uzorak pokazuje POJO klase EmployeeDtls
[Code]
package com.home.springjdbc.objects;
javni razred EmployeeDtls {
// Radnik Ime
privatan string empFName;
// Srednji ime zaposlenika
privatan string empMName;
// Posljednji ime zaposlenika
privatan string empLName;
// Odjel ime
privatan string deptName;
/**
* param Rec ime
* param empMName
* param empLName
* param deptName
*/
javni EmployeeDtls(string empFName, string empMName, string empLName,
string deptName) {
super();
ovo.Rec Rec name = Naziv;
ovo.empMName = empMName;
ovo.empLName = empLName;
ovo.deptName = deptName;
}
/*
* (ne-Javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
javni string toString() {
return “EmployeeDtls [Rec name =” + Rec ime + “, empMName =” + empMName
+ “, empLName =” + empLName + “, deptName =” + deptName + “]”;
}
/**
* @povratak empFName
*/
javni niz getEmpFName() {
return Rec ime;
}
/**
* param Rec ime
* empFName za postavljanje
*/
javni poništiti setEmpFName(string empFName) {
ovo.Rec Rec name = Naziv;
}
/**
* @povratak empMName
*/
javni niz getEmpMName() {
return empMName;
}
/**
* param empMName
* empMName za postavljanje
*/
javni poništiti setEmpMName(string empMName) {
ovo.empMName = empMName;
}
/**
* @povratak empLName
*/
javni niz getEmpLName() {
return empLName;
}
/**
* param empLName
* empLName za postavljanje
*/
javni poništiti setEmpLName(string empLName) {
ovo.empLName = empLName;
}
/**
* @povratak deptName
*/
javni string getDeptName() {
return deptName;
}
/**
* param deptName
* deptName za postavljanje
*/
javni poništiti setDeptName(string deptName) {
ovo.deptName = deptName;
}
}
[/Code]
Summary: Dakle, u ovom članku vidjeli smo kako proljeće JDBC predložak može koristiti u Java Standard i Enterprise aplikacija temelji. Također smo razgovarali o prednosti ovog pristupa i kako se to može učiniti razvoj mnogo brže nego u standardnom JDBC temelji razvoj.
Neka nam rezimirati našu raspravu u obliku slijedi natuknica -
- Proljeće je postao bitan dio moderne Java temeljen razvoj poslovnih aplikacija okoliš.
- Spring ima različite odjeljke, od čega, JDBC predložak je važan dio.
- Proljeće JDBC predložak olakšava razvoj uzimanjem opterećenje stjecanja resursa, upravljanje veze, rukovanje iznimka, i provjera opća pogreška. Mi kao programer samo treba koncentrirati na kompleksnom poslovnom scenariju.
