Java ECC Blog

PHP-based application framework: Horde

2004-12-27T23:45:00.000-02:00

Horde is a PHP-based application framework providing backend-independent interfaces for dealing with preferences, logfiles, compression, browser detection, connection tracking, MIME handling, hierarchical data, authentication, data formats, encryption, forms, session handling, file storage, remote procedure calls - and more is on the way.

Horde also makes heavy use of PEAR, the PHP Extension and Application Repository.

Text formatting and scanning - Java printf package

2004-12-23T18:18:00.000-02:00

Henrik Bengtsson's Java printf package implements common C-style printf formatting and scanf text parsing (includes methods sprintf, fprintf, scanf, sscanf and fprintf).

True C-style printf() with variable number of parameters.
High quality thanks to thousands of users.
Can save you hours or even days.
Compatible with Java 1.0.2, Java 1.1 and Java 2.
Free for non-commercial use.

You can take a look at Guido Krüger´s printf class as well.

Measuring execution times: SpeedTimer

2004-12-23T18:13:00.000-02:00

Guido Krueger's SpeedTimer gives us an easy way to measure and compare method execution times.

Measures the hardware timer resolution.
Measures the overhead of empty loop iteration.
Offers a template to help measure the speed of the code by successively running it in a loop until the elapsed time is long enough to give meaningful results.

OpenLaszlo

2004-12-14T10:32:00.000-02:00

OpenLaszlo is an open source platform for the development and delivery of rich Internet applications on the web.

With Laszlo, you can:

* Develop standards-based rich Internet applications with one code base in XML and JavaScript
* Deploy them from any J2EE application server or Java servlet container running under Linux, UNIX, Windows or Mac OS X
* Display them in any Web browser enabled with the Flash 5 Player or above, reaching 97% of all Web-enabled desktops

Apache´s persistence tool: OJB

2004-12-14T09:22:00.000-02:00

ObJectRelationalBridge - OJB supports multiple persistence APIs to provide users with their API of choice:

* A full featured ODMG 3.0 compliant API. (See the ODMG Tutorial for an introduction.)
* A JDO compliant API. We currently provide a plugin to the JDO Reference Implementation (RI). Combining the JDO RI and our plugin provides a JDO 1.0 compliant o/r solution.
A full JDO implementation is scheduled for OJB 2.0. (See JDO tutorial for an introduction to the JDO programming model.)
* An Object Transaction Manager (OTM) layer that contains all features that JDO and ODMG have in common. (See OTM tutorial for details).
* A low-level PersistenceBroker API which serves as the OJB persistence kernel. The OTM-, ODMG- and JDO-implementations are build on top of this kernel.
This API can also be used directly by applications that don't need full fledged object level transactions (See the Persistence Broker Tutorial for details).

More features:

# Transparent persistence: Persistent classes don't have to inherit from a persistent base class or to implement an interface.
# Easy use of multiple databases.
# Extremly flexible design with pluggable implementation of most service classes like PersistenceBroker, ObjectCache, SequenceManager, RowReader, ConnectionFactory, ConnectionManager, IndirectionHandler, SQLGenerator, JdbcAccess, ... and so on.
# Comes along with fully functional demo applications running against HSQLDB.

Real-world persistence: Chameleon Persistence

2004-12-13T17:42:00.000-02:00

Chameleon Persistence is a different persistence engine. It can be used for JavaBeans (in a classic O/R style), XML or other formats and is not constrained by traditional O/R requirements. Full native query language and complex query requirements are fully supported.

Features:

Designed for real enterprise needs
Not tied to JDBC-based databases
Cross data store retrievals (the object graph is spread across databases)
Very flexible data mapping (with or without JavaBeans)
Not limited to JavaBean persistence
Native data store query language support
Minimum configuration for minimum use cases
Expressions and scripts for query parameter substitution
Client-Server architecture

Fast object persistence: Prevayler

2004-12-10T18:08:00.000-02:00

Prevayler is the free-software Prevalence layer for Java.
Ridiculously simple, Prevalence is by far the fastest and most transparent persistence, fault-tolerance and load-balancing architecture for Plain Old Java Objects (POJOs).

Queries with Prevayler are more than 9000 times faster than querying Oracle through JDBC.
Queries with Prevayler are more than 3000 times faster than querying MySQL through JDBC.

These results are obtained even with the Oracle and MySQL databases fully cached in RAM and on the same physical machine as the test VM.

O/R persistence: Hibernate

2004-12-10T18:01:00.000-02:00

Hibernate is a powerful, ultra-high performance object/relational persistence and query service for Java. Hibernate lets you develop persistent classes following common Java idiom - including association, inheritance, polymorphism, composition and the Java collections framework. The Hibernate Query Language, designed as a 'minimal' object-oriented extension to SQL, provides an elegant bridge between the object and relational worlds. Hibernate also allows you to express queries using native SQL or Java-based Criteria and Example queries. Hibernate is now the most popular object/relational mapping solution for Java.

A collection of JVM options

2004-12-05T12:31:00.000-02:00

This document is a compilation of all the JVM options for various versions of the JVM on primarily SPARC/Solaris Platform. The descriptions for each option are taken mostly verbatim from the reference documents.

Baloon tooltips in Java: jBallon

2004-12-01T11:22:00.000-02:00

jBallon is a new LGPL library that allows you to have balloon-style tooltips instead of the standard Java tooltips - and there´s no need to change a single line of Java code from your application. No recompilation is needed, either.
To use JBalloonToolTips in your project you have to add this line to the project's startup script:
-Xbootclasspath/p:jBalloon.jar
You can also mix standard and balloon tooltips in one app if you want.

GUI editor for Thinlet: ThinG

2004-11-29T16:34:00.000-02:00

ThinG is a GUI editor for Thinlets. You can write/edit the XML description of your user interface and instantly see how it looks like or you can visually build it, tweak some parameters, and have the XML code automatically updated to reflect your changes.

Creating GUI apps: Thinlet

2004-11-29T16:28:00.000-02:00

Instead of using the Swing API to create your graphical applications, you may consider using Thinlet, which allows you to quickly create GUI applications, separating layout in XML files and business logic in Java code - easier than using Swing.

Thinlet is a GUI toolkit in a single Java class (compressed size is less than 40 kB) which runs under Java 1.1 (browser´s default JVM) up to 1.4, Personal Java and Personal Profile.

Java app launcher: JSmooth

2004-11-22T15:02:00.000-02:00

JSmooth is a Java application launcher that wraps an existing Jar file so that it becomes an executable Windows binary file (with '.exe' extension).
It makes java deployment much smoother and user-friendly, as it is able to find a Java VM by itself. When no VM is available, it provides feedback to the users, and can launch the default web browser to an URL that explains how to download a Java VM.
Features:

Smooth User Experience

Your users see and use a standard windows Exe binary. No more technical explanation on .jar, on javaw association, etc.
The Jsmooth EXE is smart: if no VM is found, your users are nicely explained how to install Java and/or are redirected to a web site (depending on the selected wrapper).
Flexible automatic Java VM detection

Flexible automatic Java VM detection

Detects the location of any Sun JVM installed. The wrappers use several strategies to detect all the JVM available on a computer, using windows registry, environment variables, windows path.
Detects and uses Microsoft's JView (for 1.0 and 1.1 Java applications), if available.
The JVM search sequence is fully customizable using the GUI.
If a JVM is bundled with your software, you can force the wrappers to use it.
Specify which versions of the JVM are compatible with your software.

Graphical User Interface

A Swing-based project editor allows you to easily configure the executable binary for your software.
Associate an icon to your executable, using a .ICO, .PNG, or .GIF file (automatic color reduction is done if necessary).

Application configuration

Easy java properties configuration: specify the tag=value pairs you want the wrappers to pass to your java application.
System environment variable are available in the java properties definition: just use the standard Windows %VARIABLE% syntax in your properties definition.
Pass special variables that are not available to Java program, such as the executable path and name, and even the computer name.
Specify all the classpath configuration, adding .jar, .zip, or directories, with an intuitive GUI.
Want to modify the current directory used by your Java application? The wrappers will handle this for you.

Wrappers

Provided with several exe wrappers skeletons, so that you can choose the one that best suits your needs!
Use one of the provided wrapper or create your own, and plug-it seamlessly into the jsmooth framework.

Feature-rich installer: VAInstall

2004-11-22T14:52:00.000-02:00

VAInstall is a multi-platform installer generator written in Java. Using a simple config file, it allows the packager to pick files and directories from various places on disk (unlike other installers which only use one root dir). The packager can completely reorganize the files and dirs on the destination host. The installation mode for the destination host can be graphic, xtra, text or ansi.
VAInstall doesn´t write any large temporary file on disk, and has an easy and powerful uninstallation procedure.
Features:

Multi-platform installation of applications (Java or not), or other data
6 formats possible for the auto-installable packaged archive: executable Java class, executable Jar, JavaWebStart JNLP, Windows exe, Linux-i386 exe and Unix/Linux executable shell script
Easy uninstall process
Version control: upgrades apps from existing versions or installs new versions
Forced-update mode: for differential updates or module/plug-in installation in existing apps
Four possible user-interfaces: graphic-classic, graphic-xtra, text-only or coloured ansi text
Easy configuration: a config file and a file listing
Integration with Ant thru an Ant task
Powerful archiving: you can archive files from different locations, and reorganize them as you want in your auto-install archive.
Java launch scripts generation
Windows registry management
Shortcuts generation (for Debian/Gnome targets only)
Support for choosable language during installation

Application deployment with Ant: ROXES ANT Tasks

2004-11-22T14:40:00.000-02:00

ROXES ANT Tasks are a collection of 16 Ant tasks for simplifying application deployment.

win32.properties - provides access to special Windows directories like desktop, program menu, program files and many more.
win32.registry - lets you create/read/write/delete windows registry subtrees and entries.
win32.shortcut - is able to create Windows Shortcuts. Both Windows Shortcut file formats (.url and .lnk) can be read and written.
sfx - creates native self extracting executables out of ZIP archives. Currently supported target platforms are Windows, MacOS X, almost any Unix and self executable JAVA Jar files. For Windows the executable command may contain placeholders for registry, enviroment and executable filename which are evaluated at runtime. The icon for the windows executable can be defined by the task.
jstub - jstub creates native executables for Windows, MacOS X and almost any Unix System out of a working JAR archive. For Windows the executable command may contain placeholders for registry, enviroment and executable filename which are evaluated at runtime. The icon for the windows executable can be defined be the task.
jnlp - simplifies the creation of JNLP files for JAVA Web Start. The jnlp task is able to handle ANT Filesets as resources. This feature makes jnlp file creation using the jnlp Task much more easier.
preferences - lets you access the JAVA Preferences API. You can read, write, import, export and test preferences data and nodes. Using this task is very useful for configuring applications.
properties - The properties task is able to write Java property files. This task can merge existing properties files with custom properties defined in the ant build file. The custom property definition can be used in conjunction with conditions. properties can be used to store user input during build for later use.
find - The find task is able find files using a pattern. This task is especially useful when you use libraries which name contain version/build information which may vary over the time. Using the find task you can use the file of your choice without changing the build file again and again.
compare - This task can compare 2 values either numerical ore aplanumerical and set customziable properties depending of the result.
execute - executes a block of tasks one ore more times depending of a condition.
call - executes a task one ore more times depending of a condition.
os.properties - creates properties containing informations about the underlying os.
unix.properties - makes important properties of the underlying unix system available as ant properties. espcially common kde directories like program menu, desktop etc. are supported.
unix.link - creates a unix soft link. works only under unix.
unix.kde.shortcut - creates a kde shortcut file used to create desktop or program menu entries.
unix.kde.directoryshortcut - creates a kde directory shortcut file used to create desktop or program menu entries.

Accessing the system tray: SysTray for Java

2004-11-22T14:29:00.000-02:00

SysTray for Java enables Java applications to create an icon in the system tray under Windows and KDE 3. It supports the creation of submenus, multiple independent menus, checkable menus, and everything can be changed at runtime.
The JAR and the DLL needed to run systray4j on Windows are LGPL. The code for KDE is GPL.

Running Java apps as services

2004-11-22T11:24:00.000-02:00

Java Service Wrapper allows a Java application to be run as a Windows service or a Unix daemon. It works under FreeBSD, GNU-Linux, MacOS X, Solaris, AIX, Windows NT/2000/XP/2003, Irix, HP-UX and DEC OSF1.

Javadocs knowledge base: JDocs

2004-11-19T15:14:00.000-02:00

JDocs is a comprehensive online resource for Java API documentation. All the javadocs for a variety of popular packages are loaded into our db-driven system, and users can contribute their own notes to virtually any class, field, method.

JDocs features:

HUGE collection of APIs
Familiar "javadocs" interface
Annotated with user notes
Fully indexed and searchable

(For an example, see the Javadocs for JasperReports)

User authentication against WinNT: Tagish JAAS Modules

2004-11-19T14:32:00.000-02:00

If your Java application needs to authenticate users against a Windows NT or Windows 2000 domain, take a look at JAAS Modules from free.tagish.net. By installing a small DLL - NTSystem.dll - in your system (the computer which is running your app) and a jar file - tagishauth.jar - you can authenticate users as easily as the following example:

public static void checkAuth(String userName, char[] password, String domainName) throws javax.security.auth.login.LoginException {

com.tagish.auth.win32.NTSystem ntSystem = new NTSystem();
ntSystem.logon(userName, password, domainName);
System.out.println("User validated using domain login");

}

You just have to pass the user name, password, and the NT domain to perform the authentication. When the authentication fails, a LoginException is thrown.

Creating distributed applications: TRMI

2004-11-19T13:54:00.000-02:00

Transparent RMI (TRMI for short) is a Java library based on RMI that simplifies the design of distributed applications. It has two distinct advantages:

Allows invoking a method remotely by using any interface, not just those that extend java.rmi.Remote;
Provides a mechanism for recovering from RemoteExceptions in a centralized location.

Complete reporting solution: OpenReports

2004-11-17T17:07:00.000-02:00

OpenReports is a complete web based reporting solution that provides the ability for users to view dynamically created PDF, HTML or XLS reports in a browser. It is developed in Java and uses JasperReports as the reporting engine. The goal of OpenReports is to provide a web based reporting solution built upon open source technologies that will compete against
complex and expensive reporting tools such as Crystal Reports and Cognos.
Features:

The ability to create groups of reports, and grant users access to reports by group.
The ability to generate reports as PDF, XLS, HTML, and CSV files
The ability to generate bar, pie and xy charts for inclusion in reports.
The ability to schedule and email PDF reports.
The ability to define reusable report parameters. Available parameter types include Date, Text, Query Parameters.
The ability to create multiple Datasources for use in generating reports. Support for JNDI Datasources and internal connection pooling via Commons-DBCP is included.
The ability to upload and hot deploy new reports.
Web based administration of users, groups, reports, parameters, and datasources.
Cross platform database support via Hibernate based persistence layer.
Available in a preconfigured bundle with Apache Tomcat.

This solution also has a visual report designer, OpenReports Designer, with the following features:

Edit, design, preview, and view Jasper reports.
Visual report designer.
XML editor with syntax highlighting.
Dialogs for editing report properties and elements.
View and print compiled Jasper reports.
Export compiled Jasper reports to PDF, HTML, XLS, and CSV files.
Includes a wizard for creating database driven reports.

Java-based build tool: Ant

2004-11-17T14:01:00.000-02:00

Apache Ant is a cross-platform, Java-based build tool, resembling make somewhat. Unlike make, which can be extended with shell-based commands, Ant is extended using Java classes, and instead of writing shell commands, Ant's configuration files are XML-based, calling out a target tree where various tasks get executed. But if you really need to, you can execute a shell command by using Ant's <exec> task, which allows different commands to be executed based on the host OS.

Logging framework: Log4j

2004-11-17T13:42:00.000-02:00

Log4j is an essential logging framework for Java. It helps you debug your application (with minimal impact on performance) by means of logging statements inserted in specific points of your code. Logging can be configured or even turned off at runtime via method calls or with a configuration file, all without changing the application binary.
Logging equips the developer with detailed context for application failures, thus it gets easier to correct them.

Unit testing framework: JUnit

2004-11-17T13:12:00.000-02:00

JUnit is THE unit testing framework for Java. Writing unit tests for your Java classes with JUnit becomes a snap. Check it out if you've never heard of it before - it's quite easy to learn and it will save you a lot of headaches in the future.
(You may be interested to know that there´s a Javascript unit testing framework as well)

Java instant messenger: JIM

2004-11-17T11:59:00.000-02:00

JIM, by Jeffrey Ketterer and Austin Click, is a Java server/client instant messaging program. Both the client and the server are free, and anyone can run a server.