@Path("/employeeInfo")

public class RestWebServiceJersey {

   @POST

     @Consumes(MediaType.APPLICATION_XML)

     @Produces(MediaType.APPLICATION_XML)

   public String submitEmployeeInfo(Employee employee) {

        StatusDto status = insertIntoDb(employee);

             return status;

   }

}

XMLReader xr = XMLReaderFactory.createXMLReader();

xr.setContentHandler(this);

HttpURLConnection connection = openConnection("/listPaths" + path,

"ugi=" + ugi + (recur? "&recursive=yes" : ""));

connection.setRequestMethod("GET");

connection.connect();



InputStream resp = connection.getInputStream();

xr.parse(new InputSource(resp));

TransformerFactory tFactory = TransformerFactory.newInstance();



Transformer transformer = tFactory.newTransformer(

new StreamSource(styleSheet)

);



transformer.transform(new StreamSource(xml), new StreamResult(out));

  private void expectScalarField(JsonParser parser, String name)

      throws IOException {

    expect(parser, JsonToken.FIELD_NAME);

    if (!parser.getCurrentName().equals(name)) {

      throw new RuntimeException("expected field " + name + ", got "

          + parser.getCurrentName());

    }

    final JsonToken t = parser.nextToken();

    switch (t) {

    case VALUE_NULL:

    case VALUE_FALSE:

    case VALUE_TRUE:

    case VALUE_NUMBER_INT:

    case VALUE_NUMBER_FLOAT:

    case VALUE_STRING:

      break;

    default:

      throw new RuntimeException("expected scalar field, got  " + t);

    }

  }

  public JsonEnumerator(File file) {

    try {

      final ObjectMapper mapper = new ObjectMapper();

      mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);

      mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);

      mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);

      List<Object> list = mapper.readValue(file, List.class);

      enumerator = Linq4j.enumerator(list);

    } catch (IOException e) {

      throw new RuntimeException(e);

    }

  }

Employee employee = new Employee()

               .withEmployeeId(123)

               .withDeptId(456)

               .build();



JAXBContext context = JAXBContext.newInstance(Employee.class);

Marshaller marshaller = context.createMarshaller();

marshaller.marshal(employee, System.out); // prints XML for the object

    public InputStream getDeploymentPackage(String id, String version) throws OverloadedException, IOException {

        List<ArtifactData> data = m_provider.getBundleData(id, version);

        Manifest manifest = new Manifest();

        Attributes main = manifest.getMainAttributes();



        main.putValue("Manifest-Version", "1.0");

        main.putValue("DeploymentPackage-SymbolicName", id);

        main.putValue("DeploymentPackage-Version", version);



        for (ArtifactData bd : data) {

            manifest.getEntries().put(bd.getFilename(), bd.getManifestAttributes(false));

        }



        return DeploymentPackageStream.createStreamForThread(m_connectionFactory, manifest, data.iterator(), false);

    }

    public void testGatherSingleArtifactOk() throws Exception {

        DeploymentArtifactCollector handler = new DeploymentArtifactCollector(TARGET, VERSION1);



        m_parser.parse(m_inputStream, handler);



        List<XmlDeploymentArtifact>[] artifacts = handler.getArtifacts();

        assert artifacts.length == 1 : "Expected a single artifact to be found!";

        assert artifacts[0].size() == 1 : "Expected a single artifact to be found!";



        XmlDeploymentArtifact artifact1 = artifacts[0].get(0);

        assert new URL("file:///bundle1").equals(artifact1.getUrl()) : "Expected 'file:///bundle1' URL to be found!";

        assert artifact1.getDirective().size() == 2 : "Expected two directives to be found!";

        assert "bundle1".equals(artifact1.getDirective().get(KEY_SYMBOLICNAME)) : "Expected correct symbolic name to be found!";

        assert "1.0.0".equals(artifact1.getDirective().get(KEY_VERSION)) : "Expected correct bundle version to be found!";

    }

    protected void setUp() throws Exception {

        SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();

        m_parser = saxParserFactory.newSAXParser();



        String xml = generateValidTestXml();

        m_inputStream = new ByteArrayInputStream(xml.getBytes());

    }

    private Document getDocument(InputStream input) throws IOException {

        try {

            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

            DocumentBuilder builder;

            builder = factory.newDocumentBuilder();

            return builder.parse(input);

        }

        catch (ParserConfigurationException e) {

            throw new IOException("Error instantiation XML parser:" + e.getMessage());

        }

        catch (SAXException e) {

            throw new IOException("Error parsing user data:" + e.getMessage());

        }

    }