Le but de ce tutoriel est d'utiliser une couche séparée écrite en Java pour accéder aux tables dans une base de données. Cette couche est généralement appelée couche d'accès aux données (DAL)
Le plus grand avantage de l'utilisation de DAL est qu'il simplifie l'opération d'accès de la base de données en utilisant directement certaines méthodes comme insert () et trouver (), plutôt que de toujours faire des liens en premier, puis d'exécuter certaines requêtes.
Cette couche gère tous les appels et requêtes liés à la base de données à l'intérieur.
Créer une base de données
Nous voulons créer une table simple pour l'utilisateur, nous pouvons utiliser ces champs pour créer
id int
Nom Varchar (200)
Mot de passe Varchar (200)
Âge int
Objet de transfert de données
Cette couche doit contenir une classe simple appelée objet de transfert de données (DTO). Cette classe n'est qu'une carte simple correspondant à la table de la base de données, et chaque colonne de la table correspond à une variable membre de la classe.
Notre objectif est d'utiliser des objets Java simples, plutôt que de traiter les instructions SQL et d'autres commandes liées à la base de données pour ajouter, supprimer, modifier et vérifier la base de données.
Si nous voulons cartographier la table en code Java, nous avons juste besoin de créer une classe (bean) contenant les mêmes champs.
Pour mieux encapsuler, en plus des constructeurs, nous devons déclarer toutes les variables de champ en tant que privés, créer des accessoires (getters et setters), dont l'un est le constructeur par défaut.
classe publique User {ID entier privé; nom de chaîne privé; Pass de chaîne privée; Âge entier privé;}Pour cartographier correctement les champs, nous devons considérer la valeur nul dans la base de données. Pour les valeurs par défaut d'origine de Java, telles que le type INT, sa valeur par défaut est 0, nous devons donc fournir un nouveau type de données pouvant accueillir des valeurs nulles. Nous pouvons remplacer INT en utilisant un type spécial - une classe d'encapsulation, telle que Integer.
Enfin, notre classe devrait ressembler à ceci:
classe publique User {ID entier privé; nom de chaîne privé; Pass de chaîne privée; Âge entier privé; Utilisateur public () {} Utilisateur public (nom de chaîne, String Pass, entier Âge) {this.name = name; this.pass = pass; this.age = âge; } utilisateur public (ID entier, nom de chaîne, pass de chaîne, âge entier) {this.id = id; this.name = name; this.pass = pass; this.age = âge; } public Integer Getage () {Return Age; } public void Setage (entier Âge) {this.age = age; } public Integer getID () {return id; } public void setid (INGER ID) {this.id = id; } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } public String getPass () {return pass; } public void setPass (String Pass) {this.pass = pass; }}Une bonne pratique consiste à fournir le constructeur vide par défaut, un constructeur complet et un constructeur complet sans paramètres d'ID.
Connectez-vous à la base de données
Nous pouvons utiliser une classe intermédiaire pour faciliter la connexion à la base de données. Dans cette classe, nous fournirons les paramètres de connexion de la base de données tels que la base de données JDBC, URL, nom d'utilisateur et mot de passe, et définir ces variables comme finales (il sera préférable d'obtenir ces données à partir de propriétés ou de fichiers de configuration XML)
Fournit une méthode pour renvoyer un objet de connexion ou renvoyer un null lorsque la connexion échoue ou lance une exception d'exécution.
public static final string url = "jdbc: mysql: // localhost: 3306 / testdb"; public static final string user = "testuser"; public static final pass pass = "testpass"; / ** * obtenez un objet de connexion * @return Connection Object * / public static getConnection (); return driverManager.getConnection (URL, utilisateur, pass); } catch (sqlexception ex) {throw new RuntimeException ("Erreur de connexion à la base de données", ex); }}Nous pouvons également inclure une méthode principale dans la classe pour tester la connexion. La classe complète ressemble à ceci:
Importer com.mysql.jdbc.driver; import java.sql.connection; import java.sql.drivermanager; import java.sql.sqlexception; / ** * se connecter à la base de données * @Autor hany.sad * / public class ConnectionFactory {public static string url = "JDBC: mysql: // localhost: 3306 / testdb"; public static final String user = "TesUser"; public static final String Pass = "TestPass"; / ** * Obtenez une connexion à la base de données * @return Connection Object * / Connexion statique publique getConnection () {try {driverManager.RegisterDriver (new Driver ()); return driverManager.getConnection (URL, utilisateur, pass); } catch (sqlexception ex) {throw new RuntimeException ("Erreur de connexion à la base de données", ex); }} / ** * Test Connection * / public static void main (String [] args) {connexion connection = connectionFactory.getConnection (); }}Objet d'accès aux données
La couche DAO peut effectuer des opérations CRUD. Il peut ajouter, supprimer, modifier et vérifier nos tables.
Notre interface Dao Layer devrait ressembler à ceci:
Interface publique UserDao {User GetUser (); Set <ser utilisateur> getAlUsers (); User GetUserByUserAmandAdPassword (); booléen insertUser (); Boolean UpdateUser (); booléen DeleteUser ();}Trouver des utilisateurs
Les utilisateurs peuvent interroger via tous les champs uniques comme l'ID, le nom ou le courrier électronique. Dans cet exemple, nous utilisons l'ID pour trouver l'utilisateur. La première étape consiste à créer une connexion via la classe de connecteur, puis à exécuter l'instruction SELECT pour obtenir l'utilisateur avec son ID 7. Nous pouvons utiliser cette instruction pour interroger l'utilisateur:
Sélectionnez * à partir de l'utilisateur où id = 7
C'est ici que nous faisons une instruction dynamique pour obtenir l'ID des paramètres.
En exécutant cette requête, un ensemble de résultats est obtenu, où l'utilisateur ou NULL est enregistré. Nous pouvons utiliser la méthode suivante () de résultat pour détecter s'il y a une valeur. Si TRUE est renvoyé, nous continuerons à utiliser des Getters de données pour obtenir des données utilisateur à partir du résultat. Lorsque nous encapsulons toutes les données de l'utilisateur, nous les renvoyons. Si un utilisateur avec cet ID n'existe pas ou si toute autre exception se produit (comme une instruction SQL non valide), cette méthode renverra NULL.
Utilisateur public GetUser (int id) {connexion connection = connectionFactory.getConnection (); try {instruction stmt = connection.createStatement (); ResultSet rs = stmt.ExecuteQuery ("SELECT * FROM User Where id =" + id); if (Rs.Next ()) {utilisateur utilisateur = new user (); User.SetId (Rs.GetInt ("ID")); user.setName (Rs.getString ("name")); user.setPass (Rs.GetString ("Pass")); user.Setage (Rs.GetInt ("Age")); RETOUR UTILISATEUR; }} catch (sqlexception ex) {ex.printStackTrace (); } retourner null;}Il sera plus pratique d'utiliser une méthode distincte pour extraire les données de l'ensemble de résultats, car dans de nombreuses méthodes, nous l'appellerons.
Cette nouvelle méthode lancera une conception SQELLE et, pour des raisons de limites, elle devrait être privée:
ExtractUserFromResultSet privé (resultSet RS) lève SQLEXception {user user = new User (); User.SetId (Rs.GetInt ("ID")); user.setName (Rs.getString ("name")); user.setPass (Rs.GetString ("Pass")); user.Setage (Rs.GetInt ("Age")); Retour utilisateur;}Notre méthode ci-dessus doit être modifiée dans une nouvelle méthode:
Utilisateur public GetUser (int id) {connexion connection = connectionFactory.getConnection (); try {instruction stmt = connection.createStatement (); ResultSet rs = stmt.ExecuteQuery ("SELECT * FROM User Where id =" + id); if (Rs.Next ()) {return ExtractUserFromResultSet (RS); }} catch (sqlexception ex) {ex.printStackTrace (); } retourner null;}Méthode de connexion
L'opération de connexion est similaire. Nous voulons fournir des ID alternatifs d'utilisateur et de mot de passe, ce qui n'affectera pas la liste des paramètres et les instructions de requête. Si le nom d'utilisateur et le mot de passe sont corrects, cette méthode renvoie un utilisateur valide, autrement nul. Parce qu'il existe de nombreux paramètres, l'utilisation de Preadstatement sera plus utile.
L'utilisateur public getUserByUserAmandAdPassword (String User, String Pass) {Connector Connector = new Connector (); Connexion connexion = connecteur.getConnection (); essayez {préparéstatement ps = connection.preparestatement ("select * à partir de l'utilisateur où utilisateur =? et pass =?"); ps.SetString (1, utilisateur); ps.SetString (2, pass); ResultSet rs = ps.ExecuteQuery (); if (Rs.Next ()) {return ExtractUserFromResultSet (RS); }} catch (sqlexception ex) {ex.printStackTrace (); } retourner null;}Comment interroger tous les utilisateurs
Cette méthode renvoie tous les utilisateurs, nous devons donc les retourner dans un conteneur de type tableau. Mais parce que nous ne savons pas combien il y a de disques. Il serait préférable d'utiliser une collection telle que Set ou List:
public set getAllUsers () {Connector Connector = new Connector (); Connexion connexion = connecteur.getConnection (); try {instruction stmt = connection.createStatement (); ResultSet rs = stmt.ExecuteQuery ("SELECT * FROM USER"); Set users = new HashSet (); while (Rs.Next ()) {utilisateur utilisateur = extractUserFromResultSet (RS); users.add (utilisateur); } retourne les utilisateurs; } catch (sqlexception ex) {ex.printStackTrace (); } retourner null;}Méthode d'insertion
La méthode d'insertion prendra l'utilisateur en tant que paramètre et utilisera l'objet préparé PréparetStatement pour exécuter l'instruction SQL UPDATE. La méthode ExecuteUpdate renvoie le nombre de lignes affectées. Si nous ajoutons une seule ligne, cela signifie que la méthode doit retourner 1, si c'est le cas, nous retournons vrai, sinon nous retournons faux
insertUser booléen public (utilisateur utilisateur) {connecteur Connector = new Connector (); Connexion connexion = connecteur.getConnection (); essayez {préparéstatement ps = connexion.preparestatement ("INSERT INTO VALEURS (null,? ,?)"); ps.SetString (1, user.getName ()); ps.SetString (2, user.getPass ()); ps.SetInt (3, user.getage ()); int i = ps.ExecuteUpdate (); if (i == 1) {return true; }} catch (sqlexception ex) {ex.printStackTrace (); } return false;}Méthode de mise à jour
La méthode de mise à jour est similaire à la méthode d'insertion. Le seul changement est l'instruction SQL
public boolean updateUser (utilisateur utilisateur) {connecteur connecteur = nouveau connecteur (); Connexion connexion = connecteur.getConnection (); essayez {préparéStatement ps = connection.prepareStatement ("Update user set name =?, pass =?, Âge =? Où id =?"); ps.SetString (1, user.getName ()); ps.SetString (2, user.getPass ()); ps.SetInt (3, user.getage ()); ps.SetInt (4, user.getId ()); int i = ps.ExecuteUpdate (); if (i == 1) {return true; }} catch (sqlexception ex) {ex.printStackTrace (); } return false;}Supprimer la méthode
La méthode à supprimer est d'utiliser une question simple comme
Supprimer de l'utilisateur où id = 7
L'envoi de la requête avec le paramètre ID supprimera cet enregistrement. S'il est supprimé avec succès, 1 sera retourné
public boolean DeleteUser (int id) {Connector Connector = new Connector (); Connexion connexion = connecteur.getConnection (); try {instruction stmt = connection.createStatement (); int i = stmt.ExecuteUpDate ("Supprimer de l'utilisateur où id =" + id); if (i == 1) {return true; }} catch (sqlexception ex) {ex.printStackTrace (); } return false;}Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!