使用Java的反射机制实现对象序列化与反序列化

使用Java的反射机制可以实现对象的序列化和反序列化。下面是一个简单的示例代码：

```java
import java.lang.reflect.Field;

public class ObjectSerializer {
    public static String serialize(Object obj) throws IllegalAccessException {
        Class<?> clazz = obj.getClass();
        StringBuilder sb = new StringBuilder();

        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            sb.append(field.getName()).append(":").append(field.get(obj)).append(",");
        }

        return sb.toString();
    }

    public static <T> T deserialize(String str, Class<T> clazz) throws InstantiationException, IllegalAccessException {
        T obj = clazz.newInstance();

        String[] pairs = str.split(",");
        for (String pair : pairs) {
            String[] keyValue = pair.split(":");
            String fieldName = keyValue[0];
            String fieldValue = keyValue[1];

            try {
                Field field = clazz.getDeclaredField(fieldName);
                field.setAccessible(true);
                if (field.getType() == int.class) {
                    field.set(obj, Integer.parseInt(fieldValue));
                } else if (field.getType() == String.class) {
                    field.set(obj, fieldValue);
                }
                // 根据需要可以添加更多类型的判断和处理

            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            }
        }

        return obj;
    }

    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        // 测试序列化
        Person person = new Person();
        person.setName("John");
        person.setAge(25);
        String serializedStr = serialize(person);
        System.out.println("Serialized: " + serializedStr);

        // 测试反序列化
        Person deserializedPerson = deserialize(serializedStr, Person.class);
        System.out.println("Deserialized: " + deserializedPerson.getName() + ", " + deserializedPerson.getAge());
    }
}

class Person {
    private String name;
    private int age;

    // 省略构造函数和getter/setter方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
```

在上述示例中，`serialize`方法使用反射获取对象的字段，将字段名和对应的字段值以键值对的形式拼接成字符串，完成序列化。`deserialize`方法将序列化后的字符串拆分成键值对，并使用反射根据字段名找到对应的字段，并将字段值设置回对象中，完成反序列化。

需要注意的是，上述示例中仅考虑了字符串和整数类型的字段，如果有其他类型的字段需要序列化和反序列化，可以根据需求进行相应的处理。