Spring MySQL (JDBC) Tutorial

Auch wenn der primäre Anwendungsbereich des Spring Frameworks in der JEE Anwendung liegt, kann die JDBC Unterstützung unabhängig vom gesamten Framework und somit in jeder JDBC basierten Anwendung genutzt werden. Durch Verwendung der Spring JDBC-API wird die Datenbanknutzung nicht nur einfacher, sondern auch sicherer.
Spring übernimmt hierfür beispielsweise die Verwaltung (z.B. Öffnen, Schließen) der Datenbankverbindungen, die Vorbereitung und Ausführung von Statements sowie die Verarbeitung der Transaktionen.

In dem Tutorial Java MySQL (JDBC) Tutorial wurde bereits gezeigt, wie eine Datenbankverbindung zu einem MySQL Server über den „normalen“ Weg hergestellt werden kann. In diesem Tutorial wird ebenfalls eine Datenbankverbindung zu einem MySQL Server hergestellt und mit der selben Ausgabe wie in dem zuvor genannten Tutorial ausgegeben, um den Aufwand der Verwendung des Spring JDBC-API einschätzen und gegenüber stellen zu können.

Vorweg möchte ich auf die in der Spring Dokumentation enthaltene who does what? Tabelle hinweisen, die einen guten Einblick über die Zuständigkeiten der JDBC-API des Spring Frameworks zeigt.

Action Spring You
Define connection parameters.   X
Open the connection. X  
Specify the SQL statement.   X
Declare parameters and provide parameter values   X
Prepare and execute the statement. X  
Set up the loop to iterate through the results (if any). X  
Do the work for each iteration.   X
Process any exception. X  
Handle transactions. X  
Close the connection, statement and resultset. X  

Spring JDBC-API – was benötigt wird

Um mit der JDBC-API arbeiten zu können, müssen folgende JAR Dateien dem Classpath hinzugefügt werden.

  • org.springframework.beans-3.1.0.M2.jar
  • org.springframework.core-3.1.0.M2.jar
  • org.springframework.jdbc-3.1.0.M2.jar
  • org.springframework.jdbc-sources-3.1.0.M2.jar
  • org.springframework.transaction-3.1.0.M2.jar
  • mysql-connector-java-5.1.14/mysql-connector-java-5.1.14-bin.jar
  • commons-dbcp-1.4/commons-dbcp-1.4.jar
  • org.springframework.context.support-3.1.0.M2.jar
  • org.springframework.context-3.1.0.M2.jar
  • commons-logging-1.1.1.jar
  • org.springframework.asm-3.1.0.M2.jar
  • org.springframework.expression-3.1.0.M2.jar
  • commons-pool-1.5.6.jar

Neues Java Projekt erstellen

Ein neues Java Projekt wird unter folgendem Namen angelegt:

  • SpringMySql

Packages hinzufügen

Folgende Packages müssen erstellt werden:

  • de.itblogging.spring.mysql
  • de.itblogging.spring.config

config Datei anlegen

Folgende Datei wird in dem Package de.itblogging.spring.config angelegt:

  • config.xml

Ein neues Bean mit der ID mysqlDataSource wird in dieser Konfigurationsdatei registriert. Die Treiberklasse, die URL des MySQL Servers sowie die Benutzerdaten werden gepflegt.
Hinweis: Die hier in dem Bean hardcodierten Werte können natürlich auch in einer Properties Datei ausgelagert werden. Eine weitere Option wäre die Erstellung der DataSource direkt im JavaCode. Ein Beispiel ist in der JdbcTest.java Klasse auskommentiert wiederzufinden.

<?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.xsd">

	<bean id="mysqlDataSource" class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://192.168.0.110:3306/sakila" />
		<property name="username" value="simon" />
		<property name="password" value="toor" />
	</bean>

</beans>

Java Datei anlegen

In dem Package de.itblogging.spring.mysql wird eine Testklasse angelegt:

  • JdbcTest.java

Die Klasse setzt über das JdbcTemplate ein SQL ab und schreibt das Ergebnis in die Konsole.

package de.itblogging.spring.mysql;

import java.sql.ResultSet;
import java.sql.SQLException;

import javax.sql.DataSource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public class JdbcTest
{

	/**
	 * Liefert die in der config.xml Konfigurierte DataSource
	 *
	 * @return MySQL DataSource
	 */
	private DataSource getDataSource()
	{
		// Pfad zu der Konfigurationsdate
		final String CONFIGPATH = "/de/itblogging/spring/config/config.xml";
		ApplicationContext ac = new ClassPathXmlApplicationContext(CONFIGPATH);
		// Bean mit der ID 'mysqlDataSource' (MySQL Konfiguration) laden
		DataSource dataSource = (DataSource) ac.getBean("mysqlDataSource");

		// Beispiel einer hardcodierten DataSource
//		DriverManagerDataSource dataSource2 = new DriverManagerDataSource();
//		dataSource2.setDriverClassName("com.mysql.jdbc.Driver");
//		dataSource2.setUrl("jdbc:mysql://192.168.0.110:3306/sakila");
//		dataSource2.setUsername("simon");
//		dataSource2.setPassword("toor");

		return dataSource;
	}

	/**
	 * Liefert ein mit der vorkonfigurierten DataSource gefülltes JdbcTemplate
	 *
	 * @return JdbcTemplate inkl. DataSource
	 */
	private JdbcTemplate getJdbcTemplate()
	{
		DataSource dataSource = getDataSource();
		return new JdbcTemplate(dataSource);
	}

	/**
	 * Setzt eine normale SQL Query ab und schreibt das Ergebnis in die Konsole
	 */
	private void simpleSqlQuery()
	{
		JdbcTemplate jdbcTemplate = getJdbcTemplate();

		String sql = "SELECT first_name, last_name from actor ORDER BY last_name";
		jdbcTemplate.query(sql,
				new RowMapper<String>()
				{
					@Override
					public String mapRow(final ResultSet result, final int arg1)
							throws SQLException
					{
						String first_name = result.getString("first_name");
						String last_name = result.getString(2);
						String name = last_name + ", " + first_name;

						// Der Name wird in die Konsole geschrieben
						System.out.println(name);

						return null;
					}
				});
	}

	public static void main(String[] args)
	{
		new JdbcTest().simpleSqlQuery();
	}

}

In diesem Beispiel wird der RowMapper zur Datenbankabfrage genutzt. Weitere Beispiele verschiedener Querys sind im Beitrag Spring JdbcTemplate Query Beispiele zu finden.

JdbcTest.java ausführen

Das Ergebnis wird wie erwartet in der Konsole ausgegeben.

GUINESS, PENELOPE
WAHLBERG, NICK
CHASE, ED
DAVIS, JENNIFER
LOLLOBRIGIDA, JOHNNY
NICHOLSON, BETTE
...

JDBC Helferklassen

Ist einmal mit Hilfe der DataSource eine JDBC Helferklasse (in diesem Fall JDBCTemplate) erstellt worden, können SQL Befehle über diese Objekt abgesetzt werden. Neben dem JDBCTemplate gibt es viele weitere Helferklassen wie z.B.

  • NamedParameterJdbcTemplate
  • SimpleJdbcTemplate
  • SimpleJdbcInsert
  • SimpleJdbcCall

Einige Anwendungsbeispiele mit Hilfe dieser Helferklassen werde ich in den nächsten Artikeln aufzeigen.