Hi all,
We recently started to develop a Java desktop app and management has requested that we make use of Rich Client Platform. I know of three for Java namely:
Has anyone got any experience in any of these and if so what are the strength and weaknesess of each?
thanks
From my end-user perspective.
I've seen more implementations in Eclipse than in the other two. Actually I've know about Netbeans implementations but never got one in my hands.
From Spring this is the first time I've heard about it.
While my answer is definitely a super 10,000 ft view, it reflects somehow the preference the industry had had about using one or the other.
Also, the difference is proportional to the time the platform has been available. Remember Eclipse create SWT to solve the problems Java Swing had back in 1.3 where is was simply prohibitely slow.
Netbeans have been very beneficiated by the JVM improvements and now runs very very fast.
Spring is still young ( compared with the other two ) , but as always, the new things learn from the former, chances are it is simpler to use.
Here's an article about these two platform Eclipse RCP vs Netbeans RCP. May be helpful
http://blogs.sun.com/geertjan/entry/eclipse_platform_vs_netbeans_platform
While I haven't explicitly used any of them, I have used portions of the Eclipse RCP. Specifically, I've used the Eclipse OSGi runtime (Equinox) and some common utilities and I've very pleased. OSGi is fantastic to work with. I have several friends on large contracts which use Eclipse RCP (more than I use) and they rave about it.
If my project didn't contain a large mount of legacy Swing, Eclipse RCP would be my first choice. OSGi is just so much fun! (I imagine Spring uses it too, haven't checked though)
I have experience with the Eclipse RCP and would recommend it.
Pros:
Cons:
If you choose Eclipse RCP, defiantly get this book, it is invaluble when just starting out with the framework: http://www.amazon.com/Eclipse-Rich-Client-Platform-Applications/dp/0321334612
I recommend that you take a look at JSR 296 - it's not complete yet by any stretch, but I think it hits the sweet spot for providing certain core functionality that you really, really need in every Java GUI app, without forcing you to live in an overly complicated framework.
I have used JSR 296 successfully to create a mid-sized application. For window layout in this app, we use MyDoggy (highly recommended). For layout management, we use MiGLayout (Beyond highly recommended). For data binding, we use a modified form of JSR 295 (we implemented something similar to PresentationModel on top of JSR 295 that we use for our GUI binding). I'm in the process of incorporating Guice as a DI mechanism but haven't finished that effort (so far, I think it will 'play well' with JSR 296 with a tweak here and there). Let's see... persistence is the big missing link here - I am currently evaluating Simple for XML persistence, but am running into issues with getting it to work with DI containers like Guice. I have Betwixt working, but the dependencies on Betwixt are huge so we are looking for something more streamlined.
Opinions on other RCP options for Java:
NetBeans: I have some fundamental philosophical objections to the approach used by NetBeans (too many design anti-patterns for my taste). In the end, the framework forces you to make poor design decisions - and it's almost impossible to use if you don't use NetBeans as your IDE (I tried, but I just couldn't switch from Eclipse to NB). It's probably just me, but it seems that it should be possible to write code for an RCP framework without using big complicated wizards and reams of auto-generated code and XML files. I've spent so many hours troubleshooting old Visual C++ code generated by Visual Studio that I'm extremely leery of any framework that can't be coded up by hand.
Spring RCP: The folks at Spring have a good solid design, but the documentation is really, really weak. It's pretty difficult to get up to speed on it (But once you do, you can get things done pretty quickly).
Eclipse RCP: Haven't used Eclipse just because of the deployment overhead (depends on your target audience - for us, deploying an extra 50 MB of runtime just didn't work). Without question Equinox is a beautiful thing if your app needs significant plugin functionality (of course, you could run Equinox with JSR 296 as well, or use design patterns similar to the Whiteboard pattern promoted by OSGi).
Of course it all depends on the kind of applications and services you want to provide, and the target environment. But I can also recommend OSGi as a development and deployment platform. The underlying architecture and specifications are very well developed and proven.
Besides of the Eclipse RCP you should have a look at Apache Felix (http://felix.apache.org) and Knopflerfish (http://www.knopflerfish.org), which are (smaller) open source OSGi framework implementations.
Eclipse RCP provides plug-in mechanism so that you can add new features later on the deployment. Also via the update mechanism you can change the system without user interference. In the development phase, Eclipse RCP provides a fast, robust ground with perspectives, views, editors, command and action mechanisms. If your project requires many different windows with different toolbar and menus (and also custom context menus) I suggest you to use Eclipse RCP. I only check the videos of Netbeans Platform and run the Helloworld project but it seems slow and clumsy :) 40 seconds to start-up (you can reload the application though w/o restart.) vogella.de is a good collection of tutorials for Eclipse RCP
INTRO - skip if you're only interesterd in result ;)
I was developing an editor for a custom programming language very simmilar to JSP. First I've implemented the editor as my thesis using NetBeans platform. After finishing school I've got a job and they wanted me to implement the same thing in Eclipse RCP, so now I can compare these two platforms at least in stuff I was facing during this project.
RESULT - If I had a choice between Netbeans platform and Eclipse RCP, I would definitelly pick a NetBeans platform. Why?
Great screencasts, good tutorials, very active friendly and helpful community, quite well documented and the source code is written nicely and with good code conventions. Also has some interesting gadgets (cookies, lookup). It simply suits me.
And why Eclipse RCP does not suit me?
The documentation is weaker and conventions and API are sometimes..ehm..too weird for me :-) It's quite ususal to see methods like:
/**
* Returns a description of the cursor position.
*
* @return a description of the cursor position
* @since 2.0
*/
protected String getCursorPosition() {
..
}
Well I thought they must be kidding me :-D How am I supposed to use this method? Or like this:
/**
* Returns the range of the current selection in coordinates of this viewer's document.
*
* @return a <code>Point</code> with x as the offset and y as the length of the current selection
*/
Point getSelectedRange();
Although the number and type of attributes fitts, I don't find the Point object ideal data structure for storing range ;-)
There are numbers of theese such surpises in Eclipse RCP
I'm currently developing a Spring RCP application. The documentation is really weak, that's for sure, but the blogs and forum have a good amount of information to get going. Once you do get cruising, things do move fairly fast and you really only need to learn basic Spring if you aren't familiar with the framework. The integrations with Spring libraries such as VLDocking is excellent too.
I think Spring Rich is great if your use case is to develop a standalone Java desktop application. What I mean by that is if you don't need to distribute modules and do online updates then it should fulfill most needs.
Too late to answer, but some guys might hit this page.
I would go for Netbeans RCP, 1)Netbeans platform. its quite mature and has evolved is a 'easy to use' platform for developing applications.
2)Its very easy to get started with, whereas the learning curve of eclipse RCP is pretty steep. Just goto, http://netbeans.org/kb/trails/platform.html, there you will tutorials, videos(do watch the top 10 api's videos plus try out tutorials before you read books, that way you will get a hang of things beforehand).
3)Books on netbeans RCP (i guess there are 2 on netbeans RCP) are uptodate (small changes only which you wont have much issues with). whereas the main book on RCP wasn't available for a long time (recently .that is, may 2010, the new edition has been released, so that's a very good thing for eclipse RCP developers. It wasn't there when i was trying to learn it. I get frustrated with authors who don't publish new editions, almost leaving new developers in lurch. Not everybody likes to read docs. Not publishing updated books almost amounts to killing the technology). I would love to see a cookbook type book for both platforms.
4)Netbeans has full integrated GUI builder, which is big plus. Eclipse RCP, either you have to hand code or buy some third party GUI builder.
5)Netbeans platform has this pretty cool Lookup api for intermodule communication. I guess eclipse guys use extension points for this purpose. But lookup api is easy once you get a hang of it.
6)Anyways, its a big design decision, about which platform to choose. Netbeans platform works for me. It may not work for you. Both platform require efforts, both provide wonderful 'out of the box' features. Test drive both and then decide.