Category Archives: apache isis

One thing that Naked Objects 4.0 doesn’t yet support is Java 5-style enums. We think we know what we need to do to support it (I guess that will be 4.1), but for now let me offer you a way to get the same general effect.

Let’s make this concrete by considering (hackneyed example, I know) a library. Suppose that this library can loan out both Books and CDs, and that we wanted to have a StockType to enumerate these different types of stock.

First, let’s start with an Enumerated interface:
Read the rest of this entry →

In the previous post in this series we saw how the Naked Objects metamodel uses Facets to allow arbitrary metadata to be associated to the classes, properties, collections or actions. We’ve already explored the well-defined facets that are used to capture presentation semantics and to enable interactions, but we still need to see how facets enable business rules to be captured.

As I’ve previously blogged about, Naked Objects allows three different types of business rules to be implemented. In the metamodel API there is a corresponding interface for each of these rule types, implemented by Facets:

For example, the following Read the rest of this entry →

In part one of this series we saw how to bootstrap Naked Objects, and in part two we saw how we can interact directly with domain objects as pojos (with Naked Objects taking care of persistence and transaction management). But we can also interact with domain objects through their NakedObject wrapper/adapter. Although more indirect, it is also more powerful. So let’s see how.

Recall that NakedObject does three things main things: it wraps the pojo (getObject()), it provides access to the metamodel through the corresponding NakedObjectSpecification (getSpecification()), and it provides access to the object’s Oid (getOid()).

If NakedObject is analogous to java.lang.Object, then NakedObjectSpecification is analogous to java.lang.Class, describing the class members (properties, collections and actions) of each NakedObject. It provides:
Read the rest of this entry →

In the previous post we saw how to bootstrap Naked Objects, and open a PersistenceSession. In this post let’s see how to actually get hold of and interact with a domain object.

First thing we usually do is to get hold of the registered services (as per nakedobjects.services key in nakedobjects.properties configuration file). These will typically be repositories allowing us to locate existing domain objects, like Customers or Orders. For example, in the claims example app, we have an EmployeeRepository example:
Read the rest of this entry →

One of the objectives for Naked Objects v4.0 was to make the framework more modular. So although (as the screencasts here show) it can still be used as a full-stack framework, it’s also possible to use it just for domain and persistence services. You can then graft on your own user interface as required.

What do I mean by “domain and persistence” services? Well:

• Naked Objects will automatically instantiate any domain services (including repositories and factories), and will inject these into your domain objects.
• It also makes it easy to switch from an in-memory object store while initially prototyping to a full RDBMS (or other) implementation later on.
• It’ll give you authentication/authorization, either in-built or integrating to your enterprise’s existing mechanisms.
• If you are writing client/server code (say, a JavaFX GUI), then it’ll take care of all the remoting for you, marshalling and unmarshalling your domain objects across the wire.

Moreover:
Read the rest of this entry →

In the previous post I discussed the usage of annotations in domain models, and characterized them as either capturing domain semantics intrinsic to the domain, or semantics pertaining to adjacent layers (eg persistence, or presentation).

I also mentioned though that if you really dislike annotations, it’s quite possible to redefine the Naked Objects programming model so it picks up the information from elsewhere, such as a tiny DSL. So let’s see how.
Read the rest of this entry →

Just had an enjoyable few days at the TSS Java Symposium conference in Prague. Never been to Prague before – like everyone told me, a very beautiful city.

At the conference itself also met some very interesting people and there were some interesting sessions – I intend to blog more fully about it in the next few days.

In the meantime, if you’re interested in seeing my presentation, it’s been uploaded (along with all the others) . Seemed to be well enough received and I was happy with the size of audience (my elevator pitch is improving!). There was rather too much content for an hour, though… it definitely lived up to the session title of being “a whistlestop tour”.

In this screencast we’re going to continue looking at domain object properties, building on the first post in this series.

We’ve already seen how Naked objects allows us to write supporting validateXxx() and choicesXxx() methods which we can use to limit the set of values that can be taken for a property, (eg “visa”, “mastercard” or “amex”). But suppose there were two different classes that both had the same rules? That would suggest there’s a concept missing from our ubiquitous language (eg PaymentMethodType). What the values then represent are the bounded set of instances of that type (just like an enum).

So in this screencast Read the rest of this entry →

In the first post in this series, we saw how to add a new property to a domain object and specify some choices.

One of the aims of Naked Objects is to ensure that our domain objects are behaviourally-complete: that they encapsulate a coherent set of responsibilities. Not anaemic domain models, but OO like your mother taught you.

So in this screencast Read the rest of this entry →

Naked Objects excels as a rapid prototyping environment. However, many rapid prototyping environments focus on user interface details, and gloss over the underlying domain concepts that sit underneath. With Naked Objects though (because the UI is generated automatically from the domain model), when we do rapid development prototyping we are prototyping the domain model itself.

This post is the first in a series of screencasts showing how to code using the Naked Objects programming model. In it we build upon the example claims application and show how to add a property to a domain object, and provide a list of choices (a drop-down list) for that property.
Read the rest of this entry →

In a few weeks time theserverside will be running their Java Symposium conference in Prague.

I’m pleased to say I’ll be doing a session there, providing a whistlestop tour to the various features available in Naked Objects 4.0.  If you can make it, why not drop in and introduce yourself.

As I blogged about in previously, Naked Objects is available from the Maven central repository. But to get you started there’s also a download available from the project website on Sourceforge which provides some example applications and other resources.

In this screencast I show you how to import and then run one of these example applications in Eclipse, and I go through the other resources available.
Read the rest of this entry →

One of the alternate viewers I discuss in the last chapter of the book is Scimpi. This is a web framework designed by Robert Matthews (project architect for Naked Objects itself), and which is implemented as a viewer for Naked Objects.

Like the original HTML viewer, Scimpi is still an OOUI: each of its pages correspond to a domain object. However, unlike the HTML viewer Scimpi is designed from the outset to be customisable. Whereas with the HTML viewer there’s no way to influence the page shown, Scimpi on the other hand searches for the best page to render the object by. Only if no page exists is a default view used. That means that different objects can be displayed in different ways.

Another difference is that the HTML viewer “owns” the entire page and always renders all the visible properties of the object. Scimpi in contrast uses (something akin to) taglibs, so the developer has much more control as to what is shown.

Putting the above two together, it also allows for Scimpi to provide composite views, such as an order / orderline.

I’m going to be giving a short 30 min talk on Scimpi at the Devoxx conference in November, so if you were planning on going then you might want to take a look.

The first in a series of screencasts on using Naked Objects and its sister projects. This one shows how to get started using the Maven archetype that comes with Naked Objects 4.0. For a larger view, click play and then press the button in the bottom right.
Read the rest of this entry →

Restful Objects is a sister project to Naked Objects that provides an out-of-the-box RESTful web service interface to your domain model.

Its application library (applib) defines a set of resources, annotated using JSR-311 APIs.  They are:

Read the rest of this entry →