Develop Reference

Marshalling entity to JSON using JAXB on Wildfly

Is it possible using Wildfly's JAXB implementation?
There is an answer Converting Java Object to Json using Marshaller, but it seems to be implementation specific.

if you were constrained to use the jaxb (for example, when you need the flexibility to have both xml and json class in the same spot) you might want to refer to these
Wildfly Reference
A Simple tutorial, from MKYong
but if the jaxb is not a constraint to have, i reccomend using either GSON or jackson. they are both relatively easy to use when reading json to a POJO and vice-versa

JSR-353 does not include object binding. If you want to marshal/unmarshal JSON you'd have to using something like Jackson.
It does you know real good now, but there is JSR-367 to include bindings in Java EE 8.

What are the differences between mapping,binding and parsing?

I am starting to learn web-services in java EE6.
I did web development before, but never nothing related to web services.
All is new to me and the books and the tutorials i find in the web are to technical.
I started learning about .xsd schemas and also .xml.
In that topic i feel confident, i understand what are the schemas used for and what validation means.
Now my next step is learning about JAX-B(Java Api for XML Binding). I rode some about it and i did also some practice in my IDE. But i have lots of basic doubts, that make me stuck and cannot feel confident to continue to the next topic.
Ill appreciate a lot if someone could explain me well my doubts:
What does it mean mapping and what is a mapping tool?
What does it mean binding and what is a binding tool?
What does it mean parsing and what is a parsing tool?
How is JAX-B related to mapping,binding and parsing?
I am seeking for a good answer built by you, not just a copy paste from google(Ive already been online a few hours and only got confused).

Based on what I understand..
What does it mean mapping and what is a mapping tool?
In case of Java/XML, mapping is nothing but representing a Java object model
in to an XML document representation ( and vice versa. )
A mapping tool will allow you to convert from one format to another. This is just the definition step.
What does it mean binding and what is a binding tool?
Binding is the process of in-memory(as the application is running) conversion of XML document to object represantation.
Binding is achieved through unmarshalling.
What does it mean parsing and what is a parsing tool?
Parsing is reading an input stream of data and checking whether if the stream of data coforms to certain grammar. Parsing tools consume stream of data and generate errors when the data fails to conforms to grammar that the tool is checking. It would also generate events to indicate that it has received certain "tokens" from the stream. In java/xml scenario, there are multiple types of parsers such as DOM, StAx, SAX...
How is JAX-B related to mapping,binding and parsing?
JAXB mapping:
is when you use xjc to generate java class hierachy based on an XSD
The mapping occurs when classes are generated with JAXB annotations
Mapping tool in the scenario is xjc
JAXB Binding :
Occurs when an application unmarshalls an XML document to Object represanation
(JAXBElement) unmarshaller.unmarshal(
new File("some.xml"));
Parsing :
in order to convert XML document to object represantation, the JAXB engine has to
first "parse" the xml document to ensure correctness and then tokenize to instatiate java objects. This happens internally and you do not control ito ensure correctness and then tokenize to instatiate java objects.

Would strongly suggest that you get a copy of Java Web Services Up and Running and start at chapter 1 and start from there. It is not easy or intuitive, get ready for a long learning curve. Note. All the binding stuff will just confuse you unless you have a basic understanding of how all the pieces work.

Jackson processor for java bean to json\xml serialization

Hi I am having a java bean and i need to serialize it to json. For this purpose i am using the jackson processor which is very powerful. But I also need to convert the java bean to XML.
Can this be achieved using the jackson processor ?? If yes then please provide with the links where I can get the examples.
Thanks!!!!

If you want to keep Jackson and JSON out of your pojos, you can create a translation layer that can translate to a JAXB object and use pure JAXB (JAXB being one possible implementation in this case). If your domain objects map straight to the rendered JSON or you can use mixins/PropertyNamingStrategy, you will need no annotations in your pojos. I'm not sure if this is applicable in your situation but I know that many environments strive for this.

Definitely! Jackson obviously has first-class support for JSON; but there is also simple extension module to do "mini-JAXB": jackson-xml-databind.
With Jackson's support for JAXB annotations (or not, if you just prefer Jackson's own annotations & xml module's couple additional ones), it's definitely possible to do both JSON and XML just using Jackson functionality.
I mostly recommend this for cases where XML support is a legacy thing (which is what most new services do). If XML is the main focus, it may make more sense to use JAXB.
But even then I recommend against using conversion layers from XML to JSON; ones I have seen used have been plagues with issues when they conversion at data format layer, which IMO is completely wrong place to do it. This is also why Jackson does not try converting JSON to XML (or vice versa); rather, it only supports converting POJOs to/from external data formats.

Yes it is possible. You would need to annotate your Java bean using the JAXB annotations which will give you the XML marshalling and unmarshalling support. Then, using Jackson's support for JAXB annotations you can go back and forth between Java and JSON.

Which web service stack allows binding wsdl first web service to existing classes in Java?

Greetings,
I have a complicated scenario to handle. I have a wsdl file which uses a particular XML schema.
The XML schema is actually a handcrafted implementation of a specification. There is also a Java based implementation of the same specification. So the XSD used in WSDL and Java classes at hand are quite similar, but not exactly same.
Almost all web service stacks allow creating classes from WSDL or creating WSDL from Java class annotations.
What I want to do, is to use the WSDL and bind XSD used in the wsdl to existing java classes.
Should/can I do this by manually replacing generated Java classes with existing ones? Is it a matter of changing type names in config files and moving binding annotations to existing classes?
If you know any best practices, or java web service stacks that support this kind if flexibility in a practical way, your response would be much appreciated.
Best Regards
Seref

I suggest Spring's Web Services module, which has no code generation involved, but provides a clean separation of concerns. Different concerns are broken out nicely by allowing you to provide your WSDL and existing schema(s) on one side (contract first), your existing Java-based domain model on the other, and a way to plugin in your OXM (Object-XML Mapping) technology of choice.
Since you have hand-crafted WSDL/schema and hand-crafted Java classes, the real work will be in configuring your OXM. I prefer JiBX as it keeps the concerns separated (no XML annotation garbage mixed into your domain) with JAXB as a backup if the learning curve looks too steep. Spring Web Services supports several other OXM frameworks, and you can even use several different ones at once.
As far as best-practices, I consider hand-crafted code a best practice, though I may be in the minority. If you generate classes from XML you end up with classes that are simple data containers with no behavior (assuming you want to regenerate them whenever your WSDL/XSD changes). This is bad if you favor the object-oriented paradigm because you end up having to place your "business logic" in utilities/helpers/services etc. instead of in the domain objects where it really belongs. This is one reason I favor JiBX. I can make very nice OO objects with behavior, a nice clean schema that doesn't necessarily match the objects, and can manage changes to either side with a mapping file similar to how hibernate does it for ORM (Object-Relational Mapping). You can do the same with JAXB, but that requires embedding XML structure into your object model, and binds a single XML representation to it (whereas with JiBX you can have many).

MOXY (I'm the tech lead) was designed for instances where you have an existing XML Schema and an exsting object model. It accomplishes this through XPath based mapping and can ever handle cases where the models are not that similar:
parse google geocode with xstream
MOXy also has an external binding file:
http://wiki.eclipse.org/EclipseLink/Examples/MOXy/EclipseLink-OXM.XML
MOXy is a JAXB implementation with extensions (A couple of which are mentioned above). IF you go ahead with Spring, MOXy is configured as a JAXB implementation, and you need to add a jaxb.properties file in with your model classes with the following entry:
javax.xml.bind.context.factory=org.eclipse.persistence.jaxb.JAXBContextFactory

Declarative XML -> POJO conversion

I have to write a process (in Java) which periodically hits a URL, reads the returned XML document, and persists that data into the DB. This data is further used by my application, so I have modeled them as Hibernate-mapped POJOs.
I can parse the XML and then create appropriate POJOs, but I was looking for a simpler declarative approach. What libraries are available which can take a input configuration and create the POJOs from the XML document?

Another alternative could be JiBX
Also, although you said you don't want to parse the XML, XPath can be a very concise way of extracting the content you are interested in?

JAXB can automatically create classes based on an XML Schema (assuming you have one for the XML source). At runtime, it can then convert the XML document into POJOs representing the XML. It is declarative in that you can tweak the Schema-to-class mapping, a little.
If I understand your task correctly, this is pretty much the use-case JAXB was designed for (though it can do other things too). It's part of Java 1.6 (maybe 1.5 too?), in packages: javax.xml.bind.*

You can use XStream to deserialize the XML and map it directly to the Hibernate-mapped POJOs.
Cheers.

Using Hibernate you can directly map XML to table. This is experimental feature. Check here
http://www.hibernate.org/hib_docs/v3/reference/en-US/html/xml.html

EclipseLink JAXB (MOXy) has extensions for mapping JPA entities to XML (JPA entities have things like embedded ID classes, lazy loading, and compound key relationships that need special handling), I'm not aware of any other OXM solution that does this.
For more information see:
http://wiki.eclipse.org/EclipseLink/Examples/MOXy/JPA