I would like to create a search application connected to a RDF/OWL database on Eclipse. I would like to use the Google Widget Toolkit plugin for the front end and the Protege plugin for the database side. Do I need some other "essential" tool for creating this application?
In additional to GWT i can recommend you Vaadin, for actually searching Lucene can be useful. And of course look at Spring Framework and Groovy for rapid development.
Give us more information about what you supposed to create?
If you come from java GWT will feel instantly familiar. For the front end It abstracts away most of the quirks of java script development.
In your case I would concentrate on the RPC asynchronous way and how will you transport data to the front end / serialization deserialization. GWT offers many different approaches you need to find out which solves your problem best.
Related
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.
I´ve been developing web appplications using Microsoft technologies for a long time, but now I´m been asked for building a VERY BIG application on a Java Web project. For some reason, I´m being forced for using GWT as the front-end; I´ve read some comments about it where some people says that is not the best option for big/enterprise applications (In this case, is something almost as complex as an ERP). Another requirements are: allow connecting to multiple databases, using a technology for rapid development and having a low performance cost (users don´t like to wait for pages to load)...
So the questions would be:
- Is GWT the best option?
- If so, what´s the best back-end (Java technology) that we can use? I´ve read that it could be Groovy, Spring Roo or JSF.
- Should I user Hibernate, or creating another light-weight option?
Thanks in advance
GWT is a serious framework no matter if it's used for big or small project. Before committing to GWT you have to realize that:
it's a client(browser)-based technology
it's a translation layer from Java to JavaScript where JavaScript development is either eliminated or reduced to a minimum
it's capable of integrating with server (middle tier), especially well with Java-based ones no matter what technology it uses: JDBC, Hibernate, GAE, proprietary, etc.
it's tailored toward Java/desktop developers so expect steep learning curve if it's not your background
it requires fundamental understanding of MVP (variation of MVC) frameworks
it requires familiarity with JavaScript browser technology
big projects with GWT will require using supporting frameworks like GWT MVP, Guice, gin, gwtp, etc.
The good analogy would be Swing or Eclipse RCP. They offer rich GUI desktop development platform while integration with variety of server-based technologies. But the target platform for GWT is a JavaScript-enabled browser, not a desktop.
GWT is a very capable platform and is fitting for projects of all sizes especially since 2.1. The Google Wave team helped the GWT develop APIs and practices that really help in using GWT for large projects. As far as coming from a .NET background it may be a steep learning curve at first, but Google's getting started guide for GWT is a good place to start and you should be able to hit the ground running. One thing that people often forget is that GWT is actually just a compiler that emulates portions of the JRE and in the end it is all just HTML, CSS and Javascript.
For back end technologies there are many options, but there are actually 2 decisions you must make. First you will need to decide on a web/communications layer. The way I see it you have 3 main options for the type of communications before we even get into implementations: GWT-RPC, REST(XML or JSON), or SOAP. I prefer REST with JSON however, if you have no need to expose your services outside of GWT you may be better off with GWT-RPC. If you choose to go with REST or SOAP you may even choose to not use a Java back end but instead use .NET to stay in your comfort zone. To do this I would write an XSD to describe your data model and use .NET to persist and expose your data as JSON via REST. You can then use JAXB to generate a Java representation of those classes for use in your GWT client however you will have to strip out all of the XML annotations and modify them to work as overlay types.
Secondly you will need to decide your persistence layer. Many prefer Hibernate, but I prefer JPA, either will work great for enterprise level applications. The advantage to using a Java back end with GWT-RPC communications is that you can use the RequestFactory with EntityProxy so that you only have to maintain one version of the object from the client through the persistence layer.
First you can't use JSF for back-end
i suggest you to use hibernate for back-end
and jsf for front-end especially the new version jsf2 with the power of CDI
and i recommend you to use Richfaces , Primefaces as lightweight jsf components
and also Seamframeworkas development platform
if you use it i think you will have the most powerful java web technologies
GWT can serve you in big project but it may take double time comparing
with JSF
but if you like GWT you should
Have a look at Vaadin
I have a really simple J2SE app that consists of a couple of classes. I plan to make it available to my co-workers, and I've been thinking the easiest way would be for them to access it from a browser, instead of distributing the executable on each machine.
What's the easiest method/framework that would allow me to do this? This app is pretty targeted-- it will just perform the same isolated operation, and will have some activity against the DB --but the logic is already implemented on the app. The interface would only require some input from users (login,password,ip,etc), an action component to trigger the process and nothing else.
I've been thinking of a simple JSP/Servlet app for it, but wanted to see what's available now. If any how-to link is available, would be great.
Axis allows you to to create web services from existing java classes. But this may require writing a desktop client.
Grails framework can use existing java classes and is easy to use. It follows MVC pattern similar to Ruby on Rails.
If you don't need anything complex, and you're ready to to write html with System.out.println() thenjust write a simple servlet. There are many guides online, it's very straightforward.
If the application is simple, then use simple JSP/Servlet, otherwise MVC framework(Struts...) could be used here. But using MVC framework leads learning curve.
It's kind of trade-off: you could decide the learning curve is worthy or not in your application.
There are zillions of Java web application frameworks.
95% were designed before the modern era of AJAX/DHTML-based development, and that means these new methods are grafted on rather than designed in.
Has any framework been built from the ground up with e.g. GWT + Extjs in mind?
If not, which framework has adapted best to the world of forms with dynamic numbers of fields and pages that morph client-side?
Echo2 / Echo3 by Nextapp (www.nextapp.com) is totally awesome.
Advantages over GWT:
1) It is not limited to a sub-set of java like GWT
2) It is easier (in my estimation) to learn
3) Has extremely robust design studio for almost drag and drop designing.
4) It is very fast, and works very well on all platforms browsers
5) You can write your application using either java script or java
6) It has great and straight forward methods for handling events and actions.
Personally I think that for any web-application in which you are trying to integrate java and speedy delivery I wouldn't hesitate to pick Echo3 or Echo2.
If you're starting from scratch. I'd have to say Google Web Toolkit. I have to say it is incredibly powerful. You get keep using most of your Java tools. Plus, you don't have to duplicate code that exists on both the server and the client, it just gets compiled differently for each area.
I'd consider REST-style frameworks as well as the other recommendations here- Restlet or Jersey may be good choices for the backend, while you use something like JQuery or GWT on the front end. Both frameworks can easily produce JSON, and the REST style provides a nice clean line of demarcation between your client application and your server source; I find that JSF can make that demarcation pretty muddy.
I use JSF and IceFaces. Although JSF has a few limitations, IceFaces seems to work pretty well and has ironed out a few of the problems with JSF.
I haven't used a really good AJAX Java framework as yet, although Echo2 looks interesting.
I like the stripes framework. It lets you use whatever javascript toolkit you want.
Here is their documentation on AJAX
GWT is quite powerful and easy to use (all Java, no Javascript/HTML/CSS coding). If Google has their way it will be a dominant framework/tool in web applications development, and for good reason. It already works with Google Gears (which allows offline access to web apps) - and more than likely will be optimized to work within Google Chrome.
DWR
I use this to dynamically populate drop downs, and even filter them on the fly based on user input in other places on the form.
I like the combination of JBoss Seam and Richfaces, especially with the JBoss tools that are extentions to Eclipse - makes building these sort of RIA's incredibly easy.
Wikipedia contains some useful comparisons:
Comparison of JavaScript frameworks
List of AJAX Frameworks
Your choice depends on several different factors including whether you want the "work" done client-side (most javascript frameworks) or server-side (echo2 etc.). Other things worth looking at are tools like OpenLaszlo that provide Flash (I think) out of the box, but drop back to DHTML if there is no Flash player present.
Unfortunately I think the decision comes down to balancing several competing cocerns. Check out the comparisons and try them out - most come with online demo's for you to try.
Aptana has a server side frame work called Jaxer. This is from their site:
Jaxer's core engine is based on the same Mozilla engine that you'll find in the popular Mozilla Firefox browser. This means that the execution environment you use on both the client and the server are the same. It's Ajax all the way through and through. That means you only need one set of languages -- the languages that are native to the browser -- to create entire applications.
This framework is open source and has a very nice IDE based on Eclipse. Aptana is also working on a Javascript implementation for ActiveRecord called ActiveRecordJS. Potentially you could use this both client and server side with their framework.
GWT is one of the best AJAX framework that I used ever. Most important thing about this framework is that its maintained by Google. And Everyone know "Who is Google ?"
GWT is used by many products at Google, including Google AdWords and Google
Wallet. It's open source, completely free, and used by thousands of
enthusiastic developers around the world.
GWT provide rich widgets that can be used to built any application. Almost all the widgets they have.
Another important point is GWT is continuously developing and its also have stable release which is very good thing. Another thing Google has also released GWT-Material which is again a very good thing because everyone is moving toward material.
I hope this will help you!!!