Entiendo que su problema se reduce a cómo llamar a un servicio web SOAP (JAX-WS) desde Java y obtener su objeto de retorno . En ese caso, tiene dos enfoques posibles:
- Genere las clases de Java
wsimporty utilícelas; o
- Cree un cliente SOAP que:
- Serializa los parámetros del servicio en XML;
- Llama al método web mediante manipulación HTTP; y
- Analice la respuesta XML devuelta en un objeto.
Sobre el primer enfoque (uso wsimport):
Veo que ya tiene las clases de negocio de los servicios (entidades u otras), y es un hecho que wsimportgenera un nuevo conjunto de clases (que de alguna manera son duplicados de las clases que ya tiene).
Sin embargo, me temo que en este escenario solo puedes:
- Adapte (edite) el
wsimportcódigo generado para que use sus clases de negocios (esto es difícil y de alguna manera no vale la pena; tenga en cuenta que cada vez que cambie el WSDL, tendrá que regenerar y readaptar el código); o
- Ríndete y usa las
wsimportclases generadas. (En esta solución, su código comercial podría "usar" las clases generadas como un servicio desde otra capa arquitectónica).
Acerca del segundo enfoque (cree su cliente SOAP personalizado):
Para implementar el segundo enfoque, deberá:
- Haz la llamada:
- Utilice el marco SAAJ (SOAP con API de archivos adjuntos para Java) (consulte a continuación, se envía con Java SE 1.6 o superior) para realizar las llamadas; o
- También puedes hacerlo a través
java.net.HttpUrlconnection(y algo de java.iomanipulación).
- Convierta los objetos en XML y viceversa:
- Utilice un marco OXM (Object to XML Mapping) como JAXB para serializar / deserializar el XML desde / hacia objetos
- O, si es necesario, cree / analice manualmente el XML (esta puede ser la mejor solución si el objeto recibido es solo un poco diferente del enviado).
Crear un cliente SOAP usando Classic java.net.HttpUrlConnectionno es tan difícil (pero tampoco tan simple), y puedes encontrar en este enlace un muy buen código de inicio.
Te recomiendo que uses el marco SAAJ:
SOAP con API de adjuntos para Java (SAAJ) se utiliza principalmente para tratar directamente con los mensajes de solicitud / respuesta de SOAP que ocurren detrás de escena en cualquier API de servicio web. Permite a los desarrolladores enviar y recibir mensajes de jabón directamente en lugar de utilizar JAX-WS.
Vea a continuación un ejemplo funcional (¡ejecútelo!) De una llamada de servicio web SOAP usando SAAJ. Llama a este servicio web .
import javax.xml.soap.*;
public class SOAPClientSAAJ {
// SAAJ - SOAP Client Testing
public static void main(String args[]) {
/*
The example below requests from the Web Service at:
https://www.w3schools.com/xml/tempconvert.asmx?op=CelsiusToFahrenheit
To call other WS, change the parameters below, which are:
- the SOAP Endpoint URL (that is, where the service is responding from)
- the SOAP Action
Also change the contents of the method createSoapEnvelope() in this class. It constructs
the inner part of the SOAP envelope that is actually sent.
*/
String soapEndpointUrl = "https://www.w3schools.com/xml/tempconvert.asmx";
String soapAction = "https://www.w3schools.com/xml/CelsiusToFahrenheit";
callSoapWebService(soapEndpointUrl, soapAction);
}
private static void createSoapEnvelope(SOAPMessage soapMessage) throws SOAPException {
SOAPPart soapPart = soapMessage.getSOAPPart();
String myNamespace = "myNamespace";
String myNamespaceURI = "https://www.w3schools.com/xml/";
// SOAP Envelope
SOAPEnvelope envelope = soapPart.getEnvelope();
envelope.addNamespaceDeclaration(myNamespace, myNamespaceURI);
/*
Constructed SOAP Request Message:
<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:myNamespace="https://www.w3schools.com/xml/">
<SOAP-ENV:Header/>
<SOAP-ENV:Body>
<myNamespace:CelsiusToFahrenheit>
<myNamespace:Celsius>100</myNamespace:Celsius>
</myNamespace:CelsiusToFahrenheit>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
*/
// SOAP Body
SOAPBody soapBody = envelope.getBody();
SOAPElement soapBodyElem = soapBody.addChildElement("CelsiusToFahrenheit", myNamespace);
SOAPElement soapBodyElem1 = soapBodyElem.addChildElement("Celsius", myNamespace);
soapBodyElem1.addTextNode("100");
}
private static void callSoapWebService(String soapEndpointUrl, String soapAction) {
try {
// Create SOAP Connection
SOAPConnectionFactory soapConnectionFactory = SOAPConnectionFactory.newInstance();
SOAPConnection soapConnection = soapConnectionFactory.createConnection();
// Send SOAP Message to SOAP Server
SOAPMessage soapResponse = soapConnection.call(createSOAPRequest(soapAction), soapEndpointUrl);
// Print the SOAP Response
System.out.println("Response SOAP Message:");
soapResponse.writeTo(System.out);
System.out.println();
soapConnection.close();
} catch (Exception e) {
System.err.println("\nError occurred while sending SOAP Request to Server!\nMake sure you have the correct endpoint URL and SOAPAction!\n");
e.printStackTrace();
}
}
private static SOAPMessage createSOAPRequest(String soapAction) throws Exception {
MessageFactory messageFactory = MessageFactory.newInstance();
SOAPMessage soapMessage = messageFactory.createMessage();
createSoapEnvelope(soapMessage);
MimeHeaders headers = soapMessage.getMimeHeaders();
headers.addHeader("SOAPAction", soapAction);
soapMessage.saveChanges();
/* Print the request message, just for debugging purposes */
System.out.println("Request SOAP Message:");
soapMessage.writeTo(System.out);
System.out.println("\n");
return soapMessage;
}
}
Acerca del uso de JAXB para serializar / deserializar, es muy fácil encontrar información al respecto. Puede comenzar aquí: http://www.mkyong.com/java/jaxb-hello-world-example/ .