{"id":4,"date":"2005-12-17T18:26:00","date_gmt":"2005-12-17T18:26:00","guid":{"rendered":"http:\/\/www.tutego.de\/blog\/javainsel\/?p=4"},"modified":"2005-12-17T18:26:00","modified_gmt":"2005-12-17T18:26:00","slug":"mit-spring-und-dem-jdbctemplate-auf-eine-hibernate-datenbank","status":"publish","type":"post","link":"https:\/\/www.tutego.de\/blog\/javainsel\/2005\/12\/mit-spring-und-dem-jdbctemplate-auf-eine-hibernate-datenbank\/","title":{"rendered":"Mit Spring und dem JdbcTemplate auf eine Hibernate-Datenbank"},"content":{"rendered":"

Das folgende Beispiel soll zeigen, wie man mit Spring arbeitet und Daten in einer relationalen Datenbank persistent macht. Um das Bespiel zum Laufen zu bringen m\u00fcssen im Klassenpfad sein: hsqldb.jar<\/i>, spring.jar<\/i>, log4j-1.2.9.jar<\/i> und common-logging.jar<\/i>. F\u00fcr die Log-Meldungen setzen wir in den Klassenpfad die Datei log4j.properties<\/i>:<\/p>\n

log4j.rootCategory=WARN, A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%m%n<\/pre>\n
Beginnen wir mit unserem Gesch\u00e4ftsobjekt, einem Kunden:<\/p>\n
package com.javatutor.domain;

public class Customer
{
private int    id;

private String name;

public int getId()
{
  return id;
}

public void setId( int id )
{
  this.id = id;
}

public String getName()
{
  return name;
}

public void setName( String name )
{
  this.name = name;
}

@Override
public String toString()
{
  return String.format( \"Customer[id=%d, name=%s]\", id, name );
}
}
<\/pre>\n
F\u00fcr diesen Kunden definieren wir eine DAO-Schnittstelle, die uns sp\u00e4ter Exemplare der Gesch\u00e4ftsobjekte gibt und die Speicherung erm\u00f6glichen.<\/p>\n
package com.javatutor.dao;

import java.util.Collection;

import com.javatutor.domain.Customer;

public interface CustomerDao
{
Collection<Customer> getCustomers();

Customer findCustomerById( int id );

void save( Customer customer );
}<\/pre>\n
Zum Testen der Applikation beginnen wir mit einer einfach DAO-Implementierung, die Kunden in einer HashMap speichert.<\/p>\n

package com.javatutor.dao.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import com.javatutor.dao.CustomerDao;
import com.javatutor.domain.Customer;

public class CustomerDaoMapImpl implements CustomerDao
{
 private Map<Integer, Customer> map = new HashMap<Integer, Customer>();

 public Collection<Customer> getCustomers()
 {
   return map.values();
 }

 public Customer findCustomerById( int id )
 {
   return map.get( id );
 }

 public void save( Customer customer )
 {
   map.put( customer.getId(), customer );
 }
}
<\/pre>\n
Eine Applikation wird \u00fcber die Spring-Konfigurationsdatei sp\u00e4ter mit einem konkreten CustomerDao gespritzt. Die Methode haveFun() legt einige Business-Objekte an und speichert sie \u00fcber das DAO.<\/p>\n

package com.javatutor;

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

import com.javatutor.dao.CustomerDao;
import com.javatutor.domain.Customer;

public class Application
{
 private CustomerDao customerDao;

 public void setCustomerDao( CustomerDao customerDao )
 {
   this.customerDao = customerDao;
 }

 private void haveFun()
 {
   System.out.println( customerDao.getCustomers() );

   Customer c1 = new Customer();
   c1.setId( 0 );
   c1.setName( \"Christian Ullenboom\" );
   customerDao.save( c1 );

   System.out.println( customerDao.findCustomerById( 0 ) );
  
   System.out.println( customerDao.getCustomers() );

   Customer c2 = new Customer();
   c2.setId( 1 );
   c2.setName( \"Tantiana Roujitcher\" );
   customerDao.save( c2 );

   System.out.println( customerDao.getCustomers() );
 }

 \/\/

 public static void main( String[] args )
 {
   ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext( \"spring.xml\" );
   Application bean = (Application) context.getBean( \"Application\" );
   bean.haveFun();
 }
}
<\/pre>\n
Jetzt fehlt nur noch die XML-Datei f\u00fcr Spring:<\/p>\n

<?xml version=\"1.0\"?>
<!DOCTYPE beans PUBLIC \"-\/\/SPRING\/\/DTD BEAN\/\/EN\"
\"http:\/\/www.springframework.org\/dtd\/spring-beans.dtd\">

<beans>
<bean id=\"Application\" class=\"com.javatutor.Application\">
 <property name=\"customerDao\">
  <ref local=\"CustomerDao\" \/>
 <\/property>
<\/bean>
<bean id=\"CustomerDao\" class=\"com.javatutor.dao.map.CustomerDaoMapImpl\" \/>
<\/beans>
<\/pre>\n
Startet man das Programm, ist die Ausgabe<\/p>\n

[]
Customer[id=0, name=Christian Ullenboom]
[Customer[id=0, name=Christian Ullenboom]]
[Customer[id=1, name=Tantiana Roujitcher], Customer[id=0, name=Christian Ullenboom]]
<\/pre>\n
Prima. Es klappt. Jetzt kommt eine DAO-Implementierung f\u00fcr JDBC. Zun\u00e4chst die Klasse.<\/p>\n

package com.javatutor.dao.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;

import org.springframework.dao.IncorrectResultSizeDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

import com.javatutor.dao.CustomerDao;
import com.javatutor.domain.Customer;

public class CustomerDaoJdbcImpl extends JdbcTemplate implements CustomerDao
{
@SuppressWarnings(\"unchecked\")
public Collection<Customer> getCustomers()
{
  return query( \"SELECT Id, Name FROM Customers\", new CustomerRowMapper() );
}

public Customer findCustomerById( int id )
{
  String sql = \"SELECT Id, Name FROM Customers WHERE Id = ?\";

  try
  {
    return (Customer) queryForObject( sql,
                     new Object[] { id },
                     new CustomerRowMapper());
  }
  catch ( IncorrectResultSizeDataAccessException e ) { }

  return null;
}

public void save( Customer customer )
{
  if ( findCustomerById( customer.getId() ) == null )
  {
    Object[] args = { customer.getId(), customer.getName() };
    update( \"INSERT INTO Customers (Id, Name) VALUES (?,?)\", args );
  }
  else
  {
    Object[] args = { customer.getName(), customer.getId() };
    update( \"UPDATE Customers SET Name = ? WHERE Id = ?\", args );
  }
}
}

class CustomerRowMapper implements RowMapper
{
public Object mapRow( ResultSet rs, int rowNum ) throws SQLException
{
  Customer c = new Customer();
  c.setId( rs.getInt( \"Id\" ) );
  c.setName( rs.getString( \"Name\" ) );
  return c;
}
}
<\/pre>\n
Und in der XML-Datei erg\u00e4nzen wir f\u00fcr den JDBC-DAO:<\/p>\n
<bean id=\"CustomerDaoJdbc\" class=\"com.javatutor.dao.jdbc.CustomerDaoJdbcImpl\">
<property name=\"dataSource\"><ref local=\"DataSource\" \/><\/property>
<\/bean>

<bean id=\"DataSource\" class=\"org.springframework.jdbc.datasource.DriverManagerDataSource\">
<property name=\"driverClassName\">
 <value>org.hsqldb.jdbcDriver<\/value>
<\/property>
<property name=\"url\">
 <value>jdbc:hsqldb:mem:customers<\/value>
<\/property>
<property name=\"username\">
 <value>sa<\/value>
<\/property>
<property name=\"password\">
 <value><\/value>
<\/property>
<\/bean><\/pre>\n
Damit unsere Applikation mit dem neuen JDBC-DAO gespritzt wird setzt man.<\/p>\n
 <bean id=\"Application\" class=\"com.javatutor.Application\">
 <property name=\"customerDao\">
  <ref local=\"CustomerDaoJdbc\" \/>
 <\/property>
 <property name=\"dataSource\">
  <ref local=\"DataSource\" \/>
 <\/property>
<\/bean><\/pre>\n
Gleichzeitig geben wir der Applikation eine DataSource, damit sie die Tabelle f\u00fcr die Datenbank anlegen kann.<\/p>\n

public void setDataSource( DataSource dataSource )
{
 new JdbcTemplate( dataSource ).execute( \"CREATE TABLE Customers( Id INTEGER, Name VARCHAR(128) ) \" );
}
<\/pre>\n
Das gestartet Programm gibt nun die gleiche Ausgabe.<\/p>\n","protected":false},"excerpt":{"rendered":"
Das folgende Beispiel soll zeigen, wie man mit Spring arbeitet und Daten in einer relationalen Datenbank persistent macht. Um das Bespiel zum Laufen zu bringen m\u00fcssen im Klassenpfad sein: hsqldb.jar, spring.jar, log4j-1.2.9.jar und common-logging.jar. F\u00fcr die Log-Meldungen setzen wir in den Klassenpfad die Datei log4j.properties: log4j.rootCategory=WARN, A1log4j.appender.A1=org.apache.log4j.ConsoleAppenderlog4j.appender.A1.layout=org.apache.log4j.PatternLayoutlog4j.appender.A1.layout.ConversionPattern=%m%n Beginnen wir mit unserem Gesch\u00e4ftsobjekt, einem Kunden: package […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":"","_links_to":"","_links_to_target":""},"categories":[3],"tags":[],"class_list":["post-4","post","type-post","status-publish","format-standard","hentry","category-spring"],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/comments?post=4"}],"version-history":[{"count":0,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/posts\/4\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/media?parent=4"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/categories?post=4"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tutego.de\/blog\/javainsel\/wp-json\/wp\/v2\/tags?post=4"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}