@Test
public void reduce() {
    List<Integer> collect = Stream.iterate(0, integer -> integer + 1).limit(10).collect(Collectors.toList());

    log.info("原数据");
    collect.stream().forEach(System.out::println);

    log.info("总计：{}", collect.stream().reduce((a, b) -> a + b));
    log.info("总计：{}", collect.stream().skip(10).reduce((a, b) -> a + b));
    log.info("总计：{}", collect.stream().skip(10).reduce(0, (a, b) -> a + b));

    log.info("原数据2");
    userList.stream().forEach(System.out::println);
    // 注意：这个写法无法通过编译，Stream的实现类型是 User，而累进器返回的类型是Integer，所以这需要另外使用Integer::sum 做组合操作。
    // userList.stream().reduce(0, (a, b) -> a + b.getAge())
    log.info("总计年龄：{}", userList.stream().reduce(0, (a, b) -> a + b.getAge(), Integer::sum));
}

输出结果

11:42:38.197 [main] INFO top.zsmile.test.basic.stream.StreamTest - 原数据
0
1
2
3
4
5
6
7
8
9
11:42:38.202 [main] INFO top.zsmile.test.basic.stream.StreamTest - 总计：Optional[45]
11:42:38.205 [main] INFO top.zsmile.test.basic.stream.StreamTest - 总计：Optional.empty
11:42:38.206 [main] INFO top.zsmile.test.basic.stream.StreamTest - 总计：0
11:42:38.206 [main] INFO top.zsmile.test.basic.stream.StreamTest - 原数据2
User(name=张三, age=18, roles=[ADMIN, USER])
User(name=李四, age=19, roles=[TEMP:USER])
User(name=王五, age=20, roles=[USER])
11:42:38.207 [main] INFO top.zsmile.test.basic.stream.StreamTest - 总计年龄：57

总结

合理正确的使用 Stream 流，可以给我们带来：

1. 代码简洁。更贴合数据流处理的思想。
2. 逻辑解耦。可以将各个任务分成多段流式进行处理。
3. 延迟执行。只有调用终端方法时，前面编写的中间操作才会执行，避免不必要的操作损耗。

当然也会有些新的问题

1. 调试不方便
2. 需要适应语法，熟悉lambda的使用，才能更高效开发。

• 概述
• 函数式接口
• 什么是lambda
• lambda 使用前提
• 语法
  • 简写
  • 方法引用
• 实战
  • 替代匿名内部类
    • 原理分析
  • 为什么不能修改外部变量
• 总结
• 引用

概述

• 面向对象编程思想
  • 一切事物都是对象。
  • 对象是其属性和操作的封装体。
  • 强调的是对象，必须通过对象的形式来做事，一般情况下会比较复杂。
• 函数编程思想
  • 函数强调的是按照输入量、输出量，使用输入量计算得出输出量。【拿什么东西做什么事情】
  • 同样执行线程任务，使用函数编程思想，可以直接通过传递一段代码给线程对象执行，不需要创建任务对象。

函数式接口

Functional interface 接口也称 SAM 接口，即Single Abstract Method interfaces，有且只有一个抽象方法的接口，但可以有多个非抽象方法的接口。

• 在 Java 8 中专门有一个包放函数式接口java.util.function，该包下的所有接口都有 @FunctionalInterface 注解，提供函数式接口。

• 在其他包中也有函数式接口，其中一些没有 @FunctionalInterface 注解，但是只要符合函数式接口的定义就是函数式接口，与是否有 @FunctionalInterface 注解无关，注解只是在编译时起到强制规范定义的作用。其在 Lambda 表达式中有广泛的应用。例如 Runnable 接口，也是没有使用 @FunctionalInterface 注解

什么是lambda

lambda 表达式，也可以称之为闭包或者匿名函数，是 Java8 引入的新特性。

lambda 允许把函数作为一个方法的参数（函数作为参数传入方法中执行）

lambda 使用前提

1. 必须有相应的函数式接口。函数接口是指有且只有一个抽象方法的接口。

2. 类型推断机制。在上下文信息足够的情况下，编译器可以推断出参数表的类型，而不需要显示指定。也就是方法的参数和局部变量的类型必须为 lambda 对应的接口类型，才能使用 lambda 表达式表示该接口的实例。

语法

简写

(parameters) -> expression
    
(parameters) ->{ statements; }

重要特征：

• **可选类型声明：**不需要声明参数类型，编译器可以统一识别参数值。
• **可选的参数圆括号：**一个参数无需定义圆括号，但多个参数需要定义圆括号。
• **可选的大括号：**如果主体包含了一个语句，就不需要使用大括号。
• **可选的返回关键字：**如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

方法引用

如果我们使用lambda 表达式的时候，如果要执行的表达式只是调用一个类已有的方法，那么就可以用方法引用的方式来替代。

重要特种：

• **引用静态方法：**类名::静态方法名。如果静态方法需要传参数，只要确保参数是一一对应的，编译器会自行推断出来。
• 引用对象方法：对象引用::方法名。如果执行的类是调用 lambda 表达式所在的类的方法时，可以才作用一下写法 this::方法名。
• 引用构造方法：类名::new。

实战

替代匿名内部类

class LambdaTest {
    public static void main(String[] args) {
        // 匿名内部类, Runnable
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程输出");
            }
        });

        // lambda
        Thread thread1 = new Thread(() -> {
            System.out.println("lambda线程输出");
        });
    }
}

原理分析

那么用 lambda 来替代匿名内部类有什么差别呢？我们通过编译一下来看看

# 编译class文件
javac -encoding UTF-8 LambdaTest.java

可以看见产生了两个class文件。

• LambdaTest.class

  
  import top.zsmile.test.basic.lambda.LambdaTest.1;
  
  public class LambdaTest {
      public LambdaTest() {
      }
  
      public static void main(String[] var0) {
          new Thread(new 1());
          new Thread(() -> {
              System.out.println("lambda线程输出");
          });
      }
  }
  

• LambdaTest$1.class。这是一个匿名内部类。

  final class LambdaTest$1 implements Runnable {
      LambdaTest$1() {
      }
  
      public void run() {
          System.out.println("线程输出");
      }
  }
  

那么我们来看看这个代码字节码，看看程序内部是怎么运行的。

javap -c “.\LambdaTest.class”

javap -c “.\LambdaTest$1.class”

这里我们只看主文件的字节码。

Compiled from "LambdaTest.java"
public class top.zsmile.test.basic.lambda.LambdaTest {
  public top.zsmile.test.basic.lambda.LambdaTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Thread
       3: dup
       4: new           #3                  // class top/zsmile/test/basic/lambda/LambdaTest$1
       7: dup
       8: invokespecial #4                  // Method top/zsmile/test/basic/lambda/LambdaTest$1."<init>":()V
      11: invokespecial #5                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
      14: astore_1
      15: new           #2                  // class java/lang/Thread
      18: dup
      19: invokedynamic #6,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
      24: invokespecial #5                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
      27: astore_2
      28: return
}

由这个字节码信息可以分析出：

1. 根据 4: new #3 这行可以看出，这里使用了 LambdaTest$1.class 类，new 了一个新的对象。

2. 根据 19: invokedynamic #6, 0 可以看出，lambda 是通过 invodedynamic 实现的，并且不会生成新的类和对象。 invodedynamic 是 Jvm 提供的一种指令语法。在这里作用是创建并调用 Runnable 接口 run 方法。

   而新增的 invokedynamic 指令，配合新增的方法句柄（Method Handles，它可以用来描述一个跟类型A无关 的方法m的签名，甚至不包括方法名称，这样就可以做到我们使用方法m的签名，但是直接执行的时候调用 的是相同签名的另一个方法b），可以在运行时再决定由哪个类来接收被调用的方法。在此之前，只能使用反射来实现类似的功能。该指令使得可以出现基于Jvm的动态语言，让 Jvm 更加强大。而且在 Jvm 上实现动态调用机制，不会破坏原有的调用机制。这样既很好的支持了Scala、Clojure这些JVM上的动态语言，又可以支持代码里的动态lambda表达式。

   简单来说就是以前设计某些功能的时候把做法写死在了字节码里，后来想改也改不了了。 所以这次给lambda语法设计翻译到字节码的策略是就用invokedynamic来作个弊，把实际的翻译策略隐 藏在Jdk 库的实现里（MetaFactory）可以随时改，而在外部的标准上大家只看到一个固定的 invokedynamic。

3. 既然 lambda 不会生成新的类，那么这里的 this 指向外部类的。简单上个demo。可以看出使用匿名内部类时，this 指向当前类，而 lambda 没有生成新的类，所以指向的外部类，所以无法在静态 static方法中使用，因为 static 方法没有实例对象。

   
   public class LambdaTest {
       public void run(){
           new Thread(new Runnable() {
               @Override
               public void run() 
                   System.out.println(this);
                   System.out.println("线程输出");
               }
           }).start();
   
           // lambda
           new Thread(() -> {
               System.out.println(this);
               System.out.println("lambda线程输出");
           }).start();
       }
   
       public static void main(String[] args) {
           new LambdaTest().run();
       }
   }
   
   // 输出结果
   // top.zsmile.test.basic.lambda.LambdaTest$1@1232cc0
   // 线程输出
   // top.zsmile.test.basic.lambda.LambdaTest@7e8572a1
   // lambda线程输出
   
   

为什么不能修改外部变量

lambda 表达式的局部变量可以不用声明为 final ，但是必须不可被 lambda 内部的代码修改（即具有隐性的 final ）。可是我们有时又能修改局部变量的值，这是为什么呢？

其实这和变量的类型和 final 的作用有关联，如果我们使用一些常用的类型。例如：

• 基础类型：int,float等
• 简单引用类型：String，Integer等
• 复杂对象引用
• 静态类型引用

上个简单的例子说明一下；

public class LambdaTest {
    public void run() {
        String fff = "";
        new Thread(() -> {
            this.name = "456";
//                fff="456";
            //Variable used in lambda expression should be final or effectively final
            System.out.println(this.name);
            System.out.println("lambda线程输出");
        }).start();
    }
}

这里提到了 final or effectively final。

对于一个变量，如果没有给它加final修饰，而且没有对它的二次赋值，那么这个变量就是effectively final(有效的不会变的)，如果加了final那肯定是不会变了哈。

那么如果我们想要在内部更改外部的属性，有什么方式？

1. 使用对象的属性
2. 使用引用的属性
3. 使用静态的属性

总结

lambda 的优点：

• 简化了部分的写法，使代码更为简洁紧凑
• 减少匿名内部类的创建，节省内存开支
• 不需要记忆所使用的接口和抽象函数

lambda 的缺点：

• 易读性较差，阅读代码的人需要熟悉 lambda 表达式和抽象函数中参与的类型。
• 不具备匿名内部类可扩展的特性

引用

• https://www.oracle.com/java/technologies/java8.html
• https://mp.weixin.qq.com/s?__biz=MjM5MDE0Mjc4MA==&mid=2651144680&idx=5&sn=cea5cf2b8748e4e94894558914bf26ec&chksm=bdb8b9bb8acf30ad90011a970dd18acbe2be555609d348601d76d566e4be7e4aad2b6c719e7a&scene=27#wechat_redirect
• https://www.infoq.cn/article/LlrBgvdmYPGNsVDOZuCZ
• https://xie.infoq.cn/article/a7a4b91228653c64f866367ca
• https://mp.weixin.qq.com/s?__biz=MzAxODcyNjEzNQ==&mid=2247550085&idx=5&sn=d13402dde3e283ce0140515d6347873f&chksm=9bd3a91daca4200bae75e718a36fc5aaa85f19d03f6436f1c64f86b6d1848051c4a9f6414754&scene=27#wechat_redirect
• https://xie.infoq.cn/article/b47fa71dff45feb333a31c6dc
• https://blog.csdn.net/qq_31635851/article/details/116484594

• 消除if-else
  • 消除单个IF-else
  • 消除多个if-else

消除if-else

消除单个IF-else

1. 定义函数式接口

创建一个名为IfElseFunction的函数式接口，接口的参数为两个Runnable接口。这两个两个Runnable接口分别代表了为true或false时要进行的操作。

2. 编写判断方法

在里面设置了一个静态方法 isTrueOrFalse，接收 boolean 类型传参，并返回 IfElseFunction 函数接口。

@FunctionalInterface
public interface IfElseFunction {

    void trueOrFalseHandle(Runnable trueRun, Runnable falseRun);

    static IfElseFunction isTrueOrFalse(boolean bool) {

        return (tr, fr) -> {
            if (bool) {
                tr.run();
            } else {
                fr.run();
            }
        };
    }
}

3. 使用方式

@Test
public void test4() {
    // 判断是否
    IfElseFunction.isTrueOrFalse(true).trueOrFalseHandle(() -> {
        System.out.println("我是对的");
    }, () -> {
        System.out.println("我是错的");
    });

    // 可以稍微转换一下，用来判断空值并做操作
    String name = null;
    IfElseFunction.isTrueOrFalse(name != null).trueOrFalseHandle(() -> {
        System.out.println("我的名字是：" + name);
    }, () -> {
        System.out.println("我不知道我的名字");
    });
}

消除多个if-else

还是用静态方法 IfElseFunction 接口，我们稍微改写一下使用方式即可。这里面可以看出使用了策略模式。

private static Map<String, Runnable> map;

@Before
public void before() {
    map = new HashMap<>();
    map.put("A", () -> {
        System.out.println("I’m A");
    });
    map.put("B", () -> {
        System.out.println("I’m B");
    });
    map.put("C", () -> {
        System.out.println("I’m C");
    });
    map.put("D", () -> {
        System.out.println("I’m D");
    });
}

@Test
public void test5() {
    String searchKey = "F";
    IfElseFunction.isTrueOrFalse(map.get(searchKey) != null).trueOrFalseHandle(map.get(searchKey), () -> {
        System.out.println("找不到用户");
    });
}

• 前言
• 生产型 Supplier
  • 案例
• 消费型 Consumer
  • 案例_accept
  • 案例_andThen
• 判断型 Predicate
  • 案例_test
  • 案例_negate
  • 案例_and
  • 案例_or
• 类型转换 Function
  • 案例_apply
  • 案例_compose
  • 案例_andThen

前言

在 lambda 中了解了什么是函数式接口，以及 @FunctionalInterface 注解。

我们知道函数式接口中，有且只有一个抽象方法的接口，但可以有多个非抽象方法的接口。

而 @FunctionalInterface 注解是可以检查一个接口是否为函数式接口。只是在编译时强制规范使用。 如果接口是函数接口，编译通过；如果不是，编译失败。

我们自定义函数式接口时，@FuncationalInterface 注解是可选的，就算我们不写这个注解，只要保证是函数式接口也是可以的。但是建议加上。

Java 8 在 java.util.function 包下预定了大量的函数式接口供我们使用。常用的有：

• 生产型 Supplier 接口
• Function 接口
• Consumer 接口
• Predicate 接口

生产型 Supplier

java.util.function.Supplier<T> 接口仅包含一个无参的方法 T get()。用来获取一个泛型参指定类型的对象数据。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

案例

@Test
public void test() {
    String string = supplierGet(() -> {
        return "supplier test";
    });
    System.out.println(string);
}

private static <T> T supplierGet(Supplier<T> sup) {
	return sup.get();
}

消费型 Consumer

java.util.function.Consumer<T> 接口与 Supplier 接口相反，它是消费一个数据，不产生输出，其类型是一个泛型。Consumer 中包含抽象方法void accept(T t) 意思接受一个指定泛型的数据进行处理，此外还有一个默认实现方法 Consumer<T> andThen(Consumer<? super T> after)。

@FunctionalInterface
public interface Consumer<T> {
    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

案例_accept

@Test
    public void test() {
        consumerAccept("qweqweqwe", (item) -> {
            String s = new StringBuilder(item.toString()).reverse().toString();
            System.out.println(s);
        });
    }

    private static <T> void consumerAccept(T name, Consumer<T> com) {
        com.accept(name);
    }
}

这里无论 Consumer 都会将其做一次反转后，进行打印。

案例_andThen

@Test
public void test2() {
    consumerAndThen("qwE123", (item) -> {
        System.out.println("先执行了我");
        String s = new StringBuilder(item.toString()).reverse().toString();
        System.out.println(s);
    }, item -> {
        System.out.println("后执行了我");
        String s = item.toUpperCase().toLowerCase();
        System.out.println(s);
    });
}

private static <T> void consumerAndThen(T name, Consumer<T> com, Consumer<T> com2) {
    com.andThen(com2).accept(name);
}

输出结果

先执行了我
321Ewq
后执行了我
qwe123

这里需要注意的点是：

1. 都是对原数据进行了操作，如果是基本类型值不变，如果是引用对象，只修改了引用对象的内部值。
2. 在consumer 内部修改方法剧本变量的值，会提示异常Variable used in lambda expression should be final or effectively final。这是一个隐式的 final。
3. 这里可以做链式消费数据，但是需要主要处理对象的主体。

判断型 Predicate

java.util.function.Predicate<T> 接口是接受一个特定泛型的数据，从而获得一个 boolean 结果。其中包含一个抽象方法 boolean test(T t)， 根据传入参数做检查后，返回true/false。2

@FunctionalInterface
public interface Predicate<T> {
    
    boolean test(T t);
    
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

案例_test

@Test
public void test() {
    boolean checkBool = predicateTest("str", item -> {
        if (item instanceof String) {
            return true;
        }
        return false;
    });
    System.out.println(checkBool);
}

private static <T> boolean predicateTest(T obj, Predicate<T> predicate) {
    return predicate.test(obj);
}

案例_negate

Predicate 提供了一个 negate，意为取反，即将返回boolean进行非处理。

@Test
public void tes2() {
    boolean checkBool = predicateNegate("str", item -> {
        if (item instanceof String) {
            return true;
        }
        return false;
    });
    System.out.println(checkBool);
}

private static <T> boolean predicateNegate(T obj, Predicate<T> predicate) {
    // 等效于 !predicate.test(obj);
    return predicate.negate().test(obj);
}

案例_and

Predicate 接口中有一个方法 and，表示并且关系，同时满足返回 TRUE。

/**
     * 1. 判断是否为String类型
     * 2. 判断是否以STR开始
     * 两个调价你必须同时满足
     */
@Test
public void tes3() {
    boolean checkBool = predicateAnd(Integer.valueOf(123), item -> {
        System.out.println("type");
        if (String.class.isInstance(item) ) {
            return true;
        }
        return false;
    }, item -> {
        System.out.println("starts");
        if (item.toString().toUpperCase().startsWith("STR")) {
            return true;
        }
        return false;
    });
    System.out.println(checkBool);
}

private static <T> boolean predicateAnd(T obj, Predicate<T> predicate, Predicate<T> predicate2) {
    // 等效于 predicate.test(obj) && predicate2.test(obj);
    return predicate.and(predicate2).test(obj);
}

案例_or

Predicate 接口中有一个方法 or，表示或关系，满足一个返回 TRUE。

/**
     * 1. 判断是否为Integer类型
     * 2. 判断是否以STR开始
     * 两个条件满足一个
     */
@Test
public void test4() {
    boolean checkBool = predicateOr(String.valueOf("STR111"), item -> {
        System.out.println("type");
        if (Integer.class.isInstance(item)) {
            return true;
        }
        return false;
    }, item -> {
        System.out.println("starts");
        if (item.toString().toUpperCase().startsWith("STR")) {
            return true;
        }
        return false;
    });
    System.out.println(checkBool);
}

private static <T> boolean predicateOr(T obj, Predicate<T> predicate, Predicate<T> predicate2) {
    // 等效于 predicate.test(obj) || predicate2.test(obj);
    return predicate.or(predicate2).test(obj);
}

类型转换 Function

ava.util.function.Function<T,R> 用来根据一个类型的数据得到另一个类型的数据，前者 T 称为前置条件/传入参数，后者 R 成为后置条件/返回参数。提供了一个最主要的抽象方法 R apply(T t)，根据 T 类型的数据获取 R 类型的结果。使用场景：类型转换。

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

案例_apply

@Test
public void test() {
    Integer integer = functionTest("123123", item -> {
        return Integer.valueOf(item);
    });
    System.out.println(integer);
}

public static <T, R> R functionTest(T obj, Function<T, R> function) {
    return function.apply(obj);
}

案例_compose

接口中的默认方法 compose 用来进行组合操作。传入一个 function 先执行，并将处理结果传入下一个 function

/**
     * 1. 执行apply(4)，将“4” 传入到fc2 转换为 Integer输出
     * 2. 在执行fc1 的apply方法，将Integer 4传入。
     */
@Test
public void test2() {
    Function<Integer, Integer> fc1 = i -> i * 2;
    Function<String, Integer> fc2 = i -> Integer.valueOf(i);
    System.out.println(fc1.compose(fc2).apply("4"));
}

案例_andThen

默认方法 andThen 用来进行组合操作。传入一个 function 后执行，并将处理结果传入下一个 function。与compose 功能相反，andThen 添加到后面执行，compose 插入到前面执行

/**
     * 1. 接收到 int 4 后，乘以2后，得出8返回
     * 2. 将 int 8 传入，转换为 String 返回
     */
@Test
public void test3() {
    Function<Integer, Integer> fc1 = i -> i * 2;
    Function<Integer, String> fc2 = i -> i + "";
    System.out.println(fc1.andThen(fc2).apply(4));
}

• final
  • 用法
• 注意
  • final和static修饰
• 一道面试题分析
  • 分析
  • 方法1（交换p和apple）
  • 方法2（给apple加上final关键字）

final

用法

• 被final修饰的类不可以被继承
• 被final修饰的方法不可以被重写
• 被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.
• 被final修饰的方法,JVM会尝试将其内联,以提高运行效率
• 被final修饰的常量,在编译阶段会存入常量池中

两个重排序规则：

1. 在构造函数内对一个final域的写入,与随后把这个被构造对象的引用赋值给一个引用变量,这两个操作之间不能重排序
2. 初次读一个包含final域的对象的引用,与随后初次读这个final域,这两个操作之间不能重排序。

注意

final和static修饰

用final和static修饰的属性变量（特别是在单例模式），static里面出现trycatch时，需要throw异常，否则会编译错误。

解释： 当属性被static和final同时修饰时，该属性属于类属性（类常量），就是说在类被加载进内存时就需要分配内存（初始化完成）。而构造函数是在被实例化的时候才会执行，对比static代码块是在类被加载的时候执行，且只执行这一次

一道面试题分析

最近看面试题的时候，看到这样一道题目。觉得有意思，就分析了一下看看。

public class FinalStaticClass {
    public static void main(String[] args) {
        System.out.println(Price.P.Price);//result:-2.7
    }
}

class Price {
    /**
     * method1: give apple add final, result:17.3;
     * method2: Swap 18 to 19, result:17.3;
     */
    static Price P = new Price(2.7);
    static double apple = 20;
    double Price;

    public Price(double orange) {
        Price = apple - orange;
    }
}

我们先看一下执行结果。输出2.7

为什么不是17.3呢？让我们先执行一下以下两个指令，生成反汇编文件：

javac .\FinalStaticClass
javap -c -verbose .\FinalStaticClass.class > FinalStaticClass.txt
javap -c -verbose .\Price.class >Price.txt

分析

让我们查看一下Price.txt

// from 75 to 82
0: new           #4                  // class top/zsmile/jvm/base/Price
 3: dup
 4: ldc2_w        #5                  // double 2.7d
 7: invokespecial #7                  // Method "<init>":(D)V
10: putstatic     #8                  // Field P:Ltop/zsmile/jvm/base/Price;
13: ldc2_w        #9                  // double 20.0d
16: putstatic     #2                  // Field apple:D
19: return

// Constant Pool
#1 = Methodref          #11.#25        // java/lang/Object."<init>":()V
#2 = Fieldref           #4.#26         // top/zsmile/jvm/base/Price.apple:D
#3 = Fieldref           #4.#27         // top/zsmile/jvm/base/Price.Price:D
#4 = Class              #28            // top/zsmile/jvm/base/Price
#5 = Double             2.7d
#7 = Methodref          #4.#29         // top/zsmile/jvm/base/Price."<init>":(D)V
#8 = Fieldref           #4.#30         // top/zsmile/jvm/base/Price.P:Ltop/zsmile/jvm/base/Price;
#9 = Double             20.0d

这里可以看出执行过程是：

1. new Price
2. 将double 2.7d 入栈
3. 执行类初始化，构造方法
4. 将double 2.7d 出栈，存入 Price.P
5. 将double 20.0d 入栈
6. 将double 20.0d 出栈，存入 Price.apple

我们可以看出，在执行构造方法计算 Price(D)的时候，apple还没有赋值20。我们知道对于数字基本类型的时候，默认值都为0。于是在执行构造函数的时候，相当于：0-2.7，所以得出结果-2.7。

这是因为在随后的类加载的初始化阶段，由于static代码块执行顺序是由字段在源文件中出现的顺序决定的，所以会先执行new Price(2.7)，分配对象空间并对其做初始化，此时apple的值为0，所以最终结果是-2.7。

那么我们有什么方法解决这个问题？（暂时想到2种）

1. 交换P和apple
2. 给apple 添加关键字final。

方法1（交换p和apple）

交换后，Price代码如下：

class Price {
    static double apple = 20;
    static Price P = new Price(2.7);
    double Price;

    public Price(double orange) {
        Price = apple - orange;
    }
}

// result : 17.3

老规矩生成汇编代码：

javac .\FinalStaticClass
javap -c -verbose .\Price.class >Price2.txt

让我们查看一下Price.txt

// from 75 to 82
 0: ldc2_w        #4                  // double 20.0d
 3: putstatic     #2                  // Field apple:D
 6: new           #6                  // class top/zsmile/jvm/base/Price
 9: dup
10: ldc2_w        #7                  // double 2.7d
13: invokespecial #9                  // Method "<init>":(D)V
16: putstatic     #10                 // Field P:Ltop/zsmile/jvm/base/Price;
19: return

这里我们可以看到：

1. 将20赋值给apple
2. new Price。dup是交换栈的操作，可以看做将栈顶空出。
3. 将2.7赋值给P。
4. 执行构造函数，

方法2（给apple加上final关键字）

添加后，代码如下：

class Price {
    /**
     * method1: give apple add final keyword, result:17.3;
     * method2: Swap 18 to 19, result:17.3;sfsdfsdf
     */
    static Price P = new Price(2.7);
    final static double apple = 20;
    double Price;

    public Price(double orange) {
        Price = apple - orange;
    }
}

javac .\FinalStaticClass
javap -c -verbose .\Price.class >Price3.txt

还是看Price文件。不过这次看两个地方

// from 43 to 46
static final double apple;
descriptor: D
flags: ACC_STATIC, ACC_FINAL
ConstantValue: double 20.0d

// from 74 to 80
0: new           #2                  // class top/zsmile/jvm/base/Price
3: dup
4: ldc2_w        #6                  // double 2.7d
7: invokespecial #8                  // Method "<init>":(D)V
10: putstatic     #9                  // Field P:Ltop/zsmile/jvm/base/Price;
13: return

上面代码我们可以得出：apple已经有初始值了，值为20；static代码中只有存入p和执行构造函数。 也就是说现在构造函数的执行，是 20-2.7=17.3。

因为在类加载过程中，会将类中的字面量存入常量池中。而在遇到final关键字时，在编译时，会为该静态属性赋予ConstantValue属性，ConstantValue的作用是使JVM自动为静态变量赋值。

类变量，有两种方式赋值：

1. 类构造器方法
2. ConstantValue。将会在类加载的准备阶段被赋予所指定的值(这是final static字段必须赋值的原因)

老规矩写的不清晰的地方，可以指出，我会不定时更新和修改。一起加油.

所有的伟大，都来自于一个勇敢的开始。

• 前言
• 作用
• 显式定义
  • 设置字段不参加序列化
• 原理分析
  • SerialVersionUID不是被static变量修饰了吗
• 生成serialVersionUID
  • IDEA设置后，才能自动生成
• 总结

前言

正常情况下，Java 对象都是保存在 Jvm 的堆内存中的，也就是 Jvm 不在了后，对象也会跟着销毁了。

而序列化相当于提供了一种解决方案，让我们可以在 Jvm 停止前，将对象持久化到磁盘上。这样当再次需要这个对象的时候，我们可以从磁盘中读取出来，反序列化为对象使用。

但是序列化和反序列化，不仅要求类实现了 Serializable 或 Externalizable 序列化接口，还取决于类路径以及类属性是否一致，此外还有一个非常重要的一点就是 序列化ID 要求一致，这个序列化ID就是 SerialVersionUID

作用

在进⾏反序列化时， JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进⾏⽐较， 如果相同就认为是⼀致的， 可以进⾏反序列化， 否则就会出现序列化版本不⼀致的异常， 即是InvalidCastException。

当实现java.io.Serializable接口的类没有显式地定义⼀个serialVersionUID变量时候， Java序列化机制会根据编译的Class⾃动⽣成⼀个 serialVersionUID 作序列化版本⽐较⽤， 这种情况下， 如果Class⽂件没有发⽣变化， 就算再编译多次， serialVersionUID 也不会变化的。 但是如果一个Class文件发生变化，那么serialVersionUID 就会发生变化。

也就是说，我们的类实现了 SerialVersion 接口，但是没有定义 SerialVersionUID ，然后序列化。在序列化后，由于某些原因，对类做了变更（比如增加了一个字段），那么重启应用后，对之前序列化的类做反序列化，就会抛出异常。

显式定义

如果我们没有在Class中明确定义一个SerialVersionUID 会有什么问题呢？

先上我们序列化和反序列化代码：

    @Test
    public void serializationTest() {
        SerializationIdClazz serializationClazz = new SerializationIdClazz("SerializationIdClazz", 20);
        try {
            //序列化
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
            objectOutputStream.writeObject(serializationClazz);
            objectOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }

    @Test
    public void deserializationTest() {
        try {
            // 反序列化
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
            SerializationIdClazz newClazz = (SerializationIdClazz) objectInputStream.readObject();
            log.info("反序列化后对象：{}", newClazz);
            objectInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException exception) {
            exception.printStackTrace();
        }
    }

然后是我们测试类。r

@Slf4j
@Data
class SerializationIdClazz implements Serializable {
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;

    /**
     * 构造器
     */
    public SerializationIdClazz(String name) {
        log.info("SerializationIdClazz Construct：name={}", name);
        this.name = name;
    }
    public SerializationIdClazz(String name, Integer age) {
        log.info("SerializationIdClazz Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }
}

不定义 SerialVersionUID ，我们直接进行序列化操作，然后对该类增加一个属性（性别sex）。

@Slf4j
@Data
class SerializationIdClazz implements Serializable {
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别
     */
    private int sex;

    /**
     * 构造器
     */
    public SerializationIdClazz(String name) {
        log.info("SerializationIdClazz Construct：name={}", name);
        this.name = name;
    }

    public SerializationIdClazz(String name, Integer age) {
        log.info("SerializationIdClazz Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }
}

执行结果：

java.io.InvalidClassException: SerializationIdClazz; local class incompatible: stream classdesc serialVersionUID = 3361313294555402592, local class serialVersionUID = -4142228557208270752

抛出了 InvalidClassException 并且前后自动生成的 serialVersionUID 是不一样的。

所以，一旦类实现了Serializable，就建议明确的定义一个serialVersionUID。不然在修改类的时候，就会发生异常。

设置字段不参加序列化

对于不想进行序列化的变量，可以使用 transient 关键字修饰。

transient 关键字的作用是：阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

关于 transient 还有几点注意：

• transient 只能修饰变量，不能修饰类和方法。
• transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。例如，如果是修饰 int 类型，那么反序列后结果就是 0。
• static 变量因为不属于任何对象(Object)，所以无论有没有 transient 关键字修饰，均不会被序列化。

原理分析

我们看一下源码针对于读取时，serialVersionUID 不一致抛 InvalidClassException异常。

s=>start: 开始
e=>end: 结束
readObject=>operation: readObject
readObject0=>operation: readObject0
readOrdinaryObject=>operation: readOrdinaryObject
readClassDesc=>operation: readClassDesc
readNonProxyDesc=>operation: readNonProxyDesc
initNonProxy=>operation: initNonProxy

s->readObject->readObject0->readOrdinaryObject->readClassDesc->readNonProxyDesc->initNonProxy->e

我们直接看异常抛出的关键代码

/**
  * Initializes class descriptor representing a non-proxy class.
  */
void initNonProxy(ObjectStreamClass model,
                  Class<?> cl,
                  ClassNotFoundException resolveEx,
                  ObjectStreamClass superDesc)
    throws InvalidClassException
{
    // 当前model的序列化ID,如果为空则重新计算。
    long suid = Long.valueOf(model.getSerialVersionUID());

    // 省略部分代码
    
    if (model.serializable == osc.serializable &&
        !cl.isArray() &&
        suid != osc.getSerialVersionUID()) {
        throw new InvalidClassException(osc.name,
                                        "local class incompatible: " +
                                        "stream classdesc serialVersionUID = " + suid +
                                        ", local class serialVersionUID = " +
                                        osc.getSerialVersionUID());
    }
}

比较两个serialVersionUID 是否一致。如果不相等则抛出异常。

SerialVersionUID不是被static变量修饰了吗

static 修饰的变量是静态变量，位于方法区，本身是不会被序列化的。 static 变量是属于类的而不是对象。你反序列之后，static 变量的值就像是默认赋予给了对象一样，看着就像是 static 变量被序列化，实际只是假象罢了。

生成serialVersionUID

生成serialVersionUID 的方式主要有2种：

1. 使用默认的1L。

   private static final Long serialVersionUID = 999L;
   

2. 根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段 。可以借助IDE工具生成。

IDEA设置后，才能自动生成

1. 进入 Settings 设置。

2. 在实现了 Serializable 的类使用快捷键 Alt + Enter。

总结

1. 当一个类实现serializable接口时，最好定义serialVersionUID
2. serialVersionUID主要是用来验证版本一致性的。所以兼容升级时，不要修改serialVersionUID。
3. 非兼容升级时，要修改serialVersionUID。但是要做好异常处理。

• 反射对单例的破坏
• 序列化对单例的破坏
• ObjectInputStream
  • 大致流程
  • 核心代码分析
• 防止序列化破坏单例

反射对单例的破坏

测试的单例类：

@Data
class Singleton implements Serializable{
    private volatile static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

测试方法：

@Test
public void test1() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    Singleton instance = Singleton.getInstance();
    Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
    constructor.setAccessible(true);
    Singleton singleton = constructor.newInstance();
    log.info("instance==singleton ==> {}", instance == singleton);
}

输出结果：

ReflexTest - instance==singleton ==> false

我们可以知道反射会破坏单例性，而且这种方式是无法避免的，那么序列化对单例的破坏呢？

序列化对单例的破坏

单例的测试类：

@Data
class Singleton implements Serializable{
    private volatile static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

测试方法：

@Test
public void test2() throws Exception {
    Singleton singleton = Singleton.getInstance();
    try {
        //序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
        objectOutputStream.writeObject(singleton);
        objectOutputStream.close();

        // 反序列化
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
        Singleton newClazz = (Singleton) objectInputStream.readObject();
        log.info("反序列化后对象：{}", newClazz);
        objectInputStream.close();
        log.info("newClazz==singleton ==> {}", newClazz == singleton);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException exception) {
        exception.printStackTrace();
    }
}

输出结果：

ReflexTest - 反序列化后对象：Singleton()
ReflexTest - newClazz==singleton ==> false

通过对 Singleton 的序列化和反序列化，生成了一个新的对象，破坏了 Singleton 的单例性。那么我们可以通过深入理解一下反序列化过程中发生了什么？ObjectInputStream 如何起作用的？

ObjectInputStream

分析一下 ObjectInputputStream 的 readObject 方法执行情况到底是怎样的。

大致流程

st=>start: 开始
e=>end: 结束
readObject=>operation: readObject
readObject0=>operation: readObject0
switchType=>condition: 判断类别为对象 TC_OBJECT
readObject=>operation: readObject
op=>operation: 其它操作
readOrdinaryObject=>operation: readOrdinaryObject

st->readObject->readObject0->switchType
switchType(yes)->readOrdinaryObject->e
switchType(no)->op

核心代码分析

// readOrdinaryObject
private Object readOrdinaryObject(boolean unshared)
    throws IOException
{
    if (bin.readByte() != TC_OBJECT) {
        throw new InternalError();
    }

    // 检查引用的类实例是否允许反序列化
    ObjectStreamClass desc = readClassDesc(false);
    desc.checkDeserialize();

    // 加载类
    Class<?> cl = desc.forClass();
    if (cl == String.class || cl == Class.class
        || cl == ObjectStreamClass.class) {
        throw new InvalidClassException("invalid class descriptor");
    }

    
    Object obj;
    try {
        // 类是否可以在运行时进行初始化，可以则调用初始化，这里就会破坏单例模式
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {
        throw (IOException) new InvalidClassException(
            desc.forClass().getName(),
            "unable to create instance").initCause(ex);
    }

    passHandle = handles.assign(unshared ? unsharedMarker : obj);
    ClassNotFoundException resolveEx = desc.getResolveException();
    if (resolveEx != null) {
        handles.markException(passHandle, resolveEx);
    }

    // 如果类描述符实现了 Externalizable 接口，则调用 readExternalData 进行读取数据。
    if (desc.isExternalizable()) {
        readExternalData((Externalizable) obj, desc);
    } else {
        readSerialData(obj, desc);
    }

    handles.finish(passHandle);

    // 如果 hasReadResolveMethod 检查是否设置了 readResolve方法
    if (obj != null &&
        handles.lookupException(passHandle) == null &&
        desc.hasReadResolveMethod())
    {
        // 调用readResolve方法
        Object rep = desc.invokeReadResolve(obj);
        if (unshared && rep.getClass().isArray()) {
            rep = cloneArray(rep);
        }
        // 过滤替换对象
        if (rep != obj) {
            // Filter the replacement object
            if (rep != null) {
                if (rep.getClass().isArray()) {
                    filterCheck(rep.getClass(), Array.getLength(rep));
                } else {
                    filterCheck(rep.getClass(), -1);
                }
            }
            handles.setObject(passHandle, obj = rep);
        }
    }

    return obj;
}

这里简单做一个小结：

1. 反序列化的时候，会先检查一下类型是什么？如果是Object方法，就会调用readOrdinaryObject方法，如果是其他类型，就调用对应的方法，详情可查看 readObject0 方法
2. readOrdinaryObject 方法里面会先读取类描述，然后检查类是否允许反序列化
3. 通过 isInstantiable 的调用检查类是否可以在运行初始化，如果可以就会进行初始化。这里通过反射破坏了单例。
4. 如果类描述符实现了 Externalizable 接口，则调用 readExternalData 进行读取数据。
5. 调用 hasReadResolveMethod 检查是否设置了 readResolve 方法，如果设置了则调用readResolve方法。这里防止序列化破坏

防止序列化破坏单例

修改 Singleton 类增加 readResolve 方法。

@Data
class Singleton implements Serializable {
    private volatile static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // 防止序列化破坏单例
    private Object readResolve(){
        return getInstance();
    }
}

再次调用测试方法，输出结果如下：

ReflexTest - 反序列化后对象：Singleton()
ReflexTest - newClazz==singleton ==> true

• 前言
• 实现
  • Serializable
    • 默认方式
    • transient 关键字
    • 序列化类重写 writeObject 和 readObject 方法
    • writeReplace 和 readResolve 方法
      • writeReplace
      • readResolve
  • Externalizable
  • Serializable VS Externalizable

前言

• 什么是序列化和反序列化

  • Serializatable(序列化)：将 Java 对象转化为字节序列进行传输/保存的过程。
  • DeSerialization(反序列化)：将字节序列转化为 Java 对象。

• 意义

  • 序列化机制允许将实现序列化机制的Java 对象准换回字节序列，这些字节序列可以保存到磁盘上，也通过通过网络传输后，再转换回原来的对象。
  • 该机制使得对象可以脱离程序运行而独立存在。

• 常见用途

  1. 将对象的字节序列保存到磁盘上。 建议：程序里的每个 JavaBean 对象都实现 Serializable 接口
  2. 在网络通信中传输对象的字节序列。

实现

Java 中，对象如果想要实现序列化，必须要实现以下两个接口之一：

• Serializable
• Externalizable

Serializable

Serializable 的序列化和反序列化大致有以下4种，后3种可以提供不同程度（越来越灵活）的序列化。

1. 通过 ObjectOutputStream 和 ObjectInputStream 默认的序列化和反序列化方式
2. 使用 transient 关键字，可选序列化的字段。
3. Serializable 序列化类定义了 writeObject(ObjectOutputStream out) 和 readObject(ObjectInputStream in)，则通过类定义的方法进行操作。
   • private void writeObject(java.io.ObjectOutputStream out) throws IOException；
   • private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
   • private void readObjectNoData() throws ObjectStreamException;
4. Serializable 序列化类定义了 writeReplace 和 readResolve 方法。
   • ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
   • ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

默认方式

// Test Class 

@Slf4j
@Data
class SerializationClazz implements Serializable {
    //    private static String staticVar = "123";
    private static final Long serialVersionUID = 1L;
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别
     */
    private int sex;

    private final String fff = "1";

    private void writeObject(ObjectOutputStream out) throws IOException {
        log.info("writeObject");
        //将名字反转写入二进制流
        out.writeObject(new StringBuffer(this.name).reverse().toString());
        out.writeInt(age);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        log.info("readObject");
        this.name = (String) in.readObject();
        this.age = in.readInt();
    }


    /**
     * 构造器
     */
    public SerializationClazz(String name) {
        log.info("SerializationClazz Construct：name={}", name);
        this.name = name;
    }
    public SerializationClazz(String name, Integer age) {
        log.info("SerializationClazz Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }
    public SerializationClazz(String name, Integer age, int sex) {
        log.info("SerializationClazz Construct：name={},age={},sex={}", name, age, sex);
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}

// Test Function
@Test
public void SerializationTest() {
    SerializationClazz serializationClazz = new SerializationClazz("Serialization", 20);
    try {
        // 序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
        objectOutputStream.writeObject(serializationClazz);
        objectOutputStream.close();
        
		// 反序列化
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
        SerializationClazz newClazz = (SerializationClazz) objectInputStream.readObject();
        log.info("反序列化后对象：{}", newClazz);
        objectInputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException exception) {
        exception.printStackTrace();
    }
}

我们可以看到：

• 这个对象的所有属性（包括private和引用的属性），除了static和final修饰的，都可以被序列化和反序列化。

transient 关键字

使用transient关键字选择不需要序列化的字段。

// Test Class 

@Slf4j
@Data
class SerializationClazz implements Serializable {
    //    private static String staticVar = "123";
    private static final Long serialVersionUID = 1L;
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别
     */
    private transient int sex;

    private void writeObject(ObjectOutputStream out) throws IOException {
        log.info("writeObject");
        //将名字反转写入二进制流
        out.writeObject(new StringBuffer(this.name).reverse().toString());
        out.writeInt(age);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        log.info("readObject");
        this.name = (String) in.readObject();
        this.age = in.readInt();
    }


    /**
     * 构造器
     */
    public SerializationClazz(String name) {
        log.info("SerializationClazz Construct：name={}", name);
        this.name = name;
    }
    public SerializationClazz(String name, Integer age) {
        log.info("SerializationClazz Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }
    public SerializationClazz(String name, Integer age, int sex) {
        log.info("SerializationClazz Construct：name={},age={},sex={}", name, age, sex);
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}

// Test Function
@Test
public void SerializationTest() {
    SerializationClazz serializationClazz = new SerializationClazz("Serialization", 20);
    try {
        // 序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
        objectOutputStream.writeObject(serializationClazz);
        objectOutputStream.close();
        
		// 反序列化
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
        SerializationClazz newClazz = (SerializationClazz) objectInputStream.readObject();
        log.info("反序列化后对象：{}", newClazz);
        objectInputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException exception) {
        exception.printStackTrace();
    }
}

从输出结果，我们可以看出transient修饰的sex属性，Java 序列化的时候，会忽略该字段属性。 对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。

使用 transient 关键字，我们是能很方便的忽略某些字段，但是有时候我们希望进行编解码或者加密时，transient 的灵活度并不能满足我们的要求。

序列化类重写 writeObject 和 readObject 方法

/**
 * Test writeObject and readObject
 */
@Slf4j
@Data
class SerializationClazz2 implements Serializable {
    //    private static String staticVar = "123";
    private static final Long serialVersionUID = 1L;
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别
     */
    private int sex;

    private void writeObject(ObjectOutputStream out) throws IOException {
        log.info("writeObject");
        out.writeObject(new StringBuilder(this.name).reverse());
        out.writeInt(age);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        log.info("readObject");
        this.name = ((StringBuilder) in.readObject()).reverse().toString();
        this.age = in.readInt();
    }

    /**
     * 构造器
     */
    public SerializationClazz2(String name) {
        log.info("SerializationClazz Construct：name={}", name);
        this.name = name;
    }

    public SerializationClazz2(String name, Integer age) {
        log.info("SerializationClazz Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }

    public SerializationClazz2(String name, Integer age, int sex) {
        log.info("SerializationClazz Construct：name={},age={},sex={}", name, age, sex);
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}


// Test Function
@Test
public void SerializationTest2() {
    SerializationClazz2 serializationClazz = new SerializationClazz2("Serialization", 20, 1);
    try {
        //序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
        objectOutputStream.writeObject(serializationClazz);
        objectOutputStream.close();

        // 反序列化
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
        SerializationClazz2 newClazz = (SerializationClazz2) objectInputStream.readObject();
        log.info("反序列化后对象：{}", newClazz);
        objectInputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException exception) {
        exception.printStackTrace();
    }
}

• 通过 ObjectOutputStream 会调用对象的 writeObject 方法，并将要序列化的属性写入。
• 通过 InputOutputStream 会调用对象的 readObject 方法，将序列化值读取出来。需要注意的是这里需要按照写入的顺序进行读取，并且写入的规则是什么样子的，需要按写入规则反转进行读取。
• 我们没有序列化的属性，会在反序列化后填入类型的默认值。

此外，关于 readObjectNoData 方法，我们可以看一下他的使用场景。

1. Serializable对象反序列化时，由于序列化与反序列化提供的类版本不同，序列化的class的super class不同于序列化时的class的super class；
2. 序列化流被篡改时，系统都会调用readObjectNoData()方法来初始化反序列化的对象。

如果发生上述场景的时候，没有定义readObjectNoData，那么就会初始化成类型的默认值；如果这时定义 readObjectNoData，那么 readObjectNoData 会替代 readObject 方法生效。

writeReplace 和 readResolve 方法

writeReplace

在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象。

/**
 * Test writeReplace
 */
@Slf4j
@Data
class SerializationClazz3 implements Serializable {
    //    private static String staticVar = "123";
    private static final Long serialVersionUID = 1L;
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别
     */
    private int sex;

    private Object writeReplace() throws IOException {
        log.info("writeReplace");
        return new SerializationClazz3("writeReplace", 2, 2);
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        log.info("writeObject");
        out.writeObject(this.name);
        out.writeInt(age);
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        log.info("readObject");
        this.name = in.readObject().toString();
        this.age = in.readInt();
    }

    /**
     * 构造器
     */
    public SerializationClazz3(String name) {
        log.info("SerializationClazz3 Construct：name={}", name);
        this.name = name;
    }

    public SerializationClazz3(String name, Integer age) {
        log.info("SerializationClazz3 Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }

    public SerializationClazz3(String name, Integer age, int sex) {
        log.info("SerializationClazz3 Construct：name={},age={},sex={}", name, age, sex);
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}


// Test Func
@Test
public void SerializationTest3() {
    SerializationClazz3 serializationClazz = new SerializationClazz3("Serialization", 222, 1);
    try {
        //序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
        objectOutputStream.writeObject(serializationClazz);
        objectOutputStream.close();

        // 反序列化
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
        SerializationClazz3 newClazz = (SerializationClazz3) objectInputStream.readObject();
        log.info("反序列化后对象：{}", newClazz);
        objectInputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException exception) {
        exception.printStackTrace();
    }
}

输出结果：

SerializationClazz3 - SerializationClazz3 Construct：name=Serialization,age=222,sex=1
SerializationClazz3 - writeReplace
SerializationClazz3 - SerializationClazz3 Construct：name=writeReplace,age=2,sex=2
SerializationClazz3 - writeObject
SerializationClazz3 - readObject
SerializationTest - 反序列化后对象：SerializationClazz3(name=writeReplace, age=2, sex=0)

1. writeReplace先于writeObject执行
2. writeReplace返回的对象可以是任意类型

readResolve

反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。此方法在readeObject后调用。

/**
 * Test readResolve
 */
@Slf4j
@Data
class SerializationClazz4 implements Serializable {
    //    private static String staticVar = "123";
    private static final Long serialVersionUID = 1L;
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 性别
     */
    private int sex;
    
    private Object readResolve() throws IOException {
        log.info("readResolve");
        return new SerializationClazz4("readResolve", 1, 1);
    }

    /**
     * 构造器
     */
    public SerializationClazz4(String name) {
        log.info("SerializationClazz4 Construct：name={}", name);
        this.name = name;
    }

    public SerializationClazz4(String name, Integer age) {
        log.info("SerializationClazz4 Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }

    public SerializationClazz4(String name, Integer age, int sex) {
        log.info("SerializationClazz4 Construct：name={},age={},sex={}", name, age, sex);
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}



// Test Func
@Test
public void SerializationTest4() {
    SerializationClazz4 serializationClazz = new SerializationClazz4("Serialization", 222, 1);
    try {
        //序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
        objectOutputStream.writeObject(serializationClazz);
        objectOutputStream.close();

        // 反序列化
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
        SerializationClazz4 newClazz = (SerializationClazz4) objectInputStream.readObject();
        log.info("反序列化后对象：{}", newClazz);
        objectInputStream.close();
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException exception) {
        exception.printStackTrace();
    }
}

1. 执行顺序readObject 先于 readResolve执行
2. readResolve常用来反序列单例类，保证单例类的唯一性。(详见)

注意：

• readResolve与writeReplace的访问修饰符可以是private、protected、public，如果父类重写了这两个方法，子类都需要根据自身需求重写，这显然不是一个好的设计。
• 通常建议对于final修饰的类重写readResolve方法没有问题；否则，重写readResolve使用private修饰。

Externalizable

Externalizable 继承自 Serializable，使用 Externalizable 接口需要实现 writeExternal 以及 readExternal 方法。

测试类：

@Slf4j
@Data
class ExternalizationClazz implements Externalizable {
    /**
     * 名称
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;

    public void writeExternal(ObjectOutput out) throws IOException {
        log.info("writeExternal");
        out.writeObject(this.name + "writeExternal");
        out.writeInt(age);
    }

    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        log.info("readExternal");
        this.name = in.readObject().toString() + "readExternal";
        this.age = in.readInt();
    }

    private Object writeReplace() throws IOException {
        log.info("writeReplace");
        return new ExternalizationClazz("writeReplace", 2);
    }

    private void writeObject(ObjectOutputStream out) throws IOException {
        log.info("writeObject");
        out.writeObject(this.name + "writeObject");
        out.writeInt(age);
    }


    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        log.info("readObject");
        this.name = in.readObject().toString() + "readObject";
        this.age = in.readInt();
    }


    private Object readResolve() throws IOException {
        log.info("readResolve");
        return new ExternalizationClazz("readResolve", 9);
    }


    /**
     * 构造器
     */
    public ExternalizationClazz(){

    }
    public ExternalizationClazz(String name, Integer age) {
        log.info("ExternalizationClazz Construct：name={},age={}", name, age);
        this.name = name;
        this.age = age;
    }

}

测试方法：

@Test
public void test() {
    ExternalizationClazz clazz = new ExternalizationClazz("Test", 11);
    try {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("out.txt"));
        objectOutputStream.writeObject(clazz);
        objectOutputStream.flush();
        objectOutputStream.close();

        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("out.txt"));
        ExternalizationClazz newClazz = (ExternalizationClazz) objectInputStream.readObject();
        objectInputStream.close();

        log.info("clazz => {}", clazz);
        log.info("newClazz => {}", newClazz);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

输出结果

ExternalizationClazz - ExternalizationClazz Construct：name=Test,age=11
ExternalizationClazz - writeReplace
ExternalizationClazz - ExternalizationClazz Construct：name=writeReplace,age=2
ExternalizationClazz - writeExternal
ExternalizationClazz - readExternal
ExternalizationClazz - readResolve
ExternalizationClazz - ExternalizationClazz Construct：name=readResolve,age=9
ExternalizationTest - clazz => ExternalizationClazz(name=Test, age=11)
ExternalizationTest - newClazz => ExternalizationClazz(name=readResolve, age=9)

可以看出

1. writeObject 和 readReadObject 是 Serializable 接口继承后独有的方法。因此在 Externalizable实现后不起作用，具体可看 readOrdinaryObject 源码

   // 如果类描述符实现了 Externalizable 接口，则调用 readExternalData 进行读取数据。
   if (desc.isExternalizable()) {
       // 调用 readExternal 方法
       readExternalData((Externalizable) obj, desc);
   } else {
       // 调用 readObject 方法
       readSerialData(obj, desc);
   }
   

2. Externalizable 接口的实现方式一定要有默认的无参构造函数。否则会抛出 no valid constructor 异常。

Serializable VS Externalizable

1. Serializable 是标识接口；Externalizable 继承了Serializable 接口，实现该接口需重写 readExternal 和 writerExternal 方法。

   public interface Serializable {
   }
   
   
   public interface Externalizable extends java.io.Serializable {
       void writeExternal(ObjectOutput out) throws IOException;
       void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;   
   }
   

2. Serializable 提供多种方式序列化：

   1. 默认序列化，transient 关键字忽略某些属性序列化
   2. readObject 和 writeObject 方法自定义序列化

   Externalizable只提供了 readExternal 和 writeExternal 方法序列化

   当然还有公共的都能使用的自定义序列化方法 writeReplace 和 readResolve 方法。

3. Serializable 无需无参构造法方法；而 Externalizable 需要提供无参构造方法，否则将抛出 no valid contructor 异常

4. Externalizable 不需要产生序列化ID（ serialVersionUID），而 Serializable 需要产生序列化版本（ serialVersionUID）。这与他们的序列化方式有关。

5. 相比较 Serializable，Externalizable 序列化、反序列化速度更快，内存更低。

6. 大多数场景下推荐使用 Serializable ，而且 Serializable 提供的默认序列方式，可以简化序列化和反序列化操作。而 Externalizable 适用于需要完全控制序列化和反序列化的地方，以及关注性能和效率的地方。

• 前言
• 对比
  • 可读性差
  • 指定年月生成
  • 日期格式化(重点)
    • SimpleDateFormat
    • DateTimeFormatter
  • 线程不安全(重点)
• LocalDateTime使用
  • 创建事件对象
  • 获取年月日时分秒信息
  • 转换类型
  • 修改时间
  • 格式化
  • 反解析
  • 日期间隔(Period)
  • 时间间隔(Duration)
  • 时间比较
• 总结

前言

JDK 8 里面提供了一个新的 LocalDateTime API，加强了对时间的管理。直接可以说就是为了替代 Date 使用。那么我们通过源码了解一下二者有何差异。

对比

可读性差

直接打印，不执行格式化。

Date date = new Date();
LocalDateTime localDateTime = LocalDateTime.now();
log.info("Date => {}, year={}, month={}", date, date.getYear(), date.getMonth());
log.info("LocalDateTime => {}, year={}, month={}", localDateTime, localDateTime.getYear(), localDateTime.getMonthValue());

// 输出结果
Date => Tue Oct 04 15:20:16 CST 2022, year=122, month=9
LocalDateTime => 2022-10-04T15:20:16.709, year=2022, month=10

• Date获取出来的时间不够直观；LocalDateTime可以直观看出当前时间

• Date获取的年份还需要再次计算（加上1900），才能得出正确年份；LocalDateTime可以直接得出当前年份

• Date获取的月份从0计算少一个月；而LocalDateTime获取的月份是准确的。

• 最重要的是：Date里面有很多方法已经被弃用了，而LocalDateTime本身还更多的方法等

  • localDateTime.getDayOfMonth()。获取当前月的第几天
  • localDateTime.getDayOfWeek()。获取当前星期几

指定年月生成

// 指定年月生成对象
Date pointDate = new Date(2022, 1, 1);
LocalDateTime pointDateTime = LocalDateTime.of(2022, 1, 1, 0, 0);
log.info("pointDate => {}", pointDate);
log.info("pointDateTime => {}", pointDateTime);

可以看到 Date 连构造函数都被弃用了，

日期格式化(重点)

// 格式化输出
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
log.info("Date format =>{}", simpleDateFormat.format(date));
log.info("LocalDateTime format =>{}", localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

Date 使用的是SimpleDateFormat，而LocalDateTime 是本身提供了方法。如果仅仅只是用法上的不同，那么无伤大雅。我们来看一下两者有什么区别。

SimpleDateFormat

我们先看SimpleDateFormat的部分源码。

/**
Date formats are not synchronized.
It is recommended to create separate format instances for each thread.
If multiple threads access a format concurrently, it must be synchronized externally.*/

public class SimpleDateFormat extends DateFormat {
    
    /**
     * The {@link Calendar} instance used for calculating the date-time fields
     * and the instant of time. This field is used for both formatting and
     * parsing.
     *
     * <p>Subclasses should initialize this field to a {@link Calendar}
     * appropriate for the {@link Locale} associated with this
     * <code>DateFormat</code>.
     * @serial
     */
    protected Calendar calendar;
    
    // Called from Format after creating a FieldDelegate
    private StringBuffer format(Date date, StringBuffer toAppendTo,
                                FieldDelegate delegate) {
        // Convert input date to time field list
        calendar.setTime(date);
        
        // etc
    }
}

从上面的源代码中可以看出几点。

1. 非线程安全的。官方说明DateForamt不是同步的。建议为每个线程创建单独的格式实例，如果多线程要使用同一个实例，则必须从外部同步它。

2. Calendar 是共享变量，没有做线程安全控制，多个线程同事调用format时，会调用 Calendar.setTime，导致多个线程执行时，会冲突覆盖 Calendar 的值，最终返回错误结果。

3. 由前面两点推断出，如果说每个线程需要一个单独的SimpleDateFormat，那么将会导致创建和销毁对象，开销大。

4. 对SimpleDataFormat 的format和parse方法加同步锁，会导致性能变差。

简而言之，SimpleDateForamt 是需要我们自己来保证多线程安全的。

DateTimeFormatter

既然SimpleDataFormat 是线程不安全的，那么看看 DateTimeFormatter 是怎么样的呢？

/*
 * This class is immutable and thread-safe.
 *
 * @since 1.8
 */
public final class DateTimeFormatter {
	
    
    public static DateTimeFormatter ofPattern(String pattern) {
        return new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter();
    }
    
    /**
     * Completes this builder by creating the formatter.
     *
     * @param locale  the locale to use for formatting, not null
     * @param chrono  the chronology to use, may be null
     * @return the created formatter, not null
     */
    private DateTimeFormatter toFormatter(Locale locale, ResolverStyle resolverStyle, Chronology chrono) {
        Objects.requireNonNull(locale, "locale");
        while (active.parent != null) {
            optionalEnd();
        }
        CompositePrinterParser pp = new CompositePrinterParser(printerParsers, false);
        return new DateTimeFormatter(pp, locale, DecimalStyle.STANDARD,
                resolverStyle, null, chrono, null);
    }

}

• 从类定义上，可以很明显的看出，它是不可变的，而且也是线程安全的。
• 我们调用ofPattern时，最终会调用toFormatter方法，会创建一个新的对象，也就是说，不会使用缓存对象。

简而言之，对象不可变，线程安全，用就完事了。

线程不安全(重点)

其实不单单日期格式化的类是有差别的，单单Date和LocalDateTime本身我们也能更好的取舍。

public class Date
    implements java.io.Serializable, Cloneable, Comparable<Date>{}
    
/*
 * This class is immutable and thread-safe.
 */
public final class LocalDateTime{}

• Date 是可变对象，线程不安全
• LocalDateTime 是不可变对象，线程安全。

LocalDateTime使用

创建事件对象

log.info("==========创建时间对象==========");
// 获取当前时间
LocalDateTime localDateTime = LocalDateTime.now();

// 指定时间
LocalDateTime pointDateTime = LocalDateTime.of(2022, 1, 1, 0, 0);

获取年月日时分秒信息

 log.info("==========获取时间信息==========");
 log.info("Year : {}",localDateTime.getYear());
 log.info("Month : {}",localDateTime.getMonth());
 log.info("Day : {}",localDateTime.getDayOfMonth());
 log.info("Hour : {}",localDateTime.getHour());
 log.info("Minute : {}",localDateTime.getMinute());
 log.info("Second : {}",localDateTime.getSecond());

转换类型

log.info("==========转换时间==========");
log.info("LocalDate : {}",localDateTime.toLocalDate());
log.info("LocalTime : {}",localDateTime.toLocalTime());	

修改时间

PS：修改后会生成新的对象，而不影响原先的对象。

log.info("==========加减时间==========");
log.info("操作年 : {}", localDateTime.plusYears(1));
log.info("操作月 : {}", localDateTime.plusMonths(1));
log.info("操作日 : {}", localDateTime.plusDays(1));
log.info("操作时 : {}", localDateTime.plusHours(1));
log.info("操作分 : {}", localDateTime.plusMinutes(1));
log.info("操作秒 : {}", localDateTime.plusSeconds(1));

log.info("==========设置时间==========");
log.info("操作年 : {}", localDateTime.withYear(2021));
log.info("操作月 : {}", localDateTime.withMonth(1));
log.info("操作日 : {}", localDateTime.withDayOfMonth(1));
log.info("操作时 : {}", localDateTime.withHour(1));
log.info("操作分 : {}", localDateTime.withMinute(1));
log.info("操作秒 : {}", localDateTime.withSecond(1));

格式化

log.info("==========格式化==========");
        log.info("BASIC_ISO_DATE : {}", localDateTime.format(DateTimeFormatter.BASIC_ISO_DATE));
        log.info("ISO_DATE_TIME : {}", localDateTime.format(DateTimeFormatter.ISO_DATE_TIME));
        log.info("自定义 : {}",localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

反解析

log.info("==========反解析==========");
log.info("parse : {}", localDateTime.parse("2021-01,01 11:22-02",DateTimeFormatter.ofPattern("yyyy-MM,dd HH:mm-ss")));

日期间隔(Period)

log.info("==========间隔(Period)==========");
LocalDate beforeLocalDate = LocalDate.of(2021, 1, 1);
LocalDate afterLocalDate = LocalDate.of(2022, 12, 1);
log.info("first : {}", beforeLocalDate);
log.info("sec : {}", afterLocalDate);
Period period = Period.between(beforeLocalDate, afterLocalDate);
log.info("period => {}", period);
log.info("period Year : {}", period.getYears());
log.info("period Month : {}", period.getMonths());
log.info("period Day : {}", period.getDays());
log.info("period TotalMonths : {}", period.toTotalMonths());

时间间隔(Duration)

log.info("==========时间间隔(Duration)==========");
LocalDateTime beforeLocalDateTime = LocalDateTime.of(2021, 1, 1,1,1);
LocalDateTime afterLocalDateTime = LocalDateTime.of(2022, 12, 1,1,1);
log.info("first : {}", beforeLocalDateTime);
log.info("sec : {}", afterLocalDateTime);
Duration duration = Duration.between(beforeLocalDateTime, afterLocalDateTime);
log.info("duration => {}", duration);
log.info("duration to days : {}", duration.toDays());
log.info("duration to hours : {}", duration.toHours());
log.info("duration to millis : {}", duration.toMillis());
log.info("duration seconds : {}", duration.getSeconds());

时间比较

log.info("==========时间比较==========");
log.info("first : {}", beforeLocalDateTime);
log.info("sec : {}", afterLocalDateTime);
log.info("now : {}", localDateTime);
log.info("first isAfter sec: {}", beforeLocalDateTime.isAfter(afterLocalDateTime));
log.info("sec isAfter now: {}", afterLocalDateTime.isAfter(localDateTime));
log.info("first isBefore sec: {}", beforeLocalDateTime.isBefore(afterLocalDateTime));
log.info("sec isBefore now: {}", afterLocalDateTime.isBefore(localDateTime));

总结

官方推出LocalDateTime也是为了能够替代Date使用，尽管网上有些人说性能上Date更好一点，但是LocalDateTime所带来的好处，远不是这一点性能上可以超越的。所以在使用上见仁见智，我本身也更偏向使用LocalDateTime。

• 前言
• 相关概念
  • 什么是JarUrlConnetion
  • jar协议格式
• 功能
  • 获取JarFile
  • 遍历JarEntry
  • 执行class文件
  • Manifest

前言

最近研究关于classloader，实现对模块的热插拔和类替换等功能。然后意外发现一个用于处理JAR包的官方库。

相关概念

什么是JarUrlConnetion

jarUrlConnection通过Jar协议建立一个访问jar包的连接，可以访问这个jar包内部数据

jar协议格式

jar协议的格式如：jar:{archive-url}!/{entry}。

• archive-url是文件地址
• !/是分隔符
• entry是jar包内部的目录或者文件

示例：

• 访问远程http服务器
  • 整个jar包。jar:http://www.zsmile.top/test.jar!/
  • jar包内的文件。jar:http://www.zsmile.top/test.jar!/Hello.class
  • jar包内的目录。jar:http://www.zsmile.top/test.jar!/top/smile/
• 访问本地文件系统
  • 整个jar包。jar:file://E:/test.jar!/
  • jar包内的文件。jar:file://E:/test.jar!/Hello.class
  • jar包内的目录。jar:file://E:/test.jar!/top/smile/

功能

获取JarFile

URL url = new URL("jar:file://E:/test.jar!/");
JarURLConnection conn = (JarURLConnection) url.openConnection();
JarFile jarfile = conn.getJarFile();

遍历JarEntry

Enumeration<JarEntry> entries = jarFile.entries();
while (entries.hasMoreElements()) {
JarEntry jarEntry = entries.nextElement();
System.out.println(jarEntry.getName() + " is directory ：" + jarEntry.isDirectory());
}

执行class文件

// 获取class数据流
 InputStream inputStream = jarFile.getInputStream(jarEntry);
 int available = inputStream.available();
 byte[] bytes = new byte[available];
inputStream.read(bytes);

// 借助classloader的defineClass将byte转换成class对象
Class<?> aClass = defineClass("top.zsmile.jvm.classloader.Hello", bytes, 0, bytes.length);

// 通过反射调用方法
Method method = aClass.getMethod("main", String[].class);
method.invoke(null, (Object) null);

Manifest

Manifest mainfest = jarfile.getManifest();

// 获取并遍历属性
 System.out.println("manifest Attributes:");
Attributes mainAttributes = manifest.getMainAttributes();
Set<Map.Entry<Object, Object>> entries = mainAttributes.entrySet();
for (Map.Entry<Object, Object> entry : entries) {
    System.out.println(entry.getKey() + "=>" + entry.getValue());
}

// 获取并遍历entry(不知道怎么用)
Map<String, Attributes> entries1 = manifest.getEntries();
for (Map.Entry<String, Attributes> entry : entries1.entrySet()) {
    System.out.println(entry.getKey() + "=>" + entry.getValue());
}

// 获取主函数
String mainClassName = manifest.getMainAttributes().getValue(Attributes.Name.MAIN_CLASS);

• 双亲委托
  • 好处
  • 如何理解双亲委派模型的被破化？
    • loadClass
    • 二次破坏
• 相关问题
  • 隔离问题
    • 代码演示
      • 准备两个jar
      • 测试jar隔离
  • 加载不同jar包中公共类
• 引用

双亲委托

其实上图也就几个步骤

1. 先检查类是否已经被加载过
2. 若没有加载则调用父加载器的loadClass()方法进行加载
3. 若父加载器为空则默认使用启动类加载器作为父加载器
4. 如果父类加载失败，抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。

查看loadClass的方法，我们可以看到：

• 当我们遵循双亲委派机制时，自定义的classloader需要实现findClass方法。
• 当我们打破双亲委派机制，则需要实现loadClass方法

好处

• 避免java类的重复加载
• 避免用户自定义的包名类对jvm核心api破坏，保障安全。若是不使用双亲委托，用户可能会意外实现某些核心类（Object）等，导致破坏Jvm的稳定运行。
• 基于JVM标识每个类的唯一性需要与类加载器一同判断，那么我们通过自定义类的方式，可以隔离class使用，提高我们开发灵活性。

如何理解双亲委派模型的被破化？

想要破坏这种机制，那么就自定义一个类加载器，重写其中的loadClass方法，使其不进行双亲委派即可。

在这之前看一下classloader 提供的3个常用方法的区别：

• loadClass() 就是主要进行类加载的方法，默认的双亲委派机制就实现在这个方法中
• findClass() 根据名称或位置加载.class字节码
• defineClass() 把字节码转化为Class。

loadClass

双亲委托模型是在JDK1.2之后出现的。在此之前类加载器和抽象类java.lang.ClassLoader就已经存在了。所以为了向前兼容，JDK1.2之后的java.lang.ClassLoader添加了一个新的protected方法findClass(),(在上面的源代码中也可以看见)。 而在双亲委托模型未设计出前，用户去继承java.lang.ClassLoader的唯一目的就是为了重写loadClass()方法，因为JVM在进行类加载的时候，会调用加载器私有方法loadClassInternal(),而这个方法的唯一逻辑就是去调用自己的loadClass()方法。

private Class loadClassInternal(String name)
        throws ClassNotFoundException
    {
        // For backward compatibility, explicitly lock on 'this' when
        // the current class loader is not parallel capable.
        if (parallelLockMap == null) {
            synchronized (this) {
                 return loadClass(name);
            }
        } else {
            return loadClass(name);
        }
    }

而在JDK1.2双亲委托出现之后，不提倡用户再去覆盖loadClass()方法，而应当把自己的类加载逻辑写到findClass()方法完成加载,在loadClass()方法父类加载失败，则会调用自己的findClass方法完成加载，这样就保证写出来的类加载器是符合双亲委托规则的。

二次破坏

二次破环是该双亲委托模弊端引起的。该模型能很好的解决各个类加载器对基础类的统一问题。因为它们总是作为被用户代码调用的API，但是问题就来了。如果基础类又要调用回用户的代码，该如何实现?。

典型例子：JNDI服务，它的代码由启动类加载器加载(在rt.jar中)，但JNDI目的就是对整个程序的资源进行几种管理和查找，需要调用由每个不同独立厂商实现并且部署在应用程序的ClassPath下的JNDI接口提供者的代码。但是在应用启动时候读取rt.jar包时候，是不认识这些三方厂商定义的类的，那么如何解决？

java设计团队引入了一个新设计：线程上下文类加载器(Thread Context ClassLoader)。这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置，如果创建线程时候，还未设置，将会从父线程中继承一个。如果在应用程序全局范围都没有设置，默认是appClassLoader类加载器。

class Thread implements Runnable {
     ...
    /* The context ClassLoader for this thread */
    private ClassLoader contextClassLoader;
    
@CallerSensitive
    public ClassLoader getContextClassLoader() {
        if (contextClassLoader == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(contextClassLoader,
                                                   Reflection.getCallerClass());
        }
        return contextClassLoader;
    }
    //
     public void setContextClassLoader(ClassLoader cl) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        }
        contextClassLoader = cl;
    }
    /**
     * Returns a reference to the currently executing thread object.
     *
     * @return  the currently executing thread.
     */
    public static native Thread currentThread(); //用于获取当前现在运行程序的线程
...
}

相关问题

隔离问题

大家觉得一个运行程序中有没有可能同时存在两个包名和类名完全一致的类？

JVM 及 Dalvik 对类唯一的识别是 ClassLoader id + PackageName + ClassName，所以一个运行程序中是有可能存在两个包名和类名完全一致的类的。并且如果这两个”类”不是由一个 ClassLoader 加载，是无法将一个类的示例强转为另外一个类的，这就是 ClassLoader 隔离。

java.lang.ClassCastException: android.support.v4.view.ViewPager can not be cast to android.support.v4.view.ViewPager

当碰到这种问题时可以通过 instance.getClass().getClassLoader(); 得到 ClassLoader，看 ClassLoader 是否一样。

代码演示

准备两个jar

编写HelloWord.java文件，并编译文件，打包成HelloWord.jar

package top.zsmile.jvm.classloader;

public class HelloWord {
    public static void sayHello(){
        System.out.println("Hello World1");
    }

    public static void main(String[] args) {
        sayHello();
    }
}

编写HelloWord.java文件，并编译文件，打包成HelloWord-copy.jar

package top.zsmile.jvm.classloader;

public class HelloWord {
    public static void sayHello(){
        System.out.println("Hello World2");
    }

    public static void main(String[] args) {
        sayHello();
    }
}

注意如果填写了包名，则需要在jar包内部填写按照包路径放置class文件。

测试jar隔离

public void isolate() {
    try {
        final String jarPath = "file:/D:\\project\\B.Smile\\geek-study1\\project\\src\\main\\java\\top\\zsmile\\jvm\\classloader\\HelloWord.jar";
        final String jarPath2 = "file:/D:\\project\\B.Smile\\geek-study1\\project\\src\\main\\java\\top\\zsmile\\jvm\\classloader\\HelloWord-copy.jar";
        final String className = "top.zsmile.jvm.classloader.HelloWord";

        ClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL(jarPath)}, getClass().getClassLoader());
        ClassLoader urlClassLoader2 = new URLClassLoader(new URL[]{new URL(jarPath2)}, getClass().getClassLoader());

        System.out.println("HelloWord.jar ======" + urlClassLoader);
        Class<?> aClass = Class.forName(className, true, urlClassLoader);
        runMain(aClass);
//            Object o = aClass.newInstance();
        System.out.println();


        System.out.println("HelloWord2.jar ====== " + urlClassLoader2);
        Class<?> aClass2 = Class.forName(className, true, urlClassLoader2);
        runMain(aClass2);
//            Object o2 = aClass2.newInstance();
        System.out.println();

        System.out.println("judge helloWord.class equals helloWord2.class");
        System.out.println(aClass.equals(aClass2));
    } catch (Exception e) {
        e.printStackTrace();
    }
}


public static void runMain(Class mainClass) {
    try {
        Method main = mainClass.getMethod("main", String[].class);
        main.invoke(null, (Object) null);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }

}

输出结果

HelloWord.jar ======java.net.URLClassLoader@4617c264
Hello World1

HelloWord2.jar ====== java.net.URLClassLoader@5305068a
Hello World2

judge helloWord.class equals helloWord2.class
false

这样我们可以看到不同classloader的class是相互隔离的，这样我们可以基于该机制，实现对class版本的管理。

加载不同jar包中公共类

现在 Host 工程包含了 common.jar, jar1.jar, jar2.jar，并且 jar1.jar 和 jar2.jar 都包含了 common.jar，我们通过 ClassLoader 将 jar1, jar2 动态加载进来，这样在 Host 中实际是存在三份 common.jar，如下图

们怎么保证 common.jar 只有一份而不会造成上面3中提到的 ClassLoader 隔离的问题呢，其实很简单，有三种方式：

1. 我们只要让加载 jar1 和 jar2 的 ClassLoader 的 parent 为同一个 ClassLoader，并且该 ClassLoader 加载过 common.jar，通过上面 1 中我们知道根据双亲委托，最后都会首先被 parentClassLoader加载。
2. 我们重写 jar1 和 jar2 的 ClassLoader，在 loadClass 函数中我们先去某个含有 common.jar 的 ClassLoader 中 load 即可，其实就是把上面的 parentClassLoader 换掉了而已。
3. 在生成 jar1 和 jar2 时把 common.jar 去掉，只保留 host 中一份，以 host ClassLoader 为 parentClassLoader 即可。

引用

• https://www.cnblogs.com/sidesky/p/11385188.html
• https://blog.csdn.net/briblue/article/details/54973413

• 如何排查找不到Jar包的问题？
• 如何排查类的方法不一致的问题？
• 怎么看到加载了哪些类，以及加载顺序？
• 怎么调整或修改ext和本地加载路径？
• 怎么运行期加载额外的jar包或者class呢？

如何排查找不到Jar包的问题？

有时候我们会面临明明已经把某个jar加入到了环境里，可以运行的时候还是找不到。 那么我们有没有一种方法，可以直接看到各个类加载器加载了哪些jar，以及把哪些路径加到了classpath里？答案是肯定的，代码如下：

package top.zsmile.jvm.classloader;

import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;

public class JvmClassLoaderPrintPath {
    public static void main(String[] args) {
        // 启动类加载器
        URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        System.out.println("启动类加载器");
        for (URL url : urls) {
            System.out.println(" ==> " + url.toExternalForm());
        }

        // 扩展类加载器
        printClassLoader("扩展类加载器", JvmClassLoaderPrintPath.class.getClassLoader().getParent());

        // 应用类加载器
        printClassLoader("应用类加载器", JvmClassLoaderPrintPath.class.getClassLoader());
    }


    public static void printClassLoader(String name, ClassLoader CL) {
        if (CL != null) {
            System.out.println(name + " ClassLoader ‐> " + CL.toString());
            printURLForClassLoader(CL);
        } else {
            System.out.println(name + " ClassLoader ‐> null");
        }
    }

    public static void printURLForClassLoader(ClassLoader CL) {
        Object ucp = insightField(CL, "ucp");
        Object path = insightField(ucp, "path");
        ArrayList ps = (ArrayList) path;
        for (Object p : ps) {
            System.out.println(" ==> " + p.toString());
        }
    }

    private static Object insightField(Object obj, String fName) {
        try {
            Field f = null;
            if (obj instanceof URLClassLoader) {
                f = URLClassLoader.class.getDeclaredField(fName);
            } else {
                f = obj.getClass().getDeclaredField(fName);
            }
            f.setAccessible(true);
            return f.get(obj);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

从打印结果，我们可以看到三种类加载器各自默认加载了哪些jar包和包含了哪些 classpath的路径。

如何排查类的方法不一致的问题？

假如我们确定一个jar或者class已经在classpath里了，但是却总是提示 java.lang.NoSuchMethodError ，这是怎么回事呢？很可能是加载了错误的或者重复加载了不同版本的jar包。这时候，用前面的方法就可以先排查一下，加载了具体什么jar，然后是不是不同路径下有重复的class文件，但是版本不一样。

怎么看到加载了哪些类，以及加载顺序？

还是针对上一个问题，假如有两个地方有Hello.class，一个是新版本，一个是旧的， 怎么才能直观地看到他们的加载顺序呢？也没有问题，我们可以直接打印加载的类清 单和加载顺序。

只需要在类的启动命令行参数加上 ‐XX:+TraceClassLoading 或者 ‐verbose 即 可，注意需要加载java命令之后，要执行的类名之前，不然不起作用。例如：

$ java ‐XX:+TraceClassLoading jvm.HelloClassLoader

怎么调整或修改ext和本地加载路径？

从前面的例子我们可以看到，假如什么都不设置，直接执行java命令，默认也会加载 非常多的jar包，怎么可以自定义加载哪些jar包呢？比如我的代码很简单，只加载rt.jar 行不行？答案是肯定的。

java ‐Dsun.boot.class.path="D:\Program Files\Java\jre1.8.0_231\lib\rt.jar"

其中命令行参数 ‐Dsun.boot.class.path 表示我们要指定启动类加载器加载什么， 最基础的东西都在rt.jar这个包了里，所以一般配置它就够了。 参数 ‐Djava.ext.dirs 表示扩展类加载器要加载什么，一般情况下不需要的话可以直接配置为空即可。

怎么运行期加载额外的jar包或者class呢？

简单说就是不使用命令行参数的情况下，怎么用代码来运行时改变加载类的路径和方 式。假如说，在 d:/app/jvm 路径下，有我们刚才使用过的Hello.class文件，怎么在 代码里能加载这个Hello类呢？

• 一个是前面提到的自定义ClassLoader的方式
• 还有一个就是直接在当前 的应用类加载器里，使用 URLClassLoader类的方法addURL，不过这个方法是protected的，需要反射处理一下，然后又因为程序在启动时并没有显示加载Hello类，所以在添加完了classpath以后，没法直接显式初始化，需要使用Class.forName的方式来拿到已经加载的Hello类（Class.forName("jvm.Hello")默认会初始化并执行静态代码块）

package top.zsmile.jvm.classloader;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

public class JvmAppClassLoaderAddUrl {
    public static void main(String[] args) {
        String appPath = "file:/d:/app/";
        URLClassLoader urlClassLoader = (URLClassLoader) JvmAppClassLoaderAddUrl.class.getClassLoader();
        try {
            Method addURL = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);

            addURL.setAccessible(true);
            URL url = new URL(appPath);
            addURL.invoke(urlClassLoader, url);
            Class.forName("top.zsmile.jvm.classloader.Hello"); // 效果跟Class.forName("jvm.Hello").newInstance()一样
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 前言
• 类的声明周期和加载过程
  • 加载
  • 校验
  • 准备
  • 解析
  • 初始化
• 类加载时机
• 类加载器机制
  • 添加引用类的几种方式
• 打印三类加载器的信息
• 自定义类加载示例

前言

写好的代码经过编译变成了字节码，并且可以打包成Jar 文件。
然后就可以让JVM去加载需要的字节码，变成持久代/元数据区上的Class对象，接着 才会执行我们的程序逻辑。
我们可以用java命令指定主启动类，或者是Jar包，通过约定好的机制，JVM就会自动去加载对应的字节码（可能是class文件，也可能是Jar包）。
我们知道Jar包打开后实际上就等价于一个文件夹，里面有很多class文件和资源文件，但是为了方便就打包成zip格式。 当然解压了之后照样可以直接用java命令来执 行。

把Hello.class和依赖的其他文件一起打包成jar文件

示例 1: 将 class 文件和java源文件归档到一个名为hello.jar 的档案中:
jar cvf hello.jar Hello.class Hello.java
示例 2: 归档的同时，通过 e 选项指定jar的启动类 Hello :
jar cvfe hello.jar Hello Hello.class Hello.java

然后通过 ‐jar 选项来执行jar包:

$ java ‐jar hello.jar

按照Java语言规范和Java虚拟机规范的定义, 我们用 “ 类加载 (Class Loading)” 来表示: 将class/interface名称映射为Class对象的一整个过程。 这个过程还可以划分为更具体的阶段: 加载，链接和初始化(loading, linking and initializing)。

类的声明周期和加载过程

（加载，验证，准备，解析，初始化）统称为类加载，（验证、准备、解析）链接

1. 加载：找 Class 文件
2. 校验：验证格式、依赖。验证字节码文件格式(java版本等)
3. 准备：静态字段、方法表
4. 解析：符号解析为引用
5. 初始化：构造器、静态变量复制、静态代码块
6. 使用
7. 卸载

加载

加载阶段也可以称为“装载”阶段。

1. 根据明确知道的class完全限定名, 来获取二进制classfile格式的字节流，简单点说就是 找到文件系统中/jar包中/或存在于任何地方的“ class文件 ”。 如果找不到二进制表示 形式，则会抛出 NoClassDefFound 错误。
2. 装载阶段并不会检查 classfile 的语法和格式。
3. 类加载的整个过程主要由JVM和Java 的类加载系统共同完成， 当然具体到loading 阶 段则是由JVM与具体的某一个类加载器（java.lang.classLoader）协作完成的。

校验

链接过程的第一个阶段是 *校验 ，确保class文件里的字节流信息符合当前虚拟机的要 求，不会危害虚拟机的安全。

1. 校验过程检查 classfile 的语义，判断常量池中的符号，并执行类型检查
2. 主要目的是判断字节码的合法性，比如 magic number, 对版本号进行验证。
3. 这些检查 过程中可能会抛出 VerifyError ， ClassFormatError 或 UnsupportedClassVersionError 。

因为classfile的验证属是链接阶段的一部分，所以这个过程中可能需要加载其他类， 在某个类的加载过程中，JVM必须加载其所有的超类和接口。

• 如果类层次结构有问题（例如，该类是自己的超类或接口,死循环了），则JVM将抛出 ClassCircularityError
• 而如果实现的接口并不是一个 interface，或者声明的超类是一个 interface，也会抛出 IncompatibleClassChangeError 。

准备

这个阶段将会创建静态字段, 并将其初始化为标准默认值(比如 null 或者 0值 )，并分配方法表，即在方法区中分配这些变量所使用的内存空间。

==请注意，准备阶段并未执行任何Java代码。==

public static int i = 1；

*在准备阶段 i 的值会被初始化为0，后面在类初始化阶段才会执行赋值为1； 但是下面如果使用final作为静态常量，某些JVM的行为就不一样了：

public static final int i = 1；

对应常量i，在准备阶段就会被赋值1，其实这样还是比较puzzle，例如其他语言 （C#）有直接的常量关键字const，让告诉编译器在编译阶段就替换成常量，类似于宏指令，更简单。

解析

进入可选的解析符号引用阶段。解析常量池，主要有以下四种：

• 类或接口的解析
• 字段解析
• 类方法解析
• 接口方法解析

简单的来说就是我们编写的代码中，当一个变量引用某个对象的时候，这个引用在 .class 文件中是以符号引用来存储的（相当于做了一个索引记录）。

在解析阶段就需要将其解析并链接为直接引用（相当于指向实际对象）。如果有了直接引用，那引用的目标必定在堆中存在。

加载一个class时,需要加载所有的super类和super接口。

初始化

==JVM规范明确规定, 必须在类的首次“主动使用”时才能执行类初始化==

初始化的过程包括执行：

• 类构造器方法
• static静态变量赋值语句
• static静态代码块

如果是一个子类进行初始化会先对其父类进行初始化，保证其父类在子类之前进行初 始化。所以其实在java中初始化一个类，那么必然先初始化过 java.lang.Object 类，因为所有的java类都继承自java.lang.Object。

只要我们尊重语言的语义，在执行下一步操作之前完成装载，链接和初始化这些 步骤, 如果出错就按照规定抛出相应的错误，类加载系统完全可以根据自己的策略，灵活地进行符号解析等链接过程。
为了提高性能，HotSpot JVM 通常要等到类初始化时才去装载和链接类。 因此， 如果A类引用了B类，那么加载A类并不一定会去加载B类（除非需要进行验证）。
主动对B类执行第一条指令时才会导致B类的初始化，这就需要先完成对B类的装载和链接。

类加载时机

了解了类的加载过程，我们再看看类的初始化何时会被触发呢？JVM 规范枚举了下述 多种触发情况：

• 显式调用类加载
  • 当虚拟机启动时，初始化用户指定的主类，就是启动执行的 main方法所在的类；
  • 当遇到用以新建目标类实例的 new 指令时，初始化 new 指令的目标类，就是new一个类的时候要初始化；
  • 当遇到调用静态方法的指令时，初始化该静态方法所在的类；
  • 当遇到访问静态字段的指令时，初始化该静态字段所在的类；
• 隐式调用类加载
  • 子类的初始化会触发父类的初始化；
  • 如果一个接口定义了 default 方法，那么直接实现或者间接实现该接口的类的初 始化，会触发该接口的初始化；
  • 使用反射 API 对某个类进行反射调用时，初始化这个类，其实跟前面一样，反射调用要么是已经有实例了，要么是静态方法，都需要初始化；
  • 当初次调用 MethodHandle 实例时，初始化该 MethodHandle 指向的方法所在的类。

以下几种情况不会执行类初始化：（可能会加载）

• 通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始 化。
• 定义对象数组，不会触发该类的初始化。
• 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类。
• 通过类名获取Class对象，不会触发类的初始化，Hello.class不会让Hello类初始化。
• 通过Class.forName加载指定类时，如果指定参数initialize为false时，也不会触发类初始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。Class.forName(“jvm.Hello”)默认会加载Hello类。
• 通过ClassLoader默认的loadClass方法，也不会触发初始化动作（加载了，但是不初始化）。

示例：

• 诸如 Class.forName(), classLoader.loadClass() 等Java API, 反射API, 以及 JNI_FindClass 都可以启动类加载。
• JVM本身也会进行类加载。比如在JVM启动时加载核心类，java.lang.Object, java.lang.Thread 等等。

类加载器机制

类加载过程可以描述为“通过一个类的全限定名a.b.c.XXClass来获取描述此类的Class对象”，这个过程由“类加载器（ClassLoader）”来完成。

这样的好处在于，子类加载器可以复用父加载器加载的类。

系统自带的类加载器分为三种：

• 启动类加载器（BootstrapClassLoader）
• 扩展类加载器（ExtClassLoader）
• 应用类加载器（AppClassLoader）

==一般启动类加载器是由JVM内部实现的，在Java的API里无法拿到，但是我们可以侧面看到和影响它。==

后2种类加载器在Oracle Hotspot JVM里，都 是在中 --sun.misc.Launcher-- 定义的，扩展类加载器和应用类加载器一般都继承自 URLClassLoader 类，这个类也默认实现了从各种不同来源加载class字节码转换成 Class的方法。

graph BT
URLClassLoader-->ClassLoader
ExClassLoader-->URLClassLoader
AppClassLoader-->URLClassLoader

1. 启动类加载器（bootstrap class loader）: 它用来加载 Java 的核心类，是用原生C++代码来实现的，并不继承自java.lang.ClassLoader（负责加载JDK中jre/lib/rt.jar里所有的class）。它可以看做是JVM自带的，我们再代码层面无法直接获取到启动类加载器的引用，所以不允许直接操作它， 如果打印出来就是个 null 。举例来说，java.lang.String是由启动类加载器加载的，所以 String.class.getClassLoader()就会返回null。但是后面可以看到可以通过命令行参数影响它加载什么。
2. 扩展类加载器（extensions class loader）：它负责加载JRE的扩展目录，lib/ext 或者由java.ext.dirs系统属性指定的目录中的JAR包的类，代码里直接获取它的父类加载器为null（因为无法拿到启动类加载器）。可以将多个项目共有的jar包放扩展类目录下
3. 应用类加载器（app class loader）：它负责在JVM启动时加载来自Java命令的­ classpath或者­cp选项、java.class.path系统属性指定的jar包和类路径。在应用程序代码里可以通过ClassLoader的静态方法getSystemClassLoader()来获取应用 类加载器。如果没有特别指定，则在没有使用自定义类加载器情况下，用户自定义的类都由此加载器加载。

此外还可以自定义类加载器。如果用户自定义了类加载器，则自定义类加载器都以应 用类加载器作为父加载器。应用类加载器的父类加载器为扩展类加载器。这些类加载 器是有层次关系的，启动加载器又叫根加载器，是扩展加载器的父加载器，但是直接 从ExClassLoader里拿不到它的引用，同样会返回null。

graph BT

ExtClassLoader-->BootstrapClassLoader

AppClassLoader-->ExtClassLoader

CustomClassLoader1-->AppClassLoader

CustomClassLoader2-->AppClassLoader

类加载机制有三个特点：

1. 双亲委托：当一个自定义类加载器需要加载一个类，比如java.lang.String，它很懒，不会一上来就直接试图加载它，而是先委托自己的父加载器去加载，父加载 器如果发现自己还有父加载器，会一直往前找，这样只要上级加载器，比如启动类加载器已经加载了某个类比如java.lang.String，所有的子加载器都不需要自己加载了。如果几个类加载器都没有加载到指定名称的类，那么会抛出ClassNotFountException异常。
2. 负责依赖：如果一个加载器在加载某个类的时候，发现这个类依赖于另外几个类或接口，也会去尝试加载这些依赖项。
3. 缓存加载：为了提升加载效率，消除重复加载，一旦某个类被一个类加载器加载，那么它会缓存这个加载结果，不会重复加载。

添加引用类的几种方式

1. 放到 Jdk 目录下的 lib/ext（这是扩展类加载器的加载路径） 或者 -Djava.ext.dirs 指定一个扩展类的目录
2. java -cp/classpath 或者 class文件放到当前路径（应用类加载器）
3. 自定义Classloader加载
4. 拿到当前执行类的classLoader，反射掉哦那个addUrl 方法添加jar或者路径（JDK9无效）

public class JvmAppClassLoaderAddUrl {
    public static void main(String[] args) {
        String appPath = "file:/d:/app/";
        URLClassLoader urlClassLoader = (URLClassLoader) JvmAppClassLoaderAddUrl.class.getClassLoader();
        try {
            Method addURL = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);

            addURL.setAccessible(true);
            URL url = new URL(appPath);
            addURL.invoke(urlClassLoader, url);
            Class.forName("top.zsmile.jvm.classloader.Hello"); // 效果跟Class.forName("jvm.Hello").newInstance()一样
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

jdk9以后应用类加载器、扩展类加载器和URL加载器，这三个是平级的了。不能存在一个继承关系。所以无法将应用类加载器和扩展类加载器转换成URLClassLoader。

但是呢提供了另一种方式，将上面繁杂的代码变得更简单了。

class.forName("top.zsmile.jvm.classloader.Hello")",new UrlClassLoader());

在JDK9中，整个JDK都基于模块化进行构建，以前的rt.jar, tool.jar被拆分成数十个模块，编译的时候只编译实际用到的模块，同时各个类加载器各司其职，只加载自己负责的模块。

打印三类加载器的信息

public class JvmClassLoaderPrintPath {
    public static void main(String[] args) {
        // 启动类加载器
        URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        System.out.println("启动类加载器");
        for (URL url : urls) {
            System.out.println(" ==> " + url.toExternalForm());
        }

        // 扩展类加载器
        printClassLoader("扩展类加载器", JvmClassLoaderPrintPath.class.getClassLoader().getParent());

        // 应用类加载器
        printClassLoader("应用类加载器", JvmClassLoaderPrintPath.class.getClassLoader());
    }


    public static void printClassLoader(String name, ClassLoader CL) {
        if (CL != null) {
            System.out.println(name + " ClassLoader ‐> " + CL.toString());
            printURLForClassLoader(CL);
        } else {
            System.out.println(name + " ClassLoader ‐> null");
        }
    }

    public static void printURLForClassLoader(ClassLoader CL) {
        Object ucp = insightField(CL, "ucp");
        Object path = insightField(ucp, "path");
        ArrayList ps = (ArrayList) path;
        for (Object p : ps) {
            System.out.println(" ==> " + p.toString());
        }
    }

    private static Object insightField(Object obj, String fName) {
        try {
            Field f = null;
            if (obj instanceof URLClassLoader) {
                f = URLClassLoader.class.getDeclaredField(fName);
            } else {
                f = obj.getClass().getDeclaredField(fName);
            }
            f.setAccessible(true);
            return f.get(obj);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

其中启动类加载器，只能在oraclejdk和 openjdk中获取，其他版本jdk可能不提供这样的接口。

自定义类加载示例

同时我们可以自行实现类加载器来加载其他格式的类，对加载方式、加载数据的格式进行自定义处理，只要能通过classloader返回一个Class实例即可。这就大大增强了加 载器灵活性。

比如我们试着实现一个可以用来处理简单加密的字节码的类加载器，用 来保护我们的class字节码文件不被使用者直接拿来破解。

我们先来看看我们希望加载的一个Hello类：

package jvm; 
public class Hello { 
    static {
        System.out.println("Hello Class Initialized!"); 
    } 
} 

假设这个类的内容非常重要，我们不想把编译到得到的Hello.class给别人，但是我们还是想别人可以调用或执行这个类，应该怎么办呢？一个简单的思路是，我们把这个类的class文件二进制作为字节流先加密一下，然后尝试通过自定义的类加载器来加载加密后的数据。

package jvm; 
import java.util.Base64; 
public class HelloClassLoader extends ClassLoader { 
    public static void main(String[] args) { 
        try { 
            new HelloClassLoader().findClass("jvm.Hello").newInstance(); // 加载并初始化Hello类 
        } catch (ClassNotFoundException e) {      
            e.printStackTrace(); 
        } catch (IllegalAccessException e) { 
            e.printStackTrace(); 
        } catch (InstantiationException e) { 
            e.printStackTrace(); 
        } 
    } 
    @Override 
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String helloBase64 = "yv66vgAAADQAHwoABgARCQASABMIABQKABUAFgcAFwcAGAEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBABJMb2N"+ "hbFZhcmlhYmxlVGFibGUBAAR0aGlzAQALTGp2bS9IZWxsbzsBAAg8Y2xpbml0PgEAClNvdXJjZUZpbGUBAApIZWxsby5qYXZhDAAHAAgHABkMABoAGwEAGEhlb" + "GxvIENsYXNzIEluaXRpYWxpemVkIQcAHAwAHQAeAQAJanZtL0hlbGxvAQAQamF2YS9sYW5nL09iamVjdAEAEGphdmEvbGFuZy9TeXN0ZW0BAANvdXQBABVMamF2" + "YS9pby9QcmludFN0cmVhbTsBABNqYXZhL2lvL1ByaW50U3RyZWFtAQAHcHJpbnRsbgEAFShMamF2YS9sYW5nL1N0cmluZzspVgAhAAUABgAAAAAAAgABAAcACA" + "ABAAkAAAAvAAEAAQAAAAUqtwABsQAAAAIACgAAAAYAAQAAAAMACwAAAAwAAQAAAAUADAANAAAACAAOAAgAAQAJAAAAJQACAAAAAAAJsgACEgO2AASxAAAAAQAK" + "AAAACgACAAAABgAIAAcAAQAPAAAAAgAQ"; 
    
        byte[] bytes = decode(helloBase64); 
        return defineClass(name,bytes,0,bytes.length); 
    } 
    
    public byte[] decode(String base64){
        return Base64.getDecoder().decode(base64);  
    }  
    
}

$ java jvm.HelloClassLoader
Hello Class Initialized!

==需要说明的是两个没有关系的自定义类加载器之间加载的类是不共享的（只共享父类加载器，兄弟之间不共享）==，这样就可以实现不同的类型沙箱 的隔离性，我们可以用多个类加载器，各自加载同一个类的不同版本，大家可以相互之间不影响彼此，从而在这个基础上可以实现类的动态加载卸载，热插拔的插件机制等，具体信息大家可以参考OSGi等模块化技术。

• sun.misc.launcher
  • Launcher初始化
  • ExtClassloader
  • AppClassLoader

sun.misc.launcher

java虚拟机的入口

Launcher初始化

private static URLStreamHandlerFactory factory = new Launcher.Factory();
private static Launcher launcher = new Launcher();
private static String bootClassPath = System.getProperty("sun.boot.class.path");
private ClassLoader loader;
private static URLStreamHandler fileHandler;

public Launcher() {
    Launcher.ExtClassLoader var1;
    try {
        var1 = Launcher.ExtClassLoader.getExtClassLoader();
    } catch (IOException var10) {
        throw new InternalError("Could not create extension class loader", var10);
    }

    try {
        this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
        throw new InternalError("Could not create application class loader", var9);
    }

    Thread.currentThread().setContextClassLoader(this.loader);
    String var2 = System.getProperty("java.security.manager");
    if (var2 != null) {
        SecurityManager var3 = null;
        if (!"".equals(var2) && !"default".equals(var2)) {
            try {
                var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
            } catch (IllegalAccessException var5) {
            } catch (InstantiationException var6) {
            } catch (ClassNotFoundException var7) {
            } catch (ClassCastException var8) {
            }
        } else {
            var3 = new SecurityManager();
        }

        if (var3 == null) {
            throw new InternalError("Could not create SecurityManager: " + var2);
        }

        System.setSecurityManager(var3);
    }

}

从这段Launcher构造器的代码中，我们可以获得一下信息：

1. Launcher初始化了ExtClassLoader 和 AppClassloader，并将ExtClassLoader作为AppClassloader的父加载器（注意这里不是继承关系的）
2. 这里可以看到的是，并没有显式的将BootstrapClassloader作为ExtClassloader的父加载器。但是我们可以从classloader的loadClass方法中看到，会调用native方法，实际就是从BootstrapClassloader获取（因为BootstrapClassloader实际是C++实现，并没有继承Classloader的）
3. 将线程的默认类加载器设置为AppClassloader
4. 这里没有初始化BootstrapClassloader，但可以有这样的代码 System.getProperty("sun.boot.class.path") 来加载一些包。

输出一下System.getProperty("sum.boot.class.path")的内容，我们可以看到就bootstrapClassloader的内容。也可以通过sun.misc.Launcher.getBootstrapClassPath()获取路径信息

 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/lib/resources.jar
 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/lib/rt.jar
 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/lib/sunrsasign.jar
 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/lib/jsse.jar
 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/lib/jce.jar
 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/lib/charsets.jar
 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/lib/jfr.jar
 ==> file:/C:/Program%20Files/Java/jdk1.8.0_201/jre/classes

这里还有初始化一个BootClassPathHolder

private static class BootClassPathHolder {
    static final URLClassPath bcp;

    private BootClassPathHolder() {
    }

    static {
        URL[] var0;
        if (Launcher.bootClassPath != null) {
            var0 = (URL[])AccessController.doPrivileged(new PrivilegedAction<URL[]>() {
                public URL[] run() {
                    File[] var1 = Launcher.getClassPath(Launcher.bootClassPath);
                    int var2 = var1.length;
                    HashSet var3 = new HashSet();

                    for(int var4 = 0; var4 < var2; ++var4) {
                        File var5 = var1[var4];
                        if (!var5.isDirectory()) {
                            var5 = var5.getParentFile();
                        }

                        if (var5 != null && var3.add(var5)) {
                            MetaIndex.registerDirectory(var5);
                        }
                    }

                    return Launcher.pathToURLs(var1);
                }
            });
        } else {
            var0 = new URL[0];
        }

        bcp = new URLClassPath(var0, Launcher.factory, (AccessControlContext)null);
        bcp.initLookupCache((ClassLoader)null);
    }
}

下面是我的分析：

1. 当BootClassPath(即System.getProperty("sum.boot.class.path"))时，执行器读取这些文件并加载成File[]
2. 遍历file[]，判断是否为路径，如果不是路径，则获取上层路径（D:/test/1.jar => D:/test）
3. 当不为null时，将其添加到set（用于去重）并判断是否添加成功。如果添加成功，则进入到MetaIndex.registerDirectory将路径传输进去，读取目录下meta-index(用来提供jvm启动的加载速度)，并添加到jarMap里面。
4. initLookupCache这个方法将查找到的classPath缓存到jvm中。其中null对应到的是bootstrapClassloader。这里后面有时间可以深入一下jvm的源码。

ExtClassloader

这里提取了部分代码

private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
    try {
        return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
            public Launcher.ExtClassLoader run() throws IOException {
                File[] var1 = Launcher.ExtClassLoader.getExtDirs();
                int var2 = var1.length;

                for(int var3 = 0; var3 < var2; ++var3) {
                    MetaIndex.registerDirectory(var1[var3]);
                }

                return new Launcher.ExtClassLoader(var1);
            }
        });
    } catch (PrivilegedActionException var1) {
        throw (IOException)var1.getException();
    }
}
public ExtClassLoader(File[] var1) throws IOException {
    super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
    SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
}
private static URL[] getExtURLs(File[] var0) throws IOException {
    Vector var1 = new Vector();

    for(int var2 = 0; var2 < var0.length; ++var2) {
        String[] var3 = var0[var2].list();
        if (var3 != null) {
            for(int var4 = 0; var4 < var3.length; ++var4) {
                if (!var3[var4].equals("meta-index")) {
                    File var5 = new File(var0[var2], var3[var4]);
                    var1.add(Launcher.getFileURL(var5));
                }
            }
        }
    }

    URL[] var6 = new URL[var1.size()];
    var1.copyInto(var6);
    return var6;
}

这里可以看出几点：

1. ExtClassloader 的父加载器为null
2. 加载路径为java.ext.dirs
3. 初始化方式与BootClassPathHolder有相似的地方，都采用了meta-index记载
4. ExtClassloader 继承了 URLClassloader

AppClassLoader

public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
    final String var1 = System.getProperty("java.class.path");
    final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
    return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
        public Launcher.AppClassLoader run() {
            URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
            return new Launcher.AppClassLoader(var1x, var0);
        }
    });
}

public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
    int var3 = var1.lastIndexOf(46);
    if (var3 != -1) {
        SecurityManager var4 = System.getSecurityManager();
        if (var4 != null) {
            var4.checkPackageAccess(var1.substring(0, var3));
        }
    }

    if (this.ucp.knownToNotExist(var1)) {
        Class var5 = this.findLoadedClass(var1);
        if (var5 != null) {
            if (var2) {
                this.resolveClass(var5);
            }

            return var5;
        } else {
            throw new ClassNotFoundException(var1);
        }
    } else {
        return super.loadClass(var1, var2);
    }
}

这里可以看出：

1. AppClassloader 加载路径为java.class.path
2. 重载了一下loadClass方法
   • 校验class文件
   • 查找类是否存在

• 前言
• JVM内存结构
  • 栈内存的结构
    • 小结
  • 堆内存的结构
    • 堆
    • 非堆
• JMM
  • 背景
  • 简介
• 内存屏障
  • 背景（CPU指令与乱序执行）
  • 作用
• 总结

前言

==Jvm是一个完整的计算机模型，所以自然就需要有对应的内存模型，这个模型被称为 “ Java内存模型 ”，对应的英文是“ Java Memory Model ”，简称 JMM 。==

Java内存模型规定了JVM应该如何使用计算机内存（RAM）。
广义来讲， Java内存模型分为两个部分：

• Jvm 内存结构
• JMM与线程规范

其中，JVM内存结构是底层实现，也是我们理解和认识 JMM 的基础。 大家熟知的堆内存、栈内存等运行时数据区的划分就可以归为JVM内存结构。

JVM内存结构

JVM内部使用的Java内存模型， 在逻辑上将内存划分为 线程栈 （thread stacks） 和 **堆内存 （heap）**两个部分。

==JVM中，每个正在运行的线程，都有自己的线程栈。 线程栈包含了当前正在执行的方法链/调用链上的所有方法的状态信息。==
线程栈又被称为“ 方法栈 ”或“ 调用栈 ”（call stack）。

线程栈里面保存了调用链上正在执行的所有方法中的局部变量。

• 每个线程都只能访问自己的线程栈。
• 每个线程都不能访问(看不见)其他线程的局部变量

即使两个线程正在执行完全相同的代码，但每个线程都会在自己的线程栈内创建对应代码中声明的局部变量。 所以每个线程都有一份自己的局部变量副本。

• 所有原生类型的局部变量都存储在线程栈中，因此对其他线程是不可见的。
• 线程可以将一个原生变量值的副本传给另一个线程，但不能共享原生局部变量本身。
• 堆内存中包含了Java代码中创建的所有对象，不管是哪个线程创建的。 其中也涵 盖了包装类型（例如 Byte ， Integer ， Long 等）。
• 不管是创建一个对象并将其赋值给局部变量， 还是赋值给另一个对象的成员变量，创建的对象都会被保存到堆内存中。

下图演示了线程栈上的调用栈和局部变量，以及存储在堆内存中的对象：

• 如果是原生数据类型的局部变量，那么它的内容就全部保留在线程栈上。
• 如果是对象引用，则栈中的局部变量槽位中保存着对象的引用地址，而实际的对象内容保存在堆中。
• 对象的成员变量与对象本身一起存储在堆上,不管成员变量的类型是原生数值， 还是对象引用。
• 类的静态变量则和类定义一样都保存在堆中

栈内存的结构

每启动一个线程，JVM就会在栈空间栈分配对应的 线程栈, 比如 1MB 的空间（ ‐Xss1m ）。

java虚拟机提供了参数 -Xss来指定线程的最大空间，这个参数也直接决定了方法调用的最大深度。

线程栈也叫做Java方法栈。如果使用了JNI方法，则会分配一个单独的本地方法栈 (Native Stack)

线程执行过程中，一般会有多个方法组成调用栈(Stack Trace), 比如A调用B，B调用C。每执行到一个方法，就会创建对应的 栈帧 (Frame)

栈帧是一个逻辑上的概念，具体的大小在一个方法编写完成后基本上就能确定。

比如 返回值 需要有一个空间存放吧，每个 局部变量 都需要对应的地址空间，此外 还有给指令使用的 操作数栈 ，以及class指针(标识这个栈帧对应的是哪个类的方法, 指向非堆里面的Class对象）

小结

==方法中使用的原生数据类型和对象引用地址在栈上存储；对象、对象成员 与类定义、静态变量在堆上。==

**堆内存又称为“ 共享堆 ”，**堆中的所有对象，可以被所有线程访问,只要他们能拿到对象的引用地址。

• 如果一个线程可以访问某个对象时，也就可以访问该对象的成员变量。
• 如果两个线程同时调用某个对象的同一方法，则它们都可以访问到这个对象的成员变量，但每个线程的局部变量副本是独立的

虽然各个线程自己使用的局部变量都在自己的栈上，但是大家可以共享堆上的对象，特别地各个不同线程访问同一个对象实例的基础类型的成员变量，会给每 个线程一个变量的副本

堆内存的结构

堆内存是所有线程共用的内存空间，理论上大家都可以访问里面的内容。

但JVM的具体实现一般会有各种优化。比如将逻辑上的Java堆,划分为 堆(Heap)和 非堆(Non‐Heap) 两个部分。这种划分的依据在于，==我们编写的Java代码，基本上只能使用Heap这部分空间，发生内存分配和回收的主要区域也在这部分，所以有一种说法，这里的Heap也叫GC管理的堆(GC Heap)。==

堆

GC理论中有一个重要的思想，叫做分代。 经过研究发现，程序中分配的对象，要么 用过就扔，要么就能存活很久很久。
因此，JVM将Heap内存分为年轻代（Young generation）和老年代（Old generation, 也叫 Tenured）两部分。

年轻代还划分为3个内存池，新生代(Eden space)和存活区(Survivor space), 在大部分 GC算法中有2个存活区(S0,S1)，在我们可以观察到的任何时刻，S0和S1总有一个是空的,但一般较小，也不浪费多少空间

==具体实现对新生代还有优化，那就是TLAB(Thread Local Allocation Buffer), 给每个线程先划定一小片空间，你创建的对象先在这里分配，满了再换。这能极大降低并发资 源锁定的开销。==

非堆

java 官方工具 jconsole 可以看到这样的定义。，

Non­Heap本质上还是Heap，只是一般不归GC管理，里面划分为3个内存池。

• 元数据区，Metaspace, 以前叫持久代(永久代, Permanent generation), Java8换了个名字叫 Metaspace.
• Java8将方法区移动到了Meta区里面，而方法又是class的一部分。。。和CCS交叉
• CCS, Compressed Class Space,存放class信息的，和 Metaspace 有交叉。
• Code Cache, 存放 JIT编译器编译后的本地机器代码。

JMM

背景

JMM 规范对应的是 JSR-133 《Java 语言规范》 的 Memory Model 章节

JMM规范明确定义了不同的线程之间，通过哪些方式，在什么时候可以看见其他线程保存到共享变量中的值；以及在必要时，如何对共享变量的访问进行同步。这样的好处是屏蔽各种硬件平台和操作系统之间的内存访问差异，实现了Java并发程序真正的跨平台。

简介

JMM定义了一些术语和规定：

• 被多个线程共享使用的内存称之为**“共享内存”或"堆内存"**

• 所有的对象（包括内部的实例成员变量），static变量，以及数组，都必须存放到堆内存中。

• 局部变量，方法的形参/入参，异常处理语句的入参不允许在线程之间共享，所以不受到内存模型的影响。

• 多个线程同时对一个变量执行读取/写入时，这时候只要有某个线程执行的时写操作，那么就会引起 “冲突”

• 可以被其他线程影响或感知的操作，成为线程间的交互行为，可分为：读取、写入、同步、外部操作等。

  • 同步操作包括：
    • 对 volatile变量的读写
    • 对管程(monitor) 的锁定与解锁
    • 线程的起始操作和结尾操作
  • 外部操作包括
    • 对线程执行环境之外的操作，比如停止其他线程。

JMM 规范的是线程间的交互操作，而不管线程内对局部变量进行的操作。

内存屏障

背景（CPU指令与乱序执行）

计算机按支持的指令大致可以分为两类：

• 精简指令集计算机(RISC) , 代表是如今大家熟知的 ARM 芯片，功耗低，运算能力相对较弱。
• 复杂指令集计算机(CISC) , 代表作是Intel的X86芯片系列，比如奔腾，酷睿，至强，以及AMD的CPU。特点是性能强劲，功耗高。（实际上从奔腾4架构开始，对外是复杂指令集，内部实现则是精简指令集，所以主频才能大幅度提高）

写过程序的人都知道，同样的计算，可以有不同的实现方式。 硬件指令设计同样如此，比如说我们的系统需要实现某种功能，那么复杂点的办法就是在CPU中封装一个逻辑运算单元来实现这种的运算，对外暴露一个专用指令。
当然也可以偷懒，不实现这个指令，而是由程序编译器想办法用原有的那些基础的，通用指令来模拟和拼凑出这个功能。那么随着时间的推移，实现专用指令的CPU指令集就会越来越复杂，被称为复杂指令集。 而偷懒的CPU指令集相对来说就会少很多，甚至砍掉了很多指令，所以叫精简指令集计算机。

不管哪一种指令集，CPU的实现都是采用流水线的方式。如果CPU一条指令一条指令地执行，那么很多流水线实际上是闲置的。简单理解，可以类比一个KFC的取餐窗口就是一条流水线。于是硬件设计人员就想出了一个好办法： “ 指令乱序 ”。
CPU完全可以根据需要，通过内部调度把这些指令打乱了执行，充分利用流水线资源，只要最终结果是等价的，那么程序的正确性就没有问题。但这在如今多CPU内核的时代，随着复杂度的提升，并发执行的程序面临了很多问题。

CPU是多个核心一起执行，同时JVM中还有多个线程在并发执行，这种多对多让局面变得异常复杂，稍微控制不好，程序的执行结果可能就是错误的。

作用

前面提到了CPU会在合适的时机，按需要对将要进行的操作重新排序，但是有时候这个重排机会导致我们的代码跟预期不一致。

内存屏障可分为 读屏障 和 写屏障 ，用于控制可见性。 常见的 内存屏障 包括：

• #LoadLoad
• #StoreStore
• #LoadStore
• #StoreLoad

==这些屏障的主要目的，是用来短暂屏蔽CPU的指令重排序功能。==

和CPU约定好，看见这些指令时，就要保证这个指令前后的相应操作不会被打乱。

• 比如看见 #LoadLoad ,那么屏障前面的Load指令就一定要先执行完，才能执行屏障后面的Load指令。
• 比如我要先把a值写到A字段中，然后再将b值写到B字段对应的内存地址。如果要严格保障这个顺序,那么就可以在这两个Store指令之间加入一个 #StoreStore 屏障。
• 遇到 #LoadStore 屏障时,CPU自废武功，短暂屏蔽掉指令重排序功能。
• #StoreLoad 屏障, 能确保屏障之前执行的所有store操作，都对其他处理器可 见; 在屏障后面执行的load指令,都能取得到最新的值。换句话说,有效阻止屏障之前的store指令，与屏障之后的load指令乱序、即使是多核心处理器，在执行这些操作时的顺序也是一致的

==代价最高的是 #StoreLoad 屏障, 它同时具有其他几类屏障的效果，可以用来代替另外三种内存屏障。==

如何理解呢?
就是只要有一个CPU内核收到这类指令，就会做一些操作，同时发出一条广播, 给某个内存地址打个标记，其他CPU内核与自己的缓存交互时，就知道这个缓存不是最新的，需要从主内存重新进行加载处理。

总结

1. JVM的内存区域分为: 堆内存 和 栈内存 ；
2. 栈内存
3. 堆内存的实现可分为两部分: 堆(Heap) 和 非堆(Non‐Heap) ;
4. 堆主要由GC负责管理，按分代的方式一般分为: 老年代+年轻代；年轻代=新生代 +存活区；
5. CPU有一个性能提升的利器: 指令重排序 ；
6. JMM规范对应的是 JSR133, 现在由Java语言规范和JVM规范来维护；
7. 内存屏障的分类与作用。

• 前言
• 逃逸分析
  • 测试
• 总结

前言

栈上分配是java虚拟机提供的一项优化技术，基本思想是，对于那些线程私有的对象（这里指不可能被其他线程访问的对象），可以将它们分配在栈上，而不是分配在堆上。

好处是可以在函数调用结束后自行销毁，不需要垃圾回收器的介入，从而提高性能。

逃逸分析

栈上分配的技术基础是 逃逸分析。逃逸分析的目的是判断对象的作用域是否有可能逃逸出函数体。

下面就是一个逃逸对象。因为 静态变量u有可能被任何线程访问。

private static User u;

public static void alloc(){
    u = new User();
    u.id = 1;
    u.name = "test";
}

下面就是一个非逃逸对象。因为 变量u 以局部变量存在，并且没有做公开/返回等操作。

public static void alloc(){
    User u = new User();
    u.id = 1;
    u.name = "test";
}

对于这种情况，虚拟机就有可能将User分配到栈上，而不在堆上。

测试

测试代码：

public class OnStackTest {
    public static class User {
        public int id = 0;
        public String name = "";
    }

    public static void alloc() {
        User u = new User();
        u.id = 1;
        u.name = "test";
    }

    public static void main(String[] args) {
        long b = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            alloc();
        }
        long e = System.currentTimeMillis();
        System.out.println(e - b);
    }
}

该代码执行了1一次alloc()方法创建对象，由于User对象需要占用16字节的空间，因此累计分配空间将达到1.5G。如果堆空间小于这个值，就必然发生GC。使用参数调试一下。

-server -Xmx10m -Xms10m -XX:+DoEscapeAnalysis -XX:+PrintGC -XX:-UserTLAB -XX:+EliminateAllocations

单独标签的作用可以查看启动参数说明。

这里程序执行后，会没有任何形式的GC输出。说明在执行过程中，分配过程被优化。

如果关闭逃逸分析或者标量替换中任何一个，再次执行程序，会输出大量的GC日志，说明栈上分配依赖逃逸分析和标量替换的实现。

总结

对于大量的零散小对象，栈上分配提供了一种很好的对象分配优化策略，栈上分配速度快，并可以有效避免垃圾回收带来的负面影响（STW），但由于栈空间较小，因此对于大对象也不适合在栈上分配

• 概述
  • 缺点
  • 优点
• 差别说明
  • 非直接缓冲区（堆内存）
  • 直接缓冲区（直接内存）
• 内存溢出
  • DirectByteBuffer
  • HeapByteBuffer
• 分配与回收
  • 速度比较
    • 小对象大数量
    • 大对象小数量
    • 结论
  • System.gc
  • unsafe内存管理
  • ByteBuffer.cleaner()
• 使用场景
  • 适用DirectByteBuffer(直接内存)的情况
  • 适用HeapByteBuffer(堆内存)的情况

概述

• 不是虚拟机运行时数据区的一部分，也不是《Java虚拟机规范》中定义的内存区域。
• 直接内存是在Java堆外的、直接向系统申请的内存区间。
• JVM通过NIO进行通信，使用DirectByteBuffer进行操作，用于数据缓冲区。因为可以避免 Java 堆和 Native 堆之间来回复制数据，在一些场景可以带来显著的性能提高。
• Java堆和直接内存的总和依然受限于操作系统能给出的最大内存
• 虚拟机参数设置：-DirectMemorySize可以设置直接内存大小，默认与堆内存的最大值-Xmx参数值一致。
• 可能导致OutOfMemoryError异常。 在配置 JVM 参数时，会根据机器的实际内存设置 -Xmx 等信息，但往往会忽略直接内存(默认为 -Xmx)，这可能使得各个内存区域的综合大于物理内存限制，导致扩容时出现OOM。

缺点

1. 不受JVM内存回收管理，需手动回收
2. 分配与回收回收成本高（属于操作系统内存）
3. 不好控制，频繁操作，容易内存溢出。
4. 不适合储存复杂对象。

优点

1. 一般情况下访问直接内存的速度会比JVM堆快。即读写性能高。
2. 读写频繁的场合，使用直接内存更能提高性能。
3. 大内存更适合使用。
4. 因为不受jvm控制，可以减少stw时间。

差别说明

非直接缓冲区（堆内存）

1. 当我们发起一次文件读取操作时，与操作系统交互，需要由用户态切换内核态，这时需要拷贝到内核态指定的内存空间，再将数据拷贝到jvm的堆内存。
2. 需要两份内存空间。

直接缓冲区（直接内存）

1. 本质是减少内存之间的拷贝次数和共用一份内存空间。

2. 通过directByteBuffer操作，申请到一个直接内存地址。这个直接内存地址，实际是直接在内核态进行设备间的内存操作，而不必拷贝到jvm内存中。

3. 当我们发起一次文件读操作时，通过directByteBuffer获取到一个直接内存空间，并把文件加载到这篇空间里面，这里就不用再进行内存拷贝了。

4. 简单理解，直接内存可以看作是一片内核态和用户态公用的，属于内核态的内存空间。

内存溢出

DirectByteBuffer

public class DirectMemoryOomDemo {
    static int _100Mb = 1024*1024*100;

    public static void main(String[] args) {
        List<ByteBuffer> byteBuffers = new ArrayList<>();
        int i=0;
        try {
            while (true) {
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
                byteBuffers.add(byteBuffer);
                i++;
            }
        }finally {
            System.out.println(i);
        }
    }
}

HeapByteBuffer

public class HeapMemoryOomDemo {
    static int _100Mb = 1024*1024*100;

    public static void main(String[] args) {
        List<ByteBuffer> byteBuffers = new ArrayList<>();
        int i=0;
        try {
            while (true) {
                ByteBuffer byteBuffer = ByteBuffer.allocate(_100Mb);
                byteBuffers.add(byteBuffer);
                i++;
            }
        }finally {
            System.out.println(i);
        }
    }
}

分配与回收

速度比较

小对象大数量

/**
 * 比较DirectByteBuffer和HeapByteBuffer
 */
public class CompareDemo {
    private static final int capacity = 1024;

    private static final int len = 1024 * 1000;

    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(1000);
        System.gc();
        createDirectMemory();
        Thread.sleep(1000);
        System.gc();
        Thread.sleep(1000);
        createHeapMemory();

    }

    public static void createDirectMemory() {
        long start = System.currentTimeMillis();

        ByteBuffer[] byteBuffers = new ByteBuffer[len];
        for (int i = 0; i < len; i++) {
            ByteBuffer byteBuffer = ByteBuffer.allocateDirect(capacity);
            byteBuffers[i] = byteBuffer;
        }
        long end = System.currentTimeMillis();
        System.out.println("DirectByteBuffer创建完成，耗时：" + (end - start));
    }

    public static void createHeapMemory() {
        long start = System.currentTimeMillis();
        ByteBuffer[] byteBuffers = new ByteBuffer[len];
        for (int i = 0; i < len; i++) {
            ByteBuffer byteBuffer = ByteBuffer.allocate(capacity);
            byteBuffers[i] = byteBuffer;
        }
        long end = System.currentTimeMillis();
        System.out.println("HeapByteBuffer创建完成，耗时：" + (end - start));

    }
}

这里设置了大小为1k，数量为1024000。我们运行一下查看结果。

DirectByteBuffer创建完成，耗时：1726
HeapByteBuffer创建完成，耗时：1304

可以看到DirectByteBuffer在数量越多的情况下性能更差。

大对象小数量

private static final int capacity = 1024*1024*100;
private static final int len = 10;

这里延用前面的代码，并设置了大小为100M，数量为10。我们运行一下查看结果。

DirectByteBuffer创建完成，耗时：174
HeapByteBuffer创建完成，耗时：262

可以看到这种情况下DirectByteBuffer性能更具优势。

结论

1. DirectByteBuffer不适用于频繁申请内存的场景，当数量过多，性能将直线下降，不如使用堆内存。
2. DirectByteBuffer适用于大内存申请使用的情况，且服用内存空间，这样对运行性能更加友好。

System.gc

public class DirectMemoryGcDemo {
    private static int _500MB = 1024 * 1024 * 500;

    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        System.out.println("开始分配");
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_500MB);
        long endtime = System.currentTimeMillis();

        System.out.println("分配完成,耗时：" + (endtime - start));
        System.in.read();
        byteBuffer = null;
        System.gc();
        System.out.println("执行System.gc，程序未完全退出");
        System.in.read();
        System.out.println("程序退出");
    }
}

执行程序后，分配完直接内存，会暂停，我们看一下任务管理器的情况。这里可以看到分配了一个将近500M的内存。 然后我们继续执行一下程序。 可以看见500M的java进程已经不见了。证明已经被我们System.gc()回收了。

unsafe内存管理

==通常我们最好也不要使用Unsafe类，除非有明确的目的，并且也要对它有深入的了解才行。==

另外ByteBuffer，

public class DirectmemoryUnsafeDemo {
    private final static int _100MB = 1024 * 1024 * 500;

    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();
        long base = unsafe.allocateMemory(_100MB);
        unsafe.setMemory(base, _100MB, (byte) 0);
        System.out.println("分配内存成功");
        System.in.read();
        unsafe.freeMemory(base);
        System.out.println("释放内存");
        System.in.read();
    }

    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            Unsafe unsafe = (Unsafe) field.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }
}

ByteBuffer.cleaner()

public class DirectMemoryFreeDemo {
    private static int _500MB = 1024 * 1024 * 500;

    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        System.out.println("开始分配");
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_500MB);
        long endtime = System.currentTimeMillis();

        System.out.println("分配完成,耗时：" + (endtime - start));
        System.in.read();
        if (byteBuffer.isDirect()) {
            System.out.println("byteBuffer是直接内存");
            ((DirectBuffer) byteBuffer).cleaner().clean();
        }
        System.out.println("执行Cleaner，程序未完全退出");
        System.in.read();
        System.out.println("程序退出");
    }
}

使用场景

适用DirectByteBuffer(直接内存)的情况

ByteBuffer.allocateDirect(int capacity)

1. 频繁的native IO，即java进程与本地磁盘,socket传输
2. 不需要经常创建和销毁DirectByteBuffer对象（执行分配和销毁代价大）（使用池思想，复用DirectByteBuffer）
3. DirectByteBuffer不会占用堆内存，也就是不受堆内存大小限制（受系统内存限制），只有在DirectByteBuffer回收时才释放缓冲区。
4. 大文件造成大对象，对GC负担比较重的情况。
5. 为了避免一直没有FULL GC，最终导致物理内存被耗完。我们会指定直接内存的最大值，通过-XX：MaxDirectMemerySize来指定，当达到阈值的时候，调用system.gc来进行一次full gc，把那些没有被使用的直接内存回收掉。

适用HeapByteBuffer(堆内存)的情况

ByteBuffer.allocate(int capacity)

1. 数据仅在java进程中传输使用，不进行本地io操作。
2. 体积小，对GC负担低，能够快速回收。

• -Xmx

• -Xms

• -Xss。

  • 线程栈空间大小。
  • 实例：-Xss1m。表示分配1m空间给每个线程使用。

• -server

• -XX:+DoExcapeAnalysis

  • 逃逸分析。需在-server 模式下使用。

  • -XX:+DoExcapeAnalysis启用，-XX:-DoExcapeAnalysis禁用。默认禁用

• -XX:+PrintGC

  • 打印GC日志

• -XX:+EliminateAllocations

  • 标量替换（默认打开）。作用是允许对象打散分配在栈上。
  • 比如对象拥有id和name两个字段，那么这两个字段会被视为两个独立的局部变量进行分配。

• -XX:-UserTLAB（关闭TLAB）

  • TLAB(Thread Local Allocation Buffer)，线程本地分配缓冲区。

• 前言
• 特点和作用
  • 系统属性参数
    • 常用参数
  • 自定义参数
  • 运行模式
    • 常用模式
  • 堆内存
    • 常用
    • 性能优化注意点
  • GC相关
    • 常用
    • 各版本默认GC
  • 分析诊断
    • 常用
    • 远程调试
  • JavaAgent
    • 如何设置 agent
    • 例子
      • CPU使用时间抽样分析

前言

jvm启动参数分为三类：

1. 以 - 开头的为标准参数，所有的jvm都要实现这些参数，并向后兼容。（-D设置系统属性）
2. 以 -X 开头的为非标准参数，基本都是传给JVM的，默认JVM实现这些参数的功能，但是不保证所有JVM实现都满足，且不保证向后兼容。可以使用java -X 查看当前jvm支持的非标准参数。（-Xmx8g 设置堆内存8g）
3. 以 -XX 开头的为非稳定参数，专门用于控制JVM的行为，跟具体的JVM实现有关，随时可能在下一个版本取消。
   • -XX:+-Flag形式，+-是对布尔值进行开关
   • -XX:key=value形式，指定某个选项的值

特点和作用

下面按照一些特点和作用来分类

1. 系统属性参数
2. 运行模式参数
3. 堆内存设置参数
4. GC 设置参数
5. 分析诊断参数
6. javaAgent 参数

系统属性参数

系统属性参数主要是给我们系统提供一些环境变量和传递传递系统内需要使用的一些开关或者数值。

环境变量就是配置在系统变量里比如path等信息里面，用于影响所有启动项目的。

常用参数

• -Dfile.encoding=UTF-8。设置编码类型
• -Duser.timezone=GMT+08。设置时区
• -Dmaven.test.skip=ture。设置mavne跳过测试
• -Dio.netty.eventLoopThreads=8。设置netty线程数为8

自定义参数

java -Da=100 -jar xzxx.jar

等价于，在系统里执行下面代码

System.setProperty("a","100");

// 获取代码
String a = System.getProperty("a");

linux下，还可以这样启动

a=100 java -jar xzxx.jar

运行模式

Jvm运行时，采取的运行模式。

常用模式

1. -server。设置jvm使用server模式，特点：
   • 启动速度慢，但运行时性能和内存管理效率很高，适用生产环境
   • 在具有64位能力的JDK环境将默认启用该模式，而忽略-client参数
2. -client。设置jvm使用client模式，特点：
   • 在jdk1.7之前在32位的x86机器上的默认值是-client选项。
   • 启动速度比较快，但运行时性能和内存管理效率不高，通常用与客户端应用程序或pc应用开发和调试。
3. -Xint。在解释模式（interpreted mode）下运行，特点是：
   • -Xint标记会强制JVM解释执行所有的字节码
   • 通常运行速度偏低，一般低10倍或者更多。
4. -Xcomp。与Xint相反，是编译模式，特点是：
   • JVM会在第一次使用时把所有的字节码编译成本地代码，从而带来最大程度的优化
   • 注意预热的问题
5. -Xmixed。混合模式，将解释模式和编译模式混合使用，特点是：
   • 由JVM决定，这是jvm的默认模式，也是推荐模式
   • 使用java -version可以看到mixed mode等信息

堆内存

配置堆内存分配情况

常用

• -Xmx。指定最大堆内存。如 -Xmx4g。这只是限制了 Heap 部分的最大值为4g。这个内存不包括栈内存，也不包括堆外使用的内存
• -Xms, 指定堆内存空间的初始大小。 如 -Xms4g。 而且指定的内存大小，并不是操作系统实际分配的初始值，而是GC先规划好，用到才分配。专用服务器上需要保持-Xms和-Xmx一致，否则启动后会有几次FullGC产生。当两者不一致时，堆内存扩容可能会导致性能抖动。
• -Xmn, 等价于 -XX:NewSize，使用 G1 垃圾收集器 不应该设置该选项，在其他的某些业务场景下可以设置。==官方建议设置为 -Xmx 的 1/2 ~ 1/4。==。默认Young区和Old区是1:2，所以是1/3.
• -XX：MaxPermSize=size, 这是 JDK1.7 之前使用的。Java8 默认允许的 Meta空间无限大，此参数无效。
• -XX：MaxMetaspaceSize=size, Java8 默认不限制 Meta 空间，一般不允许设置该选项。
• -XX：MaxDirectMemorySize=size，系统可以使用的最大堆外内存，这个参数跟 -Dsun.nio.MaxDirectMemorySize 效果相同。
• -Xss, 设置每个线程栈的字节数，影响栈的深度。 例如 -Xss1m 指定线程栈为1MB，与-XX:ThreadStackSize=1m 等价。 默认是1M

性能优化注意点

1. 专用服务器上需要保持 –Xms 和 –Xmx 一致。否则可能导致：
   • 应用刚启动可能就有好几个 FullGC。当两者配置不一致时，堆内存扩容可能会导致性能抖动。
   • 当内存还没到达 -Xmx配置的最大内存时，系统内存已经不够用了，然后溢出的问题。
2. -Xmn/-XX:NewSize。官方建阳设置为 -Xmx 的 1/2 ~ 1/4
3. 如果我们发现某些线程的调用栈发生了内存溢出，基本就是调用深度过深，比如死循环、2个方法来回调用，最终导致使用的总内存超出了Xss的限制(1M)，就会溢出了。
4. 尽量不要在线上做java应用程序的混合部署。每个应用都放在虚拟机或者docker里面，做到资源隔离，这样进程之间不会抢内存资源。
5. -Xmx在一般情况下可以配置内存的60%-80%，一定要留20-30%的预留空间，需要预留给堆外内存以及其它应用使用。

GC相关

常用

• -XX：+UseG1GC：使用 G1 垃圾回收器
• -XX：+UseConcMarkSweepGC：使用 CMS 垃圾回收器
• -XX：+UseSerialGC：使用串行垃圾回收器
• -XX：+UseParallelGC：使用并行垃圾回收器
• -XX：+UnlockExperimentalVMOptions -XX:+UseZGC。Java 11+。
• -XX：+UnlockExperimentalVMOptions -XX:+UseShenandoahGC。Java 12+

各版本默认GC

• java7 - Parallel GC
• java8 - Parallel GC
• java9 - G1 GC
• java10 - G1 GC
• java11 - ZGC

分析诊断

常用

• -XX：+-HeapDumpOnOutOfMemoryError 选项，当 OutOfMemoryError 产生，即内存溢出（堆内存或持久代) 时，自动 Dump 堆内存快照。
  • 示例用法： java -XX:+HeapDumpOnOutOfMemoryError -Xmx256m ConsumeHeap
• -XX：HeapDumpPath 选项，与 HeapDumpOnOutOfMemoryError 搭配使用，指定内存溢出时 Dump 文件的目录。
  • 如果没有指定则默认为启动 Java 程序的工作目录。
  • 示例用法： java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/usr/local/ConsumeHeap 自动 Dump 的 hprof 文件会存储到 /usr/local/ 目录下。
• -XX：OnError 选项，发生致命错误时（fatal error）执行的脚本。
  • 例如, 写一个脚本来记录出错时间, 执行一些命令，或者 curl 一下某个在线报警的 url。
  • 示例用法：java -XX:OnError="gdb - %p" MyApp。可以发现有一个 %p 的格式化字符串，表示进程 PID。
• -XX：OnOutOfMemoryError 选项，抛出 OutOfMemoryError 错误时执行的脚本。
• -XX：ErrorFile=filename 选项，致命错误的日志文件名,绝对路径或者相对路径。

远程调试

• -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=1506。

JavaAgent

Agent 是 JVM 中的一项黑科技，可以通过无侵入方式来做很多事情，比如注入 AOP 代码，执行统计等等，权限非常大。这里简单介绍一下配置选项，详细功能需要专门来讲。

如何设置 agent

• -agentlib:libname[=options] 启用 native 方式的 agent，参考 LD_LIBRARY_PATH 路径。
• -agentpath:pathname[=options] 启用 native 方式的 agent。 -javaagent:jarpath[=options] 启用外部的 agent 库，比如 pinpoint.jar 等等。
• -Xnoagent 则是禁用所有 agent。

例子

CPU使用时间抽样分析

JAVA_OPTS="-agentlib:hprof=cpu=samples,file=cpu.samples.log"

• 参数说明

参数说明

• -Xmx

• -Xms

• -Xss。

  • 线程栈空间大小。
  • 实例：-Xss1m。表示分配1m空间给每个线程使用。

• -server

• -XX:+DoExcapeAnalysis

  • 逃逸分析。需在-server 模式下使用。

  • -XX:+DoExcapeAnalysis启用，-XX:-DoExcapeAnalysis禁用。默认禁用

• -XX:+PrintGC

  • 打印GC日志

• -XX:+EliminateAllocations

  • 标量替换（默认打开）。作用是允许对象打散分配在栈上。
  • 比如对象拥有id和name两个字段，那么这两个字段会被视为两个独立的局部变量进行分配。

• -XX:-UserTLAB（关闭TLAB）

  • TLAB(Thread Local Allocation Buffer)，线程本地分配缓冲区。

• 前言
• Java字节码简介
• 获取字节码清单
• 解读字节码清单
• 查看class文件的常量池信息
• 查看方法信息
• 线程栈与字节码执行模型
• 方法体中的字节码解读
• 对象初始化指令：new指令, init 以及clinit 简介
• 栈内存操作指令
  • dup , dup_x1 , dup2_x1 指令补充说明
• 局部变量表
  • 垃圾回收扩展
• 流程控制指令
• 算数运算指令与类型转换指令
• 方法调用指令和参数传递
  • JDK7新增的方法调用指令invokedynamic
• 总结
• 附录
  • 关于整形入栈指令（iconst,bipush,sipush,ldc)

前言

Java中的字节码，英文名为 bytecode ,是Java代码编译后的中间代码格式。JVM需要读取并解析字节码才能执行相应的任务。

从技术人员的角度看，Java字节码是JVM的指令集。JVM加载字节码格式的class文件，校验之后通过JIT编译器转换为本地机器代码执行。

对于卓越而有追求的程序员，都能深入去探索一些技术细节， 在需要的时候，可以在代码被执行前解读和理解中间形式的代码。对于Java来说，中间代码格式就是Java字节码。 了解字节码及其工作原理，对于编写高性能代码至关重 要，对于深入分析和排查问题也有一定作用，所以我们要想深入了解JVM来说，了解字节码也是夯实基础的一项基本功。

而对于工具领域和程序分析来说,字节码就是必不可少的基础知识了，通过修改字节码来调整程序的行为是司空见惯的事情。想了解分析器(Profiler)，Mock框架，AOP 等工具和技术这一类工具，则必须完全了解Java字节码。

Java字节码简介

有一件有趣的事情，就如名称所示, **Java bytecode **由单字节( byte )的指令组成， 理论上最多支持 256 个操作码(opcode)。实际上Java只使用了200左右的操作码， 还有一些操作码则保留给调试操作。

操作码， 下面称为 指令 , 主要由 类型前缀 和 操作名称 两部分组成。

例如，' i ' 前缀代表 ‘ integer ’，所以，' iadd ' 很容易理解, 表示对整数执行加 法运算。

根据指令的性质，主要分为四个大类

1. 栈操作指令，包括与局部变量交互的指令
2. 程序流程控制指令
3. 对象操作指令，包括方法调用指令
4. 算术运算以及类型转换指令

获取字节码清单

1. 我们先创建一个HelloByteCode.java文件如下：

package top.zsmile.test.jvm.bytecode;

public class HelloByteCode {
    public static void main(String[] args) {
        HelloByteCode obj = new HelloByteCode();
    }
}

2. 通过 javac 将 .java 文件编译成 .class 文件。或者在 IDEA或者Eclipse等集成开发工具自动编译，基本上是等效的。只要能找到对应的 class即可。

javac 不指定 -d 参数编译后生成的 .class 文件默认和源代码在同一个目录。
注意: javac 工具默认开启了优化功能,生成的字节码中没有局部变量表(LocalVariableTable)，相当于 局部变量名称被擦除。如果需要这些调试信息, 在编译时请加上 -g 选项。有兴趣的同学可以试试两种方式的区别，并对比结果。

javac .\HelloByteCode.java

# 生成在demo 目录下，需要先创建目录
javac -d demo .\HelloByteCode.java

3. 可以用 javap 工具来获取 class 文件中的指令清单。 javap 是标准JDK 内置的一 款工具, 专门用于反编译class文件。

JDK自带工具的详细用法, 请使用: javac -help 或者 javap -help 来查看; 其他类似。

然后使用 javap 工具来执行反编译, 获取字节码清单：

javap -c HelloByteCode # 当前 目录执行

# demo 目录下
javap -c demo.HelloByteCode
javap -c demo/HelloByteCode
javap -c demo/HelloByteCode.class

解读字节码清单

Compiled from "HelloByteCode.java"
public class top.zsmile.test.jvm.bytecode.HelloByteCode {
  public top.zsmile.test.jvm.bytecode.HelloByteCode();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class top/zsmile/test/jvm/bytecode/HelloByteCode
       3: dup
       4: invokespecial #3                  // Method "<init>":()V
       7: astore_1
       8: return
}

可以看到，反编译后的代码清单中, 有一个默认的构造函数 HelloByteCode() , 以及 main 方法

自动生成的构造函数，其方法体应该是空的，但这里看到里面有一些指令。为什么呢？
再次回顾Java知识, 每个构造函数中都会先调用 super 类的构造函数对吧？ 但这不是JVM自动执行的, 而是由程序指令控制，所以默认构造函数中也就有一些字节码指令来干这个事情。

基本上，这几条指令就是执行 super() 调用；

 public top.zsmile.test.jvm.bytecode.HelloByteCode();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

// java/lang/Object是默认继承了Object 类，是在编译时期就确定了的。

查看class文件的常量池信息

在 javap 命令中使用 -verbose 选项时， 还显示常量池信息。

javap -c -verbose HelloByteCode

常量池 大家应该都听说过, 英文是 Constant pool 。这里做一个强调: 大多数时候指的是 运行时常量 池 。但运行时常量池里面的常量是从哪里来的呢? 主要就是由 class 文件中的 常量池结构体 组成的。

-verbose用于输出常量池和本地变量信息

Classfile /D:/project/B.Smile/SmileX-boot/smilex-study/src/test/java/top/zsmile/test/jvm/bytecode/HelloByteCode.class
  Last modified 2023-6-17; size 317 bytes
  MD5 checksum f051f7adba144f74795cb61735f4ac41
  Compiled from "HelloByteCode.java"
public class top.zsmile.test.jvm.bytecode.HelloByteCode
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER

其中显示了很多关于class文件信息： 编译时间， MD5校验和， 从哪个 .java 源文件编译得来，符合哪 个版本的Java语言规范等等。

还可以看到 ACC_PUBLIC 和 ACC_SUPER 访问标志符。

• ACC_PUBLIC 标志很容易理解：这个类是 public 类，因此用这个标志来表示。
• ACC_SUPER 标志是怎么回事呢？ 这就是历史原因, JDK1.0 的BUG修正中引入 ACC_SUPER 标志来修正 invokespecial 指令调用 super 类方法的问题，从 Java 1.1 开始， 编译器一般都会自动生成 ACC_SUPER 标志。

指令后面跟着的#1,#2,#3编号都是对常量池的引用。

==总结一下，常量池就是一个常量的大字典，使用编号的方式把程序里用到的各类常量统一管理起来，这样在字节码操作里，只需要引用编号即可。==

查看方法信息

在 javap 命令中使用 -verbose 选项时， 还显示方法的更多信息：

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1

可以看到方法描述: ([Ljava/lang/String;)V ：

• 其中小括号内是入参信息/形参信息,
• 左方括号表述数组,
• L 表示对象,
• 后面的 java/lang/String 就是类名称
• 小括号后面的 V 则表示这个方法的返回值是 void
• 方法的访问标志也很容易理解 flags: ACC_PUBLIC, ACC_STATIC ，表示public和static

还可以看到执行该方法时需要的栈(stack)深度是多少，需要在局部变量表中保留多少个槽位, 还有方法的参数个数: stack=2, locals=2, args_size=1。把上面这些整合起来其实就是一个方法：

public static void main(java.lang.String[]);
注：实际上我们一般把一个方法的修饰符+名称+参数类型清单+返回值类型，合在一起叫“方法签名”， 即这些信息可以完整的表示一个方法。

看编译器自动生成的无参构造函数字节码:

  public top.zsmile.jvm.bytecode.HelloByteCode();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Ltop/zsmile/jvm/bytecode/HelloByteCode;

你会发现一个奇怪的地方, 无参构造函数的参数个数居然不是0: stack=1, locals=1,args_size=1 。

这是因为在 Java 中, 如果是静态方法则没有 this 引用。 对于非静态方法， this 将被分配到局部变量 表的第0号槽位中, 关于局部变量表的细节,下面再进行介绍

有反射编程经验的同学可能比较容易理解: Method#invoke(Object obj, Object... args) ;
有JavaScript编程经验的同学也可以类比: fn.apply(obj, args) && fn.call(obj, arg1,arg2);

这里新建了一个静态方法进行对比

 public static void test();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String test
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 5: 0
        line 6: 8

这里可以看到 args_size=0，因为静态方法没有this引用。

线程栈与字节码执行模型

JVM是一台基于栈的计算机器。每个线程都有一个独属于自己的线程栈(JVM stack)，用于存储 栈帧 (Frame)。
每一次方法调用，JVM都会自动创建一个栈帧。 栈帧 由 操作数栈 ， 局部变量数组 以及一个 真数据区（class引用、异常处理表）组成。 class引用指向当前方法在运行时常量池中对应的class。异常处理表对应的是发生异常时，方便找到异常处理的地方。

局部变量数组 也称为 局部变量表 (LocalVariableTable), 其中包含了方法的参数，以及局部变量。 局部变 量数组的大小在编译时就已经确定: 和局部变量+形参的个数有关，还要看每个变量/参数占用多少个字节。 操作数栈是一个LIFO结构的栈， 用于压入和弹出值。 它的大小也在编译时确定。

有一些操作码/指令可以将值压入“操作数栈”； 还有一些操作码/指令则是从栈中获取操作数，并进行处理， 再将结果压入栈。操作数栈还用于接收调用其他方法时返回的结果值。

方法体中的字节码解读

0: new           #5                  // class top/zsmile/jvm/bytecode/HelloByteCode
3: dup
4: invokespecial #6                  // Method "<init>":()V
7: astore_1
8: return

==间隔不相等的原因是,有一部分操作码会附带有操作数, 也会占用字节码数组中的空间。==

例如， new 就会占用三个槽位: 一个用于存放操作码指令自身，两个用于存放操作数。 因此，下一条指令 dup 的索引从 3 开始

每个操作码/指令都有对应的十六进制(HEX)表示形式， 如果换成十六进制来表示，则方法体可表示为HEX字 符串。例如上面的方法体表示成十六进制如下所示：

甚至我们还可以在支持十六进制的编辑器中打开class文件，可以在其中找到对应的字符串：

粗暴一点，我们可以通过HEX编辑器直接修改字节码，尽管这样做会有风险，但如果只修改一个数值的话 应该会很有趣。
其实要使用编程的方式，方便和安全地实现字节码编辑和修改还有更好的办法，那就是使用ASM和 Javassist之类的字节码操作工具，也可以在类加载器和Agent上面做文章

对象初始化指令：new指令, init 以及clinit 简介

我们都知道 new 是Java编程语言中的一个关键字， 但其实在字节码中，也有一个指令叫做 new 。 当我 们创建类的实例时,编译器会生成类似下面这样的操作码：

0: new           #5                  // class top/zsmile/jvm/bytecode/HelloByteCode
3: dup
4: invokespecial #6                  // Method "<init>":()V

当你同时看到 new, dup 和 invokespecial 指令在一起时，那么一定是在创建类的实例对象！

为什么是三条指令而不是一条呢？这是因为：

• new 指令只是创建对象，但没有调用构造函数
• invokespecial 指令用来调用某些特殊方法的, 当然这里调用的是构造函数。
• dup 指令用于复制栈顶的值

==由于构造函数调用不会返回值，所以如果没有dup指令, 在对象上调用方法并初始化之后，操作数栈就会是空的，在初始化之后就会出问题, 接下来的代码就无法对其进行处理。==

这就是为什么要事先复制引用的原因，为的是在构造函数返回之后，可以将对象实例赋值给局部变量或某个字段。因此，接下来的那条指令一般是以下几种：

• astore {N} or astore_{N} – 赋值给局部变量，其中 {N} 是局部变量表中的位置。
• putfield – 将值赋给实例字段
• putstatic – 将值赋给静态字段

==在调用构造函数的时候，其实还会执行另一个类似的方法 ，甚至在执行构造函数之前就执行了。 还有一个可能执行的方法是该类的静态初始化方法 ， 但 并不能被直接调用，而 是由这些指令触发的： new , getstatic , putstatic or invokestatic 。==

实际上，还有一些情况会触发静态初始化， 详情请参考JVM规范： [http://docs.oracle.com/javase/specs/jvms/se8/html/]

栈内存操作指令

• dup 指令, 复制栈顶的值, 并将复制的值压入栈。
• pop 指令则从栈中删除最顶部的值。
• swap 指令可交换栈顶两个元素的值，例如A和B交换位置(图中示例4)；
• dup_x1 指令, 复制栈顶的值, 并将复制的值插入到最上面2个值的下方。(图中示例5)；
• dup2_x1 指令, 复制栈顶1个64位/或2个32位的值, 并将复制的值按照原始顺序，插入原始值下面一 个32位值的下方(图中示例6)。

dup_x1 和 dup2_x1 指令看起来稍微有点复杂。而且为什么要设置这种指令呢? 在栈中复制最顶部的 值？

请看一个实际案例：怎样交换2个double类型的值？

==需要注意的是, 一个double值占两个槽位，也就是说如果栈中有两个double值，它们将占用4个槽位。==

要执行交换，你可能想到了 swap 指令，但问题是 swap 只适用于单字(one-word, 单字一般指32位4个 字节, 64位则是双字)，所以不能处理double类型, 但Java中又没有 swap2 指令。

怎么办呢? 解决方法就是使用 dup2_x2 指令, 将操作数栈顶部的double值, 复制到栈底double值的下方， 然后再使用 pop2 指令弹出栈顶的double值。结果就是交换了两个 double 值。 示意图如下图所示:

dup , dup_x1 , dup2_x1 指令补充说明

• dup指令

官方说明是: 复制栈顶的值, 并将复制的值压入栈.
操作数栈的值变化情况(方括号标识新插入的值):

..., value → 
..., value [,value]

• dup_x1 指令

官方说明是: 复制栈顶的值, 并将复制的值插入到最上面2个值的下方。
操作数栈的值变化情况(方括号标识新插入的值):

..., value2, value1 → 
..., [value1,] value2, value1

• dup2_x1 指令

官方说明是: 复制栈顶 1个64位/或2个32位的值, 并将复制的值按照原始顺序，插入原始值下面一个32位值的 下方。
操作数栈的值变化情况(方括号标识新插入的值):

# 情景1: value1, value2, and value3都是分组1的值(32位元素) 
..., value3, value2, value1 → 
..., [value2, value1,] value3, value2, value1 

# 情景2: value1 是分组2的值(64位,long或double), value2 是分组1的值(32位元素) 
..., value2, value1 → 
..., [value1,] value2, value1

Table 2.11.1-B 实际类型与JVM计算类型映射和分组

局部变量表

**stack **主要用于执行指令，而局部变量则用来保存中间结果，两者之间可以直接交互。

javac -g demp/*.java
-g 参数生成调试信息

==关于 LocalVariableTable 有个有意思的事情， 就是最前面的槽位会被方法参数占用。==
在这里，因为 main 是静态方法，所以槽位0中并没有设置为 this 引用的地址。 但是对于非静态方法 来说， this 会将分配到第0号槽位中

理解这些字节码的诀窍在于:

• 给局部变量赋值时，需要使用相应的指令来进行 store ，如 astore_1 。 store 类的指令都会删除栈顶值。
• 相应的 load 指令则会将值从局部变量表压入操作数栈，但并不会删除局部变量表中的值。

垃圾回收扩展

局部变量表中的变量也是重要的垃圾回收节点，只要被局部变量表中直接或间接引用的对象都是不会被回收的。

下面看个例子，来分析一下。

// 用6M空间测试
int size = 6 * 1024 * 1024;

public void gc1() {
    byte[] a = new byte[size];
    System.gc();
}

public void gc2() {
    byte[] a = new byte[size];
    a = null;
    System.gc();
}

public void gc3() {
    {
        byte[] a = new byte[size];
    }
    System.gc();
}

public void gc4() {
    {
        byte[] a = new byte[size];
    }
    int c = 10;
    System.gc();
}

public void gc5() {
    gc1();
    System.gc();
}

• gc1。申请空间后，立即进行回收，此时byte数组被变量a引用无法回收。
• gc2。申请空间后，先将变量a设置为null，使得byte数组没有被引用，所以直接被回收
• gc3。申请空间后，虽然变量a在局部作用域内，当执行回收时，变量a已经失效，但是局部变量表中依然还有引用指向，所以无法回收。
• gc4。和gc4不同的是，回收前对变量c进行赋值，这时因为变量a已失效，所以变量c直接使用了变量a的slot，所以byte数组被回收
• gc5。执行gc1的时候，在gc1中没有释放byte数组，所以在gc1中无法回收byte数组。但是当gc1返回后，栈帧销毁，所以在gc5中可以顺利回收byte数组。

分析方法：可以使用参数 -XX:+PrintGC 执行上述几个函数，在输出日志中查看垃圾回收后堆的大小变化，判断byte数组是否被回收。

流程控制指令

流程控制指令主要是分支和循环在用, 根据检查条件来控制程序的执行流程。

public class MovingAverage {
    private int count = 0;
    private double sum = 0.0d;

    public void submit(double value) {
        this.count++;
        this.sum += value;
    }

    public double getAvg() {
        if (0 == this.count) {
            return sum;
        }
        return this.sum / this.count;
    }
}

一般是 If-Then-Else 这种三元运算符(ternary operator)，
Java中的各种循环，甚至异常处的理操作码都可归属于 程序流程控制

 0: new           #2                  // class top/zsmile/bytecode/MovingAverage
         3: dup
         4: invokespecial #3                  // Method top/zsmile/bytecode/MovingAverage."<init>":()V
         7: astore_1
         8: getstatic     #4                  // Field numbers:[I
        11: astore_2
        12: aload_2
        13: arraylength
        14: istore_3
        15: iconst_0
        16: istore        4
        18: iload         4
        20: iload_3
        21: if_icmpge     43
        24: aload_2
        25: iload         4
        27: iaload
        28: istore        5
        30: aload_1
        31: iload         5
        33: i2d
        34: invokevirtual #5                  // Method top/zsmile/bytecode/MovingAverage.submit:(D)V
        37: iinc          4, 1
        40: goto          18
        43: aload_1
        44: invokevirtual #6                  // Method top/zsmile/bytecode/MovingAverage.getAvg:()D
        47: dstore_2
        48: return
      LineNumberTable:
        line 7: 0
        line 8: 8
        line 9: 30
        line 8: 37
        line 11: 43
        line 12: 48
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           30       7     5 number   I
            0      49     0  args   [Ljava/lang/String;
            8      41     1    ma   Ltop/zsmile/bytecode/MovingAverage;
           48       1     2   avg   D

位置 [8~16] 的指令用于循环控制。
我们从代码的声明从上往下看, 在最后面的LocalVariableTable 中:

• 0 号槽位被main方法的参数 args 占据了。
• 1 号槽位被 ma 占用了。
• 5 号槽位被 number 占用了。
• 2 号槽位是for循环之后才被 avg 占用的

通过分析字节码指令可以看出，在 2 , 3 , 4 槽位有3个匿名的局部变量( astore_2 , istore_3 , istore 4 等指令)

• 2 号槽位的变量保存了 numbers 的引用值，占据了 2 号槽位。
• 3 号槽位的变量, 由 arraylength 指令使用, 得出循环的长度。
• 4 号槽位的变量, 是循环计数器， 每次迭代后使用 iinc 指令来递增。

如果我们的JDK版本再老一点, 则会在 2 , 3 , 4 槽位发现三个源码中没有出现的变量： arr$ , len$ , i$ ， 也就是循环变量

18: iload 4 
20: iload_3 
21: if_icmpge 43

这段指令将局部变量表中 4 号槽位 和 3 号槽位的值加载到栈中，并调用 if_icmpge 指令来比较他们的值。

==【 if_icmpge 解读: if, integer, compare, great equal】, 如果一个数的值大于或等于另一个值，则程序执 行流程跳转到 pc=43 的地方继续执行。==

算数运算指令与类型转换指令

Java字节码中有许多指令可以执行算术运算。实际上，指令集中有很大一部分表示都是关于数学运算的。对 于所有数值类型( int , long , double , float )，都有加，减，乘，除，取反的指令。

那么 byte 和 char , boolean 呢? JVM 是当做 int 来处理的。另外还有部分指令用于数据类型之 间的转换。

算术操作码和类型

类型转换操作码

==唯一不需要将数值load到操作数栈的指令是 iinc ，它可以直接对 LocalVariableTable 中的值进行 运算。 其他的所有操作均使用栈来执行==

方法调用指令和参数传递

这里列举了各种用于方法调用的指令：

• invokestatic ，顾名思义，这个指令用于调用某个类的静态方法，这也是方法调用指令中最快的一 个。
• invokespecial , 我们已经学过了, invokespecial 指令用来调用构造函数，但也可以用于调用 同一个类中的 private 方法, 以及可见的超类方法。
• invokevirtual ，如果是具体类型的目标对象， invokevirtual 用于调用公共，受保护和打包 私有方法。
• invokeinterface，当要调用的方法属于某个接口时，将使用 invokeinterface 指令。

那么 invokevirtual 和 invokeinterface 有什么区别呢？这确实是个好问题。 为什么需要 invokevirtual 和 invokeinterface 这两种指令呢? 毕竟所有的接口方法都是公共方法, 直接 使用 invokevirtual 不就可以了吗？

这么做是源于对方法调用的优化。JVM必须先解析该方法，然后才能调用它。

• 使用 invokestatic 指令，JVM就确切地知道要调用的是哪个方法：因为调用的是静态方法，只能 属于一个类。
• 使用 invokespecial 时， 查找的数量也很少， 解析也更加容易， 那么运行时就能更快地找到所需 的方法.

使用 invokevirtual 和 invokeinterface 的区别不是那么明显。

想象一下，类定义中包含一个方 法定义表， 所有方法都有位置编号。下面的示例中：A类包含 method1和method2方法； 子类B继承A，继 承了method1，覆写了method2，并声明了方法method3。

//method1和method2方法在类A和类B中处于相同的索引位置。
class A 
    1: method1 
    2: method2 
class B extends A
    1: method1 
    2: method2 
    3: method3

那么，在运行时只要调用 method2，一定是在位置2处找到它.

现在我们来解释 invokevirtual 和 invokeinterface 之间的本质区别。

假设有一个接口X声明了methodX方法, 让B类在上面的基础上实现接口X：

class B extends A implements X
    1: method1 
    2: method2 
    3: method3
    4: methodX

新方法methodX位于索引4处，在这种情况下，它看起来与method3没什么不同。
但如果还有另一个类C也实现了X接口，但不继承A，也不继承B：

class C implements X 
    1: methodC 
    2: methodX

类C中的接口方法位置与类B的不同，这就是为什么运行时在 invokinterface 方面受到更多限制的原因。

==与 invokinterface 相比， invokevirtual 针对具体的类型方法表是固定的，所以每次都可以精确 查找，效率更高（具体的分析讨论可以参见参考材料的第一个链接）。==

JDK7新增的方法调用指令invokedynamic

随着JDK 7的发布，字节码指令集新增了 invokedynamic 指令。这条新增加的指令是实现“动态类型语言”（Dynamically Typed Language）支持而进行的改进之一，同时也是 JDK 8以后支持的lambda表达式的实现基础。

我们知道在不改变字节码的情况下，我们在Java语言层面想调用一个类A的方法m，只有两个办法：

• 使用 A a=new A(); a.m() ，拿到一个A类型的实例，然后直接调用方法；
• 通过反射，通过A.class.getMethod拿到一个Method，然后再调用这个 Method.invoke 反射调用；

这两个方法都需要显式的把方法m和类型A直接关联起来，假设有一个类型B，也有一个一模一样的方法签名 的m方法，怎么来用这个方法在运行期指定调用A或者B的m方法呢？这个操作在JavaScript这种基于原型的语言里或者是C#这种有函数指针/方法委托的语言里非常常见，Java里是没有直接办法的。Java里我们一般 建议使用一个A和B公有的接口IC，然后IC里定义方法m，A和B都实现接口IC，这样就可以在运行时把A和B 都当做IC类型来操作，就同时有了方法m，这样的“强约束”带来了很多额外的操作。

而新增的invokedynamic指令，配合新增的方法句柄（Method Handles，它可以用来描述一个跟类型A无关 的方法m的签名，甚至不包括方法名称，这样就可以做到我们使用方法m的签名，但是直接执行的时候调用 的是相同签名的另一个方法b），可以在运行时再决定由哪个类来接收被调用的方法。在此之前，只能使用 反射来实现类似的功能。该指令使得可以出现基于JVM的动态语言，让jvm更加强大。而且在JVM上实现动 态调用机制，不会破坏原有的调用机制。这样既很好的支持了Scala、Clojure这些JVM上的动态语言，又可以支持代码里的动态lambda表达式

简单来说就是以前设计某些功能的时候把做法写死在了字节码里，后来想改也改不了了。
所以这次给lambda语法设计翻译到字节码的策略是就用invokedynamic来作个弊，把实际的翻译策略隐 藏在JDK的库的实现里（metafactory）可以随时改，而在外部的标准上大家只看到一个固定的 invokedynamic。

总结

我们可以通过字节码对整个代码的运行情况进行分析，有些时候不同的写法实现的相同功能（for和foreach），可以通过对字节码的分析判断其性能上的差距。因为编译后会将 java 所提供的语法糖去掉。

常用的指令有如下几个：

1. javac 编译 .java 文件。如果需要更多调试信息，可以加上 -g 。

   javac xxx.java
   
   javac -g xxx.java
   

2. javap。反编译 .class 文件，解析出字节码清单。可以通过 -verbose 查询更多信息（常量池信息，方法签名等）

   javap -c xxx.class 
   # or
   javap -c xxx
   
   javap -c -verbose xxx.class
   

3. 通过分析方法信息，我们可以注意到

   1. 执行该方法时需要的栈(stack)深度是多少，需要在局部变量表中保留多少个槽位， 还有方法的参数个数: stack=2, locals=2, args_size=1。
   2. args_size。无参静态方法和无参对象方法的区别在于，无参对象方法，会将 this引用 的指向通过args_size 的第一个槽位传入 方法中使用，所以无参对象方法的 args_size=1.

4. 关于对象初始化时，会调用构造方法，其实还会执行另一个类似的方法 ，甚至在执行构造函数之前就执行了。 还有一个可能执行的方法是该类的静态初始化方法 ， 但 并不能被直接调用，而 是由这些指令触发的： new , getstatic , putstatic or invokestatic 。

5. 各种用于方法调用的指令

   • invokestatic ，顾名思义，这个指令用于调用某个类的静态方法，这也是方法调用指令中最快的一 个。
   • invokespecial , 我们已经学过了, invokespecial 指令用来调用构造函数，但也可以用于调用 同一个类中的 private 方法, 以及可见的超类方法。
   • invokevirtual ，如果是具体类型的目标对象， invokevirtual 用于调用公共，受保护和打包 私有方法。
   • invokeinterface，当要调用的方法属于某个接口时，将使用 invokeinterface 指令。
   • invokedynamic，jdk7中新增的。这条新增加的指令是实现“动态类型语言”（Dynamically Typed Language）支持而进行的改进之一，同时也是 JDK 8以后支持的lambda表达式的实现基础。可以查看一下关于lambda表达式编译出来的源码可以看出差距。

6. 关于线程栈，每次方法调用都会生成一个栈帧，里面都会包括：

   • 操作栈。
   • 局部变量表。
   • 帧数据区（class引用、异常处理表）。用户获取class的常量池，以及异常发生后的处理方式。

   局部变量表和操作栈是可以互相交互的，操作栈是用来执行指令的，而局部变量表是用来记录状态的。他们通过 store 存储到局部变量表中，通过load加载到操作栈里。需要注意的是：store会删除栈顶的数据，而load不会删除局部变量表中的数据

附录

关于整形入栈指令（iconst,bipush,sipush,ldc)

• iconst。用于取值1~5
• bipush。用于取值-128~127
• sipush。用于取值-32768~32767
• ldc。用于取值-2147483648~2147483647

有几点需要注意：

• 取值-1时采用iconst_m1指令
• ldc指令是从常量池中获取值的，也能用来获取字符串

• 查看工具
  • jclasslib

查看工具

jclasslib

TODO

• 简介
• CompletableFuture创建
  • 构造函数
  • completedFuture创建
  • runAsync创建
  • supplyAsync创建
  • 结果获取
    • join和get的区别
• 流式计算

简介

CompletableFuture 是 java.io.conrrent 库在 JDK8 中新增的并发工具，同传统的 Future 相比，支持流式计算、函数式编程、聚合计算、完成通知和自定义异常处理等特性。

CompletableFuture 实现了 CompletionStage 和 Future。CompletionStage 是对 Future 的扩展，增强了流式处理、异步回调、组合处理的能力，使得在处理多任务的协同工作时更加顺利。

CompletableFuture 和 FutureTask 属于 Future 接口的实现类，都可以获取线程的执行结果。

CompletableFuture创建

构造函数

最简单的方式是通过构造函数直接 new 一个 CompletableFutrue 实例。

CompletableFuture<Object> completableFuture = new CompletableFuture<>();
Object join = completableFuture.join();
System.out.println(join);
// 无输出

但需要注意的是，新创建的 CompletableFuture 没有计算结果时，当前线程执行 join 方法，会一直阻塞。

我们可以通过 complete 方法给当前线程设置结果。

CompletableFuture<Object> completableFuture = new CompletableFuture<>();
completableFuture.complete("create");
Object join = completableFuture.join();
System.out.println(join);

// 输出create

或者交由另外的线程设置计算结果，这样就实现了线程间协作。

CompletableFuture<Object> completableFuture = new CompletableFuture<>();
new Thread(() -> {
    try {
        System.out.println("开始等待");
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("结束等待");
    completableFuture.complete("create");
}).start();
System.out.println("获取值");
Object join = completableFuture.join();
Thread.sleep(1000);
System.out.println(join);

输出结果

获取值
开始等待
结束等待
create

completedFuture创建

CompletableFuture.completedFuture 设置一个计算结果，这样 CompletableFuture 相当于已经执行过了 complete 了。当然，一般情况下这个使用较少。

/**
     * Returns a new CompletableFuture that is already completed with
     * the given value.
     *
     * @param value the value
     * @param <U> the type of the value
     * @return the completed CompletableFuture
     */
public static <U> CompletableFuture<U> completedFuture(U value) {
    return new CompletableFuture<U>((value == null) ? NIL : value);
}

这里来看一下案例

CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("completedFuture");
String join1 = completedFuture.join();
log.info("result=>{}",join1);

completedFuture = CompletableFuture.completedFuture(null);
log.info("result=>{}",completedFuture.join());

输出结果

result=>completedFuture
result=>null

runAsync创建

CompletableFuture.runAsync 要求传入 Runnable 类型的参数，因此没有返回值。所以 runAsync 适合使用在不需要返回值的计算场景中。

CompletableFuture.runAsync 有两个方法签名。其中第二种会允许传入一个线程池，当没有传入自定义线程池时，runAsync 默认会使用内部的 ForkJoinPool 线程池。

public static CompletableFuture<Void> runAsync(Runnable runnable) {
    return asyncRunStage(asyncPool, runnable);
}  

public static CompletableFuture<Void> runAsync(Runnable runnable,
                                               Executor executor) {
    return asyncRunStage(screenExecutor(executor), runnable);
}

简单案例：

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    getThreadName(0);
});
log.info("result=>{}", future.join());

// 输出结果null。

注意这里是会阻塞调用 CompletableFuture.join 的线程来等待结果返回。

supplyAsync创建

CompletableFuture.supplyAsycn 方法与 CompletableFuture.runAsync 类似，区别在于 supplyAsync 接收一个 Supplier 类型的参数，会生成一个返回值，所以 supplyAsync 适用于需要返回值的计算场景中。

简单案例

@Test
public void supplyAsync() {
    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
        getThreadName(0);
        return "success";
    });
    log.info("result=>{}", future.join());
}

输出结果

[ForkJoinPool.commonPool-worker-1] INFO top.zsmile.test.basic.threads.CompletableFutureTest - ThreadName:ForkJoinPool.commonPool-worker-1，value:0
[main] INFO top.zsmile.test.basic.threads.CompletableFutureTest - result=>success

从输出结果可以看出，CompletableFuture 生成的异步线程会打印执行线程信息，并将结果返回给主线程打印。

结果获取

CompletableFutrue 有4类获取结果的方法：

1. public T get() throws InterruptedException, ExecutionException。获取结果。如果出现异常则抛出。
2. public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException。获取结果，并允许传入超时字段，如果时间内没有获取到计算结果，则抛出 TimeoutException 异常，此时结果值为null。注意：就算抛出异常，但任务也不会中断，而是继续执行
3. public T join() 。获取结果，且不会抛出异常。
4. public T getNow(T valueIfAbsent) 。立即获取结果，如果 CompletableFuture的结果未计算完成，则返回传入结果。注意：就算抛出异常，但任务也不会中断，而是继续执行

验证一下。

@Test
public void getResult() throws ExecutionException, InterruptedException {
    // get
    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
        getThreadName(0);
        return "success";
    });
    log.info("result=>{}", future.get());

    // get
    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
        getThreadName(0);
        try {
            int i = 1;
            while (i <= 5) {
                Thread.sleep(1000);
                log.debug("sleep1 1000");
                i++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "success";
    });
    try {
        log.info("result1=>{}", future1.get(2000, TimeUnit.MILLISECONDS));
    } catch (TimeoutException e) {
        log.error("timeout1 => {}", e.getMessage());
    }

    // join
    CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
        getThreadName(0);
        return "success";
    });

    log.info("result2=>{}", future2.join());

    // getNow
    CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
        getThreadName(0);
        try {
            int i = 1;
            while (i <= 5) {
                Thread.sleep(1000);
                log.debug("sleep2 1000");
                i++;
            }
            log.info("over");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "success";
    });
    log.info("result3=>{}", future3.getNow("6666"));
    Thread.sleep(10000);
    log.info("result3=>{}", future3.getNow("6666"));
}

输出结果

11:12:26.581 [ForkJoinPool.commonPool-worker-1] INFO top.zsmile.test.basic.threads.CompletableFutureTest - ThreadName:ForkJoinPool.commonPool-worker-1，value:0
11:12:26.585 [main] INFO top.zsmile.test.basic.threads.CompletableFutureTest - result=>success
11:12:26.586 [ForkJoinPool.commonPool-worker-1] INFO top.zsmile.test.basic.threads.CompletableFutureTest - ThreadName:ForkJoinPool.commonPool-worker-1，value:0
11:12:27.601 [ForkJoinPool.commonPool-worker-1] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep1 1000
11:12:28.592 [main] ERROR top.zsmile.test.basic.threads.CompletableFutureTest - timeout1 => null
11:12:28.592 [ForkJoinPool.commonPool-worker-2] INFO top.zsmile.test.basic.threads.CompletableFutureTest - ThreadName:ForkJoinPool.commonPool-worker-2，value:0
11:12:28.592 [main] INFO top.zsmile.test.basic.threads.CompletableFutureTest - result2=>success
11:12:28.592 [main] INFO top.zsmile.test.basic.threads.CompletableFutureTest - result3=>6666
11:12:28.592 [ForkJoinPool.commonPool-worker-2] INFO top.zsmile.test.basic.threads.CompletableFutureTest - ThreadName:ForkJoinPool.commonPool-worker-2，value:0
11:12:28.607 [ForkJoinPool.commonPool-worker-1] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep1 1000
11:12:29.603 [ForkJoinPool.commonPool-worker-2] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep2 1000
11:12:29.618 [ForkJoinPool.commonPool-worker-1] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep1 1000
11:12:30.614 [ForkJoinPool.commonPool-worker-2] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep2 1000
11:12:30.630 [ForkJoinPool.commonPool-worker-1] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep1 1000
11:12:31.615 [ForkJoinPool.commonPool-worker-2] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep2 1000
11:12:31.631 [ForkJoinPool.commonPool-worker-1] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep1 1000
11:12:32.623 [ForkJoinPool.commonPool-worker-2] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep2 1000
11:12:33.630 [ForkJoinPool.commonPool-worker-2] DEBUG top.zsmile.test.basic.threads.CompletableFutureTest - sleep2 1000
11:12:33.630 [ForkJoinPool.commonPool-worker-2] INFO top.zsmile.test.basic.threads.CompletableFutureTest - over
11:12:38.605 [main] INFO top.zsmile.test.basic.threads.CompletableFutureTest - result3=>success

join和get的区别

另外 join 和 get 相同之处都是阻塞获取结果，那么这个异常抛出的差别是什么呢？

@Test
public void getOrJoin() {
    try {
        CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> 1 / 0);
        log.info("join result => {}", integerCompletableFuture.join());
    } catch (Exception e) {
        e.printStackTrace();
    }
    try {
        CompletableFuture<Integer> integerCompletableFuture2 = CompletableFuture.supplyAsync(() -> 1 / 0);
        log.info("get result => {}", integerCompletableFuture2.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}

输出结果

java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
...

java.util.concurrent.ExecutionException: java.lang.ArithmeticException: / by zero
...

这里 join 抛出 CompletionException 异常，而 get 抛出 ExecutionException 异常，既然都抛出了异常，那么他们的差别在于哪里呢？

1. join 抛出的是 unchecked 异常，即 RuntimeException 异常，这种异常在检查期间不会抛出，也不会强制要求开发者进行捕获。并且会将异常包装成 CancellationException 和 CompletionException 异常。
2. get 抛出的是经过检查的异常，InterruptedException 和 ExecutionException 。需要开发捕获处理。

流式计算

CompletableFuture 与 Future 最大的不同在于其对流式计算的支持，多个任务之间，可以关联，形成计算流。并对不同任务的计算结果进行处理。

CompletableFuture 流式方法的大致可以分为两类 带Async 和 不带Async的。带 Async 的会单独提交到线程池中。

• 前言
• 示例说明
• 注意事项
  • 案例1
  • Object#wait 和 Thread.sleep 差异在哪里
• 总结

前言

这里主要探讨中断常用的三个方法:

• interrupt()。在一个线程中调用需要中断现成的interrupt()方法，会对该线程发出信号，将中断状态标志为true
• isInterrupted()。判断当前线程的中断状态。
• interrupted()。将线程的中断状态恢复。

主要使用的阻塞三个方法：

• Object#wait。放弃锁+等待+重新获取锁
• Thread#join。【协作】等待某个线程执行完毕
• Thread#sleep。静态方法，线程休眠并让出CPU时间片

==注意：interrupt()不能中断在运行中的线程，它只能改变中断状态而已。实际完成的是让受阻塞的线程退出阻塞状态。==
确切的说：是被三种方法之一阻塞时，调用该线程的interrupt()方法，那么线程将抛出一个个InterruptedException中断异常，从而提早地终结被阻塞状态。

示例说明

public class Runner3 implements Runnable {
    @Override
    public void run() {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("我进入中断了，但我还在跑");
            } else {
                System.out.println("我没有进入中断");
            }
        }
    }
    
    public static void main(String[] args) {

        Runner3 runner3 = new Runner3();
        Thread thread3 = new Thread(runner3);
        thread3.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        thread3.interrupt();
    }
}

输出结果大致如下：

我没有进入中断
我没有进入中断
我进入中断了，但我还在跑
我进入中断了，但我还在跑
我进入中断了，但我还在跑
...

这里看到，执行interrupt()后，对线程执行中断后依然在执行，线程依然在运行。

我们调整一下run方法

   public void run() {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("我进入中断了，但我还在跑");
                Thread.interrupted();//重置状态
            } else {
                System.out.println("我没有进入中断");
            }
        }
    }

输出结果如下：

我没有进入中断
我没有进入中断
我进入中断了，但我还在跑
我没有进入中断
我没有进入中断
...

这里看到中断的状态重置了，那么我们如何去应用这个中断状态呢？

注意事项

• 当线程A执行到wait(),sleep(),join()时,抛出InterruptedException后，中断状态已经被系统复位了，线程A调用Thread.interrupted()返回的是false。
• 如果线程被调用了interrupt()，此时该线程并不在阻塞状态时，下次执行wait(),sleep(),join()时，一样会抛出InterruptedException，当然抛出后该线程的中断状态也会被系统复位。

案例1

public class Runner3 implements Runnable {
    @Override
    public void run() {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("我进入中断了，但我还在跑");
//               
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("2"+Thread.currentThread().isInterrupted());
                    //输出false
                }
            } else {
                System.out.println("我没有进入中断");
            }
            
        }
    }

    public static void main(String[] args) {
        Runner3 runner3 = new Runner3();
        Thread thread3 = new Thread(runner3);
        thread3.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread3.interrupt();
    }
}

执行上面的代码，我们可以看到在抛出异常后，Thread.currentThread().isInterrupted()输出为false，证明线程的中断状态已经复位了。

另外因为我们是先执行了interrupt()然后再进入睡眠状态，但是依然抛出了异常。

Object#wait 和 Thread.sleep 差异在哪里

因为Object#wait方法会阻塞线程，所以当我们执行interrupt时，会抛出InterruptedException异常。

那么Object#wait方法阻塞线程会导致的差异在哪里？
==最主要的差别在于sleep方法没有释放锁，而wait方法释放了锁，使得其它线程可以使用同步控制块或者方法。==

总结

1. 调用interrupt方法，会改变中断状态，但不会影响线程的运行状态。
2. 当执行了interrupt方法改变中断状态后，线程若执行Object#wait，Thread#sleep和Thread#join都会抛出InterruptedException异常，然后复位中断状态
3. 当执行了interrupt方法改变中断状态后，线程未阻塞，且将要执行Object#wait，Thread#sleep和Thread#join阻塞线程时，都会抛出InterruptedException异常，复位中断状态。

• 前言

前言

Java 中线程池的4中拒绝策略

• AbortPolicy：丢弃任务并抛出 RejectedExecutionException 异常，这是线程池默认的拒绝策略。于是你便可以根据业务逻辑选择重试或者放弃提交等策略。
• DiscardPolicy：丢弃任务，但是不抛出异常。如果线程队列已满，则后续提交的任务都会被丢弃，且是静默丢弃。 使用此策略，可能会使我们无法发现系统的异常状态。建议是一些无关紧要的业务采用此策略
• DiscardOldestPolicy： 如果线程池没被关闭且没有能力执行，则会丢弃任务队列中的头结点，通常是存活时间最长的任务，这种策略与第二种不同之处在于它丢弃的不是最新提交的，而是队列中存活时间最长的，这样就可以腾出空间给新提交的任务，但同理它也存在一定的数据丢失风险。
• CallerRunsPolicy： 有新任务提交后，如果线程池没被关闭且没有能力执行，则把这个任务交于提交任务的线程执行，也就是谁提交任务，谁就负责执行任务。这样做主要有两点好处。
  1. 新提交的任务不会丢失，也就不会造成业务损失
  2. 由于谁提交任务谁就要负责执行任务，而执行任务又是比较耗时的，在这段期间，提交任务的线程被占用，也就不会再提交新的任务，减缓了任务提交的速度，相当于是一个负反馈。在此期间，线程池中的线程也可以充分利用这段时间来执行掉一部分任务，腾出一定的空间，相当于是给了线程池一定的缓冲期。

• 利用 ThreadFactory 统一处理异常

利用 ThreadFactory 统一处理异常

线程池的使用必不可少，使用无返回值 execute() 方法时，线程执行发生异常的话，需要记录日志，方便回溯，一般做法是在线程执行方法内 try/catch 处理 ，如下所示：

@Test
public void thread() {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100));
    threadPoolExecutor.execute(() -> {
        try {
            log.info(Thread.currentThread().getName());
            int i = (1 / 0);
        } catch (Exception e) {
            log.error("发生异常 => {}", e);
        }
    });

    try {
        Thread.sleep(10000000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

因为线程池一般情况下，都不会在一个项目里创建多个线程池，那么随着线程池在项目中多个地方提交任务时，使用 try/catch 进行异常捕获和记录，对于整个线程池管理非常不方便。我们可以通过利用 ThreadFactory ，在创建线程时，指定 setUncaughtExceptionHandler 异常处理方法，这样就可以做到全局处理异常。

@Test
public void test() {
    ThreadFactory threadFactory = r -> {
        Thread thread = new Thread(r);
        thread.setName("testThread");
        thread.setUncaughtExceptionHandler((t, err) -> {
            log.info(t.getName());
            log.error("err => {}", err);
        });
        return thread;
    };
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100), threadFactory);
    //        threadPoolExecutor.setThreadFactory(threadFactory);
    threadPoolExecutor.execute(() -> {
        log.info(Thread.currentThread().getName());
        int i = (1 / 0);
    });

    try {
        Thread.sleep(10000000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

• 线程池状态
• 线程池实现原理（TODO）

线程池状态

• RUNNING
  • 线程池会接收新任务，并处理阻塞队列里面的任务
  • 通过调用 shutdown() 方法，会切换到 SHUTDOWN 状态
  • 通过调用 shutdownNow() 方法，会切换到 STOP 状态
• SHUTDOWN
  • 线程池不会接收新任务，但会处理阻塞队列中的任务；
  • 队列为空，并且线程池中执行任务也为空,进入 TIDYING 状态;
• STOP
  • 线程池不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；
  • 线程池中执行任务为空,进入 TIDYING 状态;
• TIDYING
  • 该状态表明所有任务已经运行终止，记录的任务数量为 0。
  • terminated()执行完毕，进入 TERMINATED 状态
• TERMINATED
  • 该状态表示线程池彻底终止

线程池实现原理（TODO）

• JDK、JRE、JVM的关系
  • JDK
  • JRE
  • JVM
  • JDK 与 JRE、JVM 之间的关系
• JDK的发展过程与版本变迁
  • JDK版本列表
  • Java大事记

JDK、JRE、JVM的关系

JDK

JDK（Java Development Kit） 是用于开发 Java 应用程序的软件开发工具集合，包括 了 Java 运行时的环境（JRE）、解释器（Java）、编译器（javac）、Java 归档 （jar）、文档生成器（Javadoc）等工具。简单的说我们要开发Java程序，就需要安 装某个版本的JDK工具包。

JRE

JRE（Java Runtime Enviroment ）提供 Java 应用程序执行时所需的环境，由 Java 虚拟机（JVM）、核心类、支持文件等组成。简单的说，我们要是想在某个机器上运 行Java程序，可以安装JDK，也可以只安装JRE，后者体积比较小。

JVM

Java Virtual Machine（Java 虚拟机）有三层含义，分别是：

• JVM规范要求 满足 JVM
• 规范要求的一种具体实现（一种计算机程序）
• 一个 JVM 运行实例，在命令提示符下编写 Java 命令以运行 Java 类时，都会创建一 个 JVM 实例，我们下面如果只记到JVM则指的是这个含义；如果我们带上了某种JVM 的名称，比如说是Zing JVM，则表示上面第二种含义

JDK 与 JRE、JVM 之间的关系

就范围来说，JDK > JRE > JVM：

• JDK = JRE + 开发工具
• JRE = JVM + 类库

三者在开发运行Java程序时的交互关系：

1. 简单的说，就是通过JDK开发的程序，编译以后，可以打包分发给其他装有JRE的机器上去运行。
2. 运行的程序，则是通过java命令启动的一个JVM实例，代码逻辑的执行都运行在这个JVM实例上。

Java程序的开发运行过程为：

1. 我们利用 JDK （调用 Java API）开发Java程序，编译成字节码或者打包程序
2. 然后可以用 JRE 则启动一个JVM实例，加载、验证、执行 Java 字节码以及依赖库， 运行Java程序
3. 而JVM 将程序和依赖库的Java字节码解析并变成本地代码执行，产生结果

JDK的发展过程与版本变迁

JDK版本列表

Java大事记

1. 1995年5月23日，Java语言诞生
2. 1996年1月，第一个JDK­JDK1.0诞生
3. 1997年2月18日，JDK1.1发布
4. 1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模 之纪录
5. 1997年9月，Java开发者社区成员超过十万
6. 1998年2月，JDK1.1被下载超过200万次
7. 1998年12月8日，JAVA2企业平台J2EE发布
8. 1999年6月，Sun公司发布Java的三个版本：标准版、企业版和微型版（J2SE、 J2EE、J2ME)
9. 2000年5月8日，JDK1.3发布
10. 2000年5月29日，JDK1.4发布
11. 2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升
12. 2004年9月30日，J2SE1.5发布，是Java语言的发展史上的又一里程碑事件，Java并发包JUC也是这个版本引入的。为了表示这个版本的重要性，J2SE1.5更 名为J2SE5.0
13. 2005年6月，发布Java SE 6，这也是一个比较长期使用的版本
14. 2006年11月13日，Sun公司宣布Java全线采纳GNU General Public License Version 2，从而公开了Java的源代码
15. 2009年04月20日，Oracle公司74亿美元收购Sun。取得java的版权
16. 2011年7月28日，Oracle公司发布Java SE7.0的正式版
17. 2014年3月18日，Oracle公司发布ava SE 8，这个版本是目前最广泛使用的版本
18. 2017年9月22日，JDK9发布，API有了较大的调整，添加了对WebSocket和 HTTP/2的支持，此后每半年发布一个大版本
19. 2018年3月21日，JDK10发布，最大的变化就是引入了var，如果你熟悉C#或 JavaScript/NodeJS就会知道它的作用
20. 2018年9月25日，JDK11发布，引入ZGC，这个也是第一个公布的长期维护版本 LTS
21. 2019年3月19日，JDK12发布，引入毫秒级停顿的Shenandoah GC
22. 2019年9月17日，JDK13发布，改进了CDS内存共享，ZGC归还系统内

常规的JDK，一般指OpenJDK或者Oracle JDK，当然Oracle还有一个新的JVM叫 GraalVM，也非常有意思。除了Sun/Oracle的JDK以外，原BEA公司（已被Oracle 收购）的JRockit，IBM公司的J9，Azul公司的Zing JVM，阿里巴巴公司的分支版 本DragonWell等等。

• 编程语言类型
  • 编程语言分类
  • 高级语言分类
• 关于跨平台
  • 小结
• 关于运行时（Runtime）与虚拟机（VM）
• 关于内存管理和垃圾回收（GC）
  • 总结

编程语言类型

编程语言分类

程从底向上划分为最基本的三大类：机器语言、汇编 语言、高级语言。

graph TD
机器语言-->汇编语言
汇编语言-->高级语言

按《计算机编程语言的发展与应用》一文里的定义：计算机编程语言能够实现人与机器之间的交流和沟通，而计算机编程语言主要包括汇编语言、机器语言以及高级语 言，具体内容如下：

• 机器语言：这种语言主要是利用二进制编码进行指令的发送，能够被计算机快速地识别，其灵活性相对较高，且执行速度较为可观，机器语言与汇编语言之间的相似性较高，但由于具有局限性，所以在使用上存在一定的约束性。
• 汇编语言：该语言主要是以缩写英文作为标符进行编写的，运用汇编语言进行编写的一般都是较为简练的小程序，其在执行方面较为便利，但汇编语言在程序方 面较为冗长，所以具有较高的出错率。
• 高级语言：所谓的高级语言，其实是由多种编程语言结合之后的总称，其可以对多条指令进行整合，将其变为单条指令完成输送，其在操作细节指令以及中间过程等方面都得到了适当的简化，所以，整个程序更为简便，具有较强的操作性，而这种编码方式的简化，使得计算机编程对于相关工作人员的专业水平要求不断放宽。

总之：机器语言是直接给机器执行的二进制指令，每种CPU平台都有对应的机器语言；
而汇编语言则相当于是给机器执行的指令，按照人可以理解的助记符表示，这样代码就非常长，但是性能也很好；
高级语言则是为了方便人来理解，进而快速设计和实现程序代码，一般跟机器语言和汇编语言的指令已经完全没有关系了，代码编写完成后通过编译或解释，转换成汇编 码或机器码，之后再传递给计算机去执行。

所以机器语言和汇编语言都是跟目标机器的CPU架构有直接联系，而高级语言一般就没有关系了，高级语言高级就高级在，一份代码往往是可以跨不同的目标机器的CPU架构的，不管是x86还是其他CPU，尽管不同CPU支持的指令集略有不同，但是都在编译或解释过程之后，变成实际平台的目标代码，进而代码的开发者很大程度上不需要关心目标平台的差异性。

高级语言分类

如果按照有没有虚拟机来划分，高级编程语言可分为两类：

• 有虚拟机：Java，Lua，Ruby，部分JavaScript的实现等等
• 无虚拟机：C，C++，C#，Golang，以及大部分常见的编程语言

如果按照变量是不是有确定的类型，还是类型可以随意变化来划分，高级编程语言可以分为：

• 静态类型：Java，C，C++等等
• 动态类型：所有脚本类型的语言

如果按照是编译执行，还是解释执行，可以分为：

• 编译执行：C，C++，Golang，Rust，C#，Java，Scala，Clojure，Kotlin， Swift...等等
• 解释执行：JavaScript的部分实现和NodeJS，Python，Perl，Ruby...等等

C#和Java都是编译后生成了一种中间类型的目标代码（类似汇编），但不是 汇编或机器码，在C#中称为 微软中间语言 （MSIL），在Java里叫做 Java字节码 （Java bytecode）。

虽然一般把JavaScript当做解释执行语言，但如今不少实现引擎都支持编译，比如 Google V8和Oracle Nashorn

我们还可以按照语言特点分类：

• 面向过程：C，Basic，Pascal，Fortran等等
• 面向对象：C++，Java，Ruby，Smalltalk等等
• 函数式编程：LISP、Haskell、Erlang、OCaml、Clojure、F#等等

关于跨平台

因为我们希望所编写的代码和程序，在源代码级别或者编译后，可以运行在多种不同的系统平台上，而不需要为了各个平台的不同点而去实现两套代码。

一般来说解释型语言都是跨平台的，同一份脚本代码，可以由不同平台上的解释器解释执行。
但是对于编译型语言，存在两种级别的跨平台：

• 典型的源码跨平台（C++）：
• 典型的二进制跨平台（Java字节码）：

Java语言通过虚拟机技术率先解决了这个难题。 源码只需要编译一次，然后把编译后的class文件或jar包，部署到不同平台，就可以直接通过安装在这些系统中的JVM上面执行。
同时可以把依赖库（jar文件）一起复制到目标机器，慢慢地又有了可以在各个平台都直接使用的Maven中央库（类似于linux里的yum或apt­get源，macos里的 homebrew，现代的各种编程语言一般都有了这种包依赖管理机制：python的pip，dotnet的nuget，NodeJS的npm，golang的dep，rust的cargo等等）。这样就实现了让同一个应用程序在不同的平台上直接运行的能力。

小结

• 脚本语言直接使用不同平台的解释器执行，称之为脚本跨平台，平台间的差异由不同平台上的解释器去解决。这样的话代码很通用，但是需要解释和翻译，效率较低。
• 编译型语言的代码跨平台，同一份代码，需要被不同平台的编译器编译成相应的二进制文件，然后再去分发和执行，不同平台间的差异由编译器去解决。编译产生的文件是直接针对平台的可执行指令，运行效率很高。但是在不同平台上编译复杂软件，依赖配置可能会产生很多环境方面问题，导致开发和维护的成本较高。
• 编译型语言的二进制跨平台，同一份代码，先编译成一份通用的二进制文件，然后分发到不同平台，由虚拟机运行时来加载和执行，这样就会综合另外两种跨平台语言的优势，方便快捷地运行于各种平台，虽然运行效率可能比起本地编译类 型语言要稍低一点。而这些优缺点也是Java虚拟机的优缺点

现代商业应用最宝贵的是时间和人力,对大部分系统来说，机器相对来说就不是那么值钱了。

关于运行时（Runtime）与虚拟机（VM）

Java运行时和JVM虚拟机，简单的说JRE就是Java的运行时，包括虚拟机和相关的库等资源。
可以说运行时提供了程序运行的基本环境，JVM在启动时需要加载所有运行时的核心库等资源，然后再加载我们的应用程序字节码，才能让应用程序字节码运行在JVM这个容器里。

但也有一些语言是没有虚拟机的，编译打包时就把依赖的核心库和其他特性支持，一起静态打包或动态链接到程序中，比如Golang和Rust，C#等。这样运行时就和程序指令组合在一起，成为了一个完整的应用程序，好处就是不需要 虚拟机环境，坏处是编译后的二进制文件没法直接跨平台了。

关于内存管理和垃圾回收（GC）

自从编程语言诞生以来，内存管理一直都是个非常重要的话题。因为内存资源总是有限而又宝贵的，只占用不释放，很快就会用完了。程序得不到可用内存就会崩溃（想 想C++里动不动就出现的野指针）。

内存管理就是内存的生命周期管理，包括内存的申请、压缩、回收等操作。

Java的内存管理就是GC，JVM的GC模块不仅管理内存的回收，也负责内存的分配和压缩整理。
Java程序的指令都运行在JVM上，而且我们的程序代码 并不需要去分配内存和释放内存（例如C/C++里需要使用的malloc/free），那么这些操作自然是由JVM帮我们搞定的。
JVM在我们创建Java对象的时候去分配新内存，并使用GC算法，根据对象的存活时间，在对象不使用之后，自动执行对象的内存回收操作。

对于Golang和Rust这些语言来说，其实也是存在垃圾回收的，但是它们没有虚拟机， 又是怎么实现的呢？
诀窍就在于运行时（Runtime），编译打包的时候，可以把内存使用分析的模块一起打包到应用程序中，在运行期间有专门的线程来分析内存使用情况，进而决定什么时 候执行GC，把不再使用的内存回收掉。这样就算是没有虚拟机，也可以实现GC。
而Rust语言则更进一步，直接在语言规范层面限制了所有变量的生命周期，如果超出了一个明确的范围，就会不可用，这样在编译期就能直接知道每个对象在什么时候应该分配内存，什么时候应该销毁并回收内存，做到了很精确并且很安全的内存管理。

总结

• C/C++完全相信而且惯着程序员，让大家自行管理内存，所以可以编写很自由的代码，但一个不小心就会造成内存泄漏等问题导致程序崩溃。
• Java/Golang完全不相信程序员，但也惯着程序员。所有的内存生命周期都由JVM/运行时统一管理。在绝大部分场景下，你可以非常自由的写代码，而且不 用关心内存到底是什么情况。内存使用有问题的时候，我们可以通过JVM来信息 相关的分析诊断和调整。
• Rust语言选择既不相信程序员，也不惯着程序员。 让你在写代码的时候，必须清楚明白的用Rust的规则管理好你的变量，好让机器能明白高效地分析和管理内存。 但是这样会导致代码不利于人的理解，写代码很不自由，学习成本也很高。

首先，Rust是有点反人类，否则不会一直都不火。然后，Rust之所以反人类，是因为人类这玩意既愚蠢，又自大，破事还贼多。你看C++就很相信人类，它要求人类自己把自己new出来的东西给delete掉。
C++：“这点小事我相信你可以的！”
人类：“没问题！包在我身上！”
然后呢，内存泄漏、double free、野指针满世界飘…… C++：“……”
Java选择不相信人类，但替人类把事办好。
Java：“别动，让我来，我有gc！” 人类：“你怎么做事这么慢呀？你怎么还stop the world了呀？你是不是不爱我了 呀？”
Java：“……”
Rust发现唯一的办法就是既不相信人类，也不惯着人类。
Rust：“按老子说的做，不做就不编译！”
人类：“你反人类！” Rust：“滚！

• 理论
  • 什么是RPC?
  • RPC原理是什么？

理论

什么是RPC?

RPC (Remote Procedure Call) 即远程过程调用。

RPC能够帮助我门将两个不同的服务器上的服务提供的方法，所需要的网络编程调用实现，使得将远程服务的方法像本地调用一样简单，并且忽略具体的底层网络实现细节。

RPC原理是什么？

RPC的核心功能组成大致可以看作以下几个部分：

1. 客户端（消费者）。调用远程方法的一端。
2. 客户端 Stub(桩)。代理类，将调用的服务的类，方法，参数和类型等信息传输到服务端。
3. 网络传输。就是通过什么样的网络形式和数据协议进行传输，常见的实现方式有基于自定义TCP或HTTP。
4. 服务端 Stub(桩)。实际接收到的请求信息后，调取对应的方法返回处理结果给客户端。
5. 服务端（提供者）。提供远程方法的一端。

流程大致如下：

graph TD
客户端-->|1|客户端Stub
客户端Stub-->|2|网络传输
网络传输-->|3|服务端Stub
服务端Stub-->|4|服务端
服务端-->|5|服务端Stub
服务端Stub-->|6|网络传输
网络传输-->|7|客户端Stub
客户端Stub-->|8|客户端

1. 服务消费端（Client）以本地调用的方式调用远程服务（Service）
2. 消费端Stub（Client stub）接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体（序列化）：RpcRequest
3. 消费端Stub（Client stub）找到远程服务地址，并将序列化后的消息发送给服务端Stub
4. 服务端Stub（Server Stub）收到消息后，将消息反序列化为Java对象：RpcRequest
5. 服务端Stub（Server Stub）根据对象中的类、方法、参数等信息调用本地方法。
6. 服务端Stub（Server Stub）得到方法执行的结果并将其组装成能够进行网络传输的消息体：RpcResponse（序列化）发送至消费端
7. 消费端Stub（Client Stub）接收到消息并将消息反序列化为Java对象：RpcResponse，这样就执行完整个调用流程了。

关于WIKI上的RPC流程介绍

1. 客户端调用客户端stub（client stub）。这个调用是在本地，并将调用参数push到栈（stack）中。
2. 客户端stub（client stub）将这些参数包装，并通过系统调用发送到服务端机器。打包的过程叫 marshalling。（常见方式：XML、JSON、二进制编码）
3. 客户端本地操作系统发送信息至服务器。（可通过自定义TCP协议或HTTP传输）
4. 服务器系统将信息传送至服务端stub（server stub）。
5. 服务端stub（server stub）解析信息。该过程叫 unmarshalling。
6. 服务端stub（server stub）调用程序，并通过类似的方式返回给客户端。

• 设计自己的RPC框架
  • 相关技术
  • 参考Dubbo
• 功能
• 注册中心
  • zookeeper
• 序列化/反序列化
• 负债均衡
• 传输协议
• 动态代理
• 网络传输
  • Netty

设计自己的RPC框架

相关技术

• Java

1. 动态代理机制；
2. 序列化机制以及各种序列化框架的对比，比如 hession2、kryo、protostuff；
3. 线程池的使用；
4. CompletableFuture 的使用；

• Netty

  1. 使用 Netty 进行网络传输；
  2. ByteBuf 介绍；
  3. Netty 粘包拆包；
  4. Netty 长连接和心跳机制；

• Zookeeper

  1. 基本概念；
  2. 数据结构；
  3. 如何使用 Netflix 公司开源的 Zookeeper 客户端框架 Curator 进行增删改查；

参考Dubbo

官网：https://cn.dubbo.apache.org/zh-cn/overview/home/

Dubbo节点简单说明：

• Provider： 暴露服务的服务提供方
• Consumer： 调用远程服务的服务消费方
• Registry： 服务注册与发现的注册中心
• Monitor： 统计服务的调用次数和调用时间的监控中心
• Container： 服务运行容器

Duboo 调用关系说明：

1. 服务容器负责启动，加载，运行服务提供者。
2. 服务提供者在启动时，向注册中心注册自己提供的服务。
3. 服务消费者在启动时，向注册中心订阅自己所需的服务。
4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
5. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

功能

• 注册中心 ：注册中心负责服务地址的注册与查找，相当于目录服务。
• 网络传输 ：既然我们要调用远程的方法，就要发送网络请求来传递目标类和方法的信息以及方法的参数等数据到服务提供端。
• 序列化和反序列化 ：要在网络传输数据就要涉及到序列化。
• 动态代理 ：屏蔽远程方法调用的底层细节。
• 负载均衡 ： 避免单个服务器响应同一请求，容易造成服务器宕机、崩溃等问题。
• 传输协议 ：这个协议是客户端（服务消费方）和服务端（服务提供方）交流的基础。

注册中心

注册中心主要提供服务地址的注册和查找功能。服务端启动时将服务名称及地址注册到注册中心，消费端通过服务名称找到对应的服务地址。有了服务地址之后，消费端就可以通过网络请求服务端。

框架选型：

• zookeeper
• nacos
• apollo
• redis

zookeeper

ZooKeeper 为我们提供了高可用、高性能、稳定的分布式数据一致性解决方案，通常被用于实现诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master 选举、分布式锁和分布式队列等功能。并且，ZooKeeper 将数据保存在内存中，性能是非常棒的。 在“读”多于“写”的应用程序中尤其地高性能，因为“写”会导致所有的服务器间同步状态。（“读”多于“写”是协调服务的典型场景）。

https://javaguide.cn/distributed-system/distributed-process-coordination/zookeeper/zookeeper-intro.html

https://curator.apache.org/docs/about/

https://zhuanlan.zhihu.com/p/603185454

序列化/反序列化

要在网络传输数据就要涉及到序列化。为什么需要序列化和反序列化呢？ 因为网络传输的数据必须是二进制的。因此，我们的 Java 对象没办法直接在网络中传输。为了能够让 Java 对象在网络中传输我们需要将其序列化为二进制的数据。我们最终需要的还是目标 Java 对象，因此我们还要将二进制的数据“解析”为目标 Java 对象，也就是对二进制数据再进行一次反序列化。

另外，不仅网络传输的时候需要用到序列化和反序列化，将对象存储到文件、数据库等场景都需要用到序列化和反序列化。

JDK 自带的序列化，只需实现 java.io.Serializable接口即可，不过这种方式不推荐，因为不支持跨语言调用并且性能比较差。

常见序列化：

• hessian
• kryo
• protostuff

负债均衡

负载均衡就是为了避免单个服务器响应同一请求，容易造成服务器宕机、崩溃等问题。从单机的角度提升服务器处理能力，无论是提升 CPU 处理能力，还是增加内存、磁盘等空间，都不能满足日益增长的大流量、高并发、海量数据在高性能、高可用性等方面的需求。因此，只能通过横向扩展，增加服务器，即采用集群和负载均衡架构，来共同分担访问压力、提升业务处理能力。

简单来说，就是数据中心内部会以集群模式构建各种服务，通过在入口部署负载均衡，对外提供高访问量服务，提高应用程序的可用性、可靠性和可扩展性。这就是负载均衡的产生背景，也是负载均衡技术架构设计的来源。

https://c.biancheng.net/view/9823.html

https://help.aliyun.com/document_detail/132403.html

传输协议

通过设计协议，我们定义需要传输哪些类型的数据， 并且还会规定每一种类型的数据应该占多少字节。这样我们在接收到二进制数据之后，就可以正确的解析出我们需要的数据。

通常一些标准的 RPC 协议包含下面这些内容：

• 魔数 ： 通常是 4 个字节。这个魔数主要是为了筛选来到服务端的数据包，有了这个魔数之后，服务端首先取出前面四个字节进行比对，能够在第一时间识别出这个数据包并非是遵循自定义协议的，也就是无效数据包，为了安全考虑可以直接关闭连接以节省资源。
• 序列化器编号 ：标识序列化的方式，比如是使用 Java 自带的序列化，还是 json，kryo 等序列化方式。
• 消息体长度 ： 运行时计算出来。

动态代理

代理模式就是： 我们给某一个对象提供一个代理对象，并由代理对象来代替真实对象做一些事情。你可以把代理对象理解为一个幕后的工具人。 举个例子：我们真实对象调用方法的时候，我们可以通过代理对象去做一些事情比如安全校验、日志打印等等。但是，这个过程是完全对真实对象屏蔽的。

RPC 的主要目的就是让我们调用远程方法像调用本地方法一样简单，我们不需要关心远程方法调用的细节比如网络传输。

那如何屏蔽远程方法的调用细节呢？那就是动态代理。

https://javaguide.cn/java/basis/proxy.html

网络传输

既然我们要调用远程的方法，就要发送网络请求来传递目标类和方法的信息以及方法的参数等数据到服务提供端。

常见通信框架：

• Java Socket(不推荐)
• Java Nio（不推荐）
• Netty(推荐使用)

Netty

Netty 是一个基于 NIO 的 client-server(客户端服务器)框架，使用它可以快速简单地开发网络应用程序。 2它极大地简化并简化了 TCP 和 UDP 套接字服务器等网络编程,并且性能以及安全性等很多方面甚至都要更好。 3支持多种协议如 FTP，SMTP，HTTP 以及各种二进制和基于文本的传统协议。

• 目前主流定时任务框架(截至20240126)

目前主流定时任务框架(截至20240126)

• xxl-job
• powerjob
• quartz

• RedisConnectionException异常
  • 方法1

RedisConnectionException异常

io.lettuce.core.RedisConnectionException: Unable to connect to 127.0.0.1:6379

方法1

追踪问题一直以为redis密码错误,最好尝试很多办法依旧没有解决，使用jedis连接却是正常的！！！

解决办法最后在redis 官网问题反馈里找到了答案：

因为使用的spring boot 高版本导致的:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.5</version>
    <relativePath/> 
</parent>

降低版本就行了

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>5.1.4.RELEASE</version>
</dependency>

• Redisson NoClassDefFoundError RedisStreamCommands

Redisson NoClassDefFoundError RedisStreamCommands

在高版本的 redisson-spring-boot-starter v3.13.* 中，本地执行redisson锁正常，但是放到服务器上后提示异常。这是因为缺少 RedisStreamCommands 类，换成较低版本即可

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.11.5</version>
 </dependency>

• 集成
  • springboot集成shiro实现权限控制
    • Maven版本
    • AuthenticationToken
    • Filter
    • Realm
    • Shiro配置
    • 通用的工具
      • JwtUtils.responseError
  • shiro的几种CacheManager
    • MemoryConstrainedCacheManager
      • 使用
      • 源码查看
    • shiro-redis
      • 使用
  • Springboot集成Shiro(启用和禁用Session)
    • Maven
    • OAuth2Token
    • Realm
    • Filter
    • Shiro配置
• 问题记录
  • Springboot+Shiro，使用postman会显示404，需要返回未授权响应(JSON格式)
    • 问题描述
    • 定位原因
    • 解决方案
    • 总结

集成

springboot集成shiro实现权限控制

源码地址：SmileX-boot

Maven版本

引入springboot-start

<!-- springboot-web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.3.5.RELEASE</version>
</dependency>
<!-- shiro-web -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-web-starter</artifactId>
    <shiro.version>1.9.0</shiro.version>
</dependency>

AuthenticationToken

/**
 * TOKEN
 */
public class OAuth2Token implements AuthenticationToken {
    private String token;

    public OAuth2Token(String token) {
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }

    @Override
    public Object getCredentials() {
        return token;
    }
}

Filter

/**
 * 过滤器
 */
public class OAuth2Filter extends BasicHttpAuthenticationFilter {

    @Override
    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
        //获取请求token
        String token = getRequestToken((HttpServletRequest) request);

        if (StringUtils.isBlank(token)) {
            return null;
        }

        return new OAuth2Token(token);
    }

    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        try {
            return executeLogin(request, response);
        } catch (Exception e) {
            JwtUtils.responseError(response, ResultCode.NO_AUTH, CommonConstant.S_INVALID_TOKEN);
            return false;
        }
    }

    @Override
    protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
        //处理登录失败的异常
        JwtUtils.responseError(response, ResultCode.NO_AUTH, CommonConstant.S_INVALID_TOKEN);
        return false;
    }

    /**
     * 获取请求的token
     */
    private String getRequestToken(HttpServletRequest httpRequest) {
        //从header中获取token
        String token = httpRequest.getHeader(CommonConstant.S_ACCESS_TOKEN);

        //如果header中不存在token，则从参数中获取token
        if (StringUtils.isBlank(token)) {
            token = httpRequest.getParameter(CommonConstant.S_ACCESS_TOKEN);
        }

        return token;
    }


}

Realm

public class OAuth2Realm extends AuthorizingRealm {

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof OAuth2Token;
    }

    /**
     * 授权
     *
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        
        // 授权逻辑
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        return simpleAuthorizationInfo;
    }

    /**
     * 认证
     *
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String token = (String) authenticationToken.getCredentials();
        if (token == null) {
            log.info("————————身份认证失败————————，IP地址记录：" + IPUtils.getIpAddrByRequest(SpringContextUtils.getHttpServletRequest()));
            throw new AuthenticationException("身份验证失败");
        }

        // token验证逻辑


        return new SimpleAuthenticationInfo(userId, token, getName());
    }
}

Shiro配置

@Configuration
public class ShiroConfig {

    /**
     * 注入realm
     * @return
     */
    @Bean("oAuth2Realm")
    public OAuth2Realm oAuth2Realm() {
        OAuth2Realm realm = new OAuth2Realm();
        return realm;
    }

    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager,ShiroFilterChainDefinition shiroFilterChainDefinition) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        Map<String, Filter> filters = new HashMap<>();
        filters.put("oauth2", new OAuth2Filter());
        shiroFilterFactoryBean.setFilters(filters);

        shiroFilterFactoryBean.setSecurityManager(securityManager);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition.getFilterChainMap());

        return shiroFilterFactoryBean;
    }

    /**
     * 配置拦截
     * @return
     */
    @Bean
    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
        chainDefinition.addPathDefinition("/sys/login", "anon");
        chainDefinition.addPathDefinition("/**", "oauth2");
        return chainDefinition;
    }

    @Bean("securityManager")
    public DefaultWebSecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        // 注入realm 到securityManager
        List<Realm> realms = new ArrayList<>();
        realms.add(oAuth2Realm());

        securityManager.setRealms(realms);
        securityManager.setRememberMeManager(null);
        return securityManager;
    }

    @Bean
    protected CacheManager cacheManager() {
        return new MemoryConstrainedCacheManager();
    }

    @Bean
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    public static DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        /**
         * setUsePrefix(false)用于解决一个奇怪的bug。在引入spring aop的情况下。
         * 在@Controller注解的类的方法中加入@RequiresRole等shiro注解，会导致该方法无法映射请求，导致返回404。
         * 加入这项配置能解决这个bug
         */
        defaultAdvisorAutoProxyCreator.setUsePrefix(true);
        return defaultAdvisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

通用的工具

JwtUtils.responseError

public static void responseError(ServletResponse response, Integer code, String msg) {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        R fail = R.fail(code, msg);
        try {
            ServletOutputStream outputStream = httpServletResponse.getOutputStream();
            httpServletResponse.setContentType("application/json;charset=utf-8");
httpServletResponse.setStatus(HttpStatus.UNAUTHORIZED.value());
            outputStream.print(JSON.toJSONString(fail));
            outputStream.flush();
            outputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

shiro的几种CacheManager

看官方的文档，提供了三种CacheManager。

1. MemoryConstrainedCacheManager（仅适用于单体应用）
2. HazelcastCacheManager
3. EhCacheManager

第三方提供的：

1. https://github.com/alexxiyang/shiro-redis。基于jedis，文档

对于Hazelcast没有使用过，EhCache现在我使用的比较少，所以我这里

MemoryConstrainedCacheManager

使用

直接注入配置即可。

@Bean
protected CacheManager cacheManager() {
    return new MemoryConstrainedCacheManager();
}

源码查看

这里简单查看一下MemoryConstrainedCacheManager的源码。

// 继承了一个AbstractCacheManager
public class MemoryConstrainedCacheManager extends AbstractCacheManager {
    public MemoryConstrainedCacheManager() {
    }

    protected Cache createCache(String name) {
        return new MapCache(name, new SoftHashMap());
    }
}

public abstract class AbstractCacheManager implements CacheManager, Destroyable {
    private final ConcurrentMap<String, Cache> caches = new ConcurrentHashMap();

    public AbstractCacheManager() {
    }

    public <K, V> Cache<K, V> getCache(String name) throws IllegalArgumentException, CacheException {
        if (!StringUtils.hasText(name)) {
            throw new IllegalArgumentException("Cache name cannot be null or empty.");
        } else {
            Cache cache = (Cache)this.caches.get(name);
            if (cache == null) {
                cache = this.createCache(name);
                Cache existing = (Cache)this.caches.putIfAbsent(name, cache);
                if (existing != null) {
                    cache = existing;
                }
            }

            return cache;
        }
    }
}

public interface CacheManager {
    <K, V> Cache<K, V> getCache(String var1) throws CacheException;
}

public interface Destroyable {
    void destroy() throws Exception;
}

可以看见AbstractCacheManager实现了CacheManager和Destoryable接口，实现了获取缓存和销毁的操作。

同事在AbstractCacheManager的代码内，我们可以看到它是使用了ConcurrentHashMap作为并发存储容器的。

shiro-redis

使用

导入Maven依赖

 <dependency>
     <groupId>org.crazycake</groupId>
     <artifactId>shiro-redis</artifactId>
     <version>3.3.1</version>
     <exclusions>
         <!-- 排除shiro-core包，可选 -->
         <exclusion>
             <groupId>org.apache.shiro</groupId>
             <artifactId>shiro-core</artifactId>
         </exclusion>
     </exclusions>
</dependency>

Springboot集成Shiro(启用和禁用Session)

这里主要是为了说明使用session和不用session的情况，如何取舍就看用户自身需求

1. 如果使用了session，用户登陆一次，则session有效期内的请求则不会再验证token。
2. 如果不适用session，用户每次请求都会验证 token。

Maven

引入springboot-start

<!-- springboot-web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.3.5.RELEASE</version>
</dependency>
<!-- shiro-web -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-web-starter</artifactId>
    <shiro.version>1.9.0</shiro.version>
</dependency>

OAuth2Token

/**
 * TOKEN
 */
public class OAuth2Token implements AuthenticationToken {
    private String token;

    public OAuth2Token(String token) {
        this.token = token;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }

    @Override
    public Object getCredentials() {
        return token;
    }
}

Realm

supports 方法是为了确保 OAuth2Realm 只对 OAuth2Token生效。

public class OAuth2Realm extends AuthorizingRealm {

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof OAuth2Token;
    }

    /**
     * 授权
     *
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        
        // 授权逻辑
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        return simpleAuthorizationInfo;
    }

    /**
     * 认证
     *
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String token = (String) authenticationToken.getCredentials();
        if (token == null) {
            log.info("————————身份认证失败————————，IP地址记录：" + IPUtils.getIpAddrByRequest(SpringContextUtils.getHttpServletRequest()));
            throw new AuthenticationException("身份验证失败");
        }

        // token验证逻辑


        return new SimpleAuthenticationInfo(userId, token, getName());
    }
}

Filter

/**
 * oauth2过滤器
 *
 */
public class OAuth2Filter extends BasicHttpAuthenticationFilter {

    @Override
    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
        //获取请求token
        String token = getRequestToken((HttpServletRequest) request);

        if (StringUtils.isBlank(token)) {
            return null;
        }

        return new OAuth2Token(token);
    }

    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        //获取请求token，如果token不存在，直接返回401
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        String token = getRequestToken(httpServletRequest);
        if (StringUtils.isBlank(token)) {
            JwtUtils.responseError(response, ResultCode.NO_AUTH, CommonConstant.S_INVALID_TOKEN);
            return false;
        }
        return executeLogin(request, response);
    }

    @Override
    protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
        //处理登录失败的异常
        Throwable throwable = e.getCause() == null ? e : e.getCause();
        JwtUtils.responseError(response, ResultCode.NO_AUTH, throwable.getMessage() );

        return false;
    }

    /**
     * 获取请求的token
     */
    private String getRequestToken(HttpServletRequest httpRequest) {
        //从header中获取token
        String token = httpRequest.getHeader(CommonConstant.S_ACCESS_TOKEN);

        //如果header中不存在token，则从参数中获取token
        if (StringUtils.isBlank(token)) {
            token = httpRequest.getParameter(CommonConstant.S_ACCESS_TOKEN);
        }

        return token;
    }


}

• preHandle 方法中，获取Request请求的Method是否为Options是为了解决跨域问题，现在前端浏览器会在发起真正的请求前，发起一次Options请求，用来作为跨域预检。这里捕捉到了以后直接拦截并更改状态为成功后，直接返回。

• protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
          AuthenticationToken token = createToken(request, response);
        if (token == null) {
                String msg = "createToken method implementation returned null. A valid non-null AuthenticationToken " +
                        "must be created in order to execute a login attempt.";
                throw new IllegalStateException(msg);
            }
            try {
                Subject subject = getSubject(request, response);
                subject.login(token);
                return onLoginSuccess(token, subject, request, response);
            } catch (AuthenticationException e) {
                return onLoginFailure(token, e, request, response);
            }
        }
  

  • 重写 createToken 方法是在因为在 exceuteLogin 方法的默认实现中，是通过 createToken 方法获取token信息，因为我们是基于http请求，在header中获取自定义属性的，这里就进行了重写。
  • 重写 onLoginFailure方法是因为执行login方法后，会进入 Realm 类中的 doGetAuthenticationInfo 方法进行认证，当认证失败会抛出 AuthenticationException 异常，此时try-catch捕捉到异常后会调用 onLoginFailure 方法，这时就能根据需要放回异常信息给用户。

Shiro配置

@Slf4j
@Configuration
public class ShiroConfig {

    @Resource
    private LettuceConnectionFactory lettuceConnectionFactory;

    /**
     * 注入realm
     *
     * @return
     */
    @Bean("oAuth2Realm")
    public OAuth2Realm oAuth2Realm() {
        OAuth2Realm realm = new OAuth2Realm();
        return realm;
    }

    @Bean(name = "shiroFilterFactoryBean")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager, ShiroFilterChainDefinition shiroFilterChainDefinition) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        Map<String, Filter> filters = new HashMap<>();
        filters.put("oauth2", new OAuth2Filter());
        shiroFilterFactoryBean.setFilters(filters);

        shiroFilterFactoryBean.setSecurityManager(securityManager);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition.getFilterChainMap());


        return shiroFilterFactoryBean;
    }

    /**
     * 配置拦截
     *
     * @return
     */
    @Bean
    public ShiroFilterChainDefinition shiroFilterChainDefinition() {
        DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
        chainDefinition.addPathDefinition("/sys/login", "anon");
        chainDefinition.addPathDefinition("/**", "oauth2");
        return chainDefinition;
    }

    @Bean("securityManager")
    public DefaultWebSecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        // 注入realm 到securityManager
        List<Realm> realms = new ArrayList<>();
        realms.add(oAuth2Realm());

        securityManager.setRealms(realms);
        securityManager.setCacheManager(cacheManager());
        securityManager.setSessionManager(defaultSessionManager());
        securityManager.setRememberMeManager(null);
        return securityManager;
    }

    @Bean
    public DefaultSessionManager defaultSessionManager() {
        DefaultWebSessionManager defaultWebSessionManager = new DefaultWebSessionManager();
        //有效期30分钟
        defaultWebSessionManager.setGlobalSessionTimeout(30 * 60 * 1000);
        defaultWebSessionManager.setCacheManager(cacheManager());
        defaultWebSessionManager.setDeleteInvalidSessions(true);
        return defaultWebSessionManager;
    }

    /***
     * 单机使用
     * @return
     */
    protected CacheManager cacheManager() {
        return new MemoryConstrainedCacheManager();
    }

    @Bean
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    public static DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        defaultAdvisorAutoProxyCreator.setProxyTargetClass(true);
        /**
         * setUsePrefix(false)用于解决一个奇怪的bug。在引入spring aop的情况下。
         * 在@Controller注解的类的方法中加入@RequiresRole等shiro注解，会导致该方法无法映射请求，导致返回404。
         * 加入这项配置能解决这个bug
         */
        defaultAdvisorAutoProxyCreator.setUsePrefix(true);
        return defaultAdvisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }
}

这里需要注意的是 defaultSessionManager ，因为shiro默认会使用自带的session管理，那这时session是永不过期的，那用户只需要通过一次token认证，就可以不用再认证了，那我们有什么办法呢？

1. 设置defaultSessionManager的过期时间，定时清除session。

2. 禁用默认session，使用JWT进行过期管理。

如何禁用session可以参考以下代码：我们只需要更改前面代码中的 securityManager方法，增加DefaultSubjectDAO来禁用默认session。

@Bean("securityManager")
    public DefaultWebSecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        // 注入realm 到securityManager
        List<Realm> realms = new ArrayList<>();
        realms.add(oAuth2Realm());

        /**
         * 禁用session管理
         * 根据需要判断，开启后，所有提交都需要验证Token，
         * 否则Login成功后，根据cookie获取session。
         */
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);

        securityManager.setRealms(realms);
        securityManager.setCacheManager(cacheManager());

        //设置session管理
//        securityManager.setSessionManager(defaultSessionManager());
        securityManager.setRememberMeManager(null);
        return securityManager;
    }

问题记录

Springboot+Shiro，使用postman会显示404，需要返回未授权响应(JSON格式)

问题描述

今天当我配置完springboot+shiro后，我用postman返回任何接口都会返回404。

结果显示：

配置信息：

    @Bean(name = "filterShiroFilterRegistrationBean")
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager,ShiroFilterChainDefinition shiroFilterChainDefinition) {

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        				shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition.getFilterChainMap());
        return shiroFilterFactoryBean;
    }
@Bean
public ShiroFilterChainDefinition shiroFilterChainDefinition() {
    DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
    chainDefinition.addPathDefinition("/sys/login", "anon");
    chainDefinition.addPathDefinition("/**", "authc");
    return chainDefinition;
}

很奇怪没有明白为什么会显示404，然后就去查找了官方的问题，发现在使用 authc 拦截时，如果没有通过验证，那么会重定向到 LoginUrl，可是我这里只想返回401无权限访问。

这里插一句题外话，如果把 shiroFilterFactoryBean 的beanName换成 shiroFilterFactoryBean，如下代码所示：

@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager,ShiroFilterChainDefinition shiroFilterChainDefinition) {

    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    shiroFilterFactoryBean.setSecurityManager(securityManager);
    shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition.getFilterChainMap());
    return shiroFilterFactoryBean;
}

那么这里的异常界面就会显示为：提示重定向次数过多。

定位原因

那么如何解决这个重定向 LoginUrl 问题呢？其实我们可以在官方文档默认过滤器找到答案。

我们看一下过滤器 authc 对应的过滤器 org.apache.shiro.web.filter.authc.FormAuthenticationFilter 的源码。

// 继承了 AuthenticatingFilter 认证过滤器
public class FormAuthenticationFilter extends AuthenticatingFilter {
    
    // 无权限
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        if (this.isLoginRequest(request, response)) {
            if (this.isLoginSubmission(request, response)) {
                if (log.isTraceEnabled()) {
                    log.trace("Login submission detected.  Attempting to execute login.");
                }

                return this.executeLogin(request, response);
            } else {
                if (log.isTraceEnabled()) {
                    log.trace("Login page view.");
                }

                return true;
            }
        } else {
            if (log.isTraceEnabled()) {
                log.trace("Attempting to access a path which requires authentication.  Forwarding to the Authentication url [" + this.getLoginUrl() + "]");
            }

            this.saveRequestAndRedirectToLogin(request, response);
            return false;
        }
    }
    
    //保存请求并重定向到登录页面
     protected void saveRequestAndRedirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
        saveRequest(request);
        redirectToLogin(request, response);
    }
    
    // 跳转登录页面
    protected void redirectToLogin(ServletRequest request, ServletResponse response) throws IOException {
        String loginUrl = getLoginUrl();
        WebUtils.issueRedirect(request, response, loginUrl);
    }

}

这里提取了部分源码，可以看出当用户无权限访问路径时，authc过滤器会将我们的请求重定向到 loginUrl，我们可以在shiroFilterFactoryBean里面配置它。这样就可以跳转到对应的路径了。

shiroFilterFactoryBean.setLoginUrl("/login");

既然我们知道了使用 authc 过滤器时，无权限会发生跳转的原因，那么我们应该如何实现返回JSON呢？

解决方案

我们可以自定义拦截器继承 AuthenticatingFilter 类。

public class ShiroFilter extends AuthenticatingFilter {

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        //获取请求token，如果token不存在，直接返回401
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        String token = getRequestToken(httpServletRequest);
        if (StringUtils.isBlank(token)) {
            String json = "{\"code\":401,\"msg\":\"非法token\",\"success\":false}";
            httpServletResponse.getWriter().print(json);
            return false;
        }
        return executeLogin(request, response);
    }

    /**
     * 获取请求的token
     */
    private String getRequestToken(HttpServletRequest httpRequest) {
        //从header中获取token
        String token = httpRequest.getHeader(CommonConstant.S_ACCESS_TOKEN);

        //如果header中不存在token，则从参数中获取token
        if (StringUtils.isBlank(token)) {
            token = httpRequest.getParameter(CommonConstant.S_ACCESS_TOKEN);
        }

        return token;
    }


    @Override
    protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
        //获取请求token
        String token = getRequestToken((HttpServletRequest) request);

        if (StringUtils.isBlank(token)) {
            return null;
        }

        return new OAuth2Token(token);
    }
}

通过重新重写 onAccessDenied 方法，我们就能实现当验证失败时返回json的功能，告知用户无权限操作。这里还需要把过滤器加载到 ShiroFilterFactoryBean 中。

@Bean(name = "shiroFilterFactoryBean")
public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager securityManager,ShiroFilterChainDefinition shiroFilterChainDefinition) {

    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

    // 这里将过滤器类添加进去，名称为 myAuthc 
    Map<String, Filter> filters = new HashMap<>();
    filters.put("myAuthc", new ShiroFilter());
    shiroFilterFactoryBean.setFilters(filters);
    shiroFilterFactoryBean.setSecurityManager(securityManager);
    shiroFilterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition.getFilterChainMap());

    return shiroFilterFactoryBean;
}

@Bean
public ShiroFilterChainDefinition shiroFilterChainDefinition() {
    DefaultShiroFilterChainDefinition chainDefinition = new DefaultShiroFilterChainDefinition();
    chainDefinition.addPathDefinition("/sys/login", "anon");
    // 将所有的都使用 myAuthc拦截
    chainDefinition.addPathDefinition("/**", "myAuthc");
    return chainDefinition;
}

让我们看一下效果。

总结

其实当我们使用authc过滤器，出现404的现象是正常的，因为授权失败了后会自动跳转登陆页面，那我们没有配置这个登陆页面时，就会出现404。所以我们可以通过自定义过滤器并使用的方式，从而返回JSON或者其它自己所需要的授权失败结果。

• docx转html

docx转html

这是自己写了的一个读取docx并处理成html的例子。导入 POI Maven

<!-- Apache Poi -->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.11.0</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>5.2.3</version>
</dependency>
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.2.3</version>
</dependency>

已经实现如下功能：

• 段落水平对齐方式
• 图片读取并转为base64
• 字体类型，大小，高亮，颜色，加粗，下划线，斜体
• 表格读取、背景颜色设置，垂直居中，底纹处理。

注意事项：

1. 低版本的高亮获取会提示null，升级高版本4.1.2+即可解决。

@Test
public void poiTest() throws IOException {
    //        InputStream is = new FileInputStream("D:/test/doc/import.docx");
    //        String filename = "D:/test/doc/1111.docx";
    String filename = "D:/test/doc/import.docx";
    InputStream is = new FileInputStream(filename);
    XWPFDocument doc = new XWPFDocument(is);
    List<IBodyElement> bodyElements = doc.getBodyElements();

    StringBuilder htmlStrBuild = new StringBuilder();
    for (IBodyElement bodyElement : bodyElements) {
        if (bodyElement.getElementType().equals(BodyElementType.PARAGRAPH)) {
            XWPFParagraph paragraph = (XWPFParagraph) bodyElement;
            htmlStrBuild.append(paragraphHandle(paragraph));
        } else if (bodyElement.getElementType().equals(BodyElementType.TABLE)) {
            XWPFTable table = (XWPFTable) bodyElement;
            String tableStr = "<table cellpadding=\"0\" border=\"1\" cellspacing=\"0\">";
            List<XWPFTableRow> rows = table.getRows();
            for (XWPFTableRow row : rows) {
                String rowStyle = "";
                // 行高
                if (row.getHeight() > 0) {
                    rowStyle += "height:" + (row.getHeight() / 10) + "px;";
                }
                tableStr += "<tr style=\"" + rowStyle + "\">";
                List<XWPFTableCell> tableCells = row.getTableCells();
                for (XWPFTableCell tableCell : tableCells) {
                    String cellStyle = "";
                    if (tableCell.getWidth() > 0) {
                        cellStyle += "width:" + tableCell.getWidth() + "px;";
                    }
                    // 垂直剧中
                    XWPFTableCell.XWPFVertAlign verticalAlignment = tableCell.getVerticalAlignment();
                    if (verticalAlignment != null) {
                        if (verticalAlignment.equals(XWPFTableCell.XWPFVertAlign.TOP)) {
                            cellStyle += "vertical-align:top;";
                        } else if (verticalAlignment.equals(XWPFTableCell.XWPFVertAlign.CENTER)) {
                            cellStyle += "vertical-align:center;";
                        } else if (verticalAlignment.equals(XWPFTableCell.XWPFVertAlign.BOTTOM)) {
                            cellStyle += "vertical-align:bottom;";
                        }
                    }

                    // pct-50
                    CTShd cellShd = getCellShd(tableCell);
                    if (cellShd != null) {
                        // 设置单元格背景色
                        String cellFillHex = getCellFillHex(tableCell);
                        if (cellFillHex != null) {
                            cellStyle += "background-color:#" + cellFillHex + ';';
                        }

                        // 设置单元格底纹
                        String cellColorHex = getCellColorHex(cellShd);
                        if (StringUtils.isBlank(cellColorHex)) {
                            cellColorHex = "000";
                        }
                        String shdValue = cellShd.getVal().toString();
                        if (shdValue.equals("solid")) {
                            cellStyle += String.format("background-color:#%s;", cellColorHex);
                        } else if (shdValue.startsWith("pct")) {
                            cellStyle += String.format("background:radial-gradient(circle, #%s 0.5px, transparent 0.5px);", cellColorHex);
                            Double num = Math.ceil(Double.valueOf(cellShd.getVal().toString().substring(3)) / 10);
                            cellStyle += String.format("background-size: %spx %spx;", num, num);
                        } else if (shdValue.equals("horzStripe")) {
                            cellStyle += String.format("background-image: -webkit-linear-gradient(#%s 50%%, transparent 50%%, transparent);", cellColorHex);
                            cellStyle += String.format("background-image: linear-gradient(#%s 50%%, transparent 50%%, transparent);", cellColorHex);
                            cellStyle += String.format("background-size: 3px 3px;");
                        } else if (shdValue.equals("vertStripe")) {
                            cellStyle += String.format("background-image: -webkit-linear-gradient(to right,#%s 50%%, transparent 50%%, transparent);", cellColorHex);
                            cellStyle += String.format("background-image: linear-gradient(to right,#%s 50%%, transparent 50%%, transparent);", cellColorHex);
                            cellStyle += String.format("background-size: 3px 3px;");
                        } else if (shdValue.equals("diagStripe")) {
                            cellStyle += String.format("background-image: -webkit-linear-gradient(-45deg,#%s 25%%, transparent 25%%,transparent 50%%,#%s 50%%,#%s 75%%,transparent 75%%, transparent);", cellColorHex, cellColorHex,cellColorHex);
                            cellStyle += String.format("background-image: linear-gradient(-45deg,#%s 25%%, transparent 25%%,transparent 50%%,#%s 50%%,#%s 75%%,transparent 75%%, transparent);", cellColorHex, cellColorHex,cellColorHex);
                            cellStyle += String.format("background-size: 5px 5px;");
                        } else if (shdValue.equals("reverseDiagStripe")) {
                            cellStyle += String.format("background-image: -webkit-linear-gradient(45deg,#%s 25%%, transparent 25%%,transparent 50%%,#%s 50%%,#%s 75%%,transparent 75%%, transparent);", cellColorHex, cellColorHex,cellColorHex);
                            cellStyle += String.format("background-image: linear-gradient(45deg,#%s 25%%, transparent 25%%,transparent 50%%,#%s 50%%,#%s 75%%,transparent 75%%, transparent);", cellColorHex, cellColorHex,cellColorHex);
                            cellStyle += String.format("background-size: 5px 5px;");
                        }
                    }
                    // 获取文本
                    tableStr += "<td style=\"" + cellStyle + "\">";

                    List<XWPFParagraph> paragraphs = tableCell.getParagraphs();
                    for (XWPFParagraph paragraph : paragraphs) {
                        tableStr += paragraphHandle(paragraph);
                    }
                    tableStr += "</td>";
                }
                tableStr += "</tr>";
            }
            tableStr += "</table>";
            htmlStrBuild.append(tableStr);
        }
    }

    log.info(htmlStrBuild.toString());
}


private CTShd getCellShd(XWPFTableCell tableCell) {
    if (tableCell.getCTTc() != null) {
        if (tableCell.getCTTc().getTcPr() != null) {
            return tableCell.getCTTc().getTcPr().getShd();
        }
    }
    return null;
}

private String getCellFillHex(XWPFTableCell tableCell) {
    if (tableCell.getCTTc() != null) {
        if (tableCell.getCTTc().getTcPr() != null && getCellShd(tableCell) != null) {
            return getCellFillHex(getCellShd(tableCell));
        }
    }
    return null;
}


private String getCellFillHex(CTShd chd) {
    if (chd != null) {
        Object fill = chd.getFill();
        if ("auto".equals(fill.toString())) {
            return null;
        } else if (fill instanceof byte[]) {
            return CmdUtils.bytesToHexString((byte[]) fill);
        }
    }
    return null;
}


private String getCellColorHex(XWPFTableCell tableCell) {
    if (tableCell.getCTTc() != null) {
        if (tableCell.getCTTc().getTcPr() != null && getCellShd(tableCell) != null) {
            return getCellColorHex(getCellShd(tableCell));
        }
    }
    return null;
}

private String getCellColorHex(CTShd chd) {
    if (chd != null) {
        Object color = chd.getColor();
        if ("auto".equals(color.toString())) {
            return null;
        } else if (color instanceof byte[]) {
            return CmdUtils.bytesToHexString((byte[]) color);
        }
    }
    return null;
}


private String paragraphHandle(XWPFParagraph paragraph) {
    StringBuilder htmlStrBuild = new StringBuilder();
    // 段落属性
    String paragraphStyle = "";
    //对齐方式 alignment 枚举值
    if (paragraph.getAlignment().equals(ParagraphAlignment.CENTER)) {
        paragraphStyle += "text-align:center;";
    } else if (paragraph.getAlignment().equals(ParagraphAlignment.LEFT)) {
        paragraphStyle += "text-align:left;";
    } else if (paragraph.getAlignment().equals(ParagraphAlignment.RIGHT)) {
        paragraphStyle += "text-align:right;";
    }

    //获取段落所有的文本对象
    List<XWPFRun> runs = paragraph.getRuns();
    htmlStrBuild.append("<p style=\"" + paragraphStyle + "\">");
    for (XWPFRun run : runs) {
        // 图片处理
        List<XWPFPicture> embeddedPictures = run.getEmbeddedPictures();
        if (CollectionUtils.isNotEmpty(embeddedPictures)) {
            for (XWPFPicture embeddedPicture : embeddedPictures) {
                htmlStrBuild.append("<p>");
                XWPFPictureData pictureData = embeddedPicture.getPictureData();
                String encode = "data:" + pictureData.getPackagePart().getContentType() + ";base64," + new String(Base64Utils.encode(pictureData.getData()));
                htmlStrBuild.append("<img src=\"" + encode + "\"/>");
                htmlStrBuild.append("</p>");
            }
        }

        if (StringUtils.isNotBlank(run.text())) {
            String style = "";

            //文本的颜色 color
            if (StringUtils.isNotBlank(run.getColor())) {
                style += "color:#" + run.getColor() + ";";
            }
            //文本 大小 fontSize
            if (run.getFontSizeAsDouble() != null && run.getFontSizeAsDouble() > 0) {
                style += "font-size:" + run.getFontSizeAsDouble().intValue() + "px;";
            }
            //文本 类型 fontFamily
            if (StringUtils.isNotBlank(run.getFontFamily())) {
                style += "font-family:" + run.getFontFamily() + ";";
            }
            //文本 加粗
            if (run.isBold()) {
                style += "font-weight: bolder;";
            }
            //文本 斜体
            if (run.isItalic()) {
                style += "font-style:italic;";
            }
            //文本 下划线
            if (run.getUnderline().equals(UnderlinePatterns.SINGLE)) {
                style += "text-decoration: underline;";
            }
            //文本 高亮
            if (run.isHighlighted()) {
                style += "background-color:" + run.getTextHighlightColor() + ";";
            }
            htmlStrBuild.append(String.format("<span style=\"%s\">%s</span>", style, run.text()));
        }
    }
    htmlStrBuild.append("</p>");
    return htmlStrBuild.toString();
}

• Maven导入
• 指定字段（Integer）转文本渲染
• 设置Strategy 属性
  • 注解使用
  • 设置列宽度
    • AbstractColumnWidthStyleStrategy

Maven导入

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>easyexcel</artifactId>
    <version>3.2.0</version>
</dependency>

指定字段（Integer）转文本渲染

1. 配置Converter 文件

public class TypeConverter implements Converter<Integer> {
    @Override
    public Class supportJavaTypeKey() {
        return null;
    }

    @Override
    public CellDataTypeEnum supportExcelTypeKey() {
        return null;
    }

    @Override
    public Integer convertToJavaData(CellData cellData, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
        return null;
    }

    @Override
    public CellData convertToExcelData(Integer integer, ExcelContentProperty excelContentProperty, GlobalConfiguration globalConfiguration) throws Exception {
        if (integer.equals(1)) {
            return new CellData("安卓");
        } else {
            return new CellData("苹果");
        }
    }
}

2. 再对应字段配置转换

@ExcelProperty(value = "充值端口", converter = TypeConverter.class)
private Integer sysType;

设置Strategy 属性

注解使用

• 设置列宽@ColumnWidth

@ColumnWidth(value=40)
private String name;

• 设置列属性。@ContentStyle
  • 设置边框
    • borderLeft
    • borderRight
    • borderTop
    • borderBottom
  • 设置对齐方式
    • horizontalAlignment（水平对齐）
    • verticalAlignment（垂直对齐）
  • 设置自动换行
    • wrapped。默认不换行

设置列宽度

AbstractColumnWidthStyleStrategy

public class WithdrawExcelStrategy extends AbstractColumnWidthStyleStrategy {
    @Override
    protected void setColumnWidth(WriteSheetHolder writeSheetHolder, List<CellData> list, Cell cell, Head head, Integer integer, Boolean aBoolean) {
        Sheet sheet = writeSheetHolder.getSheet();
        sheet.setColumnWidth(cell.getColumnIndex(), 10440);
    }
}

列宽计算逻辑 ：

1. 单位是1/256个字符宽度 ，所以代码中需要乘以256，且两个参数都必须为整数。
2. 正常的默认列宽是 (33英寸)33*256。但因为字体大小、单元格边框等占用额外的像素，所以实际的列宽比设置的小0.78英寸。
3. 举个例子，加入我们想要设置40英寸，那么就是40.78*256，但是因为参数要求为整数，那么就是40.78*256=10439.68，向上取整，结果为10440。
4. 最后。0.78是不同版本的误差值，这个可以根据个人情况决定误差允许范围。

• 前言
• jackson 提供的类
  • JsonSerializer
  • JsonDeserializer
  • 如何使用
    • 注解方式使用
    • 全局注册
• 一些实现的自定义序列化类
• 将LocalDateTime转化成相对时间

前言

之前我们利用 jackson 全局配置，解决了我们程序中的 Long类型精度丢失问题和 LocalDateTime和Date类型的时间格式化问题。假设现在有这么一个需求。

1分钟内：刚刚
60分钟内： 40分钟前
24小时内： 15小时前
超过24小时：昨天22:42
超过24小时且跨过发布日期2天及以上：8-3 22:42
跨过发布日期年份： 2022-8-5  22:42

要求时间格式按照这样的形势返回。这时我们可以在每个方法返回前自己写格式化，处理完后再返回。那有什么更好的方式呢？这里我们可以采用自定义序列化类来实现。

jackson 提供的类

• JsonSerializer。序列化类，T为传入的类型。
• JsonDeserializer。反序列化类，T为处理完后传入系统的类型。

JsonSerializer

来看个简单的例子，这个例子将 LocalDateTime格式化后，通过JsonGenerator.writeString转字符串传输出去。

public class LocalDateTimeSerialize extends JsonSerializer<LocalDateTime> {

    private static final DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy-M-d HH:mm");
    
    @Override
    public void serialize(LocalDateTime localDateTime, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
		jsonGenerator.writeString(localDateTime.format(format));
    }
}

JsonDeserializer

来看个简单的例子，这个例子将 LocalDateTime格式化后，通过JsonParser.writeString转字符串传输出去。

public class LocalDateTimeDeserialize extends JsonDeserializer<LocalDateTime> {

    private static final DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy-M-d HH:mm");
    
 	public Date deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        String date = jp.getText();
        try {
            return format.parse(date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

如何使用

现在序列化类和反序列化类我们都有了，那么我们应该如何使用呢？

注解方式使用

在对应的类型上添加类注解。

• @JsonDeserialize
• @JsonSerialize

@Data
public class Message{
    @JsonDeserialize(using = LocalDateTimeDeserialize.class)
    @JsonSerialize(using = LocalDateTimeSerialize.class)
    private LocalDateTime createTime;
}

全局注册

@JsonComponent
public class JacksonConfig {
    
    @Bean
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();

        // 简单类型转换
        SimpleModule module = new SimpleModule();
        module.addSerializer(Long.class, ToStringSerializer.instance);
        module.addSerializer(Long.TYPE, ToStringSerializer.instance);

        JavaTimeModule javaTimeModule = new JavaTimeModule();
        module.addSerializer(LocalDateTime.class, new LocalDateTimeSerialize());
        module.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserialize());
        objectMapper.registerModules(module, javaTimeModule);
        // 不序列化为null
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        return objectMapper;
    }


}

一些实现的自定义序列化类

将LocalDateTime转化成相对时间

需求：

1分钟内：刚刚
60分钟内： 40分钟前
24小时内： 15小时前
超过24小时：昨天22:42
超过24小时且跨过发布日期2天及以上：8-3 22:42
跨过发布日期年份： 2022-8-5  22:42

实现：

/**
 * 时间序列化注解
 * 使用方法： @JsonSerialize(using = LocalDateTimeSerialize.class)
 */
public class LocalDateTimeSerialize extends JsonSerializer<LocalDateTime> {

    private static final DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy-M-d HH:mm");
    private static final DateTimeFormatter format2 = DateTimeFormatter.ofPattern("M-d HH:mm");
    private static final DateTimeFormatter format3 = DateTimeFormatter.ofPattern("昨天HH:mm");

    /**
     * 分钟内：刚刚
     * 60分钟内： 40分钟前
     * 24小时内： 15小时前
     * 超过24小时：昨天22:42
     * 超过24小时且跨过发布日期2天及以上：8-3 22:42
     * 跨过发布日期年份： 2022-8-5  22:42
     */
    @Override
    public void serialize(LocalDateTime localDateTime, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        LocalDateTime now = LocalDateTime.now();
        if (localDateTime.getYear() < now.getYear()) {
            jsonGenerator.writeString(localDateTime.format(format));
            return;
        }
        Duration duration = Duration.between(localDateTime, now);
        if (duration.getSeconds() <= 60) {// 小于60s
            jsonGenerator.writeString("刚刚");
        } else if (duration.toMinutes() <= 60) {//小于一小时
            jsonGenerator.writeString(duration.toMinutes() + "分钟前");
        } else if (duration.toHours() < 24) {//小于24小时
            jsonGenerator.writeString(duration.toHours() + "小时前");
        } else if (duration.toDays() == 1) {
            jsonGenerator.writeString(localDateTime.format(format3));
        } else if (duration.toDays() >= 2) {
            jsonGenerator.writeString(localDateTime.format(format2));
        }else{
            jsonGenerator.writeString(localDateTime.format(format2));
        }
    }
}

• 前言
• 确认并思考问题
• 解决方案
• 引用
• 最后

前言

最近发现一个问题，就是jfreechart在linux环境下，图表中文会出现乱码，然而poi的中文不会。

然后通过百度成功搜索到了一堆没用的文章。于是中和了一下这些文章，成功解决了这个问题。

确认并思考问题

因为都是说是linux环境下的字体文件，相比于window文件下的字体文件要少。导致中文的字体乱码。

那么我们就先查找一下linux下的字体库和window下的字体库

window 字体库：（C:\Windows\Fonts）

linux 字体库：

%JAVA_HOME%/jre/lib/fonts/

/usr/share/fonts/

从这里看出我们所需要的字体库远远不够，所以把window下我们需要的字体库添加到linux。

解决方案

1. 我们进入到window 字体库：（C:\Windows\Fonts）下，将需要用到的字体文件拷贝到linux服务器，这里我们用到了三个字体文件（simsunb.ttf,simhei.ttf,simsun.ttc）

2. 上传到jdk字体库中%JAVA_HOME%/jre/lib/fonts/。如下图

3. 更新%JAVA_HOME%/jre/lib/fonts/fonts.dir文件

ttmkfdir -o fonts.dir

4. 在%JAVA_HOME%/jre/lib/fonts执行以下命令，用于创建文件夹。

mkdir fallback
cd fallback

5. 将字体文件拷贝到当前文件夹。
6. 执行以下命令，生成font相关文件。并追加到外层目录的fonts.dir文件。

mkfontscale && mkfontdir
cat fonts.scale >> ../fonts.dir

7. 进入/usr/share/fonts执行以下命令，创建文件夹。

cd /usr/share/fonts
mkdir zh_CN
cd zh_CN
mkdir TrueType

8. 进入/usr/share/fonts/zh_CN/TrueType文件夹，上传字体文件。
9. 执行下面操作指令，更新字体缓存。请将jdk路径换成自己的。

fc-cache /usr/share/fonts/zh_CN/TrueType/

fc-cache /usr/local/java/jdk1.8.0_261/jre/lib/fonts/
fc-cache /usr/local/java/jdk1.8.0_261/jre/lib/fonts/fallback/

10. 重启java服务进程。 有的教程说是一定要重启机器。但是成本太高了，所以经过不断尝试最终通过这样的方式解决了问题。

引用

JFreechart在linux下不显示及中文乱码问题

Linux下的JFreeChart出现中文乱码‘口口‘终极解决方案（亲测有效）

Linux下JDK中文乱码解决

最后

老规矩写的不清晰的地方，可以指出，我会不定时更新和修改。一起加油.

所有的伟大，都来自于一个勇敢的开始。

• 前言
• 示例说明
  • 说明
• 与dependencies区别
• 使用案例

前言

在Maven多模块的时候，管理依赖关系是非常重要的，各种依赖包冲突，查询问题起来非常复杂，于是就用到了，

示例说明

在父模块中：

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.44</version>
            </dependency>
           
        </dependencies>
</dependencyManagement>

那么在子模块中只需要和即可，如：

 <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
 </dependencies>

说明

使用dependencyManagement可以统一管理项目的版本号，确保应用的各个项目的依赖和版本一致，不用每个模块项目都弄一个版本号，不利于管理，当需要变更版本号的时候只需要在父类容器里更新，不需要任何一个子项目的修改；如果某个子项目需要另外一个特殊的版本号时，只需要在自己的模块dependencies中声明一个版本号即可。子类就会使用子类声明的版本号，不继承于父类版本号。

与dependencies区别

1. Dependencies相对于dependencyManagement，所有生命在dependencies里的依赖都会自动引入，并默认被所有的子项目继承。
2. dependencyManagement里只是声明依赖，并不自动实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;另外如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

使用案例

spring-boot-dependencies 和 spring-boot-starter-parent。

我们在日常开发中经常使用的spring-boot-starter-parent（继承了spring-boot-dependencies）里面其实就提供了版本控制，所以我们在项目的pom文件中的 dependencies 中引入一些库时，可以不需要填入版本，会自动去使用 spring-boot-dependencies 中规定的版本。

• 前言
• 功能
• 不继承spring-boot-parent
  • 基础配置
  • 版本依赖
  • 插件配置
• 直接继承spring-boot-dependencies
• 总结

前言

在很多的springboot项目中，我们都能看到pom中，有类似这样的一段代码：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.5.RELEASE</version>
</parent>

因为我这里用的版本是2.3.5.RELEASE，可能会存在一定的出入。

那么这一段有什么作用呢？让我们通过查看对应版本的pom文件内容，分析一下看看。

功能

这里因为篇幅原因，我只截取关键的代码。

<!-- spring-boot-starter-parent-2.3.5.RELEASE.pom -->
 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.5.RELEASE</version>
  </parent>

<properties>
    <java.version>1.8</java.version>
    <resource.delimiter>@</resource.delimiter>
    <maven.compiler.source>${java.version}</maven.compiler.source>
    <maven.compiler.target>${java.version}</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>

<resources>
  <resource>
    <directory>${basedir}/src/main/resources</directory>
    <filtering>true</filtering>
    <includes>
      <include>**/application*.yml</include>
      <include>**/application*.yaml</include>
      <include>**/application*.properties</include>
    </includes>
  </resource>
  <resource>
    <directory>${basedir}/src/main/resources</directory>
    <excludes>
      <exclude>**/application*.yml</exclude>
      <exclude>**/application*.yaml</exclude>
      <exclude>**/application*.properties</exclude>
    </excludes>
  </resource>
</resources>

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <parameters>true</parameters>
  </configuration>
</plugin>
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-failsafe-plugin</artifactId>
  <executions>
    <execution>
      <goals>
        <goal>integration-test</goal>
        <goal>verify</goal>
      </goals>
    </execution>
  </executions>
  <configuration>
    <classesDirectory>${project.build.outputDirectory}</classesDirectory>
  </configuration>
</plugin>
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>${start-class}</mainClass>
        <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
      </manifest>
    </archive>
  </configuration>
</plugin>
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-war-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>${start-class}</mainClass>
        <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
      </manifest>
    </archive>
  </configuration>
</plugin>
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-resources-plugin</artifactId>
  <configuration>
    <delimiters>
      <delimiter>${resource.delimiter}</delimiter>
    </delimiters>
    <useDefaultDelimiters>false</useDefaultDelimiters>
  </configuration>
</plugin>

1. 指定jdk版本为1.8
2. 指定字符集为UTF-8
3. 继承了spring-boot-dependencies.2.3.5.RELEASE。
4. 针对以yml、yaml、properties结尾的文件资源过滤，包括以profile定义的不同环境的文件。
5. 自动化的插件配置，
   • 资源插件：maven-resources-plugin（处理资源文件到输出目录）
   • 测试插件：maven-failsafe-plugin
   • 打包插件：
     • maven-jar-plugin（打包jar）
     • maven-war-plugin(打包war)
6. 依赖版本的管理。是由spring官方测试过后，较为兼容的版本，可以在spring-boot-dependencies.2.3.5.RELEASE中查看到。

spring-boot-dependencies中是通过 dependencyManagement 和 pluginManagement 对版本进行管理的。 对 dependencies 和 dependencyManagement 差别可以看一下这个文章

不继承spring-boot-parent

那么不使用parent会有什么后果呢？显而易见的，就是上面的parent提供的功能都要自己实现

基础配置

<properties>
    <java.version>1.8</java.version>
    <resource.delimiter>@</resource.delimiter>
    <maven.compiler.source>${java.version}</maven.compiler.source>
    <maven.compiler.target>${java.version}</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>

需要自己手动指定字符集和编译版本。

版本依赖

因为没有地方对依赖版本进行了控制，所以我们所有引入的依赖都需要自己填入版本。

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>
</dependencies>

这时项目在本地能够正常运行，因为依赖的配置都能获取到，但是无法打包成jar或者war包。

插件配置

 <plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>${start-class}</mainClass>
        <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
      </manifest>
    </archive>
  </configuration>
</plugin>
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-war-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>${start-class}</mainClass>
        <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
      </manifest>
    </archive>
  </configuration>
</plugin>

我们就需要自己配置对应的插件和版本，像是打包war包所需要的web.xml文件，指定主类等，都需要手动配置。当然我们也可以借助其它工具来打包。

直接继承spring-boot-dependencies

实际上spring-boot-dependencies主要的功能就是提供了一个对依赖版本的管理。让我们对版本的控制可以简化，因为是由spring官方测试过的稳定兼容版本。然后我们自己还是需要做一个类似 spring-boot-parent 的pom文件，因为这是我们实际依赖的项目插件和配置。

说简单点了，实际就是dependencyManagement和dependencies的关系。

总结

这主要是springboot的主要理念：起步依赖、简化开发。我们只需要简单的通过继承spring-boot-parent，就能快速的解决编译、资源文件输出、配置文件、打包、版本依赖等管理，而不需要繁杂的配置。

• maven 安装和配置
• 多模块
  • packaging
    • pom
    • jar
    • war
• 异常记录
  • 'packaging' with value 'jar' is invalid. aggregator projects require 'pom'

maven 安装和配置

这里使用版本是 v3.9.6。
下载地址：https://maven.apache.org/download.cgi

1. 解压到本地文件夹下
2. 打开 config\settings.xml
3. 配置本地存储位置

   <localRepository>D:/dev/repositories/maven</localRepository>
   

4. 配置阿里云镜像仓库

    <mirror>
      <id>aliyunmaven</id>
      <mirrorOf>*</mirrorOf>
      <name>阿里云公共仓库</name>
      <url>https://maven.aliyun.com/repository/public</url>
    </mirror>
   

5. 私有仓库配置（带密码）

   <servers>
   	<server>
   		<id>nexus-releases</id>
   		<username>admin</username>
   		<password>xxx</password>
   	</server>
   </servers>
   

6. 配置java版本(以1.8为例子)

   <profile>
       <id>JDK-1.8</id>
       <activation>
           <activeByDefault>true</activeByDefault>
           <jdk>1.8</jdk>
       </activation>
       <properties>
           <maven.compiler.source>1.8</maven.compiler.source>
           <maven.compiler.target>1.8</maven.compiler.target>
           <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
       </properties>
   </profile>
   

7. 配置环境变量
   • MAVEN_HOME。D:\dev\apache-maven-3.9.6
   • PATH。添加 %MAVEN_HOME%\bin

多模块

packaging

在当前分布式和微服务日益发展壮大的背景下，我们需要更了解关于maven配置的细节，以及多模块下需要注意的地方。

目前 packaging 具有以下3中配置：

1. pom
2. jar
3. war

pom

在多模块项目中，我们会把某一类模块（例如 common 模块）聚合所有通用的模块，例如log、upload等，但时本身common模块不参与打包使用，只是作为一个聚合管理，那么这时我们可以将其设置为

<packagin>pom</packagin>

为什么一定要有一个父类的POM呢？大致有以下几点好处：

1. 可以通过 Modules 标签管理子模块的编译顺序（Maven 本身采用最短路径原则）。
2. 将子模块的公共依赖包和版本交由父模块进行管理
3. groupId\artifactid\version可以从父类获取，减少子模块POM的复杂性。

jar

当没有配置 packaging 时，默认值为jar，即采用jar方式打包.

这种打包方式意味着在maven build时会将这个项目中的所有java文件都进行编译形成.class文件，且按照原来的java文件层级结构在target目录下放置，最终压缩为一个jar文件。

war

war包与jar包非常相似，同样是编译后的.class文件按层级结构形成文件树后打包形成的压缩包。不同的是，它会将项目中依赖的所有jar包都放在WEB-INF/lib这个文件夹下。

可想而知，war包非常适合部署时使用，不再需要下载其他的依赖包，能够使用户拿到war包直接使用，因此它经常使用于微服务项目群中的入口项目的pom配置中。

异常记录

'packaging' with value 'jar' is invalid. aggregator projects require 'pom'

需要将父模块的packaging设置为pom即可解决

• Mybatis 拦截器
  • 核心组件
  • 生命周期
  • 如何使用
    • Interceptor
  • 执行过程
• 拦截器注入的方式
  • Mybatis
  • Mybatis-Plus
• 拦截器使用案例
  • 拦截填充创建时间和更新时间

Mybatis 拦截器

核心组件

• Configuration：初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如插件，映射器，ObjectFactory和typeHandler对象，MyBatis所有的配置信息都维持在Configuration对象之中。
• SqlSessionFactory：SqlSession工厂。
• SqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要的数据库增删改查功能。
• Executor： MyBatis的执行器，用于执行增删改查操作。负责调用StatementHandler操作数据库，并把结果集通过ResultSetHandler进行自动映射，另外，它还处理二级缓存的操作。
• StatementHandler：MyBatis直接在数据库执行SQL脚本的对象。另外它也实现了MyBatis的一级缓存。
• ParameterHandler：负责将用户传递的参数转换成JDBC Statement所需要的参数。是MyBatis实现SQL入参设置的对象。
• ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合。是MyBatis把ResultSet集合映射成POJO的接口对象。
• TypeHandler：负责Java数据类型和JDBC数据类型之间的映射和转换。
• MappedStatement：MappedStatement维护了一条<select|update|delete|insert>节点的封装。
• SqlSource ：负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回。
• BoundSql：表示动态生成的SQL语句以及相应的参数信息。

生命周期

Mybatis 插件原理： 使用动态代理对以下四个目标对象进行包装，然后再有针对性的进行拦截，其生命周期分为包装和拦截。

• ParameterHandler：处理SQL的参数对象
• ResultSetHandler：处理SQL的返回结果集
• StatementHandler：数据库的处理对象，用于执行SQL语句
• Executor：MyBatis的执行器，用于执行增删改查操作

Mybatis 插件的周期：

1. 通过 setProperties 将配置好的 Properties 设置到插件上使用，
2. 通过 plugin.wrap(target,this) 对插件对象进行拦截后，生成代理对象返回。
3. 通过 intercept 方法对代理 。注意：再上面四大对象创建的时候，对象都不是直接返回的，而且会生成他的代理，然后返回其代理对象。

graph TD;
User --> SqlSession
SqlSession --> User

SqlSession --> Executor
Executor --> SqlSession

Executor --> ParameterHandler

ParameterHandler --> StatementHandler

StatementHandler --> ResultSetHandler

ResultSetHandler --> Executor

如何使用

自定义 Mybatis 的拦截器步骤如下：

1. 定义一个实现了 Interceptor 接口的拦截器类，并实现其方法.
2. 添加 @Interceptors 和 @Signature 注解，标记需要拦截的对象和方法，以及传入的方法参数
3. 配置插件
   1. 在 Mybatis 的全局配置XML 中 配置插件Plugin
   2. 对于去XML文件的 SpringBoot 项目，使用 @Component 注册；或者使用 SqlSessionFactory.addInterceptor 注入拦截器

Interceptor

public interface Interceptor {
    Object intercept(Invocation invocation) throws Throwable;

    default Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    default void setProperties(Properties properties) {
    }
}

• Object intercept(Invocation invocation) throws Throwable;
  • 实现拦截的地方
  • 通过 invocation.proceed() 显式推进责任链的执行。
• Object plugin(Object target) ;
  • 生成当前拦截器对该目标对象的代理。
• void setProperties(Properties properties)
  • 用于设置拦截器的自定义参数。

此外对于自定义的 Interceptor 有两个重要的注解：

1. @Intercepts，用于表明当前对象是一个 Interceptor。其值是一个 @Signature 数组，用于标识需要拦截的方法。
2. @Signature ，用于表明要拦截的接口、方法以及对应的参数类型。

下面是一个官方示例：

// ExamplePlugin.java
@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})
public class ExamplePlugin implements Interceptor {
  private Properties properties = new Properties();

  @Override
  public Object intercept(Invocation invocation) throws Throwable {
    // implement pre processing if need
    Object returnObject = invocation.proceed();
    // implement post processing if need
    return returnObject;
  }

  @Override
  public void setProperties(Properties properties) {
    this.properties = properties;
  }
}

执行过程

拦截器注入的方式

Mybatis

1. 使用 @Component 注入 SpringBoot 容器。但无法控制执行顺序

@Component
@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
})
public class UpdateInterceptor implements Interceptor {
}

2. 使用 xml 配置。mybatis-config.xml

<plugins>
    <plugin interceptor="UpdateInterceptor">
        <property name="args1" value="参数示例"/>
    </plugin>
</plugins>	

3. 使用 SqlSessionFactory。需要注意的是，这是倒序执行，后加入的先执行

@Resource
private List<SqlSessionFactory> sqlSessionFactories;

@PostConstruct
public void addInterceptor() {
    sqlSessionFactories.forEach(item -> {
        item.getConfiguration().addInterceptor(new DataScopeInterceptor());
        item.getConfiguration().addInterceptor(new DataScopeInterceptor2());
    });
}

Mybatis-Plus

1. 使用 ConfigurationCustomizer 设置执行顺序，需要注意的是倒序执行，后加入的先执行

@Configuration
public class MybatisConfig {
// 注册插件方式
    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> {
            //插件拦截链采用了责任链模式，执行顺序和加入连接链的顺序有关
            configuration.addInterceptor(new UpdateInterceptor());
        };
    }
}

2. 使用设置 Mybatis-Plus 下的 Innerterceptor

@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
    MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
    //     数据权限过滤
    interceptor.addInnerInterceptor(new DataScopeInnerInterceptor());
    interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
    interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
    return interceptor;
}

拦截器使用案例

拦截填充创建时间和更新时间

@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
})
public class UpdateInterceptor implements Interceptor {
    @Autowired
    private CommonAuthApi commonAuthApi;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        if (invocation.getTarget() instanceof Executor) {
            MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
            Object params = invocation.getArgs()[1];
            SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
            operateTime(params, sqlCommandType);
        }
        return invocation.proceed();
    }

    private void operateTime(Object params, SqlCommandType sqlCommandType) {
        Map<String, Object> userInfo = commonAuthApi.queryUserInfo();
        if (sqlCommandType == SqlCommandType.UPDATE || sqlCommandType == SqlCommandType.DELETE) {
            if (params instanceof BaseEntity) {
                BaseEntity baseEntity = (BaseEntity) params;
                LocalDateTime now = LocalDateTime.now();
                String username = userInfo.get("username").toString();
                baseEntity.setUpdateTime(now);
                baseEntity.setUpdateBy(username);
            } else if (params instanceof Map) {
                Map baseMap = (Map) params;
                LocalDateTime now = LocalDateTime.now();
                String username = userInfo.get("username").toString();
                baseMap.put("updateTime", now);
                baseMap.put("updateBy", username);
            }
        } else if (sqlCommandType == SqlCommandType.INSERT) {
            if (params instanceof BaseEntity) {
                BaseEntity baseEntity = (BaseEntity) params;
                LocalDateTime now = LocalDateTime.now();
                String username = userInfo.get("username").toString();
                baseEntity.setCreateTime(now);
                baseEntity.setCreateBy(username);
                baseEntity.setUpdateTime(now);
                baseEntity.setUpdateBy(username);
            } else if (params instanceof Map) {
                Map baseMap = (Map) params;
                LocalDateTime now = LocalDateTime.now();
                String username = userInfo.get("username").toString();
                baseMap.put("createTime", now);
                baseMap.put("createBy", username);
                baseMap.put("updateTime", now);
                baseMap.put("updateBy", username);
            }
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
}

• 前言
• JDBC 和 Mybatis
  • 核心对象
• 核心流程和工作原理
• 参考链接

前言

我们都知道 Mybatis 底层封装了 JDBC API ，Mybatis 的工作原理及核心流程与 JDBC 的使用有很多相似之处，基于 JDBC 可以方便我们更加深入学习 Mybatis

JDBC 和 Mybatis

核心对象

我们先看 JDBC 我们会用到的5个核心对象：

1. DriverManager。驱动管理类，
   1. 注册驱动
   2. 获取连接
2. Connection。数据库连接对象
   1. 获取执行 SQL 的对象
   2. 事务管理
3. Statement。用来执行 Sql 语句，但是会存在 Sql注入 的问题
4. PrepareStatement。用来执行 Sql 语句，但是他的出现解决了 Sql注入 的问题并提高了性能，一次编译，到处使用。其底层是对特殊字符做了转义。
5. ResultSet。结果集对象，封装了 Sql 查询语句的结果并提供了操作查询结果数据的方法。

而 Mybatis 也有四大核心对象：

1. SqlSession。该对象包含了所有执行 SQL 语句的所有方法。
2. Executor。根据 SqlSession 传递的参数动态地生成需要执行的SQL语句，同时负责查询缓存的维护。
3. MappedStatement。该对象是对映射SQL 的封装， 用于存储要映射的SQL语句的id、参数等信息。
4. ResultHandler。用于对返回的结果进行处理，最终得到自己想要的数据格式。

额外说明

1. 在JDBC中，Connection不直接执行SQL方法，而是利用Statement或者PrepareStatement来执行方法。在使用JDBC建立了连接之后，可以使用Connection接口的createStatement()方法来获取Statement对象，也可以调用prepareStatement()方法获得PrepareStatement对象，通过executeUpdate()方法来执行SQL语句。而在MyBatis中，SqlSession对象包含了执行SQL语句的所有方法，但是它是委托Executor执行的。从某种意义上来看，MyBatis里面的SqlSession类似于JDBC中的Connection，他们都是委托给其他类去执行。

2. 虽然SqlSession对象包含了执行SQL语句的所有方法，但是它同样包括了：

<T> T getMapper(Class<T> type);

所以SqlSession也可以委托给映射器来执行数据的增删改查操作。如下代码所示：

// 获得mapper接口的代理对象
PersonMapper pm = session.getMapper(PersonMapper.class);
// 直接调用接口的方法，查询id为1的Peson数据
Person p2 = pm.selectPersonById(1);

这上面来看，SqlSession是不是也类似于JDBC中的Connection呢？ 

核心流程和工作原理

1. 读取MyBatis的配置文件。mybatis-config.xml为MyBatis的全局配置文件，用于配置数据库连接信息。
2. 加载映射文件。映射文件即SQL映射文件，该文件中配置了操作数据库的SQL语句，需要在MyBatis配置文件mybatis-config.xml中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。
3. 构造会话工厂。通过MyBatis的环境配置信息构建会话工厂SqlSessionFactory。
4. 创建会话对象。由SqlSessionFactory创建SqlSession对象，该对象中包含了执行SQL语句的所有方法。
5. Executor执行器。MyBatis底层定义了一个Executor接口来操作数据库，它将根据SqlSession传递的参数动态地生成需要执行的SQL语句，同时负责查询缓存的维护。
6. MappedStatement对象。在Executor接口的执行方法中有一个MappedStatement类型的参数，该参数是对映射信息的封装，用于存储要映射的SQL语句的id、参数等信息。
7. 输入参数映射。输入参数类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输入参数映射过程类似于JDBC对preparedStatement对象设置参数的过程。
8. 输出结果映射。输出结果类型可以是Map、List等集合类型，也可以是基本数据类型和POJO类型。输出结果映射过程类似于JDBC对结果集的解析过程。

我们知道 Mybatis Interceptor 有四大核心对象。其实可以分别对应上上面核心流程的步骤5-8。

• Executor：MyBatis的执行器，用于执行增删改查操作

• StatementHandler：数据库的处理对象，用于执行SQL语句

• ParameterHandler：处理SQL的参数对象

• ResultSetHandler：处理SQL的返回结果集

参考链接

• 关于使用Left join 和 count时，无数据时，list 返回时出现一条空数据
• Mybatis-plus下Mybatis 拦截器，更改sql后，无生效问题。
  • mybatis-plus 的使用方法
  • 问题原因
    • 解决方法

关于使用Left join 和 count时，无数据时，list 返回时出现一条空数据

1. 创建msyql数据表

create table `tb_group`(
    id bigint(20) unsigned not null AUTO_INCREMENT,
    `name` varchar(255) CHARACTER set utf8mb4 COLLATE utf8mb4_bin DEfault Null comment "组名称",
    primary key (`id`) using btree
)ENGINE=Innodb CHARSET=utf8mb4 COMMENT="分组表";


create table `tb_detail`(
    id bigint(20) unsigned not null AUTO_INCREMENT,
		group_id bigint(20) unsigned not null,
    `name` varchar(255) CHARACTER set utf8mb4 COLLATE utf8mb4_bin DEfault Null comment "明细名称",
    primary key (`id`) using btree
)ENGINE=Innodb CHARSET=utf8mb4 COMMENT="明细表";

2. 插入数据

INSERT INTO `tb_group` (`id`, `name`) VALUES (1, '1');
INSERT INTO `tb_group` (`id`, `name`) VALUES (2, '2');
INSERT INTO `tb_detail` (`id`, `group_id`, `name`) VALUES (1, 1, '1-1');
INSERT INTO `tb_detail` (`id`, `group_id`, `name`) VALUES (2, 1, '1-2');
INSERT INTO `tb_detail` (`id`, `group_id`, `name`) VALUES (3, 2, '1-2');

3. 实体类

/**
 * 组实体类
 */
@Data
public class TbGroup{
    private Long id;
    private String name;
}
/**
 * 明细实体类
 */
@Data
public class TbDetail{
    private Long id;
    private Long groupId;
    private String name;
}
/**
 * 组统计实体类
 */
@Data
public class TbGroupAndDetailCountVo{
    private Long id;
    private String name;
    private Integer count;
}

4. 编写mapper.xml

<select id="selectGroupAndDetailCount" result="TbGroupAndDetailCountVo">
	select 
    	tb_group.id,
    	tb_group.name,
    	count(1) `count`
    from 
    	tb_group left join tb_detail on tb_group.id = tb_detail.group_id
    where tb_group.id =3 
</select>

5. 编写mapper.dao

List<TbGroupAndDetailCountVo> selectGroupAndDetailCount()

6. 我们将下面的sql在mysql里面直接执行，都会看见同样的输出结果。

7. 那通过mybatis映射后呢？

可以看见会有一条空数据count 0 。那么如何解决这个问题呢？

只需要在sql里面增加一句 group by tb_group.id即可。

select 
    	tb_group.id,
    	tb_group.name,
    	count(1) `count`
    from 
    	tb_group left join tb_detail on tb_group.id = tb_detail.group_id
    where tb_group.id =3 
    group by tb_group.id

Mybatis-plus下Mybatis 拦截器，更改sql后，无生效问题。

因为在项目里面集成了 mybatis-plus 但是我又不太想使用 mybatis-plus 的拦截器方法 InnerInterceptor ，偏向使用 Mybatis 的 Interceptor 。（完整代码可以参见 GIT项目）

mybatis-plus 的使用方法

• 数据域拦截器

public class DataScopeInnerInterceptor extends JsqlParserSupport implements InnerInterceptor {
    // ...
}

• 拦截器使用

  • 方式一：MybatisPlusInterceptor 配置拦截器，可以控制优先顺序

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        //     数据权限过滤
        interceptor.addInnerInterceptor(new DataScopeInnerInterceptor());
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return interceptor;
    }
    

  • 方式二：直接注入 Bean

    @Resource
    private DataScopeInterceptor dataScopeInterceptor;
    
    @Bean
    public PaginationInnerInterceptor paginationInterceptor() {
        return new PaginationInnerInterceptor();
    }
    
    @Bean
    public OptimisticLockerInnerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInnerInterceptor();
    }
    
    @Component
    public class DataScopeInnerInterceptor extends JsqlParserSupport implements InnerInterceptor {
        // ...
    }
    

问题原因

原先代码：通过 @Component 注入我们自己的拦截器，但是更改SQL后没有生效。

DataScopeInterceptor 没有注入成功 AND create_by = 17779983758 方法

2023-03-10 16:46:51.678  INFO 28452 --- [ XNIO-1 task-29] c.a.h.m.a.d.i.DataScopeInnerInterceptor  : MappedStatement => org.apache.ibatis.mapping.MappedStatement@564722db,BoundSQL => org.apache.ibatis.mapping.BoundSql@7247474d,SQL => SELECT id FROM kb_goods WHERE del_flag = 0 AND (usable_flag = ?) AND create_by = 17779983758
2023-03-10 16:46:51.679  INFO 28452 --- [ XNIO-1 task-29] c.a.h.m.a.d.i.DataScopeInterceptor       : MappedStatement => org.apache.ibatis.mapping.MappedStatement@564722db,BoundSQL => org.apache.ibatis.mapping.BoundSql@7c80a775,SQL => SELECT id FROM kb_goods WHERE del_flag = 0 AND (usable_flag = ?)

在我们使用 Mybatis-Plus 的注入方式时，会优先走 MybatisPlusInterceptor 的拦截器。我们看一下打印日志。虽然使用的都是同一个 MappedStatement，但是实际修改的 BoundSql 不是同一个实体，但是修改了后不起作用。

而且 MybatisPlusInterceptor 的优先级是高于我们自定义的 Interceptor 拦截器。

当我们在自定义的 Mybatis拦截器 里面更改了 SQL语句。但是 Mybatis-Plus 操作后，没有发生变化，因为MybatisPlus 本身的拦截器优先注入执行了，导致自定义的拦截器修改 BoundSQL 后没有生效。

解决方法

1. 使用Mybatis-plus提供的 ConfigurationCustomizer 类，提高自定义拦截器的执行顺序。

@Configuration
public class MybatisConfig {
// 注册插件方式
    @Bean
    public ConfigurationCustomizer configurationCustomizer() {
        return configuration -> {
            //插件拦截链采用了责任链模式，执行顺序和加入连接链的顺序有关
            configuration.addInterceptor(new UpdateInterceptor());
        };
    }
}

2. 使用SqlSessionFactory 手动更改执行顺序。

    @Resource
    private List<SqlSessionFactory> sqlSessionFactories;

    @PostConstruct
    public void addInterceptor() {

		// MybatisPlus 拦截器的初始化
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new DataScopeInnerInterceptor());
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());

        sqlSessionFactories.forEach(item -> {
            item.getConfiguration().addInterceptor(interceptor);
            // 自定义拦截器，先执行的后加入
            item.getConfiguration().addInterceptor(new DataScopeInterceptor());
        });
    }

• 前言
• 实现代码

前言

该文章基于我之前写的另一篇关于Druid多数据源的配置，若没有使用多数据，可以借鉴一下，主要是思路是创建新的连接池，然后替换掉原先的连接池，因为 Druid 初始化后不能更换连接再次初始化。

实现代码

@Slf4j
@RefreshScope
@Configuration
public class NacosListener implements InitializingBean {

    @Value("${smilex.nacos.listener.dataId}")
    private String dataId;

    @Resource
    private DataSourceProperties dataSourceProperties;

    @Autowired
    private NacosConfigManager nacosConfigManager;

    @Resource
    private DynamicDataSource dynamicDataSource;

    @Override
    public void afterPropertiesSet() throws Exception {
        NacosConfigProperties nacosConfigProperties = nacosConfigManager.getNacosConfigProperties();
        log.info(nacosConfigProperties.toString());

        ConfigService configService = nacosConfigManager.getConfigService();
        NacosConfigProperties.Config config = nacosConfigProperties.getSharedConfigs().get(0);
        configService.addListener(dataId, config.getGroup(), new Listener() {
            @Override
            public Executor getExecutor() {
                return null;
            }

            @Override
            public void receiveConfigInfo(String configInfo) {
                log.info(configInfo);
                Yaml yaml = new Yaml();
                JSONObject infoJson = new JSONObject(yaml.load(configInfo));
                refreshDataSource(infoJson);
            }
        });
    }

    /**
     * 刷新数据库
     */
    private void refreshDataSource(JSONObject infoJson) {
        JSONObject druid = getProperties(infoJson, "spring.datasource.druid");
        log.info(druid.toJSONString());
        if (druid != null) {
            DataSourceProperties dataSourceProperties = druid.toJavaObject(DataSourceProperties.class);
//            DataSource dataSource = (DataSource) dynamicDataSource.getDataSource(DynamicDataSourceConfig.MASTER);
//            DataSourceFactory.createDataSource(dataSource, dataSourceProperties);
            dynamicDataSource.replaceDataSource(DynamicDataSourceConfig.MASTER, dataSourceProperties);

        }
    }

    private JSONObject getProperties(JSONObject infoJson, String properties) {
        if (StringUtils.isNotBlank(properties)) {
            return loopProperties(infoJson, properties.split("\\."), 0);
        }
        return null;
    }

    private JSONObject loopProperties(JSONObject infoJson, String[] properties, int index) {
        if (infoJson.containsKey(properties[index])) {
            if (index < properties.length - 1) {
                return loopProperties(infoJson.getJSONObject(properties[index]), properties, index + 1);
            } else {
                return infoJson.getJSONObject(properties[index]);
            }
        }
        return null;
    }
}

• 什么是命名空间
• 基本使用
  • 新增命名空间
  • 使用命名空间

基于版本 nacos server 2.2.2

什么是命名空间

namespace(命名空间)是nacos针对于企业级开发设计用来针对于不同环境的区分，比如企业开发时有测试环境、生产环境，因此为了保证不同环境配置实现隔离提出了namespace的概念。-

• 默认在nacos中存在一个public命名空间，所有配置在没有指定命名空间时都在这个命名空间中获取配置。

• 在实际开发时可以针对于不同环境创建不同的namespace。

• 默认空间不能删除

基本使用

新增命名空间

**“命名空间ID”**如果在新增时没有填写的话，则Nacos服务端会自动随机产生一个命名空间ID。

每个命名空间都有一个唯一ID，这个ID是读取配置时指定空间的唯一标识。

使用命名空间

nacos 与 Spring Cloud 整合时，其配置文件中命令空间ID的使用配置如下：

spring:
  cloud:
    nacos:
      discovery:
        # 命名空间
        namespace: dev
      config:
        # 命名空间
        namespace: dev

注意： namespace字段的值必须是命名空间ID（可以进行自定义名称），不能是命名空间名称

• 前言
• 外置数据源

前言

nacos 中主要使用两种数据源：内置和外置。

有些时候我们使用内置数据源时，并不方便做数据查看和统一配置。所以我们会需要使用外置数据源进行配置

外置数据源

目前仅支持 Mysql

1. 安装数据库，版本要求：5.6.5+
2. 初始化mysql数据库，数据库初始化文件：mysql-schema.sql
3. 3.修改conf/application.properties文件，增加支持mysql数据源配置（目前只支持mysql），添加mysql数据源的url、用户名和密码。

### Deprecated configuration property, it is recommended to use `spring.sql.init.platform` replaced.
#spring.datasource.platform=mysql
spring.sql.init.platform=mysql

### Count of DB:
db.num=1

### Connect URL of DB:
db.url.0=jdbc:mysql://127.0.0.1:3306/smilex-nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=root

• 关于配置动态更新不起效果问题
• 关于jmenv.tbsite.net错误

关于配置动态更新不起效果问题

spring:
  cloud:
    nacos:
      discovery:
        # 命名空间
        namespace: dev
        # 注册中鼎
        server-addr: 127.0.0.1:8848
      config:
        # 命名空间
        namespace: dev
        # 配置中心地址
        server-addr: 127.0.0.1:8848
        # 配置文件格式
        file-extension: yml
        # 共享配置
        shared-configs:
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
 
 # 换成这种就可以拉取，但是动态更新会异常
#           - ${spring.application.name}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}

关于jmenv.tbsite.net错误

• 问题描述：nacos未配置cluster.conf，直接执行 ./startup ，表示使用集群模式启动，导致异常

• 解决办法：

  • 方法1：使用单机模式启动 ，执行命令 ./startup -m standalone。
  • 方法2：创建cluster.conf（可不配置）。

• 关键错误信息：

  [com.alibaba.nacos.core.cluster.ServerMemberManager]: Constructor threw exception; nested exception is ErrCode:500, ErrMsg:jmenv.tbsite.net
  

• 完整错误信息：

  "nacos is starting with cluster"
  
           ,--.
         ,--.'|
     ,--,:  : |                                           Nacos 2.2.2
  ,`--.'`|  ' :                       ,---.               Running in cluster mode, All function modules
  |   :  :  | |                      '   ,'\   .--.--.    Port: 8848
  :   |   \ | :  ,--.--.     ,---.  /   /   | /  /    '   Pid: 6824
  |   : '  '; | /       \   /     \.   ; ,. :|  :  /`./   Console: http://192.168.56.1:8848/nacos/index.html
  '   ' ;.    ;.--.  .-. | /    / ''   | |: :|  :  ;_
  |   | | \   | \__\/: . ..    ' / '   | .; : \  \    `.      https://nacos.io
  '   : |  ; .' ," .--.; |'   ; :__|   :    |  `----.   \
  |   | '`--'  /  /  ,.  |'   | '.'|\   \  /  /  /`--'  /
  '   : |     ;  :   .'   \   :    : `----'  '--'.     /
  ;   |.'     |  ,     .-./\   \  /            `--'---'
  '---'        `--`---'     `----'
  
  2024-01-09 11:24:11,379 INFO The server IP list of Nacos is []
  
  2024-01-09 11:24:12,394 INFO Nacos is starting...
  
  2024-01-09 11:24:13,414 INFO Nacos is starting...
  
  2024-01-09 11:24:14,421 INFO Nacos is starting...
  
  2024-01-09 11:24:15,429 INFO Nacos is starting...
  
  2024-01-09 11:24:16,435 INFO Nacos is starting...
  
  2024-01-09 11:24:17,442 INFO Nacos is starting...
  
  2024-01-09 11:24:18,449 INFO Nacos is starting...
  
  2024-01-09 11:24:19,462 INFO Nacos is starting...
  
  2024-01-09 11:24:20,463 INFO Nacos is starting...
  
  2024-01-09 11:24:21,473 INFO Nacos is starting...
  
  2024-01-09 11:24:21,799 INFO Nacos Log files: D:\dev\nacos-server-2.2.2\nacos\logs
  
  2024-01-09 11:24:21,800 INFO Nacos Log files: D:\dev\nacos-server-2.2.2\nacos\conf
  
  2024-01-09 11:24:21,800 INFO Nacos Log files: D:\dev\nacos-server-2.2.2\nacos\data
  
  2024-01-09 11:24:21,803 ERROR Startup errors :
  
  org.springframework.context.ApplicationContextException: Unable to start web server; nested exception is org.springframework.boot.web.server.WebServerException: Unable to start embedded Tomcat
          at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.onRefresh(ServletWebServerApplicationContext.java:163)
          at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:577)
          at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:145)
          at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:745)
          at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:423)
          at org.springframework.boot.SpringApplication.run(SpringApplication.java:307)
          at org.springframework.boot.SpringApplication.run(SpringApplication.java:1317)
          at org.springframework.boot.SpringApplication.run(SpringApplication.java:1306)
          at com.alibaba.nacos.Nacos.main(Nacos.java:35)
          at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
          at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
          at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
          at java.lang.reflect.Method.invoke(Method.java:498)
          at org.springframework.boot.loader.MainMethodRunner.run(MainMethodRunner.java:49)
          at org.springframework.boot.loader.Launcher.launch(Launcher.java:108)
          at org.springframework.boot.loader.Launcher.launch(Launcher.java:58)
          at org.springframework.boot.loader.PropertiesLauncher.main(PropertiesLauncher.java:467)
  Caused by: org.springframework.boot.web.server.WebServerException: Unable to start embedded Tomcat
          at org.springframework.boot.web.embedded.tomcat.TomcatWebServer.initialize(TomcatWebServer.java:142)
          at org.springframework.boot.web.embedded.tomcat.TomcatWebServer.<init>(TomcatWebServer.java:104)
          at org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.getTomcatWebServer(TomcatServletWebServerFactory.java:479)
          at org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory.getWebServer(TomcatServletWebServerFactory.java:211)
          at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.createWebServer(ServletWebServerApplicationContext.java:182)
          at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.onRefresh(ServletWebServerApplicationContext.java:160)
          ... 16 common frames omitted
  Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'distroFilterRegistration' defined in class path resource [com/alibaba/nacos/naming/web/NamingConfig.class]: Bean instantiation via factory method failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [org.springframework.boot.web.servlet.FilterRegistrationBean]: Factory method 'distroFilterRegistration' threw exception; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'distroFilter': Unsatisfied dependency expressed through field 'distroMapper'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'distroMapper' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-naming-2.2.2.jar!/com/alibaba/nacos/naming/core/DistroMapper.class]: Unsatisfied dependency expressed through constructor parameter 0; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serverMemberManager' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-core-2.2.2.jar!/com/alibaba/nacos/core/cluster/ServerMemberManager.class]: Bean instantiation via constructor failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.alibaba.nacos.core.cluster.ServerMemberManager]: Constructor threw exception; nested exception is ErrCode:500, ErrMsg:jmenv.tbsite.net
          at org.springframework.beans.factory.support.ConstructorResolver.instantiate(ConstructorResolver.java:658)
          at org.springframework.beans.factory.support.ConstructorResolver.instantiateUsingFactoryMethod(ConstructorResolver.java:486)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateUsingFactoryMethod(AbstractAutowireCapableBeanFactory.java:1352)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1195)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:582)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:542)
          at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
          at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
          at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
          at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:213)
          at org.springframework.boot.web.servlet.ServletContextInitializerBeans.getOrderedBeansOfType(ServletContextInitializerBeans.java:212)
          at org.springframework.boot.web.servlet.ServletContextInitializerBeans.getOrderedBeansOfType(ServletContextInitializerBeans.java:203)
          at org.springframework.boot.web.servlet.ServletContextInitializerBeans.addServletContextInitializerBeans(ServletContextInitializerBeans.java:97)
          at org.springframework.boot.web.servlet.ServletContextInitializerBeans.<init>(ServletContextInitializerBeans.java:86)
          at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.getServletContextInitializerBeans(ServletWebServerApplicationContext.java:260)
          at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.selfInitialize(ServletWebServerApplicationContext.java:234)
          at org.springframework.boot.web.embedded.tomcat.TomcatStarter.onStartup(TomcatStarter.java:53)
          at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5211)
          at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:183)
          at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1393)
          at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1383)
          at java.util.concurrent.FutureTask.run(FutureTask.java:266)
          at org.apache.tomcat.util.threads.InlineExecutorService.execute(InlineExecutorService.java:75)
          at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:134)
          at org.apache.catalina.core.ContainerBase.startInternal(ContainerBase.java:916)
          at org.apache.catalina.core.StandardHost.startInternal(StandardHost.java:835)
          at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:183)
          at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1393)
          at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1383)
          at java.util.concurrent.FutureTask.run(FutureTask.java:266)
          at org.apache.tomcat.util.threads.InlineExecutorService.execute(InlineExecutorService.java:75)
          at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:134)
          at org.apache.catalina.core.ContainerBase.startInternal(ContainerBase.java:916)
          at org.apache.catalina.core.StandardEngine.startInternal(StandardEngine.java:265)
          at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:183)
          at org.apache.catalina.core.StandardService.startInternal(StandardService.java:430)
          at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:183)
          at org.apache.catalina.core.StandardServer.startInternal(StandardServer.java:930)
          at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:183)
          at org.apache.catalina.startup.Tomcat.start(Tomcat.java:486)
          at org.springframework.boot.web.embedded.tomcat.TomcatWebServer.initialize(TomcatWebServer.java:123)
          ... 21 common frames omitted
  Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [org.springframework.boot.web.servlet.FilterRegistrationBean]: Factory method 'distroFilterRegistration' threw exception; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'distroFilter': Unsatisfied dependency expressed through field 'distroMapper'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'distroMapper' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-naming-2.2.2.jar!/com/alibaba/nacos/naming/core/DistroMapper.class]: Unsatisfied dependency expressed through constructor parameter 0; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serverMemberManager' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-core-2.2.2.jar!/com/alibaba/nacos/core/cluster/ServerMemberManager.class]: Bean instantiation via constructor failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.alibaba.nacos.core.cluster.ServerMemberManager]: Constructor threw exception; nested exception is ErrCode:500, ErrMsg:jmenv.tbsite.net
          at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:185)
          at org.springframework.beans.factory.support.ConstructorResolver.instantiate(ConstructorResolver.java:653)
          ... 61 common frames omitted
  Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'distroFilter': Unsatisfied dependency expressed through field 'distroMapper'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'distroMapper' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-naming-2.2.2.jar!/com/alibaba/nacos/naming/core/DistroMapper.class]: Unsatisfied dependency expressed through constructor parameter 0; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serverMemberManager' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-core-2.2.2.jar!/com/alibaba/nacos/core/cluster/ServerMemberManager.class]: Bean instantiation via constructor failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.alibaba.nacos.core.cluster.ServerMemberManager]: Constructor threw exception; nested exception is ErrCode:500, ErrMsg:jmenv.tbsite.net
          at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.resolveFieldValue(AutowiredAnnotationBeanPostProcessor.java:660)
          at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:640)
          at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:119)
          at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:399)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1431)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:619)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:542)
          at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
          at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
          at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
          at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
          at org.springframework.context.annotation.ConfigurationClassEnhancer$BeanMethodInterceptor.resolveBeanReference(ConfigurationClassEnhancer.java:362)
          at org.springframework.context.annotation.ConfigurationClassEnhancer$BeanMethodInterceptor.intercept(ConfigurationClassEnhancer.java:334)
          at com.alibaba.nacos.naming.web.NamingConfig$$EnhancerBySpringCGLIB$$78c17639.distroFilter(<generated>)
          at com.alibaba.nacos.naming.web.NamingConfig.distroFilterRegistration(NamingConfig.java:44)
          at com.alibaba.nacos.naming.web.NamingConfig$$EnhancerBySpringCGLIB$$78c17639.CGLIB$distroFilterRegistration$3(<generated>)
          at com.alibaba.nacos.naming.web.NamingConfig$$EnhancerBySpringCGLIB$$78c17639$$FastClassBySpringCGLIB$$886156dc.invoke(<generated>)
          at org.springframework.cglib.proxy.MethodProxy.invokeSuper(MethodProxy.java:244)
          at org.springframework.context.annotation.ConfigurationClassEnhancer$BeanMethodInterceptor.intercept(ConfigurationClassEnhancer.java:331)
          at com.alibaba.nacos.naming.web.NamingConfig$$EnhancerBySpringCGLIB$$78c17639.distroFilterRegistration(<generated>)
          at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
          at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
          at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
          at java.lang.reflect.Method.invoke(Method.java:498)
          at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:154)
          ... 62 common frames omitted
  Caused by: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'distroMapper' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-naming-2.2.2.jar!/com/alibaba/nacos/naming/core/DistroMapper.class]: Unsatisfied dependency expressed through constructor parameter 0; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serverMemberManager' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-core-2.2.2.jar!/com/alibaba/nacos/core/cluster/ServerMemberManager.class]: Bean instantiation via constructor failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.alibaba.nacos.core.cluster.ServerMemberManager]: Constructor threw exception; nested exception is ErrCode:500, ErrMsg:jmenv.tbsite.net
          at org.springframework.beans.factory.support.ConstructorResolver.createArgumentArray(ConstructorResolver.java:800)
          at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:229)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:1372)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1222)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:582)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:542)
          at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
          at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
          at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
          at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
          at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:276)
          at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1391)
          at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1311)
          at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.resolveFieldValue(AutowiredAnnotationBeanPostProcessor.java:657)
          ... 86 common frames omitted
  Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'serverMemberManager' defined in URL [jar:file:/D:/dev/nacos-server-2.2.2/nacos/target/nacos-server.jar!/BOOT-INF/lib/nacos-core-2.2.2.jar!/com/alibaba/nacos/core/cluster/ServerMemberManager.class]: Bean instantiation via constructor failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.alibaba.nacos.core.cluster.ServerMemberManager]: Constructor threw exception; nested exception is ErrCode:500, ErrMsg:jmenv.tbsite.net
          at org.springframework.beans.factory.support.ConstructorResolver.instantiate(ConstructorResolver.java:315)
          at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:296)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:1372)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:1222)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:582)
          at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:542)
          at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
          at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
          at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
          at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
          at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:276)
          at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1391)
          at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1311)
          at org.springframework.beans.factory.support.ConstructorResolver.resolveAutowiredArgument(ConstructorResolver.java:887)
          at org.springframework.beans.factory.support.ConstructorResolver.createArgumentArray(ConstructorResolver.java:791)
          ... 99 common frames omitted
  Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.alibaba.nacos.core.cluster.ServerMemberManager]: Constructor threw exception; nested exception is ErrCode:500, ErrMsg:jmenv.tbsite.net
          at org.springframework.beans.BeanUtils.instantiateClass(BeanUtils.java:224)
          at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:117)
          at org.springframework.beans.factory.support.ConstructorResolver.instantiate(ConstructorResolver.java:311)
          ... 113 common frames omitted
  Caused by: com.alibaba.nacos.api.exception.NacosException: java.net.UnknownHostException: jmenv.tbsite.net
          at com.alibaba.nacos.core.cluster.lookup.AddressServerMemberLookup.run(AddressServerMemberLookup.java:152)
          at com.alibaba.nacos.core.cluster.lookup.AddressServerMemberLookup.doStart(AddressServerMemberLookup.java:100)
          at com.alibaba.nacos.core.cluster.AbstractMemberLookup.start(AbstractMemberLookup.java:55)
          at com.alibaba.nacos.core.cluster.ServerMemberManager.initAndStartLookup(ServerMemberManager.java:224)
          at com.alibaba.nacos.core.cluster.ServerMemberManager.init(ServerMemberManager.java:171)
          at com.alibaba.nacos.core.cluster.ServerMemberManager.<init>(ServerMemberManager.java:152)
          at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
          at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
          at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
          at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
          at org.springframework.beans.BeanUtils.instantiateClass(BeanUtils.java:211)
          ... 115 common frames omitted
  Caused by: java.net.UnknownHostException: jmenv.tbsite.net
          at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:184)
          at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:172)
          at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)
          at java.net.Socket.connect(Socket.java:589)
          at sun.net.NetworkClient.doConnect(NetworkClient.java:175)
          at sun.net.www.http.HttpClient.openServer(HttpClient.java:463)
          at sun.net.www.http.HttpClient.openServer(HttpClient.java:558)
          at sun.net.www.http.HttpClient.<init>(HttpClient.java:242)
          at sun.net.www.http.HttpClient.New(HttpClient.java:339)
          at sun.net.www.http.HttpClient.New(HttpClient.java:357)
          at sun.net.www.protocol.http.HttpURLConnection.getNewHttpClient(HttpURLConnection.java:1220)
          at sun.net.www.protocol.http.HttpURLConnection.plainConnect0(HttpURLConnection.java:1156)
          at sun.net.www.protocol.http.HttpURLConnection.plainConnect(HttpURLConnection.java:1050)
          at sun.net.www.protocol.http.HttpURLConnection.connect(HttpURLConnection.java:984)
          at com.alibaba.nacos.common.http.client.request.JdkHttpClientRequest.execute(JdkHttpClientRequest.java:114)
          at com.alibaba.nacos.common.http.client.NacosRestTemplate.execute(NacosRestTemplate.java:482)
          at com.alibaba.nacos.common.http.client.NacosRestTemplate.get(NacosRestTemplate.java:72)
          at com.alibaba.nacos.core.cluster.lookup.AddressServerMemberLookup.syncFromAddressUrl(AddressServerMemberLookup.java:175)
          at com.alibaba.nacos.core.cluster.lookup.AddressServerMemberLookup.run(AddressServerMemberLookup.java:143)
          ... 125 common frames omitted
  2024-01-09 11:24:21,806 WARN [WatchFileCenter] start close
  
  2024-01-09 11:24:21,806 WARN [WatchFileCenter] start to shutdown this watcher which is watch : D:\dev\nacos-server-2.2.2\nacos\conf
  
  2024-01-09 11:24:21,808 WARN [WatchFileCenter] already closed
  
  2024-01-09 11:24:21,808 WARN [NotifyCenter] Start destroying Publisher
  
  2024-01-09 11:24:21,809 WARN [NotifyCenter] Destruction of the end
  
  2024-01-09 11:24:21,810 ERROR Nacos failed to start, please see D:\dev\nacos-server-2.2.2\nacos\logs\nacos.log for more details.
  
  2024-01-09 11:24:21,876 WARN [ThreadPoolManager] Start destroying ThreadPool
  
  2024-01-09 11:24:21,877 WARN [ThreadPoolManager] Destruction of the end
  

• 简介
• Buffer是什么
  • Buffer的重要属性
    • Position（位置）
    • limit(限制)
    • capacity（容量）
    • mark(标记)
• 进阶操作
  • 创建Buffer
  • 读写数据
  • rewind(倒带)
  • clear(清空)
  • compact(压缩)
  • duplicate(复制)

简介

java NIO中的Buffer用于和NIO通道进行交互。数据从通道中读取和写入到缓冲区。本质上是一块固定大小的内存区，其作用是是用来存储或传输使用。

java1.4之前，javaio最核心的点是在“数据流”

Buffer是什么

Buffer就是一个存储Byte基本类型的线性的有限序列。 就是说，他是一个固定大小的序列数组。

Buffer底层的本质是数组，我们以ByteBuffer为例，它的底层是：

final byte[] hb; 

Buffer的重要属性

各属性关系： mark<=position<=limit=capacity

Position（位置）

• 当前操作的索引，会自动由相应的get()和put()函数更新。
• 默认为0

limit(限制)

• 表示不能读或写的第一个索引，即从这个索引开始，后续直到capacity都不能进行操作。
• 默认为缓冲区容量(capacity)。

capacity（容量）

• 表示缓冲区的容量，由构建时设置，不能小于0，小于0会抛出异常

mark(标记)

• 一个标记索引。默认值是-1
• 通过调用mark()来设定mark=position；调用reset()设定position=mark。

进阶操作

源代码：文件地址

创建Buffer

细分来说，创建Buffer可以使用四种方式

• 直接缓冲区（DirectByteBuffer）
  • allocateDirect(int capacity)。
    • 只有ByteBuffer具备。
• 堆内存缓冲区（HeapBuffer）。
  • java对象的底层存储单位是byte字节。但是因为java中还有int,double,short等基础类型，为了简化操作，nio中都是为他们实现了一套Buffer
  • 操作方式
    • allocate(int capacity)。
    • wrap( array)
    • wrap( array,int offset,int length)

Buffer是一个接口，它下面有诸多实现，包括最基本的ByteBuffer和其他的基本类型封装的其他Buffer。

public class CreateBufferDemo {
    public static void main(String[] args) {
        ByteBuffer allocateDirect = ByteBuffer.allocateDirect(8);
        System.out.println(allocateDirect.hasArray() + "-" + allocateDirect);

        ByteBuffer allocate = ByteBuffer.allocate(8);
        System.out.println(allocate.hasArray() + "-" + allocate);

        byte[] array = new byte[10];
        ByteBuffer wrap = ByteBuffer.wrap(array);
        System.out.println(wrap.hasArray() + "-" + wrap);

        ByteBuffer wrap1 = ByteBuffer.wrap(array, 4, 3);
        System.out.println(wrap1.hasArray() + "-" + wrap1);
    }
}

让我们运行一下看看输出结果。

java.nio.DirectByteBuffer[pos=0 lim=8 cap=8]
java.nio.HeapByteBuffer[pos=0 lim=8 cap=8]
java.nio.HeapByteBuffer[pos=0 lim=10 cap=10]
java.nio.HeapByteBuffer[pos=4 lim=7 cap=10]

这里需要注意的有2点：

• 当我们使用wrap( array,int offset,int length)进行创建Buffer时，offset表示的是偏移量即position，而limit=offset+length，所以我们要保证limit<=capacity，不然会抛出异常。
• 我们可以看到allocateDirect()生成的ByteBuffer是DirectByteBuffer，并且不为数组。这是为什么呢？因为DirectByteBuffer是通过unsafe向操作系统申请的空间，虽然操作结构上也是一致的，但是实际存储中，并非使用的是java内部的数组。而其它三个最终都是基于数组的。

读写数据

 public static void main(String[] args) {
        IntBuffer buffer = IntBuffer.allocate(10);
        System.out.println("create buffer：" + buffer);

        buffer.put(new int[]{1, 2, 3, 4, 5});
        System.out.println("put buffer after：" + buffer);

        buffer.put(0, 6);
        System.out.println("update buffer after：" + buffer);

        buffer.flip();
        System.out.println("flip buffer after：" + buffer);

        printBuffer(buffer);
    }

我们通过put写入数据，这时position会不断递增，这时我们可以通过flip切换读模式，即limit=position、position=0。

rewind(倒带)

rewind会将position赋值为0，并清空mark，但不会更改limit的值。

rewind buffer position：java.nio.HeapIntBuffer[pos=2 lim=5 cap=10]
rewind buffer position&mark：java.nio.HeapIntBuffer[pos=0 lim=5 cap=10]

由于rewind会将mark清空，所以不要在rewind()后执行reset操作，会抛出InvalidMarkException。

clear(清空)

clear会将buffer还原回默认状态，即position=0;limit=capacity;mark=-1;

compact(压缩)

有时候，我们会考虑将buffer的一部分数据释放，并重新填充。为了要实现这样的需求，我们会不断反复的读写数据，但是这样性能比较差，而buffer自带的compact会很好的解决这一点。

public class BufferDemo {
    public static void main(String[] args) {
        IntBuffer buffer = IntBuffer.allocate(10);
        System.out.println("create buffer：" + buffer);

        buffer.put(new int[]{1, 2, 3, 4, 5});
        System.out.println("put buffer after：" + buffer);

        buffer.put(0, 6);
        System.out.println("update buffer after：" + buffer);

        buffer.flip();
        System.out.println("flip buffer after：" + buffer);

        printBuffer(buffer);
        buffer.position(2);
        System.out.println("compact buffer before：" + buffer);
        buffer.compact();
        System.out.println("compact buffer after：" + buffer);

        printBuffer(buffer);
        System.out.println("print buffer after：" + buffer);

        buffer.position(0);
        printBuffer(buffer);
        System.out.println("print buffer after：" + buffer);

    }

    public static void printBuffer(IntBuffer buffer) {
        System.out.print("buffer print：");
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get());
        }
        System.out.println();
    }
}

代码输出：

create buffer：java.nio.HeapIntBuffer[pos=0 lim=10 cap=10]
put buffer after：java.nio.HeapIntBuffer[pos=5 lim=10 cap=10]
update buffer after：java.nio.HeapIntBuffer[pos=5 lim=10 cap=10]
flip buffer after：java.nio.HeapIntBuffer[pos=0 lim=5 cap=10]
buffer print：62345
compact buffer before：java.nio.HeapIntBuffer[pos=2 lim=5 cap=10]
compact buffer after：java.nio.HeapIntBuffer[pos=3 lim=10 cap=10]
buffer print：4500000
print buffer after：java.nio.HeapIntBuffer[pos=10 lim=10 cap=10]
buffer print：3454500000
print buffer after：java.nio.HeapIntBuffer[pos=10 lim=10 cap=10]

这里做了几件事情：

1. 将position到limit的数据赋值到position为0的位置，即从buffer最前面开始覆盖，并丢弃了原先的数据。
2. 将position设置为被复制的数据数量。即position=limit-position，也就是说这时position指向的是缓冲区最后一位保留数据后的位置。
3. limit再次设置capacity，即整个buffer的大小，因此缓冲区可以再次填充数据。

可以使用这种类似先入先出（FIFO）队列的方式使用buffer。尽管不是非常高效的方法，但是compact对于使buffer与从端口中读取的数据包流的同步来说，还是一种较为便捷的方法。

duplicate(复制)

public class DuplicateBufferDemo {
    public static void main(String[] args) {
        IntBuffer buffer = IntBuffer.allocate(10);
        buffer.put(new int[]{0, 1, 2, 3, 4});
        System.out.println("create buffer：" + buffer);
        printBuffer(buffer, true);

        IntBuffer duplicate1 = buffer.duplicate();
        System.out.println("duplicate buffer：" + duplicate1);
        printBuffer(duplicate1, true);

        duplicate1.put(0, 7);
        System.out.println("origin and duplicate buffer start=====");
        printBuffer(buffer, true);
        printBuffer(duplicate1, true);
        System.out.println("origin and duplicate buffer end=====");


        IntBuffer duplicate2 = buffer.asReadOnlyBuffer();
        System.out.println("asReadOnlyBuffer buffer：" + duplicate2);
        buffer.put(0, 8);
        printBuffer(duplicate2, true);

        try {
            duplicate2.put(0, 6);
        } catch (Exception e) {
            System.err.println("asReadOnlyBuffer buffer update Exception:" + e.toString());
        }

        System.out.println("slice buffer before,origin buffer status：" + buffer);
        buffer.position(3);
        System.out.println("slice buffer before,origin buffer position 3 after：" + buffer);
        IntBuffer slice = buffer.slice();
        System.out.println("slice buffer：" + slice);
        printBuffer(slice, false);

        buffer.put(3, 13);
        buffer.rewind();
        slice.put(0, 23);
        System.out.println("origin buffer:" + buffer);
        printBuffer(buffer, false);
        System.out.println("slice buffer：" + slice);
        printBuffer(slice, true);
    }

    public static void printBuffer(IntBuffer buffer, boolean needFlip) {
        if (needFlip) {
            buffer.flip();
        }
        System.out.print("buffer print：");
        while (buffer.hasRemaining()) {
            System.out.print(buffer.get() + ",");
        }
        System.out.println();
    }
}

输出结果：

create buffer：java.nio.HeapIntBuffer[pos=5 lim=10 cap=10]
buffer print：0,1,2,3,4,
duplicate buffer：java.nio.HeapIntBuffer[pos=5 lim=5 cap=10]
buffer print：0,1,2,3,4,
origin and duplicate buffer start=====
buffer print：7,1,2,3,4,
buffer print：7,1,2,3,4,
origin and duplicate buffer end=====
asReadOnlyBuffer buffer：java.nio.HeapIntBufferR[pos=5 lim=5 cap=10]
buffer print：8,1,2,3,4,
slice buffer before,origin buffer status：java.nio.HeapIntBuffer[pos=5 lim=5 cap=10]
slice buffer before,origin buffer position 3 after：java.nio.HeapIntBuffer[pos=3 lim=5 cap=10]
slice buffer：java.nio.HeapIntBuffer[pos=0 lim=2 cap=2]
buffer print：3,4,
origin buffer:java.nio.HeapIntBuffer[pos=0 lim=5 cap=10]
buffer print：8,1,2,23,4,
slice buffer：java.nio.HeapIntBuffer[pos=2 lim=2 cap=2]
buffer print：23,4,
asReadOnlyBuffer buffer update Exception:java.nio.ReadOnlyBufferException

buffer提供的复制有三种方式：

• duplicate()。拷贝原buffer的position、limit、mark和capacity，他是和原先的buffer是共享数据的。
• asReadOnlyBuffer()。
  • 与duplicate类似，区别在于是只读的，并且也是与原buffer共享数据，修改原buffer也会影响到asReadOnlyBuffer。
  • 修改只读buffer，会抛出异常ReadOnlyBufferException
• slice()。与duplicate类似，区别在于他拷贝的是从原buffer的poisition到limit的部分，同时也是共享数据的。

        Configuration config = new Configuration();
        config.setHostname("localhost");
        config.setPort(9092);
        config.setMaxFramePayloadLength(1024 * 1024);
        config.setMaxHttpContentLength(1024 * 1024);

        config.setExceptionListener(new MyExceptionListener());

        final SocketIOServer server = new SocketIOServer(config);

        server.setPipelineFactory(new MySocketIOChannelHandler());


        server.addConnectListener(new ConnectListener() {
            @Override
            public void onConnect(SocketIOClient client) {
                System.out.println("client连接");
            }
        });

        server.addDisconnectListener(new DisconnectListener() {
            @Override
            public void onDisconnect(SocketIOClient client) {
                System.out.println("client断开连接");
            }
        });

        server.addEventListener("msg", byte[].class, new DataListener<byte[]>() {
            @Override
            public void onData(SocketIOClient client, byte[] data, AckRequest ackRequest) {
                client.sendEvent("msg", data);
            }
        });

        server.start();

        Thread.sleep(Integer.MAX_VALUE);

        server.stop();

当我们发送超过1M的文件时，会提示异常，但是当我们想捕获这个异常的时候，无法捕获到，先记录一下，异常如下：

[nioEventLoopGroup-3-3] WARN io.netty.channel.DefaultChannelPipeline - An exceptionCaught() event was fired, and it reached at the tail of the pipeline. It usually means the last handler in the pipeline did not handle the exception.
io.netty.handler.codec.TooLongFrameException: content length exceeded 1048576 bytes.
	at io.netty.handler.codec.MessageAggregator.handleOversizedMessage(MessageAggregator.java:420)
	at io.netty.handler.codec.MessageAggregator.invokeHandleOversizedMessage(MessageAggregator.java:404)
	at io.netty.handler.codec.MessageAggregator.decode(MessageAggregator.java:293)
	at io.netty.handler.codec.MessageToMessageDecoder.channelRead(MessageToMessageDecoder.java:88)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:374)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:360)
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:352)
	at io.netty.handler.codec.MessageToMessageDecoder.channelRead(MessageToMessageDecoder.java:102)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:374)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:360)
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:352)
	at com.corundumstudio.socketio.transport.PollingTransport.channelRead(PollingTransport.java:109)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:374)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:360)
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:352)
	at com.corundumstudio.socketio.handler.AuthorizeHandler.channelRead(AuthorizeHandler.java:137)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:374)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:360)
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:352)
	at io.netty.channel.SimpleChannelInboundHandler.channelRead(SimpleChannelInboundHandler.java:102)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:374)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:360)
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:352)
	at io.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:326)
	at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:300)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:374)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:360)
	at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:352)
	at io.netty.channel.DefaultChannelPipeline$HeadContext.channelRead(DefaultChannelPipeline.java:1422)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:374)
	at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:360)
	at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:931)
	at io.netty.channel.nio.AbstractNioByteChannel$NioByteUnsafe.read(AbstractNioByteChannel.java:163)
	at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:700)
	at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:635)
	at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:552)
	at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:514)
	at io.netty.util.concurrent.SingleThreadEventExecutor$6.run(SingleThreadEventExecutor.java:1050)
	at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74)
	at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30)
	at java.lang.Thread.run(Thread.java:748)

——————————————————————————————

20191119

发现是netty-socketio框架的问题，虽然框架内部的自定义HttpObjectAggregator重写handleOversizedMessage方法，但是在实际的运行过程中，是不进入该方法的，进入的还是MessageAggregator的handleOversizedMessage方法。先记录，继续用，后续再深入处理。

老规矩写的不清晰的地方，可以指出，我会不定时更新和修改。一起加油.

所有的伟大，都来自于一个勇敢的开始。

最近因为需要使用socket，然后觉得原生java的socket，太过于繁琐了，而且偶尔会阻塞（也许是我菜把）。然后搜索过后，踩了几天的坑，最终解决了。忍不住打算做一下博文，因为网络上的文章，都是我出现了这个问题，然后，哇好巧呀，我也是。然后PASS。懵逼 = =，解决方法呢？所以有了这个博文的诞生。写的不好尽情见谅。

首先关于配置可以参考https://blog.csdn.net/dubismile/article/details/86580858。

然后进入正题吧。当我们使用netty作为服务端与底层设备进行通信的使用，除开特殊因素外，可能碰到的第一个坑就是在于转码问题。之前用原生Java写socket的时候没有遇到过这个问题，然后这次遇到，加上对于这一个也不算懂，只能努力找问题了。

当我们使用调试助手依照16进制发送80，他的10进制大于127，这时候，我们netty获取到的值，就会变成efbfbd，如果看到是乱码的请使用以下代码获取：

ByteBufUtil.hexDump(((String) msg).getBytes())

发现跟我们发送的80完全不多，那么是在什么环节除了问题呢?让我们使用调试，取出Object msg的值编辑。惊了。居然变成这个不知道什么玩意了。起初的我一位是配置有问题，然后翻了一堆配置教程。。。然后没解决，后来想会不会是ChannelOption能设置读取出来的长度问题，然后再去了解和研究channelOption。再然后发现可能是byte的问题，那么就可能关于解码器和编码器的问题，因为Netty本身是内置了编码器和解码器的，然后我以为是我用的不对，就去了解编码器类型，然后替换尝试，都没有什么用。

于是乎，最后采取了自定义解码器了。先上代码了。

public class MyDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {
//创建字节数组,buffer.readableBytes可读字节长度
        byte[] b = new byte[buffer.readableBytes()];
//复制内容到字节数组b
        buffer.readBytes(b);
//字节数组转字符串
        String str = new String(b);

        System.out.println(str);

        out.add(bytesToHexString(b));
    }

    public String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }

    public static String toHexString1(byte[] b) {
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < b.length; ++i) {
            buffer.append(toHexString1(b[i]));
        }
        return buffer.toString();
    }

    public static String toHexString1(byte b) {
        String s = Integer.toHexString(b & 0xFF);
        if (s.length() == 1) {
            return "0" + s;
        } else {
            return s;
        }
    }
}

修改ServerChannelInitializer.java

@Component
public class ServerChannelInitializer extends ChannelInitializer<SocketChannel> {

    @Autowired
    ServerChannelHandler serverChannelHandler;

    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        //IdleStateHandler心跳机制,如果超时触发Handle中userEventTrigger()方法
        pipeline.addLast("idleStateHandler",
                new IdleStateHandler(5, 0, 0, TimeUnit.MINUTES));
        //字符串编解码器
//        pipeline.addLast(
//                new StringDecoder(),
//                new StringEncoder()
//        );

          //修改了这里
         pipeline.addLast("decoder", new MyDecoder());
        pipeline.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 4, 4, -8, 0));
//        pipeline.addLast("byteArrayEncoder", new ByteArrayEncoder());

        //自定义Handler
        pipeline.addLast("serverChannelHandler", serverChannelHandler);
    }
}

至此，大工告成。

小结：在写的过程中，我在想为什么超过127后会变成负数，然后搜索了关于这块的资料，虽然大概知道怎么计算了，但是没啥用呀。果然在项目中，不断学习新的知识，填充自身很棒。这么一趟坑我就学到了很多。

老规矩写的不清晰的地方，可以指出，我会不定时更新和修改。一起加油

所有的伟大，都来自于一个勇敢的开始。

• Bean 作用域

Bean 作用域

1. singleton(单例)：Spring容器只会创建一个bean对象；
2. prototype：每次获取bean都会重新创建一个bean对象；
3. request：对于每一个http请求，在同一个请求内Spring容器只会创建一个bean对象，若请求结束，bean也随之销毁；
4. session：在同一个http会话里，Spring容器只会创建一个bean对象，若传话结束，也随之销毁；
5. globalSession：globalSession作用域的效果与session作用域类似，但是只适用于基于portlet的web应用程序中
6. application：在servlet程序中，该作用域的bean将会作为ServletContext对象的属性，被全局访问，与singleton的区别就是，singleton作用域的bean在Spring容器中只一；application作用域的bean在ServletContex中唯一；
7. websocket：为每个websocket对象创建一个实例。仅在Web相关的ApplicationContext中生效。

• 前言
• InitializingBean
• SmartInitializingSingleton
• 区别
• 触发时机
• Spring 容器启动核心
  • SmartInitializingSingleton 的触发
  • InitializingBean的触发

前言

对于 Spring Bean 的作用域需要有一定了解。传送门

InitializingBean

实现InitializingBean接口的Bean，该Bean实例化后Bean中所有的属性被BeanFactory进行注入之后的，检查所有强制性属性的设置。

1. afterPropertiesSet() 方法在 BeanFactory 为 Bean 填充完属性后触发
2. afterPropertiesSet()方法允许Bean在最终初始化完成之后，针对BeanFactory的属性注入以及整体配置的验证。
3. afterPropertiesSet()方法可以在Bean发生错误配置(如未能设置一个基本属性)或者因为其他任何原因初始化失败而抛出异常。
4. InitializingBean有个功能类似的替换方案：在XML配置文件中配置init-method。

SmartInitializingSingleton

SmartInitializingSingleton接口中的afterSingletonsInstantiated()方法将会在所有的非惰性单实例Bean初始化完成之后进行回调。

1. bean的afterSingletonsInstantiated()方法是在所有单例bean都初始化完成后才会调用afterSingletonsInstantiated的。
2. 此接口可以解决一些因为bean初始化太早而出现的错误和问题。
3. 此接口是从Spring4.1版本开始使用的。
4. 此接口可以看作是所有的Bean初始化完成后的InitializingBean接口的一种替代方案。

区别

1. SmartInitializingSingleton只作用于非懒加载单例bean，InitializingBean无此要求。但他们都不能用于懒加载的bean。
2. SmartInitializingSingleton是在所有单例Bean都初始化完成后调用的，InitializingBean是每个bean初始化完成后就会调用。

触发时机

Spring 容器启动核心

源码 AbstractApplicationContext#refresh()

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
                // 实例化所有剩余的（非惰性初始化）单例
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

源码 AbstractApplicationContext#finishBeanFactoryInitialization()

	/**
	 * Finish the initialization of this context's bean factory,
	 * initializing all remaining singleton beans.
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no BeanFactoryPostProcessor
		// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
        // 实例化所有剩余的（非惰性初始化）单例
		beanFactory.preInstantiateSingletons();
	}

SmartInitializingSingleton 的触发

源码 DefaultListableBeanFactory#preInstantiateSingletons()

	@Override
	public void preInstantiateSingletons() throws BeansException {
		if (logger.isTraceEnabled()) {
			logger.trace("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
        // 创建一个 beanDefinitionNames 的副本用于遍历，以允许init方法注册新的bean定义。尽管这不是常规工厂启动的一部分但很好用。
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// 触发所有非惰性(懒加载)单例bean的初始化
		for (String beanName : beanNames) {
            
            // 返回合并的RootBeanDefinition，遍历父bean定义，如果指定的bean对应于子bean定义。
            // 根 Bean 定义本质上是运行时的“统一”Bean 定义视图。
           //  Spring 上下文包括实例化所有 Bean 使用的 AbstractBeanDefinition 是 RootBeanDefinition
            // 使用 getMergedLocalBeanDefinition 方法做了一次转化, 将非 RootBeanDefinition 转换为 RootBeanDefinition 以供后续操作
            // 注意, 如果当前 BeanDefinition 存在父 BeanDefinition, 会基于父 BeanDefinition 生成一个 RootBeanDefinition, 然后在将调用 OverrideFrom 子 BeanDefinition 的相关属性覆写进去
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            
            // 是否非抽象类 是否是单例， 是否非懒加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
             	// 判断是否为 FacotryBean
				if (isFactoryBean(beanName)) {
                    // 调用 getBean方法，传入 Factory_bean的前缀 + Bean名称
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    // 判断是否是 FactoryBean方法
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
                        // 是否是需要立即初始化
						boolean isEagerInit;
                        // 判断系统安全接口是否为空和Bean 是否实现了 SmartFactoryBean 接口, 如果实现了 SmartFactoryBean 
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            // 方法判断是否希望急切的进行初始化
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
                        // 如果需要立即初始化， 则通过getBean初始化
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
                    // 如果 beanName 对应的 Bean 不是 FactoryBean, 只是普通 Bean, 调用 getBean 方法通过 beanName 获取 Bean 实例对象
					getBean(beanName);
				}
			}
		}

        // 触发所有可用的Bean的初始化回调。
		for (String beanName : beanNames) {
			// 获取 beanName 对应的单例Bean实例对象
			Object singletonInstance = getSingleton(beanName);
            // 判断获取的 SigletonInstance 是否实现了 SmartInitializingSingleton 接口
			if (singletonInstance instanceof SmartInitializingSingleton) {
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                // 判断系统安全接口是否为空，触发 afterSingletonInstantiated 初始化。
				if (System.getSecurityManager() != null) {
                	AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

1. 获取所有的bean，判断是否是 beanFactory，如果是检查是否需要立即初始化，否则将其初始化。
2. 遍历触发所有可用的 Bean 初始化回调。获取单例对象，触发实现 SmartInitializingSingleton 接口的 afterSingletonsInstantiated 方法。
3. 对于 SmartInitializingSingleton 的触发实在所有非惰性单实例Bean初始化完成后进行的。

InitializingBean的触发

源码AbstractAutowireCapableBeanFactory#invokeInitMethods()

/**
	 * Give a bean a chance to react now all its properties are set,
	 * and a chance to know about its owning bean factory (this object).
	 * This means checking whether the bean implements InitializingBean or defines
	 * a custom init method, and invoking the necessary callback(s) if it does.
	 * @param beanName the bean name in the factory (for debugging purposes)
	 * @param bean the new bean instance we may need to initialize
	 * @param mbd the merged bean definition that the bean was created with
	 * (can also be {@code null}, if given an existing bean instance)
	 * @throws Throwable if thrown by init methods or by the invocation process
	 * @see #invokeCustomInitMethod
	 */
// 现在 Bean 的所有属性已经设置好了，给 Bean 一个反射的机会，以及了解他拥有的Bean Factory(这个对象)的机会
// 这意味着检查 bean 是否实现了 InitializingBean 接口或定义了自定义的初始化方法，如果有的话，将调用必要的回调
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
    throws Throwable {
	// 判断 bean 是否实现 InitializingBean 接口
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isTraceEnabled()) {
            logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }
        // 判断系统安全管理是否为空，然后调用 afterPropertiesSet 方法
        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((InitializingBean) bean).afterPropertiesSet();
                    return null;
                }, getAccessControlContext());
            }
            catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }
        else {
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }

    // 自定义初始化方法
    // 如果 mbd 不为空，且bean的类不等于 NullBean.class 
    if (mbd != null && bean.getClass() != NullBean.class) {
        // 获取初始化方法名
        String initMethodName = mbd.getInitMethodName();
       // 判断长度、
        //初始化名称是否等于“afterPropertiesSet” 和 判断是否是 isInitializingBean
        // 是否指定初始化方法
        if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
            // 调用自定义方法 init-method
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

1. Bean实例如果实现了InitializingBean接口则直接触发InitializingBean#afterPropertiesSet()。
2. 如果Bean实例指定了init-method，则通过反射激活Bean指定的init-method。
3. 如果Bean实例实现了InitializingBean接口和init-method方法，则先调用 afterPropertiesSet，然后调用 init-method
4. Spring对于InitializingBean的触发是在Bean所有属性已经设置好了之后。
5. 实现InitializingBean接口是直接调用afterPropertiesSet方法，比通过反射调用init-method指定的方法效率要高一点，但是init-method方式消除了对spring的依赖。
6. 如果调用afterPropertiesSet方法时出错，则不调用init-method指定的方法。

• Spring 加载propertie文件方式
  • @PropertySource
    • 固定编码
    • profile切换
  • 在SpringApplication启动时，注入环境

Spring 加载propertie文件方式

当应用比较大的时候，如果所有的内容都放在一个文件，会显得过分臃肿且不好理解，可以将一个文件拆分多个文件，然后在分别加载进系统。

@PropertySource

• 加载指定的属性文件(*.properties)到Spring的Environment；
• 和@Value组合使用，可以将properties中的变量注入到当前类使用。
• 和@ConfigurationProperties，可以将properties中的变量注入到当前类使用。

固定编码

@PropertySource(value = "classpath:/config/remote-ssh.properties", encoding = "utf-8", ignoreResourceNotFound = true)
@ConfigurationProperties(prefix = "ssh")
public class SshProperties {
    //    @Value("${ssh.enabled:false}")
    private boolean enabled;
}

profile切换

# application-dev.properties
smilex.path="classpath:"

# application-prod.properties
smilex.path="/opt/user/smilex"

我们通过变量的形式注入到@PropertySource即可。

@PropertySource(value = "${smilex.path}/config/remote-ssh.properties", encoding = "utf-8", ignoreResourceNotFound = true)
@ConfigurationProperties(prefix = "ssh")
public class SshProperties {
    //    @Value("${ssh.enabled:false}")
    private boolean enabled;
}

在SpringApplication启动时，注入环境

import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.env.StandardEnvironment;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import java.io.IOException;
import java.util.Properties;

@SpringBootApplication
public class AdminApiApplication {
    public static void main(String[] args) throws IOException {
        SpringApplicationBuilder springApplicationBuilder = new SpringApplicationBuilder(AdminApiApplication.class);
        Properties properties = getProperties();
        StandardEnvironment environment = new StandardEnvironment();
        environment.getPropertySources().addLast(new PropertiesPropertySource("service-properties", properties));
        springApplicationBuilder.environment(environment);
        springApplicationBuilder.run(args);
    }

    private static Properties getProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resource = resolver.getResources("classpath:*.properties");
        propertiesFactoryBean.setLocations(resource);
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
}

• 加载包下的类

加载包下的类

/**
     * 查找包下面的类
     * 规则 top.zsmile\**\*.class
     *
     * @param searchPath 路径，支持ANT
     * @return
     */
public static Map<String, Class> getClassBySuperClass(String searchPath, Class superClass) throws IOException {
    Map<String, Class> handlerMap = new HashMap<String, Class>();
    //spring工具类，可以获取指定路径下的全部类
    ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
    try {
        String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
            searchPath;
        Resource[] resources = resourcePatternResolver.getResources(pattern);
        //MetadataReader 的工厂类
        MetadataReaderFactory readerfactory = new CachingMetadataReaderFactory(resourcePatternResolver);
        for (Resource resource : resources) {
            //用于读取类信息
            MetadataReader reader = readerfactory.getMetadataReader(resource);
            //扫描到的class
            String classname = reader.getClassMetadata().getClassName();
            // 记载class类
            Class<?> clazz = Class.forName(classname);
            //判断是否有指定注解
            if (superClass != null) {
                Class<?>[] interfaces = clazz.getInterfaces();
                if (interfaces.length > 0) {
                    if (interfaces[0].equals(superClass)) {
                        handlerMap.put(classname, clazz);
                    }
                }
            } else {
                handlerMap.put(classname, clazz);
            }
        }
        return handlerMap;
    } catch (IOException | ClassNotFoundException e) {
        throw new IOException("找不到指定Class");
    }
}

• 前言
• 执行过程
  • AbstractHandlerMethodMapping
• 源代码
  • RequestCondition定义
  • AbstractRequestCondition 定义

前言

RequestCondition 是 Spring MVC 对一个请求匹配条件的概念模型。最终的实现类可能是针对以下情况之一：路径匹配，头部匹配，请求参数匹配，可产生MIME匹配，可消费MIME匹配，请求方法匹配，或者是以上各种情况的匹配条件的一个组合。

执行过程

大致执行过程：（个人理解）

1. 接收到请求后，通过AbstractHandlerMethodMapping.lookupHandlerMethod方法遍历接口
2. 通过 RequestCondition.getMatchingCondition方法获取出匹配的 RequestCondition并包装成 Match
3. 然后对 List<Match>匹配列表进行比较，通过 RequestCondition.compareTo 确定最后的最匹配的
4. 如果出现匹配程度一致的，抛出异常 IllegalStateException

AbstractHandlerMethodMapping

@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
    List<Match> matches = new ArrayList<>();
    List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
    if (directPathMatches != null) {
        addMatchingMappings(directPathMatches, matches, request);
    }
    if (matches.isEmpty()) {
        // No choice but to go through all mappings... 
        // 获取出匹配的路径条件
        addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
    }
    if (!matches.isEmpty()) {
			Match bestMatch = matches.get(0);
        	// 如果匹配数量大于1
			if (matches.size() > 1) {
				Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
                // 进行排序，执行 RequestCondition.compareTo
				matches.sort(comparator);
				bestMatch = matches.get(0);
				if (logger.isTraceEnabled()) {
					logger.trace(matches.size() + " matching mappings: " + matches);
				}
                // 如果是CORS预检查
				if (CorsUtils.isPreFlightRequest(request)) {
					return PREFLIGHT_AMBIGUOUS_MATCH;
				}
				Match secondBestMatch = matches.get(1);
                // 如果两者比较一致，抛出异常。
				if (comparator.compare(bestMatch, secondBestMatch) == 0) {
					Method m1 = bestMatch.handlerMethod.getMethod();
					Method m2 = secondBestMatch.handlerMethod.getMethod();
					String uri = request.getRequestURI();
					throw new IllegalStateException(
							"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
				}
			}
        	// 设置最匹配的路径
			request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
			handleMatch(bestMatch.mapping, lookupPath, request);
			return bestMatch.handlerMethod;
    }

    else {
        // 没有匹配出来
        return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
    }
}

源代码

RequestCondition定义

package org.springframework.web.servlet.mvc.condition;

import javax.servlet.http.HttpServletRequest;

import org.springframework.lang.Nullable;

public interface RequestCondition<T> {

	// 将此条件和另外一个请求匹配条件合并，合并逻辑由实现类决定。
	T combine(T other);

    // 检查条件是否与当前请求实例相匹配，如果不匹配返回null，
	// 如果匹配，生成一个新的请求匹配条件，该新的请求匹配条件是当前请求匹配条件
	// 举个例子来讲，如果当前请求匹配条件是一个路径匹配条件，包含多个路径匹配模板，
	// 并且其中有些模板和指定请求request匹配，那么返回的新建的请求匹配条件将仅仅
	// 包含和指定请求request匹配的那些路径模板。
    // 对于 Cors预检查请求，条件应与请求实例相匹配。如果不匹配，应确保返回一个示例空内容，不会导致匹配失败。
	@Nullable
	T getMatchingCondition(HttpServletRequest request);

	// 针对指定的请求对象request比较两个请求匹配条件。
	// 该方法假定被比较的两个请求匹配条件都是针对该请求对象request调用了
	// #getMatchingCondition方法得到的，这样才能确保对它们的比较
	// 是针对同一个请求对象request，这样的比较才有意义(最终用来确定谁是
	// 更匹配的条件)。
    // 
	int compareTo(T other, HttpServletRequest request);

}

由接口源代码可以看出，接口RequestCondition是一个泛型接口。事实上，它的泛型参数T通常也会是一个RequestCondition对象。

AbstractRequestCondition 定义

框架对接口RequestCondition有一组具体实现类。对这些具体实现类的一些通用逻辑，比如equals,hashCode和toString，是被放到抽象基类AbstractRequestCondition来实现的。同时AbstractRequestCondition还通过protected抽象方法约定了实现类其他的一些内部通用逻辑，具体如下所示：

package org.springframework.web.servlet.mvc.condition;

import java.util.Collection;
import java.util.Iterator;

import org.springframework.lang.Nullable;

/**
 * @param <T> the type of objects that this RequestCondition can be combined
 * with and compared to
 */
public abstract class AbstractRequestCondition<T extends AbstractRequestCondition<T>> implements RequestCondition<T> {

	/**
	 * 当前请求匹配条件对象是否内容为空
	 * @return  true if empty; false otherwise
	 */
	public boolean isEmpty() {
		return getContent().isEmpty();
	}

	/**
	 * 一个请求匹配条件可能由多个部分组成，这些组成部分被包装成一个名为 content 的集合
	 * 比如 ：
	 * 对于请求路径匹配条件，可能有多个 URL pattern,
	 * 对于请求方法匹配条件，可能有多个 HTTP request method,
	 * 对于请求参数匹配条件，可能有多个 param 表达式 .
	 * @return a collection of objects, never  null ， 可能为空集合
	 */
	protected abstract Collection<?> getContent();

	/**
	 * The notation to use when printing discrete items of content.
	 * 将该条件作为字符串展示时，各个组成部分之间的中缀标识符。比如 "||" 或者 "&&" 等。
	 * For example {@code " || " for URL patterns or {@code " && "} for param expressions.
	 */
	protected abstract String getToStringInfix();


	// equlas 实现 
	@Override
	public boolean equals(@Nullable Object other) {
		if (this == other) {
			return true;
		}
		if (other == null || getClass() != other.getClass()) {
			return false;
		}
		return getContent().equals(((AbstractRequestCondition<?>) other).getContent());
	}

	// hashCode 实现
	@Override
	public int hashCode() {
		return getContent().hashCode();
	}

	// toString 实现
	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder("[");
		for (Iterator<?> iterator = getContent().iterator(); iterator.hasNext();) {
			Object expression = iterator.next();
			builder.append(expression.toString());
			if (iterator.hasNext()) {
				builder.append(getToStringInfix());
			}
		}
		builder.append("]");
		return builder.toString();
	}

}

继承 AbstractRequestCondition 的具体实现类

框架还提供了一个实现类RequestConditionHolder，这是一个匹配条件持有器，用于持有某个RequestCondition对象。如果你想持有一个RequestCondition对象,但其类型事先不可知，那么这种情况下该工具很有用。但要注意的是如果要合并或者比较两个RequestConditionHolder对象，也就是二者所持有的RequestCondition对象，那么二者所持有的RequestCondition对象必须是类型相同的，否则会抛出异常ClassCastException。

• SSE介绍
• 前端DEMO
  • 基于AXIOS
  • 基于 EventSource
• SseEmitter
  • service
  • serviceImpl
  • SseSession
  • Controller
• 注意事项

SSE介绍

SSE（Server-SentEvents，即服务器发送事件）是围绕只读Comet交互推出的API或者模式。SSE API用于创建到服务器的单向连接，服务器通过这个连接可以发送任意数量的数据。服务器响应的MIME类型必须是text/event-stream，而且是浏览器中的JavaScript API能解析格式输出。SSE支持短轮询、长轮询和HTTP流，而且能在断开连接时自动确定何时重新连接。

• SSE特点：实现简单、 单向通信、自动重连
• 业务场景：客户端与服务端建立连接后，只需要服务端给客户端发送数据，客户端无需要给服务端发送数据

前端DEMO

基于AXIOS

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
  <script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-3.5.1.min.js"></script>
  <title>Document</title>
</head>

<body>
  <div class="form-group">
    <label for="clientId">clientId:</label>
    <input type="text" class="form-control" id="clientId">
  </div>
  <div class="form-group">
    <label for="content">content</label>
    <input type="text" class="form-control" id="content">
  </div>
  <button id="subscribeBtn" class="btn btn-primary">订阅</button>
  <button id="sendBtn" class="btn btn-primary">发送</button>
  <button id="closeBtn" class="btn btn-primary">关闭</button>

  <p id="responseText">

  </p>
</body>

</html>
<script>
  window.onload = function () {
    let start = 0;
    $("#subscribeBtn").click(() => {
      const clientId = $("#clientId").val();
      start = 0;
      axios({
        method: 'get',
        url: 'http://localhost:8080/smilex/open/sse/subscribe?clientId=' + clientId,
        responseType: 'stream', // 设置为流
        headers: {
          Accept: "text/event-stream" // 接受类型
        },
        onDownloadProgress: res => {
            // 每次推送会在这里打印，但不一定每次都是一次传输完的。
          console.log(res.event.currentTarget.response.substring(start, start + res.bytes))
          start += res.bytes;
        },
      }).then(function (response) {
        console.log("resposne", response)
        const stream = response.data
      });
    })
    $("#sendBtn").click(() => {
      const clientId = $("#clientId").val();
      const content = $("#content").val();
      axios({
        method: 'get',
        url: 'http://localhost:8080/smilex/open/sse/send?clientId=' + clientId + "&content=" + content,
      }).then(function (response) {
        // console.log("发送", response)
      });
    })
    $("#closeBtn").click(() => {
      const clientId = $("#clientId").val();
      axios({
        method: 'get',
        url: 'http://localhost:8080/smilex/open/sse/close?clientId=' + clientId,
      }).then(function (response) {
        // console.log("关闭", response)
      });
    })

  }
</script>

基于 EventSource

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
  <script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-3.5.1.min.js"></script>
  <title>Document</title>
</head>

<body>
  <div class="form-group">
    <label for="clientId">clientId:</label>
    <input type="text" class="form-control" id="clientId">
  </div>
  <div class="form-group">
    <label for="content">content</label>
    <input type="text" class="form-control" id="content">
  </div>
  <button id="subscribeBtn" class="btn btn-primary">订阅</button>
  <button id="sendBtn" class="btn btn-primary">发送</button>
  <button id="closeBtn" class="btn btn-primary">关闭</button>

  <p id="responseText">

  </p>
</body>

</html>
<script>
  // EventSource
 window.onload = function () {
     let source = null
 
     $("#subscribeBtn").click(() => {
       const clientId = $("#clientId").val();
       source = new EventSource("http://localhost:8080/smilex/open/sse/subscribe?clientId=" + clientId);
       source.addEventListener('message', function (e) {
         // console.log("message", e);
         //do something
         $("#responseText").html($("#responseText").html() + "\n" + e.data);
       });
 
       source.addEventListener('open', function (e) {
         //do something
         console.log("open", e)
       }, false);
 
       source.addEventListener('error', function (e) {
         console.log("error", e, source.readyState)
         if (source.readyState == EventSource.CLOSED) {
           //do something
           source.close();
         } else {
           //do something
         }
       }, false);
     })
     $("#sendBtn").click(() => {
       const clientId = $("#clientId").val();
       const content = $("#content").val();
       axios({
         method: 'get',
         url: 'http://localhost:8080/smilex/open/sse/send?clientId=' + clientId + "&content=" + content,
       }).then(function (response) {
         console.log("发送", response)
       });
     })
     $("#closeBtn").click(() => {
       const clientId = $("#clientId").val();
         // 需要主动关闭，如果直接调用接口关闭，会导致自动重连。
       source.close();
       axios({
         method: 'get',
         url: 'http://localhost:8080/smilex/open/sse/close?clientId=' + clientId,
       }).then(function (response) {
         console.log("关闭", response)
         $("#responseText")[0].innerHTML = ""
       });
     })
   }

</script>

SseEmitter

1. 前端发起连接 创建并返回SseEmitter对象
2. 调用SseEmitter对象的send方法
3. 发送结束后，调用 complete方法

service

/**
 * Sse服务
 */
public interface SseService {

    /**
     * 连接
     *
     * @param clientId
     * @return
     */
    SseEmitter connect(String clientId);

    /**
     * 发送
     *
     * @param clientId
     * @param content
     * @return
     */
    boolean send(String clientId, String content);

    /**
     * 关闭
     *
     * @param clientId
     * @return
     */
    boolean close(String clientId);

}

serviceImpl

@Slf4j
@Service
public class SseServiceImpl implements SseService {
    @Override
    public SseEmitter connect(String clientId) {
        if (SseSession.exists(clientId)) {
            SseSession.remove(clientId);
        }
        SseEmitter sseEmitter = new SseEmitter(0L);
        sseEmitter.onError((err) -> {
            log.error("type: SseSession Error, msg: {} session Id : {}", err.getMessage(), clientId);
            SseSession.onError(clientId, err);
        });

        sseEmitter.onTimeout(() -> {
            log.info("type: SseSession Timeout, session Id : {}", clientId);
            SseSession.remove(clientId);
        });

        sseEmitter.onCompletion(() -> {
            log.info("type: SseSession Completion, session Id : {}", clientId);
            SseSession.remove(clientId);
        });
        SseSession.add(clientId, sseEmitter);
        return sseEmitter;
    }

    @Override
    public boolean send(String clientId, String content) {
        if (SseSession.exists(clientId)) {
            try {
                SseSession.send(clientId, content);
                return true;
            } catch (IOException exception) {
                log.error("type: SseSession send Erorr:IOException, msg: {} session Id : {}", exception.getMessage(), clientId);
            }
        } else {
            throw new SXException("User Id " + clientId + " not Found");
        }
        return false;
    }

    @Override
    public boolean close(String clientId) {
        log.info("type: SseSession Close, session Id : {}", clientId);
        return SseSession.remove(clientId);
    }
}

SseSession

利用Map 管理全局的 SseEmitter

public class SseSession {


    private static Map<String, SseEmitter> sessionMap = new ConcurrentHashMap<>();

    public static void add(String sessionKey, SseEmitter sseEmitter) {
        if (sessionMap.get(sessionKey) != null) {
            throw new SXException("client exists!");
        }
        sessionMap.put(sessionKey, sseEmitter);
    }

    public static boolean exists(String sessionKey) {
        return sessionMap.get(sessionKey) != null;
    }

    public static boolean remove(String sessionKey) {
        SseEmitter sseEmitter = sessionMap.get(sessionKey);
        if (sseEmitter != null) {
            sseEmitter.complete();
            sessionMap.remove(sessionKey);
            return true;
        }
        return false;
    }

    public static void onError(String sessionKey, Throwable throwable) {
        SseEmitter sseEmitter = sessionMap.get(sessionKey);
        if (sseEmitter != null) {
            sseEmitter.completeWithError(throwable);
        }
    }

    public static void send(String sessionKey, String content) throws IOException {
        sessionMap.get(sessionKey).send(content);
    }

}

Controller

/**
 * SSE测试
 */
@RestController
@RequestMapping("/demo/sse")
public class DemoSseController {

    @Resource
    private SseService sseService;

    @RequestMapping(value = "/subscribe", produces = {MediaType.TEXT_EVENT_STREAM_VALUE})
    public SseEmitter subscribe(String clientId) {
        return sseService.connect(clientId);
    }


    @RequestMapping(value = "/send")
    public R send(String clientId, String content) {
        if (sseService.send(clientId, content)) {
            return R.success();
        }
        return R.fail();
    }


    @RequestMapping(value = "/close")
    public R close(String clientId) {
        sseService.close(clientId);
        return R.success();
    }


}

注意事项

1. 前端使用EventSource时，如果后端服务先关闭了连接，那么 EventSource会抛出异常并自动发起重连。所以如果不想重连，需要前端关闭后，再关闭后端连接。

• 参考

参考

https://www.cnblogs.com/guogangj/p/5457959.html

https://blog.csdn.net/f641385712/article/details/88692534

https://blog.csdn.net/f641385712/article/details/88710676

• 什么是跨域
• 什么是CORS
• SpringBoot下3种常见的cors方案
• 参考

什么是跨域

同源策略是由 Netscape 提出的一个著名的安全策略，它是浏览器最核心也最基本的安全功能，现在所有支持 JavaScript 的浏览器都会使用这个策略。所谓同源是指协议、域名以及端口要相同。

同源策略是基于安全方面的考虑提出来的，这个策略本身没问题，但是我们在实际开发中，由于各种原因又经常有跨域的需求，传统的跨域方案是 JSONP，JSONP 虽然能解决跨域但是有一个很大的局限性，那就是只支持 GET 请求，不支持其他类型的请求，在 RESTful 时代这几乎就没什么用。

什么是CORS

CORS，Cross-origin resource sharing是一个 W3C 标准，提供了 Web 服务从不同网域传来沙盒脚本的方法，以避开浏览器的同源策略，这是 JSONP 模式的现代版。

• 域，指的是一个站点，由protocal、host和port三部分组成，其中host可以是域名，也可以是 ip:port。如果没有指明，则是使用protocal的默认端口
• 同源策略， 指的是为了防止 XSS， 浏览器、客户端应该仅请求与当前页面来自同一个域的资源， 请求其他域的资源需要通过验证。

CORS需要浏览器和服务器同时支持。目前，所有浏览器都支持该功能，IE浏览器不能低于IE10。

浏览器一旦发现AJAX请求跨源，就会自动添加一些附加的头信息，有时还会多出一次附加的请求，但用户不会有感觉。

实现CORS通信的关键是服务器。只要服务器实现了CORS接口，就可以跨源通信。

关于CORS可以看一下这篇文章

SpringBoot下3种常见的cors方案

1. @CrossOrigin。针对单个类或者方法。

@CrossOrigin(value = "http://localhost:8081")
@PostMapping("/hello")
public String hello() {
    return "post hello";
}

2. WebMvcConfigurer。全局配置

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowCredentials(true)
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
                .maxAge(3600);
    }

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addFormatter(new DateFormatter("yyyy-MM-dd HH:mm:ss"));
    }
}

3. 注入CorsFilter。过滤器

@Configuration
public class CorsConfig {

    private CorsConfiguration corsConfig() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.setMaxAge(3600L);
        return corsConfiguration;
    }
    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", corsConfig());
        return new CorsFilter(source);
    }
}

4. FilterRegistrationBean。也是基于过滤器

参考

• https://www.ruanyifeng.com/blog/2016/04/cors.html
• https://blog.51cto.com/u_15080000/2593305
• https://mp.weixin.qq.com/s?__biz=MzI1NDY0MTkzNQ==&mid=2247488989&idx=1&sn=00881de1a77c2e4027ee948164644485&scene=21#wechat_redirect

• 前言
• 准备工作
  • Maven版本
  • 数据库结构
  • 常量值
• 核心
  • @SysLog
  • SysLogAspect
• 使用方法

前言

这边文章是通过使用注解+AOP的形式，在业务代码前后做日志增强的功能。这样在不更改业务代码的情况下，利用注解作为 Pointcut 快速实现日志记录的功能。

准备工作

Maven版本

这里是基于springboot-2.3.5版本，需要引入 SpringAop 库。

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

数据库结构

我这里采用的将接口访问日志，存储到 Mysql 数据库中，其它数据库原理一致，具体根据自己项目结构进行调整。

CREATE TABLE `sys_log` (
  `id` bigint(20) NOT NULL COMMENT 'ID',
  `log_module` varchar(50) NOT NULL COMMENT '日志模块，sys,blog',
  `log_title` varchar(50) NOT NULL COMMENT '日志标题',
  `log_value` varchar(50) NOT NULL COMMENT '日志内容',
  `log_type` tinyint(2) NOT NULL COMMENT '日志类型1:登录日志;2:操作日志;3:定时任务;4:异常日志;',
  `user_id` bigint(20) NOT NULL COMMENT '用户ID',
  `operate_type` tinyint(2) NOT NULL COMMENT '操作类型',
  `ip_address` varchar(100) DEFAULT NULL COMMENT 'IP地址',
  `method` varchar(500) DEFAULT NULL COMMENT '请求方法',
  `request_url` varchar(50) DEFAULT NULL COMMENT '请求url路径',
  `request_type` varchar(50) DEFAULT NULL COMMENT '请求类型',
  `request_params` text COMMENT '请求参数',
  `cost_time` int(11) DEFAULT NULL COMMENT '耗费时间',
  `err_msg` varchar(1000) DEFAULT NULL COMMENT '异常信息',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `create_by` varchar(50) DEFAULT NULL COMMENT '创建人',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `update_by` varchar(50) DEFAULT NULL COMMENT '更新人',
  `del_flag` tinyint(1) NOT NULL DEFAULT '0' COMMENT '是否删除，1是，0否',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='系统日志';

常量值

我将系统中使用的常量值单独分离了出来。

public interface CommonConstant {
    /**************************SysLog 日志常量**************************/
    //查询
    public static final int SYS_LOG_OPERATE_QUERY = 1;
    //添加
    public static final int SYS_LOG_OPERATE_SAVE = 2;
    //更新
    public static final int SYS_LOG_OPERATE_UPDATE = 3;
    //删除
    public static final int SYS_LOG_OPERATE_REMOVE = 4;
    //导入
    public static final int SYS_LOG_OPERATE_IMPORT = 5;
    //导出
    public static final int SYS_LOG_OPERATE_EXPORT = 6;

    //登录
    public static final int SYS_LOG_TYPE_LOGIN = 1;
    //操作
    public static final int SYS_LOG_TYPE_OPERATE = 2;
    //定时
    public static final int SYS_LOG_TYPE_TIME = 3;
    //异常
    public static final int SYS_LOG_TYPE_ERROR = 4;
}

核心

这里的核心基于两个事物：

1. @interface 注解类
2. @Aspect 切面编程

@SysLog

这里根据我对系统的设计划分

• module：所属模块，可以划分大模块比如(Sys,系统模块)，(Blog,博客模块)。
• title：子模块标题，可以简单划分大模块下的子模块。
• logType：日志类型，分为1:登录日志;2:操作日志;3:定时任务;4:异常日志。
• opreateType：操作类型，1查询，2添加，3修改，4删除，5导入，6导出。
• 日志内容：日志内容。

/**
 * 系统日志
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SysLog {

    /**
     * 所属模块
     *
     * @return ModuleType
     */
    ModuleType module() default ModuleType.SYS;

    /**
     * 标题
     * 例如：菜单管理
     *
     * @return
     */
    String title() default "";

    /**
     * 日志类型
     *
     * @return 1:登录日志;2:操作日志;3:定时任务;4:异常日志;
     */
    int logType() default CommonConstant.SYS_LOG_TYPE_OPERATE;

    /**
     * 操作类型
     *
     * @return （1查询，2添加，3修改，4删除，5导入，6导出）
     */
    int operateType() default 0;

    /**
     * 日志内容
     *
     * @return
     */
    String value() default "";
}

SysLogAspect

这里有几个需要注意的地方

1. 需要在类上添加@Component 和 @Aspect 注解，前者是为了将SysLogAspect 作为一个Bean，注入到Spring容器中；后者是为了开启切面功能
2. @Pointcut 注入点，注入点说明该切面在什么情况下生效，这里使用 "@annotation(top.zsmile.common.log.annotation.SysLog)" 表示只要是有加@SysLog注解的地方就能注入切面功能。
3. @Around，括号内使用的就是对应的切点sysLogPointcut()，这时around方法就会执行。
4. ProceedingJoinPoint joinPoint，指的是对应的执行点，当我们调用proceed()时，会调用对应的业务代码。

@Slf4j
@Component
@Aspect
public class SysLogAspect {
    @Autowired
    private SysLogService sysLogService;

    @Autowired
    private CommonAuthApi commonAuthApi;

    @Pointcut("@annotation(top.zsmile.common.log.annotation.SysLog)")
    public void sysLogPointcut() {

    }

    @Around("sysLogPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        long beginTime = System.currentTimeMillis();
        try {
            //执行方法
            Object result = joinPoint.proceed();
            //执行时长(毫秒)
            long time = System.currentTimeMillis() - beginTime;
            //保存日志
            saveSysLog(joinPoint, time, result);
            return result;
        } catch (Throwable throwable) {
            // 异常日志
            long time = System.currentTimeMillis() - beginTime;
            saveErrorLog(joinPoint, time, throwable.getMessage());
            throw throwable;
        }
    }

    /**
     * 保存错误日志
     *
     * @param joinPoint
     * @param costTime
     * @param errMsg
     */
    private void saveErrorLog(ProceedingJoinPoint joinPoint, long costTime, String errMsg) {
        SysLogEntity sysLogEntity = commonLog(joinPoint, costTime, CommonConstant.SYS_LOG_TYPE_ERROR);
        sysLogEntity.setErrMsg(errMsg);
        sysLogService.save(sysLogEntity);
    }

    /**
     * 保存正常日志
     *
     * @param joinPoint
     * @param costTime
     * @param result
     */
    private void saveSysLog(ProceedingJoinPoint joinPoint, long costTime, Object result) {
        SysLogEntity sysLogEntity = commonLog(joinPoint, costTime);
        sysLogService.save(sysLogEntity);
    }

    private SysLogEntity commonLog(ProceedingJoinPoint joinPoint, long costTime) {
        return commonLog(joinPoint, costTime, 0);
    }

    private SysLogEntity commonLog(ProceedingJoinPoint joinPoint, long costTime, int logType) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        SysLogEntity sysLogEntity = new SysLogEntity();
        SysLog sysLogAnno = method.getAnnotation(SysLog.class);
        if (sysLogAnno != null) {
            String title = sysLogAnno.title();
            ModuleType module = sysLogAnno.module();
            int operateType = sysLogAnno.operateType();
            String value = sysLogAnno.value();
            sysLogEntity.setLogTitle(title);
            sysLogEntity.setLogValue(value);
            sysLogEntity.setLogType(logType > 0 ? logType : sysLogAnno.logType());
            sysLogEntity.setOperateType(getOperateType(method.getName(), operateType));
            sysLogEntity.setLogModule(module.name());
        }

        //获取request
        HttpServletRequest request = SpringContextUtils.getHttpServletRequest();
        sysLogEntity.setIpAddress(IPUtils.getIpAddrByRequest(request));

        //请求的方法名
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = signature.getName();
        sysLogEntity.setMethod(className + "." + methodName);

        // 请求类型
        sysLogEntity.setRequestType(request.getMethod());

        // 耗时
        sysLogEntity.setCostTime(costTime);

        // 请求参数
        sysLogEntity.setRequestParams(getParams(joinPoint, request));

        // 操作用户Id
        Long userId = commonAuthApi.queryUserId();
        sysLogEntity.setUserId(userId);

        return sysLogEntity;
    }

    private int getOperateType(String methodName, int operateType) {
        if (operateType > 0) {
            return operateType;
        }
        if (methodName.startsWith("query") || methodName.startsWith("list")) {
            return CommonConstant.SYS_LOG_OPERATE_QUERY;
        } else if (methodName.startsWith("save")) {
            return CommonConstant.SYS_LOG_OPERATE_SAVE;
        } else if (methodName.startsWith("update")) {
            return CommonConstant.SYS_LOG_OPERATE_UPDATE;
        } else if (methodName.startsWith("remove")) {
            return CommonConstant.SYS_LOG_OPERATE_REMOVE;
        } else if (methodName.startsWith("import")) {
            return CommonConstant.SYS_LOG_OPERATE_IMPORT;
        } else if (methodName.startsWith("export")) {
            return CommonConstant.SYS_LOG_OPERATE_EXPORT;
        }
        return CommonConstant.SYS_LOG_OPERATE_QUERY;
    }

    /**
     * 获取Request参数
     *
     * @param httpServletRequest
     * @return
     */
    private String getParams(ProceedingJoinPoint joinPoint, HttpServletRequest httpServletRequest) {
        String method = httpServletRequest.getMethod();
        if (method.equalsIgnoreCase("POST") || method.equalsIgnoreCase("PUT") || method.equalsIgnoreCase("DELET")) {
            PropertyFilter profilter = new PropertyFilter() {
                @Override
                public boolean apply(Object o, String name, Object value) {
                    if (value != null && value.toString().length() > 200) {
                        return false;
                    }
                    return true;
                }
            };
            return JSON.toJSONString(joinPoint.getArgs(), profilter);
        } else {
            return JSON.toJSONString(httpServletRequest.getParameterMap());
        }
    }
}

使用方法

@SysLog(title = "角色管理", operateType = CommonConstant.SYS_LOG_OPERATE_QUERY, value = "分页查询")

• 前言
• 解决方法
  • 基于注解@JsonSerialize(不推荐)
    • 基于jackson全局配置(不推荐)
  • 使用JsonComponent 序列化配置
    • WebMvcConfigurationSupport 分析
  • WebMvcConfigurer/WebMvcConfigurationSupport
    • 分析
    • 解决方法

前言

最近在开发中，碰到一个问题，关于数据库Long类型查询后，返回给前端后，精度丢失。

297874820157145088 => 297874820157145100

• 后端源码地址
• 前端源码地址

数据库数据如下：

查询语句如下：

SELECT id AS id, dict_code AS dictCode, dict_name AS dictName, remark AS remark, create_time AS createTime, create_by AS createBy, update_time AS updateTime, update_by AS updateBy, del_flag AS delFlag FROM sys_dict WHERE (del_flag=0) LIMIT 10 OFFSET 0

查询结果：(正确，此时并未出现精度丢失)

再来看一下Springboot准备返回时的数据显示：

这里可以看到返回类型是Long类型且精度并未丢失。

可以看到这时前端显示出来的，就出现问题了。是不是网络传输的过程有问题呢？我们换PostMan试一下。

可以看见这里的id是正确的，那么应该时JavaScript导致的精度丢失了。

大致看了一下网上的思路，因为JavaScript 的整数类型范围有限，精度为17位 ，当接口返回的Long类型过长时，javaScript会进行截断，所以解决办法就是把Long类型转换成String类型返回，这样就不会由精度丢失的问题了。

解决方法

基于注解@JsonSerialize(不推荐)

最直接的方式就是在需要转换的Long类型字段使用注解标记。

@JsonSerialize
private Long id;

这样子好处是可以对单个的字段进行精细管理，但是需要每个字段都添加转换，很不方便，工作量大。

基于jackson全局配置(不推荐)

spring:
	jackson:
		generator:
			write-numbers-as-strings: true

这个方法会将全局所有的数字类型包括int/long等都转换为string类型返回，不推荐使用。

使用JsonComponent 序列化配置

@JsonComponent
public class JsonConfig {

    /**
     * 添加Long转json精度丢失的配置
     */
    @Bean
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        ObjectMapper objectMapper = builder.createXmlMapper(false).build();
        SimpleModule module = new SimpleModule();
        module.addSerializer(Long.class, ToStringSerializer.instance);
        module.addSerializer(Long.TYPE, ToStringSerializer.instance);
        objectMapper.registerModule(module);
        return objectMapper;
    }
}

为什么这样写能生效呢？我们可以看一下 WebMvcConfigurationSupport 类。

WebMvcConfigurationSupport 分析

//初始化
static {
   // etc...
    jackson2Present = ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", classLoader) && ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator", classLoader);
}

// 添加默认的httpMesssage转换器
protected final void addDefaultHttpMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
    //etc
    
    if (jackson2Present) {
        builder = Jackson2ObjectMapperBuilder.json();
        if (this.applicationContext != null) {
            builder.applicationContext(this.applicationContext);
        }

        messageConverters.add(new MappingJackson2HttpMessageConverter(builder.build()));
    }
}       

这里可以看出来Springboot提供的默认mvc配置内容：

1. 初始化并查找是否有 ObjectMapper 类
2. 如果没有发现 ObjectMapper Bean对象，就会提供给一个默认的 MappingJackson2HttpMessageConverter 对象。
3. 如果发现 ObjectMapper Bean对象，就会将这个绑定到默认的转换器上。

WebMvcConfigurer/WebMvcConfigurationSupport

这里虽然将这两个类放一起，是因为都能基于他们去重写 configureMessageConverters方法，来实现对转换器的添加。

@Configuration
public class WebConfig implements WebMvcConfigurer {
	
    /**
     * 添加Long转json精度丢失的配置
     *
     * @Return: void
     */
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
        simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
        objectMapper.registerModule(simpleModule);
        jackson2HttpMessageConverter.setObjectMapper(objectMapper);
        converters.add(jackson2HttpMessageConverter);
    }
}

这里需要注意的是，该方法可能存在失效的情况，但是如果我们改成这样，就能有效。

converters.add(0,jackson2HttpMessageConverter);

这是为什么呢？让我们探究一下。

分析

先看一下都有什么转换器。

可以看到在我们添加转换器前，就已经有了2个 Mappingjackson2HttpMessageConverter 了。我们说过springboot 自带了 HttpMessageConverter 。

那么这时出现多个，会不会相互之间有影响？

// AbstractMessageConverterMethodProcessor.class
if (selectedMediaType != null) {
    selectedMediaType = selectedMediaType.removeQualityValue();
    for (HttpMessageConverter<?> converter : this.messageConverters) {
        GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ?
                                                        (GenericHttpMessageConverter<?>) converter : null);
        if (genericConverter != null ?
            ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
            converter.canWrite(valueType, selectedMediaType)) {
            body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
                                               (Class<? extends HttpMessageConverter<?>>) converter.getClass(),
                                               inputMessage, outputMessage);
            if (body != null) {
                Object theBody = body;
                LogFormatUtils.traceDebug(logger, traceOn ->
                                          "Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
                addContentDispositionHeader(inputMessage, outputMessage);
                if (genericConverter != null) {
                    genericConverter.write(body, targetType, selectedMediaType, outputMessage);
                }
                else {
                    ((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
                }
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Nothing to write: null body");
                }
            }
            return;
        }
    }
}

// AbstractMessageConverterMethodArgumentResolver.class
for (HttpMessageConverter<?> converter : this.messageConverters) {
    Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
    GenericHttpMessageConverter<?> genericConverter =
        (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
    if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
        (targetClass != null && converter.canRead(targetClass, contentType))) {
        if (message.hasBody()) {
            HttpInputMessage msgToUse =
                getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
            body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
                    ((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
            body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
        }
        else {
            body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
        }
        break;
    }
}

这里可以看到，会遍历messageConverters转换器列表，但是问题在于，如果有一个 HttpMessageConverter 类响应了读写信息，那么就会进行返回，这样导致了后面的转换器不生效。

解决方法

那么针对这种有几种解决方法

1. 提升自定义的消息处理转换器优先级；

converters.add(0,jackson2HttpMessageConverter);

2. 移除列表里的springboot 默认的转换器；

converters.removeIf(converter -> converter instanceof MappingJackson2HttpMessageConverter);

3. 使用@EnableWebMvc 注解。慎用，会清空sprinb自带的默认转换器导致某些功能失效。此时的converters转换列表为空。

@EnableWebMvc
@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        MappingJackson2HttpMessageConverter jackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
        simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
        objectMapper.registerModule(simpleModule);
        jackson2HttpMessageConverter.setObjectMapper(objectMapper);
        converters.add(jackson2HttpMessageConverter);
    }
}

• springboot 多模块配置注意点
  • 模块依赖且项目下的包路径不一致
  • 包扫描启动分析TODO
    • 参考链接

springboot 多模块配置注意点

模块依赖且项目下的包路径不一致

当有模块A和模块B时，假设项目结构如下

• module A
  • com
    • aaa
      • TestABean.java
• module B
  • com
    • bbb
      • TestBBean.java
      • SpringbootApplication.java

此时SpringbootApplication是无法加载到com.aaa下的TestABean。这时因为com.aaa和com.bbb不属于同一目录下，而springbootApplication的扫描，默认是当前目录作为相对根路径进行扫描组件的，那么我们应该怎么处理这个问题。 有几种解决方式：

1. 利用@ComponentScan

@ComponentScan(basePackages = {"com.aaa","com.bbb"})

2. 利用@ComponentScans

@ComponentScans({@ComponentScan("com.aaa"),@ComponentScan("com.bbb")})

2. 利用@SpringBootApplication。

@SpringBootApplication(scanBasePackages = {"com.aaa","com.bbb"})

都能实现扫描到包的效果，那么这三者有什么异同呢？

1. @SpringBootApplication 默认会自动扫描同一包下的子包。

2. @SpringBootApplication和@ComponentScan设置后，都会覆盖@SpringBootApplication的默认扫描行为

3. @ComponentScans不会覆盖@SpringBootApplication的默认扫描行为

// 无法加载到TestBBean
@ComponentScan(basePackages = {"com.aaa"})
@SpringBootApplication(scanBasePackages = {"com.aaa"})

// 可以加载到TestBBean
@ComponentScan(basePackages = {"com.aaa","com.bbb"})
@SpringBootApplication(scanBasePackages = {"com.aaa","com.bbb"})
@ComponentScans({@ComponentScan("com.aaa")})

包扫描启动分析TODO

这里用的 Spring Boot 2.3.5.RELEASE 版本。

这里只关注重点的关键代码。

// ConfigurationClassParser
/**
	 * Apply processing and build a complete {@link ConfigurationClass} by reading the
	 * annotations, members and methods from the source class. This method can be called
	 * multiple times as relevant sources are discovered.
	 * @param configClass the configuration class being build
	 * @param sourceClass a source class
	 * @return the superclass, or {@code null} if none found or previously processed
	 */
@Nullable
protected final SourceClass doProcessConfigurationClass(
    ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    throws IOException {

    // ...

    // Process any @ComponentScan annotations
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
        sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
        !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // The config class is annotated with @ComponentScan -> perform the scan immediately
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
            // Check the set of scanned definitions for any further config classes and parse recursively if needed
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }
    // ...
}

这里获取了ComponenetScan和ConponentScans两个注解配置，让我们看看 AnnotationConfigUtils.attributesForRepeatable 里面发生了什么。

// AnnotationConfigUtils
static Set<AnnotationAttributes> attributesForRepeatable(AnnotationMetadata metadata,
			Class<?> containerClass, Class<?> annotationClass) {

    return attributesForRepeatable(metadata, containerClass.getName(), annotationClass.getName());
}

@SuppressWarnings("unchecked")
static Set<AnnotationAttributes> attributesForRepeatable(
    AnnotationMetadata metadata, String containerClassName, String annotationClassName) {

    Set<AnnotationAttributes> result = new LinkedHashSet<>();

    // Direct annotation present?
    addAttributesIfNotNull(result, metadata.getAnnotationAttributes(annotationClassName, false));

    // Container annotation present?
    Map<String, Object> container = metadata.getAnnotationAttributes(containerClassName, false);
    if (container != null && container.containsKey("value")) {
        for (Map<String, Object> containedAttributes : (Map<String, Object>[]) container.get("value")) {
            addAttributesIfNotNull(result, containedAttributes);
        }
    }

    // Return merged result
    return Collections.unmodifiableSet(result);
}

参考链接

• https://my.oschina.net/icebergxty/blog/3142263
• https://my.oschina.net/icebergxty/blog/3103354

• mybatis使用LocalDateTime
• springboot使用LocalDateTime
  • maven引入
  • 使用jackson 全局统一转换
  • 局部转换
    • @JsonFormat 注解

mybatis使用LocalDateTime

1. 查看mybatis版本。 从 3.4.5 开始，MyBatis 默认支持 JSR-310 。如果是3.4.5以下的版本需要引入 JSR-310。

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-typehandlers-jsr310</artifactId>
  <version>1.0.2</version>
</dependency>

2. 给JDBC连接加上时区属性，避免时间出现偏差。

&serverTimezone=Asia/Shanghai

springboot使用LocalDateTime

maven引入

• 以下几种情况不用单独引入jackson-datatype-jsr
  • 引入了 spring-boot-starter-web
  • 引入了 spring-boot-starter-json

<dependency>
         <groupId>com.fasterxml.jackson.datatype</groupId>
         <artifactId>jackson-datatype-jsr310</artifactId>
 </dependency>

使用jackson 全局统一转换

• 利用ObjectMapper输入输出转换时间格式，添加时间序列化。

public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

@Bean
public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
    ObjectMapper objectMapper = builder.createXmlMapper(false).build();

	// 简单类型转换
    SimpleModule module = new SimpleModule();
    module.addSerializer(Long.class, ToStringSerializer.instance);
    module.addSerializer(Long.TYPE, ToStringSerializer.instance);

    /**
         * localDateTime => yyyy-MM-dd HH:mm:ss
         * localDate => yyyy-MM-dd
         * localTime => HH:mm:ss
         */
    JavaTimeModule javaTimeModule = new JavaTimeModule();
    module.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
    module.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
    module.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
    module.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
    module.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
    module.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
    objectMapper.registerModules(module, javaTimeModule);
    // 不序列化为null
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    return objectMapper;
}

• 利用 Jackson2ObjectMapperBuilderCustomizer 序列化

public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

@Bean
public Jackson2ObjectMapperBuilderCustomizer jackson2ObjectMapperBuilderCustomizer() {
    return builder -> {
        builder.serializerByType(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
        builder.deserializerByType(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
        builder.serializerByType(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
        builder.deserializerByType(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
        builder.serializerByType(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
        builder.deserializerByType(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
    };
}

局部转换

@JsonFormat 注解

利用注解 @JsonFormat 加在需要用的实体类时间字段上，就会完成格式化。

public class testVO {
    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;

    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd")
    private LocalDate updateTime;
}

• springboot 下mybatis-plus配置方式
• 问题记录
  • 关于 Invalid bound statement 异常问题

springboot 下mybatis-plus配置方式

1. 基于yml配置

mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
  global-config:
    banner: false
    db-config:
      #主键类型  0:"数据库ID自增",1:"该类型为未设置主键类型", 2:"用户输入ID",3:"全局唯一ID (数字类型唯一ID)", 4:"全局唯一ID UUID",5:"字符串全局唯一ID (idWorker 的字符串表示)";
      id-type: ASSIGN_ID
      logic-delete-field: del_flag
      logic-delete-value: 1
      logic-not-delete-value: 0
      table-underline: true
  configuration:
    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 返回类型为Map,显示null对应的字段
    call-setters-on-nulls: true

2. 基于Springboot 的SqlSessionFactory Bean 注入

@Bean(name = "sqlSessionFactory")
public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
    throws Exception {
    final MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();

    GlobalConfig globalConfig = new GlobalConfig();
    globalConfig.setBanner(false);

    GlobalConfig.DbConfig dbConfig = new GlobalConfig.DbConfig();
    dbConfig.setIdType(IdType.ASSIGN_ID);
    dbConfig.setLogicDeleteField("del_flag");
    dbConfig.setLogicDeleteValue("1");
    dbConfig.setLogicNotDeleteValue("0");
    dbConfig.setTableUnderline(true);
    globalConfig.setDbConfig(dbConfig);


    MybatisConfiguration configuration = new MybatisConfiguration();
    configuration.setLogImpl(org.apache.ibatis.logging.stdout.StdOutImpl.class);
    configuration.setCallSettersOnNulls(true);

    sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:/mapper/**/*.xml"));
    sessionFactory.setGlobalConfig(globalConfig);
    sessionFactory.setDataSource(dynamicDataSource);
    sessionFactory.setConfiguration(configuration);
    return sessionFactory.getObject();
}

问题记录

关于 Invalid bound statement 异常问题

记录20220311

发现了个异常，我的项目突然出现了Invalid bound statement，然后由于项目的Application启动类，放在了com.xxx.modules下，导致会出现组件加载异常和Invalid bound statement问题，当我将Application启动类移到com.xxx下，组件扫描正常，但是依然无法扫描到xml。

经过排查，当映射成功的时候，我发现dao层的对象是mybatis-plus.mapperProxy代理，故障时却是显示是mybatis.mapperProxy代理，那么是什么原因导致这个问题呢？

尝试的解决方式1.

@ComponentScan("com.xxx.modules.dao")

此时能够扫描到xml，但是感觉到问题不应该出现在这里。

继续查找原因，发现之前写多数据源时设置了SqlSessionFactory。

@Bean(name = "sqlSessionFactory")
public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
    throws Exception {
    final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
    return sessionFactory.getObject();
}

这里的sessionFactory没有使用到yml里面的Mybatis-plus的配置。这也就意味着，我在yml里面的配置完全无效，屏蔽掉sqlSessionFactory的注释后，项目正常运行了。

• knife4j
  • 前言
  • Maven版本
  • Swagger2Config
  • 增强
  • 注意事项
    • Shiro整合使用
    • 统一返回实体
  • 界面
    • 设置全局token

knife4j

knife4j是为Java MVC框架集成Swagger生成Api文档的增强解决方案 。

• 官网

• 访问地址都是/doc.html

前言

最近打算给自己的后台管理系统增加一个API管理，但是原生的Swagger，十分嫌弃，太丑了，所以找了个Knife4j，感觉上好看很多了。

Maven版本

这里是基于springboot-2.3.5版本，OpenApi2。特别说明一下，我这里使用的是单体应用，如果架构不同会有区分微服务版本、网关版本等。

<!-- knife4j -->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
    <version>2.0.9</version>
</dependency>

Swagger2Config

因为代码篇幅较多，我将对应的说明描述下代码里面，就不在外说明了。

@Configuration
@EnableSwagger2WebMvc
public class Swagger2Config {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo()).enable(true)
                .select()
                /***
                 重要的两个方法:
                 apis():指定要生成文档的接口包基本路径
                 paths():指定针对哪些请求生成接口文档
                 参考官方资料：http://www.baeldung.com/swagger-2-documentation-for-spring-rest-api
                 ****/
                // 1. 将 top.zsmile 设置为基础包扫描。
                // 2. 只包含 RestController 注解，也可以使用 Api 注解，但是对应的类需要添加。
                // 3. 针对所有路径扫描
                .apis(RequestHandlerSelectors.basePackage("top.zsmile"))
                .apis(RequestHandlerSelectors.withClassAnnotation(RestController.class))
                .paths(PathSelectors.any())
                .build()
                .securitySchemes(securityScheme())
                .securityContexts(securityContexts());

    }

    /**
     * 安全计划
     * 使用 X-ACCESS-TOKEN 作为请求头，添加在 HTTP Header 里面
     *
     * @return
     */
    @Bean
    public List<ApiKey> securityScheme() {
        return Collections.singletonList(new ApiKey(CommonConstant.X_ACCESS_TOKEN, CommonConstant.X_ACCESS_TOKEN, "header"));
    }

    /**
     * 新增 securityContexts 保持登录状态
     */
    private List<SecurityContext> securityContexts() {
        return Collections.singletonList(SecurityContext.builder()
                .securityReferences(defaultAuth())
                //设置需要登录认证的路径，非noauth开头的都需要Token认证
                .forPaths(PathSelectors.regex("^(?!noauth).*$"))
                .build());

    }

    /**
     * 默认授权
     *
     * @return
     */
    private List<SecurityReference> defaultAuth() {
        // 权限范围：Scope=>全局，设置在keyName=>X-ACCESS-TOKEN
        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        return Collections.singletonList(new SecurityReference(CommonConstant.X_ACCESS_TOKEN, authorizationScopes));
    }

    /**
     * 文档信息
     *
     * @return
     */
    private ApiInfo apiInfo() {
        Contact smileX = new Contact("SmileX", "https://github.com/smileluck", "");
        return new ApiInfoBuilder()
                .title("SmileX项目接口文档")
                .description("API接口文档")
                .version("1.0.0")
                .termsOfServiceUrl("https://github.com/smileluck")
                .contact(smileX)
                .build();
    }
}

经过这个配置，其实已经可以使用了。

增强

接下来是为了打开knife4j的增强，可以采用注解 @EnableKnife4j 开启增强。

@EnableKnife4j
@Configuration
@EnableSwagger2WebMvc
public class Swagger2Config {}

或者通过yaml的形式进行配置。

knife4j:
  # 开启增强
  enable: true
  # 开启生产环境保护
  production: false
  # 开启Swagger的Basic认证功能,默认是false
  basic:
    enable: false
    # Basic认证用户名
    username: knifeAdmin
    # Basic认证密码
    password: knifeAdmin

更多配置请查看官方文档。

注意事项

Shiro整合使用

需要给knife4j 的路径进行放行，否则当我们访问时会出现401的问题。

/*swagger*/
chainDefinition.addPathDefinition("/doc.html", "anon");
chainDefinition.addPathDefinition("/webjars/**", "anon");
chainDefinition.addPathDefinition("/v2/api-docs", "anon");
chainDefinition.addPathDefinition("/swagger-resources", "anon");

如果使用了权限框架，如shiro、SpringSecurity，需要WebMvcConfigurer里面添加配置：

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    /**
     * 显示swagger-ui.html文档展示页，还必须注入swagger资源：
     *
     * @param registry
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("doc.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
    }
}

统一返回实体

@ApiModel("统一返回结果")
public class R<T> implements Serializable {
    public static final long serialVersionUID = 1L;

    @ApiModelProperty("状态码")
    private int code;
    @ApiModelProperty("响应信息")
    private String msg;
    @ApiModelProperty("结果")
    private T data;
    @ApiModelProperty("是否成功")
    private boolean success;

    private R(int code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
        this.success = ResultCode.SUCCESS.getCode() == code;
    }

    private R(int code, String msg) {
        this(code, msg, null);
    }

    private R(ResultCode resultCode) {
        this(resultCode.getCode(), resultCode.getMessage());
    }

    private R(ResultCode resultCode, String msg) {
        this(resultCode.getCode(), msg);
    }

    private R(ResultCode resultCode, T data) {
        this(resultCode.getCode(), resultCode.getMessage(), data);
    }

    private R(ResultCode resultCode, String msg, T data) {
        this(resultCode.getCode(), msg, data);
    }


    public static <T> R<T> success() {
        return new R(ResultCode.SUCCESS);
    }

    public static <T> R<T> success(ResultCode resultCode) {
        return new R(resultCode);
    }

    public static <T> R<T> success(ResultCode resultCode, String msg) {
        return new R(resultCode, msg);
    }

    public static <T> R<T> success(String msg) {
        return new R(ResultCode.SUCCESS, msg);
    }

    public static <T> R<T> success(T data) {
        return new R(ResultCode.SUCCESS, data);
    }

    public static <T> R<T> success(String msg, T data) {
        return new R(ResultCode.SUCCESS, msg, data);
    }

    public static <T> R<T> fail() {
        return new R(ResultCode.FAILURE);
    }

    public static <T> R<T> fail(Integer code, String msg) {
        return new R(code, msg);
    }

    public static <T> R<T> fail(ResultCode resultCode) {
        return new R(resultCode);
    }

    public static <T> R<T> fail(ResultCode resultCode, String msg) {
        return new R(resultCode, msg);
    }

    public static <T> R<T> fail(String msg) {
        return new R(ResultCode.FAILURE, msg);
    }

    public static <T> R<T> fail(T data) {
        return new R(ResultCode.FAILURE, data);
    }

    public static <T> R<T> fail(String msg, T data) {
        return new R(ResultCode.FAILURE, msg, data);
    }

    public static boolean isSuccess(@Nullable R r) {
        return ObjectUtils.nullSafeEquals(ResultCode.SUCCESS, r.getCode());
    }

    public static boolean isNotSuccess(@Nullable R r) {
        return !isSuccess(r);
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public boolean getSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

}

界面

设置全局token

只要在这里填入token，那么就会自动注入到所有请求的请求头中使用。

• 前言
• 构建工程
  • 构建新的SpringCloud工程
  • 添加Spring Cloud到现有的 Springboot 项目
  • Spring Cloud Alibaba
• 基础组件

前言

官网文档：https://spring.io/projects/spring-cloud

构建工程

构建新的SpringCloud工程

最简单的方法是访问start.spring.io网站，选择合适的SpringBoot和SpringCloud版本，进行构建。

添加Spring Cloud到现有的 Springboot 项目

如果你想要添加 SpringCloud 到一个现有的 SpringBoot 应用，第一步是确定你需要的 SpringCloud版本，这个版本将取决于你所使用的SpringBoot的版本。

更多详细的版本对应关系，可以访问网址： https://start.spring.io/actuator/info

Dalston, Edgware, Finchley, Greenwich 都已到达终点将不再支持。

现在您已经知道了要使用哪个发布系列以及该发布系列的最新服务版本，您就可以将Spring Cloud BOM添加到应用程序中了。

<properties>
    <spring-cloud.version>2022.0.1</spring-cloud.version>
</properties>
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Spring Cloud Alibaba

各个版本适配请看alibaba：https://github.com/alibaba/spring-cloud-alibaba/wiki/%E7%89%88%E6%9C%AC%E8%AF%B4%E6%98%8E

<!--版本依赖示例-->
<properties>
    <spring-boot.version>2.3.12.RELEASE</spring-boot.version>
    <spring-cloud.version>Hoxton.SR12</spring-cloud.version>
    <spring-cloud-alibaba.version>2.2.9.RELEASE</spring-cloud-alibaba.version>
</properties>
<dependencyManagement>
    <!-- SpringCloud -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${spring-cloud-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

基础组件

• 前言
• Spring 事务
  • 四大特性
  • 隔离级别
  • 七大传播机制
• 参考

前言

Spring 事务

四大特性

隔离级别

七大传播机制

参考

• https://blog.csdn.net/m0_73533108/article/details/126688445

• 前言
• 单机
  • 环境准备
  • 数据源切换
    • 思路
    • 实现代码
  • 多库事务问题
    • 临时方案
    • 实现代码
• 分布式事务
  • Atomikos
  • seata
• 引用

前言

我们使用 SpringBoot + Druid 完成了单机多数据源的切换，但是这时会出现一个问题，添加事务了以后，数据源切换出现了问题，那么应该怎么解决呢？（实际是解决数据一致性的问题）

抛出异常回滚时，子事务已经提交，无法回滚，会产生数据不一致的问题。

单机

实现事务内切换数据源(支持原生Spring声明式事务哟，仅此一家)，并支持多数据源事务回滚(有了 它除了跨服务的事务你需要考虑分布式事务，其他都不需要，极大的减少了系统的复杂程度)

这里采用的方案是：

1. 扩展 Spring Jdbc 提供的抽象类 AbstractRoutingDataSource，实现切换数据源
2. 数据源配置主要有两种
   • 基于配置文件（该文章基于这种实现，但支持动态添加）
   • 基于数据库表
3. 基于 AspectJ 实现动态数据源切换，支持方法级、类级，优先方法级别
4. 通过实现 ibatis.Transaction 和 TransactionFactory 支持原生 Spring 的 @Transaction 的多数据源事务回滚

环境准备

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.12.RELEASE</version>
</parent>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<druid.version>1.2.8</druid.version>
<mybatis-spring-boot.version>2.2.2</mybatis-spring-boot.version>

数据源切换

思路

扩展 Spring Jdbc 提供的抽象类 AbstractRoutingDataSource，实现切换数据源

• targetDataSources是目标数据源集合
• defaultTargetDataSource是默认数据源
• resolvedDataSources是解析后的数据源集合
• resolvedDefaultDataSource是解析后的默认数据源
• determineCurrentLookupKey 为抽象方法，通过扩展这个方法来实现数据源的切换，key是数据源的名称。 lookup key通常是绑定在线程上下文中，根据这个key去resolvedDataSources中取出DataSource

通过注解 + AOP + ThreadLocal 拦截方法后，添加数据源KEY到中，然后查询数据库时会获取到这个key，进而获取对应的数据源进行操作。

实现代码

1. 首先我们需要使用一个注解作为AOP切面的拦截标识

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DS {
    String value() default DynamicDataSourceProperties.PRIMARY;
}

2. 基于线程变量 ThreadLocal提供一个数据源切换的工具，采用 双端 队列存储，主要是为了支持嵌套数据源切换。

@Slf4j
public final class DataSourceContentHolder {
    private static final ThreadLocal<Deque<String>> contentHolder = new NamedThreadLocal("dynamic-datasource") {
        @Override
        protected Object initialValue() {
//            return new LinkedList<>();
            return new ArrayDeque<>();
        }
    };

    private DataSourceContentHolder() {
    }

    /**
     * 给当前线程添加数据源
     *
     * @param dataSource
     */
    public static void add(String dataSource) {
        log.debug("添加数据源 => {}", dataSource);
        contentHolder.get().add(dataSource);
    }

    /**
     * 获取当前线程数据源
     *
     * @return
     */
    public static String get() {
        String ds = contentHolder.get().peek();
        ds = StringUtils.isNotBlank(ds) ? ds : DynamicDataSourceProperties.PRIMARY;
        log.debug("获取当前数据源 => {}", ds);
        return ds;
    }

    /**
     * 清空当前数据源
     * 如果当前数据源不为空，则会只移除队列的元素
     */
    public static void poll() {
        Deque<String> queue = contentHolder.get();
        String ds = queue.poll();
        log.debug("移除数据源 => {}", ds);
        if (queue.isEmpty()) {
            contentHolder.remove();
        }
    }

    /**
     * 嵌套执行方法
     *
     * @param dataSource
     * @param callback
     */
    public static void call(String dataSource, Runnable callback) {
        try {
            add(dataSource);
            callback.run();
        } finally {
            poll();
        }
    }
}

3. 定义一个接口类并定义动态数据源的基本操作

/**
 * 动态数据源配置
 */
public interface IDynamicDataSource {

    /**
     * 是否包含数据源
     *
     * @param key 数据源KEY
     * @return
     */
    boolean containKey(Object key);

    /**
     * 添加数据源
     *
     * @param key                  数据源KEY
     * @param dataSourceProperties 数据源配置
     */
    void add(Object key, DataSourceProperties dataSourceProperties);

    /**
     * 添加数据源
     *
     * @param key        数据源KEY
     * @param dataSource 数据源
     */
    void add(Object key, DataSource dataSource);

    /**
     * 覆盖数据源Maps
     *
     * @param objectObjectMap
     */
    void setMap(Map<Object, Object> objectObjectMap);

    /**
     * 删除数据源
     *
     * @param key
     */
    void del(Object key);

    /**
     * 替换数据源
     * <p>
     * 如果数据源不存在则添加，存在则替换
     * </p>
     *
     * @param key        被替换的数据源KEY
     * @param dataSource 数据源
     */
    void replace(Object key, DataSource dataSource);

    /**
     * 替换数据源
     * <p>
     * 如果数据源不存在则添加，存在则替换
     * </p>
     *
     * @param key                  被替换的数据源KEY
     * @param dataSourceProperties 数据源配置
     */
    void replace(Object key, DataSourceProperties dataSourceProperties);

    /**
     * 获取当前数据源
     *
     * @return 数据源
     */
    Object get();

    /**
     * 通过数据源KEY，获取数据源
     *
     * @param key 数据源，不存在则为NULL
     * @return
     */
    Object get(String key);

    /**
     * 获取当前数据源的Key
     *
     * @return 数据源Key
     */
    String getKey();

}

4. 继承Spring的AbstractRoutingDataSource并实现IDynamicDataSource接口完成数据源的管理

/**
 * 实现多数数据源控制
 */
public class DynamicDataSource extends AbstractRoutingDataSource implements IDynamicDataSource {

    private static volatile DynamicDataSource INSTANCE;

    private static Map<Object, Object> dataSourceMap = new ConcurrentHashMap<>();

    private static final ReentrantLock lock = new ReentrantLock();

    public static DynamicDataSource getInstance() {
        if (INSTANCE == null) {
            synchronized (DynamicDataSource.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DynamicDataSource();
                }
            }
        }
        return INSTANCE;
    }

    public boolean containKey(Object key) {
        boolean b = dataSourceMap.containsKey(key);
        return b;
    }


    public void add(Object key, DataSourceProperties dataSourceProperties) {
        DataSource dataSource = DataSourceFactory.createDataSource(dataSourceProperties);
        add(key, dataSource);
    }

    public void add(Object key, DataSource dataSource) {
        boolean hasKey = dataSourceMap.containsKey(key);
        if (hasKey) {
//            if (o instanceof DataSource) {
//                DruidDataSource druidDataSource = (DruidDataSource) o;
//                druidDataSource.close();
//            }
            throw new SXException("数据库连接池 KEY 重复");
        }
        dataSourceMap.put(key, dataSource);
        setMap(dataSourceMap);
    }

    public void setMap(Map<Object, Object> objectObjectMap) {
        lock.lock();
        this.dataSourceMap = objectObjectMap;
        setPrimary();
        super.setTargetDataSources(dataSourceMap);
        super.afterPropertiesSet();
        lock.unlock();
    }

    /**
     * 设置主数据源
     */
    private void setPrimary() {
        Object o = this.dataSourceMap.get(DynamicDataSourceProperties.PRIMARY);
        if (o != null) {
            this.setDefaultTargetDataSource(o);
        }
    }

    public void del(Object key) {
        Object o = dataSourceMap.get(key);
        if (o != null) {
            if (o instanceof DataSource) {
                DruidDataSource dataSource = (DruidDataSource) o;
                if (dataSource != null) {
                    dataSource.close();
                    dataSourceMap.remove(key);
                    setMap(dataSourceMap);
                }
            } else {
                throw new SXException("数据池类型无法识别");
            }
        }
    }

    /**
     * @param key        被替换的数据源KEY
     * @param dataSource 数据源
     */
    public void replace(Object key, DataSource dataSource) {
        Object o = dataSourceMap.get(key);
        dataSourceMap.put(key, dataSource);
        if (DynamicDataSourceProperties.PRIMARY.equals(key)) {
            this.setDefaultTargetDataSource(dataSource);
        }
        if (o != null) {
            if (o instanceof DataSource) {
                DruidDataSource dataSource1 = (DruidDataSource) o;
                if (dataSource1 != null) {
                    dataSource1.close();
                }
            }
        }
        setMap(dataSourceMap);
    }

    /**
     * @param key                  被替换的数据源KEY
     * @param dataSourceProperties 数据源配置
     */
    public void replace(Object key, DataSourceProperties dataSourceProperties) {
        DruidDataSource dataSource = DataSourceFactory.createDataSource(dataSourceProperties);
        replace(key, dataSource);
    }


    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContentHolder.get();
    }

    @Override
    public Object get() {
        return get(getKey());
    }

    @Override
    public Object get(String key) {
        return dataSourceMap.get(key);
    }

    @Override
    public String getKey() {
        return DataSourceContentHolder.get();
    }

}

5. 创建AOP切面，实施数据源切换拦截

@Aspect
@Component
@Slf4j
@Order(-1)
public class DataSourceAspect {

    @Pointcut("@within(top.zsmile.common.datasource.annotation.DS) || @annotation(top.zsmile.common.datasource.annotation.DS)")
    public void dataSourceAspect() {

    }

    @Before("dataSourceAspect()")
    public void beforeSwitch(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        DS methodDS = method.getAnnotation(DS.class);
        String value = null;
        if (methodDS != null) {
            value = methodDS.value();
        } else {
            Class<?> aClass = joinPoint.getTarget().getClass();
            DS annotation = aClass.getAnnotation(DS.class);
            if (annotation != null) {
                value = annotation.value();

            }
        }
        if (checkValue(value)) {
            DataSourceContentHolder.add(value);
        }
    }

    /**
     * 检查数据源是否存在
     *
     * @param value
     * @return
     */
    private boolean checkValue(final String value) {
        if (!StringUtils.isEmpty(value)) {
            boolean containKey = DynamicDataSource.getInstance().containKey(value);
            if (!containKey) {
                throw new SXException("数据源" + value + "未准备");
            }
        }
        return true;
    }

    @After("dataSourceAspect()")
    public void afterSwitchDS() {
        DataSourceContentHolder.poll();
    }
}

6. 创建 Druid 公共配置文件 (DruidProperties)、 动态数据源配置文件(DynamicProperties)、数据源配置文件(DataSourceProperties)

@Data
//@ConfigurationProperties(prefix = "spring.datasource.druid")
public class DataSourceProperties {

    private String driverClassName;
    private String url;
    private String username;
    private String password;

    /**
     * Druid默认参数
     */
    private int initialSize;
    private int maxActive;
    private int minIdle;
    private long maxWait;
    private long timeBetweenEvictionRunsMillis;
    private long minEvictableIdleTimeMillis;
    private long maxEvictableIdleTimeMillis;
    private String validationQuery;
    private int validationQueryTimeout;
    private Boolean testOnBorrow;
    private Boolean testOnReturn;
    private Boolean testWhileIdle;
    private Boolean poolPreparedStatements;
    private int maxOpenPreparedStatements;
    private Boolean sharePreparedStatements;
    private String filters;
    private String connectionProperties;
}




@Data
public class DruidProperties {

    /**
     * Druid默认参数
     */
    private int initialSize = 5;
    private int maxActive = 20;
    private int minIdle = 5;
    private long maxWait = 60 * 1000L;
    private long timeBetweenEvictionRunsMillis = 60 * 1000L;
    private long minEvictableIdleTimeMillis = 1000L * 60L * 30L;
    private long maxEvictableIdleTimeMillis = 1000L * 60L * 60L * 7;
    private String validationQuery = "select 1 from DUAL";
    private int validationQueryTimeout = -1;
    private Boolean testOnBorrow = false;
    private Boolean testOnReturn = false;
    private Boolean testWhileIdle = true;
    private Boolean poolPreparedStatements = true;
    private int maxOpenPreparedStatements = -1;
    private Boolean sharePreparedStatements = false;
    private String filters = "stat,wall";
    private String connectionProperties;
}

@Slf4j
@Getter
@Setter
@ConfigurationProperties(prefix = DynamicDataSourceProperties.PREFIX)
public class DynamicDataSourceProperties {
    public static final String PREFIX = "spring.datasource.dynamic";

    /**
     * 默认数据源,master
     */
    public static final String PRIMARY = "master";

    /**
     * 所有数据源配置
     */
    private Map<String, DataSourceProperties> datasource = new LinkedHashMap<>();

    /**
     * Druid配置
     */
    private DruidProperties druid = new DruidProperties();

}

7. 数据源配置

@Configuration
@EnableConfigurationProperties(DynamicDataSourceProperties.class)
public class DynamicDataSourceConfig {

    @Resource
    private DynamicDataSourceProperties dynamicDataSourceProperties;

    /**
     * 动态数据源
     *
     * @return
     */
    @ConditionalOnMissingBean
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = DynamicDataSource.getInstance();
        Map<Object, Object> dataSourceMap = getDynamicDataSource();
        dynamicDataSource.setMap(dataSourceMap);
        return dynamicDataSource;
    }

    /**
     * mybatis-spring start config sql-session-factory
     *
     * @param dataSource
     * @return
     */
    @Bean
    public SqlSessionFactoryBeanCustomizer sqlSessionFactoryBeanCustomizer(@Qualifier("dynamicDataSource") DynamicDataSource dataSource) {
        return new SqlSessionFactoryBeanCustomizer() {
            @Override
            public void customize(SqlSessionFactoryBean factoryBean) {
                // 动态切换数据源事务必须要添加的。
                //factoryBean.setTransactionFactory(new DynamicTransactionFactory());
                factoryBean.setDataSource(dataSource);
            }
        };
    }

    /**
     * 事务管理器
     *
     * @param dynamicDataSource 动态数据源
     * @return
     */
    @ConditionalOnMissingBean
    @Bean(name = "transactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("dynamicDataSource") DynamicDataSource dynamicDataSource) {
        return new DataSourceTransactionManager(dynamicDataSource);
    }

    /**
     * 遍历数据源配置并加载
     *
     * @return
     */
    private Map<Object, Object> getDynamicDataSource() {
        DruidProperties druid = dynamicDataSourceProperties.getDruid();
        Map<String, DataSourceProperties> dataSourcePropertiesMap = dynamicDataSourceProperties.getDatasource();
        Map<Object, Object> dataSourceMap = new HashMap<>(dataSourcePropertiesMap.size());
        dataSourcePropertiesMap.forEach((k, v) -> {
            DataSourceProperties mergeProperties = DynamicDataSourceUtils.merge(v, druid);
            DruidDataSource dataSource = DataSourceFactory.createDataSource(mergeProperties);
            dataSourceMap.put(k, dataSource);
        });
        return dataSourceMap;
    }
}

到目前为止，已经可以支持多数据源的切换，但是会有一个问题，那就是 添加了 Spring声明式事务注解@Transactional后就没有办法切换数据源了。

其实市面上比较成熟的Mybatis Plus提供的 多数据源也会存在这个问题，查看源代码SpringManagedTransaction其实就可以知道原因，因为Spring 开启事务时会调getConnection()方法，其内部会缓存数据库连接。

那么问题是不是出在了数据库连接上，我们更换一下数据源的 Connection获取

多库事务问题

临时方案

如何解决切库事务问题？借助Spring的声明式事务处理，我们可以在多次切库操作时强制开启新的事务：

@DS("slave")
@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)

但是处理当我们在主事务中抛出异常回滚的时候，子事务已经提交了，无法回滚，这时就产生数据错乱了。

实现代码

1. 先在 DynamicDataSource 重写 getConnection 方法

/**
     * 处理多数据源的事务的关键
     * @return
     * @throws SQLException
     */
@Override
public Connection getConnection() throws SQLException {
    DataSource dataSource =
        super.getResolvedDataSources().get(getKey());
    return dataSource.getConnection();
}

2. 实现 Transaction 。注意这里的 Transaction 是 org.apache.ibatis.transaction.Transaction

@Slf4j
public class DynamicTransaction implements Transaction {
    /**
     * 数据源
     */
    private final DataSource dataSource;
    /**
     * 主数据源连接
     */
    private Connection connection;
    /**
     * 是否开启事务
     */
    private Boolean isConnectionTransactional;
    /**
     * 是否自动提交
     */
    private Boolean autoCommit;
    /**
     * 连接标识
     */
    private String identification;

    /**
     * 其他连接缓存
     */
    private ConcurrentMap<String, Connection> connections;

    /**
     * 构造器
     *
     * @param dataSource 数据源
     */
    public DynamicTransaction(DataSource dataSource) {
        Assert.notNull(dataSource, "No DataSource specified");
        // 当前数据源Key
        this.identification = DataSourceContentHolder.get();
        this.dataSource = dataSource;
        connections = new ConcurrentHashMap<>();
        log.debug("init dynamic transaction, identify key => {},address => {}", this.identification, this);
    }

    /**
     * @return
     * @throws SQLException
     */
    @Override
    public Connection getConnection() throws SQLException {
        /* 获取当前生效的数据源标识 */
        String current = DataSourceContentHolder.get();
        log.debug("current key => {}, identify key=> {}", current, this.identification);
        // 如果当前数据源是主数据源
        if (current.equals(this.identification)) {
            // 如果为空则创建连接
            if (this.connection == null) {
                openConnection();
            }
            return this.connection;
        } else {
            /* 不是默认数据源，获取连接并设置属性 */
            if (!connections.containsKey(current)) {
                // 如果连接不包含该数据源KEY获取的连接
                try {
                    Connection conn = this.dataSource.getConnection();
                    /* 自动提交属性和主数据源保持连接 */
                    conn.setAutoCommit(this.autoCommit);
                    connections.put(current, conn);
                } catch (SQLException ex) {
                    throw new CannotGetJdbcConnectionException("could not get jdbc connection", ex);
                }
            }
            return connections.get(current);
        }
    }

    /**
     * 打开连接
     *
     * @throws SQLException
     */
    private void openConnection() throws SQLException {
        // 获取连接
        this.connection = DataSourceUtils.getConnection(this.dataSource);
        // 是否自动提交
        this.autoCommit = this.getConnection().getAutoCommit();
        // 确定当前连接是否是事务性的。
        // 即通过 Spring 的事务管理器绑定到当前线程的
        this.isConnectionTransactional =
                DataSourceUtils.isConnectionTransactional(this.connection, this.dataSource);
        log.debug("jdbc connection [{}] will {} be managed by spring", this.connection, (this.isConnectionTransactional ? "" : "not"));
    }

    /**
     * 提交事务
     *
     * @throws SQLException
     */
    @Override
    public void commit() throws SQLException {
        // 如果主事务不为空 && 如果是 Spring 管理的事务性连接 && 不是自动提交
        if (this.connection != null && this.isConnectionTransactional &&
                !this.autoCommit) {
            // 提交主连接的事务
            log.debug("committing jdbc connection [{}]", this.connection);
            this.connection.commit();

            // 遍历提交子连接的事务
            for (Connection conn : connections.values()) {
                conn.commit();
            }
        }
    }

    /**
     * 回滚事务
     *
     * @throws SQLException
     */
    @Override
    public void rollback() throws SQLException {
        if (this.connection != null && this.isConnectionTransactional &&
                !this.autoCommit) {
            log.debug("rolling back jdbc connection [{}]", this.connection);
            this.connection.rollback();
            for (Connection conn : connections.values()) {
                conn.rollback();
            }
        }
    }

    /**
     * 关闭并释放连接
     *
     * @throws SQLException
     */
    @Override
    public void close() throws SQLException {
        DataSourceUtils.releaseConnection(this.connection, this.dataSource);
        for (Connection conn : connections.values()) {
            DataSourceUtils.releaseConnection(conn, this.dataSource);
        }
    }

    /**
     * 获取事务超时时间
     *
     * @return
     * @throws SQLException
     */
    @Override
    public Integer getTimeout() throws SQLException {
        ConnectionHolder holder = (ConnectionHolder)
                TransactionSynchronizationManager.getResource(dataSource);
        if (holder != null && holder.hasTimeout()) {
            return holder.getTimeToLiveInSeconds();
        }
        return null;
    }
}

3. 继承 SpringManagedTransactionFactory 实现事务工厂 DynamicTransactionFactory

public class DynamicTransactionFactory extends SpringManagedTransactionFactory {
    @Override
    public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) {
        return new DynamicTransaction(dataSource);
    }
}

4. 将 DynamicTransactionFactory 注入 Mybaits 的 SqlSessionFactory

    /**
     * mybatis-spring start config sql-session-factory
     *
     * @param dataSource
     * @return
     */
    @Bean
    public SqlSessionFactoryBeanCustomizer sqlSessionFactoryBeanCustomizer(@Qualifier("dynamicDataSource") DynamicDataSource dataSource) {
        return new SqlSessionFactoryBeanCustomizer() {
            @Override
            public void customize(SqlSessionFactoryBean factoryBean) {
                factoryBean.setTransactionFactory(new DynamicTransactionFactory()); // 添加到这里额
                factoryBean.setDataSource(dataSource);
            }
        };
    }

分布式事务

Atomikos

seata

引用

https://blog.csdn.net/qq_35789269/article/details/128125061

https://juejin.cn/post/7103913605539561509

https://blog.csdn.net/m0_73533108/article/details/126688445

https://blog.csdn.net/demohui/article/details/109659540?ops_request_misc=&request_id=&biz_id=102&utm_term=spring%20%E4%BA%8B%E5%8A%A1%E5%86%85%E5%88%87%E6%8D%A2%E6%95%B0%E6%8D%AE%E6%BA%90&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-109659540.142^v88^control,239^v2^insert_chatgpt

• AbstractRoutingDataSource
  • Method afterPropertiesSet
  • Method resolveSpecifiedDataSource

AbstractRoutingDataSource

我们先看一下这个类里面包含了几个变量。

   @Nullable
   private Map<Object, Object> targetDataSources;

   @Nullable
   private Object defaultTargetDataSource;

   private boolean lenientFallback = true;

   private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();

   @Nullable
   private Map<Object, DataSource> resolvedDataSources;

   @Nullable
   private DataSource resolvedDefaultDataSource;

这里我们先简单的说一下各个变量的作用：

• targetDataSources：存储未解析的目标的数据源Map
• defaultTargetDataSource: 未解析的默认的目标数据源
• lenientFallback：回退。稍后再说
• dataSourceLookup：dataSource解析器，默认是JNDI
• resolvedDataSources：将目标的数据源解析并保存成实际的数据链接后的map
• resolvedDefaultDataSource: 默认的数据源

Method afterPropertiesSet

afterPropertiesSet 是用来解析targetDataSources 来获取真正的dataSource

@Override
public void afterPropertiesSet() {
    if (this.targetDataSources == null) {
        throw new IllegalArgumentException("Property 'targetDataSources' is required");
    }
    this.resolvedDataSources = new HashMap<>(this.targetDataSources.size());
    this.targetDataSources.forEach((key, value) -> {
        Object lookupKey = resolveSpecifiedLookupKey(key);
        DataSource dataSource = resolveSpecifiedDataSource(value);
        this.resolvedDataSources.put(lookupKey, dataSource);
    });
    if (this.defaultTargetDataSource != null) {
        this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
    }
}

1. 该方法会先判断targetDataSources是否为空，如果为空抛出异常。
2. 新建一下HashMap，大小为targetDataSources的大小，然后赋值给resolvedDataSources
3. 遍历targetDataSources，解析Key和DataSource，并存储到resolvedDataSources
4. 如果设置了 defaultTargetDataSource【默认数据源】，则会将默认数据源解析后，存储到resolveDefaultDataSource

以上的流程可以看出，该方法必须在设置了targetDataSources后调用，才能生效。

所以我们在做多数据源时，有时会看到这样的代码：这是为了解析我们配置的数据源Bean。

AbstractRoutingDataSource.setTargetDataSources(Map(...))
AbstractRoutingDataSource.afterPropertiesSet();

Method resolveSpecifiedDataSource

1. 当参数DataSource的类型为DataSource时候，则返回
2. 如果是String时，因为默认时使用的JNDILookUp，所以这里会默认去根据JNDI解析。如果需要替换不同的datasourceLookUp，Spring内置了4种：
   • BeanFactoryDataSourceLookup：在SpringBean容器里面查找dataSource。
   • JndiDataSourceLookup：从JNDI数据源解析
   • MapDataSourceLookup：从Map容器解析
   • SingleDataSourceLookup：从单数据源直接返回
3. 如果不是以上两种类型，则抛出异常信息。

/**
 * Resolve the specified data source object into a DataSource instance.
 * <p>The default implementation handles DataSource instances and data source
 * names (to be resolved via a {@link #setDataSourceLookup DataSourceLookup}).
 * @param dataSource the data source value object as specified in the
 * {@link #setTargetDataSources targetDataSources} map
 * @return the resolved DataSource (never {@code null})
 * @throws IllegalArgumentException in case of an unsupported value type
 */
protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
    if (dataSource instanceof DataSource) {
        return (DataSource) dataSource;
    }
    else if (dataSource instanceof String) {
        return this.dataSourceLookup.getDataSource((String) dataSource);
    }
    else {
        throw new IllegalArgumentException(
                "Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
    }
}

 protected <T> T lookup(String jndiName, @Nullable Class<T> requiredType) throws NamingException {
    Assert.notNull(jndiName, "'jndiName' must not be null");
    String convertedName = this.convertJndiName(jndiName);

    Object jndiObject;
    try {
        jndiObject = this.getJndiTemplate().lookup(convertedName, requiredType);
    } catch (NamingException var6) {
        if (convertedName.equals(jndiName)) {
            throw var6;
        }

        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Converted JNDI name [" + convertedName + "] not found - trying original name [" + jndiName + "]. " + var6);
        }

        jndiObject = this.getJndiTemplate().lookup(jndiName, requiredType);
    }

    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Located object with JNDI name [" + convertedName + "]");
    }

    return jndiObject;
}

• springboot中使用undertow替换tomcat
  • 引入maven
  • 基本配置

springboot中使用undertow替换tomcat

引入maven

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     <!-- 排除Tomcat容器 -->
     <exclusions>
         <exclusion>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-tomcat</artifactId>
         </exclusion>
     </exclusions>
</dependency>
<!-- 引入undertow容器 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-undertow</artifactId>
    <exclusions>
        <exclusion>
            <!-- 排除websocket模块-->
            <groupId>io.undertow</groupId>
            <artifactId>undertow-websockets-jsr</artifactId>
        </exclusion>
    </exclusions>
</dependency>

基本配置

# === undertow 日志 ========
# 是否打开 undertow 日志，默认为 false
server.undertow.accesslog.enabled=false
# 设置访问日志所在目录
server.undertow.accesslog.dir=logs
# 日志格式
server.undertow.accesslog.pattern=common
# 日志文件前缀
server.undertow.accesslog.prefix=access_log.
# 日志文件后缀
server.undertow.accesslog.suffix=log

# 指定工作者线程的 I/0 线程数，默认为 2 或者 CPU 的个数
server.undertow.threads.io=2
# 指定工作者线程个数，默认为 I/O 线程个数的 8 倍
server.undertow.threads.worker=8
# 设置 HTTP POST 内容的最大长度，默认不做限制
server.undertow.max-http-post-size=4MB
# 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理；
server.undertow.buffer-size=1024
# 是否分配的直接内存(NIO直接分配的堆外内存)
server.undertow.direct-buffers=true

• 关于出现no sapjco3 in java.library.path错误

关于出现no sapjco3 in java.library.path错误

• 问题描述：出现 no sapjco3 in java.library.path 异常时，可能是缺乏相应的文件，导致无法获取到 sapjco 的资源，导致异常。

• 解决办法：引入 jar和dll 文件。文件在 Git仓库\src\资源文件下获取。

  

  1. 将 sapjco3.dll 放入jdk目录下的 \jre\bin 文件夹
  2. 将 sapjco3.jar 放入jdk目录下的 \jre\lib\ext 文件夹

• 完整错误信息：

  

• druid
  • Maven引入
  • 多数据源
    • 配置
    • 使用方式
      • 注解
  • 多次切换数据源

druid

Maven引入

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.8</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
    <exclusions>
        <!-- 移除HikariCp数据源 -->
        <exclusion>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
        </exclusion>
    </exclusions>
</dependency>

多数据源

配置

1. 设置Datasource properties

@Data
public class DataSourceProperties {

    private String driverClassName;
    private String url;
    private String username;
    private String password;

    /**
     * Druid默认参数
     */
    private int initialSize = 5;
    private int maxActive = 20;
    private int minIdle = 5;
    private long maxWait = 60 * 1000L;
    private long timeBetweenEvictionRunsMillis = 60 * 1000L;
    private long minEvictableIdleTimeMillis = 1000L * 60L * 30L;
    private long maxEvictableIdleTimeMillis = 1000L * 60L * 60L * 7;
    private String validationQuery = "select 1 from DUAL";
    private int validationQueryTimeout = -1;
    private boolean testOnBorrow = false;
    private boolean testOnReturn = false;
    private boolean testWhileIdle = true;
    private boolean poolPreparedStatements = true;
    private int maxOpenPreparedStatements = -1;
    private boolean sharePreparedStatements = false;
    private String filters = "stat,wall";
}

2. yml配置

spring:
  datasource:
    druid:
      # mysql 连接信息
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/smilex-boot?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
      username: root
      password: root
      # 其它配置
      time-between-eviction-runs-millis: 60000
      keep-alive: true
      initial-size: 5
      min-idle: 5
      max-active: 20
      max-wait: 60000
      min-evictable-idle-time-millis: 300000
      validation-query: SELECT 1 FROM DUAL
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filters: stat,wall
      stat-view-servlet:
        enabled: true
        allow: 127.0.0.1
        url-pattern: /druid/*

3. 实现AbstractRoutingDataSource

/**
 * 实现多数数据源控制
 */
public class DynamicDataSource extends AbstractRoutingDataSource {

    private static DynamicDataSource INSTANCE;

    private static Map<Object, Object> dataSourceMap = new HashMap<>();

    private static final ReentrantLock lock = new ReentrantLock();

    public static DynamicDataSource getInstance() {
        if (INSTANCE == null) {
            synchronized (DynamicDataSource.class) {
                if (INSTANCE == null) {
                    INSTANCE = new DynamicDataSource();
                }
            }
        }
        return INSTANCE;
    }

    public void addDataSource(Object key, DataSourceProperties dataSourceProperties) {
        DataSource dataSource = DataSourceFactory.createDataSource(dataSourceProperties);
        addDataSource(key, dataSource);
    }

    public void addDataSource(Object key, DataSource dataSource) {
        Object o = dataSourceMap.get(key);
        if (o != null) {
//            if (o instanceof DataSource) {
//                DruidDataSource druidDataSource = (DruidDataSource) o;
//                druidDataSource.close();
//            }
            throw new SXException("数据库连接池 KEY 重复");
        }
        dataSourceMap.put(key, dataSource);
        setDataSourceMap(dataSourceMap);
    }

    public void setDataSourceMap(Map<Object, Object> objectObjectMap) {
        lock.lock();
        this.dataSourceMap = objectObjectMap;
        super.setTargetDataSources(dataSourceMap);
        super.afterPropertiesSet();
        lock.unlock();
    }

    public void delDataSource(Object key) {
        Object o = dataSourceMap.get(key);
        if (o != null) {
            if (o instanceof DataSource) {
                DruidDataSource dataSource = (DruidDataSource) o;
                if (dataSource != null) {
                    dataSource.close();
                    dataSource = null;
                    dataSourceMap.remove(key);
                    setDataSourceMap(dataSourceMap);
                }
            } else {
                throw new SXException("数据池类型无法识别");
            }
        }
    }

    /**
     * Recording to the datasource of the map with the key
     * @param key
     * @param dataSource
     */
    public void replaceDataSource(Object key, DataSource dataSource) {
        dataSourceMap.put(key, dataSource);
        setDataSourceMap(dataSourceMap);
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContentHolder.getDataSource();
    }
}

4. 配置Spring DynamicDatasouce Bean

@Configuration
@Order(-1)
public class DynamicDataSourceConfig {


    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    @Primary
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource dynamicDataSource(DataSourceProperties dataSourceProperties) {
        DynamicDataSource dynamicDataSource = DynamicDataSource.getInstance();

        DataSource dataSource = DataSourceFactory.createDataSource(dataSourceProperties);
        dynamicDataSource.addDataSource("master", dataSource);
        dynamicDataSource.setDefaultTargetDataSource(dataSource);
        return dynamicDataSource;
    }

    @Bean(name = "transactionManager")
    public DataSourceTransactionManager transactionManager(@Qualifier("dynamicDataSource") DynamicDataSource dynamicDataSource) {
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}

5. 设置DataSourceFactory 工厂，用于根据配置生成DataSource

public class DataSourceFactory {
    public static DataSource createDataSource(DataSourceProperties properties) {
        DruidDataSource dataSource = new DruidDataSource();
        BeanUtils.copyProperties(properties, dataSource);
        return dataSource;
    }

    public static DataSource createDataSource(DataSource dataSource, DataSourceProperties properties) {
        DruidDataSource druidDataSource = (DruidDataSource) dataSource;
        BeanUtils.copyProperties(properties, druidDataSource);
        return druidDataSource;
    }
}

使用方式

注解

1. 添加注解 DataSource

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSource {
    String value() default DynamicDataSourceConfig.MASTER;
}

2. 添加拦截器 DataSourceAspect

@Aspect
@Component
@Slf4j
public class DataSourceAspect {
    @Pointcut("@within(top.zsmile.common.datasource.annotation.DS) || @annotation(top.zsmile.common.datasource.annotation.DS)")
    public void dataSourceAspect() {

    }

    @Before("dataSourceAspect()")
    public void beforeSwitch(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        DataSource methodDS = method.getAnnotation(DataSource.class);
        String value = null;
        if (methodDS != null) {
            value = methodDS.value();
        } else {
            Class<?> aClass = joinPoint.getTarget().getClass();
            DataSource annotation = aClass.getAnnotation(DataSource.class);
            if (annotation != null) {
                value = annotation.value();

            }
        }
        if (checkValue(value)) {
            DataSourceContentHolder.setDataSource(value);
        }
    }

    private boolean checkValue(final String value) {
        if (!StringUtils.isEmpty(value)) {
            boolean containKey = DynamicDataSource.getInstance().containKey(value);
            if (!containKey) {
                throw new SXException("数据源" + value + "未准备");
            }
        }
        return true;
    }

    @After("dataSourceAspect()")
    public void afterSwitchDS() {
        DataSourceContentHolder.clear();
    }
}

3. 在需要切换数据源的地方添加注解

多次切换数据源

前面我们使用的是ThreadLocal 来处理数据源的切换问题，那么相应的也有了新的问题，如果我们有以下伪代码，那这时会有什么结果。

@DataSource("test1")
public void A(){
	AMapper.queryById(1);
    B();
	AMapper.queryById(3);
}

@DataSource("test2")
public void B(){
    BMapper.queryById(2)
}

这里我们可以预计一个样子。

1. 当 AMapper.queryById(1) 时，指向数据源 test1
2. 当执行 BMapper.queryById(2) 时，指向 test2
3. 再执行 AMapper.queryById(1) 时，指向数据源 test1。

可是问题来了，我们用ThreadLocal时，他就只支持了一个变量来存储，这意味着，当一个线程存在多次切换环境时无法支持。

我们应该如何来解决这个问题。

我们可以通过替换ThreadLocal 为 ThreadLocal<Queue>来实现。修改DataSourceContentHolder 文件如下

@Slf4j
public class DataSourceContentHolder {
    private static final ThreadLocal<Queue<String>> contentHolder = new ThreadLocal() {
        @Override
        protected Object initialValue() {
            return new LinkedList<>();
        }
    };

    public synchronized static void setDataSource(String dataSource) {
        contentHolder.get().add(dataSource);
    }

    public static String getDataSource() {
        String ds = contentHolder.get().peek();
        log.debug("当前数据源 => {}", ds);
        return ds;
    }

    public static void pollDataSource() {
        Queue<String> queue = contentHolder.get();
        String ds = queue.poll();
        log.debug("移除数据源 => {}", ds);
        if (queue.isEmpty()) {
            contentHolder.remove();
        }
    }
}

• 引入Maven
• google.zxing 解析二维码异常问题

引入Maven

 <!--二维码生成和解析相关的jar包【生成】【解析】-->
<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>core</artifactId>
    <version>3.4.1</version>
</dependency>
<dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>javase</artifactId>
    <version>3.4.1</version>
</dependency>

google.zxing 解析二维码异常问题

今天发现两个内容一模一样的二维码，但是一个是使用苹果6的手机截图的，一个是苹果13截图的，但是苹果6的会抛出一个NoFoundException异常。

有问题的代码：

private static String decodeQrcode(URL file) {
    BufferedImage image = ImgUtil.read(file);
    LuminanceSource source = new BufferedImageLuminanceSource(image);
    Binarizer binarizer = new HybridBinarizer(source);
    BinaryBitmap binaryBitmap = new BinaryBitmap(binarizer);
    Map<DecodeHintType, Object> hints = Maps.newEnumMap(DecodeHintType.class);
    hints.put(DecodeHintType.CHARACTER_SET, Charsets.UTF_8.name());
    try {
        com.google.zxing.Result result = new MultiFormatReader().decode(binaryBitmap, hints);
        return result.getText();
    } catch (NotFoundException e) {
        e.printStackTrace();
        System.out.println(e.toString());
        return "";
    }
}

这时就会出现二维码异常的问题，大部分的二维码可以正常解析，但是有些二维码会报异常。经过各种尝试，做了一下更改：

1. HybridBinarizer换成GlobalHistogramBinarizer

   • zxing官方默认的HybridBinarizer，两者区别HybridBinarizer算法执行效率上要慢一些，但是更有效，专门针对黑白相间的图像设计，也更适用于有阴影和渐变的二维码图像。
   • GlobalHistogramBinarizer算法适用于低端机，对手机要求不高，识别速度快，精度高，但是无法处理阴影和渐变两个情况。

2. MultiFormatReader换成QRCodeMultiReader

   • 这里指定了单个类型，即QRCode。但是尝试了QrCodeReader解析发现还是会出现异常。于是使用了批量解析的方式，然后默认选取第一张。

更改完后，代码如下：

private static String decodeQrcode(URL file) {
    BufferedImage image = ImgUtil.read(file);
    LuminanceSource source = new BufferedImageLuminanceSource(image);
    Binarizer binarizer = new GlobalHistogramBinarizer(source);
    BinaryBitmap binaryBitmap = new BinaryBitmap(binarizer);
    Map<DecodeHintType, Object> hints = Maps.newEnumMap(DecodeHintType.class);
    hints.put(DecodeHintType.POSSIBLE_FORMATS, EnumSet.allOf(BarcodeFormat.class));
    hints.put(DecodeHintType.PURE_BARCODE, Boolean.TRUE);
    hints.put(DecodeHintType.TRY_HARDER, BarcodeFormat.QR_CODE);
    hints.put(DecodeHintType.CHARACTER_SET, Charsets.UTF_8.name());
    try {
        //            QRCodeReader qrCodeReader =new QRCodeReader();
        //            return qrCodeReader.decode(binaryBitmap,hints).getText();
        com.google.zxing.Result result[] = new QRCodeMultiReader().decodeMultiple(binaryBitmap, hints);
        return result[0].getText();
    } catch (NotFoundException e) {
        e.printStackTrace();
        System.out.println(e.toString());
        return "";
    }
}

• 前言
  • 概论
• CDI
• springboot
  • 集成
  • 配置
    • 快速失败
    • 全局错误拦截器
    • 自定义校验器
  • 使用案例
    • 方案1（@Valid/@Validated+Entity）
    • 方案2（@Validated+Params）
    • 方案3（使用Validator）
    • 分组校验
      • 组校验
      • 组序列
• Hibernate-validator-cdi(TODO，非本文重点，后续研究)
• 其它
  • @Validated 和 @Valid
• 参考文章

前言

该文章基于 springboot-2.3.5-final 和 hibernate-validator.6.1.6 版本

在日常开发中，对象的校验是一个非常重要的环节，用于校验手机邮箱，用户提交的信息是否正确。

如果我们在代码里面写入了大量的if-else不仅仅复用性极差，而且维护起来也极其麻烦，我们做项目，不单单要实现功能，还要优雅。所以求求你们别用if-else做校验了。

在这时候Validator框架应运而生，就是为了减少大量的if-else校验代码，提高开发效率。

概论

JSR303 定义了 Bean Validation 的标准 Validation-api，但是没有提供具体实现。hibernate Validator 是对这个规范的实现，并且 spring 内置的校验框架是 hibernate-validator。

PS：虽然由hibernate字眼，但不是跟hibernate ORM框架强关联。

• JSR303：JSR303是一项标准，只提供规范不提供实现。定义了校验规范即校验注解如：@Null、@NotNull、@Pattern。位于：javax.validation.constraints包下。
• hibernate validator： 是对 JSR303 规范的实现并且进行了增强和扩展。并增加了注解：@Email、@Length、@Range等。
• Spring Validation： 是对Hibernate Validation的二次封装。在SpringMvc模块中添加了自动校验。并将校验信息封装到特定的类中。同时提供此类CDI基础结构

CDI

CDI(Contexts And Dependency Injection) 是JavaEE 6标准中一个规范，将依赖注入IOC/DI上升到容器级别， 它提供了Java EE平台上服务注入的组件管理核心，简化应该是CDI的目标，让一切都可以被注解被注入。

CDI是一种依赖注入说明：

1. spring框架中隐式提供了此类CDI基础结构
2. hibernate-validator-cdi。提供给 独立的Java应用程序，需要它来使用注释创建HibernateValidator

springboot

集成

我这里用maven做例子，如果使用gradle或者其它包管理工具，替换成对应写法即可

<!--对应hibernate-validator版本6.1.6-final -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
    <version>2.3.5</version>
</dependency>

配置

快速失败

hibernate-validator 默认时会将所有参数校验后，再抛出异常。有时我们想一旦校验失败就马上抛出异常，可以配置注入进去

@Configuration
public class ValidatorConfig {
    /**
     * 快速返回校验器
     *
     * @return
     */
    @Bean
    @ConditionalOnMissingBean(value = Validator.class)
    public Validator validator() {
        //hibernate-validator 6.x没问题，7.x有问题
        ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class)
                .configure()
                .failFast(true)
                .buildValidatorFactory();
        return validatorFactory.getValidator();
    }

    /**
     * 设置快速校验，返回方法校验处理器。
     * 使用MethodValidationPostProcessor注入后，会启动自定义校验器
     *
     * @return
     */
    @Bean
    @ConditionalOnMissingBean(value = MethodValidationPostProcessor.class)
    public MethodValidationPostProcessor methodValidationPostProcessor() {
        MethodValidationPostProcessor postProcessor = new MethodValidationPostProcessor();
        postProcessor.setValidator(validator());
        return postProcessor;
    }

}

全局错误拦截器

package top.zsmile.core.exception;

import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindException;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import top.zsmile.common.core.api.R;
import top.zsmile.common.core.api.ResultCode;import top.zsmile.common.core.exception.SXException;

import java.util.List;

@Slf4j
@RestControllerAdvice
public class SXExceptionHandler {

    /**
     * 自定义异常
     */
    @ExceptionHandler(SXException.class)
    public R handleException(SXException e) {
        log.error(e.getMessage(), e);
        return R.fail(e.getMessage());
    }

    private static final String SPLINT = ",";

    @ExceptionHandler(BindException.class)
    public R BindException(BindException e) {
        log.error(e.getMessage(), e);

        List<FieldError> fieldErrors = e.getBindingResult().getFieldErrors();
        StringBuffer sb = new StringBuffer("");
        for (FieldError fieldError : fieldErrors) {
            sb.append(fieldError.getDefaultMessage()).append(SPLINT);
        }
        return R.fail(sb.substring(0, sb.length() - 1));
    }
}

自定义校验器

Bean验证主要有两部分构成：

1. 声明约束及其可配置属性的@Constraint注释。
2. constraintvalidator接口的实现，它实现了约束的行为。

这里实现了一个手机号验证。

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = PhoneValidator.class)
public @interface Phone {
    /**
     * 异常消息
     * @return
     */
    String message() default "手机号格式不正确";

    /**
     * 分组
     * @return
     */
    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};
}

public class PhoneValidator implements ConstraintValidator<Phone, String> {
    @Override
    public void initialize(Phone constraintAnnotation) {
		// 在这里获取一些注解上的值，比如message,require，设置为局部变量即可。
    }

    @Override
    public boolean isValid(String phone, ConstraintValidatorContext constraintValidatorContext) {
        if (StringUtils.isEmpty(phone)) {
            return true;
        }
        return ValidatorUtil.isPhone(phone);
    }
}

这里简单封装一个ValidatorUtil库

public class ValidatorUtil {
    private static final Pattern MOBILE_PATTERN = Pattern.compile("^(13[0-9]|14[5|7|9]|15[0|1|2|3|5|6|7|8|9]|17[0|1|6|7|8]|18[0-9])\\d{8}$");

    public static boolean isPhone(String src) {
        if (StringUtils.isEmpty(src)) {
            return false;
        }
        Matcher matcher = MOBILE_PATTERN.matcher(src);
        return matcher.matches();
    }
}

使用案例

方案1（@Valid/@Validated+Entity）

使用实体类，在实体类上加校验注解，在对应接口上添加@Valid，实现接口校验。

// 实体类
@Data
public class DatabaseConnEntity implements Serializable {
    private static final long serialVersionUID = -4123125798831566630L;
    /**
     * 连接类型：mysql
     */
    @NotBlank(message = "连接类型不能为空")
    private String type;
    
    @Phone
    private String phone;
}

// 接口
@PostMapping("/connect")
public R connect(@Valid DatabaseConnEntity databaseConnEntity) {
    return R.success();
}

// 接口2
@PostMapping("/connect")
public R connect(@Validated DatabaseConnEntity databaseConnEntity) {
    return R.success();
}

方案2（@Validated+Params）

在接受参数上加校验注解

@Validated
@RestController
@RequestMapping("/generator")
public class GeneratorController {
    @GetMapping("/info")
    public R info(@NotBlank String tableName) {
        Map<String, String> maps = generatorService.queryTable(tableName);
        if (maps == null) {
            return R.fail("查询不到该表结构");
        } else {
            return R.success(maps);
        }
    }
}

方案3（使用Validator）

public class ValidatorUtils {

    private final static Validator validator;

    static {
        // 这里可以使用 Factory工厂，也可使用Spring容器里的Bean对象。
        if (SpringContextUtils.getBean(Validator.class) != null) {
            validator = SpringContextUtils.getBean(Validator.class);
        } else {
            validator = Validation.buildDefaultValidatorFactory().getValidator();
        }
    }
    /**
     * 校验对象
     *
     * @param object 待校验对象
     * @param groups 待校验的组
     * @throws SXException 校验不通过，则报SXException异常
     */
    public static void validateEntity(Object object, Class<?>... groups)
            throws SXException {
        Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
        if (!constraintViolations.isEmpty()) {
            StringBuilder msg = new StringBuilder();
            for (ConstraintViolation<Object> constraint : constraintViolations) {
                msg.append(constraint.getMessage()).append("<br>");
            }
            throw new SXException(msg.toString());
        }
    }
}

// 使用方法
ValidatorUtils.validator(Phone);

分组校验

组校验

1. 设置组

public interface Add(){ }
public interface Update(){}

2. 在实体类里设置组

public class user{
    @NotBlank(message = "手机不能为空",groups = {Add.class})
    @Phone(groups={Update.class})
    private String phone;
}

3. 校验

// 接口2
@PostMapping("/connect")
public R connect(@Validated({Add.class}) DatabaseConnEntity databaseConnEntity) {
    return R.success();
}

组序列

默认情况下 不同级别的约束验证是无序的，但是在一些情况下，顺序验证却是很重要。

一个组可以定义为其他组的序列，使用它进行验证的时候必须符合该序列规定的顺序。在使用组序列验证的时候，如果序列前边的组验证失败，则后面的组将不再给予验证。

@GroupSequence({Add.class, Update.class})
public interface change(){}

用法和组校验一样，只需要设置成该分组即可

Hibernate-validator-cdi(TODO，非本文重点，后续研究)

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.1.6-final</version>
</dependency>

<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator-cdi</artifactId>
    <version>6.1.6-final</version>
</dependency>

其它

@Validated 和 @Valid

• 相同：

  1. 在Controller中校验方法参数时，使用@Valid和@Validated并无特殊差异（不需要分组校验的情况下）
  2. 都支持方法和参数注解

• 不同：

  1. @Valid是属于javax.validation包，而@Validated属于Spring下的。
  2. @Validated支持分组使用，@Valid不支持
  3. @Valid支持嵌套校验，而@Validated不支持
  4. @Valid支持成员属性、构造函数注解，而@Validated不支持

参考文章

• spring-validator
• https://www.cnblogs.com/sanye613/p/15027448.html
• https://rumenz.com/java-topic/hibernate/hibernate-validator-cdi/index.html

• 前言
• Salt生成
  • Random
  • ThreadLocalRandom
  • SecureRandom
    • 使用方法

前言

最近在做登录授权，因为需要保存用户密码到数据库，那此时引发了一个思考：

1. 密码明文存入，那任何人员登录数据库后，都能轻而易举的拿到用户密码，并进行登录。也就是明文存入数据库，极其容易泄露。

2. 既然密码不能明文存入数据，那只能使用密文。

   1. 如果只是对密码进行加密后存入会导致什么问题呢？同一个加密出来的密文是一致的。
   2. 密文是否可逆？通过密文是不是能反编译出明文？

3. 那针对加密的基础上，是不是可以通过额外的一个变量（salt），来进行加密，这样同样的密码+salt，得出来的密文就是不一样的了。

基于以上几点思考，这篇文章会着重讲述一下随机数生成的几种方式，主要是用来生成种子。

Salt生成

Salt就是一串随机数，只是我们都知道会分为伪随机和真随机，那么用真随机和伪随机产生的随机数就会达成不同的效果。

Random

我们最常用的方式如下：

Random random = new Random();
int num = random.nextInt(10);

那现在简单的看一下 Random 的源码。

public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}   
public Random(long seed) {
    if (getClass() == Random.class)
        this.seed = new AtomicLong(initialScramble(seed));
    else {
        // subclass might have overriden setSeed
        this.seed = new AtomicLong();
        setSeed(seed);
    }
}
private static long seedUniquifier() {
    // L'Ecuyer, "Tables of Linear Congruential Generators of
    // Different Sizes and Good Lattice Structure", 1999
    for (;;) {
        long current = seedUniquifier.get();
        long next = current * 181783497276652981L;
        if (seedUniquifier.compareAndSet(current, next))
            return next;
    }
}
private static final AtomicLong seedUniquifier
    = new AtomicLong(8682522807148012L);

从这里可以看出 Random类，默认使用了 当前系统时间(System.nanoTime()) 和 静态AtomicLong 两者的异或结果 作为种子。

也就是说当我们同时并发的时候，seed 是一样时，产生出来的随机数也是一样的。因为他们基于的随机数算法也是一样的，所以这是可以预测出来的。

我们再来看一下常用的方法 nextInt() 。

public int nextInt() {
    return next(32);
}
protected int next(int bits) {
    long oldseed, nextseed;
    AtomicLong seed = this.seed;
    do {
        oldseed = seed.get();
        nextseed = (oldseed * multiplier + addend) & mask;
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}

我们看到了这里使用了 AtomicLong 作为seed，Atomic原子类虽然保证了数据的原子性，但是其底层的CAS机制，使得在多线程并发下，性能并不算乐观。

简单写了个demo 跑了下并发

  Random random = new Random();

        new Thread(() -> {
            while (true) {
                int i = random.nextInt(1000);
                System.out.println(System.currentTimeMillis() + "--" + i);
            }
        }).start();
        new Thread(() -> {
            while (true) {
                int i = random.nextInt(1000);
                System.out.println(System.currentTimeMillis() + "--" + i);
            }
        }).start();

        new Thread(() -> {
            while (true) {
                int i = random.nextInt(1000);
                System.out.println(System.currentTimeMillis() + "--" + i);
            }
        }).start();

        new Thread(() -> {
            while (true) {
                int i = random.nextInt(1000);
                System.out.println(System.currentTimeMillis() + "--" + i);
            }
        }).start();

从执行结果上来看，4线程执行下，平均每1秒可以生成280个随机数。那有什么办法来解决多线程下的随机数生成呢？

ThreadLocalRandom

ThreadLocalRandom 是继承 Random 类，并在其基础上解决了并发生成的问题。

每一个线程有一个独立的随机数生成器，在并发的时候不需要跟别的线程竞争。效率更高！

new Thread(() -> {
    ThreadLocalRandom current = ThreadLocalRandom.current();
    while (true) {
        int i = current.nextInt();
        System.out.println(System.currentTimeMillis() + "--" + i);
    }
}).start();

ThreadLocalRandom 通过 current 方法获取当前线程所持有的 随机数生成器实例。

public static ThreadLocalRandom current() {
    if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
        localInit();
    return instance;
}

static final void localInit() {
    int p = probeGenerator.addAndGet(PROBE_INCREMENT);
    int probe = (p == 0) ? 1 : p; // skip 0
    long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
    Thread t = Thread.currentThread();
    UNSAFE.putLong(t, SEED, seed);
    UNSAFE.putInt(t, PROBE, probe);
}

localInit 方法是用来生成当前线程的属性。仅在 Thread.threadLocalRandomProbe为0时调用，表示需要一个线程本地seed值需要生成。注意：尽管初始化是 ThreadLocal 的，但我们需要依赖一个(静态)原子生成器来初始化值。

SecureRandom

我们知道 Random 实现的算法是伪随机，也就是有规律的随机算法。进行随机时，在随机算法的种子seed 的基础上进行一定的变换，从而产生随机数字。

当不可预测性至关重要时， 如大多数对安全性要求较高的环境可以使用密码学的 PRNG。 不管选择了哪一种 PRNG， 都要始终使用带有充足熵的数值作为该算法的种子。 （诸如当前时间之类的数值只提供很小的熵， 因此不应该使用（Random的实现）。 ）

1. SecureRandom 也是继承于 Random

2. SecureRandom提供加密的强随机生成器(RNG)。

3. SecureRandom 和 Random 都是种子一样时，生成出来的随机数也是一样的。二者区别在于：

   • SecureRandom 的种子必须是不可预测的。
   • Random 的种子是基于系统时间的

注意:根据实现的不同，{@code generateSeed}和{@code nextBytes}方法可能会因为熵被收集而阻塞，例如，如果它们需要从各种类unix操作系统上的/dev/random读取。

SecureRandom，实现强随机的核心方法在于：SecureRandomSpi.engineNextBytes 方法

public SecureRandom() {
    /*
         * This call to our superclass constructor will result in a call
         * to our own {@code setSeed} method, which will return
         * immediately when it is passed zero.
         */
    super(0);
    getDefaultPRNG(false, null);
}

private void getDefaultPRNG(boolean setSeed, byte[] seed) {
    String prng = getPrngAlgorithm();
    if (prng == null) {
        // bummer, get the SUN implementation
        prng = "SHA1PRNG";
        this.secureRandomSpi = new sun.security.provider.SecureRandom();
        this.provider = Providers.getSunProvider();
        if (setSeed) {
            this.secureRandomSpi.engineSetSeed(seed);
        }
    } else {
        try {
            SecureRandom random = SecureRandom.getInstance(prng);
            this.secureRandomSpi = random.getSecureRandomSpi();
            this.provider = random.getProvider();
            if (setSeed) {
                this.secureRandomSpi.engineSetSeed(seed);
            }
        } catch (NoSuchAlgorithmException nsae) {
            // never happens, because we made sure the algorithm exists
            throw new RuntimeException(nsae);
        }
    }
    // JDK 1.1 based implementations subclass SecureRandom instead of
    // SecureRandomSpi. They will also go through this code path because
    // they must call a SecureRandom constructor as it is their superclass.
    // If we are dealing with such an implementation, do not set the
    // algorithm value as it would be inaccurate.
    if (getClass() == SecureRandom.class) {
        this.algorithm = prng;
    }
}

使用方法

配置 -Djava.security参数来修改调用的算法

// 没有配置时，默认与SHA1PRNG
SecureRandom secureRandom = new SecureRandom();

SecureRandom secureRandom1 = SecureRandom.getInstance("SHA1PRNG");

// 通常可以用来作为其它算法的种子
secureRandom.generateSeed(20);

• SpringBoot 配置ssh连接数据库
  • 前言
  • 方案1
  • 参考文章

SpringBoot 配置ssh连接数据库

前言

有时候我们无法直连上数据库，这时就需要通过代理的形式。

方案1

1. 导入依赖包

<dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.50</version>
</dependency>

2. 添加ssh配置

ssh.enabled: true
ssh.remote.ip: 192.168.0.1
ssh.remote.port: 22
ssh.remote.username: root
ssh.remote.password: root
ssh.remote.target_host: 192.168.0.2
ssh.remote.target_port: 3306
ssh.local.resource_host: 127.0.0.1
ssh.local.resource_port: 3307

3. properties配置类

@Configuration
@Data
@PropertySource(value = "classpath:/config/remote-ssh.properties", encoding = "utf-8", ignoreResourceNotFound = true)
@ConditionalOnResource(resources = {"classpath:/config/remote-ssh.properties"})
public class SshProperties {
    @Value("${ssh.enabled}")
    private boolean enabled;
    @Value("${ssh.remote.ip}")
    private String ip;
    @Value("${ssh.remote.port}")
    private int port;
    @Value("${ssh.remote.username}")
    private String username;
    @Value("${ssh.remote.password}")
    private String passowrd;
    @Value("${ssh.remote.target_host}")
    private String targetHost;
    @Value("${ssh.remote.target_port}")
    private int targetPort;
    @Value("${ssh.local.resource_host}")
    private String resourceHost;
    @Value("${ssh.local.resource_port}")
    private int resourcePort;
}

// 或者这样的方式
@Configuration
@Data
@PropertySource(value = "classpath:/config/remote-ssh.properties", encoding = "utf-8", ignoreResourceNotFound = true)
@ConditionalOnResource(resources = {"classpath:/config/remote-ssh.properties"})
@ConfigurationProperties(prefix = "ssh")
public class SshProperties {
    //    @Value("${ssh.enabled:false}")
    private boolean enabled;

    @Bean
    public Remote getRemote() {
        return new Remote();
    }

    @Bean
    public Local getLocal() {
        return new Local();
    }

    @Data
    @Configuration
    @ConfigurationProperties("ssh.remote")
    public class Remote {
        //    @Value("${ssh.remote.ip}")
        private String ip;
        //    @Value("${ssh.remote.port}")
        private int port;
        //    @Value("${ssh.remote.username}")
        private String username;
        //    @Value("${ssh.remote.password}")
        private String passowrd;
        //    @Value("${ssh.remote.target_host}")
        private String targetHost;
        //    @Value("${ssh.remote.target_port}")
        private int targetPort;
    }

    @Data
    @Configuration
    @ConfigurationProperties("ssh.local")
    public class Local {
        //    @Value("${ssh.local.resource_host}")
        private String resourceHost;
        //    @Value("${ssh.local.resource_port}")
        private int resourcePort;
    }
}

4. 使用jsch加载SshProperties

@Component
@Slf4j
@ConditionalOnBean(SshProperties.class)
public class SshConfig implements ServletContextInitializer {
    private static Session session;

    @Autowired(required = false)
    private SshProperties sshProperties;


    public Session initSession() {
        try {
            //如果配置文件包含ssh.enabled属性，则使用ssh转发
            if (sshProperties.isEnabled()) {
                Session session = new JSch().getSession(sshProperties.getRemote().getUsername(), sshProperties.getRemote().getIp(), sshProperties.getRemote().getPort());
                session.setConfig("StrictHostKeyChecking", "no");
                session.setPassword(sshProperties.getRemote().getPassowrd());
                session.connect();
                //将本地端口的请求转发到目标地址的端口
                session.setPortForwardingL(sshProperties.getLocal().getResourceHost(), sshProperties.getLocal().getResourcePort(), sshProperties.getRemote().getTargetHost(), sshProperties.getRemote().getTargetPort());
                log.info("ssh forward is open.");
                return session;
            } else {
                log.info("ssh forward is closed.");
            }
        } catch (JSchException e) {
            log.error("ssh JSchException failed.", e);
        } catch (Exception e) {
            log.error("ssh settings is failed. skip!", e);
        }
        return null;
    }

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        session = initSession();
    }

    /**
     * 断开SSH连接
     */
    public void destroy() {
        this.session.disconnect();
    }
}

到这一步就大功告成了。

参考文章

• SpringBoot 通过SSH跳板机连接不能直达的IP+端口

• 待研究
  • cdi
  • hibernate-validator-cdi
  • redis
  • shiro-redis
    • springboot-redis
    • springboot-cache
• tcpip
  • 质量测试工具
  • 鎖

待研究

cdi

1. cdi和di
2. spring相关
3. jsr330和jsr229
4. ejb

https://www.jdon.com/38322

https://zhuanlan.zhihu.com/p/337965169

https://rumenz.com/java-topic/hibernate/hibernate-validator-cdi/index.html

hibernate-validator-cdi

https://rumenz.com/java-topic/hibernate/hibernate-validator-cdi/index.html

redis

shiro-redis

• http://alexxiyang.github.io/shiro-redis/
• https://github.com/alexxiyang/shiro-redis/tree/master/docs

springboot-redis

• https://lettuce.io/core/5.3.5.RELEASE/reference/index.html#spring.spring-data-redis
• https://docs.spring.io/spring-data/redis/docs/current/reference/html/#redis:connectors:connection

springboot-cache

• CacheResolver
• CacheErrorHandler
• 参考：https://blog.csdn.net/sz85850597/article/details/89301331

tcpip

• websocket
• sockjs
• sockio
• netty
• 长轮询
• stomp

质量测试工具

• sonarqube
• arthas

鎖

MPSC 。caffeine的寫鎖機制

• Blob下载

Blob下载

const url = window.URL.createObjectURL(new Blob([response]));
const link = document.createElement('a');
link.href = url;
link.setAttribute('download', 'video.mp4');
document.body.appendChild(link);
link.click();

• 基于CANVAS视频抽帧显示

基于CANVAS视频抽帧显示

export interface videoInfo {
  blob: Blob | null;
  url: string;
}

// 画视频
const drawVideo = (video: HTMLVideoElement) => {
  return new Promise<videoInfo>(success => {
    const cvs = document.createElement('canvas');
    const ctx = cvs.getContext('2d');
    cvs.width = video.videoWidth;
    cvs.height = video.videoHeight;
    ctx?.drawImage(video, 0, 0, cvs.width, cvs.height);
    cvs.toBlob(blob => {
      success({
        blob,
        url: URL.createObjectURL(blob as Blob)
      });
    });
  });
};

// 视频截取工具
export function captureFrame(videoFile: File, time: number = 0) {
  return new Promise<videoInfo>(succeed => {
    const video = document.createElement('video');
    video.currentTime = time;
    video.muted = true;
    video.preload = 'auto';
    video.autoplay = true;
    video.setAttribute('crossOrigin', 'Anonymous'); // 处理跨域
    video.setAttribute('preload', 'auto'); // auto|metadata|none
    video.src = URL.createObjectURL(videoFile);
    video.oncanplay = async () => {
      // 延时500ms防止白屏问题
      setTimeout(async () => {
        const res = await drawVideo(video);
        succeed(res);
      }, 500);
    };
  });
}
// blob\file转base64
export function toBase64(blob: Blob | File) {
  return new Promise<string>(success => {
    var reader = new FileReader();
    reader.readAsDataURL(blob);
    reader.onload = (e: any) => {
      success(e.target.result);
    }
  })
}

• 颜色工具

颜色工具

const ColorMaker = {
    // 最大支持颜色种类数
    TotalColors: 300,
    // 获取颜色 seed:颜色种子(任意int)
    getColor: (seed = 0) => {
        var ret = {
            TextColor: 'FFFFFF',
            Color: 'FF0000'
        }
        // 计算对应下标
        var idx = seed % ColorMaker.TotalColors;
        // 计算颜色
        var colorVal = ColorMaker._CalColor(idx);
        // 转成RGB 16进制字符串
        ret.Color = colorVal.toString(16).padStart(6, '0');
        // 计算互补色
        ret.TextColor = ColorMaker._CalTextColor(ret.Color);

        return ret;
    },

    getRgbColor: (seed: number = 0) => {
        const hex: string = ColorMaker.getColor(seed).Color;
        return hexToRGB(hex);
    },


    getRgbColorArr: (seed: number = 0): number[] => {
        const hex: string = ColorMaker.getColor(seed).Color;
        return hexToRGBArr(hex);
    },

    _CalColor: (idx = 0) => {
        // 默认返回红色
        var ret = 0xFF0000;
        // RGB的最大值
        var full = 0xFFFFFF;
        // 总共需要支持多少种颜色，若传0则取255
        var total = ColorMaker.TotalColors > 0 ? ColorMaker.TotalColors : 0xFF;
        // 将所有颜色平均分成x份
        var perVal = full / total;
        if (idx >= 0 && idx <= total) {
            ret = perVal * idx;
        }
        ret = Math.round(ret);
        return ret;
    },

    // 计算传入颜色的互补色
    _CalTextColor: (input = '') => {
        var R = input.substr(0, 2);
        var G = input.substr(2, 2);
        var B = input.substr(4, 2);
        var rVal = parseInt(R, 16);
        var gVal = parseInt(G, 16);
        var bVal = parseInt(B, 16);
        var hsl = rgbToHsl(rVal, gVal, bVal);

        hsl.L = (hsl.L + 0.5) % 1.0;
        var rgb = hslToRgb(hsl.H, hsl.S, hsl.L);
        var ret = (rgb.R << 16) + (rgb.G << 8) + rgb.B;
        return ret.toString(16).padStart(6, '0');
    }
};

/**
 * RGB 颜色值转换为 HSL.
 * 转换公式参考自 http://en.wikipedia.org/wiki/HSL_color_space.
 * r, g, 和 b 需要在 [0, 255] 范围内
 * 返回的 h, s, 和 l 在 [0, 1] 之间
 *
 * @param   Number  r       红色色值
 * @param   Number  g       绿色色值
 * @param   Number  b       蓝色色值
 * @return  Array           HSL各值数组
 */
function rgbToHsl(r: number, g: number, b: number) {
    r /= 255, g /= 255, b /= 255;
    let max = Math.max(r, g, b), min = Math.min(r, g, b);
    let h: number = 0, s, l = (max + min) / 2;
    if (max == min) {
        h = s = 0; // achromatic
    } else {
        let d = max - min;
        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
        switch (max) {
            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
            case g: h = (b - r) / d + 2; break;
            case b: h = (r - g) / d + 4; break;
        }
        h /= 6;
    }
    return { H: h, S: s, L: l };
}

/**
 * HSL颜色值转换为RGB.
 * 换算公式改编自 http://en.wikipedia.org/wiki/HSL_color_space.
 * h, s, 和 l 设定在 [0, 1] 之间
 * 返回的 r, g, 和 b 在 [0, 255]之间
 *
 * @param   Number  h       色相
 * @param   Number  s       饱和度
 * @param   Number  l       亮度
 * @return  Array           RGB色值数值
 */
function hslToRgb(h: number, s: number, l: number) {
    var r, g, b;
    if (s == 0) {
        r = g = b = l; // achromatic
    } else {
        var hue2rgb = function hue2rgb(p: number, q: number, t: number) {
            if (t < 0) t += 1;
            if (t > 1) t -= 1;
            if (t < 1 / 6) return p + (q - p) * 6 * t;
            if (t < 1 / 2) return q;
            if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
            return p;
        }
        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
        var p = 2 * l - q;
        r = hue2rgb(p, q, h + 1 / 3);
        g = hue2rgb(p, q, h);
        b = hue2rgb(p, q, h - 1 / 3);
    }
    return { R: Math.round(r * 255), G: Math.round(g * 255), B: Math.round(b * 255) };
}


export function hexToRGB(hex: string) {
    // 移除井号（如果存在）  
    if (hex.charAt(0) === '#') {
        hex = hex.slice(1);
    }

    // 确保长度是6个字符（包括两个字符用于每个RGB分量）  
    if (hex.length !== 6) {
        throw new Error('Invalid hex color. It should be 6 characters long including the hash.');
    }

    // 将十六进制字符串转换为RGB分量  
    var r = parseInt(hex.substring(0, 2), 16);
    var g = parseInt(hex.substring(2, 4), 16);
    var b = parseInt(hex.substring(4, 6), 16);

    return `rgb(${r}, ${g}, ${b})`;
}

export function hexToRGBArr(hex: string) {
    // 移除井号（如果存在）  
    if (hex.charAt(0) === '#') {
        hex = hex.slice(1);
    }

    // 确保长度是6个字符（包括两个字符用于每个RGB分量）  
    if (hex.length !== 6) {
        throw new Error('Invalid hex color. It should be 6 characters long including the hash.');
    }

    // 将十六进制字符串转换为RGB分量  
    var r = parseInt(hex.substring(0, 2), 16);
    var g = parseInt(hex.substring(2, 4), 16);
    var b = parseInt(hex.substring(4, 6), 16);

    return [r, g, b]
}

export default ColorMaker;

• Upload-Image

Upload-Image

<script setup lang="ts">
import { ref, h, defineEmits, watch } from "vue"
import type { UploadFileInfo, UploadInst, UploadCustomRequestOptions } from 'naive-ui'
import { fetchCommonUpload } from "@/service/api";
import { $t } from "@/locales";
// import { toBase64 } from "@/utils/videoFrame";

/**
 * @description 图片上传
 * @param options 上传的文件
 * */
interface UploadEmits {
  (e: "success", value: string): void;
  (e: "check-validate"): void;
}
const emit = defineEmits<UploadEmits>();


type FileTypes =
  | "image/apng"
  | "image/bmp"
  | "image/gif"
  | "image/jpeg"
  | "image/pjpeg"
  | "image/png"
  | "image/svg+xml"
  | "image/tiff"
  | "image/webp"
  | "image/x-icon";

interface UploadFileProps {
  defaultUrl: string;
  filelength: number; // 文件数
  fileSize: number; // 文件大小，M
  fileType: FileTypes[];
  disabled: boolean;
  size: string;
  borderRadius: string;
}


// 接受父组件参数
const props = withDefaults(defineProps<UploadFileProps>(), {
  defaultUrl: '',
  disabled: false,
  filelength: 1,
  fileSize: 5,
  fileType: () => ["image/jpeg", "image/png", "image/gif"],
  size: "120px",
  borderRadius: "100%",
});


const fileList = ref<UploadFileInfo[]>([])

const uploadRef = ref<UploadInst | null>()

const fileUrl = ref<string>("");


watch(() => props.defaultUrl, (newValue) => {
  if (fileUrl.value === '') {
    fileUrl.value = newValue;
    console.log(fileUrl.value)
  }
});

async function handleUpload({
  file,
  data,
  headers,
  withCredentials,
  action,
  onFinish,
  onError,
  onProgress
}: UploadCustomRequestOptions) {
  // fileUrl.value = await toBase64(file.file as File)
  const res = await fetchCommonUpload(file.file as File);
  fileUrl.value = res.url
  emit("success", fileUrl.value)
}

function handleBeforeUpload(data: {
  file: UploadFileInfo
  fileList: UploadFileInfo[]
}) {
  const fileInfo = data.file
  const size = fileInfo.file?.size || props.fileSize
  // 检查文件大小
  if (size > props.fileSize * 1024 * 1024) {
    window.$message?.warning(`请上传不超过${props.fileSize}M的文件`);
    return false;
  }
  if (props.fileType.indexOf(fileInfo.type as FileTypes) < 0) {
    window.$message?.warning(`上传图片不符合所需的格式`);
    return false;
  }
  return true;
}

function handleRemove() {
  fileList.value = []
}

function handleView() {
  window.$dialog?.info({
    title: $t('common.preview'),
    content: () => {
      return h(
        "img",
        { src: fileUrl.value, class: 'w-100% object-cover' }
      )
    },
    maskClosable: true,
    showIcon: false
  });
}
</script>

<template>
  <n-upload ref="uploadRef" abstract v-model:file-list="fileList" :custom-request="handleUpload"
    :accept="props.fileType.join(',')" @before-upload="handleBeforeUpload" :disabled="props.disabled">
    <div :style="['width:' + props.size, 'height:' + props.size]"
      class="border-dotted border-1 bordre-#c0ccda border-rd-2  position-relative cursor-pointer overflow-hidden">
      <n-upload-trigger #="{ handleClick }" abstract class="size-full position-relative">
        <div class="size-full position-relative" @click="handleClick" v-if="fileUrl === ''">
          <icon-local-plus class="text-24px position-absolute absolute top-50% left-50% translate--50%" />
        </div>
        <div :style="['border-radius:' + props.borderRadius]"
          class="size-full mr-10px position-absolute overflow-hidden top-50% left-50% translate--50%" v-else>
          <img :src="fileUrl" class="size-full" />
          <div
            class="position-absolute top-0 size-full  z-index-10 opacity-0 hover:opacity-100 bg-#f9f9f999 transition-all-300 transition-ease-linear">
            <div class="position-absolute top-50% left-50% translate--50% w-80% flex flex-row justify-around">
              <icon-local-view class="text-24px" @click="handleView" />
              <icon-local-upload class="text-24px" @click="() => { handleRemove(); handleClick() }" />
              <!-- <icon-local-delete class="text-24px" @click="handleRemove" /> -->
            </div>
          </div>
        </div>
      </n-upload-trigger>
    </div>
  </n-upload>
</template>

<style scoped></style>

• base64
  • background
  • canvas

base64

background

background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAAA3NCSVQICAjb4U/gAAAABlBMVEXMzMz////TjRV2AAAACXBIWXMAAArrAAAK6wGCiw1aAAAAHHRFWHRTb2Z0d2FyZQBBZG9iZSBGaXJld29ya3MgQ1M26LyyjAAAABFJREFUCJlj+M/AgBVhF/0PAH6/D/HkDxOGAAAAAElFTkSuQmCC)

canvas

function renderCanvas(img: HTMLImageElement) {
    const canvas = canvasRef.value;
    const ctx = canvas.getContext('2d')
    ctx.fillStyle = ctx.createPattern(img, 'repeat');
    ctx.scale(0.5, 0.4);
    ctx.fillRect(0, 0, canvas.width / 0.5, canvas.height / 0.4);
}

let img = new Image();
img.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAAA3NCSVQICAjb4U/gAAAABlBMVEXMzMz////TjRV2AAAACXBIWXMAAArrAAAK6wGCiw1aAAAAHHRFWHRTb2Z0d2FyZQBBZG9iZSBGaXJld29ya3MgQ1M26LyyjAAAABFJREFUCJlj+M/AgBVhF/0PAH6/D/HkDxOGAAAAAElFTkSuQmCC'
if (img.complete) {
    renderCanvas(img)
} else {
    img.onload = () => {
        renderCanvas(img)
    }
}

• 计算坐标

计算坐标

function cropImage(imagedata: ImageData) {
    let left = -1, top = -1, right = -1, bottom = -1;
    const idata = imagedata.data
    const count = idata.length;
    const countWidth = imagedata.width * 4;
    console.log(count)
    for (let i = 0, y = 0; i < count; i = i + 4) {
        if (i != 0 && i % countWidth == 0) {
            y++;
        }
        // console.log([idata[i], idata[i + 1], idata[i + 2], idata[i + 3]])
        if (
            idata[i] !== 255
            || idata[i + 1] !== 255
            || idata[i + 2] !== 255
            || idata[i + 3] !== 255
        ) {
            const x = (i - countWidth * y) / 4;
            if (left === -1) {
                left = x
            } else {
                if (left > x) {
                    left = x;
                }
                if (right === -1) {
                    right = x
                } else if (right < x) {
                    right = x
                }
            }
            if (top === -1) {
                top = y;
            } else {
                if (bottom === -1) {
                    bottom = y
                } else if (bottom < y) {
                    bottom = y
                }
            }
        }
    }
    return [left, top, right - left, bottom - top]
}

• 前言
• 封装库

前言

官方demo : https://github.com/microsoft/onnxruntime-inference-examples/blob/main/js/segment-anything/main.js

• 版本

  • "@tensorflow/tfjs": "^4.17.0",
  • "onnxruntime-web": "^1.17.0",

• 配置

  • 
    
    /**
     * Create service config by current env
     *
     * @param env The current env
     */
    export function createModelMap(env: Env.ImportMeta) {
      // const mockURL = 'https://mock.apifox.com/m1/3109515-0-default';
    
      const modelType: App.Model.ModelConfigMap = {
        dev: {
          wasm: {
            'ort-wasm.wasm': '/files/ort-wasm.wasm',
            'ort-wasm-simd.wasm': '/files/ort-wasm-simd.wasm',
            'ort-wasm-threaded.wasm': '/files/ort-wasm-threaded.wasm',
            'ort-wasm-simd-threaded.wasm': '/files/ort-wasm-simd-threaded.wasm',
          },
          onnx: {
            sam_b: ['/models/sam_vit_b_01ec64.encoder.onnx', "/models/sam_vit_b_01ec64.decoder.onnx"],
            mobile_sam: ['/models/mobile_sam.encoder.onnx', "/models/mobile_sam.decoder.onnx"]
          }
        },
        test: {
          wasm: {
            'ort-wasm.wasm': '/files/ort-wasm.wasm',
            'ort-wasm-simd.wasm': '/files/ort-wasm-simd.wasm',
            'ort-wasm-threaded.wasm': '/files/ort-wasm-threaded.wasm',
            'ort-wasm-simd-threaded.wasm': '/files/ort-wasm-simd-threaded.wasm',
          },
          onnx: {
            sam_b: ['/models/sam_vit_b_01ec64.encoder.onnx', "/models/sam_vit_b_01ec64.decoder.onnx"],
            mobile_sam: ['/models/mobile_sam.encoder.onnx', "/models/mobile_sam.decoder.onnx"]
          }
        },
        prod: {
          wasm: {
            'ort-wasm.wasm': '/files/ort-wasm.wasm',
            'ort-wasm-simd.wasm': '/files/ort-wasm-simd.wasm',
            'ort-wasm-threaded.wasm': '/files/ort-wasm-threaded.wasm',
            'ort-wasm-simd-threaded.wasm': '/files/ort-wasm-simd-threaded.wasm',
          },
          onnx: {
            sam_b: ['/models/sam_vit_b_01ec64.encoder.onnx', "/models/sam_vit_b_01ec64.decoder.onnx"],
            mobile_sam: ['/models/mobile_sam.encoder.onnx', "/models/mobile_sam.decoder.onnx"]
          }
        },
      };
    
      const { VITE_SERVICE_ENV = 'dev' } = env;
    
      return modelType[VITE_SERVICE_ENV];
    }
    

  • onnx配置

    ort.env.wasm.numThreads = data.threads;
    ort.env.wasm.simd = true;
    // ort.env.wasm.proxy = true;
    ort.env.wasm.wasmPaths = globalModelMap.wasm as ort.Env.WasmPrefixOrFilePaths;
    

  • 模型大小设置。这里需要注意的是onnx转换后，模型图像的宽高固定为1024*684，如果图像什么出现问题，需要做一下转换和计算。

封装库

• segment.ts

import * as ort from 'onnxruntime-web';
import * as tf from '@tensorflow/tfjs'
import { ref, reactive, onMounted, onUnmounted } from 'vue'
import { captureFrame, toBase64 } from '@/utils/videoFrame'
import { BlockItem, ModelMapType, ConfigType, UploadType, FrameItem, BlockItemType, PointOperaType, SegmentOperaType } from "./types/segment.d.js"
import dayjs from 'dayjs';
import ColorMaker from '@/utils/colorUtils.js';
import { createModelMap } from '~/env.config';

const MODEL_WIDTH = 1024;
const MODEL_HEIGHT = 684;

const globalModelMap = createModelMap(import.meta.env)
const MODEL_MAP: ModelMapType = globalModelMap.onnx
const modelSess: ort.InferenceSession[] = []

function getConfig(): ConfigType {
    const data: ConfigType = {
        model: "mobile_sam",
        provider: { name: "wasm" },//wasm，webgpu,webnn
        device: "cpu",
        threads: 4,
        clear_cache: false
    };
    ort.env.wasm.numThreads = data.threads;
    return data;
}


ort.env.wasm.simd = true;
// ort.env.wasm.proxy = true;
ort.env.wasm.wasmPaths = globalModelMap.wasm as ort.Env.WasmPrefixOrFilePaths;

const config = getConfig();

/**
 * fetch and cache url
 */
async function fetchAndCache(url: string) {
    try {
        const cache = await caches.open("onnx");
        if (config.clear_cache) {
            cache.delete(url);
        }
        let cachedResponse = await cache.match(url);
        if (cachedResponse == undefined) {
            await cache.add(url);
            cachedResponse = await cache.match(url);
            // console.log(`${url} (from network)`);
        } else {
            // console.log(`${url} (from cache)`);
        }
        const data = await cachedResponse?.arrayBuffer();
        return data
    } catch (error) {
        // console.log(`${url} (from network)`);
        return await fetch(url).then(response => {
            //   {
            //   mode: "cors",
            //   headers: {
            //     "Cross-Origin-Embedder-Policy": "require-corp",
            //     "Cross-Origin-Opener-Policy": "same-origin"
            //   },
            //   referrerPolicy: "same-origin",
            //   credentials: "same-origin"
            // }
            // response.headers.set("Cross-Origin-Embedder-Policy", "require-corp");
            // response.headers.set("Cross-Origin-Opener-Policy", "same-origin");
            return response.arrayBuffer()
        });
    }
}

function loadModel(model: string[], idx: number) {
    const provider = config.provider

    switch (config.provider.name) {
        case "webnn":
            if (!("ml" in navigator)) {
                throw new Error("webnn is NOT supported");
            }
            provider.deviceType = config.device;
            provider.powerPreference = 'default'
            break;
        case "webgpu":
            if (!navigator.gpu) {
                throw new Error("webgpu is NOT supported");
            }
            break;
    }

    const opt = { executionProviders: [provider] };

    fetchAndCache(model[idx]).then(async (data: any) => {
        // sess[idx] = ort.InferenceSession.create('./models/sam_vit_b_01ec64.encoder.onnx');
        // const u8data = new Uint8Array(data);
        modelSess[idx] = await ort.InferenceSession.create(data, opt);
        // console.log(`${model[idx]} loaded.`);
        // sess[idx].then(() => {
        //   console.log(`${model[idx]} loaded.`);
        if (idx == 0) {
            loadModel(model, 1);
        }
        // }, (e) => {
        //   console.log(`${model[idx]} failed with ${e}.`);
        //   throw e;

        // });
    })
}


export default function useSegment() {

    onMounted(() => {
        const model: string[] = MODEL_MAP[config.model as keyof ModelMapType];
        loadModel(model, 0);
    })
    onUnmounted(() => {
        modelSess.forEach((item) => {
            if (item != null) {
                item.release();
            }
        })
    })
    const frameList = reactive<FrameItem[]>([]);
    const frameIndex = ref(0);
    const blockList = reactive<BlockItem[]>([]);
    const blockIndex = ref(0);
    const videoUploadRef = ref();
    const videoUploadLoading = ref(false);
    const fileBase64 = ref('');
    const frameBase64 = ref('');
    const canvasRef = ref();
    const previewRef = ref();
    let colorIdx = 1, MAX_WIDTH: number = 1000, MAX_HEIGHT: number = 360
    const _useBlocks = useBlocks()
    const _useModel = useModel()
    const _useMediaUpload = useMediaUpload()
    const _useFrames = useFrames();

    // 当前帧的图像数据
    let imageImageData: ImageData | undefined, imageEmbeddings: ort.Tensor;

    function useFrames() {
        function frameAddHandle(addIndex: boolean = true, obj: { sec: number, type: number, base64: string, imageData?: ImageData, imageEmbeddings?: ort.Tensor }) {
            frameList.push({
                id: String(dayjs().valueOf()) + Math.random() * (100 - 1) + 1,
                type: obj.type,
                sec: obj.sec,
                base64: obj.base64,
                imageData: obj.imageData,
                imageEmbeddings: obj.imageEmbeddings
            });
            if (addIndex) { frameIndex.value += 1; }
        }
        function frameDelHandle() {

        }
        return {
            frameAddHandle,
            frameDelHandle
        }
    }

    function useBlocks() {
        const blockShowAll = ref(false); // true 展示全部，false 展示一个
        function blockAddHandle(obj: { type?: BlockItemType }, addIndex: boolean = true) {
            blockShowAll.value = false;
            blockList.push({
                id: String(dayjs().valueOf()) + Math.random() * (100 - 1) + 1,
                type: obj.type || 'mask',
                hasPoint: false,
                color: ColorMaker.getRgbColorArr(colorIdx),
                pointModel: [],
                pointXY: [],
                resource: '',
                resourceType: '',
                imgBase64: '',
                imgData: undefined,
                result: null,
                zIndex: 100 - blockIndex.value,
                segmentImage: '',
                segmentImageBase64: '',
                segmentImageBitmap: null
            });
            colorIdx++;
            if (addIndex) { blockIndex.value += 1; blockShowHandle(blockIndex.value); }

        }
        function blockDelHandle(index: number) {
            if (blockList.length === 1) {
                window.$message?.warning('请保留一层蒙版');
            } else {
                blockList.splice(index, 1);
                if (blockIndex.value >= blockList.length) {
                    blockIndex.value = blockList.length - 1;
                }
            }
            blockShowHandle();
        }

        function blockShowHandle(index: number = -1) {
            const canvas = canvasRef.value
            const ctx = canvas.getContext('2d');
            ctx.globalAlpha = 0.5;
            ctx.clearRect(0, 0, canvas.width, canvas.height);


            // todo: 等后面换成多帧后，需要从对应获取
            ctx.putImageData(imageImageData, 0, 0, 0, 0, canvas.width, canvas.height);
            if (index >= 0) {
                blockIndex.value = index;
                blockShowAll.value = false;
                const block = blockList[index];
                ctx.drawImage(block.segmentImageBitmap, 0, 0);
            } else {
                blockShowAll.value = true;
                for (let i = blockList.length - 1; i >= 0; i--) {
                    const block = blockList[i];
                    ctx.drawImage(block.segmentImageBitmap, 0, 0);
                }
            }
        }

        return {
            blockList,
            blockIndex,
            blockShowAll,
            blockAddHandle,
            blockDelHandle,
            blockShowHandle,
        }
    }

    function useMediaUpload() {
        const uploadType: UploadType = {
            type: 1,
            blockIndex: 0,
        };

        async function uploadHandle(type: number, bIndex: number = 0) {
            const vur = videoUploadRef.value;
            uploadType.type = type;
            uploadType.blockIndex = bIndex;
            switch (type) {
                case 1:
                    vur.accept = 'video/*'
                    break;
                case 2:
                    vur.accept = 'video/*,image/*'
                    break;
                case 3:
                    vur.accept = 'video/*'
            }
            vur.onchange = uploadVideo;
            vur.click();
        }

        async function uploadVideo() {
            if (uploadType.type === 1) {
                uploadMedia((img) => {
                    _useBlocks.blockAddHandle({ type: "mask" }, false);
                    _useModel.imageHandle(img, 'frame')
                })
            } else if (uploadType.type === 2) {
                uploadResource(uploadType.blockIndex)
            } else if (uploadType.type === 3) {
                uploadMedia((img) => {
                    // _useBlocks.blockAddHandle(false);
                    // _useModel.imageHandle(img)
                    _useModel.imageRenderHandle(img);
                })
            }
        }
        async function uploadMedia(callback: (img: HTMLImageElement) => void) {
            const vur = videoUploadRef.value;
            const file: File = vur.files[0];
            if (file) {
                frameList.length = 0;
                frameIndex.value = 0
                blockList.length = 0;
                blockIndex.value = 0;
                videoUploadLoading.value = true
                const img = new Image()
                if (file.type.startsWith("image/")) {
                    const base64 = await toBase64(file)
                    img.src = base64
                    fileBase64.value = img.src
                    frameBase64.value = img.src
                } else {
                    const info = await captureFrame(file, 1);
                    img.src = await toBase64(info.blob as Blob)
                    fileBase64.value = await toBase64(file);
                    frameBase64.value = img.src
                }
                _useFrames.frameAddHandle(false, {
                    sec: 1,
                    type: uploadType.type,
                    base64: frameBase64.value,
                })
                videoUploadLoading.value = false
                if (img.complete) {
                    if (callback != null) {
                        callback(img)
                    }
                } else {
                    img.onload = () => {
                        if (callback != null) {
                            callback(img)
                        }
                    }
                }
                vur.value = '';
            }
        }

        async function uploadResource(index: number) {
            if (index > blockList.length || index < 0) {
                return
            }
            const vur = videoUploadRef.value;
            const file: File = vur.files[0];
            if (file) {
                const item = blockList[index];
                item.resource = await toBase64(file);
                if (file.type.startsWith('image/')) {
                    item.resourceType = 'image';
                } else if (file.type.startsWith('video/')) {
                    item.resourceType = 'video';
                }
                vur.value = '';
            }
        }
        return {
            videoUploadRef,
            videoUploadLoading,
            fileBase64,
            frameBase64,
            uploadMedia,
            uploadResource,
            uploadHandle
        }
    }

    function useModel() {
        let pointOpera: PointOperaType = 'plus';
        let segmentOpera: SegmentOperaType = 'mask'

        async function imageRenderHandle(img: HTMLImageElement) {
            let renderLoading = videoUploadLoading.value ? 1 : 0;
            if (renderLoading === 0) {
                videoUploadLoading.value = true
            }
            let width = img.width;
            let height = img.height;

            if (width > MAX_WIDTH) {
                height = height * (MAX_WIDTH / width);
                width = MAX_WIDTH;
            }
            // } else {
            if (height > MAX_HEIGHT) {
                width = width * (MAX_HEIGHT / height);
                height = MAX_HEIGHT;
            }
            // }

            width = Math.round(width);
            height = Math.round(height);


            const canvas: HTMLCanvasElement = canvasRef.value;
            canvas.width = width;
            canvas.height = height;
            let context = canvas.getContext('2d');
            context?.drawImage(img, 0, 0, width, height);
            if (renderLoading === 0) {
                videoUploadLoading.value = false
            }
        }

        async function imageHandle(img: HTMLImageElement, type: "block" | "frame") {
            imageRenderHandle(img);
            videoUploadLoading.value = true;

            const frame = frameList[frameIndex.value]

            const block = blockList[blockIndex.value];
            if (block.imgBase64 === '') {
                block.imgBase64 = frameBase64.value;
            }

            const canvas: HTMLCanvasElement = canvasRef.value;
            let width = canvas.width
            let height = canvas.height
            let context = canvas.getContext('2d');

            setTimeout(async () => {
                imageImageData = context?.getImageData(0, 0, width, height);
                if (!frame.imageData) {
                    frame.imageData = imageImageData
                }

                let resizeTensor = await ort.Tensor.fromImage(imageImageData as unknown as ImageBitmap, { resizedWidth: MODEL_WIDTH, resizedHeight: MODEL_HEIGHT })
                let tfTensor = tf.tensor(resizeTensor.data, [...resizeTensor.dims]);
                tfTensor = tfTensor.reshape([3, MODEL_HEIGHT, MODEL_WIDTH]);
                tfTensor = tfTensor.transpose([1, 2, 0]).mul(255)
                const imageDataTensor = new ort.Tensor(tfTensor.dataSync(), tfTensor.shape);
                let start = Date.now();
                const feed = { "input_image": imageDataTensor };
                const res = await modelSess[0].run(feed);
                let end = Date.now();
                let time_taken = (end - start) / 1000;
                console.log(`Computing image embedding took ${time_taken} seconds`);

                imageEmbeddings = res.image_embeddings;
                if (type === "block") {
                    block.imageEmbeddings = res.image_embeddings;
                } else if (type === 'frame') {
                    frame.imageEmbeddings = res.image_embeddings;
                }
                videoUploadLoading.value = false;
            }, 500)
        }


        async function clickHandle(e: MouseEvent, label: number, fn?: (imgB64: string) => void) {
            // const originWidth = imageFrameRef.value.naturalWidth;
            // const offseWidth = imageFrameRef.value.offsetWidth;
            // const xscale = offseWidth / originWidth;

            // const originHeight = imageFrameRef.value.naturalHeight;
            // const offsetHeight = imageFrameRef.value.offsetHeight;
            // const yscale = offsetHeight / originHeight;

            // 获取x,y坐标
            // const x = Math.floor(e.offsetX / xscale);
            // const y = Math.floor(e.offsetY / yscale);

            // console.log(image_embeddings)
            // if (image_embeddings === undefined) {
            //   await sess[0];
            // }
            // const emb = await image_embeddings;

            const canvas = canvasRef.value
            const ctx = canvas.getContext('2d');

            const rect = canvas.getBoundingClientRect();
            const x = Math.floor(e.clientX - rect.left);
            const y = Math.floor(e.clientY - rect.top);
            console.log(x, y)

            const frame = frameList[frameIndex.value]
            const block = blockList[blockIndex.value];

            if (pointOpera === 'plus') {
                block.pointModel.push(label);
                block.pointXY.push(x, y);
            } else {
                block.pointModel = [label];
                block.pointXY = [x, y];
            }
            // canvas.width = imageImageData.width;
            // canvas.height = imageImageData.height;
            // console.log(canvas.width, canvas.height);

            ctx.clearRect(0, 0, canvas.width, canvas.height);

            ctx.putImageData(imageImageData, 0, 0, 0, 0, canvas.width, canvas.height);
            // ctx.fillStyle = 'blue';
            // ctx.fillRect(x, y, 10, 10);

            // const labels = [label]
            const labels = block.pointModel;
            const points = block.pointXY;

            const pointCoords = new ort.Tensor(new Float32Array(points), [1, points.length / 2, 2]);
            const pointLabels = new ort.Tensor(new Float32Array(labels), [1, labels.length]);
            const maskInput = new ort.Tensor(new Float32Array(256 * 256), [1, 1, 256, 256]);
            const hasMask = new ort.Tensor(new Float32Array([0]), [1,]);
            const origianlImageSize = new ort.Tensor(new Float32Array([MODEL_HEIGHT, MODEL_WIDTH]), [2,]);

            // const t = new ort.Tensor(emb.image_embeddings.type, Float32Array.from(emb.image_embeddings.data), emb.image_embeddings.dims);
            // console.log("t", t)
            // const t = new ort.Tensor(image_embeddings.type, Float32Array.from(image_embeddings.data), image_embeddings.dims);

            const feed = {
                "image_embeddings": imageEmbeddings,
                "point_coords": pointCoords,
                "point_labels": pointLabels,
                "mask_input": maskInput,
                "has_mask_input": hasMask,
                "orig_im_size": origianlImageSize
            }
            console.log("feed", feed)
            // const start = Date.now();
            try {
                const results = await modelSess[1].run(feed);
                console.log("Generated mask:", results);
                const mask = results.masks;

                const maskImageData = mask.toImageData();

                segmentTypeHandle(maskImageData, block)

                block.hasPoint = true;
                if (fn) {
                    fn(block.segmentImageBase64);
                }
            } catch (error) {
                console.log(`caught error: ${error}`)
            }
            // const end = Date.now();
            // console.log(`generating masks took ${(end - start) / 1000} seconds`);
        }

        function cropImage(imagedata: ImageData) {
            let left = -1, top = -1, right = -1, bottom = -1;
            const idata = imagedata.data
            const count = idata.length;
            const countWidth = imagedata.width * 4;
            console.log(count)
            for (let i = 0, y = 0; i < count; i = i + 4) {
                if (i != 0 && i % countWidth == 0) {
                    y++;
                }
                // console.log([idata[i], idata[i + 1], idata[i + 2], idata[i + 3]])
                if (
                    idata[i] !== 255
                    || idata[i + 1] !== 255
                    || idata[i + 2] !== 255
                    || idata[i + 3] !== 255
                ) {
                    const x = (i - countWidth * y) / 4;
                    if (left === -1) {
                        left = x
                    } else {
                        if (left > x) {
                            left = x;
                        }
                        if (right === -1) {
                            right = x
                        } else if (right < x) {
                            right = x
                        }
                    }
                    if (top === -1) {
                        top = y;
                    } else {
                        if (bottom === -1) {
                            bottom = y
                        } else if (bottom < y) {
                            bottom = y
                        }
                    }
                }
            }
            return [left, top, right - left, bottom - top]
        }

        async function segmentTypeHandle(maskImageData: ImageData, block: BlockItem) {
            const idata = maskImageData.data
            const count = idata.length;
            if (segmentOpera === 'mask') {
                for (let i = 0; i < count; i = i + 4) {
                    // console.log([idata[i], idata[i + 1], idata[i + 2], idata[i + 3]])
                    if (idata[i] > 0) {
                        idata[i] = block.color[0];
                        idata[i + 1] = block.color[1]
                        idata[i + 2] = block.color[2]
                        idata[i + 3] = 178; // 透明度
                    } else {
                        idata[i + 3] = 0
                    }
                }
            } else {
                for (let i = 0; i < count; i = i + 4) {
                    // console.log([idata[i], idata[i + 1], idata[i + 2], idata[i + 3]])
                    if (idata[i] > 0) {
                        idata[i + 3] = 0; // 透明度
                    } else {
                        idata[i] = 255
                        idata[i + 1] = 255
                        idata[i + 2] = 255
                        idata[i + 3] = 255
                    }
                }
            }

            const canvas = canvasRef.value
            const ctx = canvas.getContext('2d');

            // ctx.globalAlpha = 0.5;
            // convert image data to image bitmap
            // let imageBitmap = await createImageBitmap(maskImageData, { resizeWidth: canvas.width, resizeHeight: canvas.height, resizeQuality: "medium" });
            let imageBitmap = await createImageBitmap(maskImageData);
            // canvas.width = maskImageData.width;
            // canvas.height = maskImageData.height;
            ctx.drawImage(imageBitmap, 0, 0);

            if (segmentOpera === 'crop') {
                const locate = cropImage(ctx.getImageData(0, 0, canvas.width, canvas.height));
                const imagedata = ctx.getImageData(locate[0], locate[1], locate[2], locate[3])
                imageBitmap = await createImageBitmap(imagedata);

                const tmpCanvas = document.createElement('canvas');
                const tmpCtx = tmpCanvas.getContext('2d');
                // 设置canvas的尺寸并将复制的ImageData绘制到canvas上
                tmpCanvas.width = locate[2]
                tmpCanvas.height = locate[3]
                tmpCtx?.drawImage(imageBitmap, 0, 0);
                block.segmentImageBase64 = tmpCanvas.toDataURL()

                ctx.clearRect(0, 0, canvas.width, canvas.height);
                ctx.putImageData(imageImageData, 0, 0, 0, 0, canvas.width, canvas.height);
                previewHandle(imagedata)
            } else {
                const tmpCanvas = document.createElement('canvas');
                const tmpCtx = tmpCanvas.getContext('2d');
                // 设置canvas的尺寸并将复制的ImageData绘制到canvas上
                tmpCanvas.width = canvas.width;
                tmpCanvas.height = canvas.height;
                tmpCtx?.drawImage(imageBitmap, 0, 0);
                block.segmentImageBase64 = tmpCanvas.toDataURL()
            }
            block.segmentImage = canvas.toDataURL();
            block.segmentImageBitmap = imageBitmap;
        }

        function previewHandle(imagedata: ImageData) {
            if (previewRef.value) {
                const tagName = previewRef.value.tagName
                if (tagName === 'CANVAS') {
                    const canvas = previewRef.value
                    const ctx = canvas.getContext('2d')
                    canvas.width = imagedata.width;
                    canvas.height = imagedata.height;
                    ctx.putImageData(imagedata, 0, 0, 0, 0, imagedata.width, imagedata.height);
                } else if (tagName === 'IMG') {
                    const tmpCanvas = document.createElement('canvas');
                    const tmpCtx = tmpCanvas.getContext('2d');
                    // 设置canvas的尺寸并将复制的ImageData绘制到canvas上
                    tmpCanvas.width = imagedata.width;
                    tmpCanvas.height = imagedata.height;
                    tmpCtx?.putImageData(imagedata, 0, 0, 0, 0, imagedata.width, imagedata.height);
                    previewRef.value.src = tmpCanvas.toDataURL()
                }
            }
        }

        function setMaxSize(width: number, height: number) {
            MAX_WIDTH = width;
            MAX_HEIGHT = height
        }

        function setSegmentOpera(tempSegmentOpera: SegmentOperaType) {
            segmentOpera = tempSegmentOpera
        }

        function setPointOpera(type: PointOperaType) {
            pointOpera = type
        }

        return {
            canvasRef,
            previewRef,
            imageHandle,
            imageRenderHandle,
            clickHandle,
            setPointOpera,
            setSegmentOpera,
            setMaxSize,
        }
    }

    return {
        _useBlocks,
        _useModel,
        _useMediaUpload,
        _useFrames,
    }
}

• segment.d.ts

import * as ort from 'onnxruntime-web';
type xy = {
    x: number;
    y: number;
};

export type BlockItemType = "mask" | "panel"

export interface BlockItem {
    id: string;
    type: BlockItemType,// mask遮罩，panel切图
    hasPoint: boolean; // 是否操作
    color: number[]; // 颜色 rgba
    pointModel: number[]; // 操作模式
    pointXY: number[]; // 操作点
    resource: string;
    resourceType: string;
    imgBase64: string; // 图片base64
    imgData: ImageData | undefined;
    result: Api.AiTools.SegmentFrame | null;
    zIndex: number;
    segmentImage: string;// 图片遮罩
    segmentImageBase64: string;// 图片遮罩base64
    segmentImageBitmap: ImageBitmap | null;// 图片遮罩位图
    imageEmbeddings?: ort.Tensor | undefined;
}
export interface ModelMapType {
    sam_b: string[];
    mobile_sam: string[];
}

export interface ProviderType extends ort.InferenceSession.ExecutionProviderOption {
    deviceType?: string;
    powerPreference?: string;
}

export interface ConfigType {
    model: string;
    provider: ProviderType;
    device: string;
    threads: number;
    clear_cache: boolean;
}

export interface UploadType {
    type: number; // 1是主视频，2是每一帧的蒙版视频，3是普通图片
    blockIndex: number;
}

export interface FrameItem {
    id: string;
    type: number; // UploadType.type
    sec: number;// 视频第几秒
    base64: string;// 图片BASE64
    imageData: ImageData | undefined;
    imageEmbeddings: ort.Tensor | undefined;
}

export type PointOperaType = 'plus' | 'cover';// 追加/覆盖

export type SegmentOperaType = 'mask' | 'crop';// 遮罩/截取

• 使用

<script setup lang="ts">
import { ref } from 'vue';
import useSegment from "@/hooks/ai/segment"
import { $t } from '@/locales';

const segment = useSegment();
const {
  videoUploadRef, videoUploadLoading, fileBase64, frameBase64, uploadHandle } = segment._useMediaUpload
const { blockList, blockIndex, blockAddHandle, blockDelHandle, blockShowHandle, } = segment._useBlocks;
const { canvasRef, clickHandle } = segment._useModel

const MediaLabelRadioRef = ref<InstanceType<typeof MediaLabelRadio>>()

async function imageClickHandle(e: MouseEvent) {
  clickHandle(e, MediaLabelRadioRef.value?.getValue() as number)
}

</script>

<template>
  <div>
    <n-layout>
      <n-layout has-sider>
        <n-layout-sider bordered content-class="p-12px" :default-collapsed="true" :collapsed-width="0"
          :show-collapsed-content="false" :width="160" show-trigger="arrow-circle">
          <n-spin :show="videoUploadLoading">
            <n-flex vertical>
              <n-button type="primary" @click="uploadHandle(1)">{{ $t('tapai.uploadVideo') }}</n-button>
              <n-button v-show="frameBase64 !== ''" type="primary" @click="blockAddHandle({})">{{ $t('tapai.addMask')
                }}</n-button>
              <n-button v-show="frameBase64 !== ''" type="primary" @click="renderVideo">{{ $t('tapai.renderVideo')
                }}</n-button>
            </n-flex>
          </n-spin>
        </n-layout-sider>
        <n-layout-content content-class="p-12px">
          <input ref="videoUploadRef" type="file" class="hidden" />
          <n-spin :show="videoUploadLoading">
            <div class="h-360px flex flex-row flex-items-center flex-justify-center">
              <n-empty v-show="frameBase64 === ''" size="large" description="请不要上传大小超过100M，时长超过10M中的视频">
                <template #extra>
                  <n-button size="small" @click="uploadHandle(1)">{{ $t('tapai.uploadVideo') }}</n-button>
                </template>
              </n-empty>
              <div v-show="frameBase64 != ''" class="h-100% position-relative">
                <canvas @click="imageClickHandle" ref="canvasRef"></canvas>
              </div>
            </div>
          </n-spin>
        </n-layout-content>
      </n-layout>
      <n-layout-footer bordered>
        <n-spin v-show="frameBase64 != ''" :show="videoUploadLoading">
          <div class="p-y-12px flex flex-row flex-justify-center">
            <div
              class="flex flex-col border-solid border-0px bg-#fff dark:bg-#2d2d32 cursor-pointer h-120px w-150px mr-10px position-relative flex-items-center flex-justify-around">
              <n-button text @click="blockShowHandle()">{{ $t('tapai.showAll') }}</n-button>
              <n-button text @click="blockAddHandle({})">{{ $t('tapai.addMask') }}</n-button>
            </div>
            <n-scrollbar x-scrollable>
              <div class="flex flex-row h-120px">
                <div v-for="(item, index) in blockList" :key="item.id"
                  class="border-solid border-0px cursor-pointer h-100% w-150px mr-10px position-relative bg-#fff dark:bg-#2d2d32 flex flex-col flex-items-center flex-justify-center"
                  :class="{ 'border-red': blockIndex === index }" @click="blockShowHandle(index)">
                  <div class="h-100px w-100% position-relative flex flex-items-center flex-justify-center">
                    <img v-if="item.segmentImage === ''" :src="frameBase64" class="w-100% h-100% object-contain" />
                    <!-- <img class="w-100% position-absolute top-50% left-50% translate--50%"
                      :src="item.result?.segmentImage" /> -->
                    <img v-else class="w-100% h-100% object-contain" :src="item.segmentImage" />
                  </div>
                  <n-popconfirm :show-icon="false" :positive-text="null" :negative-text="null">

                    <template #trigger>
                      <n-button text>{{ $t('tapai.operation') }}</n-button>
                    </template>
                    <n-space vertical>
                      <n-button text type="primary" size="tiny" @click.stop="uploadHandle(2, index)">
                        {{ item.resource != '' ? $t('tapai.reUpload') : $t('tapai.uploadResource') }}
                      </n-button>
                      <n-button :loading="videoUploadLoading" text type="error" size="tiny"
                        @click.stop="blockDelHandle(index)">
                        {{ $t('tapai.delMask') }}</n-button>
                    </n-space>
                  </n-popconfirm>
                </div>
              </div>
            </n-scrollbar>
          </div>
        </n-spin>
      </n-layout-footer>
    </n-layout>
  </div>
</template>

<style scoped></style>

• electron+electron forge+vite+react+ts
  • 环境说明
  • 开始构建

electron+electron forge+vite+react+ts

How to create an Electron app with React, TypeScript, and Electron Forge

环境说明

1. 安装最新的node环境。这里使用 18.16.0

开始构建

1. 使用 electron forge 搭建 vite 集成的框架

npm init electron-app@latest my-new-app -- --template=vite

2. 集成 react 依赖

npm install --save react react-dom
npm install --save-dev @types/react @types/react-dom
npm install --save-dev @vitejs/plugin-react

3. 集成tailwind css

   1. 安装 tailwind css

   npm install -D tailwindcss postcss autoprefixer
   npx tailwindcss init -p
   

   2. 配置 tailwind.config.js 。如果没有在根目录下创建

   /** @type {import('tailwindcss').Config} */
   export default {
     content: [
       "./index.html",
       "./src/**/*.{js,ts,jsx,tsx}",
     ],
     theme: {
       extend: {},
     },
     plugins: [],
   }
   

   3. 在 index.css 添加如下代码，或者全局引用的css文件

   @tailwind base;
   @tailwind components;
   @tailwind utilities;
   

4. 集成 react-router v6

npm install react-router-dom localforage match-sorter sort-by

• electron: Running postinstall script, failed in 44.4s

electron: Running postinstall script, failed in 44.4s

1. 配置镜像源

   # 配置
   pnpm config set electron_mirror https://npm.taobao.org/mirrors/electron/
   pnpm config set electron_mirror http://npm.taobao.org/mirrors/electron/
   
   
   # 删除 
   pnpm config delete electron_mirror
   

2. 执行安装

   pnpm install 
   

• 安装
  • 问题记录
    • TypeError: cb.apply is not a function
• 常用指令
• 部署
  • nginx映射

安装

1. 安装 node 12+

2. 配置淘宝镜像

   npm config set registry https://registry.npm.taobao.org
   

3. 安装全局 gitbook-cli

   npm install gitbook-cli -g
   

问题记录

TypeError: cb.apply is not a function

找到对应的文件 D:\dev-tools\nvm-noinstall\v14.18.2\node_modules\gitbook-cli\node_modules\npm\node_modules\graceful-fs\polyfills.js 注释下面几行代码

  // fs.stat = statFix(fs.stat)
  // fs.fstat = statFix(fs.fstat)
  // fs.lstat = statFix(fs.lstat)

常用指令

1. 初始化 gitbook。

   • 初始化项目，按照 gitbook 规范会自动创建 README.md 和 SUMMARY.md 两个文件，具体用途见下文.
   • 其实 SUMMARY.md 是电子书的章节目录，gitbook 会初始化相应的文件目录结构，所以主要是用于开发初始阶段.

   gitbook init
   

2. 启动 gitbook

   • 启动本地服务，程序无报错则可以在浏览器预览电子书效果: http://localhost:4000
   • 由于能够实时预览电子书效果，并且大多数开发环境搭建在本地而不是远程服务器中，所以主要用于开发调试阶段.

   gitbook serve
   

3. 构建 gitbook 静态网页

   • 构建静态网页而不启动本地服务器，默认生成文件存放在 _book/ 目录，当然输出目录是可配置的，暂不涉及，见高级部分.
   • 输出静态网页后可打包上传到服务器，也可以上传到 github 等网站进行托管，因而主要用于发布准备阶段.

   gitbook build