Tutorial: Exposing a Jax REST service as an OSGi Remote Service

Introduction

Jax RESTful Web Services (Jax-RS) is a popular standard for exposing rest services, with a number of implementations such as Jersey, CXF), with others appearing frequently.

This tutorial will show the use of ECF's OSGi Remote Services to expose a Jax-RS service as an OSGi Remote Service and thereby gain all the advantages of OSGi Services, such as superior handling of service dynamics, service versioning, and a clear separation of service contract from service implementation.

ECF's uniquely provides open APIs for customizing or replacing the distribution providers responsible for providing the underlying remote service communication.

ECF has a number of distribution provider implementations, including two based upon Jax-RS. The git repo containing this provider and the examples from this tutorial may be found here. Two distribution providers are available based upon the Jax-RS specification. One uses the Jersey implementation and the other uses the Apache CXF implementation. Both of these distribution providers support a small extensible core allowing the easy customization or substitution of alternative Jax-RS implementations.

This tutorial will guide through

Describing how Jax-RS remote services are implemented
Declaring an example Jax-RS remote CRUD service so that it may be used as an OSGi Remote Service
Showing how to implement the Remote Service

Jax-RS Remote Services

With Jax-RS, typically a server-side implementation 'resource' class is annotated with Jax-RS specified java annotations. For example:

// The Java class will be hosted at the URI path "/helloworld"
@Path("/helloworld")
public class HelloWorldResource implements HelloWorldService {
 
    // 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 getMessage() {
        // Return some textual content
        return "Hello World";
    }
}

The @Path and @Get annotations are used by the Jax-RS implementation on the server to expose the sayHello method for access by a client via using an URL such as:

curl http://localhost:8080/helloworld

would return "Hello World".

For this tutorial we will describe a more complicated Jax-RS service for accessing a simple database of Students.

In order to make this student database service available for clients/consumers as an OSGi Remote Service, it's useful to abstract an interface with the appropriate methods and including the same Jax-RS annotations. Here is such an interface for the StudentResource

@Path("/studentservice")
public interface StudentService {
 
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students")
	Students getStudents();
 
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/studentscf")
	CompletableFuture<Students> getStudentsCF();
 
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students/{studentId}")
	Student getStudent(@PathParam("studentId") String id);
 
	@POST
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students/{studentName}")
	Student createStudent(@PathParam("studentName") String studentName);
 
	@PUT
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students")
	Student updateStudent(Student student);
 
	@DELETE
	@Path("/students/{studentId}")
	@Produces(MediaType.APPLICATION_JSON)
	Student deleteStudent(@PathParam("studentId") String studentId);
}

Here is the complete interface class.

Note that the method signatures and Jax-rs annotations in this service interface are exactly the same as those given on the service resource implementation class

// The jax-rs path annotation for this service
@Path("/studentservice")
// The OSGi DS (declarative services) component annotation. 
@Component(immediate = true, property = { "service.exported.interfaces=*", "service.intents=osgi.async",
		"service.intents=jaxrs","osgi.basic.timeout=50000" })
public class StudentServiceImpl implements StudentService {
 
	// Provide a map-based storage of students
	private static Map<String, Student> students = Collections.synchronizedMap(new HashMap<String, Student>());
	// Create a single student and add to students map
	static {
		Student s = new Student("Joe Senior");
		s.setId(UUID.randomUUID().toString());
		s.setGrade("First");
		Address a = new Address();
		a.setCity("New York");
		a.setState("NY");
		a.setPostalCode("11111");
		a.setStreet("111 Park Ave");
		s.setAddress(a);
		students.put(s.getId(), s);
	}
 
	// Implementation of StudentService based upon the students map
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students")
	public Students getStudents() {
		Students result = new Students();
		result.setStudents(new ArrayList<Student>(students.values()));
		return result;
	}
 
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/studentscf")
	public CompletableFuture<Students> getStudentsCF() {
		CompletableFuture<Students> cf = new CompletableFuture<Students>();
		cf.complete(getStudents());
		return cf;
	}
 
	@GET
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students/{studentId}")
	public Student getStudent(@PathParam("studentId") String id) {
		return students.get(id);
	}
 
	@POST
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students/{studentName}")
	public Student createStudent(@PathParam("studentName") String studentName) {
		if (studentName == null)
			return null;
		synchronized (students) {
			Student s = new Student(studentName);
			s.setId(UUID.randomUUID().toString());
			students.put(s.getId(), s);
			return s;
		}
	}
 
	@PUT
	@Consumes(MediaType.APPLICATION_JSON)
	@Produces(MediaType.APPLICATION_JSON)
	@Path("/students")
	public Student updateStudent(Student student) {
		Student result = null;
		if (student != null) {
			String id = student.getId();
			if (id != null) {
				synchronized (students) {
					result = students.get(student.getId());
					if (result != null) {
						String newName = student.getName();
						if (newName != null)
							result.setName(newName);
						result.setGrade(student.getGrade());
						result.setAddress(student.getAddress());
					}
				}
			}
		}
		return result;
	}
 
	@DELETE
	@Path("/students/{studentId}")
	@Produces(MediaType.APPLICATION_JSON)
	public Student deleteStudent(@PathParam("studentId") String studentId) {
		return students.remove(studentId);
	}
}

Here is the entire source for the Jax-RS service resource implementation class.

The full example project with this service interface and dependencies is provided here and the entire example is available in the three projects: com.mycorp.examples.student, com.mycorp.examples.student.remoteservice.host, and com.mycorp.examples.student.client in this repo location.

Note that the code in these projects only include dependencies on standardized Jax-RS annotation classes only. Note also that the following defines the OSGi Remote Service standard properties needed to export using either the Jersey or CXF Jax-RS implementation

// The OSGi DS (declarative services) component annotation. 
@Component(immediate = true, property = { "service.exported.interfaces=*", "service.intents=osgi.async",
		"service.intents=jaxrs","osgi.basic.timeout=50000" })

They do not contain dependencies on either Jax-RS implementation (Jersey, CXF, etc) code; nor do they contain dependencies on either ECF Remote Services implementation code or OSGi code.

Note also that the annotations are only those standardized by the Jax-RS specification (i.e. in javax.ws.rs.* packages), and so are not bound to any Jax-RS implementation. With the ECF distribution provider, this allows the use of either Jersey or Apache CXF without having to change the StudentService method signatures or annotations. Further, if one wishes, the Jax-RS distribution provider can be extended to support a Jax-RS implementation other than Jersey or Apache CXF.

With this interface and the ECF Remote Service Jax-RS provider bundles and their dependencies, we can create a client/consumer application that uses this remote service. ECF's implementation will dynamically create a proxy implementation of the StudentService interface, and make it available to the consumer.

As an OSGi service, it can be discovered and made available in several ways, but the easiest is to have the proxy instance injected via Declarative Services. Here is the java code for a DS component that injects the StudentService proxy into the service consumer code:

	@Reference
	void bindStudentService(StudentService service) throws Exception {
		this.studentService = service;
		System.out.println("Discovered student service=" + this.studentService);
		// Get all students
		Students students = studentService.getStudents();
		// Get first student from list
		Student s0 = students.getStudents().get(0);
		// Print out first student
		System.out.println("Student0=" + s0);
		// If there is anyone there, then update
		if (s0 != null) {
			s0.setGrade("Eighth");
			// And update
			System.out.println("Updated Student0=" + studentService.updateStudent(s0));
		}
 
		// Get student with completablefuture
		studentService.getStudentsCF().whenComplete((s, except) -> {
			if (except != null)
				except.printStackTrace();
			else
				System.out.println("Student=0=" + s.getStudents().get(0));
		});
		// Create a new student
		Student newstudent = studentService.createStudent("April Snow");
		System.out.println("Created student=" + newstudent);
		// when done change the grade to first
		newstudent.setGrade("First");
		Address addr = new Address();
		addr.setStreet("111 NE 1st");
		addr.setCity("Austin");
		addr.setState("Oregon");
		addr.setPostalCode("97200");
		newstudent.setAddress(addr);
		// update
		Student updatednewstudent = studentService.updateStudent(newstudent);
		System.out.println("Updated student=" + updatednewstudent);
		// Then delete new student
		Student deletedstudent = studentService.deleteStudent(updatednewstudent.getId());
		System.out.println("Deleted student=" + deletedstudent);
	}

Here is the entire source for the consumer implementation class.

When the StudentService remote service is discovered and the proxy created, the proxy is injected by calling the DS/SCR runtime. The example code in the bindStudentService method invokes the StudentService proxy methods. These method calls will be turned into valid Jax-RS http client calls by the ECF-created remote service proxy.

Summary

By using ECF's implementation of OSGi Remote Services and the ECF Jax-RS provider, OSGi Remote Services proxy is automatically discovered, validated, and created to allow synchronous and/or asynchronous access to the Jax-RS service. Note that if desired, the remote service can also be easily accessed via non-proxy or non-Java clients...e.g. via curl, application code, javascript, other languages, etc.