Spring JDBC - Kurzanleitung
Während der Arbeit mit Datenbanken mit einfachem altem JDBC wird es umständlich, unnötigen Code zu schreiben, um Ausnahmen zu behandeln, Datenbankverbindungen zu öffnen und zu schließen usw. Spring JDBC Framework kümmert sich jedoch um alle Details auf niedriger Ebene, beginnend mit dem Öffnen der Verbindung, dem Vorbereiten und Ausführen der SQL-Anweisung, Verarbeiten von Ausnahmen, Behandeln von Transaktionen und endgültiges Schließen der Verbindung.
Sie müssen lediglich die Verbindungsparameter definieren, die auszuführende SQL-Anweisung angeben und die erforderliche Arbeit für jede Iteration ausführen, während Sie Daten aus der Datenbank abrufen.
Spring JDBC bietet verschiedene Ansätze und entsprechend unterschiedliche Klassen für die Schnittstelle mit der Datenbank. In diesem Tutorial werden wir den klassischen und beliebtesten Ansatz verwenden, der die JDBC-Vorlagenklasse des Frameworks verwendet. Dies ist die zentrale Framework-Klasse, die die gesamte Datenbankkommunikation und Ausnahmebehandlung verwaltet.
JDBC-Vorlagenklasse
Die JDBC-Vorlagenklasse führt SQL-Abfragen aus, aktualisiert Anweisungen und Aufrufe gespeicherter Prozeduren, führt eine Iteration über ResultSets durch und extrahiert zurückgegebene Parameterwerte. Außerdem werden JDBC-Ausnahmen abgefangen und in die generische, informativere Ausnahmehierarchie übersetzt, die im Paket org.springframework.dao definiert ist.
Instanzen der JDBC-Vorlagenklasse sind nach der Konfiguration threadsicher. Sie können also eine einzelne Instanz einer JDBC-Vorlage konfigurieren und diese gemeinsam genutzte Referenz dann sicher in mehrere DAOs einfügen.
Bei Verwendung der JDBC-Vorlagenklasse wird häufig eine DataSource in Ihrer Spring-Konfigurationsdatei konfiguriert und diese gemeinsam genutzte DataSource-Bean dann in Ihre DAO-Klassen in Abhängigkeit injiziert. Die JDBC-Vorlage wird im Setter für die DataSource erstellt.
Datenzugriffsobjekt (DAO)
DAO steht für Data Access ObjectDies wird häufig für die Datenbankinteraktion verwendet. DAOs bieten eine Möglichkeit zum Lesen und Schreiben von Daten in die Datenbank und sollten diese Funktionalität über eine Schnittstelle verfügbar machen, über die der Rest der Anwendung auf sie zugreifen kann.
Die DAO-Unterstützung (Data Access Object) im Frühjahr erleichtert die konsistente Arbeit mit Datenzugriffstechnologien wie JDBC, Hibernate, JPA oder JDO.
Dieses Kapitel führt Sie durch den Prozess des Einrichtens von Spring-AOP auf Windows- und Linux-basierten Systemen. Spring AOP kann einfach installiert und in Ihre aktuelle Java-Umgebung und MAVEN integriert werden, indem einige einfache Schritte ohne komplexe Einrichtungsverfahren ausgeführt werden. Während der Installation ist eine Benutzerverwaltung erforderlich.
System Anforderungen
| JDK | Java SE 2 JDK 1.5 oder höher |
| Erinnerung | 1 GB RAM (empfohlen) |
| Festplattenplatz | Keine Mindestanforderung |
| Betriebssystemversion | Windows XP oder höher, Linux |
Fahren wir nun mit den Schritten zur Installation von Spring AOP fort.
Schritt 1 - Überprüfen Sie Ihre Java-Installation
Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie je nach Plattform, auf der Sie arbeiten, einen der beiden folgenden Befehle aus.
Wenn die Java-Installation ordnungsgemäß durchgeführt wurde, werden die aktuelle Version und die Spezifikation Ihrer Java-Installation angezeigt. Eine Beispielausgabe ist in der folgenden Tabelle angegeben.
| Plattform | Befehl | Beispielausgabe |
|---|---|---|
| Windows | Öffnen Sie die Befehlskonsole und geben Sie - ein \>java -version |
Java-Version "1.7.0_60" Java (TM) SE-Laufzeitumgebung (Build 1.7.0_60-b19) Java Hotspot (TM) 64-Bit-Server-VM (Build 24.60-b09, gemischter Modus) |
| Linux | Befehlsterminal öffnen und - eingeben $java -version |
Java-Version "1.7.0_25" Öffnen Sie die JDK-Laufzeitumgebung (rhel-2.3.10.4.el6_4-x86_64). Öffnen Sie die JDK 64-Bit-Server-VM (Build 23.7-b01, gemischter Modus). |
Wir gehen davon aus, dass die Leser dieses Tutorials Java SDK Version 1.7.0_60 auf dem i-System installiert haben. Falls Sie kein Java SDK haben, laden Sie die aktuelle Version von herunterhttps://www.oracle.com/technetwork/java/javase/downloads/index.html und habe es installiert.
Schritt 2 - Legen Sie Ihre Java-Umgebung fest
Stellen Sie die Umgebungsvariable JAVA_HOME so ein, dass sie auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel,
| Plattform | Beschreibung |
|---|---|
| Windows | Setzen Sie JAVA_HOME auf C: \ ProgramFiles \ java \ jdk1.7.0_60 |
| Linux | Exportieren Sie JAVA_HOME = / usr / local / java-current |
Hängen Sie den vollständigen Pfad des Java-Compiler-Speicherorts an den Systempfad an.
| Plattform | Beschreibung |
|---|---|
| Windows | Fügen Sie die Zeichenfolge "C: \ Programme \ Java \ jdk1.7.0_60 \ bin" an das Ende der Systemvariablen PATH an. |
| Linux | Export PATH = $ PATH: $ JAVA_HOME / bin / |
Führen Sie den Befehl aus java -version an der Eingabeaufforderung wie oben erläutert.
Schritt 3 - Laden Sie das Maven-Archiv herunter
Laden Sie Maven 3.3.3 von herunter https://maven.apache.org/download.cgi
| Betriebssystem | Archivname |
|---|---|
| Windows | apache-maven-3.3.3-bin.zip |
| Linux | apache-maven-3.3.3-bin.tar.gz |
| Mac | apache-maven-3.3.3-bin.tar.gz |
Schritt 4 - Extrahieren Sie das Maven-Archiv
Extrahieren Sie das Archiv in das Verzeichnis, in dem Sie Maven 3.3.3 installieren möchten. Das Unterverzeichnis apache-maven-3.3.3 wird aus dem Archiv erstellt.
| Betriebssystem | Standort (kann je nach Installation unterschiedlich sein) |
|---|---|
| Windows | C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3 |
| Linux | / usr / local / apache-maven |
| Mac | / usr / local / apache-maven |
Schritt 5 - Maven-Umgebungsvariablen festlegen
Fügen Sie M2_HOME, M2, MAVEN_OPTS zu Umgebungsvariablen hinzu.
| Betriebssystem | Ausgabe |
|---|---|
| Windows | Legen Sie die Umgebungsvariablen mithilfe der Systemeigenschaften fest. M2_HOME = C: \ Programme \ Apache Software Foundation \ apachemaven-3.3.3 M2 =% M2_HOME% \ bin MAVEN_OPTS = -Xms256m -Xmx512m |
| Linux | Öffnen Sie das Befehlsterminal und legen Sie die Umgebungsvariablen fest. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 export M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m |
| Mac | Öffnen Sie das Befehlsterminal und legen Sie die Umgebungsvariablen fest. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 export M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m |
Schritt 6 - Hinzufügen des Speicherorts des Maven Bin-Verzeichnisses zum Systempfad
Hängen Sie nun die Variable M2 an den Systempfad an.
| Betriebssystem | Ausgabe |
|---|---|
| Windows | Hängen Sie die Zeichenfolge% M2% an das Ende der Systemvariablen Path an. |
| Linux | export PATH = $ M2: $ PATH |
| Mac | export PATH = $ M2: $ PATH |
Schritt 7 - Überprüfen Sie die Maven-Installation
Öffnen Sie nun die Konsole und führen Sie Folgendes aus mvn Befehl.
| Betriebssystem | Aufgabe | Befehl |
|---|---|---|
| Windows | Öffnen Sie die Befehlskonsole | c: \> mvn --version |
| Linux | Öffnen Sie das Befehlsterminal | $ mvn --version |
| Mac | Terminal öffnen | Maschine: <joseph $ mvn --version |
Überprüfen Sie abschließend die Ausgabe der oben genannten Befehle, die wie folgt aussehen sollten:
| Betriebssystem | Ausgabe |
|---|---|
| Windows | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Maven-Startseite: C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3 Java-Version: 1.7.0_75, Hersteller: Oracle Corporation Java-Startseite: C: \ Programme \ Java \ jdk1.7.0_75 \ jre Standardgebietsschema: en_US, Plattformcodierung: Cp1252 |
| Linux | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Maven nach Hause: /usr/local/apache-maven/apache-maven-3.3.3 Java-Version: 1.7.0_75, Hersteller: Oracle Corporation Java-Startseite: /usr/local/java-current/jdk1.7.0_75/jre |
| Mac | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Maven nach Hause: /usr/local/apache-maven/apache-maven-3.3.3 Java-Version: 1.7.0_75, Hersteller: Oracle Corporation Java-Startseite: /Library/Java/Home/jdk1.7.0_75/jre |
Schritt 8 - Eclipse IDE einrichten
Alle Beispiele in diesem Tutorial wurden mit Eclipse IDE geschrieben. Daher würde ich vorschlagen, dass Sie die neueste Version von Eclipse auf Ihrem Computer installiert haben.
Laden Sie zum Installieren der Eclipse-IDE die neuesten Eclipse-Binärdateien von herunter https://www.eclipse.org/downloads/. Nachdem Sie die Installation heruntergeladen haben, entpacken Sie die Binärdistribution an einem geeigneten Ort. Zum Beispiel in C: \ eclipse unter Windows oder / usr / local / eclipse unter Linux / Unix. Stellen Sie abschließend die Variable PATH entsprechend ein.
Eclipse kann durch Ausführen der folgenden Befehle auf einem Windows-Computer gestartet werden, oder Sie können einfach auf eclipse.exe doppelklicken.
%C:\eclipse\eclipse.exeEclipse kann durch Ausführen der folgenden Befehle auf einem Unix-Computer (Solaris, Linux usw.) gestartet werden.
$/usr/local/eclipse/eclipseWenn nach einem erfolgreichen Start alles in Ordnung ist, sollte das folgende Ergebnis angezeigt werden.
Sobald Sie mit diesem letzten Schritt fertig sind, können Sie mit Ihrem ersten JDBC-Beispiel fortfahren, das Sie im nächsten Kapitel sehen werden.
Lassen Sie uns eine Datenbanktabelle erstellen Student in unserer Datenbank TEST. Ich gehe davon aus, dass Sie mit der MySQL-Datenbank arbeiten. Wenn Sie mit einer anderen Datenbank arbeiten, können Sie Ihre DDL- und SQL-Abfragen entsprechend ändern.
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);Jetzt müssen wir der JDBC-Vorlage eine DataSource bereitstellen, damit sie sich selbst konfigurieren kann, um Datenbankzugriff zu erhalten. Sie können die DataSource in der XML-Datei mit einem Code konfigurieren, der wie folgt angezeigt wird:
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>Im nächsten Kapitel schreiben wir die erste Anwendung unter Verwendung der konfigurierten Datenbank.
Um die Konzepte zu verstehen, die sich auf das Spring JDBC-Framework mit der JDBC-Vorlagenklasse beziehen, schreiben wir ein einfaches Beispiel, das Einfüge- und Leseoperationen in der folgenden Student-Tabelle implementiert.
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);Lassen Sie uns fortfahren, eine einfache konsolenbasierte Spring JDBC-Anwendung zu schreiben, die JDBC-Konzepte demonstriert.
Projekt erstellen
Öffnen Sie die Befehlskonsole, wechseln Sie in das Verzeichnis C: \ MVN und führen Sie Folgendes aus mvn Befehl.
C:\MVN>mvn archetype:generate -DgroupId = com.tutorialspoint -DartifactId = Student
-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = falseMaven beginnt mit der Verarbeitung und erstellt die vollständige Projektstruktur der Java-Anwendung.
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.4:generate (default-cli) > generate-sources
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.4:generate (default-cli) < generate-sources
@ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.4:generate (default-cli) @ standalone-pom --
-
[INFO] Generating project in Batch mode
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar (5 KB at 1.1 KB/s
ec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom (703 B at 1.2 KB/
sec)
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: Student
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\Student
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:17 min
[INFO] Finished at: 2017-02-19T21:11:14+05:30
[INFO] Final Memory: 15M/114M
[INFO] ------------------------------------------------------------------------Wechseln Sie nun in das Verzeichnis C: / MVN. Sie sehen ein Java-Anwendungsprojekt mit dem Namen student (wie in Artefakt-ID angegeben). Aktualisieren Sie die Datei POM.xml, um Spring JDBC-Abhängigkeiten einzuschließen. Fügen Sie die Dateien Student.java, StudentMapper.java, MainApp.java, StudentDAO.java und StudentJDBCTemplate.java hinzu.
POM.xml
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>Student</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>Student</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
</dependencies>
</project>Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to create
* a record in the Student table.
*/
public void create(String name, Integer age);
public Student getStudent(Integer id);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void create(String name, Integer age) {
String SQL = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( SQL, name, age);
System.out.println("Created Record Name = " + name + " Age = " + age);
return;
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate = (StudentJDBCTemplate)
context.getBean("studentJDBCTemplate");
System.out.println("------Records Creation--------" );
studentJDBCTemplate.create("Zara", 11);
studentJDBCTemplate.create("Nuha", 2);
studentJDBCTemplate.create("Ayan", 15);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
------Records Creation--------
Created Record Name = Zara Age = 11
Created Record Name = Nuha Age = 2
Created Record Name = Ayan Age = 15
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15Das folgende Beispiel zeigt, wie Sie mithilfe von Spring JDBC mithilfe von Insert Query eine Abfrage erstellen. Wir werden einige Datensätze in die Schülertabelle einfügen.
Syntax
String insertQuery = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( insertQuery, name, age);Wo,
insertQuery - Abfrage mit Platzhaltern einfügen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Einfügen eines Schülerobjekts in die Datenbank.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in das eine Abfrage eingefügt wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Kapitel erstellte Projekt StudentSpring JDBC - First Application. |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to create
* a record in the Student table.
*/
public void create(String name, Integer age);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void create(String name, Integer age) {
String insertQuery = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( insertQuery, name, age);
System.out.println("Created Record Name = " + name + " Age = " + age);
return;
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Records Creation--------" );
studentJDBCTemplate.create("Zara", 11);
studentJDBCTemplate.create("Nuha", 2);
studentJDBCTemplate.create("Ayan", 15);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
------Records Creation--------
Created Record Name = Zara Age = 11
Created Record Name = Nuha Age = 2
Created Record Name = Ayan Age = 15
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15Das folgende Beispiel zeigt, wie eine Abfrage mit Spring JDBC gelesen wird. Wir werden die verfügbaren Datensätze in der Schülertabelle lesen.
Syntax
String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());Wo,
selectQuery - Wählen Sie die Abfrage aus, um die Schüler zu lesen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen des Schülerobjekts aus der Datenbank.
StudentMapper - StudentMapper ist ein RowMapper-Objekt, mit dem jeder abgerufene Datensatz einem Schülerobjekt zugeordnet wird.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in dem eine Abfrage ausgewählt wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id="studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15Das folgende Beispiel zeigt, wie eine Abfrage mit Spring JDBC aktualisiert wird. Wir werden die verfügbaren Datensätze in der Schülertabelle aktualisieren.
Syntax
String updateQuery = "update Student set age = ? where id = ?";
jdbcTemplateObject.update(updateQuery, age, id);Wo,
updateQuery - Abfrage aktualisieren, um Schüler mit Platzhaltern zu aktualisieren.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Aktualisieren des Student-Objekts in der Datenbank.
Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine Abfrage aktualisiert. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void update(Integer id, Integer age);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void update(Integer id, Integer age){
String SQL = "update Student set age = ? where id = ?";
jdbcTemplateObject.update(SQL, age, id);
System.out.println("Updated Record with ID = " + id );
return;
}
public Student getStudent(Integer id) {
String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
SQL, new Object[]{id}, new StudentMapper());
return student;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("----Updating Record with ID = 2 -----" );
studentJDBCTemplate.update(2, 20);
System.out.println("----Listing Record with ID = 2 -----" );
Student student = studentJDBCTemplate.getStudent(2);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20Das folgende Beispiel zeigt, wie Sie eine Abfrage mit Spring JDBC löschen. Wir werden einen der verfügbaren Datensätze in der Schülertabelle löschen.
Syntax
String deleteQuery = "delete from Student where id = ?";
jdbcTemplateObject.update(deleteQuery, id);Wo,
deleteQuery - Abfrage löschen, um Schüler mit Platzhaltern zu löschen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Löschen des Student-Objekts in der Datenbank.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, mit dem eine Abfrage gelöscht wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
/**
* This is the method to be used to delete
* a record from the Student table corresponding
* to a passed student id.
*/
public void delete(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
public void delete(Integer id){
String SQL = "delete from Student where id = ?";
jdbcTemplateObject.update(SQL, id);
System.out.println("Deleted Record with ID = " + id );
return;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("----Delete Record with ID = 2 -----" );
studentJDBCTemplate.delete(2);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20Das folgende Beispiel zeigt, wie eine gespeicherte Prozedur mit Spring JDBC aufgerufen wird. Wir werden einen der verfügbaren Datensätze in der Schülertabelle lesen, indem wir eine gespeicherte Prozedur aufrufen. Wir werden einen Ausweis übergeben und eine Studentenakte erhalten.
Syntax
SimpleJdbcCall jdbcCall = new SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));Wo,
jdbcCall - SimpleJdbcCall-Objekt zur Darstellung einer gespeicherten Prozedur.
in - SqlParameterSource-Objekt zum Übergeben eines Parameters an eine gespeicherte Prozedur.
student - Schülerobjekt.
out - Zuordnungsobjekt zur Darstellung der Ausgabe des Ergebnisses eines Aufrufs einer gespeicherten Prozedur.
Das SimpleJdbcCallKlasse kann verwendet werden, um eine gespeicherte Prozedur mit IN- und OUT-Parametern aufzurufen. Sie können diesen Ansatz verwenden, wenn Sie mit einem der RDBMS wie Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle und Sybase arbeiten.
Um den Ansatz zu verstehen, betrachten Sie die folgende gespeicherte MySQL-Prozedur, die die Schüler-ID verwendet und den Namen und das Alter des entsprechenden Schülers mithilfe der OUT-Parameter zurückgibt. Lassen Sie uns diese gespeicherte Prozedur in der TEST-Datenbank mithilfe der MySQL-Eingabeaufforderung erstellen.
DELIMITER $$ DROP PROCEDURE IF EXISTS `TEST`.`getRecord` $$
CREATE PROCEDURE `TEST`.`getRecord` (
IN in_id INTEGER,
OUT out_name VARCHAR(20),
OUT out_age INTEGER)
BEGIN
SELECT name, age
INTO out_name, out_age
FROM Student where id = in_id;
END $$
DELIMITER ;Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine gespeicherte Prozedur aufruft. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}Der Code, den Sie für die Ausführung des Aufrufs schreiben, umfasst das Erstellen einer SqlParameterSource, die den Parameter IN enthält. Es ist wichtig, den für den Eingabewert angegebenen Namen mit dem in der gespeicherten Prozedur deklarierten Parameternamen abzugleichen. Die Methode execute verwendet die IN-Parameter und gibt eine Map zurück, die alle out-Parameter enthält, die durch den in der gespeicherten Prozedur angegebenen Namen gekennzeichnet sind.
Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
ID : 1, Name : Zara, Age : 11Das folgende Beispiel zeigt, wie eine gespeicherte Funktion mit Spring JDBC aufgerufen wird. Wir werden einen der verfügbaren Datensätze in der Schülertabelle lesen, indem wir eine gespeicherte Funktion aufrufen. Wir geben einen Ausweis ab und erhalten einen Schülernamen.
Syntax
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withFunctionName("get_student_name");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
String name = jdbcCall.executeFunction(String.class, in);
Student student = new Student();
student.setId(id);
student.setName(name);Wo,
in - SqlParameterSource-Objekt zum Übergeben eines Parameters an eine gespeicherte Funktion.
jdbcCall - SimpleJdbcCall-Objekt zur Darstellung einer gespeicherten Funktion.
jdbcTemplateObject - StudentJDBCTemplate-Objekt für die aufgerufene gespeicherte Funktion aus der Datenbank.
student - Schülerobjekt.
Das SimpleJdbcCallKlasse kann verwendet werden, um eine gespeicherte Funktion mit dem Parameter IN und einem Rückgabewert aufzurufen. Sie können diesen Ansatz verwenden, wenn Sie mit einem der RDBMS wie Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle und Sybase arbeiten.
Um den Ansatz zu verstehen, betrachten Sie die folgende gespeicherte MySQL-Prozedur, die die Schüler-ID verwendet und den Namen des entsprechenden Schülers zurückgibt. Lassen Sie uns diese gespeicherte Funktion in Ihrer TEST-Datenbank mithilfe der MySQL-Eingabeaufforderung erstellen.
DELIMITER $$
DROP FUNCTION IF EXISTS `TEST`.`get_student_name` $$
CREATE FUNCTION `get_student_name` (in_id INTEGER)
RETURNS varchar(200)
BEGIN
DECLARE out_name VARCHAR(200);
SELECT name
INTO out_name
FROM Student where id = in_id;
RETURN out_name;
DELIMITER ;Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine gespeicherte Funktion aufruft. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withFunctionName("get_student_name");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
String name = jdbcCall.executeFunction(String.class, in);
Student student = new Student();
student.setId(id);
student.setName(name);
return student;
}
}Der Code, den Sie für die Ausführung des Aufrufs schreiben, umfasst das Erstellen einer SqlParameterSource, die den Parameter IN enthält. Es ist wichtig, den für den Eingabewert angegebenen Namen mit dem Namen des in der gespeicherten Funktion deklarierten Parameternamens abzugleichen. Die executeFunction-Methode verwendet die IN-Parameter und gibt einen String zurück, wie in der gespeicherten Funktion angegeben.
Es folgt der Inhalt der MainApp.java Datei
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
ID : 1, Name : ZaraDas folgende Beispiel zeigt, wie ein BLOB mithilfe einer Aktualisierungsabfrage mithilfe von Spring JDBC aktualisiert wird. Wir werden die verfügbaren Datensätze in der Schülertabelle aktualisieren.
Schülertisch
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
IMAGE BLOB,
PRIMARY KEY (ID)
);Syntax
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("image", new SqlLobValue(new ByteArrayInputStream(imageData),
imageData.length, new DefaultLobHandler()), Types.BLOB);
String SQL = "update Student set image = :image where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);Wo,
in - SqlParameterSource-Objekt zum Übergeben eines Parameters zum Aktualisieren einer Abfrage.
SqlLobValue - Objekt zur Darstellung eines SQL BLOB / CLOB-Wertparameters.
jdbcTemplateObject - NamedParameterJdbcTemplate-Objekt zum Aktualisieren des Schülerobjekts in der Datenbank.
Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine Abfrage aktualisiert. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void updateImage(Integer id, byte[] imageData);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
private byte[] image;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public byte[] getImage() {
return image;
}
public void setImage(byte[] image) {
this.image = image;
}
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setImage(rs.getBytes("image"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;
import java.io.ByteArrayInputStream;
import java.sql.Types;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public void updateImage(Integer id, byte[] imageData) {
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("image", new SqlLobValue(new ByteArrayInputStream(imageData),
imageData.length, new DefaultLobHandler()), Types.BLOB);
String SQL = "update Student set image = :image where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new
NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
System.out.println("Updated Record with ID = " + id );
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
byte[] imageData = {0,1,0,8,20,40,95};
studentJDBCTemplate.updateImage(1, imageData);
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
Updated Record with ID = 1Sie können das gespeicherte Byte [] überprüfen, indem Sie die Datenbank abfragen.
Das folgende Beispiel zeigt, wie ein CLOB mithilfe einer Aktualisierungsabfrage mithilfe von Spring JDBC aktualisiert wird. Wir werden die verfügbaren Datensätze in der Schülertabelle aktualisieren.
Schülertisch
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
DESCRIPTION LONGTEXT,
PRIMARY KEY (ID)
);Syntax
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(
description, new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);Where,
in − SqlParameterSource object to pass a parameter to update a query.
SqlLobValue − Object to represent an SQL BLOB/CLOB value parameter.
jdbcTemplateObject − NamedParameterJdbcTemplate object to update student object in the database.
To understand the above-mentioned concepts related to Spring JDBC, let us write an example, which will update a query. To write our example, let us have a working Eclipse IDE in place and use the following steps to create a Spring application.
| Step | Description |
|---|---|
| 1 | Update the project Student created under chapter Spring JDBC - First Application. |
| 2 | Update the bean configuration and run the application as explained below. |
Following is the content of the Data Access Object interface file StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void updateDescription(Integer id, String description);
}Following is the content of the Student.java file.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
private String description;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}Following is the content of the StudentMapper.java file.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
return student;
}
}Following is the implementation class file StudentJDBCTemplate.java for the defined DAO interface StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;
import java.io.ByteArrayInputStream;
import java.sql.Types;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public void updateDescription(Integer id, String description) {
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(description,
new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new
NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
System.out.println("Updated Record with ID = " + id );
}
}Following is the content of the MainApp.java file.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
studentJDBCTemplate.updateDescription(1,
"This can be a very long text upto 4 GB of size.");
}
}Following is the configuration file Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Once you are done creating the source and bean configuration files, let us run the application. If everything is fine with your application, it will print the following message.
Updated Record with ID = 1You can check the description stored by querying the database.
Following example will demonstrate how to make a batch update using Spring JDBC. We'll update the available records in Student table in a single batch operation.
Syntax
String SQL = "update Student set age = ? where id = ?";
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,
new BatchPreparedStatementSetter() {
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setInt(1, students.get(i).getAge());
ps.setInt(2, students.get(i).getId());
}
public int getBatchSize() {
return students.size();
}
});Where,
SQL − Update query to update student's age.
jdbcTemplateObject − StudentJDBCTemplate object to update student object in database.
BatchPreparedStatementSetter − Batch executor, set values in PerparedStatement per item identified by list of objects student and index i. getBatchSize() returns the size of the batch.
updateCounts − Int array containing updated row count per update query.
To understand the above-mentioned concepts related to Spring JDBC, let us write an example which will update a batch operation. To write our example, let us have a working Eclipse IDE in place and use the following steps to create a Spring application.
| Step | Description |
|---|---|
| 1 | Update the project Student created under chapter Spring JDBC - First Application. |
| 2 | Update the bean configuration and run the application as explained below. |
Following is the content of the Data Access Object interface file StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
public void batchUpdate(final List<Student> students);
}Following is the content of the Student.java file.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Following is the content of the StudentMapper.java file.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Following is the implementation class file StudentJDBCTemplate.java for the defined DAO interface StudentDAO.
package com.tutorialspoint;
import java.sql.PreparedStatement;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import java.sql.SQLException;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL,
new StudentMapper());
return students;
}
public void batchUpdate(final List<Student> students){
String SQL = "update Student set age = ? where id = ?";
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,
new BatchPreparedStatementSetter() {
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setInt(1, students.get(i).getAge());
ps.setInt(2, students.get(i).getId());
}
public int getBatchSize() {
return students.size();
}
});
System.out.println("Records updated!");
}
}Following is the content of the MainApp.java file.
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> initialStudents = studentJDBCTemplate.listStudents();
System.out.println("Initial Students");
for(Student student2: initialStudents){
System.out.print("ID : " + student2.getId() );
System.out.println(", Age : " + student2.getAge());
}
Student student = new Student();
student.setId(1);
student.setAge(10);
Student student1 = new Student();
student1.setId(3);
student1.setAge(10);
List<Student> students = new ArrayList<Student>();
students.add(student);
students.add(student1);
studentJDBCTemplate.batchUpdate(students);
List<Student> updatedStudents = studentJDBCTemplate.listStudents();
System.out.println("Updated Students");
for(Student student3: updatedStudents){
System.out.print("ID : " + student3.getId() );
System.out.println(", Age : " + student3.getAge());
}
}
}Following is the configuration file Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Once you are done creating the source and bean configuration files, let us run the application. If everything is fine with your application, it will print the following message.
Initial Students
ID : 1, Age : 11
ID : 3, Age : 15
Records updated!
Updated Students
ID : 1, Age : 10
ID : 3, Age : 10Following example will demonstrate how to make a batch update using objects in Spring JDBC. We'll update the available records in Student table in a single batch operation.
Syntax
String SQL = "update Student set age = :age where id = :id";
SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(students.toArray());
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,batch);
System.out.println("records updated!");Where,
SQL − Update query to update student's age.
jdbcTemplateObject − StudentJDBCTemplate object to update student object in database.
batch − SqlParameterSource object to represent a batch of object.
updateCounts − Int array containing updated row count per update query.
To understand the above-mentioned concepts related to Spring JDBC, let us write an example which will update a batch operation. To write our example, let us have a working Eclipse IDE in place and use the following steps to create a Spring application.
| Step | Description |
|---|---|
| 1 | Update the project Student created under chapter Spring JDBC - First Application. |
| 2 | Update the bean configuration and run the application as explained below. |
Following is the content of the Data Access Object interface file StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
public void batchUpdate(final List<Student> students);
}Following is the content of the Student.java file.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
public void batchUpdate(final List<Student> students){
String SQL = "update Student set age = :age where id = :id";
SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(students.toArray());
NamedParameterJdbcTemplate jdbcTemplateObject = new
NamedParameterJdbcTemplate(dataSource);
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,batch);
System.out.println("Records updated!");
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> initialStudents = studentJDBCTemplate.listStudents();
System.out.println("Initial Students");
for(Student student2: initialStudents){
System.out.print("ID : " + student2.getId() );
System.out.println(", Age : " + student2.getAge());
}
Student student = new Student();
student.setId(1);
student.setAge(15);
Student student1 = new Student();
student1.setId(3);
student1.setAge(16);
List<Student> students = new ArrayList<Student>();
students.add(student);
students.add(student1);
studentJDBCTemplate.batchUpdate(students);
List<Student> updatedStudents = studentJDBCTemplate.listStudents();
System.out.println("Updated Students");
for(Student student3: updatedStudents){
System.out.print("ID : " + student3.getId() );
System.out.println(", Age : " + student3.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
Initial Students
ID : 1, Age : 10
ID : 3, Age : 10
Records updated!
Updated Students
ID : 1, Age : 15
ID : 3, Age : 16Das folgende Beispiel zeigt, wie Sie mit Spring JDBC mehrere Stapelaktualisierungen in einem einzigen Aufruf durchführen. Wir aktualisieren die verfügbaren Datensätze in der Student-Tabelle in einem Mehrfachstapelvorgang, bei dem die Stapelgröße 1 beträgt.
Syntax
String SQL = "update Student set age = ? where id = ?";
int[][] updateCounts = jdbcTemplateObject.batchUpdate(SQL,students,1,
new ParameterizedPreparedStatementSetter<Student>() {
public void setValues(PreparedStatement ps, Student student)
throws SQLException {
ps.setInt(1, student.getAge());
ps.setInt(2, student.getId());
}
});Wo,
SQL - Abfrage aktualisieren, um das Alter des Schülers zu aktualisieren.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Aktualisieren des Student-Objekts in der Datenbank.
ParameterizedPreparedStatementSetter - Batch Executor, setzen Sie Werte in PerparedStatement pro Element, das durch die Liste der Schüler identifiziert wird.
updateCounts - Int [] [] Array mit aktualisierter Zeilenanzahl pro Aktualisierungsabfrage pro Stapel.
Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das den Mehrfachstapelvorgang aktualisiert. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
public void batchUpdate(final List<Student> students);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.sql.PreparedStatement;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ParameterizedPreparedStatementSetter;
import java.sql.SQLException;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
public void batchUpdate(final List<Student> students){
String SQL = "update Student set age = ? where id = ?";
int[][] updateCounts = jdbcTemplateObject.batchUpdate(SQL,students,1,
new ParameterizedPreparedStatementSetter<Student>() {
public void setValues(PreparedStatement ps, Student student)
throws SQLException {
ps.setInt(1, student.getAge());
ps.setInt(2, student.getId());
}
});
System.out.println("Records updated!");
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> initialStudents = studentJDBCTemplate.listStudents();
System.out.println("Initial Students");
for(Student student2: initialStudents){
System.out.print("ID : " + student2.getId() );
System.out.println(", Age : " + student2.getAge());
}
Student student = new Student();
student.setId(1);
student.setAge(17);
Student student1 = new Student();
student1.setId(3);
student1.setAge(18);
List<Student> students = new ArrayList<Student>();
students.add(student);
students.add(student1);
studentJDBCTemplate.batchUpdate(students);
List<Student> updatedStudents = studentJDBCTemplate.listStudents();
System.out.println("Updated Students");
for(Student student3: updatedStudents){
System.out.print("ID : " + student3.getId() );
System.out.println(", Age : " + student3.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
Initial Students
ID : 1, Age : 15
ID : 3, Age : 16
records updated!
Updated Students
ID : 1, Age : 17
ID : 3, Age : 18Das org.springframework.jdbc.core.JdbcTemplateKlasse ist die zentrale Klasse im JDBC-Kernpaket. Es vereinfacht die Verwendung von JDBC und hilft, häufige Fehler zu vermeiden. Es führt den JDBC-Kernworkflow aus und belässt den Anwendungscode, um SQL bereitzustellen und Ergebnisse zu extrahieren. Diese Klasse führt SQL-Abfragen oder -Updates aus, initiiert die Iteration über ResultSets und fängt JDBC-Ausnahmen ab und übersetzt sie in die generische, informativere Ausnahmehierarchie, die in definiert istorg.springframework.dao Paket.
Klassenerklärung
Es folgt die Deklaration für die Klasse org.springframework.jdbc.core.JdbcTemplate -
public class JdbcTemplate
extends JdbcAccessor
implements JdbcOperationsVerwendung
Step 1 - Erstellen Sie ein JdbcTemplate-Objekt mit einer konfigurierten Datenquelle.
Step 2 - Verwenden Sie JdbcTemplate-Objektmethoden, um Datenbankoperationen durchzuführen.
Beispiel
Das folgende Beispiel zeigt, wie eine Abfrage mit der JdbcTemplate-Klasse gelesen wird. Wir werden die verfügbaren Datensätze in der Schülertabelle lesen.
Syntax
String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());Wo,
selectQuery - Wählen Sie die Abfrage aus, um die Schüler zu lesen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen des Student-Objekts aus der Datenbank.
StudentMapper - StudentMapper ist ein RowMapper-Objekt, mit dem jeder abgerufene Datensatz dem Schülerobjekt zugeordnet wird.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in dem eine Abfrage ausgewählt wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id="dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id="studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15Das org.springframework.jdbc.core.PreparedStatementSetterDie Schnittstelle fungiert als allgemeine Rückrufschnittstelle, die von der JdbcTemplate-Klasse verwendet wird. Diese Schnittstelle legt Werte für ein PreparedStatement fest, das von der JdbcTemplate-Klasse für jede einer Reihe von Aktualisierungen in einem Stapel mit demselben SQL bereitgestellt wird.
Die Implementierungen sind für die Einstellung aller erforderlichen Parameter verantwortlich. SQL mit Platzhaltern wurde bereits bereitgestellt. Es ist einfacher, diese Schnittstelle als PreparedStatementCreator zu verwenden. Das JdbcTemplate erstellt das PreparedStatement, wobei der Rückruf nur für das Festlegen von Parameterwerten verantwortlich ist.
Schnittstellendeklaration
Es folgt die Deklaration für die Schnittstelle org.springframework.jdbc.core.PreparedStatementSetter -
public interface PreparedStatementSetterVerwendung
Step 1 - Erstellen Sie ein JdbcTemplate-Objekt mit einer konfigurierten Datenquelle.
Step 2 - Verwenden Sie JdbcTemplate-Objektmethoden, um Datenbankoperationen durchzuführen, während Sie das PreparedStatementSetter-Objekt übergeben, um Platzhalter in der Abfrage zu ersetzen.
Beispiel
Das folgende Beispiel zeigt, wie eine Abfrage mithilfe der JdbcTemplate-Klasse und der PreparedStatementSetter-Schnittstelle gelesen wird. Wir werden die verfügbaren Aufzeichnungen eines Schülers in der Schülertabelle lesen.
Syntax
final String SQL = "select * from Student where id = ? ";
List <Student> students = jdbcTemplateObject.query(
SQL, new PreparedStatementSetter() {
public void setValues(PreparedStatement preparedStatement) throws SQLException {
preparedStatement.setInt(1, id);
}
},
new StudentMapper());Wo,
SQL - Wählen Sie die Abfrage aus, um die Schüler zu lesen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen des Schülerobjekts aus der Datenbank.
PreparedStatementSetter - PreparedStatementSetter-Objekt zum Festlegen von Parametern in der Abfrage.
StudentMapper - StudentMapper ist ein RowMapper-Objekt, mit dem jeder abgerufene Datensatz einem Schülerobjekt zugeordnet wird.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in dem eine Abfrage ausgewählt wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(final Integer id) {
final String SQL = "select * from Student where id = ? ";
List <Student> students = jdbcTemplateObject.query(
SQL, new PreparedStatementSetter() {
public void setValues(PreparedStatement preparedStatement) throws SQLException {
preparedStatement.setInt(1, id);
}
},
new StudentMapper());
return students.get(0);
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.println(", Age : " + student.getAge());
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
ID : 1, Age : 17Das org.springframework.jdbc.core.ResultSetExtractorinterface ist eine Rückrufschnittstelle, die von den Abfragemethoden von JdbcTemplate verwendet wird. Implementierungen dieser Schnittstelle führen die eigentliche Arbeit zum Extrahieren von Ergebnissen aus einem ResultSet aus, müssen sich jedoch nicht um die Ausnahmebehandlung kümmern.
SQLExceptions werden vom aufrufenden JdbcTemplate abgefangen und verarbeitet. Diese Schnittstelle wird hauptsächlich im JDBC-Framework selbst verwendet. Ein RowMapper ist normalerweise eine einfachere Wahl für die ResultSet-Verarbeitung, da ein Ergebnisobjekt pro Zeile anstelle eines Ergebnisobjekts für das gesamte ResultSet zugeordnet wird.
Schnittstellendeklaration
Es folgt die Deklaration für die Schnittstelle org.springframework.jdbc.core.ResultSetExtractor -
public interface ResultSetExtractorVerwendung
Step 1 - Erstellen Sie ein JdbcTemplate-Objekt mit einer konfigurierten Datenquelle.
Step 2 - Verwenden Sie JdbcTemplate-Objektmethoden, um Datenbankoperationen durchzuführen, während Sie die Ergebnismenge mit ResultSetExtractor analysieren.
Beispiel
Das folgende Beispiel zeigt, wie eine Abfrage mithilfe der JdbcTemplate-Klasse und der ResultSetExtractor-Schnittstelle gelesen wird. Wir werden die verfügbaren Aufzeichnungen eines Schülers in der Schülertabelle lesen.
Syntax
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL,
new ResultSetExtractor<List<Student>>(){
public List<Student> extractData(
ResultSet rs) throws SQLException, DataAccessException {
List<Student> list = new ArrayList<Student>();
while(rs.next()){
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
student.setImage(rs.getBytes("image"));
list.add(student);
}
return list;
}
});
return students;
}Wo,
SQL - Wählen Sie die Abfrage aus, um die Schüler zu lesen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen des Schülerobjekts aus der Datenbank.
ResultSetExtractor - ResultSetExtractor-Objekt zum Analysieren des Ergebnismengenobjekts.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in dem eine Abfrage ausgewählt wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import java.util.ArrayList;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL,
new ResultSetExtractor<List<Student>>(){
public List<Student> extractData(
ResultSet rs) throws SQLException, DataAccessException {
List<Student> list = new ArrayList<Student>();
while(rs.next()){
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
student.setImage(rs.getBytes("image"));
list.add(student);
}
return list;
}
});
return students;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> students = studentJDBCTemplate.listStudents();
for(Student student: students){
System.out.print("ID : " + student.getId() );
System.out.println(", Age : " + student.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
ID : 1, Age : 17
ID : 3, Age : 18Das org.springframework.jdbc.core.RowMapper<T>Die Schnittstelle wird von JdbcTemplate zum Zuordnen von Zeilen eines ResultSet pro Zeile verwendet. Implementierungen dieser Schnittstelle führen die eigentliche Arbeit des Zuordnens jeder Zeile zu einem Ergebnisobjekt aus. SQLE-Ausnahmen, wenn sie ausgelöst werden, werden vom aufrufenden JdbcTemplate abgefangen und verarbeitet.
Schnittstellendeklaration
Es folgt die Erklärung für org.springframework.jdbc.core.RowMapper<T> Schnittstelle -
public interface RowMapper<T>Verwendung
Step 1 - Erstellen Sie ein JdbcTemplate-Objekt mit einer konfigurierten Datenquelle.
Step 2 - Erstellen Sie ein StudentMapper-Objekt, das die RowMapper-Schnittstelle implementiert.
Step 3 - Verwenden Sie JdbcTemplate-Objektmethoden, um Datenbankoperationen durchzuführen, während Sie das StudentMapper-Objekt verwenden.
Das folgende Beispiel zeigt, wie eine Abfrage mit spring jdbc gelesen wird. Wir ordnen gelesene Datensätze aus der Studententabelle dem Student-Objekt mithilfe des StudentMapper-Objekts zu.
Syntax
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());Wo
SQL - Abfrage lesen, um alle Schülerdatensätze zu lesen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen von Schülerdatensätzen aus der Datenbank.
StudentMapper - StudentMapper-Objekt zum Zuordnen von Schülerdatensätzen zu Schülerobjekten.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in dem eine Abfrage gelesen und das Ergebnis mit dem StudentMapper-Objekt zugeordnet wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDao.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDao {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}Es folgt der Inhalt der MainApp.java Datei
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18Das org.springframework.jdbc.core.NamedParameterJdbcTemplateclass ist eine Vorlagenklasse mit einem grundlegenden Satz von JDBC-Operationen, die die Verwendung benannter Parameter anstelle des herkömmlichen '?' Platzhalter. Diese Klasse delegiert an eine umschlossene JdbcTemplate, sobald die benannten Parameter durch den JDBC-Stil '?' Platzhalter werden zur Ausführungszeit erstellt. Außerdem kann eine Werteliste auf die entsprechende Anzahl von Platzhaltern erweitert werden.
Schnittstellendeklaration
Es folgt die Erklärung für org.springframework.jdbc.core.NamedParameterJdbcTemplate Klasse -
public class NamedParameterJdbcTemplate
extends Object
implements NamedParameterJdbcOperationsSyntax
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(description, new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);Wo,
in - SqlParameterSource-Objekt zum Übergeben eines Parameters zum Aktualisieren einer Abfrage.
SqlLobValue - Objekt zur Darstellung eines SQL BLOB / CLOB-Wertparameters.
jdbcTemplateObject - NamedParameterJdbcTemplate-Objekt zum Aktualisieren des Schülerobjekts in der Datenbank.
Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine Abfrage aktualisiert. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void updateDescription(Integer id, String description);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
private String description;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;
import java.io.ByteArrayInputStream;
import java.sql.Types;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public void updateDescription(Integer id, String description) {
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(
description, new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject =
new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
System.out.println("Updated Record with ID = " + id );
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
studentJDBCTemplate.updateDescription(1,
"This can be a very long text upto 4 GB of size.");
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
Updated Record with ID = 1Sie können die gespeicherte Beschreibung überprüfen, indem Sie die Datenbank abfragen.
Das org.springframework.jdbc.core.SimpleJdbcInsertclass ist ein wiederverwendbares Multithread-Objekt, das einfache Einfügefunktionen für eine Tabelle bietet. Es bietet eine Metadatenverarbeitung, um den Code zu vereinfachen, der zum Erstellen einer grundlegenden Einfügeanweisung erforderlich ist. Die eigentliche Einfügung wird mit Spring's JdbcTemplate behandelt
Klassenerklärung
Es folgt die Erklärung für org.springframework.jdbc.core.SimpleJdbcInsert Klasse -
public class SimpleJdbcInsert
extends AbstractJdbcInsert
implements SimpleJdbcInsertOperationsDas folgende Beispiel zeigt, wie Sie eine Abfrage mit Spring JDBC einfügen. Wir werden einen Datensatz mit dem SimpleJdbcInsert-Objekt in die Schülertabelle einfügen.
Syntax
jdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("Student");
Map<String,Object> parameters = new HashMap<String,Object>();
parameters.put("name", name);
parameters.put("age", age);
jdbcInsert.execute(parameters);Wo,
jdbcInsert - SimpleJdbcInsert-Objekt zum Einfügen eines Datensatzes in die Schülertabelle.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen des Student-Objekts in der Datenbank.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in das eine Abfrage eingefügt wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to create
* a record in the Student table.
*/
public void create(String name, Integer age);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
SimpleJdbcInsert jdbcInsert;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
this.jdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("Student");
}
public void create(String name, Integer age) {
Map<String,Object> parameters = new HashMap<String,Object>();
parameters.put("name", name);
parameters.put("age", age);
jdbcInsert.execute(parameters);
System.out.println("Created Record Name = " + name + " Age = " + age);
return;
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Records Creation--------" );
studentJDBCTemplate.create("Nuha", 2);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
------Records Creation--------
Created Record Name = Nuha Age = 12
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ID : 4, Name : Nuha, Age : 12Das org.springframework.jdbc.core.SimpleJdbcCallKlasse ist ein wiederverwendbares Multithread-Objekt, das einen Aufruf einer gespeicherten Prozedur oder einer gespeicherten Funktion darstellt. Es bietet eine Metadatenverarbeitung, um den Code zu vereinfachen, der für den Zugriff auf grundlegende gespeicherte Prozeduren / Funktionen erforderlich ist.
Sie müssen lediglich den Namen der Prozedur / Funktion und eine Zuordnung mit den Parametern angeben, wenn Sie den Aufruf ausführen. Die Namen der angegebenen Parameter werden mit den In- und Out-Parametern abgeglichen, die beim Erstellen der gespeicherten Prozedur deklariert wurden.
Klassenerklärung
Es folgt die Erklärung für org.springframework.jdbc.core.SimpleJdbcCall Klasse -
public class SimpleJdbcCall
extends AbstractJdbcCall
implements SimpleJdbcCallOperationsDas folgende Beispiel zeigt, wie eine gespeicherte Prozedur mit Spring SimpleJdbcCall aufgerufen wird. Wir werden einen der verfügbaren Datensätze in der Schülertabelle lesen, indem wir eine gespeicherte Prozedur aufrufen. Wir werden einen Ausweis übergeben und eine Studentenakte erhalten.
Syntax
SimpleJdbcCall jdbcCall = new SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));Wo,
jdbcCall - SimpleJdbcCall-Objekt zur Darstellung einer gespeicherten Prozedur.
in - SqlParameterSource-Objekt zum Übergeben eines Parameters an eine gespeicherte Prozedur.
student - Schülerobjekt.
out - Zuordnungsobjekt zur Darstellung der Ausgabe des Ergebnisses eines Aufrufs einer gespeicherten Prozedur.
Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine gespeicherte Prozedur aufruft. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}Der Code, den Sie für die Ausführung des Aufrufs schreiben, umfasst das Erstellen einer SqlParameterSource, die den Parameter IN enthält. Es ist wichtig, den für den Eingabewert angegebenen Namen mit dem in der gespeicherten Prozedur deklarierten Parameternamen abzugleichen. Die Methode execute verwendet die IN-Parameter und gibt eine Map zurück, die alle out-Parameter enthält, die durch den in der gespeicherten Prozedur angegebenen Namen gekennzeichnet sind.
Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
ID : 1, Name : Zara, Age : 11Das org.springframework.jdbc.object.SqlQuery Klasse stellt ein wiederverwendbares Operationsobjekt bereit, das eine SQL-Abfrage darstellt.
Klassenerklärung
Es folgt die Erklärung für org.springframework.jdbc.object.SqlQuery Klasse -
public abstract class SqlQuery<T>
extends SqlOperationVerwendung
Step 1 - Erstellen Sie ein JdbcTemplate-Objekt mit einer konfigurierten Datenquelle.
Step 2 - Erstellen Sie ein StudentMapper-Objekt, das die RowMapper-Schnittstelle implementiert.
Step 3 - Verwenden Sie JdbcTemplate-Objektmethoden, um Datenbankoperationen durchzuführen, während Sie das SqlQuery-Objekt verwenden.
Das folgende Beispiel zeigt, wie eine Abfrage mit dem SqlQuery-Objekt gelesen wird. Wir ordnen gelesene Datensätze aus der Studententabelle dem Student-Objekt mithilfe des StudentMapper-Objekts zu.
Syntax
String sql = "select * from Student";
SqlQuery<Student> sqlQuery = new SqlQuery<Student>() {
@Override
protected RowMapper<Student> newRowMapper(Object[] parameters,
Map<?, ?> context) {
return new StudentMapper();
}
};
sqlQuery.setDataSource(dataSource);
sqlQuery.setSql(sql);
List <Student> students = sqlQuery.execute();Wo,
SQL - Abfrage lesen, um alle Schülerdatensätze zu lesen.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen von Schülerdatensätzen aus der Datenbank.
StudentMapper - StudentMapper-Objekt zum Zuordnen der Schülerdatensätze zu Schülerobjekten.
SqlQuery - SqlQuery-Objekt, um Schülerdatensätze abzufragen und sie Schülerobjekten zuzuordnen.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in dem eine Abfrage gelesen und das Ergebnis mithilfe des StudentMapper-Objekts zugeordnet wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDao.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDao {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.object.SqlQuery;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String sql = "select * from Student";
SqlQuery<Student> sqlQuery = new SqlQuery<Student>() {
@Override
protected RowMapper<Student> newRowMapper(Object[] parameters, Map<?, ?> context){
return new StudentMapper();
}
};
sqlQuery.setDataSource(dataSource);
sqlQuery.setSql(sql);
List <Student> students = sqlQuery.execute();
return students;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ID : 4, Name : Nuha, Age : 12Das org.springframework.jdbc.object.SqlUpdate Klasse stellt ein wiederverwendbares Operationsobjekt bereit, das ein SQL-Update darstellt.
Klassenerklärung
Es folgt die Erklärung für org.springframework.jdbc.object.SqlUpdate Klasse -
public abstract class SqlUpdate<T>
extends SqlOperationVerwendung
Step 1 - Erstellen Sie ein JdbcTemplate-Objekt mit einer konfigurierten Datenquelle.
Step 2 - Erstellen Sie ein StudentMapper-Objekt, das die RowMapper-Schnittstelle implementiert.
Step 3 - Verwenden Sie JdbcTemplate-Objektmethoden, um Datenbankoperationen auszuführen, während Sie das SqlUpdate-Objekt verwenden.
Das folgende Beispiel zeigt, wie eine Abfrage mit SqlUpdate Object aktualisiert wird. Wir ordnen Aktualisierungsdatensätze von Student Table dem Student-Objekt mithilfe des StudentMapper-Objekts zu.
Syntax
String SQL = "update Student set age = ? where id = ?";
SqlUpdate sqlUpdate = new SqlUpdate(dataSource,SQL);
sqlUpdate.declareParameter(new SqlParameter("age", Types.INTEGER));
sqlUpdate.declareParameter(new SqlParameter("id", Types.INTEGER));
sqlUpdate.compile();
sqlUpdate.update(age.intValue(),id.intValue());Wo,
SQL - Abfrage aktualisieren, um Schülerdatensätze zu aktualisieren.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen von Studentendatensätzen aus der Datenbank.
StudentMapper - StudentMapper-Objekt zum Zuordnen von Schülerdatensätzen zu Schülerobjekten.
sqlUpdate - SqlUpdate-Objekt zum Aktualisieren von Schülerdatensätzen.
Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in dem eine Abfrage gelesen und das Ergebnis mit dem StudentMapper-Objekt zugeordnet wird. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDao.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDao {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void update(Integer id, Integer age);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.sql.Types;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.SqlUpdate;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void update(Integer id, Integer age){
String SQL = "update Student set age = ? where id = ?";
SqlUpdate sqlUpdate = new SqlUpdate(dataSource,SQL);
sqlUpdate.declareParameter(new SqlParameter("age", Types.INTEGER));
sqlUpdate.declareParameter(new SqlParameter("id", Types.INTEGER));
sqlUpdate.compile();
sqlUpdate.update(age.intValue(),id.intValue());
System.out.println("Updated Record with ID = " + id );
return;
}
public Student getStudent(Integer id) {
String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
SQL, new Object[]{id}, new StudentMapper());
return student;
}
}Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("----Updating Record with ID = 1 -----" );
studentJDBCTemplate.update(1, 10);
System.out.println("----Listing Record with ID = 1 -----" );
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
----Updating Record with ID = 1 -----
Updated Record with ID = 1
----Listing Record with ID = 1 -----
ID : 1, Name : Zara, Age : 10Das org.springframework.jdbc.core.StoredProcedureKlasse ist die Oberklasse für Objektabstraktionen von gespeicherten RDBMS-Prozeduren. Diese Klasse ist abstrakt und es ist beabsichtigt, dass Unterklassen eine typisierte Methode für den Aufruf bereitstellen, die an die angegebene Ausführungsmethode (java.lang.Object ...) delegiert. Die geerbte SQL-Eigenschaft ist der Name der im RDBMS gespeicherten Prozedur.
Klassenerklärung
Es folgt die Erklärung für org.springframework.jdbc.core.StoredProcedure Klasse -
public abstract class StoredProcedure
extends SqlCallDas folgende Beispiel zeigt, wie eine gespeicherte Prozedur mit Spring StoredProcedure aufgerufen wird. Wir werden einen der verfügbaren Datensätze in der Schülertabelle lesen, indem wir eine gespeicherte Prozedur aufrufen. Wir werden einen Ausweis übergeben und eine Studentenakte erhalten.
Syntax
class StudentProcedure extends StoredProcedure{
public StudentProcedure(DataSource dataSource, String procedureName){
super(dataSource,procedureName);
declareParameter(new SqlParameter("in_id", Types.INTEGER));
declareParameter(new SqlOutParameter("out_name", Types.VARCHAR));
declareParameter(new SqlOutParameter("out_age", Types.INTEGER));
compile();
}
public Student execute(Integer id){
Map<String, Object> out = super.execute(id);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}Wo,
StoredProcedure - StoredProcedure-Objekt zur Darstellung einer gespeicherten Prozedur.
StudentProcedure - Das StudentProcedure-Objekt erweitert StoredProcedure, um die Eingabe, die Ausgabevariable und das Zuordnungsergebnis zum Student-Objekt zu deklarieren.
student - Schülerobjekt.
Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine gespeicherte Prozedur aufruft. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.
| Schritt | Beschreibung |
|---|---|
| 1 | Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student . |
| 2 | Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus. |
Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}Es folgt der Inhalt der Student.java Datei.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}Es folgt der Inhalt der StudentMapper.java Datei.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle StudentDAO.
package com.tutorialspoint;
import java.sql.Types;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlOutParameter;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.object.StoredProcedure;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
StudentProcedure studentProcedure = new StudentProcedure(dataSource, "getRecord");
return studentProcedure.execute(id);
}
}
class StudentProcedure extends StoredProcedure{
public StudentProcedure(DataSource dataSource, String procedureName) {
super(dataSource,procedureName);
declareParameter(new SqlParameter("in_id", Types.INTEGER));
declareParameter(new SqlOutParameter("out_name", Types.VARCHAR));
declareParameter(new SqlOutParameter("out_age", Types.INTEGER));
compile();
}
public Student execute(Integer id){
Map<String, Object> out = super.execute(id);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}Der Code, den Sie für die Ausführung des Aufrufs schreiben, umfasst das Erstellen einer SqlParameterSource, die den Parameter IN enthält. Es ist wichtig, den für den Eingabewert angegebenen Namen mit dem in der gespeicherten Prozedur deklarierten Parameternamen abzugleichen. Die Methode execute verwendet die IN-Parameter und gibt eine Map zurück, die alle out-Parameter enthält, die durch den in der gespeicherten Prozedur angegebenen Namen gekennzeichnet sind.
Es folgt der Inhalt der MainApp.java Datei.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}Es folgt die Konfigurationsdatei Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.
ID : 1, Name : Zara, Age : 10