关键字transient

男娘i 2024-05-01 16:01 74阅读 0赞

**定义：**Java语言的关键字，变量修饰符，如果用**transient**声明一个实例变量，当对象存储时，它的值不需要维持。换句话来说就是，用**transient**关键字标记的成员变量不参与序列化过程。

**作用：**Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。

**编码试验加以证明：**

1.自定义类（为了方便，我直接在main方法所在类中添加的一个静态**[属性类，或者叫成员类][Link 1]**）

2.写一个测试方法

> public static void testTransient()\{  
> String name1="常规属性",name2="transient修饰的属性";  
> TransientTest test = new TransientTest(name1, name2);  
> System.out.println("序列化前："+test.toString());  
> ObjectOutputStream outStream;  
> ObjectInputStream inStream;  
> String filePath = "D:/test/object/TransientTest.obj";  
> try \{  
> outStream = new ObjectOutputStream(new FileOutputStream(filePath));  
> outStream.writeObject(test);  
>   
> inStream = new ObjectInputStream(new FileInputStream(filePath));  
> TransientTest readObject = (TransientTest)inStream.readObject();  
> System.out.println("序列化后："+readObject.toString());  
> \} catch (IOException e) \{  
> // TODO Auto-generated catch block  
> e.printStackTrace();  
> \} catch (ClassNotFoundException e) \{  
> // TODO Auto-generated catch block  
> e.printStackTrace();  
> \}  
> \}  
>

3.在main方法中执行，然后可以看到得到的结果为

![2019112815311431.png][]

印证了上面所讲的“用transient关键字标记的成员变量不参与序列化过程”。

用二进制查看器打开这个文件也可以看到，数据中只有name1，没有name2。

在查看JDK源码的时候会发现很多地方都会加上**transient**关键字来修饰一些属性，那究竟是出于什么考虑才这么做呢？

**我觉得，应该是为了节约磁盘空间，避免造成不必要的浪费吧。**

延伸：至于这里为什么有个ArrayList，因为这个类中也有一个**transient**修饰的变量，是用来存储list的元素内容的

![20191128153448941.png][]

翻译出来就是：

/ \* \*

\*存储ArrayList元素的数组缓冲区。

\* ArrayList的容量是这个数组缓冲区的长度。任何

\*带有elementData的空ArrayList == DEFAULTCAPACITY\_EMPTY\_ELEMENTDATA = \{\}

\*当添加第一个元素时，将被扩展到DEFAULT\_CAPACITY = 10。

\* /

细心地小伙伴应该也有看出来，上面的部分，list的内容为什么进过序列化反序列化，依然还在

**原因：**这个缓冲区的容量实际上并不是ArrayList的容量，因为其实际上会预留一些空间，当空间不足时还会扩容，为减少浪费，因此在序列化时不会按照默认算法将这个成员变量写入磁盘。而是写了个writeObject方法，序列化时会调用这个方法将其持久化，在反序列化是，调用readObject，将其恢复出来。

>     /**
>      * Save the state of the <tt>ArrayList</tt> instance to a stream (that
>      * is, serialize it).
>      *
>      * @serialData The length of the array backing the <tt>ArrayList</tt>
>      *             instance is emitted (int), followed by all of its elements
>      *             (each an <tt>Object</tt>) in the proper order.
>      */
>     private void writeObject(java.io.ObjectOutputStream s)
>         throws java.io.IOException{
>         // Write out element count, and any hidden stuff
>         int expectedModCount = modCount;
>         s.defaultWriteObject();
>     
>         // Write out size as capacity for behavioural compatibility with clone()
>         s.writeInt(size);
>     
>         // Write out all elements in the proper order.
>         for (int i=0; i<size; i++) {
>             s.writeObject(elementData[i]);
>         }
>     
>         if (modCount != expectedModCount) {
>             throw new ConcurrentModificationException();
>         }
>     }

>     /**
>      * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
>      * deserialize it).
>      */
>     private void readObject(java.io.ObjectInputStream s)
>         throws java.io.IOException, ClassNotFoundException {
>         elementData = EMPTY_ELEMENTDATA;
>     
>         // Read in size, and any hidden stuff
>         s.defaultReadObject();
>     
>         // Read in capacity
>         s.readInt(); // ignored
>     
>         if (size > 0) {
>             // be like clone(), allocate array based upon size not capacity
>             int capacity = calculateCapacity(elementData, size);
>             SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
>             ensureCapacityInternal(size);
>     
>             Object[] a = elementData;
>             // Read in all elements in the proper order.
>             for (int i=0; i<size; i++) {
>                 a[i] = s.readObject();
>             }
>         }
>     }

补充：java.io.ObjectInputStream的defaultReadObject（）方法：就是默认情况，咱们最开始那种现象，即没有transient修饰的时候，可以序列化反序列化，有transient修饰时，就不可以

>     /**
>      * Read the non-static and non-transient fields of the current class from
>      * this stream.  This may only be called from the readObject method of the
>      * class being deserialized. It will throw the NotActiveException if it is
>      * called otherwise.
>      *
>      * @throws  ClassNotFoundException if the class of a serialized object
>      *          could not be found.
>      * @throws  IOException if an I/O error occurs.
>      * @throws  NotActiveException if the stream is not currently reading
>      *          objects.
>      */
>     public void defaultReadObject()
>         throws IOException, ClassNotFoundException
>     {
>         SerialCallbackContext ctx = curContext;
>         if (ctx == null) {
>             throw new NotActiveException("not in call to readObject");
>         }
>         Object curObj = ctx.getObj();
>         ObjectStreamClass curDesc = ctx.getDesc();
>         bin.setBlockDataMode(false);
>         defaultReadFields(curObj, curDesc);
>         bin.setBlockDataMode(true);
>         if (!curDesc.hasWriteObjectData()) {
>             /*
>              * Fix for 4360508: since stream does not contain terminating
>              * TC_ENDBLOCKDATA tag, set flag so that reading code elsewhere
>              * knows to simulate end-of-custom-data behavior.
>              */
>             defaultDataEnd = true;
>         }
>         ClassNotFoundException ex = handles.lookupException(passHandle);
>         if (ex != null) {
>             throw ex;
>         }
>     }

参考ArrayList，在上面的TransientTest中添加2个方法，见代码：

>     public static class TransientTest implements Serializable
>     {
>        private static final long serialVersionUID = 233858934995755239L;
>        private String name1;
>        private transient String name2;
>        private ArrayList<String> list = new ArrayList<String>();
>     
>        public TransientTest(String name1, String name2)
>        {
>           this.name1 = name1;
>           this.name2 = name2;
>           list.add("hahhha");
>        }
>     
>        public String toString()
>        {
>           return String.format("TransientTest.toString(): name1=%s,name2=%s,list=%s", name1, name2, list);
>        }
>     
>        private void writeObject(java.io.ObjectOutputStream s)
>           throws java.io.IOException
>        {
>           s.defaultWriteObject();
>           s.writeObject(name2);
>        }
>     
>        private void readObject(java.io.ObjectInputStream s)
>           throws java.io.IOException, ClassNotFoundException
>        {
>           s.defaultReadObject();
>           name2 = String.valueOf(s.readObject());
>        }
>     }

然后在main方法中执行testTransient()，此时得到的结果是：

![20191128154256547.png][]

[Link 1]: https://blog.csdn.net/u010188178/article/details/83073085
[2019112815311431.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/01/52bf0c4f3d364d1dbbbe5d5d3c8bc7fe.png
[20191128153448941.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/01/335fcabe574140faa253632f8e56571d.png
[20191128154256547.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/01/15577591f15a444d8405022dcf8cc212.png