      // Parser SAX
      import javax.xml.parsers.SAXParserFactory;
      import javax.xml.parsers.SAXParser;
      SAXParserFactory spf = SAXParserFactory.newInstance();
      SAXParser sp = spf.newSAXParser();

      // StAX XMLStreamReader
      import javax.xml.stream.XMLInputFactory;
      import javax.xml.stream.XMLStreamReader;
      XMLInputFactory xif = XMLInputFactory.newInstance();
      XMLStreamReader reader = xif.createXMLStreamReader (inputStream);

      // Parser DOM
      import javax.xml.parsers.DocumentBuilderFactory;
      import javax.xml.parsers.DocumentBuilder;
      DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
      DocumentBuilder db = dbf.newDocumentBuilder();
--------------------------------------------------------------------------------------------------------------------------------------
  // JAXB Unmarshaller
  import javax.xml.bind.JAXBContext;
  import javax.xml.bind.Unmarshaller;
  JAXBContext jc = JAXBContext.newInstance("mypackage");
  Unmarshaller u = jc.createUnmarshaller();
--------------------------------------------------------------------------------------------------------------------------------------
   // Tworzenie instancji obiektu SchemaFactory
   import javax.xml.validation.SchemaFactory;
   import javax.xml.validation.Schema;
   import javax.xml.transform.stream.StreamSource;
   import javax.xml.validation.Validator;
   import javax.xml.transform.sax.SAXResult;
   SchemaFactory sf =
     SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

   StreamSource ss1 = new StreamSource("schema1.xsd");
   StreamSource ss2 = new StreamSource("schema2.xsd");

   // Kompilowanie schematw
   Schema schemas = sf.newSchema (new Source[] {ss1, ss2});

   // Tworzenie weryfikatora
   Validator validator = schemas.newValidator();

   // Konfigurowanie weryfikatora
   validator.setErrorHandler (errorHandler);

   // Tworzenie klasy SAXSource
   SAXSource saxSource = new SAXSource (inputSource);

   //Weryfikacja okrelonego rda wejciowego oraz wysanie poszerzonych
   //rezultatw weryfikacji do programu obsugi.
   validator.validate (saxSource, new SAXResult(contentHandler));
--------------------------------------------------------------------------------------------------------------------------------------
public class Processor {
      public void parse() {
            // Definiuje parser do stosowania z danym programem rozwizywania encji
            SAXParser parser =
                SAXParserFactory.newInstace().newSAXParser();
            XMLReader reader = parser.getXMLReader();

            // Definiuje odpowiednio reader
            reader.setContentHandler (myHandler);
            reader.setEntityResolver (new CustomEntityResolver());
            reader.parse (...);
      }
}

// Definiuje niestandardowy program rozwizywania encji
import org.xml.sax.EntityResolver;
import javax.xml.parsers.SAXParser;
import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;
import org.apache.xml.resolver.tools.CatalogResolver;

public class CustomEntityResolver implements EntityResolver {
      // pami podrczna do przechowywania encji
      private ConcurrentHashMap<String, InputSource> entityCache =
          new ConcurrentHashMap<String, InputSource>();
      CatalogResolver cResolver = new CatalogResolver();
      public InputSource resolveEntity (String publicId,
      String systemId) throws SAXException, IOException {
      // Dla uproszczenia ignorowanie sprawdzania publicId
      if (systemId != null) {
            InputSource is = entityCache.get(systemId);
            if ( is != null) {
                  // zwraca wersj z pamici podrcznej
                  return is;
            }
            else {
                  // Stosuje katalog do rozwizywania
                  is = cResolver.resolveEntity (publicId, systemId);
                  entityCache.put (systemId, is);
                  return is;
           }
      }

      // Umoliwia rozwizanie za pomoc domylnego programu do rozwizywania encji.
      return null;
      }
}
--------------------------------------------------------------------------------------------------------------------------------------
      <?xml version="1.0" encoding="UTF-8"?>
      <catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
            <public publicId="-//Sun Microsystems, Inc.//DTD Enterprise 
JavaBeans 2.0//EN" uri="dtds/ejb-jar_2_0.dtd"/>
            <system systemId="http://java.sun.com/dtd/ejb-jar_2_0.dtd"
 uri="dtds/ejb-jar_2_0.dtd/>
      </catalog>

--------------------------------------------------------------------------------------------------------------------------------------
// Wykorzystuje interfejsy API load and save
import org.w3c.dom.DOMConfiguration;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.bootstrap.DOMImplementationRegistry;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSParser;
import org.w3c.dom.ls.LSParserFilter;
import org.w3c.dom.traversal.NodeFilter;

public class PartialDOM {
      public void processPartial (String docLocation) {
            System.setProperty (DOMImplementationRegistry.PROPERTY,
  "com.sun.org.apache.xerces.internal.dom.DOMImplementationSourceImpl");
            try {
                  DOMImplementationRegistry registry =
                      DOMImplementationRegistry.newInstance();
                  DOMImplementation domImpl =
                      registry.getDOMImplementation("LS 3.0");
                  DOMImplementationLS implLS =
                      (DOMImplementationLS)domImpl;
                  LSParser parser =
                  implLS.createLSParser(
                      DOMImplementationLS.MODE_SYNCHRONOUS,
                      "http://www.w3.org/2001/XMLSchema");
                  // Konfiguruje parser, jeli jest to wymagane
                  DOMConfiguration config=parser.getDomConfig();
                  // Definiuje filtr
                  parser.setFilter(new InputFilter());
                  Document document = parser.parseURI("invoice.xml");
            }
            catch (ClassCastException ex) {
                  ex.printStackTrace();
            }
            catch (InstantiationException ex) {
                  ex.printStackTrace();
            }
            catch (IllegalAccessException ex) {
                  ex.printStackTrace();
            }
            catch (ClassNotFoundException ex) {
                  ex.printStackTrace();
            }
      }
      private static class InputFilter implements LSParserFilter {
            private boolean skip = true;
            public InputFilter () {}
            public short acceptNode(Node node) {
                  return NodeFilter.FILTER_ACCEPT;
            }

            public int getWhatToShow() {
                  return NodeFilter.SHOW_ELEMENT;
            }

            public short startElement(Element element) {
                  if (element.getTagName().equals("Summary") || !skip) {
                        System.out.println ("accepted element - " +
                                            element.getTagName());
                        skip = false;
                        return NodeFilter.FILTER_ACCEPT;
                  }
                  else
                        return NodeFilter.FILTER_SKIP;
           }
           public short EndElement (Element element) {
                 if (element.getTagName().equals("Summary")) {
                       skip = true;
                       return NodeFilter.FILTER_ACCEPT;
                 }
                 else
                       return NodeFilter.FILTER_SKIP;
                 }
           }
      }
}
--------------------------------------------------------------------------------------------------------------------------------------
import java.io.File;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.XMLReader;
import com.sun.xmltest.genjaxb20.ubl07.InvoiceSummaryType;

public class JAXBPartialUnmarshaller {

      public static void main(String[] args) throws Exception {
            JAXBContext jc =
               JAXBContext.newInstance("com.sun.xmltest.genjaxb20.ubl");
            Unmarshaller unmarshaller = jc.createUnmarshaller();
            // instaluje funkcj zwrotn na instancji Summary
            unmarshaller.setListener(new Unmarshaller.Listener() {
                  public void beforeUnmarshall(Object target,
                                              Object parent) {}
                  public void afterUnmarshall(Object target,
                                             Object parent) {
                        if(target instanceof InvoiceSummaryType) {
                              InvoiceSummaryType ist =
                                  (InvoiceSummaryType) target;
                              // Mamy ju obiekt  dostp do pola
                              System.out.println ("value = " +
                                  ist.getSubtotalAmount().
                                      getValue().floatValue());
                              // Jeli to wymagane, moe zatrzyma parsowanie,
                              // wyrzucajc wyjtek.
                       }
                  }
            });
            // tworzy nowy parser XML
            SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setNamespaceAware(true);
            XMLReader reader = factory.newSAXParser().getXMLReader();
            reader.setContentHandler
                (unmarshaller.getUnmarshallerHandler());
            for (String arg : args) {
            // parsuje wszystkie dokumenty okrelone w wierszu polece
            reader.parse(new File(arg).toURI().toString());
      }
}
--------------------------------------------------------------------------------------------------------------------------------------
<xsd:element name="person">
  <xsd:complexType>
    <xsd:sequence>
      <xsd:element name="name"
type="xsd:string"/>
      <xsd:any processContents="skip"
maxOccurs="unbounded" minOccurs="0" />
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
--------------------------------------------------------------------------------------------------------------------------------------
import org.w3c.dom.Element;
@XmlRootElement
class Person {
  public String getName();
  public void setName(String);

  @XmlAnyElement
  public List<Element> getAny();
}
--------------------------------------------------------------------------------------------------------------------------------------
<xsd:complexType name="Synthetic">
      <xsd:sequence>
             <xsd:element name="barray" type="xsd:base64Binary" />
      </xsd:sequence>
</xsd:complexType>
--------------------------------------------------------------------------------------------------------------------------------------
Content-Type: text/xml;charset="utf-8"
...
<?xml version="1.0" ?>
 <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
  <S:Body>
   <echoSynthetic
xmlns="http://www.sun.com/wstest/testcases/test/wsdltypes">
    <synthetic>
      <barray>AAAAAAAAAAAAAA==</barray>
    </synthetic>
   </echoSynthetic>
  </S:Body>
 </S:Envelope>
--------------------------------------------------------------------------------------------------------------------------------------
--uuid:e18b7da7-8169-44a0-9465-cd9d2694850d
Content-Id: <rootpart*e18b7da7-8169-44a0-9465-cd9d2694850d@example.jaxws.sun.
com
>
Content-Type: application/xop+xml;charset=utf-8;type="text/xml"
Content-Transfer-Encoding: binary
<?xml version="1.0" ?>
 <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
  <S:Body>
   <echoSynthetic xmlns="http://www.sun.com/wstest/testcases/test/wsdltypes">
    <synthetic>
     <barray>
      <Include xmlns="http://www.w3.org/2004/08/xop/include"
href="cid:3fa1ce96-
3f3e-4db9-bee8-c04e85b852a4@example.jaxws.sun.com"/>
     </barray>
    </synthetic>
   </echoSynthetic>
  </S:Body>
</S:Envelope>
--uuid:e18b7da7-8169-44a0-9465-cd9d2694850d
Content-Id: <3fa1ce96-3f3e-4db9-bee8-c04e85b852a4@example.jaxws.sun.com>
Content-Type: application/octet-stream
Content-Transfer-Encoding: binary
--------------------------------------------------------------------------------------------------------------------------------------
@javax.xml.ws.SOAP.MTOM @javax.xml.ws.WebService
  public class TestServiceImpl implements TestService {
     ...
 }
--------------------------------------------------------------------------------------------------------------------------------------
<webservices ..>     <port-component>
        ...
        <enable-mtom>true</enable-mtom>
     </port-component>
 </webservice>
--------------------------------------------------------------------------------------------------------------------------------------
import javax.xml.ws.soap.MTOMFeature;
  TestServicePortType test =
          new TestService().getTestServicePort ( new MTOMFeature());
--------------------------------------------------------------------------------------------------------------------------------------
TestServicePortType proxy = new TestService().getTestServicePort();
java.util.Map<String, Object> requestContext = ((BindingProvider)proxy).
getRequestContext();
requestContext.put (
com.sun.xml.ws.developer.JAXWSProperties.MTOM_THRESHOLD_VALUE, 6000);
--------------------------------------------------------------------------------------------------------------------------------------
import javax.xml.ws.soap.MTOMFeature;
import com.sun.xml.ws.developer.StreamingAttachmentFeature;
import com.sun.xml.ws.developer.JAXWSProperties;

public EchoDocPortType initProxy() {
      MTOMFeature feature = new MTOMFeature();
      // Konfiguruje, e caa wiadomo MIME jest parsowana gorliwie,
      // Zaczniki poniej 4MB s przechowywane w pamici
      StreamingAttachmentFeature stf =
          new StreamingAttachmentFeature(null, true, 4000000L);
      EchoDocPortType proxy =
          new EchoDocService().getEchoDocPort(feature, stf);
      java.util.Map<String, Object> ctxt =
          ((BindingProvider)proxy).getRequestContext();

      // Wczenie trybu HTTP chunking, w pozostaych przypadkach buforuje HttpURLConnection
      ctxt.put(JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 8192);
      return proxy;
}
--------------------------------------------------------------------------------------------------------------------------------------
import com.sun.xml.ws.developer.StreamingDataHandler;

public void echoDoc (EchoOctetDocAttachIn ecd) {
      DataHandler dh = ecd.getDoc();
      try {
             java.io.InputStream is;
             if (dh instanceof StreamingDataHandler) {
                   is = ((StreamingDataHandler)dh).readOnce();
             }
             else {
                   is = dh.getInputStream();
             }

             // Przetwarza dane wykorzystywane przez InputStream
             // Zamyka strumie oraz program obsugi danych.
             is.close();
             dh.close();
      }
      catch (Exception e) {
             e.printStackTrace();
      }
}
--------------------------------------------------------------------------------------------------------------------------------------
<xsd:element name="echoDocAttachIn">
  <xsd:complexType>
    <xsd:sequence> <xsd:element
         name="doc"
         type="xsd:base64Binary"
         xmime:expectedContentTypes="t
ext/xml"/>
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
--------------------------------------------------------------------------------------------------------------------------------------
//<xsd:element name="echoDocAttachIn">
  <xsd:complexType>
    <xsd:sequence> <xsd:element
         name="doc"
         type="xsd:base64Binary"
         xmime:expectedContentTypes="a
pplication/octet-stream"/>
    </xsd:sequence>
  </xsd:complexType>
</xsd:element>
--------------------------------------------------------------------------------------------------------------------------------------
public String echoDocAttach
(EchoDocAttachIn ecd) {
   Source source = ecd.getDoc();
   try {
      XMLInputFactory sFactory =
XMLInputFactory.newInstance();
      XMLStreamReader reader =
sFactory.createXMLStreamReader
(source);
    }
     catch (Exception e) {
         ...
    }
}
--------------------------------------------------------------------------------------------------------------------------------------
public String echoDocAttach
(EchoDocAttachIn ecd) {
   DataHandler dh = ecd.getDoc();
   try {
      XMLInputFactory sFactory =
XMLInputFactory.newInstance();
      XMLStreamReader reader =
sFactory.createXMLStreamReader (dh.
getInputStream());
    }
     catch (Exception e) {
         ...
    }
}
--------------------------------------------------------------------------------------------------------------------------------------
import javax.xml.ws.Provider;
import javax.xml.transform.Source;
import javax.xml.ws.Service;
import javax.xml.ws.ServiceMode;
import javax.xml.ws.WebServiceProvider;
@WebServiceProvider
@ServiceMode(value=Service.Mode.PAYLOAD)
public class InvoiceProcessService implements Provider<Source> {
      //Buforuje fabryk, kiedy jest to waciwe
      private XMLInputFactory sFactory = XMLInputFactory.newInstance();
      public InvoiceProcessService() {}
      public Source invoke (Source request) {
            // Pozyskuje StAX Reader ze rda
            try {
                  XMLStreamReader reader =
                      staxFactory.createXMLStreamReader(request);
            }
            catch (XMLStreamException ex) {
                   return processError();
            }
            return processPayload (reader);
      }
}
--------------------------------------------------------------------------------------------------------------------------------------
import import com.sun.xml.ws.api.message.Message;
public class CustomMessageProvider implements Provider<Message> {
      ..
      public Message invoke(Message message) {..}
}
--------------------------------------------------------------------------------------------------------------------------------------
@WebServiceProvider()
@ServiceMode(value=Service.Mode.PAYLOAD)
@BindingType (value=HTTPBinding.HTTP_BINDING)
public class SourceProviderDocService implements Provider<Source> { .. }
--------------------------------------------------------------------------------------------------------------------------------------
Map<String, List<String> httpHeaders = new HashMap<String,
List<String>>();
httpHeaders.put("Accept-Encoding", Collections.singletonList("gzip"));
Map<String, Object> reqContext =
((bindingProvider)proxy).getRequestContext(); requestContext.
put(MessageContext.HTTP_REQUEST_HEADERS, httpHeaders);
--------------------------------------------------------------------------------------------------------------------------------------
Map<String, List<String> httpHeaders = new HashMap<String,
List<String>>();
httpHeaders.put("Content-Encoding", Collections.singletonList ("gzip"));
httpHeaders.put("Accept-Encoding", Collections.singletonList ("gzip"));
Map<String, Object> reqContext =
((bindingProvider)proxy).getRequestContext(); requestContext.
put(MessageContext.HTTP_REQUEST_HEADERS, httpHeaders);
--------------------------------------------------------------------------------------------------------------------------------------
<catalog xmlns="rn:oasis:names:tc:entity:xmlns:xml:catalog" prefix="system>
      <system systemId="http://javaperf.sun.com/wstest?wsdl"
uri="DocumentService.wsdl"/>
</catalog>


