import org.json.JSONException;
import org.json.JSONObject;
import org.json.XML;

XML.toJSONObject(xml_text).toString()

org.json.XML

Off-the-shelf programs to convert XML to JSON almost invariably produce something that isn't quite the JSON you want. That's because you know more about the semantics of the data than the general-purpose program does. Some of the utilities are more customizable than others, but none is perfect.

I think for most real-life conversions you should expect to do some tweaking either of the XML pre-transformation, or of the JSON post-transformation. Tweaking the XML is probably easier because there's nothing quite as powerful as XSLT on the JSON side.

You could try the XmlMapper from jackson (com.fasterxml.jackson.dataformat.xml.XmlMapper)

XmlMapper xmlMapper = new XmlMapper();
JsonNode jsonNode = xmlMapper.readTree(string.getBytes());
ObjectMapper objectMapper = new ObjectMapper();
String value = objectMapper.writeValueAsString(jsonNode);

edit: Dependencies I've used

<dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.0</version>
</dependency>
<dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-xml</artifactId>
        <version>2.9.0</version>
</dependency>

JSON in Java has some great resources.

Maven dependency:

<dependency>
  <groupId>org.json</groupId>
  <artifactId>json</artifactId>
  <version>20180813</version>
</dependency>

XML.java is the class you're looking for:

import org.json.JSONObject;
import org.json.XML;
import org.json.JSONException;

public class Main {

    public static int PRETTY_PRINT_INDENT_FACTOR = 4;
    public static String TEST_XML_STRING =
        "<?xml version=\"1.0\" ?><test attrib=\"moretest\">Turn this to JSON</test>";

    public static void main(String[] args) {
        try {
            JSONObject xmlJSONObj = XML.toJSONObject(TEST_XML_STRING);
            String jsonPrettyPrintString = xmlJSONObj.toString(PRETTY_PRINT_INDENT_FACTOR);
            System.out.println(jsonPrettyPrintString);
        } catch (JSONException je) {
            System.out.println(je.toString());
        }
    }
}

Output is:

{"test": {
    "attrib": "moretest",
    "content": "Turn this to JSON"
}}

The source XML file or string can be parsed in many different ways. I choose the XmlDocument class since it's simple to use and directly compatible with the JSON serializer.

The XML has two elements:
- A prolog that defines the XML version (but not the encoding: UTF-8 is assumed)
- A Root element (ATT_ADDR_VAL_RESP), which contains Attributes that need to be removed when the XML is converted to a JSON format.

The XmlDocument.Load() or XmlDocument.LoadXml() methods can be used to generate XML Document object.
- The former expects a Stream or a string that represents a Path to a file (or a Xml/Text Reader)
- The latter only parses XML strings

Assuming it's a Stream, we can generate the XmlDocument using its Load() method:

Dim doc = New XmlDocument()
doc.Load([XML Stream])  
' or doc.Load([XML File Path])
' or doc.LoadXml([XML String])

To remove the prolog element, we can remove the first child Node of the XmlDocument:

doc.RemoveChild(doc.FirstChild)

Since the Root element (ATT_ADDR_VAL_RESP) needs to be preserved (as in the sample result), while its Attributes should be removed, we can use the XmlNode.Attributes collection's RemoveAll() method to perform the clean-up:

doc.FirstChild.Attributes.RemoveAll()

If the Root element is not really required, we could also use the JsonConvert.SerializeXmlNode overload that allows to specify whether the Root element should be preserved:

Dim json = JsonConvert.SerializeXmlNode(doc, Formatting.Indented, True)

The last argument specifies that the Root element should be omitted.

The first child Node of the Root element also contains Arguments that need to be removed:

For Each childNode As XmlNode in doc.FirstChild.ChildNodes
    childNode.Attributes.RemoveAll()
Next

All parts combined, using Json.NET to serialize the XML to a JSON string:

Dim doc = New XmlDocument()
doc.Load([XML Stream])  

' FirstChild is the prolog element
doc.RemoveChild(doc.FirstChild)

' Now FirstChild is the XML Root element
doc.FirstChild.Attributes.RemoveAll()

For Each childNode As XmlNode in doc.FirstChild.ChildNodes
    childNode.Attributes.RemoveAll()
Next

' Or RemoveAllAttributes(doc)

Dim json = JsonConvert.SerializeXmlNode(doc, Formatting.Indented)

If all child Nodes need to be stripped of their Attributes, a recursive method can be used instead of a loop:

RemoveAllAttributes(doc)
(...)

Private Sub RemoveAllAttributes(XmlNode node)
    if node.Attributes IsNot Nothing Then node.Attributes.RemoveAll()
    For Each childNode As XmlNode In node.ChildNodes
        If childNode.Attributes IsNot Nothing Then childNode.Attributes.RemoveAll()
        If childNode.HasChildNodes Then
            RemoveAllAttributes(childNode)
        End if
    Next
End Sub

You may take a look at the Json-lib Java library, that provides XML-to-JSON conversion.

String xml = "<hello><test>1.2</test><test2>123</test2></hello>";
XMLSerializer xmlSerializer = new XMLSerializer();  
JSON json = xmlSerializer.read( xml );  

If you need the root tag too, simply add an outer dummy tag:

String xml = "<hello><test>1.2</test><test2>123</test2></hello>";
XMLSerializer xmlSerializer = new XMLSerializer();  
JSON json = xmlSerializer.read("<x>" + xml + "</x>");