Novo

阿里云搭建代理服务器

Mon, 06 Nov 2023 00:00:00 +0000

本文仅做技术分享，请勿使用服务器做违法行为。

阿里云高校计划，每年 300 无门槛优惠券。

VPS 选择

非大陆机器即可，阿里云可以选则香港或者新加坡的轻量应用服务器，香港的每天 0 点限额发售，网络相对会比较稳定一点。

重装系统

因为阿里云自带的镜像会自带安装有阿里云盾，会监控服务器，所以…要重新安装一个纯净的镜像。

登录阿里云控制台，创建实例后之前点远程连接

连接上后，使用一键重装脚本 https://github.com/veip007/dd

这里贴出命令：

wget -N --no-check-certificate https://down.vpsaff.net/linux/dd/network-reinstall-os.sh && chmod +x network-reinstall-os.sh && ./network-reinstall-os.sh

根据自身需求和主机配置，选择系统，这里我选择的是Debian 10系统

输入编号回车就开始下载和解压系统相关文件了，然后会断连。

大约要等10-20分钟，让主机自己进行系统安装，如果主机支持VNC，可以通过VNC，观察系统安装进度。

如果能通过 ssh 连接上主机了，说明系统安装成功了，下图是已经成功安装后的界面，可以看到阿里云的云监控是停机状态，后续可以自行修改 root 密码。

搭建 x-ui 面板

https://github.com/vaxilu/x-ui

这里贴出命令

bash <(curl -Ls https://raw.githubusercontent.com/vaxilu/x-ui/master/install.sh)

安装过程会让你设置初始账号和面板访问端口，端口设置一个不常见的即可，记得在阿里云控制台开放一下访问的端口。

搭建节点

直接看视频从 5分钟开始 https://www.youtube.com/watch?v=SpxTFes1B8U

节点的端口记得也要在阿里云设置开放
访问面板 404 page not found 问题，是因为根目录变了

可以用 x-ui 命令查看根目录

WSL2 使用宿主机的代理

Fri, 15 Sep 2023 00:00:00 +0000

由于 WSL1 中 Linux 子系统和宿主机是共享网络的，所以使用宿主机的代理只需要将代理设置成 http://127.0.0.1:port 即可。但是 WSL2 基于 Hyper-V 运行，导致 Linux 子系统和 Windows 在网络上是两台各自独立的机器，从 Linux 子系统访问 Windows 首先需要找到 Windows 的 IP。而且每次启动 WSL IP 都会变动，并且在学校中宿主机 IP 也会变，所以每次重新启动后都要重新设置一下很麻烦，可以通过脚本来开启 / 关闭代理。

WSL 中获取宿主机 IP

WSL2 会把 IP 写在 /etc/resolv.conf 中，因此可以用 cat /etc/resolv.conf | grep nameserver | awk '{ print $2 }' 这条指令获得宿主机 IP 。

WSL2 自己的 IP 可以用 hostname -I | awk '{print $1}' 得到。

代理软件打开 Allow LAN

代理软件中设置允许来自局域网的连接。以 Clash 为例：

防火墙设置

放行代理的请求，或者直接关闭防火墙。

手动设置代理

export http_proxy='http://<Windows IP>:<Port>'
export https_proxy='http://<Windows IP>:<Port>'
# 设置 git 代理
git config --global http.proxy "${http_proxy}"
git config --global https.proxy "${http_proxy}"

脚本设置代理

脚本第 4 行 <PORT> 记得换成自己宿主机代理的端口，clash 默认代理端口是 7890

#!/bin/bash
hostip=$(cat /etc/resolv.conf | grep nameserver | awk '{ print $2 }')
wslip=$(hostname -I | awk '{print $1}')
port=<PORT>

PROXY_HTTP="http://${hostip}:${port}"

set_proxy(){
    export http_proxy="${PROXY_HTTP}"
    export HTTP_PROXY="${PROXY_HTTP}"

    export https_proxy="${PROXY_HTTP}"
    export HTTPS_proxy="${PROXY_HTTP}"
}

unset_proxy(){
    unset http_proxy
    unset HTTP_PROXY
    unset https_proxy
    unset HTTPS_PROXY
}

proxy_info(){
    echo "Host ip:" ${hostip}
    echo "WSL ip:" ${wslip}
    echo "Current proxy:" $https_proxy
}

if [ "$1" = "set" ]
then
    set_proxy

elif [ "$1" = "unset" ]
then
    unset_proxy

elif [ "$1" = "info" ]
then
    proxy_info
else
    echo "Unsupported arguments."
fi

如果希望 git 也能通过代理，可以分别在 set_proxy 和 unset_proxy 函数中加上如下命令

# 添加代理
git config --global http.proxy "${PROXY_HTTP}"
git config --global https.proxy "${PROXY_HTTP}"

# 移除代理
git config --global --unset http.proxy
git config --global --unset https.proxy

之后运行 . ./proxy.sh set 就可以自动设置代理了。unset 可以取消代理，info 可以查看代理状态，能够用来检查环境变量是否被正确修改。

运行的时候不要忘记之前的 .，或者使用 source ./proxy.sh set，只有这样才能够修改环境变量

直接运行例如 ./proxy.sh set 或者 sh proxy.sh set，这样会是运行在一个子 shell 中，对当前 shell 没有效果

另外可以在 ~/.bashrc 中选择性的加上下面两句话，记得将里面的路径修改成你放这个脚本的路径。

alias proxy="source /path/to/proxy.sh"
. /path/to/proxy.sh set

第一句话可以为这个脚本设置别名 proxy，这样在任何路径下都可以通过 proxy 命令使用这个脚本了，之后在任何路径下，都可以随时都可以通过输入 proxy unset 来暂时取消代理。

第二句话就是在每次 shell 启动的时候运行该脚本实现自动设置代理，这样以后不用额外操作就默认设置好代理啦~

验证代理

curl 一下 google，如果代理成功，则有网页返回，并且可以在代理软件中查看到日志。

这里不能用 ping 命令测试，因为 ping 用的是 ICMP 协议，而一般的代理只接管 TCP、UDP 以上的流量。

curl google.com

如何理解引用拷贝、深拷贝和浅拷贝

Fri, 31 Dec 2021 00:00:00 +0000

引用拷贝：引用拷贝，就是拷贝引用地址。两个不同的引用指向同一个对象。
浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点）
- 如果属性是基本类型(int,double,long,boolean等)，拷贝的就是基本类型的值
- 如果属性是引用类型，拷贝的就是内存地址（即复制引用但不复制引用的对象）
  
  注：String类型通过常量赋值时相当于基本数据类型，由于String为不可变对象，是无法修改原String的状态的，其会生成一个新的String对象
深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

图示：

案例：

实现浅拷贝

在需要拷贝的类上实现 Cloneable 接口，并重写 clone() 方法。实现很简单，直接调用的是父类 Object 的 clone() 方法。
使用的时候调用实现类的clone方法

public class Address implements Cloneable{
    private final String name;
    // 省略构造函数、Getter&Setter方法
    @Override
    public Address clone() {
        try {
            return (Address) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

public class Person implements Cloneable {
    private Address address;
    // 省略构造函数、Getter&Setter方法
    @Override
    public Person clone() {
        try {
            Person person = (Person) super.clone();
            return person;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

测试：

Person person1 = new Person(new Address("武汉"));
Person person1Copy = person1.clone();
// true
System.out.println(person1.getAddress() == person1Copy.getAddress());

从输出结构就可以看出， person1 的克隆对象和 person1 使用的仍然是同一个 Address 对象。

如果改变该类的引用属性，克隆对象的引用属性也会随着改变。

实现深拷贝

对 Person 类的 clone() 方法进行修改，连带着要把 Person 对象内部的 Address 对象一起复制。

@Override
public Person clone() {
    try {
        Person person = (Person) super.clone();
        person.setAddress(person.getAddress().clone());
        return person;
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

测试：

Person person1 = new Person(new Address("武汉"));
Person person1Copy = person1.clone();
// false
System.out.println(person1.getAddress() == person1Copy.getAddress());

从输出结构就可以看出，虽然 person1 的克隆对象和 person1 包含的 Address 对象已经是不同的了。意味着深拷贝创建一个新的对象，是完全独立于原对象的，所以无论怎么修改属性，另一个对象中的属性也不会随着改变。

实现引用拷贝

 Person person = new Person();
 Person person1 = person;

无论是改变person还是person1的任何属性，都会跟着改变。

Java对象序列化与反序列化

Fri, 24 Dec 2021 00:00:00 +0000

概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。

简单来说：

序列化：将数据结构或对象转换成二进制字节流的过程
反序列化：将在序列化过程中所生成的二进制字节流转换成数据结构或者对象的过程

对于 Java 这种面向对象编程语言来说，我们序列化的都是对象（Object）也就是实例化后的类(Class)，但是在 C++这种半面向对象的语言中，struct(结构体)定义的是数据结构类型，而 class 对应的是对象类型。

维基百科：

序列化（serialization）在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化（也称为解编组、deserialization、unmarshalling）。

综上：序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。

ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

public ObjectOutputStream(OutputStream out)：创建一个指定OutputStream的ObjectOutputStream。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

一个对象要想序列化，必须满足两个条件:

该类必须实现java.io.Serializable 接口，Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出NotSerializableException 。
该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。
被static修饰的属性也不会被序列化(因为static属性不属于对象)
注意：
- transient 只能修饰变量，不能修饰类和方法。
- transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。

public class Employee implements java.io.Serializable {
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
        System.out.println("Address  check : " + name + " -- " + address);
    }
}

2.写出对象方法

public final void writeObject (Object obj) : 将指定的对象写出。

public class SerializeDemo{
    public static void main(String [] args)   {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.address = "beiqinglu";
        e.age = 20; 
        try {
            // 创建序列化流对象
          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
            // 写出对象
            out.writeObject(e);
            // 释放资源
            out.close();
            fileOut.close();
            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        } catch(IOException i)   {
            i.printStackTrace();
        }
    }
}
输出结果：
Serialized data is saved

ObjectInputStream类

ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

public ObjectInputStream(InputStream in)：创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用ObjectInputStream读取对象的方法：

public final Object readObject () : 读取一个对象。

public class DeserializeDemo {
   public static void main(String [] args)   {
        Employee e = null;
        try {       
             // 创建反序列化流
             FileInputStream fileIn = new FileInputStream("employee.txt");
             ObjectInputStream in = new ObjectInputStream(fileIn);
             // 读取一个对象
             e = (Employee) in.readObject();
             // 释放资源
             in.close();
             fileIn.close();
        }catch(IOException i) {
             // 捕获其他异常
             i.printStackTrace();
             return;
        }catch(ClassNotFoundException c)  {
            // 捕获类找不到异常
             System.out.println("Employee class not found");
             c.printStackTrace();
             return;
        }
        // 无异常,直接打印输出
        System.out.println("Name: " + e.name);  // zhangsan
        System.out.println("Address: " + e.address); // beiqinglu
        System.out.println("age: " + e.age); // 0
    }
}

对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。

反序列化操作2

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个InvalidClassException异常。发生这个异常的原因如下：

该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类，提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Employee implements java.io.Serializable {
     // 加入序列版本号
     private static final long serialVersionUID = 1L;
     public String name;
     public String address;
     // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
     public int eid; 

     public void addressCheck() {
         System.out.println("Address  check : " + name + " -- " + address);
     }
}

案例：序列化集合

将存有多个自定义对象的集合序列化操作，保存到list.txt文件中。
反序列化list.txt ，并遍历集合，打印对象信息。

案例分析

把若干学生对象，保存到集合中。
把集合序列化。
反序列化读取时，只需要读取一次，转换为集合类型。
遍历集合，可以打印所有的学生信息

案例实现

public class SerTest {
    public static void main(String[] args) throws Exception {
        // 创建 学生对象
        Student student = new Student("test1", "address1");
        Student student2 = new Student("test2", "address2");
        Student student3 = new Student("test3", "address3");

        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(student);
        arrayList.add(student2);
        arrayList.add(student3);
        // 序列化操作
        // serializ(arrayList);
        
        // 反序列化  
        ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("list.txt"));
        // 读取对象,强转为ArrayList类型
        ArrayList<Student> list  = (ArrayList<Student>)ois.readObject();
        
        for (int i = 0; i < list.size(); i++ ){
            Student s = list.get(i);
            System.out.println(s.getName()+"--"+ s.getPwd());
        }
    }

    private static void serializ(ArrayList<Student> arrayList) throws Exception {
        // 创建 序列化流 
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
        // 写出对象
        oos.writeObject(arrayList);
        // 释放资源
        oos.close();
    }
}

如何理解 KMP

Sat, 04 Dec 2021 00:00:00 +0000

基本概念：

非平凡前缀：包含首位字符但不包含末位字符的子串组合。
非平凡后缀：包含末位字符但不包含首位字符的子串组合。
next数组定义(又称部分匹配表)：模式串T j指针的变化(即当主串与模式串的某一位字符不匹配时，模式串要回退的位置)
next[j]的值：当前字符j之前(j-1位)的串的前后缀的相似度(重合字符数+1)

模式串求next数组

此教程面向的对象：

了解KMP算法原理，可以手写next数组
看过求next数组的代码，进行过相关思考

next[j]数组函数定义：

看懂求next数组代码最重要的是理解下面两句话：

next[j+1]的最大值为next[j]+1
如果$P_{k1}\neq P_{j}$ ,那么next[j+1]可能的最大值为next[next[j]]+1,以此类推即可高效求出next[j+1]。(重点)

第一句话的意思是，我们已知next[j]的情况下，继续与下一位字符匹配，最理想的情况就是下一位字符匹配依然相等$P_{k1}$= $P_{j}$，next[j+1]=next[j]+1,相似度+1

第二句话的意思是，我们已知next[j]的情况下，继续与下一位字符匹配,匹配不相等（next[j]只是当前字符j之前的串的前后缀的相似度,然而决定回溯跨度的是整个S串的前后缀的相似度），进行回溯，继续下一次匹配

流程： ①求next[j+1],则已知next[1]、next[2]$\cdots$next[j]

②假设next[j]=$k_1$,则有$P_1\cdots P_{k-1}$ = $P_{j-k+1}\cdots P_{j-1}$(前k1-1位字符与后k1-1位字符重合)

③如果$P_{k1}$= $P_{j}$,则$P_1\cdots P_{k-1}P_{k1}$ = $P_{j-k+1}\cdots P_{j-1}P_{j}$,则next[j+1]=k1+1,否则进入下一步

④假设next[k1]=k2,则有$P_1\cdots P_{k2-1}$ = $P_{k1-k2+1}\cdots P_{k1-1}$

⑤第二第三步联合得到：$P_1\cdots P_{k2-1}$ = $P_{k1-k2+1}\cdots P_{k1-1}$ = $P_{j-k1+1}\cdots P_{k2-k1+j-1}$ = $P_{j-k2+1}\cdots P_{j-1}$ 即四段重合

⑥这时候，再判断如果$P_{k2}$ = $P_{j}$, 则$P_1\cdots P_{k2-1}P_{k2}$ = $P_{j-k2+1}\cdots P_{j-1}P_{j}$ ,则next[j+1]=k2+1;否则再取next[k2]=k3…以此类推

图解：

假设我们已知next[16] = 8 ,需要求next[17]

next[16] = 8 ,那么就是在j=16的字符前的串的前后缀有 8 -1 =7个字符重复

求next[17] 我们只需要比较$P_{8}$和$P_{16}$，最理想的情况就是$P_{8}$ = $P_{16}$ 那么next[17] = next[16]+1

若$P_{8}$ ≠ $P_{16}$ ，k进行回溯，回溯到next[8] （我们假设next[8] = 4）

next[8] = 4 ,那么就是在j=4的字符前的串的前后缀有 4 -1 =3个字符重复

现在求next[17] 我们只需要比较$P_{4}$和$P_{16}$，第二理想情况就是$P_{4}$ = $P_{16}$ 那么next[17] = next[8]+1 = 5

为什么呢

因为蓝色部分相等，且橙色部分相等，那我们就可以推出四部分是相等的

如果第二理想情况都不满足，即$P_{4}$ ≠ $P_{16}$，k继续回溯，k = next[4] （我们假设next[4] = 2）

同理，若$P_{2}$ = $P_{16}$ 那么next[17] = next[4]+1 = 3

否则，继续回溯，若回溯到next[1]=0,还不相等，则说明相似度为0，递推结束，双指针往后移一位，进行新一轮子串比较

求next数组代码

void getNext(string T,int* next){
	int i = 1,k = 0;
    next[1] = 0;
    //T[0]代表模式串T的长度
    while(i < T[0]){
        if(k == 0 || T[i] == T[k]) next[++i] = ++k; //字符相同继续比较
        else k = next[k]; //若字符不相同 k指针回溯
    }
}

举个例子：

模式串：ababac

先用一个例子来看代码的运行流程

开始i指针指向1，k指针指向0，只有一个指针指向了字符，至少需要两个字符才能比较，进入第一个if满足k == 0，next[++i] =++k,

i,k指针都向前移一位

next[2] = 1；即j=2，在j之前只有一个字符，所以前后缀相似度为1

i = 2 ，k = 1 T[2]不等于T[1] k指针回溯到next[k] 即next[1] = 0 ;

此时k又等于0了满足if i，k指针都向前移一位，比较下一位

next[3] = 1

i = 3 ， k = 1 T[3] = T[1] 满足if i ，k 指针继续后移

next[4] = 2

i = 4 ，k = 2 T[4] = T[2] 满足if i，k指针继续后移

next[5] = 3

i = 5，k = 3 T[5] = T[3] 满足if i，k指针继续后移

next[6] = 4

i = 6，k = 4 T[6] ≠ T[4] k指针开始回溯到next[k] =next[4] = 2

i 不变，k = 2 T[6] ≠ T[2] k指针继续回溯到next[k] =next[2] = 1

i 不变，k = 1 T[6] ≠ T[1] 这次匹配不成功则说明子串$P_{1}P_{2}P_{3}P_{4}P_{5}P_{6}$前后缀并不重复，于是k指针回溯到next[k] =next[1] = 0，进行i ，k指针后移比较下一个子串

我们再通过gif动画再来回顾一遍上面的流程：

主串和模式串的匹配

这一部分就比较简单

代码

//返回子串T在主串S中第pos字符之后的位置，若不存在则返回0
//代码需要根据自己的索引值更改循环的边界
int KMP(string S,string T,int pos){
    int i = pos;
    int j = 1;
    int next[255];---------------------------1
    getNext(T,next);-------------------------2
    
    while(i <= S[0] && j <= T[0]){
        if(j == 0 || S[i] == T[i]){
            ++i;
            ++j;
        }else{
            j = next[j];---------------------3
        }
    }
    
    if(j > T[0]) return i-T[0];
    else return 0;
}

下面看两个例子

通过上面两个例子也可以看出KMP算法仅当模式与主串之间存在许多“部分匹配”和模式串前后缀相似度小的情况下才能体现它的优势，否则和朴素模式匹配差异并不明显