| <!-- | |
| ~ Licensed to the Apache Software Foundation (ASF) under one | |
| ~ or more contributor license agreements. See the NOTICE file | |
| ~ distributed with this work for additional information | |
| ~ regarding copyright ownership. The ASF licenses this file | |
| ~ to you under the Apache License, Version 2.0 (the | |
| ~ "License"); you may not use this file except in compliance | |
| ~ with the License. You may obtain a copy of the License at | |
| ~ | |
| ~ http://www.apache.org/licenses/LICENSE-2.0 | |
| ~ | |
| ~ Unless required by applicable law or agreed to in writing, | |
| ~ software distributed under the License is distributed on an | |
| ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| ~ KIND, either express or implied. See the License for the | |
| ~ specific language governing permissions and limitations | |
| ~ under the License. | |
| --> | |
| <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" | |
| "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> | |
| <html lang="en" xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"> | |
| <head> | |
| <meta name="generator" content= | |
| "HTML Tidy for Windows (vers 14 June 2007), see www.w3.org" /> | |
| <meta http-equiv="content-type" content="" /> | |
| <title>POJO Web Services using Axis2</title> | |
| <link href="../css/axis-docs.css" rel="stylesheet" type="text/css" | |
| media="all" /> | |
| </head> | |
| <body lang="en" xml:lang="en"> | |
| <h1>POJO Web Services using Apache Axis2</h1> | |
| <p>Want a quick way to get a Web service up and running in no time? | |
| Then you should consider creating a Plain Old Java Object (POJO) | |
| that you can deploy using Apache Axis2 on Apache Tomcat. POJOs are | |
| fast to build and easy to maintain, which means you'll save a lot | |
| of time building and debugging your code. This document shows you | |
| how to take a simple POJO, and deploy it on Apache Tomcat as a Web | |
| service in the exploded directory format. You'll also learn how to | |
| take a POJO based on the Spring Framework, and deploy that as an | |
| AAR packaged Web service on Tomcat.</p> | |
| <h2>Content</h2> | |
| <ul> | |
| <li><a href="#introduction">Introduction</a></li> | |
| <li><a href="#pojo">The POJO</a></li> | |
| <li><a href="#pojows">POJO Web service using Apache Axis2 and | |
| Tomcat</a> | |
| <ul> | |
| <li><a href="#definingservice">Defining the Service: | |
| services.xml</a></li> | |
| </ul> | |
| </li> | |
| <li><a href="#buildpojows">Building the POJO Web Service Using | |
| Ant</a></li> | |
| <li><a href="#testingpojows">Testing the POJO Web Service Using | |
| RPCServiceClient</a> | |
| <ul> | |
| <li><a href="#limitationspojo">Limitations and Strengths of | |
| POJO</a></li> | |
| </ul> | |
| </li> | |
| <li><a href="#springpojows">Spring-based POJO Web Service</a> | |
| <ul> | |
| <li><a href="#quickintro">Quick Introduction</a></li> | |
| <li><a href="#servicedef">The Service Definition: | |
| services.xml</a></li> | |
| <li><a href="#initializingspring">Initializing the Spring | |
| application context: SpringInit</a></li> | |
| <li><a href="#testingrpc">Testing Using an | |
| RPCServiceClient</a></li> | |
| </ul> | |
| </li> | |
| <li><a href="#jsr181pojows">JSR 181 Annotation support with POJO Web services</a> | |
| <ul> | |
| <li><a href="#jsr181definingservice">Sample JSR 181 POJO Web Service</a></li> | |
| </ul> | |
| </li> | |
| <li><a href="#summary">Summary</a></li> | |
| <li><a href="#furtherstudy">For Further Study</a></li> | |
| </ul> | |
| <a name="introduction" id="introduction"></a> | |
| <h2>Introduction</h2> | |
| <p>The task of building a Web service can sometimes be | |
| overwhelming, but not with POJOs! The old-school Plain Old Java | |
| Object is a simple and quick way to get most, if not all, of your | |
| currently existing Java classes up on the Web as readily accessible | |
| Web services. This document describes how to build a POJO-style Web | |
| service with Apache Axis2 and Tomcat. It is organized as | |
| follows:</p> | |
| <ul> | |
| <li>The POJO: This is the Java class that you'll use throughout | |
| this document</li> | |
| <li>POJO deployment</li> | |
| <li>Test the POJO Web service using an RPC based client</li> | |
| <li>Limitations of straight POJO</li> | |
| <li>Spring-based POJO Web service and deployment</li> | |
| </ul> | |
| <p>The code for the document can be found at | |
| Axis2_HOME/samples/pojoguide and Axis2_HOME/samples/pojoguidespring | |
| once you extract the <a href= | |
| "../../download/@axis2_version_dir@/download.html#std-bin">Axis2 | |
| Standard Distribution</a>. (It is better to get it now as it will | |
| help you to follow along.) Let's get started.</p> | |
| <a name="pojo" id="pojo"></a> | |
| <h2>The POJO</h2> | |
| <p>The POJO you'll be using throughout this document is a Weather | |
| service POJO that consists of two classes: WeatherService and | |
| Weather. Weather contains the Weather data: Temperature, forecast, | |
| rain (will it rain?), and howMuchRain (See Code Listing 1).</p> | |
| <p><b>Code Listing 1: The Weather POJO</b></p> | |
| <pre> | |
| package sample.pojo.data; | |
| public class Weather{ | |
| float temperature; | |
| String forecast; | |
| boolean rain; | |
| float howMuchRain; | |
| public void setTemperature(float temp){ | |
| temperature = temp; | |
| } | |
| public float getTemperature(){ | |
| return temperature; | |
| } | |
| public void setForecast(String fore){ | |
| forecast = fore; | |
| } | |
| public String getForecast(){ | |
| return forecast; | |
| } | |
| public void setRain(boolean r){ | |
| rain = r; | |
| } | |
| public boolean getRain(){ | |
| return rain; | |
| } | |
| public void setHowMuchRain(float howMuch){ | |
| howMuchRain = howMuch; | |
| } | |
| public float getHowMuchRain(){ | |
| return howMuchRain; | |
| } | |
| } | |
| </pre> | |
| <p>And here's the WeatherService class, shown in Code Listing | |
| 2.</p> | |
| <p><b>Code Listing 2: The WeatherService class</b></p> | |
| <pre> | |
| package sample.pojo.service; | |
| import sample.pojo.data.Weather; | |
| public class WeatherService{ | |
| Weather weather; | |
| public void setWeather(Weather weather){ | |
| this.weather = weather; | |
| } | |
| public Weather getWeather(){ | |
| return this.weather; | |
| } | |
| } | |
| </pre> | |
| <p>Note that it's all just straight POJOs with field items and | |
| <code>getter</code> and <code>setter</code> methods for each field. | |
| Next, you'll take a look at what you need to do to make it ready | |
| for deployment on Apache Axis2 and Tomcat.</p> | |
| <a name="pojows" id="pojows"></a> | |
| <h2>POJO Web Service Using Apache Axis2 and Tomcat</h2> | |
| <p>Got the POJOs? Great. This section will show you how to package | |
| them in the exploded directory format for easy deployment. First | |
| you'll look at the services.xml file that defines the Web service, | |
| and then you'll build the files using <a href= | |
| "http://ant.apache.org/">Apache Ant</a>, and deploy the Web service | |
| on Tomcat.</p> | |
| <a name="definingservice" id="definingservice"></a> | |
| <h3>Defining the Service: services.xml</h3> | |
| <p>Before Axis2 can understand what is going on, you have to tell | |
| it to use the services.xml file. Let's get right into it (see Code | |
| Listing 3).</p> | |
| <p><b>Code Listing 3: The service definition file: | |
| services.xml</b></p> | |
| <pre> | |
| <service name="WeatherService" scope="application"> | |
| <description> | |
| Weather POJO Service | |
| </description> | |
| <messageReceivers> | |
| <messageReceiver | |
| mep="http://www.w3.org/2004/08/wsdl/in-only" | |
| class="org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver"/> | |
| <messageReceiver | |
| mep="http://www.w3.org/2004/08/wsdl/in-out" | |
| class="org.apache.axis2.rpc.receivers.RPCMessageReceiver"/> | |
| </messageReceivers> | |
| <parameter name="ServiceClass"> | |
| sample.pojo.service.WeatherService | |
| </parameter> | |
| </service> | |
| </pre> | |
| <p>The name of the service is specified as WeatherService and the | |
| scope of the service is application. As you can see in the | |
| WeatherService POJO, there are two methods: IN-ONLY method and | |
| IN-OUT method. Hence the messageReceiver elements are ordered | |
| within the messageReceivers tag. Lastly, the ServiceClass parameter | |
| specifies the class of the Web service, which is | |
| sample.pojo.service.WeatherService. When operations of your Web | |
| service get called, the methods of the WeatherService class will be | |
| called. Next let usl take a look at an easy method of building your | |
| application using Ant.</p> | |
| <a name="buildpojows" id="buildpojows"></a> | |
| <h2>Building the POJO Web Service Using Apache Ant</h2> | |
| <p><a href="http://ant.apache.org/">Ant</a> is a slick build tool. | |
| It helps reduce the time to build the applications, and several of | |
| the Axis2 command-line tools create the build.xml files for you. | |
| (We will not be going into too much detail on the build.xml file | |
| that you'll be using.)</p> | |
| <p>Here are the main Ant tasks you'll be using:</p> | |
| <ul> | |
| <li>generate.service -- This Ant task builds the service relevant | |
| source, and copies the files to build/WeatherService</li> | |
| <li>rpc.client -- This task builds the client relevant files, | |
| builds a JAR at <em>build/lib/rpc-client.jar</em>, and then runs | |
| the client</li> | |
| </ul> | |
| <p>Before you can build the source, you'll need to download the | |
| Axis2 @axis2_version@-bin and @axis2_version@-war distributions | |
| from <a href= | |
| "../../download/@axis2_version_dir@/download.html">here</a>. Then | |
| modify the following line inside the build.xml file (in the | |
| Axis2_HOME/samples/pojoguide directory in the extracted Axis2 | |
| @axis2_version@ Standard Binary (bin) Distribution) :</p> | |
| <pre> | |
| <property name="axis2.home" value="c:\apps\axis2" /> | |
| </pre> | |
| <p>This modification contains the path to the root of the unzipped | |
| Axis2 @axis2_version@-bin <a href= | |
| "../../download/@axis2_version_dir@/download.html#std-bin">download</a>. | |
| With that explanation, you'll now build the source by typing the | |
| following: ant</p> | |
| <p>The following directory format should now exist at | |
| build/WeatherService:</p> | |
| <pre> | |
| - WeatherService | |
| - META-INF | |
| - services.xml | |
| - sample | |
| - pojo | |
| - data | |
| - Weather.class | |
| - service | |
| - WeatherService.class | |
| </pre> | |
| <p>Simple isn't it? An excellent way to dive into Web services | |
| development.</p> | |
| <p>Now get a <a href="http://tomcat.apache.org/">Tomcat</a> | |
| distribution (I used v5.5), and start it up by running | |
| <em>bin/startup.bat</em> or <em>bin/startup.sh</em>. Once it's | |
| running, deploy the Axis2 @axis2_version@-war by copying the | |
| axis2.war file to Tomcat's webapps directory. Tomcat will proceed | |
| by deploying axis2 and un-archiving it into the webapps directory. | |
| Now copy the WeatherService directory that was created at the time | |
| of building our project to: | |
| <em><tomcat-home>/webapps/axis2/WEB-INF/services</em>.</p> | |
| <p>The service should deploy quickly. You willl test the Web | |
| service using the RPCServiceClient in the next section.</p> | |
| <a name="testingpojows" id="testingpojows"></a> | |
| <h2>Testing the POJO Web Service Using RPCServiceClient</h2> | |
| <p>OK, so the Web service should be running on Tomcat. Now you'll | |
| build a simple RPCServiceClient and test the POJO Web service. | |
| You'll first start out with the class constructs, creating the | |
| RPCServiceClient and initializing the values of the Weather class | |
| within the Web service (See Code Listing 4).</p> | |
| <p><b>Code Listing 4: Setting the weather</b></p> | |
| <pre> | |
| package sample.pojo.rpcclient; | |
| import javax.xml.namespace.QName; | |
| import org.apache.axis2.AxisFault; | |
| import org.apache.axis2.addressing.EndpointReference; | |
| import org.apache.axis2.client.Options; | |
| import org.apache.axis2.rpc.client.RPCServiceClient; | |
| import sample.pojo.data.Weather; | |
| public class WeatherRPCClient { | |
| public static void main(String[] args1) throws AxisFault { | |
| RPCServiceClient serviceClient = new RPCServiceClient(); | |
| Options options = serviceClient.getOptions(); | |
| EndpointReference targetEPR = new EndpointReference( | |
| <b>"http://localhost:8080/axis2/services/WeatherService");</b> | |
| options.setTo(targetEPR); | |
| // Setting the weather | |
| QName opSetWeather = | |
| new QName("http://service.pojo.sample/xsd", "<b>setWeather"); | |
| Weather w = new Weather(); | |
| w.setTemperature((float)39.3); | |
| w.setForecast("Cloudy with showers"); | |
| w.setRain(true); | |
| w.setHowMuchRain((float)4.5); | |
| Object[] opSetWeatherArgs = new Object[] { w }; | |
| serviceClient.invokeRobust(opSetWeather, opSetWeatherArgs);</b> | |
| ... | |
| </pre> | |
| <p>The most interesting code to note is in bold font. Notice the | |
| targetEPR variable you create, setting the endpoint reference to | |
| http://localhost:8080/axis2/services/WeatherService. This is where | |
| you deployed it on Axis2. You can also verify this by asking Axis2 | |
| to list its services by going to the following URL: | |
| http://localhost:8080/axis2/services/listServices.</p> | |
| <p>Next the opSetWeather variable gets setup, pointing to the | |
| setWeather operation. Then the Weather data is created and | |
| initialized. Lastly, you invoke the Web service, which initializes | |
| the weather data (you'll verify this soon). Next you get back the | |
| weather data (see Code Listing 5).</p> | |
| <p><b>Code Listing 5: Getting the weather data</b></p> | |
| <pre> | |
| ... | |
| serviceClient.invokeRobust(opSetWeather, opSetWeatherArgs); | |
| // Getting the weather | |
| QName opGetWeather = | |
| new QName("http://service.pojo.sample/xsd", "<b>getWeather"); | |
| Object[] opGetWeatherArgs = new Object[] { }; | |
| Class[] returnTypes = new Class[] { Weather.class }; | |
| Object[] response = serviceClient.invokeBlocking(opGetWeather, | |
| opGetWeatherArgs, returnTypes); | |
| Weather result = (Weather) response[0]; | |
| if (result == null) { | |
| System.out.println("Weather didn't initialize!"); | |
| return; | |
| }</b> | |
| ... | |
| </pre> | |
| <p>First you set the operation in opGetWeather to getWeather. Then | |
| you create an empty argument list. Note that this time you expect | |
| something back from the Web service, and so you create a list of | |
| return types. Then you invoke the Web service using a blocking call | |
| and wait for the weather data to be returned to you, and you place | |
| it in the result variable. Lastly, you make sure it isn't null and | |
| that it was successfully initialized by the previous call to | |
| setWeather. Now display the data to verify it. (see Code Listing | |
| 6).</p> | |
| <p><b>Code Listing 6: Displaying the data</b></p> | |
| <pre> | |
| ... | |
| return; | |
| } | |
| // Displaying the result | |
| <b>System.out.println("Temperature : " + | |
| result.getTemperature()); | |
| System.out.println("Forecast : " + | |
| result.getForecast()); | |
| System.out.println("Rain : " + | |
| result.getRain()); | |
| System.out.println("How much rain (in inches) : " + | |
| result.getHowMuchRain()); | |
| }</b> | |
| } | |
| </pre> | |
| <p>You should receive the data shown in Code Listing 7.</p> | |
| <p><b>Code Listing 7: Output from running the client</b></p> | |
| <pre> | |
| rpc.client.run: | |
| [java] Temperature : 39.3 | |
| [java] Forecast : Cloudy with showers | |
| [java] Rain : true | |
| [java] How much rain (in inches) : 4.5 | |
| </pre> | |
| <p>Excellent! You have a working POJO Web service! Next you'll | |
| quickly morph this one into a Spring based POJO.</p> | |
| <a name="limitationspojo" id="limitationspojo"></a> | |
| <h3>Limitations and Strengths of POJO</h3> | |
| <p>We've covered the strengths of using POJO based Web services, | |
| but what about any limitations? One main limitation of POJO based | |
| Web services is the lack of initialization support (meaning that | |
| you have to go into your Web service and initialize the values | |
| before the Web service is completely useful). However, you'll soon | |
| see how to overcome that limitation with a Spring based POJO, which | |
| is covered next.</p> | |
| <a name="springpojows" id="springpojows"></a> | |
| <h2>Spring-based POJO Web Service</h2> | |
| <p>Spring is a hot framework for J2EE and makes bean usage a | |
| breeze. You'll use it in this section to create a Spring based POJO | |
| Web service. For this section, you'll need the spring.jar from the | |
| latest 1.x Spring download.</p> | |
| <a name="quickintro" id="quickintro"></a> | |
| <h3>Quick Introduction</h3> | |
| <p>If you take a look at the source code of this document in | |
| Axis2_HOME/samples/pojoguidespring (to see how the Spring based | |
| POJO Web service is coded), you can see that the Weather class | |
| didn't change at all and the WeatherService class only got its name | |
| changed to WeatherSpringService.</p> | |
| <p>You'll also notice an applicationContext.xml file, which we'll | |
| cover later. It is used to setup the beans used in our Web | |
| service.</p> | |
| <p>Now you might wonder what the SpringInit.java class is for. This | |
| service is necessary to initialize the Spring Framework's | |
| application context.</p> | |
| <p>The client is pretty much the same, except you won't use it to | |
| initialize the Weather data in the Web service, since Spring does | |
| that for you using Inversion of Control (IoC), which is covered | |
| next.</p> | |
| <a name="servicedef" id="servicedef"></a> | |
| <h3>The Service Definition: services.xml</h3> | |
| <p>Since the core POJOs didn't change, you move straight to the | |
| services.xml file. It's a bit longer this time because it | |
| instantiates two services in one file (see Code Listing 7).</p> | |
| <p><b>Code Listing 7: Defining the services: services.xml</b></p> | |
| <pre> | |
| <serviceGroup> | |
| <service <b>name="SpringInit" | |
| class="sample.spring.service.SpringInit</b>"> | |
| <description> | |
| This web service initializes Spring. | |
| </description> | |
| <b><parameter name="ServiceClass"> | |
| sample.spring.service.SpringInit | |
| </parameter> | |
| <parameter name="ServiceTCCL">composite</parameter> | |
| <parameter name="load-on-startup">true</parameter></b> | |
| <operation name="springInit"> | |
| <messageReceiver | |
| class="org.apache.axis2.receivers.RawXMLINOutMessageReceiver"/> | |
| </operation> | |
| </service> | |
| <service <b>name="WeatherSpringService</b>"> | |
| <description> | |
| Weather Spring POJO Axis2 AAR deployment | |
| </description> | |
| <b><parameter name="ServiceClass"> | |
| sample.spring.service.WeatherSpringService | |
| </parameter> | |
| <parameter name="ServiceObjectSupplier"> | |
| org.apache.axis2.extensions.spring.receivers.SpringAppContextAwareObjectSupplier | |
| </parameter> | |
| <parameter name="SpringBeanName"> | |
| weatherSpringService | |
| </parameter></b> | |
| <messageReceivers> | |
| <messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-only" | |
| class="org.apache.axis2.rpc.receivers.RPCInOnlyMessageReceiver"/> | |
| <messageReceiver mep="http://www.w3.org/2004/08/wsdl/in-out" | |
| class="org.apache.axis2.rpc.receivers.RPCMessageReceiver"/> | |
| </messageReceivers> | |
| </service> | |
| </serviceGroup> | |
| </pre> | |
| <p>You'll see a few familiar items in the above listing, and | |
| several changes. Once again, the items in bold are most important. | |
| The ServiceTCCL property under the SpringInit service makes sure | |
| that the Spring class loader is used for the Web service, allowing | |
| it to properly instantiate the Spring application context. The | |
| load-on-startup variable is a must-have so that the service loads | |
| up immediately on startup, creating the Spring application context. | |
| The WeatherSpringService stays similar to the WeatherService | |
| previously with a couple of additions: The ServiceObjectSupplier | |
| provides the service with the Spring application context, making it | |
| "Spring Aware."</p> | |
| <p>Lastly, the SpringBeanName points to the name of the bean | |
| associated with this Web service, which is defined in the | |
| applicationContext.xml file (essentially the WeatherSpringService). | |
| We'll cover the applicationContext.xml file next. The application | |
| context, applicationContext.xml file tells the Spring Framework | |
| what beans are defined. For this example, you'll define three of | |
| them (see Code Listing 8).</p> | |
| <p><b>Code Listing 8: Defining the application context: | |
| applicationContext.xml</b></p> | |
| <pre> | |
| <?xml version="1.0" encoding="UTF-8"?> | |
| <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" | |
| "http://www.springframework.org/dtd/spring-beans.dtd"> | |
| <beans> | |
| <bean id="<b>applicationContext</b>" class= | |
| "org.apache.axis2.extensions.spring.receivers.ApplicationContextHolder" /> | |
| <b><bean id="weatherSpringService" | |
| class="sample.spring.service.WeatherSpringService"> | |
| <property name="weather" ref="weatherBean"/> | |
| </bean> | |
| <bean id="weatherBean" class="sample.spring.bean.Weather"> | |
| <property name="temperature" value="89.9"/> | |
| <property name="forecast" value="Sunny"/> | |
| <property name="rain" value="false"/> | |
| <property name="howMuchRain" value="0.2"/> | |
| </bean></b> | |
| </beans> | |
| </pre> | |
| <p>The first one is Axis2's hook into Spring's application context | |
| (needed since AAR deployment is quite different from regular WAR | |
| deployment). Next, you define the bean to which the services.xml | |
| file points, which is the weatherSpringService bean that points to | |
| the WeatherSpringService class. It has one field property that gets | |
| initialized by the Spring Framework - weather. This will be set to | |
| the weatherBean. The weatherBean is an instantiation of the Weather | |
| class that holds information on the weather. Spring will initialize | |
| it to the values shown above, and set the Weather object in the | |
| WeatherSpringService class to the weatherBean instantiation. Thus, | |
| when you deploy the Web service, you won't have to instantiate the | |
| values because they'll already be set.</p> | |
| <p>Next up is the SpringInit class.</p> | |
| <a name="initializingspring" id="initializingspring"></a> | |
| <h3>Initializing the Spring Application Context: SpringInit</h3> | |
| <p>Without the Spring application context being initialized | |
| quickly, you'll run into problems. The SpringInit class initializes | |
| the Spring application context on startup because it is a | |
| ServiceLifeCycle class whose startUp method gets called upon | |
| loading the class (and because its load-on-startup property is set | |
| in the services.xml file). The only code worth mentioning in this | |
| class is shown in Code Listing 9.</p> | |
| <p><b>Code Listing 9: SpringInit's startUp method</b></p> | |
| <pre> | |
| public void startUp(ConfigurationContext ignore, | |
| AxisService service) { | |
| <b>ClassLoader classLoader = service.getClassLoader(); | |
| ClassPathXmlApplicationContext appCtx = new | |
| ClassPathXmlApplicationContext</b>(new String[] | |
| {"<b>applicationContext.xml</b>"}, | |
| false); | |
| <b>appCtx.setClassLoader(classLoader); | |
| appCtx.refresh();</b> | |
| if (logger.isDebugEnabled()) { | |
| logger.debug("\n\nstartUp() set spring classloader " + | |
| "via axisService.getClassLoader() ... "); | |
| } | |
| } | |
| </pre> | |
| <p>Note that this method retrieves the Spring class loader, and | |
| creates an application context with applicationContext.xml as the | |
| parameters. This new application context then gets the Spring class | |
| loader as its class loader. The Spring Framework is now up and | |
| ready for our WeatherSpringService.</p> | |
| <h3>Build and Deploy Using Apache Axis2 and Tomcat</h3> | |
| <p>Your POJO is now ready for primetime within the Spring | |
| Framework. Before you build, you'll first need to make sure the | |
| axis2-spring-@axis2_version@.jar and spring.jar files are in the | |
| project's <em>Axis2_HOME/lib</em> directory.</p> | |
| <p><strong>Note:</strong> The service will not deploy if you add | |
| the above .jar files to the service archive due to class loding | |
| issues.</p> | |
| <p>Now build the source and create an AAR file by typing: ant</p> | |
| <p>It'll be created at <em>target/WeatherSpringService.aar</em>. | |
| Copy it to | |
| <em><tomcat-home>/webapps/axis2/WEB-INF/services</em>, and | |
| Axis2 should deploy it quickly.</p> | |
| <p>Next, test the Web service to see whether Spring will really | |
| initialize the weather data for you.</p> | |
| <a name="testingrpc" id="testingrpc"></a> | |
| <h3>Testing Using an RPCServiceClient</h3> | |
| <p>It's as simple as it was for the other Web service, except this | |
| time type: ant rpc.client</p> | |
| <p>Feel free to browse the code for this client in | |
| src/client/WeatherSpringRPCClient.java. Essentially, this client | |
| does the same thing as the client testing the WeatherService. | |
| Except that this one skips the "Setting the weather" task since the | |
| weather data should have already been set by the Spring framework | |
| at startup.</p> | |
| <p>Thus, you should get the following as output from the | |
| client:</p> | |
| <pre> | |
| run.client: | |
| [javac] Compiling 1 source file to C:\axis2-@axis2_version@\samples\pojoguidespring\build\cl | |
| asses | |
| <b>[java] Temperature : 89.9 | |
| [java] Forecast : Sunny | |
| [java] Rain : false | |
| [java] How much rain (in inches) : 0.2</b> | |
| </pre> | |
| <p>Which are exactly the values you set in the | |
| applicationContext.xml file!</p> | |
| <a name="jsr181pojows" id="jsr181pojows"></a> | |
| <h2>SR 181 Annotation support with POJO Web services</h2> | |
| <p>Got the JSR 181 annotated POJOs? Great. This section will show you how to package | |
| them in to a jar format for easy pojo deployment with the help of Axis2 POJO deployer. | |
| First create the JSR 181 Annotated class.</p> | |
| <a name="jsr181definingservice" id="jsr181definingservice"></a> | |
| <h3>Sample JSR 181 POJO Web Service</h3> | |
| <p>For example lets assume that our JSR 181 Annotated class is. | |
| </p> | |
| <pre> | |
| @WebService(name="JSR181TestService" targetNamespace="http://www.test.org/jsr181/Example") | |
| @SOAPBinding(style=SOAPBinding.Style.RPC) | |
| public class TestService { | |
| @WebMethod(operationName = "echoMethod") | |
| public String echoString(@WebParam(name="stringIn")String s){ | |
| return s; | |
| } | |
| } | |
| </pre> | |
| <p>Compile this with the help of the Axis2 libs in to a jar file. | |
| Add one additional like to the axis2.xml to deploy jar files on the pojo directory | |
| </p> | |
| <pre> | |
| Ex: <deployer extension=".jar" directory="pojo" class="org.apache.axis2.deployment.POJODeployer"/> | |
| </pre> | |
| <p>Create a pojo directory if its not already there under the Axis2 repository and put the JSR 181 Annotated | |
| jar inside that and start Axis2. You will see the service up and running !!</p> | |
| <a name="summary" id="summary"></a> | |
| <h2>Summary</h2> | |
| <p>Apache Axis2 is an excellent way to expose your POJOs as Web | |
| services. Spring adds greater flexibility to your POJOs by adding | |
| beans support and initialization abilities, along with all the | |
| other goodies provided by the Spring framework.</p> | |
| <a name="furtherstudy" id="furtherstudy"></a> | |
| <h2>For Further Study</h2> | |
| <p>Apache Axis2-<a href= | |
| "http://ws.apache.org/axis2/">http://ws.apache.org/axis2/</a></p> | |
| <p>Axis2 Architecture-<a href= | |
| "http://ws.apache.org/axis2/1_0/Axis2ArchitectureGuide.html">http://ws.apache.org/axis2/1_0/Axis2ArchitectureGuide.html</a></p> | |
| <p>Introduction to Apache Axis2-<a href= | |
| "http://www.redhat.com/magazine/021jul06/features/apache_axis2/">http://www.redhat.com/magazine/021jul06/features/apache_axis2/</a></p> | |
| <p>Working With Apache Axis2-<a href= | |
| "http://www.wso2.net/articles/axis2/java/2006/09/13/working-with-axis2">http://www.wso2.net/articles/axis2/java/2006/09/13/working-with-axis2</a></p> | |
| <p>Apache Tomcat-<a href= | |
| "http://tomcat.apache.org/">http://tomcat.apache.org</a></p> | |
| <p>Spring Framework-<a href= | |
| "http://www.springframework.org/">http://www.springframework.org/</a></p> | |
| </body> | |
| </html> |