Using the NetBeans Platform on the Server with Wicket on the Client

For completeness, this is the NetBeansPlatformDecoratorFilter code, definitely similar to the Servlet:
package it.tidalwave.netbeans.servlet;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.openide.util.Lookup;

public class NetBeansPlatformDecoratorFilter implements Filter
{
private Filter delegate;

public void init (final FilterConfig config)
throws ServletException
{
try
{
NetBeansPlatformUtils.boot(config.getServletContext());
}
catch (Exception e)
{
throw new ServletException(e);
}

final ClassLoader classLoaderSave = NetBeansPlatformUtils.installPlatformClassLoader();

try
{
final String className = config.getInitParameter("netbeans.filter.delegate");
final Class delegateClass = Thread.currentThread().getContextClassLoader().loadClass(className);
delegate = (Filter)Lookup.getDefault().lookup(delegateClass);

if (delegate == null)
{
throw new RuntimeException("Can't lookup " + className);
}

delegate.init(config);
}
catch (Exception e)
{
throw new ServletException(e);
}
finally
{
Thread.currentThread().setContextClassLoader(classLoaderSave);
}
}

public void doFilter (final ServletRequest request,
final ServletResponse response,
final FilterChain chain)
throws IOException, ServletException
{
final ClassLoader classLoaderSave = NetBeansPlatformUtils.installPlatformClassLoader();

try
{
delegate.doFilter(request, response, chain);
}
catch (Exception e)
{
throw new ServletException(e);
}
finally
{
Thread.currentThread().setContextClassLoader(classLoaderSave);
}
}

public void destroy()
{
final ClassLoader classLoaderSave = NetBeansPlatformUtils.installPlatformClassLoader();

try
{
delegate.destroy();
}
finally
{
Thread.currentThread().setContextClassLoader(classLoaderSave);
}
}
}

Article Type: 
How-to
0

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)

Comments

harris goldstone replied on Fri, 2009/01/09 - 3:25pm

In a Wicket application, what is some of the typical functionality that I could let the NetBeans Platform handle?

Fabrizio Giudici replied on Sun, 2009/01/11 - 7:12am

Hi Harris.

At the moment, the great advantage is for what concerns the tier of services and models, that is the business tier. It is something that can be best clarified by examples, and I'll post some in future here on DZone (also with other two "series" of posts about NetBeans Platform Idioms etc...); for the moment, take this small one: I have a Metadata infrastructure that allow to extract metadata from media (e.g. photos), eventually store them in a database, where they can be searched for. Every kind of metadata (EXIF, IPTC, whatever) is implemented by separate modules, as well as persistence in the database is enabled by just adding specific modules, without requiring any configuration. This means that I can easily satisfy different needs (blueMarine itself, blueOcean base, blueOcean as used by my customer, and hopefully other future customers) by just assembling different set of modules in specific custom platforms. This has been achieved mostly by means of the Lookup API (and in future I could use more the layer.xml facility). Most of this stuff could be used also by taking simple .jars as libraries out of the NetBeans Platform; but as the number of configurations increases, it is really important to have the capability of checking compatibilities and dependencies among modules. You could be always safe with a good testing, but in any case I appreciate when a static tool finds / prevents problems as early as possible. Furthermore, having the very same process for two different projects is a big time saver for me.

There are two different uses of the Platform that I'll evaluate soon. First is the "Event Bus" (based on "Central Lookup" by Wade Chandler) that I've talked about a few months ago; in blueMarine it introduces another great deal of decoupling that in the customer's project based on blueOcean I don't have yet. While the Event Bus as is works fine with a single user (it is a singleton), it must be adapted in the case of concurrency (it should be enough to write a variant based on ThreadLocal). Second is about the use of Nodes for a number of things, including dynamic generation of menus based on the functions that you have dynamically included in the current configuration. This is more sensible because of the cited potential problem with the AWT Thread, which would be a serious bottleneck on the server side.

aldobrucale replied on Mon, 2009/01/19 - 8:49am

How can I access org.netbeans.Main from my module? It belongs to the Bootstrap module, but when I add this dependency and try to compile, the build system says that the module containing NetBeansPlatformUtils "is not a friend of <nb-platform-dir>/nbbuild/netbeans/platform9/lib/boot.jar".

Fabrizio Giudici replied on Mon, 2009/01/19 - 9:08am

Actually I've never used the o.n.Main from a Platform module - since it's boot code, I've used it from plain JSE code, and of course I've just included the relevant .jar in the path. For what reason do you need to access o.n.Main from a _Platform_ module? Before searching for you a solution to your question, maybe we can find another, better way to do the thing you're trying.

aldobrucale replied on Mon, 2009/01/19 - 11:22am in response to: fabriziogiudici

Thank you Fabrizio, of course a module cannot boot the application that is supposed to load it!

I placed the servlet in a regular web project, now it works perfectly. Very interesting, thank you.

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.