Spring jdb modèl
Apèsi sou lekòl la: Kòm nou tout konnen ki te fondasyon an sezon prentan vin yon pati esansyèl nan modèn Java ki baze devlopman nan aplikasyon. te Fondasyon an sezon prentan efektivman jere yo pran kontwòl nan chak depatman nan mond lan devlopman Java. se modèl la jdb nan sezon prentan yo itilize nan pi fò nan sezon prentan an aplikasyon JEE baze yo kominike avèk baz done a.
Nan atik sa a mwen pral pale sou ki jan jwenn aksè nan yon baz done relasyon lè l sèvi avèk modèl la jdb nan sezon prentan.
Entwodiksyon: Nou tout konnen enpòtans ki genyen nan baz done relasyon nan devlopman aplikasyon antrepriz. Spring se youn nan cadres yo lajman ki itilize nan Java ki baze devlopman antrepwiz aplikasyon. Spring gen modil diferan tankou ORM, sekirite, tranzaksyon, JPS, JMS elatriye sipòte bezwen an nan devlopman aplikasyon antrepriz. Kòm sezon prentan bay eleman ki disponib fasilman yo ploge-a, apwòch la modèn pou devlopman antrepriz Java aplikasyon sèvi ak karakteristik yo ki anpil. Kòm yon rezilta devlopman nan se anpil pi vit e pi efikas. Spring bay yon apwòch senp yo okipe aktivite baz done konnen kòm sezon prentan jdb modèl.
Dezavantaj nan estanda API jdb: Standard jdb API gen dezavantaj sa yo.
- Apa de egzekite rechèch la prensipal, ou bezwen ekri yon anpil nan kòd okipe pwoblèm yo ki anviwònman ekzekisyon tankou kreye pi koneksyon, deklarasyon, resultset elatriye.
- Bezwen okipe eksepsyon Kòd manyen separeman.
- Bezwen okipe pwoblèm transactionnelle.
Avantaj nan sezon prentan jdb modèl: Spring jdb modèl gen avantaj sa yo konpare ak apwòch la nòmal nan estanda jdb.
- se Netwayaj nan itilize resous fè otomatikman yo bò sous jdb modèl. Se konsa, devlopè yo pa bezwen deranje sou divilge resous yo. Pakonsekan li anpeche fwit memwa.
- Spring jdb modèl manch eksepsyon nan ak erè nan yon fason pi efikas. Li konvèti SQLExceptions yo jdb nan RuntimeExceptions, se konsa devlopè yo ka okipe li nan fason pi fleksib.
- Modèl la sezon prentan jdb tou konvèti machann erè yo ki espesifik nan yon mesaj pi bon sans. Se konsa, handlings yo nan erè sa yo se pi efikas.
Pou kòmanse:
In this document, kite a sèvi ak gradle kòm yon zouti bati yo bati aplikasyon nou an. Se pou nou kòmanse avèk yon aplikasyon senp itilize nan magazen ak rekipere detay yo nan anplwaye ansanm ak depatman yo nan yon òganizasyon. Nan egzanp nou an, nou pral gen atribi sa yo nan objè a anplwaye:-
- Anplwaye Id
- Anplwaye Prenon
- Anplwaye Middle Non
- Anplwaye Siyati
- Anplwaye Depatman Id
Ak objè a depatman gen atribi sa yo:-
- Depatman Id
- Depatman Non
Koulye a, kite nou kreye objè yo java ki pral itilize yo kominike avèk baz done a. klas POJO nou pou de antite sa yo yo ki nan lis kòm anba:
Listing1: Egzanp ki montre Gwoup la Anplwaye
[Code]
package com.home.springjdbc.objects;
piblik klas Employee {
// Anplwaye a Id
prive chèn empId;
// anplwaye premye Non a
prive chèn empFName;
// anplwaye mitan Non a
prive chèn empMName;
// anplwaye dènye Non a
prive chèn empLName;
// anplwaye Depatman an Id
prive chèn empDeptId;
piblik Employee ( chèn empId, chèn empFName, chèn empMName,
chèn empLName, chèn empDeptId ) {
super();
sa a.EmpID = EmpID;
sa a.empFName = empFName;
sa a.empMName = empMName;
sa a.empLName = empLName;
sa a.empDeptId = empDeptId;
}
/**
* @return the empId
*/
piblik String getEmpId () {
return empId;
}
/**
* @param empId
* the empId to set
*/
piblik anile setEmpId ( chèn empId ) {
sa a.EmpID = EmpID;
}
/**
* @return the empFName
*/
piblik String getEmpFName () {
return empFName;
}
/**
* @param empFName
* the empFName to set
*/
piblik anile setEmpFName ( chèn empFName ) {
sa a.empFName = empFName;
}
/**
* @return the empMName
*/
piblik String getEmpMName () {
return empMName;
}
/**
* @param empMName
* the empMName to set
*/
piblik anile setEmpMName ( chèn empMName) {
sa a.empMName = empMName;
}
/**
* @return the empLName
*/
piblik String getEmpLName () {
return empLName;
}
/**
* @param empLName
* the empLName to set
*/
piblik anile setEmpLName ( chèn empLName) {
sa a.empLName = empLName;
}
/**
* @return the empDeptId
*/
piblik String getEmpDeptId () {
return empDeptId;
}
/**
* @param empDeptId
* the empDeptId to set
*/
piblik anile setEmpDeptId ( chèn empDeptId ) {
sa a.empDeptId = empDeptId;
}
/*
* ( non-Javadoc )
*
* @see java.lang.Object#toString ()
*/
@ Pase sou desizyon
piblik String toString () {
return “Employee [ empId=” + empId + “, empFName=” + empFName
+ “, empMName=” + empMName + “, empLName=” + empLName
+ “, empDeptId=” + empDeptId + “]”;
}
}
[/Code]
Listing2: Sample showing the Department Class
[Code]
package com.home.springjdbc.objects;
piblik klas Department {
// The department Id
prive String deptId;
// The department Name
prive String deptName;
piblik Department ( String deptId, String deptName) {
super ();
sa a.deptId = deptId;
sa a.deptName = deptName;
}
/**
* @return the deptId
*/
piblik String getDeptId () {
return deptId;
}
/**
* @param deptId
* the deptId to set
*/
piblik anile setDeptId ( String deptId ) {
sa a.deptId = deptId;
}
/**
* @return the deptName
*/
piblik String getDeptName () {
return deptName;
}
/**
* @param deptName
* the deptName to set
*/
piblik anile setDeptName ( String deptName ) {
sa a.deptName = deptName;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
@ Pase sou desizyon
piblik String toString () {
return “Department [ deptId=” + deptId + “, deptName=” + deptName + “]”;
}
}
[/Code]
Spring provides a template class known as JdbcTemplate. This class is responsible for communicating with SQL relational databases and JDBC. In the traditional approach the maximum of a JDBC code is occupied in handling connection management, resource acquisition, exception handling, and general error checking which is irreverent in the context of what we are trying to achieve. The JdbcTemplate takes care of all of these things and as a developer we should focus only on the business logic. A sample implementation of the template class is shown as under –
Listing3: Sample showing the implementation of JDBC template
[Code]
package com.home.springjdbc.dao;
enpòte java.sql.Driver;
enpòte java.sql.ResultSet;
enpòte java.sql.SQLException;
enpòte java.util.List;
enpòte org.springframework.jdbc.core.JdbcTemplate;
enpòte org.springframework.jdbc.core.RowMapper;
enpòte org.springframework.jdbc.datasource.SimpleDriverDataSource;
enpòte com.home.springjdbc.objects.Employee;
piblik klas EmployeeDAO {
piblik estatik anile prensipal ( chèn arg[] ) {
// simple DS for test (not for production!)
SimpleDriverDataSource dataSource = nouvo SimpleDriverDataSource();
dataSource.setDriverClass((Class<? fin Driver>) org.h2.Driver.klas);
dataSource.setUsername( “sa” );
dataSource.setUrl( “jdbc:h2:mem” );
dataSource.setPassword( “” );
JdbcTemplate jdbcTemplate = nouvo JdbcTemplate(dataSource);
Sistèm.soti.println( “Creating tables” );
jdbcTemplate.execute( “drop table employees if exists” );
jdbcTemplate.execute( “create table employees(”
+ “id varchar(25), first_name varchar(255), middle_name varchar(255), last_name varchar(255), deptId varchar(25))”);
Fisèl[] records = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland D66;”.split(“;”);
pou ( String singleRecord : records ) {
Fisèl [] cols = singleRecord.split(” “);
Sistèm.soti.printf( ” Adding employee record for %s %s %s %s %sn”,cols[0], cols[1], cols[2], cols[3], cols[4]);
jdbcTemplate.update(“INSERT INTO employees(id, first_name, middle_name, last_name, deptId) values(?,?,?,?,?)”,cols[0], cols[1], cols[2], cols[3], cols[4]);
}
Sistèm.soti.println ( ” Querying for customer records where first_name = ‘Erin’:” );
List<Employee> results = jdbcTemplate.query(
“select * from employees where first_name = ?”,
nouvo Object[] { “Erin” }, nouvo RowMapper<Employee>() {
@ Pase sou desizyon
piblik Employee mapRow(ResultSet rs, Int rowNum)
throws SQLException {
return nouvo Employee(rs.getString(“id”),
rs.getString(“first_name”), rs.getString(“middle_name”),
rs.getString(“last_name”), rs.getString(“deptId”));
}
});
pou (Employee employee : results) {
Sistèm.soti.println(employee);
}
}
}
[/Code]
In the above example, we set up a JDBC data source using the SimpleDriverDataSource from spring. We then use this data source to construct the JDBCTemplate instance. Once the JDBCTemplate class is created, we can easily start calling the database. First, we create the table using the execute method of the template. Then we insert few records using the update method of the template. Finally we use the query method to fetch the records of our choice. In our example we have used a simple query to fetch the record from the employee table. But as per our design we see that the employee table has a relation with the department table via the column – deptId. So we can also use the same code to fetch records joining these two tables. Just we need to change the query to put a join. The above code could be modified as under –
Listing4: Sample showing the modified query
[Code]
List<Employee> results = jdbcTemplate.query(
“select emp.first_name, emp.middle _name, emp.last _name, dept.dept_Name from employees emp, department dept where emp.first_name = ?”,
nouvo Object[] { “Erin” }, nouvo RowMapper<Employee>() {
@ Pase sou desizyon
piblik EmployeeDtls mapRow(ResultSet rs, Int rowNum)
throws SQLException {
return nouvo Employee( rs.getString(“first_name”),
rs.getString(“middle_name”),
rs.getString(“last_name”),
rs.getString(“dept_Name “));
}
});
pou (EmployeeDtls employeeDtl : results) {
Sistèm.soti.println(employeeDtl);
}
[/Code]
To execute this we should have another POJO class EmployeeDtls as under –
Listing5: Sample showing the POJO class EmployeeDtls
[Code]
package com.home.springjdbc.objects;
piblik klas EmployeeDtls {
// anplwaye premye Non a
prive chèn empFName;
// anplwaye mitan Non a
prive chèn empMName;
// anplwaye dènye Non a
prive chèn empLName;
// The department Name
prive String deptName;
/**
* @param empFName
* @param empMName
* @param empLName
* @param deptName
*/
piblik EmployeeDtls(chèn empFName, chèn empMName, chèn empLName,
String deptName) {
super();
sa a.empFName = empFName;
sa a.empMName = empMName;
sa a.empLName = empLName;
sa a.deptName = deptName;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
@ Pase sou desizyon
piblik String toString() {
return “EmployeeDtls [empFName=” + empFName + “, empMName=” + empMName
+ “, empLName=” + empLName + “, deptName=” + deptName + “]”;
}
/**
* @return the empFName
*/
piblik String getEmpFName() {
return empFName;
}
/**
* @param empFName
* the empFName to set
*/
piblik anile setEmpFName(chèn empFName) {
sa a.empFName = empFName;
}
/**
* @return the empMName
*/
piblik String getEmpMName() {
return empMName;
}
/**
* @param empMName
* the empMName to set
*/
piblik anile setEmpMName(chèn empMName) {
sa a.empMName = empMName;
}
/**
* @return the empLName
*/
piblik String getEmpLName() {
return empLName;
}
/**
* @param empLName
* the empLName to set
*/
piblik anile setEmpLName(chèn empLName) {
sa a.empLName = empLName;
}
/**
* @return the deptName
*/
piblik String getDeptName() {
return deptName;
}
/**
* @param deptName
* the deptName to set
*/
piblik anile setDeptName(String deptName) {
sa a.deptName = deptName;
}
}
[/Code]
Summary: So in this article we have seen how spring JDBC template can be used in Java based standard and enterprise applications. We have also discussed the advantages of this approach and how it can make the development much faster compared to the standard JDBC based development.
Let us summarize our discussion in the form of following bullet points –
- Spring has become an essential part of the modern Java based enterprise application development environment.
- Spring has different sections, out of which, the JDBC template is an important part.
- Spring JDBC template eases the development by taking the load of resource acquisition, connection management, exception handling, and general error checking. We as a developer just need to concentrate on the complex business scenario.
