Java EE 6 — das Spiel geht weiter

Es war klar, dass es nach der Java EE 5 ein Java EE 6 geben wird. Nun wurde die neue JSR 313: JavaTM Platform, Enterprise Edition 6 (Java EE 6) Specification ausgerufen. Teil der Java EE 6 wird sein:

  • JSR-196 Java Authentication SPI for Containers
  • JSR-236 Timer for Application Servers
  • JSR-237 Work Manager for Application Servers
  • JSR-299 Web Beans
  • JSR-311 JAX-RS: Java API for RESTful Web Services

Auf Web-Beans bin ich gespannt, denn da gehen die Ideen von JBoss Seam ein, also EJB 3 und JSF zu verheiraten.

Aktualisiert werden laut Standard:

  • Enterprise JavaBeans
  • Java Persistence API
  • Servlets
  • JavaServer Faces
  • JAX-WS

Und Verschoben sind:

  • JSR-168 Portlet Specification
  • JSR-170 Content Repository for Java technology API
  • JSR-207 Process Definition for Java
  • JSR-208 Java Business Integration (JBI)
  • JSR-225 XQuery API for Java (XQJ)
  • JSR-235 Service Data Objects
  • JSR-286 Portlet Specification 2.0
  • JSR-289 SIP Servlet v1.1
  • JSR-301 Portlet Bridge Specification for JavaServer Faces

Das Release ist für das 3 Q 2008 angedacht. Viel Zeit also noch.

Das "Swing Application Framework" (JSR 296)

Hans Mueller schrieb schon für JavaOne 2007 eine kleine Einführung in das vielleicht zukünftige Swing-Framework (JSR 296) in Java 7: http://weblogs.java.net/blog/hansmuller/archive/ts-3399-final.pdf. Neben https://appframework.dev.java.net/intro/index.html ist nun unter http://weblogs.java.net/blog/diverson/archive/2007/04/swing_applicati.html ist nun eine weitere keine Beschreibung dazugekommen.

Um die Aufgaben kurz zusammenzufassen: Das Swing-Framwork soll eine (sehr?) leichtgewichtige Alternative zu Eclipse RPC und dem NetBeans Framework werden, um Actions, Properties und Voreinstellungen komfortabel zusammenzubringen. Zentral ist die Klasse Application, die den Lebenszyklus einer Swing-Applikation definiert.

JSR-296 Architecture Diagram

Von https://appframework.dev.java.net/intro/index.html

Im Allgemeinen werden eigene Klassen dann von Application abgeleitet.

public class MySwingApp extends Application {
JFrame mainFrame = null;
@Override protected void startup( String[] args ) {
mainFrame = new JFrame();
mainFrame.setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE );
mainFrame.pack();
mainFrame.setVisible( true );
}
public static void main( String[] args ) {
launch( MySwingApp.class, args );
}
}

In startup() werden nun die Komponenten aufgebaut. Dabei können Elemente wie das JLabel auf Eigenschaften aus Property-Dateien zurückgreifen:

JLabel l = new JLabel();
l.setName( "myLabel" );

Unter dem Namen myLabel gibt es einen Property-Eintrag:

myLabel.text=Text vom Label.

Auch der Name des Fensters lässt sich so setzen:

Application.title=Hallo Welt!

Um einem JButton eine Action zuzuweisen (Listener sind nicht mehr nötig), bekommt jede Aktion einen Namen, die in einer Map eingetragen ist.

ApplicationActionMap aMap = ApplicationContext.getInstance().getActionMap( getClass(), this );
JButton btn = new JButton();
b.setName( "myButton" );
b.setAction( aMap.get( "los" ) );

Die Aktionen selbst kommen von Methoden, die mit @Action annotiert sind.  Standardmäßig bestimmt der Methodenname den Namen der Action, doch das kann mit name überschrieben werden.

@Action( name = "los" );
public void myAction( ActionEvent e ) {
System.out.println( "Es hat klick gemacht." );
}

Properties der Schaltflächen lassen weitere Eigenschaften zu:

myButton.Action.text = &Klick mich...
myButton.Action.accelerator = control K
myButton.Action.shortDescription = klicke und du wirst was erleben

Weitere Links:

PHP in purem Java mit Quercus

Quercus (http://quercus.caucho.com/) implementiert eine PHP 5 Engine in purem Java. Die Software ist unter LGPL und stammt von Caucho, die auch den performanten Resin-Server implementieren. Laut Herstellerangaben laufen bisher

Von den PHP-Funktionen fehlen bisher:

  • call_user_method, call_user_method_array, get_declared_interfaces, interface_exists, property_exists
  • date_default_timezone_get, date_default_timezone_set, date_sunrise, date_sunset, idate, localtime, strptime
  • debug_print_backtrace, restore_exception_handler, set_exception_handler
  • exif_read_data, exif_thumbnail, exif_tagname
  • disk_free_space (stub), disk_total_space (stub), readlink (stub), umask (stub)
  • register_tick_function, unregister_tick_function
  • bind_textdomain_codeset (stub)
  • headers_list, setrawcookie
  • ob_iconv_handler
  • imagecolorclosesthwb, imagecolorset, imagecolorstotal, imageftbbox, imagefttext, imagegammacorrect, imageinterlace, imagelayereffect, imageloadfont, imagepalettecopy, imagepsbbox, imagepscopyfont, imagepsencodefont, imagepsextendfont, imagepsfreefont, imagepsloadfont, imagepsslantfont, imagepstext, imagerotate, iptcembed, image2wbmp, jpeg2wbmp, png2wbmp, imagecreatefromgd2, imagecreatefromgd2part, imagecreatefromgd, imagegd2, imagegd
  • ezmlm_hash
  • mhash_keygen_s2k
  • connection_aborted, connection_status, connection_timeout, __halt_compiler, highlight_file, highlight_string, ignore_user_abort, php_check_syntax, php_strip_whitespace, show_source, sys_getloadavg, time_nanosleep, time_sleep_until
  • mysqli_debug, mysqli_disable_reads_from_master, mysqli_disable_rpl_parse, mysqli_info, mysqli_kill, mysqli_master_query, mysqli_report, mysqli_rpl_parse_enabled, mysqli_rpl_probe, mysqli_rpl_query_type, mysqli_send_long_data, mysqli_send_query, mysqli_server_end, mysqli_server_init, mysqli_ssl_set, mysqli_stmt_send_long_data, mysqli_thread_id, mysqli_thread_safe
  • dns_get_record, inet_ntop, inet_pton, long2ip, pfsockopen, socket_get_status, socket_get_blocking, socket_get_timeout
  • assert_options, dl (stub), get_current_user (stub), get_included_files, get_magic_quotes_gpc, get_magic_quotes_runtime, get_required_files, getopt, getrusage, ini_restore, memory_get_usage, php_ini_scanned_files, php_logo_gid, phpcredits, putenv, restore_include_path, set_magic_quotes_runtime, zend_logo_gid, zend_version
  • proc_close, proc_get_status, proc_nice, proc_open, proc_terminate
  • stream_bucket_append, stream_bucket_make_writeable, stream_bucket_new, stream_bucket_prepend, stream_filter_append, stream_filter_prepend, stream_filter_register, stream_filter_remove, stream_get_filters, stream_get_meta_data, stream_select, stream_set_blocking, stream_set_timeout (stub), stream_set_write_buffer (stub), stream_socket_accept, stream_socket_server, stream_socket_client, stream_socket_enable_crypto, stream_socket_get_name, stream_socket_pair, stream_socket_recvform, stream_socket_sendto, stream_socket_server
  • xml_error_string, xml_get_current_byte_index, xml_get_current_column_number, xml_get_current_line_number, xml_get_error_code, xml_set_external_entity_ref_handler
  • und noch ein paar

Aus PHP heraus lassen sich Java-Objekte bauen und auf die gesamte API zugreifen:

<?php

$a = new java(„java.util.Date“, 1234567);

echo $a->day();

?>

Neu eingeführt in PHP wurde auch das import Schlüsselwort.

Beiträge, die sich mit Quercus beschäftigen und zeigen, wie das MediaWiki und Forums-Software läuft, sind:

Insel: Innere Klasse und Serializable

Werden Exemplare einer nicht statischen inneren Klasse serialisiert, die äußere Klasse implementiert aber nicht Serializable, gibt es einen Fehler, denn intern hält ein Objekt der inneren Klasse einen Verweis auf das Exemplar der äußeren Klasse. Statische innere Klassen machen das nicht, was das Problem mit der Serialisierung lösen kann. Das Datenvolumen kann natürlich groß werden, wenn schlanke nicht-statische innere Serializable-Klassen in einer äußeren Serializable-Klassen liegen, die sehr viele Eigenschaften besitzt.

JAX-WS 2.1 with Spring under Java 6

First you need some jars in your classpath of an web application

  • commons-logging.jar
  • jaxw-api.jar
  • jaxws-rt.jar
  • jaxws-spring-1.1.jar
  • saaj-api.jar
  • saaj-impl.jar
  • spring.jar
  • stax-ex.jar
  • streambuffer.jar
  • xbean-spring-2.8.jar

The Jars are from Spring itself, http://geronimo.apache.org/xbean/, https://jax-ws.dev.java.net/ (jax-ws 2.1, JAXWS2.1_nightly.zip) and https://jax-ws-commons.dev.java.net/spring/ (jaxws-spring-1.1.jar). It is although important to place

  • jaxb-api.jar
  • jaxb-impl.jar

under C:\Programme\Apache Software Foundation\Tomcat 5.5\common\endorsed.

This was the necessary and boring preparation.

Next the Web Service itself

package com.tutego.service;

import javax.jws.WebMethod;
import javax.jws.WebService;
import javax.jws.soap.SOAPBinding;

@WebService
@SOAPBinding(style = SOAPBinding.Style.RPC)
public class GreeterService
{
@WebMethod
public String greet( String name )
{
return "Hello " + name + "!"
}
}

And web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>SpringWeb</display-name>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>jaxws-servlet</servlet-name>
<servlet-class>
com.sun.xml.ws.transport.http.servlet.WSSpringServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>jaxws-servlet</servlet-name>
<url-pattern>/greet</url-pattern>
</servlet-mapping>
</web-app>

The applicationContext.xml follows the suggestions with the namespace.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ws="http://jax-ws.dev.java.net/spring/core"
xmlns:wss="http://jax-ws.dev.java.net/spring/servlet"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://jax-ws.dev.java.net/spring/core http://jax-ws.dev.java.net/spring/core.xsd
http://jax-ws.dev.java.net/spring/servlet http://jax-ws.dev.java.net/spring/servlet.xsd">
<ws:service id="greeterService"
impl="com.tutego.service.GreeterService" />
<wss:bindings id="jax-ws.http">
<wss:bindings>
<wss:binding url="/greet" service="#greeterService" />
</wss:bindings>
</wss:bindings>
</beans>

Now you can consume your WS. If your Web-Context is SpringWeb use http://localhost:8080/SpringWeb/greet?wsdl. Enjoy it!

Spring in einer Web-Applikationen nutzen – so einfach ist das

Mit dem WTP ist es eine Sache von Minuten.

Lege ein Dynamic-Web-Projekt an. Nenne es etwa spring.

Aus dem Spring-all-in-one-glücklich.zip kopiere spring.jar und common-loggings.jar in das WEB-INF/lib.

Lege in WEB-INF eine Datei applicationContext.xml.

Setze in die Datei:

<?xml version="1.0" encoding="UTF-8"?> 


<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>

<bean id="date" class="java.util.Date" />

</beans>

Setzte in WEB-INF/web.xml die Zeilen:

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/applicationContext.xml
</param-value>
</context-param>

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

Schreibe eine index.jsp

<%@page import="org.springframework.web.context.support.WebApplicationContextUtils"%>
<%@page import="org.springframework.context.ApplicationContext"%>
<%
ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());
%>

<%= appContext.getBean("date") %>

Das war’s. Unter http://localhost:8080/spring/ gibt’s dann das Datum.

Aktuelle Closure-Varianten (BGGA, CICE, FCM) im Vergleich

Zwar wird Java 7 höchst wahrscheinlich Closures bekommen, aber nicht jeder wird wissen, dass im Moment ganz unterschiedliche Varianten diskutiert werden:

– Gilad Bracha, Neal Gafter, James Gosling, Peter von der Ahé (BGGA)
– Bob Lee, Doug Lea, and Josh Bloch (CICE)
– Stefan Schulz (FCM)

Der Blog-Eintragt http://www.jroller.com/page/scolebourne?entry=java_7_comparing_closure_proposals vergleicht Szenarien mit den drei bisherigen Vorschlägen.

Find all hyperlinks in a text file

FileChannel     fc = new FileInputStream( "c:/a.html" ).getChannel();
ByteBuffer byteBuf = fc.map( FileChannel.MapMode.READ_ONLY, 0, fc.size() );
CharBuffer charBuf = Charset.defaultCharset().newDecoder().decode( byteBuf );
Pattern pattern = Pattern.compile( "<a.*?href=[\"']([^\"]*?)[\"'].*?>", Pattern.CASE_INSENSITIVE );
Matcher m = pattern.matcher( charBuf );

while ( m.find() )
System.out.println( m.group( 1 ) );

fc.close();

Axis2/XFire Zoff. Der Gewinner: JAXWS 2.1?

Im Moment tobt der Kampf zwischen Axis2 und XFire um die Performance-Krone. Einige Benchmarks zeigen Axis2 vorne, doch das wohl nur, weil eigentlich XML-Bindings-Frameworks (JAXB bei XFire, ADB (Axis2 Data Binding) bei Asix2), also vergleichen werden, und nicht der Serialisierer selbst. Andere wiederum erfreuen sich über die Rechtschreibfehler in der Axis2-Doku bis zur Frustration:

  • isOneHanlder
    boolean isOneHanlder
    this is want if the phaseFirst and phaseLst same hanlder that is for this phase there is only one phase
  • This send the SOAP Message to other SOAP nodes and this alone write the SOAP Message to the wire. Out flow must be end with one of this kind.
  • cloneOMElement
    public OMElement cloneOMElement()
    Clones this element. Since both elements are build compleletely, you will lose the differed building capability.
    Returns:
    Returns OMElement.

Im Moment sieht gar nicht so schlecht für die Referenzimplementierung aus, insbesondere seit der neuen Version JAXWS 2.1 FCS. Die Performance-Ergebnisse sind ausgezeichnet und Spring-Support gibt’s auch. Was will man mehr?

small.png

Einiges mehr zur Debatte:

SwingX Demos

Unter http://swinglabs.org/demos.jsp gibt’s ein Demo (JNLP) aller zentraler SwingX-Komponenten. Im Incubator ist auch einiges interssantes dabei — eine JXSplitButton Demo habe ich immer schon vermisst.

JNLP-Demos:

SOAP-Encodings — Eine kleine Übersicht

RPC-Style oder Document-Style

RPC-Syle (Remote Procedure Style)
Web-Services werden im Sinne von entfernten Methodenaufrufen genutzt.
Eine Web-Service-Methode kann Übergabeparameter und Rückgaben besitzen.
Die Übergabewerte müssen umkodiert werden. XML selbst zum Beispiel wird als umkodierter String übertragen.

Document-Style
Eine Web-Service-Methode hat nur ein Argument.
Das Argument geht als echtes XML-kodiertes Objekt auf den Weg und wird nicht umkodiert.
Da sich jedes beliebige XML-Dokument schicken lässt, ist das flexibler bei Anpassungen, denn Änderungen am WSDL für die Argumente sind nicht nötig.

SOAP-Encoding/Literal-Encoding

SOAP nutzt XML um Daten zu übertragen.
Im Fall von Methoden müssen Argumente und Rückgabewerte wie Zahlen, Strings aber auch Arrays der Datentypen in XML kodiert werden.

Zwei Kodierungen gibt es:

  • Literal-Encoding. Literal Encoding nutzt ein XML Schema zum Validieren der SOAP-Daten.
  • SOAP-Encoding, auch Section 5 Encoding genannt. Das 5. Kapitel der W3C-Spezifiaktion für SOAP schreibt vor, wie Argumente verpackt werden.

Mit den Varianten RPC- oder Document-Style zu versenden und Daten über SOAP-Encoding oder Literal zu kodieren gibt es theoretisch vier Möglichkeiten.

  • RPC/SOAP-Encoding wird nach WS-I Basic Profile nicht empfohlen. (Kann XFire etwa auch nicht.)
  • Document/SOAP ergibt keinen Sinn.

Document/Wrapped

Die Variante über Document/Literal, auch Document/Bare genannt, ist in der Praxis üblich. Sie bietet auch die beste Performance http://www-128.ibm.com/developerworks/webservices/library/ws-soapenc/.

Zwar nimmt Document/Literal nur exakt ein Argument, es lässt sich aber tricksen, in dem mehrere Argumente zu einem neuen komplexen Typ werden. Das nennt man Document/Wrapped. Damit ist auch addPerson(int id, String name) möglich.
Die Paramter id und name werden in einen eigenen Complex-Type gepackt.

LevelGZIPOutputStream — GZIPOutputStream mit Kompressionslevel

Der normale GZIPOutputStream nutzt einen Standardkompressionswert. Um diesen zu ändern, ruft man beim Deflator, der eigentlich hinter der Kompresssion steckt, setLevel() auf, um den Kompressionslevel setzen. Die folgende Unterklasse regelt das für uns:

import java.io.IOException;
import java.io.OutputStream;
import java.util.zip.GZIPOutputStream;

public class LevelGZIPOutputStream extends GZIPOutputStream
{
/**
* Creates a new output stream with a default buffer size and
* sets the current compression level to the specified value.
*
* @param out the output stream.
* @param level the new compression level (0-9).
* @exception IOException If an I/O error has occurred.
* @exception IllegalArgumentException if the compression level is invalid.
*/
public LevelGZIPOutputStream( OutputStream out, int compressionLevel )
throws IOException
{
super( out );
def.setLevel( compressionLevel );
}
}

XFire + JSR 181 Annotations + Jetty = Simple Web-Service

package xfire;

import javax.jws.WebMethod;
import javax.jws.WebService;

@WebService( serviceName = "GreeterService" )
public class GreeterService
{
@WebMethod
public String greet( Person p )
{
return "Hello " + p.getName() + "!";
}
}


package xfire;

public class Person
{
private String name;

public Person()
{
}

public Person( String name )
{
this.name = name;
}


public String getName()
{
return name;
}

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


package xfire;

import org.codehaus.xfire.XFire;
import org.codehaus.xfire.XFireFactory;
import org.codehaus.xfire.annotations.AnnotationServiceFactory;
import org.codehaus.xfire.annotations.jsr181.Jsr181WebAnnotations;
import org.codehaus.xfire.server.http.XFireHttpServer;
import org.codehaus.xfire.service.Service;

public class ServiceServer
{
public static void main( String[] args ) throws Exception
{
XFire xfire = XFireFactory.newInstance().getXFire();
AnnotationServiceFactory factory = new AnnotationServiceFactory(
new Jsr181WebAnnotations(),
xfire.getTransportManager() );
Service service = factory.create( GreeterService.class );
xfire.getServiceRegistry().register( service );
new XFireHttpServer().start();
// http://localhost:8081/GreeterService?wsdl
}
}

package xfire;

import java.net.MalformedURLException;

import org.codehaus.xfire.client.XFireProxyFactory;
import org.codehaus.xfire.service.Service;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;

public class ServiceClient
{
public static void main( String[] args ) throws MalformedURLException
{
ObjectServiceFactory serviceFactory = new ObjectServiceFactory();
Service serviceModel = serviceFactory.create( GreeterService.class );

GreeterService service = (GreeterService)
new XFireProxyFactory().create( serviceModel,
"http://localhost:8081/GreeterService" );
String s = service.greet( new Person( "Ulli" ) );
System.out.println( s );
}
}

Absonderliche Schreibweise bei einer Feld-Rückgabe

Da blättere ich gerade durch das „Just Java“ Buch und glaube, schon einen Fehler gefunden zu haben, da sagt mir der Compiler, dass alles in Ordnung ist:

public class T
{
public static int foo()[]
{
return new int[] { 1, 2, 3 };
}

public static void main( String[] args )
{
System.out.println( foo().length );
}
}

Diese sonderbare Rückgabe habe ich noch nie gesehen und ist mir in der Grammatik der Sprache Java auch noch nie aufgefallen.

Gerade noch in der Java EE, jetzt schon in der Java SE

Was früher noch Teil der J2EE war, ist heute Teil der Java Standard Edition.

Viele Teile der Java Enterprise Edition werden so geläufig, dass sie in die Java Standard Edition wandern.

  • Dennoch wurde es unter der Enterprise-Edition mehr: 78 Pakete in Java EE 5, 54 Pakete in J2EE 1.4, 32 in J2EE 1.3

@Service-EJBs bei JBoss — EJB 3.1 ruft

Bei JBoss ist eine Service-Bean eine besondere EJB, wovon es serverseitig nur ein Exemplar gibt.
Unterschiedliche Clients werden immer mit dem gleichen Exemplar arbeiten.
Es ist ein Singleton, ein nicht gepooltes Objekt.
Eine Service-Bean wird mit @org.jboss.annotation.ejb.Service annotiert.

@Service
public class VitalityCheckBean implements…

Über @Remote und/oder @Local wäre sich auch ganz normal von außen zugänglich.

Interessant sind Service-Bean, weil sie an einem MBean-Server angemeldet werden können und so über JMX zugänglich sind.
Dazu muss die EJB
mit @Service annotiert werden,
ein Management-Interface für die JMX-Operationen implementieren und
mit der Annotation @org.jboss.annotation.ejb.Management das Management-Interface benennen.
Das Management-Interface ist eine ganz normale Java-Schnittstelle und muss keiner Namenskonvention folgen.
Alle dort genannten Methoden sind über eine JMX-Konsole sichtbar.

interface MyManagementInterface
{
void doIt();
String getValue();
void setValue( String string );
}

import org.jboss.annotation.ejb.*;

@Service
@Management( MyManagementInterface.class )
public class SimpleServiceBean implements MyManagementInterface
{
private String string = „(default)“

public void doIt() {
System.out.println( „Ausgabe“ );
}

public void setValue( String string ) {
this.string = string;
}

public String getValue() {
return string;
}
}

In der JMX-Konsole unter http://localhost:8080/jmx-console/ suchen nach SimpleServiceBean mit ManagementInterface.

Der JMX-ObjectName lässt sich über das Attribut objectName der Annotation @Service ändern:
@Service(objectName=“javatutor:service=SimpleServiceBean“)
@Management(MyManagementInterface.class)
public class SimpleServiceBean implements …

Weiteres, auch zum Lebenszkylus unter