I would like to expose OSGi bundles as SOAP web services or in other words publish web service endpoints which are provided by OSGi bundles.
The architectural model/idea is that there is a host web application which is a normal war file deployed on JBoss (5.1.0 GA) offering a SOAP web service interface (JAX-WS).This host application starts the OSGi framework embedded (via ServletContextListener - currently Equinox) and loads a number of OSGi bundles which function as plugins.
The plugin bundles have a dependency to the host application as part of the request processing is delegated to them via internally defined interfaces.At the same time the plugin bundles should also be able to contribute an own public SOAP web service interface (endpoint implementations and the respective WSDL files to be published and made available by the application server).
The first approach we followed was that the host web application deploys a dispatcher/proxy servlet which delegates the processing to the relevant endpoints provided by the OSGi bundles.
There is the servlet bridge solution in OSGi/Equinox (BridgeServlet/HTTPServiceServlet) which enables the programmatic registration of servlets (for ex. in BundleActivators of the plugin bundles) using the HTTP Service specification.
The problem is that I have SOAP-based web service endpoints and would need to be able to wrap them in a javax.servlet.Servlet implementation.
That's usually an interna of the WS stack implementations of Java EE 5 servers which follow the servlet–based web services approach (endpoints defined as servlets in web.xml) and internally use to install native endpoint servlets for web service endpoints.
I did not find such a public endpoint servlet implementation which could be registered with the HTTP Service (maybe something similar like com.sun.jersey.spi.container.servlet.ServletContainer which can be used to publish REST-based services for JAX-RS applications in OSGi)
I am a little surprised that I did not find as much about registering SOAP-based WS endpoints with the OSGi HTTP Service or may be I do not see the obvious.
I have found something similar, JAX-WS-Commons/Spring (spring support for configuring JAX-WS, http://jax-ws-commons.java.net/spring/), which internally uses the class WSServletDelegate of the JAX-WS RI (metro) to process web requests for the endpoints.
But I am not sure about it, it seems kind of deprecated and I need to provide the metro WS stack jars to JBoss (or in the war file) in order to make it work on JBoss 5.1.0 GA.
Another approach seems to be distributed OSGI, which allows to publish OSGi services for remote access.
However, I could not find clear information about how to provide these services as web services on JBoss.
Other realisation aspects are:
we are bound to JBoss 5.1.0 GA and changes to the JBoss configuration should be as minimal as possible (in order to have minimal constraints to the setup of our customers)
All web services are developed contract-first which means that the original WSDL's are to be used by the providing container.
the plugin components should be as simple as possible concerning dependencies or technologies (in order to have minimal requirements to the skill of the plugin developers)
we use Spring 3 and Gemini Blueprint.
Finally, there are some ambiguities and unclear aspects and unfortunately I could not find reports on projects with similar requirements.
So, I would be eager to hear some suggestions or comments of the experts.
Maybe there are options I don't see, or maybe somebody has realised similar projects before and likes to share experiences.
Thanks a lot.
I am not an expert but another approach I have seen is to put the whole app server with an application into the OSGi container. It is an option in Sling launchpad http://sling.apache.org/documentation/the-sling-engine/architecture.html#launchpad
HTH
Related
I have one Eclipse RCP3 project.Now I need to call a rest api|(java) and Post some information using that API. Need Help.
Being a Java application, an Eclipse RCP app can use most existing Java REST client libraries. My opinion is that the easiest way is to use the ECF JAX-RS Jersey Client. I recently wrote an article about how to incorporate this into an Eclipse RCP application:
https://www.modumind.com/2020/05/19/eclipse-rcp-and-rest-an-introduction/
In short, the JAX-RS Jersey Client is an OSGi Remote Services client created as part of the Eclipse Communications Framework (ECF) project. It embeds a Jersey/Jackson JAX-RS implementation that allows you to create REST clients as annotated interfaces that are made available as OSGi services locally. Jackson is used to data bind the REST responses to Java POJOs which require little or no annotation.
This solution allows you to skip most of the scaffolding code that usually has to be written to make REST calls in a Java application. But of course, you can also use Jersey and Jackson directly, those plugins are made available via Eclipse Orbit project.
http://www.eclipse.org/orbit
The GitHub repository for the ECF JAX-RS Jersey Client can be found here:
https://github.com/ECF/JaxRSProviders
payara micro doesn't provide a JAX-WS stack out of the box. Does anyone know about a way to serve SOAP Interfaces with payara micro?
Payara Micro doesn't provide SOAP functionality out of the box yet. The only option currently is to use a library that can help you, such as Apache CXF or Metro. You can either bundle the library into your app or bundle it into a custom Payara Micro JAR with the --addJars and --outputUberJar options.
It's essentially the same thing you would need to do with plain servlet containers like Tomcat, Jetty; or with Java EE Web Profile-only containers like TomEE, because none of them contains the SOAP functionality out of the box.
I am new to spring RESTful web services. can anyone tell me how to create RESTful web services in spring with annotations and what all jars to be included in the project? also how do i test it whether my web service is working fine. do we have a small demo example which serves the same purpose.
http://www.mkyong.com/spring-mvc/spring-3-rest-hello-world-example/ is a very good and useful tutorial. It goes through how to set up the Spring MVC project from scratch using Maven as your build tool and then it goes through a Spring MVC controller that uses the URL to perform REStful Web Services. Although it may seem small, the tutorial is very useful in getting you started and provides you with a platform to carry out more complex tasks. The following reference may be useful as a reference. http://static.springsource.org/spring/docs/3.0.0.M3/reference/html/ch18s02.html
While Developing a Java EE Web app, I would like to know simple ways to access an stateless EJB object through Rest.
This project needs no Dynamic Web from Java, as Client side is fully javascript deployed, so communication is done only with Ajax calls.
As I've read one way would be to create 2 EJB one for functionality other to represent Web Service.
Is there a way to avoid the Web Service part? (avoid completely the WAR) Maybe with DI?
Java EE 6, EJB 3.1, Eclipse desired. I also believe the right application server would be Glassfish instead of Jboss, due to it's compatibility with EJB 3.0
No interesting in using JAX-WS
With EJB 3.1 you can actually publish a session bean as a JAX-RS web service, if you package your (properly annotated) session bean inside a WAR.
So, the simplest solution I can think of would be to create a WAR (a dynamic web app if you're using Eclipse) and create a JAX-RS annotated stateless session bean inside the web app. You don't need any EJB projects at all.
Not really. In Java EE 6 you can directly publish a Session Bean as a JAX-WS web service, but not as a JAX-RS web service. You're pretty much stuck with creating a WAR that hosts that JAX-RS services that front the EJBs themselves.
I know this isn't the best place to put this question but here it goes...
I'm using IBM Websphere Integration Developer...
I used JAX-WS runtime to create webservices from a Java test class, that instantiates severall other classes.
I did this by:
Right clicking on the Java test
class
Web Services -> Create Web Service
Service: Webshpere Process Manager v7.0 Web Service Runtime: IBM
Websphere JAX-WS
Checking "Publish the Web Service" -> Next -> Document Wrapped
Checking "Generate WSDL file into the project"
Checking "Configure WSDL service name" -> Finish
This resulted on the creating of a Delegate Java class on the same package of the test class
The creation of a WSDL file and an XSD file.
The Web Service is working great an this is solved...
No I need to have a similar process to generate a REST web service, and found out the JAX-RS API.
In order to have this I installed the "Websphere Application Server Feature Pack for Web 2.0" and thought that by doing this I would have the abilitty to use no only JAX-WS, JAX-RPC, but also JAX-RS, but this doesn't work.
I need the ability to generate REST Web Services automatically from a Java text class so is or isnt this possible?
Regards
As it turns out the automatization supplied by the usage of JAX-WS and JAX-RPC is not possible at this moment for JAX-RS API.
Despite of this, you can do this quite easily using Rational Application Developer, but not as easily on Websphere Integration Develloper.
Regards