Java Blog

GWT Drag and Drop

2010-01-29T18:13:00.001+01:00

Das Projekt unter http://code.google.com/p/gwt-dnd/ gehört mit den zu den bekanntesten Drag & Drop Bibliotheken für GWT. Die von Fred Allen-Sauer geschriebene Bibliothek ist ordentlich mit Beispielen hinterlegt, sodass der Einstieg einfach ist. Ein kleines Beispiel soll die Bibliothek demonstrieren.

a) Nach dem Einbinden der Jar-Datei ist in der XML-Datei für GWT folgendes einzutragen:

<inherits name='com.allen_sauer.gwt.dnd.gwt-dnd'/>

b) Von http://code.google.com/p/gwt-dnd/source/browse/trunk/DragDrop/war/DragDropDemo.css sind die Einträge beginnend mit demo-FlexTableRowExample in die eigene CSS-Datei mit aufzunehmen (nicht alle Einträge sind nötig)

c) Aus http://code.google.com/p/gwt-dnd/source/browse/trunk/DragDrop/#DragDrop/war/images nimmt man die Grafik row-dragger-8.gif passend etwa in das WEB-INF/images mit auf und schaut auf den URL-Eintrag in der CSS, dass der Pfad passt.

c) Von http://code.google.com/p/gwt-dnd/source/browse/trunk/DragDrop/#DragDrop/demo/com/allen_sauer/gwt/dnd/demo/client/example/flextable kopiert man die Dateien

FlexTableRowDragController

FlexTableRowDropController

FlexTableUtil

in das eigene GWT-Projekt.

In onModuleLoad() kann es dann so aussehen:

AbsolutePanel panel = new AbsolutePanel();
panel.setPixelSize(450, 300);
panel.addStyleName("demo-FlexTableRowExample");

FlexTableRowDragController dragController = new FlexTableRowDragController( panel );
FlexTable table = new FlexTable();

table.addStyleName( "demo-flextable" );

HTML handle1 = new HTML( "Heinzelmann (100 €)" );
handle1.addStyleName( "demo-drag-handle" );
table.setWidget( 0, 0, handle1 );
dragController.makeDraggable( handle1 );

HTML handle2 = new HTML( "Wumme (200 €)" );
handle2.addStyleName( "demo-drag-handle" );
table.setWidget( 1, 0, handle2 );
dragController.makeDraggable( handle2 );

HTML handle3 = new HTML( "Fred (90 €)" );
handle3.addStyleName( "demo-drag-handle" );
table.setWidget( 2, 0, handle3 );
dragController.makeDraggable( handle3 );

panel.add(table, 10, 20);
FlexTableRowDropController dropController = new FlexTableRowDropController(table);
dragController.registerDropController(dropController);

RootPanel.get().add( panel );

Anschließend haben wir eine Webseite mit

Heinzelmann (100 €)

Wumme (200 €)

Fred (90 €)

wobei wir die 3 Einträge in der Reihenfolge verschieben können.

Dokumentation zur standardisierten Dependency Injection (CDI)

2010-01-23T12:03:00.001+01:00

Beschreibt die zweiteilige Dokumentation unter http://www.theserverside.com/tt/articles/article.tss?l=DependencyInjectioninJavaEE6. Die Referenzimplementierung von Contexts and Dependency Injection for Java EE (CDI) ist Weld und auch dort gibt es eine sehr gute Dokumentation. DZone hat auch schon gleich eine Reference Card.

Erste Spezifikation der neuen Java 7 Closures

2010-01-23T11:38:00.001+01:00

Die gibt es unter http://mail.openjdk.java.net/pipermail/lambda-dev/2010-January/000349.html. Das ganze heißt “Projekt Lambda”. Vom ersten Überfliegen her wirklich eine starke Vereinfachung der ersten BGGA-Closures Variante und ohne große Überraschungen.

“This is still an issue.” – Bug-Fixes bei Eclipse

2010-01-22T02:11:00.001+01:00

2006 habe ich einen https://bugs.eclipse.org/bugs/show_bug.cgi?id=149380 bei Eclipse eingetragen. Heute purzelt mal wieder eine Nachricht rein “This is still an issue.” Wie wahr nach 4 Jahren. Aber vielleicht bin ich einfach zu ungeduldig…

Denormalisierung für schnelle Key/Value Speichersysteme

2010-01-20T07:46:00.001+01:00

RDBMS kommen im distributed Cloud-Computing selten vor. Daher muss man auch die Datenhaltung überdenken. Ein Blog-Eintrag diskutiert die Änderungen sehr gut: http://highscalability.com/how-i-learned-stop-worrying-and-love-using-lot-disk-space-scale. Im Prinzip geht es darum, aus Joins zu verzichten, und Daten in den verschiedenen Entities zu duplizieren. Die Erfahrung habe ich bei meinen GWT und GAE/J Projekt ebenfalls gemacht. Es führt zu weniger Lesezugriffen insgesamt, wenn man die Daten lokal in der Entity hält und nicht erst aus verschiedenen Entities zusammensucht, wie man bei normalisierten relationalen Modellen tut. (Außerdem ist es bei vielen lese-Zugriffen auch billiger, die Daten an einer Stelle zu haben, anstatt sie von verschiedenen Stellen über Lesezugriffe, die jeweils Kosten nach sich ziehen, einzusammeln.)

In meinen GWT-GAE/J-Projekt habe ich noch einen anderen Ansatz, die Zugriffe auf die Big-Table zu minimieren. Grundsätzlich: Alle GWT-RPC Implementierungen sind Fassaden, die auf Services zurückgreifen (Googe Guice injiziert diese in die RPC-Fassaden). Für diese Endpoints gibt es dann noch einmal einen Caching-Dekorator als eine Art Caching-Aspekt, der sich wie ein Proxy um die eigentlichen RPC-Implementierungen legt. Diese speichert relevante Daten im MemCache zwischen und minimiert so (langsame) Zugriffe auf die Big-Table. Bei Schreibzugriffen löscht der Caching-Proxy die relevanten Daten aus dem Cache, sodass sie neu geladen werden müssen. Das ist einfach und fix.

Groovy 1.7 und Groovy Eclipse 2.0

2010-01-20T07:14:00.001+01:00

Ein paar Tage ist es schon her, da wurde Groovy 1.7 veröffentlicht. Die Neuerungen gibt es unter http://docs.codehaus.org/display/GROOVY/Groovy+1.7+release+notes. Im Wesentlichen sind es die Unterstützung von geschachtelten und anonymen inneren Klassen, ein paar AST-Sachen.

Ganz frisch ist nun das Update der Groovy IDE auf Eclipse Basis. Die Version 2.0 ist fertig und ist nahezu ein vollständiger rewrite. Die News listet http://docs.codehaus.org/display/GROOVY/Groovy-Eclipse+2.0.0+New+and+Noteworthy auf. Weiterhin mit bunten Bildern:

Java 6 Update 18

2010-01-20T05:05:00.001+01:00

Die Änderungen http://java.sun.com/javase/6/webnotes/6u18.html sind vielfältig. Zum einen für die Systemkonfigurationen:

Ubuntu 8.04 LTS Desktop Edition for both JFB and Java SE (x86) in 32-bit
SLES 11
Windows 7 support is now available
Red Hat Enterprise Linux 5.3

Dann:

VisualVM 1.2 is included in 1.6.0_18. Mehr unter https://visualvm.dev.java.net/relnotes121.html

Im JDK gibt es ein Update der Datenbank

Java DB 10.5.3.0

Aus dem Bereich XML:

JSR-173 StAX 1.2 API Upgrade. In erster Linie JavaDoc Korrekturen aber auch Änderungen, da der richtige Klassenlader nun genutzt wird. http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6861589

Und vieles mehr im Bereich Tuning und Fehlerbehebung.

Thema der Woche: “Sicheres” Programmieren

2010-01-20T04:31:00.001+01:00

Studiere im Artikel http://java.sun.com/security/seccodeguide.html die Guidelines 0 bis 5.

Gib für alle einzelnen Tipps ein alternatives Beispiel. (Aufgabe für 2 Wochen.)

Ant 1.8.0RC1 ist auf dem Weg

2010-01-19T17:54:00.001+01:00

Ant 1.7 gibt’s ja schon gefühlte ewige Zeit und bei Ant, dem make des 2.0 Zeitalters, steht ein Update ein. Nichts großes, sondern eher Detailverbesserungen:

Apache Ant 1.8.0RC1 is now available for download .

a new top level element extension-point allows build files to be extended with custom targets more easily
if and unless attributes will be evaluated according to the values of the properties entered if these properties evaluate to true, false, on, off
Ant now requires Java 1.4 or later
new task include provides an alternative to <import> that should be preferred when you don't want to override any targets
numerous bug fixes and improvements as documented in Bugzilla and in WHATSNEW

While in open source projects a final release date strongly depends on the free time of the volunteers/committers, the final release is expected one to two months maximum after this RC. So Ant 1.8.0 is expected between mid February and mid March 2010.

Googles erstes Smartphone mit Android 2.1 verfügbar

2010-01-06T03:55:00.001+01:00

Einige Informationen dazu:

Mit dem MVP-Modell GWT-Anwendungen entwickeln

2010-01-04T06:36:00.001+01:00

Unter http://code.google.com/webtoolkit/doc/latest/tutorial/mvp-architecture.html widmet sich Google nun etwas mehr der Architektur von GWT-Anwendungen. Der Artikel "Large scale application development and MVP" beschreibt, wie die drei Teile Model, View und Presenter zusammenarbeiten und getestet werden können. Komplexer wird das Bsp. da noch History-Management und der Event-Bus mit ins Boot kommen.

Im Quellcode auf der Seite gibt es einige Fehler durch ein falsch verarbeitet <. So steht etwa

public interface Display extends HasValue> {
 HasClickHandlers getAddButton();
 HasClickHandlers getDeleteButton();
 HasClickHandlers getList();
 void setData(List data);
 int getClickedRow(ClickEvent event);
 List getSelectedRows();
 Widget asWidget();
}

statt

public interface Display {
 HasClickHandlers getAddButton();
 HasClickHandlers getDeleteButton();
 HasClickHandlers getList();
 void setData(List<String> data);
 int getClickedRow(ClickEvent event);
 List<Integer> getSelectedRows();
 Widget asWidget();
}

Google Collections Library 1.0 ist raus und bald nicht mehr eigenständig

2010-01-01T09:04:00.001+01:00

Überraschung zum 30.12.2009: Die Google Collections Library (http://code.google.com/p/google-collections/) sieht der Version 1.0. Zweite Überraschung: Die Coll. Lib. wird Teil von Googles allgemeiner Java-Utility-Lib. http://code.google.com/p/guava-libraries/.

NetBeans 6.8

2009-12-16T13:29:00.001+01:00

Von http://www.netbeans.com/ gibt es eine neue Version, die insbesondere im Bereich des neuen Java EE 6 punktet. Die Neuigkeiten führt http://wiki.netbeans.org/NewAndNoteworthyNB68 auf.

Google App Engine 1.3

2009-12-16T13:15:00.001+01:00

Kurz nach 1.2.8 veröffentlich Google nun die Google App Engine 1.3. Von http://googleappengine.blogspot.com/2009/12/app-engine-sdk-130-released-including.html:

Store and Serve - Files can be uploaded and stored as blobs, to be served later in response to user requests. Developers can build their own organizational structures and access controls on top of blobs.
Pricing and Quotas - We include blob storage and transfer under the same datastore pricing and quotas you're already familiar with. For more information, see the App Engine quotas page.
The new Blobstore API is now available in both App Engine SDKs for local development. At this time it can only be used by applications that have enabled billing. There's a lot more information about the API and how it works in the Blobstore documentation (Python, Java) so please check that out and post any questions to the groups.
This release also includes some performance tweaks to the Java runtime. For example, we've sped up many reflective operations by up to 10x resulting in improvements on the order of 10% for applications based on dynamic languages. As always, there are a few other minor changes and bug fixes in this release, so make sure to read our release notes (Python, Java).

Thema der Woche: MVC/MVP

2009-12-16T13:11:00.001+01:00

Lies die Einträge

und skizziere kurz die Unterschiede zwischen den beiden Gui-Pattern MVC und MVP.

Skizziert http://www.c-sharpcorner.com/UploadFile/OVZh/Introducing_MVCSharp_framework03062008064516AM/Images/Untitled-2.gif den Unterschied? Was hat das allen mit Testen zu tun?

Das MVP ist weiterhin gültig, aber der Name hat sich etwas verändert. Erkläre das am Beispiel des Diagramms http://geekswithblogs.net/dchristiansen/archive/2007/12/07/microsoft-patterns-and-practices-team-release-the-model-view-presenter.aspx.

Schreibe ein Beispielprogramm.

Eine Maske soll nach dem Benutzernamen und Passwort fragen.
Ein Fake-Login-Service soll eine bekanntes Username/Passwort-Pärchen authentifizieren. Sind die Werte korrekt, soll eine einfache Meldung erscheinen und der Dialog geschlossen werden.
Schreibe einen JUnit-Testfall

IntelliJ IDEA 9 ist draußen – kommerziell und die Open-Source-Version

2009-12-11T18:31:00.001+01:00

Die Webseite http://www.jetbrains.com/idea/whatsnew/index.htm listet die wichtigsten Neuerungen auf:

GlassFish v3 und Java EE 6 freigegeben

2009-12-11T17:33:00.001+01:00

Unter http://www.theserverside.com/news/thread.tss?thread_id=58858 ist heute zu lesen:

Sun has released the Java Platform Enterprise Edition 6and the GlassFish Enterprise Server v3.
Java EE 6 includes new specifications that add new functionality to the platform, like dependency injection, Bean Valiation and RESTful services, as well as improvements to the existing specifications including very significant improvements to Java Server Faces, Enterprise Java Beans, JPA, Servlets and Java Connectors. Java EE 6 also includes a Web Profile. Additional information on Java EE 6 is available from the WebSite and this Overview Article.
The GlassFish v3 Server implements the Java EE 6 specification. GlassFish v3 is Open Source and fully modular, built on an OSGi kernel and the Grizzly NIO infrastructure. GlassFish v3 is suitable for a wide range of applications, from development to deployments. The long list of additional GFv3 features includes embeddability, very fast startup, redeploy-on-save, session state persistence, dynamic language support, management and monitoring facilities, graphical, CLI and REST command interfaces, and an update center. GlassFish v3 is supported by NetBeans, Eclipse and IntelliJ IDEA.
Additional information on GlassFish v3 Server is available from the Product Page and our main Team Announcement. GFv3 can be downloaded here; the full version is 70MB and the Web Profile 50MB.

GWT 2.0 ist fertig

2009-12-09T15:24:00.001+01:00

http://code.google.com/intl/de-DE/webtoolkit/download.html

App Engine Java SDK 1.2.8 aktualisiert

2009-12-08T18:57:00.001+01:00

Von der http://code.google.com/p/googleappengine/ gibt’s eine neue Version. Die Neuerungen in kürze:

Support for JAXB. JAXB is included in JDK 1.6 (and App Engine's production servers). If you're using JDK 1.5 with your local dev_appserver, you will need to include the JAXB libraries with your application to use it.

http://code.google.com/p/googleappengine/issues/detail?id=1267

New support for application pre-compilation to reduce the length of loading requests. To enable pre-compilation on your application, add this flag to your appengine-web.xml:

<precompilation-enabled>true</precompilation-enabled>
If you have trouble deploying your application, you should remove this flag or set it to false.

Added Quota API (com.google.appengine.api.quota) to match Python
Low-level Memcache API now supports incrementAll()
HTTPResponse object now has getFinalUrl() method for 302 redirects.

http://code.google.com/p/googleappengine/issues/detail?id=1464

Java Dev Appserver now automatically executes tasks. If you prefer the old behavior where tasks do not automatically execute you can use the --jvm_flag=-Dtask_queue.disable_auto_task_execution flag when starting the server.
Additional file extensions permitted when sending mail.

http://code.google.com/p/googleappengine/issues/detail?id=494

Fixed issue with Java mail handler not processing multipart messages correctly
Fixed agent code included in appengine-local-runtime.jar results in RuntimeException

http://code.google.com/p/googleappengine/issues/detail?id=2280

Fixed issue with sort orders defined on properties that allow multiple values

http://code.google.com/p/googleappengine/issues/detail?id=2349

Fixed problem with dropped query strings after requiring log-in

http://code.google.com/p/googleappengine/issues/detail?id=2225

Removed limitation preventing multiple parameters with the same name

http://code.google.com/p/googleappengine/issues/detail?id=2090

Fixed issue with local datastore incorrectly sorting results of ancestor queries

http://code.google.com/p/googleappengine/issues/detail?id=2177

Neu: Release 5.0

2009-12-08T18:52:00.001+01:00

Vom Quellcode-Checker Checkstyle gibt es eine neue Version 5. Die Änderungen beschreiben die Seite http://checkstyle.sourceforge.net/releasenotes.html.

The following checks were added since release 4.4:

AnnotationUseStyle
MissingDeprecated
MissingOverride
PackageAnnotation
SuppressWarnings
EqualsAvoidNull
NoClone
NoFinalizer
AvoidStaticImport
JavadocPackage
ClassTypeParameterName
MethodTypeParameterName
RegexpMultiline
RegexpSingleline
RegexpSinglelineJava
OuterTypeNumber
FileTabCharacter
GenericWhitespace

JUnit 4.8 freigegeben

2009-12-02T19:53:00.001+01:00

Die Infos gibt es unter http://kentbeck.github.com/junit/doc/ReleaseNotes4.8.html. Die Änderungen halten sich in Grenzen:

Summary of Changes in version 4.8

Categories

From a given set of test classes, the Categories runner runs only the classes and methods that are annotated with either the category given with the @IncludeCategory annotation, or a subtype of that category. Either classes or interfaces can be used as categories. Subtyping works, so if you say @IncludeCategory(SuperClass.class), a test marked @Category({SubClass.class}) will be run.
You can also exclude categories by using the @ExcludeCategory annotation
Example:
public interface FastTests { /* category marker */ }
public interface SlowTests { /* category marker */ }

public static class A {
    @Test
    public void a() {
        fail();
    }

    @Category(SlowTests.class)
    @Test
    public void b() {
    }
}

@Category({SlowTests.class, FastTests.class})
public static class B {
    @Test
    public void c() {

    }
}

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@SuiteClasses( { A.class, B.class }) // Note that Categories is a kind of Suite
public static class SlowTestSuite {
  // Will run A.b and B.c, but not A.a
}

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@ExcludeCategory(FastTests.class)
@SuiteClasses( { A.class, B.class }) // Note that Categories is a kind of Suite
public static class SlowTestSuite {
  // Will run A.b, but not A.a or B.c
}
Bug fixes

github#16: thread safety of Result counting

Update von Swing Look and Feel Synthetica V2.9 – tolle Screenshots

2009-11-22T16:55:00.001+01:00

Die Version 2.9 verbesser der Aussehen insbesondere bei den neuen Java 6 Updates. Infos gibt http://weblogs.java.net/blog/wzberger/archive/2009/11/22/synthetica-blackeye-highlights.

Der vorgegebene Konstruktor (engl. default constructor) und Begriffsverwirrungen

2009-11-21T18:25:00.002+01:00

Wenn wir in unserer Klasse überhaupt keinen Konstruktor angeben, legt der Compiler automatisch einen an. Dieser Konstruktor nennt Sun default constructor, was wir als vorgegebener Konstruktor (selten auch Vorgabekonstruktor) eindeutschen wollen.

Schreiben wir nur

class Player
{
}

macht der Compiler daraus immer automatisch:

class Player
{
Player() { }
}

Der vorgegebene Konstruktor hat immer die gleiche Sichtbarkeit wie die Klasse. Ist also die Klasse public/private/protected, wird auch der automatisch eingeführte Konstruktor public/private/protected sein. Ist die Klasse paketsichtbar, ist es auch der Konstruktor.

Vorgegebener und expliziter Standard-Konstruktor

Ob ein parameterloser Konstruktor vom Compiler oder Entwickler angelegt wurde ist ein Implementierungsdetail, der für Nutzer der Klasse irrelevant ist. Daher ist es im Grunde egal, ob wir einen Standard-Konstruktor selbst anlegen oder wir uns einen vorgegebenen Konstruktor vom Compiler generieren lassen: im Bytecode lässt sich das nicht mehr unterscheiden. Selbst die JavaDoc API-Dokumentation, von einer public class C1 {} und public class C2 { public C2(){} } wäre strukturell gleich.

Bytecode der Klassen C1 und C2 im Vergleich

In der Begriffswelt der Insel heißt ein parameterloser Konstruktor immer Standard-Konstruktor, was natürlich den Unterschied verschwimmen lässt, ob der Standard-Konstruktor von Hand angelegt wurde oder als vorgegebener Konstruktor vom Compiler eingeführt wurde. Um das noch klarer zu unterscheiden, können wir es mit vorgegebener (Standard-)Konstruktor und expliziter Standard-Konstruktor weiter präzisieren.

Auch wenn der Compiler einen vorgegeben Konstruktor anlegt, ist es oft sinnvoll, einen eigenen Standard-Konstruktor anzugeben, auch wenn der Rumpf leer ist. Ein Grund ist, ihn zu mit JavaDoc zu dokumentieren, eine anderer, die Sichtbarkeit explizit zu wählen, etwa wenn die Kasse public ist, aber der Konstruktor nur die Paketsichtbarkeit haben soll.

Begrifflichkeit I In der Java-Language Specification gibt es bei den Konstruktoren nur die Trennungen in no-arg-constructor (parameterloser Konstruktor) und default constructor (vorgegebener Konstruktor), aber den Begriff „standard constructor“ gibt es nicht. Viele Autoren übersetzen die englische Bezeichnung „default constructor“ (unserem vorgegebenen Konstruktor) einfach nur mit „Standard-Konstruktor“.

Begrifflichkeit II Einige Autoren nennen nur den vom Entwickler explizit geschriebenen parameterlosen Konstruktor „Standard-Konstruktor“ und trennen dies sprachlich vom Compiler generierten Konstruktor, den sie weiterhin „Default-Konstruktor“ nennen. Beide werden dann zusammengefasst einfach parameterlose Konstruktoren genannt. Wenn also etwa die Frage gestellt wird, ob die Deklaration class C { } einen Standard-Konstruktor enthält, ist die Begrifflichkeit des Autors zu prüfen. Wenn der Autor nur den ausprogrammierten parameterlosen Konstruktor „Standard-Konstruktor“ genannt hat, so hätte die Klasse C nach dessen Definition keinen „Standard-Konstruktor“. Nach der Insel-Definition hätte die Klasse zwar einen vorgegebenen (Standard-)Konstruktor, aber keinen expliziten Standard-Konstruktor.

Frustrierend: Java 7 doch später

2009-11-19T17:40:00.001+01:00

Heute auf der Devoxx Konferenz gab es die Info, dass wegen der neuen Spracheigenschaften sich Java 7 von Februar auf etwa September verschieben wird. Immerhin wird es dann wohl Closures geben und das Projekt Coin wird vermutlich noch mehr aufnehmen, etwa die Aufzählung von mehreren Exceptions im catch-Block.

Überraschung: Wohl doch Closures in Java 7

2009-11-19T17:20:00.001+01:00