RPC知识杂项

RPC

package-info.java 文件是 Java 语言中的一种特殊文件，它用于提供有关 Java 包（package）的元数据信息。这个文件可以包含包级别的注释、文档信息和其他与包相关的元数据。

/**
 * 这是一个示例包级别的注释文档。
 */
@SomeAnnotation
package com.example.mypackage;

import com.example.SomeAnnotation;

Arrays.asList返回的列表是不可修改的（immutable）列表。这意味着在这个列表上调用add、remove等修改操作会导致UnsupportedOperationException` 异常。

这段代码看起来是使用 JMH（Java Microbenchmarking Harness）进行性能测试的注解配置。JMH 是 Java 专用的微基准测试工具，用于测量和评估 Java 程序的性能。

下面是对你提供的注解的简要解释：

1. @BenchmarkMode({Mode.All}):

   • 指定性能测试的模式。Mode.All 表示使用所有可用的基准测试模式（如Throughput、AverageTime等）。

2. @Warmup(iterations = 3, time = 5, timeUnit = TimeUnit.SECONDS):

   • 设置预热阶段的配置。在性能测试开始之前，JMH 会先运行几个迭代（iterations）来预热 JVM，以避免因为 JIT 编译的影响导致测试结果不准确。time 指定预热阶段的持续时间，单位是秒。

3. @Measurement(iterations = 3, time = 5, timeUnit = TimeUnit.SECONDS):

   • 设置实际测量性能的阶段的配置。iterations 指定测量阶段的迭代次数，time 指定测量阶段的持续时间，单位是秒。

4. @Threads(10000):

   • 指定并发线程的数量。在这里，设置为 10000 个线程。

5. @Fork(1):

   • 指定进行性能测试时 fork 的次数。在这里，设置为 1，表示每个测试运行在单独的 JVM 进程中。

6. @State(Scope.Benchmark):

   • 指定测试类的状态范围。在这里，设置为 Scope.Benchmark，表示每个测试运行时都会创建一个新的实例。

7. @OutputTimeUnit(TimeUnit.SECONDS):

   • 指定输出结果的时间单位，这里设置为秒。

8. @Slf4j:

   • 使用 Lombok 注解，自动生成日志记录器（Logger）。

这些注解配置使得你的测试类能够以指定的配置运行性能测试，并且通过日志记录器（Slf4j）记录相关的信息。确保你的测试方法被正确实现，并且符合 JMH 的规范，以获得准确的性能测量结果。

@PathVariable 是 Spring Framework 中的一个注解，用于从请求路径中获取变量的值。它主要用于处理带有动态参数的 URL 地址，将 URL 中的变量提取出来并作为方法参数进行使用。

在 Spring MVC 中，@PathVariable 的用法如下：

@RequestMapping("/example/{id}")
public String exampleMethod(@PathVariable("id") String id) {
    // 方法体
}

在这个例子中，@PathVariable("id") 注解用于标注方法参数 id，表示从路径中提取名为 “id” 的变量的值。当请求匹配到 “/example/{id}” 路径时，其中的 {id} 部分会被提取出来，然后传递给方法参数 id。

举例来说，如果请求的路径是 “/example/123”，那么 id 的值将是 “123”。

除了基本的用法外，@PathVariable 还支持一些其他的配置项，例如指定默认值、正则表达式匹配等。

@RequestMapping("/example/{id}/{name}")
public String exampleMethod(
    @PathVariable("id") String id,
    @PathVariable("name") String name,
    @PathVariable(value = "age", required = false) Integer age) {
    // 方法体
}

在这个例子中，有两个路径变量 “id” 和 “name”，还有一个可选的路径变量 “age”，其中 “age” 是可选的，因为设置了 required = false。这样，请求 “/example/123/Alice” 可以匹配这个方法，而请求 “/example/123/Alice/25” 也可以匹配，并且 “age” 的值为 25。

这是 Spring MVC 中使用的两个注解：@RestController 和 @RequestMapping。

1. @RestController：

   • @RestController 是一个组合注解，它相当于 @Controller 和 @ResponseBody 的结合。它表示这个类是一个控制器（Controller），并且处理请求时返回的结果是直接写入 HTTP 响应体而不是渲染到视图。

   @RestController
   public class MyController {
       // Controller methods
   }

2. @RequestMapping：

   • @RequestMapping 用于映射请求路径到相应的处理方法。它可以标注在类级别和方法级别上。
   • 在类级别上，它可以指定该类中所有处理方法的基础路径。
   • 在方法级别上，它用于具体的请求路径映射。

   @RequestMapping("/example")
   public class MyController {
       @RequestMapping("/hello")
       public String hello() {
           return "Hello, World!";
       }
   }

   在这个例子中，类 MyController 的基础路径是 “/example”，而 hello() 方法处理的请求路径是 “/example/hello”。

综合使用这两个注解，可以创建一个处理 HTTP 请求的控制器，并定义请求路径与处理方法的映射关系。例如：

@RestController
@RequestMapping("/api")
public class MyRestController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello from API!";
    }

    @RequestMapping("/greet/{name}")
    public String greet(@PathVariable String name) {
        return "Hello, " + name + "!";
    }
}

在这个例子中，MyRestController 类被标记为 @RestController，基础路径是 “/api”。它包含两个处理方法，分别处理 “/api/hello” 和 “/api/greet/{name}” 的请求路径。 @PathVariable 用于获取路径中的变量值。

package com.wxy.rpc.server.annotation;  
  
import java.lang.annotation.*;  
  
/**  
* Rpc Service 注解，标注该类为服务实现类  
*  
* @author Wuxy  
* @version 1.0  
* @ClassName RpcService  
* @Date 2023/1/6 17:15  
*/  
@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Inherited  
public @interface RpcService {  
  
/**  
* 对外暴露服务的接口类型，默认为 void.class  
*/  
Class<?> interfaceClass() default void.class;  
  
/**  
* 对外暴露服务的接口名（全限定名），默认为 ""  
*/  
String interfaceName() default "";  
  
/**  
* 版本号，默认 1.0  
*/  
String version() default "1.0";  
  
}

看起来这是一个自定义的注解 @RpcService，用于标注类为RPC服务实现类。让我们分析一下这个注解的属性：

1. interfaceClass()：指定对外暴露服务的接口类型，默认为 void.class。这表示该服务可能是没有明确的接口，或者该服务的实现类直接实现了某个接口。
2. interfaceName()：指定对外暴露服务的接口名（全限定名），默认为 ""。如果 interfaceClass 不为 void.class，则通过 interfaceName 可以指定明确的接口名。
3. version()：指定服务的版本号，默认为 "1.0"。在一些RPC框架中，可以根据版本号来管理和调用不同版本的服务。

这个注解可能是在自定义的RPC框架中使用的，用于标识哪些类是RPC服务实现类。通过这个注解，框架可以扫描并注册这些服务，然后提供远程调用的能力。

如果你有与这个注解相关的其他类或者框架的使用说明，可以提供更多上下文，我可以提供更详细的解释。

@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Inherited

这部分是Java注解的元注解，用于定义注解的行为和范围。让我们逐个解释：

1. @Target(ElementType.TYPE)：指定了这个注解可以应用在类、接口、枚举类等类型上。在这里，@RpcService 注解只能标注在类上。
2. @Retention(RetentionPolicy.RUNTIME)：指定了这个注解在运行时保留。这意味着这个注解可以通过反射机制在运行时获取到，这通常是自定义注解用于实现一些运行时处理逻辑的必要条件。
3. @Documented：指定了这个注解应该被 javadoc 工具记录。这样，在生成文档时，使用了这个注解的类的文档中会包含这个注解的信息。
4. @Inherited：指定了这个注解可以被继承。通常情况下，注解不会被子类继承。但是使用 @Inherited 注解后，如果一个类使用了这个注解，它的子类也会继承这个注解。

这些元注解是用于约束 @RpcService 注解的使用方式和生命周期。例如，通过 @Target 约束只能标注在类上，通过 @Retention 约束它在运行时可见，通过 @Inherited 约束它可以被继承。

• random：随机选择一个可用的服务实例。
• roundrobin：轮询选择可用的服务实例。
• leastactive：选择活跃度最低的服务实例。

反射

反射就是把java类中的各种成分映射成一个个的Java对象

在运行期间，一个类，只有一个Class对象产生。

http://t.csdnimg.cn/yAax4

invoke 是 Java 反射机制中的一个方法，用于动态地调用类的方法。具体来说，invoke 方法允许在运行时通过反射调用一个方法，可以是静态方法或实例方法，私有方法或公有方法。

堆和栈是计算机内存中两个重要的区域，它们分别用于存储不同类型的数据和执行不同的任务。

1. 栈（Stack）:

   • 栈是一种线性数据结构，采用后进先出（LIFO）的原则。
   • 主要用于存储方法调用时的局部变量、方法参数、返回地址等信息。
   • 栈的操作是非常快速的，仅涉及栈顶的数据的入栈和出栈操作。
   • 栈的大小通常是有限制的，由系统设置，如果栈溢出了，通常是由于递归调用层次太深或者无限循环。

2. 堆（Heap）:

   • 堆是一种用于动态分配内存的区域，也称为动态内存。
   • 主要用于存储程序运行中动态创建的对象和数据。
   • 堆的大小通常较大，受到系统总内存的限制，动态分配和释放内存的速度较慢。
   • 在堆上分配的内存需要手动释放，否则可能会导致内存泄漏。

3. 区别与用途:

   • 栈是一种有限且相对较小的内存区域，用于存储方法调用时的局部数据，操作速度快。
   • 堆是一种动态分配内存的区域，用于存储程序运行时动态创建的对象和数据，容量较大。

心跳检查在网络通信中起到了多个重要的作用：

1. 连接保活： 在一些长连接的场景中，为了确保连接的稳定性，可以通过定期发送心跳包来检测连接是否正常。如果长时间没有数据交流，服务器或客户端可能会认为连接已经失效，通过心跳检查可以避免因为连接长时间空闲而被关闭。
2. 检测对方存活状态： 心跳检查可以用于检测对方是否存活。通过定期发送心跳包，可以判断连接的另一端是否正常运行，从而及时处理连接异常情况。
3. 网络故障排查： 在复杂的网络环境中，可能会出现网络故障或不稳定的情况。通过心跳检查，可以及时发现连接状态异常，有助于排查网络问题。
4. 释放资源： 在某些情况下，连接异常或失效时需要及时释放相关资源，例如关闭连接、清理缓存等。心跳检查可以在连接异常时触发相应的处理逻辑。

总的来说，心跳检查是一种保障通信稳定性和实时性的机制，特别在长连接的应用场景中更为重要。

---

invoke 是 InvocationHandler 接口中的方法，用于处理动态代理中的方法调用。在动态代理中，当代理对象调用方法时，实际上是调用 invoke 方法。invoke 方法接收三个参数：

1. proxy：代理对象。
2. method：被调用的方法。
3. args：方法的参数。

invoke 方法的主要作用是在真实对象方法执行前后进行一些额外的操作，例如记录日志、性能监控、事务管理等。通常，invoke 方法的实现会调用真实对象的相应方法，并在调用前后执行一些附加逻辑。

在动态代理中，invoke 方法的返回值会成为代理方法的返回值。如果 invoke 方法返回 null，那么代理方法的返回值也是 null。如果 invoke 方法抛出异常，那么代理方法也会抛出异常。

下面是一个简单的例子，演示了 invoke 方法的使用：

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

// 接口
interface Subject {
    void request();
}

// 真实主题类
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 动态代理处理器
class DynamicProxyHandler implements InvocationHandler {
    private Object realSubject;

    public DynamicProxyHandler(Object realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("DynamicProxy: Pre-processing");
        Object result = method.invoke(realSubject, args);
        System.out.println("DynamicProxy: Post-processing");
        return result;
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();

        // 创建动态代理
        Subject proxy = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(),
                new Class[]{Subject.class},
                new DynamicProxyHandler(realSubject)
        );

        // 调用代理对象的方法
        proxy.request();
    }
}

在上述例子中，DynamicProxyHandler 类实现了 InvocationHandler 接口，其中的 invoke 方法负责调用真实对象的 request 方法，并在前后输出一些信息。

---

这段说明是关于 Java 动态代理的基本原理和核心类的解释。让我简要解释一下：

1. InvocationHandler 接口： 该接口定义了一个方法 invoke，在实际使用时，它接收三个参数：Object obj 代表代理类，Method method 代表被代理的方法，Object[] args 代表该方法的参数数组。该方法在动态代理类中被实现，负责处理被代理方法的调用。
2. Proxy 类： 该类是动态代理的核心类。它的构造函数 protected Proxy(InvocationHandler h) 接收一个 InvocationHandler 对象，用于给内部的 h 赋值。Proxy 类中的 getProxyClass 方法用于获取一个代理类，其中 loader 是类装载器，interfaces 是真实类所拥有的全部接口的数组。newProxyInstance 方法返回代理类的一个实例，返回后的代理类可以当作被代理类使用，可以调用被代理类在接口中声明过的方法。

这些类和接口的组合，使得在运行时动态生成一个类，该类具有与指定接口相同的方法，且这些方法的实现由 InvocationHandler 中的 invoke 方法来定义。这种机制允许在运行时创建代理类，避免了静态代理需要手动编写代理类的繁琐过程。

---

Request和Response

1. 请求（Request）：

   • 一种信息传递的行为，通常由客户端发起，用于向服务器请求某种服务或资源。
   • 请求通常包含客户端需要的信息，如要执行的操作、要访问的资源、参数等。
   • 请求的例子包括浏览器向服务器请求网页、移动应用向服务器请求数据等。

2. 响应（Response）：

   • 对请求的回应，由服务器发起，用于向客户端提供请求的结果或执行的服务。
   • 响应通常包含服务器处理请求的状态、数据等信息。
   • 响应的例子包括服务器返回网页内容、返回API调用的结果等。

在Web开发中，HTTP协议是常用的通信协议，而HTTP请求和响应的结构如下：

• HTTP请求结构：
  • 请求行：包含请求方法（GET、POST等）、请求的URL、HTTP协议版本。
  • 请求头：包含关于请求的一些附加信息，如User-Agent、Host等。
  • 请求体（对于POST请求等有内容的请求）：包含实际发送的数据。
• HTTP响应结构：
  • 状态行：包含HTTP协议版本、状态码和状态描述。
  • 响应头：包含关于响应的一些附加信息，如Content-Type、Content-Length等。
  • 响应体：包含服务器返回的实际数据。

总体而言，请求和响应是网络通信中两个关键的概念，描述了信息在客户端和服务器之间的传递和处理过程。

---

private static final AtomicInteger ai = new AtomicInteger();

AtomicInteger是java.util.concurrent包中的一个原子整数类。在这个代码中，private static final AtomicInteger ai = new AtomicInteger();创建了一个静态的、不可变的AtomicInteger实例，用于生成递增的序列号。

每次调用getSequenceId()方法时，ai.getAndIncrement()会原子地将当前值增加1，并返回增加前的值，用作数据包的序列号。这确保了在多线程环境下，序列号的生成是线程安全的，不会出现竞态条件。

粘包和拆包

1. 粘包（Packet Concatenation）：

   • 定义： 粘包是指发送方发送的多个小数据包被接收方一次性接收，形成一个大的数据包。
   • 原因： 发送方在发送数据时，可能会将多个小的数据包放在一起发送，接收方在接收时无法知道何时是一个完整的数据包，从而导致多个数据包被接收成一个。
   • 影响： 如果不处理粘包，接收方可能无法正确解析数据包，导致数据处理错误。

2. 拆包（Packet Fragmentation）：

   • 定义： 拆包是指发送方发送的一个大的数据包被接收方拆分成多个小的数据包接收。
   • 原因： 发送方在发送数据时，数据包的大小可能大于接收方的缓冲区大小，因此接收方需要将大的数据包拆分成小的数据包进行接收。
   • 影响： 如果不处理拆包，接收方可能无法正确组装数据包，导致数据包解析错误。

在网络通信中，解决粘包和拆包的问题通常需要借助协议或者特定的技术手段。上面提到的 RpcFrameDecoder 类就是使用了长度字段进行帧解码，以解决粘包和拆包问题。通过在数据包中添加长度字段，接收方可以根据长度信息准确地划分出完整的数据包。

以下是一个简单的Java实现的建造者模式的示例代码：

// 产品类
class Product {
    private String part1;
    private String part2;

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                '}';
    }
}

// 抽象建造者接口
interface Builder {
    void buildPart1(String part1);
    void buildPart2(String part2);
    Product getResult();
}

// 具体建造者实现
class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPart1(String part1) {
        product.setPart1(part1);
    }

    @Override
    public void buildPart2(String part2) {
        product.setPart2(part2);
    }

    @Override
    public Product getResult() {
        return product;
    }
}

// 指导者
class Director {
    public void construct(Builder builder, String part1, String part2) {
        builder.buildPart1(part1);
        builder.buildPart2(part2);
    }
}

// 客户端
public class BuilderPatternExample {
    public static void main(String[] args) {
        // 创建具体建造者
        Builder builder = new ConcreteBuilder();
        // 创建指导者
        Director director = new Director();
        // 指导建造者构建产品
        director.construct(builder, "Part1", "Part2");
        // 获取构建好的产品
        Product product = builder.getResult();
        // 打印产品信息
        System.out.println(product);
    }
}

在这个示例中，Product 是要构建的复杂对象，Builder 是抽象建造者接口，ConcreteBuilder 是具体建造者的实现，Director 是指导者，负责使用建造者构建产品。在客户端中，通过指导者和具体建造者来创建最终的产品。这样的设计允许你通过不同的建造者构建不同的产品，同时保持了产品的构建过程与表示的分离。

链式调用，相当于一个模板，可以换不同的产品。
先构建Product的实体类，在写一个接口类，把这个实体类的属性和方法抽离出来，
写一个实现类，这个类里面有一个new好的Product实体类，里面相当于是getter和setter方法，链式调用的话解返回this，最后还有个返回product。
指导者类：接受product对象和参数即可。

解码、编码

public RpcFrameDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength) { super(maxFrameLength, lengthFieldOffset, lengthFieldLength); }

这个构造函数用于创建一个RpcFrameDecoder实例，它是LengthFieldBasedFrameDecoder的子类。以下是参数的解释：

• maxFrameLength：数据帧的最大长度。如果超过这个长度，就会触发LengthFieldBasedFrameDecoder的exceptionCaught方法，通常用于处理解码时的异常情况，比如超出预期的帧长度。

• lengthFieldOffset：长度域的偏移字节数。指的是长度域的起始位置距离整个帧起始位置的字节数。

• lengthFieldLength：长度域的字节数。这个参数指定了长度域的大小。它决定了用来表示数据帧长度的字节数，比如，如果设置为 4，那么长度域将占用 4 个字节，表示一个 32 位的整数。

---

 --------------------------------------------------------------------
| 魔数 (4byte) | 版本号 (1byte)  | 序列化算法 (1byte) | 消息类型 (1byte) |
--------------------------------------------------------------------
| 状态类型 (1byte) | 消息序列号 (4byte) | 消息长度 (4byte) |
--------------------------------------------------------------------
|                   消息内容 (不固定长度)                      |
--------------------------------------------------------------------

这段注释描述了消息的协议格式，每个字段的含义如下：

1. 魔数 (4byte): 用于第一时间判断是否为无效数据包，通常是一个特定的字节序列，这里是wrpc。
2. 版本号 (1byte): 用于表示协议的版本号，这里是1。
3. 序列化算法 (1byte): 用于表示消息体的序列化算法，例如JSON、Kryo等。
4. 消息类型 (1byte): 表示消息的类型，包括请求消息、响应消息、心跳检查请求、心跳检查响应等。
5. 消息状态 (1byte): 表示消息的状态类型，可能用于标识消息处理的状态。
6. 消息序列号 (4byte): 表示消息的序列号，用于唯一标识一次请求-响应的过程。
7. 消息长度 (4byte): 表示消息体的长度，即后续的消息内容字段的字节数。
8. 消息内容 (不固定长度): 实际的消息体内容，长度由前面的消息长度字段指定。

这种消息格式的设计使得协议在传输过程中能够准确解析消息的各个部分，确保消息的完整性和可靠性。不同字段的组合形成一个完整的消息协议，通过这样的方式进行通信，可以有效地在网络中传输各种类型的消息。

Serializable 是 Java 中的一个接口，用于标识一个类的对象可以被序列化。序列化是将对象的状态转换为字节流的过程，而反序列化则是将字节流转换回对象的状态。实现 Serializable 接口的类可以通过序列化将其对象保存到文件、数据库或者通过网络传输。

主要作用包括：

1. 对象持久化： 序列化允许将对象的状态保存到文件或数据库中，以便在程序重新启动时恢复对象的状态。
2. 网络通信： 序列化也常用于在网络中传输对象。例如，通过 Java 的 Socket 进行通信时，可以将对象序列化后通过网络传输，接收方再进行反序列化还原为对象。
3. 分布式系统： 在分布式系统中，不同计算机节点之间需要进行对象的传输，序列化就是一种方便的方式，例如，在使用 Java RMI（远程方法调用）时。

要实现 Serializable 接口，类中的所有成员变量（字段）也必须是可序列化的，或者标记为 transient，表示不参与序列化。这是因为序列化是递归的，会将对象的所有成员变量进行序列化。

Throwable

Throwable 是 Java 中表示可抛出异常的根类，是异常处理机制的核心。Throwable 继承自 Object 类，它有两个主要的子类：Error 和 Exception。

1. Error： 代表着严重的问题，通常是系统无法恢复的错误，比如虚拟机错误、内存溢出等。程序不应该捕获 Error 类及其子类的实例，因为它们表示系统级错误，程序无法通过捕获它们来进行修复。

2. Exception： 是一个更具体的异常类，它包括了程序运行时可能遇到的各种异常情况。Exception 又分为受检查异常（Checked Exception）和非受检查异常（Unchecked Exception）。

   • 受检查异常（Checked Exception）： 继承自 Exception 但不继承自 RuntimeException 的异常。程序在编译时必须对其进行处理，要么通过 try-catch 块捕获并处理，要么在方法声明中使用 throws 关键字声明抛出。
   • 非受检查异常（Unchecked Exception）： 继承自 RuntimeException 或其子类的异常。这类异常通常是由程序错误导致的，程序员应该尽量避免它们的发生。与受检查异常不同，编译器不会强制要求对非受检查异常进行处理，但良好的编程实践通常也会处理它们。

Throwable 类提供了一些重要的方法，如 getMessage() 用于获取异常的详细信息，printStackTrace() 用于打印异常堆栈信息等。在实际编程中，通常使用 Exception 的子类来表示具体的异常情况。

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR})  
@Retention(RetentionPolicy.SOURCE)  
public @interface Builder {  
String builderMethodName() default "builder";  
  
String buildMethodName() default "build";  
  
String builderClassName() default "";  
  
boolean toBuilder() default false;  
  
AccessLevel access() default AccessLevel.PUBLIC;  
  
String setterPrefix() default "";  
  
@Target({ElementType.FIELD})  
@Retention(RetentionPolicy.SOURCE)  
public @interface Default {  
}  
  
@Target({ElementType.FIELD, ElementType.PARAMETER})  
@Retention(RetentionPolicy.SOURCE)  
public @interface ObtainVia {  
String field() default "";  
  
String method() default "";  
  
boolean isStatic() default false;  
}  
}

这段代码定义了一个 Java 注解 @Builder，用于在编译期间生成与建造者模式相关的代码。让我们逐行解释：

1. @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR}): 指定了注解可以应用的目标元素类型，包括类、方法和构造函数。
2. @Retention(RetentionPolicy.SOURCE): 指定了注解的保留策略，即注解在源代码中有效，而在编译后的类文件和运行时不保留。
3. public @interface Builder: 声明了一个注解类型 Builder。
4. String builderMethodName() default "builder";: 定义了一个 String 类型的成员变量 builderMethodName，表示生成的 Builder 类的方法名，默认值为 “builder”。
5. String buildMethodName() default "build";: 定义了一个 String 类型的成员变量 buildMethodName，表示生成的 Builder 类的构建方法名，默认值为 “build”。
6. String builderClassName() default "";: 定义了一个 String 类型的成员变量 builderClassName，表示生成的 Builder 类的名称，默认为空字符串。
7. boolean toBuilder() default false;: 定义了一个 boolean 类型的成员变量 toBuilder，表示是否生成一个用于构建 Builder 对象的方法，默认值为 false。
8. AccessLevel access() default AccessLevel.PUBLIC;: 定义了一个 AccessLevel 类型的成员变量 access，表示生成的 Builder 类的访问级别，默认为 AccessLevel.PUBLIC。
9. String setterPrefix() default "";: 定义了一个 String 类型的成员变量 setterPrefix，表示生成的 setter 方法的前缀，默认为空字符串。
10. @Target({ElementType.FIELD}): 定义了一个注解类型 Default，表示默认值的注解，应用于字段。
11. @Retention(RetentionPolicy.SOURCE): 定义了注解类型 Default 的保留策略。
12. public @interface ObtainVia { ... }: 定义了一个注解类型 ObtainVia，表示通过字段或参数获取默认值的注解。
13. String field() default "";: 定义了一个 String 类型的成员变量 field，表示通过字段获取默认值时的字段名称，默认为空字符串。
14. String method() default "";: 定义了一个 String 类型的成员变量 method，表示通过方法获取默认值时的方法名称，默认为空字符串。
15. boolean isStatic() default false;: 定义了一个 boolean 类型的成员变量 isStatic，表示获取默认值的方法是否是静态方法，默认值为 false。

总体而言，这个注解用于配置生成 Builder 模式相关代码的各种参数，使得使用者可以根据需要自定义生成的代码的各个方面。

修饰参数： 在方法的参数中使用 final，表示该参数是只读的，方法体内不能修改这个参数的值。

这段代码定义了一个名为 SPI 的注解（Annotation）。下面是对该注解的解释：

• @Target(ElementType.TYPE): 表示该注解仅能用于类（class），具体来说，是用于标注类的声明。
• @Retention(RetentionPolicy.RUNTIME): 表示该注解在运行时可以被通过反射机制读取。这意味着你可以在运行时检查类是否使用了该注解，然后进行相应的处理。
• @Documented: 表示该注解应该包含在生成的 Java 文档中。
• public @interface SPI { }: 定义了一个注解 SPI，该注解本身没有任何成员变量。注解的名字通常被用来表示一种特定的行为或配置。

一般来说，这样的注解在框架中用于标识可插拔的组件或服务提供者接口（Service Provider Interface，SPI）。在运行时，框架可以通过反射机制扫描并加载具有该注解的类，以实现一些动态的配置或扩展机制。

namingService.getAllInstances(serverName)：从 namingService 中获取所有指定服务名（serverName）的实例。

负载均衡 | Apache Dubbo

TreeMap是Java中的一个有序映射（SortedMap）实现，基于红黑树数据结构。它继承自AbstractMap类，并实现了NavigableMap接口。

以下是TreeMap的一些关键特性：

1. 有序性： TreeMap中的元素是有序的，它按照键的自然顺序或者通过构造函数提供的Comparator进行排序。这使得在遍历TreeMap时，元素是按照排序顺序返回的。

2. 红黑树： TreeMap的底层数据结构是一颗红黑树。红黑树是一种自平衡二叉查找树，确保了在插入、删除等操作后，树依然能够保持相对平衡，以保证对数级别的查询、插入和删除复杂度。

3. 键的唯一性： TreeMap中的键是唯一的，每个键只能对应一个值。如果插入一个已经存在的键，新的值将会替代原来的值。

4. NavigableMap接口： TreeMap实现了NavigableMap接口，提供了一系列用于导航映射的方法，比如获取子映射、获取首尾元素等。

ByteArrayOutputStream baos = new ByteArrayOutputStream();  
HessianSerializerOutput hso = new HessianSerializerOutput(baos);  
hso.writeObject(object);  
hso.flush();

这段代码使用了 Hessian 序列化库来将对象序列化为字节数组。让我简单解释一下：

1. ByteArrayOutputStream: 这是 Java 内置的一个字节数组输出流。它的作用是在内存中创建一个字节数组缓冲区，所有通过 write 方法写入的数据都会存储在这个缓冲区中。

2. HessianSerializerOutput: 这是 Hessian 序列化库的类，用于将对象序列化为 Hessian 格式的数据。Hessian 是一种二进制序列化格式，通常用于在网络上传输对象。

3. hso.writeObject(object): 这一行代码调用了 HessianSerializerOutput 的 writeObject 方法，将指定的对象 object 序列化到字节数组输出流中。

4. hso.flush(): 这一行代码调用了 flush 方法，将缓冲区的数据刷新到 ByteArrayOutputStream 中。在序列化过程中，数据通常被先写入缓冲区，最后再刷新到输出流。

综合起来，这段代码的作用是将一个对象使用 Hessian 序列化库序列化为字节数组，并存储在 ByteArrayOutputStream 中。最终，你可以通过 baos.toByteArray() 获取序列化后的字节数组。这通常用于将对象转换为可在网络上传输的形式，或者进行持久化存储。

---

OutputStream 是 Java 中用于写入字节流的抽象类。它的作用是将字节写入输出流，从而实现数据的输出。具体来说，OutputStream 提供了一系列的 write 方法，可以将字节、字节数组等数据写入输出流。

它的工作原理是，当你调用 write 方法写入数据时，数据会被发送到输出流的目的地。这个目的地可以是文件、网络连接、内存缓冲区等。具体的目的地由 OutputStream 的子类实现决定。

例如，在上述提到的代码中，ByteArrayOutputStream 就是 OutputStream 的一个实现，它的作用是将数据写入内存中的字节数组缓冲区。你可以通过调用 toByteArray() 方法获取这个缓冲区中的数据。

总的来说，OutputStream 提供了一个通用的字节输出接口，使得程序可以将字节数据写入不同的目的地，包括文件、网络、内存等。

---

java反射

序列化 — Kryo序列化

假设 ServiceInfo 类有以下属性：

public class ServiceInfo {
    private String serviceName;
    private String address;
    private Integer port;

    // 其他属性和方法省略
}

如果 serviceInfo 的实例的属性值为：

• serviceName: “exampleService”
• address: “192.168.1.100”
• port: 8080

那么通过 toMap 方法，将会生成一个包含键值对的 Map，其内容类似于：

{
    "serviceName": "exampleService",
    "address": "192.168.1.100",
    "port": "8080"
}

请注意，port 的值在 ServiceInfo 中是 Integer 类型，但在 Map 中会被转换为字符串。这是因为 toMap 方法对 port 进行了额外的处理，将其转为字符串类型。

Map

public class MapTest {  
  
private static final Gson gson = new GsonBuilder().create();  
  
public static Map<String, Object> toMap(ServiceInfo serviceInfo) {  
if (serviceInfo == null) {  
return Collections.emptyMap();  
}  
Map map = gson.fromJson(gson.toJson(serviceInfo), Map.class);  
map.put("port", serviceInfo.getPort().toString());  
return map;  
}  
  
public static void main(String[] args) {  
// 创建 ServiceInfo 对象  
ServiceInfo serviceInfo = new ServiceInfo();  
serviceInfo.setServiceName("exampleService");  
serviceInfo.setAddress("localhost");  
serviceInfo.setPort(8080);  
  
// 使用 toMap 方法将 ServiceInfo 转换为 MapMap<String, Object> map = toMap(serviceInfo);  
  
// 打印结果  
System.out.println(map);  
// 运行结果： {serviceName=exampleService, address=localhost, port=8080}}  
  
}

0xfff 是十六进制表示法，它表示的是十六进制数。将 0xfff 转换为十进制，可以按照十六进制到十进制的转换规则进行：

0xfff=15*16^2+15*16^1+15*16^0

Snowflake算法是一种生成分布式唯一ID的算法，通常用于分布式系统中，确保在分布式环境中生成的ID不会重复。Snowflake算法的核心思想是利用一个64位的整数，其中各个部分表示不同的信息。具体结构如下：

• 1位标志位（不使用）： 最高位是一个符号位，正数为0，负数为1。
• 41位时间戳（毫秒级）： 41位可以表示的时间戳数为2^41 - 1，即69年。
• 10位机器ID： 可以分配的机器ID数为2^10 - 1，即1023台机器。
• 12位序列号： 可以生成的序列号为2^12 - 1，即每毫秒可以生成4095个唯一ID。

Snowflake算法的生成过程是：

1. 从当前时间戳获取41位，表示毫秒级的时间戳。
2. 获取机器ID和数据中心ID，分别占用10位，用于区分不同的机器和数据中心。
3. 获取12位序列号，用于在同一毫秒内区分不同的ID。
4. 将上述四部分信息合并成一个64位整数，即生成的唯一ID。

Snowflake算法具有以下特点：

• 唯一性： 在同一时刻，相同机器和数据中心生成的ID是唯一的。
• 有序性： 生成的ID是递增的，因为时间戳是按照毫秒递增的。
• 分布式： 可以在分布式环境中使用，通过不同的机器ID和数据中心ID来保证唯一性。

这种算法简单、高效，并且在很多分布式系统中得到了广泛应用。

spring.factories 是 Spring Boot 中的一个重要的配置文件，用于自动装配和加载 Spring Boot 启动器（starter）、自动配置（auto-configuration）、和一些其他的 Spring 相关组件。该文件通常位于项目的 META-INF 目录下。

具体来说，spring.factories 文件的作用如下：

1. 自动装配（Auto-Configuration）：在 Spring Boot 项目中，自动装配是通过 spring.factories 文件来声明的。该文件中列出了自动配置类的全限定名，这些类包含了一些自动配置的逻辑。Spring Boot 在启动时会自动检测并应用这些自动配置，以简化开发者的配置工作。

2. 启动器（Starter）：启动器是一种依赖，它包含了一组预配置的依赖项，以及一些在 Spring Boot 项目中通常一起使用的库。spring.factories 文件也用于声明启动器。当项目依赖了某个启动器时，其中的配置和依赖项会被自动引入。

3. 其他扩展机制：除了自动装配和启动器之外，spring.factories 还可以用于声明其他 Spring 扩展机制的实现类，如监听器、事件等。

下面是一个简化的 spring.factories 文件示例：

# 自动配置
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.CustomAutoConfiguration,\
com.example.AnotherAutoConfiguration

# 启动器
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example:example-starter:1.0.0

在这个示例中，EnableAutoConfiguration 键后面列出了两个自动配置类的全限定名，以及一个启动器的坐标（groupId:artifactId:version）。

通过使用 spring.factories，Spring Boot 实现了一种基于约定的自动化配置机制，让开发者能够更方便地构建和扩展 Spring Boot 项目。

在Spring框架中，配置类是用来声明配置信息的类。这些类通常使用@Configuration注解进行标记，用于定义Spring容器中的Bean、配置项等。

主要作用包括：

1. 定义Bean： 配置类中可以通过@Bean注解声明Bean，Spring容器会根据这些配置在运行时创建相应的Bean实例。

   @Configuration
   public class MyConfig {
   
       @Bean
       public MyBean myBean() {
           return new MyBean();
       }
   }

2. 外部配置： 配置类可以通过@Value注解等方式引入外部的配置信息，使得配置更加灵活。

   @Configuration
   @PropertySource("classpath:my.properties")
   public class MyConfig {
   
       @Value("${my.property}")
       private String myProperty;
   }

3. 组件扫描： 配置类可以使用@ComponentScan注解启用组件扫描，自动发现和注册Spring组件（包括Bean）。

   @Configuration
   @ComponentScan("com.example")
   public class AppConfig {
       // ...
   }

4. 条件化配置： 通过@Conditional相关注解，可以根据条件选择性地应用某些配置。

   @Configuration
   @ConditionalOnProperty(name = "my.feature.enabled", havingValue = "true")
   public class MyFeatureConfig {
       // ...
   }

5. AOP配置： 配置类可以定义切面、通知等，实现面向切面编程（AOP）。

   @Configuration
   @EnableAspectJAutoProxy
   public class AopConfig {
       // ...
   }

6. 其他配置： 配置类还可以用于配置事务、国际化、缓存等其他方面的配置。

配置类的使用使得应用程序配置更加模块化、可维护，提高了代码的可读性和可测试性。 Spring Boot应用通常会包含一个或多个配置类，用于集中管理应用的配置。