SpringJDBC-クイックガイド
プレーンな古いJDBCを使用してデータベースを操作している間、例外を処理したり、データベース接続を開いたり閉じたりするために不要なコードを書くのは面倒になります。ただし、Spring JDBC Frameworkは、接続の開き、準備、 SQLステートメントの実行、例外の処理、トランザクションの処理、そして最後に接続を閉じます。
接続パラメーターを定義し、実行するSQLステートメントを指定して、データベースからデータをフェッチしながら、各反復に必要な作業を実行するだけです。
Spring JDBCは、データベースとインターフェースするためのいくつかのアプローチとそれに対応する異なるクラスを提供します。このチュートリアルでは、フレームワークのJDBCテンプレートクラスを利用する、古典的で最も一般的なアプローチを採用します。これは、すべてのデータベース通信と例外処理を管理する中央フレームワーククラスです。
JDBCテンプレートクラス
JDBCテンプレートクラスは、SQLクエリを実行し、ステートメントとストアドプロシージャの呼び出しを更新し、ResultSetに対して反復を実行し、返されたパラメータ値を抽出します。また、JDBC例外をキャッチし、org.springframework.daoパッケージで定義されている一般的でより有益な例外階層に変換します。
JDBCテンプレートクラスのインスタンスは、一度設定されるとスレッドセーフになります。したがって、JDBCテンプレートの単一インスタンスを構成してから、この共有参照を複数のDAOに安全に挿入できます。
JDBCテンプレートクラスを使用する場合の一般的な方法は、Spring構成ファイルでデータソースを構成してから、その共有データソースBeanをDAOクラスに依存性注入することです。JDBCテンプレートは、データソースのセッターで作成されます。
データアクセスオブジェクト(DAO)
DAOは Data Access Objectこれは一般的にデータベースの相互作用に使用されます。DAOは、データベースに対してデータを読み書きする手段を提供するために存在し、アプリケーションの残りの部分がDAOにアクセスするためのインターフェイスを介してこの機能を公開する必要があります。
Springでのデータアクセスオブジェクト(DAO)のサポートにより、JDBC、Hibernate、JPA、JDOなどのデータアクセステクノロジを一貫した方法で簡単に操作できます。
この章では、WindowsおよびLinuxベースのシステムでSpring-AOPをセットアップするプロセスについて説明します。Spring AOPは、複雑なセットアップ手順なしでいくつかの簡単な手順に従うことで、現在のJava環境およびMAVENに簡単にインストールして統合できます。インストール中にユーザー管理が必要です。
システム要求
JDK | Java SE 2 JDK1.5以降 |
記憶 | 1 GB RAM(推奨) |
ディスクスペース | 最小要件はありません |
オペレーティングシステムのバージョン | Windows XP以降、Linux |
それでは、SpringAOPをインストールする手順に進みましょう。
ステップ1-Javaのインストールを確認する
まず、システムにJavaソフトウェア開発キット(SDK)をインストールする必要があります。これを確認するには、作業しているプラットフォームに応じて、次の2つのコマンドのいずれかを実行します。
Javaのインストールが適切に行われている場合は、Javaインストールの現在のバージョンと仕様が表示されます。次の表に出力例を示します。
プラットホーム | コマンド | サンプル出力 |
---|---|---|
ウィンドウズ | コマンドコンソールを開き、「-」と入力します。 \>java -version |
Javaバージョン「1.7.0_60」 Java(TM)SEランタイム環境(ビルド1.7.0_60-b19) Java Hotspot(TM)64ビットサーバーVM(ビルド24.60-b09、混合モード) |
Linux | コマンドターミナルを開き、「-」と入力します。 $java -version |
Javaバージョン「1.7.0_25」 JDKランタイム環境を開きます(rhel-2.3.10.4.el6_4-x86_64) JDK 64ビットサーバーVMを開きます(ビルド23.7-b01、混合モード) |
このチュートリアルの読者は、JavaSDKバージョン1.7.0_60がシステムにインストールされていることを前提としています。Java SDKをお持ちでない場合は、現在のバージョンをからダウンロードしてください。https://www.oracle.com/technetwork/java/javase/downloads/index.html そしてそれをインストールしてもらいます。
ステップ2-Java環境を設定する
Javaがマシンにインストールされているベースディレクトリの場所を指すように環境変数JAVA_HOMEを設定します。例えば、
プラットホーム | 説明 |
---|---|
ウィンドウズ | JAVA_HOMEをC:\ ProgramFiles \ java \ jdk1.7.0_60に設定します |
Linux | JAVA_HOME = / usr / local / java-currentをエクスポートします |
Javaコンパイラの場所のフルパスをシステムパスに追加します。
プラットホーム | 説明 |
---|---|
ウィンドウズ | 文字列「C:\ ProgramFiles \ Java \ jdk1.7.0_60 \ bin」をシステム変数PATHの最後に追加します。 |
Linux | PATH = $ PATH:$ JAVA_HOME / bin /をエクスポートします |
コマンドを実行します java -version 上で説明したコマンドプロンプトから。
ステップ3-Mavenアーカイブをダウンロードする
Maven3.3.3をからダウンロード https://maven.apache.org/download.cgi
OS | アーカイブ名 |
---|---|
ウィンドウズ | apache-maven-3.3.3-bin.zip |
Linux | apache-maven-3.3.3-bin.tar.gz |
マック | apache-maven-3.3.3-bin.tar.gz |
ステップ4-Mavenアーカイブを抽出する
Maven3.3.3をインストールするディレクトリにアーカイブを抽出します。サブディレクトリapache-maven-3.3.3がアーカイブから作成されます。
OS | 場所(インストールによって異なる場合があります) |
---|---|
ウィンドウズ | C:\ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 |
Linux | / usr / local / apache-maven |
マック | / usr / local / apache-maven |
ステップ5-Maven環境変数を設定する
M2_HOME、M2、MAVEN_OPTSを環境変数に追加します。
OS | 出力 |
---|---|
ウィンドウズ | システムプロパティを使用して環境変数を設定します。 M2_HOME = C:\ Program Files \ Apache Software Foundation \ apachemaven-3.3.3 M2 =%M2_HOME%\ bin MAVEN_OPTS = -Xms256m -Xmx512m |
Linux | コマンドターミナルを開き、環境変数を設定します。 エクスポートM2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 エクスポートM2 = $ M2_HOME / bin エクスポートMAVEN_OPTS = -Xms256m -Xmx512m |
マック | コマンドターミナルを開き、環境変数を設定します。 エクスポートM2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 エクスポートM2 = $ M2_HOME / bin エクスポートMAVEN_OPTS = -Xms256m -Xmx512m |
ステップ6-システムパスにMavenビンディレクトリの場所を追加する
次に、M2変数をシステムパスに追加します。
OS | 出力 |
---|---|
ウィンドウズ | 文字列;%M2%をシステム変数Pathの最後に追加します。 |
Linux | PATH = $ M2:$ PATHをエクスポートします |
マック | PATH = $ M2:$ PATHをエクスポートします |
ステップ7-Mavenのインストールを確認する
コンソールを開き、以下を実行します mvn コマンド。
OS | 仕事 | コマンド |
---|---|---|
ウィンドウズ | コマンドコンソールを開く | c:\> mvn --version |
Linux | コマンドターミナルを開く | $ mvn --version |
マック | オープンターミナル | マシン:<joseph $ mvn --version |
最後に、上記のコマンドの出力を確認します。これは次のようになります。
OS | 出力 |
---|---|
ウィンドウズ | Apache Maven 3.3.3(7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17:27:37 + 05:30) Mavenホーム:C:\ Program Files \ Apache Software Foundation \ apache-maven-3.3.3 Javaバージョン:1.7.0_75、ベンダー:Oracle Corporation Javaホーム:C:\ Program Files \ Java \ jdk1.7.0_75 \ jre デフォルトのロケール:en_US、プラットフォームエンコーディング:Cp1252 |
Linux | Apache Maven 3.3.3(7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17:27:37 + 05:30) Mavenホーム:/usr/local/apache-maven/apache-maven-3.3.3 Javaバージョン:1.7.0_75、ベンダー:Oracle Corporation Javaホーム:/usr/local/java-current/jdk1.7.0_75/jre |
マック | Apache Maven 3.3.3(7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17:27:37 + 05:30) Mavenホーム:/usr/local/apache-maven/apache-maven-3.3.3 Javaバージョン:1.7.0_75、ベンダー:Oracle Corporation Javaホーム:/Library/Java/Home/jdk1.7.0_75/jre |
ステップ8-EclipseIDEをセットアップする
このチュートリアルのすべての例は、EclipseIDEを使用して作成されています。したがって、最新バージョンのEclipseをマシンにインストールすることをお勧めします。
Eclipse IDEをインストールするには、から最新のEclipseバイナリをダウンロードします。 https://www.eclipse.org/downloads/。インストールをダウンロードしたら、バイナリディストリビューションを便利な場所に解凍します。たとえば、Windowsの場合はC:\ eclipse、Linux / Unixの場合は/ usr / local / eclipseです。最後に、PATH変数を適切に設定します。
Eclipseは、Windowsマシンで次のコマンドを実行することで起動できます。または、eclipse.exeをダブルクリックするだけです。
%C:\eclipse\eclipse.exe
Eclipseは、Unix(Solaris、Linuxなど)マシンで次のコマンドを実行することで起動できます。
$/usr/local/eclipse/eclipse
起動が成功した後、すべてが正常であれば、次の結果が表示されます。
この最後のステップが完了すると、次の章で説明する最初のJDBCの例に進む準備が整います。
データベーステーブルを作成しましょう Student 私たちのデータベースで TEST。MySQLデータベースを使用していると仮定します。他のデータベースを使用している場合は、それに応じてDDLクエリとSQLクエリを変更できます。
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);
次に、データソースをJDBCテンプレートに提供して、データベースアクセスを取得するように自身を構成できるようにする必要があります。次のようなコードを使用して、XMLファイルでデータソースを構成できます。
<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>
次の章では、構成されたデータベースを使用して最初のアプリケーションを作成します。
JDBCTemplateクラスを使用したSpringJDBCフレームワークに関連する概念を理解するために、次のStudentテーブルで挿入操作と読み取り操作を実装する簡単な例を記述しましょう。
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);
JDBCの概念を示す簡単なコンソールベースのSpringJDBCアプリケーションの作成に進みましょう。
プロジェクトの作成
コマンドコンソールを開き、C:\ MVNディレクトリに移動して、次のコマンドを実行します。 mvn コマンド。
C:\MVN>mvn archetype:generate -DgroupId = com.tutorialspoint -DartifactId = Student
-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = false
Mavenは処理を開始し、完全なJavaアプリケーションプロジェクト構造を作成します。
[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] ------------------------------------------------------------------------
次に、C:/ MVNディレクトリに移動します。(artifactIdで指定された)studentという名前で作成されたJavaアプリケーションプロジェクトが表示されます。POM.xmlを更新して、SpringJDBCの依存関係を含めます。Student.java、StudentMapper.java、MainApp.java、StudentDAO.java、およびStudentJDBCTemplate.javaファイルを追加します。
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>
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
------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 : 15
次の例は、SpringJDBCを使用してInsertクエリを使用してクエリを作成する方法を示しています。StudentTableにいくつかのレコードを挿入します。
構文
String insertQuery = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( insertQuery, name, age);
どこ、
insertQuery −プレースホルダーを持つクエリを挿入します。
jdbcTemplateObject −データベースに学生オブジェクトを挿入するStudentJDBCTemplateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを挿入する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | 章の下で作成されたプロジェクトStudentを更新しますSpring JDBC - First Application。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
------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 : 15
次の例は、SpringJDBCを使用してクエリを読み取る方法を示しています。StudentTableで利用可能なレコードを読み取ります。
構文
String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());
どこ、
selectQuery −生徒を読むためのクエリを選択します。
jdbcTemplateObject −データベースから学生オブジェクトを読み取るStudentJDBCTemplateオブジェクト。
StudentMapper − StudentMapperは、フェッチされた各レコードを学生オブジェクトにマップするRowMapperオブジェクトです。
Spring JDBCに関連する上記の概念を理解するために、クエリを選択する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15
次の例は、SpringJDBCを使用してクエリを更新する方法を示しています。StudentTableで利用可能なレコードを更新します。
構文
String updateQuery = "update Student set age = ? where id = ?";
jdbcTemplateObject.update(updateQuery, age, id);
どこ、
updateQuery −クエリを更新して、プレースホルダーで生徒を更新します。
jdbcTemplateObject −データベース内の学生オブジェクトを更新するStudentJDBCTemplateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを更新する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20
次の例は、SpringJDBCを使用してクエリを削除する方法を示しています。StudentTableで使用可能なレコードの1つを削除します。
構文
String deleteQuery = "delete from Student where id = ?";
jdbcTemplateObject.update(deleteQuery, id);
どこ、
deleteQuery −プレースホルダーを持つ生徒を削除するには、クエリを削除します。
jdbcTemplateObject −データベース内の学生オブジェクトを削除するStudentJDBCTemplateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを削除する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20
次の例は、SpringJDBCを使用してストアドプロシージャを呼び出す方法を示しています。ストアドプロシージャを呼び出すことにより、StudentTableで使用可能なレコードの1つを読み取ります。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"));
どこ、
jdbcCall −ストアドプロシージャを表すSimpleJdbcCallオブジェクト。
in −パラメータをストアドプロシージャに渡すためのSqlParameterSourceオブジェクト。
student −学生オブジェクト。
out −ストアドプロシージャの呼び出し結果の出力を表すオブジェクトをマップします。
ザ・ SimpleJdbcCallクラスを使用して、INおよびOUTパラメータを使用してストアドプロシージャを呼び出すことができます。このアプローチは、Apache Derby、DB2、MySQL、Microsoft SQL Server、Oracle、SybaseなどのRDBMSのいずれかで作業しているときに使用できます。
このアプローチを理解するために、次のMySQLストアドプロシージャを検討してください。このプロシージャは、学生IDを取得し、OUTパラメータを使用して対応する学生の名前と年齢を返します。MySQLコマンドプロンプトを使用して、TESTデータベースにこのストアドプロシージャを作成しましょう-
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 ;
Spring JDBCに関連する上記の概念を理解するために、ストアドプロシージャを呼び出す例を作成しましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
呼び出しを実行するために作成するコードには、INパラメーターを含むSqlParameterSourceの作成が含まれます。入力値に指定された名前を、ストアード・プロシージャーで宣言されたパラメーター名の名前と一致させることが重要です。executeメソッドは、INパラメーターを受け取り、ストアード・プロシージャーで指定された名前でキー設定されたoutパラメーターを含むマップを返します。
以下は、の内容です MainApp.java ファイル。
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());
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
ID : 1, Name : Zara, Age : 11
次の例は、SpringJDBCを使用してストアド関数を呼び出す方法を示しています。ストアド関数を呼び出すことにより、StudentTableで使用可能なレコードの1つを読み取ります。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);
どこ、
in −パラメータをストアド関数に渡すためのSqlParameterSourceオブジェクト。
jdbcCall −ストアド関数を表すSimpleJdbcCallオブジェクト。
jdbcTemplateObject −データベースからストアド関数を呼び出すStudentJDBCTemplateオブジェクト。
student −学生オブジェクト。
ザ・ SimpleJdbcCallクラスを使用して、INパラメータと戻り値を使用してストアド関数を呼び出すことができます。このアプローチは、Apache Derby、DB2、MySQL、Microsoft SQL Server、Oracle、SybaseなどのRDBMSのいずれかで作業しているときに使用できます。
このアプローチを理解するために、次のMySQLストアドプロシージャについて考えてみます。このプロシージャは、学生IDを取得し、対応する学生の名前を返します。それでは、MySQLコマンドプロンプトを使用して、TESTデータベースにこのストアド関数を作成しましょう-
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 ;
Spring JDBCに関連する上記の概念を理解するために、ストアド関数を呼び出す例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
呼び出しを実行するために作成するコードには、INパラメーターを含むSqlParameterSourceの作成が含まれます。入力値に指定された名前を、ストアド関数で宣言されたパラメーター名の名前と一致させることが重要です。executeFunctionメソッドはINパラメータを受け取り、ストアド関数で指定された文字列を返します。
以下は、の内容です MainApp.java ファイル
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() );
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
ID : 1, Name : Zara
次の例は、SpringJDBCを使用して更新クエリを使用してBLOBを更新する方法を示しています。StudentTableで利用可能なレコードを更新します。
学生テーブル
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
IMAGE BLOB,
PRIMARY KEY (ID)
);
構文
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);
どこ、
in −クエリを更新するためのパラメータを渡すSqlParameterSourceオブジェクト。
SqlLobValue − SQL BLOB / CLOB値パラメーターを表すオブジェクト。
jdbcTemplateObject −データベース内の学生オブジェクトを更新するためのnamedParameterJdbcTemplateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを更新する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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 );
}
}
以下は、の内容です MainApp.java ファイル。
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);
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
Updated Record with ID = 1
データベースにクエリを実行すると、保存されているbyte []を確認できます。
次の例は、SpringJDBCを使用して更新クエリを使用してCLOBを更新する方法を示しています。StudentTableで利用可能なレコードを更新します。
学生テーブル
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
DESCRIPTION LONGTEXT,
PRIMARY KEY (ID)
);
構文
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);
どこ、
in −クエリを更新するためのパラメータを渡すSqlParameterSourceオブジェクト。
SqlLobValue − SQL BLOB / CLOB値パラメーターを表すオブジェクト。
jdbcTemplateObject −データベース内の学生オブジェクトを更新するためのnamedParameterJdbcTemplateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを更新する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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 );
}
}
以下は、の内容です MainApp.java ファイル。
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.");
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
Updated Record with ID = 1
データベースに問い合わせることで、保存されている説明を確認できます。
次の例は、SpringJDBCを使用してバッチ更新を行う方法を示しています。単一のバッチ操作でStudentテーブルの使用可能なレコードを更新します。
構文
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();
}
});
どこ、
SQL −クエリを更新して、学生の年齢を更新します。
jdbcTemplateObject −データベース内の学生オブジェクトを更新するStudentJDBCTemplateオブジェクト。
BatchPreparedStatementSetter−バッチエグゼキュータ、オブジェクトのリストstudentおよびインデックスiによって識別されるアイテムごとにPerparedStatementに値を設定します。getBatchSize()は、バッチのサイズを返します。
updateCounts −更新クエリごとに更新された行数を含むint配列。
Spring JDBCに関連する上記の概念を理解するために、バッチ操作を更新する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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!");
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
Initial Students
ID : 1, Age : 11
ID : 3, Age : 15
Records updated!
Updated Students
ID : 1, Age : 10
ID : 3, Age : 10
次の例は、SpringJDBCのオブジェクトを使用してバッチ更新を行う方法を示しています。単一のバッチ操作でStudentテーブルの使用可能なレコードを更新します。
構文
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!");
どこ、
SQL −クエリを更新して、学生の年齢を更新します。
jdbcTemplateObject −データベース内の学生オブジェクトを更新するStudentJDBCTemplateオブジェクト。
batch −オブジェクトのバッチを表すSqlParameterSourceオブジェクト。
updateCounts −更新クエリごとに更新された行数を含むint配列。
Spring JDBCに関連する上記の概念を理解するために、バッチ操作を更新する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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!");
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
Initial Students
ID : 1, Age : 10
ID : 3, Age : 10
Records updated!
Updated Students
ID : 1, Age : 15
ID : 3, Age : 16
次の例は、SpringJDBCを使用して1回の呼び出しで複数のバッチ更新を行う方法を示しています。バッチサイズが1の複数バッチ操作で、Studentテーブルで使用可能なレコードを更新します。
構文
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());
}
});
どこ、
SQL −クエリを更新して、学生の年齢を更新します。
jdbcTemplateObject −データベース内の学生オブジェクトを更新するStudentJDBCTemplateオブジェクト。
ParameterizedPreparedStatementSetter −バッチエグゼキュータ、オブジェクトのリストで識別されるアイテムごとにPerparedStatementに値を設定します。
updateCounts −バッチごとの更新クエリごとの更新された行数を含むint [] []配列。
Spring JDBCに関連する上記の概念を理解するために、複数のバッチ操作を更新する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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!");
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
Initial Students
ID : 1, Age : 15
ID : 3, Age : 16
records updated!
Updated Students
ID : 1, Age : 17
ID : 3, Age : 18
ザ・ org.springframework.jdbc.core.JdbcTemplateclassは、JDBCコアパッケージの中心的なクラスです。JDBCの使用を簡素化し、一般的なエラーを回避するのに役立ちます。コアJDBCワークフローを実行し、SQLを提供して結果を抽出するアプリケーションコードを残します。このクラスは、SQLクエリまたは更新を実行し、ResultSetに対して反復を開始し、JDBC例外をキャッチして、で定義されている一般的でより有益な例外階層に変換します。org.springframework.dao パッケージ。
クラス宣言
以下は、org.springframework.jdbc.core.JdbcTemplateクラスの宣言です。
public class JdbcTemplate
extends JdbcAccessor
implements JdbcOperations
使用法
Step 1 −構成済みのデータソースを使用してJdbcTemplateオブジェクトを作成します。
Step 2 −JdbcTemplateオブジェクトメソッドを使用してデータベース操作を行います。
例
次の例は、JdbcTemplateクラスを使用してクエリを読み取る方法を示しています。StudentTableで利用可能なレコードを読み取ります。
構文
String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());
どこ、
selectQuery −生徒を読むためのクエリを選択します。
jdbcTemplateObject −データベースから学生オブジェクトを読み取るStudentJDBCTemplateオブジェクト。
StudentMapper − StudentMapperは、フェッチされた各レコードを学生オブジェクトにマップするRowMapperオブジェクトです。
Spring JDBCに関連する上記の概念を理解するために、クエリを選択する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15
ザ・ org.springframework.jdbc.core.PreparedStatementSetterinterfaceは、JdbcTemplateクラスで使用される一般的なコールバックインターフェイスとして機能します。このインターフェースは、同じSQLを使用するバッチ内の多数の更新ごとに、JdbcTemplateクラスによって提供されるPreparedStatementに値を設定します。
実装は、必要なパラメータを設定する責任があります。プレースホルダー付きのSQLはすでに提供されています。このインターフェイスは、PreparedStatementCreatorよりも簡単に使用できます。JdbcTemplateはPreparedStatementを作成し、コールバックはパラメーター値の設定のみを担当します。
インターフェイス宣言
以下は、org.springframework.jdbc.core.PreparedStatementSetterインターフェースの宣言です。
public interface PreparedStatementSetter
使用法
Step 1 −構成済みのデータソースを使用してJdbcTemplateオブジェクトを作成します。
Step 2 − JdbcTemplateオブジェクトメソッドを使用してデータベース操作を行い、PreparedStatementSetterオブジェクトを渡してクエリのプレースホルダーを置き換えます。
例
次の例は、JdbcTemplateクラスとPreparedStatementSetterインターフェイスを使用してクエリを読み取る方法を示しています。StudentTableで学生の利用可能な記録を読み取ります。
構文
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());
どこ、
SQL −生徒を読むためのクエリを選択します。
jdbcTemplateObject −データベースから学生オブジェクトを読み取るStudentJDBCTemplateオブジェクト。
PreparedStatementSetter −クエリでパラメータを設定するためのPreparedStatementSetterオブジェクト。
StudentMapper − StudentMapperは、フェッチされた各レコードを学生オブジェクトにマップするRowMapperオブジェクトです。
Spring JDBCに関連する上記の概念を理解するために、クエリを選択する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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);
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
ID : 1, Age : 17
ザ・ org.springframework.jdbc.core.ResultSetExtractorinterfaceは、JdbcTemplateのクエリメソッドで使用されるコールバックインターフェイスです。このインターフェースの実装は、ResultSetから結果を抽出する実際の作業を実行しますが、例外処理について心配する必要はありません。
SQLExceptionsは、JdbcTemplateの呼び出しによってキャッチおよび処理されます。このインターフェースは、主にJDBCフレームワーク自体の中で使用されます。RowMapperは通常、ResultSet処理のより簡単な選択であり、ResultSet全体に対して1つの結果オブジェクトではなく、行ごとに1つの結果オブジェクトをマッピングします。
インターフェイス宣言
以下は、org.springframework.jdbc.core.ResultSetExtractorインターフェースの宣言です。
public interface ResultSetExtractor
使用法
Step 1 −構成済みのデータソースを使用してJdbcTemplateオブジェクトを作成します。
Step 2 − JdbcTemplateオブジェクトメソッドを使用して、ResultSetExtractorを使用して結果セットを解析しながらデータベース操作を行います。
例
次の例は、JdbcTemplateクラスとResultSetExtractorインターフェイスを使用してクエリを読み取る方法を示しています。StudentTableで学生の利用可能な記録を読み取ります。
構文
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;
}
どこ、
SQL −生徒を読むためのクエリを選択します。
jdbcTemplateObject −データベースから学生オブジェクトを読み取るStudentJDBCTemplateオブジェクト。
ResultSetExtractor −結果セットオブジェクトを解析するためのresultSetExtractorオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを選択する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
ID : 1, Age : 17
ID : 3, Age : 18
ザ・ org.springframework.jdbc.core.RowMapper<T>インターフェイスは、JdbcTemplateによって、行ごとにResultSetの行をマッピングするために使用されます。このインターフェイスの実装は、各行を結果オブジェクトにマッピングする実際の作業を実行します。スローされたSQLExceptionは、呼び出し元のJdbcTemplateによってキャッチおよび処理されます。
インターフェイス宣言
以下はの宣言です org.springframework.jdbc.core.RowMapper<T> インターフェイス-
public interface RowMapper<T>
使用法
Step 1 −構成済みのデータソースを使用してJdbcTemplateオブジェクトを作成します。
Step 2 −RowMapperインターフェースを実装するStudentMapperオブジェクトを作成します。
Step 3 − JdbcTemplateオブジェクトメソッドを使用して、StudentMapperオブジェクトの使用中にデータベース操作を行います。
次の例は、springjdbcを使用してクエリを読み取る方法を示しています。StudentMapperオブジェクトを使用して、StudentTableからStudentオブジェクトに読み取ったレコードをマップします。
構文
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
どこ
SQL −クエリを読んで、すべての学生の記録を読みます。
jdbcTemplateObject −データベースから学生レコードを読み取るStudentJDBCTemplateオブジェクト。
StudentMapper −学生レコードを学生オブジェクトにマップするStudentMapperオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、StudentMapperオブジェクトを使用してクエリを読み取り結果をマップする例を作成しましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ザ・ org.springframework.jdbc.core.NamedParameterJdbcTemplateclassは、JDBC操作の基本セットを備えたテンプレートクラスであり、従来の「?」ではなく名前付きパラメーターを使用できます。プレースホルダー。このクラスは、名前付きパラメーターからJDBCスタイル '?'に置換されると、ラップされたJdbcTemplateに委任します。プレースホルダーは実行時に実行されます。また、値のリストを適切な数のプレースホルダーに拡張することもできます。
インターフェイス宣言
以下はの宣言です org.springframework.jdbc.core.NamedParameterJdbcTemplate クラス-
public class NamedParameterJdbcTemplate
extends Object
implements NamedParameterJdbcOperations
構文
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);
どこ、
in −クエリを更新するためのパラメータを渡すSqlParameterSourceオブジェクト。
SqlLobValue − SQL BLOB / CLOB値パラメーターを表すオブジェクト。
jdbcTemplateObject −データベース内の学生オブジェクトを更新するためのnamedParameterJdbcTemplateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを更新する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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 );
}
}
以下は、の内容です MainApp.java ファイル。
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.");
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
Updated Record with ID = 1
データベースに問い合わせることで、保存されている説明を確認できます。
ザ・ org.springframework.jdbc.core.SimpleJdbcInsertクラスはマルチスレッドで再利用可能なオブジェクトであり、テーブルに簡単に挿入する機能を提供します。基本的な挿入ステートメントの作成に必要なコードを簡素化するためのメタデータ処理を提供します。実際の挿入は、SpringのJdbcTemplateを使用して処理されています
クラス宣言
以下はの宣言です org.springframework.jdbc.core.SimpleJdbcInsert クラス-
public class SimpleJdbcInsert
extends AbstractJdbcInsert
implements SimpleJdbcInsertOperations
次の例は、SpringJDBCを使用してクエリを挿入する方法を示しています。SimpleJdbcInsertオブジェクトを使用してStudentTableに1つのレコードを挿入します。
構文
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);
どこ、
jdbcInsert −学生テーブルにレコードを挿入するSimpleJdbcInsertオブジェクト。
jdbcTemplateObject −データベース内の学生オブジェクトを読み取るStudentJDBCTemplateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、クエリを挿入する例を書いてみましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
------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 : 12
ザ・ org.springframework.jdbc.core.SimpleJdbcCallクラスは、ストアドプロシージャまたはストアド関数の呼び出しを表す、マルチスレッドで再利用可能なオブジェクトです。基本的なストアドプロシージャ/関数にアクセスするために必要なコードを簡素化するメタデータ処理を提供します。
提供する必要があるのは、プロシージャ/関数の名前と、呼び出しを実行するときにパラメータを含むマップだけです。提供されたパラメーターの名前は、ストアード・プロシージャーが作成されたときに宣言されたinおよびoutパラメーターと照合されます。
クラス宣言
以下はの宣言です org.springframework.jdbc.core.SimpleJdbcCall クラス-
public class SimpleJdbcCall
extends AbstractJdbcCall
implements SimpleJdbcCallOperations
次の例は、SpringSimpleJdbcCallを使用してストアドプロシージャを呼び出す方法を示しています。ストアドプロシージャを呼び出すことにより、StudentTableで使用可能なレコードの1つを読み取ります。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"));
どこ、
jdbcCall −ストアドプロシージャを表すSimpleJdbcCallオブジェクト。
in −パラメータをストアドプロシージャに渡すためのSqlParameterSourceオブジェクト。
student −学生オブジェクト。
out −ストアドプロシージャの呼び出し結果の出力を表すオブジェクトをマップします。
Spring JDBCに関連する上記の概念を理解するために、ストアドプロシージャを呼び出す例を作成しましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
呼び出しを実行するために作成するコードには、INパラメーターを含むSqlParameterSourceの作成が含まれます。入力値に指定された名前を、ストアード・プロシージャーで宣言されたパラメーター名の名前と一致させることが重要です。executeメソッドは、INパラメーターを受け取り、ストアード・プロシージャーで指定された名前でキー設定されたoutパラメーターを含むマップを返します。
以下は、の内容です MainApp.java ファイル。
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());
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
ID : 1, Name : Zara, Age : 11
ザ・ org.springframework.jdbc.object.SqlQuery クラスは、SQLクエリを表す再利用可能な操作オブジェクトを提供します。
クラス宣言
以下はの宣言です org.springframework.jdbc.object.SqlQuery クラス-
public abstract class SqlQuery<T>
extends SqlOperation
使用法
Step 1 −構成済みのデータソースを使用してJdbcTemplateオブジェクトを作成します。
Step 2 −RowMapperインターフェースを実装するStudentMapperオブジェクトを作成します。
Step 3 − SqlQueryオブジェクトの使用中に、JdbcTemplateオブジェクトメソッドを使用してデータベース操作を行います。
次の例は、SqlQueryオブジェクトを使用してクエリを読み取る方法を示しています。StudentMapperオブジェクトを使用して、StudentTableからStudentオブジェクトに読み取ったレコードをマップします。
構文
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();
どこ、
SQL −クエリを読んで、すべての学生の記録を読みます。
jdbcTemplateObject −データベースから学生レコードを読み取るStudentJDBCTemplateオブジェクト。
StudentMapper −学生レコードを学生オブジェクトにマップするStudentMapperオブジェクト。
SqlQuery −学生レコードをクエリし、それらを学生オブジェクトにマップするためのSqlQueryオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、StudentMapperオブジェクトを使用してクエリを読み取り、結果をマップする例を作成しましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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();
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ID : 4, Name : Nuha, Age : 12
ザ・ org.springframework.jdbc.object.SqlUpdate クラスは、SQL更新を表す再利用可能な操作オブジェクトを提供します。
クラス宣言
以下はの宣言です org.springframework.jdbc.object.SqlUpdate クラス-
public abstract class SqlUpdate<T>
extends SqlOperation
使用法
Step 1 −構成済みのデータソースを使用してJdbcTemplateオブジェクトを作成します。
Step 2 −RowMapperインターフェースを実装するStudentMapperオブジェクトを作成します。
Step 3 − SqlUpdateオブジェクトの使用中にデータベース操作を実行するには、JdbcTemplateオブジェクトメソッドを使用します。
次の例は、SqlUpdateオブジェクトを使用してクエリを更新する方法を示しています。StudentMapperオブジェクトを使用して、更新レコードをStudentTableからStudentオブジェクトにマップします。
構文
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());
どこ、
SQL -クエリを更新して、学生の記録を更新します。
jdbcTemplateObject −データベースから学生レコードを読み取るStudentJDBCTemplateオブジェクト。
StudentMapper −学生レコードを学生オブジェクトにマップするStudentMapperオブジェクト。
sqlUpdate −学生の記録を更新するためのSqlUpdateオブジェクト。
Spring JDBCに関連する上記の概念を理解するために、StudentMapperオブジェクトを使用してクエリを読み取り結果をマップする例を作成しましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
以下は、の内容です MainApp.java ファイル。
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());
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
----Updating Record with ID = 1 -----
Updated Record with ID = 1
----Listing Record with ID = 1 -----
ID : 1, Name : Zara, Age : 10
ザ・ org.springframework.jdbc.core.StoredProcedureclassは、RDBMSストアドプロシージャのオブジェクト抽象化のためのスーパークラスです。このクラスは抽象であり、サブクラスは、提供されたexecute(java.lang.Object ...)メソッドに委任する呼び出し用の型付きメソッドを提供することを目的としています。継承されたSQLプロパティは、RDBMSのストアドプロシージャの名前です。
クラス宣言
以下はの宣言です org.springframework.jdbc.core.StoredProcedure クラス-
public abstract class StoredProcedure
extends SqlCall
次の例は、SpringStoredProcedureを使用してストアドプロシージャを呼び出す方法を示しています。ストアドプロシージャを呼び出すことにより、StudentTableで使用可能なレコードの1つを読み取ります。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;
}
}
どこ、
StoredProcedure −ストアドプロシージャを表すStoredProcedureオブジェクト。
StudentProcedure − StudentProcedureオブジェクトはStoredProcedureを拡張して、入力、出力変数を宣言し、結果をStudentオブジェクトにマップします。
student −学生オブジェクト。
Spring JDBCに関連する上記の概念を理解するために、ストアドプロシージャを呼び出す例を作成しましょう。例を書くために、動作するEclipse IDEを配置し、次の手順を使用してSpringアプリケーションを作成します。
ステップ | 説明 |
---|---|
1 | Spring JDBC-FirstApplicationの章で作成されたプロジェクトStudentを更新します。 |
2 | Bean構成を更新し、以下で説明するようにアプリケーションを実行します。 |
以下は、データアクセスオブジェクトインターフェイスファイルの内容です。 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);
}
以下は、の内容です Student.java ファイル。
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;
}
}
以下は、の内容です StudentMapper.java ファイル。
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;
}
}
以下は実装クラスファイルです StudentJDBCTemplate.java 定義されたDAOインターフェース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;
}
}
呼び出しを実行するために作成するコードには、INパラメーターを含むSqlParameterSourceの作成が含まれます。入力値に指定された名前を、ストアード・プロシージャーで宣言されたパラメーター名の名前と一致させることが重要です。executeメソッドは、INパラメーターを受け取り、ストアード・プロシージャーで指定された名前でキー設定されたoutパラメーターを含むマップを返します。
以下は、の内容です MainApp.java ファイル。
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());
}
}
以下は設定ファイルです 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>
ソースとBeanの構成ファイルの作成が完了したら、アプリケーションを実行しましょう。アプリケーションに問題がない場合は、次のメッセージが出力されます。
ID : 1, Name : Zara, Age : 10