Developer Utilities

/**
 * JAX-WS RI specific property constants for advanced configuration
 */
package com.sun.xml.ws.developer;
public final class JAXWSProperties {
    /** Content negotiation property for client */
    public static final String CONTENT_NEGOTIATION_PROPERTY = "com.sun.xml.ws.client.ContentNegotiation";
    
    /** MTOM threshold value for attachment handling */
    public static final String MTOM_THRESHOLOD_VALUE = "com.sun.xml.ws.common.MtomThresholdValue";
    
    /** HTTP exchange property for accessing raw HTTP */
    public static final String HTTP_EXCHANGE = "com.sun.xml.ws.http.exchange";
    
    /** Connect timeout property */
    public static final String CONNECT_TIMEOUT = "com.sun.xml.ws.connect.timeout";
    
    /** Request timeout property */
    public static final String REQUEST_TIMEOUT = "com.sun.xml.ws.request.timeout";
    
    /** HTTP response code property */
    public static final String HTTP_RESPONSE_CODE = "com.sun.xml.ws.http.response.code";
    
    /** Inbound header list map property */
    public static final String INBOUND_HEADER_LIST_PROPERTY = "com.sun.xml.ws.api.message.HeaderList";
    
    /** Hostname verifier property for SSL */
    public static final String HOSTNAME_VERIFIER = "com.sun.xml.ws.transport.https.client.hostname.verifier";
    
    /** SSL socket factory property */
    public static final String SSL_SOCKET_FACTORY = "com.sun.xml.ws.transport.https.client.SSLSocketFactory";
    
    /** Disable XML security property */
    public static final String DISABLE_XML_SECURITY = "com.sun.xml.ws.disableXmlSecurity";
}

/**
 * Extended binding provider interface with JAX-WS RI extensions
 */
public interface WSBindingProvider extends BindingProvider {
    /** Set endpoint address */
    void setAddress(String address);
    
    /** Get WS-Addressing endpoint reference */
    WSEndpointReference getWSEndpointReference();
    
    /** Get port information */
    WSPortInfo getPortInfo();
    
    /** Set outbound headers for next request */
    void setOutboundHeaders(Headers headers);
    
    /** Set outbound headers from objects */
    void setOutboundHeaders(Object... headers);
    
    /** Set outbound headers from list */
    void setOutboundHeaders(List<Header> headers);
    
    /** Get inbound headers from last response */
    Headers getInboundHeaders();
    
    /** Get request context as property set */
    PropertySet getRequestContext();
    
    /** Get response context as property set */
    PropertySet getResponseContext();
}

/**
 * Feature for enabling streaming attachment processing
 */
@WebServiceFeature.ID("http://java.sun.com/xml/ns/jaxws/")
public final class StreamingAttachmentFeature extends WebServiceFeature {
    /** Default constructor with system temp directory */
    public StreamingAttachmentFeature();
    
    /** Constructor with custom directory and settings */
    public StreamingAttachmentFeature(String dir, boolean parseEagerly, long memoryThreshold);
    
    /** Get directory for temporary files */
    public String getDir();
    
    /** Check if attachments are parsed eagerly */
    public boolean isParseEagerly();
    
    /** Get memory threshold for streaming */
    public long getMemoryThreshold();
    
    /** Get feature ID */
    public String getID();
}

/**
 * Streaming data handler for efficient attachment processing
 */
public final class StreamingDataHandler extends DataHandler {
    /** Create streaming data handler */
    public StreamingDataHandler(Object obj, String type);
    
    /** Create from URL */
    public StreamingDataHandler(URL url);
    
    /** Get content as streaming source */
    public StreamingDataSource getDataSource();
    
    /** Check if content is buffered in memory */
    public boolean isBuffered();
    
    /** Move content to file system */
    public void moveTo(File file) throws IOException;
    
    /** Close and clean up temporary resources */
    public void close() throws IOException;
}

/**
 * Feature for enabling schema validation of SOAP messages
 */
@WebServiceFeature.ID("http://java.sun.com/xml/ns/jaxws/schemaValidation")
public final class SchemaValidationFeature extends WebServiceFeature {
    /** Default constructor enabling validation */
    public SchemaValidationFeature();
    
    /** Constructor with enable/disable flag */
    public SchemaValidationFeature(boolean enabled);
    
    /** Constructor with custom error handler */
    public SchemaValidationFeature(Class<? extends ValidationErrorHandler> errorHandler);
    
    /** Get error handler class */
    public Class<? extends ValidationErrorHandler> getErrorHandler();
    
    /** Get feature ID */
    public String getID();
}

/**
 * Schema validation annotation for per-service configuration
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@WebServiceFeatureAnnotation(id = SchemaValidationFeature.ID, bean = SchemaValidationFeature.class)
public @interface SchemaValidation {
    /** Enable or disable validation */
    boolean enabled() default true;
    
    /** Custom error handler class */
    Class<? extends ValidationErrorHandler> handler() default ValidationErrorHandler.class;
}

/**
 * Custom validation error handler interface
 */
public abstract class ValidationErrorHandler implements ErrorHandler {
    /** Handle validation warning */
    public abstract void warning(SAXParseException exception) throws SAXException;
    
    /** Handle validation error */
    public abstract void error(SAXParseException exception) throws SAXException;
    
    /** Handle fatal validation error */
    public abstract void fatalError(SAXParseException exception) throws SAXException;
}

/**
 * Annotation for enabling stateful web service behavior
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Stateful {
    /** Timeout for stateful instances in milliseconds */
    long timeout() default 600000; // 10 minutes default
    
    /** Maximum number of stateful instances */
    int maxInstances() default 100;
    
    /** Cleanup policy for expired instances */
    CleanupPolicy cleanupPolicy() default CleanupPolicy.ON_TIMEOUT;
    
    /** Cleanup policy enumeration */
    enum CleanupPolicy {
        ON_TIMEOUT,
        ON_MAX_INSTANCES,
        MANUAL
    }
}

/**
 * Stateful web service context for managing instance state
 */
public final class StatefulWebServiceContext {
    /** Get current stateful instance ID */
    public static String getInstanceId(WebServiceContext context);
    
    /** Invalidate current stateful instance */
    public static void invalidate(WebServiceContext context);
    
    /** Get instance timeout */
    public static long getInstanceTimeout(WebServiceContext context);
    
    /** Set instance timeout */
    public static void setInstanceTimeout(WebServiceContext context, long timeout);
}

/**
 * Feature for Member Submission WS-Addressing support
 */
@WebServiceFeature.ID("http://schemas.xmlsoap.org/ws/2004/08/addressing/")
public final class MemberSubmissionAddressingFeature extends WebServiceFeature {
    /** Default constructor enabling MS addressing */
    public MemberSubmissionAddressingFeature();
    
    /** Constructor with enable/disable flag */
    public MemberSubmissionAddressingFeature(boolean enabled);
    
    /** Constructor with validation flag */
    public MemberSubmissionAddressingFeature(boolean enabled, boolean required);
    
    /** Check if addressing is required */
    public boolean isRequired();
    
    /** Get feature ID */
    public String getID();
}

/**
 * Member Submission addressing annotation
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@WebServiceFeatureAnnotation(id = MemberSubmissionAddressingFeature.ID, 
                           bean = MemberSubmissionAddressingFeature.class)
public @interface MemberSubmissionAddressing {
    /** Enable or disable addressing */
    boolean enabled() default true;
    
    /** Require addressing headers */
    boolean required() default false;
}

/**
 * Member Submission endpoint reference implementation
 */
public final class MemberSubmissionEndpointReference extends EndpointReference {
    /** Create MS endpoint reference from Source */
    public MemberSubmissionEndpointReference(Source eprInfoset);
    
    /** Get endpoint reference address */
    public String getAddress();
    
    /** Get reference parameters */
    public List<Element> getReferenceParameters();
    
    /** Get reference properties */
    public List<Element> getReferenceProperties();
    
    /** Get port type */
    public QName getPortType();
    
    /** Get service name */
    public QName getServiceName();
}

/**
 * Feature for specifying JAXB context usage
 */
@WebServiceFeature.ID("http://java.sun.com/xml/ns/jaxws/jaxbcontext/")
public final class UsesJAXBContextFeature extends WebServiceFeature {
    /** Constructor with JAXB context */
    public UsesJAXBContextFeature(JAXBContext jaxbContext);
    
    /** Get JAXB context */
    public JAXBContext getJAXBContext();
    
    /** Get feature ID */
    public String getID();
}

/**
 * Annotation for specifying JAXB context
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@WebServiceFeatureAnnotation(id = UsesJAXBContextFeature.ID, bean = UsesJAXBContextFeature.class)
public @interface UsesJAXBContext {
    /** JAXB context factory method */
    String value();
}

/**
 * Feature for customizing binding type
 */
public final class BindingTypeFeature extends WebServiceFeature {
    /** Constructor with binding ID */
    public BindingTypeFeature(String bindingId);
    
    /** Get binding ID */
    public String getBindingId();
    
    /** Get feature ID */
    public String getID();
}

/**
 * Feature for customizing serialization behavior
 */
public final class SerializationFeature extends WebServiceFeature {
    /** Constructor with encoding */
    public SerializationFeature(String encoding);
    
    /** Get character encoding */
    public String getEncoding();
    
    /** Get feature ID */
    public String getID();
}

/**
 * HTTP session scope annotation for servlet environments
 */
package com.sun.xml.ws.developer.servlet;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface HttpSessionScope {
    /** Session timeout in minutes */
    int timeout() default 30;
    
    /** Create session if none exists */
    boolean create() default true;
}

/**
 * HTTP session context for accessing servlet session
 */
public final class HttpSessionContext {
    /** Get HTTP session from web service context */
    public static HttpSession getSession(WebServiceContext context);
    
    /** Get HTTP session with create flag */
    public static HttpSession getSession(WebServiceContext context, boolean create);
    
    /** Get servlet request */
    public static HttpServletRequest getRequest(WebServiceContext context);
    
    /** Get servlet response */
    public static HttpServletResponse getResponse(WebServiceContext context);
}

import com.sun.xml.ws.developer.*;
import com.sun.xml.ws.developer.servlet.*;

// Streaming attachment configuration
@WebService
@StreamingAttachment(dir = "/tmp/attachments", threshold = 4096, parseEagerly = true)
public class FileUploadService {
    @WebMethod
    public String uploadFile(@WebParam(name = "file") DataHandler file) throws IOException {
        // Handle large file with streaming
        StreamingDataHandler streamingHandler = (StreamingDataHandler) file;
        
        if (!streamingHandler.isBuffered()) {
            // File is being streamed, move to permanent location
            File destination = new File("/uploads/" + UUID.randomUUID() + ".dat");
            streamingHandler.moveTo(destination);
            return "File uploaded: " + destination.getName();
        }
        
        return "File buffered in memory";
    }
}

// Schema validation configuration
@WebService
@SchemaValidation(enabled = true, handler = CustomValidationErrorHandler.class)
public class ValidatingService {
    @WebMethod
    public Response processData(@WebParam(name = "request") Request request) {
        // Request is automatically validated against schema
        return new Response();
    }
}

public class CustomValidationErrorHandler extends ValidationErrorHandler {
    public void error(SAXParseException exception) throws SAXException {
        // Log validation error
        logger.error("Schema validation error: " + exception.getMessage());
        throw exception; // Fail the request
    }
    
    public void warning(SAXParseException exception) throws SAXException {
        // Log warning but continue
        logger.warn("Schema validation warning: " + exception.getMessage());
    }
    
    public void fatalError(SAXParseException exception) throws SAXException {
        logger.fatal("Fatal schema validation error: " + exception.getMessage());
        throw exception;
    }
}

// Stateful web service
@WebService
@Stateful(timeout = 300000, maxInstances = 50) // 5 minute timeout, max 50 instances
public class StatefulCalculator {
    private double accumulator = 0.0;
    
    @WebMethod
    public double add(@WebParam(name = "value") double value, @Resource WebServiceContext context) {
        accumulator += value;
        
        // Extend session timeout
        StatefulWebServiceContext.setInstanceTimeout(context, 600000); // 10 minutes
        
        return accumulator;
    }
    
    @WebMethod  
    public void clear(@Resource WebServiceContext context) {
        accumulator = 0.0;
        // Optionally invalidate session
        // StatefulWebServiceContext.invalidate(context);
    }
}

// Client-side advanced configuration
MyService service = new MyService();
MyServiceInterface port = service.getMyServicePort(
    new StreamingAttachmentFeature("/tmp", false, 8192),
    new SchemaValidationFeature(true),
    new MemberSubmissionAddressingFeature(true, true)
);

WSBindingProvider wsBP = (WSBindingProvider) port;

// Configure request properties
Map<String, Object> requestContext = wsBP.getRequestContext();
requestContext.put(JAXWSProperties.CONNECT_TIMEOUT, 30000);
requestContext.put(JAXWSProperties.REQUEST_TIMEOUT, 60000);
requestContext.put(JAXWSProperties.CONTENT_NEGOTIATION_PROPERTY, ContentNegotiation.optimistic);

// Custom JAXB context usage
@WebService
@UsesJAXBContext("createCustomJAXBContext")
public class CustomJAXBService {
    @WebMethod
    public CustomResponse processCustomData(@WebParam(name = "data") CustomData data) {
        return new CustomResponse();
    }
    
    public static JAXBContext createCustomJAXBContext() throws JAXBException {
        return JAXBContext.newInstance(CustomData.class, CustomResponse.class);
    }
}

// Servlet-based stateful service
@WebService
@HttpSessionScope(timeout = 60, create = true)
public class ShoppingCartService {
    @WebMethod
    public void addItem(@WebParam(name = "item") Item item, @Resource WebServiceContext context) {
        HttpSession session = HttpSessionContext.getSession(context);
        
        @SuppressWarnings("unchecked")
        List<Item> cart = (List<Item>) session.getAttribute("cart");
        if (cart == null) {
            cart = new ArrayList<>();
            session.setAttribute("cart", cart);
        }
        
        cart.add(item);
    }
    
    @WebMethod
    public List<Item> getCart(@Resource WebServiceContext context) {
        HttpSession session = HttpSessionContext.getSession(context, false);
        if (session != null) {
            @SuppressWarnings("unchecked")
            List<Item> cart = (List<Item>) session.getAttribute("cart");
            return cart != null ? cart : new ArrayList<>();
        }
        return new ArrayList<>();
    }
}

// Advanced client configuration with SSL
BindingProvider bp = (BindingProvider) port;
Map<String, Object> requestContext = bp.getRequestContext();

// SSL configuration
requestContext.put(JAXWSProperties.SSL_SOCKET_FACTORY, createCustomSSLSocketFactory());
requestContext.put(JAXWSProperties.HOSTNAME_VERIFIER, createCustomHostnameVerifier());

// Custom headers
WSBindingProvider wsBP = (WSBindingProvider) port;
Header authHeader = Headers.create(new QName("http://example.com", "Authentication"), "Bearer token123");
wsBP.setOutboundHeaders(authHeader);