一些名词的解释

一些名词的解释

service mesh

就是服务治理功能从代码里抽出来

istio

service mesh的一个实现

containerd

hadoop

是apache基金会的开发的分布式系统基础架构。两个核心设计HDFS以及MapReduce。
HDFS提供海量数据的存储
MapReduce提供海量数据的计算
Hadoop 的作用非常简单，就是在多计算机集群环境中营造一个统一而稳定的存储和计算环境，并能为其他分布式应用服务提供平台支持。也就是说， Hadoop 在某种程度上将多台计算机组织成了一台计算机（做同一件事），那么 HDFS 就相当于这台计算机的硬盘，而 MapReduce 就是这台计算机的 CPU 控制器。
HDFS 运行在许多不同的计算机上，有的计算机专门用于存储数据，有的计算机专门用于指挥其它计算机储存数据。这里所提到的"计算机"我们可以称之为集群中的节点。

命名节点 (NameNode)

命名节点 (NameNode) 是用于指挥其它节点存储的节点。任何一个"文件系统"(File System, FS) 都需要具备根据文件路径映射到文件的功能，命名节点就是用于储存这些映射信息并提供映射服务的计算机，在整个 HDFS 系统中扮演"管理员"的角色，因此一个 HDFS 集群中只有一个命名节点。

数据节点 (DataNode)

数据节点 (DataNode) 使用来储存数据块的节点。当一个文件被命名节点承认并分块之后将会被储存到被分配的数据节点中去。数据节点具有储存数据、读写数据的功能，其中存储的数据块比较类似于硬盘中的"扇区"概念，是 HDFS 存储的基本单位。

副命名节点 (Secondary NameNode)

副命名节点 (Secondary NameNode) 别名"次命名节点"，是命名节点的"秘书"。这个形容很贴切，因为它并不能代替命名节点的工作，无论命名节点是否有能力继续工作。它主要负责分摊命名节点的压力、备份命名节点的状态并执行一些管理工作，如果命名节点要求它这样做的话。如果命名节点坏掉了，它也可以提供备份数据以恢复命名节点。副命名节点可以有多个。

java-ssh

https://www.runoob.com/w3cnote/hadoop-setup.html

jackson

java最好的json库
jackson-core
jackson-anntations
jackson-databind

1. jackson-core库，这是个低阶API库，提供流式解析工具JsonParser，流式生成工具JsonGenerator；
2. 尽管jackson-databind负责序列化和反序列化处理，但它的底层实现是调用了jackson-core的API；
   JsonParser负责将JSON解析成对象的变量值，核心是循环处理JSON中的所有内容；

JsonGenerator负责将对象的变量写入JSON的各个属性，这里是开发者自行决定要处理哪些字段；

Java内部类详解–成员内部类，局部内部类，匿名内部类，静态内部类

https://www.cnblogs.com/latter/p/5665015.html

java的Serializable空接口

仅仅是一个标识，标识这个类可以被jvm序列化和反序列化，但是需要和private static final long serialVersionUID一起工作

1. 类实现Serializable接口告诉jvm自己可以被序列化和反序列化
   如果你没有写serialVersionUID，当你序列化之后修改了类的定义再反序列化的时候就会报错。猜测jvm会根据类定义计算一个serialVersionUID值，当修改了类定义后再反序列化就会报错。
2. 为了避免上面的情况出现，又想可以修改类，那就加一个serialVersionUID静态变量吧。这样在你修改了了类后，反序列化依然不会报错
3. 如果你修改了类，并且希望之前序列化的类不能在被反序列化，那就改一下serialVersionUID的值。这样之前被序列化的类序列化的时候就会报错。
4. 序列化逃避了java的单例模式

package com.tom.tom.serial;

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

public class TestSerial {
    public static void main(String[] args) {

//        toSerial();
        fromSerial();
    }
    //序列化过程
    public static void toSerial() {
        try {
            User user = new User("id", "user");
            System.out.println(user);

            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("user.txt"));
            objectOutputStream.writeObject(user);
            objectOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //反序列化过程
    public static void fromSerial(){
        try {
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("user.txt"));
            User user = (User) objectInputStream.readObject();
            System.out.println(user);
            objectInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

package com.tom.tom.serial;

import java.io.Serializable;

public class User implements Serializable {

    public User(String userId, String userName) {
        this.userId = userId;
        this.userName = userName;
    }

//    private static final long serialVersionUID = 2L;

    private String userId;
    private String userName;

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public String toString() {
        return this.hashCode() + "User{" + "userId='" + userId + '\'' + ", userName='" + userName + '\'' + ", address='" + address + '\'' + '}';
//        return this.hashCode() + "User{" + "userId='" + userId + '\'' + ", userName='" + userName + '}';

    }
}

序列化和反序列化逃避单例模式

package com.tom.tom.serial;

import java.io.Serializable;

public class MySingletion implements Serializable {



    public void show() {
        System.out.println("show...");
    }
    private static final long serialVersionUID = 1L;


    private static volatile MySingletion mySingletion = null;

    private MySingletion(){}
    public static MySingletion getInstance() {
        if (mySingletion == null) {
            synchronized (MySingletion.class) {
                if (mySingletion == null) {
                    mySingletion = new MySingletion();
                }
            }
        }
        return mySingletion;
    }
}



package com.tom.tom.serial;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestSingletion {
    public static void main(String[] args) {



        MySingletion instance = MySingletion.getInstance();
        System.out.println(instance);
        MySingletion instance1 = MySingletion.getInstance();
        System.out.println(instance1);
        System.out.println(instance == instance1);

        instance.show();

        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("MySingletion.txt"));
            objectOutputStream.writeObject(instance);
            objectOutputStream.close();



            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("MySingletion.txt"));
            MySingletion o = (MySingletion)objectInputStream.readObject();
            o.show();
            System.out.println(o);
            objectInputStream.close();


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




    }
}

com.tom.tom.serial.MySingletion@72ea2f77
com.tom.tom.serial.MySingletion@72ea2f77
true
show...
show...
com.tom.tom.serial.MySingletion@17f052a3

Process finished with exit code 0