DDevelopment & Design

Eclipse ecosystem

Do you use Eclipse? Or perhaps you use other IDE but would like to try “the big E”? Well, that’s OK, and completely understandable, because Eclipse is actually a great, versatile tool. But Eclipse is not just an IDE, in fact it is a comp let, extensible platform. What’s even more important, there are tones of valuable Eclipse-related projects gathered around the platform.

Yes, there are lots. Some are good, some are bad, but the usual, stock ones, signed by Eclipse, are worth taking a closer look. They’re not a mere innovation to the way we write code with an IDE. Those tools provide new ways to _create_ our code.

Consider Eclipse just a foundation for better things to come. Having Equinox OSGI container underneath it is fully modular ecosystem, that allows multiple bundles (in which we pack the plug-ins) coexist, and benefit from each others functionalities. Not dwelling on details of OSGI, it gives us a simple extensible platform to play with.

That in fact is great, because out of piles of Eclipse components you can build your own component base, and thus create a basis for your own solution. Since Eclipse is extensible you can extend the IDE’s workbench, by implementing plug-ins, or you can choose to implement a standalone application, that is based on RCP (Rich Client Platform) concept. And there are really big apps written with this in mind, like IBM’s Lotus Suite, totally based on Eclipse – and pretty neat also.

Well, that looks nice, but who writes so much code these days, who wants to create all the domain classes and GUI stuff by hand crafted api interfaces? Nope, one no longer have to go this path, just try Eclipse EMF sub-project, which offers model driven development practices, and whole bunch of code generation plug-ins will come to aid you. Using EMF you can create your domain model in just a few clicks, or import it from your existing java interfaces – actually you can use a couple more ways to do this. Having an EMF model you are just a few clicks from generating a working, domain editor, that would serve as a sandbox for your ideas about the domain you’re implementing, or it can be used right away in your new shiny web application.

Another few clicks and you get free model persistence with Hibernate, or other ORM framework. And this really works.

Since it would be nice to present things to end users you could generate some basic graphic editor, of course Eclipse supports that. But who uses thick clients today? Be serious, right? If you want something web-enabled, you don’t have to move your skills from the Eclipse ecosystem, just try out Eclipse RAP and have your Eclipse application in your browser via some serious Javascript voodoo magic – like on-the-fly converters. Of course other popular frameworks are allowed :)

What is most important here, is the constant use of the same tools, developing subsequent stages of the app don’t require you to switch skills. It’s Java all way up to this place.

And it gets more interesting when you dive deeper and deeper into this rich and flourishing community. Some examples of the vastness of the platform may be:

  • Swordfish – SOA solution, with BAM (Business Activity Monitoring) implemented
  • XText – enables you to write a simple (or not) DSLs for your apps
  • E4 – next gen Eclipse IDE, with many great ideas in it

Of course, the whole picture gets a bit blurry if you consider more technical details, there is not so much ease of use or scalability, etc, as you might expected. The whole Eclipse ecosystem may not be suitable for all your applications, but it may be for some. Or perhaps it is suitable for only a couple stages in your current project?

Let this be just a simple introduction to the rich Eclipse Community projects. With next iterations of this cycle I’d like to describe more in-depth details of the Eclipse framework, and various usage scenarios for Eclipse projects. Stay tuned!

— Previous article

Passive view for Ext GWT applications

Next article —

Writer versus Constructor

You May Also Like
DDevelopment & Design

Simple trick to DRY your Grails controller

Grails controllers are not very DRY. It's easy to find duplicated code fragments in default generated controller. Take a look at code sample below. It is duplicated four times in show, edit, update and delete actions:

class BookController {
def show() {
def bookInstance = Book.get(params.id)
if (!bookInstance) {
flash.message = message(code: 'default.not.found.message', args: [message(code: 'book.label', default: 'Book'), params.id])
redirect(action: "list")
return
        }
        [bookInstance: bookInstance]
    }
}

Why is it duplicated?

There is a reason for that duplication, though. If you move this snippet to a method, it can redirect to "list" action, but it can't prevent controller from further execution. After you call redirect, response status changes to 302, but after method exits, controller still runs subsequent code.

Solution

At TouK we've implemented a simple trick to resolve that situation:

  1. wrap everything with a simple withStoppingOnRender method,
  2. whenever you want to render or redirect AND stop controller execution - throw EndRenderingException.

We call it Big Return - return from a method and return from a controller at once. Here is how it works:

class BookController {
def show(Long id) {
withStoppingOnRender {
Book bookInstance = Book.get(id)
validateInstanceExists(bookInstance)
            [bookInstance: bookInstance]
        }
    }

protected Object withStoppingOnRender(Closure closure) {
try {
return closure.call()
        } catch (EndRenderingException e) {}
    }

private void validateInstanceExists(Book instance) {
if (!instance) {
flash.message = message(code: 'default.not.found.message', args: [message(code: 'book.label', default: 'Book'), params.id])
redirect(action: "list")
throw new EndRenderingException()
        }
    }
}

class EndRenderingException extends RuntimeException {}

Example usage

For simple CRUD controllers, you can use this solution and create some BaseController class for your controllers. We use withStoppingOnRender in every controller so code doesn't look like a spaghetti, we follow DRY principle and code is self-documented. Win-win-win! Here is a more complex example:

class DealerController {
@Transactional
def update() {
withStoppingOnRender {
Dealer dealerInstance = Dealer.get(params.id)
validateInstanceExists(dealerInstance)
validateAccountInExternalService(dealerInstance)
checkIfInstanceWasConcurrentlyModified(dealerInstance, params.version)
            dealerInstance.properties = params
saveUpdatedInstance(dealerInstance)
redirectToAfterUpdate(dealerInstance)
        }
    }
}
DDevelopment & Design

Confitura 2013 afterthoughts

Confitura, the biggest free-of-charge Java conference in Europe, took place on the 6th of July in Warsaw. TouK's presence was heavy, with 5 separate talks, all chosen in call for papers, no sponsored bullshit. We were sponsoring deck chairs during the...Confitura, the biggest free-of-charge Java conference in Europe, took place on the 6th of July in Warsaw. TouK's presence was heavy, with 5 separate talks, all chosen in call for papers, no sponsored bullshit. We were sponsoring deck chairs during the...