Open Tutorial

1 Im Quellcodeordner des HTTP Servers diesen Befehl absetzen. Das SSL sowie das Proxy Modul werden bei der Kompilierung beachtet.

./configure --enable-ssl=shared --enable-proxy=shared --prefix=/apache/apache2

Shared bedeutet dynamisches Laden, falls das OS dies unterstützt. Sprich den Eintrag mit mod_xxx in der httpd.conf setzen zu können. Die andere Methode wäre, dass im Apache selbst das Modul als Binary statisch eingebunden wird.

2 Den Befehl make ausführen.
3 Den Befehl make install ausführen.
4 In der httpd.conf zwei Ports aktivieren.

Listen 80
Listen 443

5 In der httpd.conf müssen die Module geladen werden.

# SSL
LoadModule ssl_module modules/mod_ssl.so

# Proxy
LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_http_module modules/mod_proxy_http.so

6 Es muss ein SSL-Zertifikat erstellt werden. Siehe dazu folgende http://opentutorial.blogspot.com/2008/06/apache-224-webserver-with-ssl-on.html
Die Zertifikate werden in den neuen Ordner conf/ssl verschoben.

Hinweise:
Möchte man solch ein SSL-Zertifikat verwenden, muss auf dem PC OpenSSL installiert werden. Weiterhin muss die Umgebungsvariable OPENSSL_CONF auf die Datei openssl.cfg zeigen.
Danach muss man sich vom Rechner abmelden und wieder anmelden. Ein Neustart ist nicht nötig.

7 In der httpd.conf muss am Dateiende folgendes stehen.

# SSL Cache erhoeht die Leistung, wenn Zugriffe auf den gleichen Server stattfinden
SSLSessionCache shm:/apache/apache2/logs/ssl_gcache_data(512000)

# Muss auf off stehen, sonst ist es ein open proxy und damit ein Sicherheitsproblem
ProxyRequests Off

# In der hosts muss zur IP die Zuordnung www.myserver.de stehen, damit das mit virtuelle Host funktioniert
# 192.168.192.33 www.myserver.de (möglcher Auszug aus der hosts)
#
# Reverse proxy auf dem Port 443 mit SSL-Zertifikat
<VirtualHost *:443>
ServerName www.myserver.de
ProxyPass /service http://www.myserver.de:81/service
ProxyPassReverse /service http://www.myserver.de:81/service
SSLEngine On
SSLCertificateKeyFile conf/ssl/server.key
SSLCertificateFile conf/ssl/server.crt
</VirtualHost>

# Reverse proxy auf dem Port 80 ohne SSL Zertifikat
<VirtualHost *:80>
ServerName www.myserver.de
ProxyPass /service http://www.myserver.de:81/service
ProxyPassReverse /service http://www.myserver.de:81/service
</VirtualHost>

1: Activate the following modules:
LoadModule authnz_ldap_module modules/mod_authnz_ldap.so
LoadModule ldap_module modules/mod_ldap.so

2: Add the lines


DAV svn

AuthBasicProvider ldap
SVNPath d:\svn_repository

AuthType Basic

AuthName "Your Subversion Repository"

AuthzSVNAccessFile d:\svn_repository\conf\svnaccess.conf
AuthLDAPURL "ldap://myldapserver.de:389/o=myserver.de?mail?sub?(objectClass=*)"

Require valid-user



into the file httpd.conf.

1 Apache 2.2.13 can be downloaded from the website http://httpd.apache.org/ (recommended the windows binary).

2 You must install Apache 2.2.13 under d.
e.g.:
d:\Apache2_2

3 Copy the files D:\svn-win32-1.6.5\bin\mod_authz_svn.so and D:\svn-win32-1.6.5\bin\mod_dav_svn.so into the folder D:\Apache2_2\modules.

4 Copy lib*.dll and intl3_svn.dll into the folder D:\Apache2_2\bin.

5 Uncomment the following lines
LoadModule dav_module modules/mod_dav.so
LoadModule dav_fs_module modules/mod_dav_fs.so

6 Add the following lines
LoadModule dav_svn_module modules/mod_dav_svn.so
LoadModule authz_svn_module modules/mod_authz_svn.so

7 SSPI Modul can be downloaded from the website http://sourceforge.net/projects/mod-auth-sspi/

8 Extract the file mod_auth_sspi-1.0.4-2.2.2.zip.

9 Copy the file mod_auth_sspi.so into the folder D:\Apache2_2\modules. Edit the file httpd.conf and add the line LoadModule sspi_auth_module modules/mod_auth_sspi.so

10 Add at the end of the httpd.conf following lines

DAV svn
SVNListParentPath on
SVNPath D:\svn_repository
# SVNIndexXSLT "/svnindex.xsl"
# AuthType Basic
AuthType SSPI
AuthName "Repository"
# AuthUserFile D:\Apache2_2\bin\passwd
# AuthUserFile D:\svn_repository\conf\passwd
AuthzSVNAccessFile D:\svn_repository\conf\svnaccess.conf
Require valid-user

# Domain
SSPIAuth On
SSPIAuthoritative On
SSPIDomain mydomain
SSPIOmitDomain on
SSPIUsernameCase lower
SSPIPerRequestAuth on
SSPIOfferBasic On


11 Uncomment the entry auth-access = write into file D:\svn_repository\conf\svnserve.conf.

12 Add the new file D:\svn_repository\conf\svnaccess.conf.
e.g.:
svnaccess.conf:
[groups]
Dev = domainuser1, domainuser2
[/]
* = r

[/ProjectA]
@Dev = rw

[/ProjectB]
@Dev = r

13 Start the Subversion windows service.

14 Test the Subversion access per Browser http://localhost/svn

1 Subversion 1.6.5 can be downloaded from the website http://subversion.tigris.org/ (recommended zip file).

2 The zip file svn-win32-1.6.5.zip must extract under d.
e.g.:
d:\svn-win32-1.6.5
d:\svn-win32-1.6.5\bin
...

3 Now you must create the repository svn_repository under drive d.
e.g.:
d:\svn_repository

4 The repository can be created by the command d:\svn-win32-1.6.5\bin\svnadmin create --fs-type fsfs d:\svn_repository
e.g.:
d:\svn_repository\conf
d:\svn_repository\dav
d:\svn_repository\db
...
6 Register Subversion as Windows Service by running the command sc create svnserve binpath= "D:\svn-win32-1.6.5\bin\svnserve.exe --service --root d:\svn_repository"" displayname= "Subversion" depend= tcpip start= auto

7 Create the folder ProjectA and ProjectB into the folder d:\svn-win32-1.6.5\bin.

8 Now we import the folder ProjectA and ProjectB into the repository. Run the command svn import ProjectA file:///d:/svn_repository/ProjectA -m "ProjectA initial import" and
svn import ProjectA file:///d:/svn_repository/ProjectA -m "ProjectA initial import" to import the folder.

9 The client software TortoiseSVN-1.6.5.16974-win32-svn-1.6.5.msi can be downloaded from the website http://tortoisesvn.tigris.org/

10 Install the client software TortoiseSVN-1.6.5.16974-win32-svn-1.6.5.msi. Notice: The client pc must be rebooted after installation.

11 Choose the Repo-browser from the svn context menue. You can see the imported projects by typing the address svn://localhost into the address field.

Hallo liebe Leser,

ich kann nun stolz verkünden, dass das JavaFX Taschenbuch im Handel erhältlich ist, samt Quellcode. Der Quellcode ist über die entwickler.press Seite verfügbar.
Auch eine E-Book Variante gibt es.

Viel Spaß damit.

Gruß
Mike

Liebe Leser,

ich habe in der Vergangenheit öfters Artikel eingestellt, dass hat nachgelassen. Nun erfahrt Ihr den Grund dafür. In den letzten zwei Monaten habe ich ein Taschenbuches zum Thema JavaFX geschrieben. Es wird vermutlich im Juni 2009 erscheinen, ein genaues Datum habe ich noch nicht.

Anbei der Link zum Buch. Viel Spaß damit.

http://entwickler-press.de/ep/psecom,id,7,reihe,schnell+kompakt.html

You are a java developer and your production system base on linux or another unix derivate. It`s not impossible you get the failure "Can’t connect to X11 window server" when you use the lib jCharts (http://jcharts.sourceforge.net/).

To solve the problem here some helpful backround information.

http://www.ashishgaikwad.com/?p=33
http://www.jguru.com/faq/view.jsp?EID=222296
http://www.idautomation.com/kb/xwindow-error.html

To fix the problem I prefer the page http://www.ashishgaikwad.com/?p=33.

When you use the IBM DB2 Driver for JDBC Type 4, you choose a security mechanism by specifying a value for the securityMechanism property.

Im ersten Teil der Serie wurden die Befehle zur Serverauthentifizierung vorgestellt.
Hier wird nun ein Batchskript erstellt, um sich die Schreibarbeit zu sparen.

Schritt 1:

Notepad öffnen und alle Einträge einfügen. Die Datei soll SSL_Serverauthentifizierung.bat heißen.

@echo on

echo Allgemeine Umgebungsvariablen definieren

set CLIENT_ALIAS="ssl_client"
set CLIENT_PW="x$4f8xZj"
set CLIENT_KEYSTORE=%CLIENT_ALIAS%.jks
set CLIENT_CERTFILE=%CLIENT_ALIAS%.cert

set SERVER_DNAME="cn=127.0.0.1, ou=Test Team, o=Test Org, l=Erfurt, st=Thueringen, c=DE"
set SERVER_ALIAS="ssl_server"
set SERVER_PW="x$4f8xZj"
set SERVER_KEYSTORE=%SERVER_ALIAS%.jks
set SERVER_CERTFILE=%SERVER_ALIAS%.cert

set VALIDITY="2000"

echo Schluesselpaar und Schluesselspeicher des Servers generieren
echo Erstellt außerdem ein selbstunterzeichnetes Zertifikat mit oeffentlichem
echo Schluessel fuer den Server
echo Anders als der Client benoetigt ein Server immer ein Schluesselpaar
keytool -genkey -keypass %SERVER_PW% -validity %VALIDITY% -dname %SERVER_DNAME% -alias %SERVER_ALIAS% -keystore %SERVER_KEYSTORE% -storepass %SERVER_PW%

echo Selbst-Zertifizierung
keytool -selfcert -v -alias %SERVER_ALIAS% -storepass %SERVER_PW% -keystore %SERVER_KEYSTORE% -validity %VALIDITY%

echo Ausgabe des Serverschluesselspeichers
keytool -list -keystore %SERVER_KEYSTORE% -storepass %SERVER_PW%

echo Zertifikat mit oeffentlichem Schluessel des Server in eine Datei exportieren
keytool -export -alias %SERVER_ALIAS% -file %SERVER_CERTFILE% -keystore %SERVER_KEYSTORE% -storepass %SERVER_PW%

echo Zertifikat mit oeffentlichem Schluessel des Server als neues
echo anerkanntes Zertifikat in den Clientschluesselspeicher importieren.
keytool -import -file %SERVER_CERTFILE% -keystore %CLIENT_KEYSTORE% -storepass %CLIENT_PW%

echo Ausgabe des Clientschluesselspeichers
keytool -list -keystore %CLIENT_KEYSTORE% -storepass %CLIENT_PW%


pause

Schritt 2:

Nun startet man das Skript und bestägt jeweils Aufforderung mit ja. Das ist notwendig, damit die Zertifikate in den Schlüsselspeicher importiert werden können.

Zusammenfassung:

Web-Anwendungen sollten 7x24h zur Verfügung stehen, denn nichts ist schlimmer, wenn der Service nicht erreichbar ist oder eine undefinierte Meldung dem Benutzer angeboten wird.
Sicher darf ein Service ausfallen, aber der Mensch merkt sich nur zu oft die unangenehmen Dinge, die positiven sind eine Selbstverständlichkeit.

Sehr oft wird der Apache HTTP Server vor einem oder mehreren Tomcat Servern vorgeschaltet:

• statische Inhalte werden vom Apache HTTP Server schneller ausgeliefert und

• der Apache Webserver kann als Load Balancer die Http-Anfragen auf mehrere Tomcat Server verteilen.

Der Apache HTTP Webserver muss das mod_jk Modul laden, nun können Anfragen über das AJP 1.3 Protokoll an ein oder mehrere Tomcat Server weitergeleitet werden.

Die Tomcat Server haben einen AJP 1.3 Connector Port geöffnet. Das Apache mod_jk Modul kennt die Adressen der Tomcat Server aus der 'worker.properties' Datei.

In dieser Konfiguration wird davon ausgegangen, dass über den Port 443 des Apache HTTP Webserves die Request per Load Balancing an die jeweilige Tomcat Instance automatisch verteilt werden. Ebenso tauschen die Tomcats ihre Sessions per Session Replikation aus.




Für den praktischen Einsatz wurde der Tomcat 5.5.20 und den Apache HTTP Webserver in der Version 2.2.4 genommen.

Schritt 1:

Tomcat apache-tomcat-5.5.20.zip herunterladen und z.B.: nach C:\Tomcat-5.5.20\Tomcat1 entpacken.

Schritt 2:

Die Ordner conf, logs, shared, temp, webapps und work in den Ordner Tomcat2 kopieren.



Schritt 3:

Jetzt wird der Tomcat1 als Windows Dienst registiert. Dafür müssen noch die Umgebungsvariablen CATALINA_BASE, CATALINA_HOME und JAVA_HOME unter System variables angelegt werden. Man kann natürlich die Variablen an einen Benutzer binden, um es einfach zu halten wurden die Variablen als Systemvariablen deklariert.



CATALINA_BASE: C:\Tomcat-5.5.20\Tomcat1
CATALINA_HOME: C:\Tomcat-5.5.20\Tomcat1



JAVA_HOME: C:\j2sdk1.4.2_17\bin

Jetzt fügen wir noch im Path den Wert %CATALINA_HOME%\bin hinzu.



Schritt 4:

Auf der DOS-Konsole muss der Befehl service install Tomcat1 im Ordner C:\Tomcat-5.5.20\Tomcat1\bin eingeben werden. Der Dienst sollte zur Verfügung stehen.



Vorher muss der Dienst gestartet werden. Eine Überprüfung mit der URL: http://localhost:8080/ sollte das beweisen.



Schritt 5:

Jetzt müssen wir noch den Tomcat2 als weiteren Dienst registieren. Dafür muss die server.xml im Ordner C:\Tomcat-5.5.20\Tomcat2\conf angepasst werden.

ALT: <Server port="8005" shutdown="SHUTDOWN">
NEU: <Server port="8015" shutdown="SHUTDOWN">

ALT: <Connector port="8080" maxHttpHeaderSize="8192"...
NEU: <Connector port="8090" maxHttpHeaderSize="8192"...

ALT: <Connector port="8009" enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />
NEU: <Connector port="8019" enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />

Schritt 6:

In den Systemvariablen den Wert für CATALINA_BASE ändern in C:\Tomcat-5.5.20\Tomcat2.



Jetzt muss ein neues DOS-Fenster geöffnet und im Ordner C:\Tomcat-5.5.20\Tomcat1\bin den Befehl service install Tomcat2 absetzen werden.



Schritt 7:

Der Tomcat2 sollte nun als zweiter Windows-Dienst registiert sein.



Ob beide Dienste Tomcat 1 und 2 erfolgreich funktionieren ist wie folgt zu prüfen.

Tomcat 1 (Port 8080): http://localhost:8080/



Tomcat 2 (Port 8090): http://localhost:8090/



Schritt 8:

Beide Dienste stehen nun über unterschiedliche Ports 8080 und 8090 zur Verfügung. Der letzte Test im Task Manager bestätigt, dass beide Prozesse laufen.



Schritt 9:

Nun laden wir den Apache HTTP Server von der URL http://httpd.apache.org/download.cgi in der Version 2.2.4 runter.



Schritt 10:




Schritt 11:



Schritt 12:



Schritt 13:
Die Installationsroutine des Apache wurde hier nicht mit aufgeführt, ich denke, dass man damit klar kommen sollte. Als Installationsordner wurde C:\Apache-2.2.4 gewählt. Anschließend kann der Dienst gestartet werden.



Im Browser http://localhost eingeben. Es sollte folgendes erscheinen. Damit haben wir nun einen Apache HTTP Webserver in der Version 2.2.4 installiert. Jedoch fehlt
noch die Anbindung zum Tomcat. Dazu wird das Modul mod_jk.so in der httpd.conf eingebunden. Weiteres dazu später.



Schritt 14:

Nun stoppen wir den Dienst und geben der Datei mod_jk-1.2.26-httpd-2.2.4.so einen neuen Namen mod_jk.so und kopieren diese unter C:\Apache-2.2.4\modules.

Schritt 15:

Jetzt wird die Konfigurationsdatei httpd.conf angepasst und folgende Zeile LoadModule jk_module modules/mod_jk.so hinzugefügt um das Module zu laden.



Schritt 16:

Jetzt muss eine Datei workers.properties erstellt und im Ordner conf des Apache abgelegt werden.



Der Apache HTTP Server muss nun alle Requests der Clients an den Tomcat 1 und 2 weiterreichen, die Datei workers.properties sagt dem Apache, wo er diese zwei Instanzen finden kann.

Schritt 17:

Nun wird wieder die http.conf angepasst, damit die workers.properties auch gefunden wird.
Am besten plaziert man die folgenden Einträge nach dem LoadModule Eintrag. Weiter legen wir fest, dass jsp-examples nur durch worker1
behandelt wird sowie tomcat-docs durch worker2. Bisher haben wir noch kein automatisches Load Balancing zwischen dem Apache und den Tomcat hergestellt.

# Path to workers.properties
JkWorkersFile c:/Apache-2.2.4/conf/workers.properties

# Path to jk logs
JkLogFile c:/Apache-2.2.4/logs/mod_jk.log

# Jk log level [debug/error/info]
JkLogLevel info

# Jk log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "

# JkOptions for forwarding
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories

# JkRequestLogFormat set the request format
JkRequestLogFormat "%w %V %T"


JkMount /jsp-examples worker1
JkMount /jsp-examples/* worker1

JkMount /tomcat-docs worker2
JkMount /tomcat-docs/* worker2

Schritt 18:

Der Apache HTTP Webserver kennt nun den Tomcat 1 und 2. Jedoch müssen wir in der server.xml des Tomcat 1 und 2 noch das Attribute jvmRoute richtig
setzen, damit der Apache auch worker1 und worker2 richtig zuordnen kann.

Tomcat 1: <Engine name="Catalina" defaultHost="localhost" jvmRoute="worker1">

Tomcat 2: <Engine name="Catalina" defaultHost="localhost" jvmRoute="worker2">

Anschließend starten wir noch alle Dienste.



Schritt 19:

In den index.html Seiten kann man im Tag title noch den Zusatz Tomcat 1 oder Tomcat 2 einfügen, damit man eine Unterscheidung hat.

Tomcat 1: http://localhost/jsp-examples/
Tomcat 2: http://localhost/tomcat-docs

Schritt 20:

Wenn der Test aus Schritt 19 erfolgreich verlaufen ist, dann kommt nun die eigentliche Anpassung des Apache. Damit eine automatische
Delegation durch den Apache vorgenommen werden kann, ist erneut die workers.properties anzupassen.

#worker.list=worker1,worker2
worker.list=balancer

worker.worker1.port=8009
worker.worker1.host=localhost
worker.worker1.type=ajp13
worker.worker1.lbfactor=1

worker.worker2.port=8019
worker.worker2.host=localhost
worker.worker2.type=ajp13
worker.worker2.lbfactor=1

worker.balancer.type=lb
worker.balancer.balance_workers=worker1,worker2
worker.balancer.method=B

Schritt 21:

Jetzt passen wir noch die httpd.conf an.

JkMount /jsp-examples balancer
JkMount /jsp-examples/* balancer

Hier entscheidet der Apache automatisch ob er Tomcat 1 oder 2 nehmen soll für die Anwendung jsp-examples. Über den Parameter lbfactor kann man
erreichen, welcher Tomcat mehr Requests verarbeiten soll.

Schritt 22:

Bis jetzt haben wir nur Load Balancing eingerichtet, jedoch nicht den Tomcat 1 und 2 zu einem Cluster verbunden. Damit die Session Replikation funktioniert muss in der Datei C:\Tomcat-5.5.20\Tomcat1\conf\server.xml der Tag Cluster gelöscht und durch folgenden Eintrag ersetzt werden.

<Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
managerClassName="org.apache.catalina.cluster.session.DeltaManager"
expireSessionsOnShutdown="false"
useDirtyFlag="true">

<Membership
className="org.apache.catalina.cluster.mcast.McastService"
mcastAddr="228.0.0.4"
mcastPort="45564"
mcastFrequency="500"
mcastDropTime="3000"/>

<Receiver
className="org.apache.catalina.cluster.tcp.ReplicationListener"
tcpListenAddress="127.0.0.1"
tcpListenPort="4001"
tcpSelectorTimeout="100"
tcpThreadCount="6"/>

<Sender
className="org.apache.catalina.cluster.tcp.ReplicationTransmitter"
replicationMode="pooled"/>

<Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
filter=".*\.gif;.*\.js;.*\.jpg;.*\.htm;.*\.html;.*\.txt;"/>
</Cluster>

Nun das ganze noch für den Tomcat 2 in der Datei C:\Tomcat-5.5.20\Tomcat2\conf\server.xml.

<Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
managerClassName="org.apache.catalina.cluster.session.DeltaManager"
expireSessionsOnShutdown="false"
useDirtyFlag="true">

<Membership
className="org.apache.catalina.cluster.mcast.McastService"
mcastAddr="228.0.0.4"
mcastPort="45564"
mcastFrequency="500"
mcastDropTime="3000"/>

<Receiver
className="org.apache.catalina.cluster.tcp.ReplicationListener"
tcpListenAddress="127.0.0.1"
tcpListenPort="4002"
tcpSelectorTimeout="100"
tcpThreadCount="6"/>

<Sender
className="org.apache.catalina.cluster.tcp.ReplicationTransmitter"
replicationMode="pooled"/>

<Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
filter=".*\.gif;.*\.js;.*\.jpg;.*\.htm;.*\.html;.*\.txt;"/>
</Cluster>

Schritt 23:

Anschließend startet man den Tomcat 1 und darauf den Tomcat 2.
In der Log-Datei des Tomcat 1 kann man überprüfen, ob der Cluster erfolgreich gestartet wurde und die Replication im Grunde zur Verfügung steht.
Ein richtiger Test kann erst durch eine Anwendung abgedeckt werden, die die Kriterien eines Clusters erfüllt, weitere Angaben dazu sind unter
folgender URI http://tomcat.apache.org/tomcat-5.5-doc/cluster-howto.html zu finden.

05.06.2008 08:41:52 org.apache.catalina.cluster.tcp.SimpleTcpCluster start
INFO: Cluster is about to start
05.06.2008 08:41:52 org.apache.catalina.cluster.tcp.SimpleTcpCluster createDefaultClusterListener
INFO: Add Default ClusterListener at cluster localhost
05.06.2008 08:41:52 org.apache.catalina.cluster.tcp.ReplicationTransmitter start
INFO: Start ClusterSender at cluster Catalina:type=Cluster,host=localhost with name Catalina:type=ClusterSender,host=localhost
05.06.2008 08:41:52 org.apache.catalina.cluster.mcast.McastService start
INFO: Sleeping for 2000 milliseconds to establish cluster membership
05.06.2008 08:41:52 org.apache.catalina.cluster.tcp.SimpleTcpCluster memberAdded
INFO: Replication member added:org.apache.catalina.cluster.mcast.McastMember[tcp://127.0.0.1:4002,catalina,127.0.0.1,4002, alive=39548]
05.06.2008 08:41:54 org.apache.catalina.cluster.mcast.McastService registerMBean
INFO: membership mbean registered (Catalina:type=ClusterMembership,host=localhost)

Diese Konfiguration geht davon aus, dass man keine sperate CA Stelle benötigt. Mit OpenSSL ist es ohne weiteres möglich, dass man selber an die
Stelle der CA treten kann. Der Apache wird auf Port 443 und mit Auslieferung eines Zertifikats konfiguriert. Das heißt, die URL beginnt nicht mit HTTP,
sondern mit HTTPS. Im zweiten Teil des Tutorials Clustering and Load Balancing with Tomcat 5.5.20 and Apache 2.2.4 on Windows geht
die Konfiguration des Apache HTTP Webservers noch einen Schritt weiter, indem alle Request die auf https://localhost/... gehen sofort per Load Balancing an
die Tomcat Instanze weitergereicht werden.

Schritt 1:

Unter der URL http://httpd.apache.org/ den Apache in der Version 2.2.4 herunterladen und z.B.: unter C:\Apache-2.2.4 installieren.
Wichtig ist, dass wir die Version mit OpenSSL nehmen, sonst müssten wir uns später noch das SSL Modul herunterladen.

Schritt 2:

Hat man keinen Apache mit OpenSSL installiert, dann muss die Software unter http://www.slproweb.com/products/Win32OpenSSL.html heruntergeladen und installiert werden.

Schritt 3:

Bevor wir die httpd.conf anpassen, wollen wir noch ein Zertifikat ertellen. Dazu müssen die Dateien ssleay32.dll und libeay32.dll im Ordner C:\WINDOWS\system32 liegen.

Im Prinzip benötigt man keine eigene CA (Certification Authority). Jedoch wird davon ausgegangen, dass in einem späteren Projektverlauf diese Anwenderanforderung besteht.
Daher erstellen wir zuerst eine 3 Jahre gültige CA, zum unterschreiben unserer Zertifikate, welche die Echtheit mit der digitalen Unterschrift bezeugt. Das cacert.pem sollte man bei einer späteren Verbreitung in eine Datei mit der Endung .crt umwandeln. Dann kann Windows etwas damit anfangen. Für PEM wurde das Passwort test vergeben.

openssl req -new -x509 -days 1096 -keyout cakey.pem -out cacert.pem



Mit dem folgenden Befehl erhalten wir ein Certificate Request in der Datei server.csr. Die Fragen sollte man korrekt beantworten, die wichtigsten sind CN (Common Name).
Hier muss die IP oder der Domänename eingetragen werden.

openssl req -new -keyout server.key -out server.csr



Anschließend unterschreiben wir noch mit unserer eigenen CA, wobei das Zertifiakt eine Gültigkeit von 1 Jahr hat.

openssl x509 -req -in server.csr -CA cacert.pem -CAkey cakey.pem -CAcreateserial -out server.crt -days 365



Jetzt kopieren wir noch den Schlüssel, damit dieser nicht beim Start des Apache abgefragt wird.

copy server.key server.key.tmp



openssl rsa -in server.key.tmp -out server.key



Den Key (privater Schluessel) und das unterschriebene Zertifikat (öffentlicher Schlüssen), wird noch zusammengepackt und fuer Windows ins pkcs12 Format umgewandelt.

copy /b server.key + server.crt servercert.pem



openssl pkcs12 -export -in servercert.pem -out clientcert.p12 -name "localhost"



Zum Abschluß prüfen wir noch, ob der Modulus passt. Beide Zahlenkolonnen müssen stimmen, ist jeweils rot markiert.

openssl x509 -noout -text -in server.crt



openssl rsa -noout -text -in server.key




Hat man das server.crt im Browser importiert, dann sieht man folgende Einträge. Hier sieht man sehr deutlich, dass wir eine eigene CA verwendet haben, denn
unter Herausgegeben von steht MM Test Company drin. Unter Herausgegeben für, sieht man, dass das Zertifikat für den XYZ Company gedacht ist.




Schritt 4:

Jetzt haben wir ein Zertifiakt und können die httpd.conf angepassen.

Wir entfernen bzw. fügen das SSL Module hinzu mit der folgenden Zeile

LoadModule ssl_module modules/mod_ssl.so

Der Port 80 wird durch Port 443 ersetzt.

Listen 443

Ebenso kommen folgende Zeilen an das Dateiende.

SSLEngine On
SSLMutex default
SSLSessionCache dbm:c:/Apache-2.2.4/logs/ssl_gcache_data
SSLCertificateFile conf/ssl/server.crt
SSLCertificateKeyFile conf/ssl/server.key

Schritt 5:

Nun starten wir den Dienst unter Windows neu und prüfen den Erfolg in dem wir im Browser https://localhost eingeben.
Wenn ein Zertifikat angeboten wird, dann haben wir alles richtig gemacht und es wird folgende Seite im Browser geladen. Ebenso ist es
möglich, dass man vorher das Zertifiakt im Browser importiert, dann kommt keine Abfrage, ob man dem Zertifiakt vertrauen möchte.

Schritt 1:

Unter der URI http://www.springframework.org/ und http://www.hibernate.org/ muss das ZIP-Archiv heruntergeladen und z.B.: im Ordner C:\libs entpackt werden.

Schritt 2:

Zum einfachen Test reicht es aus, wenn man ein normales Java-Projekt unter Eclipse anlegt.



Schritt 3:

Da wir die Libraries auch verwenden wollen, muss unter Windows/Preferences (Englische Version von Eclipse) die Konfiguration so aussehen.



Schritt 4:

Nun werden in den Projekteigenschaften noch die beiden neuen Libraries eingebunden. Bitte nicht stören lassen, hier im Bild sind weitere Libraries vorhanden.



Schritt 5:

Nun erstellt man ein Paket z.B: de.th.ibm.vs.server.service.conf und erstellt dort die XML-Datei application-context.xml.

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

  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="org.hsqldb.jdbcDriver"/>
    <property name="url" value="jdbc:hsqldb:hsql://localhost/xdb"/>
    <property name="username" value="sa"/>
    <property name="password" value=""/>
  </bean>

  <bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mappingResources">
      <list>
        <value>de/th/ibm/vs/server/service/conf/Kunde.hbm.xml</value>
      </list>
    </property>
    <property name="hibernateProperties">
      <props>
        <prop key="hibernate.show_sql">true</prop>     
        <prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
        <prop key="hibernate.current_session_context_class">thread</prop>
        <prop key="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</prop>
        <prop key="hibernate.cache.provider_class">org.hibernate.cache.NoCacheProvider</prop>
        <!--
        Tabellen werden erzeugt wie es in der *.hbm.xml steht.
        <prop key="hibernate.hbm2ddl.auto">create</prop>
        <prop key="hibernate.hbm2ddl.auto">update</prop>
        -->
        <prop key="hibernate.hbm2ddl.auto">create</prop>
      </props>
    </property>
  </bean>

   <bean id="kundeDAO" class="de.th.ibm.vs.server.dao.KundeDAOImpl">
        <property name="sessionFactory" ref="mySessionFactory"/>
   </bean>

</beans>

Schritt 6:

Im Paket de.th.ibm.vs.server.service.conf die Datei Kunde.hbm.xml anlegen.

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
  "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
  <class name="de.th.ibm.vs.server.service.bean.Kunde" table="KUNDEN">
    <id name="id" column="ID" type="integer">
      <generator class="native"/>
    </id>
    <property name="name"  column="NAME"  type="string" not-null="true"/>
    <property name="plz"   column="PLZ"   type="integer"/>
    <property name="ort"   column="ORT"   type="string"/>
    <property name="datum" column="DATUM" type="date"/>
    <property name="sprache" column="SPRACHE" type="string"/>
  </class>
</hibernate-mapping>

Schritt 7:

Damit wir Spring und Hibernate auch verwenden können, muss der ApplicationContext auch initialisiert werden. Dazu kann man die folgende Klasse ServiceUtil im zuvor
angelegten Paket de.th.ibm.vs.server.service.util verwenden.

public class ServiceUtil {

 protected static Logger logger = Logger.getLogger(ServiceUtil.class);

 protected static ApplicationContext appContext;

 static {
     logger.info("------------------------------------------------------");
     logger.info("Initializing Spring");
     //TODO Ersetzen durch XML-Propertie Datei, derzeit noch hier statisch eingetragen
     appContext = new ClassPathXmlApplicationContext( "de/th/ibm/vs/server/service/conf/application-context.xml" );
        
     logger.info("Finished Initializing Spring");
     logger.info("------------------------------------------------------");
}


 /**
  * @return Returns the appContext.
  */
 public static ApplicationContext getAppContext() {
     return appContext;
 }
}

Schritt 8:

In diesem Beispiel wird nur ein Domän-Objekt Kunde im Paket de.th.ibm.vs.server.service.bean verwendet. Wie man in der Klasse sieht
enthält diese nur Getter und Setter Methoden. Im Prinzip braucht man die Klasse nicht von Hand erstellen, sondern Hibernate kann das automatisch
durch reverse engineering, wenn eine Datenbank bereits existiert. Somit ist es möglich, dass man ein vollständiges Datenbankdesgin
erstellt und daraus sich die Domän-Objekt erstellen lässt, dass trifft auch auf die *.hbm.xml Dateien zu (Verwendung des Hibernate Plugins).
Hier jedoch wurde der andere Weg gewählt, dass aus einem Domän-Objekt eine Datenbanktabelle erstellt.
Das bewirkt der folgende Eintrag create
hätte man diese update gewählt, dann werden lediglich Änderungen auf den
vorhanden Tabellen durchgeführt. Bei der anderen Option werden alle Tabelle phy. gelöscht. Also ist hier Vorsicht geboten, da auch die Daten dann weg sind.

public class Kunde implements java.io.Serializable {
 private int id;

 private String name;

 private int plz;

 private String ort;

 private Date datum;

 private String sprache;


 /**
  * @return Returns the datum.
  */
 public Date getDatum() {
     return datum;
 }
 /**
  * @param datum The datum to set.
  */
 public void setDatum(Date datum) {
     this.datum = datum;
 }
 /**
  * @return Returns the id.
  */
 public int getId() {
     return id;
 }
 /**
  * @param id The id to set.
  */
 public void setId(int id) {
     this.id = id;
 }
 /**
  * @return Returns the name.
  */
 public String getName() {
     return name;
 }
 /**
  * @param name The name to set.
  */
 public void setName(String name) {
     this.name = name;
 }
 /**
  * @return Returns the ort.
  */
 public String getOrt() {
     return ort;
 }
 /**
  * @param ort The ort to set.
  */
 public void setOrt(String ort) {
     this.ort = ort;
 }
 /**
  * @return Returns the plz.
  */
 public int getPlz() {
     return plz;
 }
 /**
  * @param plz The plz to set.
  */
 public void setPlz(int plz) {
     this.plz = plz;
 }
 /**
  * @return Returns the sprache.
  */
 public String getSprache() {
     return sprache;
 }
 /**
  * @param sprache The sprache to set.
  */
 public void setSprache(String sprache) {
     this.sprache = sprache;
 }
}

Schritt 9:

In der application-context.xml stehen folgende Zeilen.

<bean id="kundeDAO" class="de.th.ibm.vs.server.dao.KundeDAOImpl">
<property name="sessionFactory" ref="mySessionFactory"/>
</bean>

Damit das auch klappt und Spring uns ein Objekt vom Typ KundeDAOImpl erzeugen kann muss man ein Interface KundeDAO und die Klasse KundeDAOImpl
im Paket de.th.ibm.vs.server.dao anlegen.

public interface KundeDAO {

 public void persist(Object transientInstance);
}

public class KundeDAOImpl implements KundeDAO {

 private SessionFactory sessionFactory;

 public void setSessionFactory(SessionFactory sessionFactory) {
     this.sessionFactory = sessionFactory;
 }

 /* (non-Javadoc)
  * @see de.th.ibm.vf.dao.KundeDAO#persist(java.lang.Object)
  */
 public void persist(Object transientInstance) {
     System.out.println("persisting "+ transientInstance.getClass().getName() + " instance");
     try {
         HibernateTemplate ht = new HibernateTemplate(this.sessionFactory);
         ht.persist(transientInstance);
         System.out.println("persist successful");
     } catch (RuntimeException re) {
         System.err.println("persist failed", re);
         throw re;
     }
 }
}

Schritt 10:

In einer Klasse mit einer main(...) Methode müssen lediglich folgende Zeile eingetragen werden. Jetzt kann die Klasse als reine Java-Applikation starten und ein Eintrag in
der Datenbank xdb sollte erfolgen. Nicht vergessen, dass man den Datenbankserver vorher starten muss, sonst klappt es nicht.

public class TestSpringHibernate {

 public static void main(String[] args) {
     Kunde kunde = new Kunde();
         kunde.setDatum( new Date() );
         kunde.setName( "IBM" );
         kunde.setOrt( "Suhl" );
         kunde.setSprache("Deutsch");
        
     ApplicationContext ac = ServiceUtil.getAppContext();
     KundeDAO kdao = (KundeDAO) ac.getBean("kundeDAO");
     kdao.persist(kunde);
 }
}

Schritt 1:

Unter der URI http://hsqldb.org/ muss das ZIP-Archiv heruntergeladen und z.B.: im Ordner C:\libs entpackt werden.

Schritt 2:

Möchte man die HSQLDB als lokalen Datenbankserver verwenden, dann muss der folgende Befehl im bin Verzeichnis der C:\libs\hsqldb_1_8_0_9\bin

java -cp ../lib/hsqldb.jar org.hsqldb.Server -database.0 file:c:/temp/db2 -dbname.0 xdb



abgesetzt werden. Im konkreten Fall wurde die Datenbank xdb mit der Datendatei db2 im Verzeichnis c:/temp angelegt.
Wenn alles geklappt hat, dann sollte das so aussehen.

Schritt 3:

Zu guter letzt möchte man evt. mit einer Client Software ähnlich zum Control Center der DB2 auf der gestarteten Datenbank xdb in gewohnter Weise arbeiten. Dazu verwendet man den Befehl
java -cp ../lib/hsqldb.jar org.hsqldb.util.DatabaseManager im C:\libs\hsqldb_1_8_0_9\bin. In diesem Fenster wird ein ausgedachter Name in Setting Name
eingetragen, hier Test. Wichtig ist hier natürlich der Type und im Feld URL noch xdb einzutragen. Das war schon alles.

Die Installation von Tomcat 6 ist im Grunde kein Problem. Dennoch gibt es ein paar Besonderheit. In diesem Tutorial über Tomcat 6 wid die Umgebungsvariable CATALINA_HOME in Verbindung mit Tomcat 6 unter Windows als Benutzervariable und nicht als Systemvariable eingerichtet. Ich habe die Variable nicht als Systemvariable angelegt, da Anwendungen meist unter einen technischen Benutzer laufen. Nur für diesen Benutzer sollen die Variablen gelten, dazu muss man folgendes tun.

Schritt 1:

Unter http://tomcat.apache.org/download-6-0.cgi muss man Tomcat 6.0.14 herunterladen und entpacken. Man kann auch den Windows-Installer oder die ZIP-Datei wählen. Im vorliegenden Fall wurde die ZIP-Datei gewählt und unter D:\Tomcat entpackt.

Schritt 2:

Jetzt muss eine Benutzervariable CATALINA_HOME festgelegt werden.


















Variable Name: CATALINA_HOME
Variable Value: D:\Tomcat\apache-tomcat-6.0.14

Schritt 3:

Jetzt muss die Systemvariable PATH erweitert werden. Dazu legen wir uns eine Benutzervariable PATH an, falls diese nicht schon existiert. Dort tragen wir die zuvor angelegte Variable CATALINA_HOME ein. Wenn man auf der Konsole set eingibt, dann findet man im PATH einen neuen Eintrag.


















Variable Name: PATH
Variable Value: %CATALINA_HOME%\bin

Schritt 4:

Da wir die ZIP-Version des Tomcat 6 ausgewählt haben, muss noch die tomcat-users.xml angepasst werden. Das ist dann notwendig, wenn man die Administrationskonsole des Tomcat 6 aufrufen möchte, denn hier muss man sich authentifizieren.

< ?xml version='1.0' encoding='utf-8'?>
< tomcat-users>
< role rolename="manager"/>
< role rolename="admin"/>
< user username="webadmin" password="webadmin" roles="admin,manager"/>
< /tomcat-users>

Die Installation von Java ist im Grunde kein Problem. Dennoch gibt es ein paar Besonderheiten. In diesem Java Tutorial wird die Umgebungsvariable JAVA_HOME unter Windows als Benutzervariable nicht als Systemvariable eingerichtet. Man muss das nicht zwingend so machen, aber möchte man auf der DOS-Konsole z.B.: das Tool keytool und das unabhängig von der Java Installationsverzeichnis verwenden, dann sollte man folgendes tun. Ich habe die Variable nicht als Systemvariable angelegt, da Anwendungen meist unter einen technischen Benutzer laufen. Nur für diesen Benutzer sollen die Variablen gelten, dazu muss man folgendes tun.

Schritt 1:

Um das Java SDK oder JDK unter Windows zu installieren muss zuerst unter der URL http://java.sun.com/javase/downloads/index.jsp das JDK 6 update 2 herunterladen und z.B.: unter D:\Java installieren.

Schritt 2:

Jetzt muss eine Benutzervariable JAVA_HOME festgelegt werden.


















Variable Name: JAVA_HOME
Variable Value: D:\Java\jdk1.6.0_02

Schritt 3:

Jetzt muss die Systemvariable PATH erweitert werden. Dazu legen wir uns eine neue Benutzervariable PATH an. Dort tragen wir die zuvor angelegte Variable JAVA_HOME ein. Wenn man auf der Konsole set eingibt, dann findet man im PATHeinen neuen Eintrag.


















Variable Name: PATH
Variable Value: %JAVA_HOME%\bin

Schritt 4:

Test auf der Konsole mit java -version, sollte so ausehen.