I am trying to implement this example. The first method in FileResource is supposed to return a json response, but the response is coming through as XML. I have never used jersey before. I tried adding #produces yielding this:
#GET #Produces("application/json")
#Path("/url")
public Response getCallbackUrl() {
String url = blobstoreService.createUploadUrl("/rest/file");
return Response.ok(new FileUrl(url)).build();
}
Now I'm getting
A message body writer for Java class FileUrl, and Java type class FileUrl, and MIME media type application/json was not found
How can I fix this? Thanks for any help. And if you need any more info let me know. I don't know much of the jersey terminology.
You need a few more dependencies in order to produce JSON output.
Take a look at: http://jersey.java.net/nonav/documentation/latest/chapter_deps.html
Scroll down to:
11.4.1.2. MOXy
Maven developers, using JSON serialization support of JAXB beans when using the MIME media type application/json require a dependency on the jersey-json module (explicit dependency on org.eclipse.persistence.moxy is required).
An alternative to "vanilla" Jersey that you might be interested in is Dropwizard. Their blurb is:
Dropwizard has out-of-the-box support for sophisticated configuration, application metrics, logging, operational tools, and much more, allowing you and your team to ship a production-quality HTTP+JSON web service in the shortest time possible.
Yep you'll need some jersey / json dependency here :
<dependency>
<groupId>com.sun.jersey</groupId>
<artifactId>jersey-json</artifactId>
<version>1.2</version>
</dependency>
with your version of jersey of course.
Related
I have created a SOAP web-service, running in a tomcat container, using CXF and a WSDL contract approach. The Java code was generated from the WSDL using the maven plugin "cxf-codegen-plugin".
Now, I would like to also expose the web-service as a custom HTTP / JSON web-service by mapping the XML data into JSON data. But I haven't been successful yet and I would appreciate any help to achieve that.
I found that old documentation https://cxf.apache.org/docs/json-support.html on CXF's website (which has also been recently duplicated and not corrected here https://cwiki.apache.org/confluence/display/CXF20DOC/JSON+Support). I got it running with a small fix : sf.setBindingId(HTTPBinding.HTTP_BINDING); instead of sf.setBindingId(HttpBindingFactory.HTTP_BINDING_ID); since HttpBindingFactory does not exist anymore in CXF 3.x versions.
The first issue with that solution is that it depends on jettison-json whose last release was published in July 2016. The project looks dead. I could not find any suitable replacement. I only found StAXON which is worst : last release in February 2014.
Is there any other library that is well maintained and that implements StAX ?
The second issue is that the example uses a server bean while I already have a container. For the SOAP service, I simply use the public static Endpoint publish(String address, Object implementor) function.
How can I use both the Tomcat container and the JSON/XML conversion ?
The third issue is that I could not send a valid JSON request so far. The absence of documentation does not help. Still, I managed to get as far as sending a valid JSON equivalent of the SOAP header content. But I could not manage to guess how to make CXF also reads the equivalent of the SOAP body. The Java interface of the web-service is public Response get(Header header, Body body); and I keep getting errors : org.apache.cxf.interceptor.Fault: wrong number of arguments while invoking public abstract Response ServicePort.get(Header,Body) with params [Header#88f6973[user=bbcc2545-27ea-43cd-a1fe-c4a194258e0f]]. Obviously the body is missing.
Is there anyone who knows the right JSON syntax to send a request to a CXF HTTP / JSON web-service that relies on jettison-json ? (Or where could one find a comprehensive documentation ?)
I use TomEE 7.0.1 with Jackson 2 as JAX-RS JSON provider (configured in openejb-jar.xml). Posting json to jax-rs services works perfectly well and uses the jackson annotations.
But using JAX-RS client (or cxf webclient) always uses Johnzon even if I provide Jackson to the Webclient.create method. After some debugging I am sure that TomEE adds Johnzon to the client factory somehow and no other message body parser for json can be used.
Is this a bug with the TomEE CXF integration or do I miss something?
Johnzon is registered on the bus by default to have a default JSON (mapping) and JSON-P provider. CXF is clever enough to make bus providers with a lower priority than applications ones (register() for client API) so if you call register you expect to use jackson...and still use johnzon - I suspect it is the case you hit.
That's perfectly normal and due to two things:
JAX-RS specification priority definition
Jackson Consumes/Produce definition
To summarize (1) says that more specific is the provider higher is its priority so an "application/json" provider will be priveledged in favor of a "/" one.
To avoid issues Johnzon uses "application/json". However jackson uses a custom matching strategy and therefore uses "/". So the bus priority is ignored since mediatype priority is enough to say johnzon is "more adapted" than jackson for json.
To solve it the easiest is likely to override jackson provider (just extend it) and decorate it with #Provides/#Consumes with MediaType.APPLICATION_JSON instead of wildcard one.
I want to develop one web api,that will produce and consume both JSON and XML data.
I have used JAXB for XML support and it is working fine.
Now i want to add JSON type.i studied different tutorial, all are using different dependencies as below:
jersey-media-json-jackson
jersey-json
jersey-media-multipart
please help me whcih perfect and which support both XML and JSON.
what is difference between them all?
1. Jersey-Media-Json-Jackson
Jackson JSON processor could be controlled via providing a custom Jackson 2 ObjectMapper (or ObjectMapper for Jackson 1) instance. This could be handy if you need to redefine the default Jackson behaviour and to fine-tune how your JSON data structures look like. Detailed description of all Jackson features is out of scope of this guide. The example below gives you a hint on how to wire your ObjectMapper (ObjectMapper) instance into your Jersey application.
In order to use Jackson as your JSON (JAXB/POJO) provider you need to register JacksonFeature (Jackson1Feature) and a ContextResolver<T> for ObjectMapper,
2. Jersey-Json :
Jersey JSON support comes as a set of JAX-RS MessageBodyReader<T> and MessageBodyWriter<T> providers distributed with jersey-json module. These providers enable using three basic approaches when working with JSON format:
POJO support
JAXB based JSON support
Low-level, JSONObject/JSONArray based JSON support
3. Jersey-media-multipart
The multipart in this module provide an integration of multipart/* request and response bodies in a JAX-RS runtime environment. The set of registered providers is leveraged, in that the content type for a body part of such a message reuses the same MessageBodyReader<T>/MessageBodyWriter<T> implementations as would be used for that content type as a standalone entity.
The following list of general MIME MultiPart features is currently supported:
The MIME-Version: 1.0 HTTP header is included on generated responses.
It is accepted, but not required, on processed requests.
A MessageBodyReader implementation for consuming MIME MultiPart
entities.
A MessageBodyWriter implementation for producing MIME MultiPart
entities. The appropriate #Provider is used to serialize each body
part, based on its media type.
Optional creation of an appropriate boundary parameter on a generated
Content-Type header, if not already present.
the Apache CXF project offers a proxy based client implementation for REST services. This looks like:
Resource resource = JAXRSClientFactory.create( baseAddress, Resource.class )
Does anyone know a similar implementation for Jersey?
I spotted an approach using #HyperMediaController annotations, but I want to stick to JSR-311 default annotations like #Path and #Get ...
Has anyone an idea?
A proxy implementation exists, but unfortunately it's not even mentioned in Jersey Client API documentation (neither in Jersey User Guide) as of version 2.22.1.
What I found was JavaDoc for WebResourceFactory, even better is the package JavaDoc. Here's a snippet from the JavaDoc on the usage of the WebResourceFactory:
Client client = ClientBuilder.newClient();
WebTarget target = client.target("http://localhost:8080/");
MyResourceIfc resource = WebResourceFactory.newResource(MyResourceIfc.class, target);
In Maven you then need:
<dependency>
<groupId>org.glassfish.jersey.ext</groupId>
<artifactId>jersey-proxy-client</artifactId>
<version>2.22.1</version>
</dependency>
in addition to
<dependency>
<groupId>org.glassfish.jersey.core</groupId>
<artifactId>jersey-client</artifactId>
<version>2.22.1</version>
</dependency>
I found WebResourceFactory miss generic types supports and it's source code was really hard to understand. So we created https://github.com/adaptris/jaxrs-client-proxy and we are currently devloping it.
To use it you need to build a resource:
ResourceBuilder builder = new ResourceBuilder();
resource = builder.
url("https://host/api").
build(Resource.class);
client = resource.get();
Then you can call client - which is proxy of your jax-rs annotation described interface (Resource.class). You should close a resource after stoping using it as it is recommended by jax-rs client api.
resource.close()
More details on github projet page.
I created an own implementation. See utils-apl-derived wiki page therefore.
Is there a way to build Spring Web calls that consume and produce application/json formatted requests and responses respectively?
Maybe this isn't Spring MVC, I'm not sure. I'm looking for Spring libraries that behave in a similar fashion to Jersey/JSON. The best case would be if there was an annotation that I could add to the Controller classes that would turn them into JSON service calls.
A tutorial showing how to build Spring Web Services with JSON would be great.
EDIT: I'm looking for an annotation based approach (similar to Jersey).
EDIT2: Like Jersey, I am looking for REST support (POST,GET,DELETE,PUT).
EDIT3: Most preferably, this will be the pom.xml entries and some information on using the spring-js with jackson Spring native version of things.
In case other ppl get here later:
http://blog.springsource.com/2010/01/25/ajax-simplifications-in-spring-3-0/
was the most useful link for me. That finally made me understand the model (after less than a day of searching).
You can certainly have controllers that return a View which is in JSON output. Take a look at the Spring-JSON project.
To consume requests in JSON I would assume you would just want a controller to pass a request parameter off to a JSON library which could parse the data?
There is no pre-packaged way to do what you want as Jersey is nicely integrated with Spring via the Jersey-Spring API so there's really no reason to re-invent the wheel.
Check this one out
Adding support for JSON and XML views
Source code for Spring Finance Manager
Since spring-mvc 3.0 official support for Ajax remoting with JSON is provided as part of Spring MVC. This includes support for generating JSON responses and binding JSON requests using the Spring MVC #Controller programming model.
see here
This feature is now part of Spring since version 3.0. You can simply use the #ResponseBody annotation to specify that you want the return value from your request handler methods to be serialized to JSON and sent as the response body. See http://blog.springsource.com/2010/01/25/ajax-simplifications-in-spring-3-0/
It seems that DWR framework looks very close to what you want to get.
You can configure Spring MVC interceptors through handler mappings and then use the mappings to transform the returning data to JSON. The handler configuration can be done in xml (no need to recompile), and this can be completely transparent to the rest of the application.
It's fairly easy to annotate controllers with some annotation, and then hook up the BeanFactory bootstrap process to register the controllers within some handler mapping process.
I have used this approach to transform the result from spring controllers into GWT RPC calls.
You can also use Spring AOP to intercept controller method calls and unwrap/wrap the requests from/to JSON.