A few days ago a friend of mine who was skiing at La Plagne (France) Tweeted this photo asking “Am I the only one being shocked about this ?“. I don’t know if he had many answers, but clearly, I was shocked. Shocked as a man, shocked as a dad of a 8 years old girl who will become a woman. In this photo Sony makes the parallel between a woman and a play station : two toys you can play with.

I’m sure all of us, in our different countries, have seen adverts of half-naked women drinking beer or half-naked women driving a car. This has been going on for decades… meaning… it works ! If you want to sell something ? Just use a naked woman. Yes, it works, you will sell more yogurts, beers, cars, perfumes .. and make more money. So can we all agree here please ? Put a naked woman on your advert and you will make more money ! Ok ? Good ! So now let’s move on !

In the industry I work in (IT), things move very fast, so a recipe that worked in 2000 doesn’t always work in 2013. That’s why we need to be fast, swift, agile, and need to innovate to create value (otherwise your business dies). Sony has the same problem.  Looks like in the advertising industry they don’t have this problem, don’t need to innovate and use the same old good recipe : naked woman == more business !

Sony, it looks like your business is not going too well. Maybe you should innovate, re-structure your company, have new ideas. I know, it’s difficult. Making business in 2013 is difficult because the competition is huge. But by using this kind of adverts, you look like your are at one inch of closing the company… and your last trick to come back to business is to use sexist adverts. Or maybe you really deserve your “junk status“.

Women, please, stop creating a world where you’ll get more and more uncomfortable living in. You don’t have to get naked for us to eat a yogurt or drive a car. Tell your female friends about it please !

Guys, can we just move on ?

I would like to know the people who created this advert. If they could spend more time playing with their girlfriends (boyfriends) and wives (husbands) in their private lives, they would not create such crape. If you don’t have a partner to play with in your bed at home, bad luck, keep your sexual frustration for you, but do not expose it to everybody.

I’ll not go into “BOYCOT SONY’S PRODUCTS” because a bunch of idiots damaged the work of thousands of Sony’s employees. I just want these employees to go back to there managers and say “hey guys, the company is not in good shape, so instead of spending money in silly adverts, let’s go back to our original message : innovation”. So please Sony, make us dream like you used to (walkman, discman, floppy disks, compact disc, PlayStation, movie, music, entertainment, computers, flash memory cards, blu-ray disc, cameras, semiconductors…)… or go out of business if you can’t innovate anymore… but stop using sexist advertisement !

References

• How Sony Is Turning into a Ghost in Japan and Around the World
• What Is Sony Now?
• Investors heckle Sir Howard Stringer at Sony’s annual meeting
• Sony caps worst year ever with $6.4B loss
• How Kazuo Hirai plans to save Sony from mediocrity
• Viewpoint: How Sony slipped back

After the announcement of the NoMock Movement I had to write another post about integration testing. Here it goes  : how to test your nice RESTful URIs ?

Use Case

Often you hear that URIs have to be expressive… and you want to test that your URIs are nicely written. How do you do that ? Unit testing with mock frameworks such as Restito or Rest assured ? If you do that you’ll be mocking the important part of what you really : a web server. Thanks to integration testing, you can just run your RESTful web service in an in memory web container and check that your URIs are correct (useful when you have many RESTful web services and get lost in your URIs)

JAX-RS 2.0 Client API

To integration-test URIs I will use the new JAX-RS 2.0 Client API and the Jersey implementation. If you haven’t followed what’s been happening, here are some news about JAX-RS. At the time of writing this post JAX-RS 2.0 is nearly out and will be in Java EE 7 by Q2 2013. The client API wasn’t standardized in JAX-RS 1.1 and it’s one of the novelties in 2.0. It allows you to make HTTP requests to your remote RESTful web services easily. It is a fluent request building API (i.e. using the Builder design pattern) that uses a small number of classes and interfaces which are in the javax.ws.rs.client package. The Client interface (obtained with the ClientFactory) is a builder of WebTarget instances. A WebTarget represents a distinct URI from which you can invoke requests on to obtain a Response. From this Response you can check HTTP status, length or cookies but more importantly you can get its content (a.k.a entity, message body or payload) through the Entity class.

With that in mind, here are the lines of code to invoke a GET method on a remote RESTful web service located at http://www.myserver.com/book and return a text/plain value:

Client client = ClientFactory.newClient();
WebTarget target = client.target("http://www.myserver.com/book");
Invocation invocation = target.request(MediaType.TEXT_PLAIN).buildGet();
Response response = invocation.invoke();

Thanks to the builder API and some shortcuts, you can write the same behavior in a single line of code:

Response response = ClientFactory.newClient().target("http://www.myserver.com/book").request(MediaType.TEXT_PLAIN).get();

RESTful Web Service

Let’s start with a simple RESTful web service with only GET methods. As you can see below, this service allows you to get a Customer by login (note the regular expression that only allows lowercase) and by ID (regular expression forces to have digits). Then there are two other methods that allow you to search customers by zip code (query param) or name and surname (matrix param).

@Path("/customer")
@Produces(MediaType.APPLICATION_XML)
public class CustomerRestService {

    @GET
    @Path("{login: [a-z]*}")
    public Response getCustomerByLogin(@PathParam("login") String login) {
        Customer customer = new Customer("John", "Smith", "jsmith@gmail.com", "1234565");
        customer.setLogin(login);
        return Response.ok(customer).build();
    }

    @GET
    @Path("{customerId : \\d+}")
    public Response getCustomerById(@PathParam("customerId") Long id) {
        Customer customer = new Customer("John", "Smith", "jsmith@gmail.com", "1234565");
        customer.setId(id);
        return Response.ok(customer).build();
    }

    @GET
    public Response getCustomersByZipCode(@QueryParam("zip") Long zip) {
        Customers customers = new Customers();
        customers.add(new Customer("John", "Smith", "jsmith@gmail.com", "1234565"));
        customers.add(new Customer("John", "Smith", "jsmith@gmail.com", "1234565"));
        return Response.ok(customers).build();
    }

    @GET
    @Path("search")
    public Response getCustomerByName(@MatrixParam("firstname") String firstname, @MatrixParam("surname") String surname) {
        Customers customers = new Customers();
        customers.add(new Customer("John", "Smith", "jsmith@gmail.com", "1234565"));
        customers.add(new Customer("John", "Smith", "jsmith@gmail.com", "1234565"));
        return Response.ok(customers).build();
    }
}

How to invoke these methods ?

• /customer/agoncal invokes the getCustomerByLogin (GET method and the path parameter only allows lowercases)
• /customer/1234 invokes getCustomerById (GET method and a numerical path parameter)
• /customer?zip=75012 invokes getCustomersByZipCode using QueryParam
• /customer/search;firstname=John;surname=Smith invokes getCustomerByName using MatrixParam

And if you have a URI like /customer/AGONCAL it would be invalid because of the uppercase (the regex only allows lower cases).

Integration-Testing URIs

So let’s test these URIs in an integration test using a real HTTP server.

public class CustomerRestServiceIT {

    @Test
    public void shouldCheckURIs() throws IOException {

        URI uri = UriBuilder.fromUri("http://localhost/").port(8282).build();

        // Create an HTTP server listening at port 8282
        HttpServer server = HttpServer.create(new InetSocketAddress(uri.getPort()), 0);
        // Create a handler wrapping the JAX-RS application
        HttpHandler handler = RuntimeDelegate.getInstance().createEndpoint(new ApplicationConfig(), HttpHandler.class);
        // Map JAX-RS handler to the server root
        server.createContext(uri.getPath(), handler);
        // Start the server
        server.start();

        Client client = ClientFactory.newClient();

        // Valid URIs
        assertEquals(200, client.target("http://localhost:8282/customer/agoncal").request().get().getStatus());
        assertEquals(200, client.target("http://localhost:8282/customer/1234").request().get().getStatus());
        assertEquals(200, client.target("http://localhost:8282/customer?zip=75012").request().get().getStatus());
        assertEquals(200, client.target("http://localhost:8282/customer/search;firstname=John;surname=Smith").request().get().getStatus());

        // Invalid URIs
        assertEquals(404, client.target("http://localhost:8282/customer/AGONCAL").request().get().getStatus());
        assertEquals(404, client.target("http://localhost:8282/customer/dummy/1234").request().get().getStatus());

        // Stop HTTP server
        server.stop(0);
    }
}

The idea is to launch an in-memory HTTP server. Jersey has several extensions so you can use Grizzly or GlassFish. But a very simple test would be to just use the com.sun.net.httpserver.HttpServer that comes with the Oracle JDK. As you can see in line 11, the only thing we need to do is to attach a com.sun.net.httpserver.HttpHandler with the JAX-RS application configuration (class ApplicationConfig not shown here, but you can download the code). Then you just need to start the in memory web server (server.start();), check your valid (return code 200) and invalid (return code 404) URIs and stop the server. That’s it.

I Gave a Quick Try at Unit-Test

I did give a try at unit testing this use case using  Restito. I have to be honest here, I’ve quickly looked at the developer’s guide and after struggling with Maven dependencies (REST Assured, Grizzly, Google Collections…) I managed to “unit test” my use case. I haven’t looked much into it but the logs from Restito looked a bit weired for a unit test :

org.glassfish.grizzly.http.server.NetworkListener start
org.glassfish.grizzly.http.server.HttpServer start
[HttpServer] Started
org.glassfish.grizzly.http.server.NetworkListener stop

So I don’t know if Restito is really starting Grizzly HTTP server of not, but if it is, it’s not really mocking much.

Conclusion

This integration-test will run in a few milliseconds (on my Mac, 3 secondes on a normal Windows XP box) and you will really check your URIs not mocking anything… But of course, this is a very simple test. Most of the time you need database access, injection and so on. That’s when when you bring Arquillian into play ;o) Maybe a topic to write about in a future post.

References

• Restito
• Rest Assured

If you use Maven in your projects you might wonder what “Let’s Turn Integration Tests with Maven into a First-Class Citizen” means. A bit of introduction on that. Maven is based around the central concept of a build lifecycle and if you look at the default lifecycle bindings  you see the following phases :

• process-resources
• compile
• process-test-resources
• test-compile
• test
• package
• install
• deploy

As you can see, unit tests are central in Maven. Package your project with mvn package or deploy it with mvn deploy and this will kick the test phase. Why ? Because in the default lifecycle bindings of Maven, the test phase is automatically called through the Surefire plugin. The maven-surefire-plugin is designed for running unit tests and if any of the tests fail then it will fail the build immediately.

So where are the integration tests ? Not in the default lifecycle, that’s for sure. They are handled by a different plugin : Failsafe. The maven-failsafe-plugin is a fork of Surefire designed to run integration tests (after the package phase, on the integration-test phase). But on the contrary of Surefire, Failsafe is not activate by default, you need to explicitelly add it to you pom.xml and attach a phase to it :

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-failsafe-plugin</artifactId>
  <version>2.12.4</version>
  <executions>
    <execution>
      <goals>
        <goal>integration-test</goal>
        <goal>verify</goal>
      </goals>
    </execution>
  </executions>
</plugin>

The Maven lifecycle has four phases for running integration tests:

• pre-integration-test: on this phase you can start any required service or do any action (starting a database, a webserver…)
• integration-test: failsafe will run the test on this phase
• post-integration-test: time to shutdown all services
• verify: failsafe runs another goal that interprets the results of tests here

The Failsafe Plugin has only 2 goals:

• failsafe:integration-test : runs the integration tests of an application.
• failsafe:verify : verifies that the integration tests of an application passed.

By default, the Surefire plugin executes **/Test*.java, **/*Test.java, and **/*TestCase.java test classes. The Failsafe plugin will look for **/IT*.java, **/*IT.java, and **/*ITCase.java. So if you are using unit test and integration tests, make sure to put them all in src/test/java and use this naming convention.

How does this work ? You run mvn test : unit test are executed. You run mvn verify : unit test and then integration tests are executed. But if unit test fail, integration tests are not passed. Meaning that, for Maven, unit tests are more important than integration test.

How to seperate unit and integration test ?

What I really want is to be able to, either run UT or IT or none of them. Something like :

• mvn install -DskipUTs : Skips Unit tests
• mvn install -DskipITs : Skips Integration tests
• mvn install -DskipTests : Skips both Unit and Integration Tests

Here is a little trick you need to do in your pom.xml (again, thanks Arnaud)

<project>
  ...
  <properties>
    <skipTests>false</skipTests>
    <skipITs>${skipTests}</skipITs>
    <skipUTs>${skipTests}</skipUTs>
  </properties>

  <build>
    <plugins>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <version>2.12.4</version>
        <configuration>
          <skipTests>${skipTests}</skipTests>
          <skipITs>${skipITs}</skipITs>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>integration-test</goal>
              <goal>verify</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.12.4</version>
        <configuration>
          <skipTests>${skipUTs}</skipTests>
        </configuration>
      </plugin>

    </plugins>
  </build>
</project>

Conclusion

Unit testing is at the heart of Maven… but not integration testing. With this little trick you can put UT and IT at the same level : you can run either both tests, UT only, IT only or none. But it would be good to have this behaviour by default, without any configuration. That would mean adding the integration-test phase to the default lifecycle bindings of Maven.

What do you think ? Shall I start a discussion on the Maven Mailing List ? Create a JIRA issue ? Shall we put integration tests at the same level of unit test ? Any other idea of how we could integrate both more closely ?

Référence

• Integration tests with Maven (Part 1)
• Integration Tests with Maven (Part 2)

This weekly IT magazine has a palmares once a year where they elect people who they think will influence IT for the coming year. I still don’t really know how they elect people, which criteria they take into account or who votes. Anyway, I was a bit surprised when I saw my name in these 100 influential people where you find the french minister Fleur Pellerin, Xavier Niel (Free), Rafi Haladjian (Sen.se), Miguel Valdes Faura (Bonitasoft), Octave Klaba (OVH) and plenty of people from Bull, IBM, Dassault, Orange, Cloudwatt, Atos…

So here I am in the middle of all these names. And what do they have to say about me ? Here is a translation of the magazine you can find here :

“Antonio Goncalves, Devoxx France.
This Java specialist is a star among developers. He has written two books on the subject and his blog antoniogoncalves.org has become a reference. Regularly, we see him at the Paris JUG, which he leads, or on the JBoss community website. Today this young man of 40 years is also the creator of Devoxx France, the conference for passionate developers held for the first time in Paris in April 2012″.

First, I would like to thank 01 Informatique who say I am a young man… even if I’m 40. It’s always good to know that you are young (in a job where companies don’t want senior developers). Second, I would like to thank them again for saying I’m a star. I’ve always consider John Coltrane, Thelonious Monk, Miles Davis or George Gershwin to be stars. I wonder if my star has the same value of theirs ;o)  Oh, and by the way, what the hell this thing about JBoss community website in the article ?

Anyway, I’m sure my mum will be happy to know that I will be one of the 100th most influencial IT people in France in 2013

Have you ever felt uncomfortable surrounded by a group of people who all agree and you don’t ? Feels strange doesn’t it. You think ‘what’s wrong with me ?‘. That’s exactly what I felt all these years with Unit Testing and Mocking. Everybody was unit testing, everybody was mocking… and I was questioning the relevance of so much mocking. Through my customers’ projects I’ve seen everything from zero test coverage to complex unit tests with more mocks than code to test. But everybody agreed that mocking was the way to go, so I did the same (BTW, thank you Mockito for showing me the way, your framework rocks).

Then in memory databases arrived (but some were still mocking DB access). Then in memory web servers arrived (but some were still mocking HTTP requests). Then Microsoft decided to do a 64 bits OS so we could have more memory. Then in memory containers arrived (but some where still mocking container services). Then Arquillian arrived. So while everybody was mocking I took all these new tools and started to write more and more integration tests, less unit tests and less mocks.

So now I’m officially launching the NoMock Movement (‘Not Only Mocks Movement’). This movement is for people stopping being ashamed of not mocking every single aspect of their code and starting to write more integration tests. Join the movement, don’t be ashamed and repeat after me : Stop mocking, start testing !

What are the concrete actions of this movement ? For now it’s just buying the nomock.org domain name and pointing it to my own website (isn’t that arrogant !) and then I’ll see what to do with it when I have some free time (a GitHub site where everybody can aggregate resources about integration testing would be good, so you can all contribute). I’ve also created the NoMockMov Twitter account and will use it to promote integration testing (by re-tweeting any useful article/blog/resource).

And now, go back to coding (real code)

References :

• Is there such a thing as the NoMock movement?
• Mocks are a Mockery
• Stop Mocking, Start Testing
• Dan Allen on Arquillian Testing Framework
• What You Test Is What You Run

Disclaimer : of course I use unit tests and mocks, I’m just saying that today we can also use integration tests.

Disclaimer bis : Take a laugh, not everything in life has to be taken seriously ;o)

In this interview I talk about the Paris JUG, Devoxx France, but mostly about my life as a Java EE 7 hacker. Yes, Java EE 7 will be out in April 2013 (in 6 months) so every spec is in Early Draft, the reference implementations are in Alpha or Beta and there is few documentation and blogs. Being expert member of Java EE 7 (JSR 342), Java EE 7 is a topic that takes a lot of my time lately. In this interview I mostly talk about things that you expect will be working… but they won’t (not always easy to have all the spec leads agree and integrate well). But I also show some code that will make your life easier ;o)

Again, thank you Stephen Chin for the interview. You can check out his photos.

So first, let’s write a SOAP Web Service. I’m using the one I use on my book : a SOAP Web Service that validates a credit card. If you look at the code, there is nothing special about it (the credit card validation algorithm is a dummy one: even numbers are valid, odd are invalid). Let’s start with the interface :

import javax.jws.WebService;

@WebService
public interface Validator {
    public boolean validate(CreditCard creditCard);
}

Then the SOAP Web Service implementation :

@WebService(endpointInterface = "org.agoncal.book.javaee7.chapter21.Validator")
public class CardValidator implements Validator {

  public boolean validate(CreditCard creditCard) {

    Character lastDigit = creditCard.getNumber().charAt(creditCard.getNumber().length() - 1);

    return Integer.parseInt(lastDigit.toString()) % 2 != 0;
  }
}

What do you need to test this SOAP Web Service ? Nothing ! The code above is just a POJO so you can write a unit test that checks the validation algorithm. Something as follow :

public class CardValidatorTest {

  @Test
  public void shouldCheckCreditCardValidity() {

    CardValidator cardValidator = new CardValidator();

    CreditCard creditCard = new CreditCard("12341234", "10/10", 1234, "VISA");

    assertFalse("Credit card should be valid", cardValidator.validate(creditCard));
    creditCard.setNumber("12341233");
    assertTrue("Credit card should not be valid", cardValidator.validate(creditCard));
  }
}

In this unit test I instantiate the CardValidator class and invoke the validate method. This is acceptable, but what if your SOAP Web Serivce uses Handlers ? What if it overrides mapping with the webservice.xml deployment descriptor ? Uses the WebServiceContext ? In short, what if your SOAP Web Service uses containers’ services ? Unit testing becomes useless. So let’s test your SOAP Web Service inside the container and write an the integration test. For that we can use an in-memory web container. And I’m not just talking about a GlassFish, JBoss or Tomcat, but something as simple as the web container that come with the SUN’s JDK. Sun’s implementation of Java SE 6 includes a light-weight HTTP server API and implementation : com.sun.net.httpserver.

Note that this default HTTP server is in a com.sun package. So this might not be portable depending on the version of your JDK. Instead of using the default HTTP server it is also possible to plug other implementations as long as they provide a Service Provider Implementation (SPI) for example Jetty’s J2se6HttpServerSPI.

So this is how an integration test using an in memory web container can look like :

public class CardValidatorIT {

  @Test
  public void shouldCheckCreditCardValidity() throws MalformedURLException {
    // Publishes the SOAP Web Service
    Endpoint endpoint = Endpoint.publish("http://localhost:8080/cardValidator", new CardValidator());
    assertTrue(endpoint.isPublished());
    assertEquals("http://schemas.xmlsoap.org/wsdl/soap/http", endpoint.getBinding().getBindingID());

    // Data to access the web service
    URL wsdlDocumentLocation = new URL("http://localhost:8080/cardValidator?wsdl");
    String namespaceURI = "http://chapter21.javaee7.book.agoncal.org/";
    String servicePart = "CardValidatorService";
    String portName = "CardValidatorPort";
    QName serviceQN = new QName(namespaceURI, servicePart);
    QName portQN = new QName(namespaceURI, portName);

    // Creates a service instance
    Service service = Service.create(wsdlDocumentLocation, serviceQN);
    Validator cardValidator = service.getPort(portQN, Validator.class);

    // Invokes the web service
    CreditCard creditCard = new CreditCard("12341234", "10/10", 1234, "VISA");

    assertFalse("Credit card should be valid", cardValidator.validate(creditCard));
    creditCard.setNumber("12341233");
    assertTrue("Credit card should not be valid", cardValidator.validate(creditCard));

    // Unpublishes the SOAP Web Service
    endpoint.stop();
    assertFalse(endpoint.isPublished());
  }
}

The Endpoint.publish() method uses by default the light-weight HTTP server implementation that is included in Sun’s Java SE 6. It publishes the SOAP Web Service and starts listening on URL http://localhost:8080/cardValidator. You can even go to http://localhost:8080/cardValidator?wsdl to see the generated WSDL. The integration test looks for the WSDL document, creates a service using the WSDL information, gets the port to the SOAP Web Service and then invokes the validate method. The method Endpoint.stop() stops the publishin of the service and shutsdown the in-memory web server.

Again, you should be careful as this integration test uses the default HTTP server which is in a com.sun package and therefore not portable.

Few months ago I was struggling (again) with logging configuration in JBoss 7.x. I was so depressed that I wrote to the Java EE 7 expert group : Logs. Should we finally do something ? (you should read it, there are valuable opinions expressed by the members). As a developer I’ve used all the possible logging Java frameworks for the last 12 years and I still struggle with logging in 2012. How many logging frameworks do we have ? Look at the list :

• JUL : the good old java.util.logging API that is included in our JDK. Bad luck, it is there and nobody uses it
• Log4j : widely used, Log4j hasn’t really been updated lately (update : the team is working on a 2.0 version)
• Commons Logging : How many more Apache logging frameworks do you want ?
• SLF4J : if you are not sure which logging API to use, well, use an abstraction (hum, abstraction, we love abstraction)
• Logback : the successor of Log4J (successor ? really ?)
• TinyLog : because all these frameworks are too big, we need to use a tiny one
• And many many many more Java logging frameworks

I’m not a log expert and I’m sure all these frameworks exist for good reasons (I’m trying to be politically correct here), but for god sake, we just need to write logs. I don’t want to do a benchmark of all the logging APIs to make up my mind. I don’t want to have to relearn a new logging framework each time a new version of my application server is out (yes, JBoss 7 uses its own JBoss Logging API). To be honest, instead of all saying “using System.out.println is bad” we should have encouraged it and let Java SE redirect the messages to files (using external configuration). This way our code would be full of System.out.println("message") or System.out.println(WARNING, "message") and we would have avoided all the logging frameworks. Anyway, this is the situation we’re in.

Let’s standardize a logging API

Standardizing too soon is bad… but we’ve been doing logs for more than a decade now. We have a big expertise in logging, we could even take some ideas of other languages. So it’s time to standardize logging. Let’s not do the same mistake as JUL  and only standardize an API. Then, we could let all the known frameworks to implement it and fight about better performances or functionalities. Today, logging portability is a nightmare, enough. With a standard API we could also have some tooling and descent log viewers coming on board.

Integrate this logging API in Java EE (and other specs)

If all the Java EE specs (EJB, JPA, JAX-RS, CDI…) use this standard API and impose it to the implementations, we could then easily change the level of logs in a standard way on our applications by using a simple package naming convetion :

javax.ejb.level = debug         // EJB spec
javax.persistence.level = debug // JPA spec
org.weld.level = debug          // CDI implementation (Weld)
my.app.level = debug            // My application

And who knows, when modularization arrives we could get rid of java.util.logging and have a new javax.logging module in Java SE (and choose the implementation).

Think to the future

If we had a Logging API 1.0 specification, then, when multi-tenancy comes along, we could have a Logging API 1.1 which handles it (wouldn’t it be nice to have multi-tenant logs with no effort ?). Another idea would be to play with staging. JSF 2.0 introduced staging and it might be spread all over Java EE. If that’s the case, we could simply use default logging : DEBUG for development, WARNING for production… That would simplify configuration.

Do you feel like being a spec lead ?

No, it’s not because I write this blog post that I want to be a spec lead. I’m not the right person, I’ve never implemented a logging framework, I’m just a user of theses APIs. So if you feel you know the topic well, if you know people who could help you by being part of your expert group (if you want, I could even join this expert group), then do it. Entering the JCP is not a piece of cake, you need to do a bit of administration to have your JSR approved, but it’s doable.  You would need a bit of time, but it’s doable. Even if you start now I’m not sure there will be enough time to take the Java EE 7 train, but the JCP has some examples of quick JSRs.

So, who wants to be a Logging API Spec Lead ? Do you think it’s a good idea to standardize a Logging API ?

The Petstore had a huge momentum and we started to see plenty of Petstore-like applications flourish (the idea was to build an entire application with a certain technology). But let’s face it, the J2EE version was far too complex and was using plenty of (today outdated) design patterns. When I wrote my Java EE 5 book back in 2006 (sorry, it’s written in French), I decided to write a Petstore-like application in Java EE 5 but much simpler. But again, it’s out-dated today.

Later on I wrote a book about Java EE 6and felt there was a need to have an updated Petstore so we could discover new patterns and APIs. Unfortunately Sun/Oracle didn’t do it… so I’ve decided to do it myself (with some help from my friends Antoine Sabot-Durand, Brice Leporini, Hervé Le Morvan). I’ve updated my YAPS Petstore to follow Java EE 6 and all its goodies (CDI, EJB Lite, REST interface, Bean Validation).

The goals of this sample is to :

• use Java EE 6 and just Java EE 6 : no external framework or dependency (I even use java.util.logging API ;o)
• make it simple : no complex business algorithm, but I use most of the Java EE 6 APIs, the point is to bring Java EE 6 technologies together to create an eCommerce website

If you want to use a different web interface (PrimeFaces, pure HTML, Android…), external frameworks, add some sexy alternative JVM language… feel free to fork the code and do so. But I won’t do it because I want this EE 6 Petstore to remain simple and to stick to Java EE 6.

The only external frameworks that I’ve used are Twitter Bootstrap (so my JSF pages don’t look too ugly) and Arquillian for integration testing. My goal is to be able to deploy this Yaps Petstore on different application servers. For now it’s mostly GlassFish, JBoss but some work is also happening on TomEE and I’ll try to port it later on Resin, Weblogic, Websphere…. and who knows, do some performance benchmark of the same application but on different servers.

My next task is to deploy this Yaps Petstore on CloudBees… stay tuned. In the meantime, give it a try and let me know what you think.

By now you all know the JPA 2.0 Criteria API : a type safe way to write a JQPL query. This API is clever in the way that you don’t use Strings to build your query, but is quite verbose… and sometimes you get lost in dozens of lines of Java code, just to write a simple query. You get lost in your CriteriaQuery, you don’t know why your query doesn’t work, and you would love to debug it. But how do you debug it ? Well, one way would be by just displaying the JPQL and/or SQL representation. Simple, isn’t it ? Yes, but JPA 2.0 javax.persistence.Query doesn’t have an API to do this. You then need to rely on the implementation… meaning, the code is different if you use EclipseLink, Hibernate or OpenJPA.

The CriteriaQuery we want to debug

Let’s say you have a simple Book entity and you want to retrieve all the books sorted by their id. Something like SELECT b FROM Book b ORDER BY b.id DESC. How would you write this with the CriteriaQuery ? Well, something like these 5 lines of Java code :

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Book> q = cb.createQuery(Book.class);
Root<Book> b = q.from(Book.class);
q.select(b).orderBy(cb.desc(b.get("id")));
TypedQuery<Book> findAllBooks = em.createQuery(q);

So imagine when you have more complex ones. Sometimes, you just get lost, it gets buggy and you would appreciate to have the JPQL and/or SQL String representation to find out what’s happening. You could then even unit test it.

Getting the JPQL/SQL String Representations for a Criteria Query

So let’s use an API to get the JPQL/SQL String representations of a CriteriaQuery (to be more precise, the TypedQuery created from a CriteriaQuery). The bad news is that there is no standard JPA 2.0 API to do this. You need to use the implementation API hoping the implementation allows it (thank god that’s (nearly) the case for the 3 main JPA ORM frameworks). The good news is that the Query interface (and therefore TypedQuery) has an unwrap method. This method returns the provider’s query API implementation. Let’s see how you can use it with EclipseLink, Hibernate and OpenJPA.

EclipseLink

EclipseLink‘s Query representation is the org.eclipse.persistence.jpa.JpaQuery interface and the org.eclipse.persistence.internal.jpa.EJBQueryImpl implementation.  This interface gives you the wrapped native query (org.eclipse.persistence.queries.DatabaseQuery) with two very handy methods : getJPQLString() and getSQLString(). Unfortunatelly the getJPQLString() method will not translate a CriteriaQuery into JPQL, it only works for queries originally written in JPQL (dynamic or named query). The getSQLString() method relies on the query being “prepared”, meaning you have to run the query once before getting the SQL String representation.

findAllBooks.unwrap(JpaQuery.class).getDatabaseQuery().getJPQLString(); // doesn't work for CriteriaQuery
findAllBooks.unwrap(JpaQuery.class).getDatabaseQuery().getSQLString();

Hibernate

Hibernate‘s Query representation is org.hibernate.Query. This interface has several implementations and the very useful method that returns the SQL query string : getQueryString(). I couldn’t find a method that returns the JPQL representation, if I’ve missed something, please let me know.

findAllBooks.unwrap(org.hibernate.Query.class).getQueryString()

OpenJPA

OpenJPA‘s Query representation is org.apache.openjpa.persistence.QueryImpl and also has a getQueryString() method that returns the SQL (not the JPQL). It delegates the call to the internal org.apache.openjpa.kernel.Query interface. I couldn’t find a method that returns the JPQL representation, if I’ve missed something, please let me know.

findAllBooks.unwrap(org.apache.openjpa.persistence.QueryImpl.class).getQueryString()

Unit testing

Once you get your SQL String, why not unit test it ? Hey, but I don’t want to test my ORM, why would I do that ? Well, it happens that I’ve discovered a but in the new releases of OpenJPA by unit testing a query… so, there is a use case for that. Anyway, this is how you could do it :

assertEquals("SELECT b FROM Book b ORDER BY b.id DESC", findAllBooksCriteriaQuery.unwrap(org.apache.openjpa.persistence.QueryImpl.class).getQueryString());

Conclusion

As you can see, it’s not that simple to get a String representation for a TypedQuery. Here is a digest of the three main ORMs :

(*) Only possible on a dynamic or named query. Not possible on a CriteriaQuery
(**) You need to execute the query first, if not, the value is null

To illustrate all that I’ve written simple test cases using EclipseLink, Hibernate and OpenJPA that you can download from GitHub. Give it a try and let me know.

And what about having an API in JPA 2.1 ?

For a developers’ point of view it would be great to have two methods in the javax.persistence.Query (and therefore javax.persistence.TypedQuery) interface that would be able to easily return the JPQL and SQL String representations, e.g : Query.getJPQLString() and Query.getSQLString(). Hey, that would be the perfect time to have it in JPA 2.1 that will be shipped in less than a year. Now, as an implementer, this might be tricky to do, I would love to ear your point of view on this.

Anyway, I’m going to post an email to the JPA 2.1 Expert Group… just in case we can have this in the next version of JPA ;o)

References

• http://efreedom.com/Question/1-6412774/Get-SQL-String-JPQLQuery
• http://old.nabble.com/Cannot-get-the-JPQL—SQL-String-of-a-CriteriaQuery-td33882629.html
• http://paddyweblog.blogspot.fr/2010/04/some-examples-of-criteria-api-jpa-20.html
• http://www.altuure.com/2010/09/23/jpa-criteria-api-by-samples-part-i/
• http://www.altuure.com/2010/09/23/jpa-criteria-api-by-samples-%E2%80%93-part-ii/
• http://www.jumpingbean.co.za/blogs/jpa2-criteria-api
• http://wiki.eclipse.org/EclipseLink/FAQ/JPA#How_to_get_the_SQL_for_a_Query.3F