Spring JDBC modèle
Vue d'ensemble: Comme nous le savons tous que le cadre de printemps est devenu une partie essentielle du développement d'applications Java moderne. Le cadre de printemps a effectivement réussi à prendre le contrôle de tous les services dans le monde du développement Java. Le modèle JDBC du printemps est utilisé dans la plupart du ressort des applications JEE base pour communiquer avec la base de données.
Dans cet article, je vais parler sur la façon d'accéder à une base de données relationnelle en utilisant le modèle JDBC du printemps.
Présentation: Nous connaissons tous l'importance de la base de données relationnelle dans le développement d'applications d'entreprise. Le printemps est l'un des cadres largement utilisés dans le développement d'applications d'entreprise Java. Spring a différents modules comme ORM, la sécurité, transaction, JPS, JMS etc pour soutenir la nécessité du développement d'applications d'entreprise. Comme le printemps fournit des composants facilement disponibles pour plug-in, l'approche moderne pour le développement des entreprises d'applications Java utilise les fonctionnalités largement. En conséquence, le développement est plus rapide et plus efficace. Spring fournit une approche simple pour gérer les activités de base de données savent que le printemps JDBC modèle.
Inconvénients de l'API JDBC standard: Standard API JDBC présente les inconvénients suivants.
- En dehors de l'exécution de la requête principale, vous devez écrire beaucoup de code pour gérer les questions d'environnement d'exécution comme la création d'une connexion, déclaration, resultset etc.
- Nécessité de traiter le code de gestion des exceptions séparément.
- Nécessité de traiter les questions transactionnelles.
Avantages du printemps JDBC modèle: Spring JDBC modèle présente les avantages suivants par rapport à l'approche normale du standard JDBC.
- Nettoyage des ressources utilisées se fait automatiquement par le ressort JDBC modèle. Ainsi, les développeurs ne doivent pas se soucier de libérer les ressources. Par conséquent, il empêche les fuites de mémoire.
- Spring JDBC modèle gère l'exception et les erreurs d'une manière plus efficace. Il convertit les SQLExceptions JDBC dans RuntimeExceptions, de sorte que les développeurs peuvent gérer de manière plus flexible.
- Le modèle ressort JDBC convertit également les erreurs spécifiques au fournisseur dans un message plus significatif. les manutentions de ces erreurs sont donc plus efficaces.
Commencer:
In this document, nous allons utiliser gradle comme un outil de construction pour construire notre application. Commençons par une simple application utilisée pour stocker et récupérer les détails des employés ainsi que leurs départements d'une organisation. Dans notre exemple, nous allons avoir les attributs suivants de l'objet de l'employé:-
- employé Id
- Employé Prénom
- Nom de l'employé Moyen
- Employé Nom
- Employé Département Id
Et l'objet du département possède les attributs suivants:-
- Département Id
- Nom du département
Maintenant, laissez-nous créer les objets java qui seront utilisés pour communiquer avec la base de données. Nos classes POJO pour ces deux entités sont listées comme sous:
Listing1: Exemple montrant la classe des employés
[Code]
package com.home.springjdbc.objects;
publique classe Employee {
// L'employé Id
privé Chaîne EMPID;
// L'employé premier Nom
privé Chaîne empFName;
// Le prénom de l'employé
privé Chaîne empMName;
// Le dernier nom de l'employé
privé Chaîne emplName;
// Le département de l'employé Id
privé Chaîne empDeptId;
publique Employee ( Chaîne EMPID, Chaîne empFName, Chaîne empMName,
Chaîne emplName, Chaîne empDeptId ) {
Super();
ce.EmpID = EmpID;
ce.Nom Rec Rec = nom;
ce.empMName = empMName;
ce.emplName = emplName;
ce.empDeptId = empDeptId;
}
/**
* @retour le EMPID
*/
publique string getEmpId () {
return EmpID;
}
/**
* @param EmpID
* le EMPID pour définir
*/
publique annulera setEmpId ( Chaîne EMPID ) {
ce.EmpID = EmpID;
}
/**
* @retour le empFName
*/
publique string getEmpFName () {
return nom Rec;
}
/**
* @param nom Rec
* le empFName pour définir
*/
publique annulera setEmpFName ( Chaîne empFName ) {
ce.Nom Rec Rec = nom;
}
/**
* @retour le empMName
*/
publique string getEmpMName () {
return empMName;
}
/**
* @param empMName
* le empMName pour définir
*/
publique annulera setEmpMName ( Chaîne empMName) {
ce.empMName = empMName;
}
/**
* @retour le emplName
*/
publique string getEmpLName () {
return emplName;
}
/**
* @param emplName
* le emplName pour définir
*/
publique annulera setEmpLName ( Chaîne emplName) {
ce.emplName = emplName;
}
/**
* @retour le empDeptId
*/
publique string getEmpDeptId () {
return empDeptId;
}
/**
* @param empDeptId
* le empDeptId pour définir
*/
publique annulera setEmpDeptId ( Chaîne empDeptId ) {
ce.empDeptId = empDeptId;
}
/*
* ( non-Javadoc )
*
* @see java.lang.Object # toString ()
*/
@ Override
publique Chaîne toString () {
return “Employee [ EmpID =” + EmpID + “, Nom Rec =” + nom Rec
+ “, empMName =” + empMName + “, emplName =” + emplName
+ “, empDeptId =” + empDeptId + “]”;
}
}
[/Code]
Listing2: Exemple montrant la classe Département
[Code]
package com.home.springjdbc.objects;
publique classe Département {
// Le département Id
privé Chaîne deptId;
// Le département Nom
privé Chaîne DEPTNAME;
publique Département ( Chaîne deptId, Chaîne DEPTNAME) {
Super ();
ce.deptId = deptId;
ce.DEPTNAME = DEPTNAME;
}
/**
* @retour le deptId
*/
publique Chaîne getDeptId () {
return deptId;
}
/**
* @param deptId
* le deptId pour définir
*/
publique annulera setDeptId ( Chaîne deptId ) {
ce.deptId = deptId;
}
/**
* @retour le DEPTNAME
*/
publique Chaîne getDeptName () {
return DEPTNAME;
}
/**
* @param DEPTNAME
* le DEPTNAME pour définir
*/
publique annulera setDeptName ( Chaîne DEPTNAME ) {
ce.DEPTNAME = DEPTNAME;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
publique Chaîne toString () {
return “Département [ deptId =” + deptId + “, DEPTNAME =” + DEPTNAME + “]”;
}
}
[/Code]
Spring fournit une classe de modèle connu sous le nom JdbcTemplate. Cette classe est responsable de la communication avec SQL bases de données relationnelles et JDBC. Dans l'approche traditionnelle, le maximum d'un code JDBC est occupé dans la gestion de connexion de manutention, l'acquisition de ressources, gestion des exceptions, et la vérification d'erreur générale qui est irrévérencieux dans le contexte de ce que nous essayons de réaliser. Le JdbcTemplate prend soin de toutes ces choses et en tant que développeur, nous devrait se concentrer uniquement sur la logique métier. Une mise en œuvre de la classe de modèle de l'échantillon est présenté comme sous -
Listing3: Exemple montrant la mise en œuvre du modèle JDBC
[Code]
package com.home.springjdbc.dao;
importer java.sql.Driver;
importer java.sql.ResultSet;
importer java.sql.SQLException;
importer java.util.List;
importer org.springframework.jdbc.core.JdbcTemplate;
importer org.springframework.jdbc.core.RowMapper;
importer org.springframework.jdbc.datasource.SimpleDriverDataSource;
importer com.home.springjdbc.objects.Employee;
publique classe EmployeeDAO {
publique statique annulera principale ( String args[] ) {
// DS simples pour le test (pas pour la production!)
SimpleDriverDataSource dataSource = nouveau SimpleDriverDataSource();
dataSource.setDriverClass((Class<? s'étend Chauffeur>) org.h2.Driver.classe);
dataSource.setUsername( “elle” );
dataSource.setUrl( “jdbc:h2:Mem” );
dataSource.setPassword( “” );
JdbcTemplate jdbcTemplate = nouveau JdbcTemplate(la source de données);
Système.sur.println( “Création de tableaux” );
jdbcTemplate.execute( “déposer les employés de la table si elle existe” );
jdbcTemplate.execute( “créer des employés de table(”
+ “id varchar(25), prenom varchar(255), middle_name varchar(255), varchar last_name(255), deptId varchar(25))”);
Chaîne[] records = “E001 Dean Andrew Roberts D25; E002 Jeff Longman Dean D42; E003 Erin Nancy Kirkland D66;”.Divisé(“;”);
pour ( Chaîne singleRecord : Enregistrements ) {
Chaîne [] cols = singleRecord.split(” “);
Système.sur.printf( ” Ajout d'enregistrement de l'employé pour% s% s% s% s% s n”,cols[0], cols[1], cols[2], cols[3], cols[4]);
jdbcTemplate.update(“employés INSERT INTO(ça, Prénom, deuxième nom, nom de famille, deptId) values(?,?,?,?,?)”,cols[0], cols[1], cols[2], cols[3], cols[4]);
}
Système.sur.println ( ” Querying for customer records where first_name = ‘Erin’:” );
liste<Employee> Résultat = jdbcTemplate.query(
“select * des employés où prenom = ?”,
nouveau Objet[] { “Erin” }, nouveau RowMapper<Employee>() {
@ Override
publique mapRow des employés(rs ResultSet, int rowNum)
jette SQLException {
return nouveau Employee(rs.getString(“ça”),
rs.getString(“Prénom”), rs.getString(“deuxième nom”),
rs.getString(“nom de famille”), rs.getString(“deptId”));
}
});
pour (employé des employés : résultats) {
Système.sur.println(employé);
}
}
}
[/Code]
Dans l'exemple ci-dessus, nous avons créé une source de données JDBC utilisant le SimpleDriverDataSource du printemps. Nous utilisons ensuite cette source de données pour construire l'instance JdbcTemplate. Une fois que la classe JdbcTemplate est créé, nous pouvons facilement commencer à appeler la base de données. First, nous créons la table en utilisant la méthode execute du modèle. Ensuite, nous insérons quelques enregistrements en utilisant la méthode de mise à jour du modèle. Enfin, nous utilisons la méthode de requête pour récupérer les dossiers de notre choix. Dans notre exemple, nous avons utilisé une simple requête pour récupérer l'enregistrement de la table des employés. Mais selon notre conception, nous voyons que la table des employés a une relation avec la table de service via la colonne - deptId. Ainsi, nous pouvons également utiliser le même code pour récupérer les enregistrements joignant ces deux tables. Juste nous devons changer la requête pour mettre une jointure. Le code ci-dessus pourrait être modifié comme sous -
Listing4: Exemple montrant la requête modifiée
[Code]
liste<Employee> Résultat = jdbcTemplate.query(
“sélectionnez emp.first_name, _name emp.middle, _name emp.last, dept.dept_Name des employés emp, département dept où emp.first_name = ?”,
nouveau Objet[] { “Erin” }, nouveau RowMapper<Employee>() {
@ Override
publique EmployeeDtls mapRow(rs ResultSet, int rowNum)
jette SQLException {
return nouveau Employee( rs.getString(“Prénom”),
rs.getString(“deuxième nom”),
rs.getString(“nom de famille”),
rs.getString(“dept_name “));
}
});
pour (EmployeeDtls employeeDtl : résultats) {
Système.sur.println(employeeDtl);
}
[/Code]
Pour exécuter cela, nous devrions avoir une autre classe POJO EmployeeDtls comme sous -
Listing5: Exemple montrant les EmployeeDtls de classe POJO
[Code]
package com.home.springjdbc.objects;
publique classe EmployeeDtls {
// L'employé premier Nom
privé Chaîne empFName;
// Le prénom de l'employé
privé Chaîne empMName;
// Le dernier nom de l'employé
privé Chaîne emplName;
// Le département Nom
privé Chaîne DEPTNAME;
/**
* @param nom Rec
* @param empMName
* @param emplName
* @param DEPTNAME
*/
publique EmployeeDtls(Chaîne empFName, Chaîne empMName, Chaîne emplName,
Chaîne DEPTNAME) {
Super();
ce.Nom Rec Rec = nom;
ce.empMName = empMName;
ce.emplName = emplName;
ce.DEPTNAME = DEPTNAME;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object # toString()
*/
@ Override
publique Chaîne toString() {
return “EmployeeDtls [Nom Rec =” + nom Rec + “, empMName =” + empMName
+ “, emplName =” + emplName + “, DEPTNAME =” + DEPTNAME + “]”;
}
/**
* @retour le empFName
*/
publique string getEmpFName() {
return nom Rec;
}
/**
* @param nom Rec
* le empFName pour définir
*/
publique annulera setEmpFName(Chaîne empFName) {
ce.Nom Rec Rec = nom;
}
/**
* @retour le empMName
*/
publique string getEmpMName() {
return empMName;
}
/**
* @param empMName
* le empMName pour définir
*/
publique annulera setEmpMName(Chaîne empMName) {
ce.empMName = empMName;
}
/**
* @retour le emplName
*/
publique string getEmpLName() {
return emplName;
}
/**
* @param emplName
* le emplName pour définir
*/
publique annulera setEmpLName(Chaîne emplName) {
ce.emplName = emplName;
}
/**
* @retour le DEPTNAME
*/
publique Chaîne getDeptName() {
return DEPTNAME;
}
/**
* @param DEPTNAME
* le DEPTNAME pour définir
*/
publique annulera setDeptName(Chaîne DEPTNAME) {
ce.DEPTNAME = DEPTNAME;
}
}
[/Code]
Summary: Donc, dans cet article, nous avons vu comment modèle printemps JDBC peut être utilisé dans les applications Java standard et entreprise basée. Nous avons également discuté des avantages de cette approche et comment il peut rendre le développement beaucoup plus rapide par rapport à l'élaboration de la norme sur la base JDBC.
Résumons notre discussion sous forme de points de balle suivante -
- Le printemps est devenu une partie essentielle de l'environnement de développement d'applications d'entreprise moderne basé sur Java.
- Spring a différentes sections, parmi lesquels, le modèle JDBC est une partie importante.
- Spring JDBC modèle facilite le développement en prenant la charge de l'acquisition des ressources, gestion de connexion, gestion des exceptions, et l'erreur de vérification générale. Nous en tant que développeur juste besoin de se concentrer sur le scénario d'affaires complexes.
