首发公众号:【赵侠客】

引言

我相信作为一名java开发者你一定听过或者看过类似《你还在用for循环遍历List吗？》、《JDK8都10岁了，你还在用for循环遍历List吗？》这类鄙视在Java中使用for循环遍历List的水文。这类文章说的其实就是使用Java8中的Stream.foreach()来遍历元素，在技术圈感觉使用新的技术就高大上，开发者们也都默许接受新技术的很多缺点，而使用老的技术或者传统的方法就会被人鄙视，被人觉得Low，那么使用forEach()真的很高大上吗？它真的比传统的for循环好用吗？本文就列出10大推荐使用for而不是forEach()的理由。

理由一、for性能更好

在我的固有认知中我是觉得for的循环性能比Stream.forEach()要好的，因为在技术界有一条真理：

越简单越原始的代码往往性能也越好

而且搜索一些文章或者大模型都是这么觉得的，可时我并没有找到专业的基准测试证明此结论。那么实际测试情况是不是这样的呢？虽然这个循环的性能差距对我们的系统性能基本上没有影响，不过为了证明for的循环性能真的比Stream.forEach()好我使用基准测试用专业的实际数据来说话。我的测试代码非常的简单，就对一个List<Integer> ids分别使用for和Stream.forEach()遍历出所有的元素，以下是测试代码：

@State(Scope.Thread)

public class ForBenchmark {

    private List<Integer> ids ;

    @Setup

    public void setup() {

        ids = new ArrayList<>();

        //分别对10、100、1000、1万、10万个元素测试

        IntStream.range(0, 10).forEach(i -> ids.add(i));

    }

    @TearDown

    public void tearDown() {

        ids = new ArrayList<>();

    }

    @Benchmark

    public void testFor() {

        for (int i = 0; i <ids.size() ; i++) {

            Integer id = ids.get(i);

        }

    }



    @Benchmark

    public void testStreamforEach() {

        ids.stream().forEach(x->{

            Integer id=x;

        });

    }



    @Test

    public void testMyBenchmark() throws Exception {

        Options options = new OptionsBuilder()

                .include(ForBenchmark.class.getSimpleName())

                .forks(1)

                .threads(1)

                .warmupIterations(1)

                .measurementIterations(1)

                .mode(Mode.Throughput)

                .build();

        new Runner(options).run();

    }

}

我使用ArrayList分对10、100、1000、1万，10万个元素进行测试，以下是使用JMH基准测试的结果，结果中的数字为吞吐量，单位为ops/s，即每秒钟执行方法的次数：

从使用Benchmark基准测试结果来看使用for遍历List比Stream.forEach性能在元素越小的情况下优势越明显，在10万元素遍历时性能反而没有Stream.forEach好了，不过在实际项目开发中我们很少有超过10万元素的遍历。

所以可以得出结论：

在小List(万元素以内)遍历中for性能要优于Stream.forEach

理由二、for占用内存更小

Stream.forEach()会占用更多的内存，因为它涉及到创建流、临时对象或者对中间操作进行缓存。for 循环则更直接，操作底层集合，通常不会有额外的临时对象。可以看如下求和代码，运行时增加JVM参数-XX:+PrintGCDetails -Xms4G -Xmx4G输出GC日志：

• 使用for遍历

List<Integer> ids = IntStream.range(1,10000000).boxed().collect(Collectors.toList());

int sum = 0;

for (int i = 0; i < ids.size(); i++) {

    sum +=ids.get(i);

}

System.gc();

//GC日志

[GC (System.gc()) [PSYoungGen: 392540K->174586K(1223168K)] 392540K->212100K(4019712K), 0.2083486 secs] [Times: user=0.58 sys=0.09, real=0.21 secs]                               

从GC日志中可以看出，使用for遍历List在GC回收前年轻代使用了392540K，总内存使用了392540K，回收耗时0.20s

• 使用stream

List<Integer> ids = IntStream.range(1,10000000).boxed().collect(Collectors.toList());

int sum = ids.stream().reduce(0,Integer::sum);

System.gc();

//GC日志

[GC (System.gc()) [PSYoungGen: 539341K->174586K(1223168K)] 539341K->212118K(4019712K), 0.3747694 secs] [Times: user=0.55 sys=0.83, real=0.38 secs]                              

从GC日志中可以看出，回收前年轻代使用了539341K，总内存使用了539341K，回收耗时0.37s ，从内存占用情况来看使用for会比Stream.forEach()占用内存少37%，而且Stream.foreach() GC耗时比for多了85%。

理由三、for更易控制流程

我们使用for遍历List可以很方便的使用break、continue、return来控制循环，而使用Stream.forEach在循环中是不能使用break、continue，特别指出的使用return是无法中断Stream.forEach循环的，如下代码：

List<Integer> ids = IntStream.range(1,4).boxed().collect(Collectors.toList());

ids.stream().forEach(i->{

    System.out.println(""+i);

    if(i>1){

        return;

    }

});

System.out.println("==");

for (int i = 0; i < ids.size(); i++) {

    System.out.println(""+ids.get(i));

    if(ids.get(i)>1){

        return;

    }

}

输出：

forEach-1

forEach-2

forEach-3

==

for-1

for-2

从输出结果可以看出在Stream.forEach中使用return后循环还会继续执行的，而在for循环中使用return将中断循环。

理由四、for访问变量更灵活

这点我想是很多人在使用Stream.forEach中比较头疼的一点，因为在Stream.forEach中引用的变量必须是final类型，也就是说不能修改forEach循环体之外的变量，但是我们很多业务场景就是修改循环体外的变量，如以下代码:

Integer sum=0;

for (int i = 0; i < ids.size(); i++) {

    sum++;

}



ids.stream().forEach(i -> {

    //报错

    sum++;

});

像上面的这样的代码在实际中是很常见的，sum++在forEach中是不被允许的，有时为了使用类似的方法我们只能把变量变成一个引用类型：

AtomicReference<Integer> sum= new AtomicReference<>(0);

ids.stream().forEach(i -> {

    sum.getAndSet(sum.get() + 1);

});

所以在访问变量方面for会更加灵活。

理由五、for处理异常更方便

这一点也是我使用forEach比较头疼的，在forEach中的Exception必须要捕获处理，如下代码：

public void testException() throws Exception {

  List<Integer> ids = IntStream.range(1, 4).boxed().collect(Collectors.toList());

  for (int i = 0; i < ids.size(); i++) {

      //直接抛出Exception

      System.out.println(div(i, i - 1));

  }



  ids.stream().forEach(x -> {

      try {

          //必须捕获Exception

          System.out.println(div(x, x - 1));

      } catch (Exception e) {

          throw new RuntimeException(e);

      }

  });

}



private Integer div(Integer a, Integer b) throws Exception {

    return a / b;

}

我们在循环中调用了div()方法，该方法抛出了Exception，如果是使用for循环如果不想处理可以直接抛出，但是使用forEach就必须要自己处理异常了，所以for在处理异常方面会更加灵活方便。

理由六、for能对集合添加、删除

在for循环中可以直接修改原始集合（如添加、删除元素），而 Stream 不允许修改基础集合，会抛出 ConcurrentModificationException，如下代码：

List<Integer> ids = IntStream.range(0, 4).boxed().collect(Collectors.toList());

for (int i = 0; i < ids.size(); i++) {

    if(i<1){

        ids.add(i);

    }

}

System.out.println(ids);



List<Integer> ids2 = IntStream.range(0, 4).boxed().collect(Collectors.toList());

ids2.stream().forEach(x -> {

    if(x<1){

        ids2.add(x);

    }

});

System.out.println(ids2);

输出：

[0, 1, 2, 3, 0]

java.util.ConcurrentModificationException

如果你想在循环中添加或者删除元素foreach是无法完成了，所以for处理集合更方便。

理由七、for Debug更友好

Stream.forEach()使用了Lambda表达示，一行代码可以搞定很多功能，但是这也给Debug带来了困难，如下代码：

List<Integer> ids = IntStream.range(0, 4).boxed().collect(Collectors.toList());

for (int i = 0; i < ids.size(); i++) {

    System.out.println(ids.get(i));

}

List<Integer> ids2 = IntStream.range(0, 4).boxed().collect(Collectors.toList());

ids2.stream().forEach(System.out::println);

以下是DeBug截图：

我们可以看出使用for循环Debug可以一步一步的跟踪程序执行步骤，但是使用forEach却做不到，所以for可以更方便的调试你的代码，让你更快捷的找到出现问题的代码。

理由八、for代码可读性更好

Lambda表达示属于面向函数式编程，主打的就是一个抽象，相比于面向对象或者面向过程编程代码可读性是非常的差，有时自己不写的代码过段时间后自己都看不懂。就比如我在文章《解密阿里大神写的天书般的Tree工具类，轻松搞定树结构！》一文中使用函数式编程写了一个Tree工具类，我们可以对比一下面向过程和面向函数式编程代码可读性的差距：

• 使用for面向过程编程代码：

 public static List<MenuVo> makeTree(List<MenuVo> allDate,Long rootParentId) {

      List<MenuVo> roots = new ArrayList<>();

      for (MenuVo menu : allDate) {

          if (Objects.equals(rootParentId, menu.getPId())) {

              roots.add(menu);

          }

      }

      for (MenuVo root : roots) {

           makeChildren(root, allDate);

      }

      return roots;

  }

  public static MenuVo makeChildren(MenuVo root, List<MenuVo> allDate) {

      for (MenuVo menu : allDate) {

          if (Objects.equals(root.getId(), menu.getPId())) {

              makeChildren(menu, allDate);

              root.getSubMenus().add(menu);

          }

      }

      return root;

  }

• 使用forEach面向函数式编程代码：

public static <E> List<E> makeTree(List<E> list, Predicate<E> rootCheck, BiFunction<E, E, Boolean> parentCheck, BiConsumer<E, List<E>> setSubChildren) {

      return list.stream().filter(rootCheck).peek(x -> setSubChildren.accept(x, makeChildren(x, list, parentCheck, setSubChildren))).collect(Collectors.toList());

}

private static <E> List<E> makeChildren(E parent, List<E> allData, BiFunction<E, E, Boolean> parentCheck, BiConsumer<E, List<E>> children) {

    return allData.stream().filter(x -> parentCheck.apply(parent, x)).peek(x -> children.accept(x, makeChildren(x, allData, parentCheck, children))).collect(Collectors.toList());

}

对比以上两段代码，可以看出面向过程的代码思路非常的清晰，基本上可以一眼看懂代码要做什么，反观面向函数式编程的代码，我想大都人一眼都不知道代码在干什么的，所以使用for的代码可读性会更好。

理由九、for更好的管理状态

for循环可以轻松地在每次迭代中维护状态，这在Stream.forEach中可能需要额外的逻辑来实现。这一条可理由三有点像，我们经常需要通过状态能控制循环是否执行，如下代码：

boolean  flag = true;

for (int i = 0; i < 10; i++) {

    if(flag){

        System.out.println(i);

        flag=false;

    }

}



AtomicBoolean flag1 = new AtomicBoolean(true);

IntStream.range(0, 10).forEach(x->{

    if (flag1.get()){

        flag1.set(false);

        System.out.println(x);

    }

});

这个例子说明了在使用Stream.forEach时，为了维护状态，我们需要引入额外的逻辑，如使用AtomicBoolean，而在for循环中，这种状态管理是直接和简单的。

理由十、for可以使用索引直接访问元素

在某些情况下，特别是当需要根据元素的索引（位置）来操作集合中的元素时，for就可以直接使用索引访问了。在Stream.forEach中就不能直接通过索引访问，比如我们需要将ids中的数字翻倍：

List<Integer> ids = IntStream.range(0, 4).boxed().collect(Collectors.toList());

for (int i = 0; i < ids.size(); i++) {

   ids.set(i,i*2);

}



List<Integer> ids2 = IntStream.range(0, 4).boxed().collect(Collectors.toList());

ids2=ids2.stream().map(x->x*2).collect(Collectors.toList());

我们使用for循环来遍历这个列表，并在每次迭代中根据索引i来修改列表中的元素。这种操作直接且直观。而使用Stream.foreach()不能直接通过索引下标访问元素的，只能将List转换为流，然后使用map操作将每个元素乘以2，最后，我们使用Collectors.toList()将结果收集回一个新的List。

总结

本文介绍了在实际开发中更推荐使用for循环而不是Stream.foreach()来遍历List的十大理由，并给出了具体的代码和测试结果，当然这并不是说就一定要使用传统的for循环，要根据自己的实际情况来选择合适的方法。通过此案件也想让读者明白在互联网世界中你所看到的东西都是别人想让你看到的，这个世界是没有真相的，别人想让你看到的就是所谓的”真相“，做为吃瓜群众一定不能随波逐流，要有鉴别信息真假的能力和培养独立思考的能力。

ArrayList扩容原理（源码理解）

从源码角度对ArrayList扩容原理进行简介，我们可以更深入地了解其内部实现和工作原理。以下是基于Java标准库中ArrayList扩容原理源码的简介

1、类定义与继承关系

ArrayList在Java中的定义如下：

public class ArrayList<E> extends AbstractList<E>

        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

{

ArrayList是一个泛型类，继承自AbstractList并实现了List接口，同时还实现了RandomAccess、Cloneable和Serializable接口。这 些接口分别表示ArrayList支持随机访问、可以被克隆以及可以被序列化。

2、核心成员变量（牢记）

elementData：是实际存储元素的数组，它可以是默认大小的空数组（当没有指定初始容量且没有添加元素 时），也可以是用户指定的初始容量大小的数组，或者是在扩容后新分配的数组。
size：表示数组中当前元素的个数。

transient Object[] elementData; //数组



private int size;               //元素个数

DEFAULT_CAPACITY是ArrayList的默认容量，当没有指定初始容量时，会使用这个值。

    //默认初始容量。

private static final int DEFAULT_CAPACITY = 10;

EMPTY_ELEMENTDATA表示空数组。

DEFAULTCAPACITY_EMPTY_ELEMENTDATA也表示空数组，为了区分而命名不同。

    

    //用于创建空对象的共享空数组实例。

private static final Object[] EMPTY_ELEMENTDATA = {};

   

    //用于默认大小的空数组实例的共享空数组实例。我们将它与EMPTY_ELEMENTDATA区分开来，以便在添加第一个元素时知道要扩容多少。

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

3、构造方法

ArrayList提供了多个构造方法，包括无参构造方法、指定初始容量的构造方法。
java

   

//无参构造



     //构造一个初始容量为10的空数组。    

public ArrayList() {

    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}

     

//有参构造



     //构造具有指定初始容量的空数组。     

public ArrayList(int initialCapacity) {                    			//构建有参构造方法

    if (initialCapacity > 0) {                             			//如果传入参数>0

        this.elementData = new Object[initialCapacity];    			//创建一个数组，大小为传入的参数

    } else if (initialCapacity == 0) {                     			//如果传入的参数=0

        this.elementData = EMPTY_ELEMENTDATA;              			//得到一个空数组

    } else {                                               			//否则

        throw new IllegalArgumentException("Illegal Capacity: "+    //抛出异常

                                               initialCapacity);        

    }

}

这里可以看到无参构造方法用的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA表示空数组，而有参构造方法中当传入参数=0，用的是EMPTY_ELEMENTDATA表示空数组。

4、扩容机制

具体流程：

1、开始添加元素前先判断当前数组容量是否足够（ensureCapacityInternal（）方法），这里有个特例就是添加第一个元素时要先将数组扩容为初始容量大小（calculateCapacity（）方法）。如果足够就向数组中添加元素。

2、如果当前数组容量不够，开始计算新容量的大小并赋值给新数组，复制原始数组中的元素到新数组中（grow（）方法）

流程图如下：

从向ArrayList添加元素来观察底层源码是如何实现的

观察add（）方法，其中提到一个不认识的ensureCapacityInternal（）方法，把他看做用来判断数组容量是否足够的方法,判断完后将元素添加到数组中

public boolean add(E e) {

    ensureCapacityInternal(size + 1);  //判断数组容量是否足够，传入的一个大小为（size+1）的参数

    elementData[size++] = e;           //添加元素

    return true;

}

现在来看上面add（）方法提到的ensureCapacityInternal（）方法, 进入查看源码,又出现两个不认识的方法: calculateCapacity（）方法和ensureExplicitCapacity（）方法。

private void ensureCapacityInternal(int minCapacity) {       //这里minCapacity大小就是上面传入参数：size+1

        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

    }

```

calculateCapacity（）方法：里面有一个判断语句，判断当前数组是不是空数组。如果是空数组那就将数组容量初始化为10，如果不是空数组，那就直接返回minCapacity。
ensureExplicitCapacity（）方法：重点观察判断语句，将calculateCapacity（）方法中传进来的minCapacity与原数组的长度作比较，当原数组长度小于minCapacity的值就开始进行扩容。

//    calculateCapacity方法

private static int calculateCapacity(Object[] elementData, int minCapacity) {

           //判断数组是否为空

    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {  

           //数组为空时比较，DEFAULT_CAPACITY=10，minCapacity=size+1，DEFAULT_CAPACITY一定比minCapacity大，所以空数组容量初始化为10

        return Math.max(DEFAULT_CAPACITY, minCapacity);      

    }          

           //数组不为空，minCapacity=size+1，相当于不变

    return minCapacity;

         

}



//-------------------------------------------分割线-----------------------------------------------------//





//    ensureExplicitCapacity方法

private void ensureExplicitCapacity(int minCapacity) {//这里的minCapacity是上面传过来的

    modCount++;   

    if (minCapacity - elementData.length > 0)         //判断数组长度够不够，不够才扩

        grow(minCapacity);

}

举例

前面都是判断数组要不要进行扩容，下面内容就是如何扩容。

首先，grow（）方法是扩容的入口，它根据当前容量计算新容量，并调用Arrays.copyOf方法复制数组。hugeCapacity（）方法用于处理超大容量的情况，确保不会超出数组的最大限制。

*   这一步是为了先确定扩容的大小，再将元素复制到新数组中





private void grow(int minCapacity) {        

    int oldCapacity = elementData.length;                //定义一个oldCapacity接收当前数组长度

    int newCapacity = oldCapacity + (oldCapacity >> 1);  //定义一个newCapacity接收oldCapacity1.5倍的长度

    if (newCapacity - minCapacity < 0)                   //如果newCapacity长度<minCapacity

        newCapacity = minCapacity;                       //将minCapacity赋值给newCapacity

    if (newCapacity - MAX_ARRAY_SIZE > 0)                //如果newCapacity长度>最大的数组长度

        newCapacity = hugeCapacity(minCapacity);         //将进行hugeCapacity方法以后的值赋值给newCapacity

    elementData = Arrays.copyOf(elementData, newCapacity);//开始扩容

}

查看hugeCapacity（）方法 (防止扩容后的数组太大了)
MAX_ARRAY_SIZE 理解为：快接近integer的最大值了。
Integer.MAX_VALUE 理解为：integer的最大值。

private static int hugeCapacity(int minCapacity) {

    if (minCapacity < 0)                             //如果minCapacity<0

        throw new OutOfMemoryError();                //抛出异常

    return (minCapacity > MAX_ARRAY_SIZE) ?          //返回一个值，判断minCapacity是否大于MAX_ARRAY_SIZE

        Integer.MAX_VALUE :                          //大于就返回 Integer.MAX_VALUE

        MAX_ARRAY_SIZE;                              //小于就返回 MAX_ARRAY_SIZE

}



```

最后一步，了解是如何如何将元素添加到新数组的

查看Arrays.copyof源代码

用于将一个原始数组（original）复制到一个新的数组中，新数组的长度（newLength）可以与原始数组不同。



public static <T> T[] copyOf(T[] original, int newLength) {

    return (T[]) copyOf(original, newLength, original.getClass());

}

查看copyof（）方法 (判断新数组与原数组类型是否一致)

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {

    @SuppressWarnings("unchecked")

    T[] copy = ((Object)newType == (Object)Object[].class)

        ? (T[]) new Object[newLength]

        : (T[]) Array.newInstance(newType.getComponentType(), newLength);

    System.arraycopy(original, 0, copy, 0,

                     Math.min(original.length, newLength));

    return copy;

}

开始复制原数组的元素到新数组中

将一个数组`src`的从索引`srcPos`开始的`length`个元素复制到另一个数组`dest`的从索引`destPos`开始的位置。



public static native void arraycopy(Object src,  int  srcPos,

                                    Object dest, int destPos,

                                    int length);

                                            

                                            参数说明：

参数说明：

• src：原数组，类型为Object，表示可以接受任何类型的数组。


• srcPos：原数组的起始索引，即从哪个位置开始复制元素。


• dest：新数组，类型为Object，表示可以接受任何类型的数组。


• destPos：新数组的起始索引，即从哪个位置开始粘贴元素。


• length：要复制的元素数量。

从宏观上来说，ArrayList展现的是一种动态数组的扩容，当数组中元素个数到达一定值时数组自动会扩大容量，以方便元素的存放。

从微观上来说，ArrayList是在当数组中元素到达一定值时，去创建一个大小为原数组1.5倍容量的新数组，将原数组的元素复制到新数组当中，抛弃原数组。

在数据库查询中，count(*) 和 count(1) 是两个常见的计数表达式，都可以用来计算表中行数。

很多人都以为 count(*) 效率更差，主要是因为在早期的数据库系统中，count(*) 可能会被实现为对所有列进行扫描，而 count(1) 则可能只扫描单个列。

但事实真是如此吗？

执行原理

先来看看这两者的执行原理：

count(*) 查询所有满足条件的行，包括包含空值的行。在大多数数据库中，count(*) 会直接统计行数，并不会实际去读取每行中的详细数据，因为数据库引擎会自行优化该计数操作，以提高执行效率。

count(1) 也是计算表中的行数，这里的 1 是一个常量，只是作为一个占位符，并没有实际的含义。与 count(*) 类似，数据库引擎也会对 count(1) 进行优化，以快速确定表中的行数。

count(*) 和 count(1) 的 性能差异

再说性能，在大多数数据库中，其实 count(*) 和 count(1) 的性能非常相似，甚至可以说没有区别，这是因为大多数数据库引擎对这两种计数方式进行相同的优化，并没有明显的执行效率上的差异。但是在特殊情况下可能会有细微的差异，造成这种差异的原因通常有以下几种：

1. 数据库引擎的差异

不同的数据库引擎可能对 count(*) 和 count(1) 采取不同的优化策略，这在某些情况下可能会导致两种计数方式的性能差异。例如：

• SQL Server：在某些版本的 SQL Server 中，count(1) 在特定的查询计划中可能稍微快一些，但这种差异通常微乎其微，只有在处理非常大的表或复杂查询时才会显现出来。


• MyISAM 引擎：在不附加任何 WHERE 查询条件的情况下，统计表的总行数会非常快，因为 MyISAM 会用一个变量存储表的行数。如果没有 WHERE 条件，查询语句将直接返回该变量值，使得速度很快。然而，只有当表的第一列定义为 NOT NULL 时，count(1) 才能得到类似的优化。如果有 WHERE 条件，则该优化将不再适用。


• InnoDB 引擎：尽管 InnoDB 表也存储了一个记录行数的变量，但遗憾的是，这个值只是一个估计值，并无实际意义。在 Innodb 引擎下， count(*) 和 count(1) 哪个快呢？结论是：这俩在高版本的 MySQL 是没有什么区别的，也就没有 count(1) 会比 count(*) 更快这一说了。

另外，还有一个问题是 Innodb 是通过主键索引来统计行数的吗？

如果该表只有一个主键索引，没有任何二级索引的情况下，那么 count(*) 和 count(1) 都是通过通过主键索引来统计行数的。

如果该表有二级索引，则 count(*) 和 count(1) 都会通过占用空间最小的字段的二级索引进行统计。

2. 索引的影响

如果表上有合适的索引，无论是count(1) 还是 count(*) 都可以利用索引来快速确定行数，而不必扫描整个表。在这种情况下，两者的性能差异通常可以忽略不计。例如，如果有一个基于主键的索引，数据库可以快速通过索引确定表中的行数，而无需读取表中的每一行数据。

实战分析

话不多说，下面我们通过实验来验证上述理论：

第一步：创建表与插入数据

用 Chat2DB 给我们生成一个创建表的 sql 语句，直接用自然语言描述我们想要的字段名和字段类型即可生成建表语句，也可以生成测试数据。

然后用存储过程向 student 表中插入两万条测试数据。（存储过程执行两次）

插入数据后的 student 表如下：

这个时候执行 select count(*) from student 和 select count(1) from student 可以看到解释器的结果如下，耗时均为 2 ms（两者一致，所以就只截了一张图），两者都用主键索引进行行数的统计：

第二步：执行计数查询

创建二级索引 IDCard 进行统计结果如下：

可以看出用二级索引进行统计的解释器结果还是一致。

结论

综上所述，count(1) 和 count(*) 的性能基本相同，并不存在 COUNT(1) 比 COUNT(*) 更快的说法。总体而言，在大多数情况下，两者之间的性能差异是可以忽略不计的。

在选择使用哪种方式时，应当优先考虑代码的可读性和可维护性。count(*) 在语义上更为明确，表示计算所有行的数量，而不依赖于任何特定的值。因此，从代码清晰度的角度出发，通常建议优先使用 count(*)。

当然，如果在特定的数据库环境中，经过实际测试发现 count(1) 具有明显的性能优势，那么也可以选择使用 count(1)。但在一般情况下，不必过分纠结于这两种计数方式之间的性能差异。

希望本文能帮助你在使用计数操作时作出更为合理的选择。

Chat2DB 文档：docs.chat2db.ai/zh-CN/docs/…

Chat2DB 官网：chat2db.ai/zh-CN

Chat2DB GitHub：github.com/codePhiliaX…

1. 引言

Spring AI Alibaba 开源项目基于 Spring AI 构建，是阿里云通义系列模型及服务在 Java AI 应用开发领域的最佳实践，提供高层次的 AI API 抽象与云原生基础设施集成方案，帮助开发者快速构建 AI 应用。

2. 效果展示

源代码地址 DailySmileStart/simple-chatboot (gitee.com)

3. 代码实现

依赖

        <dependency>

            <groupId>com.alibaba.cloud.ai</groupId>

            <artifactId>spring-ai-alibaba-starter</artifactId>

            <version>1.0.0-M2</version>

        </dependency>



        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-thymeleaf</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>



        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

注意：由于 spring-ai 相关依赖包还没有发布到中央仓库，如出现 spring-ai-core 等相关依赖解析问题，请在您项目的 pom.xml 依赖中加入如下仓库配置。

<repositories>

  <repository>

    <id>spring-milestones</id>

    <name>Spring Milestones</name>

    <url><https://repo.spring.io/milestone></url>

    <snapshots>

      <enabled>false</enabled>

    </snapshots>

  </repository>

</repositories>

@SpringBootApplication

public class SimpleChatbootApplication {



    public static void main(String[] args) {

        SpringApplication.run(SimpleChatbootApplication.class, args);

    }



}

配置自定义ChatClient

import org.springframework.ai.chat.client.ChatClient;

import org.springframework.ai.chat.client.advisor.MessageChatMemoryAdvisor;

import org.springframework.ai.chat.memory.ChatMemory;

import org.springframework.ai.chat.memory.InMemoryChatMemory;

import org.springframework.ai.chat.model.ChatModel;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;



@Configuration

public class ChatClientConfig {



   static ChatMemory chatMemory = new InMemoryChatMemory();

   @Bean

    public ChatClient chatClient(ChatModel chatModel) {

       return ChatClient.builder(chatModel)

                .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))

                .build();

    }



}

controller类

import ch.qos.logback.core.util.StringUtil;

import com.hbduck.simplechatboot.demos.function.WeatherService;

import org.springframework.ai.chat.client.ChatClient;

import org.springframework.ai.chat.model.ChatModel;

import org.springframework.ai.chat.model.ChatResponse;

import org.springframework.http.MediaType;

import org.springframework.http.codec.ServerSentEvent;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

import reactor.core.publisher.Flux;



import java.util.UUID;



import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY;

import static org.springframework.ai.chat.client.advisor.AbstractChatMemoryAdvisor.CHAT_MEMORY_RETRIEVE_SIZE_KEY;



@RestController

@RequestMapping("/ai")

public class ChatModelController {



	private final ChatModel chatModel;

	private final ChatClient chatClient;



	public ChatModelController(ChatModel chatModel, ChatClient chatClient) {

		this.chatClient = chatClient;

		this.chatModel = chatModel;

	}



	@GetMapping("/stream")

	public String stream(String input) {



		StringBuilder res = new StringBuilder();

		Flux<ChatResponse> stream = chatModel.stream(new Prompt(input));

		stream.toStream().toList().forEach(resp -> {

			 res.append(resp.getResult().getOutput().getContent());

		});



		return res.toString();

	}

	@GetMapping(value = "/memory", produces = MediaType.TEXT_EVENT_STREAM_VALUE)

	public Flux<ServerSentEvent<String>> memory(@RequestParam("conversantId") String conversantId, @RequestParam("input") String input) {

		if (StringUtil.isNullOrEmpty(conversantId)) {

			conversantId = UUID.randomUUID().toString();

		}

		String finalConversantId = conversantId;



		Flux<ChatResponse> chatResponseFlux = chatClient

				.prompt()

				.function("getWeather", "根据城市查询天气", new WeatherService())

				.user(input)

				.advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, finalConversantId)

						.param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))

				.stream().chatResponse();



		return Flux.concat(

				// First event: send conversationId

				Flux.just(ServerSentEvent.<String>builder()

						.event("conversationId")

						.data(finalConversantId)

						.build()),

				// Subsequent events: send message content

				chatResponseFlux.map(response -> ServerSentEvent.<String>builder()

						.id(UUID.randomUUID().toString())

						.event("message")

						.data(response.getResult().getOutput().getContent())

						.build())

		);

	}

}

配置文件

server:

  port: 8000



spring:

  thymeleaf:

    cache: true

    check-template: true

    check-template-location: true

    content-type: text/html

    enabled: true

    encoding: UTF-8

    excluded-view-names: ''

    mode: HTML5

    prefix: classpath:/templates/

    suffix: .html

  ai:

    dashscope:

      api-key: ${AI_DASHSCOPE_API_KEY}

    chat:

      client:

        enabled: false

前端页面

<!DOCTYPE html>

<html>

<head>

    <title>AI Chat Bot</title>

    <style>

        #chatBox {

            height: 400px;

            border: 1px solid #ccc;

            overflow-y: auto;

            margin-bottom: 10px;

            padding: 10px;

        }

        .message {

            margin: 5px;

            padding: 5px;

        }

        .user-message {

            background-color: #e3f2fd;

            text-align: right;

        }

        .bot-message {

            background-color: #f5f5f5;

            white-space: pre-wrap;  /* 保留换行和空格 */

            word-wrap: break-word;  /* 长单词换行 */

        }

    </style>

</head>

<body>

    <h1>AI Chat Bot</h1>

    <div id="chatBox"></div>

    <input type="text" id="userInput" placeholder="Type your message..." style="width: 80%">

    <button onclick="sendMessage()">Send</button>



    <script>

        let conversationId = null;

        let currentMessageDiv = null;



        function addMessage(message, isUser) {

            const chatBox = document.getElementById('chatBox');

            const messageDiv = document.createElement('div');

            messageDiv.className = `message ${isUser ? 'user-message' : 'bot-message'}`;

            messageDiv.textContent = message;

            chatBox.appendChild(messageDiv);

            chatBox.scrollTop = chatBox.scrollHeight;

            return messageDiv;

        }



        async function sendMessage() {

            const input = document.getElementById('userInput');

            const message = input.value.trim();



            if (message) {

                addMessage(message, true);

                input.value = '';



                // Create bot message container

                currentMessageDiv = addMessage('', false);



                const eventSource = new EventSource(`/ai/memory?conversantId=${conversationId || ''}&input=${encodeURIComponent(message)}`);



                eventSource.onmessage = function(event) {

                    const content = event.data;

                    if (currentMessageDiv) {

                        currentMessageDiv.textContent += content;

                    }

                };



                eventSource.addEventListener('conversationId', function(event) {

                    if (!conversationId) {

                        conversationId = event.data;

                    }

                });



                eventSource.onerror = function(error) {

                    console.error('SSE Error:', error);

                    eventSource.close();

                    if (currentMessageDiv && currentMessageDiv.textContent === '') {

                        currentMessageDiv.textContent = 'Sorry, something went wrong!';

                    }

                };



                // Close the connection when the response is complete

                eventSource.addEventListener('complete', function(event) {

                    eventSource.close();

                    currentMessageDiv = null;

                });

            }

        }



        // Allow sending message with Enter key

        document.getElementById('userInput').addEventListener('keypress', function(e) {

            if (e.key === 'Enter') {

                sendMessage();

            }

        });

    </script>

</body>

</html>

带chat memory 的对话

可以使用 InMemoryChatMemory实现

   //初始化InMemoryChatMemory

   static ChatMemory chatMemory = new InMemoryChatMemory();

   //在ChatClient 配置memory

      @Bean

    public ChatClient chatClient(ChatModel chatModel) {

       return ChatClient.builder(chatModel)

                .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory))

                .build();

    }

    //调用时配置

   		Flux<ChatResponse> chatResponseFlux = chatClient

				.prompt()

				.function("getWeather", "根据城市查询天气", new WeatherService())

				.user(input)

				.advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, finalConversantId)

						.param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))

				.stream().chatResponse();

工具

“工具（Tool）”或“功能调用（Function Calling）”允许大型语言模型（LLM）在必要时调用一个或多个可用的工具，这些工具通常由开发者定义。工具可以是任何东西：网页搜索、对外部 API 的调用，或特定代码的执行等。LLM 本身不能实际调用工具；相反，它们会在响应中表达调用特定工具的意图（而不是以纯文本回应）。然后，我们应用程序应该执行这个工具，并报告工具执行的结果给模型。

通过工具来实现获取当前天气

天气获取的类，目前使用硬编码温度

import com.fasterxml.jackson.annotation.JsonClassDescription;

import com.fasterxml.jackson.annotation.JsonInclude;

import com.fasterxml.jackson.annotation.JsonProperty;

import com.fasterxml.jackson.annotation.JsonPropertyDescription;

import com.hbduck.simplechatboot.demos.entity.Response;



import java.util.function.Function;



public class WeatherService implements Function<WeatherService.Request, Response> {



    @Override

    public Response apply(Request request) {

        if (request.city().contains("杭州")) {

            return new Response(String.format("%s%s晴转多云, 气温32摄氏度。", request.date(), request.city()));

        }

        else if (request.city().contains("上海")) {

            return new Response(String.format("%s%s多云转阴, 气温31摄氏度。", request.date(), request.city()));

        }

        else {



            return new Response(String.format("%s%s多云转阴, 气温31摄氏度。", request.date(), request.city()));

        }

    }



    @JsonInclude(JsonInclude.Include.NON_NULL)

    @JsonClassDescription("根据日期和城市查询天气")

    public record Request(

            @JsonProperty(required = true, value = "city") @JsonPropertyDescription("城市, 比如杭州") String city,

            @JsonProperty(required = true, value = "date") @JsonPropertyDescription("日期, 比如2024-08-22") String date) {

    }

}

chatClient配置function

Flux<ChatResponse> chatResponseFlux = chatClient

				.prompt()

				.function("getWeather", "根据城市查询天气", new WeatherService())

				.user(input)

				.advisors(spec -> spec.param(CHAT_MEMORY_CONVERSATION_ID_KEY, finalConversantId)

						.param(CHAT_MEMORY_RETRIEVE_SIZE_KEY, 10))

				.stream().chatResponse();

说到到某个语言的语法可能大家会觉得很枯燥、乏味，而日常开发中我们往往更加注重的是业务逻辑和页面开发，语法的使用大多也停留在满足基本的需求。其实 Dart 语法有很多有意思的地方的，仔细探究一下你会发现，它的简洁清晰、灵活多样的语法会让人爱不释手。在本文中，我们将探索 Dart 语法的各种奇妙之处吧。

unwrap 操作

在 Flutter 中，unwrap 操作常常用于处理可能为空的数据，以便过滤掉空值并只保留非空值。其使用场景也相当广泛，例如 为 Future 和 Streams 添加 unwrap 来处理掉非空数据，或者从网络请求或其他异步操作中获取数据，并在数据流中处理结果等等，如下面这段代码：

extension Unwrap<T> on Future<T?> {

  Future<T> unwrap() => then(

        (value) => value != null

        ? Future<T>.value(value)

        : Future.any([]),

  );

}

unwrap 函数将可能为空的 Future 解包，如果 Future 返回的值不为 null，则将值包装在一个新的 Future 中返回，否则返回一个空的 Future。调用示例：

class ImagePickerHelper {

  static final ImagePicker _imagePicker = ImagePicker();

  static Future<File> pickImageFromGallery() => _imagePicker

      .pickImage(source: ImageSource.gallery)

      .unwrap()

      .then((xFile) => xFile.path)

      .then((filePath) => File(filePath));

}

这里用到图片选择器插件 image_picker，只有当返回的 xFile 不为空时才进行后续操作。如果不调用 unwrap 函数，此时这里返回的 xFile 为 optional 类型，要使用之前需要判断是否为 null。日常开发中这种情况还不少，给 Future 添加 Unwrap 函数之后这样非空判断集中在这一个函数里面处理。

unwrap 不仅在 Future 中使用，还可以为 Streams 添加 unwrap 操作，代码如下：

extension Unwrap<T> on Stream<T?> {

  Stream<T> unwrap() => where((event) => event != null).cast();

}

unwrap 方法，通过 where 过滤掉了 null 的事件，并使用 cast() 方法将结果转换为 Stream<T> 类型，将可空的事件转换为非空的事件流，下面是调用代码：

void main() {

  Stream<int?>.periodic(

    const Duration(seconds: 1),

    (value) => value % 2 == 0 ? value : null,

  ).unwrap().listen((evenValue) {

    print(evenValue);

  });

  /* 输出结果

    0

    2

    4

    6

    ...

  */

}

通过 extension 给 Future 和 Streams 添加 unwrap 函数后让我们的代码看起来清晰简洁多了，有没有？

数组的展开、合并和过滤

下面代码为任意类型的可迭代对象（Iterable）添加名为 Flatten 的扩展。在这个扩展中，函数 flatten 使用了递归算法将多层嵌套的 Iterable 里面的所有元素扁平化为单层 Iterable。

extension Flatten<T extends Object> on Iterable<T> {

  Iterable<T> flatten() {

    Iterable<T> _flatten(Iterable<T> list) sync* {

      for (final value in list) {

        if (value is List<T>) {

          yield* _flatten(value);

        } else {

          yield value;

        }

      }

    }

    return _flatten(this);

  }

}

注意了上面代码中使用了 yield 关键字，在 Flutter 中，yield 关键字用于生成迭代器，通常与sync* 或 async* 一起使用。它允许您在处理某些数据时逐步生成数据，而不是在内存中一次性处理所有数据。对于处理大量数据或执行长时间运行的操作非常有用，因为它可以节省内存并提高性能。

这个和 ES6 中使用 function* 语法和 yield 关键字来生成值一个东西，也是逐个生成值，而不需要一次性生成所有值。以下是 JS 写法：

function* generateNumbers(n) {

    for (let i = 0; i < n; i++) {

        yield i;

    }

}



const numbers = generateNumbers(5);

for (const number of numbers) {

    console.log(number);

}

我们来看看 Dart 中的 flatten() 函数的调用：

Future<void> main() async {

  final flat = [

    [[1, 2, 3], 4, 5],

    [6, [7, [8, 9]], 10],

    11,12

  ].flatten();

  print(flat); // (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

}

嵌套的集合可能在数据处理、转换或展示中经常遇到，而将这些嵌套的集合扁平化可以简化数据处理过程，使代码更加简洁和易于理解。另外一点，递归展多维数组在面试中经常会出现，说不定哪天就用上了哈。

如果将两个数组合并成一个数组该怎么操作呢？其实和 Map 的合并相似，也是用到了自定义操作符 operator ，来看看怎么实现的。

extension InlineAdd<T> on Iterable<T> {

  Iterable<T> operator +(T other) => followedBy([other]);

  Iterable<T> operator &(Iterable<T> other) => followedBy(other);

}



void main() {

  const Iterable<int> values = [10, 20, 30];

  print((values & [40, 50]));

  // 输出结果：(10, 20, 30, 40, 50)

}

添加了两个操作符：+ 和 &。将一个元素或者另一个可迭代对象添加到当前的可迭代对象中，然后返回一个新的可迭代对象，让可迭代对象 terable 有了合并数组的功能。

当数组中有一个为 null 的对象时，该如何过滤掉这个 null 对象呢，很简单可以这样做：

extension CompactMap<T> on Iterable<T?> {

  Iterable<T> compactMap<E>([

    E? Function(T?)? transform,

  ]) =>

      map(transform ?? (e) => e).where((e) => e != null).cast();

}



void main() {

  const list = ['Hello', null, 'World'];

  print(list); // [Hello, null, World]

  print(list.compactMap()); // [Hello, World]

  print(list.compactMap((e) => e?.toUpperCase())); // [HELLO, WORLD]

}

Map 的过滤和合并

下面代码是 Map 类型的 extension，为 Map 类型添加了查找过滤的函数。

extension DetailedWhere<K, V> on Map<K, V> {

  Map<K, V> where(bool Function(K key, V value) f) => Map<K, V>.fromEntries(

        entries.where((entry) => f(entry.key, entry.value)),

      );



  Map<K, V> whereKey(bool Function(K key) f) =>

      {...where((key, value) => f(key))};

  Map<K, V> whereValue(bool Function(V value) f) =>

      {...where((key, value) => f(value))};

}

• where : 接受一个函数作为参数，该函数接受 Map 的键和值作为参数，并返回一个布尔值。


• whereKey : 接受一个只接受键作为参数的函数。


• whereValue : 这个方法接受一个只接受值作为参数的函数。

下面是调用：

void main(){

  const Map<String, int> people = {'John': 20, 'Mary': 21, 'Peter': 22};

  print(people.where((key, value) => key.length > 4 && value > 20)); // {Peter: 22}

  print(people.whereKey((key) => key.length < 5)); // {John: 20, Mary: 21}

  print(people.whereValue((value) => value.isEven)); // {John: 20, Peter: 22}

}

其中 where 方法先使用 entries 获取 Map 的键值对列表，然后使用 entries.where 方法对列表中的每个键值对进行过滤，最后使用 fromEntries 方法将过滤后的键值对列表转换回 Map，最后返回的新的 Map 中只包含满足条件的键值对，达到对 Map 中键值过滤的效果，也让代码更加简洁和易读。

Map 过滤还有另外一种写法

extension Filter<K, V> on Map<K, V> {

  Iterable<MapEntry<K, V>> filter(

    bool Function(MapEntry<K, V> entry) f,

  ) sync* {

    for (final entry in entries) {

      if (f(entry)) {

        yield entry;

      }

    }

  }

}



void main(){

  const Map<String, int> people = {

    'foo': 20,

    'bar': 31,

    'baz': 25,

    'qux': 32,

  };

  final peopleOver30 = people.filter((e) => e.value > 30);

  print(peopleOver30); // 输出结果：(MapEntry(bar: 31), MapEntry(qux: 32))

}

Map 其它一些更有趣的 extension，如 Merge 功能，将两个 Map 合并成一个，代码如下：

extension Merge<K, V> on Map<K, V> {

  Map<K, V> operator |(Map<K, V> other) => {...this}..addEntries(

      other.entries,

    );

}

上面的代码用到了 operator 关键字，在 Dart 中，operator 关键字用于定义自定义操作符或者重载现有的操作符。通过 operator 关键字，我们可以为自定义类定义各种操作符的行为，使得我们的类可以像内置类型一样使用操作符。

如 operator + 来定义两个对象相加的行为，operator [] 来实现索引操作，operator == 来定义相等性比较。这种语义式的也更加符合直觉、清晰易懂。

下面来看看 Map 的 Merge 功能调用代码例子：

const userInfo = {

  'name': 'StellarRemi',

  'age': 28,

};



const address = {

  'address': 'shanghai',

  'post_code': '200000',

};



void main() {

  final allInfo = userInfo | address;

  print(allInfo);

  // 输出结果：{name: StellarRemi, age: 28, address: shanghai, post_code: 200000}

}

调用的时候也很简单直接 userInfo | address;，这种操作在处理数据更新或合并配置等情况下特别有用。使用的时候需要注意的是，如果两个 Map 中有重复的键，那么上述操作会保留最后一个 Map 中的值。

小结

怎么样，上面的这些 Dart 的语法是不是很有意思，有没有函数式编程那味儿，后面还会单独一篇来分享 Dart 语言面向对象的设计。好了，今天就到这里，也希望通过本文的分享，能够激发大家对 Dart 语言的兴趣，感谢您的阅读，记得关注点赞哈。

Nacos作为一款非常流行的微服务注册中心，我们在构建微服务项目时往往会使用到它。最近发现一款轻量级的Nacos项目r-nacos，占用内存极低，性能也很强大，分享给大家。本文就以我的mall-swarm微服务电商实战项目为例，来聊聊它在项目中的使用。

r-nacos简介

r-nacos是一款使用rust实现的nacos服务，对比阿里的nacos来说，可以提供相同的注册中心和配置中心功能。同时它占用的内存更小，性能也很优秀，能提供更稳定的服务。

下面是r-nacos管理控制台使用的效果图，大家可以参考下：

mall-swarm项目简介

由于之后我们需要用到mall-swarm项目，这里简单介绍下它。 mall-swarm项目（11k+star）是一套微服务商城系统，基于2024最新微服技术栈，涵盖Spring Cloud Alibaba、Spring Boot 3.2、JDK17、Kubernetes等核心技术。mall-swarm在电商业务的基础集成了注册中心、配置中心、监控中心、网关等系统功能。

• Github地址：github.com/macrozheng/…


• Gitee地址：gitee.com/macrozheng/…


• 教程网站：cloud.macrozheng.com

项目演示：

安装

r-nacos支持Windows下的exe文件安装，也支持Linux下的Docker环境安装，这里以Docker安装为例。

• 首先通过如下命令下载r-nacos的Docker镜像：

docker pull qingpan/rnacos:stable

• 安装完成后通过如下命令运行r-nacos容器；

docker run --name rnacos -p 8848:8848 -p 9848:9848 -p 10848:10848 -d qingpan/rnacos:stable

• 接下来就可以访问r-nacos的控制台了，默认管理员账号密码为admin:admin，访问地址：http://192.168.3.101:10848/rnacos/

项目实战

接下来就以我的mall-swarm微服务电商实战项目为例，来讲解下它的使用。由于mall-swarm项目中各个服务的配置与运行都差不多，这里以mall-admin模块为例。

• 首先我们需要下载mall-swarm项目的代码，下载完成后修改项目的bootstrap-dev.yml文件，将其中的nacos连接地址改为r-nacos的地址，项目地址：github.com/macrozheng/…

spring:

  cloud:

    nacos:

      discovery:

        server-addr: http://192.168.3.101:8848

      config:

        server-addr: http://192.168.3.101:8848

        file-extension: yaml

• 接下来在r-nacos的配置列表中添加mall-admin-dev.yaml配置，该配置下项目的config目录下；

• 之后把mall-admin模块运行起来，此时在r-nacos的服务列表功能中就可以看到注册好的服务了；

• 接下来把其他模块的配置也添加到r-nacos的配置列表中去；

• 再运行其他模块，最终服务列表显示如下；

• 之后通过网关就可以访问到mall-swarm项目的在线API文档了，访问地址：http://localhost:8201/doc.html

• 这里我们再把mall-swarm项目的后台管理系统前端项目mall-admin-web给运行起来；

• 最后我们再把mall-swarm项目的前台商城系统前端项目mall-app-web给运行起来，发现都是可以正常从网关调用API的。

其他使用

r-nacos除了提供了基本的注册中心和配置中心功能，还提供了一些其他的实用功能，这里我们一起来了解下。

• 如果你想添加一些其他访问的用户，或者修改admin用户的信息，可以使用用户管理功能；

• 如果你想对r-nacos中配置信息进行导入导出，可以使用数据迁移功能；

• 如果你想对r-nacos中的运行状态进行监控，你可以使用系统监控功能，监控还是挺全的。

性能压测

r-nacos的性能还是非常好的，这里有个r-nacos官方提供的性能压测结果表，大家可以参考下。

对比Nacos

个人感觉对比阿里的nacos，占用的内存资源减少了非常多，运行不到10M内存，而nacos需要900M，服务器资源不宽裕的小伙伴可以尝试下它。

总结

今天以我的mall-swarm微服务电商实战项目为例，讲解了r-nacos的使用。从功能上来说r-nacos是完全可以替代nacos的，而且它占用内存资源非常低，性能也很强大，感兴趣的小伙伴可以尝试下它！

项目地址

github.com/nacos-group…

个人公众号：IT周瑜，十二年Java开发和架构经验，一年大模型应用开发经验，爱好研究源码，比如Spring全家桶源码、MySQL源码等，同时也喜欢分享技术干货，期待你的关注

最近闲着的时候在看Spring 6.2的源码，发现了一些新特性，比如本文要介绍的@Fallback注解。

相信大家都知道@Primary注解，而@Fallback相当于是@Primary的反向补充。

Spring在进行依赖注入时，会根据属性的类型去Spring容器中匹配Bean，但有可能根据类型找到了多个Bean，并且也无法根据属性名匹配到Bean时，就会报错，比如expected single matching bean but found 2，此时，就可以利用@Primary来解决。

加了@Primary的Bean表示是同类型多个Bean中的主Bean，换句话说，如果Spring根据类型找到了多个Bean，会选择其中加了@Primary的Bean来进行注入，因此，同类型的多个Bean中只能有一个加了@Primary，如果有多个也会报错more than one 'primary' bean found。

比如以下代码会使用orderService1来进行注入：

@Bean

@Primary

public OrderService orderService1() {

    return new OrderService();

}



@Bean

public OrderService orderService2() {

    return new OrderService();

}

而加了@Fallback注解的Bean为备选Bean，比如以下代码会使用orderService2来进行依赖注入：

@Bean

@Fallback

public OrderService orderService1() {

    return new OrderService();

}



@Bean

public OrderService orderService2() {

    return new OrderService();

}

因为orderService1加了@Fallback注解，相当于备胎，只有当没有其他Bean可用时，才会用orderService1这个备胎，有其他Bean就会优先用其他Bean。

@Primary和@Fallback都是用在依赖注入时根据类型找到了多个Bean的场景中：

• @Primary比较强势，它在说：“直接用我就可以了，不用管其他Bean”


• @Fallback比较弱势，它在说：“先别用我，先用其他Bean”

如果根据类型只找到一个Bean就用不着他两了，另外，同类型多个Bean中@Primary的Bean只能有一个，但可以有多个@Fallback。

大家觉得@Fallback注解怎么样？

实际上，@Primary和@Fallback两个注解的源码实现在同一个方法中，源码及注释如下，感兴趣的同学可以看看：

protected String determinePrimaryCandidate(Map<String, Object> candidates, Class<?> requiredType) {

    String primaryBeanName = null;

    // First pass: identify unique primary candidate

    // 先找@Primary注解的Bean



    // candidates就是根据类型找到的多个Bean，key为beanName, Value为bean对象

    for (Map.Entry<String, Object> entry : candidates.entrySet()) {

        String candidateBeanName = entry.getKey();

        Object beanInstance = entry.getValue();

        if (isPrimary(candidateBeanName, beanInstance)) {

            if (primaryBeanName != null) {

                boolean candidateLocal = containsBeanDefinition(candidateBeanName);

                boolean primaryLocal = containsBeanDefinition(primaryBeanName);



                // 找到多个@Primary会报错

                if (candidateLocal == primaryLocal) {

                    throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),

                                                              "more than one 'primary' bean found among candidates: " + candidates.keySet());

                }

                else if (candidateLocal) {

                    primaryBeanName = candidateBeanName;

                }

            }

            else {

                // 找到一个@Primary注解的Bean就先存着，看是不是还有其他@Primay注解的Bean

                primaryBeanName = candidateBeanName;

            }

        }

    }



    // Second pass: identify unique non-fallback candidate

    // 没有@Primary注解的Bean情况下，才找没有加@Fallback注解的，加了@Fallback注解的Bean会被过滤掉

    if (primaryBeanName == null) {

        for (String candidateBeanName : candidates.keySet()) {



            // 判断是否没有加@Fallback

            if (!isFallback(candidateBeanName)) {



                // 如果有多个Bean没有加@Fallback，会返回null，后续会根据属性名从多个bean中进行匹配，匹配不到就会报错

                if (primaryBeanName != null) {

                    return null;

                }

                primaryBeanName = candidateBeanName;

            }

        }

    }

    return primaryBeanName;

}

<dependency>

    <groupId>org.codehaus.groovygroupId>

    <artifactId>groovy-allartifactId>

    <version>2.5.16version>

    <type>pomtype>

dependency>

public interface InterfaceA {



    /**

     * 执行规则

     */

    void testMethod();

}

3. resource目录下创建.groovy实现上面的接口

@Slf4j

class GroovyInterfaceAImpl implements InterfaceA {



    @Override

    void testMethod() {

        log.info("我是groovy编写的InterfaceA接口实现类中的接口方法")

        GroovyScriptService groovyScriptService = SpringUtils.getBean(GroovyScriptService.class)

        GroovyScript groovyScript = Optional.ofNullable(groovyScriptService.getOne(new QueryWrapper()

                .eq("name", "groovy编写的java接口实现类")

                .eq("version", 1))).orElseThrow({ -> new RuntimeException("没有查询到脚本") })

        log.info("方法中进行了数据库查询，数据库中的groovy脚本是这个:{}", "\n" + groovyScript.getScript())

    }

}

4. mysql数据库中建个表groovy_script

 5. 将刚才编写的.groovy文件内容存入数据库

@RunWith(SpringRunner.class)

@SpringBootTest

public class GroovyTest {



    @Resource

    private GroovyScriptService groovyScriptService;



    @Test

    public void test01() {

        GroovyScript groovyScript = new GroovyScript();

        groovyScript.setScript("package groovy\n" +

                "\n" +

                "import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper\n" +

                "import com.demo.groovy.entity.GroovyScript\n" +

                "import com.demo.groovy.service.GroovyScriptService\n" +

                "import com.demo.groovy.service.InterfaceA\n" +

                "import com.demo.groovy.util.SpringUtils\n" +

                "import groovy.util.logging.Slf4j\n" +

                "\n" +

                "\n" +

                "@Slf4j\n" +

                "class GroovyInterfaceAImpl implements InterfaceA {\n" +

                "\n" +

                "    @Override\n" +

                "    void testMethod() {\n" +

                "        log.info("我是groovy编写的InterfaceA接口实现类中的接口方法")\n" +

                "        GroovyScriptService groovyScriptService = SpringUtils.getBean(GroovyScriptService.class)\n" +

                "        GroovyScript groovyScript = Optional.ofNullable(groovyScriptService.getOne(new QueryWrapper()\n" +

                "                .eq("name", "groovy编写的java接口实现类")\n" +

                "                .eq("version", 1))).orElseThrow({ -> new RuntimeException("没有查询到脚本") })\n" +

                "        log.info("方法中进行了数据库查询，数据库中的groovy脚本是这个:{}", "\n" + groovyScript.getScript())\n" +

                "    }\n" +

                "}");

        groovyScript.setVersion(1);

        groovyScript.setName("groovy编写的java接口实现类");

        groovyScriptService.save(groovyScript);

    }

}

6. 从数据读取脚本，GroovyClassLoader加载脚本为Class（注意将Class对象进行缓存）

@Service("groovyScriptService")

@Slf4j

public class GroovyScriptServiceImpl extends ServiceImpl<GroovyScriptServiceMapper, GroovyScript> implements GroovyScriptService {



    private static final Map<String, Md5Clazz> SCRIPT_MAP = new ConcurrentHashMap<>();



    @Override

    public Object getInstanceFromDb(String name, Integer version) {

        //查询脚本

        GroovyScript groovyScript = Optional.ofNullable(baseMapper.selectOne(new QueryWrapper<GroovyScript>()

                .eq("name", name)

                .eq("version", version))).orElseThrow(() -> new RuntimeException("没有查询到脚本"));

        //将groovy脚本转换为java类对象

        Class clazz = getClazz(name + version.toString(), groovyScript.getScript());

        Object instance;



        try {

            instance = clazz.newInstance();

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

        return instance;

    }



    private Class getClazz(String scriptKey, String scriptText) {

        String md5Hex = DigestUtil.md5Hex(scriptText);

        Md5Clazz md5Script = SCRIPT_MAP.getOrDefault(scriptKey, null);

        if (md5Script != null && md5Hex.equals(md5Script.getMd5())) {

            log.info("从缓存获取的Clazz");

            return md5Script.getClazz();

        } else {

            CompilerConfiguration config = new CompilerConfiguration();

            config.setSourceEncoding("UTF-8");

            GroovyClassLoader groovyClassLoader = new GroovyClassLoader(Thread.currentThread().getContextClassLoader(), config);

            try {

                Class clazz = groovyClassLoader.parseClass(scriptText);

                SCRIPT_MAP.put(scriptKey, new Md5Clazz(md5Hex, clazz));

                groovyClassLoader.clearCache();

                log.info("groovyClassLoader parseClass");

                return clazz;

            } catch (Exception e) {

                throw new RuntimeException(e);

            } finally {

                try {

                    groovyClassLoader.close();

                } catch (IOException e) {

                    log.error("close GroovyClassLoader error", e);

                }

            }

        }

    }



    @Data

    private static class Md5Clazz {

        private String md5;

        private Class clazz;



        public Md5Clazz(String md5, Class clazz) {

            this.md5 = md5;

            this.clazz = clazz;

        }

    }

}

7. 测试

@RestController

@RequestMapping("/test")

@Slf4j

public class GroovyTestController {



    @Resource

    private GroovyScriptService groovyScriptService;



    @GetMapping("")

    public String testGroovy() {

        InterfaceA interfaceA = (InterfaceA) groovyScriptService.getInstanceFromDb("groovy编写的java接口实现类", 1);

        interfaceA.testMethod();

        return "ok";

    }

}

8. 接口方法被执行。想要修改接口的话在idea里面把groovy文件编辑好更新到数据库就行了，即时生效。

本文简单给大家提供一种思路，希望能对大家有所帮助，如有不当之处还请大家指正。本人之前在项目中用的比较多的是Groovyshell，执行的是一些代码片段，而GroovyClassLoader则可以加载整个脚本为Class，Groovy对于java开发者来说还是比较友好的，上手容易。

作为一名“手残党”，你是否常常因为复杂的操作和高难度的游戏内容而感到沮丧？不用担心，《黑神话：悟空》不仅仅是为硬核玩家准备的，它同样为我们这些操作不那么娴熟的玩家提供了无比精彩的游戏体验。

本文将带你深入探讨《黑神话：悟空》背后的技术原理，揭示风灵月影团队如何通过创新的技术手段，让每一位玩家，无论技术水平如何，都能在游戏中找到属于自己的乐趣。我们将揭秘那些让你在游戏中感受到无比真实和沉浸的细节，从逼真的角色动画到动态的环境效果，每一个细节都展示了团队的卓越才能和对游戏品质的追求。让我们一同走进这场技术与艺术的盛宴，感受《黑神话：悟空》背后的科技魔法，了解这些技术如何让你在游戏中无论是战斗还是探索，都能享受到极致的体验。

我的黑神话悟空数值

欢迎加入宗门

风灵月影修改器

Attach一个游戏进程，黑神话悟空进程名固定

Attach一个进程之后，可以修改对应的游戏数值

使用方式上每次启动游戏都要启动风灵月影，重启的游戏风铃月影也会重新Attach进程。

游戏修改器的工作原理

游戏修改器的技术原理主要涉及对游戏内存的实时修改和对游戏数据的动态调整。以下是修改器的主要技术原理和工作机制：

内存修改

动态链接库（DLL）注入

调试工具

数据文件修改

反作弊机制

以上是游戏修改器的主要技术原理。通过这些技术，修改器能够对游戏进行各种修改和调整，提供丰富的功能来提升玩家的游戏体验。然而，使用修改器时应注意相关法律和游戏规定，避免影响游戏的公平性和他人体验。

blog.csdn.net/m0_74942241… （可部分阅读）

代码示例

以下是一个简单的内存扫描示例：

#include <windows.h>

#include <iostream>

#include <vector>



// 扫描目标内存

std::vector<LPVOID> ScanMemory(HANDLE hProcess, int targetValue) {

    std::vector<LPVOID> addresses;

    MEMORY_BASIC_INFORMATION mbi;

    LPVOID address = 0;



    while (VirtualQueryEx(hProcess, address, &mbi, sizeof(mbi))) {

        if (mbi.State == MEM_COMMIT && (mbi.Protect == PAGE_READWRITE || mbi.Protect == PAGE_WRITECOPY)) {

            SIZE_T bytesRead;

            std::vector<BYTE> buffer(mbi.RegionSize);

            if (ReadProcessMemory(hProcess, address, buffer.data(), mbi.RegionSize, &bytesRead)) {

                for (SIZE_T i = 0; i < bytesRead - sizeof(targetValue); ++i) {

                    if (memcmp(buffer.data() + i, &targetValue, sizeof(targetValue)) == 0) {

                        addresses.push_back((LPVOID)((SIZE_T)address + i));

                    }

                }

            }

        }

        address = (LPVOID)((SIZE_T)address + mbi.RegionSize);

    }



    return addresses;

}



int main() {

    DWORD processID = 1234; // 替换为目标进程的实际PID

    int targetValue = 100; // 要查找的值



    HANDLE hProcess = OpenTargetProcess(processID);

    if (hProcess) {

        std::vector<LPVOID> addresses = ScanMemory(hProcess, targetValue);

        for (auto addr : addresses) {

            std::cout << "Found value at address: " << addr << std::endl;

            ModifyMemory(hProcess, addr, 999); // 修改内存

        }

        CloseHandle(hProcess);

    }



    return 0;

}

修改目标进程的内存

#include <windows.h>

#include <iostream>



// 打开目标进程

HANDLE OpenTargetProcess(DWORD processID) {

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processID);

    if (hProcess == NULL) {

        std::cerr << "Failed to open process. Error: " << GetLastError() << std::endl;

    }

    return hProcess;

}



// 查找目标内存地址（假设我们已经知道地址）

void ModifyMemory(HANDLE hProcess, LPVOID address, int newValue) {

    SIZE_T bytesWritten;

    if (WriteProcessMemory(hProcess, address, &newValue, sizeof(newValue), &bytesWritten)) {

        std::cout << "Memory modified successfully." << std::endl;

    } else {

        std::cerr << "Failed to modify memory. Error: " << GetLastError() << std::endl;

    }

}



int main() {

    DWORD processID = 1234; // 替换为目标进程的实际PID

    LPVOID targetAddress = (LPVOID)0x00ABCDEF; // 替换为目标内存地址

    int newValue = 999; // 要写入的新值



    HANDLE hProcess = OpenTargetProcess(processID);

    if (hProcess) {

        ModifyMemory(hProcess, targetAddress, newValue);

        CloseHandle(hProcess);

    }



    return 0;

}

以下是一个使用内联钩子实现函数劫持的简单示例（基于Windows平台）：

#include <windows.h>



// 原始函数类型定义

typedef int (WINAPI *MessageBoxAFunc)(HWND, LPCSTR, LPCSTR, UINT);



// 保存原始函数指针

MessageBoxAFunc OriginalMessageBoxA = NULL;



// 自定义函数

int WINAPI HookedMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType) {

    // 修改参数或执行其他逻辑

    lpText = "This is a hooked message!";

    // 调用原始函数

    return OriginalMessageBoxA(hWnd, lpText, lpCaption, uType);

}



// 设置钩子

void SetHook() {

    // 获取原始函数地址

    HMODULE hUser32 = GetModuleHandle("user32.dll");

    OriginalMessageBoxA = (MessageBoxAFunc)GetProcAddress(hUser32, "MessageBoxA");



    // 修改函数头部指令

    DWORD oldProtect;

    VirtualProtect(OriginalMessageBoxA, 5, PAGE_EXECUTE_READWRITE, &oldProtect);

    *(BYTE*)OriginalMessageBoxA = 0xE9; // JMP指令

    *(DWORD*)((BYTE*)OriginalMessageBoxA + 1) = (DWORD)HookedMessageBoxA - (DWORD)OriginalMessageBoxA - 5;

    VirtualProtect(OriginalMessageBoxA, 5, oldProtect, &oldProtect);

}



int main() {

    // 设置钩子

    SetHook();

    // 测试钩子

    MessageBoxA(NULL, "Original message", "Test", MB_OK);

    return 0;

}

CheatEngine

上述通过代码的方式成本比较高，我们通过工具修改内存值和函数劫持
http://www.cheatengine.org/downloads.p…

使用教程 blog.csdn.net/CYwxh0125/a…

如何实现自动扫描

风灵月影如何实现自动修改值，不需要每次搜索变量内存地址？

猜想1：变量内存地址固定？

经过测试发现不是

猜想2：通过变量字符串搜索？

算了不猜了，直接问GPT，发现应该是通过指针内存扫描的方式。

指针扫描适合解决的问题

指针扫描是一种高级技术，用于解决动态内存地址变化的问题。在某些应用程序（特别是游戏）中，内存地址在每次运行时可能会变化，这使得简单的内存扫描方法难以长期有效地找到目标变量。指针扫描通过查找指向目标变量的指针链，可以找到一个稳定的基址（静态地址），从而解决动态内存地址变化的问题。

1. 动态内存分配

许多现代应用程序和游戏使用动态内存分配，导致每次运行时同一变量可能位于不同的内存地址。指针扫描可以找到指向这些变量的指针链，从而定位到一个稳定的基址。

2. 多次重启后的地址稳定性

通过指针扫描找到的静态基址和指针链，即使在应用程序或系统重启后，仍然可以有效地找到目标变量的位置。这样，用户无需每次重新扫描内存地址。

3. 多级指针

有些变量可能通过多级指针间接引用。指针扫描可以处理这种情况，通过多级指针链找到最终的目标变量。

指针扫描的基本步骤

以下是使用 Cheat Engine 进行指针扫描的基本步骤：

1. 初始扫描

首先，使用普通的内存扫描方法找到目标变量的当前内存地址。例如，假设在游戏中找到当前金钱值的地址是 0x00ABCDEF。

2. 指针扫描

3. 验证指针路径

4. 使用指针路径

示例：使用 Cheat Engine 进行指针扫描

假设你在游戏中找到了当前金钱值的地址 0x00ABCDEF，并想通过指针扫描找到一个稳定的基址。

1. 初始扫描

2. 指针扫描

3. 验证指针路径

4. 使用指针路径

注意事项

通过以上步骤，指针扫描技术可以帮助用户找到稳定的基址，解决动态内存地址变化的问题，从而实现更可靠的内存修改。

打开服务器连接，找到文件夹，删掉，找到打包的目录，ctrl + C, ctrl + v 。。。。
烦的要死。。内网开发，node 的 ssh2 依赖库一时半会还导不进来。

索性，自己写一个！

原生 NodeJS 代码，不需要引用任何第三方库 win10 及以上版本，系统自带ssh 命令行工具，如果没有，需要自行安装

首先,需要生成本地秘钥；

ssh-keygen

执行上述命令后，系统会提示你输入文件保存位置和密码，如果你想使用默认位置和密码，直接按回车接受即可。这将在默认的SSH目录~/.ssh/下生成两个文件：id_rsa（私钥）和id_rsa.pub（公钥）

开启服务端使用秘钥登录

一般文件位置位于 /etc/ssh/sshd_config 中，

找到下面两行 ，取消注释，值改为 yes

RSAAuthentication yes

PubkeyAuthentication yes

将秘钥添加到服务端：

打开服务端文件 /root/.ssh/authorized_keys 将公钥 粘贴到新的一行中

重启服务端 ssh 服务

sudo service ssh restart

编写自动化上传脚本（nodejs 脚本）

// 创建文件 ./build/Autoactic.js



const { exec, spawn } = require('child_process');

const fs= require('fs');



// C:/Users/admin/.ssh/server/ServiceOptions.json

// 此处储存本地连接服务端相关配置数据（目的为不将秘钥暴露给 Git 提交代码）

// {

//     服务端关键字（记录为哪个服务器）

//     "Test90"： {

//         服务器登录用户名

//         "Target": "root@255.255.255.255",

//         本地证书位置（秘钥）

//         "Pubkey": "C:/User/admin/.shh/server/file"

//     }

// }



// 温馨提示 本机储存的秘钥需要调整权限，需要删除除了自己以外其他的全部用户

const ServiceOption = Json.parse(fs.readFileSync("C:/Users/admin/.ssh/server/ServiceOptions.json"), "utf-8");



// 本地项目文件路径（dist 打包后的实际路径）

const LocalPath = "D:/Code/rmgm/jilinres/jprmcrm/dev/admin/dist"；

// 服务端项目路径

const ServerPath = "/home/rmgmuser/web/pmr";



// 运行单行命令 （scp 命令，上传文件使用）

const RunSSHCode = function (code) {

    return new Promise((resolve, reject) => {

        const process = exec(code, (error, sodut, stderr) => {

            if (error) {

                console.error(`执行错误： ${error}`)

                reject();

                return;

            };

            console.log(`sodut:${sodut}`);

            if (stderr) {

                console.error(`stderr:${stderr}`)

            };

            if (process && !process.killed){

                process.kill();

            };

            setTimeout(()=>{

                resolve();

            },10);

        })

    })

}



// 执行服务端命令 （执行 ssh 命令行）

const CommandHandle(command) {

    return new Promise((resolve, reject) => {

        const child = spawn('ssh', ['-i', ServiceOption.Test90.Pubkey, '-o', 'StrictHostKeyChecking=no', ServiceOption.Test90.Target], {

            stdio: ['pipe']

        });

        child.on('close',(err)=>{

            console.log(`--close--:${err}`);

            if (err === 0) {

                setTimeout(()=>{ resolve() },10)

            } else {

                reject();

            }

        })

        child.on('error',(err)=>{

            console.error(`--error--:${err}`)

        });

        console.log(`--command--:${command}`);

        child.stdin.end(command);

        child.stdout.on('data',(data)=>{

            console.log(`Stdout:${data}`);

        })

        child.stderr.on('data',(data)=>{

            console.log(`Stdout:${data}`);

        })

    }

};





// 按照顺序执行代码

!(async function (CommandHandle, RunSSHCode){

    try {

        console.log(`创建文件夹 => ${ServerPath}`);

        await CommandHandle(`mkdir -p ${ServerPath}`);

        console.log(`创建文件夹 => ${ServerPath} => 完成`);

    

        console.log(`删除历史文件 => ${ServerPath}`);

        await CommandHandle(`find ${ServerPath} -type d -exec rm -rf {} +`);

        console.log(`删除历史文件 => ${ServerPath} => 完成`);

    

        console.log(`上传本地文件 => 从 本地 ${LocalPath} 到 服务端 ${ServerPath}`);

        await RunSSHCode(`scp -i ${serviceOption.Test90.pubkey} -r ${LocalPath}/ ${serviceOption.Test90.Target}:${ServerPath}/`);

        console.log(`上传本地文件 => 从 本地 ${LocalPath} 到 服务端 ${ServerPath} => 完成`);

        

        // 吉林环境个性配置 非必须（更改访问权限）

        console.log(`更改访问权限 => ${ServerPath}`);

        await CommandHandle(`chown -R rmgmuser:rmgmuser ${ServerPath}`);

        console.log(`更改访问权限 => ${ServerPath} => 完成`);

    

    } catch (error) {

        console.error(`---END---`, error)

    }

})(CommandHandle, RunSSHCode)

更改打包命令：

// package.json

{

    // ....

    "scripts": {

        // .....



        "uploadFile" : "node ./build/Autoactic.js"

        // 原始的 build 改为 prebuild 命令

        "preBuild" : "vue-cli-service build --mode production"

        // npm 按顺序运行多个命令行

        "build" : "npm run preBuild && npm run uploadFile"

        

         // .....

    }

    //... 

}

效果 打包结束后，直接上传到服务端。

有特殊需求，例如重启服务等，可自行添加。

导读

本文介绍用 Webhooks 代替 Jenkins 更简单地实现自动化部署。不论用 Jenkins 还是 Webhooks，都需要一定的服务端基础。

Webhooks 的使用更简单，自然功能就不如 Jenkins 丰富，因此更适合小项目。

背景

笔者一直在小厂子做小项目，只做前端的时候，部署项目就是 npm run build 然后压缩发给后端。后来到另一个小厂子做全栈，开始自己部署，想着捣鼓一下自动化部署。

Jenkins 是最流行的自动化部署工具，但是弄到一半我头都大了。我只是想部署一个小项目而已，结果安装、配置、启动 Jenkins 这工作量好像比我手动部署还大呢，必须找个更简单的办法才行。果然经过一番捣鼓，发现 Webhooks 又简单又实用，更适合我们小厂子小项目。

原理

首先我们的项目应该都放在 Git 平台上，主流的 Git 平台上都有 Webhooks。它的作用是：在你推送代码、发布版本等操作时，自动向你提供的地址发一个请求。

你的服务器收到这个请求后，要做的事情就是调用一段事先写好的脚本。这段脚本的任务是拉取最新代码、安装依赖（可选）、打包项目、重新启动项目。

这样当你在 Git 平台上发布版本后，服务器就会自动部署最新代码了。

实现

实现步骤可以和上面的原理反着来：先写好脚本，然后启动服务，最后创建 Webhooks。

在此之前，你的服务器需要先安装 Git，并能够拉取你的代码。这部分内容很常规，看官可以在其他地方搜到。

1. 自动部署脚本

Nuxt

自动部署脚本就是代替我们手动打包、部署的工作。在 Linux 中，它应该写在一个 .sh 文件里。我的前端项目用 Nuxt 开发，脚本主要内容如下：

# 进入项目文件

cd /usr/local/example



# 拉取最新代码

git pull



# 打包

npm run build



# 重启服务

pm2 reload ecosystem.config.js

你可以在 Git 上随便更新点内容，然后在 XShell 或其他工具打开服务器控制台，执行这段代码，然后到线上版本看更新有没有生效。

笔记一开始经过了一番折腾，发现最好得记录部署日志，那样方便排查问题。完整脚本如下：

# 日志文件路径

LOG_FILE="/usr/local/example/$(date).txt"



# 记录开始时间

echo "Deployment started at $(date)" > $LOG_FILE



# 进入项目文件

cd /usr/local/example



# 拉取最新代码

git pull >> $LOG_FILE 2>&1



# 打包

npm run build >> $LOG_FILE 2>&1



# 重启服务

pm2 reload ecosystem.config.js >> $LOG_FILE 2>&1



# 记录结束时间

echo "Deployment finished at $(date)" >> $LOG_FILE

Eggjs

笔者后端用了 Eggjs，其自动部署脚本如下：

# 日志文件

LOG_FILE="/usr/local/example/$(date).txt"



# 记录开始时间

echo "Deployment started at $(date)" > $LOG_FILE



# 进入项目文件

cd /usr/local/example



# 拉取最新代码

git pull >> $LOG_FILE 2>&1



# Egg 没有重启命令，要先 stop 再 start

npm stop >> $LOG_FILE 2>&1



npm start >> $LOG_FILE 2>&1



# 记录结束时间

echo "Deployment finished at $(date)" >> $LOG_FILE

Eggjs 项目没有构建的步骤，其依赖要事先安装好。因此如果开发过程中安装了新依赖，记得到服务端安装一下。

Midwayjs

由于 Eggjs 对 TypeScript 的支持比较差，笔者后来还用了 Midwayjs 来开发服务端，其脚本如下：

# 日志文件

LOG_FILE="/usr/local/example/$(date).txt"



# 记录开始时间

echo "Deployment started at $(date)" > $LOG_FILE



# 进入项目文件

cd /usr/local/example



# 拉取最新代码

git pull >> $LOG_FILE 2>&1



# 重装依赖

export NODE_ENV=development

npm install >> $LOG_FILE 2>&1



# 构建

npm run build >> $LOG_FILE 2>&1



# 移除开发依赖

npm prune --omit=dev >> $LOG_FILE 2>&1



# 启动服务

npm start >> $LOG_FILE 2>&1



# 记录结束时间

echo "Deployment finished at $(date)" >> $LOG_FILE

Midwayjs 的自动部署脚本比较特殊：在 npm install 之前需要先指定环境为 development，那样才会安装所有依赖，否则会忽略 devDependencies 中的依赖，导致后面的 npm run build 无法执行。这点也是费了笔者好长时间才排查清楚，因为它在 XShell 里执行的时候默认的环境就是 development，但是到了 Webhooks 调用的时候又变成了 product。

2. 启动一个独立的小服务

上面这些脚本，应该由一个独立的小服务来执行。笔者一开始让项目的 Eggjs 服务来执行，也就是想让 Eggjs 服务自动部署自己，就失败了。原因是：脚本在执行到 npm stop 时，Eggjs 服务把自己关掉了，自然就执行不了 npm start。

笔者启动了一个新的 Eggjs 服务来实现这个功能，使用其他语言、框架同理。其中执行脚本的控制器代码如下：

const { Controller } = require('egg');

const { exec } = require('child_process');



class EggController extends Controller {

  async index() {

    const { ctx } = this;

    try {

      // 执行 .sh 脚本

      await exec('sh /usr/local/example/egg.sh');

      ctx.body = {

        'msg': 'Deployment successful'

      };

    } catch (error) {

      ctx.body = {

        'msg': 'Deployment failed：' + JSON.stringify(error)

      };

    }

  }

}



module.exports = EggController;

如果启动成功，你应该可以在 Postman 之类的工具上发起这个控制器对应的请求，然后成功执行里面的 .sh 脚本。

注意这些请求必须是 POST 请求。

3. 到 Git 平台创建 Webhooks

笔者用的是GitCode，其他平台类似。到代码仓库 -> 项目设置 -> WebHook 菜单 -> 新建 Webhook：

• URL：上面独立小服务的请求地址；


• Token：在 Git 平台生成即可；


• 事件类型：我希望是发布版本的时候触发，所以选 Tag推送事件。

创建好之后，激活这个 hook，然后随便提交些新东西，到代码仓库 -> 代码 -> 创建发行版：

填写版本号、版本描述后，滑到底部，勾选“最新版本”，点击发布按钮。

这样就能触发前面创建的 WebHook，向你的独立小服务发送请求，小服务就会去调用自动部署脚本。

怎么样，是不是比 Jenkins 简单太多了。当然功能也比 Jenkins 简单太多，但是对小厂子小项目来说，也是刚好够用。

前言

标题党了，原生go很好用，只不过我习惯了java封装大法。最近在看golang，因为是javaer，所以突发奇想，不如开发一个类似于 Maven 或 Gradle 的构建工具来管理 Go 项目的依赖，众所周知，构建和发布是一个复杂的任务，但通过合理的设计和利用现有的工具与库，可以实现一个功能强大且灵活的工具。

正文分为两部分：项目本身和如何使用

一、项目本身

1. 项目需求分析

核心需求

可选需求

• 缓存机制：缓存依赖和构建结果以提升速度。


• 并行执行：支持并行下载和编译。

2. 技术选型

2.1 编程语言

• Go 语言：由于我们要构建的是 Go 项目的构建工具，选择 Go 语言本身作为开发语言是合理的。

2.2 依赖管理

• Go Modules：Go 自带的依赖管理工具已经很好地解决了依赖管理的问题，可以直接利用 Go Modules 来解析和管理依赖。

2.3 构建工具

• Go 标准库：Go 的标准库提供了强大的编译和构建功能（如 go build, go install 等命令），可以通过调用这些命令或直接使用相关库来进行构建。

2.4 发布工具

• Docker：对于发布管理，可能需要集成 Docker 来构建和发布 Docker 镜像。


• upx：用于压缩可执行文件。

2.5 配置文件格式

• YAML 或 TOML：选择一种易于阅读和编写的配置文件格式，如 YAML 或 TOML。

3. 系统架构设计

3.1 模块划分

3.2 系统流程

4. 模块详细设计与实现

4.1 依赖管理模块

4.1.1 设计

利用 Go Modules 现有的功能来管理依赖。可以通过 go list 命令来获取项目的依赖：

4.1.2 实现

package dependency



import (

    "fmt"

    "os/exec"

)



// ListDependencies 列出项目所有依赖

func ListDependencies() ([]byte, error) {

    cmd := exec.Command("go", "list", "-m", "all")

    return cmd.Output()

}



// DownloadDependencies 下载项目所有依赖

func DownloadDependencies() error {

    cmd := exec.Command("go", "mod", "download")

    output, err := cmd.CombinedOutput()

    if err != nil {

        return fmt.Errorf("download failed: %s", output)

    }

    return nil

}

4.2 构建管理模块

4.2.1 设计

调用 Go 编译器进行构建，支持跨平台编译和自定义构建选项。

4.2.2 实现

package build



import (

    "fmt"

    "os/exec"

    "runtime"

    "path/filepath"

)



// BuildProject 构建项目

func BuildProject(outputDir string) error {

    // 设置跨平台编译参数

    var goos, goarch string

    switch runtime.GOOS {

    case "windows":

        goos = "windows"

    case "linux":

        goos = "linux"

    default:

        goos = runtime.GOOS

    }

    goarch = "amd64"



    output := filepath.Join(outputDir, "myapp")

    cmd := exec.Command("go", "build", "-o", output, "-ldflags", "-X main.version=1.0.0")

    output, err := cmd.CombinedOutput()

    if err != nil {

        return fmt.Errorf("build failed: %s", output)

    }

    fmt.Println("Build successful")

    return nil

}

4.3 发布管理模块

4.3.1 设计

打包构建结果并发布到不同平台。例如，构建 Docker 镜像并发布到 Docker Hub。

4.3.2 实现

package release



import (

    "fmt"

    "os/exec"

)



// BuildDockerImage 构建 Docker 镜像

func BuildDockerImage(tag string) error {

    cmd := exec.Command("docker", "build", "-t", tag, ".")

    output, err := cmd.CombinedOutput()

    if err != nil {

        return fmt.Errorf("docker build failed: %s", output)

    }

    fmt.Println("Docker image built successfully")

    return nil

}



// PushDockerImage 推送 Docker 镜像

func PushDockerImage(tag string) error {

    cmd := exec.Command("docker", "push", tag)

    output, err := cmd.CombinedOutput()

    if err != nil {

        return fmt.Errorf("docker push failed: %s", output)

    }

    fmt.Println("Docker image pushed successfully")

    return nil

}

5. 任务管理模块

允许用户定义和执行自定义任务：

package task



import (

    "fmt"

    "os/exec"

)



type Task func() error



func RunTask(name string, task Task) {

    fmt.Println("Running task:", name)

    err := task()

    if err != nil {

        fmt.Println("Task failed:", err)

        return

    }

    fmt.Println("Task completed:", name)

}



func TestTask() error {

    cmd := exec.Command("go", "test", "./...")

    output, err := cmd.CombinedOutput()

    if err != nil {

        return fmt.Errorf("tests failed: %s", output)

    }

    fmt.Println("Tests passed")

    return nil

}

6. 插件系统

可以通过动态加载外部插件或使用 Go 插件机制来实现插件系统：

package plugin



import (

    "fmt"

    "plugin"

)



type Plugin interface {

    Run() error

}



func LoadPlugin(path string) (Plugin, error) {

    p, err := plugin.Open(path)

    if err != nil {

        return nil, err

    }

    symbol, err := p.Lookup("PluginImpl")

    if err != nil {

        return nil, err

    }

    impl, ok := symbol.(Plugin)

    if !ok {

        return nil, fmt.Errorf("unexpected type from module symbol")

    }

    return impl, nil

}

5. 示例配置文件

使用 YAML 作为配置文件格式，定义项目的构建和发布选项：

name: myapp

version: 1.0.0

build:

  options:

    - -ldflags

    - "-X main.version=1.0.0"

release:

  docker:

    image: myapp:latest

    tag: v1.0.0

tasks:

  - name: test

    command: go test ./...