The problem in solving such a Serializable exception is finding the field that is not Serializable. The stacktrace of java doesn’t help much. Fortunatelly, after some searching I’ve found the solution, in the comment of blog posting: add the option -Dsun.io.serialization.extendedDebugInfo=true to the JVM startup parameters.
Now the stacktrace gives you the exact fieldname or expression that is causing the problems, as you can see in the example below:

2011-07-23 21:44:50,362 ERROR [http-8080-1] [] org.apache.wicket.util.lang.Objects - Error serializing object class nl.gerbrandict.forum.AdminPage [object=[Page class = nl.gerbrandict.forum.AdminPage, id = 2, version = 0]]
java.io.NotSerializableException: org.springframework.beans.factory.support.DefaultListableBeanFactory
- field (class "org.springframework.orm.hibernate3.HibernateTransactionManager", name: "beanFactory", type: "interface org.springframework.beans.factory.BeanFactory")
- object (class "org.springframework.orm.hibernate3.HibernateTransactionManager", org.springframework.orm.hibernate3.HibernateTransactionManager@10fd8ce3)
- custom writeObject data (class "org.springframework.transaction.interceptor.TransactionInterceptor")
- object (class "org.springframework.transaction.interceptor.TransactionInterceptor", org.springframework.transaction.interceptor.TransactionInterceptor@2c96cb51)
- field (class "org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor", name: "transactionInterceptor", type: "class org.springframework.transaction.interceptor.TransactionInterceptor")
..
        - field (class "nl.gerbrandict.forum.AdminModel", name: "person", type: "class nl.gerbrandict.forum.Person")

(note: not publishing the entire stack trace and using some sample dummy field/classnames).
Although I haven’t tried, enabling this option in production is most likely a bad idea, because Serialization is already a pretty inefficient process without any debugging information enabled. In my case, I was using a PropertyModel somewhere, using non model as target object.

WicketMessage: org.apache.wicket.WicketRuntimeException: component myForm:myTable:editor not found on page nl.gerbrand-ict.gui.HomePage[id = 4], listener interface = [RequestListenerInterface name=IActivePageBehaviorListener, method=public abstract void org.apache.wicket.behavior.IBehaviorListener.onRequest()]

Root cause:

...

In place of the … there was a full stacktrace, which information that’s not not relevant for this posting.

Turned out the solution was pretty simple, but the cause isn’t that easy to find and is quite a good example how some design decisions in Wicket aren’t considered as clean.

I’m using Ajax-features of Wicket extensively.
I was creating a table, which contained editable fields (AjaxEdiableLabel). This would allow the user to click on a field in the table, to edit the content.
Somewhere I had the following code:

target.addComponent(item);
if .. needed .. {
target.addComponent(myTable.this);
... make item invisible
}
super.onSubmit(target);

The super.onSubmit belonged, in this case, to AjaxEditableLabel. I found out the super.onSubmit() would call target.addComponent(this); to update the editable label itself. As you could see, in my code I’m telling wicket to update the component that’s the parent of the editable label also.

In this case, the code caused wicket to first update the parent-panel, which in this case makes the child-component invisible. Then the wicket tries to redraw the child-component, which is then invisible. That will trigger the above error.
Unfortunately, solving this error isn’t quite easy in all cases. Especially when you’d use a AjaxSelfUpdatingBehaviour you can have little control on the redrawing order.

Fortunately I found a good tip on the wicket mailing list to get rid of the exception. Add the following code your Wicketapplication class (the class that extends org.apache.wicket.protocol.http.WebApplication):

    @Override
    protected IRequestCycleProcessor newRequestCycleProcessor() {
    	//Tip from http://apache-wicket.1842946.n4.nabble.com/WicketRuntimeException-component-not-found-on-page-td3055902.html
    	return new WebRequestCycleProcessor(){
    		public IRequestTarget resolve(final RequestCycle requestCycle,
    				final RequestParameters requestParameters) {
    	        try {
    	            return super.resolve(requestCycle, requestParameters);
    	        } catch (InvalidUrlException e) {
    	            if (requestCycle.getRequest().getURL().contains("LinkListener") || requestCycle.getRequest().getURL().contains("BehaviorListener")) {
    	            	log.warn("Couldn't process event, is ignored because of: "+e.getMessage());
                        //ignore exception
    	                return new PageRequestTarget(requestCycle.getRequest().getPage());
    	            } else {
                        //normal operation
    	            	throw e;
    	            }
    	        }
    	    }

    	};
    }

The above code will ignore all of the exception that occur when wicket tries to do something with an component that’s no longer available because of an ajax-update. Of course this fix isn’t very nice, hopefully later versions of Wicket fix the error all-together when Ajax-support is improved. For now, this seems the best solution.

Roger gave an overview of the new JavaFX 2.0, the road-map and the planned features. The software seems to be developed in an agile manner: the dead line is fixed, as is policy at Oracle (not meeting a dead line means exit for the responsible executive), but the final set of features is not.
The preview is available now for a limited audience, in May the first public beta will be released and in November the final will be available.

The most important news I heard:

• JavaFX 2.0 will be a library (jfx.jar), rather than a separate scripting language JavaFX. The language works in the language Java of course, but you can use the language Scala, JRuby, Jython or other languages available on the JVM. JavaFX script is end-of-life. Fortunately, the syntax of the library calls is quite similar, and there’s a program to translate JavaFX script into equivalent Javacode. Curiously, the translator, FX Translator, is written in Scala.
  Update 2011-06-15: I only heard about the fx translator at the here mentioned presentation. I could find little references to the translator: a back-reference to this posting (sigh) and the fxtranslator mentioned shortly in this posting on DrDobbs.
  If you want to use the FXtranslator, you’ll have to contact Oracle for now. I guess Oracle will release the automatic translation tool in some time too.
• The Swing-controls can be used from JavaFX 2.0. The ‘traditional Swing’ is now in maintenance mode, Oracle won’t create an new features for the original Swing library. Meaning, if you want to develop Swing applications, or more generally, desktop applications in Java now, you can best get the beta or coming GA of JavaFX.
• JavaFX 2.0 will be available on neither the Mobiles nor Televisions! Oracle has accepted (Sun’s) loss, and will only focus on the desktop for the time being.
  JavaFX seems practical on tablet-devices. However, since most tablet devices are enlarged mobiles (running a mobile os) ratter than flattened laptops (running a full desktop os), you can’t use JavaFX on any of those devices for the time being.
• The JavaFX is supported on the MS-Windows platform only for the coming time, (but) it will run on Mac, Linux or other platforms unsupported. This means, you might miss the hardware acceleration when not using Windows. Mind you: Roger was using a Mac while doing his presentation and demonstration the code-samples so the MS-Windows-only support might not look as dramatic as it seems at first glance.
• Of course JavaFX runs on the JVM 6 or higher. If all goes well, JavaFX will be part of JDK 8. Before that JavaFX can be downloaded as a plugin before from java.com, which will be not to painful for users, especially if they already have some version of the Java-plugin installed.

The JavaFX SDK contains a set of sample application called ‘Ensemble’. Roger presented a few impressive programs, and showed the source code. The audience, including the Oracle employee hosting the event was very tech oriented so everyone was eager to see the code of all the nice examples.

Furthermore, Roger frequently mentioned Podcasts. I have yet to listen to them, but maybe if I have some time left. Should find a way to broadcast audio while doing the dishes.
All in all a nice event. Oracle may turn JavaFX in something that might be practical and usable on a limited number of platforms, ratter then trying to take over the world (or more specifically taking on Android, Flex, Apple IOS).

As you might notice, I’ve got no code examples or screen-shots. I hope to get access to the beta release of JavaFX 2.0, I’m quite interested in trying out all those nifty things, and expect some nice blog postings on JavaFX soon!

Update 2011-06-01: The public beta of JavaFX is out! I’ve published on JavaFX on the Xebia-blog.

Adding a custom manifest entry is quite easy. Just add an entry to the configuration of the Maven 2 ear plugin, as shown in the example below:

<plugin>
<artifactId>maven-ear-plugin</artifactId>
<configuration>
<archive>
<manifestEntries>
<WebLogic-Application-Version>${project.version}</WebLogic-Application-Version>
</manifestEntries>
</archive>
...
</plugin>

This will cause the Manifest file to contain an entry WebLogic-Application-Version containing the current version of your Maven project.
However, this wasn’t enough for me: I’m sometimes modifying and recreating the ear multiple times per day during development. The maven project version remains the same, which means Weblogic won’t see my new development ear as a new version.
The solution is to include a timestamp in the version as well. By default, Maven doesn’t include a timestamp. Fortunately there’s Stackoverflow with the answer: there’s an external plugin called buildnumber-maven-plugin that allows you do that.
For my weblogic specific entry I added the following to the pom.xml file:

<groupId>org.codehaus.mojo</groupId>
<artifactId>buildnumber-maven-plugin</artifactId>
<version>1.0-beta-3</version>
<configuration>
<format>{0,date,yyyyMMddHHmmss}</format>
<items>
<item>timestamp</item>
</items>
</configuration>
<executions>
<execution>
<phase>validate</phase>
<goals>
<goal>create</goal>
</goals>
</execution>
</executions>
</plugin>

The above entry will make a variable buildNumber available during build containing a timestamp.
The maven ear configuration becomes:

<plugin>
<artifactId>maven-ear-plugin</artifactId>
<configuration>
<archive>
<manifestEntries>
<!-- Buildnumber property is generated by buildnumber-maven-plugin,
see above -->
<WebLogic-Application-Version>${project.version}_${buildNumber}</WebLogic-Application-Version>
</manifestEntries>
</archive>
...
</plugin>

After installation in Weblogic using the admin console, weblogic now lists the version number, date and time after I install my ear. Upgrading the application won’t result in two applications being listed.



I wanted to try out a persistence API for Cassandra. There’s a JPA implementation for Cassandra: Kundera, as well as JDO implementation, on top (or using) datanucleus: datanucleus-cassandra.

Just to clarify why I would want such a thing: nosql solutions such as Cassandra are, in essence distributed key-value stores. I know, from following a few classes on databases and distributed databases when attending the university that’s a whole lot more complicated to implement then it may seem.
Nevertheless, to do anything useful with that you need a layer on top of the key-value store. Basically all SQL databases like Oracle or MySQL have SQL layer around there key-value store. But the nice thing about stuff like Cassandra you can put something more convenient on top.

I wanted to try out both, starting with the JDO version, as that seemed more like a natural fit, and I once started ORM with JDO 1.0 many years ago.
I’d need a git client on Windows, and apparently there’s already a Tortoise Git client, based on the truly great TortoiseSVN, on of the tools I really miss on my Mac. The client version of git first had to be installed, but that was quite easy as well, just download and install msysgit.
The tortoisegit client looks very well, and seems easy to use. At least I got the code of datanucleus-cassandra in a breeze. Well now it’s kind of late, I’ll try out later.

Other stuff I want to try out: creating a Rest service using Restlet on Google AppEngine. Just to find out how that works. But later.

Finally I saw a demo on VMForce. Looks very promising, as I like Spring for development and that’s what you’d use. Nothing is released however, now there’s just articles and a demo.

Also, this allows for fine-grained security at database level: Virtual Private Database.

(c) Oracle

As described in the above image and referenced article, the user identified by userid 106 (let’s say that’s user john) will access the database using a private database connection. The user can only access rows that have that userid as primary or foreign key.  John can’t see the passwords, orders, credit card data or anything of other users even if he would somehow hack the webapplication. How to set up this finegrained securiy is beyond this article, but I hope the above example explains what the purpose VPD is.

If you develop your JEE software using Oracle software  proxy authentication requires only a bit of configuration, for example, see the following article how to setup proxy authentication using JHeadstart.

However, what if you’re JEE applicication consists of non-oracle software? Can you still use proxy authentication when you use software like JBoss, Hibernate, IBatis, MyFaces, Wicket etc? Yes you can! I’ll explain below how to set up proxy authentication using JBoss in such a way you don’t have to modify any of the code that uses JDBC, directly or indirectly.

• First a way is needed to set a username for each (JDBC) database connection retrieved. It-eye weblog explains how to open a connection to a database using java, and then switch to another username.
• Secondly, in your application users should authenticate them self using the default mechanism of J2EE 1.4 (and higher) application, using JAAS. Usually creating a security policy inside your web.xml or inside your ear is enough. Here’s the information how to do this under JBoss: Secure a webapplication.
  Since we’re using a database, the best option would be to use database based authentication, meaning user information comes out of a database table. There’s a lot of documentation on the web how to do add security, so I won’t repeat that here.
• Database connection in JBoss are retrieved using connection pooling, as is custom in any JEE server.  You can create a custom connection pool, that changes the switches to the user name that is currently logged in at the webapplication. That way, every action on the database is done under a database user that is currently logged in.Do to be able to do that, first, you’ll need a custom connection factory that extends the default connection factory. Our connection factory will return a customized datasource that modifies code.Here’s a code listing:

  package nl.gerbrandict.dbconnaudit;
  
  import java.sql.SQLException;
  import javax.resource.ResourceException;
  import javax.resource.spi.ConnectionManager;
  
  import org.apache.log4j.Logger;
  import org.apache.commons.lang.StringUtils;
  import org.jboss.resource.adapter.jdbc.local.LocalManagedConnectionFactory;
  
  /**
   * An extended connection factory, that uses the Oracle feature to change the username of an existing connection
   *
  
   * When a user authenticated on the application server, the database connection will switch to that username.
   * This allows for better auditing and potentially for improved security.
   *
   * Properties (get'ers and set'ters) can be set via the configuration section of the -ds file
   * @author gvdieijen
   */
  public class DBConnAuditConnectionFactory extends LocalManagedConnectionFactory {
  
      private String defaultProxyUser;
  
      public DBConnAuditConnectionFactory() throws SQLException {
          super();
  
      }
  
      @Override
      public Object createConnectionFactory(ConnectionManager cm) throws ResourceException {
          return new OracleWrapperDataSource(this, cm);
      }
  
      public void setEnableProxySession(Boolean enableProxySession) {
          this.enableDbConnAudit = enableProxySession;
      }
  
      public void setDefaultProxyUser(final String defaultProxyUser) {
          if (StringUtils.isEmpty(defaultProxyUser)) {
              this.defaultProxyUser=null;
          } else {
               this.defaultProxyUser = defaultProxyUser;
          }
      }
  
      /**
       * Default db user to open proxy session for, when no authenticated user is active
       * @return
       */
      public String getDefaultProxyUser() {
      	return this.defaultProxyUser;
      }
  }

  As you can see, the file returns a OracleWrapperDatasource. That’s custom class, that extends the default WrapperDatasource of JBoss, and changes the user of jdbc connection just before the connection is handed of to the application. To speak in terms of the fine book

• Now, How can you use that new class? They have to be packed into a rar file. Functionally, that’s a Resource Adapter, a module that allows a J2EE application to use resources. Technically (and practically), it’s just a jar-archive similar to a war, with a different extension. Maven can create these files automatically for you, if you set the packaging type to rar instead of jar (which is the default).
• When you download JBoss, you’ll get a sample connection pool for a in-memory database: default-ds.xml, located in the server/default/deploy directory of jboss. To use the custom classses, copy the file into (for example) myoracleproxy-ds.xml and create a minor modification so a custom connection factory is used – update the managedconnectionfactory property, that a custom connectionfactory is used, that returns the proxied connections:

  <managedconnectionfactory-class>nl.gerbrandict.dbconnaudit.DBConnAuditConnectionFactory</managedconnectionfactory-class>

All in all, after some tweaking, all queries and updates to your Oracle database are done under the J2EE username. This means when user Joe logs in, all his database access will be logged under user Joe as well. This can improve auditing as well as security.

In the coming postings I want to investigate that claim using my knowledge of experience in Java/J2EE and my complete lack of experience in Scala. Can you say to you’re developers, or yourself, from this day on, we’ll use Scala instead of Java to do our development?

For now, I found this nice presentation I want to share: Introduction To Scala For Java Developers by Miles Sabin.

• Hitting ‘Run’ and waiting a few seconds,
• to hitting ‘Run and deploy’ in my IDE and waiting about 20-30 seconds,
• to executing a ant script, restarting the application server and waiting 5 minutes
• to compiling a class file, uploading the class and accompanied libraries using a cumbersome webinterface and then executing a PLSQL script to run that class, wasting in total time amount 15 minutes (yes, that was a a very big and professional company)
  

In my opinion, the programmer is productive when he either codes, or when he tests his codes. Any time spent on waiting or performing some troublesome actions like accessing a web interface is pure waste. In short the above time ranging from a few seconds to 15 minutes is dead time.

Of course all that time wasted not only frustrates developers, it’ll cost quite some time and thus money. Now how can you limit that dead time, that is wasted by developers? One way is your have your developers write perfect code at once. Of course that’s not very realistic. Recently I found a very nice tool to limit that dead time, when you develop Java software: JRebel. What does that mean for you as java-developer:
JRebel runs as a software agent within your virtual machine, that in turn runs your application server. What JRebel does, is taking over the class-loader.
You can specify the output directories of your IDE (target/classes, /bin, etc.). Now whenever you make a change in your code, IDE’s like Eclipse can compile that code into a new class file in the output directory. JRebel will automatically detect the changed class file. Thus no waste! Since JRebel plugs into the VM, it’ll work with virtually any application server.

Hier is de officiele introductie

Op 11 november 2009 werd JFall 2009, een van de twee congressen die jaarlijks door de NLJug worden georganiseerd, gehouden. Naast de inhoudelijke sessies, is een van de mooiste aspecten van JFall (en JSpring) het ontmoeten van andere Java programmeurs. In dit Whitebook vind je een verslag van dit congres en van een aantal sessies, o.a. over Java SE 7 en de nieuwe Google ontwikkelingen. Lees het volledige artikel »

en hier is de whitebook: JFall 2009, een verslag