[JAVA] [Für Super-Anfänger] Mirage SQL Super-Einführung

Einführung

Ich habe kürzlich gelernt, wie man SQL in einer Java-Anwendung ausführt, ohne es direkt in Java zu schreiben. Es ist wie ein sogenanntes Out-of-the-Box-SQL, aber in meiner kleinen Entwicklungserfahrung war die Umgebung bereits zu Beginn der Entwicklung erstellt worden. Daher gab es einige Dinge, die ich nicht gut verstand, und ich nahm mir einige Zeit, um die Umgebung zu erstellen. Ich versuchte es. Es scheint verschiedene Java SQL-Ausführungstools (OR-Mapper) zu geben, und es gab einen Artikel, in dem sie sorgfältig verglichen wurden. Deshalb habe ich persönlich das einfachste ausgewählt und damit gespielt. Ich werde zu diesem Zeitpunkt die Bauweise vorstellen.

Dieses Mal werde ich das externe SQL vorstellen, das eine Bibliothek namens MirageSQL verwendet. Es gibt viele andere, siehe hier.

1. Einführung in die Umwelt

Zunächst werde ich die in diesem Artikel verwendete Umgebung vorstellen.

1.1. Entwicklungsumgebung

Die Entwicklungsumgebung ist hier.

1.2. Tabelle

Ich schreibe kein kompliziertes SQL, daher verwende ich eine einzelne Tabelle. Beschreiben Sie die Definition und DDL.

■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. Erstellen Sie ein Projekt

Verwenden Sie Eclipse, um ein Beispielprojekt zu erstellen. Es gibt zwei Möglichkeiten, die Umgebung zu erstellen: Die eine besteht darin, Maven zu verwenden, und die andere darin, sie selbst zu erstellen. Maven ist praktisch, hat aber einige Nachteile, an die ich nicht denken kann (zumindest bin ich ...), also werde ich es dieses Mal selbst bauen.

Datei> Neu> Java-Projekt Klicken Sie hier, um den Assistenten zum Erstellen von Projekten anzuzeigen.

Geben Sie den Projektnamen ein und fahren Sie mit dem nächsten fort. Der Projektname kann beliebig sein, im Beispiel lautet er jedoch "SampleMirageSQLBasic".

Klicken Sie auf Neuen Quellordner erstellen.

Geben Sie Ressourcen für den Ordnernamen ein und Sie sind fertig.

Stellen Sie sicher, dass der Ordner "Ressourcen" hinzugefügt und vollständig ist.

"Beispiel für Mirage SQL Basic" wurde dem Paket-Explorer hinzugefügt. Dies ist der Baum direkt nach dem Erstellen des Projekts.

Erstellen Sie als Nächstes einen Ordner, um die abhängigen Bibliotheken zu platzieren. Klicken Sie mit der rechten Maustaste auf das Projekt> Neu> Klicken Sie auf den Ordner.

Geben Sie den Ordnernamen in das Dialogfeld ein, um den Vorgang abzuschließen. Der Ordnername lautet "lib".

Der Ordner "lib" wurde erstellt.

Stellen Sie als Nächstes die Bibliotheken bereit, die für die Verwendung von MirageSQL erforderlich sind. In Maven werden 6 Gläser als Abhängigkeiten hinzugefügt. Wenn Sie sie jedoch in der Mindestkonfiguration verwenden, müssen Sie sie nicht hinzufügen. Fügen Sie nur diejenigen mit einem Kreis in den erforderlichen Spalten in der folgenden Tabelle als abhängige Bibliotheken hinzu. Gleichzeitig werden die für das App-Protokoll verwendete Bibliothek und der für die DB-Verbindung verwendete JDBC-Treiber hinzugefügt.

Legen Sie die obige Bibliothek in den Ordner lib und fügen Sie sie Ihrem Erstellungspfad hinzu. Wählen Sie die hinzugefügte Bibliothek aus und klicken Sie mit der rechten Maustaste auf> Erstellungspfad> Zum Erstellungspfad hinzufügen.

Alle in der Referenzbibliothek platzierten Gläser wurden hinzugefügt. Zu diesem Zeitpunkt ist die Projekterstellung abgeschlossen.

Dieses Mal habe ich es selbst erstellt, aber als Referenz werde ich den Beschreibungsinhalt von pom.xml beim Erstellen mit Maven beschreiben.

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

3. Implementierung

Implementieren Sie abschließend das Beispielprogramm.

3.1. Anwendungseinstellungen

Richten Sie Anwendungen wie MirageSQL und Logger ein.

3.1.1. Einstellungen der Verbindungsziel-DB

Stellen Sie die Datenbank ein, zu der eine Verbindung über die Anwendung hergestellt werden soll. Platzieren Sie die Eigenschaft, die das Verbindungsziel definiert, im Ordner "Ressourcen", der beim Erstellen des Projekts hinzugefügt wurde, und legen Sie sie fest. Die Verbindung zur Datenbank verwendet die MirageSQL-Funktion. Aufgrund der Einschränkung der Funktion müssen die Definitionsinformationen jedoch im Stammverzeichnis des im Klassenpfad registrierten Ordners abgelegt werden. Außerdem sollte der Dateiname "jdbc.properties" sein.

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

Mirage SQL-Verbindungsziel-DB-Einstellung

MirageSQL erkennt das Verbindungsziel automatisch

Stellen Sie sicher, dass Sie den Dateinamen "jdbc.properties" im Klassenpfad verwenden

Platzieren Sie es im Stammverzeichnis des registrierten Ordners.

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

Zu verwendender JDBC-Treiber

jdbc.driver=oracle.jdbc.driver.OracleDriver

Verbindungszeichenfolge der Verbindungsziel-DB

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

#Verbundener Benutzer jdbc.user=scott #Passwort jdbc.password=tiger

3.1.2. Protokollausgabeeinstellungen

Legen Sie die Ausgabe des Anwendungsprotokolls fest. Wenn Sie das Protokoll in eine Datei ausgeben möchten, stellen Sie den Kommentar wieder her und verwenden Sie ihn.

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

<! - Appender-Einstellungen->

			</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>

<! - Einstellen des für die Ausgabe verwendeten Loggers->

3.2. Implementierung der Datenbankzugriffsverarbeitung

Lassen Sie uns einen einfachen Such-, Einfüge- und Aktualisierungsprozess durchführen.

3.2.1 SQL-Implementierung

Lassen Sie uns Such-SQL implementieren. SQL kann an einer beliebigen Stelle platziert werden, solange es sich um einen im Klassenpfad registrierten Ordner handelt. Im Beispiel wird jedoch ein neuer Ordner mit dem Namen "sql" zu "resources" hinzugefügt und SQL dort platziert. Jeder Dateiname

• SelectUsr.sql
• InsertUsr.sql
• UpdateUsr.sql

Wird besorgt.

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

• Von BEGIN bis END
• Wenn die gesamte Verarbeitung in der Box weg ist
• Weil es als SQL-Syntax seltsam sein wird
• Dieser Abschnitt verschwindet automatisch. --------------------------------------------/ /BEGIN/ where /-------------------------------------------------
• Nur wenn der Parameter uno nicht null ist
• Ein zeilenfähiges Steuerelement.
• In Mirage SQL sowohl dynamische SQL-Steuerung als auch Parameterdefinition
• Schreiben Sie im Kommentarformat. --------------------------------------------------*/ /IF uno != null/ UNO = /uno/0 /END/ /IF uname != null/ and UNAME like /uname/'' /END/ /END/

Diese SQL heißt 2WaySQL. Einfach ausgedrückt ist 2WaySQL eine SQL, die ausgeführt werden kann, indem die SQL unverändert eingefügt wird oder selbst wenn die Parameter in der Anwendung variabel sind. In MirageSQL können Sie dynamisches SQL implementieren, das je nach Inhalt der angegebenen Parameter jedes Mal unnötige Zeilen aktiviert oder deaktiviert. Wenn Sie die Steueranweisung in Form eines Kommentars in SQL einbetten, ist MirageSQL hilfreich.

Implementieren Sie INSERT und UPDATE mit demselben 2-Wege-SQL. Platzieren Sie sie in der Reihenfolge SelectUsr.sql.

■InsertUsr.sql

• Neuen Datensatz in Benutzertabelle einfügen insert into USR ( UNO , UNAME , AGE , BDATE ) values ( /UNO/1000 -- UNO NUMBER(4) NOT NULL , 'test02' -- ENAME VARCHAR2(10) , 0 -- AGE NUMBER(7,2) , SYSDATE -- BDATE DATE )

  ■UpdateUsr.sql

• Benutzertabelle aktualisieren update USR set AGE = /age/0 where UNO = /uno/1000

3.2.2. Entität erstellen

Implementieren Sie eine Klasse namens Entität, die der Container für die abgerufenen Daten ist. Da dies nur ein Container für Daten ist, müssen Sie nichts anderes tun als das Feld, um den erfassten Datensatz abzulegen, und den Prozess, um ihn zu erfassen und festzulegen. Im Beispiel wird die toString-Methode überschrieben, um die Ausgabe des Erfassungsergebnisses zu vereinfachen. Klicken Sie mit der rechten Maustaste auf den Ordner "src"> Neu> Fügen Sie die Entitätsklasse aus der Klasse hinzu.

Geben Sie das Paket, den Namen und fertig. Die Paket- und Klassennamen müssen nicht mit dem Beispiel übereinstimmen.

Beschreibt die Implementierung der hinzugefügten Klasse. Dieses Mal werden wir alle Spalten durchsuchen, daher haben wir ein Feld vorbereitet, um die Werte aller Spalten festzulegen. Die in der tatsächlichen Tabelle definierten Spalten und die Felder der Entitätsklasse werden mithilfe von Anmerkungen miteinander verknüpft, und die Schlüsselspalten werden zusätzlich mit Anmerkungen versehen. Durch Definieren von Schlüsselspalten mit Anmerkungen können Einfügen und Aktualisieren ohne Verwendung von SQL durchgeführt werden.

■ Implementierung der Entitätsklasse 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;

/**

• [Benutzertabellenentität]
  *
  

• Verwenden Sie Anmerkungen, um DB-Spalten und -Felder abzugleichen.
  • @author tarosa0001 */ public class Usr { / ** Benutzernummer * / @PrimaryKey(generationType = GenerationType.APPLICATION) @Column(name = "UNO") private Long uNo;

/** Nutzername */ @Column(name = "UNAME") private String uName;

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

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

	/**

• [Konstruktor]
  *
  

• Verwenden Sie Argumente, um Felder für die Benutzerentität festzulegen.

• @param uNo Benutzernummer

• @param uName Benutzername

• @param Alter Alter

• @param bDate Geburtstag */ public Usr(Long uNo, String uName, Double age, String bDate) { this.uNo = uNo; this.uName = uName; this.age = age; this.bDate = bDate; }

   /**
  

• [Prozess zur Erfassung der Benutzernummer]
  

• Holen Sie sich die Benutzernummer.
  

• @return uKeine Benutzernummer */ public Long getuNo() { return uNo; }

   /**
  

• [Einstellungsprozess für Benutzernummer]
  

• Stellen Sie die Benutzernummer ein.
  

• @param uNo Benutzernummer */ public void setuNo(Long uNo) { this.uNo = uNo; }

   /**
  

• [Prozess zur Erfassung des Benutzernamens]
  

• Holen Sie sich den Benutzernamen.
  

• @return uName Benutzername */ public String getuName() { return uName; }

   /**
  

• [Einstellungsprozess für Benutzername]
  

• Legen Sie den Benutzernamen fest.
  

• @param uName Benutzername */ public void setuName(String uName) { this.uName = uName; }

   /**
  

• [Alterserfassungsprozess]
  

• Holen Sie sich Alter.
  

• @return age age */ public Double getAge() { return age; }

   /**
  

• [Alterseinstellungsprozess]
  

• Stellen Sie das Alter ein.
  

• @param Alter Alter */ public void setAge(Double age) { this.age = age; }

   /**
  

• [Erwerbsvorgang zum Geburtstag]
  

• Holen Sie sich einen Geburtstag.
  

• @return bDate Geburtstag */ public String getbDate() { return bDate; }

   /**
  

• [Geburtstagseinstellungsprozess]
  

• Stellen Sie den Geburtstag ein.
  

• @param bDate Geburtstag */ public void setbDate(String bDate) { this.bDate = bDate; }

   /**
    * {@inheritDoc}
    */
   @Override
   public String toString() {
  

// String-Darstellungsassembly 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 Implementierung der Datenbankzugriffsverarbeitung

Implementieren Sie die Datenbankzugriffsverarbeitung. Fügen Sie die Klasse auf die gleiche Weise wie die Entität hinzu. Die Paket- und Klassennamen lauten wie folgt.

Paketname: jp.co.sample.tarosa.dao Klassenname: UsrDao

In dieser Klasse werden wir die DB-Such-, Einfüge- und Aktualisierungsverarbeitung implementieren.

■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;

/**

• [Benutzertabellenzugriffsklasse]
  *
  

• Eine Klasse, die Operationen an Benutzertabellen ausführt.

  • @author tarosa0001 */ public class UsrDao { / ** Logger * / private Logger logger = LogManager.getLogger(UsrDao.class);

    /**

• [Benutzertabellensuchprozess]
  *
  

• Durchsuchen Sie die Benutzertabelle. */ public void selectUsr() { logger.info ("Benutzertabellensuchprozess starten");

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

// Sitzungsobjekt generieren. // Eine Instanz mit der MirageSQL-Klassenmethode abrufen // ------------------------------------------------------------- Session session = SessionFactory.getSession(); SqlManager sqlManager = session.getSqlManager();

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

// Sitzung starten // Es gibt auch eine Möglichkeit, mit Spring zu arbeiten // ------------------------------------------------------------- session.begin(); try { // ------------------------------------------------------------- // Datensatzsuche mit SQL starten // Generieren Sie SQL-Ressourcen mit Mirage SQL-Funktionen // ------------------------------------------------------------- SqlResource selecttUsrSql = new ClasspathSqlResource("sql/SelectUsr.sql");

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

// Suchbedingungsparameter generieren // Geben Sie hier die Mitarbeiternummer an // Geben Sie den Parameter als Zeichenfolge an, auch wenn es sich um einen numerischen Wert handelt // ------------------------------------------------------------- Map<String, Object> params = new HashMap<>(); params.put("uno", "9000");

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

// SQL als Ressource generieren und Parameter als Map übergeben. // ------------------------------------------------------------- Usr usr = sqlManager.getSingleResult(Usr.class, selecttUsrSql, params);

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

// Suchergebnisse ausgeben // -------------------------------------------- System.out.println(usr); System.out.println("--------------------------------------------");

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

// Als nächstes setzen Sie den Benutzernamen in den Parameter // ------------------------------------------------------------- params = new HashMap<>(); params.put("uname", "%TARO");

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

// Mehrere Ergebnisse erhalten, da der Benutzername der Suche entspricht // ------------------------------------------------------------- List result = sqlManager.getResultList(Usr.class, selecttUsrSql, params);

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

// Alle Suchergebnisse ausgeben // ------------------------------------------------------------- result.forEach(li -> System.out.println(li)); System.out.println("--------------------------------------------");

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

// Alle ohne Parameter suchen // ------------------------------------------------------------- result = sqlManager.getResultList(Usr.class, selecttUsrSql);

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

// Alle Suchergebnisse ausgeben // ------------------------------------------------------------- result.forEach(li -> System.out.println(li));

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

// Sitzung festschreiben // -------------------------------------------- session.commit(); } catch(Exception e) { logger.error ("DB-Fehler", e);

// Im Fehlerfall zurücksetzen session.rollback(); } finally { // Stellen Sie sicher, dass Sie die Sitzung freigeben session.release(); }

logger.info ("Suchprozess für Endbenutzertabellen"); }

	/**

• [Einfügen der Benutzertabelle]
  *
  

• Fügen Sie einen Datensatz in die Benutzertabelle ein. */ public void insertUsr() { logger.info ("Einfügen der Benutzertabelle starten");

   	Session session = SessionFactory.getSession();
  

// Sitzung starten session.begin(); try { // ------------------------------------------------------------ // Generiere eine Entität für den Datensatz zu INSERT // INSERT mit Mirage SQL-Methoden anstelle von 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 ("Anzahl der in die Entität eingefügten Anzahl der eingefügten:" + Ergebnis);

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

// INSERT mit SQL // MirageSQL kann INSERT SQL nicht ausgeben // INSERT mit der Update-Methode. // ------------------------------------------------------------ Map<String, Object> params = new HashMap<>(); // Parameter einstellen sowie suchen params.put("uno", "1001"); SqlResource insertUsrSql = new ClasspathSqlResource("sql/insertUsr.sql"); result = session.getSqlManager().executeUpdate(insertUsrSql, params); System.out.println ("Anzahl der von SQL eingefügten Anzahl der eingefügten:" + Ergebnis);

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

logger.info ("Einfügen von Endbenutzertabellen"); }

	/**

• [Aktualisierung der Benutzertabelle]
  *
  

• Aktualisieren Sie die Datensätze in der Benutzertabelle. */ public void updateUsr() { logger.info ("Aktualisierung der Benutzertabelle starten");

   	Session session = SessionFactory.getSession();
  

// Sitzung starten session.begin();

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

// Generiere eine Entität für den Datensatz zu UPDATE // INSERT mit Mirage SQL-Methoden anstelle von 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 ("Update count:" + Ergebnis);

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

// UPDATE mit SQL // MirageSQL kann INSERT SQL nicht ausgeben // INSERT mit der Suchmethode. // ------------------------------------------------------------ Map<String, Object> params = new HashMap<>(); // Parameter einstellen sowie suchen params.put("uno", "1001"); params.put("age", "300"); SqlResource updateUsrSql = new ClasspathSqlResource("sql/updateUsr.sql"); result = session.getSqlManager().executeUpdate(updateUsrSql, params); System.out.println ("Update count:" + Ergebnis);

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

logger.info ("Ende der Aktualisierung der Mitarbeitertabelle"); } }

3.2.4 Implementierung der Hauptverarbeitung

Schließlich wird der Hauptprozess, der die bisher implementierten Prozesse ausführt, implementiert und abgeschlossen. Gehen Sie wie zuvor vor, um eine Klasse hinzuzufügen.

Paketname: jp.co.sample.tarosa.main Klassenname: SampleMirageSQLBasic

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

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

/**

• [Hauptklasse des Mirage SQL-Beispiels]
  *
  

• Mirage Eine Klasse mit SQL-Beispiel Hauptverarbeitung.
  • @author tarosa0001 */ public class SampleMirageSQLBasic { / ** Logger * / private static Logger logger = LogManager.getLogger(SampleMirageSQLBasic.class);

    /**

• [Hauptverarbeitung]
  *
  

• Hauptverarbeitung des Mirage SQL-Beispiels.
  
• @param args Befehlsargument */ public static void main(String[] args) { logger.info ("Hauptverarbeitung gestartet");

// Datenzugriffsobjektgenerierung UsrDao dao = new UsrDao();

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

// Suchverarbeitungsaufruf // ------------------------------------------------------------- dao.selectUsr();

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

// Einfügungsaufruf // ------------------------------------------------------------- dao.insertUsr();

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

// Verarbeitungsaufruf aktualisieren // ------------------------------------------------------------- dao.updateUsr();

logger.info ("Hauptverarbeitung beendet"); } }

3.2.5 Abschluss der Implementierung

Zu diesem Zeitpunkt ist die Implementierung des Beispielprogramms abgeschlossen. Abschließend werde ich den Baum des abgeschlossenen Projekts auflisten. Stellen Sie sicher, dass Ihr Projekt den folgenden Baum hat.

■ Baum (Text) Projektstamm ├─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 * Für die Protokollausgabe hinzugefügt

4. Führen Sie aus

Klicken Sie mit der rechten Maustaste auf das Projekt> Ausführen> Beispiel in der Java-Anwendung ausführen.

■ Konsolenausgabe [2018-09-10 21: 03: 04.829], INFO, main, jp.co.sample.tarosa.main.SampleMirageSQLBasic, Main Starten Sie die Verarbeitung [2018-09-10 21: 03: 04.833], INFO, main, jp.co.sample.tarosa.dao.UsrDao, Suchvorgang für Benutzertabellen gestartet 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, Benutzertabellensuchvorgang abgeschlossen [2018-09-10 21: 03: 07.043], INFO, main, jp.co.sample.tarosa.dao.UsrDao, Einfügungsprozess für Benutzertabelle gestartet Anzahl der in die Entität eingefügten Elemente Anzahl der eingefügten Elemente: 1 Anzahl der Einfügungen in SQL Anzahl der Einfügungen: 1 [2018-09-10 21: 03: 07.168], INFO, main, jp.co.sample.tarosa.dao.UsrDao, Vorgang zum Einfügen der Benutzertabelle abgeschlossen [2018-09-10 21: 03: 07.168], INFO, main, jp.co.sample.tarosa.dao.UsrDao, Aktualisierung der Benutzertabelle gestartet Anzahl der Updates: 1 Anzahl der Updates: 1 [2018-09-10 21: 03: 07.250], INFO, main, jp.co.sample.tarosa.dao.UsrDao, Aktualisierung der Mitarbeitertabelle abgeschlossen [2018-09-10 21: 03: 07.250], INFO, main, jp.co.sample.tarosa.main.SampleMirageSQLBasic, Hauptverarbeitung abgeschlossen

■ Tabelle vor dem Update

■ Aktualisierte Tabelle

Am Ende

Dies ist das Ende der Grundlagen der Implementierung von externem SQL mit MirageSQL. Dieses Mal ist es nur die grundlegende Verwendung, also habe ich alles selbst implementiert, aber es gibt auch eine Möglichkeit, mit spring bei der Transaktionskontrolle zusammenzuarbeiten. Wenn Sie spring verwenden, erledigt spring dies für Sie, ohne dass Sie den Sitzungsstart usw. selbst implementieren müssen. Dies erfordert die separate Kenntnis des Frühlings, daher werde ich ihn in diesem Artikel weglassen. Wenn ich etwas Freizeit habe, werde ich einen Artikel darüber schreiben, wie man es in Zusammenarbeit mit dem Frühling umsetzt. Bitte warten Sie eine Weile, wie Sie mit dem Frühling zusammenarbeiten können.

EX. Referenzartikel

Hier sind einige Referenzartikel, die mir geholfen haben, Mirage SQL zu studieren und sogar diesen Artikel zu schreiben. Ich bin dem Autor und dem Administrator für das Schreiben des Referenzartikels dankbar.

• Mirage SQL ~ Datenzugriffsbibliothek für Java mit 2Way SQL
• Offizielles Mirage SQL-Wiki