Я реалізую клас, який можна серіалізувати (тому це об’єкт значення для використання з RMI). Але мені потрібно це перевірити. Чи є спосіб зробити це легко?
уточнення : я реалізую клас, тому тривіально додати Serializable у визначення класу. Мені потрібно вручну провести серіалізацію / десеріалізацію, щоб перевірити, чи працює.
Я знайшов це запитання на C # , чи існує подібна відповідь для Java?
Відповіді:
Найпростіший спосіб - перевірити, чи об’єкт є екземпляром java.io.Serializableабо java.io.Externalizable, але це насправді не доводить, що об’єкт справді серіалізується.
Єдиний спосіб бути впевненим - спробувати це по-справжньому. Найпростіший тест - це щось на зразок:
new ObjectOutputStream(new ByteArrayOutputStream()).writeObject(myObject);
і перевірте, чи не створює виняток.
Apache Commons Lang надає досить коротку версію:
SerializationUtils.serialize(myObject);
і знову перевірте виняток.
Ви можете бути ще більш суворим і переконатися, що він десериалізується назад до чогось, рівного оригіналу:
Serializable original = ...
Serializable copy = SerializationUtils.clone(original);
assertEquals(original, copy);
і так далі.
serializeта deserialize. Див. SerializationUtils
deserialize()і clone()повернутися Object, чи не Serializable.
nullне можна серіалізувати , але вони є , він буде серіалізуватися; ініціювати їх, і цього не буде.
корисні методи, засновані на відповіді Скефмана:
private static <T extends Serializable> byte[] pickle(T obj)
throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
oos.close();
return baos.toByteArray();
}
private static <T extends Serializable> T unpickle(byte[] b, Class<T> cl)
throws IOException, ClassNotFoundException
{
ByteArrayInputStream bais = new ByteArrayInputStream(b);
ObjectInputStream ois = new ObjectInputStream(bais);
Object o = ois.readObject();
return cl.cast(o);
}
Коротка відповідь: ви можете придумати кілька об’єктів-кандидатів і насправді спробувати їх серіалізувати, використовуючи вибраний вами механізм. Перевірка тут полягає в тому, що під час маршірування / демаршалювання не виникають помилки, а отриманий «регідратаційний» об’єкт дорівнює оригіналу.
Як варіант, якщо у вас немає об’єктів-кандидатів, ви можете реалізувати тест на основі відображення, який інтроспектує (нестатичні, неперехідні) поля вашого класу, щоб переконатись, що вони теж можна серіалізувати. Якщо говорити з досвіду, це напрочуд швидко стає складним, але це можна зробити в розумних межах.
Недоліком цього останнього підходу є те, що якщо поле є, наприклад List<String>, тоді ви можете або провалити клас за відсутність строго серіалізованого поля, або просто припустити, що буде використана серіалізуюча реалізація List. І те, і інше не є ідеальним. (Майте на увазі, остання проблема існує і для прикладів; якщо кожен приклад, що використовується в тесті, використовує списки, що піддаються серіалізації, ніщо не заважає використанню несеріалізованої версії якимось іншим кодом на практиці).
Це працює лише для повністю заповнених об'єктів, якщо вам потрібно, щоб будь-які об'єкти, складені у вашому об'єкті верхнього рівня, також мали можливість серіалізації, тоді вони не можуть бути нульовими, щоб цей тест був дійсним, оскільки серіалізація / десеріалізація пропускає нульові об'єкти
Цей код повинен це зробити ...
import java.io.ByteArrayOutputStream;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
public class Main
{
public static void main(String[] args)
{
System.out.println(isSerializable("Hello"));
System.out.println(isSerializable(new Main()));
}
public static boolean isSerializable(final Object o)
{
final boolean retVal;
if(implementsInterface(o))
{
retVal = attemptToSerialize(o);
}
else
{
retVal = false;
}
return (retVal);
}
private static boolean implementsInterface(final Object o)
{
final boolean retVal;
retVal = ((o instanceof Serializable) || (o instanceof Externalizable));
return (retVal);
}
private static boolean attemptToSerialize(final Object o)
{
final OutputStream sink;
ObjectOutputStream stream;
stream = null;
try
{
sink = new ByteArrayOutputStream();
stream = new ObjectOutputStream(sink);
stream.writeObject(o);
// could also re-serilalize at this point too
}
catch(final IOException ex)
{
return (false);
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
// should not be able to happen
}
}
}
return (true);
}
}
instanceof Externalizableпередбачає instanceof Serializable. Не потрібно тестувати обидва.
Ви можете зробити наступний тест:
Ось приклад для серіалізації та десеріалізації об’єкта у файл:
Я намагався написати модульний тест (у Groovy, використовуючи Spock), який може перевірити, що даний інтерфейс для використання з RMI насправді повністю серіалізується - усі параметри, винятки та можливі реалізації типів, визначених у методах.
Здається, це поки працює для мене, однак, це зробити трохи хитро, і можуть бути випадки, які це не охоплює, тому використовуйте на свій страх і ризик!
Вам потрібно буде замінити приклади інтерфейсів Notificationтощо на свій. Приклад включає одне поле, яке не можна серіалізувати, як ілюстрацію.
package example
import groovy.transform.CompileDynamic
import groovy.transform.CompileStatic
import spock.lang.Specification
import java.lang.reflect.*
import java.rmi.Remote
import java.rmi.RemoteException
/** This checks that the a remoting API NotifierServer is safe
*
* It attempts to flush out any parameter classes which are
* not Serializable. This isn't checked at compile time!
*
*/
@CompileStatic
class RemotableInterfaceTest extends Specification {
static class NotificationException extends RuntimeException {
Object unserializable
}
static interface Notification {
String getMessage()
Date getDate()
}
static interface Notifier extends Remote {
void accept(Notification notification) throws RemoteException, NotificationException
}
static interface NotifierServer extends Remote {
void subscribe(Notification notifier) throws RemoteException
void notify(Notification message) throws RemoteException
}
// From https://www.javaworld.com/article/2077477/learn-java/java-tip-113--identify-subclasses-at-runtime.html
/**
* Scans all classes accessible from the context class loader which belong to the given package and subpackages.
*
* @param packageName The base package
* @return The classes
* @throws ClassNotFoundException
* @throws IOException
*/
static Class[] getClasses(String packageName)
throws ClassNotFoundException, IOException {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader()
assert classLoader != null
String path = packageName.replace('.', '/')
Enumeration resources = classLoader.getResources(path)
List<File> dirs = new ArrayList()
while (resources.hasMoreElements()) {
URL resource = resources.nextElement()
dirs.add(new File(resource.getFile()))
}
ArrayList classes = new ArrayList()
for (File directory : dirs) {
classes.addAll(findClasses(directory, packageName))
}
return classes.toArray(new Class[classes.size()])
}
/**
* Recursive method used to find all classes in a given directory and subdirs.
*
* @param directory The base directory
* @param packageName The package name for classes found inside the base directory
* @return The classes
* @throws ClassNotFoundException
*/
static List<Class> findClasses(File directory, String packageName) throws ClassNotFoundException {
List<Class> classes = new ArrayList()
if (!directory.exists()) {
return classes
}
File[] files = directory.listFiles()
for (File file : files) {
if (file.isDirectory()) {
//assert !file.getName().contains(".");
classes.addAll(findClasses(file, packageName + "." + file.getName()))
} else if (file.getName().endsWith(".class")) {
classes.add(Class.forName(packageName + '.' + file.getName().substring(0, file.getName().length() - 6)))
}
}
return classes
}
/** Finds all known subclasses of a class */
@CompileDynamic
static List<Class> getSubclasses(Class type) {
allClasses
.findAll { Class it ->
!Modifier.isAbstract(it.modifiers) &&
it != type &&
type.isAssignableFrom(it)
}
}
/** Checks if a type is nominally serializable or remotable.
*
* Notes:
* <ul>
* <li> primitives are implicitly serializable
* <li> interfaces are serializable or remotable by themselves, but we
* assume that since #getSerializedTypes checks derived types of interfaces,
* we can safely assume that all implementations will be checked
*</ul>
*
* @param it
* @return
*/
static boolean isSerializableOrRemotable(Class<?> it) {
return it.primitive || it.interface || Serializable.isAssignableFrom(it) || Remote.isAssignableFrom(it)
}
/** Recursively finds all (new) types associated with a given type
* which need to be serialized because they are fields, parameterized
* types, implementations, etc. */
static void getSerializedTypes(final Set<Class<?>> types, Type... it) {
for(Type type in it) {
println "type: $type.typeName"
if (type instanceof GenericArrayType) {
type = ((GenericArrayType)type).genericComponentType
}
if (type instanceof ParameterizedType) {
ParameterizedType ptype = (ParameterizedType)type
getSerializedTypes(types, ptype.actualTypeArguments)
break
}
if (type instanceof Class) {
Class ctype = (Class)type
if (ctype == Object)
break
if (types.contains(type))
break
types << ctype
for (Field field : ctype.declaredFields) {
println "${ctype.simpleName}.${field.name}: ${field.type.simpleName}"
if (Modifier.isVolatile(field.modifiers) ||
Modifier.isTransient(field.modifiers) ||
Modifier.isStatic(field.modifiers))
continue
Class<?> fieldType = field.type
if (fieldType.array)
fieldType = fieldType.componentType
if (types.contains(fieldType))
continue
types << fieldType
if (!fieldType.primitive)
getSerializedTypes(types, fieldType)
}
if (ctype.genericSuperclass) {
getSerializedTypes(types, ctype.genericSuperclass)
}
getSubclasses(ctype).each { Class c -> getSerializedTypes(types, c) }
break
}
}
}
/** Recursively checks a type's methods for related classes which
* need to be serializable if the type is remoted */
static Set<Class<?>> getMethodTypes(Class<?> it) {
Set<Class<?>> types = []
for(Method method: it.methods) {
println "method: ${it.simpleName}.$method.name"
getSerializedTypes(types, method.genericParameterTypes)
getSerializedTypes(types, method.genericReturnType)
getSerializedTypes(types, method.genericExceptionTypes)
}
return types
}
/** All the known defined classes */
static List<Class> allClasses = Package.packages.collectMany { Package p -> getClasses(p.name) as Collection<Class> }
@CompileDynamic
def "NotifierServer interface should only expose serializable or remotable types"() {
given:
Set<Class> types = getMethodTypes(NotifierServer)
Set<Class> nonSerializableTypes = types.findAll { !isSerializableOrRemotable(it) }
expect:
nonSerializableTypes.empty
}
}