As I mentioned on my previous post, I'm now coding my Actions on
WebWork using JavaScript. I think this feature has been available on
WebWork for a long time, but I found so few documentation about it I
thought I needed to do something about it. So, here goes my lame and
highly irresponsible HOWTO. Hope you enjoy it, and if there's something
wrong in it, please and correct me. Feel free to be rude or whatever -
I need to know more about the subject, badly :)
In the current 1.3.0 version of WebWork,
you can code your actions using Java, JSP or JavaScript. I've seen lots
of people using the first two ones, but nobody using the latter one.
First, allow me some time to explain the good, and - I'm sure there are
a handful of them - the bad points of using this approach.
Good:
Very easy to develop and prototype code
Cheap JavaScript professionals on the market just waiting to get
their hands dirty on something that's not a broken browser
implementation of JS
Dynamic typing - no more parseInt(), toString() and the like
Functions are first class objects, so you can have fun with some functional programming coolness
More flexible arrays
Global variables - yeah, they're a good point, when you're writing small scripts instead of OOP code full of bureaucracy
Syntax very clean and similar to Java, so most of the code is instantly readable by any Java developer
Lots of good documentation on Java and JavaScript integration
No typecasts ;)
Bad:
Performance hit, although minimal, as Rhino (the interpreter used internally by WebWork) does its job well
Those cheap JavaScript professionals often don't know OOP, so expect to lose some time on code reviews and giving some training
There are some dark corners, both on the language and on Rhino's implementation, and you'll need to be aware of them
Little debbuging support (that applies only to the WebWork
implementation, not Rhino in general). I'll have to investigate a
little more on this; I may be wrong here
Still, it's not (J|P)ython, and the language, in comparision, is
very poor. Python can get a lot less readable for a Java developer,
though (don't believe me? Try figuring out what this does at a single
glance: [x(y[z++:1-z]) for x in y], and I'm sure you'll be puzzled for a few hours, while you read the Python manuals)
It's kinda kludgy to make JavaScript objects accessible in Java,
but I can understand that, and I'm sure the Rhino guys did their best,
but it's still not fully transparent
Okay, now, let's get our web server running, first. Make sure you have
a sane web server that you can poke around, and be prepared to start
and stop it some times.
First, create a new web application and follow the instructions from the WebWork documentation.
When you have your jars, web.xml, views.properties (empty, for now) and
webwork.properties all set up, make a test deployment just to make sure
everything's alright. You'll end up with something like this:
/
/js-howto /WEB-INF /classes /lib web.xml
Now, the fun times begin. Create a new JavaScript file, hello.js,
inside WEB-INF/classes (important: JavaScript sources must be located
somewhere in the classpath, and the easiest place for now is
WEB-INF/classes), and two files, hello-input.vm and hello-success.vm,
located on your webapp's root:
There's something different here, huh? Yeap, all variables left over
from the JavaScript execution are available in the $results read-only
Map (read-only, in this case, meaning you can't put() or clear() it -
not even from JavaScript).
Now, change your views.properties file to contain these lines:
And that's it. Deploy and run the code (if you're using vanilla
Tomcat or Jetty, just go to localhost:8080/yourwebapp/hello.action) and
everything's working. Voila! :)
Previous Topic
