Code style: Remove unnecessary statements and keywords

Bad

Good

import java.lang.*;

import java.util.*;

import java.util.Scanner;

import java.util.*;

class MyClass extends Object { }

class MyClass { }

class MyClass {

int i = 0;

boolean b = false;

char c = ‚\u0000‘;

String s = null;

double d = 0.0;

}

class MyClass {

int i;

boolean b;

char c;

String s;

double d;

}

class MyClass {

MyClass() { super(); }

}

class MyClass {

MyClass() { }

}

interface MyInterface {

public abstract void foo();

}

interface MyInterface {

void foo();

}

void lollipop() {

return;

}

void lollipop() {

}

java.lang.String s;

String s;

Object[] param = new Object[ 1 ];

param[ 0 ] = i;

Object[] param = { i };

Something missing?

Verzeichnisstrukturen für Java-Projekte

In den Java-Projekten haben sich unterschiedliche Verzeichnisstrukturen durchgesetzt. Je nach Komplexität ist eine einfache ausreichend oder eine starke Strukturierung gibt eine Vorgabe.

Eine einfache Vorgabe ist, die Order mit dem Quellcode und den übersetzten Klassendateien zu trennen. Die üblichen Ordnernamen für Java SE-Projekte sind src und bin. Entwicklungsumgebungen wie Eclipse übersetzten Java-Typen aus dem src- in den bin-Ordner und kopieren Ressourcen wie Bilder und Übersetzungsdateien bei jedem Build ebenfalls in den bin-Ordner. Eclipse unterstützte diesen Aufbau standardmäßig, wenn beim Dialog für ein neues Java-Projekt unter „Project Layout“ die Option „Create separate folders vor source and class files“ aktiviert ist.

Unter NetBeans ist die Standardstruktur etwas anders und eng mit dem Build-Tool Ant verbunden. Der Ordner src enthält die Standard-Klasen und Ressourcen, ein zweiter Ordner test die Test-Klassen und Ressourcen. Die übersetzten Java-Klassen nimmt der Ordner build/classes auf. Das Ergebnis des Builds, eine Jar-Datei im Fall eines einfachen Java-Projekts, steht im Ordner dist.

Einen deutlichen Schritt weiter geht die Anregung vom Build-Manager Maven. Es schlägt zwei Hauptordner src und target vor. Der src-Ordner enthält alle Quellen und Ressourcen und ein build übersetzt das Projekt in den target-Ordner. Maven empfiehlt, den src-Ordner weiter nach Artefakten zu unterteilen: main (eigentliche Applikation oder Bibliothek), test (Testfälle), demo (Beispiele). Unter diesen Artifakten-Ordnern folgenden weitere Unterordner. Der wichtigste Ordner ist für Java-Projekte java. Es kommen optional hinzu: ressources (für Ressourcen), config (Konfigurationsdaten), webapp (Dateien einer Web-Applikation). Für den Ausgabeordner target wiederum sieht Maven die Unterteilung in classes (übersetze Klassen aus src/main/java und Kopie aus src/main/resources), javadoc (Java-Doc von src/main/java), test-classes (Test-Klassen aus src/test/java und Kopie aus src/test/resources).

Inconsistent lower/uppercase abbreviations in Java type names

Library

Uppercase Variant

Lowercase Variant

Special Case

Java SE

GZIPOutputStream

ZipOutputStream

HttpURLConnection

DGC

MidiSystem

StAXSource

AWTError

JdbcRowSet

 

HTML

Clob, Blob, NClob

 

ImageIO

 

 

JAXBContext

 

 

JMXConnector

 

 

JPEGImageWriteParam

 

 

PBEKey

 

 

RMIClassLoader

 

 

RSAKey

 

 

SAXParser

 

 

SOAPElement

 

 

SQLException

 

 

SSLContext

 

 

UIDefaults

 

 

URI, URL, PrinterURI

ReferenceUriSchemesSupported

 

Java EE

XMLEvent

XmlElement

W3CDomHandler

XMLOutputFactory

XmlSchema

 

XMLType

XmlType

 

EJB

Xid

 

ELResolver

JspTag

 

HTTPBinding

HtmlMessage

 

JAXBElement

SqlResultSetMapping

 

JDBCStats

HttpServlet

 

JMSSessionStats

 

 

JVMStats

 

 

SAAJResult

 

 

SOAPBinding

 

 

URIValidator

 

 

XAConnection

 

 

Spring

MessageEOFException

JmsException

 

OC4JJtaTransactionManager

JmxUtils

 

SQLErrorCodes

SqlCall

 

SQLExceptionTranslator

SqlFunction

 

URIEditor

UrlResource

 

 

JndiRmiClientInterceptor

 

 

JpaTemplate

 

 

JstlView

 

 

MimeMailMessage

 

 

SimpleJaxWsServiceExporter

 

 

XmlBeanFactory

 

Apache Commons

NTPUDPClient

NtpUtils

HttpURL

FTPClient, POP3Client

HttpClient

 

SimpleSMTPHeader

 

 

NTLMScheme

 

 

RFC2965Spec

 

 

URI

 

 

 

What is your favourite example or inconsistent usage?

 

 

Werbung: Wir haben neue Java-Seminare!

Buchkritik: Beautiful Code: Leading Programmers Explain How They Think

Beautiful Code: Leading Programmers Explain How They Think
Andy Oram, Greg Wilson. O’Reilly. 2007. 618 Seiten
Bekannten Autoren und Software-Architekten geben in 33 Kapiteln viele Beispiele ihrer Kunst, und Einblicke in ihr Schaffen. Doch sehr spezielle Beispiele in diversen Programmiersprachen machen es für Java-Programmierer schwer, hier „schönen Code“ zu entdecken. Unter dem Strich bleibt nicht viel für Java-Entwickler über, wenn Programmiersprachen wie C, Ruby, LISP ihren Platz finden und Algorithmen vorgestellt werden, die für die allermeisten kaum relevant sind. Interessant ist es allemal, und wer sich viel Zeit für die Einarbeitung nimmt, wird auch sicherlich viel entdecken, zumal das Design einen größeren Stellenwert einnimmt, als der Quellcode an sich. Bei den wenigen Java-Programmen gibt leider etwas zu bemängeln. Einmal ein einfacher Fehler auf Seite Seite 478, in dem die Klammerung falsch ist:

class Sample {}
public static void main(String[] argv) {
System.out.println("Hello World");
}

Der zweite Hammer haut aber stärker rein und ist definitiv kein Beispiel für „Beautiful Code“. Seite 332 stellt eine EJB Session-Bean FileReaderBean vor, die über eine FileInputStream Daten vom Dateisystem holt – das ist nun wirklich nicht in Ordnung. Toll finde ich, dass die Erlöse an Amnesty International gehen: „All royalties from this book will be donated to Amnesty International.”. Das nette Kapitel Code in Motion ist online verfügbar.

Google Android und die nicht-JVM

Google Android ist der Versuch von Google, ein quelloffenes und freies SDK für mobile Endgeräte zu etablieren. Nach ein paar Monaten gibt es die ersten Stimmen aus dem Netz, die nicht so positiv sind. Insbesondere werden die mangelhafte Dokumentation (damit meine ich nicht die „FAQ“ http://code.google.com/android/kb/general.html), fehlende Beispiele und ein nicht öffentliches Issue/Bug-Tracking-System bemängelt. Interessant ist ebenfalls der Ansatz von Google, eine eigene JVM auszuliefern, um sich damit eventuell um Lizenzrechte rumzuwinden. Die Idee ist, den Java Quellcode zunächst über den Standard-Compiler in Java Bytecode zu übersetzen, aber dann über einen weiterer Präprozessor dx den JVM-Bytecode in das so genannte DEX-Format zu bringen, was die VM Dalvik dann ausführt. Dalvik ist etwas anders gebaut als die Standars-JVMs, denn es ist zum Beispiel eine Register-Maschine und keine Stack-Maschine. Ein weiteres Detail sind die Bibliotheken. Die Java Standard Library kommt vom Apache Harmony Projekt und ist somit Apache-Lizenz, genauso wie vieles von Android auch. (Das Betriebssystem unter der Haube ist Linux und somit GPL.)

Sehr große Anfrage an den JBuilder

In meiner Linksammlung sitzt http://www.borland.com/jbuilder, was mit der Browser nun beantwortet mit:

 

Server Error in ‚/‘ Application.


Server Too Busy

Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.
Exception Details: System.Web.HttpException: Server Too Busy
Source Error:

An unhandled exception was generated during the execution of the current web request. Information regarding the origin and location of the exception can be identified using the exception stack trace below.

Stack Trace:

[HttpException (0x80004005): Server Too Busy]
System.Web.HttpRuntime.RejectRequestInternal(HttpWorkerRequest wr) +148


Version Information: Microsoft .NET Framework Version:1.1.4322.2300; ASP.NET Version:1.1.4322.2300

Entweder geht es dem Produkt wahnsinnig gut und jeder will den JBuilder kaufen/laden/… oder .NET ist so schlecht, dass es mit der Last nicht umgehen kann.

Warum catch ( Exception e ) schlecht ist, und was man dagegen tun kann

Eine ganze Reihe von Java-Methoden lösen eine ganze Reihe von unterschiedlichen Ausnahmen aus:

private void setLaf()

{

try

{

UIManager.setLookAndFeel( UIManager.getSystemLookAndFeelClassName() );

}

catch ( ClassNotFoundException e )

{

handle();

}

catch ( InstantiationException e )

{

handle();

}

catch ( IllegalAccessException e )

{

handle();

}

catch ( UnsupportedLookAndFeelException e )

{

handle();

}

}


Oftmals befindet sich dann im Quellecode eine Anweisung wie catch ( Exception e ), die große Kaskaden von catch-Anweisungen verkleinern soll. (So kann man auch den gleichen Handler verwenden.) Das Problem dabei: Man fängt mehr, als man will, insbesondere wertvolle RuntimeExceptions, die man ungern als checked SQL- oder sonstwas-Exeption vernudelt haben möchte. Wenn ich mir moderne Frameworks, wie Spring oder Java EE 5 anschaue, wird dort ausschließlich mit RuntimeException gearbeitet, und die fängt eine catch ( Exception e ) ebenfalls brutal ab. Wenn zum Beispiel das Framework aufgrund einer unchecked Exception eine Transaktion abbricht, wir diesen Fehler aber schon „weggefangen“ haben, ist das ein echtes Problem.

Ich sehe für eine vernünftige Behandlung mehrere Möglichkeiten:

  • Warten auf Java 3000, da dort sicherlich so etwas wie catch ( IOException, SQLException e ) definiert wird.
  • Eine gemeinsame handle()-Funktion zu definieren, die man dann aus den catch-Handlern ansteuert.
  • Ein catch ( Exception e ) und dann ein instanceof Test auf die erwarteten Exceptions mit einer re-thow, wenn der Typ nicht bekannt ist.

Schlechter Quellcode von NeuralBuild (NeuralLimits)

Über den Artikel http://entwickler.com/itr/news/psecom,neu,1,id,39010,nodeid,82.html bin ich auf einen Generator aufmerksam geworden, der automatisch DOAs und Transfer-Objekte erzeugt. Leider ist doch der generierte Quellcode wenig überzeugend. En Besipiel:

    public Integer insertCompany(Company criteriaCompany)
throws NeuralBuildJavaSampleDAOInsertException {
Integer keyVal = new Integer(0);
con = connMgr.getConnection("neuralbuildjavasample");
int setindex = 1;
String vSQL = constructInsertPreparedStatement(criteriaCompany);
try {
PreparedStatement ps = con.prepareStatement(vSQL,
PreparedStatement.RETURN_GENERATED_KEYS);
if (criteriaCompany.CompanyID_isSet) {
ps.setInt(setindex, criteriaCompany.getCompanyID().intValue());
setindex++;
}
if (criteriaCompany.CompanyName_isSet) {
ps.setDate(setindex,
(java.sql.Date) criteriaCompany.getCompanyName());
setindex++;
}
ps.executeUpdate();
ResultSet rs = ps.getGeneratedKeys();
if (rs.next()) {
keyVal = Integer.valueOf(rs.getObject(1).toString());
}
rs.close();
rs = null;
ps.close();
} catch (Exception e) {
connMgr.freeConnection("neuralbuildjavasample", con);
throw new NeuralBuildJavaSampleDAOInsertException("Insert Failed " +
e.getMessage(), e);
}
connMgr.freeConnection("neuralbuildjavasample", con);
return keyVal;
}
  • new Integer(0) wird immer gebaut, auch wenn es später überschrieben wird.
  • finally fehlt: So ist das close() nicht garantiert. (Nicht sooo schlimm, da bei Freigabe der Connection auch ResultSet und XXXStatement freigegeben werden.)
  • Quellcode-Duplizierung bei connMgr.freeConnection(„neuralbuildjavasample“, con);. Das gehört auf jeden Fall in finally{}
  • Was soll den rs = null; bewirken? Den GC hilt das bei lokalen Variablen nun wirklich nicht.
  • catch (Exception e) muss wirklich sein? Ode doch catch (SQLException e)?
  • Wenn die Rückgabe ein Integer-Objekt ist, warum dann „Integer.valueOf(rs.getObject(1).toString());“ schreiben? Das funktioniert zwar, aber wenn getObject() schon in Integer ist, muss man nicht erst in ein String und dann wieder zurück konvertieren.
  • Sollte man wirklich einfach nur 0 zurückliefern, wenn man keinen Schlüssel bekam?

Die anderen Methoden habe auch so ihre Macken, so mit der Namensgebung.

  • CachedRowSet Rs = null; Groß-/Kleinschreibung!
  • Gemische Groß-/Kleinschreibung ist Standard, nicht so bei setindex.
  • Unterstriche sind von Sun in der Namenskonvention nur bei Konstanten vorgesehen, aber nicht etwa bei CompanyID_isSet
  • Ist die Namensgebung so gut, wenn man liest
    ps.setDate(setindex, (java.sql.Date) criteriaCompany.getCompanyName() );
    Also setDate() auf ein Company-Name?
  • Die API-Doku sollte nicht schreiben: „Delete an object from the database.“ sondern laut Suns-JavaDoc-Vorgaben: „Deletes an object from the database.“

JAXB2-Annotationen an Beispielen

Schreiben der Felder statt Nutzen der Setter/Getter: Annotiere die Klasse mit

@XmlAccessorType( XmlAccessType.FIELD )

 

@XmlAttribute

 

class Person

{

  String name;

 

  @XmlAttribute

  int id;

}

<person id=“123″>

    <name>Christian</name>

</person>

 

@XmlValue

Gibt es nur ein Element kann @XmlValue dies in den Rumpf setzten.

 

class Person

{

  int id;

}

<person>

    <id>123</id>

</person>

class Person

{

  @XmlValue int id;

}

<person>123</person>

 

@Transient

Nimmt Element aus der XML-Abbildung aus.

 

class Person

{

  @XmlTransient int id;

 

  String firstname;

  String lastname;

}

<person>

    <firstname>Christian</firstname>

    <lastname>Ullenboom</lastname>

</person>

 

@XmlList

Schreibt Elemente einer Sammlung nicht in einzelnen Elementen, sondern mit Leerzeichen getrennt.

 

class Person

{

  List<String> emails;

}

 

<person>

    <emails>muh@kuh.de</emails>

    <emails>zick@zack.com</emails>

</person>

 

class Person

{

  @XmlList

  List<String> emails;

}

<person>

    <emails>muh@kuh.de zick@zack.com</emails>

</person>

Elemente einpacken mit @XmlElementWrapper

 

class Person

{

  List<String> emails;

}

<person>

    <emails>muh@kuh.de</emails>

    <emails>zick@zack.com</emails>

</person>

class Person

{

  @XmlElementWrapper(name = „emails“)

  @XmlElement(name = „email“)

  List<String> emails;

}

<person>

    <emails>

        <email>muh@kuh.de</email>

        <email>zick@zack.com</email>

    </emails>

</person>

 

 

Reihenfolge ändern

 

class Person

{

  String lastname, firstname;

}

<person>

    <lastname>Ullenboom</lastname>

    <firstname>Christian</firstname>

</person>

@XmlType( propOrder = { „firstname“, „lastname“ } )

class Person

{

  String lastname, firstname;

}

<person>

    <firstname>Christian</firstname>

    <lastname>Ullenboom</lastname>

</person>

 

@XmlJavaTypeAdapter

Anpassen der XML-Abbildung, etwa für Datumswerte.

 

class Person

{

  Date birthday;

}

<person>

    <birthday>1973-03-12T00:00:00+01:00</birthday>

</person>

class Person

{

  @XmlJavaTypeAdapter( DateAdapter.class )

  Date birthday;

}

 

class DateAdapter extends XmlAdapter<String, Date>

{

  private final static DateFormat formatter = new SimpleDateFormat( „dd/MM/yyyy“ );

 

  public Date unmarshal( String date ) throws ParseException

  {

    return formatter.parse( date );

  }

 

  public String marshal( Date date )

  {

    return formatter.format( date );

  }

}

<person>

    <birthday>12/03/1973</birthday>

</person>

 

Der spezielle Datentyp XMLGregorianCalendar

 

Neben der Möglichkeit, Datumswerte mit einen XmlJavaTypeAdapter zu übersetzen, bietet JAXB den Datentype XMLGregorianCalendar.

 

Person p = new Person();

GregorianCalendar c = new GregorianCalendar( 1973, Calendar.MARCH, 12 );

p.birthday = DatatypeFactory.newInstance().newXMLGregorianCalendar( c );;

 
 

class Person

{

  XMLGregorianCalendar birthday;

}

<person>

    <birthday>1973-03-12T00:00:00.000+01:00</birthday>

</person>

 

Die Abbildung enthält alle notwendigen Werte. Sollen Segmente, wie die Zeitzone herausgenommen werden, so markiert man sie aus:

 

Person p = new Person();

GregorianCalendar c = new GregorianCalendar( 1973, Calendar.MARCH, 12 );

XMLGregorianCalendar gc = DatatypeFactory.newInstance().newXMLGregorianCalendar( c );

gc.setTimezone(DatatypeConstants.FIELD_UNDEFINED);

gc.setTime(DatatypeConstants.FIELD_UNDEFINED, DatatypeConstants.FIELD_UNDEFINED, DatatypeConstants.FIELD_UNDEFINED);

p.birthday = gc;
 

class Person

{

  XMLGregorianCalendar birthday;

}

<person>

    <birthday>1973-03-12</birthday>

</person>

 

Elemente einbetten mit @XmlElements

 

Person p = new Person();

EmailContact c1 = new EmailContact();

c1.address = „hoho@weihnachtsmann.de“;

PhoneContact c2 = new PhoneContact();

c2.number = „0011-123456789“;

p.contacts = Arrays.asList( c1, c2 );

 

@XmlRootElement

@XmlAccessorType( XmlAccessType.FIELD )

class Person

{

  @XmlElements(

  {

      @XmlElement( name = „email“, type = EmailContact.class ),

      @XmlElement( name = „phone“, type = PhoneContact.class )

  } )

  List<Object> contacts = new ArrayList<Object>();

}

 

@XmlAccessorType( XmlAccessType.FIELD )

class EmailContact

{

  @XmlValue

  String address;

}

 

@XmlAccessorType( XmlAccessType.FIELD )

class PhoneContact

{

  @XmlValue

  String number;

}

<person>

    <email>hoho@weihnachtsmann.de</email>

    <phone>0011-123456789</phone>

</person>

JNotify: Was tut sich im Dateisystem?

Die kleine (native) unter Linux und Windows arbeitende Bibliothek JNotify meldet Änderungen an Dateien. Ein Beispiel:

String path = "c:/";

int mask = JNotify.FILE_CREATED | JNotify.FILE_DELETED | JNotify.FILE_MODIFIED | JNotify.FILE_RENAMED;


boolean watchSubtree = true;


int watchID = JNotify.addWatch(path, mask, watchSubtree, new JNotifyListener()
{
@Override
public void fileCreated( int arg0, String arg1, String arg2 )
{
System.out.println( "created" );
}


@Override
public void fileDeleted( int arg0, String arg1, String arg2 )
{
System.out.println( "deleted" );
}

@Override
public void fileModified( int arg0, String arg1, String arg2 )
{
System.out.println( "modified" );
}

@Override
public void fileRenamed( int arg0, String arg1, String arg2, String arg3 )
{
System.out.println( "renamed" );
}
} );

Und am Ende:

JNotify.removeWatch(watchID);

jodconverter für OpenOffice Dateiformatkonvertierungen

Der zweite Schritt meiner Rechnungserstellung ist die Konvertierung in PDF. Auch dazu gibt es eine prima Bibliothek: http://www.artofsolving.com/opensource/jodconverter. (Einziger Nachteil: viele Jars.) Damit kann man Word, PowerPoint, RTF und alles andere in ein bliebiges Zielformat bringen.

private static void ensureStartedOpenOfficeService()
{
try
{
new Socket( "127.0.0.1", 8100 );
}
catch ( Exception e )
{
String path = "C:/Programme/OpenOffice.org 2.3/program/";
ProcessBuilder processBuilder = new ProcessBuilder( path+"soffice", "-headless", "-accept=\"socket,host=127.0.0.1,port=8100;urp;\"", "-nofirststartwizard" );
try
{
processBuilder.start();
}
catch ( IOException ioe )
{
throw new RuntimeException( ioe );
}
}
}
public static void convert( String source, String destination )
{
ensureStartedOpenOfficeService();

OpenOfficeConnection connection = null;
try
{
connection = new SocketOpenOfficeConnection( 8100 );
connection.connect();
DocumentConverter converter = new OpenOfficeDocumentConverter( connection );
File inputFile = new File( source );
File outputFile = new File( destination );
converter.convert( inputFile, outputFile );
}
catch ( ConnectException e )
{
throw new RuntimeException( e );
}
finally
{
connection.disconnect();
}
}

Für meine Rechnungen also:

String destination    = "S:/Private/Traida/Bills/bill1";
String destinationOds = destination + ".ods";
String destinationPdf = destination + ".pdf";
convert( destinationOds, destinationPdf );

OpenOffice als Template-Engine: Dokument einlesen, verändern, schreiben

Da ich meine Rechnungen automatisch generiert und als PDF konvertiert haben möchte, habe nach einer Lösung gesucht, wie ich die Rechnungsdaten aus einer Datenquelle in der Template einsetzten kann, und am Ende eine PDF bekomme. Klar sind Report-Generatoren dafür auf der Welt, aber meine Vorlagen möchte ich nicht für Eclipse BIRT oder Jasper schreiben, sondern in Word bzw. OpenOffice. RTF ist relativ leicht zu schreiben und für ein Template meines Erachtens ganz gut. Meine Gedanken kreisten daher einige Zeit um RTF->PDF, doch da gibt es keine freie Lösung. Auch Wege wie RTF->FO->PDF sind möglich, aber dafür gibt es ebenfalls keine leichtgewichtigen freien Lösungen.

Schon für meinen PowerPoint->PDF-Konverter habe ich mit OpenOffice gearbeitet und das klappte ganz gut. Das habe ich für meine Templates nun wieder überlegt — ein recht harter Weg für simple RTFs zwar, aber es funktioniert. Doch anstatt RTF zu nutzen, wollte ich gleich das XML-Format verwenden. Dazu muss man wissen, dass OO ein Zip-Archiv für das OO-Dokument vorsieht und dort in einer XML-Datei den Content ablegt. Mit der großartigen Open-Source-Bibliothek https://truezip.dev.java.net/ ist der Zugriff auf Archive sehr einfach.

Mit TrueZIP ist eine einfache Lösung entstanden, ein OO-Dokument mit Template-Anweisungen wie ${address} zu lesen, Ersetzungen vorzunehmen, und alles wieder zu schreiben. Diesen Text hier zu schreiben hat länger gedauert, als die 90 Zeilen Quellcode. Also los:


import java.io.*;
import java.nio.channels.FileChannel;
import de.schlichtherle.io.ArchiveDetector;

public class OpenOfficeUtils
{
public static void main( String[] args )
{
String source = "S:/Private/Traida/Bills/template.ods";
String destination = "S:/Private/Traida/Bills/bill1.ods";

copyFile( source, destination );

String content = readOpenOfficeContent( source );

content = content.replace( "${addressline1}", "Christian Ullenboom" );

writeOpenOfficeContent( destination, content );
}

public static String readOpenOfficeContent( String filename )
{
Reader is = null;

try
{
de.schlichtherle.io.File file = new de.schlichtherle.io.File( filename + "/content.xml", ArchiveDetector.ALL );
char[] fileContent = new char[ (int) file.length() ];
is = new de.schlichtherle.io.FileReader( file ); // TODO: <?xml version="1.0" encoding="UTF-8"?>
is.read( fileContent );

return new String(fileContent);
}
catch ( IOException e )
{
throw new IllegalArgumentException( e );
}
finally
{
try { is.close(); } catch ( Exception e ) { }
}
}

public static void writeOpenOfficeContent( String filename, String content )
{
Writer os = null;

try
{
de.schlichtherle.io.File file = new de.schlichtherle.io.File( filename + "/content.xml", ArchiveDetector.ALL );
os = new de.schlichtherle.io.FileWriter( file );
os.write( content );
}
catch ( IOException e )
{
throw new IllegalArgumentException( e );
}
finally
{
try { os.close(); } catch ( Exception e ) { }
}
}

public static void copyFile( String in, String out )
{
FileChannel inChannel = null;
FileChannel outChannel = null;

try
{
inChannel = new FileInputStream( new File(in) ).getChannel();
outChannel = new FileOutputStream( new File(out) ).getChannel();
inChannel.transferTo( 0, inChannel.size(), outChannel );
}
catch ( IOException e )
{
throw new IllegalArgumentException( e );
}
finally
{
try { inChannel.close(); } catch ( Exception e ) { }
try { outChannel.close(); } catch ( Exception e ) { }
}
}
}

Strg+F11: Noch so eine komische Eclipse-Änderung

Vor nicht allzulanger Zeit startete Eclipse mit Strg+F11 das letzte Programm. Dann änderte man dies und Eclipse versuchte automatisch das im Editor aktive Programm zu starten. Ich denke, dass diese Umstellung eher lästig ist und eines der ersten Sachen sein dürfte, die man abschaltet. Das geht so: In den Preferences unter Run/Debug > Launching den Schalter bei Always launch the … einstellen.

image

1 Stunde Suchen für eine doofe Eclipse-Einstellung

<Sarkasmus>Dankenswerterweise</Sarkasmus> hat Eclipse eine neue Einstellung bekommen, in dem gewissen Daten vom Kopieren in den Output-Folder ausgenommen werden können. Dass sich diese Einstellung unter Java > Compiler > Building befindet, fand ich erst nach langem Suchen hier: http://www.codecommit.com/blog/eclipse/wtps-crazy-and-undocumented-setting-change

wtp-screwup

Mein Problem: Bei der Entwicklung mit Wicket stehen die HTML-Seiten Seite an Seite mit den Java-Klassen. In den classes-Folder für die Web-Anwendung gingen aber nur die Klassen und nicht die HTML-Dateien. Da gestern auf einer anderen Eclipse-Version alles noch lief, war ich heute lange verzweifelt und kann glücklicherweise nach dieser Einstellung wieder an die Arbeit gehen.

SQL für Objekte: JoSQL (SQL for Java Objects)

JoSQL (SQL for Java Objects) unter http://josql.sourceforge.net/index.html ist eine Open-Source Biblitohek, um SQL-Anfragen an Objektgrafen zu stellen. Die Webseite gibt interessante Beispiele.

String query = "SELECT * FROM   java.io.File WHERE  name LIKE '%.mp3'";
Query q = new Query();
q.parse( query );
QueryResults results = q.execute( Arrays.asList( new File("C:/Data/Musik/").listFiles() ) );
System.out.println( results.getResults() );

Oder für Ausdrücke:

/*
* Use as a file filter.
*/
String exp = "lastModified BETWEEN toDate('10/May/2007') AND toDate('28/Jun/2007') " +
"AND " +
"length >= 10 * 1024" +
"AND " +
"path LIKE '%/subdir/%'";

ExpressionEvaluator ee = new ExpressionEvaluator (exp, File.class);

if (ee.isTrue (myfile))
{
// Process the file.
}