GWT + Struts 1.x + Netbeans Tutorial (Part 7b)

GWT + Struts 1.x + Netbeans Tutorial (Part 7b)

GWT + Struts 1.x + Netbeans Tutorial (Part 7b)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=3131558703471022668

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Continues from part 7a...

We have configured our module to use different locales, but we haven't tied the Struts locale to the GWT locale. The GWT locale is specified by a parameter in the request called, surprisingly enough, "locale". Let's assume you access your application in your callback address (127.0.0.1 / localhost) through port 8080 in this fashion: 

http://localhost:8080/app

You can pass a parameter defining what language to load by appending a locale attribute and the resulting address would be:

http://localhost:8080/app?locale=en

Sounds easy, but it's cumbersome (or not) to pass this parameter in each call. I don't want to be worrying about this, i just want to configure it and forget about it. So i chose the other option to specify a locale, which is to define it in the JSP. This sounds dangerous since looks like we're hard-coding the language into the JSP, but you can make it dynamic by selecting the language that Struts has detected (and is using).

I added this line to my welcomeStruts.jsp file inside the head:

<meta name='gwt:property' content="locale=${sessionScope['org.apache.struts.action.LOCALE']}">

Remember to add the <%@page isELIgnored="false" %< to the JSP as seen on a previous chapter when we discussed GAE quirks if you're using Google App Engine (GAE).

Now we're going to create a sub-interface of the Messages interface with the same name as our localized properties files. This will help us make the properties files with our translations available to GWT. Create an interface in the same package where your localized properties files are and name it accordingly (with the same name as your localized properties files). In this example the files are named MessageResource[_ll[_CC]].properties so our interface will be named MessageResource. This interface should extend the Messages interface from the i18n package, be careful not to extend any of the other available Messages classes or interfaces.

Inside this interface we declare methods to access our key=value pairs, and since we made the interface extend Messages, we can also use the placeholder facility to pass strings which are not to be localized, such as "Welcome {0}!!!". If our access method is called "greet" when we call greet("Mary") the output will be "Welcome Mary!!!". In a real application you would do something like greet(user.getFirstname()).

I added 2 key/value pairs to each properties file. button.clickme and label.hellogwt with the respective translation in each file. In the English file it reads:

button.clickme=Click me!
label.hellogwt=Hello, GWT!!!

And in the Spanish file it reads:

button.clickme=Presióname!
label.hellogwt=Hola, GWT!!!

In the interface i added accessors to those 2 keys by declaring 2 methods:

/**
   * @gwt.key button.clickme
   * @return the localized click me message
   */ 

@Key("button.clickme")
public String getClickMe();


/**
   * @gwt.key label.hellogwt
   * @return the localized hello gwt message
   */
@Key("label.hellogwt")
public String getHelloGWT();

Continues here... 

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.
I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 7a)

GWT + Struts 1.x + Netbeans Tutorial (Part 7a)

GWT + Struts 1.x + Netbeans Tutorial (Part 7a)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=5022580530370518864

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Part 7: Tying the I18N support from both GWT and Struts.

We have a working Struts application with regular page navigation, and GWT support, which is also i18n aware. This is important to keep in mind, it's ONLY i18n aware, in the sense that it knows about different locales. If you access you application from a web browser with an accept-language header different from "en" there are some glitches in the GWT display, it doesn't detect the language quite right.

It uses the "default" locale, which is English. I don't know if this just happened to myself or if it's a glitch in general. I will treat it as a general issue, because the fix i propose is also a nice-to-have feature, as usual.

I want both my Struts application and my GWT modules to keep in sync of what languages each one of them is using. Since changing the Struts language is easier i will make the GWT language a slave of the Struts language. This is something you would do if you have an existing i18n Struts application to which you just added GWT support. My application in this tutorial is a new application as well, and the steps needed to synchronize both views to the same language requires only a few lines of code in the JSPs, we also need to configure our gwt.xml file for this module to inherit the i18n classes and finally we're going to make our message resources available to GWT, just as it is available to Struts, but with a nice improvement which is provided by the i18n module in GWT.

In the previous section i mentioned the Constants and Messages interfaces, which provide utilities to internationalize an application. We're going to build a class that finds our international messages automatically from the given keys. GWT also comes with a command line tool called i18nCreator which can help us create this interface for us automatically. I'm gonna do it manually, since the procedure for the i18nCreator is pretty straightforward and requires little input. I recommend you read about i18n and i18nCreator in the GWT documentation and use it as a way to save you both time and patience.

I'm assuming our language translations are located in the com.example.strutsgwt.client.i18n package. Our entry point is located in the com.example.strutsgwt.client package. Our module gwt.xml file is located in the com.example.strutsgwt package. Our JSPs in the usual location.

The first thing we're going to do is configure our module's gwt.xml file by inheriting the i18n module. To achieve this we're going to edit it by adding the following after our <module> tag:

<inherits name="com.google.gwt.i18n.I18N"/>

Now we need to declare the languages we're going to use, i wish it could be dynamic, and i suspect there's a way to do it which escapes me, so if anyone knows how, please post below and I'll add it here (with correct attribution of course). Now I'll give you an example of the code you need to place inside your gwt.xml file to declare your languages:

<!-- Internationalization support. -->

<extend-property name="locale" values="en"/>

<extend-property name="locale" values="es"/>

<set-property-fallback name="locale" value="en"/>

I'm going to explain these lines and in this way you're going to adapt it to your case. I declared 2 languages: en and es (English and Spanish, respectively) and in the last line i declared the "default" language, which in this case is en (English). You can declare your own languages in this fashion and remember to read the documentation for the GWT locales.

Continues here...

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 7c)

GWT + Struts 1.x + Netbeans Tutorial (Part 7c)

GWT + Struts 1.x + Netbeans Tutorial (Part 7c)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=5417785457948665333

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Continues from part 7b...

The annotations tell the GWT compiler which method accesses which key. That's all we need to do to access a key inside the properties file, just add an access method and annotate it.

Finally to test all our configuration we're going to modify our EntryPoint to make use of the internationalized messages by asking GWT to create an implementation of our interface, but don't worry because all it takes is one line in our GWT code. I declared an attribute in the EntryPoint named messageResource of type MessageResource in this way:

MessageResource messageResource = (MessageResource) (GWT.create(MessageResource.class)); 

and now you can use that object to call the appropriate translated message by calling each declared method. In my example i have a label and a button that toggles the label when clicked. I removed the static text from the button and replaced it with messageResource.getClickMe() and for the label i did the same with the messageResource.getHelloGWT() method. So it should read:

final Label label = new Label(messageResource.getHelloGWT());
final Button button = new Button(messageResource.getClickMe());

That's how you manage to get the internationalized version of your messages from GWT. There's just one more thing you need to do to close the circle and that is associate the locale parameter to your Struts locale when it's present, because it takes precedence over the gwt:property defined in the meta tag. To do it just place the following code before the <html:html lang="true"> tag:

<logic:present parameter="locale">

<% request.getSession().setAttribute("org.apache.struts.action.LOCALE", new Locale(request.getParameter("locale"))); %>

</logic:present>

Now if the locale parameter is present, then Struts will use that setting and if it's not present then GWT will use whatever Struts is using. They're collaborating to present the information in the same way. Now you could create a menu to choose languages using the GWT facilty that returns all the available languages (just an idea).

After compiling you should have a perfectly synchronized locale between both Struts and GWT and an easily internationalized application, just drop a new properties file with a new language and declare it in the gwt.xml file and you're set. You have access to the message resources from both the Struts' tags and your GWT Messages interface.

The steps followed in this part of the tutorial are:

• Configure the module's gwt.xml file to use GWT's i18n support and declare languages.
• Tie Struts' i18n locale detection and set it as the current locale in GWT by editing JSPs.
• Create Messages, Contants or ConstantsWithLookUp sub-interfaces for the language properties files.
• Use your interface to access the key/value pairs by declaring methods in it and using @annotations.

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 6)

GWT + Struts 1.x + Netbeans Tutorial (Part 6)

GWT + Struts 1.x + Netbeans Tutorial (Part 6)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=7477257457894450184

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Part 6: Add I18N support to a Struts 1.x application.

TL;DR: move the MessageResource.properties file(s) to the "client" package. I used a package called "i18n" inside it, so mine points to:

com.example.strutsgwt.client.i18n.MessageResource

also modify struts-config.xml to reflect the change.

You might think this is a joke, because Struts has a very simple and straightforward way to add i18n support. Netbeans creates each new Struts project already having a default properties file (in English) which you can simply copy and rename, adding the appropriate language and country codes to the end, to add a new language to your application. So, is this a joke? No, this is not a joke.

This is a foreword to the i18n support in both Struts and GWT and how they work. The title should read "Adding i18n support to Struts in preparation for GWT".

Now that we have that clear, we need to know a few things about how Struts and GWT each handle i18n support. Struts uses properties files in a key=value format for all definitions we may want to have internationalized and you can also put placeholders for any dynamic strings you want to pass "as is" into the internationalized version.  GWT uses 2 interfaces: Constants and Messages (there are other classes too, read the API). The first works just as the key=value properties file in Struts and the second works like the  key=value properties with placeholders. They are pretty similar, right? Yes, they are. In fact what we're going to do is prepare the Struts project to accept the GWT i18n out of the box and also from the GWT point of view we're going to use the existing i18n support already provided by the Struts project.

GWT compiles everything in the "client" package into the JavaScript permutations, or so i think (please correct me if i'm wrong in the comment section). Therefore, to be able to use the i18n properties files from Struts we need to place those files into the "client" package. When you created the Struts project you were asked where to put the resources.

It was something like com.example.strutsgwt.MessageResource and you might have changed it a bit. So, now navigate to that package in your source structure.

I'm going to use the following structure to keep things tidy: com.example.strutsgwt.client.i18n. So create those packages and place your provided properties files inside.

After you move those files, you need to configure Struts to find them at the new location. You configure Struts to find the location of the message resources file (which i'm calling MessageResources.properties) by modifying the struts-config.xml file and changing the <message-resources> tag to <message-resources parameter="com/example/strutsgwt/client/i18n/MessageResources" /> and check everything works by compiling and testing.

You can then go ahead and add a new language by copying the MessageResources.properties file to the same package, renaming that file to MessageResources_es.properties or MessageResources_fr.properties (or your favorite language code) and modify the contents to the correct translation for each key that is found in the default file.

You should now have a working internationalized Struts web application project which is ready for GWT.

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 5)

GWT + Struts 1.x + Netbeans Tutorial (Part 5)

GWT + Struts 1.x + Netbeans Tutorial (Part 5)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=3385583661419780246

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Part 5: Add GWT support to a Struts 1.x application.

In the previous parts we've configured our environment to work with both GWT and Struts. This part is as short as the last one, we're going to add GWT support to our "existing" Struts application (which happens to be a new Struts application too) and also make the GWT module available to our welcome page.

To add GWT support to our Struts project we need to right-click the project's name in the project tab in Netbeans, and select "Properties". In the properties section select "Frameworks" we need to click the "Add" button next to the "Used Frameworks" list and select Google Web Toolkit from the available frameworks list. Especify the location of the GWT SDK and the GWT Module name. Things get a lot easier if you expecify the GWT Module name  to be the same as your MessageResource location and adding a dot and the module name in this way: ".<the-module-name-here>" at the end.
In our example i chose com.example.strutsgwt.Welcome.

After adding the GWT framework to our project, our structure changes to accommodate to the new classes, we get a "client" package with an EntryPoint subclass inside, a <the-module-name-here>.gwt.xml module file and a welcome file. We defined our Struts message resources file location to be com.example.strutsgwt.MessageResource therefore it can be found inside the com.example.strutsgwt package along with the Welcome.gwt.xml file. The gwt.xml file has the name of the module, which in our example it would translate to Welcome.gwt.xml.

Let's get to the important part, how to add the generated JavaScript to the pages we want. In the welcomeGWT.html file you find along with the welcome files and JSPs there are 2 important lines you need to copy. First there's a meta tag with a property GWT understands and then there's the usual script tag with the location of the EntryPoint. We are going to copy those 2 lines from the welcomeGWT.html file to the welcomeStruts.jsp file. I placed the 2 lines inside the head section of the JSP file.

You can now compile everything and test it. GWT compiles your Java code into JavaScript code so the compilation is a bit long and you might want to get used to this coding philosophy: use Hosted Mode for GWT testing, make changes and refresh the page while using hosted mode. I use Hosted Mode for the client (GWT) and i like compiling everything every now and then to check the whole project. Find your own pace.

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 4)

GWT + Struts 1.x + Netbeans Tutorial (Part 4)

GWT + Struts 1.x + Netbeans Tutorial (Part 4)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=5005962839791507501

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Part 4: Create a simple Struts 1.x application.

TL;DR: Scroll down to the video.

This is a straightforward task. Simply open Netbeans, if it's not already opened, click "File" and then select "New Project" or alternatively you could Click on the "New Project" icon on the toolbar. After selecting "New Project", choose the "Java Web" category and then the "Web Application" project type. In the "New Web Application" wizard fill-in the information, such as the project name and click "next". 

I am using Google App Engine (GAE) as a web server but you can choose any servlet container you like, such as Apache Tomcat or Sun Glassfish, which come bundled with Netbeans. If you're using GAE as the server, and you haven't added it to your services (i.e. it's not selectable in the drop-down menu), click the "Add" button. Select "Google App Engine" from the server selection list and click "next". In the location, point to the easy-to-find location where you saved and unpacked the GAE SDK. Configure the properties and click "finish". Now you can use the GAE development server to develop web applications for the Google App Engine cloud server.

After selecting the server for your new web application, click "next" and head to the frameworks section and check the "Struts" framework, don't worry if your application will have i18n support because we will deal with those specific details in the following parts of the tutorial, now check the "Add Struts TLDs" check-box and click "finish". If you noticed we didn't add GWT support to the web application, although it was available from the frameworks menu. This was done intentionally to create the Struts file structure first and to configure it the way you would normally do when starting a new web application using Struts. We'll worry about GWT later, because what we just did also allows you to follow the next parts of the tutorial and apply GWT support to an existing Struts 1.x web application without having to rewrite or manually create the required file structure.

The music clips are here on the left, just in case you feel like listening to something while you read.

GAE quirks

So, we now have a new web application project with Struts support that should work in GAE (or maybe not). Except that sessions are not ON by default, so we need to modify appengine-web-xml to enable sessions using the Netbeans editor by clicking the "Enable Support for Servlet Sessions" check-box or by adding this <sessions-enabled>true</sessions-enabled> inside the root. What next? Ok, we need to adjust a few things according to the "Will it play in App Engine" page. In that page it says: 

JSP session beans are not supported; to enable EL parsing, add <% @page isElIgnored="false" %> to your JSPs and <%@tag isElIgnored="false" %> to your tag files.

So, how do we make session beans available to JSPs? We need to make them available through memcache using the persistence provided by GAE (they need to make a buck somewhere around here). I found this technique running around in the wilderness of the interwebs, but i think the low-level API gives you more control, the choice is up to you. So for now we're covered and we can pretend we can use session beans in JSP, provided we only store Serializable objects in which all the important attributes are Serializable as well.

Now we adress the other issue; EL parsing. In every page we create we need to insert the <%@page isELIgnored="false"%> directive to be able to use EL (expression language) inside our JSPs. Problem solved. 

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 3)

GWT + Struts 1.x + Netbeans Tutorial (Part 3)

GWT + Struts 1.x + Netbeans Tutorial (Part 3)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=633092783451796132

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Part 3: Add the Google Web Toolkit framework to Netbeans.

TL;DR: It's nice to have regular page navigation and GWT features together. Scroll down to the red link.

The Google Web Toolkit (from now on GWT) is a framework that allows you to write your user interface (from now on Client) in the Java programming language and then does a cross-compilation into JavaScript. What it means is that you can create your user interface as you would do in a Swing style application and the framework translates that into the native user interface for each web browser supported (e.g. in Opera, Safari, Internet Explorer, Firefox a GWT button is a real BUTTON element in HTML so the native rendering is preferred on top of a virtual widget that behaves like a button like a DIV with an "onclick" method defined or other combinations of elements).

It comes with a few command-line tools such as the webAppCreator and the i18nCreator which let's you kick-start any project with GWT support and add I18N support to a new or existing project, respectively. It has a nice feature called Hosted Mode which let's you debug and test your code against a browser of your choice by installing a plug-in to said browser (as of now it supports Apple Safari, Microsoft Internet Explorer, Mozilla Firefox and obviously Google Chrome). Sadly it doesn't support Opera (doesn't have a plug-in yet). I test in Opera and other browsers, but the process of changing or adding a few lines of code and then firing up 5 browsers is a time-consuming and resource-wasting task. I have my personal philosophy in which i test the development code in IE (the most problematic from my point of view) and then rely on the capabilities of GWT to behave consistently in the same way across all other browsers.

GWT lets you harness the capabilities of AJAX in a simple and elegant way. Once you know how to create services and implement them, it becomes a real time-saver when it comes to changing just a small portion of the Client or even uploading the files The Google Way. I like having options and i like having the ability of changing just a small part of a web page or completely forwarding or redirecting the Client to another view. I've seen whole applications that behave like desktop applications and although it can be a nice way to present your layout, it can also be mind-boggling to the regular novice user.  

Usability Engineering Principles by Jakob Nielsen (pictured) is a nice lecture on this topic. Users feel somewhat safe with what they currently use, so the change to a full desktop-like application inside a web browser should not make them feel like they're learning anything. A normal user can remember 7 items in average, but when they feel they're learning they reset the counter to make room for the new information.

Enough chit-chat, let's focus on our topic and let's add the GWT framework to Netbeans.  

1. Download the GWT SDK here and save it to an easy-to-find location as usual.
2. Unpack the file using your favorite utility (7zip). 
3. Open Netbeans and click on "Tools" on the menubar.
4. Select "Plugins" and the plug-in dialog opens.
5. Click on "Available plugins" tab.
6. On the Search box type "GWT4NB".
7. Check the check-box of the plug-in named GWT4NB.
8. Click the "Install" button at the bottom.

After installing the plugin you will have the option of adding GWT framework support to your new or existing Java Web applications. When you choose to add the GWT support to the application you will be prompted to enter the location of the GWT SDK which you downloaded earlier (and which you unpacked to an easy-to-find location, remember?).

That's all there is to installing the GWT framework to Netbeans.

---

If you have any suggestions, ideas for systems integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 2)

GWT + Struts 1.x + Netbeans Tutorial (Part 2)

GWT + Struts 1.x + Netbeans Tutorial (Part 2)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=7737782772860722179

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Part 2: Add the Struts framework to Netbeans.

The Struts 1.x framework is a well-tested, well-documented, mature, popular MVC framework and many developers are familiar with it. It has pros and cons just as any other framework. There are other frameworks that compete with Struts, you can find more info here. I chose it for this tutorial for it's simplicity and because it's a framework that's been around for over 10 years. It's not the only one but the features are good, it helps you keep your code tidy and it also provides a few features to avoid boilerplate code, like a choice of automatic server-side validation versus automatic client-side validation in JavaScript and so on.

Assuming the framework is not installed or activated on your Netbeans installation. The procedure to activate it is simple, just click on "Tools" and then "Plugins". On the plugins dialog, select the "Available plugins" tab and type "Struts" in the Search box in the upper right-hand side of the dialog. If it appears on the result catalog, click the check-box beside it and at the bottom left-hand side of the dialog click the "Install" button. 

If it didn't appear in the results catalog then switch to the "Installed" tab and type "Struts" in the Search box in the upper right-hand side of the dialog. You should see it in the results catalog. You can check if it's active by looking for a green tick on the "Active" column at the right side of the listing. If it's not active, click the check-box beside the Struts listing and look for the "Activate" button on the lower left-hand side of the dialog.

After it's installed and activated you'll be able to select it from the Frameworks list when you create a new Java Web project from the New Project Wizard or add Struts support to an existing project by right-clicking the project, then clicking on "properties" and selecting it from the "Frameworks" menu in the project's property dialog.

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Part 1)

GWT + Struts 1.x + Netbeans Tutorial (Part 1)

GWT + Struts 1.x + Netbeans Tutorial (Part 1)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=980267668956012162

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Part 1: Add the Google App Engine server to Netbeans

TL;DR: Copy this http://kenai.com/projects/nbappengine/downloads/download/Latest_NetBeans68/updates.xml and watch video below. 

When I added the Google App Engine Development Server to my Netbeans IDE I had a little trouble and I'm not sure what was causing the problem, perhaps the JSF2.0 (Mojarra i think) didn't like the new server. 

I absolutely dislike Eclipse IDE, but that's just my personal opinion. After playing with Netbeans 6.9 beta and Netbeans 6.9, I decided to switch back to Netbeans 6.8 because I wanted to test a few ideas to see if they worked on GAE (Google App Engine). I wanted to use JSF2.0 and GWT to compare the AJAX functionalities that both frameworks have.

I got disappointed of all te configurations you have to make to get JSF2.0 working on Google App Engine, so i changed to a well-tested and simple (from a newbie perspective) MVC framework: Struts 1. 

If you want to comment on the advantages and disadvantages you see between your choice or flavor of MVC and those of Struts then use the comments section below. 

I re-installed Netbeans 6.8 which I have been using at work since it came out in December and I'm quite pleased. I would recommend you stay away from Netbeans 6.9 at least until September, to give it time to settle, because i think the new features still need a little more testing, but i could be wrong. 

After installing Netbeans 6.8 we need to add the Google App Engine Server. Download the App Engine SDK here and store it in an easy-to-find location. You will need to tell the plug-in where to find the library for the App Engine SDK. We will install the App Engine update center from the "Plugins" option in the "Tools" menu.

After selecting "Plugins", click on "Settings" and then look for a button that reads "Add" on the lower right-hand corner of the plug-ins dialog. When you click the "Add" button you're presented with a dialog to add a new update center in which you're going to enter the following:

Name: App Engine

URL: http://kenai.com/projects/nbappengine/downloads/download/Latest_NetBeans68/updates.xml

After you have added the update center, then go to the "Available plug-ins" tab and on the Search box type "App Engine" you will see several plug-ins, check all their check-boxes and click "Install". Now you can use Google App Engine as a container for any of your web applications.

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---

GWT + Struts 1.x + Netbeans Tutorial (Intro)

GWT + Struts 1.x + Netbeans Tutorial (Intro)

GWT + Struts 1.x + Netbeans Tutorial (Intro)

https://www.blogger.com/share-post.g?blogID=4038066669955738165&postID=260637781938079119

---

---

<c:choose>
     <c:when test="${user.likes}"> 
          Share this with your friends
     </c:when>
     <c:otherwise>  
          Send me feedback.
     </c:otherwise>
<:choose>

---

Is it true you're having trouble adding GWT support to a new (or existing) Struts 1.x web application developed in Netbeans (or not) and possibly to be deployed in Google App Engine (or another JSP container like Tomcat)?

I'll be adding the steps pointed below, subscribe to the RSS feed to get a notification whenever i post a new step. You'll find this tutorial a little different, since i don't use (or like using) any other libraries. You'll find the source code in the sources part of the tutorial.

The tutorial walks you through the whole process in small steps:

1. Add the Google App Engine Server to Netbeans.
2. Add the Struts framework to Netbeans.
3. Add the GWT framework to Netbeans.
4. Create a simple Struts 1.x application.
5. Add GWT support to a Struts 1.x application. 
6. Add I18N support to a Struts 1.x application.
7. Tie the I18N support from both GWT and Struts.
8. Facebook Authentication (Canvas + Web Application)
9. Leveraging Struts and GWT, (DevServer / HostedMode) when to use which.
10. Add a new workflow using Struts.
11. Add a new module using GWT.
12. Source code. Where to go next.

---

If you have any suggestions, ideas for full blown system integration (sb) or comments, leave a message below.

I would appreciate if you could Share this with your friends

---

---