blob: 25ae4d20d3b6ad65fa3869cfe091b80a377f92bd (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. Alternatively, the contents of this file may be used under
* the terms of the GNU Lesser General Public License Version 2.1 or later,
* or the Apache License Version 2.0.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*/
package javassist.util.proxy;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectStreamClass;
/**
* An input stream class which knows how to deserialize proxies created via {@link ProxyFactory} and
* serializedo via a {@link ProxyObjectOutputStream}. It must be used when deserialising proxies created
* from a proxy factory configured with {@link ProxyFactory#useWriteReplace} set to false.
*
* @author Andrew Dinn
*/
public class ProxyObjectInputStream extends ObjectInputStream
{
/**
* create an input stream which can be used to deserialize an object graph which includes proxies created
* using class ProxyFactory. the classloader used to resolve proxy superclass and interface names
* read from the input stream will default to the current thread's context class loader or the system
* classloader if the context class loader is null.
* @param in
* @throws java.io.StreamCorruptedException whenever ObjectInputStream would also do so
* @throws IOException whenever ObjectInputStream would also do so
* @throws SecurityException whenever ObjectInputStream would also do so
* @throws NullPointerException if in is null
*/
public ProxyObjectInputStream(InputStream in) throws IOException
{
super(in);
loader = Thread.currentThread().getContextClassLoader();
if (loader == null) {
loader = ClassLoader.getSystemClassLoader();
}
}
/**
* Reset the loader to be
* @param loader
*/
public void setClassLoader(ClassLoader loader)
{
if (loader != null) {
this.loader = loader;
} else {
loader = ClassLoader.getSystemClassLoader();
}
}
protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
boolean isProxy = readBoolean();
if (isProxy) {
String name = (String)readObject();
Class superClass = loader.loadClass(name);
int length = readInt();
Class[] interfaces = new Class[length];
for (int i = 0; i < length; i++) {
name = (String)readObject();
interfaces[i] = loader.loadClass(name);
}
length = readInt();
byte[] signature = new byte[length];
read(signature);
ProxyFactory factory = new ProxyFactory();
// we must always use the cache and never use writeReplace when using
// ProxyObjectOutputStream and ProxyObjectInputStream
factory.setUseCache(true);
factory.setUseWriteReplace(false);
factory.setSuperclass(superClass);
factory.setInterfaces(interfaces);
Class proxyClass = factory.createClass(signature);
return ObjectStreamClass.lookup(proxyClass);
} else {
return super.readClassDescriptor();
}
}
/**
* the loader to use to resolve classes for proxy superclass and interface names read
* from the stream. defaults to the context class loader of the thread which creates
* the input stream or the system class loader if the context class loader is null.
*/
private ClassLoader loader;
}
|
