跟随Y4的路线学习

https://github.com/Y4tacker/JavaSec

java基础知识

中途看到一个很好的网站

https://liaoxuefeng.com/books/java/quick-start/index.html

this变量

this 是一个变量，指向当前正在执行代码的那个对象。

class Person {String name;void setName(String name) {this.name = name; // this.name 是成员变量，name 是参数}
}

方法可变参数

可变参数用类型...定义，可变参数相当于数组类型：

class Group {private String[] names;public void setNames(String... names) {this.names = names;}
}Group g = new Group();
g.setNames("Xiao Ming", "Xiao Hong", "Xiao Jun"); // 传入3个String
g.setNames("Xiao Ming", "Xiao Hong"); // 传入2个String

构造方法

如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来：

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

将属性定义为private，外部无法直接访问，通过方法才可以访问，而idea有自动生成get方法和set方法的快捷键，将鼠标移动到类里，按下alt+insert。蛋疼的是新键盘没有insert…于是改成contrl+shift+G了

继承的关键字

protected

一个protected字段和方法可以被其子类，以及子类的子类所访问

super

class Person {protected String name;protected int age;public Person(String name, int age) {this.name = name;this.age = age;}
}class Student extends Person {protected int score;public Student(String name, int age, int score) {this.score = score;}
}

运行上面的代码，会得到一个编译错误，大意是在Student的构造方法中，无法调用Person的构造方法。

这是因为在Java中，任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super();，所以，Student类的构造方法实际上是这样：

class Student extends Person {protected int score;public Student(String name, int age, int score) {super(); // 自动调用父类的构造方法this.score = score;}
}

但是，Person类并没有无参数的构造方法，因此，编译失败。

解决方法是调用Person类存在的某个构造方法。例如：

class Student extends Person {protected int score;public Student(String name, int age, int score) {super(name, age); // 调用父类的构造方法Person(String, int)this.score = score;}
}

阻止继承

从Java 15开始，允许使用sealed修饰class，并通过permits明确写出能够从该class继承的子类名称。

例如，定义一个Shape类：

public sealed class Shape permits Rect, Circle, Triangle {...
}

方法重载

直接写方法就行，要求参数个数或位置不能完全一致

向上转型和向下转型

向上转型是可以的，即子类可以转为父类，但向下转型是不允许的，在类型转换时，父类->子类无法凭空变出多的那部分功能。

Person p = new Student();

可以理解为将新建的Student实例转化为person类，可以对person类进行相关的操作

为了避免向下转型出错，Java提供了instanceof操作符，可以先判断一个实例究竟是不是某种类型：

Person p = new Person();
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Student); // false

instanceof判断一个实例是否是指定类或指定类的子类，从Java 14开始，判断instanceof后，可以直接转型为指定变量，避免再次强制转型。

在逻辑关系不适合使用继承时可以使用组合，类可以拥有其他类的实例，嵌套之后可以拿到其他类的方法和属性

class Student extends Person {protected Book book;protected int score;
}

多态

Override（重写）和Overload（重载）是两个与方法相关的概念

在 Java 中，方法签名由 方法名 和 参数列表（包括参数的类型、数量和顺序）组成。

Override 发生在子类中，当子类重新定义（重写）父类中已有的方法时，称为重写。重写的目的是让子类提供自己的方法实现，覆盖父类的实现。条件：

• 方法签名（方法名 + 参数列表）必须与父类中的方法完全相同。

• 返回类型必须相同（或子类方法返回类型是父类方法返回类型的子类，称为协变返回类型）。

• 访问修饰符不能比父类更严格（例如，父类是 public，子类不能是 protected 或 private）。

• 子类方法抛出的异常不能比父类方法抛出的异常范围更广。

• 通常使用 @Override 注解来明确表示这是一个重写方法，防止错误。

Overload 发生在同一个类中，当定义多个方法名相同但参数列表不同的方法时，称为方法重载。重载方法是独立的新方法，互不干扰。

条件：

• 方法名必须相同。
• 参数列表必须不同（参数数量或参数类型不同）。
• 返回类型、访问修饰符、异常声明可以不同，但这些不影响重载的判断。

多态的特性就是，运行期才能动态决定调用的子类方法。对某个类型调用某个方法，执行的实际方法可能是某个子类的覆写方法。

抽象

使用abstract修饰的类就是抽象类。抽象类无法实例化

接口

如果抽象类所有方法都是抽象方法，就可以把该类改写为接口

interface Person {void run();String getName();
}

接口定义的所有方法默认都是public abstract的，所以这两个修饰符写不写效果都一样。接口不能定义实例字段

static静态字段

特性	实例字段	静态字段
修饰符	无static	使用static
所属	属于对象	属于类
内存分配	每个对象一份，存储在堆中	类加载时分配，存储在方法区
访问方式	通过对象实例（如obj.field）	通过类名或对象（如Class.field）
生命周期	与对象一致	与类的生命周期一致

static修饰的属性可以直接通过类名访问，修改会影响到所有用到该属性的实例，因为所有实例都会共享该字段

default方法

定义：在接口中使用default关键字修饰的方法，提供了方法的具体实现，而非抽象方法。

向接口添加default方法不会破坏现有实现类的代码，因为它们自动继承默认实现。可以用 @Override重写

包

包没有父子关系。java.util和java.util.zip是不同的包，两者没有任何继承关系。

查找class的顺序，先查当前package，再查import的包，最后查java.lang包

final

final修饰class可以阻止被继承

final修饰method可以阻止被子类覆写

final修饰局部变量可以阻止被重新赋值

package abc;public class Hello {protected void hi(final int t) {t = 1; // error!}
}

内部类

定义在一个类内部的类，要实例化一个内部类，首先需要实例化它的外部类

Outer.Inner inner = outer.new Inner();

内部类除了可以引用外部类实例，还可以修改外部类的private字段

匿名类（Anonymous Class）是：Java 中一种没有显式名称的类，通常用于一次性使用的场景

定义的时候就{}加入类体，new后一般跟父类名或接口名

interface MyInterface {void doSomething();
}public class Test {public static void main(String[] args) {// 匿名类实现 MyInterfaceMyInterface obj = new MyInterface() {@Overridepublic void doSomething() {System.out.println("Doing something");}};obj.doSomething();}
}

静态内部类：static修饰的内部类和Inner Class有很大的不同，它不再依附于Outer的实例，而是一个完全独立的类，因此无法引用Outer.this，但它可以访问Outer的private静态字段和静态方法。如果把StaticNested移到Outer之外，就失去了访问private的权限。

java序列化与反序列化

序列化的类必须实现Serializable接口，实例可以序列化，类不可以，所以类中的static修饰的成员变量也不可以，transient标记的变量同样不可以反序列化

可以重写writeObject和readObject方法来自定义序列化和反序列化

安全问题的产生：只要反序列化数据，重写的readObject方法肯定就会自动执行

1. 入口类的readObject方法里本身就存在危险方法
2. 入口类参数中含有其他可控类，该类有危险方法
3. 入口类参数中包含可控类，该类继续调用其他类

反射

可以通过反射的机制修改某些成员的属性

获取对象的类

public class ReflectionTest {public static void main(String[] args) {Person p=new Person("abc",20);Class c=p.getClass();//反射就是操作Class}
}

从原型Class实例化对象（无参构造和有参构造）

 //无参构造方法
Class c=p.getClass();
c.newInstance();
//有参构造方法
Constructor tmp=c.getConstructor(String.class,int.class);
Person person2=(Person) tmp.newInstance("cc",10);

获取类里面属性

c.getField(p.name);
c.getFields();
c.getDeclaredFields();//获取到所有修饰符修饰的属性

修改private成员属性

Field age=c.getDeclaredField("age");
age.setAccessible(true);
age.set(person2,21);
System.out.println(person2);

访问类里面方法

Method[] m=c.getDeclaredMethods();
for(Method m1:m){System.out.println(m1);
}

调用类里面方法

Method m=c.getMethod("act1");
m.invoke(person2);//如果函数需要接收参数
Method m=c.getMethod("act1",String.class);
m.invoke(person2,"aaa");//私有方法访问与私有属性一样

urldns链

没错，来到了入门必见的一条链子

这条链子虽然简单，但是对我这样的小白来说，一下子有点想不明白hashmap的反序列化为什么会跟url类产生关系，ai的过程中突然顿悟了，hashmap在反序列化时是不是会调用hashcode()方法计算键的哈希值（后面会跟这条链子），而如果这个键是url类呢？url类有自己重写的hashcode方法，所以到这一步它会调用自己的hashcode方法，它自己的方法中会对域名发起一次解析请求，从而留下记录。

先跟一下hashmap的实现

先进readObject方法

再进最下面的hash方法

发现调用了hashcode方法计算key，也就是计算url，那么到这里就可以知道如果传入的类是url类，那么就会在反序列化时调用url类自己的hashcode方法了，那么它自己的hashcode方法又是什么样的呢。

进入url类，找到hashcode方法

发现当hashcode==-1时（应该是一个默认值），会调用handle类的hashcode方法，跟进handle类

继续跟进

发现在URLStreamHandler类的hashcode方法中，调用了getHostAddress方法，所以会对当前url进行一次解析

再来一个简单的序列化反序列化验证一手

import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Scanner;public class Hello {public static void main(String[] args) throws Exception {HashMap<URL,Integer> h=new HashMap<URL,Integer>();URL url=new URL("http://zf8tay.dnslog.cn");h.put(url,20);// 序列化到文件FileOutputStream fos = new FileOutputStream("exploit.ser");ObjectOutputStream oos = new ObjectOutputStream(fos);oos.writeObject(h);oos.close();// 反序列化（假设目标系统执行）FileInputStream fis = new FileInputStream("exploit.ser");ObjectInputStream ois = new ObjectInputStream(fis);ois.readObject(); // 反序列化时触发 URL 的 hashCode()ois.close();}}

这个时候发现有两条记录，这是为什么呢？

跟进put方法，发现同样会调用hash方法，从而调用url类的hashcode方法，所以在序列化之前就会发起解析请求，想要阻止也很简单，在put前通过反射修改hashcode的值不是-1，put后再改回来即可

动态代理

代理就是加入一个代理类，即可以用原来类的方法，又可以自己加入方法，避免了直接对原生类的修改。

静态代理就是每一次调用方法都把底层逻辑写上，而如果很多方法的调用是相似的，就可以使用动态代理简化过程。不过要注意动态代理只能用于接口类

先写一个接口和接口的实现

interface Myservice{void sayhello(String name);
}
class Myserviceimp implements Myservice{@Overridepublic void sayhello(String name){System.out.println("hello,"+name);}
}

动态代理的InvocationHandler,invoke方法就像readObject方法一样，会在动态代理时自动执行

class Myhandle implements InvocationHandler{private  Object target;public Myhandle(){}public Myhandle(Object o){this.target=o;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable{Object res=method.invoke(target,args);return res;}
}

主函数测试

public class DynamicProxyTest {public static void main(String[] args) {
// 创建真实对象MyService realService = new MyServiceImpl();// 创建动态代理MyService proxyService = (MyService) Proxy.newProxyInstance(MyService.class.getClassLoader(),new Class<?>[]{MyService.class},new MyInvocationHandler(realService));// 调用代理对象的方法proxyService.sayHello("Alice");}
}

类加载器（ClassLoader）

首先得知道什么是类加载器

Java的类加载器（ClassLoader）就像一个“搬运工”，负责把编译好的.class文件（字节码）加载到JVM（Java虚拟机）中，让程序能用。简单来说，它的工作是找到类文件、读进来、然后交给JVM处理。

它先去找到类文件，然后把类文件转换为字节流，然后JVM把这些字节流转换为可执行的类对象。java有几种类加载器

• Bootstrap ClassLoader：最顶层，加载Java核心库（比如java.lang.String）。

• Extension ClassLoader：加载扩展库。

• Application ClassLoader：加载你自己写的程序的类。

在类初始化时会执行静态代码块，类实例化时会执行构造代码块和无参构造函数

动态加载类方法Class.forname可以自行选择是否初始化

双亲委派模型

听着高大上，其实就是加载类时，先试着让上级（父加载器）加载，干不了自己再干，比如Object类，所有的类都会向上让Bootstrap ClassLoader来加载这个类，所以无论在哪里调用这个类都是一样的，避免了冲突与混乱。

• 动态性：可以动态加载类，比如从网络下载个类直接用。利用URLClassLoader类

import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;public class loader {public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {URLClassLoader u=new URLClassLoader(new URL[]{new URL("file://F:\\web\\idea&vs脚本\\")});Class<?> c=u.loadClass("test");c.newInstance();}
}

同时，我们在test.java类的static区里可以加入方法，验证类在初始化时会自动执行静态代码块

public class test {static {System.out.println("已执行静态代码块");}
}

注意test.java要先编译为test.class文件

Spring Boot 2

1.Spring Boot 2

Spring Boot 2 是基于 Spring 框架 的一个开源 Java 开发框架，旨在简化企业级应用的开发。它通过提供“开箱即用”的配置、自动配置和嵌入式服务器，减少了开发者手动配置的工作量。Spring Boot 2 是 Spring Boot 的第二个主要版本（发布于 2018 年）

2. Maven

Maven 是一个广泛使用的 构建自动化工具，主要用于 Java 项目管理。它通过一个中央配置文件（pom.xml，Project Object Model）来管理项目的依赖、构建、测试和部署流程。Maven 简化了依赖管理和构建过程，避免了手动下载 JAR 文件的麻烦。

此后可以通过maven下载依赖和进行相关测试等操作，后续把项目打成jar包，直接在目标服务器执行即可。

myapp/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/Application.java
│   │   ├── resources/
│   │   │   └── application.properties
│   ├── test/
│   │   └── java/
├── pom.xml
├── target/  # 编译和打包输出

特点

依赖管理

父项目是一个用来管理和组织其他项目的“模板”或“蓝图”项目，通常以一个 Maven 或 Gradle 配置文件（比如 pom.xml）的形式存在。在 Spring Boot 中，父项目主要用来统一管理依赖版本、配置和构建规则，让子项目（实际的开发项目）可以直接“继承”这些设置，简化开发。

通俗点说，父项目就像一个“家里的管家”，它帮你把常用的工具、规则和资源（比如依赖库的版本、编译方式等）都整理好，写在一本“家规”里。你的具体项目（子项目）只要认这个“管家”为“家长”，就能直接用它准备好的东西，不用自己从头配置。

在 Spring Boot 2 中的具体例子：

Spring Boot 提供了一个官方的父项目，叫 spring-boot-starter-parent。它的 pom.xml 文件里定义了：

• 一堆常用依赖（比如 Spring 框架、测试库、日志库等）的推荐版本。
• 项目构建的默认配置（比如 Java 版本、Maven 插件等）。
• 一些通用的属性（比如编码格式）。

你在子项目的 pom.xml 里通过以下方式“继承”这个父项目：

<parent>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-parent</artifactId>    <version>2.7.18</version> <!-- 假设用这个版本 --> </parent>

自动版本仲裁

“自动版本仲裁”指的是：当你使用 Spring Boot 的父项目（比如 spring-boot-starter-parent）或依赖管理工具（比如 spring-boot-dependencies）时，Spring Boot 会帮你“自动挑选”一些常用依赖的版本号。你在子项目的 pom.xml 文件里添加这些依赖时，不需要手动写版本号，因为父项目已经预先定义好了这些依赖的推荐版本。

那些不在 Spring Boot 父项目或 spring-boot-dependencies 预定义列表中的依赖。因为 Spring Boot 不知道这些依赖的推荐版本，所以你需要手动指定版本号。

自动配好Tomcat

3.Tomcat 是什么？

Apache Tomcat 是一个开源的 Web 服务器和 Servlet 容器，主要用于运行 Java 开发的 Web 应用。它由 Apache 软件基金会维护，是 Java 生态中最常用的服务器之一。

通俗解释：Tomcat 就像一个“餐厅服务员”，专门负责接收客户的请求（比如用户在浏览器访问你的网站），然后把请求交给你的 Java 程序（比如 Spring Boot 应用）处理，再把处理结果（网页、数据）送回给客户。

Tomcat 的主要功能

1. 处理 HTTP 请求：接收用户通过浏览器发送的请求（比如 GET、POST），并返回响应（网页、JSON 数据等）。
2. 运行 Servlet 和 JSP：支持 Java 的 Servlet（处理动态请求的 Java 程序）和 JSP（Java 服务器页面）技术，让开发者可以构建动态网站。
3. 嵌入式或独立运行
   • 独立运行：可以单独安装 Tomcat 作为一个服务器，把你的应用（WAR 文件）部署上去。
   • 嵌入式运行：Spring Boot 把 Tomcat 打包到应用里，运行项目时 Tomcat 直接启动，省去部署步骤。

在 Spring Boot 中的作用

• Spring Boot 默认把 Tomcat 作为内置 Web 服务器，包含在 spring-boot-starter-web 依赖中。

• 你写好 Spring Boot 应用（比如 REST API 或网页），运行 main 方法，Tomcat 就会启动，监听 HTTP 请求（默认端口 8080）。

• 你可以用浏览器或工具（比如 Postman）访问 http://localhost:8080，Tomcat 会把请求交给你的代码处理。

4.自动配好SpringMVC

Spring MVC 是 Spring 框架的一个模块，全称是 Spring Model-View-Controller，用于构建基于 Java 的 Web 应用程序。它是一个基于 MVC 设计模式的框架，帮助开发者以清晰的方式组织和开发 Web 项目。

MVC 模式：

• Model（模型）：表示数据和业务逻辑，比如数据库中的用户信息或计算结果。
• View（视图）：用户看到的内容，比如网页、JSON 响应。
• Controller（控制器）：接收用户请求，协调 Model 和 View，决定“做什么”和“返回什么”。

Spring MVC 帮你把这三部分组织好，让开发 Web 应用更简单。

Spring MVC 和 Tomcat 的关系

• Tomcat：是 Web 服务器，负责接收 HTTP 请求和发送响应，像“快递员”。

• Spring MVC：是 Web 框架，运行在 Tomcat 里，负责处理请求的逻辑，像“餐厅服务团队”。

• Spring Boot 把两者结合，Tomcat 作为嵌入式服务器，Spring MVC 作为请求处理核心，开发者只管写业务代码。

配置生成对应的类

默认配置：Spring Boot 像个贴心的管家，给你准备了一堆默认设置（比如 Tomcat 端口、文件上传大小），存在各种 Properties 类里（比如 MultipartProperties）。

自定义配置：你觉得默认值不合适，就在 application.properties 里写自己的值（比如改文件上传大小为 10MB）。

绑定到类：Spring Boot 看到你的配置文件，把值“贴”到对应的 Properties 类上（比如 MultipartProperties 的 maxFileSize 变成 10MB）。

创建对象：Spring Boot 把这个配置好的 Properties 类变成一个对象（Bean），放进 Spring 的“工具箱”（IOC 容器），程序随时可以拿来用。

容器

在 Spring Boot（或更广义的 Spring 框架）中，容器指的是 Spring 的 IOC 容器（Inversion of Control Container，控制反转容器），也叫 ApplicationContext。它是一个核心机制，负责管理应用程序中的对象（称为 Bean），包括创建、配置、组装和生命周期管理。

容器就像一个“智能管家”或“工具箱”，专门负责存放和管理你的程序里用到的各种“工具”（对象/Bean）。这些工具可能是你的业务逻辑类、配置类（如 MultipartProperties）、数据库连接等。容器不仅保管这些工具，还会自动帮你把它们组装好、配置好，并在需要时拿出来用。

Spring Boot 基于 Spring 框架，使用的容器是 ApplicationContext（具体实现如 AnnotationConfigApplicationContext）。

当你启动 Spring Boot 应用（运行 main 方法），Spring Boot 会自动创建一个容器。

容器会扫描你的代码（比如标有 @Component、@Service、@Controller 的类）和配置（比如 application.properties），把需要的对象创建并放进去。

容器的组件添加功能如何工作？

Spring 容器通过以下步骤将组件（Bean）添加到自身：

1. 扫描代码

   • 容器启动时，会扫描项目中的类，寻找标有特定注解的类（比如 @Component、@Controller、@Service、@Repository）或通过配置指定的类。
   • Spring Boot 默认扫描主类（带 @SpringBootApplication 的类）所在包及其子包。

2. 识别组件

   • 容器识别哪些类需要变成 Bean。通常通过注解（如 @Component）或 XML/Java 配置指定。
   • 比如，标有 @Controller 的类会被识别为 Web 控制器，标有 @Service 的类会被识别为业务逻辑组件。

3. 创建 Bean

   • 容器为每个识别到的组件创建对象（Bean），并根据需要配置它的属性（比如通过配置文件或依赖注入）。
   • 比如，MultipartProperties 类会被创建为一个 Bean，配置文件中的 spring.servlet.multipart.max-file-size 会绑定到它的字段。

4. 依赖注入

   • 如果一个 Bean 需要依赖其他 Bean（比如 Controller 需要 Service），容器会自动把依赖的 Bean 注入。
   • 比如，用 @Autowired 注解标记的字段，容器会找到对应的 Bean 填充。

5. 存储到容器

   • 创建好的 Bean 会被存到容器中，容器给每个 Bean 分配一个名字（通常是类名首字母小写），程序可以通过名字或类型获取 Bean。

6. 管理生命周期

   ：

   • 容器不仅负责添加组件，还管理 Bean 的生命周期（创建、初始化、使用、销毁）。

---

组件添加的常见方式

Spring 提供了多种方式让类被容器识别并添加为 Bean。以下是主要的添加方式，配以通俗解释：

使用注解（最常见）

Spring 提供了一系列注解，标记在类上后，容器会自动识别并创建 Bean。

• 常用注解
  • @Component：通用组件，表示这个类需要被容器管理。
  • @Controller / @RestController：用于 Web 控制器，处理 HTTP 请求。
  • @Service：用于业务逻辑层。
  • @Repository：用于数据访问层（比如数据库操作）。
  • @Configuration：用于定义配置类，里面可以声明更多的 Bean。

0字节截断

在JDK7u40后这个得已修复，简单来说这个00截断其实就是因为Java对文件系统部分的实现是用C语言做的处理，C语言中对字符串来说都认为遇到0字节\0就是字符串末尾，因此造成了这个问题。

\0 是 C 语言中表示 空字符（null character）的写法，对应 ASCII 码值为 0 的字符。在 Java 中，它等价于 Unicode 字符 \u0000。