Practice 2. SOAP & REST

Transcription

1 Enterprise System Integration Practice 2. SOAP & REST Prerequisites Practice 1. MySQL and JPA Introduction JAX-WS stands for Java API for XML Web Services. JAX-WS is a technology for building web services and clients that communicate using XML. JAX-WS allows developers to write message-oriented as well as RPCoriented web services. In JAX-WS, a web service operation invocation is represented by an XML-based protocol such as SOAP. The SOAP specification defines the envelope structure, encoding rules, and conventions for representing web service invocations and responses. These calls and responses are transmitted as SOAP messages (XML files) over HTTP. Although SOAP messages are complex, the JAX-WS API hides this complexity from the application developer. On the server side, the developer specifies the web service operations by defining methods in an interface written in the Java programming language. The developer also codes one or more classes that implement those methods. Client programs are also easy to code. ( 1. Creating a Web Service The aim of this practice is to take the code we implemented last time and generate a Web Service out of it using annotations. a. In the class ItemDAO.java implement the following methods: i. getitem(int id): it retrieves the Item with the corresponding id. ii. delete(int id): it drops the item from the database with the given id. b. Create a façade that will describe the Web Service and will call the methods in the ItemDAO.java. It will look like a copy of ItemDAO.java, in the sense that, the received

2 2 parameters and the return value of every method will be same as those of the method it is invoking (look the code below). package item; import java.util.list; import javax.ejb.ejb; public class ItemDAOwsdl ItemDAO itemdao; public void persist(item item) { itemdao.persist(item); public List<Item> getallitems() { return itemdao.getallitems(); public void delete(int id) { itemdao.delete(id); private Item getitem(int id) { return getitem(id); Note: Ideally, the ItemDAO.java could be used to describe the Web Service as well, however, some versions of GlassFish seems to have a conflict with different types of annotations (i.e., JAX-WS and JPA) in the same class. c. A service endpoint interface or service endpoint implementation (SEI) is a Java interface or class, respectively, that declares the methods that a client can invoke on the service. In our example, the façade we created above will be the service endpoint, and for this reason, we need to put annotation above the name of the class. For exposing the methods to web service clients we annotate every method

3 3 package item; import java.util.list; import javax.ejb.ejb; import javax.jws.webmethod; import javax.jws.webresult; import javax.jws.webservice; import public class ItemDAOwsdl ItemDAO public void persist(item item) { public List<Item> getallitems() { return public void delete(@webparam(name = "ʺid"ʺ) int id) = "ʺitem"ʺ) private Item getitem(@webparam(name = "ʺid"ʺ) int id) { return getitem(id); helps us to specify the name of the parameter as it appears in the generated WSDL defines the name of the return value as it appears in the generated WSDL document. d. In order to convert a Java object e.g., the Item that we retrieve in getitem(int id) method-- from and to XML, we need to annotate also the class that describes the object. For that we will use the following annotations: - Marks a java class as being mapped to an element in XML/XSD. The parameter name should be, by convention, the class name in lower camel case (the same as a java variable). annotation maps a property or field to an XML element. marks a field or property as serialized to an XML attribute.

4 4 e. The annotated class would look something @Table(name = "Item") public class Item implements Serializable { private static final long serialversionuid = 1L; // @GeneratedValue(strategy = = false) Long String String = DateAdapter.class) Date date; Note that because Date is not represented as one of the standard XML schema types, we need to define our own adapter. It would look like this: package item; import java.text.simpledateformat; import java.util.date; import javax.xml.bind.annotation.adapters.xmladapter; public class DateAdapter extends XmlAdapter<String, Date> { // the desired format private String pattern = "ʺyyyy- MM- dd"ʺ; public String marshal(date date) throws Exception { return new SimpleDateFormat(pattern).format(date); public Date unmarshal(string datestring) throws Exception { return new SimpleDateFormat(pattern).parse(dateString);

5 5 f. Run your project making a right click on your project, Run as -> Run on server. g. In the administration console, select your project and View Endpoint -> Tester h. If you select getallitems, you would get something like this: <?xml version="1.0" encoding="utf-8"?> <S:Envelope xmlns:s=" <S:Body> <ns2:getallitemsresponse xmlns:ns2=" <return id="1"> <name>car</name> <color>red</color> <date> </date> </return> </ns2:getallitemsresponse> </S:Body> </S:Envelope> The tag <return> can be modified putting the following annotation at the top of the method item ). The labels <name>, <color> and <date> correspond to the name of the variables annotated Finally, note that id appears as an attribute of the <return> label, since we put annotation for the variable id. i. Export your project as a war file and deploy it in ats.cs.ut.ee. You have to create the JDBC resource with the same name you put in persistence.xml. 2. Creating a Web Service client a. Create a java project b. Right click on the project, New -> Other -> Web Services -> Web Service Client i. Specify the address of the WSDL file. You can get this information by going to the administration console of the GlassFish server where your project is deployed, and clicking in Applications -> Your_Application -> View Endpoint. c. Create a main class and test each one of your methods you implemented. For instance ItemDAOwsdlServiceLocator a = new ItemDAOwsdlServiceLocator(); ItemDAOwsdl w = a.getitemdaowsdlport(); Item[] list = w.getallitems(); for (Item i : list) System.out.println(i.getName() +", " + i.getcolor());

6 6 3. Creating a RESTful Web Service a. Create a new façade similar to the one depicted in section 1.b. We are going to use another type of annotations (JAX-RS) in this new façade for implementing our RESTful Web Service. b. Add the annotation /Item ) above of the name of the class. In REST, stateless means that there is no client session data stored on the server. The server only records and manages the state of the resources it exposes. If there needs to be session specific data, it should be held and maintained by the client and transferred to the server with each request as specifies the relative path for a resource class or method. The URL for getting the information about all items in the database is similar to: will specify the HTTP request type of a resource. Following the convention, POST will be used to create a new Item. GET will be used to retrieve the information about a given element. PUT will update an Item. Finally, DELETE will be used to remove elements. GET, PUT and POST methods need the id of the items for finding the entities and performing the actions. Add the correct annotation for each of the methods you have implemented in your façade. d. We will over each of the method to specify the format of the response. The elements retrieved by some of the methods (i.e. getitem and getallitems) will be automatically transformed into the XML format since Item.java is already annotated (look section1.e). e. In order to receive parameters in a method, we need to add other annotations (@Path as depicted in @Path("{id") public Item getitem(@pathparam("id") int id) { return binds the parameter to a path segment. Therefore, the URL to retrieve the information of an element will be something like this: f. Once you have finished putting the annotations, then you have to add the following code in the file web.xml:

7 7 <servlet> <servlet-name>jersey REST Service</servlet-name> <servletclass>com.sun.jersey.spi.container.servlet.servletcontainer</servlet-class> <init-param> <param-name>com.sun.jersey.config.property.packages</param-name> <param-value>item</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>jersey REST Service</servlet-name> <url-pattern>/rest/*</url-pattern> </servlet-mapping> Note that the <param-value> corresponds to the name of the package where your façade describing your RESTful web service is contained. g. One you have deployed your project, you can use your browser for testing the methods that you annotated h. Look at the Response codes in the following link: i. Adapt every method of your RESTful Web Service, so that they retrieve the right codes. Try to consider as many cases as possible, no elements to show, exceptions, etc. public Response int id) { Item i = itemdao.getitem(id); if (i == null) return Response.status(404).build(); return Response.status(200).entity(i).build(); j. Normally type erasure removes generic type information such that a Response instance that contains, e.g., an entity of type List<String> appears to contain a raw List<?> at runtime. When the generic type is required to select a suitable MessageBodyWriter, the class GenericEntity may be used to wrap the entity and capture its generic type. In some cases, for instance getallitems(), it will be necessary to create a GenericEntity to encapsulate public Response getallitems() { final GenericEntity<List<Item>> entity = new GenericEntity<List<Item>>(itemdao.getAllItems()) { ; return Response.status(200).entity(entity).build();

8 8 4. Creating a Restful Web Service client a. Create a Java project b. Right click on the project -> Properties -> Java Build Path -> Add Library -> Server Runtime c. Create a main class and follow the code below for making a client for your RESTful service. WebResource can use different methods for testing all the methods you implemented. d. import javax.ws.rs.core.mediatype; import com.sun.jersey.api.client.client; import com.sun.jersey.api.client.clientresponse; import com.sun.jersey.api.client.webresource; public class Main { public static void main(string[] args) { try { Client client = Client.create(); WebResource webresource = client.resource(" ClientResponse response = webresource.accept(mediatype.text_xml).get(clientresponse.class); if (response.getstatus()!= 200) { throw new RuntimeException("Failed : HTTP error code : " + response.getstatus()); String output = response.getentity(string.class); System.out.println("Output from Server... \n"); System.out.println(output); catch (Exception e) { e.printstacktrace();