ThreadLocal是什么？

试想以下情况：

在多线程的情况下，对一同一个变量操作可能会出现冲突，解决的办法就是对这个变量加锁。但是我们有时候其实就是想要一个全局变量，不想让多个线程去干扰。那么能不能有一个变量，名字相同，但是多个线程操作的时候又不会相互影响呢？

从另外一个角度来说，对于一个变量，在一个线程的任何一个地方都可能需要用到，但是通过传参的方式又比较麻烦，有没有一个变量是贯穿整个线程，我们想取就能取到的呢。

ThreadLocal就是这么一个变量，那么这个变量是怎么实现的呢？

ThreadLocal源码分析

ThreadLocal github地址

首先看用法

public class Client {

    private static final ThreadLocal<String> myThreadLocal = ThreadLocal.withInitial(() -> "This is the initial value");



    public static void main(String[] args) {



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

            new Thread(new MyRunnable(), "线程"+i).start();

        }



    }



    public static class MyRunnable implements Runnable {



        @Override

        public void run() {

            String name = Thread.currentThread().getName();

            System.out.println(name + "的threadLocal"+ ",设置为" + name);

            myThreadLocal.set(name);

            try {

                Thread.sleep(1000);

            } catch (InterruptedException ignored) {}

            System.out.println(name + ":" + myThreadLocal.get());

        }



    }

}



------

  

线程0的threadLocal,设置为线程0

线程3的threadLocal,设置为线程3

线程4的threadLocal,设置为线程4

线程2的threadLocal,设置为线程2

线程1的threadLocal,设置为线程1

线程5的threadLocal,设置为线程5

线程0:线程0

线程4:线程4

线程5:线程5

线程2:线程2

线程1:线程1

线程3:线程3

例子中有六个线程，myThreadLocal里存的都是自己线程独有的变量。这样就实现了变量的线程隔离，而且如果不向传参数，在另外一个函数里直接就能get到这个变量，这对于很多场景下都非常有用。

我们下面来分析一下源码：

1. 首先每一个Thread，都有一个ThreadLocalMap，变量名字叫做threadLocas，里面保存的是多个ThreadLocal，所以每一个线程才能保存属于自己线程的值。


2. ThreadLocal封装了getMap()、Set()、Get()、Remove()4个核心方法。主要是对ThreadLocalMap来进行操作。


3. ThreadLocalMap是一个ThreadLocal的内部类，它实现了一个自定义的Map，ThreadLocalMap中的Entry[]数组存储数据。


4. Entry的键是threadLocal变量本身，值就是设置的变量的值。Entry的key是对ThreadLocal的弱引用，当ThreadLocal不再有强引用的时候，就会清理掉这个key，防止内存泄漏（然而并不能，后面会说）

get方法

public T get() {

        Thread t = Thread.currentThread();

        ThreadLocalMap map = getMap(t);

        if (map != null) {

            ThreadLocalMap.Entry e = map.getEntry(this);

            if (e != null) {

                @SuppressWarnings("unchecked")

                T result = (T)e.value;

                return result;

            }

        }

        return setInitialValue();

}



 ThreadLocalMap getMap(Thread t) {

        return t.threadLocals;

}

1. 获取当前的Thread对象，通过getMap获取Thread内的ThreadLocalMap，ThreadLocalMap的定义如下：ThreadLocal.ThreadLocalMap threadLocals = null;


2. 如果map已经存在，以当前的ThreadLocal为键，获取Entry对象，并从从Entry中取出值


3. 否则，调用setInitialValue进行初始化。

setInitialValue

private T setInitialValue() {

    T value = initialValue();

    Thread t = Thread.currentThread();

    ThreadLocalMap map = getMap(t);

    if (map != null)

        map.set(this, value);

    else

        createMap(t, value);

    return value;

}

1. 首先是调用initialValue生成一个初始的value值，深入initialValue函数，我们可知它就是返回一个null；


2. 然后还是在get以下Map，如果map存在，则直接map.set,这个函数会放在后文说；


3. 如果不存在则会调用createMap创建ThreadLocalMap，这里正好可以先说明下ThreadLocalMap了。

ThreadLocalMap

createMap

void createMap(Thread t, T firstValue) {

    t.threadLocals = new ThreadLocalMap(this, firstValue);

}

static class ThreadLocalMap {

    static class Entry extends WeakReference<ThreadLocal<?>> {

        Object value;

        Entry(ThreadLocal<?> k, Object v) {

            super(k);

            value = v;

    	}

	}

    private static final int INITIAL_CAPACITY = 16;



    private Entry[] table;



    private int size = 0;



    private int threshold; // Default to 0



    private void setThreshold(int len) {

        threshold = len * 2 / 3;

    }



    private static int nextIndex(int i, int len) {

        return ((i + 1 < len) ? i + 1 : 0);

    }



    private static int prevIndex(int i, int len) {

        return ((i - 1 >= 0) ? i - 1 : len - 1);

    }

	...

}

1. 首先是Entry的定义，前面已经说过；


2. 初始的容量为INITIAL_CAPACITY = 16；


3. 主要数据结构就是一个Entry的数组table；


4. size用于记录Map中实际存在的entry个数；


5. threshold是扩容上限，当size到达threashold时，需要resize整个Map，threshold的初始值为len * 2 / 3；


6. nextIndex和prevIndex则是为了安全的移动索引，后面的函数里经常用到。

map.getEntry

private Entry getEntry(ThreadLocal<?> key) {

    int i = key.threadLocalHashCode & (table.length - 1);

    Entry e = table[i];

    if (e != null && e.get() == key)

        return e;

    else

        return getEntryAfterMiss(key, i, e);

}

1. 计算索引位置


2. 获取Entry，如果Entry存在，且key和threadLocal相等，那么返回


3. 否则，调用getEntryAfterMiss。

getEntryAfterMiss

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {

    Entry[] tab = table;

    int len = tab.length;



    while (e != null) {

        ThreadLocal<?> k = e.get();

        if (k == key)

            return e;

        if (k == null)

            expungeStaleEntry(i);

        else

            i = nextIndex(i, len);

        e = tab[i];

    }

    return null;

}

1. 如果k==key,那么代表找到了这个所需要的Entry，直接返回；


2. 如果k==null，那么证明这个Entry中key已经为null,那么这个Entry就是一个过期对象，这里调用expungeStaleEntry清理该Entry。

为什么会需要清理呢？

如果说ThreadLocal变量被人为的置为null了，ThreadLocal对象只有一个弱引用指着，就会被GC，Entry的key没有了，value可能会内存泄漏。ThreadLocal在每一个get，set的时候都会清理这种过期的key。

为什么需要循环查找key?

这是一种解决hash冲突的手段，这里用的是开放地址法，既有冲突之后，把要插入的元素放在要插入的位置后面为null的地方。HashMap则采用的是链地址法。

expungeStaleEntry

private int expungeStaleEntry(int staleSlot) {

    Entry[] tab = table;

    int len = tab.length;



    // expunge entry at staleSlot

    tab[staleSlot].value = null;

    tab[staleSlot] = null;

    size--;



    // Rehash until we encounter null

    Entry e;

    int i;

    for (i = nextIndex(staleSlot, len);

         (e = tab[i]) != null;

         i = nextIndex(i, len)) {

        ThreadLocal<?> k = e.get();

        if (k == null) {

            e.value = null;

            tab[i] = null;

            size--;

        } else {

            int h = k.threadLocalHashCode & (len - 1);

            if (h != i) {

                tab[i] = null;



                // Unlike Knuth 6.4 Algorithm R, we must scan until

                // null because multiple entries could have been stale.

                while (tab[h] != null)

                    h = nextIndex(h, len);

                tab[h] = e;

            }

        }

    }

    return i;

}

1. expunge entry at staleSlot：这段主要是将i位置上的Entry的value设为null，Entry的引用也设为null，那么系统GC的时候自然会清理掉这块内存；


2. Rehash until we encounter null: 这段就是扫描位置staleSlot之后，null之前的Entry数组，清除每一个key为null的Entry，同时若是key不为空，做rehash，调整其位置。

这里rehash的作用是什么？

我们清理的过程中会把某个值设置为null，如果之前这个值后面的区域是和前两连起来的，那么下次循环查找的时候，就会只查到null为止。比如三个hash值碰撞的key，中间的那个被删除了，那么第三个key在查找的时候会从第一个开始查找，查找到第二个就停止了，第三个就查不到了。

set

public void set(T value) {

    Thread t = Thread.currentThread();

    ThreadLocalMap map = getMap(t);

    if (map != null)

        map.set(this, value);

    else

        createMap(t, value);

}

map.set

private void set(ThreadLocal<?> key, Object value) {

    Entry[] tab = table;

    int len = tab.length;

    int i = key.threadLocalHashCode & (len-1);

  

    for (Entry e = tab[i];

         e != null;

         e = tab[i = nextIndex(i, len)]) {

        ThreadLocal<?> k = e.get();

  

        if (k == key) {

            e.value = value;

            return;

        }

  

        if (k == null) {

            replaceStaleEntry(key, value, i);

            return;

        }

    }



    tab[i] = new Entry(key, value);

    int sz = ++size;

    if (!cleanSomeSlots(i, sz) && sz >= threshold)

        rehash();

}

1. 首先还是根据key计算出位置i，然后查找i位置上的Entry，


2. 若是Entry已经存在并且key等于传入的key，那么这时候直接给这个Entry赋新的value值。


3. 若是Entry存在，但是key为null，则调用replaceStaleEntry来更换这个key为空的Entry


4. 不断循环检测，直到遇到为null的地方，这时候要是还没在循环过程中return，那么就在这个null的位置新建一个Entry，并且插入，同时size增加1。


5. 最后调用cleanSomeSlots，这个函数就不细说了，你只要知道内部还是调用了上面提到的expungeStaleEntry函数清理key为null的Entry就行了，最后返回是否清理了Entry，接下来再判断sz>thresgold,这里就是判断是否达到了rehash的条件，达到的话就会调用rehash函数。

rehash

private void rehash() {

    expungeStaleEntries();



    // Use lower threshold for doubling to avoid hysteresis

    if (size >= threshold - threshold / 4)

        resize();

}





private void resize() {

    Entry[] oldTab = table;

    int oldLen = oldTab.length;

    int newLen = oldLen * 2;

    Entry[] newTab = new Entry[newLen];

    int count = 0;



    for (int j = 0; j < oldLen; ++j) {

        Entry e = oldTab[j];

        if (e != null) {

            ThreadLocal<?> k = e.get();

            if (k == null) {

                e.value = null; // Help the GC

            } else {

                int h = k.threadLocalHashCode & (newLen - 1);

                while (newTab[h] != null)

                    h = nextIndex(h, newLen);

                newTab[h] = e;

                count++;

            }

        }

    }



    setThreshold(newLen);

    size = count;

    table = newTab;

}

1. 首先，size大于threshold的时候才会rehash。


2. 清理空key，如果size大于3/4的threshold，调用resize()函数。


3. 每次扩容大小扩展为原来的2倍，然后再一个for循环里，清除空key的Entry，同时重新计算key不为空的Entry的hash值，把它们放到正确的位置上，再更新ThreadLocalMap的所有属性。

remove

private void remove(ThreadLocal<?> key) {

    Entry[] tab = table;

    int len = tab.length;

    int i = key.threadLocalHashCode & (len-1);

    for (Entry e = tab[i];

         e != null;

         e = tab[i = nextIndex(i, len)]) {

         if (e.get() == key) {

            e.clear();

            expungeStaleEntry(i);

            return;

        }

    }

}

先计算出hash值，若是第一次没有命中，就循环直到null，在此过程中也会调用expungeStaleEntry清除空key节点。

什么是内存泄漏？

当程序分配了空间但是却忘了回收导致以后的程序都无法或暂时无法使用这块空间，就发生了内存泄漏。和内存溢出不一样，内存溢出是内存不足的时候出现的。这块要理解清楚，才能明白ThreadLocal为什么会导致内存泄漏。

Java 引用类型

要说到ThreadLocal引起内存泄漏，还得从java的四种引用类型说起。

java中有四种引用类型，分别是强软弱虚。

强引用

一个对象被强引用，那么他就不会被回收。

软引用

如果一个对象只具有软引用，那么它的性质属于可有可无的那种。如果此时内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。

软引用可以和一个引用队列联合使用，如果软件用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

    Object obj = new Object();

    ReferenceQueue queue = new ReferenceQueue();

    SoftReference reference = new SoftReference(obj, queue);

    //强引用对象滞空，保留软引用

    obj = null;

当内存不足时，软引用对象被回收时，reference.get()为null，此时软引用对象的作用已经发挥完毕，这时将其添加进ReferenceQueue 队列中

如果要判断哪些软引用对象已经被清理：

    SoftReference ref = null;

    while ((ref = (SoftReference) queue.poll()) != null) {

        //清除软引用对象

    }

弱引用

弱引用和软引用的区别就是，如果一个对象只有弱引用，那么只要GC，不管内存够不够，都会回收他的内存。注意这里的”只有弱引用“。如果这个对象还被其他变量强引用，那么他是不会被回收的。

虚引用

如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收的活动。

为什么要有四种引用类型？

1. 可以让程序员通过代码的方式来决定某个对象的生命周期。


2. 有利于垃圾回收


3. 能够实现一些复杂的数据结构。

ThreadLocal什么情况下会出现内存泄漏？

threadlocal里面使用了一个存在弱引用的map,当释放掉threadlocal的强引用以后,map里面的value却没有被回收.而这块value永远不会被访问到了. 所以存在着内存泄露。

如果这个时候还会去调用get set方法，那么这块内存可能会被清理掉。

如果没有去调用get set方法，如果这个线程很快销毁了，那么也不会内存泄漏。

最坏的情况就是，threadLocal对象设置成null了，然后使用线程池，这个线程被重复使用了，但是有一直没有调用get set方法，这个期间就会发生真正的内存泄漏。

其实ThreadLocal发生内存泄露的条件还是比较苛刻的，只要是使用规范，那么就没有什么问题。

ThreadLocal最佳实践

1. 每次使用完手动调用remove函数，删除不再使用的ThreadLocal.


2. 可以将ThreadLocal设置成private static的，这样ThreadLocal会尽量和线程本身一起消亡。

ThreadLocal应用案例

管理数据库连接。

  假如A类的方法a中，会调用B类的方法b和C类的方法c，a方法开启了事务，b方法和c方法会去操作数据库。我们知道，要想实现事务，那么b方法和c方法中所使用的的数据库连接一定是同一个连接，那怎么才能实现所用的是同一个数据库连接呢？答案就是通过ThreadLocal来管理。

MDC日志链路追踪。

MDC（Mapped Diagnostic Contexts）主要用于保存每次请求的上下文参数，同时可以在日志输出的格式中直接使用 %X{key} 的方式，将上下文中的参数输出至每一行日志中。而保存上下文信息主要就是通过ThreadLocal来实现的。
假如在交易流程每个环节的日志中，你都想打印全局流水号transId，流程可能涉及多个系统、多个线程、多个方法。有一些环节中，全局流水号并不能当做参数传递，那你怎么才能获取这个transId参数呢，这里就是利用了Threadlocal特性。每个系统或者线程在接收到请求时，都会将transId存放到ThreadLocal中，在输出日志时，将transId获取出来，进行打印。这样，我们就可以通过transId，在日志文件中查询全链路的日志信息了。

InheritableThreadLocal

使用ThreadLocal时，子线程获取不到父线程通过set方法保存的数据，要想使子线程也可以获取到，可以使用InheritableThreadLocal类。

RPC调用时使用 @Validated进行参数校验不起作用

球球了，RPC之间调用别再使用 if-else做参数校验了。众所周知，@Validated 是一款非常好用的参数校验工具。但在RPC调用时不可用，在当前的微服务大环境下，微服务之间的调用怎么做到优雅的参数校验呢？

话不多说，直接上干货

引包

<dependency>

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

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

</dependency>

1. 参数校验 这里我们先要定义一个注解来代替来继承 @Validated

import org.springframework.validation.annotation.Validated;



@Validated

public @interface RPCValidated {

}

2. 然后使用AOP来解析参数，进行参数校验。

import lombok.extern.slf4j.Slf4j;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.reflect.MethodSignature;

import org.hibernate.validator.messageinterpolation.ResourceBundleMessageInterpolator;

import org.hibernate.validator.resourceloading.PlatformResourceBundleLocator;

import org.springframework.stereotype.Component;

import wangjubao.base.common.extend.Response;



import javax.validation.ConstraintViolation;

import javax.validation.Validation;

import javax.validation.Validator;

import java.util.ArrayList;

import java.util.List;

import java.util.Set;



@Aspect

@Component

@Slf4j

public class ValidatedAop {

    private static Validator validator;



    static {

        validator = Validation.byDefaultProvider().configure()

                .messageInterpolator(new ResourceBundleMessageInterpolator(

                        new PlatformResourceBundleLocator("validationMessages")))

                .buildValidatorFactory().getValidator();

    }



    @Around("@annotation(com.qiaoba.annotation.RPCValidated))")

    public Object around(ProceedingJoinPoint joinPoint) {

        Object[] args = joinPoint.getArgs();

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();

        // 执行方法参数的校验

        Set<ConstraintViolation<Object>> constraintViolations = validator.forExecutables().validateParameters(joinPoint.getThis(), signature.getMethod(), args);

        List<String> messages = new ArrayList<>();

        for (ConstraintViolation<Object> error : constraintViolations) {

            messages.add(error.getMessage());

        }

        if (!messages.isEmpty()) {

            return Response.paramError("参数错误:", messages.get(0));

        }

        try {

            return joinPoint.proceed(args);

        } catch (Throwable e) {

            e.printStackTrace();

            return Response.error("操作失败:", e.getMessage());

        }

    }

}

3. 使用方法,在接口Impl实现类加上定义的@RPCValidated

@Override

@RPCValidated

public Response create(MessageSmsRechargeDto dto) {

    //todo：业务逻辑......

}

4. 在Interfaces接口层加上@Valid注解

Response create(@Valid MessageSmsRechargeDto params);

5. 实体类

@Data

public class MessageSmsRechargeDto implements Serializable {





    /**

     * 充值公司

     */

    @NotNull(message = "充值公司不能为空 ")

    private Long companyId;



    /**

     * 充值备注

     */

    @NotEmpty(message = "充值备注不能为空 ")

    private String rechargeRemark;

 }

--- 至此，整个流程完成，加上自定义的参数校验注解@RPCValidated后，就可以优雅的进行参数校验，不用再写各种if-else 做参数校验了

组件库可参考：flutter.dev、bruno(贝壳开源组件库)

以下从部分GetX文档转载 用于记录。
框架： Flutter GetX

GetX 是 Flutter 上的一个轻量且强大的解决方案：高性能的状态管理、智能的依赖注入和便捷的路由管理。

GetX 有3个基本原则：

性能： GetX 专注于性能和最小资源消耗。GetX 打包后的apk占用大小和运行时的内存占用与其他状态管理插件不相上下。效率： GetX 的语法非常简捷，并保持了极高的性能，能极大缩短你的开发时长。 结构： GetX 可以将界面、逻辑、依赖和路由完全解耦，用起来更清爽，逻辑更清晰，代码更容易维护。 GetX 并不臃肿，却很轻量。

三大功能

状态管理

目前，Flutter有几种状态管理器。但是，它们中的大多数都涉及到使用ChangeNotifier来更新widget，这对于中大型应用的性能来说是一个很糟糕的方法。你可以在Flutter的官方文档中查看到，ChangeNotifier应该使用1个或最多2个监听器，这使得它们实际上无法用于任何中等或大型应用。

Get 并不是比任何其他状态管理器更好或更差，而是说你应该分析这些要点以及下面的要点来选择只用Get，还是与其他状态管理器结合使用。

Get不是其他状态管理器的敌人，因为Get是一个微框架，而不仅仅是一个状态管理器，既可以单独使用，也可以与其他状态管理器结合使用。

Get有两个不同的状态管理器：简单的状态管理器（GetBuilder）和响应式状态管理器（GetX）。

响应式状态管理器

响应式编程可能会让很多人感到陌生，因为觉得它很复杂，但是GetX将响应式编程变得非常简单。

• 你不需要创建StreamControllers.


• 你不需要为每个变量创建一个StreamBuilder。


• 你不需要为每个状态创建一个类。


• 你不需要为一个初始值创建一个get。

使用 Get 的响应式编程就像使用 setState 一样简单。

让我们想象一下，你有一个名称变量，并且希望每次你改变它时，所有使用它的小组件都会自动刷新。

这就是你的计数变量。

var name = 'Jonatas Borges';

要想让它变得可观察，你只需要在它的末尾加上".obs"。

var name = 'Jonatas Borges'.obs;

而在UI中，当你想显示该值并在值变化时更新页面，只需这样做。

Obx(() => Text("${controller.name}"));

这就是全部，就这么简单。

关于状态管理的更多细节

关于状态管理更深入的解释请查看这里。在那里你将看到更多的例子，以及简单的状态管理器和响应式状态管理器之间的区别。

你会对GetX的能力有一个很好的了解。

路由管理

如果你想免上下文（context）使用路由/snackbars/dialogs/bottomsheets，GetX对你来说也是极好的，来吧展示：

在你的MaterialApp前加上 "Get"，把它变成GetMaterialApp。

GetMaterialApp( // Before: MaterialApp(

  home: MyHome(),

)

导航到新页面

Get.to(NextScreen());

用别名导航到新页面。查看更多关于命名路由的详细信息这里

Get.toNamed('/details');

要关闭snackbars, dialogs, bottomsheets或任何你通常会用Navigator.pop(context)关闭的东西。

Get.back();

进入下一个页面，但没有返回上一个页面的选项（用于闪屏页，登录页面等）。

Get.off(NextScreen());

进入下一个页面并取消之前的所有路由（在购物车、投票和测试中很有用）。

Get.offAll(NextScreen());

注意到你不需要使用context来做这些事情吗？这就是使用Get路由管理的最大优势之一。有了它，你可以在你的控制器类中执行所有这些方法，而不用担心context在哪里。

关于路由管理的更多细节

关于别名路由，和对路由的低级控制，请看这里。

依赖管理

Get有一个简单而强大的依赖管理器，它允许你只用1行代码就能检索到与你的Bloc或Controller相同的类，无需Provider context，无需inheritedWidget。

Controller controller = Get.put(Controller()); // 而不是 Controller controller = Controller();

• 注意：如果你使用的是Get的状态管理器，请多注意绑定api，这将使你的界面更容易连接到你的控制器。

你是在Get实例中实例化它，而不是在你使用的类中实例化你的类，这将使它在整个App中可用。 所以你可以正常使用你的控制器（或类Bloc）。

提示：  Get依赖管理与包的其他部分是解耦的，所以如果你的应用已经使用了一个状态管理器（任何一个，都没关系），你不需要全部重写，你可以使用这个依赖注入。

controller.fetchApi();

想象一下，你已经浏览了无数条路由，现在你需要拿到一个被遗留在控制器中的数据，那你需要一个状态管理器与Provider或Get_it一起使用来拿到它，对吗？用Get则不然，Get会自动为你的控制器找到你想要的数据，而你甚至不需要任何额外的依赖关系。

Controller controller = Get.find();

//是的，它看起来像魔术，Get会找到你的控制器，并将其提供给你。你可以实例化100万个控制器，Get总会给你正确的控制器。

然后你就可以恢复你在后面获得的控制器数据。

Text(controller.textFromApi);

类的生命周期

加载阶段

加载阶段可以细分如下

• 加载类的二进制流
• 数据结构转换，将二进制流所代表的静态存储结构转化成方法区的运行时的数据结构
• 生成java.lang.Class对象，作为方法区这个类的各种数据的访问入口

加载类的二进制流的方法

• 从zip包中读取。我们常见的JAR、AAR依赖
• 运行时动态生成。我们常见的动态代理技术，在java.reflect.Proxy中就是用ProxyGenerateProxyClass来为特定的接口生成代理的二进制流

验证

验证是连接阶段的第一步，这一阶段的目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

1. 文件格式验证：如是否以魔数 0xCAFEBABE 开头、主、次版本号是否在当前虚拟机处理范围之内、常量合理性验证等。
   此阶段保证输入的字节流能正确地解析并存储于方法区之内，格式上符合描述一个 Java类型信息的要求。
2. 元数据验证：是否存在父类，父类的继承链是否正确，抽象类是否实现了其父类或接口之中要求实现的所有方法，字段、方法是否与父类产生矛盾等。
   第二阶段，保证不存在不符合 Java 语言规范的元数据信息。
3. 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。例如保证跳转指令不会跳转到方法体以外的字节码指令上。
4. 符号引用验证：在解析阶段中发生，保证可以将符号引用转化为直接引用。

可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

准备

为类变量分配内存并设置类变量初始值，这些变量所使用的内存都将在方法区中进行分配。

解析

虚拟机将常量池内的符号引用替换为直接引用的过程。
解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符 7 类符号引用进行

初始化

到初始化阶段，才真正开始执行类中定义的 Java 程序代码，此阶段是执行 () 方法的过程。

类加载的时机

虚拟机规范规定了有且只有 5 种情况必须立即对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）

1. 遇到new、getstatic 和 putstatic 或 invokestatic 这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。对应场景是：使用 new 实例化对象、读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）、以及调用一个类的静态方法。

2. 对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。

3. 当初始化类的父类还没有进行过初始化，则需要先触发其父类的初始化。（而一个接口在初始化时，并不要求其父接口全部都完成了初始化）

4. 虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），
   虚拟机会先初始化这个主类。

5. 当使用 JDK 1.7 的动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getStatic、REF_putStatic、REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

注意：

1. 通过子类引用父类的静态字段，不会导致子类初始化。
2. 通过数组定义来引用类，不会触发此类的初始化。MyClass[] cs = new MyClass[10];
3. 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

类加载器

把实现类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作的代码模块称为“类加载器”。

将 class 文件二进制数据放入方法区内，然后在堆内（heap）创建一个 java.lang.Class 对象，Class 对象封装了类在方法区内的数据结构，并且向开发者提供了访问方法区内的数据结构的接口。

类的唯一性

对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性。

即使两个类来源于同一个 Class 文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那这两个类也不相等。
这里所指的“相等”，包括代表类的 Class 对象的 equals() 方法、 isAssignableFrom() 方法、isInstance() 方法的返回结果，也包括使用 instanceof 关键字做对象所属关系判定等情况

双亲委托机制

如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载。

    protected Class loadClass(String name, boolean resolve)

        throws ClassNotFoundException

    {

            // First, check if the class has already been loaded

//先从缓存中加没加载这个类

            Class c = findLoadedClass(name);

            if (c == null) {

                try {

                    if (parent != null) {

//从parent中加载

                        c = parent.loadClass(name, false);

                    } else {

                        c = findBootstrapClassOrNull(name);

                    }

                } catch (ClassNotFoundException e) {

                    // ClassNotFoundException thrown if class not found

                    // from the non-null parent class loader

                }

//加载不到，就自己加载

                if (c == null) {

                    // If still not found, then invoke findClass in order

                    // to find the class.

                    c = findClass(name);

                }

            }

            return c;

    }

 



 

好处

• 避免重复加载，当父加载器已经加载了该类的时候，就没有必要子ClassLoader再加载一次。
• 安全性考虑，防止核心API库被随意篡改。

Android中ClassLoader

• ClassLoader是一个抽象类，定义了ClassLoader的主要功能
• BootClassLoader是ClassLoader的子类（注意不是内部类，有些材料上说是内部类，是不对的），用于加载一些系统Framework层级需要的类，是Android平台上所有的ClassLoader的最终parent
• SecureClassLoader扩展了ClassLoader类，加入了权限方面的功能，加强了安全性
• URLClassLoader继承SecureClassLoader，用来通过URI路径从jar文件和文件夹中加载类和资源，在Android中基本无法使用
• BaseDexClassLoader是实现了Android ClassLoader的大部分功能
• PathClassLoader加载应用程序的类，会加载/data/app目录下的dex文件以及包含dex的apk文件或者java文件（有些材料上说他也会加载系统类，我没有找到，这里存疑）
• DexClassLoader可以加载自定义dex文件以及包含dex的apk文件或jar文件，支持从SD卡进行加载。我们使用插件化技术的时候会用到
• InMemoryDexClassLoader用于加载内存中的dex文件

ClassLoader的加载流程源码分析

-> ClassLoader.java 类

protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException {

    synchronized(this.getClassLoadingLock(name)) {

        //先查找class是否已经加载过，如果加载过直接返回

        Class c = this.findLoadedClass(name);

        if (c == null) {

            long t0 = System.nanoTime();



            try {

                if (this.parent != null) {

                   //委托给parent加载器进行加载 ClassLoader parent;

                    c = this.parent.loadClass(name, false);

                } else {

                   //当执行到顶层的类加载器时，parent = null

                    c = this.findBootstrapClassOrNull(name);

                }

            } catch (ClassNotFoundException var10) {

            }



            if (c == null) {

                long t1 = System.nanoTime();

                c = this.findClass(name);

                PerfCounter.getParentDelegationTime().addTime(t1 - t0);

                PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

                //如果parent加载器中没有找到，

                PerfCounter.getFindClasses().increment();

            }

        }



        if (resolve) {

            this.resolveClass(c);

        }



        return c;

    }

}



 

由子类实现

protected Class findClass(String name) throws ClassNotFoundException {

    throw new ClassNotFoundException(name);

}



 

BaseDexClassLoader类中findClass方法

protected Class findClass(String name) throws ClassNotFoundException {

    List suppressedExceptions = new ArrayList();

    // pathList是DexPathList，是具体存放代码的地方。

    Class c = pathList.findClass(name, suppressedExceptions);

    if (c == null) {

        ClassNotFoundException cnfe = new ClassNotFoundException(

                "Didn't find class "" + name + "" on path: " + pathList);

        for (Throwable t : suppressedExceptions) {

            cnfe.addSuppressed(t);

        }

        throw cnfe;

    }

    return c;

}



 

public Class findClass(String name, List suppressed) {

    for (Element element : dexElements) {

        Class clazz = element.findClass(name, definingContext, suppressed);

        if (clazz != null) {

            return clazz;

        }

    }



    if (dexElementsSuppressedExceptions != null) {

        suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));

    }

    return null;

}



 

public Class findClass(String name, ClassLoader definingContext,

        List suppressed) {

    return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed) : null;

}



 

public Class loadClassBinaryName(String name, ClassLoader loader, List suppressed) {

    return defineClass(name, loader, mCookie, this, suppressed);

}



private static Class defineClass(String name, ClassLoader loader, Object cookie,

                                 DexFile dexFile, List suppressed) {

    Class result = null;

    try {

        result = defineClassNative(name, loader, cookie, dexFile);

    } catch (NoClassDefFoundError e) {

        if (suppressed != null) {

            suppressed.add(e);

        }

    } catch (ClassNotFoundException e) {

        if (suppressed != null) {

            suppressed.add(e);

        }

    }

    return result;

}



// 调用 Native 层代码

private static native Class defineClassNative(String name, ClassLoader loader, Object cookie, DexFile dexFile)



 

本文转自 juejin.cn/post/703847…，如有侵权，请联系删除。

前言

在实际的开发项目中,一个对外暴露的接口往往会面临很多次请求，我们来解释一下幂等的概念：任意多次执行所产生的影响均与一次执行的影响相同。按照这个含义，最终的含义就是 对数据库的影响只能是一次性的，不能重复处理。如何保证其幂等性，通常有以下手段：

1、数据库建立唯一性索引，可以保证最终插入数据库的只有一条数据。

2、token机制，每次接口请求前先获取一个token，然后再下次请求的时候在请求的header体中加上这个token，后台进行验证，如果验证通过删除token，下次请求再次判断token。

3、悲观锁或者乐观锁，悲观锁可以保证每次for update的时候其他sql无法update数据(在数据库引擎是innodb的时候,select的条件必须是唯一索引,防止锁全表)

4、先查询后判断，首先通过查询数据库是否存在数据，如果存在证明已经请求过了，直接拒绝该请求，如果没有存在，就证明是第一次进来，直接放行。

redis 实现自动幂等的原理图：

搭建 Redis 服务 API

1、首先是搭建redis服务器。

2、引入springboot中到的redis的stater，或者Spring封装的jedis也可以，后面主要用到的api就是它的set方法和exists方法,这里我们使用springboot的封装好的redisTemplate。

推荐一个 Spring Boot 基础教程及实战示例：
github.com/javastacks/…

/**

 * redis工具类

 */

@Component

public class RedisService {



    @Autowired

    private RedisTemplate redisTemplate;



    /**

     * 写入缓存

     * @param key

     * @param value

     * @return

     */

    public boolean set(finalString key, Object value) {

        boolean result = false;

        try {

            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();

            operations.set(key, value);

            result = true;

        } catch (Exception e) {

            e.printStackTrace();

        }

        return result;

    }



    /**

     * 写入缓存设置时效时间

     * @param key

     * @param value

     * @return

     */

    public boolean setEx(finalString key, Object value, Long expireTime) {

        boolean result = false;

        try {

            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();

            operations.set(key, value);

            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);

            result = true;

        } catch (Exception e) {

            e.printStackTrace();

        }

        return result;

    }



    /**

     * 判断缓存中是否有对应的value

     * @param key

     * @return

     */

    public boolean exists(finalString key) {

        return redisTemplate.hasKey(key);

    }



    /**

     * 读取缓存

     * @param key

     * @return

     */

    public Objectget(finalString key) {

        Object result = null;

        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();

        result = operations.get(key);

        return result;

    }



    /**

     * 删除对应的value

     * @param key

     */

    public boolean remove(finalString key) {

        if (exists(key)) {

            Boolean delete = redisTemplate.delete(key);

            return delete;

        }

        returnfalse;



    }



}

自定义注解 AutoIdempotent

自定义一个注解，定义此注解的主要目的是把它添加在需要实现幂等的方法上，凡是某个方法注解了它，都会实现自动幂等。后台利用反射如果扫描到这个注解，就会处理这个方法实现自动幂等，使用元注解ElementType.METHOD表示它只能放在方法上，etentionPolicy.RUNTIME表示它在运行时。

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

public @interface AutoIdempotent {



}

token 创建和检验

token服务接口：我们新建一个接口，创建token服务，里面主要是两个方法，一个用来创建token，一个用来验证token。创建token主要产生的是一个字符串，检验token的话主要是传达request对象，为什么要传request对象呢？主要作用就是获取header里面的token,然后检验，通过抛出的Exception来获取具体的报错信息返回给前端。

publicinterface TokenService {



    /**

     * 创建token

     * @return

     */

    public  String createToken();



    /**

     * 检验token

     * @param request

     * @return

     */

    public boolean checkToken(HttpServletRequest request) throws Exception;



}

token的服务实现类：token引用了redis服务，创建token采用随机算法工具类生成随机uuid字符串,然后放入到redis中(为了防止数据的冗余保留,这里设置过期时间为10000秒,具体可视业务而定)，如果放入成功，最后返回这个token值。checkToken方法就是从header中获取token到值(如果header中拿不到，就从paramter中获取)，如若不存在,直接抛出异常。这个异常信息可以被拦截器捕捉到，然后返回给前端。

@Service

publicclass TokenServiceImpl implements TokenService {



    @Autowired

    private RedisService redisService;



    /**

     * 创建token

     *

     * @return

     */

    @Override

    public String createToken() {

        String str = RandomUtil.randomUUID();

        StrBuilder token = new StrBuilder();

        try {

            token.append(Constant.Redis.TOKEN_PREFIX).append(str);

            redisService.setEx(token.toString(), token.toString(),10000L);

            boolean notEmpty = StrUtil.isNotEmpty(token.toString());

            if (notEmpty) {

                return token.toString();

            }

        }catch (Exception ex){

            ex.printStackTrace();

        }

        returnnull;

    }



    /**

     * 检验token

     *

     * @param request

     * @return

     */

    @Override

    public boolean checkToken(HttpServletRequest request) throws Exception {



        String token = request.getHeader(Constant.TOKEN_NAME);

        if (StrUtil.isBlank(token)) {// header中不存在token

            token = request.getParameter(Constant.TOKEN_NAME);

            if (StrUtil.isBlank(token)) {// parameter中也不存在token

                thrownew ServiceException(Constant.ResponseCode.ILLEGAL_ARGUMENT, 100);

            }

        }



        if (!redisService.exists(token)) {

            thrownew ServiceException(Constant.ResponseCode.REPETITIVE_OPERATION, 200);

        }



        boolean remove = redisService.remove(token);

        if (!remove) {

            thrownew ServiceException(Constant.ResponseCode.REPETITIVE_OPERATION, 200);

        }

        returntrue;

    }

}

拦截器的配置

web配置类，实现WebMvcConfigurerAdapter，主要作用就是添加autoIdempotentInterceptor到配置类中，这样我们到拦截器才能生效，注意使用@Configuration注解，这样在容器启动是时候就可以添加进入context中。

@Configuration

publicclass WebConfiguration extends WebMvcConfigurerAdapter {



    @Resource

   private AutoIdempotentInterceptor autoIdempotentInterceptor;



    /**

     * 添加拦截器

     * @param registry

     */

    @Override

    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(autoIdempotentInterceptor);

        super.addInterceptors(registry);

    }

}

拦截处理器：主要的功能是拦截扫描到AutoIdempotent到注解到方法,然后调用tokenService的checkToken()方法校验token是否正确，如果捕捉到异常就将异常信息渲染成json返回给前端。

/**

 * 拦截器

 */

@Component

publicclass AutoIdempotentInterceptor implements HandlerInterceptor {



    @Autowired

    private TokenService tokenService;



    /**

     * 预处理

     *

     * @param request

     * @param response

     * @param handler

     * @return

     * @throws Exception

     */

    @Override

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {



        if (!(handler instanceof HandlerMethod)) {

            returntrue;

        }

        HandlerMethod handlerMethod = (HandlerMethod) handler;

        Method method = handlerMethod.getMethod();

        //被ApiIdempotment标记的扫描

        AutoIdempotent methodAnnotation = method.getAnnotation(AutoIdempotent.class);

        if (methodAnnotation != null) {

            try {

                return tokenService.checkToken(request);// 幂等性校验, 校验通过则放行, 校验失败则抛出异常, 并通过统一异常处理返回友好提示

            }catch (Exception ex){

                ResultVo failedResult = ResultVo.getFailedResult(101, ex.getMessage());

                writeReturnJson(response, JSONUtil.toJsonStr(failedResult));

                throw ex;

            }

        }

        //必须返回true,否则会被拦截一切请求

        returntrue;

    }



    @Override

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {



    }



    @Override

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {



    }



    /**

     * 返回的json值

     * @param response

     * @param json

     * @throws Exception

     */

    private void writeReturnJson(HttpServletResponse response, String json) throws Exception{

        PrintWriter writer = null;

        response.setCharacterEncoding("UTF-8");

        response.setContentType("text/html; charset=utf-8");

        try {

            writer = response.getWriter();

            writer.print(json);



        } catch (IOException e) {

        } finally {

            if (writer != null)

                writer.close();

        }

    }



}

测试用例

模拟业务请求类，首先我们需要通过/get/token路径通过getToken()方法去获取具体的token，然后我们调用testIdempotence方法，这个方法上面注解了@AutoIdempotent，拦截器会拦截所有的请求，当判断到处理的方法上面有该注解的时候，就会调用TokenService中的checkToken()方法，如果捕获到异常会将异常抛出调用者，下面我们来模拟请求一下：

@RestController

publicclass BusinessController {



    @Resource

    private TokenService tokenService;



    @Resource

    private TestService testService;



    @PostMapping("/get/token")

    public String  getToken(){

        String token = tokenService.createToken();

        if (StrUtil.isNotEmpty(token)) {

            ResultVo resultVo = new ResultVo();

            resultVo.setCode(Constant.code_success);

            resultVo.setMessage(Constant.SUCCESS);

            resultVo.setData(token);

            return JSONUtil.toJsonStr(resultVo);

        }

        return StrUtil.EMPTY;

    }



    @AutoIdempotent

    @PostMapping("/test/Idempotence")

    public String testIdempotence() {

        String businessResult = testService.testIdempotence();

        if (StrUtil.isNotEmpty(businessResult)) {

            ResultVo successResult = ResultVo.getSuccessResult(businessResult);

            return JSONUtil.toJsonStr(successResult);

        }

        return StrUtil.EMPTY;

    }

}

使用postman请求，首先访问get/token路径获取到具体到token：

利用获取到到token,然后放到具体请求到header中,可以看到第一次请求成功，接着我们请求第二次：

第二次请求，返回到是重复性操作，可见重复性验证通过，再多次请求到时候我们只让其第一次成功，第二次就是失败：

总结

本篇博客介绍了使用springboot和拦截器、redis来优雅的实现接口幂等，对于幂等在实际的开发过程中是十分重要的，因为一个接口可能会被无数的客户端调用，如何保证其不影响后台的业务处理，如何保证其只影响数据一次是非常重要的，它可以防止产生脏数据或者乱数据，也可以减少并发量，实乃十分有益的一件事。而传统的做法是每次判断数据，这种做法不够智能化和自动化，比较麻烦。而今天的这种自动化处理也可以提升程序的伸缩性。

FlutterWeb初体验

[toc]

背景

因为最近业务需求的变动，在APP的某一部分页面会经常性发生变动，一般情况下来说，这种不稳定的页面不应该由原生来承担，修改发版的成本太大了，最合理的做法是由H5来承担，由原生提供必要的bridge来调用原生方法，但是由于种种历史债务，还是没有如此实现，经历了痛苦的发版以及等待审核后，我在想flutterWeb是不是可以解决这个问题？

想法

页面进入流程

项目架构想法

整个项目转为支持FlutterWeb

整个项目转为flutterweb，可以打包成web文件直接部署在服务器，而app依旧打包成apk和ipa，但是在路由监听处留下开关，当有页面需要紧急修复或者紧急更改的情况下，下发配置，跳转的时候根据路由配置跳转WebView或者原生页面。

抽离出某个模块，单个模块支持web

抽离出一个module，由一个壳工程引用，这个壳工程用于把该module打包成web；同时该模块依然被app工程引用，作为一个功能模块，而部署的时候只部署了这个模块的web产物。

因为目前app集成了一定数量的原生端的第三方sdk，直接支持flutterweb工程量较大，所以先尝试第二个方法。

壳工程结构图

其中

flutter_libs 是基础的lib库，封装了基础的网络请求，持久化存储，状态管理等基础，壳工程和app工程也会引用

ly_income是功能module，也是我们主要开发需求的模块，它会被壳工程引用作为web的打包内容，也会被app工程引用作为原生的页面展示。

实践

打包问题处理

因为是新建的项目工程，打包成flutterWeb并不会有那么多障碍。

开启web支持

执行 flutter config查看目前的配置信息，如果看到

Settings:

  enable-web: true

  enable-macos-desktop: true

那就是已经开启了，如果还没，可以使用flutter config --enable-web开启配置

打包模式选择

而flutterWeb打包也有两种模式可以选择：html模式和CanvasKit模式

它们两者各自的特别是：

html模式

flutter build web --web-renderer html

当我们采用html渲染模式时，flutter会采用HTML的custom element，CSS，Canvas和SVG来渲染UI元素

优点是：体积比较小

缺点是：渲染性能比较差，跨端一致性可能不受保障

CanvasKit模式

flutter build web --web-renderer canvaskit

当我们采用canvaskit渲染模式时，flutter将 Skia 编译成 WebAssembly 格式，并使用 WebGL 渲染。应用在移动和桌面端保持一致，有更好的性能，以及降低不同浏览器渲染效果不一致的风险。但是应用的大小会增加大约 2MB。

优点是：跨端一致性受保障，渲染性能更好

缺点是：体积比较大，load页面时间会更久

跨域问题处理

之前一直是做app开发，跨域这个词只听过，还没见识过。

了解跨域

跨域是指浏览器的不执行其他网站脚本的，由于浏览器的同源策略造成，是对JavaScript的一种安全限制

说白点理解，当你通过浏览器向其他服务器发送请求时，不是服务器不响应，而是服务器返回的结果被浏览器限制了。

而什么是同源策略的同源

同源指的是协议、域名、端口 都要保持一致

http://www.123.com:8080/index.html （http协议，http://www.123.com 域名、8080 端口 ，只要这三个有一项不一样的都是跨域，这里不一一举例子）

http://www.123.com:8080/matsh.html（…

http://www.123.com:8081/matsh.html（…

注意：localhost 和127.0.0.1 虽然都指向本机，但也属于跨域。

而跨域的解决方法也暂时不适用我：

1. JSONP方式 （我们项目的请求都是post请求）


2. 反向代理，ngixn （ngixn小白）


3. 配置浏览器 （好像不太适用，应该，大概，也许，可能，或许）


4. 项目配置跨域 （因为只是尝试项目，需要后台和运维支持的话，需要跨部门沟通，太麻烦了）

摘自网络 什么是跨域，侵删歉

常规做法

1. 
   

   本地调试的时候修改代码，支持跨域请求

   
   

   在上图红框中添加代码--disable-web-security

   
   

然后删除以下两个文件，执行flutter doctor生成新的一份，再尝试run起来，你会发现浏览器已经支持跨域了，你可以很开心地在浏览器run接口了。但是仅支持本地调试！！！

2. ngixn做转发，但是这个... 我没有怎么用过ngixn，而且需要在周末做完调研给出可行性报告，也没有时间去学习，先搁置，后续再拿起来看看


3. 后端和运维同学帮忙调试跨域，因为是尝试而已，没有必要用到其他部门的资源，先搁置，后续如果可实际应用，再要求他们协助。

骚操作

保命前提：

1. 这个其实就是配置转发的做法，但是这块我没什么经验，时间紧任务重所以就先这么尝试做了


2. 其实这个就是类似于openfeign之类的想法，但是我并不知道后台开发的FeignClient，而且也有点危险，还是调用开发的接口更加稳妥


3. 纯个人做法，肯定还会有更好的方法，但是这个是我当时最快的达成方案，勿喷。

如果说我要求不了后台服务做跨域，那可不可以我自己要求我自己做跨域呢？

比如：

我请求我的服务器，我的服务器再去请求后台服务，我访问后台服务跨域而已，我的服务器访问后台服务可不跨域，我的服务器跨域又咋样，自己的东西随便拿捏。

1. 新建一个springboot项目


2. 搭建一个controller，参数是url全路径以及参数json字符串，配置好header之后请求后台服务并返回信息

@CrossOrigin

@RestController

@RequestMapping("api/home")

public class GatewayController {



    @PostMapping("/gatewayApi")

    public String gatewayApi(@RequestParam("url") String url, @RequestParam("params") String json) {

        try {

            JSONObject jsonObject = JSONObject.parseObject(json);

            JSONObject result = doPost(jsonObject, url);

            if (result != null) {

                return result.toString();

            } else {

                return errMsg().toString();

            }

        } catch (Exception e) {

            return errMsg(e.getMessage()).toString();

        }

    }

}

3. 配置跨域信息

@SpringBootConfiguration

public class WebGlobalConfig {



    @Bean

    public CorsFilter corsFilter() {



        //创建CorsConfiguration对象后添加配置

        CorsConfiguration config = new CorsConfiguration();

        //设置放行哪些原始域

        config.addAllowedOriginPattern("*");

        //放行哪些原始请求头部信息

        config.addAllowedHeader("*");

        //暴露哪些头部信息

        config.addExposedHeader("*");

        //放行哪些请求方式

        config.addAllowedMethod("GET");     //get

        config.addAllowedMethod("PUT");     //put

        config.addAllowedMethod("POST");    //post

        config.addAllowedMethod("DELETE");  //delete

        //corsConfig.addAllowedMethod("*");     //放行全部请求



        //是否发送Cookie

        config.setAllowCredentials(true);



        //2. 添加映射路径

        UrlBasedCorsConfigurationSource corsConfigurationSource =

                new UrlBasedCorsConfigurationSource();

        corsConfigurationSource.registerCorsConfiguration("/**", config);

        //返回CorsFilter

        return new CorsFilter(corsConfigurationSource);

    }

}

4. 打包后部署到服务器


5. module里的接口不再请求后台服务，而是请求我的服务器，因为只是转发，所以没有改动任何数据结构，只需要请求地址改动下


6. 可以跨域了

与原生交互问题

设想中web的页面可以有三种方式：

1. 集成在app里面作为原生页面，这个的交互没什么好说的。


2. 打包成web项目，通过webview进行加载，那需要额外处理持久化信息的获取与写入，以及与原生页面的跳转交互


3. 只有url，测试人员可以通过url路径传参之类的切换账号，方便测试

针对业务来说，页面的加载流程应该是这样的：

不同场景做不同的操作

原生

通过持久化工具类获取用户基础信息，然后读取接口判断身份，根据身份去做不同展示，点击跳转时间也是直接的通过路由跳转

通过webview加载

通过js交互，从原生模块拿到用户基础信息（存疑，是否直接读接口？，这样避免对原生api的依赖，如果有需求修改的话可以尽量不依赖），然后读取接口判断身份，根据身份不同去做不同展示，如果是dialog之类的交互可以直接实现，如果是跳转页面之类的，可以通过js交互进行原生操作

通过url加载的

通过url的参数串获取到对应的用户id，读取接口获取用户信息，其他操作如上，但是页面没有跳转之类的交互

实现

从链接上面获取参数

比如url为：```xxx.yyy.zzz/value

要如何拿到value值？

因为项目里刚好使用了Get做状态管理，而刚好Get已经实现了这一块，世间上的事情就是这么刚好。（好像navigator2已经支持这个了，不过还没仔细看过）

1. 
   

   配置路由表

   
   

   
   
   class RouterConf {
   
     static const String appIncomeArgs = '/app/inCome/:fromApp';
   
     static const String appIncome = '/app/inCome/';
   
     static List<GetPage> _getPages = [];
   
     static List<GetPage> get getPages {
   
       _getPages = [
   
         GetPage(name: appIncomeArgs, page: () => const StoreKeeperInComePage()),
   
       ];
   
       return _getPages;
   
     }
   
   }
   

   
   

   这里appIncome配置了两个路由名

   
   

   但是实际使用时以没带**:fromApp为准的，fromApp我觉得可以理解成一个占位符，也就是fromApp=value**

   
   


2. 
   

   获取对应的value

   
   

   在base类里面定义一个bool值,在init的回调里面去做获取操作

   
   

     bool ifFromApp = false;
   
     Map<String, String?> _args = Get.parameters;
   
     if (_args.isNotEmpty && _args.containsKey('fromApp')) {
   
         String? _fromAppFlag = Get.parameters['fromApp'];
   
         if ((_fromAppFlag?.isNotEmpty ?? false)) {
   
           ifFromApp = _fromAppFlag == "1";
   
         }
   
       }
   

   
   

根据不同情景做操作

以在webview打开为例，在页面加载时通过js交互获取用户信息，拿到用户信息后替换cache类里缓存的id，token之类的，因为拦截器里面会读取这些值用于拼接通用参数

  @override

  void onReady() {

    if (ifFromApp) {

      initUserInfo();

      js.context['getUserInfoCallback'] = getUserInfoCallback;

    }else{

      _loadInterface();

    }



    super.onReady();

  }



  void initUserInfo() {

    js.context.callMethod("callFlutterMethod", [

      json.encode({

        "api": "getUserInfo",

        "data": {

          "name": 'getUserInfo',

          "needCallback": true,

          "needToken": true,

          "callbackName": 'getUserInfoCallback',

          "callbackArgs": 'info'

        },

      })

    ]);

  }

  

  void getUserInfoCallback(msg, info) {

    Map<String, dynamic> _args = {};

    if (info != null) {

      if (info is String) {

        _args = jsonDecode(info);

      } else {

        _args = info;

      }

      if (_args.containsKey("info")) {

        dynamic _realInfo = _args['info'];

        if (_realInfo is String) {

          _args = jsonDecode(_realInfo);

        } else {

          _args = _realInfo;

        }

      }

      if (_args.containsKey('name')) {

        debugPrint(' _args[name]---------${_args['name']}');

        CacheManager.instance.oName = _args['name'];

      }

      if (_args.containsKey('uId')) {

        debugPrint(' _args[uId]---------${_args['uId']}');



        CacheManager.instance.userId = _args['uId'];

      }

      if (_args.containsKey('oId')) {

        debugPrint(' _args[oId]---------${_args['oId']}');

        CacheManager.instance.userOId = _args['oId'];

      }

      if (_args.containsKey('token')) {

        debugPrint(' _args[token]---------${_args['token']}');



        CacheManager.instance.userToken = _args['token'];

      }

      if (_args.containsKey('headImg')) {

        debugPrint(' _args[headImg]---------${_args['headImg']}');

        CacheManager.instance.headImgUrl = _args['headImg'];

      }

      state.userName = CacheManager.instance.oName;

      state.userHeaderImg = CacheManager.instance.headImgUrl;

      _loadInterface();

    }

  }

每次都做这个判断是真的恶心，应该把这些东西抽离出来，通过中间件去实现，避免页面上耦合了这个判断。

接下去就是正常的请求接口渲染页面的流程了。

与原生的交互

这里借鉴的是这位大佬的文章 flutterweb与flutter的交互 侵删歉

唯一需要注意的就是在web项目里面增加一个js

在app里面也要做一点操作：

class NativeBridge implements JavascriptChannel {

  BuildContext context; //来源于当前widget, 便于操作UI

  Future<WebViewController> _controller; //当前webView 的 controller



  NativeBridge(this.context, this._controller);



  // api 与具体函数的映射表，可通过 _functions[key](data) 调用函数

  get _functions => <String, Function>{

        "getUserInfo": _getUserInfo,

        "incomeDetail": _incomeDetail,

        "incomeHistory": _incomeHistory,

      };



  @override

  String get name =>

      "nativeBridge"; // js 通过 nativeBridge.postMessage(msg); 调用flutter



  // 处理js请求

  @override

  get onMessageReceived => (msg) async {

        // 将收到的string数据转为json

        Map<String, dynamic> message = json.decode(msg.message);

        // 异步是因为有些api函数实现可能为异步，如inputText，等待UI相应

        // 根据 api 字段，调用具体函数

        final data = await _functions[message["api"]](message["data"]);

      };



  //拿token

  _getUserInfo(data) async {

    handlerCallback(data);

  } //拿token



  _incomeDetail(data) async {

    Get.toNamed(RouterConf.OLD_STOREKEEPER_INCOME_LIST);

  }



  _incomeHistory(data) async {

    Get.toNamed(RouterConf.STORE_KEEPER_INCOME_HISTORY);

  }



  handlerCallback(data) async {

    LoginModel? _login = await UserManager.getLoginModel();

    UserInfoModel? _user = await UserManager.getUserInfo();

    String? _name = _user?.resultData?.organization?.organizationName;

    String? _uId = _user?.resultData?.user?.userId?.toString() ?? "";

    String? _oId =

        _user?.resultData?.organization?.organizationId?.toString() ?? "";

    String? _token = _login?.resultData?.xAUTHTOKEN;

    String? _img = _user?.resultData?.user?.portraitUrl;

    _img = ImgSize.getImgUrlThumbnail(_img);

    Map<String, dynamic> _infos = {

      "name": _name,

      "uId": _uId,

      "oId": _oId,

      "token": _token,

      "headImg": _img,

    };



    if (data['needCallback']) {

      var args = data['callbackArgs'];

      if (data['needToken']) {

        args = "'${data['callbackArgs']}','${jsonEncode(_infos)}'";

      }

      doCallback(data['callbackName'], args);

    }

  }



  doCallback(name, args) {

    _controller.then((value) => value.evaluateJavascript("$name($args)"));

  }

}

在webview里面设置channels：

 javascriptChannels: <JavascriptChannel>[

        NativeBridge(context, widget.controller!.future)

      ].toSet(),

结尾

目前来说好像这个方案是可行的，把一个app页面通过网页跑起来确实是挺爽的，但是慢也是真的慢，

也可能因为我的服务器是丐版中的丐版，加载起来是真的慢：

但是挺好玩的，虽然代码很烂，但是开心就是了。

这边文章主要将掘金app的文章详情界面的内容构造和效果的实现，也是完结篇，或者有兴趣的同学们可以谈论想要去实现哪个页面的或者功能都可以谈论起来。一起进步。一个人终究没有一群人会走得远。

标题部分

看了一下掘金app文章详情的效果，我的思路是自定义一个appbar然后，左半部分是一个返回按钮，右部分是点击弹出分享的悬浮窗口，中间部分根据内容列表的滑动进行改变，大体思路就是通过pageView构建中间部分，禁止手势滑动，使用主动触发滑动效果，触发机制是内容滑动改变的距离
效果如下：

import 'package:flutter/cupertino.dart';

import 'package:flutter/material.dart';

import 'package:get/get.dart';



class DetailPage extends StatefulWidget {

  DetailPage({Key key}) : super(key: key);



  @override

  _DetailPageState createState() => _DetailPageState();

}



class _DetailPageState extends State<DetailPage> {

  PageController controller = new PageController();

  @override

  Widget build(BuildContext context) {

    return Scaffold(

        body: Column(

      children: [

        Container(

          width: Get.width,

          height: 80,

          decoration: BoxDecoration(color: Colors.white),

          padding: EdgeInsets.only(

              top: Get.context.mediaQueryPadding.top, left: 10, right: 10),

          child: Row(

            children: [

              InkWell(

                child: Icon(

                  CupertinoIcons.back,

                  color: Color.fromRGBO(38, 38, 40, 1),

                ),

                onTap: () {

                  print('点击了返回');

                  Get.back();

                },

              ),

              Expanded(

                  child: PageView.builder(

                itemBuilder: (context, index) {

                  if (index == 0) {

                    return Container(

                      alignment: Alignment.center,

                      child: Text('一步一步完成Flutter应用开发-掘金文章详情页面'),

                    );

                  }

                  return Container(

                    child: Row(

                      children: [

                        Container(

                          height: 20,

                          width: 20,

                          decoration: BoxDecoration(

                              color: Colors.red,

                              borderRadius: BorderRadius.circular(10)),

                        )

                      ],

                    ),

                  );

                },

                itemCount: 2,

                scrollDirection: Axis.vertical,

                physics: NeverScrollableScrollPhysics(),

                controller: controller,

              )),

              InkWell(

                child: Icon(

                  Icons.list,

                  color: Color.fromRGBO(38, 38, 40, 1),

                ),

                onTap: () {

                  controller.animateTo(40,

                      duration: Duration(milliseconds: 500),

                      curve: Curves.ease);

                },

              ),

            ],

          ),

        )

      ],

    ));

  }

}

基于这个思想接下来完成下面的内容

内容部分的构建

这部分想要知道掘金内容的返回格式是什么，是markdown内容或者是html内容，如果是html内容传送门，可以参考一下。
效果：

这块主要是通过markdown形式展示详情内容引入

flutter_markdown: ^0.5.2

在上述代码中加入详情内容代码

ScrollController _scrollController = new ScrollController();



  @override

  void initState() {

    super.initState();

    _scrollController

      ..addListener(() {

        setState(() {

          if (_scrollController.offset > 88 && _scrollController.offset < 100) {

            controller.animateTo(30,

                duration: Duration(milliseconds: 500), curve: Curves.ease);

          } else if (_scrollController.offset <= 0) {

            controller.animateTo(0,

                duration: Duration(milliseconds: 500), curve: Curves.ease);

          }

        });

      });

  }

  

  @override

  Widget build(BuildContext context) {

      ...省略上述代码

      //_markdownData为内容常量

      Expanded(

            child: Markdown(

          data: _markdownData,

          controller: _scrollController,

        ))

  }

悬浮弹窗

使用getX的Get.dialog进行展示悬浮弹窗
效果：

代码如下：

renderItem(title) {

    return Column(

      children: [

        Container(

          height: 40,

          width: 40,

          margin: EdgeInsets.only(top: 10),

          decoration: BoxDecoration(

              color: Colors.red, borderRadius: BorderRadius.circular(20)),

        ),

        Padding(padding: EdgeInsets.only(top: 8)),

        Material(

          child: Text(title),

        )

      ],

    );

  }



//调用方法

Get.dialog(

                      UnconstrainedBox(

                        alignment: Alignment.bottomCenter,

                        child: Container(

                            width: Get.width,

                            height: Get.height * 0.6,

                            decoration: BoxDecoration(

                                color: Colors.white,

                                borderRadius: BorderRadius.only(

                                    topLeft: Radius.circular(20),

                                    topRight: Radius.circular(20))),

                            child: Column(

                              children: [

                                Padding(padding: EdgeInsets.only(top: 40)),

                                Row(

                                  mainAxisAlignment:

                                      MainAxisAlignment.spaceAround,

                                  crossAxisAlignment: CrossAxisAlignment.center,

                                  children: [

                                    renderItem('卡片分享'),

                                    renderItem('微信分享'),

                                    renderItem('朋友圈分享'),

                                    renderItem('微博分享'),

                                  ],

                                ),

                                Padding(padding: EdgeInsets.only(top: 20)),

                                Divider(

                                  height: 2,

                                  color: Colors.grey,

                                ),

                                Padding(padding: EdgeInsets.only(top: 20)),

                                Row(

                                  mainAxisAlignment:

                                      MainAxisAlignment.spaceAround,

                                  crossAxisAlignment: CrossAxisAlignment.center,

                                  children: [

                                    renderItem('卡片分享'),

                                    renderItem('微信分享'),

                                    renderItem('朋友圈分享'),

                                    renderItem('微博分享'),

                                  ],

                                ),

                                Row(

                                  mainAxisAlignment:

                                      MainAxisAlignment.spaceAround,

                                  crossAxisAlignment: CrossAxisAlignment.center,

                                  children: [

                                    renderItem('卡片分享'),

                                    renderItem('微信分享'),

                                    renderItem('朋友圈分享'),

                                    renderItem('微信分享'),

                                  ],

                                ),

                                Expanded(child: Container()),

                                GestureDetector(

                                  onTap: () {

                                    Get.back();

                                  },

                                  child: Container(

                                    margin: EdgeInsets.only(

                                        bottom: Get

                                            .context.mediaQueryPadding.bottom),

                                    width: Get.width,

                                    height: 40,

                                    alignment: Alignment.center,

                                    child: Material(

                                      child: Text(

                                        '取消',

                                      ),

                                    ),

                                  ),

                                ),

                              ],

                            )),

                      ),

                      useRootNavigator: false,

                      useSafeArea: false);

over ～～～～

概述

Lottie 是一款优秀的移动应用动画效果框架，支持为原生应用添加动画效果。Lottie 在不需要对代码进行重写的情况下让工程师更加方便的创建更丰富的动画效果，有了 Lottie 就不再需要使用 Gif 动画来展现效果，在移动开发领域 Lottie 已经广为人知。 伴随着 Jetpack Compose 1.0 的正式发布，Lottie 也同样支持了 Jetpack Compose。这篇文章将指引你如何在 Jeptack Compose 中使用 Lottie 动画。这篇文章所使用的 Lottie 动画文件来自 Lottie 官方网站 ，你可以在这里找到更多免费的 Lottie 动画文件。

添加 Lottie 依赖项

你需要 build.gradle(app) 脚本文件中，添加依赖项目。

implementation "com.airbnb.android:lottie-compose:4.0.0"

配置 Lottie 资源

你可以通过 Lottie 官方网站 或其他途径获取到你想要添加的Lottie动画对应静态 json 资源，或者你也可以使用URL方式。

如果你使用的是静态 json 文件方式，你可以将其放入 res/raw 目录下。

如果你使用的是URL方式，后续需要加载 lottie 时，你可以选用 URL 方式。

创建 Lottie 动画

首先，我们创建两个 mutableState 用于描述动画的速度与开始暂停状态。

var isPlaying by remember {

    mutableStateOf(true)

}

var speed by remember {

    mutableStateOf(1f)

}

下一步，我们需要加载我们预先准备好的 Lottie资源。 这里我选择使用本地res/raw目录下静态资源的方式。

val lottieComposition by rememberLottieComposition(

     spec = LottieCompositionSpec.RawRes(R.raw.lottie),

)

当然 Lottie 还为你提供了其他加载方式。

sealed interface LottieCompositionSpec {

    // 加载 res/raw 目录下的静态资源

    inline class RawRes(@androidx.annotation.RawRes val resId: Int) : LottieCompositionSpec



    // 加载 URL

    inline class Url(val url: String) : LottieCompositionSpec



    // 加载手机目录下的静态资源

    inline class File(val fileName: String) : LottieCompositionSpec



    // 加载 asset 目录下的静态资源

    inline class Asset(val assetName: String) : LottieCompositionSpec



    // 直接加载 json 字符串

    inline class JsonString(val jsonString: String) : LottieCompositionSpec

}

再接下来，我们还需要描述 Lottie 的动画状态。

val lottieAnimationState by animateLottieCompositionAsState (

    composition = lottieComposition, // 动画资源句柄

    iterations = LottieConstants.IterateForever, // 迭代次数

    isPlaying = isPlaying, // 动画播放状态

    speed = speed, // 动画速度状态

    restartOnPlay = false // 暂停后重新播放是否从头开始

)

最后，我们仅需要把动画资源句柄和动画状态提供给 LottieAnimation Composable 即可。

LottieAnimation(

    lottieComposition,

    lottieAnimationState,

    modifier = Modifier.size(400.dp)

)

效果展示

源代码

@Preview

@Composable

fun LottieDemo() {

    var isPlaying by remember {

        mutableStateOf(true)

    }

    var speed by remember {

        mutableStateOf(1f)

    }



    val lottieComposition by rememberLottieComposition(

        spec = LottieCompositionSpec.RawRes(R.raw.lottie),

    )



    val lottieAnimationState by animateLottieCompositionAsState (

        composition = lottieComposition,

        iterations = LottieConstants.IterateForever,

        isPlaying = isPlaying,

        speed = speed,

        restartOnPlay = false

    )





    Box(

        modifier = Modifier.fillMaxSize(),

        contentAlignment = Alignment.Center

    ) {

        Column {

            Text(

                text = "Lottie Animation In Jetpack Compose",

                fontSize = 30.sp

            )

            Spacer(modifier = Modifier.height(30.dp))

            LottieAnimation(

                lottieComposition,

                lottieAnimationState,

                modifier = Modifier.size(400.dp)

            )



            Row(

                horizontalArrangement = Arrangement.SpaceAround,

                modifier = Modifier.fillMaxWidth(),

                verticalAlignment = Alignment.CenterVertically

            ) {

                Row(

                    horizontalArrangement = Arrangement.SpaceBetween,

                    verticalAlignment = Alignment.CenterVertically

                ) {

                    Button(

                        onClick = {

                            speed = max(speed - 0.25f, 0f)

                        },

                        colors = ButtonDefaults.buttonColors(

                            backgroundColor = Color(0xFF0F9D58)

                        )

                    ) {

                        Text(

                            text = "-",

                            color = Color.White,

                            fontWeight = FontWeight.Bold,

                            fontSize = 20.sp,

                        )

                    }



                    Text(

                        text = "Speed ( $speed ) ",

                        color = Color.Black,

                        fontWeight = FontWeight.Bold,

                        fontSize = 15.sp, modifier = Modifier.padding(horizontal = 10.dp)



                    )

                    Button(

                        onClick = {

                            speed += 0.25f

                        },

                        colors = ButtonDefaults.buttonColors(

                            backgroundColor = Color(0xFF0F9D58)

                        )

                    ) {

                        Text(

                            text = "+",

                            color = Color.White,

                            fontWeight = FontWeight.Bold,

                            fontSize = 20.sp

                        )

                    }

                }



                Button(

                    onClick = {

                        isPlaying = !isPlaying

                    },

                    colors = ButtonDefaults.buttonColors(

                        backgroundColor = Color(0xFF0F9D58)

                    )

                ) {

                    Text(

                        text = if (isPlaying) "Pause" else "Play",

                        color = Color.White

                    )

                }

            }

        }

    }

}

前言

用了这么久 Flutter 了，居然都不知道他的启动过程，真的是学之有愧啊，今天我们来分析一下 Flutter 的启动流程，以及他的渲染过程，对其做一个简单的剖析。

启动流程

Flutter 的启动入口在 lib/main.dart 里的 main() 函数中，他是 Dart 应用程序的起点，main 函数中最简单的实现如下：

void main() => runApp(MyApp());

可以看到，main 函数中只调用了 runApp() 方法，我们看看它里面都干了什么：

void runApp(Widget app) {

  WidgetsFlutterBinding.ensureInitialized()

    ..scheduleAttachRootWidget(app)

    ..scheduleWarmUpFrame();

}

接收了一个 widget 参数，它是 Flutter 启动后要展示的第一个组件，而 WidgetsFlutterBinding 正是绑定 widget 和 Flutter 引擎的桥梁，定义如下：

/// 基于 Widgets 框架的应用程序的具体绑定。

class WidgetsFlutterBinding extends BindingBase with GestureBinding, SchedulerBinding, ServicesBinding, PaintingBinding, SemanticsBinding, RendererBinding, WidgetsBinding {



  static WidgetsBinding ensureInitialized() {

    if (WidgetsBinding.instance == null)

      WidgetsFlutterBinding();

    return WidgetsBinding.instance!;

  }

}

可以看到 WidgetsFlutterBinding 继承自 BindingBase ，并且混入了很多 Binding，在介绍这些 Binding 之前我们先介绍一下 Window ，下面是 Window 的官方解释：

The most basic interface to the host operating system's user interface.

主机操作系统用户界面的最基本界面。

很明显，Window 正是 Flutter Framework 连接宿主操作系统的接口，

我们看一下 Window 类的部分定义：

@Native("Window,DOMWindow")

class Window extends EventTarget  implements WindowEventHandlers,  WindowBase  GlobalEventHandlers,

        _WindowTimers, WindowBase64 {

          

  // 当前设备的DPI，即一个逻辑像素显示多少物理像素，数字越大，显示效果就越精细保真。

  // DPI是设备屏幕的固件属性，如Nexus 6的屏幕DPI为3.5 

  double get devicePixelRatio => _devicePixelRatio;

  

  // Flutter UI绘制区域的大小

  Size get physicalSize => _physicalSize;



  // 当前系统默认的语言Locale

  Locale get locale;

    

  // 当前系统字体缩放比例。  

  double get textScaleFactor => _textScaleFactor;  

    

  // 当绘制区域大小改变回调

  VoidCallback get onMetricsChanged => _onMetricsChanged;  

  // Locale发生变化回调

  VoidCallback get onLocaleChanged => _onLocaleChanged;

  // 系统字体缩放变化回调

  VoidCallback get onTextScaleFactorChanged => _onTextScaleFactorChanged;

  // 绘制前回调，一般会受显示器的垂直同步信号VSync驱动，当屏幕刷新时就会被调用

  FrameCallback get onBeginFrame => _onBeginFrame;

  // 绘制回调  

  VoidCallback get onDrawFrame => _onDrawFrame;

  // 点击或指针事件回调

  PointerDataPacketCallback get onPointerDataPacket => _onPointerDataPacket;

  // 调度Frame，该方法执行后，onBeginFrame和onDrawFrame将紧接着会在合适时机被调用，

  // 此方法会直接调用Flutter engine的Window_scheduleFrame方法

  void scheduleFrame() native 'Window_scheduleFrame';

  // 更新应用在GPU上的渲染,此方法会直接调用Flutter engine的Window_render方法

  void render(Scene scene) native 'Window_render';



  // 发送平台消息

  void sendPlatformMessage(String name,

                           ByteData data,

                           PlatformMessageResponseCallback callback) ;

  // 平台通道消息处理回调  

  PlatformMessageCallback get onPlatformMessage => _onPlatformMessage;

  

  ... //其它属性及回调

    

}        

可以看到 Window 中包含了当前设备和系统的一些信息和 Flutter Engine 的一些回调。

现在回过头来看一下 WidgetsFlutterBinding 混入的各种 Binding。通过查看这些 Binding 的源码，我们可以发现这些 Binding 中基本都是监听并处理 Window 对象中的一些事件，然后将这些事件安装 Framework 的模型进行包装，抽象后然后进行分发。可以看到 WidgetsFlutterBinding 正是粘连 Flutter engine 与上层 Framework 的胶水。

• 
  

  GestureBinding：提供了 window.onPointerDataPacket 回调，绑定 Fragment 手势子系统，是 Framework 事件模型与底层事件的绑定入口。

  
  

  mixin GestureBinding on BindingBase implements HitTestable, HitTestDispatcher, HitTestTarget {
  
    @override
  
    void initInstances() {
  
      super.initInstances();
  
      _instance = this;
  
      window.onPointerDataPacket = _handlePointerDataPacket;
  
    }
  
  }
  
  复制代码

  
  


• 
  

  ServiceBinidng：提供了 window.onPlatformMessage 回调，用户绑定平台消息通道(message channel) ，主要处理原生和 Flutter 通信。

  
  

  mixin SchedulerBinding on BindingBase {
  
    @override
  
    void initInstances() {
  
      super.initInstances();
  
      _instance = this;
  
      if (!kReleaseMode) {
  
        addTimingsCallback((List<FrameTiming> timings) {
  
          timings.forEach(_profileFramePostEvent);
  
        });
  
      }
  
    }
  
  

  
  


• 
  

  SchedulerBinding：提供了 window.onBeginFrame 和 window.onDrawFrame 回调，监听刷新事件，绑定 Framework 绘制调度子系统。

  
  


• 
  

  PaintingBinding ：绑定绘制库，主要用户处理图片缓存

  
  


• 
  

  SemanticsBidning：语义化层与 Flutter engine 的桥梁，主要是辅助功能的底层支持。

  
  


• 
  

  RendererBinding：提供了 window.onMetricsChanged ，window.onTextScaleFactorChanged 等回调。他是渲染树与 Flutter engine 的桥梁。

  
  


• 
  

  WidgetsBinding：提供了 window.onLocaleChange，onBulidScheduled 等回调。他是 Flutter widget 层与 engine 的桥梁。

  
  

widgetsFlutterBinding.ensureInitiallized() 负责初始化一个 widgetsBinding 的全局单例，紧接着会调用 WidgetBinding 的 attachRootwWidget 方法，该方法负责将根 Widget 添加到 RenderView 上，代码如下：

void scheduleAttachRootWidget(Widget rootWidget) {

  Timer.run(() {

    attachRootWidget(rootWidget);

  });

}

void attachRootWidget(Widget rootWidget) {

  final bool isBootstrapFrame = renderViewElement == null;

  _readyToProduceFrames = true;

  _renderViewElement = RenderObjectToWidgetAdapter<RenderBox>(

    container: renderView,

    debugShortDescription: '[root]',

    child: rootWidget,

  ).attachToRenderTree(buildOwner!, renderViewElement as RenderObjectToWidgetElement<RenderBox>?);

  if (isBootstrapFrame) {

    SchedulerBinding.instance!.ensureVisualUpdate();

  }

}

注意，代码中有 renderView和 renderViewElement 两个变量，renderView 是一个 Renderobject ，他是渲染树的根。而 renderViewElement 是 renderView 对应的 Element 对象。

可见该方法主要完成了根 widget 到根RenderObject 再到根 Element 的整个关联过程，我们在看看 attachToRenderTree 的源码实现过程：

RenderObjectToWidgetElement<T> attachToRenderTree(BuildOwner owner, [ RenderObjectToWidgetElement<T>? element ]) {

  if (element == null) {

    owner.lockState(() {

      element = createElement();

      assert(element != null);

      element!.assignOwner(owner);

    });

    owner.buildScope(element!, () {

      element!.mount(null, null);

    });

  } else {

    element._newWidget = this;

    element.markNeedsBuild();

  }

  return element!;

}

该方法负责创建根 element，即 RenderObjectToWidgetElement ，并且将 element 与 widget 进行关联，即创建出 widget 树对应的 element 树。

如果 element 创建过了，则将根 element 中关联的 widget 设为新的，由此可以看出 element 只会创建一次，后面会进行复用。那么 BuildOwner 是什么呢？，其实他就是 widget framework 的管理类，它跟踪哪些 widget 需要重新构建。

组件树在构建完毕后，回到 runApp 的实现中，当调完 attachRootWidget 后，最后一行会调用 WidgetsFlutterBainding 实例的 scheduleWarmUpFrame() 方法，该方法的是现在 SchedulerBinding 中，他被调用后会立即进行一次绘制，在此次绘制结束前，该方法就会锁定事件分发，也就是说在本次绘制结束完成之前 Flutter 不会响应各种事件，这可以保证在绘制过程中不会触发新的重绘。

总结

通过上面上面的分析我们可以知道 WidgetsFlutterBinding 就像是一个胶水，它里面会监听并处理 window 对象的事件，并且将这些事件按照 framework的模型进行包装并且分发。所以说 widgetsFlutterBinding 正是连接 Flutter engine 与上传 Framework 的胶水。

  WidgetsFlutterBinding.ensureInitialized()

    ..scheduleAttachRootWidget(app)

    ..scheduleWarmUpFrame();

• ensureInitialized ：负责初始化 WidgetsFlutterBinding ，并且监听 window 的事件进行包装分发。


• scheduleAttachRootWidget：在该方法的后续中，会创建根 Element ，调用 mount 完成 element 和 RenderObject 树的创建


• scheduleWarmUpFrame：开始绘制第一帧

渲染官线

Frame

一次绘制过程，我们可以将其称为一帧(frame)，我们知道 flutter 可以实现 60 fps，就是指 1 秒中可以进行60次重绘，FPS 越大，界面就会越流畅。

这里需要说明的是 Flutter 中的 frame 并不等于屏幕的刷新帧，因为 Flutter UI 框架并不是每次屏幕刷新都会触发，这是因为，如果 UI 在一段时间不变，那么每次重新走一遍渲染流程是不必要的，因此 Flutter 在第一帧渲染结束后会采取一种主动请求 frame 的方式来实现只有当 UI 可能会改变时才会重新走渲染流程。

1，Flutter 会在 window 上注册一个 onBeginFrame 和一个 onDrawFrame回调，在 onDrawFrame 回调中最终会调用 drawFrame。

2，当我们调用 window.scheduleFrame 方法之后，Flutter 引擎会在合适时机(可以认为是在屏幕下一次刷新之前，具体取决于 Flutter 引擎实现) 来调用 onBeginFrame 和 onDrawFrame。

在调用 window.scheduleFrame 之前会对 onBeginFrame 和 onDrawFrame 进行注册，如下所示：

void scheduleFrame() {

  if (_hasScheduledFrame || !framesEnabled)

    return;

  assert(() {

    if (debugPrintScheduleFrameStacks)

      debugPrintStack(label: 'scheduleFrame() called. Current phase is $schedulerPhase.');

    return true;

  }());

  ensureFrameCallbacksRegistered();

  window.scheduleFrame();

  _hasScheduledFrame = true;

}



 void ensureFrameCallbacksRegistered() {

    window.onBeginFrame ??= _handleBeginFrame;

    window.onDrawFrame ??= _handleDrawFrame;

  }

可以看见，只有主动调用 scheduleFrame 之后，才会调用 drawFrame(该方法是注册的回调)。

所以我们在 Flutter 中提到 frame 时，如无特别说明，则是和 drawFrame() 相互对应，而不是和屏幕的刷新相对应。

Frame 处理流程

当有新的 frame 到来时，开始调用 SchedulerBinding.handleDrawFrame 来处理 frame，具体过程就是执行四个任务队列：transientCallbacks，midFrameMicotasks，persistentCallbacks，postFrameCallbacks。当四个任务队列执行完毕后当前 frame 结束。

综上，Flutter 将整个生命周期分为 5 种状态，通过 SchedulerPhase 来表示他们：

enum SchedulerPhase {

  /// 空闲状态，并没有 frame 在处理，这种状态表示页面未发生变化，并不需要重新渲染

  /// 如果页面发生变化，需要调用 scheduleFrame 来请求 frame。

  /// 注意，空闲状态只是代表没有 frame 在处理。通常微任务，定时器回调或者用户回调事件都有可能被执行

  /// 比如监听了 tap 事件，用户点击后我们 onTap回调就是在 onTap 执行的

  idle,



  /// 执行 临时 回调任务，临时回调任务只能被执行一次，执行后会被移出临时任务队列。

  /// 典型代表就是动画回调会在该阶段执行

  transientCallbacks,



  /// 在执行临时任务是可能会产生一下新的微任务，比如在执行第一个临时任务时创建了一个 Fluture，

  /// 且这个 Future 在所有任务执行完毕前就已经 resolve

  /// 这种情况 Future 的回调将会在 [midFrameMicrotasks] 阶段执行

  midFrameMicrotasks,



  /// 执行一些持久的任务(每一个 frame 都要执行的任务)，比如渲染官线(构建，布局，绘制)

  /// 就是在该任务队列执行的

  persistentCallbacks,



  /// 在当前 frame 在结束之前将会执行 postFrameCallbacks，通常进行一些清理工作和请求新的 frame

  postFrameCallbacks,

}

需要注意，接下来需要重点介绍的渲染管线就是在 persistentCallbacks 中执行的。

渲染管线(rendering pipline)

当我们页面需要发生变化时，我们需要调用 scheduleFrame() 方法去请求 frame，该方法中会注册 _handleBeginFrame和 _handleDrawFrame。 当 frame 到来时就会执行 _handleDrawFrame，代码如下：

void _handleDrawFrame() {

  //判断当前 frame 是否需要推迟，这里的推迟原因是当前坑是预热帧	

  if (_rescheduleAfterWarmUpFrame) {

    _rescheduleAfterWarmUpFrame = false;

    //添加一个回调，该回调会在当前帧结束后执行

    addPostFrameCallback((Duration timeStamp) {

      _hasScheduledFrame = false;

      //重新请求 frame。

      scheduleFrame();

    });

    return;

  }

  handleDrawFrame();

}

void handleDrawFrame() {

  assert(_schedulerPhase == SchedulerPhase.midFrameMicrotasks);

  Timeline.finishSync(); // end the "Animate" phase

  try {

    // 切换当前生命周期状态	

    _schedulerPhase = SchedulerPhase.persistentCallbacks;

     // 执行持久任务的回调，  

    for (final FrameCallback callback in _persistentCallbacks)

      _invokeFrameCallback(callback, _currentFrameTimeStamp!);



    // postFrame 回调

    _schedulerPhase = SchedulerPhase.postFrameCallbacks;

    final List<FrameCallback> localPostFrameCallbacks =

        List<FrameCallback>.from(_postFrameCallbacks);

    _postFrameCallbacks.clear();

    for (final FrameCallback callback in localPostFrameCallbacks)

      _invokeFrameCallback(callback, _currentFrameTimeStamp!);

  } finally {

     // 将状态改为空闲状态

    _schedulerPhase = SchedulerPhase.idle;

    Timeline.finishSync(); // end the Frame

     //....

    _currentFrameTimeStamp = null;

  }

}

在上面的代码中，对持久任务进行了遍历，并且进行回调，对应的是 _persistentCallbacks ,通过对调用栈的分析，发现该回调是在初始化 RendererBinding 的时候被添加到 _persistentCallbacks 中的：

mixin RendererBinding on BindingBase, ServicesBinding, SchedulerBinding, GestureBinding, SemanticsBinding, HitTestable {

  @override

  void initInstances() {

    super.initInstances();

    //添加持久任务回调......

    addPersistentFrameCallback(_handlePersistentFrameCallback);

    initMouseTracker();

    if (kIsWeb) {

      //添加 postFrame 任务回调

      addPostFrameCallback(_handleWebFirstFrame);

    }

  }

  void addPersistentFrameCallback(FrameCallback callback) {

    _persistentCallbacks.add(callback);

  }

所以最终的回调就是 _handlePersistentFrameCallback

void _handlePersistentFrameCallback(Duration timeStamp) {

  drawFrame();

  _scheduleMouseTrackerUpdate();

}

在上面代码中，调用到了 drawFrame 方法。

通过上面的分析之后，我们知道了当 frame 到来时，会调用到 drawFrame 中，由于 drawFrame 有一个实现方法，所以首先会调用到 WidgetsBinding 的 drawFrame() 方法，如下：

void drawFrame() {

  .....//省略无关

  try {

    if (renderViewElement != null)

      buildOwner!.buildScope(renderViewElement!); // 1.重新构建widget树

    super.drawFrame();

    buildOwner!.finalizeTree();

  } 

}

最终的调用如下：

void drawFrame() {

  assert(renderView != null);

  pipelineOwner.flushLayout(); // 2.更新布局

  pipelineOwner.flushCompositingBits();//3.更新“层合成”信息

  pipelineOwner.flushPaint(); // 4.重绘

  if (sendFramesToEngine) {

    renderView.compositeFrame(); // 5. 上屏，会将绘制出的bit数据发送给GPU

	...../////

  }

}

可以到上面代码主要做了五件事：

1，重新构建 widget 树(buildScope())

2，更新布局(flushLayout())

3，更新"层合成"信息(flushCompositingBits())

4，重绘(flushPaint())

5，上屏：将绘制的产物显示在屏幕上

上面的五部我们称为 rendering pipline ，中文翻译为 “渲染流水线” 或者 “渲染管线”，而这五个步骤便是重中之重。下面我们以 setState 的更新流程为例先对整个更新流程有一个比较深的印象。

setState 执行流

void setState(VoidCallback fn) {

  assert(fn != null);

  //执行 callback，返回值不能是 future  

  final Object? result = fn() as dynamic;

  assert(() {

    if (result is Future) {

      throw ...//

    }

  }());

  _element!.markNeedsBuild();

}

void markNeedsBuild() {

  ....//

  //标注该 element 需要重建

  _dirty = true;

  owner!.scheduleBuildFor(this);

}

void scheduleBuildFor(Element element) {

 //注释1   

 if (!_scheduledFlushDirtyElements && onBuildScheduled != null) {

     _scheduledFlushDirtyElements = true;

     onBuildScheduled!();

  }    

  //注释2

  _dirtyElements.add(element);

  element._inDirtyList = true;

}

当调用 setState 后：

1，首先调用 markNeedsBuild 方法，将 element 的 dirty 标记为 true，表示需要重建

2，接着调用 scheduleBuildFor ，将当前的 element 添加到 _dirtyElements 列表中(注释2)

下面我们着重看一下 注释1的代码，

首先判断 _scheduledFlushDirtyElements 如果为 false，该字段值初始值默认就是 false，接着判断 onBuildScheduled 不为 null，其实 onBuildScheduled 在 WidgetBinding初始化的时候就已经创建了，所以他是不会为 null 的。

当条件成立后，就会直接执行 onBuildScheduled 回调。我们跟踪一下：

mixin WidgetsBinding on BindingBase, ServicesBinding, SchedulerBinding, GestureBinding, RendererBinding, SemanticsBinding {

  @override

  void initInstances() {

    super.initInstances();

    ...///  

    buildOwner!.onBuildScheduled = _handleBuildScheduled

  }

void _handleBuildScheduled() {

  ...///

  ensureVisualUpdate();

}

根据上面代码我们可以知道 onBuildScheduled 确实是在 WidgetsBinding 的初始化方法中进行初始化的。并且他的实现中调用了 ensureVisualUpdate 方法，我们继续跟进一下：

void ensureVisualUpdate() {

  switch (schedulerPhase) {

    case SchedulerPhase.idle:

    case SchedulerPhase.postFrameCallbacks:

      scheduleFrame();

      return;

    case SchedulerPhase.transientCallbacks:

    case SchedulerPhase.midFrameMicrotasks:

    case SchedulerPhase.persistentCallbacks:

      return;

  }

}

上面代码中，判断了 schedulerPhase 的状态，如果是 idle 和 postFrameCallbacks 状态的时候，就开始调用 scheduleFrame。

对于上面每种状态所代表的意义，在文章上面已经说过了，这里就不在赘述。值得一提的是，在每次 frame 流程完成的时候，在 finally 代码块中将状态又改为了 idle 。这也侧面说明如果你频繁的 setState 的时候，如果上次的渲染流程没有完成，则不会发起新的渲染。

接着继续看 scheduleFrame：

void scheduleFrame() {

  //判断流程是否已经开始了

  if (_hasScheduledFrame || !framesEnabled)

    return;

  // 注释1

  ensureFrameCallbacksRegistered();

  // 注释2

  window.scheduleFrame();

  _hasScheduledFrame = true;

}

注释1：注册 onBeginFrame 和 onDrawFrame ，这两个函数类型的字段在上面的 "渲染管线中已经说过了"。

注释2：flutter framework 想 Flutter Engine 发起一个请求，接着 Flutter 引擎会在合适的时机去调用 onBeginFrame 和 onDrawFrame。这个时机可以认为是屏幕下一次刷新之前，具体取决于 Flutter 引擎实现。

到此，setState 中最核心的就是触发了一个 请求，在下一次屏幕刷新的时候就会回调 onBeginFrame，执行完成之后才会调用 onDrawFrame 方法。

void handleBeginFrame(Duration? rawTimeStamp) {

  ...///

  assert(schedulerPhase == SchedulerPhase.idle);

  _hasScheduledFrame = false;

  try {

    Timeline.startSync('Animate', arguments: timelineArgumentsIndicatingLandmarkEvent);

    //将生命周期改为 transientCallbacks，表示正在执行一些临时任务的回调

    _schedulerPhase = SchedulerPhase.transientCallbacks;

    final Map<int, _FrameCallbackEntry> callbacks = _transientCallbacks;

    _transientCallbacks = <int, _FrameCallbackEntry>{};

    callbacks.forEach((int id, _FrameCallbackEntry callbackEntry) {

      if (!_removedIds.contains(id))

        _invokeFrameCallback(callbackEntry.callback, _currentFrameTimeStamp!, callbackEntry.debugStack);

    });

    _removedIds.clear();

  } finally {

    _schedulerPhase = SchedulerPhase.midFrameMicrotasks;

  }

}

上面代码主要是执行了_transientCallbacks 的回调方法。执行完成后将生命周期改为了 midFrameMicrotasks。

接下来就是执行 handlerDrawFrame 方法了。该方法在上面已经分析过了，已经知道它最终就会走到 drawFrame 方法中。

# WidgetsBindign.drawFrame()

void drawFrame() { 

.....//省略无关

  try {

    if (renderViewElement != null)

      buildOwner!.buildScope(renderViewElement!); // 1.重新构建widget树

    super.drawFrame();

    buildOwner!.finalizeTree();

  } 

}

# RendererBinding.drawFrame()

void drawFrame() {

  assert(renderView != null);

  pipelineOwner.flushLayout(); // 2.更新布局

  pipelineOwner.flushCompositingBits();//3.更新“层合成”信息

  pipelineOwner.flushPaint(); // 4.重绘

  if (sendFramesToEngine) {

    renderView.compositeFrame(); // 5. 上屏，会将绘制出的bit数据发送给GPU

	...../////

  }

}

以上，便是 setState 调用的大概过程，实际的流程会更加复杂一点，例如在这个过程中不允许再次调用 setState，还有在 frame 中会涉及到动画的调度，以及如何进行布局更新，重绘等。通过上面的分析，我们需要对整个流程有一个比较深的印象。

至于上面 drawFrame 中的绘制流程，我们放在下一篇文章中介绍。

正确解决：Flutter Textfield长按报错修复:NosuchMethodError: The getter 'pasterButtonLabel' was ca ？？？？？？？？？

为什么叫正确解决？？
关于这个问题，我在百度上看过很多人的答案，基本无一例外都是，说：“Cupertino缺少了对应的非英文版本的支持”。
大家真的看过源码吗？真的是缺少Cupertino么？我是真不相信的，flutter出了这么多年，连个中文都不支持？然后我就查阅了源码：
我发现了这个类 GlobalCupertinoLocalizations
有木有很眼熟，他和
GlobalMaterialLocalizations & GlobalWidgetsLocalizations 没啥区别

class _GlobalCupertinoLocalizationsDelegate extends LocalizationsDelegate {

  const _GlobalCupertinoLocalizationsDelegate();



  @override

  bool isSupported(Locale locale) => kCupertinoSupportedLanguages.contains(locale.languageCode);



  static final Map> _loadedTranslations = >{};



  @override

  Future load(Locale locale) {

    assert(isSupported(locale));

    return _loadedTranslations.putIfAbsent(locale, () {

      util.loadDateIntlDataIfNotLoaded();



      final String localeName = intl.Intl.canonicalizedLocale(locale.toString());

      assert(

        locale.toString() == localeName,

        'Flutter does not support the non-standard locale form $locale (which '

        'might be $localeName',

      );



      late intl.DateFormat fullYearFormat;

      late intl.DateFormat dayFormat;

      late intl.DateFormat mediumDateFormat;

      // We don't want any additional decoration here. The am/pm is handled in

      // the date picker. We just want an hour number localized.

      late intl.DateFormat singleDigitHourFormat;

      late intl.DateFormat singleDigitMinuteFormat;

      late intl.DateFormat doubleDigitMinuteFormat;

      late intl.DateFormat singleDigitSecondFormat;

      late intl.NumberFormat decimalFormat;



      void loadFormats(String? locale) {

        fullYearFormat = intl.DateFormat.y(locale);

        dayFormat = intl.DateFormat.d(locale);

        mediumDateFormat = intl.DateFormat.MMMEd(locale);

        // TODO(xster): fix when https://github.com/dart-lang/intl/issues/207 is resolved.

        singleDigitHourFormat = intl.DateFormat('HH', locale);

        singleDigitMinuteFormat = intl.DateFormat.m(locale);

        doubleDigitMinuteFormat = intl.DateFormat('mm', locale);

        singleDigitSecondFormat = intl.DateFormat.s(locale);

        decimalFormat = intl.NumberFormat.decimalPattern(locale);

      }



      if (intl.DateFormat.localeExists(localeName)) {

        loadFormats(localeName);

      } else if (intl.DateFormat.localeExists(locale.languageCode)) {

        loadFormats(locale.languageCode);

      } else {

        loadFormats(null);

      }



      return SynchronousFuture(getCupertinoTranslation(

        locale,

        fullYearFormat,

        dayFormat,

        mediumDateFormat,

        singleDigitHourFormat,

        singleDigitMinuteFormat,

        doubleDigitMinuteFormat,

        singleDigitSecondFormat,

        decimalFormat,

      )!);

    });

  }



  @override

  bool shouldReload(_GlobalCupertinoLocalizationsDelegate old) => false;



  @override

  String toString() => 'GlobalCupertinoLocalizations.delegate(${kCupertinoSupportedLanguages.length} locales)';

}

源码中加载语言也没说不支持中文啊！！
还有网上很多配置本地化时候都是这么写的：

          GlobalMaterialLocalizations.delegate,

          GlobalWidgetsLocalizations.delegate,

仔细看了源码，我想说：
这么写不香么？？
GlobalMaterialLocalizations.delegates

  /// A value for [MaterialApp.localizationsDelegates] that's typically used by

  /// internationalized apps.

  ///

  /// ## Sample code

  ///

  /// To include the localizations provided by this class and by

  /// [GlobalWidgetsLocalizations] in a [MaterialApp],

  /// use [GlobalMaterialLocalizations.delegates] as the value of

  /// [MaterialApp.localizationsDelegates], and specify the locales your

  /// app supports with [MaterialApp.supportedLocales]:

  ///

  /// ```dart

  /// new MaterialApp(

  ///   localizationsDelegates: GlobalMaterialLocalizations.delegates,

  ///   supportedLocales: [

  ///     const Locale('en', 'US'), // English

  ///     const Locale('he', 'IL'), // Hebrew

  ///   ],

  ///   // ...

  /// )

  /// ```

  static const List> delegates = >[

    GlobalCupertinoLocalizations.delegate,

    GlobalMaterialLocalizations.delegate,

    GlobalWidgetsLocalizations.delegate,

  ];

}

仅此一篇文章，我希望大家认真阅读源码，提升水平