Class AcrossJVMSerializationFeature
- java.lang.Object
-
- org.powermock.api.mockito.repackaged.AcrossJVMSerializationFeature
-
- All Implemented Interfaces:
java.io.Serializable
@Incubating class AcrossJVMSerializationFeature extends java.lang.Object implements java.io.Serializable
This is responsible for serializing a mock, it is enabled if the mock is implementingSerializable
.The way it works is to enable serialization via the
enableSerializationAcrossJVM(MockCreationSettings)
, if the mock settings is set to be serializable it will add theAcrossJVMSerializationFeature.AcrossJVMMockitoMockSerializable
interface. This interface defines a theAcrossJVMSerializationFeature.AcrossJVMMockitoMockSerializable.writeReplace()
whose signature match the one that is looked by the standard Java serialization.Then in the
MethodInterceptorFilter
of mockito, if thewriteReplace
method is called, it will use the custom implementation of this classwriteReplace(Object)
. This method has a specific knowledge on how to serialize a mockito mock that is based on CGLIB.Only one instance per mock! See
TODO use a proper way to add the interface TODO offer a way to disable completely this behavior, or maybe enable this behavior only with a specific setting TODO check the class is mockable in the deserialization sideMethodInterceptorFilter
- Since:
- 1.10.0
- See Also:
CglibMockMaker
,MethodInterceptorFilter
-
-
Nested Class Summary
Nested Classes Modifier and Type Class Description static interface
AcrossJVMSerializationFeature.AcrossJVMMockitoMockSerializable
Simple interface that hold a correctwriteReplace
signature that can be seen by anObjectOutputStream
.static class
AcrossJVMSerializationFeature.AcrossJVMMockSerializationProxy
This is the serialization proxy that will encapsulate the real mock data as a byte array.static class
AcrossJVMSerializationFeature.MockitoMockObjectInputStream
Special Mockito awareObjectInputStream
that will resolve the Mockito proxy class.private static class
AcrossJVMSerializationFeature.MockitoMockObjectOutputStream
Special Mockito awareObjectOutputStream
.
-
Field Summary
Fields Modifier and Type Field Description private boolean
instanceLocalCurrentlySerializingFlag
private static java.lang.String
MOCKITO_PROXY_MARKER
private java.util.concurrent.locks.Lock
mutex
private static long
serialVersionUID
-
Constructor Summary
Constructors Constructor Description AcrossJVMSerializationFeature()
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description <T> void
enableSerializationAcrossJVM(org.mockito.mock.MockCreationSettings<T> settings)
Enable serialization serialization that will work across classloaders / and JVM.boolean
isWriteReplace(java.lang.reflect.Method method)
private boolean
mockIsCurrentlyBeingReplaced()
private void
mockReplacementCompleted()
private void
mockReplacementStarted()
java.lang.Object
writeReplace(java.lang.Object mockitoMock)
Custom implementation of thewriteReplace
method for serialization.
-
-
-
Field Detail
-
serialVersionUID
private static final long serialVersionUID
- See Also:
- Constant Field Values
-
MOCKITO_PROXY_MARKER
private static final java.lang.String MOCKITO_PROXY_MARKER
- See Also:
- Constant Field Values
-
instanceLocalCurrentlySerializingFlag
private boolean instanceLocalCurrentlySerializingFlag
-
mutex
private final java.util.concurrent.locks.Lock mutex
-
-
Method Detail
-
isWriteReplace
public boolean isWriteReplace(java.lang.reflect.Method method)
-
writeReplace
public java.lang.Object writeReplace(java.lang.Object mockitoMock) throws java.io.ObjectStreamException
Custom implementation of thewriteReplace
method for serialization. Here's how it's working and why :-
When first entering in this method, it's because some is serializing the mock, with some code like :
So,objectOutputStream.writeObject(mock);
ObjectOutputStream
will track thewriteReplace
method in the instance and execute it, which is wanted to replace the mock by another type that will encapsulate the actual mock. At this point, the code will return anAcrossJVMSerializationFeature.AcrossJVMMockSerializationProxy
. -
Now, in the constructor
AcrossJVMMockSerializationProxy(Object)
the mock is being serialized in a custom way (usingAcrossJVMSerializationFeature.MockitoMockObjectOutputStream
) to a byte array. So basically it means the code is performing double nested serialization of the passedmockitoMock
.However the
ObjectOutputStream
will still detect the customwriteReplace
and execute it. (For that matter disabling replacement viaObjectOutputStream.enableReplaceObject(boolean)
doesn't disable thewriteReplace
call, but just just toggle replacement in the written stream,writeReplace
is always called byObjectOutputStream
.)In order to avoid this recursion, obviously leading to a
StackOverflowError
, this method is using a flag that marks the mock as already being replaced, and then shouldn't replace itself again. This flag is local to this class, which means the flag of this class unfortunately needs to be protected against concurrent access, hence the reentrant lock.
- Parameters:
mockitoMock
- The Mockito mock to be serialized.- Returns:
- A wrapper (
AcrossJVMSerializationFeature.AcrossJVMMockSerializationProxy
) to be serialized by the calling ObjectOutputStream. - Throws:
java.io.ObjectStreamException
-
-
mockReplacementCompleted
private void mockReplacementCompleted()
-
mockReplacementStarted
private void mockReplacementStarted()
-
mockIsCurrentlyBeingReplaced
private boolean mockIsCurrentlyBeingReplaced()
-
enableSerializationAcrossJVM
public <T> void enableSerializationAcrossJVM(org.mockito.mock.MockCreationSettings<T> settings)
Enable serialization serialization that will work across classloaders / and JVM.Only enable if settings says the mock should be serializable. In this case add the
AcrossJVMSerializationFeature.AcrossJVMMockitoMockSerializable
to the extra interface list.- Type Parameters:
T
- Type param to not be bothered by the generics- Parameters:
settings
- Mock creation settings.
-
-