Features: Integration anderer Libraries und Frameworks

Features: Integration anderer Libraries und Frameworks

• Übersicht
• Data Access Objects - JDBC
• Object/Relational Mapping
• Java Enterprise Edition - Enterprise Java Beans & Remoting
• Web - Spring MVC
• Dynamische Sprachen

1. core
   Das core-Paket bietet Unterstützung bei dem Zugriff auf Datenbanken mit JDBC. Es bietet die Klasse JdbcTemplate an. Mit dieser Klasse sind Datenbankabfragen einfacher zu programmieren. Der Programmierer muss sich nicht mehr um das Herstellen der Verbindung, die Ausführung des Statements, die Exception-Behandlung oder das Schließen der Verbindung kümmern. Es ist nur noch nötig das Statement festzulegen und die Ergebnisse zu behandeln. Eine XML-Konfigurationdatei zum Ausführen von Statements und Queries könnte wie folgt aussehen:

   <!-- XML-Header -->
   <beans>
     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
       <property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
       <property name="url" value="jdbc.hsqldb:hsql://localhost:"/>
       <property name="username" value="system"/>
       <property name="password" value="manager"/>
     </bean>
     <bean id="execStatement" class="ExecStatement">
       <property name="dataSource" ref="dataSource"/>
     </bean>
     <bean id="runQuery" class="RunQuery">
       <property name="dataSource" ref="dataSource"/>
     </bean>
   </beans>
   

   Dies konfiguriert eine Bean dataSource, die alle Informationen zum Verbinden mit einer Datenbank enthält. Spring stellt verschiedene DataSources zur Verfügung. Die hier genutzte DriverManagerDataSource ermöglicht es Verbindung zu Datenbanken mit dem angegebenen Treiber herzustellen. Spring bietet verschiedene vorgefertige, konfigurierbare DataSources und abstrakte Klassen, um eigene DataSources zu erstellen, an. Die Bean execStatement bekommt, um den Zugriff auf die Datenbank zu ermöglichen, eine Referenz auf diese DataSource zugewiesen. Dies gilt auch für die Bean runQuery. Die Klasse ExecStatement, welche die komplette Behandlung des Statements beinhaltet, sieht folgendermaßen aus:

   import javax.sql.DataSource;
   import org.springframework.jdbc.core.JdbcTemplate;
   
   public class ExecStatement {
     private JdbcTemplate jt;
     private DataSource dataSource;
   
     public void setDataSource(DataSource dataSource) {
       this.dataSource = dataSource;
     }
   
     public void doExecute() {
       jt = new JdbcTemplate(dataSource);
       jt.execute("create table mytable (id integer, name varchar(100))");
     }
   }
   

   Bei Erzeugung der Bean durch Spring wird die Eigenschaft dataSource durch die entsprechende Setter-Methode gestezt. Zum Ausführen des Statements wird lediglich die Methode doExecute aufgerufen.
   Die Klasse runQuery zum Ausführen von Queries sieht wie folgt aus:

   import javax.sql.DataSource;
   import org.springframework.jdbc.core.JdbcTemplate;
   
   public class RunQuery {
     private JdbcTemplate jt;
     private DataSource dataSource;
   
     public void setDataSource(DataSource dataSource) {
       this.dataSource = dataSource;
     }
   
     public int getCount() {
       jt = new JdbcTemplate(dataSource);
       int count = jt.queryForInt("select count(*) from mytable");
       return count;
     }
   
     public List getList() {
       jt = new JdbcTemplate(dataSource);
       List rows = jt.queryForList("select * from mytable");
       return rows;
     }
   }
   

   Die Erzeugung geschieht wie auch bei dem Ausführen des Statements. Das JdbcTemplate von Spring bietet verschiedene Methoden um auf Datenbanken zuzugreifen. Weitere Methoden sind zum Beispiel queryForLong, update oder queryForObject.
2. datasource
   In dem Paket datasource bietet Spring folgende fertige und abstrakte Klassen sowie Tools für den Zugriff auf Datenbanken:

   DataSourceUtils	bietet statische Klassen zum Aufbauen und Schließen von Verbindungen.
   SmartDataSource	Interface gegen das komplett eigene DataSources geschrieben werden können.
   AbstractDataSource	Abstrakte Klasse, die zum einfachen Erstellen von eigenen DataSources erweitert werden kann.
   SingleConnectionDataSource	Vordefinierte DataSource bei der nur eine Verbindung mit der Datenbank hergestellt wird. Aufrufe von close() werden ignoriert. Verbindung wird erst beim Zerstören der Instanz geschlossen.
   DriverManagerDataSource	Erstellt Verbindung mit angegebenen Treiber. Bei jedem Zugriff wird einen neue Verbindung hergestellt.
   TransactionAwareDataSourceProxy	Proxy, der eine echte DataSource ummantelt um Transaktionsmanagment in Form von Commits und Rollbacks zu realisieren.
   DataSourceTransactionManager	Transaktionsmanagment-fähige Implementation.

   Zum Testen empfiehlt sich die SingleConnectionDataSource, die allerdings nicht Thread-sicher ist. Später sollte die DriverManagerDataSource genutzt und gegebenenfalls mit dem DataSourceTransactionManager ummantelt werden.
3. support
   Das Paket support ermöglicht das Übersetzen von SQL-Exception zu DataAccessException. Spring bietet eine umfangreichere Hierarchie für Exceptions beim Datenbankenzugriff als JDBC. Mithilfe dieser Hierarchie ist es möglich differenzierter auf Exceptions einzugehen. Die Umwandlung der Fehler erfolgt bei der Nutzung des JdbcTemplate automatisch. Es ist über das Erweitern der Klasse SQLErrorCodeSQLExceptionTranslator auch möglich die Umwandlung der Fehler eigenen Bedürfnissen anzupassen.
4. object
   Spring bietet in diesem Paket eine Möglichkeit die Ergebnisse von Datenbankabfragen in Objekte umzuwandeln. Wenn aus einer Abfrage eine Liste von Zeilen zurückkommt gibt es hier die Möglichkeit alle Ergebniszeilen zu durchlaufen und jede in ein Objekt zu schreiben. Spring bietet dafür die abstrakte Klasse MappingSqlQuery, in welcher der Konstruktor sowie die Methode mapRow implementiert werden müssen. Eine vollständige Implementierung könnte folgendermaßen aussehen:

   import org.springframework.jdbc.object.MappingSqlQuery;
   
   private class KundeMappingQuery extends MappingSqlQuery {
   
     public KundeMappingQuery(DataSource ds) {
       super(ds, "SELECT id, name FROM mytable");
       compile();
     }
   
     public Object mapRow(ResultSet rs, int rowNumber) throws SQLException {
       Kunde kunde = new Kunde();
       kunde.setId((Integer) rs.getObject("id"));
       kunde.setName(rs.getString("name"));
       return kunde;
     } 
   }
   

   Hier wird eine Abfrage und die Umwandlung einer Ergebniszeile in ein Objekt beschrieben.
   Der Zugriff auf die erzeugten Objekte geschieht dann wie folgt:

   public List getKunden() {
     KundeMappingQuery kundeQuery = new KundeMappingQuery(dataSource); 
     List kunden = kundeQuery.execute();
     return kunden;
   }
   

• Spring bietet die Möglichkeit EJBs zu verwalten. Eventuelle benötigte Business Deligates erzeugt Spring dabei automatisch. EJBs können damit ohne JDNI Lookups und Service Locators, und damit auch außerhalb einer Java Servers, genutzt werden ohne dass der Programmierer die Business Deligates von Hand schreiben muss.
• Es ist möglich Webservices und Remoting unter Spring zu integrieren. Spring unterstüzt zum Beispiel Remote Method Invocation (RMI), JAXRPC, Hessian und Burlap. RMI-Implementierungen in Spring können dabei sehr kurz gehalten werden. Sobald gegen Interfaces programmiert sind und diese dem Client bekannt sind, ist ein einfacher Zugriff auf Instanzen von Klassen, die diese Interfaces implementieren, möglich.

<web-app>
  <servlet>
    <servlet-name>name_des_containers</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>name_des_containers</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>
</web-app>