We are no Maven lovers, because it helps to forget how things work. But we think the dependency management is useful. It's great for developers who need specific library versions without managing them manually.

The user aspect is one thing, but nobody tells you that it's not trivial to release libraries. One problem is the pre-deployment process. Before you are able to deploy your jar files, you have to do a lot of things like GPG key generation, publishing GPG key, find the right repository, prepare your build, special pom cration and so on.

If you already have release builds with version numbers, javadoc and source archives, you'll save a lot of time. If you don't have complete and clean release builds - see you later.

Let's start with a good documentation about requirements:
https://docs.sonatype.org/display/Repository/Sonatype+OSS+Maven+Repository+Usage+Guide

Of course, it assumes that you'll use Sonatype as your repository, but all others are not too different.

This posting is not a complete documentation. It simply shows the problems we had.

Our simple pom files:
pom.xml (jvxall)
pom.xml (jvxclient)

The first is with dependencies and the second without, because our client doesn't have dependencies.

The real problems started with the integration in our ant script, because the documentation of Maven plugins were awful. It's easier to read the source code than to find out how plugins work. One example: Read following plugin documentation and tell me the valid values for "types" and "classifier". There are no examples on the page! Google around and copy/paste a little bit - awful!

Here's a working ant call

Above call submits e.g. jvx-1.1.jar, jvx-1.1-javadoc.jar and jvx-1.1-sources.jar to the repository.

Why one call instead of 3 separate calls, as described in the documentation?

Short: It's better
Long: It's better to submit all dependent files in one "maven session". Above call creates a new maven project and if you call this command per file, there's no logical connection between them. If you plan to deploy snapshot releases - forget it - it doesn't work with different calls because every upload gets a new buildnumber. But all files need the same buildnumber! Such deployments can't be used. If you read the Sonatype document, you saw that "deploy" task didn't deploy javadoc and sources! The "stage" task did. I'm not sure, but I think they had the same problem with separate uploads! Trust me, above call works with snapshots and final releases.

Our naming conventions

(${maven.version.postfix} is -SNAPSHOT for snapshot releases and empty for final releases)

Repository Id, URL

${mvn.id} = sonatype-nexus-staging
${mvn.url} = https://oss.sonatype.org/service/local/staging/deploy/maven2

Other problems?

Proxy settings for Maven, Use an external GPG key, Autentication.

If you copy the following settings.xml to <users.home>/.m2 and modify it to fit your needs, it should solve all problems:

We configured the proxy via ant build.xml

Simply add "proxy" task as dependency of another task.

Maybe it's easier to release libraries with other build systems or maybe it works out-of-the-box with Maven itself, but the whole process is really bad.

Good luck!

We now provide our JVx nightly via Maven Snapshots. Our nightly build job automatically uploads new JVx snapshots. If you want to use the last JVx snapshot in your project, simply add:

to your pom.xml and set JVx' version to: 1.2_beta-SNAPSHOT.

If you use our new JVx archetype 1.1.9, simple change the version in the master project:

All SNAPSHOT versions contain debugging information. The release versions don't.

We tried to find a simple solution to convert MS Office files to pdf, without online services. We tried OpenOffice but the results were awful! There are a lot of free, and commercial, PDF printers available. But they are for desktops and a user has to print manually. We wanted a solution that works without user interaction.

There is a very useful open source project called PDFCreator. It also is a printer but has a useful API. The API is available via COM, which is not the best technology for Java, but it's also not bad.

We didn't find a ready-to-use solution for our idea and it shouldn't cost money. The solution had to be open source. We found some great commercial tools and SDKs but all of them were not cheap.

We spent some hours and used PDFCreator, Jacob and some other open source tools to create an "Online service for PDFCreator". The result of our work is toPDF.

What is toPDF?

It's a small library that allows conversion of files to PDF, via PDFCreator. It's also a web application that offers services for remote conversion via http. The application has a REST service and a simple servlet service.

Simply POST binary data via http request and receive a PDF in the response. The servlet supports multipart form-data and simple application/octet-stream as requests. The REST service also supports multipart form-data but also JSON requests.

A short example:

or as Multipart:

The conversion via PDFCreator works great, but not perfect. There are different problems with small page margins in Word documents, problems with OpenOffice documents, ...

The problem is not toPDF, because it works as good as PDFCreator does. If PDFCreator doesn't convert a document, toPDF has no chance to convert it.

We had problems with simple image conversions to PDF because default windows print dialog appeared and we didn't associate image extensions with another tool. We solved the conversion of images with iText instead of PDFCreator. Now it's possible to create PDFs from images very easily without pop-ups.

License?

AGPL 3.0, because PDFCreator is licensed under GPL and iText is licensed under AGPL.

Used tools and libraries

toPDF is a mixture of different open source projects:

PDFCreator
iText
RESTlet
Jackson
JVx
Apache commons FileUpload and IO
Jacob
PDFCreator4J

Installation?

• toPDF was written in Java, but the installation only makes sense on Windows (same requirements as PDFCreator)
• Install PDFCreator (default desktop installation, with COM)
• Deploy topdf.war on Tomcat or JBoss or your preferred Java application server. If your application server runs as windows service, be sure that it runs as OS user.

We have more class diagrams for you. They should help to understand how JVx "thinks".

The first one shows the persistence (server-side):

JVx Persistence

You work with our generic model (client-side) to access data:

JVx Generic model

and use conditions to filter data:

JVx conditions

And the last one shows the application architecture with JVx' default implementation:

Application

We got a lot of requests regarding a JVx UI class diagram. We didn't have one, because we thought that our javadoc is a good starting point. But you need it, and here it is.

JVx UI

Our new UI implementation for JVx is code complete. We did implement all necessary JVx interfaces and many cool features. Compared to our old web UI, based on GXT (extJS), the new one is back to the roots - back to Java. We use Vaadin 7 as rendering engine and are happy with the Apache 2.0 license.

The old web UI didn't have a tree implementation and the chart engine was based on Flash. Our new JVx Vaadin UI has a tree implementation and it supports Vaadin charts. Oh and another cool thing is the out-of-the-box support for mobile devices. This wasn't really cool with old web UI.

I wanna show you some screenshots with a really cool JVx application:

Charts

Tree

The application is a JVx application but with some CSS.
The same application - as desktop version, looks like a standard swing application (started with Swing launcher):

Charts (swing)

Tree (swing)

We didn't change the source code of the application to run it as Vaadin application and as Swing application. The only difference was the configuration via web.xml for Vaadin and start parameters for swing.

The source code of JVx Vaadin UI is available, but we need some time to review the code before we release the binaries.

Most of you know JVx as a full-stack application framework. You use it for creating backend applications or for your ERP applications. It offers different UI implementations for Desktops, Mobile Devices and Web Browsers. It has so many productivity features and now there is one more:

Yes, you read right - a whole application!

How it looks like?

JVx as Vaadin Portlet

It's not a fake, it's the well known Contacts screen from our Showcase application. We didn't change the source code to run the screen as Portlet! As you can see, we didn't use menus or toolbars, only one screen. A Portlet should be simple because Liferay offers menus and site navigation.

How it works?

Use your existing application, bundle it together with JVx.vaadin and configure the Portlet Launcher in your deployment descriptor. You need some additional configuration files for liferay, but there's no difference between your current Portlets and a Portlet for a JVx application.

Everything you need is Open Source and released under Apache License 2.0, but we don't have detailed documentation at the moment. Support us with your contribution!

Boost your productivity

If you develop a lot of different Portlets for your customers and won't waste time for XML file creation, simply use VisionX. It has a WYSIWYG UI editor and creates your database model on-the-fly. It is your pain killer!

It offers Liferay Portlet creation with 4 mouse clicks. Don't create everything manually and save time - Use VisionX!

VisionX Screen Design

We've used VisionX to demonstrate the creation of above contacts screen. We spent 5 minutes to create a complete application, with database model, user management and Liferay Portlet deployment. We were amazingly fast!

Every Java developer heard "Write once run anywhere" more than once. But exactly this is what JVx stands for.

Write your application only once and run it on your desktop, as Java application in your browser, as Java Webstart application or as HTML5 application in your browser. Oh, and why not... run it as native application on your mobile devices. Everything is possible and was successfully tested with JVx.

As a rule, don't create more than one application for all that platforms. And there's no need to change your source code, to run your application on one or all of those platforms. One code base for all platforms!

If you'll create a simple application, it will look like one of these:

JVx SwingUI (Browser)

JVx SwingUI (Desktop)

The left screenshot shows a JVx application started as Java application in your Browser. On the right is the same application as desktop version. This was cool some years ago, but isn't nowadays - isn't it?

Nowadays you need a modern web application that runs in your browser without plugins.

We don't think so, because web UIs should be simple and clean.

What do you think about following screenshot:

JVx VaadinUI

Trust me, it's not a fake. It's the same application as above, but started with JVx' VaadinUI and a different application style. Isn't it amazing?

Are you curious? Interested in other screenshots?
No problem:

Contacts

Application Login

(Thanks to Vaadin Dashboard demo application for the inspiration)

I'm thrilled and what about you?

As I told you, all screenshots were from the same application and without code changes! This is possible because of JVx' single sourcing principle. One great feature and a big advantage of JVx is that it doesn't hide the underlying technology from you. If you want use technology specific components or features, just do it. But be aware, if you use technology dependent things you should check the technology first, to be still technology independent and avoid problems!

Sounds confusing?

A simple example should explain what I meant. In our example we'll show a standard Vaadin window in our application.

We are still technology independent but above code only works with Vaadin! You always have access to the "real" resource via getResource() but the returned object dependes on the used technology. In our example, the UI.

Another example of technology mixing, directly from our Vaadin integration:

We created a Menu with JVx and added the menu to a standard Vaadin VerctialLayout. The advantage is that we can use JVx' event concept instead of Vaadin' listener concept. How?

Did you see following statement:

This means every click on the menu item calls the method doShowChangePassword of object this. If you want the same result with Vaadin listeners, you have to do following:

Technology mixing works in both directions. It's so great!

One of the best features of JVx with Vaadin is the usage of CSS. It has never been easier to style your application. Set CSS directly via css file or programmatically via Vaadin API.

Expect amazing results!

Wow, what a title

Some weeks ago, I blogged about JVx with Exchange servers. The project now supports Appointments and Tasks.

To demonstrate some features, we created an application that integrates powerful frameworks. We took Vaadin with Calendar AddOn, JavaFX' webview and integrated all together in a standard JVx application.

Take a look:

JVx + JavaFX + Vaadin + Exchange

Did you notice that the calendar is a JavaFX WebView?

Our exchange storages still use the EWS Java API but now with some tweaks.
More information will follow in other posts...

I'm happy to show you first impressions of our upcoming Vaadin UI for JVx

What is JVx Vaadin UI?

It's cool. It's modern. It's fantastic. It's the replacement of our GXT WebUI and it's back to the roots - back to Java.
Simply use your existing JVx applications and use Vaadin as UI technology.

Not clear enough?

Develop your application with JVx and start the application as Desktop application with Swing or simply run the same application with Vaadin. There's no need to change your application if want another UI technology!

GXT WebUI vs. VaadinUI?

The big difference between our existing WebUI (based on GXT) and Vaadin UI is that you can extend your application easily with Vaadin AddOns, if you want. Use the whole Vaadin universe to enrich your web application, but use JVx to be UI technology independent. There's no need to code JavaScript.

The license of Vaadin is great for business applications and 3rd party extensions.

We'll post more details about our Vaadin UI, but now it's time for some impressions. We used our good old showcase application with a picture of Hans:

JVx with Swing

JVx with Vaadin

Above images show exactly the same JVx application. The Vaadin version still looks like a desktop application and we're planning a new application style for web applications because MDI is not really cool in browsers...