Miles to go ...

JavaFX 1.0 launched - access services hosted on embedded GlassFish

Today Sun announces the availability of Java FX 1.0.

JavaFX 1.0 is a rich client platform for creating and delivering Rich Internet Applications across all screens (desktop, browser, and mobile) of your life. It consists of the following key components:

JavaFX SDK includes JavaFX script compiler and runtime tools, and a host of libraries to create RIAs for desktop, browser and mobile platforms, command-line tools & Ant tasks and other goodies. NetBeans 6.5 support (as plugin or bundled with IDE) that allows to build, preview and debug JavaFX applications using NetBeans IDE. If you prefer CLI support then SDK can be downloaded. Production Suite is a suite of tools and plugins for creative tools (such as Illustrator CS3+) that allows graphical assets to be exported to JavaFX applications.

This blog shows how to create a simple JavaFX application using NetBeans IDE. The application plays a movie, allows the viewer to cast a vote if they liked it, and see aggregate response from other viewers. The application is developed using NetBeans 6.5, JavaFX 1.0 plugin, and coded using JavaFX Script. The voting engine is deployed as a RESTful Web service using Jersey on GlassFish.

1. In NetBeans 6.5 IDE, install JavaFX plugin as explained here and RESTful Web services plugin as explained here. Both the plugins may be installed in one step by selecting the required plugins together.
2. Download NetBeans project for JavaFX client from here and add Jersey dependencies as explained in bullet #5 below. 
3. Download Web service endpoint Maven project from here and deploy the endpoint as explained in bullet #4 below.
4. Run the JavaFX application as explained here.

1. In NetBeans 6.5, install "JavaFX SDK" plugin.  In the "Tools" menu, "Plugins", search on "JavaFX", select "JavaFX SDK" and click on "Install".
2. Create a new project of type "JavaFX", "JavaFX Script Application". Take the default values as shown below:
   
   
   
   and click on "Finish".
3. The source code for this class can be downloaded from here or alternatively constructed as explained in the sub-bullets.
1. In the newly created class, change the Stage (root area for all scene content) to:
   
   

   Stage {    title: "GlassFish Media Player"    width: 625    height: 360    resizable: false    scene: myScene }

2. Create a scene that contains the view of the media to be played and controls the display of the Vote or Result nodes:
   
   

   var myScene: Scene = Scene {    content: MediaView {            fitWidth: 625            fitHeight: 360            mediaPlayer: bind myPlayer            onMouseEntered: function( e: MouseEvent ):Void {                println("mouse entered");                if (voted == false) {                    insert Vote{} into myScene.content;                } else {                    insert Result{} into myScene.content;                }            }            onMouseExited: function( e: MouseEvent ):Void {                delete myScene.content[1]            }        } }

3. Create a Media Player to use with the scene:
   
   

   var myPlayer: MediaPlayer = MediaPlayer{     autoPlay: true     media: bind myMedia };

4. Create the media object to be used with the Media Player:
   
   

   var myMedia: Media = Media {     source: "http://sun.edgeboss.net/download/sun/media/1460825906/1460825906_2957290001_DayEarth-Bluray.flv"    };

   
   You can change the location of the movie here in the media player. For example, changing it to "http://mediacast.sun.com/users/ArunGupta/media/v3prelude-nb65-webapp.flv" will start playing the screencast #27.
   
5. Create a Vote class that is a CustomNode and appears when a user's mouse enters the scene where the video is playing. The user can select whether he likes the clip or not and the vote is recorded making a Web service call using Jersey Client APIs:
   
   

   class Vote extends CustomNode {    override function create():Node {        return Group {            content: [                Rectangle {                    fill: Color.GREEN                    x: 185                    y: 145                    width: 243                    height: 38                    arcWidth: 20                    arcHeight: 20                },                Text {                    x: 195                    y: 170                    fill: Color.WHITE                    font: Font {                        size: 18                    }                    content: "I love it"                },                Rectangle{                    x: 191                    y: 148                    smooth: false                    width: 73                    height: 32                    fill: Color.TRANSPARENT                    onMouseClicked: function( e: MouseEvent ):Void {                        println("clicked I love it");                        voted = true;                        wsClient.voteLoveIt();                        delete myScene.content[1]                    }                },                Text{                    x: 305                    y: 170                    fill: Color.WHITE                    font: Font {                        size: 18                    }                    content: "Not so great"                    },                Rectangle {                    x: 301                    y: 148                    smooth: false                    width: 118                    height: 32                    fill: Color.TRANSPARENT                                       onMouseClicked: function( e: MouseEvent ):Void {                        voted = true;                        println("clicked Not so great");                        wsClient.voteNotSoGreat();                        delete myScene.content[1]                    }                }            ]        }    } };

6. Create a Result class that is a CustomNode and simply reports on how many voters like this clip:
   
   

   class Result extends CustomNode {    override function create():Node {        var resultPercent = wsClient.showResults();        var resultString = "{resultPercent} voters liked this clip";        return Group {            content: [                Rectangle {                    fill: Color.BLUE                    x: 187                    y: 145                    width: 244                    height: 38                    arcWidth: 20                    arcHeight: 20                    onMouseClicked: function( e: MouseEvent ):Void {                        delete myScene.content[1]                    }                },                Text {                    x: 199                    y: 170                    fill: Color.WHITE                    font: Font {                        size: 18                    }                    content: resultString                }            ]        }    } };

7. Add two instance variables:
   
   

   var voted = false; var wsClient = new WebserviceClient;

   
   The first variable captures if the viewer has already voted and the second variable is an instance to the RESTful Web service client.
   
8. Add the following import statements:
   
   

   import javafx.scene.*; import javafx.scene.input.MouseEvent; import javafx.scene.media.Media; import javafx.scene.media.MediaPlayer; import javafx.scene.media.MediaView; import javafx.scene.paint.Color; import javafx.scene.shape.Rectangle; import javafx.scene.text.Font; import javafx.scene.text.Text; import javafx.stage.Stage;

   
   "Fix Imports" should be able to fix them and bug #154307 is already filed for that.
4. Create a new class that is used to capture the Vote as:
   
   

   @javax.xml.bind.annotation.XmlRootElement public class VoteBean {     public static enum VOTE { LOVE_IT, NOT_SO_GREAT };         public VOTE vote;     public VoteBean() { vote = VOTE.LOVE_IT; }     public VoteBean(VOTE vote) {         this.vote = vote;     } }

   
   This is a simple Javabean with a standard JAXB annotation. This ensures that XML is used as the data format for transfering results between client and endpoint. The source code for this class is available here.
   
5. Add Jersey libraries to the project by right-clicking on Project, select Libraries, click on "Add Library...", select "JAX-RS 1.0" and "Jersey 1.0 (JAX-RS RI)", and click on "Add Library".
   
   
   
   If these libraries are not available then install the "RESTful Web Services" plugin from the Plugin Center.
6. And finally add the class that invokes the RESTful Webservice endpoint:
   
   

   public class WebserviceClient {     private static com.sun.jersey.api.client.WebResource createWebResource() {         return com.sun.jersey.api.client.Client.create().                 resource("http://localhost:8080/movie-feedback-webapp/webresources/myresource");     }     public static void voteLoveIt() {         createWebResource().type("application/json").                 post(new VoteBean(VoteBean.VOTE.LOVE_IT));     }     public static void voteNotSoGreat() {         createWebResource().type("application/json").                 post(new VoteBean(VoteBean.VOTE.NOT_SO_GREAT));     }     public static String showResults() {         return createWebResource().get(String.class);     } }

   
   The Webservice endpoint will be hosted at "http://localhost:8080/movie-feedback-webapp/webresources/myresource". A WebResource is created from the Client. The POST methods are used to cast the user vote and GET method is used to retrieve the aggregated results. The source code for this class is available here.

1. Create and deploy a RESTful Web service endpoint
1. Create a template RESTful Web service endpoint as described in TOTD #56. Lets use the artifactId as "movie-feedback-webapp".
2. Create the bean "VoteBean" in "org.glassfish.samples" package. This is the exactly same bean used earlier by the client:
   
   

   @javax.xml.bind.annotation.XmlRootElement public class VoteBean {     public static enum VOTE { LOVE_IT, NOT_SO_GREAT };     public VOTE vote;     public VoteBean() { vote = VOTE.LOVE_IT; }     public VoteBean(VOTE vote) {         this.vote = vote;     } }

3. Update the generated resource
1. Add @com.sun.jersey.spi.resource.Singleton as class annotation so that only one instance of the resource is created for the entire web application. This allows to save state (preferences from other users) in the RESTful resource.
   
2. Add two instance variables:
   
   

   int loveIt;     int noSoGreat;

3. Add a method that will process HTTP POST requests as:
   
   

   @POST     public void postOneVote(VoteBean bean) {         if (bean.vote == VoteBean.VOTE.LOVE_IT) {             loveIt++;         } else {             noSoGreat++;         }         System.out.println("In POST: " + bean.vote);     }

   
   This method stores the vote in the resource. The handling of POST request messages by Jersey is explained in TOTD #58.
   
4. Add a method that will process HTTP GET requests as:
   
   

   @GET     @Produces("text/plain")     public String getOpinion() {         if (loveIt == 0 && noSoGreat == 0)             return "No votes cast yet!";         return (loveIt * 100) / (loveIt + noSoGreat) + "%";     }

   
   This method calculates the percentage of viewers who liked the movie.
4. Deploy the endpoint using "mvn glassfish:run" in "movie-feedback-webapp" directory.

• How to install JavaFX capabilities to an existing NetBeans 6.5 installation
• How to create a simple JavaFX application that plays media files
• Integrate it with existing Java libraries (Jersey client libraries in this case)
• Invoke services hosted on GlassFish

Posted by Arun Gupta in webservices  |  Comments[13]

TOTD #58: Jersey and GlassFish - how to process POST requests ?

Lets extend the Jersey endpoint (TOTD# 56) and client (TOTD# 57) such that it can accept a POST request and then invoke it.

1. Add a new method to "MyResource.java" from TOTD# 56 as:
   
   

   @POST     @Consumes("application/json")     @Produces("application/json")     public Greeting postIt(Greeting greeting) {         System.out.println("In POST: " + greeting.greeting);         return greeting;     }

   
   The first line indicates that the Java method will process HTTP POST requests. The second and third line shows that the method consumes and produces JSON data format.
   
2. Add a new method to "AppTest.java" from TOTD# 57 as:
   
   

   public void testPost() {         Greeting result = createResource().                 type("application/json").                 post(Greeting.class, new Greeting("yo!"));         assertTrue(result.greeting.equals("yo!"));     }

   
   The main difference from the "testApp()" method is specifying the MIME type of the generated outbound request as "application/json".
   
3. Running the test as "mvn test" shows the following output:
   
   

   Running org.glassfish.samples.AppTest 1 * Out-bound request 1 > GET http://localhost:8080/helloworld-webapp/webresources/myresource 1 > 1 < 200 1 < X-Powered-By: Servlet/2.5 1 < Transfer-Encoding: chunked 1 < Content-Type: text/plain 1 < Server: GlassFish/v3 1 < Date: Tue, 25 Nov 2008 20:19:34 GMT 1 < <?xml version="1.0" encoding="UTF-8" standalone="yes"?><greeting><greeting>Hi there!</greeting></greeting> 1 * In-bound response 1 * Out-bound request 1 > POST http://localhost:8080/helloworld-webapp/webresources/myresource 1 > Content-Type: application/json 1 > {"greeting":"yo!"} 1 < 200 1 < X-Powered-By: Servlet/2.5 1 < Transfer-Encoding: chunked 1 < Content-Type: application/json 1 < Server: GlassFish/v3 1 < Date: Tue, 25 Nov 2008 20:19:34 GMT 1 < {"greeting":"yo!"} 1 * In-bound response Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.191 sec

   
   The output shows request/response messages when both the tests are run together. Here are some highlights:
1. "GET" and "POST" methods are clearly highlighted.
2. The two "Content-Type" headers with value "text/plain" and "application/json" are output from two tests. The output from POST method has two Content-Type headers, one for outbound request and another one for inbound response.
3. The body content of POST method is using JSON format.
   

Posted by Arun Gupta in webservices  |  Comments[4]

TOTD #57: Jersey Client API - simple and easy to use

TOTD #56 explains how to create a RESTful Web service endpoint using Jersey and publish the resource using JSON representation. The blog entry showed how the endpoint can be accessed from a Web browser. This Tip Of The Day explains how to use Jersey Client APIs to invoke the published endpoint.

Lets get started!

1. Create a new directory "./src/test/java/org/glassfish/samples"
2. Add a test
1. Add a template test file "AppTest.java" as shown below:
   
   

   package org.glassfish.samples; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestSuite; /**  * Unit test for simple App.  */ public class AppTest     extends TestCase {     /**      * Create the test case      *      * @param testName name of the test case      */     public AppTest( String testName )     {         super( testName );     }     /**      * @return the suite of tests being tested      */     public static Test suite()     {         return new TestSuite( AppTest.class );     }     /**      * Rigourous Test :-)      */     public void testApp()     {         assertTrue(true);     } }

2. Add a new method "createResource()" as:
   
   

   private WebResource createResource() {         Client client = Client.create();         WebResource resource = client.resource("http://localhost:8080/helloworld-webapp/webresources/myresource");         return resource;     }

   
   This code creates a default instance of Jersey Client and creates a Web resource from that client for the URI passed as an argument.
3. Change the implementation of "testApp()" method as:
   
   

   Greeting result = createResource().get(Greeting.class);         assertTrue(result.greeting.equals("Hi there!"));

   
   This invokes the GET method on the resource by passing specific type and compares the returned and expected value.
   
4. Add the following "imports":
   
   

   import com.sun.jersey.api.client.Client; import com.sun.jersey.api.client.WebResource;

5. Copy "Greeting.java" from TOTD #56 to "./src/test/java/org/glassfish/samples" directory.
3. Run the test
1. Deploy the endpoint as "mvn glassfish:run".
2. Run the test as "mvn test". The following output is shown:
   
   

   ~/samples/jersey/helloworld-webapp >mvn test [INFO] Scanning for projects... [INFO] ------------------------------------------------------------------------ [INFO] Building helloworld-webapp Jersey Webapp [INFO]    task-segment: [test] [INFO] ------------------------------------------------------------------------ [INFO] [resources:resources] [INFO] Using default encoding to copy filtered resources. [INFO] [compiler:compile] [INFO] Nothing to compile - all classes are up to date [INFO] [resources:testResources] [INFO] Using default encoding to copy filtered resources. [INFO] [compiler:testCompile] [INFO] Compiling 1 source file to /Users/arungupta/samples/jersey/helloworld-webapp/target/test-classes [INFO] [surefire:test] [INFO] Surefire report directory: /Users/arungupta/samples/jersey/helloworld-webapp/target/surefire-reports -------------------------------------------------------  T E S T S ------------------------------------------------------- Running org.glassfish.samples.AppTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.587 sec Results : Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESSFUL [INFO] ------------------------------------------------------------------------ [INFO] Total time: 4 seconds [INFO] Finished at: Mon Nov 24 16:50:17 PST 2008 [INFO] Final Memory: 18M/43M [INFO] ------------------------------------------------------------------------

4. View request and response messages
1. Change the implementation of "createResource()" method as (changes highlighted in bold):
   
   

   Client client = Client.create();         WebResource resource = client.resource("http://localhost:8080/helloworld-webapp/webresources/myresource");         resource.addFilter(new LoggingFilter());         return resource;

2. Running the tests as "mvn test" now shows the output, with request and response messages, as shown below:
   
   

   Running org.glassfish.samples.AppTest 1 * Out-bound request 1 > GET http://localhost:8080/helloworld-webapp/webresources/myresource 1 > 1 < 200 1 < X-Powered-By: Servlet/2.5 1 < Transfer-Encoding: chunked 1 < Content-Type: application/json 1 < Server: GlassFish/v3 1 < Date: Tue, 25 Nov 2008 07:07:51 GMT 1 < {"greeting":"Hi there!"} 1 * In-bound response Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.074 sec

Posted by Arun Gupta in Finance  |  Comments[8]

TOTD #56: Simple RESTful Web service using Jersey and Embeddable GlassFish - Text and JSON output

Jersey is the open source, production quality, JAX-RS (JSR 311) Reference Implementation for building RESTful Web services in the GlassFish community. It also provides an API that allows developers to extend Jersey to suite their requirements.

1. Create a simple web app using Maven as:
   
   

   ~/samples/jersey >mvn archetype:generate -DarchetypeCatalog=http://download.java.net/maven/2 [INFO] Scanning for projects... [INFO] Searching repository for plugin with prefix: 'archetype'. [INFO] ------------------------------------------------------------------------ [INFO] Building Maven Default Project [INFO]    task-segment: [archetype:generate] (aggregator-style) [INFO] ------------------------------------------------------------------------ [INFO] Preparing archetype:generate [INFO] No goals needed for project - skipping [INFO] Setting property: classpath.resource.loader.class => 'org.codehaus.plexus.velocity.ContextClassLoaderResourceLoader'. [INFO] Setting property: velocimacro.messages.on => 'false'. [INFO] Setting property: resource.loader => 'classpath'. [INFO] Setting property: resource.manager.logwhenfound => 'false'. [INFO] [archetype:generate] [INFO] Generating project in Interactive mode [INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0) Choose archetype: 1: remote -> jersey-quickstart-grizzly (Archetype for creating a RESTful web application with Jersey and Grizzly) 2: remote -> jersey-quickstart-webapp (Archetype for creating a Jersey based RESTful web application WAR packaging) Choose a number:  (1/2): 2 [INFO] snapshot com.sun.jersey.archetypes:jersey-quickstart-webapp:1.0.1-SNAPSHOT: checking for updates from jersey-quickstart-webapp-repo Define value for groupId: : org.glassfish.samples Define value for artifactId: : helloworld-webapp Define value for version:  1.0-SNAPSHOT: : Define value for package: : org.glassfish.samples Confirm properties configuration: groupId: org.glassfish.samples artifactId: helloworld-webapp version: 1.0-SNAPSHOT package: org.glassfish.samples  Y: : [INFO] ---------------------------------------------------------------------------- [INFO] Using following parameters for creating OldArchetype: jersey-quickstart-webapp:1.0.1-SNAPSHOT [INFO] ---------------------------------------------------------------------------- [INFO] Parameter: groupId, Value: org.glassfish.samples [INFO] Parameter: packageName, Value: org.glassfish.samples [INFO] Parameter: package, Value: org.glassfish.samples [INFO] Parameter: artifactId, Value: helloworld-webapp [INFO] Parameter: basedir, Value: /Users/arungupta/samples/jersey [INFO] Parameter: version, Value: 1.0-SNAPSHOT [INFO] ********************* End of debug info from resources from generated POM *********************** [INFO] OldArchetype created in dir: /Users/arungupta/samples/jersey/helloworld-webapp [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESSFUL [INFO] ------------------------------------------------------------------------ [INFO] Total time: 21 seconds [INFO] Finished at: Mon Nov 24 14:09:27 PST 2008 [INFO] Final Memory: 12M/30M [INFO] ------------------------------------------------------------------------

2. Edit the generated "pom.xml" to add dependencies on GlassFish plugin
1. Add the following plugin in the "pom.xml" under <build>/<plugins>:
   
   

   <plugin>                 <groupId>org.glassfish</groupId>                 <artifactId>maven-glassfish-plugin</artifactId>             </plugin>

2. Add the following plugin repositories:
   
   

   <pluginRepositories>         <pluginRepository>             <id>maven2-repository.dev.java.net</id>             <name>Java.net Repository for Maven</name>             <url>http://download.java.net/maven/2/</url>             <layout>default</layout>         </pluginRepository>         <pluginRepository>             <id>maven-repository.dev.java.net</id>             <name>Java.net Maven 1 Repository (legacy)</name>             <url>http://download.java.net/maven/1</url>             <layout>legacy</layout>         </pluginRepository>     </pluginRepositories>

3. Optionally, if the generated dependencies in "pom.xml" as shown below:
   
   

   <dependency>             <groupId>org.glassfish.distributions</groupId>             <artifactId>web-all</artifactId>             <version>10.0-build-20080430</version>             <scope>test</scope>         </dependency>         <dependency>             <groupId>org.glassfish.embedded</groupId>             <artifactId>gf-embedded-api</artifactId>             <version>1.0-alpha-4</version>             <scope>test</scope>         </dependency>

   
   are changed to:
   
   

   <dependency>             <groupId>org.glassfish.distributions</groupId>             <artifactId>web-all</artifactId>             <version>10.0-SNAPSHOT</version>             <scope>test</scope>         </dependency>         <dependency>            <groupId>org.glassfish.embedded</groupId>            <artifactId>glassfish-embedded-all</artifactId>            <version>3.0-Prelude-SNAPSHOT</version>         </dependency>

   
   then the latest version of Embedded GlassFish APIs are used.
4. Also optionally, if you want to run against Jersey 1.0 bits then change the following property from "1.0.1-SNAPSHOT" to "1.0".
   
   

   <properties>         <jersey-version>1.0</jersey-version>     </properties>

3. Run the application
1. The generated source code is:
   
   

   package org.glassfish.samples; import javax.ws.rs.GET; import javax.ws.rs.Path; import javax.ws.rs.Produces; // The Java class will be hosted at the URI path "/helloworld" @Path("/myresource") public class MyResource {         // The Java method will process HTTP GET requests     @GET     // The Java method will produce content identified by the MIME Media     // type "text/plain"     @Produces("text/plain")     public String getIt() {         return "Hi there!";     } }

   
   Invoking "mvn glassfish:run" starts the embedded GlassFish and shows the following output:
   
   

   ~/samples/jersey/helloworld-webapp >mvn glassfish:run [INFO] Scanning for projects... [INFO] Searching repository for plugin with prefix: 'glassfish'. [INFO] ------------------------------------------------------------------------ [INFO] Building helloworld-webapp Jersey Webapp [INFO]    task-segment: [glassfish:run] [INFO] ------------------------------------------------------------------------ [INFO] Preparing glassfish:run [INFO] [resources:resources] [INFO] Using default encoding to copy filtered resources. [INFO] [compiler:compile] [INFO] Compiling 1 source file to /Users/arungupta/samples/jersey/helloworld-webapp/target/classes [INFO] [glassfish:run] Nov 24, 2008 2:36:05 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: HK2 initialized in 229 ms Nov 24, 2008 2:36:05 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: com.sun.enterprise.naming.impl.ServicesHookup@2470b02c Init done in 237 ms Nov 24, 2008 2:36:05 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: com.sun.enterprise.v3.server.Globals@13b3d787 Init done in 239 ms Nov 24, 2008 2:36:05 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: com.sun.enterprise.v3.server.SystemTasks@61bedd7d Init done in 244 ms Nov 24, 2008 2:36:05 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: com.sun.enterprise.v3.services.impl.HouseKeeper@2b9f7952 Init done in 245 ms Nov 24, 2008 2:36:05 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: com.sun.enterprise.v3.services.impl.CmdLineParamProcessor@5249d560 Init done in 248 ms JMXMP connector server URL = service:jmx:jmxmp://localhost:8888 Nov 24, 2008 2:36:05 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start INFO: Listening on port 8080 Nov 24, 2008 2:36:06 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: com.sun.enterprise.v3.services.impl.GrizzlyService@1baa56a2 startup done in 551 ms Nov 24, 2008 2:36:06 PM com.sun.enterprise.v3.services.impl.ApplicationLoaderService postConstruct INFO: loader service postConstruct started at 1227566166208 Nov 24, 2008 2:36:06 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: Application Loader startup done in 740 ms Nov 24, 2008 2:36:06 PM com.sun.enterprise.v3.server.AppServerStartup run INFO: Glassfish v3 started in 740 ms Nov 24, 2008 2:36:07 PM com.sun.enterprise.web.WebModuleContextConfig authenticatorConfig SEVERE: webModuleContextConfig.missingRealm Nov 24, 2008 2:36:07 PM com.sun.jersey.api.core.PackagesResourceConfig init INFO: Scanning for root resource and provider classes in the packages:   org.glassfish.samples Nov 24, 2008 2:36:07 PM com.sun.jersey.api.core.PackagesResourceConfig init INFO: Root resource classes found:   class org.glassfish.samples.MyResource Nov 24, 2008 2:36:07 PM com.sun.jersey.api.core.PackagesResourceConfig init INFO: Provider classes found: Hit ENTER for redeploy

   
   Notice how GlassFish v3 starts up in sub-second (740 ms in this case).
   
2. "http://localhost:8080/helloworld-webapp" shows the following output:
   
   
3. Clicking on "Jersey resource" redirects to "http://localhost:8080/helloworld-webapp/webresources/myresource" and shows the following output:
   
   
4. Change the output representation to produce JSON representation
1. Add a new JAXB bean:
   
   

   package org.glassfish.samples; import javax.xml.bind.annotation.XmlRootElement; /**  * @author arungupta  */ @XmlRootElement public class Greeting {     public String greeting;     public Greeting() { }     public Greeting(String greeting) {         this.greeting = greeting;     } }

2. Change the method implementation in MyResource as:
   
   

   //    @Produces("text/plain")     @Produces("application/json")     public Greeting getIt() {         return new Greeting("Hi there!");     }

3. And now "http://localhost:8080/helloworld-webapp/webresources/myresource" shows the following output:
   
   
   
   Notice the output is now in JSON format.
5. Optionally a WAR file can be created using the command:
   
   

   mvn clean package

   
   and the WAR file is generated in "target/helloworld-webapp.war". If Jersey is installed using GlassFish v3 Update Center then you can use "maven-assembly-plugin" to customize packaging of WAR and drastically reduce the size.
   

Posted by Arun Gupta in webservices  |  Comments[16]

GlassFish @ Silicon Valley Code Camp 2008 - Trip Report

1400 registrations, 112 sessions, free pizza, a barbecue on Saturday night, raffles and lot more - that is Silicon Valley Code Camp. Jitu, Jiandong, Jacob, and I presented on GlassFish at Silicon Valley Code Camp over the weekend. The event had higher attendance (close to 500) than last year and certainly is a great networking event for the local community.

• Develop/Run/Debug Rails application using NetBeans and GlassFish
• Rapid Deployment Technology for Web application using NetBeans and GlassFish
• Tic Tac Toe using Rails and GlassFish
• Embeddable GlassFish in Action
• Deploying OSGi bundles in GlassFish

Posted by Arun Gupta in web2.0  |  Comments[2]

SOAP and REST - both equally important to Sun

"Sun moving away from SOAP to embrace REST" is the misleading title of an article recently published in SD Times. The article provides a good introduction to JAX-RS and Jersey. But I really wonder what motivated the author of this article to use this title. This blog, hopefully, provides a better context.

Jersey is the Reference Implementation of Java API for RESTful Web Services (JAX-RS, JSR 311) and was released earlier this week. The headline indicates that Sun is leaving SOAP and will support REST. The debate between REST and SOAP is not new and there are religious camps on both sides (even within Sun). And that's completely understandable because each technology has its own merits and demerits. But just because a new JSR aimed to make RESTful Web services easy in the Java platform is released, it does not mean Sun Microsystems is leaving existing technology in trenches.

The addition of Jersey to Sun's software portfolio makes the Web services stack from GlassFish community a more compelling and comprehensive offering. This is in contrast  to "moving away" from SOAP as indicated by the title. As a matter of fact, Jersey will be included as part of Metro soon, the Web Services stack of GlassFish. And then you can use JAX-WS (or Metro) if you like to use SOAP or JAX-RS (or Jersey) if you prefer RESTful Web services. It's all about a offering choice to the community instead of showing a direction.

Here are some data points for JAX-WS:

• The JAX-WS 2.0 specification was released on May 11, 2006. There have been couple of maintenance releases since then and another one brewing.
• Parts of Metro, the implementation of JAX-WS, are currently baked into GlassFish, embeddable in JBoss WS Stack, and also part of Oracle Weblogic and IBM Websphere.
• The implementation stack is mature and used in several key customer deployments. 
• JAX-WS is already included in Java SE 6 and hence available to a much wider audience.
• As opposed to "moving away", JAX-WS 2.2 (currently being worked upon) will be included in Java EE 6 platform, as will Jersey be.

Posted by Arun Gupta in webservices  |  Comments[9]

LOTD #1: Using Silverlight to access GlassFish Metro and JAX-WS Web service endpoints

Following TOTD (Tip Of The Day) pattern, I'm starting LOTD (Link Of The Day) series today. These are light-weight entries with generally a single line description and links to other blogs/articles/tips/whitepapers/screencasts/etc.

Let's start with three recent entries on MSDN that describe how to invoke Metro and JAX-WS Web service endpoints from Microsoft Silverlight and .NET:

• Call a Java EE Web service from .NET Client
• Call a Java EE Web service from Silverlight Client (deployed on GlassFish)
• Call a Metro Web service from Silverlight (deployed on Tomcat)

Posted by Arun Gupta in webservices  |  Comments[2]

Why GlassFish Metro over Axis ?

Metro (Web services stack from GlassFish) is kicking strong these days - here are two instances!

1. ArcGIS SOAP stack gains 90% performance improvement using Metro
   
   An intern in the Web services team for performance enhancement of ArcGIS SOAP SDK reported:
   
   "With Axis 1.x based tool kits XML parsing was identified as a bottleneck and therefore we wanted to make a switch to a tool kit that uses the Streaming API for XML Parsing (StAX). We identified that Metro (Glassfish's SOAP Stack) was the way to go and i generated the new Metro based SDK for accessing Web-Services."
   
   And the conclusion is ...
   
   "The result of this project is an increased performance of the ArcGIS Server's SOAP stack (by about 90%)."
   
   Pretty cool - Metro (Web services stack baked in GlassFish) gave about 90% improvement over Axis! Read more details about the study here.
2. Change of the guard: AXIS out, JAX-WS in
   
   Here are some relevant points:
   
   "I have come to a conclusion: I no longer want to deal with the hassle that has become Apache AXIS."
   
   "AXIS2 is current, but has become very large, the doc is poor, the support is invisible, the generated code smells, and the seams are everywhere.  Fifty nine jar files?  Really?   Do I need this hassle?  With JAX-WS, do I need AXIS any longer? I think not."
   
   "But I honestly cannot believe customers will continue to put up with the furball that AXIS2 has become. And if I am in a position to make a recommendation, I will recommend JAX-WS. It works."
   

Posted by Arun Gupta in webservices  |  Comments[0]

Getting Started with GlassFish in IntelliJ IDEA

IntelliJ IDEA 7.0.x include plugins that provide support for configuring GlassFish. This blog provides clear instructions on how to get started by developing and deploying a JSP, Servlet and Web services using GlassFish in IntelliJ. The instructions are using IntelliJ 7.0.3 Build #7757 (with no additional plugins).

1. Create a new project
1. Clicking on "Create New Project" or "File", "New Project". Take the default as shown below:
   
   
   
   and click on "Next >".
2. Enter the project name as "GlassFishRocks" and take all defaults as shown:
   
   
   
   and click on "Next >".
   
3. Take another default for the source directory as shown:
   
   
   
   and click on "Next >".
4. For the first time use, JDK needs to be specified. Click on "+" in top-left corner as shown here:
   
   
   
   Take the default option of "JSDK" and specify the Home Directory as shown:
   
   
   
   Click on "OK" and then click on "Next >".
5. Let's create a Web application. Select the list of technologies as shown:
   
   
   
   and finally (phew!) click on "Finish". The expanded project looks like:
   
   
2. Create a GlassFish configuration
1. Select "Run", "Edit Configurations" as shown:
   
   
   
2. Click on "+" on top-left corner and select GlassFish as shown below:
   
   
   
3. Specify the location of GlassFish Application server at:
   
   
   
   by clicking on "Configure" button and enter the values as shown:
   
   
   
   and click on "OK". You can download and install GlassFish v2 UR2 from here.
   
4. Enter the "Name" and select the "Server Domain" as shown:
   
   
   
   and click on "OK".
3. Deploy the Web application
1. Click on the green button in the toolbar:
   
   
   
2. Click on the "Fix" button on the bottom and then click "Run". The recently created Web module is selected to be deployed as shown:
   
   
3. This starts the GlassFish v2 UR2 Application Server and deploys the Web application showing the console as:
   
   
   
   and also shows the default page at "http://localhost:8080/GlassFishRocksWeb/". You can edit "index.jsp", re-deploy the Web facet and refresh the page to see the updated message.
   
   Notice, even though project's name is "GlassFishRocks", the application context root is "GlassFishRocksWeb".
4. Now lets create/deploy a new Servlet.
1. Create a new project as described above and name it "KillerServlet".
2. Right-click on the project and select "New", "Servlet" as shown:
   
   
3. Enter the values as shown:
   
   
   
   and click on "OK".
4. The "Java EE: Structure" shows the project as:
   
   
   
5. Double-click on "HelloServlet" (nested one) and add the following fragment to "doGet" method:
   
   

   java.io.PrintWriter out = response.getWriter();         try {             out.println("<html>");             out.println("<head>");             out.println("<title>Servlet NewServlet</title>");             out.println("</head>");             out.println("<body>");             out.println("<h1>Servlet NewServlet at " + request.getContextPath () + "</h1>");             out.println("</body>");             out.println("</html>");         } finally {             out.close();         }

   
   NetBeans IDE auto-generates this code for a Servlet ;-) And add the following to "doPost" method:
   
   

   doGet(request, response);

6. Double-click on "web.xml" and then select "Assembly Descriptor" tab.
7. Click on "+" in Servlet Mappings and specify the values as:
   
   
   
8. Deploy the project (as described above) and output from Servlet is displayed at "http://localhost:8080/KillerServletWeb/hello". Read more details in Creating Java EE Apps and Servlets with IntelliJ IDEA.
   
   Remember the weird context root, it's "KillerServletWeb" instead of "KillerServlet". Now there may be a good reason to do so but nothing obvious.
5. Now lets create a simple Web service using the Metro Web services stack (the stack baked into GlassFish)
1. Create a new project with name "GlassFishWS" following the instructions given above.
2. Select the list of technologies as shown:
   
   
3. The default generated Web service looks like:
   
   
4. The default generated Web service uses light-weight Endpoint API to host the endpoint. Run the Web service by right-clicking in the editor pane and selecting "Run" as shown or default shortcut of Ctrl+Shift+F10:
   
   
5. The WSDL is now available at "http://localhost:9000/HelloWorld?wsdl".
6. Right-click on the project and select "New", "Web Service Client" as shown:
   
   
   
   enter the value as "WSClient" and click on "OK".
7. In the next dialog, enter the values as shown:
   
   
8. The generated client code has some errors as shown:
   
   
   
   Change the code to:
   
   

   client.HelloWorld service = new client.HelloWorldService().getHelloWorldPort();       //invoke business method       System.out.println(service.sayHelloWorldFrom("Duke"));

   
   and run WSClient.main to see the result as:
   
   
   
   Now you deployed a Metro Web service using light-weight Endpoint API.  The bundled plugin version is 0.9 build 2 and the steps are so much cleaner from 0.7 version of the plugin.
   
   Read more about Web Services support in IntelliJ IDEA.
9. Deploying this Web service on GlassFish is really simple.
1. Create a new GlassFish configuration as explained above.
2. Run the project using this configuration and the Web service is now hosted at "http://localhost:8080/GlassFishWSWeb/services/HelloWorld?wsdl".
3. Generate a client using the steps described above.

• JEEAS-180 does not allow an application to be re-deployed to GlassFish and that's why the examples above use different projects.
• JEEAS-181  asks for better integration of GlassFish logs in the IDE.
• JEEAS-182 require support for GlassFish v3 in the GlassFish plugin. Please help by voting for this issue.
• WSVC-61 reports the errors generated in Web services client code

• Debugging Apps on GlassFish using IntelliJ
• GlassFish on Eclipse Ganymede
• NetBeans 6.5 M1: GlassFish v3 + Rails
• Screencast #24: Getting Started with GlassFish v3 TP2
• NetBeans IDE and GlassFish
• GlassFish Plugins

Posted by Arun Gupta in webservices  |  Comments[10]

GlassFish Metro Web Services Training Course

Interested in understanding the nitty gritty details of how Metro in GlassFish provides Secure, Reliable, Transactional and .NET 3.0 interoperable Web services ? You can certainly read all about it in Metro Users Guide, post questions to Metro Forum, subscribe to Metro Blogs or The Aquarium.

But now there is a new 5 hours Web-based course, WTMB-SAS-1500, from Sun Training. The course content is organized in 5 different modules: WMT-SAS-1543:Adding Quality of Service and .NET Interoperability to Web Services WMT-SAS-2544: Creating Reliable and Secure Interoperable Web Services WMT-SAS-2545: Creating Transactional Web Services WMT-SAS-2546: Working With the Web Services Policy WMT-SAS-2547: Brokered Trust Each module explains What/Why/How of each technology and then shows a complete demo using NetBeans on how to use that feature. The course can be taken within 365 days after the purchase. Read more details here.

• WMT-SAS-1536: GlassFish Application Server Introduction
• WMTB-SAS-1600: GlassFish Application Server Administration Bundle

Posted by Arun Gupta in webservices  |  Comments[7]

BizTalk Services SDK, GlassFish and Metro

Microsoft BizTalk R11 CTP was released last week and now contains a sample that is based on GlassFish, Metro and NetBeans. Even though today is April 1st, this is not intended to be an April Fool's Day joke. Read more about the sample in this blog entry. The relevant bits from the entry are quoted below:

The sample shows how to use the BizTalk Services Identity Security Token Service (STS) to secure the communication between a Java client and a Java service providing federated authentication and claims-based authorization. The sample, which you can find in ./Samples/OtherPlatforms/StandaloneAccessControl/JavaEE5 once you installed the SDK, is a pure Java sample not requiring any of our bits on either the service or client side. The interaction with our services is purely happening on the wire.

The Metro team over at Sun Microsystems has made a very significant contribution to making this all work. Before we started making changes to accommodate Java, there would have been very little hope for anyone to get this seemingly simple scenario to work. We had to make quite a few changes even though our service did follow the specs.

As a result of this collaboration, Metro 1.2 is going to be a better and more interoperable release for the Sun's customers and the greater Java community and BizTalk Services as well as our future identity products will be better and more interoperable, too. Win-Win. Thank you, Sun.

Thank you Microsoft for adding this sample to the BizTalk Services SDK.

Metro team demonstrated a similar demo at JavaOne 2007. The demo shows how an Excel 2007 client can invoke a secure and reliable endpoint deployed on GlassFish. The entire source code for the sample, along with instructions to build, are available here.

This is possible today because of our participation in previous 6 plugfests (Mar 2008, Nov 2007, Jul 2007, Oct 2006, Mar 2006, Nov 2005) hosted by Microsoft.

Technorati: glassfish netbeans metro webservices biztalk microsoft interoperability

Posted by Arun Gupta in webservices  |  Comments[3]

Slides for St Louis & Kansas City Developer Update Meetings

I presented on GlassFish and Metro in Developer Update meetings in St Louis & Kansas City. The slides are available here. The demos shown in the talk can be seen at:

• Secure and Reliable Web service development and deployment using NetBeans IDE

Posted by Arun Gupta in webservices  |  Comments[3]

Rails powered by GlassFish & jMaki @ The Server Side Java Symposium, Las Vegas - Mar 26, 2008

If you want to learn more about:

• How to use GlassFish as development & deployment platform for Rails applications ?
• How GlassFish v3 Gem provides a "green" alternative to WEBrick & Mongrel ?
• How to use NetBeans & jMaki plug-in to embed rich widgets in your Rails applications ?

Posted by Arun Gupta in web2.0  |  Comments[1]

Travel Schedule - Next 5 weeks

Here is my travel schedule for next 5 weeks:

• How Metro provides enterprise-grade open source Web services stack for meeting all your needs
• How jMaki allows you to create Rich Internet Applications
• How Rails applications can be powered by GlassFish & jMaki
• Asynchronous Ajax that allows you to scale your applications tremendously
• And any other topic that you are interested in :)

Posted by Arun Gupta in General  |  Comments[2]

TOTD #23: JavaFX Client invoking a Metro endpoint

This TOTD is inspired by Learning JavaFX Script - Part 3. The original article explains how to invoke a Web service from a JavaFX client using NetBeans 5.5.1 and GlassFish v1. Newer version of both NetBeans and GlassFish are available since the article was written. This TOTD (tip of the day) explains how to invoke a Metro endpoint deployed on GlassFish v2 from a JavaFX client - all using NetBeans 6.

1. Following screencast #ws7, create a plain (without Security or Reliability enabled) Metro endpoint using NetBeans 6 and GlassFish v2.
2. In NetBeans 6 IDE, install the JavaFX plugin as described here.
3. Create Web service client library - Creating a Web service client in JavaFX Script Application is causing a NullPointerException (issue #126352). The workaround I used is to create a separate library with client-side artifacts and then include it as dependency in the JavaFX client project.
   1. Create a new project of type "Java Class Library" as shown below:
      
      
      
      and click on "Finish".
   2. Enter the project name as "MetroClientLibrary" as shown below:
      
      
      
      and click on "Finish".
   3. Right-click on the newly created project, select "New", "Web Service Client...".
   4. Click on "Browse..." button next to "Project" radio button and select the deployed Web service from Metro endpoint project. If the Web service is deployed on a different machine then you may specify the WSDL URL. Specify the package name "client" as shown below:
      
      
      
      and click on "Finish".
   5. Once the Web service client-side artifacts are generated (indicated by expandable Web Service References tree node), right-click on the project and select "Build". This generates a JAR file that will be utilized later. The location of this jar file is shown in the Output console. In our case, it is
      
      C:\workarea\samples\javafx\MetroClientLibrary\dist\MetroClientLibrary.jar.
4. Create JavaFX project
   1. Create a new JavaFX project by right-clicking in the Project explorer, selecting "New Project" and entering the values as shown below:
      
      
   2. Click on "Next >" and enter the values as shown below:
      
      
      
      and click on "Finish".
   3. Right-click on the newly created project, "Properties", "Libraries", "Add JAR/Folder" and select the JAR file created in "MetroClientLibrary" project as shown below:
      
      
      
      and click on "OK".
      
      Notice, Java SE 6 U4 is used to compile and run this project. If you are using an earlier version of Java SE 6, then you need to override JAX-WS 2.1 and JAXB 2.1 jars using endorsed mechanism as explained here. The classes in these jars are already bundled in Java SE 6 U4.
   4. In metroclient.Main.fx file, replace "// place your code here" with the following code:
      
      import java.lang.*;
import javafx.ui.*;

import client.NewWebServiceService;
import client.NewWebService;

class InputModel {
    attribute name: String?;
}
var inputModel = InputModel { };
var nameField = TextField { };
nameField.action = operation() {
    inputModel.name = nameField.value;
};

class ButtonClickModel {
    attribute result: String;
}
var model = new ButtonClickModel();

Frame {
    title: "JavaFX Client -> Metro endpoint"
    width: 350
    height: 200
    content: GridPanel {
        rows: 3
        vgap: 5
        cells:
        [SimpleLabel {
            text: "Name : "
        },
        nameField,
        SimpleLabel {
            text: "Result from endpoint : "
        },
        Label {
            text: bind "{model.result}"
        },
        Button {
            text: "Invoke Web Service!"
            action: operation() {
                do {
                    try {
                        var service: NewWebServiceService = new NewWebServiceService();
                        var port: NewWebService = service.getNewWebServicePort();
                        var name: String = "{nameField.value}";
                        var result: String = port.sayHello(name);
                        System.out.println("response: {result}");
                        model.result = result;
                    } catch (e:Exception) {
                        System.out.println("exception: {e}");
                    }
                }
            }
        }
        ]
    }
    visible: true
};
5. Invoke the JavaFX client project
   1. Right-click on the recently create project ("MetroClient") and select "Run Project". The following window is displayed:
      
      
   2. Enter "Duke" in the text box and click on "Invoke Web Service!" button to see the result as shown below:
      
      

After following these steps, you have created a JavaFX client that can invoke a Metro endpoint project deployed on GlassFish - all using NetBeans IDE.

Now Metro provides secure, reliable, transactional and .NET 3.0 interoperable Web service. Have you tried/used any of those features in Metro ?

Please leave suggestions on other TOTD that you'd like to see. A complete archive is available here.

Technorati: totdd javafx metro glassfish netbeans webservices

Posted by Arun Gupta in webservices  |  Comments[13]