In diesem Tutorial wird Schritt für Schritt die Erstellung einer einfachen Flexanwendung, welche Zugriff auf eine MySQL Datenbank über BlazeDS/Hibernate hat, erklärt. Wer kein Hibernate einsetzen möchte oder kann, sollte besser dieses Tutorial verwenden, oder die Stellen mit Hibernate einfach großzügig überlesen.

Vorraussetzungen:

• Adobe Flex Builder 3
• Adobe BlazeDS (Turnkey)
• MySQL 5.0 oder höher
• MySQL Connector/J 5.1
• Hibernate 3 oder höher
• Sun JDK 6 Update 10 oder höher

1. Flex Builder einrichten:

Um die Programmierumgebung angenehmer zu machen, richten wir den Flex Builder 3 zunächst so ein, dass damit auch Java-Klassen erstellt und kompiliert werden können:

Help - Software and Updates -> Find and Install... -> Search for new features to install

In der Liste “The Eclipse Project Updates” auswählen und auf “Finish” klicken. Der Update Manager fordert u.U. während der Suche auf, einen geeigneten Update Mirror auswählen. Die Suche kann ein paar Minuten dauern. Ist die Suche abgeschlossen, in der Liste bei

The Eclipse Project Updates -> Eclipse 3.3.2 -> Eclipse Java Development Tools 3.3.2xxx

ein Häkchen machen. Dann auf “Next”, den Vereinbarungen zustimmen, auf “Next” und dann auf “Finish” klicken. Während der Installation der Verifizierung zustimmen und auf “Install all” klicken. Nach der Installation den Flex Builder neu starten. Er ist nun fähig, wie das normale Eclipse, Java-Klassen zu erstellen und kompilieren.

2. BlazeDS einrichten:

BlazeDS Turnkey kommt bereits mit einer fertig konfigurierten Apache Tomcat Umgebung. Damit unser Flex Projekt nachher korrekt läuft, müssen allerdings noch ein paar Bibliotheken hinzugefügt werden. Dazu folgende Dateien nach %blazeds%/tomcat/webapps/blazeds/WEB-INF/lib kopieren (Hinweis: Von hibernate werden die Pakete Core, Annotations und EntityManager benötigt!):

von Hibernate:

• antlr.jar,asm.jar,asm-attrs.jar, cglib.jar, commons-collections.jar, dom4j.jar, ejb3-persistence.jar, hibernate3.jar, hibernate-annotations.jar, hibernate-commons-annotations.jar, hibernate-core.jar, javassist.jar, jta.jar, log4j.jar, slf4j-api-1.5.2.jar, slf4j-log4j12.jar

von MySQL Connector/J:

• mysql-connector-java-5.1.7-bin.jar

Nun muss noch eine Javaklasse festgelegt werden, die wir von Flex aus ansprechen und die Steuerung der Hibernatefunktionen übernimmt (geht natürlich auch mit mehreren Klassen, aber in unserem kleinen Beispiel reicht eine). Dazu wird in der Datei

%blazeds%\tomcat\webapps\blazeds\WEB-INF\flex\remoting-config.xml

eine neue Destination angelegt:

<?xml version="1.0" encoding="UTF-8"?>
<service id="remoting-service" class="flex.messaging.services.RemotingService">
	<adapters>
		<adapter-definition id="java-object" class="flex.messaging.services.remoting.adapters.JavaAdapter" default="true"/>
	</adapters>
	<default-channels>
		<channel ref="my-amf"/>
	</default-channels>
	<destination id="hibernateControl">
		<properties>
			<source>HibernateControl</source>
		</properties>
	</destination>
</service>

Über die id wird die Destination in Flex angesprochen, und im source-Tag wird die anzusprechende Klasse festgelegt. BlazeDS ist nun fertig konfiguriert. Um Tomcat zu starten, folgendes in die Kommandozeile tippen:

cd %blazeds%		(das verzeichnis in das blazeds entpackt wurde)
cd tomcat\bin
catalina run

Im Webbrowser “http://localhost:8400″ aufrufen. Läuft Tomcat korrekt, sollte dort die BlazeDS Startseite erscheinen.

3. Hibernate konfigurieren:

Hibernate braucht, um korrekt zu funktionieren, eine Konfigurationsdatei hibernate.cfg.xml. Diese wird in

%blazeds%\tomcat\webapps\blazeds\WEB-INF\classes

abgelegt. In Ihr werden die zur Benutzung der Datenbank relevanten Informationen festgelegt, und es werden die Mappings (Binden von Klassen an Tabellen in der Datenbank) erstellt:

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
	<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
	<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/tutorial</property>
	<property name="hibernate.connection.username">root</property>
	<property name="hibernate.connection.password"></property>
	<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
	<property name="show_sql">false</property>
	<property name="hibernate.hbm2ddl.auto">update</property>
	<property name="hibernate.connection.pool_size">10</property>
	<mapping class="User"/>
</session-factory>
</hibernate-configuration>

Ggf. müssen die Zugangsdaten angepasst werden. In unserem Beispiel verwenden wir eine lokale Datenbank “tutorial”, auf die wir als Datenbankbenutzer “root” ohne Passwort zugreifen. Gemappt wird die Klasse “User”, welche später erstellt wird. Hibernate erstellt beim ersten Zugriff auf die Klasse automatisch die dazugehörige Tabelle in der Datenbank.

4. Flex Projekt erstellen:

Im Flex Builder ein neues Flex Projekt erstellen, das Projekt “tutorial” nennen und einen Speicherort auswählen. Als Applikation type “Web application” wählen, als Application Server type “J2EE”. Ein Häkchen bei “Use remote object access service” setzen und die “LiveCycle Data Services” auswählen. Dann auf “Next” klicken.

Unter “Server location” sind die Pfade zum Tomcat einzustellen:

Root Folder: 	%blazeds%\tomcat\webapps\blazeds\
Root URL:	http://localhost:8400/blazeds
Context root:	/blazeds

Unter “Compiled Flex application location” stellen wir das Output folder für unsere Flex-Applikation ein:

%blazeds%\tomcat\webapps\blazeds\tutorial

Dorthin werden später die tutorial.swf und die tutorial.html exportiert, und wir können diese dann im Browser über “http://localhost:8400/blazeds/tutorial/tutorial.html” aufrufen. Auf “Finish” klicken. Die Flex-Applikation ist nun fertig eingerichtet.

5. Java Projekt erstellen:

Im Flex-Builder auf

File -> New -> Other

und dort unter “Java” “Java Project” auswählen. Im nächsten Fenster dem Projekt einen Namen geben (”turorial_java”). Unter Contents “Create new project in workspace” und unter JRE “Use an execution environment JRE” “J2SE-1.5″ auswählen. Dann auf “Next” klicken und im Reiter “Source” unten das “Default output folder” einstellen:

Browse -> Create New Folder -> Advanced

Häkchen bei “Link to folder in the file system” machen und bei “Browse” folgendes Verzeichnis auswählen:

%blazeds%/tomcat/webapps/blazeds/WEB-INF/classes

Flex Builder wird die kompilierten Java-Klassen dorthin erstellen, so brauchen wir später nichts mehr kopieren.Dann im Reiter “Libraries” auf “Add External JARs” klicken und die gleichen Dateien auswählen, die wir auch unter (2) für BlazeDS benötigt haben. Zum Abschluss alles “Finish” bestätigen.

Hibernate benötigt innerhalb des Java Projektes noch eine kleine Konfigurationsdatei. Deshalb folgenden Code unter dem Namen “log4j.properties” in den src-Ordner des Projektes speichern:

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
# Achtung, die vorherige Zeile wird versehendlich umgebrochen
log4j.rootLogger=debug, stdout
log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug
### log just the SQL
log4j.logger.org.hibernate.SQL=debug

Das Java-Projekt ist nun fertig eingerichtet.

6. Java Klassen erstellen:

Hiberbate benötigt für jede Aktion eine SessionFactory. Wie auf hibernate.org empfohlen, erstellen wir dafür eine kleine Hilfsklasse namens “HibernateUtil”:

import org.hibernate.*;
import org.hibernate.cfg.*;
 
public class HibernateUtil {
 
	private static final SessionFactory sessionFactory;
 
	static {
		try {
			sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
		} catch (Throwable ex) {
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex.toString());
		}
	}
 
	public static Session getSession() throws HibernateException{
		try {
			return sessionFactory.openSession();
		} catch (Exception e) {
			return null;
		}
	}
}

Als nächstes erstellen wir unsere persistente Klasse “User”. Sie besteht aus einem Konstruktor und zwei Attributen:

import javax.persistence.*;
 
@Entity
public class User {
 
	@Id @GeneratedValue
	public int id;
 
	@Column
	public String name;
 
	User() {super();}
}

Das Attribut “@Entity” gibt an, das es sich um eine persistente Klasse handelt. Mit dem Attribut “@Id” wird angegeben, das es sich bei der Eigenschaft um einen Primärschlüssel handelt und mit “@GeneratedValue” wird festgelegt, das der Wert der Eigenschaft automatisch vergeben wird. “@Column” bezeichnet eine normale Spalte.

Die dritte Klasse die wir benötigen, is die in der “remoting-config.xml” angegebene “HibernateControl”.
Sie übernimmt das Anlegen und Auslesen von Datensätzen.

import org.hibernate.*;
import java.util.*;
 
public class HibernateControl {
 
	//liefert ein User-Objekt mit angegebener ID
	public static User getUser(int id) {
		Session s = HibernateUtil.getSession();Transaction tx = s.beginTransaction();
		List users = s.createQuery("from User where id like " + id).list();
		User user = (User) users.iterator().next();
		tx.commit();
		return user;
	}
 
	//generiert 4 User und packt sie in die Datenbank
	public static void makeSomeUsers() {
		User u1 = new User();
		u1.name = "Peter";
		User u2 = new User();
		u2.name = "Uwe";
		User u3 = new User();
		u3.name = "Horst";
		User u4 = new User();
		u4.name = "Inge";
 
		Session s = HibernateUtil.getSession();
		Transaction tx = s.beginTransaction();
 
		s.save(u1);
		s.save(u2);
		s.save(u3);
		s.save(u4);
 
		tx.commit();
	}
 
	//Test-Main zum Testen der Methoden ohne Flex
	public static void main(String[] args) {
		makeSomeUsers();
 
		System.out.println(getUser(3).name);
	}
}

Zum Testen der Funktionalität haben wir zusätzlich eine main-Methode implementiert. Diese ruft die interne Klassenmethode makeSomeUsers() auf, welche 4 Datensätze in der Datenbank generiert, und ruft danach den Datensatz mit der Id 3 ab und lässt ihn zur Konsole ausgeben. Steht dort in der letzen Zeile

Horst

wurde alles richtig gemacht.

7. Flex Oberfläche erstellen:

Damit wir in Flex das User-Objekt, was uns von getUser() zurückgegeben wird, auch korrekt behandeln können, muss im Projekt auch eine zur Java-Klasse User persistente Klasse User erzeugt werden. Dazu auf:

File -> New -> ActionScript Class

gehen, und der Klasse den Namen User verpassen. Der Code der Klasse sieht wie folgt aus:

package {
[Bindable]
[RemoteClass(alias="User")]
	public class User {
	public var id:int;
	public var name:String;
 
	public function User() {super();}
}
}

Zu guter Letzt erstellen wir eine kleine Flex-Oberfläche mit einem RemoteObject zur Integration unserer Hibernate-Anwendung:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
<mx:Script>
	<![CDATA[
		import mx.rpc.events.FaultEvent;
		import mx.rpc.events.ResultEvent;
 
		private function handler(event:ResultEvent):void {
			var user:User = User(event.result);
 
			output.text = "Der User mit der ID " + user.id;
			output.text+= " hat den Namen " + user.name + ".";
		}
 
		private function faultHandler (event:FaultEvent):void {
			output.text = event.fault.faultString.toString();
		}
	]]>
</mx:Script>
 
<mx:RemoteObject id="rmTut" destination="hibernateControl" fault="faultHandler(event)">
	<mx:method name="getUser" result="handler(event)"/>
</mx:RemoteObject>
 
<mx:TextArea width="200" height="100" id="output" verticalCenter="-25" horizontalCenter="0"/>
<mx:TextInput width="20" height="20" id="input" text="1" horizontalCenter="90" verticalCenter="41"/>
<mx:Button label="getUser" id="button" click="rmTut.getUser(input.text);" horizontalCenter="-65" verticalCenter="42"/>
<mx:Label text="mit ID Nummer" width="93" horizontalCenter="25" verticalCenter="42"/>
</mx:Application>

Die destination des RemoteObjects ist gleich der id der destination in der “remoting-config.xml”. Innerhalb des RemoteObjects wird durch das Tag eine Methode festgelegt. Der Name der Methode entspricht dabei dem Namen der Methode in der HibernateControl Klasse (Parameter werden erst beim Aufruf mit übergeben). Zum Verarbeiten des Rückgabewertes der Funktion muss ein Resulthandler mit den Parameter “event” definiert werden. Das event ist vom Typ ResultEvent und enthält das User-Objekt welches uns die Methode getUser() zurückgibt. Dieses muss zum Verarbeiten in den (persistenten) Typ User gecastet werden.

So sollte es aussehen wenn alles funktioniert.

Für tiefergreifende Informationen und Funktionen zu und von Hibernate gibt es auf der Homepage hibernate.org sehr gute Tutorials. Auch wurde hier der Übersichtlichkeit zu Liebe bewusst und so weit es ging auf etwaiige Try/Catches und sonstiges Abfangen von Fehlern verzichtet.

Bookmark It

Hide Sites