[JAVA] [Pour les super débutants] Super introduction à Mirage SQL

introduction

J'ai récemment appris à exécuter SQL dans une application Java sans l'écrire directement en Java. C'est comme un SQL soi-disant prêt à l'emploi, mais dans ma petite expérience de développement, l'environnement avait déjà été construit lorsque j'ai commencé le développement, et il y avait certaines choses que je ne comprenais pas bien, alors j'ai pris le temps de créer l'environnement. Je l'ai essayé. Il semble y avoir divers outils d'exécution Java SQL (OR mappers), et il y avait un article qui les comparait soigneusement, donc j'ai personnellement choisi le plus simple et j'ai joué avec. , Je présenterai la méthode de construction à ce moment-là.

Cette fois, je présenterai le SQL externe qui utilise une bibliothèque appelée MirageSQL. Il y en a beaucoup d'autres, veuillez donc voir ici.

1. Introduction à l'environnement

Tout d'abord, je présenterai l'environnement utilisé dans cet article.

1.1. Environnement de développement

L'environnement de développement est ici.

Catégorie mono version Remarques
Environnement de développement intégré Eclipse 64bit 4.4 Luna
Base de données Oracle Database 64bit 11g(11.2.0.1.0)

1.2. Tableau

Je n'écris pas de SQL compliqué, j'utilise donc une seule table. Décrivez la définition et le DDL.

Nom de colonne Type de données Nombre de chiffres PK NULL？
UNO NUMBER 4 〇 ×
UNAME VARCHAR2 10
AGE NUMBER 7,2
BDATE DATE 
■DDL
CREATE TABLE SCOTT.USR
(
	UNO                         NUMBER(4) NOT NULL,
	UNAME                       VARCHAR2(10),
	AGE                         NUMBER(7,2),
	BDATE                       DATE,
	CONSTRAINT PK_USER PRIMARY KEY (UNO)
);

2. Créez un projet

Utilisez Eclipse pour créer un exemple de projet. Il existe deux façons de créer l'environnement, l'une consiste à utiliser Maven et l'autre à le créer vous-même. Maven est pratique, mais il a quelques inconvénients auxquels je ne peux pas penser (du moins je le suis ...), donc je vais le construire moi-même cette fois.

Fichier> Nouveau> Projet Java Cliquez pour afficher l'assistant de création de projet.

p1.jpg

Entrez le nom du projet et passez au suivant. Le nom du projet peut être tout ce que vous voulez, mais dans l'exemple, il s'agit de "SampleMirageSQLBasic".

p2.jpg

Cliquez sur Créer un nouveau dossier source.

p3.jpg

Entrez les ressources pour le nom du dossier et vous avez terminé.

p4.jpg

Confirmez que le dossier «ressources» a été ajouté et complet.

p5.jpg

«Sample Mirage SQL Basic» a été ajouté à l'explorateur de packages. Il s'agit de l'arborescence juste après la création du projet.

p6.jpg

Ensuite, créez un dossier pour placer les bibliothèques dépendantes. Cliquez avec le bouton droit sur le projet> Nouveau> Cliquez sur le dossier.

p7.jpg

Entrez le nom du dossier dans la boîte de dialogue pour terminer. Le nom du dossier est "lib".

p8.jpg

Le dossier "lib" a été créé.

p9.jpg

Ensuite, déployez les bibliothèques nécessaires pour utiliser MirageSQL. Dans Maven, 6 jars sont ajoutés en tant que dépendances, mais si vous l'utilisez dans la configuration minimale, vous n'avez pas besoin de l'ajouter. Ajoutez uniquement ceux avec un cercle dans les colonnes requises du tableau suivant en tant que bibliothèques dépendantes. En même temps, la bibliothèque utilisée pour le journal d'application et le pilote JDBC utilisé pour la connexion à la base de données sont également ajoutés.

jar Obligatoire Remarques
javassist-3.21.0-GA.jar 〇
miragesql-2.0.0.jar 〇
slf4j-api-1.7.25.jar 〇
ognl-3.2.3.jar 〇
log4j-api-2.9.1.jar Utilisé pour la sortie du journal.
log4j-core-2.9.1.jar Utilisé pour la sortie du journal.
ojdbc8.jar Utilisé pour se connecter à DB.
junit-4.12.jar Maven l'ajoute, mais ce n'est pas obligatoire.
hamcrest-core-1.3.jar Maven l'ajoute, mais ce n'est pas obligatoire.

Placez la bibliothèque ci-dessus dans le dossier lib et ajoutez-la à votre chemin de construction. Sélectionnez la bibliothèque ajoutée et cliquez avec le bouton droit sur> Chemin de construction> Ajouter au chemin de construction.

p1.jpg

Tous les pots placés dans la bibliothèque de référence ont été ajoutés. À ce stade, la création du projet est terminée.

p2.jpg

Cette fois, je l'ai construit moi-même, mais pour référence, je vais décrire le contenu de la description de pom.xml lors de la construction avec Maven.

■pom.xml
<dependency>
	<groupId>com.miragesql</groupId>
	<artifactId>miragesql</artifactId>
	<version>2.1.0</version>
</dependency>

3. Mise en œuvre

Enfin, implémentez l'exemple de programme.

3.1. Paramètres de l'application

Configurez des applications telles que MirageSQL et des enregistreurs.

3.1.1. Paramètres de la base de données de destination de la connexion

Définissez la base de données à laquelle se connecter à partir de l'application. Placez la propriété qui définit la destination de la connexion dans le dossier «ressources» ajouté lors de la création du projet et définissez-le. La connexion à la base de données utilise la fonction MirageSQL, mais en raison de la limitation de la fonction, il semble que les informations de définition doivent être placées à la racine du dossier enregistré dans le chemin de classe. De plus, il semble que le nom du fichier devrait être "jdbc.properties".

■jdbc.properties
# -----------------------------------------------------------------

Paramètre de base de données de destination de connexion Mirage SQL

MirageSQL détecte automatiquement la destination de la connexion, donc

Veillez à utiliser le nom de fichier "jdbc.properties" dans le chemin de classe

Placez-le à la racine du dossier enregistré.

# -----------------------------------------------------------------

Pilote JDBC à utiliser

jdbc.driver=oracle.jdbc.driver.OracleDriver

Chaîne de caractères de connexion du DB de destination de connexion

jdbc.url=jdbc:oracle:thin:@localhost:1521/ORCL

Utilisateur connecté

jdbc.user=scott

#Mot de passe jdbc.password=tiger

3.1.2. Paramètres de sortie du journal

Définissez la sortie du journal des applications. Si vous souhaitez exporter le journal dans un fichier, veuillez restaurer le commentaire et l'utiliser.

■log4j2.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration>
<Configuration status="off">

<! - Paramètres de l'appender-> 

			</PatternLayout>
		</Console>

		<RollingFile name="FILE" fileName="./log/appLog.log" filePattern="appLog-%d{yyyy-MM-dd}-%i.log">
			<TimeBasedTriggeringPolicy />
<!--			<SizeBasedTriggeringPolicy size="100MB" /> -->
			<DefaultRolloverStrategy max="3"/>
		</RollingFile>
	</Appenders>

<! - Réglage de l'enregistreur utilisé pour la sortie->

3.2. Mise en œuvre du traitement des accès aux bases de données

Faisons un simple processus de recherche, d'insertion et de mise à jour.

3.2.1 Implémentation SQL

Implémentons la recherche SQL. SQL peut être placé n'importe où tant qu'il s'agit d'un dossier enregistré dans le chemin de classe, mais dans l'exemple, un nouveau dossier appelé «sql» est ajouté à «resources» et SQL y est placé. Chaque nom de fichier

ça ira.

■SelectUsr.sql
select
	*
from
	USR
/*-------------------------------------------

Ce SQL s'appelle 2WaySQL. Pour faire simple, 2WaySQL est un SQL qui peut être exécuté en collant le SQL tel quel, ou même si les paramètres sont variables dans l'application. Dans MirageSQL, vous pouvez implémenter un SQL dynamique qui active ou désactive les lignes inutiles à chaque fois, en fonction du contenu des paramètres spécifiés. Si vous intégrez l'instruction de contrôle dans le SQL sous la forme d'un commentaire, MirageSQL sera utile.

Implémentez INSERT et UPDATE avec le même SQL bidirectionnel. Placez-les dans l'ordre de SelectUsr.sql.

■InsertUsr.sql

3.2.2. Créer une entité

Implémentez une classe appelée entité qui sera le conteneur des données récupérées. Comme il ne s'agit que d'un conteneur pour les données, il n'est pas nécessaire de faire autre chose que le champ pour mettre l'enregistrement acquis et le processus pour l'acquérir et le définir. Dans l'exemple, la méthode toString est remplacée pour faciliter la sortie du résultat de l'acquisition. Faites un clic droit sur le dossier "src"> Nouveau> Ajouter la classe d'entité de la classe.

p3.jpg

Entrez le package, le nom et vous avez terminé. Les noms de package et de classe ne doivent pas nécessairement correspondre à l'exemple.

p01.jpg

Décrit l'implémentation de la classe ajoutée. Puisque nous recherchons toutes les colonnes cette fois, nous avons préparé un champ pour définir les valeurs de toutes les colonnes. Les colonnes définies dans la table réelle et les champs de la classe d'entité sont associés les uns aux autres à l'aide d'annotations, et les colonnes clés sont en outre annotées. En définissant des colonnes clés avec des annotations, l'insertion et la mise à jour peuvent être effectuées sans utiliser SQL.

■ Implémentation de la classe d'entité package jp.co.sample.tarosa.entity;

import com.miragesql.miragesql.annotation.Column;
import com.miragesql.miragesql.annotation.PrimaryKey;
import com.miragesql.miragesql.annotation.PrimaryKey.GenerationType;

/**

/** Nom d'utilisateur */ @Column(name = "UNAME") private String uName;

/ ** Âge * / @Column(name = "AGE") private Double age;

/** anniversaire */ @Column(name = "BDATE") private String bDate;

	/**

// Assemblage de représentation de chaîne StringBuilder sb = new StringBuilder(); sb.append(this.uNo); sb.append(", "); sb.append(this.uName); sb.append(", "); sb.append(this.age); sb.append(", "); sb.append(this.bDate);

		return new String(sb);
	}
}

3.2.3 Mise en œuvre du traitement d'accès à la base de données

Implémentez le traitement de l'accès à la base de données. Ajoutez la classe de la même manière que l'entité. Les noms de package et de classe sont les suivants.

Nom du paquet: jp.co.sample.tarosa.dao Nom de la classe: UsrDao

Nous implémenterons le traitement de recherche de base de données, d'insertion et de mise à jour dans cette classe.

■UsrDao.java
package jp.co.sample.tarosa.dao;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jp.co.sample.tarosa.entity.Usr;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import com.miragesql.miragesql.ClasspathSqlResource;
import com.miragesql.miragesql.SqlManager;
import com.miragesql.miragesql.SqlResource;
import com.miragesql.miragesql.session.Session;
import com.miragesql.miragesql.session.SessionFactory;

/**

// Génère un objet de session. // Récupère une instance à l'aide de la méthode de classe MirageSQL // ------------------------------------------------------------- Session session = SessionFactory.getSession(); SqlManager sqlManager = session.getSqlManager();

		// -------------------------------------------------------------

// Démarrer la session // Il existe également un moyen de travailler avec Spring // ------------------------------------------------------------- session.begin(); try { // ------------------------------------------------------------- // Lancer la recherche d'enregistrements par SQL // Générer des ressources SQL à l'aide des fonctionnalités Mirage SQL // ------------------------------------------------------------- SqlResource selecttUsrSql = new ClasspathSqlResource("sql/SelectUsr.sql");

			// -------------------------------------------------------------

// Générer des paramètres de condition de recherche // Indiquez ici le numéro d'employé // Spécifiez le paramètre sous forme de chaîne de caractères même s'il s'agit d'une valeur numérique // ------------------------------------------------------------- Map<String, Object> params = new HashMap<>(); params.put("uno", "9000");

			// -------------------------------------------------------------

// Génère du SQL en tant que ressource et passe les paramètres sous forme de carte. // ------------------------------------------------------------- Usr usr = sqlManager.getSingleResult(Usr.class, selecttUsrSql, params);

			// --------------------------------------------

// Sortie des résultats de la recherche // -------------------------------------------- System.out.println(usr); System.out.println("--------------------------------------------");

			// -------------------------------------------------------------

// Ensuite, définissez le nom d'utilisateur dans le paramètre // ------------------------------------------------------------- params = new HashMap<>(); params.put("uname", "%TARO");

			// -------------------------------------------------------------

// Obtient plusieurs résultats car le nom d'utilisateur ressemble à la recherche // ------------------------------------------------------------- List result = sqlManager.getResultList(Usr.class, selecttUsrSql, params);

			// -------------------------------------------------------------

// Affiche tous les résultats de la recherche // ------------------------------------------------------------- result.forEach(li -> System.out.println(li)); System.out.println("--------------------------------------------");

			// -------------------------------------------------------------

// Recherche tout sans paramètres // ------------------------------------------------------------- result = sqlManager.getResultList(Usr.class, selecttUsrSql);

			// -------------------------------------------------------------

// Affiche tous les résultats de la recherche // ------------------------------------------------------------- result.forEach(li -> System.out.println(li));

			// --------------------------------------------

// Session de validation // -------------------------------------------- session.commit(); } catch(Exception e) { logger.error ("Erreur DB", e);

// Revenir en arrière en cas d'erreur session.rollback(); } finally { // Assurez-vous de libérer la session session.release(); }

logger.info ("Processus de recherche de table de l'utilisateur final"); }

	/**

// Démarrer la session session.begin(); try { // ------------------------------------------------------------ // Génère une entité pour l'enregistrement à INSÉRER // INSERT à l'aide des méthodes Mirage SQL au lieu de SQL. // ------------------------------------------------------------ Usr usr = new Usr(new Long(1000), "test01", new Double(0), new SimpleDateFormat("yyyy-MM-dd").format(new Date())); SqlManager sqlManager = session.getSqlManager(); int result = sqlManager.insertEntity(usr); System.out.println ("Numéro d'inséré dans l'entité Nombre d'inséré:" + résultat);

			// ------------------------------------------------------------

// INSERT en utilisant SQL // MirageSQL n'a pas la capacité d'émettre INSERT SQL // INSERT en utilisant la méthode de mise à jour. // ------------------------------------------------------------ Map<String, Object> params = new HashMap<>(); // Définir les paramètres ainsi que la recherche params.put("uno", "1001"); SqlResource insertUsrSql = new ClasspathSqlResource("sql/insertUsr.sql"); result = session.getSqlManager().executeUpdate(insertUsrSql, params); System.out.println ("Nombre d'inséré par SQL Nombre d'inséré:" + résultat);

			session.commit();
		} catch(Exception e) {
			e.printStackTrace();
			session.rollback();
		} finally {
			session.release();
		}

logger.info ("Processus d'insertion de table de l'utilisateur final"); }

	/**

// Démarrer la session session.begin();

		try {
			// ------------------------------------------------------------

// Génère une entité pour l'enregistrement à UPDATE // INSERT à l'aide des méthodes Mirage SQL au lieu de SQL. // ------------------------------------------------------------ Usr usr = new Usr(new Long(1000), "test01", new Double(99), new SimpleDateFormat("yyyy-MM-dd").format(new Date())); SqlManager sqlManager = session.getSqlManager(); int result = sqlManager.updateEntity(usr); System.out.println ("Nombre de mises à jour:" + résultat);

			// ------------------------------------------------------------

// MISE À JOUR en utilisant SQL // MirageSQL n'a pas la capacité d'émettre INSERT SQL // INSERT en utilisant la méthode de recherche. // ------------------------------------------------------------ Map<String, Object> params = new HashMap<>(); // Définir les paramètres ainsi que la recherche params.put("uno", "1001"); params.put("age", "300"); SqlResource updateUsrSql = new ClasspathSqlResource("sql/updateUsr.sql"); result = session.getSqlManager().executeUpdate(updateUsrSql, params); System.out.println ("Nombre de mises à jour:" + résultat);

			session.commit();
		} catch(Exception e) {
			e.printStackTrace();
			session.rollback();
		} finally {
			session.release();
		}

logger.info ("Fin du processus de mise à jour de la table des employés"); } }

3.2.4. Mise en œuvre du traitement principal

Enfin, le processus principal qui exécute les processus mis en œuvre jusqu'à présent est mis en œuvre et terminé. Suivez la même procédure que précédemment pour ajouter une classe.

Nom du paquet: jp.co.sample.tarosa.main Nom de la classe: SampleMirageSQLBasic

■SampleMirageSQLBasic.java
import jp.co.sample.tarosa.dao.UsrDao;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**

// Génération d'objets d'accès aux données UsrDao dao = new UsrDao();

		// -------------------------------------------------------------

// Appel de traitement de recherche // ------------------------------------------------------------- dao.selectUsr();

		// -------------------------------------------------------------

// Appel d'insertion // ------------------------------------------------------------- dao.insertUsr();

		// -------------------------------------------------------------

// Mettre à jour l'appel de traitement // ------------------------------------------------------------- dao.updateUsr();

logger.info ("Traitement principal terminé"); } }

3.2.5. Achèvement de la mise en œuvre

À ce stade, la mise en œuvre de l'exemple de programme est terminée. Enfin, je listerai l'arborescence du projet terminé. Assurez-vous que votre projet possède l'arborescence suivante.

p04.jpg

■ Arbre (texte) Racine du projet ├─src │ └─jp │ └─co │ └─sample │ └─tarosa │ ├─dao │ │ UsrDao.java │ │ │ ├─entity │ │ Usr.java │ │ │ └─main │ SampleMirageSQLBasic.java │ ├─resources │ │ jdbc.properties │ │ log4j2.xml │ │ │ └─sql │ InsertUsr.sql │ SelectUsr.sql │ UpdateUsr.sql │ ├─lib │ javassist-3.21.0-GA.jar │ log4j-api-2.9.1.jar │ log4j-core-2.9.1.jar │ miragesql-2.0.0.jar │ ognl-3.2.3.jar │ ojdbc8.jar │ slf4j-api-1.7.25.jar │ └─log * Ajouté pour la sortie du journal

4. Exécuter

Faites un clic droit sur le projet> Exécuter> Exécuter l'exemple dans l'application Java.

p1.jpg

■ Sortie de la console [2018-09-10 21: 03: 04.829], INFO, main, jp.co.sample.tarosa.main.SampleMirageSQLBasic, traitement de démarrage principal [2018-09-10 21: 03: 04.833], INFO, main, jp.co.sample.tarosa.dao.UsrDao, le processus de recherche de la table des utilisateurs a commencé SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder". SLF4J: Defaulting to no-operation (NOP) logger implementation SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details. 9000, ATARO, 20.0, 1990-01-01 00:00:00.0 -------------------------------------------- 9003, DTARO, 30.0, 1980-08-01 00:00:00.0 9000, ATARO, 20.0, 1990-01-01 00:00:00.0 -------------------------------------------- 9003, DTARO, 30.0, 1980-08-01 00:00:00.0 9000, ATARO, 20.0, 1990-01-01 00:00:00.0 9001, BJIRO, 21.0, 1989-05-25 00:00:00.0 9002, CSABURO, 19.0, 1991-12-31 00:00:00.0 [2018-09-10 21: 03: 07.043], INFO, main, jp.co.sample.tarosa.dao.UsrDao, processus de recherche de la table des utilisateurs terminé [2018-09-10 21: 03: 07.043], INFO, main, jp.co.sample.tarosa.dao.UsrDao, le processus d'insertion de table utilisateur a commencé Nombre d'éléments insérés dans l'entité Nombre d'éléments insérés: 1 Nombre d'insertions dans SQL Nombre d'insertions: 1 [2018-09-10 21: 03: 07.168], INFO, main, jp.co.sample.tarosa.dao.UsrDao, processus d'insertion de table utilisateur terminé [2018-09-10 21: 03: 07.168], INFO, main, jp.co.sample.tarosa.dao.UsrDao, le processus de mise à jour de la table des utilisateurs a commencé Nombre de mises à jour: 1 Nombre de mises à jour: 1 [2018-09-10 21: 03: 07.250], INFO, main, jp.co.sample.tarosa.dao.UsrDao, processus de mise à jour de la table des employés terminé [2018-09-10 21: 03: 07.250], INFO, main, jp.co.sample.tarosa.main.SampleMirageSQLBasic, traitement principal terminé

■ Tableau avant mise à jour p02.jpg

■ Tableau mis à jour p03.jpg

À la fin

C'est la fin des bases de l'implémentation de SQL en dehors de MirageSQL. Cette fois, ce n'est que l'utilisation de base, donc j'ai tout mis en œuvre par moi-même, mais il existe également un moyen de coopérer avec spring pour le contrôle des transactions. Si vous utilisez spring, spring le fera pour vous sans avoir à implémenter vous-même le début de session, etc. Cela nécessite une connaissance du ressort séparément, je vais donc l'omettre dans cet article. Si j'ai un peu de temps libre, j'écrirai un article sur la manière de le mettre en œuvre en coopération avec Spring, alors attendez un peu pour savoir comment coopérer avec Spring.

EX. Article de référence

Voici quelques articles de référence qui m'ont aidé à étudier Mirage SQL et même à écrire cet article. Je remercie l'auteur et l'administrateur d'avoir rédigé l'article de référence.

Recommended Posts

[Pour les super débutants] Super introduction à Mirage SQL
[Pour les super débutants] Super introduction à DBUnit
[Pour les super débutants] Ant super introduction
[Pour les super débutants] Super introduction à Maven
[Pour les super débutants] Struts2 Super Primer - Édition 2018
Apprenons l'instruction SQL SELECT pour les débutants
[Pour les super super débutants] Qu'est-ce que l'orientation objet?
Super introduction de Ractor
[Pour les super débutants] Comment utiliser l'autofocus: vrai
[Introduction à Java] Bases de l'arithmétique Java (pour les débutants)
Utilisons Java New FileIO! (Introduction, pour les débutants)
Introduction à Java pour les débutants Connaissance de base du langage Java ①
Introduction super facile Groovy
Comment utiliser GitHub pour les super débutants (développement d'équipe)
Exécution de débogage Java [pour les débutants Java]
[Java] Instruction de base pour les débutants
(Pour les débutants) [Rails] Installer Devise
Plus utilisable Enumerable pour les débutants
Java pour les débutants, masquage des données
Application Java pour les débutants: stream