RESTful WS using Jersey Part 2 – Parameterized approach

This post is in sequel  RESTful WS using Jersey Part 1 - Hello World. It shows how to utilize parameterized urls as well as query string. Please refer Part 1 to know developing restful services from scratch. This post utilizes same example.

Parameters can be passed as part of path as well as url query string. Jersey provides two annotations @PathParam  and @QueryParam for extracting parameters from path and query respectively.

We have modified getText method to accept both kind of parameters as below

1. Complete resource class will be

package demo.resorces;

import javax.ws.rs.core.Context;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.PathParam;
import javax.ws.rs.Consumes;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.GET;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;

/**
* REST Web Service
*
* @author Yogesh
*/

@Path("hello/{UserName}")
public class HelloResource {
    @Context
    private UriInfo context;

    /** Creates a new instance of HelloResource */
    public HelloResource() {
    }

    /**
     * Retrieves representation of an instance of demo.resorces.HelloResource
     * @return an instance of java.lang.String
     */
    @GET
    //@Produces("text/plain")
    @Produces("text/html")
    public String getText(@PathParam("UserName")  String userName,
               @QueryParam("query") String query) {
        //TODO return proper representation object
        //return "Hello from GetText";
        String response = null;
        if("location".equalsIgnoreCase(query))
            response = "<html><body><h1>"+userName+"'s location is Hyderabad</h1></body></html>";
        else if ("age".equalsIgnoreCase(query))
            response = "<html><body><h1>"+userName+"'s age is 26</h1></body></html>";
        return response;
    }

    /**
     * PUT method for updating or creating an instance of HelloResource
     * @param content representation for the resource
     * @return an HTTP response with content of the updated or created resource.
     */
    @PUT
    @Consumes("text/plain")
    public void putText(String content) {
    }
}

Here two main changes are

  • Modified @path annotation so that it recognize path parameters "hello/{UserName}", whatever will after after hello/ will be considered as value for USerName parameter.
  • getText method accep parameters with thwo annotations @PathParama and @QueryParam. Both are being used to parse respective parameters from url to parameters.

2. Modify Project property to change default launch url to include parameters in url

11

3. Run the project and you will see following output

12

Change the query parameters as ?query=location

13

Comments

Post a Comment

Popular posts from this blog

Composite Design Pattern by example

Image
This post explains Composite design pattern with an example. When to use ? – Use Composite pattern when you have treat a collection of objects as they were once one thing. With Composite design pattern it is very easy to simplify operations over collection data structure. It reduces complexity of the code required if you were going to handle collection as special case. How to Use? - The Composite pattern consist of Component, Leaf and Composite Classes as shown below class diagram Component – Component declares the common interface that both the single and composite nodes will implements Leaf – The leaf class represent the singular atomic data type implementing he component interface.     Composite – Composite is an abstract entity which declares common functionality which are needed by concrete implementation for handling collection data. An Example -   Item.java public interface Item {     public double getPrice(); }   ColdDrink.java pu
Read more

State Design Pattern by Example

Image
State pattern falls under the category of Behavioral patterns. State design pattern comes in picture when a system’s behavior is depends on its own state or some other resource’s state. If an implementation is depends on the states, we end up with snarl of conditional statement every where in code. A very neat approach to deal with such situation is to separate out every state’s behavior and use them where ever they are applicable. The state pattern allows an object to alter its behavior when is internal state changes . The object is appeared to change its class. State pattern is a way to implement the same. Class Diagram : As above class diagram shows, System class holds state instance. As state of system changes , all handle request delegated to respective State’s concrete implementation. Example : Have an example of Vending machine. Vending machine has following states No Coin Inserted Coin Inserted Dispensing Empty Following diagram explain behavior
Read more

Eclipse command framework core expression: Property tester

Image
Addition to Eclipse command framework series, this post explains use of property tester to control command’s enable/visible properties. In earlier post we have tried declarative way to achieve same thing but property tester gives us more control. Property tester is associated with, tester class which implements PropertyTester.java, a namespace and set of property which it supports. We can refer this property tester using its namespace + a property name. It gives you call back to test() method with property name as parameter inside property tester class. We can configure property tester for type of input parameter. Here is sample declaration of property tester extension point < extension point ="org.eclipse.core.expressions.propertyTesters" > < propertyTester class ="com.example.advance.cmd.EditorTester" id ="com.example.advance.cmd.propertyTester1" namespace ="com.example.advance.cm
Read more