We have a Java server application using a message based communication passing around strongly typed complex POJO messages. Our regular client is a rich-client Flex application that has a very heavy art and UI development process that doesn't lend itself to rapid prototyping.
We are planning on building a Java UI to test server functionality, currently we have been testing our backend Java server using a console based client using basic commands. The reason we need it in Java is because the messages we are passing around are strongly typed complex Java objects (integrating in any other language requires parsing custom JSON which we are building a code generator for Actionscript to ease this pain).
The issue with using the basic console client, is we're developing a new application where state is being tracked across multiple messages, and simple text console output doesn't make sense we need a more complex UI to show results.
What tools are there for rapidly building a rich client Java UI for use by developers to quickly add new UI's to test a Java backend?
Coding Swing and UIs by hand sucks.
I've looked at Eclipse Rich Client Platform and it looks promising but I'm concerned that the learning curve, and the ease of adding a new UI to test server functionality is not going to be easy. Is there like a light-weight Eclipse RCP, I wouldn't be against having a small subset of developers working on the core Eclipse RCP application while day to day work can be done in a simple rapid-prototyping environment that will easily integrate.
Some Java UI technologies I've been looking into (has anyone had experience rapidly prototyping UI's with a low learning curve for server developers).
Spring RichClient
Groovy Swing Builder
Eclipse Rich Client Platform (RCP)
If you prefer Flex;
Try spring with blazeds
Test it with flexunit
or JSF;
simple jsf design connect to managed bean (mix with spring) and managed bean connect to your service layer ....n
Test it with jsfunit.
You can test it selenium also.
or Swing;
Design with Swixml or Thinlet ((these are remind mxml)
P.S: Don't waste your time to design nice ui. You can do it later. Functionality is important than good looking. Later CSS do it for you. I repeat this, by myself :)
Really, if you are going to use Swing, your developers are going to face a learning curve. Groovy SwingBuilder and similar libraries are just DSLs that cut out a lot of boilerplate and repetitive code. SwingBuilder certainly saves time (and is more elegant than pure java), but really the complex part of using Swing is dealing with the underlying framework.
The NetBeans Swing UI builder (Matisse) is really nice if you want drag-and-drop Swing development, but you still have to be pretty familiar with Swing if you want to understand how to hook everything together.
Related
I have a complete and pure Java project (GUI game) which I want to run it on my website.
What is the best to do without creating the whole java project from scratch or is there any technologies I can use to embedded my java project on my website.
I know it became more difficult to do this as most broswer do not support java anymore. I know there is a way to do using Java Web Application using Apache Tomcat, but I do not want to do route. I am trying to find more easier and better to solution to this
Thank you
Unfortunately, It is quite possible that you need to rewrite some parts of your application. Mainly because it is a different language (I assume SWING, AWT, or another Java-based library, but you could tell more about your project and used libraries).
There is usually two parts of a game/application (super simplified):
backend,
frontend,
I am quite sure you can use most of your backend code. But the frontend probably needs to be rewritten. It is even better if you loosely coupled those two parts meaning there is no code in the backend for the frontend because you will have a harder time now breaking it down.
For example, you could check Vaadin and see what you could use from there to refactor your GUI application to be work on a plain browser.
Vaadin basically lets you write only or MOSTLY Java code and still create a website, webpage.
Good luck!
p.s: Next time I recommend you (if you wanna publish it to a different platform) a cross-platform language, you write once and you can run it publish it on multiple platforms.
Any there web application frameworks without needing to write HTML/UI?
I want to develop a web application from end to end but I am not familiar with HTML/UI, so looking for a Java based framework or tool which generates UI/HTML code automatically without actually writing HTML code (like Eclipse's UI designer plugin).
So can anybody suggest if there are there any tools/plugins to do that?
There cannot be a single correct answer to this question and I agree with the initial comments. However, three technologies that came to mind instantly:
Google Web Toolkit, GWT
Vaadin (based on GWT)
Sencha Touch, you'd have to be familiar with JavaScript though
You can also use the tools such as WYSIWYG (i.e. What You See IS What You Get).
Where without knowledge of ui you can still design ui.
I'm working on a client-side Java application for which I want to create a web-based user interface (which will be served up to a browser from the local app). At the risk of oversimplifying, its a microblogging tool that will support functionality similar to Twitter and Facebook. Its open source, and you can read more on our wiki.
Its important that this app is extremely easy to use, and I also want it to look good relative to contemporary web applications (such as the examples available on the Chrome web store). Since I am not a web designer, I'm hoping to use tools that give me an attractive UI "out of the box". Oh, and I need to keep the distributable file reasonably small (un him so whatever I use needs to be reasonably lightweight.
So far, I've looked at Sproutcore and GWT.
Sproutcore apps definite have the appearance I'm hoping for, but I'm not that familiar with JavaScript, and after some experimentation is not entirely clear to me how I will achieve some of the more sophisticated functionality that I think I'm going to need.
Being Java, GWT is more within my comfort zone, however I had a hell of a time just getting my development environment set up properly. It seems that GWT wants to dictate the structure of my application, but since the user interface is only a small part of it I'm not willing to build the entire app around GWT.
Something else I've been thinking about is using CoffeeScript (which seems more palatable him and him him him him him than JavaScript, and there are Maven builders for it), perhaps together with JQuery-UI.
What other options should I consider?
To recommend two big javascript frameworks Sencha and Cappuccino.
These have an extensive UI toolkit out of the box. The latter has an MVC framework build in, the former has a general JavaScript library build in. Both come highly recommended.
Also as recommended jQuery UI is a reasonable toolkit. I would personally couple Sencha for its rich UI toolkit and a lightweight MVC framework like Backbone. I'm afraid this does require learning JavaScript well.
You can also instead drive your JavaScript UI toolkit mainly from the server and skip the clientside MVC. For that sencha should surfice as a UI toolkit, but if you want meaningful functionality you will need some more structure. I would also recommend RequireJS for modular file management.
Take a look on Vaadin its based on GWT but simpler to use. I use it since 2 years and i'am not a designer too.
Take a look at jQuery & jQuery UI (jQuery Modile if you are looking to deploy to hand held devices)
Also, since you mentioned that you are not a designer, you might want to implement the front end in an MVVM pattern to separate the UI from the business logic of your applications. Knockout is a nice way to do with with decelerative data binding
I don't like writing plain JavaScript, so I'll tell you little bit about Java based frameworks. Recently, I've picked Google Web Toolkit.
Pros:
plenty of materials
Eclipse + Google plugin
Very intuitive API
3rd party libraries
Fancy widgets + optimized JavaScript
lot of generics
very active community
awesome async callbacks
Cons:
very slow debugging, that will drive you mad sooner or later
lot of deprecated code for so young framework
Mixed feelings:
You don't have to write declarative UI (you can do Swing-like development), but your code grows bigger and less maintainable, so it is quite probable that you'll eventually learn some declarative UI like UI Binder
Visual designer for GWT is somehow nice, but very unstable (eclipse) :(
Some considerations:
Do some prototyping with Vaadin. Try some debugging. Then try GWT and debugging on similar sized project. Consider debugging as the VERY important decision factor, because GWT debugging was the most frustrating thing for me.
Consider JSF + some nice rich component framework for JSF like RichFaces, IceFaces, PrimeFaces etc (but you app won't be "light" and "small" anymore if you really care). Be sure to be perfectly comfortable with environment (IDE + plugins), nothing beats JSF there (I'd pick RichFaces + Seam today, if full Java EE is option).
If you don't want to learn javascript I recommend you GWT with Sencha-GWT (GXT), you can develop all your app in java language, and also debug your code in java.
It is very easy to create a web app with this technology, and provides almost all funcionality available in javascript version.
Also you can mix it with hibernate and giled to persist your data, and giled helps you to serialize hibernate objects.
I have been writing an application in SproutCore for the front-end and a Java backend. In my mind this works perfectly.
The backend can stop worrying about HTML and JavaScript contents on the client side, if the request is XHR or plain request/response. I can implement the backends using plain old Java Servlets, and only worry about the data that is passed between the client and the server (JSON for the most part).
The client becomed fast and responsive, and SproutCore has a rich amount of components that you can mix and match.
So in other words with SproutCore (and Cappuccino and other full-blows MVC JavaScript frameworks) you can let your client do what it does best : Render and display HTML, CSS and JavaScript, while leaving your server to worry about what it does best: retrieve, store and update data. If you are interested, the source code for this project is available with the GPLv3 licence: https://github.com/joachimhs/EurekaJ
I have written an article about the differnt approaches between server-side MVC and client-side MVC here: http://haagen.name/2011/05/24/The_RIA_MVC_Model.html.
Also SproutCore comes with the MIT licence, so its avaiable for use without (m)any restrictions.
The application that I would like to revamp is pretty well organized. UI is separated into a module. UI controllers implement the interface PropertyChangeListener. When other modules want to have something happened in the UI they just fire PropertyChangeEvents on UI controllers not being aware what is behind them. Current implementations of injected PropertyChangeListeners could be easily replaced with Griffon controllers implementing the same interface.
Calling Java methods from Groovy is not a big deal so the communication from UI to the rest of the application shouldn't be a big deal.
Are there any tutorials or written down experiences with porting UI modules written in Swing to Griffon framework?
Unfortunately I don't think there is anything for going from legacy Java Swing to Griffon. A project I was working on last year was in a similar state. At the SpringOne2GX conference I asked the Griffon authors about using Griffon from a legacy Swing application. They said that right now unfortunately Griffon was for greenfield applications only. This is something they hoped to get to but to my knowledge is still not possible. This was as of September 2009.
You might be able to get something to work but I think you would be the one writing the tutorial on how to do this.
In the upcoming Griffon 0.9.1 you can write model/view/controller artifacts with pure Java.
So, maybe it will be a good start point to port your application to Griffon.
Check out details here http://docs.codehaus.org/display/GRIFFON/Griffon+0.9.1#Griffon0.9.1-NonGroovyArtifacts
I've looked breifly into GWT and like the idea that I can develop in Java and have the application compile down to HTML and JavaScript. Is the concept behind GWT and AWT and Swing the same or different?
It is programmed very similarly(patterned after Swing) and the code is 100% java (compiles with a standard Java compiler without errors), but the way it works is very different. Instead of compiling into a Java app, it compiles into Javascript that is sent to your browser.
This ability to program good active Javascript without actually coding Javascript and HTML is pretty nice.
Also, since it programs much like swing, you can do stuff like adding listeners that effect other controls pretty easily.
GWT is very much similar to Swing in its usage of Widgets, Panels and the EventListeners it provides. A different way to look at GWT is to think of Javascript and HTML as Assembly language and GWT as a sort of High level language which generates Javascript and HTML. With GWT its easy to develop desktop-like apps for the web using the same tools you would use for building a desktop app
Define concept.
AWT/Swing are used for desktop Java apps or applets. They both require JVM to run.
GWT is used to translate Java code to Javascript. This only runs on Javascript engines, i.e. browser.
The API design, as stated above, is similar to Swing. You get the same Panels, Buttons and other Component classes as in Swing.
AWT and Swing are for programming stand-alone applications (and to a lesser extent, applets). GWT is supposed to make programming web applications similar to stand-alone apps. I wouldn't program a non-web app using GWT.
GWT is conceptually similar to Swing, but is more a replacement for JSPs than anything else.
GWT is a javascript toolkit that allows you to write the javascript in Java. The only real similarities to Swing and AWT are that they are toolkits for creating user interfaces and they use Java. The end product is different and the real purpose for using them is different. GWT gives you the ability to generate a ajax user interface for a web browser while the other 2 give you a console (or applet) java app. In my mind the real reason for using GWT is to get a quick ajax interface up for prototyping purposes. But I dont think its really production ready- ie I dont thing Google uses it in their own webapps. A better choice for more robust ajax webapps is http://developer.yahoo.com/yui/ or http://script.aculo.us/.
disclamer: While I do work at IT Mill, this is just for information to the original poster. This isn't marketing spam.
If you like the idea of being able to write Java and get a webpage out of that, you might be interested in IT Mill Toolkit. It's a toolkit for making RIA software on top of a J2EE stack, and it uses GWT heavily.
One of the basic ideas are that the code generated by GWT is just as prone to client-side forging attacks as any other JS/Ajax-traffic. IT Mill Toolkit makes sure that the data is validated server-side too.
The toolkit is also designed in such a way that if you are familiar to Swing, you should have no problems picking it up.