We Keep Coding

accept argument with object which has a specific annotation

PROBLEM
If I generate a jaxb object from an XML root element named 'Message' it produces the following class:
#XmlRootElement(name = "Message")
public class Message{
...
}
I have a method with the following definition:
public void doSomething(Object rootElement) {
...
}
This method is part of a framework used by 30+ developers. The method only accepts a class with the annotation #XmlRootElement. Developers sometimes miss this crucial javadoc and pass a non #XmlRootElement object to the method giving errors during runtime. As the generated class has no superclass, no interfaces, etc I have to accept an Object as argument.
QUESTION
Is it not possible to enforce this check compile time ?
ALREADY TRIED
I've looked into (via jaxb binding file) letting generated classes implement an interface and then accept this interface as argument, however it cannot (in an automated manner) be applied to only the root element class.
We have several hundred different XML Schema files from which we generated in an automated manner.

How can I send the Object class to server with Jackson?

I have a Message class like this:
class Message {
#JsonProperty("content")
Object content;
}
where the content attribute can be a User, a Post, or a String
and I have to send this object to the server and cast the content to the right class.
I'm using Jackson annotations to serialize the JSON, but when I try to cast the content, an error appears, because the attribute content arrives in the server like a LinkedHashMap object.
The error is:
ERROR [org.apache.catalina.core.ContainerBase.[jboss.web].[default-host].[/MegaRadarSocial].[Resteasy]] (http-localhost-127.0.0.1-8080-1) Servlet.service() for servlet Resteasy threw exception: org.jboss.resteasy.spi.UnhandledException: java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to br.com.megaradar.megaradarsocial.model.User
I would like a help to casting...
Thanks

As you control both ends (server and client), you could try Genson library http://code.google.com/p/genson/. One of its features allows you to serialize to json and type information, this enables you to deserialize back to the right type.
Genson genson = new Genson.Builder().setWithClassMetadata(true).create();
json = genson.serialize(yourMessage);
// then deserialize it back
Message message = genson.deserialize(json, Message .class);
The serialized json will look like : {"content": {"#class":"package.path.Message", ...the object values...}}
You can even define aliases for the serialized classes
new Genson.Builder().addAlias("message", Message.class)
Important: Note that you need to use the same configuration of genson on both sides. So enable type information with setWithClassMetadata and if you use aliases, you must define the same on the client side.

What you need is #JsonTypeInfo annotation, like so:
class Message {
#JsonTypeInfo(use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.PROPERTY property="type")
#JsonProperty("content")
Object content;
}
(you can see http://programmerbruce.blogspot.com/2011/05/deserialize-json-with-jackson-into.html for examples)
which would add property "type" with class name as value (there are many alternative ways as well) when serializing, and using that when deserializing.

Thank you for all the answers. But I found another way to convert my Object to any type I want.
I'm using the method convertValue from the ObjectMapper object. Then, I can simulate the casting.
Thanks again

Document-literal-bare webservice in Weblogic

I need to create a webservice, that accepts any xml in the request soap:Body element and replies with any xml in the respond soap:Body. The appropriate WS operation style is (in my opinion) "document-literal-bare". I expect that the resulting WSDL message would look something like this:
<s0:message name="process">
<s0:part type="xs:any"/>
</s0:message>
How am I to do it?
Details:
In Weblogic 10.3, I have written:
#WebService(.....)
#SOAPBinding(style=SOAPBinding.Style.DOCUMENT, use=SOAPBinding.Use.LITERAL, parameterStyle=ParameterStyle.BARE)
public class BackEndSimulatorWS {
#WebMethod
public XmlObject process(XmlObject request) {
.....
}
}
However the Eclipse protests with
(The "process" method) must be doc/literal/wrapped when binding wildcards to any.
I understand that the WS must be able to determine which method to execute, so I tried to annotate the method with
#Webmethod(action="simulation")
but this didn't help. When I replace the org.apache.xmlbeans.XmlObject parameter and response type with org.w3c.dom.Document, the error disappears, but the resulting WSDL messages are not general, they are of the {java:org.w3c.dom}:Document type.
Any help will be appreciated.

apache camel and jackson

I'm trying out apache-camel, and I've set up a basic route that calls an http service via http4 component, transforms the result via unmarshal().json(JsonLibrary.Jackson), and then prints out part of the response in a bean component.
The problem I'm having is that it blows up at runtime when it gets to the json unmarhsaller:
No type converter available to convert from type: java.util.HashMap to the required type: com.xxx.MyType
The response is of this format:
{"data":[{"x":"y"},{"x":"z"}]}
And my object model is like:
#lombok.Data
class Response {
private List<Elem> data;
}
#lombok.Data
class Elem {
private String x;
}
So it would appear that the unmarshaller thinks the response is a hash map, whereas I want it to unmarshal into an object structure. Is there a way to get it to do what I want?

Found the answer, posting in case anyone else runs into this. The route builder should be setup like:
from("direct:start").to("http4://...").unmarshal().json(JsonLibrary.Jackson,com.xxx.Response)
.to("bean:com.xxx.MyResponseEchoer")
I.e. pass the class type to the json method.

Webservice with CXF: How to use the ResponseWrapper?

We are creating a webservice (CXF-based) driven by a java class (Java2WS) with the following method:
#WebMethod
#RequestWrapper(className = "com.myproject.wrapper.MyRequestWrapper")
#ResponseWrapper(className = "com.myproject.wrapper.MyResponseWrapper")
public MyResponse verifyCode(#WebParam(name = "code") String code) {
...
return new MyResponse("Hello",StatusEnum.okay);
}
I use the wrappers to define the elements of the request resp. response in more detail: the correct element names (which start with an uppercase character), required and optional elements, ...). But I am not sure if this is the right way to do it (there is no in-depth documentation about wrappers, isn't it?)
The class MyResponse:
public class MyResponseWrapper {
private String result;
private ModeEnum status;
// getters and setters
}
The class MyReponseWrapper
#XmlRootElement
#XmlAccessorType(XmlAccessType.FIELD)
#XmlType(name = "myResponse")
public class MyResponseWrapper {
#XmlElement(name="Result")
private String result;
#XmlElement(name = "Status")
private StatusEnum status;
public MyResponseWrapper() {
result="fu"; // just for testing
}
// getters and setters
}
Currently I don't understand the Wrappers. When I return an instance of MyReponse, how does the data from MyResponse be injected into MyResponseWrapper respectivly to the SOAP body of the response?
By testing this webservice I can see that an instance of MyResponseWrapper is instantiated and the SOAP body contains the correct elements but with default data (for example: result="fu" instead of "Hello"). I expected that CXF injects matching data from MyResponse to MyResponseWrapper. Is that wrong?
If this is the wrong way to do it:
Wat is the right way to specify the resulting SOAP xml when using Java2WS?
By the way: The above source snippets are just examples taken from our more complex (more fields) classes.

This is the right way to do it.
The request and response wrappers just allow for overriding the xml namespace and element/attribute names for the request/response elements; respectively - which in turn map to the methods used to manage those values.
Ref: http://cxf.apache.org/docs/developing-a-service.html#DevelopingaService-The#RequestWrapperannotation
The #RequestWrapper annotation is defined by the
javax.xml.ws.RequestWrapper interface. It is placed on the methods in
the SEI. As the name implies, #RequestWrapper specifies the Java class
that implements the wrapper bean for the method parameters that are
included in the request message sent in a remote invocation. It is
also used to specify the element names, and namespaces, used by the
runtime when marshalling and unmarshalling the request messages.
The following table describes the properties of the #RequestWrapper
annotation.
localName
Specifies the local name of the wrapper element in the XML
representation of the request message. The default value is the name
of the method or the value of the #WebMethod annotation's
operationName property.
targetNamespace
Specifies the namespace under which the XML wrapper element is
defined. The default value is the target namespace of the SEI.
className
Specifies the full name of the Java class that implements the wrapper
element.