Um den/die Ordner durchzulaufen existiert ein DirectoryWalker.
Um den abstrakten DirectoryWalker nutzen zu können könnte man z.B. eine folgende Implementierung nutzen:

public class TestDirectoryWalker extends DirectoryWalker {

	public TestDirectoryWalker(IOFileFilter dirFilter, IOFileFilter fileFilter, int depth) {
		super(dirFilter, fileFilter, depth);
	}

        /**
          * This method sets the start directory and starts the DirectoryWalker.
          */
	public List search(File startDir) throws IOException {

		List results = new ArrayList();
		walk(startDir, results);
		return results;
	}

	protected boolean handleDirectory(File directory, int depth, Collection results) {
		// return true, cause every sub directory is allowed
		return true;
	}

	protected void handleFile(File file, int depth, Collection results) {		

                // we want only the files with the name "abc.txt" in the
                // subdirectories. This files will be inserted in the given
                // result collection. This collection is the same as the
                // created List in search(File)
		String filename = file.getName();
		if("abc.txt".equalsIgnoreCase(filename))
			results.add(file);
	}
}

Wie man sehen kann, kann man innerhalb weniger Zeilen einen DirectoryWalker schreiben, der alle Unterordner durchgeht und alle Dateien mit dem Titel “abc.txt” liefert.
Die Nutzung ist genauso simpel:

TestDirectoryWalker idw = new TestDirectoryWalker(DirectoryFileFilter.DIRECTORY, FileFilterUtils.suffixFileFilter(".txt"), 3);

		String startDir = "D:/Temp/.../blub";
		List files = null;
		try {
                        // search the directory for the wanted files
			files = idw.search(new File(startDir));
			System.out.println("Files: #" + files.size());

                        // sort the resulting files using the LastModifiedFileComparator
			System.out.println("first file: " + files.get(0));
			Collections.sort(files, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);

			System.out.println("oldest file: " + files.get(0));
		} catch (IOException e) {
			e.printStackTrace();
		}

Der Konstruktor TestDirectoryWalker(IOFileFilter, IOFileFilter, int) erwartet zwei Filter, einen für die Ordner und einen für die Dateien. Die Auswahl ist umfangreich, ansonsten kann man auch seinen eigenen schreiben.

Als letztes ist vielleicht noch die Zeile

Collections.sort(files, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);

interessant. LastModifiedFileComparator ist wie der Name schon andeutet, eine Klasse welches Comparator implementiert bzgl. File.lastModified(). Die Liste mit den gefundenen Dateien wird aufsteigend sortiert.

Innerhalb weniger Minuten kann man verschiedene Ordner nach speziellen Dateien suchen. Dank Apache Commons IO.

Das Beispiel zeigt wie man mittels JMS eine MQ Nachricht verschicken und empfangen kann.
Die Architektur steht hier nicht im Vordergrund, das nur die MQ Kommunikation.

Für das Versenden von MQ Nachrichten ist ein MQQueueSender verantwortlich, entsprechendes gilt für das Empfangen (MQQueueReceiver).
Da bei MQ mehrere Clients Nachrichten verschicken können und jedem Client nur seine Antworten interessieren, gibt es die Möglichkeit dem Receiver einen Filter (Selector) anzugeben. Mit diesem Selector werden dann nur die MQ Nachrichten geliefert (empfangen), welche die Kriterien erfüllen.
Hier lohnt es sich (nur) Correlation und Message ID zu nutzen, da andere Eigenschaften zu langsam in der Filterung sind.
Bei der Correlation ID muss noch das Präfix ‘ID:’ angehangen werden, welches bei der Message ID schon automatisch vorhanden ist.

Nachfolgend ein kleines MQ JMS Beispiel

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TextMessage;

import com.ibm.jms.JMSTextMessage;
import com.ibm.mq.jms.JMSC;
import com.ibm.mq.jms.MQQueue;
import com.ibm.mq.jms.MQQueueConnection;
import com.ibm.mq.jms.MQQueueConnectionFactory;
import com.ibm.mq.jms.MQQueueReceiver;
import com.ibm.mq.jms.MQQueueSender;
import com.ibm.mq.jms.MQQueueSession;
import com.ibm.msg.client.wmq.v6.base.internal.MQC;

public class TestMQJMSPlain {

     public static void main(String[] args) {

         MQQueueConnectionFactory cf = new MQQueueConnectionFactory();

         try {

           cf.setHostName("...");
           cf.setPort(1415);
           cf.setTransportType(JMSC.MQJMS_TP_CLIENT_MQ_TCPIP);
           cf.setQueueManager("...");
           cf.setChannel("SYSTEM.DEF.SVRCONN");
           String qIn = "...";
           String qOut = "...";

           MQQueueConnection connection = (MQQueueConnection) cf.createQueueConnection();
           // create a new Session, which is not transacted
           MQQueueSession session = (MQQueueSession) connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
           // create queues
           MQQueue queueRead = (MQQueue) session.createQueue(qIn);
           MQQueue queueWrite = (MQQueue) session.createQueue(qOut);
           // if the client on the other side is a non-jms client set this property
           queueWrite.setTargetClient(JMSC.MQJMS_CLIENT_NONJMS_MQ);

           // create a sender
           MQQueueSender sender =  (MQQueueSender) session.createSender(queueWrite);
           MQQueueReceiver receiver = null;      

           // create the message which will be sent over MQ
           JMSTextMessage message = (JMSTextMessage) session.createTextMessage(dat);
          // define the message type (not really necessary, depends from the client on the other side)
          message.setJMSType(MQC.MQFMT_STRING);
          // set a correlation ID
          message.setJMSCorrelationID("MyIdSomethingElse" + System.currentTimeMillis());
          // set the replay queue
          message.setJMSReplyTo(queueRead);

          // lets start the connection
          connection.start();

          // send the JMS-Message
          sender.send(message);

          // create the selector to retrieve only the right response
          // the combination of message and correlation ID depends the individually defined constraints
          // it is wise to use the correlation and message ID for the selector, cause this are
          // faster as some other properties
          // Hint: the format for correlation ID is
          // JMSCorrelationID = 'ID:AF01CE....hex string...'
          // the prefix 'ID' is mandatory. However the message ID contains the fragment 'ID:'
          String selector = "JMSCorrelationID = 'ID:" + dumpId2Hex(message.getJMSCorrelationIDAsBytes()) +
                                 "' AND JMSMessageID = '" + message.getJMSMessageID() + "'";

          // create a receiver with the defined selector
          receiver = (MQQueueReceiver) session.createReceiver(queueRead, selector);

          // receive the response (with match the filter in the selector). This call blocks max. 20000 ms
          Message receivedMessage = receiver.receive(20000);

          // check if message is received and a text message
          if (receivedMessage instanceof TextMessage) {
               // get the content...
              String replyString = ((TextMessage) receivedMessage).getText();
         }

         // close everything...
         sender.close();
         receiver.close();
         session.close();
         connection.close();		    

           }
	    catch (JMSException jmsex) {
	    	log.error("JMSException", jmsex);
	    }
	    catch (Exception ex) {
	    	log.error("An other error occurred.", ex);
	    }
     }
}

Wie man bei [1] sehen kann, unterstüzt WebSphere 6.1 Servlet 2.4 und JSP 2.0 – das entspricht etwa einem Tomcat 5.5.x [2]. Möchte man nun JSF 1.2 (mittels MyFaces 1.2.x) nutzen hat man da ein kleines Problem.
JSF 1.2 benötigt nämlich Servlet 2.5, JSP 2.1 und Java 5 oder später. Genau das kann WebSphere 6.1 mit seiner integrierten JSF 1.1 Implementierung nicht bieten.

Erst bei WebSphere Application Server 7 werden die gewünschten Versionen unterstützt. Wenn man jetzt nicht auf Version 7 umsteigen will/kann, und nicht unzählige Bibliotheken in WebSphere 6 ersetzen will, kann man es sich “einfach” machen und auf JSP verzichten. Das geht. Und zwar mit JSF und Facelets [4] als View-Technologie. D.h. es ist kein JSP mehr notwendig und WebSphere kann irgendeine Version anbieten.

Ich werde jetzt hier nicht Facelets beschreiben, das ich mach vielleicht mal später. Speziell geht es hier gerade um die Nutzung von JSF 1.2 mit Facelets in WebSphere Application Server 6.x.

Dazu muss in dem WEB-INF/lib-Ordner alle benötigten Bibliotheken aufgeführt werden. Das sind mindestens diese:

• commons-beanutils-1.7.0.jar
• commons-codec-1.3.jar
• commons-collections-3.2.jar
• commons-digester-1.8.jar
• commons-discovery-0.4.jar
• el-api-1.0.jar
• el-impl-1.0.jar
• jsf-facelets-1.1.11.jar
• jstl-1.2.jar
• myfaces-api-1.2.5.jar
• myfaces-impl-1.2.5.jar
• myfaces-shared-impl-3.0.5.jar

Wie man vielleicht bemerkt hat, commons-logging.jar ist nicht dabei. Denn diese existiert schon in WebSphere App Server und sollte rausgenommen werden. Weiter sind die el-*.jars auch drin. Die hat WebSphere gar nicht und werden von Facelets benötigt.

Nachdem man nun das WAR-Archiv in WebSphere Application Server deployed hat, muss man noch die Reihenfolge des Classloaders ändern, damit zuerst die eigenen Bibliotheken genutzt werden und nicht z.B. JSF 1.1 von WebSphere. Das wählt man in “Modul verwalten”, wenn man das Web-Modul ausgewählt hat aus, und selektiert in der Select-Box den Eintrag, damit der Classloader der Anwendung zuerst gewählt wird (intern auch als “PARENT_LAST” bekannt).

Nun kann die Anwendung gestartet werden und sollte ohne Probleme laufen. Im Endeffekt einfach. Wenn man weiß wie!

Links:
[1] WebSphere supported Specifications and API
[2] Tomcat
[3] MyFaces
[4] Facelets

Überblick

Um JavaFX-Anwendung zu nutzen, braucht man standardmäßig nur die aktuelle Java Version. Hier ist Java 1.6.0_11 [3] passend, da diese Version die Fähigkeit anbietet, Applets auf den Desktop zu ziehen. Beim ersten Aufruf einer JavaFX-Anwendung werden die Runtime-Bibliotheken beim ersten Mal runtergeladen, wenn sie nicht vorhanden sind. Bei entsprechender Implimentierung der JavaFX-Anwendung (was ja ein Applet ist), kann man sich das Applet auf den Desktop ziehen. Schließt man dann den Browser, bekommt man die Möglichkeit ein Verweis auf den Desktop zu erstellen, um später das Applet – und nur das Applet, nicht auch den Browser – wieder zu nutzen.

JavaFX kommt auch mit einer neuen Script-Sprache, dem JavaFX Script. JavaFX Script ist eine deklarative kompilierbare Scriptsprache, was auch type inference – und somit implizit auch statische Typen – anbietet.

Entwicklung

Zur Entwicklung. Sun setzt ja bekanntlich auf Netbeans. Das bedeutet in dem Fall, es gibt ein Netbeans-Version [4] mit integriertem JavaFX. Diese Version beinhaltet das JavaFX Software Development Kit, Beispiele und bei Windows noch den JavaFX Mobile Emulator.

Zusätzlich gibt es Plugins für Photoshop und Adobe Illustrator. Mit JavaFX sollen ja auch schöne GUIs erstellt werden und hierfür bietet man Grafikern eine einfache Möglichkeit dies in ihren bekannten Umgebungen zu erstellen. Wie gut diese Plugins funktionieren, kann ich leider nicht sagen.

Für Eclipse-Nutzer gibt es ein veraltetes Plugin [5], hier ist zu hoffen, dass demnächst eine aktuellere Version veröffentlich wird.

Mit Netbeans kann man jedenfalls recht einfach erste JavaFX Anwendungen realisieren. Für die grafische Darstellung kann man eine Palette von vorhandenen Mustern, Transformationen etc nutzen. Jedoch gibt es hier keinen visuellen Designer. Die Palette beinhaltet nur Code-Fragmente, die in den existierenden Code eingefügt werden können. Ob es hier einen Designer geben wird, ist fraglich, da entsprechen Photoshop/Illustrator Plugins existieren.

Features

Die Features dürfen nun auch nicht vergessen werden:

• RIA Plattform für verschiedene Endgeräte
• Einfache Integration für Grafiker
• Gute Unterstützung von Grafiken, 2D, 3D, Video, Audio
• Zugang zu Java-Bibliotheken

Für weitere Details sei auf die Überblicks-Seite in [1] verwiesen.

Links:
[1] JavaFX Überblick: http://javafx.com/about/overview/
[2] JavaFX Getting Started with the Technology: http://javafx.com/docs/gettingstarted/javafx/
[3] Java SE 6 Update Release Notes: http://java.sun.com/javase/6/webnotes/6u11.html
[4] JavaFX Download (for Windows): http://javafx.com/downloads/windows.jsp
[5] OpenJFX Eclipse Plugin v0.0.2: http://download.java.net/general/openjfx/plugins/eclipse/
[6] JavaFX API: http://java.sun.com/javafx/1/docs/api/index.html
[7] JavaFX Script Language: http://java.sun.com/javafx/1/tutorials/core/
[8] JavaFX Language Reference: http://openjfx.java.sun.com/current-build/doc/reference/JavaFXReference.html
[9] JavaFX Blog: http://blogs.sun.com/javafx/