java.beans.ExceptionListener#java.beans.XMLDecoder源码实例Demo

static void test(AbstractTest object) {
    ByteArrayOutputStream output = new ByteArrayOutputStream();

    XMLEncoder encoder = new XMLEncoder(output);
    encoder.setPersistenceDelegate(
            object.getClass(),
            new DefaultPersistenceDelegate(new String[] {"value"}));

    encoder.writeObject(object);
    encoder.close();

    System.out.print(output);

    ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());
    XMLDecoder decoder = new XMLDecoder(input);
    AbstractTest result = (AbstractTest) decoder.readObject();
    decoder.close();

    if (object.getValue() != result.getValue())
        throw new Error("Should be " + object);
}
 

@Override
protected void validate(XMLDecoder decoder) {
    Number[] numbers = getArray(Number.class, 2, decoder.readObject());
    if (!numbers[0].equals(Byte.valueOf("-111"))) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected byte value");
    }
    if (!numbers[1].equals(Long.valueOf("1111"))) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected long value");
    }

    Object[] objects = getArray(Object.class, 3, decoder.readObject());
    if (objects[0] != null) {
        throw new Error("unexpected first value");
    }
    if (!objects[1].equals("Hello, world!")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected string value");
    }
    if (objects[2] != null) {
        throw new Error("unexpected last value");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    Number[] numbers = getArray(Number.class, 2, decoder.readObject());
    if (!numbers[0].equals(Byte.valueOf("-111"))) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected byte value");
    }
    if (!numbers[1].equals(Long.valueOf("1111"))) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected long value");
    }

    Object[] objects = getArray(Object.class, 3, decoder.readObject());
    if (objects[0] != null) {
        throw new Error("unexpected first value");
    }
    if (!objects[1].equals("Hello, world!")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected string value");
    }
    if (objects[2] != null) {
        throw new Error("unexpected last value");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    JPanel panel = (JPanel) decoder.readObject();
    if (2 != panel.getComponents().length) {
        throw new Error("unexpected component count");
    }
    JButton button = (JButton) panel.getComponents()[0];
    if (!button.getText().equals("button")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected button text");
    }
    if (SwingConstants.CENTER != button.getVerticalAlignment()) {
        throw new Error("unexpected vertical alignment");
    }
    JLabel label = (JLabel) panel.getComponents()[1];
    if (!label.getText().equals("label")) { // NON-NLS: hardcoded in XML
        throw new Error("unexpected label text");
    }
    if (button != label.getLabelFor()) {
        throw new Error("unexpected component");
    }
}
 

/**
 * This is entry point to start testing.
 *
 * @param security  use {@code true} to start
 *                  second pass in secure context
 */
final void test(boolean security) {
    byte[] array = getFieldValue("XML").getBytes(); // NON-NLS: the field name
    ByteArrayInputStream input = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(input);
    decoder.setExceptionListener(this);
    validate(decoder);
    try {
        throw new Error("unexpected object" + decoder.readObject());
    } catch (ArrayIndexOutOfBoundsException exception) {
        // expected exception
    }
    decoder.close();
    if (security) {
        System.setSecurityManager(new SecurityManager());
        test(false);
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate(0L, decoder.readObject());
    validate((long) Byte.MAX_VALUE, decoder.readObject());
    validate((long) Byte.MIN_VALUE, decoder.readObject());
    validate((long) Short.MAX_VALUE, decoder.readObject());
    validate((long) Short.MIN_VALUE, decoder.readObject());
    validate((long) Integer.MAX_VALUE, decoder.readObject());
    validate((long) Integer.MIN_VALUE, decoder.readObject());
    validate(Long.MAX_VALUE, decoder.readObject());
    validate(Long.MIN_VALUE, decoder.readObject());
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate((short) 0, decoder.readObject());
    validate((short) Byte.MAX_VALUE, decoder.readObject());
    validate((short) Byte.MIN_VALUE, decoder.readObject());
    validate(Short.MAX_VALUE, decoder.readObject());
    validate(Short.MIN_VALUE, decoder.readObject());
}
 

public static void main(String[] args) throws Exception {
    StringBuilder sb = new StringBuilder(256);
    sb.append("file:");
    sb.append(System.getProperty("test.src", "."));
    sb.append(File.separatorChar);
    sb.append("test.jar");

    URL[] url = {new URL(sb.toString())};
    URLClassLoader cl = new URLClassLoader(url);

    Class type = cl.loadClass("test.Test");
    if (type == null) {
        throw new Error("could not find class test.Test");
    }


    InputStream stream = new ByteArrayInputStream(DATA.getBytes());

    ExceptionListener el = new ExceptionListener() {
        public void exceptionThrown(Exception exception) {
            throw new Error("unexpected exception", exception);
        }
    };

    XMLDecoder decoder = new XMLDecoder(stream, null, el, cl);
    Object object = decoder.readObject();
    decoder.close();

    if (!type.equals(object.getClass())) {
        throw new Error("unexpected " + object.getClass());
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    if (!Boolean.TRUE.equals(decoder.readObject())) {
        throw new Error("true expected");
    }
    if (!Boolean.FALSE.equals(decoder.readObject())) {
        throw new Error("false expected");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate(0.0f, decoder.readObject());
    validate(100.0f, decoder.readObject());
    validate(-1e15f, decoder.readObject());
    validate(100e-20f, decoder.readObject());
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate(PREFIX, decoder.readObject());
    validate(POSTFIX, decoder.readObject());
    validate(PREFIX + POSTFIX, decoder.readObject());
    validate(PREFIX + '\u0000' + POSTFIX, decoder.readObject());
}
 

@Override
protected void validate(XMLDecoder decoder) {
    this.exception = null;
    validate(decoder, A.class);
    validate(decoder, B.class);
    validate(decoder, C.class);
    validate(decoder, D.class);
    validate(decoder, E.class);
    if (this.exception == null) {
        throw new Error("NoSuchMethodException expected");
    }
}
 

private static void test(Locale locale, byte[] data) {
    Locale.setDefault(locale);
    System.out.println("locale = " + locale);

    XMLDecoder decoder = new XMLDecoder(new ByteArrayInputStream(data));
    System.out.println("object = " + decoder.readObject());
    decoder.close();
}
 

/**
 * Returns the owner of the owner document handler
 * as a value of <java> element.
 *
 * @return the owner of the owner document handler
 */
private Object getValue() {
    Object owner = getOwner().getOwner();
    if ((this.type == null) || isValid(owner)) {
        return owner;
    }
    if (owner instanceof XMLDecoder) {
        XMLDecoder decoder = (XMLDecoder) owner;
        owner = decoder.getOwner();
        if (isValid(owner)) {
            return owner;
        }
    }
    throw new IllegalStateException("Unexpected owner class: " + owner.getClass().getName());
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate(0, decoder.readObject());
    validate((int) Byte.MAX_VALUE, decoder.readObject());
    validate((int) Byte.MIN_VALUE, decoder.readObject());
    validate((int) Short.MAX_VALUE, decoder.readObject());
    validate((int) Short.MIN_VALUE, decoder.readObject());
    validate(Integer.MAX_VALUE, decoder.readObject());
    validate(Integer.MIN_VALUE, decoder.readObject());
}
 

@Override
protected void validate(XMLDecoder decoder) {
    decoder.setOwner(this);
    if (this != decoder.readObject()) {
        throw new Error("owner should be the same");
    }
    if (this.message == null) {
        throw new Error("owner's method is not called");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    this.exception = null;
    validate(decoder, A.class);
    validate(decoder, B.class);
    validate(decoder, C.class);
    validate(decoder, D.class);
    validate(decoder, E.class);
    if (this.exception == null) {
        throw new Error("NoSuchMethodException expected");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate(PREFIX, decoder.readObject());
    validate(POSTFIX, decoder.readObject());
    validate(PREFIX + POSTFIX, decoder.readObject());
    validate(PREFIX + '\u0000' + POSTFIX, decoder.readObject());
}
 

@Override
protected void validate(XMLDecoder decoder) {
    if (!decoder.readObject().equals(Character.valueOf('X'))) {
        throw new Error("unexpected character");
    }
    if (!decoder.readObject().equals(Character.valueOf((char) 0x20))) {
        throw new Error("unexpected character code");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    this.exception = null;
    validate(decoder, A.class);
    validate(decoder, B.class);
    validate(decoder, C.class);
    validate(decoder, D.class);
    validate(decoder, E.class);
    if (this.exception == null) {
        throw new Error("NoSuchMethodException expected");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    this.exception = null;
    validate(decoder, A.class);
    validate(decoder, B.class);
    validate(decoder, C.class);
    validate(decoder, D.class);
    validate(decoder, E.class);
    if (this.exception == null) {
        throw new Error("NoSuchMethodException expected");
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate(decoder.readObject());
    validate(decoder.readObject(), null);
    validate(decoder.readObject(), "single");
    validate(decoder.readObject(), "first", "second", "third");
}
 

public ReadOnlyURLMapper() {

        if (LASTPLATFORMS_FILE.exists()) {
            try {
                XMLDecoder decoder = new XMLDecoder(new FileInputStream(LASTPLATFORMS_FILE));
                String[] last = (String[]) decoder.readObject();
                if (last != null) {
                    reference.set(last);
                }
            } catch (Exception ex) {
            }
        }

    }
 

void loadSettings(File file) throws IOException, IntrospectionException, PropertyVetoException {
    if (file == null) {
        cameraSettings = null;
        projectorSettings = null;
        objectFinderSettings = null;
        markerDetectorSettings = null;
        alignerSettings = null;
        handMouseSettings = null;
        virtualBallSettings = null;
        realityAugmentorSettings = null;
        trackingSettings = null;

        trackingWorker = null;
    } else {
        XMLDecoder decoder = new XMLDecoder(new BufferedInputStream(new FileInputStream(file)));
        cameraSettings = (CameraDevice.Settings)decoder.readObject();
        projectorSettings = (ProjectorDevice.Settings)decoder.readObject();
        objectFinderSettings = (ObjectFinder.Settings)decoder.readObject();
        markerDetectorSettings = (MarkerDetector.Settings)decoder.readObject();
        alignerSettings = (GNImageAligner.Settings)decoder.readObject();
        handMouseSettings = (HandMouse.Settings)decoder.readObject();
        virtualBallSettings = (VirtualBall.Settings)decoder.readObject();
        realityAugmentorSettings = (RealityAugmentor.Settings)decoder.readObject();
        trackingSettings = (TrackingWorker.Settings)decoder.readObject();
        decoder.close();
    }

    settingsFile = file;
    if (settingsFile == null) {
        setTitle("ProCamTracker");
    } else {
        setTitle(settingsFile.getName() + " - ProCamTracker");
    }

    buildSettingsView();

    if (trackingWorker == null) {
        statusLabel.setText("Idling.");
    }
}
 

private <T> T copyObjectViaXmlEncoder(T o) {
  ByteArrayOutputStream bos = new ByteArrayOutputStream();
  XMLEncoder enc = new XMLEncoder(bos);
  enc.writeObject(o);
  enc.close();
  ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
  XMLDecoder dec = new XMLDecoder(bin);
  Object o2 = dec.readObject();
  dec.close();
  assertTrue("no reference identity", o2 != o);
  assertEquals("same class", o.getClass(), o2.getClass());
  return (T) o2;
}
 

/**
 * Legacy XML loader
 * Deserializes the Nukelog Map.
 */
@SuppressWarnings("unchecked")
private void loadXMLLRUMap(Map<String, NukeData> nukees) {
    // de-serializing the Hashtable.
    try (XMLDecoder xd = new XMLDecoder(new FileInputStream(
            _nukebeansPath + VirtualFileSystem.separator + "nukebeans.xml"))) {
        //switchClassLoaders();
        nukees.putAll((Map<String, NukeData>) xd.readObject());
        logger.debug("Loaded log from .xml, size: {}", nukees.size());
    } catch (FileNotFoundException e) {
        // nukelog does not exists yet.
    }
}
 

private Object readObject(byte[] array) {
    ByteArrayInputStream input = new ByteArrayInputStream(array);
    XMLDecoder decoder = new XMLDecoder(input);
    decoder.setExceptionListener(this);
    initialize(decoder);
    Object object = decoder.readObject();
    decoder.close();
    return object;
}
 

@Override
protected void validate(XMLDecoder decoder) {
    for (int i = 0; i < 3; i++) {
        if (decoder != decoder.readObject()) {
            throw new Error("decoder instance expected");
        }
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    for (int i = 0; i < 3; i++) {
        if (decoder != decoder.readObject()) {
            throw new Error("decoder instance expected");
        }
    }
}
 

@Override
protected void validate(XMLDecoder decoder) {
    validate(0.0f, decoder.readObject());
    validate(100.0f, decoder.readObject());
    validate(-1e15f, decoder.readObject());
    validate(100e-20f, decoder.readObject());
}