org.xml.sax.ext

---

1. Checking for Lexical Handler Support

try {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    LexicalHandler handler = reader.getContentHandler();
    handler.startDTD(null, null, null);
} catch (SAXNotSupportedException e) {
    // Lexical handler not supported
}

2. Getting the Lexical Handler

XMLReader reader = XMLReaderFactory.createXMLReader();
LexicalHandler handler = reader.getContentHandler();

3. Implementing the Lexical Handler Interface

public class MyLexicalHandler implements LexicalHandler {
    public void startDTD(String name, String publicId, String systemId) { }
    public void endDTD() { }
    public void startEntity(String name) { }
    public void endEntity(String name) { }
    public void startCDATA() { }
    public void endCDATA() { }
    public void comment(char[] ch, int start, int length) { }
}

4. Setting the Lexical Handler

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setContentHandler(new MyLexicalHandler());

5. Generating a Lexical Event

LexicalHandler handler = new MyLexicalHandler();
handler.comment("This is a comment");

6. Using the Lexical Handler with a Parser

Parser parser = new SAXParserFactory().newSAXParser();
parser.parse("file.xml", new MyLexicalHandler());

7. Detecting Declarative Event

try {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    DeclHandler handler = reader.getDeclHandler();
    handler.elementDecl(null, null, null, null);
} catch (SAXNotSupportedException e) {
    // Declarative event handler not supported
}

8. Getting the Declarative Event Handler

XMLReader reader = XMLReaderFactory.createXMLReader();
DeclHandler handler = reader.getDeclHandler();

9. Implementing the DeclHandler Interface

public class MyDeclHandler implements DeclHandler {
    public void elementDecl(String name, String model) { }
    public void attributeDecl(String eName, String aName,
        String type, String mode, String value) { }
    public void internalEntityDecl(String name, String value) { }
    public void externalEntityDecl(String name, String publicId, String systemId) { }
}

10. Setting the DeclHandler

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setDeclHandler(new MyDeclHandler());

11. Generating a Declarative Event

DeclHandler handler = new MyDeclHandler();
handler.elementDecl("myElement", null);

12. Using the DeclHandler with a Parser

Parser parser = new SAXParserFactory().newSAXParser();
parser.parse("file.xml", new MyDeclHandler());

13. Locating the Error Handler

XMLReader reader = XMLReaderFactory.createXMLReader();
ErrorHandler handler = reader.getErrorHandler();

14. Setting the Error Handler

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setErrorHandler(new MyErrorHandler());

15. Processing Error

public class MyErrorHandler implements ErrorHandler {
    public void warning(SAXParseException exception) { }
    public void error(SAXParseException exception) { }
    public void fatalError(SAXParseException exception) { }
}

16. Using Error Handler

try {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    reader.parse("file.xml");
} catch (SAXException e) {
    ErrorHandler handler = e.getErrorHandler();
    handler.fatalError(e);
}

17. Entity Resolver Implementation

public class MyEntityResolver implements EntityResolver {
    public InputSource resolveEntity(String publicId, String systemId) { }
}

18. Setting Entity Resolver

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setEntityResolver(new MyEntityResolver());

19. Using EntityResolver

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.parse("file.xml"); // EntityResolver will be used to resolve entities

20. Customizing DTD Validation

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setDTDHandler(new MyDTDHandler());

21. Implementing CustomValidationHandler

public class MyDTDHandler implements DTDHandler {
    public void notationDecl(String name, String publicId, String systemId) { }
    public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName) { }
}

22. Customizing DTD Handler

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setDTDHandler(new MyDTDHandler());

23. Implementing DTDHandler

public class MyDTDHandler implements DTDHandler {
    public void notationDecl(String name, String publicId, String systemId) { }
    public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName) { }
}

24. Using Extended Attributes

ExtensionHandler handler = reader.getExtensionHandler();
handler.setFeature("http://xml.org/sax/features/use-attributes2", true);

25. Checking for Property Support

try {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    reader.setFeature("http://xml.org/sax/features/validation", true);
} catch (SAXNotRecognizedException e) {
    // Feature is not recognized
} catch (SAXNotSupportedException e) {
    // Property not supported
}

26. Checking for Feature Support

try {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    reader.getFeature("http://xml.org/sax/features/validation");
} catch (SAXNotRecognizedException e) {
    // Feature is not recognized
} catch (SAXNotSupportedException e) {
    // Property not supported
}

27. Custom Attributes Implementation

public class MyExtensionHandler implements ExtensionHandler {
    public Object getExtension(String uri) { }
}

28. Custom Attributes Registration

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setProperty("http://xml.org/sax/properties/ext-handler", new MyExtensionHandler());

29. Implementing a PropertyDeclHandler

public class MyPropertyDeclHandler implements PropertyDeclHandler {
    public void propertyDecl(String name, String value) { }
}

30. Setting a PropertyDeclHandler

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setPropertyDeclHandler(new MyPropertyDeclHandler());

31. Checking for PropertyDeclHandler

try {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    reader.getPropertyDeclHandler();
} catch (SAXNotSupportedException e) {
    // PropertyDeclHandler is not supported
}

32. Determining the Value of a Property

XMLReader reader = XMLReaderFactory.createXMLReader();
String value = reader.getProperty("http://xml.org/sax/properties/lexical-handler");

33. Setting a Property

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setProperty("http://xml.org/sax/properties/lexical-handler", new MyLexicalHandler());

34. Implementation of SAXException

public class MySAXException extends SAXException {
    public MySAXException(String message) {
        super(message);
    }
}

35. Throwing a Custom Exception

try {
    // Some code that could throw a SAXException
} catch (SAXException e) {
    if (e instanceof MySAXException) {
        // Handle the custom exception
    }
}

36. Generating a Customized SAXException

SAXParseException exception = new SAXParseException("My custom exception message", null, null, 1, 1);
throw exception;

37. Using the CharacterDataHandler

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setContentHandler(new MyCharacterDataHandler());

38. Implementing the CharacterDataHandler Interface

public class MyCharacterDataHandler implements ContentHandler {
    public void characters(char[] ch, int start, int length) { }
}

39. Using XMLReader

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setContentHandler(new MyContentHandler());

40. Implementing the ContentHandler Interface

public class MyContentHandler implements ContentHandler {
    public void startDocument() { }
    public void endDocument() { }
    public void startPrefixMapping(String prefix, String uri) { }
    public void endPrefixMapping(String prefix) { }
    public void startElement(String uri, String localName, String qName, Attributes atts) { }
    public void endElement(String uri, String localName, String qName) { }
    public void characters(char[] ch, int start, int length) { }
    public void ignorableWhitespace(char[] ch, int start, int length) { }
    public void processingInstruction(String target, String data) { }
    public void skippedEntity(String name) { }
}

41. Using XMLFilter

XMLReader reader = XMLReaderFactory.createXMLReader();
XMLFilter filter = new MyXMLFilter();
reader.setContentHandler(filter);
filter.setContentHandler(new MyContentHandler());

42. Implementing the XMLFilter Interface

public class MyXMLFilter implements XMLFilter {
    public XMLReader getParent() { }
    public void setParent(XMLReader parent) { }
    public ContentHandler getContentHandler() { }
    public void setContentHandler(ContentHandler handler) { }
    public EntityResolver getEntityResolver() { }
    public void setEntityResolver(EntityResolver resolver) { }
    public ErrorHandler getErrorHandler() { }
    public void setErrorHandler(ErrorHandler handler) { }
    public DTDHandler getDTDHandler() { }
    public void setDTDHandler(DTDHandler handler) { }
    public ContentHandler startDocument() { }
    public ContentHandler endDocument() { }
    public ContentHandler startPrefixMapping(String prefix, String uri) { }
    public ContentHandler endPrefixMapping(String prefix) { }
    public ContentHandler startElement(String uri, String localName, String qName, Attributes atts) { }
    public ContentHandler endElement(String uri, String localName, String qName) { }
    public ContentHandler characters(char[] ch, int start, int length) { }
    public ContentHandler ignorableWhitespace(char[] ch, int start, int length) { }
    public ContentHandler processingInstruction(String target, String data) { }
    public ContentHandler skippedEntity(String name) { }
}

43. Generating Synthetic SAX

XMLFilter filter = new MyXMLFilter();
filter.setParent(XMLReaderFactory.createXMLReader());

44. Using the DeclHandler2

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setDeclHandler(new MyDeclHandler2());

45. Implementing the DeclHandler2 Interface

public class MyDeclHandler2 implements DeclHandler2 {
    public void elementDecl(String name, String model) { }
    public void attributeDecl(String eName, String aName,
        String type, String mode, String value, boolean cdata) { }
    public void internalEntityDecl(String name, String value) { }
    public void externalEntityDecl(String name, String publicId, String systemId) { }
}

46. Using the DTDHandler2

XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setDTDHandler(new MyDTDHandler2());

47. Implementing DTDHandler2

public class MyDTDHandler2 implements DTDHandler2 {
    public void notationDecl(String name, String publicId, String systemId) { }
    public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName) { }
}

48. Implementing ErrorHandler2

public class MyErrorHandler2 implements ErrorHandler2 {
    public void warning(SAXParseException exception) { }
    public void error(SAXParseException exception) { }
    public void fatalError(SAXParseException exception) { }
    public void getLocalizedMessage(SAXParseException exception) { }
}

49. Implementing EntityResolver2

public class MyEntityResolver2 implements EntityResolver2 {
    public InputSource resolveEntity(String publicId, String systemId) { }
    public InputSource resolveEntity(String name, String baseURI, String systemId) { }
}

50. Implementing LexicalHandler2

public class MyLexicalHandler2 implements LexicalHandler2 {
    public void startDTD(String name, String publicId, String systemId) { }
    public void endDTD() { }
    public void startEntity(String name) { }
    public void endEntity(String name) { }
    public void startCDATA() { }
    public void endCDATA() { }
    public void comment(char[] ch, int start, int length) { }
    public void startDTD(String name, String publicId, String systemId, String baseURI) { }
    public void endDTD(String name) { }
    public void startEntity(String name, String baseURI) { }
    public void endEntity(String name, String baseURI) { }
}