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

EhCache config with BeanUtils

BeanUtils allows you to set Bean properties.If you have configuration stored in a Map it's tempting to use BeanUtils to automagically setup EhCache configuration.Sadly this class has mixed types in setters and getter and thus BeanUtils that use Introsp...
DDevelopment & Design

Using WsLite in practice

TL;DR

There is a example working GitHub project which covers unit testing and request/response logging when using WsLite.

Why Groovy WsLite ?

I’m a huge fan of Groovy WsLite project for calling SOAP web services. Yes, in a real world you have to deal with those - big companies have huge amount of “legacy” code and are crazy about homogeneous architecture - only SOAP, Java, Oracle, AIX…

But I also never been comfortable with XFire/CXF approach of web service client code generation. I wrote a bit about other posibilites in this post. With JAXB you can also experience some freaky classloading errors - as Tomek described on his blog. In a large commercial project the “the less code the better” principle is significant. And the code generated from XSD could look kinda ugly - especially more complicated structures like sequences, choices, anys etc.

Using WsLite with native Groovy concepts like XmlSlurper could be a great choice. But since it’s a dynamic approach you have to be really careful - write good unit tests and log requests. Below are my few hints for using WsLite in practice.

Unit testing

Suppose you have some invocation of WsLite SOAPClient (original WsLite example):

def getMothersDay(long _year) {
    def response = client.send(SOAPAction: action) {
       body {
           GetMothersDay('xmlns':'http://www.27seconds.com/Holidays/US/Dates/') {
              year(_year)
           }
       }
    }
    response.GetMothersDayResponse.GetMothersDayResult.text()
}

How can the unit test like? My suggestion is to mock SOAPClient and write a simple helper to test that builded XML is correct. Example using great SpockFramework: 

void setup() {
   client = Mock(SOAPClient)
   service.client = client
}

def "should pass year to GetMothersDay and return date"() {
  given:
      def year = 2013
  when:
      def date = service.getMothersDay(year)
  then:
      1 * client.send(_, _) >> { Map params, Closure requestBuilder ->
            Document doc = buildAndParseXml(requestBuilder)
            assertXpathEvaluatesTo("$year", '//ns:GetMothersDay/ns:year', doc)
            return mockResponse(Responses.mothersDay)
      }
      date == "2013-05-12T00:00:00"
}

This uses a real cool feature of Spock - even when you mock the invocation with “any mark” (_), you are able to get actual arguments. So we can build XML that would be passed to SOAPClient's send method and check that specific XPaths are correct:

void setup() {
    engine = XMLUnit.newXpathEngine()
    engine.setNamespaceContext(new SimpleNamespaceContext(namespaces()))
}

protected Document buildAndParseXml(Closure xmlBuilder) {
    def writer = new StringWriter()
    def builder = new MarkupBuilder(writer)
    builder.xml(xmlBuilder)
    return XMLUnit.buildControlDocument(writer.toString())
}

protected void assertXpathEvaluatesTo(String expectedValue,
                                      String xpathExpression, Document doc) throws XpathException {
    Assert.assertEquals(expectedValue,
            engine.evaluate(xpathExpression, doc))
}

protected Map namespaces() {
    return [ns: 'http://www.27seconds.com/Holidays/US/Dates/']
}

The XMLUnit library is used just for XpathEngine, but it is much more powerful for comparing XML documents. The NamespaceContext is needed to use correct prefixes (e.g. ns:GetMothersDay) in your Xpath expressions.

Finally - the mock returns SOAPResponse instance filled with envelope parsed from some constant XML:

protected SOAPResponse mockResponse(String resp) {
    def envelope = new XmlSlurper().parseText(resp)
    new SOAPResponse(envelope: envelope)
}

Request and response logging

The WsLite itself doesn’t use any logging framework. We usually handle it by adding own sendWithLogging method:

private SOAPResponse sendWithLogging(String action, Closure cl) {
    SOAPResponse response = client.send(SOAPAction: action, cl)
    log(response?.httpRequest, response?.httpResponse)
    return response
}

private void log(HTTPRequest request, HTTPResponse response) {
    log.debug("HTTPRequest $request with content:\n${request?.contentAsString}")
    log.debug("HTTPResponse $response with content:\n${response?.contentAsString}")
}

This logs the actual request and response send through SOAPClient. But it logs only when invocation is successful and errors are much more interesting… So here goes withExceptionHandler method:

private SOAPResponse withExceptionHandler(Closure cl) {
    try {
        cl.call()
    } catch (SOAPFaultException soapEx) {
        log(soapEx.httpRequest, soapEx.httpResponse)
        def message = soapEx.hasFault() ? soapEx.fault.text() : soapEx.message
        throw new InfrastructureException(message)
    } catch (HTTPClientException httpEx) {
        log(httpEx.request, httpEx.response)
        throw new InfrastructureException(httpEx.message)
    }
}
def send(String action, Closure cl) {
    withExceptionHandler {
        sendWithLogging(action, cl)
    }
}

XmlSlurper gotchas

Working with XML document with XmlSlurper is generally great fun, but is some cases could introduce some problems. A trivial example is parsing an id with a number to Long value:

def id = Long.valueOf(edit.'@id' as String)

The Attribute class (which edit.'@id' evaluates to) can be converted to String using as operator, but converting to Long requires using valueOf.

The second example is a bit more complicated. Consider following XML fragment:

<edit id="3">
   <params>
      <param value="label1" name="label"/>
      <param value="2" name="param2"/>
   </params>
   <value>123</value>
</edit>
<edit id="6">
   <params>
      <param value="label2" name="label"/>
      <param value="2" name="param2"/>
   </params>
   <value>456</value>
</edit>

We want to find id of edit whose label is label1. The simplest solution seems to be:

def param = doc.edit.params.param.find { it['@value'] == 'label1' }
def edit = params.parent().parent()

But it doesn’t work! The parent method returns multiple edits, not only the one that is parent of given param…

Here’s the correct solution:

doc.edit.find { edit ->
    edit.params.param.find { it['@value'] == 'label1' }
}

Example

The example working project covering those hints could be found on GitHub.