mola plantilla JDBC
Visión global: Como todos sabemos que o cadro primavera tornouse parte esencial do desenvolvemento de aplicacións baseado en Java moderna. O Spring Framework efectivamente conseguiu tomar o control de todos os departamentos do mundo de desenvolvemento Java. O modelo JDBC da primavera é usado na maioría do freo aplicacións Jee base para comunicarse co banco de datos.
Neste artigo vou falar sobre como acceder a un banco de datos relacional utilizando o modelo JDBC da primavera.
Introdución: Todos sabemos a importancia de base de datos relacional no desenvolvemento de aplicacións corporativas. Primavera é un dos cadros amplamente utilizados en desenvolvemento de aplicacións corporativos baseados en Java. Primavera ten diferentes módulos como ORM, seguridade, transacción, JPS, JMS, etc, para apoiar a necesidade de desenvolvemento de aplicacións corporativas. Mentres a primavera ofrece compoñentes facilmente dispoñibles para plugin, a visión moderna para o desenvolvemento de aplicacións Java empresa utiliza os recursos extensivamente. Como resultado, o desenvolvemento é moito máis rápido e eficiente. Spring ofrece un sistema sinxelo para xestionar actividades de base de datos coñecido como resorte plantilla JDBC.
Desvantaxes da API JDBC estándar: JDBC estándar API ten as seguintes inconvenientes.
- Ademais de realizar a consulta de inicio, ten que escribir unha morea de código para xestionar as cuestións ambientais execución como a creación de conexión, afirmación, resultset etc.
- Debe xestionar código de manipulación de excepción en separado.
- Debe xestionar cuestións transnacionais.
Vantaxes do freo plantilla JDBC: mola plantilla JDBC ten as seguintes vantaxes en comparación coa visión normal do patrón de JDBC.
- Limpeza dos recursos utilizados faise automaticamente polo primavera molde JDBC. Así, os desenvolvedores non se preocupe sobre a liberación de recursos. Por iso, evita perdas de memoria.
- mola plantilla JDBC procesa a excepción e erros de forma máis eficiente. El converte os SQLExceptions JDBC en RuntimeExceptions, de xeito que os desenvolvedores poden tratar con isto de forma máis flexible.
- A primavera molde JDBC tamén converte os erros específicos do provedor nunha mensaxe mellor significativa. Así, os manejos destes erros son máis eficientes.
Comezar:
In this document, imos usar Gradle como unha ferramenta de construción para construír a nosa aplicación. Imos comezar cunha simple aplicación usada para almacenar e recuperar a información de empregados, xunto cos seus departamentos dunha organización. No noso exemplo, teremos os seguintes atributos do obxecto empregado:-
- empregado Id
- empregado Nome
- Nome do medio empregado
- empregado Apelidos
- Funcionario do Departamento de Id
E o obxecto departamento ten os seguintes atributos:-
- Departamento Id
- nome Departamento
Agora imos crear os obxectos java que serán usados para comunicarse co banco de datos. As nosas clases POJO para estas dúas entidades se listan como a continuación:
Listing1: Exemplo mostra a clase Employee
[Code]
package com.home.springjdbc.objects;
público clase Employee {
// O funcionario Id
privado cordas empID;
// O nome do funcionario
privado cordas empFName;
// O nome do medio empregado
privado cordas empMName;
// O último nome do funcionario
privado cordas emplName;
// O departamento empregado Id
privado cordas empDeptId;
público Employee ( cordas empID, cordas empFName, cordas empMName,
cordas emplName, cordas empDeptId ) {
super();
esta.EmpID = EmpID;
esta.nome Rec Rec = name;
esta.empMName = empMName;
esta.emplName = emplName;
esta.empDeptId = empDeptId;
}
/**
* @return o empID
*/
público cadea getEmpId () {
return EmpID;
}
/**
* @param EmpID
* o EmpID para definir
*/
público invalidar setEmpId ( cordas empID ) {
esta.EmpID = EmpID;
}
/**
* @return o empFName
*/
público getEmpFName cadea () {
return nome do Rec;
}
/**
* @param nome do Rec
* o empFName para definir
*/
público invalidar setEmpFName ( cordas empFName ) {
esta.nome Rec Rec = name;
}
/**
* @return o empMName
*/
público getEmpMName cadea () {
return empMName;
}
/**
* @param empMName
* o empMName para definir
*/
público invalidar setEmpMName ( cordas empMName) {
esta.empMName = empMName;
}
/**
* @return o emplName
*/
público getEmpLName cadea () {
return emplName;
}
/**
* @param emplName
* o emplName para definir
*/
público invalidar setEmpLName ( cordas emplName) {
esta.emplName = emplName;
}
/**
* @return o empDeptId
*/
público getEmpDeptId cadea () {
return empDeptId;
}
/**
* @param empDeptId
* o empDeptId para definir
*/
público invalidar setEmpDeptId ( cordas empDeptId ) {
esta.empDeptId = empDeptId;
}
/*
* ( non-javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Override
público cadea toString () {
return “Employee [ EmpID =” + EmpID + “, nome Rec =” + nome do Rec
+ “, empMName =” + empMName + “, emplName =” + emplName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Mostra mostrando o Departamento de Clase
[Code]
package com.home.springjdbc.objects;
público clase departamento {
// O departamento Id
privado cordas DEPTID;
// O nome do departamento
privado cordas NOMEDEPTO;
público departamento ( cordas DEPTID, cordas NOMEDEPTO) {
super ();
esta.DEPTID = DEPTID;
esta.NOMEDEPTO = NOMEDEPTO;
}
/**
* @return o DEPTID
*/
público cordas getDeptId () {
return DEPTID;
}
/**
* @param DEPTID
* o DEPTID para definir
*/
público invalidar setDeptId ( cordas DEPTID ) {
esta.DEPTID = DEPTID;
}
/**
* @return o NOMEDEPTO
*/
público cordas getDeptName () {
return NOMEDEPTO;
}
/**
* @param NOMEDEPTO
* o NOMEDEPTO para definir
*/
público invalidar setDeptName ( cordas NOMEDEPTO ) {
esta.NOMEDEPTO = NOMEDEPTO;
}
/*
* (non-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
público cadea toString () {
return “departamento [ DEPTID =” + DEPTID + “, NOMEDEPTO =” + NOMEDEPTO + “]”;
}
}
[/Code]
Spring ofrece unha clase de modelo coñecido como JdbcTemplate. Esta clase é responsable da comunicación con bases de datos relacionais SQL e JDBC. Na visión tradicional máximo dun código JDBC é ocupado na xestión de conexión de manipulación, adquisición de recursos, manipulación de excepción, e comprobación de erros xeral que é irreverente no contexto do que estamos intentando conseguir. O JdbcTemplate coida de todas estas cousas e como un creador debemos concentrar só na lóxica de negocio. A posta en marcha de exemplo da clase de modelo móstrase como a continuación -
Listing3: Exemplo mostra a implantación do modelo de JDBC
[Code]
package com.home.springjdbc.dao;
descargar java.sql.Driver;
descargar java.sql.ResultSet;
descargar java.sql.SQLException;
descargar java.util.List;
descargar org.springframework.jdbc.core.JdbcTemplate;
descargar org.springframework.jdbc.core.RowMapper;
descargar org.springframework.jdbc.datasource.SimpleDriverDataSource;
descargar com.home.springjdbc.objects.Employee;
público clase EmployeeDAO {
público estático invalidar principal ( String args[] ) {
// DS simple para proba (non para a produción!)
SimpleDriverDataSource dataSource = novo SimpleDriverDataSource();
dataSource.setDriverClass((clase<? esténdese a Chofer>) org.h2.Driver.clase);
dataSource.setUsername( “seu” );
dataSource.setUrl( “JDBC:h2:mem” );
dataSource.setPassword( “” );
JdbcTemplate JdbcTemplate = novo JdbcTemplate(dataSource);
Sistema.fóra.println( “Creación de táboas” );
jdbcTemplate.execute( “deixa a táboa empregados, se existe” );
jdbcTemplate.execute( “crear empregados de mesa(”
+ “VARCHAR id(25), first_name VARCHAR(255), middle_name VARCHAR(255), VARCHAR last_name(255), DEPTID VARCHAR(25))”);
Corda[] rexistros = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland D66;”.división(“;”);
a ( cordas singleRecord : rexistros ) {
Corda [] cols = singleRecord.split(” “);
Sistema.fóra.printf( ” Engadindo rexistro de funcionario a% s% s% s% s% s n”,cols[0], cols[1], cols[2], cols[3], cols[4]);
jdbcTemplate.update(“funcionarios INSERT INTO(identidade, nome, segundo nome, Apelido, DEPTID) values(?,?,?,?,?)”,cols[0], cols[1], cols[2], cols[3], cols[4]);
}
Sistema.fóra.println ( ” Querying for customer records where first_name = ‘Erin’:” );
lista<Employee> resulta = jdbcTemplate.query(
“select * dos empregados, onde first_name = ?”,
novo obxecto[] { “Erin” }, novo RowMapper<Employee>() {
@ Override
público mapRow empregado(ResultSet rs, int rowNum)
lanza SQLException {
return novo Employee(rs.getString(“identidade”),
rs.getString(“nome”), rs.getString(“segundo nome”),
rs.getString(“Apelido”), rs.getString(“DEPTID”));
}
});
a (empregado empregado : resultados) {
Sistema.fóra.println(empregado);
}
}
}
[/Code]
No exemplo anterior,, montar unha fonte de datos JDBC usando SimpleDriverDataSource desde a primavera. Logo usan esta fonte de datos para construír a instancia JDBCTemplate. Xa que a clase JDBCTemplate é creado, podemos facilmente comezar a chamar a base de datos. First, creamos a táboa usando o método execute do modelo. Logo inserir algúns rexistros usando o método de actualización do modelo. Finalmente, usamos o método de consulta para buscar os rexistros da nosa elección. No noso exemplo, utilizamos unha consulta simple para buscar o rexistro da táboa de empregado. Pero segundo a nosa concepción, vemos que a táboa de funcionarios ten unha relación coa táboa de departamento a través da columna - DEPTID. Por iso, tamén pode usar o mesmo código para buscar rexistros xuntar estas dúas táboas. Só necesitamos cambiar a consulta para poñer unha xuntanza. O código anterior podería ser modificado como a continuación -
Listing4: Exemplo mostra a consulta modificada
[Code]
lista<Employee> resulta = jdbcTemplate.query(
“selecciona emp.first_name, _name emp.middle, _name emp.last, dept.dept_Name dos empregados emp, departamento dept onde emp.first_name = ?”,
novo obxecto[] { “Erin” }, novo RowMapper<Employee>() {
@ Override
público EmployeeDtls mapRow(ResultSet rs, int rowNum)
lanza SQLException {
return novo Employee( rs.getString(“nome”),
rs.getString(“segundo nome”),
rs.getString(“Apelido”),
rs.getString(“DEPT_NAME “));
}
});
a (EmployeeDtls employeeDtl : resultados) {
Sistema.fóra.println(employeeDtl);
}
[/Code]
Para realizar isto, temos que ter máis EmployeeDtls clase POJO como a continuación -
Listing5: Mostra mostrando os EmployeeDtls clase POJO
[Code]
package com.home.springjdbc.objects;
público clase EmployeeDtls {
// O nome do funcionario
privado cordas empFName;
// O nome do medio empregado
privado cordas empMName;
// O último nome do funcionario
privado cordas emplName;
// O nome do departamento
privado cordas NOMEDEPTO;
/**
* @param nome do Rec
* @param empMName
* @param emplName
* @param NOMEDEPTO
*/
público EmployeeDtls(cordas empFName, cordas empMName, cordas emplName,
cordas NOMEDEPTO) {
super();
esta.nome Rec Rec = name;
esta.empMName = empMName;
esta.emplName = emplName;
esta.NOMEDEPTO = NOMEDEPTO;
}
/*
* (non-javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
público cadea toString() {
return “EmployeeDtls [nome Rec =” + nome do Rec + “, empMName =” + empMName
+ “, emplName =” + emplName + “, NOMEDEPTO =” + NOMEDEPTO + “]”;
}
/**
* @return o empFName
*/
público getEmpFName cadea() {
return nome do Rec;
}
/**
* @param nome do Rec
* o empFName para definir
*/
público invalidar setEmpFName(cordas empFName) {
esta.nome Rec Rec = name;
}
/**
* @return o empMName
*/
público getEmpMName cadea() {
return empMName;
}
/**
* @param empMName
* o empMName para definir
*/
público invalidar setEmpMName(cordas empMName) {
esta.empMName = empMName;
}
/**
* @return o emplName
*/
público getEmpLName cadea() {
return emplName;
}
/**
* @param emplName
* o emplName para definir
*/
público invalidar setEmpLName(cordas emplName) {
esta.emplName = emplName;
}
/**
* @return o NOMEDEPTO
*/
público cordas getDeptName() {
return NOMEDEPTO;
}
/**
* @param NOMEDEPTO
* o NOMEDEPTO para definir
*/
público invalidar setDeptName(cordas NOMEDEPTO) {
esta.NOMEDEPTO = NOMEDEPTO;
}
}
[/Code]
Summary: Así, neste artigo, vimos como mola plantilla JDBC pode ser usado en aplicacións Java Standard e Enterprise con base. Tamén discutir as vantaxes deste enfoque, e como pode facer o desenvolvemento moito máis rápido en comparación co estándar de desenvolvemento baseado JDBC.
Imos resumir nosa discusión en forma de seguir puntos de bala -
- Primavera converteuse nunha parte esencial do contorno de desenvolvemento de aplicacións empresariais baseadas Java moderna.
- Primavera ten seccións diferentes, dos cales, o modelo JDBC é unha parte importante.
- mola plantilla JDBC facilita o desenvolvemento, tomando a carga de adquisición de recursos, xestión de conexión, manipulación de excepción, e erro xeral comprobación. Nós, como un creador só precisa concentrarse no escenario de negocios complexo.
