Examples of using Jersey with pax web whiteboard extender?

classic Classic list List threaded Threaded
23 messages Options
12
Reply | Threaded
Open this post in threaded view
|

Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
Does anyone know of any code examples of creating a REST API with
Jersey, from a whiteboard servlet started as a DS component?

Thanks!


- Steinar

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

themanatuf
This is what I used as my guide:




On Wednesday, June 27, 2018, 11:48:44 AM EDT, Steinar Bang <[hidden email]> wrote:





Does anyone know of any code examples of creating a REST API with
Jersey, from a whiteboard servlet started as a DS component?

Thanks!


- Steinar


Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

jbonofre
In reply to this post by Steinar Bang
Not using Jersey but cxfrs.

I can add this new example using jersey.

Regards
JB
Le 27 juin 2018, à 23:48, Steinar Bang <[hidden email]> a écrit:
Does anyone know of any code examples of creating a REST API with
Jersey, from a whiteboard servlet started as a DS component?

Thanks!


- Steinar

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Scott Lewis
In reply to this post by Steinar Bang
With ECF photon there are  remote service
 providers built on both cxf and jersey

https://github.com/ECF/JaxRSProviders

The remote service example in this repo uses ds and standard jaxrs annotations..  Example also uses r7 asyc remote services and runs unmodified on either jersey or cxf distribution providers.

Scott

From: "Jean-Baptiste Onofré" &lt;[hidden email]&gt;
Date: Wed, Jun 27, 2018 5:17 pm
To: [hidden email]
Subject: Re: Examples of using Jersey with pax web whiteboard extender?

 Not using Jersey but cxfrs.
 

 

 

 I can add this new example using jersey.
 

 

 

 Regards
 

 

 JB
 

 Le 27 juin 2018, à 23:48, Steinar Bang &lt;
 [hidden email]&gt; a écrit:
 
  Does anyone know of any code examples of creating a REST API with
Jersey, from a whiteboard servlet started as a DS component?

Thanks!


- Steinar


 

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

jbonofre
I will add a exemple on Karaf using ECF. That could help.

Regards
JB
Le 28 juin 2018, à 11:32, Scott Lewis <[hidden email]> a écrit:
With ECF photon there are  remote service 
providers built on both cxf and jersey

https://github.com/ECF/JaxRSProviders

The remote service example in this repo uses ds and standard jaxrs annotations.. Example also uses r7 asyc remote services and runs unmodified on either jersey or cxf distribution providers.

Scott

From: "Jean-Baptiste Onofré" &lt;[hidden email]&gt;
Date: Wed, Jun 27, 2018 5:17 pm
To: [hidden email]
Subject: Re: Examples of using Jersey with pax web whiteboard extender?

Not using Jersey but cxfrs.






I can add this new example using jersey.






Regards




JB


Le 27 juin 2018, à 23:48, Steinar Bang &lt;
[hidden email]&gt; a écrit:

Does anyone know of any code examples of creating a REST API with
Jersey, from a whiteboard servlet started as a DS component?

Thanks!


- Steinar




Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Tim Ward-2
Have you considered using the OSGi R7 JAX-RS whiteboard? It will almost certainly be easier than trying to set up your own JAX-RS runtime, and it’s designed to make building modular rest applications really easy. It also natively (and transparently) supports the full range of JAX-RS annotations and extensions, making it a better fit than repurposing a remote services implementation for many JAX-RS applications.

The reference implementation from Aries is just preparing for it’s official release (it uses CXF), and there are other implementations in the works elsewhere based on different JAX-RS providers. 

You can see examples of using the JAX-RS whiteboard in the tutorials at https://enroute.osgi.org 

Best Regards,

Tim

On 28 Jun 2018, at 04:37, Jean-Baptiste Onofré <[hidden email]> wrote:

I will add a exemple on Karaf using ECF. That could help.

Regards
JB
Le 28 juin 2018, à 11:32, Scott Lewis <[hidden email]> a écrit:
With ECF photon there are  remote service 
providers built on both cxf and jersey

https://github.com/ECF/JaxRSProviders

The remote service example in this repo uses ds and standard jaxrs annotations.. Example also uses r7 asyc remote services and runs unmodified on either jersey or cxf distribution providers.

Scott

From: "Jean-Baptiste Onofré" &lt;[hidden email]&gt;
Date: Wed, Jun 27, 2018 5:17 pm
To: [hidden email]
Subject: Re: Examples of using Jersey with pax web whiteboard extender?

Not using Jersey but cxfrs.






I can add this new example using jersey.






Regards




JB


Le 27 juin 2018, à 23:48, Steinar Bang &lt;
[hidden email]&gt; a écrit:

Does anyone know of any code examples of creating a REST API with
Jersey, from a whiteboard servlet started as a DS component?

Thanks!


- Steinar





Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
In reply to this post by themanatuf
>>>>> - <[hidden email]>:

> This is what I used as my guide:
> https://github.com/jersey/jersey/tree/master/examples/osgi-http-service

Thanks!

What I've done so far, in my vaadin-to-react rewrite,
 https://github.com/steinarb/ukelonn/tree/using-react
is to just create a servlet for each service.
 https://github.com/steinarb/ukelonn/tree/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/api

The servlets either handle POST or GET or both, and what's POSTed is a
JSON object that is turned into a Java bean by jackson, and what's
returned is a bean that is turned into a JSON object by Jackson.  The
beans are defined here:
 https://github.com/steinarb/ukelonn/tree/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/api/beans
and here
 https://github.com/steinarb/ukelonn/tree/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.api/src/main/java/no/priv/bang/ukelonn/beans

This has worked well enough and have the advantage of the servlets being
components that can have the class giving access to the database
injected.

The service definition is
 https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.api/src/main/java/no/priv/bang/ukelonn/UkelonnService.java#L36

The service implementation, is this DS component
 https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/impl/UkelonnServiceProvider.java#L42

However, with Jersey getting injection of the above service into the
resource classes isn't so easy.

The obvious first step is to make a DS component from ServletContainer
 http://javadox.com/org.glassfish.jersey.containers/jersey-container-servlet-core/2.7/org/glassfish/jersey/servlet/ServletContainer.html

But the ServletContainer wants to find and instanciate the resource
classes, so they can't be DS components in their own right.  And there
are no backpointers from a resource to the class that instanciated it.

So that would mean I would have to resort to static access methods for
singletons, which is what I did in the JSF/Primefaces version, and in
the first versions of the vaadin version.

And going back to using singletons feels very much like a step
backwards...:-)

If someone are looking for the react/webpack stuff, it is here:
 https://github.com/steinarb/ukelonn/tree/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/frontend

To handle the login I use apache shiro, which is enabled by creating the
servlet context "/ukelonn" with this DS component
 https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/impl/UkelonnServletContextHelper.java
and then putting this filter on the "/ukelonn" servlet context
 https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/impl/UkelonnShiroFilter.java#L42
and putting all of the servlets into this context and making their paths
relative to the context.

The UkelonnShiroFilter handles all of the cookie magic during login and
logout, and blocks access to URLs according to login state and role(s)

The shiro.ini file that defines the various accesses to the URLs
(including the API URL), is here:
 https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/resources/shiro.ini

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Scott Lewis
FYI:   I've recently created a tutorial describing how to export from
Karaf a jaxrs-annotated remote service with either cxf or jersey [1].   
It does require an interface with jaxrs annotations that are the same as
the resource annotations, but you (Steinar) already have the
UkelonService so I don't think that will be a burden.

Also:   I've very recently added bndtools 4 project and bndrun templates
for using either jersey or cxf to export the same jaxrs service [2].   I
haven't had a chance to create tutorial about these templates yet, but
if you are using bndtools 4 it might be helpful.

[1] https://wiki.eclipse.org/Tutorial:_JaxRS_Remote_Services_on_Karaf

[2] https://github.com/ECF/JaxRSProviders/issues/6

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
>>>>> Scott Lewis <[hidden email]>:

> FYI:   I've recently created a tutorial describing how to export from
> Karaf a jaxrs-annotated remote service with either cxf or jersey
> [1].    It does require an interface with jaxrs annotations that are
> the same as the resource annotations, but you (Steinar) already have
> the UkelonService so I don't think that will be a burden.

That's interesting! Just annotating my service interface, and its
implementation with jaxrs annotations, like the StudentService and
StudentServiceImpl here...?
 https://wiki.eclipse.org/Tutorial:_Exposing_a_Jax_REST_service_as_an_OSGi_Remote_Service

(the downside is that I would have to move to karaf 4.2, and I ran into
some issues doing when I inadvertently tried 4.2.0.  JB had some ideas
about what was the cause of my problem, and I will look into them)

How would the service provided by the StudentServiceImpl component be
exposed as a REST service on HTTP in a servlet?

> Also:   I've very recently added bndtools 4 project and bndrun
> templates for using either jersey or cxf to export the same jaxrs
> service [2].  

That's probably the answer to my previous question? :-)

> I haven't had a chance to create tutorial about these templates yet,
> but if you are using bndtools 4 it might be helpful.

I'm using 3.5.1 of maven-bundle-plugin, so probably not bndtools 4,
unfortunately.

Thanks!

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Scott Lewis
On 7/13/2018 3:40 PM, Steinar Bang wrote:
>
> That's interesting! Just annotating my service interface, and its
> implementation with jaxrs annotations, like the StudentService and
> StudentServiceImpl here...?
>   https://wiki.eclipse.org/Tutorial:_Exposing_a_Jax_REST_service_as_an_OSGi_Remote_Service

Yes.   I haven't looked at your annotations, and so don't know if they
all are from the javax.ws.rs packages...but assuming so...that's the idea.

>
> (the downside is that I would have to move to karaf 4.2, and I ran into
> some issues doing when I inadvertently tried 4.2.0.  JB had some ideas
> about what was the cause of my problem, and I will look into them)

It's quite possible that things would run on Karaf 4.0 or 4.0 (with
java8), but I haven't tested that so don't want to make any claims. Also
I found a small issue with gogo on 4.2 that's been fixed in 4.2.1
stream...but that only affects the added RSA console commands.

>
> How would the service provided by the StudentServiceImpl component be
> exposed as a REST service on HTTP in a servlet?

Yes.   For both it registers a servlet with HttpService (jetty). For CXF
it's a subclass of

org.apache.cxf.jaxrs.servlet.CXFNonSpringJaxrsServlet

and for jersey it's a

org.glassfish.jersey.servlet.ServletContainer.ServletContainer

it doesn't currently use the http whiteboard, but it could...and may
eventually.

>
>> Also:   I've very recently added bndtools 4 project and bndrun
>> templates for using either jersey or cxf to export the same jaxrs
>> service [2].
> That's probably the answer to my previous question? :-)
>
>> I haven't had a chance to create tutorial about these templates yet,
>> but if you are using bndtools 4 it might be helpful.
> I'm using 3.5.1 of maven-bundle-plugin, so probably not bndtools 4,
> unfortunately.

Ok.

Scott

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
>>>>> Scott Lewis <[hidden email]>:

[snip!]
> Yes.   I haven't looked at your annotations, and so don't know if they
> all are from the javax.ws.rs packages...but assuming so...that's the
> idea.

The DS annotations are from
 mvn:org.osgi/org.osgi.service.component.annotations/6.0.0

The whiteboard constants used in the annotation arguments, are from
 mvn:org.ops4j.pax.web/pax-web-extender/6.0.3

I haven introduced any javax.ws.rs stuff yet.

[snip!]
> it doesn't currently use the http whiteboard, but it could...and may
> eventually.

Ah, ok.  I need something that uses the http whiteboard.

But just annotating the service interface to get REST services would
have been really neat. :-)

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

jbonofre
Hi Steinar,

I recommend to use the annotation from  osgi.cmpn.

javax.ws.rs can be provided by the spec or a impl (like CXF).

Regards
JB

On 14/07/2018 12:14, Steinar Bang wrote:

>>>>>> Scott Lewis <[hidden email]>:
>
> [snip!]
>> Yes.   I haven't looked at your annotations, and so don't know if they
>> all are from the javax.ws.rs packages...but assuming so...that's the
>> idea.
>
> The DS annotations are from
>  mvn:org.osgi/org.osgi.service.component.annotations/6.0.0
>
> The whiteboard constants used in the annotation arguments, are from
>  mvn:org.ops4j.pax.web/pax-web-extender/6.0.3
>
> I haven introduced any javax.ws.rs stuff yet.
>
> [snip!]
>> it doesn't currently use the http whiteboard, but it could...and may
>> eventually.
>
> Ah, ok.  I need something that uses the http whiteboard.
>
> But just annotating the service interface to get REST services would
> have been really neat. :-)
>

--
Jean-Baptiste Onofré
[hidden email]
http://blog.nanthrax.net
Talend - http://www.talend.com
Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
In reply to this post by Steinar Bang
>>>>> Steinar Bang <[hidden email]>:

> The service definition is
>  https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.api/src/main/java/no/priv/bang/ukelonn/UkelonnService.java#L36

> The service implementation, is this DS component
>  https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/impl/UkelonnServiceProvider.java#L42

> However, with Jersey getting injection of the above service into the
> resource classes isn't so easy.

Based in the following two stackoverflow threads I have a tentative plan
for getting the service injected into Jersey resources using my current
stack (ie. karaf 4.1.5 and OSGi 6.0.0):
 https://stackoverflow.com/questions/38373867/inject-dao-instance-into-jersey-resource?noredirect=1&lq=1
 https://stackoverflow.com/questions/16216759/dependency-injection-with-jersey-2-0

(However, once I'm on karaf 4.2.x and OSGi 7.0.0, and once I hear
rumours that Scott Lewis' approach will be working with the http
whiteboard, then ditching my resource classes and annotating the service
is something I will try)

Outline of my plan:
 1. Make the service implementation extend ResourcesConfig
 2. Create a class extending AbstractBinder, that in its configure()
    method will bind an instance of the service implmentation to the
    UkelonnService interface
 3. In the @Activate method of the service implementation, register the
    activated instance with Jersey, using the AbstractBinder above
 4. In the resource classes use JSR330 @Inject of the UkelonnService
 5. Create a whiteboard DS service from the JerseyServletContainer, with:
    a. param configuration configuring a package to scan for resources
    b. add a @Reference for an UkelonnService and an @Activate method, to
       ensure that the servlet isn't activated, and plugged into the
       whiteboard until a service is available that can be injected into
       the created resources (and it should also ensure the servlet is
       taken down if the UkelonnService implementation is taken down)

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Scott Lewis
In reply to this post by Steinar Bang
On 7/14/2018 3:14 AM, Steinar Bang wrote:
> <stuff deleted>
> [snip!]
>> it doesn't currently use the http whiteboard, but it could...and may
>> eventually.
> Ah, ok.  I need something that uses the http whiteboard.

I would welcome a contribution to use the http whiteboard for this
project [1].   It would/will be a simple matter of changing the
jersey.server and cxf.server code that creates a servlet and registers
it via HttpService to using the whiteboard impl to do the same thing.

>
> But just annotating the service interface to get REST services would
> have been really neat. :-)

Yes.   One result is that for free you get a versionable, type-safe,
proxy for your jaxrs service.  Also remote service dynamics and seemless
use of DS and/or other injection based upon the service registry.  Also
a standardized mgmt agent (chap 122 in cmpn spec) and service discovery.

Scott

[1] https://github.com/ECF/JaxRSProviders
[2]
https://osgi.org/specification/osgi.cmpn/7.0.0/service.remoteserviceadmin.html

>

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Scott Lewis
In reply to this post by Steinar Bang
On 7/14/2018 10:33 AM, Steinar Bang wrote:
> <stuff deleted>
> (However, once I'm on karaf 4.2.x and OSGi 7.0.0, and once I hear
> rumours that Scott Lewis' approach will be working with the http
> whiteboard, then ditching my resource classes and annotating the service
> is something I will try)

If you would like to expidite, please open an issue here [1] for the use
of http-whiteboard in jersey and cxf distribution providers, and it
could happen pretty quickly.

BTW:  why do you require http-whiteboard for implementation?   I'm not
arguing against using http-whiteboard, but I expect that using
HttpService directly and http-whiteboard can co-exist in a single
framework,  so why not consider both?

Scott

[1] https://github.com/ECF/JaxRSProviders

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
>>>>> Scott Lewis <[hidden email]>:


> If you would like to expidite, please open an issue here [1] for the
> use of http-whiteboard in jersey and cxf distribution providers, and
> it could happen pretty quickly.

https://github.com/ECF/JaxRSProviders/issues/7

(but as I say below: the biggest hurdle for me is transitioning to karaf
4.2.x as I ran into some problems when I (inadvertently) tried it last
week)

> BTW:  why do you require http-whiteboard for implementation?   I'm not
> arguing against using http-whiteboard, but I expect that using
> HttpService directly and http-whiteboard can co-exist in a single
> framework,  so why not consider both?

The ukelonn webapp[1] started out in July 2016 as a JSF/primefaces war
bundle, configured with web.xml[2].  In October 2016 I started running the
webapp on karaf (and using OSGi for webapps became a *lot* easier...).  

Then it was transformed into a vaadin application[3], still as a war
bundle with web.xml.  Then it was transformed into vaadin webapp in a
jar bundle with the servlets registering with the HttpService, then
finally turned into a vaadin webapp using http whiteboard (the current
master).

I'm now in the process of transforming this into a reactjs webapp[4],
and am still using http whiteboard.  Registering with the HttpService is
of course possible, but feels like a step backwards. :-)

The biggest hurdle will be the transition to karaf 4.2.0, which I
eventually need to make, but right now it's more fun to work on the
reactjs part of things.  So it will happen sometime in the future.

References:
[1] <https://github.com/steinarb/ukelonn>
[2] <https://github.com/steinarb/ukelonn/tree/using-primefaces>
[3] <https://github.com/steinarb/ukelonn/tree/using-vaadin>
[4] <https://github.com/steinarb/ukelonn/tree/using-react>

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Tim Ward-2
Hi Steinar,

If you’re looking to use JAX-RS then the standard approach would be to use the JAX-RS Whiteboard specification (https://osgi.org/specification/osgi.cmpn/7.0.0/service.jaxrs.html). There are examples of how you can do this in OSGi enRoute (https://enroute.osgi.org). The reference implementation from Apache Aries is easily available in Maven Central (https://mvnrepository.com/artifact/org.apache.aries.jax.rs/org.apache.aries.jax.rs.whiteboard/1.0.0)

The good news is that the JAX-RS whiteboard doesn’t need you to annotate your interfaces with JAX-RS annotations, or even use interfaces at all if you don’t want to. The whiteboard will automatically process any services that set the relevant properties from the specification. If you are using OSGi R7 then you can do this with Component Property annotations, but R7 isn’t required (you can just put the properties on using the component annotation). The Aries implementation also runs just fine on an R6 framework with R6 compendium services. It even uses the Http Service whiteboard 1.0 specification, which is what you want!

The really good news is that because your JAX-RS resources are provided as services you can use DS to inject your service dependencies. This prevents you from having to mess around trying to add service injection to the JAX-RS runtime.

In summary, you should be able to add Aries JAX-RS whiteboard 1.0.0, Aries JAX-RS API 1.0.0, and ServiceMix Specs  Annotation API 1.3 and start using it.

Best Regards,

Tim

On 14 Jul 2018, at 23:18, Steinar Bang <[hidden email]> wrote:

Scott Lewis <[hidden email]>:


If you would like to expidite, please open an issue here [1] for the
use of http-whiteboard in jersey and cxf distribution providers, and
it could happen pretty quickly.

https://github.com/ECF/JaxRSProviders/issues/7

(but as I say below: the biggest hurdle for me is transitioning to karaf
4.2.x as I ran into some problems when I (inadvertently) tried it last
week)

BTW:  why do you require http-whiteboard for implementation?   I'm not
arguing against using http-whiteboard, but I expect that using
HttpService directly and http-whiteboard can co-exist in a single
framework,  so why not consider both?

The ukelonn webapp[1] started out in July 2016 as a JSF/primefaces war
bundle, configured with web.xml[2].  In October 2016 I started running the
webapp on karaf (and using OSGi for webapps became a *lot* easier...).  

Then it was transformed into a vaadin application[3], still as a war
bundle with web.xml.  Then it was transformed into vaadin webapp in a
jar bundle with the servlets registering with the HttpService, then
finally turned into a vaadin webapp using http whiteboard (the current
master).

I'm now in the process of transforming this into a reactjs webapp[4],
and am still using http whiteboard.  Registering with the HttpService is
of course possible, but feels like a step backwards. :-)

The biggest hurdle will be the transition to karaf 4.2.0, which I
eventually need to make, but right now it's more fun to work on the
reactjs part of things.  So it will happen sometime in the future.

References:
[1] <https://github.com/steinarb/ukelonn>
[2] <https://github.com/steinarb/ukelonn/tree/using-primefaces>
[3] <https://github.com/steinarb/ukelonn/tree/using-vaadin>
[4] <https://github.com/steinarb/ukelonn/tree/using-react>


Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
In reply to this post by Steinar Bang
>>>>> Steinar Bang <[hidden email]>:

>> The service definition is
>> https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.api/src/main/java/no/priv/bang/ukelonn/UkelonnService.java#L36

>> The service implementation, is this DS component
>> https://github.com/steinarb/ukelonn/blob/5ca75f438407c594ed476bed790d984b0007cfdf/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/impl/UkelonnServiceProvider.java#L42

>> However, with Jersey getting injection of the above service into the
>> resource classes isn't so easy.

> Based in the following two stackoverflow threads I have a tentative plan
> for getting the service injected into Jersey resources using my current
> stack (ie. karaf 4.1.5 and OSGi 6.0.0):
>  https://stackoverflow.com/questions/38373867/inject-dao-instance-into-jersey-resource?noredirect=1&lq=1
>  https://stackoverflow.com/questions/16216759/dependency-injection-with-jersey-2-0
[snip!]

> Outline of my plan:
>  1. Make the service implementation extend ResourcesConfig

Turns out this wasn't necessary.  What's @Inject'ed into Jersey
resources by HK2 JSR330 injections, can be any class.

>  2. Create a class extending AbstractBinder, that in its configure()
>     method will bind an instance of the service implmentation to the
>     UkelonnService interface

I ended up just creating an anonymous inner and registering it
immediately.

>  3. In the @Activate method of the service implementation, register the
>     activated instance with Jersey, using the AbstractBinder above

This was wrong.  The instances that needs to be injected, must bek
registered with the ResourceConfig used by the ServletContainer.  They
cannot be registered with any old ResourceConfig.

>  4. In the resource classes use JSR330 @Inject of the UkelonnService

This was as predicted.  Needed to

>  5. Create a whiteboard DS service from the JerseyServletContainer, with:
>     a. param configuration configuring a package to scan for resources
>     b. add a @Reference for an UkelonnService and an @Activate method, to
>        ensure that the servlet isn't activated, and plugged into the
>        whiteboard until a service is available that can be injected into
>        the created resources (and it should also ensure the servlet is
>        taken down if the UkelonnService implementation is taken down)

Actually, the ServletContainer DS component needs to have the
UkelonnService (and an OSGi LogService) injected as OSGi services,
because it needs to register them as instances in its ResourceConfig.

The trick to get everything working, was to first have the
ServletContainer create a ResourceConfig object containing all of the
servlet setup, then copy that ResourceConfig and register OSGi services
for Jersey injection and reload the ServletContainer with the copy.

The procedure to get Jersey working with OSGi services UkelonnService
and LogService injected into the Jersey resource objects, is then as
follows:
 1. Create a whiteboard DS component exposing a Servlet service from
    Jersey ServletContainer, configuring the package to scan for API
    resources:
     https://github.com/steinarb/ukelonn/blob/59c6c693027e6d400ccd9e6b1777ce7f5adb4096/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/api/UkelonnRestApiServlet.java#L37
 2. Make the DS component of ServletContainer depend on OSGi services
    UkelonnService and LogService
     https://github.com/steinarb/ukelonn/blob/59c6c693027e6d400ccd9e6b1777ce7f5adb4096/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/api/UkelonnRestApiServlet.java#L74
 3. Override the ServletContainer.init(WebConfig) method, and:
    a. Call super.init(WebConfig) to make sure that a ServletConfig
       containing the information set up by the http whiteboard is
       created (contains the servletcontext, the servlet name and the
       package to scan for Jersey resources)
        https://github.com/steinarb/ukelonn/blob/59c6c693027e6d400ccd9e6b1777ce7f5adb4096/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/api/UkelonnRestApiServlet.java#L57
    b. Copy the ResourceConfig of the ServletContainer (because that
       ServletConfig is immutable after the setup, and calling
       ServletConfig.register() will cause an IllegalOperationException)
    c. On the ServletConfig copy, register an anonymous inner inheriting
       AbstractBinder that in its configure() method registers the
       OSGi services injected into the ServletContainer as JSR330
       injections in the Jersey resources
    d. Call ServletContainer.reload(ResourceConfig) with the
       ResourceConfig copy as the argument
  4. In the resources use JSR330 injections of UkelonnService and/or
     LogService, e.g.
      https://github.com/steinarb/ukelonn/blob/59c6c693027e6d400ccd9e6b1777ce7f5adb4096/ukelonn.bundle/src/main/java/no/priv/bang/ukelonn/api/resources/RegisterJob.java#L32

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Steinar Bang
In reply to this post by jbonofre
>>>>> Jean-Baptiste Onofré <[hidden email]>:

> Not using Jersey but cxfrs.
> I can add this new example using jersey.

If you want, and tell me where to put it, I can whip up an example and
provide a pull request?

Basically this Counter example with Jersey instead of implementing the
REST service directly in a servlet (and the packages switched to
something appropriate for karaf examples):
 https://github.com/steinarb/frontend-karaf-demo

That would demonstrate in addition to Jersey:
 - http whiteboard with DS
 - serving a react.js application from a DS component karaf, packaged
   with webpack into a bundle.js file

Alternatively this one with the REST service implemented in a servlet
replaced with a Jersey resource?
 https://github.com/steinarb/whiteboard-web-and-api-karaf-demo

The latter example has a very simple plain javascript app embdedded in
an index.html file.  This can easily be replaced by a webpack'd react.js
application if of interest.

The latter example is already split into two separate bundles.  To make
things really interesting it would be good to delegate the actual
counting into an OSGi service that can be injected into the Jersey
resources, making it have a total of 4 bundles (an API bundle defining
the service, a bundle implementing the service in a DS component, a
webapi bundle using Jersey and injecting the service from the DS
component into Jersey resources, and a webgui bundle (that can be
changed into a react.js app).

Reply | Threaded
Open this post in threaded view
|

Re: Examples of using Jersey with pax web whiteboard extender?

Tim Ward-2
Would it not be easier to:


Using those features should be able to make the example more concise and compelling.

Best Regards,

Tim

On 23 Jul 2018, at 20:19, Steinar Bang <[hidden email]> wrote:

Jean-Baptiste Onofré <[hidden email]>:

Not using Jersey but cxfrs.
I can add this new example using jersey.

If you want, and tell me where to put it, I can whip up an example and
provide a pull request?

Basically this Counter example with Jersey instead of implementing the
REST service directly in a servlet (and the packages switched to
something appropriate for karaf examples):
https://github.com/steinarb/frontend-karaf-demo

That would demonstrate in addition to Jersey:
- http whiteboard with DS
- serving a react.js application from a DS component karaf, packaged
  with webpack into a bundle.js file

Alternatively this one with the REST service implemented in a servlet
replaced with a Jersey resource?
https://github.com/steinarb/whiteboard-web-and-api-karaf-demo

The latter example has a very simple plain javascript app embdedded in
an index.html file.  This can easily be replaced by a webpack'd react.js
application if of interest.

The latter example is already split into two separate bundles.  To make
things really interesting it would be good to delegate the actual
counting into an OSGi service that can be injected into the Jersey
resources, making it have a total of 4 bundles (an API bundle defining
the service, a bundle implementing the service in a DS component, a
webapi bundle using Jersey and injecting the service from the DS
component into Jersey resources, and a webgui bundle (that can be
changed into a react.js app).


12