为了避免XMLEncoder的序列化，你如何在Javabean中将属性标记为瞬态？

Question

Using the "transient" keyword on a variable declaration or "@Transient" on the getter does not stop the XMLEncoder from serializing properties. The only way I've found to tell the XMLEncoder not to serialize specific properties is with code like:

BeanInfo info = Introspector.getBeanInfo(MyClass2.class);
PropertyDescriptor[] propertyDescriptors = info.getPropertyDescriptors();
for (int i = 0; i < propertyDescriptors.length; ++i) {
    PropertyDescriptor pd = propertyDescriptors[i];
    if (pd.getName().equals("props")) {
        pd.setValue("transient", Boolean.TRUE);
    }
}

Really??? Is there an easier way that doesn't require runtime code to loop through all the properties? Something like the transient modifier would rock!

Here's a JavaBean that will have all it's properties serialized by XMLEncoder, despite the use of "transient":

import java.io.Serializable;
import java.beans.XMLEncoder;

public class TestJavaBeanSerialization implements Serializable {
    public TestJavaBeanSerialization() {}
    private transient String myProp1 = null;
    private String myProp2 = null;
    @Transient public String getMyProp1() { return myProp1; }
    public void setMyProp1(String a) { myProp1 = a; }
    public String getMyProp2() { return myProp2; }
    public void setMyProp2(String a) { myProp2 = a; }

    public static void main( String[] args ) {
        TestJavaBeanSerialization myObj = new TestJavaBeanSerialization();
        myObj.setMyProp1("prop 1");
        myObj.setMyProp2("prop 2");
        XMLEncoder encoder = new XMLEncoder(System.out);
        encoder.writeObject(myObj);
        encoder.close();        
    }

}

Here's the output of running this program:

<?xml version="1.0" encoding="UTF-8"?> 
<java version="1.6.0_29" class="java.beans.XMLDecoder"> 
 <object class="TestJavaBeanSerialization"> 
  <void property="myProp1"> 
   <string>prop 1</string> 
  </void> 
  <void property="myProp2"> 
   <string>prop 2</string> 
  </void> 
 </object> 
</java> 

UPDATE

I still have not received a definitive answer to the original question. There's this article that people keep referencing, but it's not clear and no one's given a reference to an API or spec that clearly states the only way to mark a property as transient is to loop through all the properties and call "setValue".

Answer 1

You use the wrong @Transient

Should use java.beans.Transient for the annotation. javax.persistence.Transient is only respected in the context of database persistence, not BeanInfo serialization.

Answer 2

A workaround might be to use JAXB as your XML serializer which is bundled with Java 1.6. It supports an @XmlTransient annotation.

Answer 3

I had a similar problem and I was looking for an easier solution. The way I managed it is by breaking Java Beans conventions.

If you don't want to serialize a field, don't set getters setters for it. Instead of "get" and "set", use other prefixes like "retrieve" and "save". For example -

int x=0;
public int retrieveX() {
    return x;
}
public void saveX(int x) {
    this.x = x;
}

This did the trick for me and I'm sure will help others who don't specifically need Java Beans conventions in the code. Using this way makes the variable available throughout your application but at the same time hiding it from XMLEncoder serializer.

Hope it helps someone in future.

Answer 4

I was accustomed to use this known solution for several years in my own code but there is a much more simple one since Java 1.7: the java.beans.Transient annotation . Note that you can use it on the getters and the setters but not on the fields unlike javax.persistence.Transient (JPA).

import java.beans.Transient;
import java.beans.XMLEncoder;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.Arrays;

public class Test {

public static final void main(String[] args) throws Throwable {
    final Capsule caps = new Capsule();
    caps.setIdentifier("6545346");
    caps.setMe("Julien");
    caps.setSentences(new ArrayList<>(Arrays.asList(new String[]{"I don't like my job","I prefer sleeping"})));
    try (FileOutputStream fOut = new FileOutputStream(new File(System.getProperty("user.home"), "test.xml")); 
         BufferedOutputStream out = new BufferedOutputStream(fOut);
         XMLEncoder encoder = new XMLEncoder(out)) {
        encoder.writeObject(caps);
        encoder.flush();
    }
}

public static final class Capsule {

    private String identifier;

    private transient String me;

    private transient ArrayList<String> sentences;

    public Capsule() {
        super();
    }

    @Transient
    public ArrayList<String> getSentences() {
        return sentences;
    }

    @Transient
    public void setSentences(ArrayList<String> sentences) {
        this.sentences = sentences;
    }

    public String getIdentifier() {
        return identifier;
    }

    public void setIdentifier(String identifier) {
        this.identifier = identifier;
    }

    @Transient
    public String getMe() {
        return me;
    }

    @Transient
    public void setMe(String me) {
        this.me = me;
    }
}}

The result is:

<?xml version="1.0" encoding="UTF-8"?>
<java version="1.7.0_76" class="java.beans.XMLDecoder">
 <object class="Test$Capsule">
  <void property="identifier">
   <string>6545346</string>
  </void>
 </object>
</java>

Note the absence of the transient values. I couldn't skip the collections in 2009 but it seems to work now.

Answer 5

this is the only way that declare properties is transient.you can see the article. Url is http://www.oracle.com/technetwork/java/persistence4-140124.html?ssSourceSiteId=otncn#transient

Answer 6

myProp1字段添加静态，并在getMyProp1方法之前删除'@Transient'关键字，然后运行程序，结果是你想要的？