Skip to main content

Version 2.0.1 Released!

After a long period of happy exPOJO usage on a variety of different projects we saw some room for simplification and improvement and version 2.0.1 is the result of this.

We've made some excellent refinements and added some new features:

New ModelExposerFactory
The most notable refinement is that the PersistenceProviderFactory has been renamed to ModelExposerFactory which is extended within your application to become the single object reponsible for producing ModelExposer's when required.

Previously ModelExposers were produced by the ExpojoServletContextListener which unfortunately tied the use of exPOJO to web based applications. Now that ModelExposer's are produced by a separate ModelExposerFactory that is independent of the servlet API exPOJO can be used equally well in web app and traditional Java applications.

Even within web based development there is often the need for background threads running as part of the web app or running as services outside of a servlet container and this recent refinement of the exPOJO design makes it possible to implement exPOJO in both the web app and supporting services using common source code.

Simple Wrapping of method within a transaction context
The basic pattern for using the ModelExposer is as follows:


try
{
// Either find a ModelExposer associated with the current context or create
// a new one each time - the choice is yours. The context could be a HTTP
// session or anything you want it to be.
modelExposer = context.getModelExposer();

if ( modelExposer == null )
{
modelExposer = ModelExposerFactory().get().createModelExposer();
context.setModelExposer(modelExposer):
}

// Inject (attach) the ModelExposer to this thread so that within any
// methods executed by this thread the model exposer is instantly
// accessible without requiring direct injection of individual
// objects via ModelExposer.get()
modelExposer.attach();

// Get the PersistenceProvider and begin a transaction
PersistenceProvider pp = modelExposer.getPp();

pp.beginTx();


// Typically call a method to perform work like servicing a HTTP request or
// executing an iteration of a periodic background task
// do something with your model - load objects, navigate along
// relationships etc., populating UI components: pages, forms, fields etc.,
doWork();

// example of code that may be executed within a method that does the work:
// UI elements, model objects etc., all have access to the repositories and
// services and the methods of the PersistenceProvider by simply calling the
// convenience methods eg.,

// User user = UserRepository.get().findUser(username);

// Order order = OrderService.get().createOrder(customer);
...

// Commit the transaction
pp.commitTx();
}
catch (Exception e)
{
// rollback if required etc.,

}
finally
{
// Detach from this thread - as threads are pooled in a servlet container we must
// not leave the model exposer attached to any particular thread after it
// has finished servicing the current http request
modelExposer.detach();
}

In exPOJO 1.x what tended to happen was that this familiar pattern ended up being implemented in multiple places throughout the code. In 2.x a new method in ModelExposer makes it simple to wrap code in such a pattern without having to repeatedly write implementations of the whole pattern. The implementation within ModelExposer can simply be reused, wrapping any doWork() style method that you require. The doWork() style method in ModelExposer is actually called execute() and it supports the passing of parameters if required.

Comments

Popular posts from this blog

expojo 1.3.2 released!

exPOJO 1.3.2 has just been released.

exPOJO is a super lightweight framework that provides:
dependency injection in Java (no XML - say goodbye to Spring forever!) using the easy to use ModelExposer class.high productivity persistence using the 'exposed POJO model pattern' to access your objects via Hibernate or JDO.an ORM wrapper that helps you to build code that is portable across different ORMs.Version 1.3.2 adds an exceptionally useful 'auto query resource clean up' class donated by Guido Anzuoni from Object Magic: http://www.objectmagic.org. Using this class to encapsulate returned query collection result you don't need to explicitly clean up the query resources associated with those results. Guido's class 'automagically' cleans up the resources when it is garbage collected. This is great for users of the OpenPersistenceManagerInView pattern. Currently Guido's class works with JDO only.Version 1.3.2 also adds a new flushChanges method which is gre…

exPOJO: version 1.3 released!

exPOJO Version 1.3 has recently been released.

It now makes dependency injection even easier to use. Simply configure the ExpojoServletFilter in your web.xml and voila!! Too easy.

For the lovers of the highly productive "exposed POJO domain model" pattern you will find the latest version of POJO irresistable.

Read more and download here.

Expojo 2.2 is on its way!

Expojo 2.2 is almost here
Expojo 2.2 has some very useful enhancements but the main changes are name changes to some key classes which make more sense.
Don't worry, we haven't removed the old classes (yet) so your existing code should work fine.

Some of the name changes are:
ModelExposer > ExpojoContext This class is automatically bound to the thread processing a HTTP request by the ExpojoFilter. ExpojoContext is readily available anywhere in your code via ExpojoContext.get().
It contains all the Repository and Service components that are registered in ExpojoContextFactory's addComponents method.
ModelExposerFactory > ExpojoContextFactory This factory can be overridden but most likely the existing implementations will provide what you need.
ExpojoServletContextListener > ExpojoFoundation This class has not really been a ServletContextListener for a long time (the listening is all done by ExpojoFilter now) so it was time for a name change. ExpojoFoundation is the …