Spring JDBC šablona
Přehled: Jak všichni víme, že rámec na jaře se stal neodmyslitelnou součástí moderního vývoje aplikací Java. Rámec jaro skutečně podařilo převzít kontrolu nad každé oddělení ve vývojovém světě Java. JDBC šablona pružiny se používá ve většině pružiny aplikací JEE založené na komunikaci s databází.
V tomto článku se budu mluvit o tom, jak získat přístup k relační databáze pomocí šablony JDBC jara.
Úvod: Všichni víme, že je důležité, relační databáze v oblasti vývoje podnikových aplikací. Jaro je jedním z nejpoužívanějších rámců Java vývoj podnikových aplikací. Jaro má různé moduly, jako ORM, bezpečnostní, transakce, JPS, JMS atd podporovat potřebu vývoje podnikových aplikací. Jako pramen poskytuje snadno dostupné komponenty plug-in, Moderní přístup k rozvoji podnikové aplikace Java využívá funkce značně. Výsledkem je, že vývoj je mnohem rychlejší a účinnější. Pružina poskytuje jednoduchý přístup k zvládnout činnosti v oblasti databází známe jako jarní JDBC šablonu.
Nevýhody standardní JDBC API: Standardní JDBC API má následující nevýhody.
- Na rozdíl od provedení hlavního dotazu, musíte napsat spoustu kódu zvládnout problémy Execution Environment, jako je vytvoření připojení, prohlášení, resultset etc.
- Muset zvládnout zpracování výjimek kód samostatně.
- Muset zvládnout transakčních problémy.
Výhody pružiny JDBC šablony: Spring JDBC šablona má následující výhody ve srovnání s běžným přístupem standardních JDBC.
- Čištění použitých prostředků se provádí automaticky pružiny JDBC šablonou. Takže vývojáři nemusí starat o uvolnění prostředků. Z tohoto důvodu brání úniky paměti.
- Spring JDBC šablona zpracovává výjimku a chyby v efektivnějším způsobem. Převádí JDBC SQLExceptions do RuntimeExceptions, takže vývojáři mohou s ní zacházet v pružněji.
- Šablona na jaře JDBC také převádí na konkrétní chyby dodavatele v lepší smysluplnou zprávu. Takže Manipulační těchto chyb jsou účinnější.
Začínáme:
In this document, pojďme použít gradle jako stavět nástrojem k budování naší aplikace. Začněme s jednoduchou aplikací slouží k ukládání a načítání podrobnosti o zaměstnance spolu s jejich odděleními organizace. V našem příkladu, budeme mít následující atributy objektu zaměstnanců:-
- Id zaměstnanec
- Zaměstnanec Jméno
- Zaměstnanec Prostřední jméno
- Zaměstnanec Příjmení
- ID oddělení zaměstnanec
A objekt útvar má následující atributy:-
- Id Oddělení
- Jméno Oddělení
Nyní pojďme vytvořit java objekty, které budou použity ke komunikaci s databází. Naše POJO třídy pro tyto dva subjekty jsou uvedeny v:
Listing1: Vzorek ukazuje třídu zaměstnance
[Code]
package com.home.springjdbc.objects;
veřejnost třída Employee {
// Pracovník Id
soukromý řetězec EmpID;
// Pracovník Podle jména
soukromý řetězec empFName;
// Pracovník prostřední jméno
soukromý řetězec empMName;
// Zaměstnanec Příjmení
soukromý řetězec empLName;
// Oddělení zaměstnanec Id
soukromý řetězec empDeptId;
veřejnost Employee ( řetězec EmpID, řetězec empFName, řetězec empMName,
řetězec empLName, řetězec empDeptId ) {
Super();
tento.EmpID = EmpID;
tento.Rec Rec name = název;
tento.empMName = empMName;
tento.empLName = empLName;
tento.empDeptId = empDeptId;
}
/**
* @vrátit se EmpID
*/
veřejnost string getEmpId () {
return EmpID;
}
/**
* @param EmpID
* EmpID nastavení
*/
veřejnost zrušit setEmpId ( řetězec EmpID ) {
tento.EmpID = EmpID;
}
/**
* @vrátit se empFName
*/
veřejnost string getEmpFName () {
return Rec název;
}
/**
* @param Rec název
* empFName nastavení
*/
veřejnost zrušit setEmpFName ( řetězec empFName ) {
tento.Rec Rec name = název;
}
/**
* @vrátit se empMName
*/
veřejnost string getEmpMName () {
return empMName;
}
/**
* @param empMName
* empMName nastavení
*/
veřejnost zrušit setEmpMName ( řetězec empMName) {
tento.empMName = empMName;
}
/**
* @vrátit se empLName
*/
veřejnost string getEmpLName () {
return empLName;
}
/**
* @param empLName
* empLName nastavení
*/
veřejnost zrušit setEmpLName ( řetězec empLName) {
tento.empLName = empLName;
}
/**
* @vrátit se empDeptId
*/
veřejnost string getEmpDeptId () {
return empDeptId;
}
/**
* @param empDeptId
* empDeptId nastavení
*/
veřejnost zrušit setEmpDeptId ( řetězec empDeptId ) {
tento.empDeptId = empDeptId;
}
/*
* ( non-javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Override
veřejnost String toString () {
return “Employee [ EmpID =” + EmpID + “, Rec name =” + Rec název
+ “, empMName =” + empMName + “, empLName =” + empLName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Vzorek ukazuje třídu oddělení
[Code]
package com.home.springjdbc.objects;
veřejnost třída oddělení {
// Oddělení Id
soukromý řetězec deptId;
// Oddělení Name
soukromý řetězec DEPTNAME;
veřejnost oddělení ( řetězec deptId, řetězec DEPTNAME) {
Super ();
tento.deptId = deptId;
tento.DEPTNAME = DEPTNAME;
}
/**
* @vrátit se deptId
*/
veřejnost řetězec getDeptId () {
return deptId;
}
/**
* @param deptId
* deptId nastavení
*/
veřejnost zrušit setDeptId ( řetězec deptId ) {
tento.deptId = deptId;
}
/**
* @vrátit se DEPTNAME
*/
veřejnost řetězec getDeptName () {
return DEPTNAME;
}
/**
* @param DEPTNAME
* DEPTNAME nastavení
*/
veřejnost zrušit setDeptName ( řetězec DEPTNAME ) {
tento.DEPTNAME = DEPTNAME;
}
/*
* (non-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
veřejnost String toString () {
return “oddělení [ deptId =” + deptId + “, DEPTNAME =” + DEPTNAME + “]”;
}
}
[/Code]
Pružina poskytuje třídu šablony známý jako JdbcTemplate. Tato třída je zodpovědná za komunikaci s relační databází SQL a JDBC. V tradičním přístupem maximum z JDBC kód je obsazen v správu připojení manipulačního, získávání zdrojů, zpracování výjimek, a kontrola obecná chyba, která je neuctivý v kontextu toho, co se snažíme dosáhnout. JdbcTemplate se postará o všechny tyto věci a jako developer bychom se měli zaměřit pouze na obchodní logiky. Implementace vzorek šablony třídy je zobrazen jako v -
Listing3: Vzorek ukazující provádění JDBC šablony
[Code]
package com.home.springjdbc.dao;
import java.sql.Driver;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.SimpleDriverDataSource;
import com.home.springjdbc.objects.Employee;
veřejnost třída EmployeeDAO {
veřejnost statický zrušit hlavní ( String args[] ) {
// Jednoduché DS pro zkoušku (ne pro výrobu!)
SimpleDriverDataSource zdroj dat = nový SimpleDriverDataSource();
dataSource.setDriverClass((Třída<? rozšiřuje Řidič>) org.h2.Driver.třída);
dataSource.setUsername( “jí” );
dataSource.setUrl( “JDBC:h2:Mem” );
dataSource.setPassword( “” );
JdbcTemplate JdbcTemplate = nový JdbcTemplate(zdroj dat);
Systém.ven.System.out.println( “vytváření tabulek” );
jdbcTemplate.execute( “klesnout zaměstnance tabulky, pokud existuje” );
jdbcTemplate.execute( “vytvořit tabulku Zaměstnanci(”
+ “id varchar(25), first_name varchar(255), middle_name varchar(255), last_name varchar(255), deptId varchar(25))”);
Řetěz[] záznamy = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland D66;”.rozdělit(“;”);
pro ( řetězec singleRecord : evidence ) {
Řetěz [] cols = singleRecord.split(” “);
Systém.ven.printf( ” Přidání záznam zaměstnance pro% s% s% s% s% s n”,cols[0], cols[1], cols[2], cols[3], cols[4]);
jdbcTemplate.update(“Zaměstnanci vložit do(id, jméno, prostřední jméno, příjmení, deptId) hodnoty(?,?,?,?,?)”,cols[0], cols[1], cols[2], cols[3], cols[4]);
}
Systém.ven.System.out.println ( ” Querying for customer records where first_name = ‘Erin’:” );
Seznam<Employee> Výsledkem = jdbcTemplate.query(
“select * od zaměstnanců kde first_name = ?”,
nový Objekt[] { “Erin” }, nový RowMapper<Employee>() {
@ Override
veřejnost mapRow zaměstnanec(výsledný rs, int rownum)
hází SQLException {
return nový Employee(rs.getString(“id”),
rs.getString(“jméno”), rs.getString(“prostřední jméno”),
rs.getString(“příjmení”), rs.getString(“deptId”));
}
});
pro (zaměstnanec zaměstnanec : výsledky) {
Systém.ven.System.out.println(zaměstnanec);
}
}
}
[/Code]
Ve výše uvedeném příkladu, jsme založili zdroje dat JDBC pomocí SimpleDriverDataSource od jara. My pak použít tento zdroj dat pro konstrukci instance JDBCTemplate. Jakmile je vytvořen třídy JDBCTemplate, můžeme snadno začít volat do databáze. First, jsme se vytvořit tabulku pomocí metody spuštění šablony. Potom vložíme několik záznamů pomocí metody aktualizace šablony. Nakonec jsme se použít metodu dotazu načíst záznamy z našeho výběru. V našem příkladu jsme použili jednoduchý dotaz načíst záznam z tabulky zaměstnanců. Ale podle našeho návrhu vidíme, že tabulka zaměstnanec má vztah s tabulkou oddělení přes kolonu - deptId. Takže můžeme také použít stejný kód k načtení záznamů spojující tyto dvě tabulky. Jen musíme změnit dotaz dát spojit. Výše uvedený kód může být upraven jako v -
Listing4: Vzorek zobrazující modifikovanou dotazu
[Code]
Seznam<Employee> Výsledkem = jdbcTemplate.query(
“select emp.first_name, emp.middle _name, emp.last _name, dept.dept_Name od zaměstnanců zam, Oddělení Odbor kde emp.first_name = ?”,
nový Objekt[] { “Erin” }, nový RowMapper<Employee>() {
@ Override
veřejnost EmployeeDtls mapRow(výsledný rs, int rownum)
hází SQLException {
return nový Employee( rs.getString(“jméno”),
rs.getString(“prostřední jméno”),
rs.getString(“příjmení”),
rs.getString(“dept_Name “));
}
});
pro (EmployeeDtls employeeDtl : výsledky) {
Systém.ven.System.out.println(employeeDtl);
}
[/Code]
Chcete-li to provést bychom měli mít další POJO třídy EmployeeDtls jako v -
Listing5: Vzorek ukazuje POJO tříd EmployeeDtls
[Code]
package com.home.springjdbc.objects;
veřejnost třída EmployeeDtls {
// Pracovník Podle jména
soukromý řetězec empFName;
// Pracovník prostřední jméno
soukromý řetězec empMName;
// Zaměstnanec Příjmení
soukromý řetězec empLName;
// Oddělení Name
soukromý řetězec DEPTNAME;
/**
* @param Rec název
* @param empMName
* @param empLName
* @param DEPTNAME
*/
veřejnost EmployeeDtls(řetězec empFName, řetězec empMName, řetězec empLName,
řetězec DEPTNAME) {
Super();
tento.Rec Rec name = název;
tento.empMName = empMName;
tento.empLName = empLName;
tento.DEPTNAME = DEPTNAME;
}
/*
* (non-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
veřejnost String toString() {
return “EmployeeDtls [Rec name =” + Rec název + “, empMName =” + empMName
+ “, empLName =” + empLName + “, DEPTNAME =” + DEPTNAME + “]”;
}
/**
* @vrátit se empFName
*/
veřejnost string getEmpFName() {
return Rec název;
}
/**
* @param Rec název
* empFName nastavení
*/
veřejnost zrušit setEmpFName(řetězec empFName) {
tento.Rec Rec name = název;
}
/**
* @vrátit se empMName
*/
veřejnost string getEmpMName() {
return empMName;
}
/**
* @param empMName
* empMName nastavení
*/
veřejnost zrušit setEmpMName(řetězec empMName) {
tento.empMName = empMName;
}
/**
* @vrátit se empLName
*/
veřejnost string getEmpLName() {
return empLName;
}
/**
* @param empLName
* empLName nastavení
*/
veřejnost zrušit setEmpLName(řetězec empLName) {
tento.empLName = empLName;
}
/**
* @vrátit se DEPTNAME
*/
veřejnost řetězec getDeptName() {
return DEPTNAME;
}
/**
* @param DEPTNAME
* DEPTNAME nastavení
*/
veřejnost zrušit setDeptName(řetězec DEPTNAME) {
tento.DEPTNAME = DEPTNAME;
}
}
[/Code]
Summary: Takže v tomto článku jsme viděli, jak na jaře JDBC šablona může být použita v Javě založené na standardních a podnikové aplikace. Také jsme diskutovali výhody tohoto přístupu, a jak to může udělat vývoj mnohem rychleji ve srovnání se standardním vývojem JDBC na bázi.
Shrňme si naši diskusi v podobě následujícího odrážky -
- Jaro se stala neodmyslitelnou součástí moderního Java vývoj podnikových aplikací prostředí.
- Jaro má různé úseky, z toho, šablona JDBC je důležitou součástí.
- Spring JDBC šablona usnadňuje vývoj tím, že zatížení pořízení zdrojů, řízení připojení, zpracování výjimek, a kontrola obecná chyba. My jako vývojář stačí se soustředit na složité podnikatelské scénář.
