I am currently hanging out at the lovely JavaOne conference in San Francisco, checking out cool new Java technology and meeting interesting people. Of course I'm here as a representative from my employer I also do some blogging (in Danish).
Yesterday I saw an interesting session about JFreeChart and surviving as an Open Source professional. Dave Gilbert told us about how he has managed to live from his hobby as a JFreeChart developer, about cool new features of the excellent charting API and about the struggles of making money on Open Source. Very fascinating stuff and I hope that everybody in the chart-consuming business will give it a try. I was quite happily surprised to see the new interactive chart functionality that has been put into the API - I'm wondering how that hadn't found my attention before now! It gave rise to a couple of ideas (or rather: Sparked my motivation) for me to try and implement charting in DataCleaner.
20090605
eobjects.org @ JavaOne
20090429
Seam, EJB's and EAR-packaging in Maven
Lately I've been designing a new course on the splendid JBoss Seam (2.1) Web and Java EE framework. One thing that strikes me, being an enterprise Java developer, is that almost no good examples of setting up Seam using Maven exist. I realize that Seam's appeal comes from a tradition of wanting things to be nice and easy, so the seam-gen tool has absolute merits for creating your project but to me the downside of this approach is that you're bound to use Ant as a build tool and for a lot of reasons I won't go into here, I strongly prefer using Maven.
The examples of using Maven to build Seam applications that I have been able to track down have been limited in a variety of ways:
- Most of them required to use a specific Maven archetype which altered the default project layout.
- Almost all of them where out of date and was bound to a very "custom" maven repository which I don't think is suitable for enterprise application infrastructure.
- Those that didn't fall within the former two points where restricted to web-applications (WAR-files) only and thus didn't support using EJB's in the Seam applications.
Project structure
OK - to meet the demand of packaging an EAR file I've created a Maven project consisting of three modules. It's possible that this part can be optimized a bit since I use a seperate module for doing all the packaging (which to my understanding is the way to do it). The modules are:
- ejbs - containing the EJB's and possibly other "backend"-stuff like JPA-classes and so on.
- web - containing the web application
- packaging - for packaging the EAR file containg the two other modules (and Seam)
One of the big issues that I faced was figuring out how to configure Maven's dependency management framework to generate a correct set of EAR, JAR and WAR files. If this is done wrong it won't work and you'll waste hours (or at least I did) trying to figure out what is wrong.
All provided dependencies go into the parent project. These are all the dependencies provided by your container (plus Seam itself which will be packaged within the EAR file). You will need to add JBoss's Maven repository to resolve these dependencies. Here are the important parts of my parent project pom:
<repositories>In the ejbs module you will not need any dependencies!
<repository>
<id>repository.jboss.org</id>
<name>JBoss Repository</name>
<url>http://repository.jboss.org/maven2</url>
</repository>
</repositories>
<modules>
<module>ejbs</module>
<module>web</module>
<module>packaging</module>
</modules>
<dependencies>
<dependency>
<groupId>org.jboss.seam</groupid>
<artifactId>jboss-seam</artifactid>
<version>2.1.1.GA</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.faces</groupid>
<artifactId>jsf-api</artifactid>
<version>1.2_02</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupid>
<artifactId>hibernate-entitymanager</artifactid>
<version>3.4.0.GA</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupid>
<artifactId>hibernate-validator</artifactid>
<version>3.1.0.GA</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupid>
<artifactId>servlet-api</artifactid>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupid>
<artifactId>jsp-api</artifactid>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.ejb</groupid>
<artifactId>ejb-api</artifactid>
<version>3.0</version>
</dependency>
</dependencies>
In the web module you will need to add seam-ui (excluding the "core" seam, because it is provided within the EAR file), facelets and other web-dependencies such as RichFaces, seam-pdf or whatever. Here are the dependencies of my web module pom:
<dependencies>If you want to write Seam components that pertain only to the web module, then you will probably also need to include the ejbs module as a dependency in the web module pom. But remember to set the scope as provided, because it's all within the same EAR.
<dependency>
<groupId>com.sun.facelets</groupid>
<artifactId>jsf-facelets</artifactid>
<version>1.1.11</version>
</dependency>
<dependency>
<groupId>org.jboss.seam</groupid>
<artifactId>jboss-seam-ui</artifactid>
<version>2.1.1.GA</version>
<exclusions>
<exclusion>
<groupId>org.jboss.seam</groupid>
<artifactId>jboss-seam</artifactid>
</exclusion>
</exclusions>
</dependency>
</dependencies>
Last but not least you will need to write the packaging module pom. The Seam Documentation have been used to guide how this pom is structured: The ejbs module needs to be a registered EJB module. The web module needs to be a registered WAR module. And Seam itself needs to be a registered EJB module as well! JBoss EL needs to be placed in the /lib directory of the EAR and you need to make sure to exclude the EL API dependency from several artifacts - otherwise you'll get weird classpath issues when deploying. The important parts of the packaging module pom looks like this (pay attention to the parts in bold):
<build>So that's all the Maven configuration. Now to some "gotchas" in regards to Seam configuration. A lot of these things are being "disguised" by seam-gen so consider this a list of things you might have forgotten if you're building the project from the bottom up:
<plugins>
<plugin>
<artifactId>maven-ear-plugin</artifactid>
<configuration>
<modules>
<jarmodule>
<groupId>org.jboss.el</groupid>
<artifactId>jboss-el</artifactid>
<includeinapplicationxml>false</includeinapplicationxml>
<bundledir>lib</bundledir>
</jarmodule>
<webmodule>
<!-- add web module groupId and artifactId here -->
<contextroot>/seam-ejb-ex</contextroot>
</webmodule>
</modules>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<!-- add ejbs module groupId, artifactId and version here -->
<type>ejb</type>
</dependency>
<dependency>
<!-- add web module groupId, artifactId and version here -->
<type>war</type>
</dependency>
<dependency>
<groupId>org.jboss.seam</groupid>
<artifactId>jboss-seam</artifactid>
<version>2.1.1.GA</version>
<type>ejb</type>
<exclusions>
<exclusion>
<groupId>javax.el</groupid>
<artifactId>el-api</artifactid>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.jboss.el</groupid>
<artifactId>jboss-el</artifactid>
<version>1.0_02.CR2</version>
<type>jar</type>
<exclusions>
<exclusion>
<groupId>javax.el</groupid>
<artifactId>el-api</artifactid>
</exclusion>
</exclusions>
</dependency>
</dependencies>
- Remember to put empty seam.properties files in to the resource folders of both the ejbs and web modules.
- Remember to register the Seam interceptors (as described in the Seam Documentation) in the ejb-jar.xml file, located in the resources/META-INF folder ejbs module.
- The components.xml file should be located in the web module's WEB-INF folder. But you can't just copy the file from a seam-gen project because seam-gen dynamically replaces some "magic strings" in it to see to container compliancy. Instead you will have to add this static entry to the components.xml file yourself:
<core:init pattern="seam-ejb-ex/#{ejbName}/local"></core:init>
Note the seam-ejb-ex part of that static jndi pattern string. You will have to replace this part of the string with the context root entry that was highlighted in the packaging module pom!
I hope this blog entry have cleared up some of the confusion that I met when I tried building Maven-based Seam/EJB projects. Please let me know if it works out and remember that you can download the full example and use it as a reference as you like.
20090420
DataCleaner 1.5.1 released
I'm happy to announce the release of DataCleaner version 1.5.1. This release is a minor release, nevertheless containing a few nice features - especially for the users who are enjoying the exporting features that was introduced in 1.5:
- An additional HTML export format have been added to the built-in export formats (usable when exporting Profiler results in the desktop app and when executing the runjob command-line tool).
- The export format is now choosable directly in the desktop app.
- Four new measures where added to the String Analysis profile: avg. chars and max/min/avg white spaces.
The new version of DataCleaner is (as always) downloadable for free on the downloads page and feedback from users is also greatly appreciated, ie:
- Fill out our online user survey, or
- Post your comments and questions at our discussion forum.
We hope that you all enjoy DataCleaner 1.5.1.
20090211
Data quality pro interview
Dylan Jones over at data quality pro is working on a feature about DataCleaner and I'm very thankful for his work already (and pretty excited to see the final result). The feature have just been started with an interview with a very important person ... Me! :-) For all of those who take an interest in DataCleaner, the visions of the product and it's story I hope that you will head over there and read the article.
To be continued with more posts on the data quality pro articles.
20090125
Free OLAP cube icon
Okay this is a bit off-topic compared to my normal posts, but here goes.
When I do websites or GUI design I usually look out for free/open source icon packages such as Tango or Crystal. I have been looking for a nice-looking icon to represent an OLAP cube, preferably in a style and coloring similar to the Tango icon set. Sorry to say, I didn't find any, so I went ahead and spent some hours creating a new icon on my own. Here's the result:![]()
And a plain version without the sum/count text elements (good if you need to resize it to very small sizes):![]()
I'm giving this away under a beerware license, so if you want it, it's yours.
20090120
DataCleaner 1.5 - a heavy league Data Profiler
Often when I speak to data quality professionals and people from the business intelligence world I get the notion that most people think of Open Source tools as slightly immature when it comes to heavy processing, large loads, millions-of-rows-kinda-stuff. And this has had some truth to it. I don't want to name names, but at least I have heard a lot of stories about Open Source data integration / ETL tools that wasn't up for the job when you had millions of rows to transform. So I guess this notion have stuck to Open Source data profilers and data quality applications too...
In DataCleaner 1.5 I want this notion demystified and eradicated! Here are some of the things we are working on to make this release a truly enterprise-ready, performance-oriented and scalable application:
- Multi-threaded, multi-connection, multi-query execution enging
The execution engine in DataCleaner have been thoroughly refactored to support multithreading, multiple connections and query-splitting to perform loadbalancing on the threads and connections. This really boosts performance for large jobs and sets the bar for processing large result sets in Open Source tools I think. - On-disk caching for memory-intensive profiles and validation rules
Some of the profiles and validation rules are almost inherently memory intensive. We are doing a lot of work optimizing them as much as we can but some thing are simply not possible to change. As an example, a Value Distribution profile simply HAS to know all distinct values of each column that is being profiled. If it doesn't - then it's not a value distribution profile. So we are implementing various degrees of on-disk caching to make this work without flooding memory. This means that the stability of DataCleaner is improved to a heavy league level. - Batch processing and scheduling
The last (but not least important) feature that I'm going to mention is the new command line interface for DataCleaner. By providing a command line interface for executing DataCleaner jobs you are able to introduce DataCleaner into a grand architecture for data quality, data warehousing, master data management or whatever it is that you are using it for. You can schedule it using any scheduling tool that you like and you can save the results to automate reporting and result analysis.
20090107
Using Python and Django to build the new DataCleaner website
I have for a long time been a dedicated Java developer and in many ways, still am. But developing the new website for DataCleaner have been quite an eye-opener for the potential of dynamic languages and Python in particular. There are so many things about that language that I love and I must say that doing the same thing in Java would have taken at least twice the time! And thats even though I'm not an unexperienced Java developer.
OK, so what's the big difference? Well, deployment is one very crucial difference. J2EE servers are great for stability and system administration but often I find myself, as a web developer, not needing all those things that much - I just need a server that always runs and will tell me what I am doing wrong. Django (which have been my Python web-framework) have been excellent in doing this for me so I can kick-start my application in a matter of seconds.
Type-safety is another big difference. Java is type-safe, Python (and other dynamic languages) is not. For back-end development I am a big advocate of type-safety but in front-end development dynamic classes are such a great treat! An example of this is when transfering data from Controllers to the View in the Django framework's Model-View-Controller architecture. If you want to present some domain objects that are related in the view, but not in the domain model (or perhaps the domain model has some details to it that you want to skip for understandability), then you just infer a completely new attribute into the domain object! In Java or other type-safe languages such as C#, you would typically have to create a Map for storing the new particular association and then do a lookup in the view to resolve the association. This means more "logic" in the view and code that is harder to comprehend.
All in all I'm very happy to use Django. I would have liked a few more features in their QuerySet API (especially aggregation queries, which should be on the way) but then again - for the typical website it is pretty sufficient and allows fallback to native SQL. Thank you Django.
Note: This is not to say that I am abandoning Java, not at all! I love Java for it's stability and superior integrational capabilities, but in some cases, I simply want something that is fast and more in tune with the user experiencing and prototyping process of building websites.