java प्रामाणिकता वसंत SOAP से कार्यदिवस तक



spring wsdl (1)

मैं SOAP अनुरोधों को संभालने में बहुत नया हूँ और मैं यहां सूचीबद्ध कार्यदिवस SOAP API का उपयोग करने की कोशिश कर रहा हूं। मैंने स्प्रिंग ट्यूटोरियल के आधार पर डब्लूएसडीएल से कक्षाएं जेनरेट करने के लिए एक gradle/ant स्क्रिप्ट का उपयोग किया है

अब जब कक्षाएं उत्पन्न हुईं हैं, तो मुझे फ़ंक्शंस की आवश्यकता है। समस्या ये है कि मुझे नहीं पता कि मेरे अनुरोधों को कैसे प्रमाणित किया जाए।

अभी तक मेरे पास इतना ही है:

import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import org.springframework.ws.client.core.support.WebServiceGatewaySupport;
import workday_Staffing.wsdl.GetWorkersRequestType;
import workday_Staffing.wsdl.GetWorkersResponseType;

public class StaffingClient extends WebServiceGatewaySupport {

    public StaffingClient() {
        Jaxb2Marshaller jaxb2Marshaller = new Jaxb2Marshaller();
        jaxb2Marshaller.setContextPath("workday_Staffing.wsdl");
        setMarshaller(jaxb2Marshaller);
        setUnmarshaller(jaxb2Marshaller);
    }

    public void makeWorkdayRequest() {

        // make the request - missing some authentication here
        GetWorkersRequestType request = new GetWorkersRequestType();
        GetWorkersResponseType workersResponseType = (GetWorkersResponseType) getWebServiceTemplate()
            .marshalSendAndReceive(request);
    }
}

जवाब यहाँ एक अच्छी सीसा जैसा लगता है, लेकिन मुझे याद आ रहा है कि क्लाइंट बनाने और प्रमाणीकरण कैसे जोड़ना है।

किसी भी प्रकार की सहायता सराहनीय होगी।


मुख्य रूप से, ऐसा लगता है कि आप WS-Security credentials के लिए SOAPHandler द्वारा प्रमाणीकरण के टुकड़े खो चुके हैं। एफवाईआई, यह वसंत नहीं है, लेकिन एपीआई के वी 16 के रूप में कोड काम कर रहा था।

पुरानी यादों की गलियों में यात्रा हेतु धन्यवाद।

कदम

  1. कार्यदिवस के उपयोगकर्ता नाम और किरायेदार सेट करें
  2. कार्यदिवस का पासवर्ड सेट करें
  3. वेब सेवा क्लाइंट स्टब (पूर्व HumanResourcesService) सेट करें
  4. वेब सेवा ग्राहक पोर्ट सेट करें
  5. क्लाइंट स्टब के लिए कार्यदिवस क्रेडेंशियल्स हैंडलर को जोड़ें, पोर्ट के संदर्भ में, कार्यदिवस के उपयोगकर्ता @ किरायेदार, और कार्यदिवस का पासवर्ड।
  6. अनुरोध प्रसंग प्राप्त करें
  7. अनुरोध संदर्भ के कार्यदिवस की वेबसाइज़र समापन बिंदु सेट करें (देखें wdEndPoint)
  8. GetWorkersRequestType
  9. वैकल्पिक रूप से आपके अनुरोध के लिए कुछ पैरामीटर सेट करें
  10. प्रतिक्रिया प्राप्त करें
  11. प्रतिक्रिया डेटा प्राप्त करें

दिनचर्या

  • GetWorkers
  • WorkdayCredentials

गेटवॉर्कर कोड

package com.workday.demo;

import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.Map;
import java.math.BigDecimal;

import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import javax.xml.ws.BindingProvider;

import com.workday.human_resources.*;

public class GetWorkers {

    public static void main(String[] args) {

        try {

            // Enter user/password and endpoint information for Proof of Concept
            final String wdUser = "[email protected]";
            final String wdPassword = "zzz";

            // final String wdEndpoint =
            // "https://e2-impl-cci.workday.com/ccx/service/exampleTenant/Human_Resources/v16";
            final String wdEndpoint = "https://impl-cc.workday.com/ccx/service/exampleTenant/Human_Resources/v16";

            System.out.println("Starting...");

            // Create the Web Service client stub
            HumanResourcesService service = new HumanResourcesService();
            HumanResourcesPort port = service.getHumanResources();

            // Add the WorkdayCredentials handler to the client stub
            WorkdayCredentials.addWorkdayCredentials((BindingProvider) port, wdUser, wdPassword);

            // Assign the Endpoint URL
            Map<String, Object> requestContext = ((BindingProvider) port).getRequestContext();
            requestContext.put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY,   wdEndpoint);

            // Define the paging defaults
            final int countSize = 200;
            int totalPages = 1;
            int currentPage = 1;

            // Set the current date/time
            GregorianCalendar cal = new GregorianCalendar();
            XMLGregorianCalendar xmlCal = DatatypeFactory.newInstance().newXMLGregorianCalendar(cal);

            // Loop over all of the pages in the web service response
            while (totalPages >= currentPage) {
                // Create a "request" object
                GetWorkersRequestType request = new GetWorkersRequestType();

                // Set the WWS version desired
                request.setVersion("v10");

                // Set the date/time & page parameters in the request
                ResponseFilterType responseFilter = new ResponseFilterType();
                responseFilter.setAsOfEntryDateTime(xmlCal);
                responseFilter.setAsOfEffectiveDate(xmlCal);
                responseFilter.setPage(BigDecimal.valueOf(currentPage));
                responseFilter.setCount(BigDecimal.valueOf(countSize));
                request.setResponseFilter(responseFilter);

                // Set the desired response group(s) to return
                WorkerResponseGroupType responseGroup = new WorkerResponseGroupType();
                responseGroup.setIncludeReference(true);
                request.setResponseGroup(responseGroup);

                // Submit the request creating the "response" object
                GetWorkersResponseType response = port.getWorkers(request);

                // Display all Workers
                Iterator<WorkerType> i = response.getResponseData().getWorker()
                        .iterator();
                while (i.hasNext()) {
                    WorkerType worker = i.next();
                    {
                        System.out.println(worker.getWorkerReference()
                                .getDescriptor());
                    }
                }

                // Update page number
                if (totalPages == 1) {
                    totalPages = response.getResponseResults().getTotalPages()
                            .intValue();
                }
                currentPage++;
            }

        } catch (ProcessingFaultMsg e) {
            e.printStackTrace();
        } catch (ValidationFaultMsg e) {
            e.printStackTrace();
        } catch (DatatypeConfigurationException e) {
            e.printStackTrace();
        }
    }
}

कार्य दिवस प्रमाणन कोड

package com.workday.demo;

import java.util.List;

import javax.xml.soap.SOAPElement;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPHeader;
import javax.xml.soap.SOAPMessage;
import javax.xml.ws.BindingProvider;
import javax.xml.ws.handler.Handler;
import javax.xml.ws.handler.MessageContext;
import javax.xml.ws.handler.soap.SOAPHandler;
import javax.xml.ws.handler.soap.SOAPMessageContext;
import javax.xml.namespace.QName;
import java.util.Set;

/**
 * This class creates a handler that will add the WS-Security username and
 * password to the to the SOAP request messages for a client side proxy.
 * 
 */
public class WorkdayCredentials implements SOAPHandler<SOAPMessageContext> {

    /** Namespace for the SOAP Envelope. */
    private static String SOAPENVNamespace = "http://schemas.xmlsoap.org/soap/envelope/";

    /** The prefix that will be used for the SOAP Envelope namespace. */
    private static String SOAPENVPrefix = "soapenv";

    /** Namespace for the WS-Security SOAP header elements. */
    private static String WSSENamespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";

    /** The prefix that will be used for the WS-Security namespace. */
    private static String WSSEPrefix = "wsse";

    /**
     * The WS-Security URI that specifies that the password will be transmitted
     * as plain text.
     */
    private static String WSSEPasswordText = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText";

    /**
     * The user name that will be sent in the WS-Security header on the SOAP
     * request message. This is of the form [email protected]
     */
    private String username;

    /**
     * The password that will be sent in the WS-Security header on the SOAP
     * request message.
     */
    private String password;

    /**
     * This method created an instance of the WorkdayCredentials class and adds
     * it as a handler to the bindingProvider supplied.
     * 
     * @param bindingProvider
     *            The client stub to which the handler will be added. The most
     *            convenient way to obtain the required bindingProvvider is to
     *            call one of the getPort methods on the Service class for the
     *            Web service and then cast the returned object to a
     *            BindingProvider.
     * @param username
     *            The id and tenant name for the user. This is of the form
     *            [email protected]
     * @param password
     *            The password for the system user.
     */
    @SuppressWarnings("unchecked")
    public static void addWorkdayCredentials(BindingProvider bindingProvider,
            String username, String password) {
        List<Handler> handlerChain = bindingProvider.getBinding().getHandlerChain();
        handlerChain.add(new WorkdayCredentials(username, password));
        bindingProvider.getBinding().setHandlerChain(handlerChain);
    }

    /**
     * Creates a WorkdayCredentials handler and initialises the member
     * variables. In most cases, the addWorkdayCredentials static method should
     * be used instead.
     * 
     * @param username
     *            The id and tenant name for the user. This is of the form
     *            [email protected]
     * @param password
     *            The password for the system user.
     */
    public WorkdayCredentials(String username, String password) {
        this.username = username;
        this.password = password;
    }

    /**
     * Returns null as this handler doesn't process any Headers, it just adds
     * one.
     */
    public Set<QName> getHeaders() {
        return null;
    }

    /**
     * Adds WS-Security header to request messages.
     */
    public boolean handleMessage(SOAPMessageContext smc) {
        Boolean outboundProperty = (Boolean) smc
                .get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);
        if (outboundProperty.booleanValue()) {
            addWSSecurityHeader(smc, username, password);
        }
        return true;
    }

    /**
     * Returns true, no action is taken for faults messages.
     */
    public boolean handleFault(SOAPMessageContext smc) {
        return true;
    }

    public void close(MessageContext messageContext) {
    }

    /**
     * Adds a WS-Security header containing a UsernameToken to a SOAP message.
     * 
     * @param smc
     *            The SOAPMessageContent to which the WS-Security header will be
     *            added.
     * @param username
     *            The WS-Security username.
     * @param password
     *            The WS-Security password.
     * 
     * @throws java.lang.RuntimeException
     *             This exception will be thrown if a SOAPException occurs when
     *             modifying the message.
     */
    private void addWSSecurityHeader(SOAPMessageContext smc, String username,
            String password) throws java.lang.RuntimeException {

        try {
            // Get the SOAP Header
            SOAPMessage message = smc.getMessage();
            SOAPHeader header = message.getSOAPHeader();
            if (header == null) {
                // Create header as it doesn't already exist
                message.getSOAPPart().getEnvelope().addHeader();
                header = message.getSOAPHeader();
            }

            // Add WS-Security SOAP Header
            SOAPElement heSecurity = header.addChildElement("Security",
                    WSSEPrefix, WSSENamespace);
            heSecurity.addAttribute(message.getSOAPPart().getEnvelope()
                    .createName("mustUnderstand", SOAPENVPrefix,
                            SOAPENVNamespace), "1");

            // Add the Usernametoken element to the WS-Security Header
            SOAPElement heUsernameToken = heSecurity.addChildElement(
                    "UsernameToken", WSSEPrefix, WSSENamespace);

            // Add the Username element to the UsernameToken Element
            heUsernameToken.addChildElement("Username", WSSEPrefix,
                    WSSENamespace).addTextNode(username);

            // Add the Password element to the UsernameToken Element
            SOAPElement hePassword = heUsernameToken.addChildElement(
                    "Password", WSSEPrefix, WSSENamespace);
            hePassword.addAttribute(message.getSOAPPart().getEnvelope()
                    .createName("Type"), WSSEPasswordText);
            hePassword.addTextNode(password);

        } catch (SOAPException e) {
            throw new RuntimeException(
                    "Failed to add WS-Security header to request", e);
        }
    }
}




workday