1 线程的启动方式

线程的启动方式只有两种。

方式1：继承Thread，然后调用start()启动。

private static class PrimeThread extends Thread {

    @Override

    public void run() {

        System.out.println("thread extend Thread---name:" + Thread.currentThread().getName());

    }

}



PrimeThread thread = new PrimeThread();

thread.start();

方式2：实现Runnable，然后交给Thread去启动。

private static class PrimeRunnable implements Runnable {

    @Override

    public void run() {

        System.out.println("thread implements Runnable---name:" + Thread.currentThread().getName());

    }

}



PrimeRunnable runnable = new PrimeRunnable();

new Thread(runnable).start();

其他的比如线程池、FutureTask等都属于这两种的包装或封装。

并且Thread源码的注释中也清楚的写了有两种方式创建线程：

* <p>

* There are two ways to create a new thread of execution. One is to

* declare a class to be a subclass of <code>Thread</code>. This

* subclass should override the <code>run</code> method of class

    * <code>Thread</code>. An instance of the subclass can then be

    * allocated and started. For example, a thread that computes primes

    * larger than a stated value could be written as follows:

* <hr><blockquote><pre>

*     class PrimeThread extends Thread {

*         long minPrime;

*         PrimeThread(long minPrime) {

*             this.minPrime = minPrime;

*         }

*

*         public void run() {

*             // compute primes larger than minPrime

*             &nbsp;.&nbsp;.&nbsp;.

*         }

*     }

* </pre></blockquote><hr>

* <p>

* The following code would then create a thread and start it running:

* <blockquote><pre>

*     PrimeThread p = new PrimeThread(143);

*     p.start();

* </pre></blockquote>

* <p>

* The other way to create a thread is to declare a class that

    * implements the <code>Runnable</code> interface. That class then

        * implements the <code>run</code> method. An instance of the class can

            * then be allocated, passed as an argument when creating

            * <code>Thread</code>, and started. The same example in this other

            * style looks like the following:

* <hr><blockquote><pre>

*     class PrimeRun implements Runnable {

*         long minPrime;

*         PrimeRun(long minPrime) {

*             this.minPrime = minPrime;

*         }

*

*         public void run() {

*             // compute primes larger than minPrime

*             &nbsp;.&nbsp;.&nbsp;.

*         }

*     }

* </pre></blockquote><hr>

 * <p>

2 线程的状态

Java中线程的状态分为6种：

1、初始(NEW)：新创建了一个线程，但是还没有调用start()方法。

2、运行(RUNNABLE)：Java线程中将就绪(READY)和运行中(RUNNING)两种装填笼统的称为“运行”。

线程对象创建后，其他线程(比如main线程)调用了该对象的start()方法，该状态的线程位于可运行线程池中，获取CPU的使用权，此时处于就绪状态(READY)，就绪状态的线程在获得CPU时间片后变为运行中状态(RUNNING)。

3、阻塞(BLOCKED)：表示线程阻塞于锁。

4、等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。

5、超时等待(TIMED_WAITING)：该状态不同于WATING，它可以在指定的时间后自行返回。

6、终止(TERMINATED)：表示该线程已经执行完毕。

线程生命周期如下：

3 死锁

3.1 概念

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。

死锁是必然发生在多操作者（M>=2个）情况下，争夺多个资源（N>=2个，且N<=M）才会发生这种情况。很明显，单线程自然不会有死锁。

死锁还有几个要求：

1. 争夺资源的顺序不对，如果争夺资源的顺序是一样的，也不会产生死锁。


2. 争夺者拿到资源不放手。

3.1.1 学术定义

死锁的发生必须具备以下四个必要条件。

1. 互斥条件： 指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。


2. 请求和保持条件： 指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。


3. 不剥夺条件： 指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。


4. 环路等待条件： 指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源。

理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和解除死锁。只要打破四个必要条件之一就能有效预防死锁的发生。

• 打破互斥条件：改造独占性资源为虚拟资源，大部分资源已无法改造。


• 打破不可抢占条件：当一进程占有一独占性资源后又申请一独占性资源而无法满足，则退出原占有的资源。


• 打破占有且申请条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待，这样就不会占有且申请。


• 打破循环等待条件：实现资源有序分配策略，对所有设备实现分类编号，所有进程只能采用按序号递增的形式申请资源。

避免死锁常见的算法有有序资源分配法、银行家算法。

示例代码：

/**

 * @Description: 死锁的产生

 * @CreateDate: 2022/3/15 2:31 下午

 */

public class NormalDeadLock {



    /**

     * 第1个锁

     */

    private static final Object LOCK_1 = new Object();

    /**

     * 第2个锁

     */

    private static final Object LOCK_2 = new Object();



    /**

     * 第1个拿锁的方法 先去拿锁1，再去拿锁2

     *

     * @throws InterruptedException 中断异常

     */

    private static void method1() throws InterruptedException {

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

        synchronized (LOCK_1) {

            System.out.println(threadName + " get LOCK_1");

            Thread.sleep(100);

            synchronized (LOCK_2) {

                System.out.println(threadName + " get LOCK_2");

            }

        }

    }



    /**

     * 第2个拿锁的方法 先去拿锁2，再去拿锁1，这就导致方法1和方法2各拿一个锁，然后互不相让，都不释放自己的锁，造成了互斥，就产生了死锁

     *

     * @throws InterruptedException 中断异常

     */

    private static void method2() throws InterruptedException {

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

        synchronized (LOCK_2) {

            System.out.println(threadName + " get LOCK_2");

            Thread.sleep(100);

            synchronized (LOCK_1) {

                System.out.println(threadName + " get LOCK_1");

            }

        }

    }



    /**

     * 子线程PrimeThread1

     */

    private static class PrimeThread1 extends Thread {

        private final String name;



        public PrimeThread1(String name) {

            this.name = name;

        }



        @Override

        public void run() {

            Thread.currentThread().setName(name);

            try {

                method1();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }



    /**

     * 子线程PrimeThread2

     */

    private static class PrimeThread2 extends Thread {

        private final String name;



        public PrimeThread2(String name) {

            this.name = name;

        }



        @Override

        public void run() {

            Thread.currentThread().setName(name);

            try {

                method2();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }



    public static void main(String[] args) {

        PrimeThread1 thread1 = new PrimeThread1("PrimeThread1");

        PrimeThread2 thread2 = new PrimeThread2("PrimeThread2");



        thread1.start();

        thread2.start();

    }



}

执行后，可以看到控制台没有结束运行，看不到Process finished with exit code 0，但是又一直处于静止状态。

PrimeThread1 get LOCK_1

PrimeThread2 get LOCK_2

3.2 危害

1. 线程不工作了，但是整个程序还是活着的。


2. 没有任何的异常信息可以供我们检查。


3. 一旦程序发生了发生了死锁，是没有任何的办法恢复的，只能重启程序，对正式已发布程序来说，这是个很严重的问题。

3.3 解决方案

关键是保证拿锁的顺序一致。

两种解决方式：

1、内部通过顺序比较，确定拿锁的顺序。

比如上述示例代码中，可以让方法1和方法2同时都先拿锁1，然后再去拿锁2，就能解决死锁问题。

private static void method1() throws InterruptedException {

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

        synchronized (LOCK_1) {

            System.out.println(threadName + " get LOCK_1");

            Thread.sleep(100);

            synchronized (LOCK_2) {

                System.out.println(threadName + " get LOCK_2");

            }

        }

}



private static void method2() throws InterruptedException {

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

        synchronized (LOCK_1) {

            System.out.println(threadName + " get LOCK_1");

            Thread.sleep(100);

            synchronized (LOCK_2) {

                System.out.println(threadName + " get LOCK_2");

            }

        }

}

修改后后，可以看到程序能正常执行。

PrimeThread1 get LOCK_1

PrimeThread1 get LOCK_2

PrimeThread2 get LOCK_1

PrimeThread2 get LOCK_2



Process finished with exit code 0

2、采用尝试拿锁的机制。

示例代码：

/**

 * @Description: 尝试拿锁，解决死锁问题

 * @CreateDate: 2022/3/15 2:57 下午

 */

public class TryGetLock {

    /**

     * 第1个锁

     */

    private static final Lock LOCK_1 = new ReentrantLock();

    /**

     * 第2个锁

     */

    private static final Lock LOCK_2 = new ReentrantLock();



    /**

     * 方法1 先尝试拿锁1，再尝试拿锁2，拿不到锁2的话连同锁1一起释放

     *

     * @throws InterruptedException 中断异常

     */

    private static void method1() throws InterruptedException {

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

        Random r = new Random();

        while (true) {

            if (LOCK_1.tryLock()) {

                System.out.println(threadName + " get LOCK_1");

                try {

                    if (LOCK_2.tryLock()) {

                        try {

                            System.out.println(threadName + " get LOCK_2");

                            System.out.println("method1 do working...");

                            break;

                        } finally {

                            LOCK_2.unlock();

                        }

                    }

                } finally {

                    LOCK_1.unlock();

                }

            }

            //注意：这里需要给个很短的间隔时间去让其他线程拿锁，不然可能会造成活锁

            Thread.sleep(r.nextInt(3));

        }

    }



    /**

     * 方法2 先尝试拿锁2，再尝试拿锁1，拿不到锁1的话连同锁2一起释放

     *

     * @throws InterruptedException 中断异常

     */

    private static void method2() throws InterruptedException {

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

        Random r = new Random();

        while (true) {

            if (LOCK_2.tryLock()) {

                System.out.println(threadName + " get LOCK_2");

                try {

                    if (LOCK_1.tryLock()) {

                        try {

                            System.out.println(threadName + " get LOCK_1");

                            System.out.println("method2 do working...");

                            break;

                        } finally {

                            LOCK_1.unlock();

                        }

                    }

                } finally {

                    LOCK_2.unlock();

                }

            }

            Thread.sleep(r.nextInt(3));

        }

    }



    private static class PrimeThread1 extends Thread {

        private final String name;



        public PrimeThread1(String name) {

            this.name = name;

        }



        @Override

        public void run() {

            Thread.currentThread().setName(name);

            try {

                method1();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }



    private static class PrimeThread2 extends Thread {

        private final String name;



        public PrimeThread2(String name) {

            this.name = name;

        }



        @Override

        public void run() {

            Thread.currentThread().setName(name);

            try {

                method2();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }



    public static void main(String[] args) {

        PrimeThread1 thread1 = new PrimeThread1("PrimeThread1");

        PrimeThread2 thread2 = new PrimeThread2("PrimeThread2");



        thread1.start();

        thread2.start();

    }

}

执行结果：

PrimeThread2 get LOCK_2

PrimeThread1 get LOCK_1

PrimeThread2 get LOCK_2

PrimeThread2 get LOCK_1

method2 do working...

PrimeThread1 get LOCK_1

PrimeThread1 get LOCK_2

method1 do working...



Process finished with exit code 0

4 其他线程安全问题

4.1 活锁

两个线程在尝试拿锁的机制中，发生多个线程之间互相谦让，不断发生同一个线程总是拿到同一把锁，在尝试拿另一把锁时因为拿不到，而将本来已经持有的锁释放的过程。

解决办法：每个线程休眠随机数，错开拿锁的时间。

如上边的尝试拿锁示例代码中，如果不加随机sleep，就会造成活锁。

4.2 线程饥饿

低优先级的线程，总是拿不到执行时间。

5 ThreadLocal

5.1 与Synchonized的比较

ThreadLocal和synchonized都用于解决多线程并发訪问。但是ThreadLocal与synchronized有本质的差别。synchronized是利用锁的机制，使变量或代码块在某一时该仅仅能被一个线程访问。而ThreadLocal为每个线程都提供了变量的副本，使得每个线程在某一时间访问到的并非同一个对象，这样就隔离了多个线程对数据的数据共享。

5.2 ThreadLocal的使用

ThreadLocal类接口很简单，只有4个方法：

• protected T initialValue()返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。


• public void set(T value)设置当前线程的线程局部变量。


• public T get()返回当前线程所对应的线程局部变量。


• public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。

public final static ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<String>();

THREAD_LOCAL代表一个能够存放String类型的ThreadLocal对象。此时不论什么一个线程能够并发访问这个变量，对它进行写入、读取操作，都是线程安全的。

示例代码：

/**

 * @Description: 使用ThreadLocal

 * @CreateDate: 2022/3/15 3:37 下午

 */

public class UseThreadLocal {



    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();



    private void startThreadArray() {

        Thread[] threads = new Thread[3];

        for (int i = 0; i < threads.length; i++) {

            threads[i] = new Thread(new PrimeRunnable(i));

        }

        for (int i = 0; i < threads.length; i++) {

            threads[i].start();

        }

    }



    private static class PrimeRunnable implements Runnable {

        private final int id;



        public PrimeRunnable(int id) {

            this.id = id;

        }



        @Override

        public void run() {

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

            THREAD_LOCAL.set("线程" + id);

            System.out.println(threadName + ":" + THREAD_LOCAL.get());

        }

    }



    public static void main(String[] args) {

        UseThreadLocal useThreadLocal = new UseThreadLocal();

        useThreadLocal.startThreadArray();

    }

}

5.3 ThreadLocal的内部实现

    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;

    }

ThreadLocal.ThreadLocalMap threadLocals = null;

上面先取到当前线程，然后调用getMap方法获取对应的ThreadLocalMap，ThreadLocalMap是ThreadLocal的静态内部类，然后Thread类中有一个这样类型成员，所以getMap是直接返回Thread的成员。

看下ThreadLocal的内部类ThreadLocalMap源码：

    static class ThreadLocalMap {



        /**

         * The entries in this hash map extend WeakReference, using

         * its main ref field as the key (which is always a

         * ThreadLocal object).  Note that null keys (i.e. entry.get()

         * == null) mean that the key is no longer referenced, so the

         * entry can be expunged from table.  Such entries are referred to

         * as "stale entries" in the code that follows.

         */

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

            /** The value associated with this ThreadLocal. */

            Object value;

            

            //类似于map的key、value结构，key就是ThreadLocal，value就是要隔离访问的变量

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

                super(k);

                value = v;

            }

        }



        /**

         * The initial capacity -- MUST be a power of two.

         */

        private static final int INITIAL_CAPACITY = 16;



        /**

         * The table, resized as necessary.

         * table.length MUST always be a power of two.

         * 用数组保存了Entry，因为可能有多个变量需要线程隔离访问

         */

        private Entry[] table;

可以看到有个Entry内部静态类，它继承了WeakReference，总之它记录了两个信息，一个是ThreadLocal<?>类型，一个是Object类型的值。getEntry方法则是获取某个ThreadLocal对应的值，set方法就是更新或赋值相应的ThreadLocal对应的值。

        private Entry getEntry(ThreadLocal<?> key) {

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

            Entry e = table[i];

            // Android-changed: Use refersTo()

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

                return e;

            else

                return getEntryAfterMiss(key, i, e);

        }

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



            // We don't use a fast path as with get() because it is at

            // least as common to use set() to create new entries as

            // it is to replace existing ones, in which case, a fast

            // path would fail more often than not.



            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();

        }

回顾get方法，其实就是拿到每个线程独有的ThreadLocalMap，然后再用ThreadLocal的当前实例，拿到Map中的相应的Entry，然后就可以拿到相应的值返回出去。当然，如果Map为空，还会先进行Map的创建，初始化等工作。

前言

开发中，如果在runApp方法执行之前设置Android沉浸式样式报错，需要先设置WidgetsFlutterBinding.ensureInitialized();这一行代码才行，为什么，接下来看下这一行代码具体做了啥。

点进去发现这个方法在runApp中进行了实现，并且还调用了WidgetsFlutterBinding的另两个方法，

方法体：

void runApp(Widget app) {

  WidgetsFlutterBinding.ensureInitialized()

    ..scheduleAttachRootWidget(app)

    ..scheduleWarmUpFrame();

}

接下来我们对这三个方法进行一个一个进行分析。

1、WidgetsFlutterBinding.ensureInitialized()

代码：

/// widgets框架的具体绑定，将框架绑定到Flutter引擎的中间层。

/// A concrete binding for applications based on the Widgets framework.

/// This is the glue that binds the framework to the Flutter engine.

class WidgetsFlutterBinding extends BindingBase with GestureBinding,

SchedulerBinding, ServicesBinding, PaintingBinding,

SemanticsBinding, RendererBinding, WidgetsBinding {



/// 只有需要绑定时，才需要调用这个方法，在runApp之前调用。

/// You only need to call this method if you need the binding to be

/// initialized before calling [runApp].



static WidgetsBinding ensureInitialized() {

  if (WidgetsBinding.instance == null)

    WidgetsFlutterBinding();

  return WidgetsBinding.instance!;

}

}

可以看到，WidgetsFlutterBinding 继承了 BindingBase，并混入了一些其他Binding。

先看下BindingBase类,

/// 初始化 获取唯一window

ui.SingletonFlutterWindow get window => ui.window;

/// 初始化PlatformDispatcher实例，平台消息和配置的中心入口点,负责分发事件给Flutter引擎。

ui.PlatformDispatcher get platformDispatcher => ui.PlatformDispatcher.instance;

主要是获取了window实例和PlatformDispatcher实例。

再看下其他Binding解释：

• 
  

  GestureBinding：处理手势相关。

  
  


• 
  

  SchedulerBinding: 处理系统调度。

  
  


• 
  

  ServicesBinding：处理与原生的交互。

  
  


• 
  

  PaintingBinding：处理绘制相关。

  
  


• 
  

  SemanticsBinding：处理语义化。

  
  


• 
  

  RendererBinding：处理渲染相关。

  
  


• 
  

  WidgetsBinding：Widgets相关。

  
  

Flutter框架层的相关基础绑定。

接着我们看下改变状态栏的代码。

改变样式核心代码：

if (_pendingStyle != _latestStyle) {

// 通过和原生平台进行通信 来改变具体平台状态样式

  SystemChannels.platform.invokeMethod<void>(

    'SystemChrome.setSystemUIOverlayStyle',

    _pendingStyle!._toMap(),

  );

  _latestStyle = _pendingStyle;

}

通过 ensureInitialized的注释和修改样式的代码即可解决我们开头的疑问，因为设置状态栏样式是通过原生window窗口进行修改的，所以这里如果需要修改状态栏，就需要进行和原生绑定才能拿到原生的window窗口来进行修改。

从注释来看:WidgetsFlutterBinding是widgets框架的具体绑定，将框架绑定到Flutter引擎的中间层。

通过 ensureInitialized方法返回 一个WidgetsBinding单例类。

至此，WidgetsFlutterBinding.ensureInitialized()；的工作已经结束。

就是做了初始化引擎绑定，返回WidgetsBinding。

..scheduleAttachRootWidget(app)

上一个方法我们知道返回了WidgetsBinding类，那这个方法就是在WidgetsBinding这个类里，接下来先看下这个类。

/// widgets和Flutter引擎之间的粘合剂，中间层

/// The glue between the widgets layer and the Flutter engine.

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

  @override

  void initInstances() {

    super.initInstances();

    _instance = this;

    // Initialization of [_buildOwner] has to be done after

    // [super.initInstances] is called, as it requires [ServicesBinding] to

    // properly setup the [defaultBinaryMessenger] instance.

    _buildOwner = BuildOwner();

    buildOwner!.onBuildScheduled = _handleBuildScheduled;

    

/// 略



@protected

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();

  }

}

可以看到这是一个mixin类，创建了BuildOwner的实例，这个类是用来管理Element的，在attachRootWidget方法中创建了RenderObjectToWidgetAdapter实例，并设置了我们的runApp中的参数根节点rootWigdt。

/// 桥接 RenderObject 到 Element 

/// A bridge from a [RenderObject] to an [Element] tree.

  RenderObjectToWidgetAdapter({

    this.child,

    required this.container,

    this.debugShortDescription,

  }) : super(key: GlobalObjectKey(container));

RenderObjectToWidgetAdapter 是桥接RenderObject到Element的,Element是持有Widget的具体实现，通过RenderObject进行渲染，也就是通过这个方法实现了 Widget、Element、RenderObject的初始及绑定关系。

..scheduleWarmUpFrame();

绑定之后，接下来就是将内容显示在屏幕上，从以下代码分别调用了handleBeginFrame、handleDrawFrame方法，通过hadScheduledFrame判断是否调用handleBeginFrame触发scheduleFrame方法，调用 window.scheduleFrame(); 最终调用 platformDispatcher.scheduleFrame();通知引擎在合适的时机进行帧绘制。

void scheduleWarmUpFrame() {

  if (_warmUpFrame || schedulerPhase != SchedulerPhase.idle)

    return;

  _warmUpFrame = true;

  final TimelineTask timelineTask = TimelineTask()..start('Warm-up frame');

  final bool hadScheduledFrame = _hasScheduledFrame;

  // We use timers here to ensure that microtasks flush in between.

  Timer.run(() {

    assert(_warmUpFrame);

    handleBeginFrame(null);

  });

  Timer.run(() {

    assert(_warmUpFrame);

    handleDrawFrame();

 

    resetEpoch();

    _warmUpFrame = false;

    if (hadScheduledFrame)

      scheduleFrame();

  });

  

  



void scheduleFrame() {

  window.scheduleFrame();

}



/// Requests that, at the next appropriate opportunity, the [onBeginFrame] and

/// [onDrawFrame] callbacks be invoked.

void scheduleFrame() => platformDispatcher.scheduleFrame();

小结

runApp中的三个方法执行的三步分别是：

1、初始化WidgetsFlutterBinding返回WidgetBinding实例。

2、初始化Widget、Elment、RenderObject三棵树并确定绑定关系。

3、通知引擎合适时机进行帧绘制。更快的将内容显示到屏幕中。

一、前言

• 装饰者模式
  
  
  
  • 作用：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。
  
  
  • 本质：该模式通过创建一个包装对象，来包裹真实的对象。
  
  
  • 核心操作：
    
    
    
    • 创建一个装饰类，包含一个被装饰类的实例
    
    
    • 装饰类重写所有被装饰类的方法
    
    
    • 在装饰类中对需要增强的功能进行扩展
    
    
    
    
  
  
  
  

二、使用装饰者模式

• 例子：枪支部件


• 重点：装饰器类设计（实现被装饰类相同的接口，构造器接收被装饰类的接口实例对象）

像绝地求生这种大型射击游戏，里面的枪支系统是很复杂的，有很多种枪，而且几乎每种枪上都可以装配各种各样的部件，比如消声器、八倍镜之类的，部件的作用各不相同，有的可以增加火力，有的可以提高精确度，等等，现在我们来简单设计一下这个枪支系统，枪有很多种，所以需要定义一个接口来描述枪都有哪些能力，供后续扩展各种新枪：

/**

 * 枪支接口

 *

 * @author GitLqr

 */

interface Gun {

    /**

     * 攻击力

     */

    fun attack(): Float



    /**

     * 噪音

     */

    fun noise(): Float



    /**

     * 生产日期

     */

    fun prodDate(): String

}



/**

 * Ump9

 *

 * @author GitLqr

 */

class Ump9Gun : Gun {

    override fun attack() = 100f



    override fun noise() = 20f



    override fun prodDate() = "2020-02-18"

}

这里只实现了 Ump9 这个型号的枪，后续还可以根据需要扩展，现在来想想枪支部件怎么设计？在 Java 中，给一个类扩展行为有两种选择：

• 设计一个继承它的子类


• 使用装饰者模式对该类进行装饰

那么枪支部件合适用继承方式来设计吗？显然不合适，因为一个部件可以装配在不只一种枪上，所以继承这种方式排除。另一种方式，使用装饰者模式有一个很大的优势，在于符合“组合优于继承”的设计原则，我们知道，部件可以和任意枪组合，显示，使用装饰者模式来设计枪支部件是一个不错的选择：

/**

 * 枪支部件

 *

 * @author GitLqr

 */

abstract class GunPart(protected val gun: Gun) : Gun



/**

 * 消声器

 *

 * @author GitLqr

 */

class Muffler(gun: Gun) : GunPart(gun) {

    override fun attack() = gun.attack() - 5



    override fun noise() = 0f



    override fun prodDate() = gun.prodDate()

}



/**

 * 燃烧子弹

 *

 * @author GitLqr

 */

class FireBullet(gun: Gun) : GunPart(gun) {

    override fun attack() = gun.attack() + 200



    override fun noise() = gun.noise()



    override fun prodDate() = gun.prodDate()

}

程序设计时，装饰器（部件）会引用被装饰实例（枪），并实现被装饰实例的所有接口，然后在需要增强的接口方法中加入增强逻辑。因为枪支部件 GunPart 接收 Gun 类型构造参数，而且本身也是 Gun 接口的实现类，所以，可以让多种枪支部件 GunPart 嵌套修饰枪实例：

// 使用

var ump9: Gun = Ump9Gun()

println("装配前：ump9 攻击力 ${ump9.attack()}，噪音 ${ump9.noise()}")

ump9 = Muffler(FireBullet(ump9)) // 装配了 燃烧子弹、消声器 的ump9

println("装配后：ump9 攻击力 ${ump9.attack()}，噪音 ${ump9.noise()}")



// 输出

装配前：ump9 攻击力 100.0，噪音 20.0

装配后：ump9 攻击力 295.0，噪音 0.0

三、改良装饰者模式

• 例子：枪支部件


• 重点：类委托（by 关键字）

在上面的例子中，装饰者模式可以很好的解决实例组合的情况，但是代码还是显得比较啰唆，因为需要重写所有的装饰对象方法，所以可能会存在大量样板代码。比如 FireBullet 只装饰增强 attack() 方法，而 noise()、prodDate() 均不做修改，但还要是把这两个方法重写一遍。Kotlin 中有类委托特性，利用 by 关键字，将装饰类的所有方法委托给一个被装饰的类对象，然后只需覆写装饰的方法即可：

/**

 * 枪支部件

 *

 * @author GitLqr

 */

abstract class GunPart(protected val gun: Gun) : Gun by gun



/**

 * 消声器

 *

 * @author GitLqr

 */

class Muffler(gun: Gun) : GunPart(gun) {

    override fun attack() = gun.attack() - 5

    override fun noise() = 0f

}



/**

 * 燃烧子弹

 *

 * @author GitLqr

 */

class FireBullet(gun: Gun) : GunPart(gun) {

    override fun attack() = gun.attack() + 200

}

可以看到，使用类委托之后，装饰类 FireBullet 中的样板代码不用重写了，从而减少了代码量。

总结：

在多module的项目中，对版本的统一管理很重要，可以避免多个版本库的冲突问题，也方便日后的统一升级等等

Android的版本依赖的统一管理，有三种方式：

• 传统apply from的方式


• buildsrc方式


• composing builds方式

一、传统apply from的方式

在根目录新建一个config.gradle（或其他随意的xxx.gradle）文件
或在根目录的build.gradle定义一些变量
如：

ext {

    android = [

            compileSdkVersion: 30,

            buildToolsVersion: "30",

            minSdkVersion    : 16,

            targetSdkVersion : 28,

            versionCode      : 100,

            versionName      : "1.0.0"

    ]



    versions = [

            appcompatVersion       : "1.1.0",

            coreKtxVersion         : "1.2.0",

            supportLibraryVersion  : "28.0.0",

            glideVersion           : "4.11.0",

            okhttpVersion          : "3.11.0",

            retrofitVersion        : "2.3.0",

            constraintLayoutVersion: "1.1.3",

            gsonVersion            : "2.8",

            //等等······

    ]



    dependencies = [

            //base

            "constraintLayout"      : "androidx.constraintlayout:constraintlayout:${version["constraintLayoutVersion"]}",

            "appcompat"             : "androidx.appcompat:appcompat:${version["appcompatVersion"]}",

            "coreKtx"               : "androidx.core:core-ktx:${version["coreKtxVersion"]}",

            //等等······

    ]

}

在工程的根目录build.gradle添加：

apply from"config.gradle"

在需要依赖的module的build.gradle中，依赖的方式如下：

dependencies {

	...

    // 添加appcompatVersion依赖

    api rootProject.ext.dependencies["appcompatVersion"]

    ...

 }

【缺点】

• 无法跟踪代码，需要手动搜索相关的依赖


• 可读性很差

二、buildsrc方式

什么是buildsrc

当运行 gradle 时会检查项目中是否存在一个名为 buildsrc 的目录。然后 gradle 会自动编译并测试这段代码，并将其放入构建脚本的类路径中。

对于多项目构建，只能有一个 buildsrc 目录，该目录必须位于根项目目录中, buildsrc 是 gradle 项目根目录下的一个目录，它可以包含我们的构建逻辑。

与脚本插件相比，buildsrc 应该是首选，因为它更易于维护、重构和测试代码。

优缺点：

1】优点：

• buildSrc是Android默认插件，共享 buildsrc 库工件的引用，全局只有这一个地方可以修改它


• 支持自动补全，支持跳转。

2】缺点：

• 依赖更新将重新构建整个项目，项目越大，重新构建的时间就越长，造成不必要的时间浪费。

Gradle 文档

A change in buildSrc causes the whole project to become out-of-date. Thus, when making small incremental changes, the --no-rebuild command-line option is often helpful to get faster feedback. Remember to run a full build regularly or at least when you’re done, though.

buildSrc的更改会导致整个项目过时，因此，在进行小的增量更改时，-- --no-rebuild命令行选项通常有助于获得更快的反馈。不过，请记住要定期或至少在完成后运行完整版本。

使用方式：

参考：Kotlin + buildSrc for Better Gradle Dependency Management

• 
  

  在项目根目录下新建一个名为 buildSrc 的文件夹(名字必须是 buildSrc，因为运行 Gradle 时会检查项目中是否存在一个名为 buildSrc 的目录)

  
  


• 
  

  在 buildSrc 文件夹里创建名为 build.gradle.kts 的文件，添加以下内容

  
  

plugins {

    `kotlin-dsl`

}

repositories{

    jcenter()

}

• 在 buildSrc/src/main/java/包名/ 目录下新建 Deps.kt 文件，添加以下内容

object Versions {

    ......

     

    val appcompat = "1.1.0"



    ......

}



object Deps {

    ......

   

    val appcompat =  "androidx.appcompat:appcompat:${Versions.appcompat}"

    

    ......

}

• 重启 Android Studio，项目里就会多出一个名为 buildSrc 的 module，实现效果

三、composing builds方式

摘自 Gradle 文档：复合构建只是包含其他构建的构建. 在许多方面，复合构建类似于 Gradle 多项目构建，不同之处在于，它包括完整的 builds ，而不是包含单个 projects

• 组合通常独立开发的构建，例如，在应用程序使用的库中尝试错误修复时


• 将大型的多项目构建分解为更小，更孤立的块，可以根据需要独立或一起工作

优缺点：

1】优点：

• 支持单向跟踪


• 自动补全


• 依赖更新时，不会重新构建整个项目

2】缺点：

• 需要在每一个module中都添加相应的插件引用

使用方式：

参考Gradle文档

• 新建的 module 名称 VersionPlugin(名字随意)


• 在 versionPlugin 文件夹下的 build.gradle 文件内，添加以下内容

buildscript {

    repositories {

        jcenter()

    }

    dependencies {

        // 因为使用的 Kotlin 需要需要添加 Kotlin 插件

        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.6.10"

    }

}



apply plugin: 'kotlin'

apply plugin: 'java-gradle-plugin'

repositories {

    // 需要添加 jcenter 否则会提示找不到 gradlePlugin

    jcenter()

}



gradlePlugin {

    plugins {

        version {

            // 在 app 模块需要通过 id 引用这个插件

            id = 'com.yu.plugin'

            // 实现这个插件的类的路径

            implementationClass = 'com.yu.versionplugin.VersionPlugin'

        }

    }

}

• 在 VersionPlugin/src/main/java/包名/ 目录下新建 DependencyManager.kt 文件，添加相关的依赖配置，如：

package com.yu.versionplugin



/**

 * 配置和 build相关的

 */

object BuildVersion {

    const val compileSdkVersion = 29

    const val buildToolsVersion = "29.0.2"

    const val minSdkVersion = 17

    const val targetSdkVersion = 26

    const val versionCode = 102

    const val versionName = "1.0.2"

}



/**

 * 项目相关配置

 */

object BuildConfig {

    //AndroidX

    const val appcompat = "androidx.appcompat:appcompat:1.2.0"

    const val constraintLayout = "androidx.constraintlayout:constraintlayout:2.0.4"

    const val coreKtx = "androidx.core:core-ktx:1.3.2"

    const val material = "com.google.android.material:material:1.2.1"

    const val junittest = "androidx.test.ext:junit:1.1.2"

    const val swiperefreshlayout = "androidx.swiperefreshlayout:swiperefreshlayout:1.1.0"

    const val recyclerview = "androidx.recyclerview:recyclerview:1.1.0"

    const val cardview = "androidx.cardview:cardview:1.0.0"



    //Depend

    const val junit = "junit:junit:4.12"

    const val espresso_core = "com.android.support.test.espresso:espresso-core:3.0.2"

    const val guava = "com.google.guava:guava:24.1-jre"

    const val commons = "org.apache.commons:commons-lang3:3.6"

    const val zxing = "com.google.zxing:core:3.3.2"



    //leakcanary

    const val leakcanary = "com.squareup.leakcanary:leakcanary-android:2.4"



    //jetPack

    const val room_runtime = "androidx.room:room-runtime:2.2.5"

    const val room_compiler = "androidx.room:room-compiler:2.2.5"

    const val room_rxjava2 = "androidx.room:room-rxjava2:2.2.5"

    const val lifecycle_extensions = "android.arch.lifecycle:extensions:1.1.1"

    const val lifecycle_compiler = "android.arch.lifecycle:compiler:1.1.1"

    const val rxlifecycle = "com.trello.rxlifecycle3:rxlifecycle:3.1.0"

    const val rxlifecycle_components = "com.trello.rxlifecycle3:rxlifecycle-components:3.1.0"



    //Kotlin

    const val kotlinx_coroutines_core = "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7"

    //...

}

• 在 VersionPlugin/src/main/java/包名/ 目录下新建 VersionPlugin.kt，实现Plugin接口，如下：

package com.yu.versionplugin



import org.gradle.api.Plugin

import org.gradle.api.Project



class VersionPlugin : Plugin<Project>{

    override fun apply(p0: Project) {



    }



    companion object{

        

    }

}

• 在 settings.gradle 文件内添加如下代码，并重启 Android Studio

//注意是 includeBuild

includeBuild 'VersionPlugin'

• 在 app 模块 build.gradle 文件内 首行 添加以下内容

plugins{

    // 这个 id 就是在 VersionPlugin 文件夹下 build.gradle 文件内定义的 id

    id "com.yu.plugin"

}

// 定义的依赖地址

import com.yu.versionplugin.*

• 使用如下：

import com.yu.versionplugin.*



plugins {

    id 'com.android.application'

    id 'kotlin-android'

    id 'com.yu.plugin'

}



android {

    compileSdk 32



    defaultConfig {

        applicationId "com.yu.versiontest"

        minSdk BuildVersion.minSdkVersion

        targetSdk BuildVersion.targetSdkVersion

        versionCode BuildVersion.versionCode

        versionName BuildVersion.versionName

    }

    //.....

}



dependencies {



    implementation BuildConfig.coreKtx

    implementation BuildConfig.appcompat

    implementation BuildConfig.material

    //......

}

前言

众所周知，Flutter 的 WebView 不太友好，用起来不顺手。
我们 Flutter 开发常用的 WebView 库有2个，一个是 Flutter 官方自己出的 webview_flutter ，另一个是比较流行的 flutter_inappwebview 。这两个库其实差不多，flutter_inappwebview 功能比较丰富，封装了很多事件、方法等，但是很多问题这两个库都会遇到。本文以 webview_flutter 为基础库展开讲解相关问题以及解决方案。

问题

白屏、UI错乱

如上图所示

• 测试的时候发现部分手机（如OPPO）会出现白屏现象（左图）


• 原生与 Flutter 混编，打开页面会发现页面布局变了，顶部banner变小了（右图）

查阅网上的一些解决方案，千篇一律都是：

if (Platform.isAndroid) WebView.platform = SurfaceAndroidWebView();

但是，这样设置其实是不对的，还会出现以上问题，真正的解决方案是：

if (Platform.isAndroid) WebView.platform = AndroidWebView();

视频自动播放

由于需求需要，打开页面的时候，列表的第一个视频（YouTube/Facebook 视频）需要自动播放。
但是发现没法自动播放，如下图，会出现播放之后马上暂停的现象。

查阅资料得知，是谷歌浏览器的隐私政策导致的。

• Chrome 的自动播放策略
  
  
  
  • 始终允许静音自动播放。
  
  
  • 在以下情况下允许自动播放声音：
    
    
    
    • 用户与域进行了交互（单击、点击等）
    
    
    • 在桌面上，用户的媒体参与指数阈值已被超过，这意味着用户之前播放过有声视频。
    
    
    • 用户已将网站添加到移动设备的主屏幕或在桌面设备上安装 PWA。
    
    
    
    
  
  
  • 顶级框架可以将自动播放权限委托给其 iframe 以允许自动播放声音。
  
  
  
  

所以要想视频自动播放，有两种方案：

• 静音播放。
  
  
  
  • 在 Web 端调用视频播放器的静音即可自动播放。
  
  
  
  


• 模拟点击。
  
  
  
  • 给 WebView 设置一个 GlobalKey 。
    

    WebView(
    
        key: logic.state.videoGlobalKey,
    
        ......
    
      );
    
    }
    

    
    
  
  
  • 然后在 WebView 的 onPageFinished 方法里，通过 GlobalKey 获取 WebView 的位置，从而进行模拟点击，就可以自动播放视频了。
    

    var currentContext = state.videoGlobalKey.currentContext;
    
    var offset = (currentContext?.findRenderObject() as RenderBox)
    
        .localToGlobal(Offset.zero);
    
    //模拟点击
    
    var addPointer = PointerAddedEvent(
    
      pointer: 0,
    
      position: Offset(
    
          offset.dx + 92.w,
    
          offset.dy + 92.w),
    
    );
    
    var downPointer = PointerDownEvent(
    
      pointer: 0,
    
      position: Offset(
    
          offset.dx + 92.w,
    
          offset.dy + 92.w),
    
    );
    
    var upPointer = PointerUpEvent(
    
      pointer: 0,
    
      position: Offset(
    
          offset.dx + 92.w,
    
          offset.dy + 92.w),
    
    );
    
    GestureBinding.instance!.handlePointerEvent(addPointer);
    
    GestureBinding.instance!.handlePointerEvent(downPointer);
    
    GestureBinding.instance!.handlePointerEvent(upPointer);
    

    
    
  
  
  
  

这两种方案各有利弊，方案一无法播放声音（需要用户手动点击开启声音），方案二偶尔会有误触的操作。我们 APP 通过与产品商量最终选取的是方案一的解决方案。

另外 iOS 端自动播放会自动全屏，需要设置以下属性：

WebView(

    key: logic.state.videoGlobalKey,

    // 允许在线播放（解决iOS播放视频自动全屏）

    allowsInlineMediaPlayback: true,

    ......

  );

}

CAS以及Atomic原子操作详解

CAS

• 
  

  什么是CAS

  
  
  
  
  • 针对一个变量，首先比较它在内存中的值与某个期望的值是否相同，如果相同就给它赋予新值
  
  
  • 其原子性是直接在硬件层面得到保障的
  
  
  • CAS是一种无锁算法，在不使用锁的情况下实现多线程之间的变量同步
  
  
  
  


• 
  

  底层: CAS的底层实现

  
  
  
  
  • 从JVM源码层面的看CAS
    
    
    
    • 原子性
      
      
      
      • 在单核处理器是通过cmpxchgl指令来保证原子性的，在多核处理器下无法保证了，通过lock前缀的加持变为lock cmpxchgl保证了原子性，这里lock前缀指令拥有保证后续指令的原子性的作用
      
      
      
      
    
    
    • 有序性
      
      
      
      • 通过C++关键字volatile禁止指令重排序保证有序性，对于C++关键字volatile有两个作用一个是禁止重排序，一个是防止代码被优化
      
      
      
      
    
    
    • 其中可见性在JVM源码层面是保证的了，因为多核处理器下会加lock前缀指令，但是Java代码层面实现的CAS不能保证get加锁标记和set加锁标记的可见性，比如Atomic类中需要通过volatile修饰state保证可见性
    
    
    
    
  
  
  
  


• 
  

  缺陷: CAS的缺陷

  
  
  
  
  • 一般CAS都是配合自旋，自旋时间过长，可能会导致CPU满载，所以一般会选择自旋到一定次数去park
  
  
  • 每次只能保证一个共享变量进行原子操作
  
  
  • ABA问题
    
    
    
    • 问题: 什么是ABA问题
      
      
      
      • 当有多个线程对一个原子类进行操作时，某个线程在这段时间内将A修改到B，又马上将其修改为A，其他线程并不感知，还是会被修改成功
      
      
      
      
    
    
    • 问题: ABA问题的解决方案
      
      
      
      • 数据库有个锁是乐观锁，是一种通过版本号方式来进行数据同步，也就是每次更新的时候都会匹配这个版本号，只有符号才能更新成功，同样的ABA问题也是基于这种去解决的，相应的Java也提供了对应的原子类AtomicStampedRefrence，其内部reference就是我们实际存储的变量，stamp就是版本号，每次修改可以通过加1来保证版本的唯一性
      
      
      
      
    
    
    
    
  
  
  
  


• 
  

  问题: CAS失败自旋的操作存在什么问题

  
  
  
  
  • CAS自旋时间过长不成功，会给CPU带来较大的开销
  
  
  
  


• 
  

  CAS的应用

  
  
  
  
  • 
    

    CAS操作的是由Unsafe类提供支持，该类定义了三种针对不同类型变量的CAS操作

    
    

    public final native boolean compareAndSwapObject(Object o, long offset,Object expected,Object x);
    
    public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x);               
    
    public final native boolean compareAndSwapLong(Object o, long offset,long expected,long x);
    

    
    
  
  
  
  

Atomic原子类

• 在并发编程中很容易出现并发安全的问题，比如自增操作，有可能不能获取正确的值，一般情况想到的是synchronized来保证线程安全，但是由于它是悲观锁，并不是最高效的解决方案，所以Juc提供了乐观锁的方式去提升性能
  
  
  
  • 基本类型: AtomicInteger、AtomicLong、AtomicBoolean
  
  
  • 引用类型: AtomicReference、AtomicStampedRerence、AtomicMarkableReference
  
  
  • 数组类型: AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
  
  
  • 对象属性原子修改器: AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater
  
  
  • 原子类型累加器(JDK8增加的类): DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder、Striped64
  
  
  
  

LongAdder和DoubleAdder

瓶颈详解

• 对于高并发场景下，多个线程同时进行自旋操作，会出现大量失败并不断自旋的情况，此时AtomicLong自旋会成为瓶颈，LongAdder引入解决了高并发场景，AtomicInteger、AtomicLong的自旋瓶颈问题

LongAdder原理

• AtomicLong中有个内部变量value保存着实际的值，所有的操作都是针对该变量进行，在高并发场景下，value变量其实就是一个热点，多个线程同时竞争这个热点，而这样冲突的概率就比较大了


• 重点: LongAdder的基本思路就是分散热点，将value的值分散到一个数组中，不同线程会命中到这个数组的不同槽位中，各个线程只对自己槽位中的那个值进行CAS操作，这样就分散了热点，冲突的概率就小很多，如果要获取真正的值，只需要将各个槽位的值累加返回


• LongAdder设计的精妙之处: 尽量减少热点冲突，不到最后万不得已，尽量将CAS操作延迟


• 注意: LongAdder的sum方法会有线程安全的问题
  
  
  
  • 高并发场景下除非全局加锁，否则得不到程序运行中某个时刻绝对准确的值，由于计算总和时没有对Cell数组进行加锁，所以在累加过程中可能有其他线程对于Cell数组中的值因为线程安全无法保障进行了修改，也有可能对数组进行了扩容，所以sum返回的值并不是非常精确的，其返回值并不是一个调用sum方法的原子快照值
  
  
  
  

LongAdder逻辑

LongAccumulator

• LongAccumulator是LongAdder的增强版本，LongAdder只针对数组值进行加减运算，而LongAccumulator提供了自定义的函数操作


• LongAccumulator内部原理和LongAdder几乎完全一样，都是利用了父类Striped64的longAccumulate方法

前言

• 前面铺掉了那么多都是在讲原则，讲图例。很多同学可能都觉得和设计模式不是很搭边。虽说设计模式也是理论的东西，但是设计原则可能对我们理解而言更加的抽象。不过好在原则东西不是很多，后面我们就可以开始转讲设计模式了。


• 我的思路是按照设计模式进行分类整理。期间穿插相关的知识进行扩展从而保证我们学习的更加的全面。在正式开始前我现在这里立个Flag。争取在20周内完成我们设计模式章节的内容。期间可能会有别的学习，20周争取吧


• 相信单例模式是大家第一个使用到的设计模式吧。不管你怎么样，我第一个使用的就是单例模式。其实单例模式也是分很多种的【饿汉式】、【懒汉式】。如果在细分还有线程安全和线程不安全版本的。

饿汉式

• 顾名思义饿汉式就是对类需求很迫切。从Java角度看就是类随着JVM启动就开始创建，不管你是否使用到只要JVM启动就会创建。

 public class SingleFactory

 {

     private static Person person = new Person();

 

     private SingleFactory()

     {

     }

 

     public static Person getInstance()

     {

         return person;

     }

 }

• 上面这段代码就是饿汉式单例模式。通过这单代码我们也能够总结出单例模式的几个特点

• 
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  特点
  隐藏类的创建即外部无法进行创建
  内部初始化好一个完整的类
  提供一个可以访问到内部实例的方法，这里指的是getInstance

  
  

• 单例模式特点还是很容易区分的。饿汉式感觉挺好的，那为什么后面还会出现懒汉式及其相关的变形呢？下面我们就来看看饿汉式有啥缺点吧。


• 首先上面我们提到饿汉式的标志性特点就是随着JVM 的启动开始生成实例对象。这是优点同时也是缺点。大家应该都用过Mybatis等框架，这些框架为了加快我们程序的启动速度纷纷推出各种懒加载机制。


• 何为懒加载呢？就是用到的时候再去初始化相关业务，将和启动不相关的部分抽离出去，这样启动速度自然就快了起来了。在回到饿汉式，你不管三七二十一就把我给创建了这无疑影响了我的程序启动速度。如果这个单例模式你使用了倒还好，假如启动之后压根就没用到这个单例模式的类，那我岂不是吃力不讨好。不仅浪费了时间还浪费了我的空间。


• 所以说，处于对性能的考虑呢？还是建议大家不要使用饿汉式单例。但是，存在即是合理的，我们不能一棒子打死一堆人。具体场景具体对待吧XDM。

🐶变形1

 public class SingleFactory

 {

     private static Person person ;

 

     static {

         person = new Person();

     }

 

     private SingleFactory()

     {

     }

 

     public static Person getInstance()

     {

         return person;

     }

 }

• 咋一看好像和上面的没啥区别哦。仔细对比你就会发现我们这里并没有立刻创建Person这个类，而是放在静态代码块中初始化实例了。


• 放在静态代码块和直接创建其实是一样的。都是通过类加载的方式来进行实例化的。基本同根同源没啥可说的 。


• 关于Static关键字我们之前也有说过，他涉及到的是类加载的顺序。我们在类加载的最后阶段就是执行我们的静态代码块

懒汉式

 public class SingleFactory

 {

     private static Person person = null;

 

     private SingleFactory()

     {

     }

 

     public static Person getInstance()

     {

         try

         {

             Thread.sleep(30);

         }

         catch (InterruptedException e)

         {

            e.printStackTrace();

         }

         if(person==null){

             person=new Person();

         }

         return person;

     }

 }

• 懒汉式就是将我们的对象创建放在最后一刻进行创建。并不是跟随类加载的时候生成对象的，这样会造成一定程度的内存浪费。懒汉式更加的提高了内存的有效利用。在getInstance方法中我们在获取对象前判断是否已经生成过对象。如果没有在生成对象。这种行为俗称懒，所以叫做懒汉式单例模式

🐱变形1

• 上面懒汉式单例中我加入了睡眠操作。这是因为我想模拟出他的缺点。上面这种方式在高并发的场景下并不能保证系统中仅有一个实例对象。

 public class SingleFactory

 {

     private static Person person = null;

 

     private SingleFactory()

     {

     }

 

     public static Person getIstance()

     {

         try

         {

             Thread.sleep(30);

         }

         catch (InterruptedException e)

         {

             e.printStackTrace();

         }

         synchronized (SingleFactory.class)

         {

             if (person == null)

             {

                 person = new Person();

             }

         }

         return person;

     }

 }

• 只需要加一把锁，就能保证线性操作了。但是仔细想想难道这样就真的安全了吗。

double-check

• 在多线程下安全的单例模式应该非double-check莫属了吧。

 public class OnFactory {

     private static volatile OnFactory onFactory;

 

     public static OnFactory getInstance() {

         if (null == onFactory) {

             synchronized (OnFactory.class) {

                 if (null == onFactory) {

                     onFactory = new OnFactory();

                 }

             }

         }

         return onFactory;

     }

 }

• 这段代码是之前咱们学习double-check和volatile的时候写过的一段代码。在这里我们不仅在锁前后都判断了而且还加上了volatile进行内存刷新。关于volatile需要的在主页中搜索关键词即可找到。这里仅需要知道一点volatile必须存在否则线程不安全。

一、前言

• 责任链模式
  
  
  
  • 作用：避免请求的发送者和接收者之间的耦合关系，将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
  
  
  • 举例：OKHttp 的拦截器、Servlet 中的 FilterChain
  
  
  
  

二、使用责任链模式

• 例子：学生会经费申请


• 重点：1 个请求会在 n 个处理器组成的处理器链上传递

以学生会经费申请会例，学生会会有一些日常开销以及活动开支，需要向学院的学生会基金申请经费，如果金额在 100 元之内，由分部长审批；如果金额在 100 到 500 元之间，由会长审批；如果金额在 500 到 1000 元之间，由学院辅导员审批；而如果金额超过 1000 元，则默认打回申请。像这种需要一层层往后传递请求的情况，非常适合采用责任链模式来设计程序：

/**

 * 经费申请事件

 *

 * @author GitLqr

 */

data class ApplyEvent(val money: Int, val title: String)



/**

 * 经费审批处理器

 *

 * @author GitLqr

 */

interface ApplyHandler {

    val successor: ApplyHandler?

    fun handleEvent(event: ApplyEvent)

}

注意：责任链模式需要将处理器对象连成一条链，最简单粗暴的方式就是让前驱处理器持有后继处理器 successor

接着，根据案例需要，编写各个角色对应的处理器类：

/**

 * 部长

 *

 * @author GitLqr

 */

class GroupLeader(override val successor: ApplyHandler?) : ApplyHandler {

    override fun handleEvent(event: ApplyEvent) {

        when {

            event.money <= 100 -> println("Group Leader handled application: ${event.title}.")

            successor != null -> successor.handleEvent(event)

            else -> println("Group Leader: This application cannot be handled.")

        }

    }

}



/**

 * 会长

 *

 * @author GitLqr

 */

class President(override val successor: ApplyHandler?) : ApplyHandler {

    override fun handleEvent(event: ApplyEvent) {

        when {

            event.money <= 500 -> println("President handled application: ${event.title}.")

            successor != null -> successor.handleEvent(event)

            else -> println("President: This application cannot be handled.")

        }

    }

}



/**

 * 学院

 *

 * @author GitLqr

 */

class College(override val successor: ApplyHandler?) : ApplyHandler {

    override fun handleEvent(event: ApplyEvent) {

        when {

            event.money <= 1000 -> println("College handled application: ${event.title}.")

            successor != null -> successor.handleEvent(event)

            else -> println("College: This application cannot be handled.")

        }

    }

}

最后，创建各个角色处理器实例，并按顺序组成一条链，由链头开始接收、转发需要被处理的经费申请事件：

// 使用

// val college = College(null)

// val president = President(college)

// val groupLeader = GroupLeader(president)

val groupLeader = GroupLeader(President(College(null)))

groupLeader.handleEvent(ApplyEvent(10, "buy a pen")) // 买只钢笔

groupLeader.handleEvent(ApplyEvent(200, "team building")) // 团建

groupLeader.handleEvent(ApplyEvent(600, "hold a debate match")) // 举行辩论赛

groupLeader.handleEvent(ApplyEvent(1200, "annual meeting of the college")) // 学院年会



// 输出

Group Leader handled application: buy a pen.

President handled application: team building.

College handled application: hold a debate match.

College: This application cannot be handled.

从输出结果可以看到，经费申请事件会在处理器链上传递，直到被一个合适的处理器处理并终止。

注意：这话是针对当前案例说的，责任链模式没有硬性要求一个请求只能被一个处理器处理，你可以在前面的处理器中对请求进行加工，提取数据等等操作，并且可以选择是否放行，交由后面的处理器继续处理，这需要根据实际情况，灵活应变。

三、改良责任链模式

• 例子：学生会经费申请


• 重点：偏函数 Partial Function

在对上述案例进行改良之前，我们先来了解一下偏函数是什么，在不同的编程语言中，对偏函数的理解还不一样，在 Python 中，偏函数是使用 functools.partial 把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。而在 Scala 中，偏函数是使用 PartialFunction 构建一个仅仅处理输入参数的部分分支的函数，换句话说，就是带有判断条件的函数，只有满足条件的参数，才会被函数处理。

以上结论来自以下两篇文章：

• 廖雪峰官方网站上的 Python 《偏函数》http://www.liaoxuefeng.com/wiki/101695…


• 数据工匠记（作者：匠人李）的 Scala 《偏函数（Partial Function）》http://www.lllpan.top/article/77

题外话：对 Scala 偏函数有兴趣的可以看一下上面的文章，写的很通透。

回过头来，责任链模式的核心机理是，整个链条上的每个处理环节都有对其输入的校验标准，当输入的参数处于某个责任链节的有效接收范围之内，该环节才能对其做出正常的处理操作。那么，我们是不是可以把链条上的每个处理环节看做是一个个的偏函数呢？是的，不过 Kotlin 中并没有内置偏函数 API，好在有一个第三方 Kotlin 函数库【funKTionale】，其中的 partialfunctions.kt 就有 Scala 中偏函数的类似实现：

// https://github.com/MarioAriasC/funKTionale/blob/master/funktionale-utils/src/main/kotlin/org/funktionale/utils/partialfunctions.kt



class PartialFunction<in P1, out R>(private val definetAt: (P1) -> Boolean, private val f: (P1) -> R) : (P1) -> R {

    override fun invoke(p1: P1): R {

        if (definetAt(p1)) {

            return f(p1)

        } else {

            throw IllegalArgumentException("Value: ($p1) isn't supported by this function")

        }

    }



    fun isDefinedAt(p1: P1) = definetAt(p1)

}

这个 PartialFunction 类第一眼看上去感觉好复杂，分成如下几步，方便理解：

• PartialFunction 继承自一个函数类型 (P1) -> R，编译器会强制要求实现 invoke() 方法，这意味着 PartialFunction 实例对象可以像调用函数那样使用。


• 构造参数 1 definetAt: (P1) -> Boolean 用于判断 P1 参数是否满足被处理的条件。


• 构造参数 2 f: (P1) -> R 用于处理 P1 参数并返回 R 类型值。


• 成员方法 invoke 中，当 P1 满足条件时，则将 P1 交给 构造参数 2 f: (P1) -> R 处理；否则抛出异常。


• 成员方法 isDefinedAt 只是构造参数 1 definetAt 的拷贝。

所以，用一句话概括 PartialFunction 实例对象，就是一个带有判断条件的"函数"，只有满足条件的参数，才会被"函数"处理。现在我们用一个个 PartialFunction 实例来代替处理器是完全没问题的，问题是怎么把它们链接起来呢？【funKTionale】中还为 PartialFunction 扩展了一个 orElse 函数，这就是把偏函数组合起来的关键：

// https://github.com/MarioAriasC/funKTionale/blob/master/funktionale-utils/src/main/kotlin/org/funktionale/utils/partialfunctions.kt



infix fun <P1, R> PartialFunction<P1, R>.orElse(that: PartialFunction<P1, R>): PartialFunction<P1, R> {

    return PartialFunction({ this.isDefinedAt(it) || that.isDefinedAt(it) }) {

        when {

            this.isDefinedAt(it) -> this(it)

            that.isDefinedAt(it) -> that(it)

            else -> throw IllegalArgumentException("function not definet for parameter ($it)")

        }

    }

}

同样，也分成如下几步，方便理解：

• orElse 是 PartialFunction 的扩展函数，故内部可以使用 this 获取原本的 PartialFunction 实例（也就是 receiver）。


• orElse 只接收一个 PartialFunction 类型参数 that，并且返回一个 PartialFunction 类型实例，故 orElse 可以嵌套调用。


• orElse 返回值是一个使用了两个 PartialFunction 实例对象 （即 this 和 that）组合出来的一个新的 PartialFunction 实例对象，


• orElse 返回值的意图是，只要原本的 this 和 that 中有一个条件成立，那么就让条件成立的那个来处理参数 P1 ，否则抛出异常。其实，这个 that 就相当于是责任链模式中的 successor。


• orElse 使用 infix 修饰，故支持中缀表达式写法。

注意：你可能一时看不懂 PartialFunction({ xxx }){ yyy } 这个奇怪的语法，其实很简单，在创建一个 PartialFunction 实例时，可以传入两个 Lambda 表达式，所以正常写法应该是这样的 PartialFunction({ xxx }, { yyy }) ，不过，在 Kotlin 中，当 Lambda 表达式作为最后一个参数传入时，可以写到函数外部，所以就出现了 PartialFunction({ xxx }){ yyy } 这种写法。

好了，现在用 PartialFunction 来改良原本的责任链模式代码：

/**

 * 使用自运行Lambda来构建一个个 PartialFunction 实例：部长、会长、学院

 *

 * @author GitLqr

 */

val groupLeader = {

    val definetAt: (ApplyEvent) -> Boolean = { it.money <= 200 }

    val handler: (ApplyEvent) -> Unit = { println("Group Leader handled application: ${it.title}.") }

    PartialFunction(definetAt, handler)

}()

val president = {

    val definetAt: (ApplyEvent) -> Boolean = { it.money <= 500 }

    val handler: (ApplyEvent) -> Unit = { println("President handled application: ${it.title}.") }

    PartialFunction(definetAt, handler)

}()

val college = {

    val definetAt: (ApplyEvent) -> Boolean = { true }

    val handler: (ApplyEvent) -> Unit = {

        when {

            it.money <= 1000 -> println("College handled application: ${it.title}.")

            else -> println("College: This application is refused.")

        }

    }

    PartialFunction(definetAt, handler)

}()

注意：自运行 Lambda 相当于是 js 中的立即执行函数。

接下来就是用 orElse 将一个个 PartialFunction 实例链接起来：

// 使用

// val applyChain = groupLeader.orElse(president.orElse(college))

val applyChain = groupLeader orElse president orElse college // 中缀表达式

applyChain(ApplyEvent(10, "buy a pen")) // 买只钢笔

applyChain(ApplyEvent(200, "team building")) // 团建

applyChain(ApplyEvent(600, "hold a debate match")) // 举行辩论赛

applyChain(ApplyEvent(1200, "annual meeting of the college")) // 学院年会



// 输出

Group Leader handled application: buy a pen.

Group Leader handled application: team building.

College handled application: hold a debate match.

College: This application is refused.

使用 PartialFunction 之后，不仅可以不幅度减少代码量，结合 orElse 能获得更好的语法表达。以上，就是使用偏函数改良责任链模式的全部内容了。为了加深对偏函数的理解，这里引用数据工匠记的 Scala 《偏函数（Partial Function）》原文中的话：

为什么要用偏函数呢？以我个人愚见，还是一个重用粒度的问题。函数式的编程思想是以一种“演绎法”而非“归纳法”去寻求解决空间。也就是说，它并不是要去归纳问题然后分解问题并解决问题，而是看透问题本质，定义最原初的操作和组合规则，面对问题时，可以通过组合各种函数去解决问题，这也正是“组合子（combinator）”的含义。偏函数则更进一步，将函数求解空间中各个分支也分离出来，形成可以被组合的偏函数。

简介

在开发过程中通常会遇到一些不规则的UI，比如不规则的线条，多边形，统计图表等等，用那些通用组件通过组合的方式无法进行实现，这就需要我们自己进行绘制。可以通过使用CuntomPaint组件并结合画笔CustomPainter去进行手动绘制各种图形。

CustomPaint介绍

CustomPaint是一个继承SingleChildRenderObjectWidget的Widget，这里主要介绍几个重要参数：

child：CustomPaint的子组件。
painter： 画笔，绘制的图形会显示在child后面。

foregroundPainter：前景画笔，绘制的图形会显示在child前面。

size：绘制区域大小。

CustomPainter介绍

CustomPainter是一个抽象类，通过自定义一个类继承自CustomPainter，重写paint和shouldRepaint方法，具体绘制主要在paint方法里。

paint介绍

主要两个参数：
Canvas：画布，可以用于绘制各种图形。
Size：绘制区域的大小。

void paint(Canvas canvas, Size size)

shouldRepaint介绍

在Widget重绘前会调用该方法确定时候需要重绘，shouldRepaint返回ture表示需要重绘，返回false表示不需要重绘。

bool shouldRepaint(CustomPainter oldDelegate)

示例

这里我们通过绘制一个饼状图来演示绘制的整体流程。

使用CustomPaint

首先，使用CustomPaint，绘制大小为父组件最大值，传入自定义painter。

@override

Widget build(BuildContext context) {

    return CustomPaint(

      size: Size.infinite,

      painter: PieChartPainter(),

    );

}

自定义Painter

自定义PieChartPainter继承CustomPainter

class PieChartPainters extends CustomPainter {

  @override

  void paint(Canvas canvas, Size size) {

    

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) {

    return oldDelegate != this;

  }

}

绘制

接着我们来实现paint方法进行绘制

@override

void paint(Canvas canvas, Size size) {

    //移动到中心点

    canvas.translate(size.width / 2, size.height / 2);

    //绘制饼状图

    _drawPie(canvas, size);

    //绘制扇形分割线

    _drawSpaceLine(canvas);

    //绘制中心圆

    _drawHole(canvas, size);

}

绘制饼状图

我们以整个画布的中点为圆点，然后计算出每个扇形的角度区域，通过canvas.drawArc绘制扇形。

void _drawPie(Canvas canvas, Size size) {

    var startAngle = 0.0;

    var sumValue = models.fold<double>(0.0, (sum, model) => sum + model.value);

    for (var model in models) {

      Paint paint = Paint()

        ..style = PaintingStyle.fill

        ..color = model.color;

      var sweepAngle = model.value / sumValue * 360;

      canvas.drawArc(Rect.fromCircle(radius: model.radius, center: Offset.zero),

          startAngle * pi / 180, sweepAngle * pi / 180, true, paint);



      //为每一个区域绘制延长线和文字

      _drawLineAndText(

          canvas, size, model.radius, startAngle, sweepAngle, model);



      startAngle += sweepAngle;

    }

}

绘制延长线以及文本

延长线的起点为扇形区域边缘中点位置，长度为一个固定的长度，转折点坐标通过半径加这个固定长度和三角函数进行计算，然后通过转折点的位置决定横线终点的方向，而横线的长度则根据文字的宽度决定，然后通过canvas.drawLine进行绘制直线。

文本绘制使用TextPainter.paint进行绘制，paint方法里面最终是通过canvas.drawParagraph进行绘制的。

最后再在文字的前面通过canvas.drawCircle绘制一个小圆点。

 void _drawLineAndText(Canvas canvas, Size size, double radius,

      double startAngle, double sweepAngle, PieChartModel model) {

    var ratio = (sweepAngle / 360.0 * 100).toStringAsFixed(2);



    var top = Text(model.name);

    var topTextPainter = getTextPainter(top);



    var bottom = Text("$ratio%");

    var bottomTextPainter = getTextPainter(bottom);



    // 绘制横线

    // 计算开始坐标以及转折点的坐标

    var startX = radius * (cos((startAngle + (sweepAngle / 2)) * (pi / 180)));

    var startY = radius * (sin((startAngle + (sweepAngle / 2)) * (pi / 180)));



    var firstLine = radius / 5;

    var secondLine =

        max(bottomTextPainter.width, topTextPainter.width) + radius / 4;

    var pointX = (radius + firstLine) *

        (cos((startAngle + (sweepAngle / 2)) * (pi / 180)));

    var pointY = (radius + firstLine) *

        (sin((startAngle + (sweepAngle / 2)) * (pi / 180)));



    // 计算坐标在左边还是在右边

    // 并计算横线结束坐标

    // 如果结束坐标超过了绘制区域，则改变结束坐标的值

    var marginOffset = 20.0; // 距离绘制边界的偏移量

    var endX = 0.0;

    if (pointX - startX > 0) {

      endX = min(pointX + secondLine, size.width / 2 - marginOffset);

      secondLine = endX - pointX;

    } else {

      endX = max(pointX - secondLine, -size.width / 2 + marginOffset);

      secondLine = pointX - endX;

    }



    Paint paint = Paint()

      ..style = PaintingStyle.fill

      ..strokeWidth = 1

      ..color = Colors.grey;



    // 绘制延长线

    canvas.drawLine(Offset(startX, startY), Offset(pointX, pointY), paint);

    canvas.drawLine(Offset(pointX, pointY), Offset(endX, pointY), paint);



    // 文字距离中间横线上下间距偏移量

    var offset = 4;

    var textWidth = bottomTextPainter.width;

    var textStartX = 0.0;

    textStartX =

        _calculateTextStartX(pointX, startX, textWidth, secondLine, textStartX, offset);

    bottomTextPainter.paint(canvas, Offset(textStartX, pointY + offset));



    textWidth = topTextPainter.width;

    var textHeight = topTextPainter.height;

    textStartX =

        _calculateTextStartX(pointX, startX, textWidth, secondLine, textStartX, offset);

    topTextPainter.paint(canvas, Offset(textStartX, pointY - offset - textHeight));



    // 绘制文字前面的小圆点

    paint.color = model.color;

    canvas.drawCircle(

        Offset(textStartX - 8, pointY - 4 - topTextPainter.height / 2),

        4,

        paint);

}

绘制扇形分割线

在绘制完扇形之后，然后在扇形的开始的那条边上绘制一条直线，起点为圆点，长度为扇形半径，终点的位置根据半径和扇形开始的那条边的角度用三角函数进行计算，然后通过canvas.drawLine进行绘制。

void _drawSpaceLine(Canvas canvas) {

    var sumValue = models.fold<double>(0.0, (sum, model) => sum + model.value);

    var startAngle = 0.0;

    for (var model in models) {

      _drawLine(canvas, startAngle, model.radius);

      startAngle += model.value / sumValue * 360;

    }

}



void _drawLine(Canvas canvas, double angle, double radius) {

    var endX = cos(angle * pi / 180) * radius;

    var endY = sin(angle * pi / 180) * radius;

    Paint paint = Paint()

      ..style = PaintingStyle.fill

      ..color = Colors.white

      ..strokeWidth = spaceWidth;

    canvas.drawLine(Offset.zero, Offset(endX, endY), paint);

  }

绘制内部中心圆

这里可以通过传入的参数判断是否需要绘制这个圆，使用canvas.drawCircle进行绘制一个与背景色一致的圆。

void _drawHole(Canvas canvas, Size size) {

    if (isShowHole) {

      holePath.reset();

      Paint paint = Paint()

        ..style = PaintingStyle.fill

        ..color = Colors.white;

      canvas.drawCircle(Offset.zero, holeRadius, paint);

    }

}

触摸事件处理

接下来我们来处理点击事件，当我们点击某一个扇形区域时，此扇形需要突出显示，如下图：

重写hitTest方法

注意

这个方法的返回值决定是否响应事件。

默认情况下返回null，事件不会向下传递，也不会进行处理；
如果返回true则当前组件进行处理事件；
如果返回false则当前组件不会响应点击事件，会向下一层传递；

我直接在这里处理点击事件，通过该方法传入的offset确定点击的位置，如果点击位置是在圆形区域内并且不在中心圆内则处理事件同时判断所点击的具体是哪个扇形，反之则恢复默认状态。

@override

bool? hitTest(Offset offset) {

    if (oldTapOffset.dx==offset.dx && oldTapOffset.dy==offset.dy) {

      return false;

    }

    oldTapOffset = offset;

    for (int i = 0; i < paths.length; i++) {

      if (paths[i].contains(offset) &&

          !holePath.contains(offset)) {

        onTap?.call(i);

        oldTapOffset = offset;

        return true;

      }

    }

    onTap?.call(-1);

    return false;

}

至此，我们通过onTap向上传递出点击的是第几个扇形，然后进行处理，更新UI就可以了。

动画实现

这里通过Widget继承ImplicitlyAnimatedWidget来实现，ImplicitlyAnimatedWidget是一个抽象类，继承自StatefulWidget，既然是StatefulWidget那肯定还有一个State，State继承AnimatedWidgetBaseState（此类继承自ImplicitlyAnimatedWidgetState），感兴趣的小伙伴可以直接去看源码

实现AnimatedWidgetBaseState里面的forEachTween方法，主要是用于来更新Tween的初始值。

@override

void forEachTween(TweenVisitor<dynamic>visitor) {

   customPieTween = visitor(customPieTween, end, (dynamic value) {

      return CustomPieTween(begin: value, end: end);

    }) as CustomPieTween;

}

自定义CustomPieTween继承自Tween，重写lerp方法，对需要做动画的参数进行处理

class CustomPieTween extends Tween<List<PieChartModel>> {

  CustomPieTween({List<PieChartModel>? begin, List<PieChartModel>? end})

      : super(begin: begin, end: end);



  @override

  List<PieChartModel> lerp(double t) {

    List<PieChartModel> list = [];

    begin?.asMap().forEach((index, model) {

      list.add(model

        ..radius = lerpDouble(model.radius, end?[index].radius ?? 100.0, t));

    });

    return list;

  }



  double lerpDouble(double radius, double radius2, double t) {

    if (radius == radius2) {

      return radius;

    }

    var d = (radius2 - radius) * t;

    var value = radius + d;

    return value;

  }

}

完整代码

感兴趣的小伙伴可以直接看源码
GitHub：chart_view

前言

之前的文章都有简述Element，这篇将着重去讲Element
Widget是描述一个UI元素的配置数据，Element才真正代表屏幕显示元素

分类

如上图所示Element分为两类

• 
  

  ComponentElement ： 组合类Element。这类Element主要用来组合其他更基础的Element，得到功能更加复杂的Element。开发时常用到的StatelessWidget和StatefulWidget相对应的Element：StatelessElement和StatefulElement，即属于ComponentElement。

  
  


• 
  

  RenderObjectElement ： 渲染类Element，对应Renderer Widget，是框架最核心的Element。RenderObjectElement主要包括LeafRenderObjectElement（叶子无节点），SingleChildRenderObjectElement（单child），和MultiChildRenderObjectElement（多child）。

  
  

Element生命周期

Element有4种状态：initial，active，inactive，defunct。其对应的意义如下：

• initial：初始状态，Element刚创建时就是该状态。


• active：激活状态。此时Element的Parent已经通过mount将该Element插入Element Tree的指定的插槽处（Slot），Element此时随时可能显示在屏幕上。


• inactive：未激活状态。当Widget Tree发生变化，Element对应的Widget发生变化，同时由于新旧Widget的Key或者的RunTimeType不匹配等原因导致该Element也被移除，因此该Element的状态变为未激活状态，被从屏幕上移除。并将该Element从Element Tree中移除，如果该Element有对应的RenderObject，还会将对应的RenderObject从Render Tree移除。但是，此Element还是有被复用的机会，例如通过GlobalKey进行复用。


• defunct：失效状态。如果一个处于未激活状态的Element在当前帧动画结束时还是未被复用，此时会调用该Element的unmount函数，将Element的状态改为defunct，并对其中的资源进行清理。

Element4种状态间的转换关系如下图所示：

ComponentElement

State和StatefulElement是一一对应的，只有在初始化StatefulElement时，才会初始化对应的State并将其绑定到StatefulElement上

核心流程

一个Element的核心操作流程有，创建、更新、销毁三种，下面将分别介绍这三个流程。

创建

ComponentElement的创建起源与父Widget调用inflateWidget，然后通过mount将该Element挂载至Element Tree，并递归创建子节点。

更新

由父Element执行更新子节点的操作（updateChild），由于新旧Widget的类型和Key均未发生变化，因此触发了Element的更新操作，并通过performRebuild将更新操作传递下去。其核心函数updateChild之后会详细介绍。

销毁

由父Element或更上级的节点执行更新子节点的操作（updateChild），由于新旧Widget的类型或者Key发生变化，或者新Widget被移除，因此导致该Element被转为未激活状态，并被加入未激活列表，并在下一帧被失效。

核心函数

• inflateWidget

Element inflateWidget(Widget newWidget, dynamic newSlot) {

  final Key key = newWidget.key;

//复用GlobalKey对应的Element

  if (key is GlobalKey) {

    final Element newChild = _retakeInactiveElement(key, newWidget);

    if (newChild != null) {

      newChild._activateWithParent(this, newSlot);

      final Element updatedChild = updateChild(newChild, newWidget, newSlot);

      return updatedChild;

    }

  }

//创建Element，并挂载至Element Tree

  final Element newChild = newWidget.createElement();

  newChild.mount(this, newSlot);

  return newChild;

}

复制代码

1. 判断新Widget是否有GlobalKey，如果有GlobalKey，则从Inactive Elements列表中找到对应的Element并进行复用。（可能从树的另一个位置嫁接或重新激活）


2. 无可复用Element，则根据新Widget创建对应的Element，并将其挂载至Element Tree。

• mount

void mount(Element parent, dynamic newSlot) {

//更新_parent等属性，将元素加入Element Tree

  _parent = parent;

  _slot = newSlot;

  _depth = _parent != null ? _parent.depth + 1 : 1;

  _active = true;

  if (parent != null) // Only assign ownership if the parent is non-null

    _owner = parent.owner;

//注册GlobalKey

  final Key key = widget.key;

  if (key is GlobalKey) {

    key._register(this);

  }

  _updateInheritance();

}

复制代码

1. 将给Element加入Element Tree，更新_parent，_slot等树相关的属性。


2. 如果新Widget有GlobalKey，将该Element注册进GlobalKey中，其作用下文会详细分析。


3. ComponentElement的mount函数会调用_firstBuild函数，触发子Widget的创建和更新。

• performRebuild

@override

void performRebuild() {

//调用build函数，生成子Widget

  Widget built;

  built = build();

//根据新的子Widget更新子Element

  _child = updateChild(_child, built, slot);

}

复制代码

1. 调用build函数，生成子Widget。


2. 根据新的子Widget更新子Element。

• update

@mustCallSuper

void update(covariant Widget newWidget) {

  _widget = newWidget;

}

复制代码

1. 将对应的Widget更新为新的Widget。


2. 在ComponentElement的各种子类中，还会调用rebuild函数触发对子Widget的重建。

• updateChild

@protected

Element updateChild(Element child, Widget newWidget, dynamic newSlot) {

  if (newWidget == null) {

//新的Child Widget为null，则返回null；如果旧Child Widget，使其未激活

    if (child != null)

      deactivateChild(child);

    return null;

  }

  Element newChild;

  if (child != null) {

//新的Child Widget不为null，旧的Child Widget也不为null

    bool hasSameSuperclass = true;

    if (hasSameSuperclass && child.widget == newWidget) {

      if (child.slot != newSlot)

        updateSlotForChild(child, newSlot);

      newChild = child;

    } else if (hasSameSuperclass && Widget.canUpdate(child.widget, newWidget)){

//Key和RuntimeType相同，使用update更新

      if (child.slot != newSlot)

        updateSlotForChild(child, newSlot);

      child.update(newWidget);

      newChild = child;

    } else {

//Key或RuntimeType不相同，使旧的Child Widget未激活，并对新的Child Widget使用inflateWidget

      deactivateChild(child);

      newChild = inflateWidget(newWidget, newSlot);

    }

  } else {

//新的Child Widget不为null，旧的Child Widget为null，对新的Child Widget使用inflateWidget

    newChild = inflateWidget(newWidget, newSlot);

  }



  return newChild;

}

复制代码

根据新的子Widget，更新旧的子Element，或者得到新的子Element。
逻辑如下（伪代码）：

if（newWidget == null）{

	if(Child == null){

		return null;

	}else{

		移除旧的子Element，返回null

	}

}else{

	if(Child == null){

		返回新Element

	}else{

		如果Widget能更新，更新旧的子Element，并返回之；否则创建新的子Element并返回。

	}

}



复制代码

该逻辑概括如下：

1. 如果newWidget为null，则返回null，同时如果有旧的子Element则移除之。


2. 如果newWidget不为null，旧Child为null，则创建新的子Element，并返回之。


3. 如果newWidget不为null，旧Child不为null，新旧子Widget的Key和RuntimeType等都相同，则调用update方法更新子Element并返回之。


4. 如果newWidget不为null，旧Child不为null，新旧子Widget的Key和RuntimeType等不完全相同，则说明Widget Tree有变动，此时移除旧的子Element，并创建新的子Element，并返回之。

RenderObjectElement

RenderObjectElement同核心元素Widget及RenderObject之间的关系如下图所示：

如图：

RenderObjectElement持有Parent Element，但是不一定持有Child Element，有可能无Child Element，有可能持有一个Child Element（Child），有可能持有多个Child Element(Children)。
RenderObjectElement持有对应的Widget和RenderObject，将Widget、RenderObject串联起来，实现了Widget、Element、RenderObject之间的绑定。

核心流程

如ComponentElement一样，RenderObjectElement的核心操作流程有，创建、更新、销毁三种，接下来会详细介绍这三种流程。

• 创建

-

RenderObjectElement的创建流程和ComponentElement的创建流程基本一致，其最大的区别是ComponentElement在mount后，会调用build来创建子Widget，而RenderObjectElement则是create和attach其RenderObject。

• 更新

RenderObjectElement的更新流程和ComponentElement的更新流程也基本一致，其最大的区别是ComponentElement的update函数会调用build函数，重新触发子Widget的构建，而RenderObjectElement则是调用updateRenderObject对绑定的RenderObject进行更新。

• 销毁

RenderObjectElement的销毁流程和ComponentElement的销毁流程也基本一致。也是由父Element或更上级的节点执行更新子节点的操作（updateChild），导致该Element被停用，并被加入未激活列表，并在下一帧被失效。其不一样的地方是在unmount Element的时候，会调用didUnmountRenderObject失效对应的RenderObject。

核心函数

• inflateWidget

该函数和ComponentElement的inflateWidget函数完全一致，此处不再复述。

• mount

void mount(Element parent, dynamic newSlot) {

  super.mount(parent, newSlot);

  _renderObject = widget.createRenderObject(this);

  attachRenderObject(newSlot);

  _dirty = false;

}

复制代码

该函数的调用时机和ComponentElement的一致，当Element第一次被插入Element Tree的时候，该方法被调用。其主要职责也和ComponentElement的一致，此处只列举不一样的职责，职责如下：

1. 调用createRenderObject创建RenderObject，并使用attachRenderObject将RenderObject关联到Element上。


2. SingleChildRenderObjectElement会调用updateChild更新子节点，MultiChildRenderObjectElement会调用每个子节点的inflateWidget重建所有子Widget。

• performRebuild

@override

void performRebuild() {

//更新renderObject

  widget.updateRenderObject(this, renderObject);

  _dirty = false;

}

复制代码

performRebuild的主要职责如下：

调用updateRenderObject更新对应的RenderObject。

• update

@override

void update(covariant RenderObjectWidget newWidget) {

  super.update(newWidget);

  widget.updateRenderObject(this, renderObject);

  _dirty = false;

}

复制代码

update的主要职责如下：

1. 将对应的Widget更新为新的Widget。


2. 调用updateRenderObject更新对应的RenderObject。

• updateChild

@protected

List updateChildren(List oldChildren, List newWidgets, { Set forgottenChildren }) {

  int newChildrenTop = 0;

  int oldChildrenTop = 0;

  int newChildrenBottom = newWidgets.length - 1;

  int oldChildrenBottom = oldChildren.length - 1;



  final List newChildren = oldChildren.length == newWidgets.length ?

      oldChildren : List(newWidgets.length);



  Element previousChild;



// 从顶部向下更新子Element

  // Update the top of the list.

  while ((oldChildrenTop <= oldChildrenBottom) && (newChildrenTop <= newChildrenBottom)) {

    final Element oldChild = replaceWithNullIfForgotten(oldChildren[oldChildrenTop]);

    final Widget newWidget = newWidgets[newChildrenTop];

    if (oldChild == null || !Widget.canUpdate(oldChild.widget, newWidget))

      break;

    final Element newChild = updateChild(oldChild, newWidget, IndexedSlot(newChildrenTop, previousChild));

    newChildren[newChildrenTop] = newChild;

    previousChild = newChild;

    newChildrenTop += 1;

    oldChildrenTop += 1;

  }



// 从底部向上扫描子Element

  // Scan the bottom of the list.

  while ((oldChildrenTop <= oldChildrenBottom) && (newChildrenTop <= newChildrenBottom)) {

    final Element oldChild = replaceWithNullIfForgotten(oldChildren[oldChildrenBottom]);

    final Widget newWidget = newWidgets[newChildrenBottom];

    if (oldChild == null || !Widget.canUpdate(oldChild.widget, newWidget))

      break;

    oldChildrenBottom -= 1;

    newChildrenBottom -= 1;

  }



// 扫描旧的子Element列表里面中间的子Element，保存Widget有Key的Element到oldKeyChildren，其他的失效

  // Scan the old children in the middle of the list.

  final bool haveOldChildren = oldChildrenTop <= oldChildrenBottom;

  Map oldKeyedChildren;

  if (haveOldChildren) {

    oldKeyedChildren = {};

    while (oldChildrenTop <= oldChildrenBottom) {

      final Element oldChild = replaceWithNullIfForgotten(oldChildren[oldChildrenTop]);

      if (oldChild != null) {

        if (oldChild.widget.key != null)

          oldKeyedChildren[oldChild.widget.key] = oldChild;

        else

          deactivateChild(oldChild);

      }

      oldChildrenTop += 1;

    }

  }



// 根据Widget的Key更新oldKeyChildren中的Element。

  // Update the middle of the list.

  while (newChildrenTop <= newChildrenBottom) {

    Element oldChild;

    final Widget newWidget = newWidgets[newChildrenTop];

    if (haveOldChildren) {

      final Key key = newWidget.key;

      if (key != null) {

        oldChild = oldKeyedChildren[key];

        if (oldChild != null) {

          if (Widget.canUpdate(oldChild.widget, newWidget)) {

            // we found a match!

            // remove it from oldKeyedChildren so we don't unsync it later

            oldKeyedChildren.remove(key);

          } else {

            // Not a match, let's pretend we didn't see it for now.

            oldChild = null;

          }

        }

      }

    }



    final Element newChild = updateChild(oldChild, newWidget, IndexedSlot(newChildrenTop, previousChild));

    newChildren[newChildrenTop] = newChild;

    previousChild = newChild;

    newChildrenTop += 1;

  }



  newChildrenBottom = newWidgets.length - 1;

  oldChildrenBottom = oldChildren.length - 1;



  // 从下到上更新底部的Element。.

  while ((oldChildrenTop <= oldChildrenBottom) && (newChildrenTop <= newChildrenBottom)) {

    final Element oldChild = oldChildren[oldChildrenTop];

    final Widget newWidget = newWidgets[newChildrenTop];

    final Element newChild = updateChild(oldChild, newWidget, IndexedSlot(newChildrenTop, previousChild));

    newChildren[newChildrenTop] = newChild;

    previousChild = newChild;

    newChildrenTop += 1;

    oldChildrenTop += 1;

  }



// 清除旧子Element列表中其他所有剩余Element

  // Clean up any of the remaining middle nodes from the old list.

  if (haveOldChildren && oldKeyedChildren.isNotEmpty) {

    for (final Element oldChild in oldKeyedChildren.values) {

      if (forgottenChildren == null || !forgottenChildren.contains(oldChild))

        deactivateChild(oldChild);

    }

  }



  return newChildren;

}

复制代码

该函数的主要职责如下：

1. 复用能复用的子节点，并调用updateChild对子节点进行更新。


2. 对不能更新的子节点，调用deactivateChild对该子节点进行失效。

其步骤如下：

1. 从顶部向下更新子Element。


2. 从底部向上扫描子Element。


3. 扫描旧的子Element列表里面中间的子Element，保存Widget有Key的Element到oldKeyChildren，其他的失效。


4. 对于新的子Element列表，如果其对应的Widget的Key和oldKeyChildren中的Key相同，更新oldKeyChildren中的Element。


5. 从下到上更新底部的Element。


6. 清除旧子Element列表中其他所有剩余Element。

文章参考于：zhuanlan.zhihu.com/p/369286610

前言

StatelessWidget 和 StatefulWidget 只是用来组装控件的容器，并不负责组件最后的布局和绘制。在 Flutter 中，布局和绘制工作实际上是在 Widget 的另一个子类 RenderObjectWidget 内完成的。
RenderObjectWidget为RenderObjectElement提供配置信息。
RenderObjectElement包装了RenderObject，RenderObject为应用程序提供真正的渲染。

源码

abstract class RenderObjectWidget extends Widget {

 

  const RenderObjectWidget({ Key? key }) : super(key: key);



  @override

  @factory

  RenderObjectElement createElement();



  @protected

  @factory

  RenderObject createRenderObject(BuildContext context);



  @protected

  void updateRenderObject(BuildContext context, covariant RenderObject renderObject) { }



  @protected

  void didUnmountRenderObject(covariant RenderObject renderObject) { }

}

• createElement 需要返回一个继承RenderObjectElement的类


• createRenderObject 创建 Render Widget 对应的 Render Object，同样子类需要重写该方法。该方法在对应的 Element 被挂载到树上时调用(Element.mount)，即在 Element 挂载过程中同步构建了「Render Tree」


• updateRenderObject 在 Widget 更新后，修改对应的 Render Object。该方法在首次 build 以及需要更新 Widget 时都会调用；


• didUnmountRenderObject 「Render Object」从「Render Tree」上移除时调用该方法。

RenderObjectElement 源码

abstract class RenderObjectElement extends Element {

  RenderObject _renderObject;

 

  @override

  void mount(Element parent, dynamic newSlot) {

    super.mount(parent, newSlot);

    _renderObject = widget.createRenderObject(this);

    attachRenderObject(newSlot);

    _dirty = false;

  }

   

  @override

  void update(covariant RenderObjectWidget newWidget) {

    super.update(newWidget);

    widget.updateRenderObject(this, renderObject);

    _dirty = false;

  }

  ...

}

• mount： RenderObject 对象的创建，以及与渲染树的插入工作，插入到渲染树后的 Element 就可以显示到屏幕中了。


• update： 如果 Widget 的配置数据发生了改变，那么持有该 Widget 的 Element 节点也会被标记为 dirty。在下一个周期的绘制时，Flutter 就会触发 Element 树的更新，并使用最新的 Widget 数据更新自身以及关联的 RenderObject 对象，接下来便会进入 Layout 和 Paint 的流程。而真正的绘制和布局过程，则完全交由 RenderObject 完成。

RenderObject 主要处理一些固定的操作，如：布局、绘制和 Hit testing。 与ComponentElement一样RenderObjectElement也是抽象类，不同的是ComponentElement不会直接创建RenderObject,而是间接通过创建其他Element创建RenderObject。

RenderObjectElement主要有三个系统的子类，分别处理renderObject作为child时的不同情况。

1. LeafRenderObjectElement：叶子渲染对象对应的元素，处理没有children的renderObject。


2. SingleChildRenderObjectElement：处理只有单个child的renderObject。


3. MultiChildRenderObjectElement： 处理有多个children的渲染对象

有时RenderObject的child模型更复杂一些，比如多维数组的形式，则可能需要基于RenderObjectElement实现一个新的子类。

RenderObjectElement 充当widget与renderObject之间的中介者。需要进行方法覆盖，以便它们返回元素期望的特定类型，例如：

class FooElement extends RenderObjectElement {                                       

                                                                                    

 @override                                                                          

 Foo get widget => super.widget; 

                                                   

@override                                                                          

RenderFoo get renderObject => super.renderObject;                                  

                                                                          

}               

widget返回Foo，renderObject 返回RenderFoo

系统常用组件与RenderObjectElement：

RenderObject源码

abstract class RenderObject extends AbstractNode with DiagnosticableTreeMixin implements HitTestTarget {

  ...

  void layout(Constraints constraints, { bool parentUsesSize = false }) {...}

  

  void paint(PaintingContext context, Offset offset) { }

}

布局和绘制完成后，接下来的事情就交给 Skia 了。在 VSync 信号同步时直接从渲染树合成 Bitmap，然后提交给 GPU。

文章参考：http://www.jianshu.com/p/c3de443a7…

前言

ProxyWidget作为抽象基类本身没有任何功能，但他有两个实现类ParentDataWidget & InheritedElement

源码

abstract class ProxyWidget extends Widget {

  

  const ProxyWidget({ Key? key, required this.child }) : super(key: key);

  

  final Widget child;

}

InheritedWidget

InheritedWidget 用于在树上向下传递数据。

通过BuildContext.dependOnInheritedWidgetOfExactType可以获取最近的「Inherited Widget」，需要注意的是通过这种方式获取「Inherited Widget」时，当「Inherited Widget」状态有变化时，会导致该引用方 rebuild。

通常，为了使用方便会「Inherited Widget」会提供静态方法of，在该方法中调用BuildContext.dependOnInheritedWidgetOfExactType。of方法可以直接返回「Inherited Widget」，也可以是具体的数据。

有时，「Inherited Widget」是作为另一个类的实现细节而存在的，其本身是私有的(外部不可见)，此时of方法就会放到对外公开的类上。最典型的例子就是Theme，其本身是StatelessWidget类型，但其内部创建了一个「Inherited Widget」：_InheritedTheme，of方法就定义在上Theme上：

  static ThemeData of(BuildContext context) {

    final _InheritedTheme? inheritedTheme = context.dependOnInheritedWidgetOfExactType<_InheritedTheme>();

    final MaterialLocalizations? localizations = Localizations.of(context, MaterialLocalizations);

    final ScriptCategory category = localizations?.scriptCategory ?? ScriptCategory.englishLike;

    final ThemeData theme = inheritedTheme?.theme.data ?? _kFallbackTheme;

    return ThemeData.localize(theme, theme.typography.geometryThemeFor(category));

  }

该of方法返回的是ThemeData类型的具体数据，并在其内部首先调用了BuildContext.dependOnInheritedWidgetOfExactType。

我们经常使用的「Inherited Widget」莫过于MediaQuery，同样提供了of方法：

  static MediaQueryData of(BuildContext context) {

    assert(context != null);

    assert(debugCheckHasMediaQuery(context));

    return context.dependOnInheritedWidgetOfExactType()!.data;

  }

源码

abstract class InheritedWidget extends ProxyWidget {



  const InheritedWidget({ Key? key, required Widget child })

    : super(key: key, child: child);



  @override

  InheritedElement createElement() => InheritedElement(this);



  @protected

  bool updateShouldNotify(covariant InheritedWidget oldWidget);

}

createElement

「Inherited Widget」对应的 Element 为InheritedElement，一般情况下InheritedElement子类不用重写该方法；

updateShouldNotify

「Inherited Widget」rebuilt 时判断是否需要 rebuilt 那些依赖它的 Widget；

如下是MediaQuery.updateShouldNotify的实现，在新老Widget.data 不相等时才 rebuilt 那依赖的 Widget。

  @override

  bool updateShouldNotify(MediaQuery oldWidget) => data != oldWidget.data;

依赖了 InheritedWidget 在数据变动的情况下 didChangeDependencies 会被调用，
依赖的意思是 使用 return context.dependOnInheritedWidgetOfExactType()
如果使用context.getElementForInheritedWidgetOfExactType().widget的话，只会用其中的数据，而不会重新rebuild

@override

InheritedElement getElementForInheritedWidgetOfExactType() {

  final InheritedElement ancestor = _inheritedWidgets == null ? null : _inheritedWidgets[T];

  return ancestor;

}

@override

InheritedWidget dependOnInheritedWidgetOfExactType({ Object aspect }) {

  assert(_debugCheckStateIsActiveForAncestorLookup());

  final InheritedElement ancestor = _inheritedWidgets == null ? null : _inheritedWidgets[T];

  //多出的部分

  if (ancestor != null) {

    return dependOnInheritedElement(ancestor, aspect: aspect) as T;

  }

  _hadUnsatisfiedDependencies = true;

  return null;

}

我们可以看到，dependOnInheritedWidgetOfExactType() 比 getElementForInheritedWidgetOfExactType()多调了dependOnInheritedElement方法，dependOnInheritedElement源码如下：

  @override

  InheritedWidget dependOnInheritedElement(InheritedElement ancestor, { Object aspect }) {

    assert(ancestor != null);

    _dependencies ??= HashSet();

    _dependencies.add(ancestor);

    ancestor.updateDependencies(this, aspect);

    return ancestor.widget;

  }

可以看到dependOnInheritedElement方法中主要是注册了依赖关系！看到这里也就清晰了，调用dependOnInheritedWidgetOfExactType() 和 getElementForInheritedWidgetOfExactType()的区别就是前者会注册依赖关系，而后者不会，所以在调用dependOnInheritedWidgetOfExactType()时，InheritedWidget和依赖它的子孙组件关系便完成了注册，之后当InheritedWidget发生变化时，就会更新依赖它的子孙组件，也就是会调这些子孙组件的didChangeDependencies()方法和build()方法。而当调用的是 getElementForInheritedWidgetOfExactType()时，由于没有注册依赖关系，所以之后当InheritedWidget发生变化时，就不会更新相应的子孙Widget。

文章内容参考：http://www.jb51.net/article/221…

「Offer 驾到，掘友接招！我正在参与2022春招系列活动-经验复盘，点击查看 活动详情 即算参赛

你的支持对我意义重大！

🔥 Hi，我是旭锐。本文已收录到 GitHub · Android-NoteBook 中。这里有 Android 进阶成长路线笔记 & 博客，有志同道合的朋友，欢迎跟着我一起成长。（联系方式 & 入群方式在 GitHub）

前言

• 在 Android 面试中很重视基础知识的考察，其中语言基础主要包括 Java、Kotlin、C/C++ 三种编程语言。在小彭面试的经验中，发现很多同学的 Kotlin 语言能力只是停留在一些非常入门的语法使用上；


• 在这篇文章里，我将为你浓缩总结 Kotlin 中最常用的知识点和原理。希望通过这篇文章能够帮助你扫除支持盲区，对于一些语法背后的原理也有所涉猎。

1. 为什么要使用 Kotlin？

面试官问这个问题一方面可能是先想引入 Kotlin 这个话题，另一方面是想考察你的认知能力，是不是真的有思考过 Kotlin 的优势 / 价值，还是随波逐流别人用我也跟着用。你可以这么回答：

在 Android 生态中主要有 C++、Java、Kotlin 三种语言 ，它们的关系不是替换而是互补。其中，C++ 的语境是算法和高性能，Java 的语境是平台无关和内存管理，而 Kotlin 则融合了多种语言中的优秀特性，带来了一种更现代化的编程方式。 例如简化异步编程的协程（coroutines），提高代码质量的可空性（nullability），lambda 表达式等。

2. 语法糖的味道

• 
  

  == 和 equal() 相同，=== 比较内存地址

  
  


• 
  

  顶级成员（函数 & 属性）的原理： Kotlin 顶级成员的本质是 Java 静态成员，编译后会自动生成文件名Kt的类，可以使用@Jvm:fileName注解修改自动生成的类名。

  
  


• 
  

  默认参数的原理： Kotlin 默认参数的本质是将默认值 固化 到调用位置，所以在 Java 中无法直接调用带默认参数的函数，需要在 Kotlin 函数上增加@JvmOverloads注解，指示编译器生成重载方法（@JvmOverloads会为默认参数提供重载方法）。

  
  


• 
  

  解构声明的原理： Kotlin 解构声明可以把一个对象的属性分解为一组变量，所以解构声明的本质是局部变量。

  
  

  举例：
  
  val (name, price) = Book("Kotlin入门", 66.6f)
  
  println(name)
  
  println(price)
  
  -------------------------------------------
  
  Kotlin 类需要声明`operator fun componentN()`方法来实现解构功能，否则是不具备解构声明的功能的，例如：
  
  class Book(var name: String, var price: Float) {
  
      operator fun component1(): String { // 解构的第一个变量
  
          return name
  
      }
  
  
  
      operator fun component2(): Float { // 解构的第二个变量
  
          return price
  
      }
  
  }
  

  
  


• 
  

  Sequences 序列的原理： Sequences 提升性能的关键在于多个操作共享同一个 Iterator 迭代器，只需要一次循环就可以完成数据操作。Sequences 又是懒惰的，需要遇到终端操作才会开始工作。

  
  


• 
  

  扩展函数的原理： 扩展函数的语义是在不修改类 / 不继承类的情况下，向一个类添加新函数或者新属性。本质是静态函数，静态函数的第一个参数是接收者类型，调用扩展时不会创建适配对象或者任何运行时的额外消耗。在 Java 中，我们只需要像调用普通静态方法那样调用扩展即可。相关资料：Kotlin | 扩展函数（终于知道为什么 with 用 this，let 用 it）

  
  


• 
  

  let、apply、with 的区别和应用场景： let、with、apply 都是标准库函数，它们的主要区别在 lambda 参数类型定义不同。apply、with 的 lambda 参数是 T 的扩展函数，因此在 lambda 内使用 this 引用接收者对象，而 let 的 lambda 参数是参数为 T 的高阶函数，因此 lambda 内使用 it 引用唯一参数。

  
  


• 
  

  委托机制的原理： Kotlin 委托的语法关键字是 by，其本质上是面向编译器的语法糖，三种委托（类委托、对象委托和局部变量委托）在编译时都会转化为 “无糖语法”。例如类委托：编译器会实现基础接口的所有方法，并直接委托给基础对象来处理。例如对象委托和局部变量委托：在编译时会生成辅助属性（prop$degelate），而属性 / 变量的 getter() 和 setter() 方法只是简单地委托给辅助属性的 getValue() 和 setValue() 处理。相关资料：Kotlin | 委托机制 & 原理 & 应用

  
  


• 
  

  中缀函数： 声明 infix 关键字的函数是中缀函数，调用中缀函数时可以省略圆点以及圆括号等程序符号，让语句更自然。

  
  

  中缀函数的要求：
  
  - 1、成员函数或扩展函数
  
  - 2、函数只有一个参数
  
  - 3、不能使用可变参数或默认参数
  
  
  
  举例：
  
  infix fun String.吃(fruit: String): String {
  
      return "${this}吃${fruit}"
  
  }
  
  调用： "小明" 吃 "苹果"
  

  
  

3. 类型系统

• 
  

  数值类型： Kotlin 将基本数据类型和引用型统一为：Byte、Short、Int、Long、Float、Double、Char 和 Boolean。需要注意的是，类型的统一并不意味着 Kotlin 所有的数值类型都是引用类型，大多数情况下，它们在编译后会变成基本数据类型，类型参数会被编译为引用类型。

  
  


• 
  

  隐式转换： Kotlin 不存在隐式类型转换，即时是低级类型也需要显式转换为高级类型：

  
  

  //隐式转换，编译器会报错
  
  val anInt: Int = 5
  
  val ccLong: Long = anInt 
  
  
  
  //需要去显式的转换,下面这个才是正确的 
  
  val ddLong: Long = anInt.toLong()
  

  
  


• 
  

  平台类型： 当可空性注解不存在时，Java 类型会被转换为 Kotlin 的平台类型。平台类型本质上是 Kotlin 编译器无法确定其可空信息，既可以把它当作可空类型，也可以把它当作非空类型。

  
  

  
  

  如果所有来自 Java 的值都被看成非空是不合理的，反之把 Java 值都当作可空的，由会引出大量 Null 检查。综合考量，平台类型是 Kotlin 为开发者选择的折中的设计方案。

  
  

  
  


• 
  

  类型转换： 较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。

  
  

  val b: Byte = 1 // OK
  
  val i: Int = b // 编译错误
  
  val i: Int = b.toInt() // OK
  

  
  


• 
  

  只读集合和可变集合： 只读集合只可读，而可变集合可以增删该差（例如 List 只读，MutableList 可变）。需要注意，只读集合引用指向的集合不一定是不可变的，因为你使用的变量可能是众多指向同一个集合的其中一个。

  
  


• 
  

  Array 和 IntArray 的区别： Array 相当于引用类型数组 Integer[]，IntArray 相当于数值类型数组 int[]。

  
  


• 
  

  Unit： Any 的子类，作为函数返回值时表示没有返回值，可以省略，与 Java void 类似。

  
  


• 
  

  Nothing： 表示表达式或者函数永远不会返回，Nothing? 唯一允许的值是 null。

  
  


• 
  

  Java Void： void 的包装类，与 void 类似表示一个函数没有有效的返回值，返回值只能是 null。

  
  

4. 面向对象

• 
  

  类修饰符： Kotlin 类 / 方法默认是 final 的，如果想让继承类 / 重写方法，需要在基类 / 基方法添加 open 修饰符。

  
  

  final：不允许继承或重写
  
  open：允许继承或重写
  
  abstract：抽象类 / 抽象方法
  

  
  


• 
  

  访问修饰符： Java 默认的访问修饰符是 protected，Kotlin 默认的访问修饰符是 public。

  
  

  public：所有地方可见
  
  internal：模块中可见，一个模块就是一组编译的 Kotlin 文件
  
  protected：子类中可见（与 Java 不同，相同包不可见，Kotlin 没有 default 包可见）
  
  private：类中可见
  

  
  


• 
  

  构造函数：

  
  
  
  
  • 默认构造函数： class 默认有一个无参主构造函数，如果显式声明了构造函数，则默认的无参主构造函数失效；
  
  
  • 主构造函数： 声明在 class 关键字后，其中 constructor 关键词可以省略；
  
  
  • 次级构造函数： 如果声明了次级构造函数，则默认的无参主构造函数会失效。如果存在主构造函数，次级构造函数需要直接或间接委托给主构造函数。
  
  
  
  


• 
  

  init 函数执行顺序： 主构造函数 > init > 次级构造函数

  
  


• 
  

  内部类： Kotlin 默认为静态内部类，如果想访问类中的成员方法和属性，需要添加 inner 关键字称为非静态内部类；Java 默认为非静态内部类。

  
  


• 
  

  data 关键字原理： data 关键字用于定义数据类型，编译器会自动从主构造函数中提取属性并生成一系列函数：equals()/hashCode()、toString()、componentN()、copy()。

  
  


• 
  

  sealed 关键字原理： 密封类用来表示受限的类继承结构，密封类可以有子类，但是所有子类都必须内嵌在该密封类中。

  
  


• 
  

  object 与 companion object 的区别 object 有两层语义：静态匿名内部类 + 单例对象 companion object 是伴生对象，一个类只能有一个，代表了类的静态成员（函数 / 属性）

  
  


• 
  

  单例： Kotlin 可以使用 Java 相似的方法实现单例，也可以采用 Kotlin 特有的语法。相关资料：Kotlin下的5种单例模式

  
  
  
  
  • object
  
  
  
  

  // Kotlin实现
  
  object SingletonDemo
  

  
  
  
  
  • by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED)
  
  
  
  

  class SingletonDemo private constructor() {
  
      companion object {
  
          val instance: SingletonDemo by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
  
  		        SingletonDemo() 
  
  				}
  
      }
  
  }
  

  
  


• 
  

  泛型： 关于泛型能问的都在这里了（含Kotlin）

  
  

5. lambda 表达式

• 
  

  lambda 表达式本质上是「可以作为值传递的代码块」。在老版本 Java 中，传递代码块需要使用匿名内部类实现，而使用 lambda 表达式甚至连函数声明都不需要，可以直接传递代码块作为函数值。

  
  


• 
  

  it： 当 lambda 表达式只有一个参数，可以用 it 关键字来引用唯一的实参。

  
  


• 
  

  lambda 表达式的种类

  
  
  
  
  • 1、普通 Lambda 表达式：例如 ()->R
  
  
  • 2、带接收者对象的 Lambda 表达式：例如 T.()->R
  
  
  
  


• 
  

  lambda 表达式访问局部变量的原理： 在 Java 中，匿名内部类访问的局部变量必须是 final 修饰的，否则需要使用数组或对象做一层包装。在 Kotlin 中，lambda 表达式可以直接访问非 final 的局部变量，其原理是提供了一层包装类，修改局部变量本质上是修改包装类中的属性。

  
  

  class Ref<T>(var value:T)
  
  复制代码

  
  


• 
  

  lambda 表达式编译优化： 在循环中使用 Java 8 与 Kotlin 中的 lambda 表达式时，会存在编译时优化，编译器会将 lambda 优化为一个 static 变量，除非 lambda 表达式中访问了外部的变量或函数。

  
  


• 
  

  inline 内联函数的原理：

  
  
  
  
  • 
    

    内联 lambda 表达式参数（主要优点）： 内联函数的参数如果是 lambda 表达式，则该参数默认也是 inline 的。lambda 表达式也会被固化的函数调用位置，从而减少了为 lambda 表达式创建匿名内部类对象的开销。当 lambda 表达式被经常调用时，可以减少内存开销。

    
    
  
  
  • 
    

    减少入栈出栈过程（次要优点）： 内联函数的函数体被固化到函数调用位置，执行过程中减少了栈帧创建、入栈和出栈过程。需要注意：如果函数体太大就不适合使用内联函数了，因为会大幅度增加字节码大小。

    
    
  
  
  • 
    

    @PublishApi 注解： 编译器要求内联函数必须是 public 类型，使用 @PublishApi 注解可以实现 internal 等访问修饰的同时又实现内联

    
    
  
  
  • 
    

    noinline 非内联： 如果在内联函数内部，lambda 表达式参数被其它非内联函数调用，会报编译时错误。这是因为 lambda 表达式已经被拉平而无法传递给其他非内联函数。可以给参数加上 noinline 关键字表示禁止内联。

    
    

    inline fun test(noinline inlined: () -> Unit) {
    
        otherNoinlineMethod(inlined)
    
    }
    
    复制代码

    
    
  
  
  • 
    

    非局部返回（Non-local returns）： 一个不带标签的 return 语句只能用在 fun 声明的函数中使用，因此在 lambda 表达式中的 return 必须带标签，指明需要 return 的是哪一级的函数：

    
    

    fun song(f: (String) -> Unit) {
    
        // do something
    
    }
    
    
    
    fun behavior() {
    
        song {
    
            println("song $it")
    
            return //报错: 'return' is not allowed here
    
            return@song // 局部返回
    
            return@behavior // 非局部返回
    
        }
    
    }
    

    
    

    唯一的例外是在内联函数中的 lambda 表达式参数，可以直接使用不带标签的 return，返回的是调用内联函数的外部函数，而不是内联函数本身，默认就是非局部返回。

    
    

    inline fun song(f: (String) -> Unit) {
    
        // do something
    
    }
    
    
    
    fun behavior() {
    
        song {
    
            println("song $it")
    
            return // 非局部返回
    
            return@song // 局部返回
    
            return@behavior // 非局部返回
    
        }
    
    }
    

    
    
  
  
  • 
    

    crossinline 非局部返回： 禁止内联函数的 lambda 表达式参数使用非局部返回

    
    
  
  
  • 
    

    实化类型参数 reified： 因为泛型擦除的影响，运行期间不清楚类型实参的类型，Kotlin 中使用 带实化类型参数的内联函数 可以突破这种限制。实化类型参数在插入到调用位置时会使用类型实参的确切类型代替，因此可以确定实参类型。

    
    

    在这个函数里，我们传入一个List，企图从中过滤出 T 类型的元素：
    
    
    
    Java：
    
    <T> List<T> filter(List list) {
    
        List<T> result = new ArrayList<>();
    
        for (Object e : list) {
    
            if (e instanceof T) { // compiler error
    
                result.add(e);
    
            }
    
        }
    
        return result;
    
    }
    
    ---------------------------------------------------
    
    Kotlin：
    
    fun <T> filter(list: List<*>): List<T> {
    
        val result = ArrayList<T>()
    
        for (e in list) {
    
            if (e is T) { // cannot check for instance of erased type: T
    
                result.add(e)
    
            }
    
        }
    
        return result
    
    }
    
    
    
    调用：
    
    val list = listOf("", 1, false)
    
    val strList = filter<String>(list)
    
    ---------------------------------------------------
    
    内联后：
    
    val result = ArrayList<String>()
    
    for (e in list) {
    
        if (e is String) {
    
            result.add(e)
    
        }
    
    }
    

    
    
  
  
  
  

5. DSL 领域特定语言

DSL 是专门用于解决某个问题的语言，虽然没有通用语言那么全面，但在解决特定问题时更加高效。案例：Compose 的 UI 代码也是采用了 DSL，使得 Compose 拥有了不输于 XML 的编码效率。实现 DSL 需要可以利用的 Kotlin 语法特性，相关资料：Kotlin DSL 实战：像 Compose 一样写代码

• 
  

  高阶函数： 使得 lambda 参数脱离圆括号，减少一个参数；

  
  


• 
  

  扩展函数： 传递 Receiver，减少一个参数；

  
  


• 
  

  Context Receivers： 传递多个 Receiver，在扩展函数的基础上减少多个参数；

  
  


• 
  

  中缀函数： 让语法更简洁自然；

  
  


• 
  

  @DSLMarker： 用于限制 lambda 中不带标签的 this 只能访问到最近的 Receiver 类型，当调用更外层的 Receiver 时必须显式指定 this@XXX。

  
  

  context(View)
  
  val Float.dp 
  
      get() = this * this@View.resources.displayMetrics.density
  
  
  
  class SomeView : View {
  
    val someDimension = 4f.dp
  
  }
  

  
  

6. 总结

少部分比较聪明的小伙伴就会问了，你这怎么没有涉及协程、Flow 这些知识点？那是因为这些知识点比较多，小彭决定单独放在一篇文章里。一篇文章拆成两篇用，它不香吗？

一、前言

在原生应用开发中，我们通常会使用YYModel、SwiftyJSON、GSON等库实现JSON解析，并使用JSONConverter等类似工具实现JSON自动转模型，极大的提高工作效率。
但在Flutter开发中，却并没有类似的解析库给我们使用，因为这样的库需要使用运行时反射，这在 Flutter 中是禁用的。运行时反射会干扰 Dart 的 tree shaking，使用_tree shaking_，可以在 release 版中“去除”未使用的代码，这可以显著优化应用程序的大小。由于反射会默认应用到所有代码，因此_tree shaking_ 会很难工作，因为在启用反射时很难知道哪些代码未被使用，因此冗余代码很难剥离，所以 Flutter 中禁用了 Dart 的反射功能，而正因如此也就无法实现动态转化 Model 的功能。

二、json_serializable

虽然不能在Flutter中使用运行时反射，但官方提供了类似易于使用的API，它是基于代码生成库实现，json_serializable package，它是一个自动化的源代码生成器，可以生成JSON序列化模板，由于序列化代码无需手写和维护，将运行时产生JSON序列化异常的风险降至最低，使用方法如下：

1. 在项目中添加json_serializable

要包含json_serializable到我们的项目中，需要一个常规和两个开发依赖项。简而言之，开发依赖项是不包含在我们的应用程序源代码中的依赖项。
通过此链接可以查看这些所需依赖项的最新版本 。

在您的项目根文件夹中运行 flutter packages get (或者在编辑器中点击 “Packages Get”) 以在项目中使用这些新的依赖项.

2. 以json_serializable的方式创建model类

让我们看看如何将我们的User类转换为一个json_serializable。为了简单起见，我们使用前面示例中的简化JSON model。

user.dart

import 'package:json_annotation/json_annotation.dart';



// user.g.dart 将在我们运行生成命令后自动生成

part 'user.g.dart';



///这个标注是告诉生成器，这个类是需要生成Model类的

@JsonSerializable()

class User {

  String name;

  String email;



  User(this.name, this.email);



  factory User.fromJson(Map json) => _$UserFromJson(json);

  Map toJson() => _$UserToJson(this);

}

有了这个设置，源码生成器将生成用于序列化name和email字段的JSON代码。

如果需要，自定义命名策略也很容易。例如，如果我们正在使用的API返回带有_snake_case_的对象，但我们想在我们的模型中使用_lowerCamelCase_， 那么我们可以使用@JsonKey标注：

@JsonKey(name: 'registration_date_millis')

final int registrationDateMillis;

3. 运行代码生成程序

• 一次性生成

通过在我们的项目根目录下运行flutter packages pub run build_runner build，我们可以在需要时为我们的Model生成JSON序列化代码。 这触发了一次性构建，它通过我们的源文件，挑选相关的并为它们生成必要的序列化代码。

• 持续生成

虽然这非常方便，但如果我们不需要每次在model类中进行更改时都要手动运行构建命令的话会更好。
使用_watcher_可以使我们的源代码生成的过程更加方便。它会监视我们项目中文件的变化，并在需要时自动构建必要的文件。我们可以通过flutter packages pub run build_runner watch在项目根目录下运行来启动_watcher_。
只需启动一次观察器，然后并让它在后台运行，这是安全的

4. 使用json_serializable模型

要通过json_serializable方式反序列化JSON字符串，我们不需要对先前的代码进行任何更改。

Map userMap = JSON.decode(json);

var user = new User.fromJson(userMap);

序列化也一样。调用API与之前相同。

String json = JSON.encode(user);

有了json_serializable，我们只需要编写User类文件 。源代码生成器创建一个名为user.g.dart的文件，它具有所有必需的序列化逻辑。 现在，我们不必编写自动化测试来确保序列化的正常工作 - 这个库会确保序列化工作正常。

三、 JSONConverter

如上面所写，即便使用了json_serializable，仍然需要手动编写模型类文件并逐一编写对应的模型属性，生产工作中一个项目可能会有几百个API, 如果全部手写依旧浪费大量摸鱼的时间，这里我们可以使用JSONConverter, 它可根据后台返回的JSON自动生成模型文件，配合json_serializable，可以非常方便的实现接口对接，模型文件一键生成，极大节省程序员的体力。

另外JSONConverter除了支持Flutter，还支持其他语言和第三方库，功能可能说非常丰富了。

四、总结

生产项目中推荐使用json_serializable + JSONConverter 完成服务端返回的JSON数据解析工作，效率翻倍！！

一、 入坑

一直以来有一个口口相传的秘诀，就是Flutter版本等到*.*.3版本再升级。

大版本升级一定要慎重的。不然不知道哪个界面中就会出现未知的异常。

Flutter3.0发布了，但是选择不升级，忍了一个星期后，突然发现Flutter开始支持APPLE Silicon M1了。心动了，控制不住自己了，升吧。

然后出现了，我的小怪兽。

上拉和下拉进行刷新界面的时候，出现了诡异的现象。

二、现象

第一反应是Flutter3.0的锅，而已经无法回退版本了，只能选择一往无前。

用一休的大脑：

• 第三方库不兼容了，赶紧升级下版本。


• RefreshIndicator有新改动吗。


• ListView有改动吗？


• Column配合Expanded界面混乱了。


• ListView的Item用错了。


• Debug模式也有这个问题吗。

。。。。。。
前前后后修改，编译，运行，修改，编译，运行。。。（还好我的M1 Max效率还是比较高的）

三、分析

询问度娘，google，gitHub。。。查看所有可能的答案。如果真的是ListView有问题，那应该早就有人碰到了。怎么说3.0出来已经一个星期了。
Nope Nope Nope
行吧。请教同事，拉来所有同事问问，出谋划策。
No Way
排查了所有组件的可能性，把所有代码都删干净了，仅仅就一个ListView了，还是存在一样的问题。
那这个锅就是你了ListView了，出来的怪兽。不要躲了。

四、解决

为了确定是Flutter 3.0的锅，然后甩给Flutter，搞一个Demo吧。风风火火。。。

Demo竟然没有没有没有问题。Flutter表示这个锅它不背啊。

啊啊啊啊 流失了一天宝贵时光，此处省去1万字...

终于在比较了所有代码后，发现了它，那个引起问题的代码。

五、原因

是的。

<item name="android:fitsSystemWindows">true</item>

就是它，删除后，出现了，出现了。

那么舒服的感觉，我很喜欢。

六、后记

一定要记得*.*.3版本再升级，不能TiMi时间浪费在编译上了。

前言

在原生Android开发的时候，我们经常会用到ARouter，来设计我们项目的整体架构。因为ARouter会帮助我们实现模块化的思想，那么在Flutter中如何去构建模块化的架构呢？再深入一点，如何去运行一个单一模块，不去跑整体项目呢？本篇文章将会带你学习Flutter版本下的单工程架构模式。

应用场景

两模块业务有较大的隔离性，业务有迁移不同项目的可能性

开始

展示效果

那我们在开始前，看下我项目的展示效果：

整体项目运行

单工程模式下运行

架构分析

本项目有三个独立工程

1. 家长端工程


2. 教师端工程


3. 公用lib工程

一个应用飞阅应用中包含三个独立工程，三个独立工程可单独通过壳来运行

如何构建单工程架构

Flutter具有天然的模块化思想，是可以不借助其他工具来实现单工程构建。

事前准备

1. Android stuido

步骤1

构建一个Flutter plugin

这个plugin就是你的单工程，构建好的插件如图所示

你需要构建几个plugin呢？简单分析一下，我们公司有两个业务端，需要合并在一个项目里做，那么至少需要两个plugin，但是由于有公用的页面，这时候需要提取出一个公用的模块。那么由此分析，我公司需要三个plugin，那么就需要按照如上步骤在建立两个plugin

步骤二

建立好的plugin进行关联

• 公用工程yaml

name: commonlib

description: 阅卷公用lib

dependencies:

  flutter:

    sdk: flutter

  flutter_localizations:

    sdk: flutter

  #####本地库

  flutter_base_lib:

    path: ../flutter_baselib/flutter_base_lib

  #####本UI地库

  flutter_base_ui:

    path: ../flutter_baselib/flutter_base_ui

• 老师工程yaml

name: teacher

description: 老师端

dependencies:

  flutter:

    sdk: flutter

  commonlib:

    path: ../commonlib

• 家长工程yaml

name: client

description: 学生&家长工程

dependencies:

  flutter:

    sdk: flutter

  commonlib:

    path: ../commonlib

• 总工程yaml

dependencies:

  flutter:

    sdk: flutter

  flutter_localizations:

    sdk: flutter

  teacher:

    path: ./teacher

  client:

    path: ./client

  commonlib:

    path: ./commonlib

步骤三

业务拆封

1. 将登录与注册等业务拆分到commonlib


2. 老师端独有业务拆分


3. 家长端独有业务拆分


4. 路由拆分


5. 启动代码重新构建

部分示例代码：

家长端路由代码

class ClientRouterPage{



  static Widget? getRouter(RouteSettings settings){

  	//判断家长权限

    if(UserStore().getIdentityType() == CommonlibConfig.ruleParent){

      String? routerName = settings.name;

      //跳转家长业务页面

      switch (routerName) {

        case RouterName.home:

          return HomePage();

        case RouterName.bind_student:

          return BindStudentPage();

      }

    }

  }

主工程全部代码（只有一个类，只有如下代码）

class MyCommentConfiger extends ICommentConfiger{



  @override

  Widget getRouter(RouteSettings settings) {

  	//通过登录用户类型来跳转不同业务

  	//老师跳转

    var teachertRouter = RouterPage.getRouter(settings);

    if(teachertRouter!=null){

      return teachertRouter;

    }

    //家长跳转

    var clientRouter = ClientRouterPage.getRouter(settings);

    if(clientRouter!=null){

      return clientRouter;

    }

    //commonlib跳转

    return LibRouterPage.getRouter(settings);

  }



}

//启动运行

void main() {



  Application.init(

      init: AppInit(MyCommentConfiger()),

      syncinitFin: () {

        runApp(App());

      });



}

家长端壳工程全部代码

class ClientCommentConfiger extends ICommentConfiger{



  @override

  Widget getRouter(RouteSettings settings) {

    var router = ClientRouterPage.getRouter(settings);

    if(router!=null){

      return router;

    }

    //commonlib跳转

    return LibRouterPage.getRouter(settings);

  }



}

//启动运行

void main() {

  Application.init(

      init: AppInit(ClientCommentConfiger()),

      syncinitFin: () {

        runApp(App());

      });

}

如上就是单工程架构模式的全部内容

说明：单工程架构模式，主要适用于业务有一定的隔离性，如果你的项目有一块业务极其的独立，那么你可以采用这种模式。该块业务也可以快速移植到其他项目上。

前言

跟我学flutter系列：
跟我学flutter：我们来举个例子通俗易懂讲解dart 中的 mixin
跟我学flutter：我们来举个例子通俗易懂讲解异步（一）ioslate
跟我学flutter：我们来举个例子通俗易懂讲解异步（二）ioslate循环机制

跟我学flutter：在国内如何发布自己的Plugin 或者 Package

跟我学flutter：Flutter雷达图表（一）如何使用kg_charts

跟我学flutter：细细品Widget（一）Widget&Element初识

跟我学flutter：细细品Widget（二）StatelessWidget&StatefulWidget

跟我学flutter：细细品Widget（三）ProxyWidget，InheritedWidget

跟我学flutter：细细品Widget（四）Widget 渲染过程 与 RenderObjectWidget

跟我学flutter：细细品Widget（五）Element

企业级篇目：
跟我学企业级flutter项目：用bloc手把手教你搭建用户认证系统
跟我学企业级flutter项目：dio网络框架增加公共请求参数&header
跟我学企业级flutter项目：如何用dio封装一套企业级可扩展高效的网络层
跟我学企业级flutter项目：如何封装一套易用，可扩展的Hybrid混合开发webview
跟我学企业级flutter项目：手把手教你制作一款低耦合空页面widget

StatelessWidget和StatefulWidget是Flutter开发必不可少的。两者的区别在于state。有状态的widget需要继承StatefulWidget无状态的需要继承StatelessWidget。

StatelessWidget

无状态Widget

源码

abstract class StatelessWidget extends Widget {



  const StatelessWidget({ Key? key }) : super(key: key);



  @override

  StatelessElement createElement() => StatelessElement(this);



  @protected

  Widget build(BuildContext context);

}

createElement

StatelessWidget的对应Element 为StatelessElement

build

用于构建widget
build 在很多种情况下会被调用

1. Widget第一次被加载（Widget 第一次被加入到 Widget Tree 中 ，更准确地说是其对应的 Element 被加入到 Element Tree 时，即 Element 被挂载（mount）时）


2. Parent Widget 修改了其配置信息；


3. 该 Widget 依赖的Inherited Widget发生变化时。

当Parent Widget或 依赖的Inherited Widget频繁变化时，build方法也会频繁被调用。因此，提升build方法的性能就显得十分重要，Flutter 官方给出了几点建议：

1.减少不必要的中间节点，即减少 UI 的层级，*如：对于「Single Child Widget」，没必要通过组合「Row」、「Column」、「Padding」、「SizedBox」等复杂的 Widget 达到某种布局的目标，或许通过简单的「Align」、「CustomSingleChildLayout」即可实现。又或者，为了实现某种复杂精细的 UI 效果，不一定要通过组合多个「Container」，再附加「Decoration」来实现，通过 「CustomPaint」自定义或许是更好的选择；
2.尽可能使用const Widget，*为 Widget 提供const构造方法；
3.可以将「Stateless Widget」重构成「Stateful Widget」，*以便可以使用「Stateful Widget」中一些特定的优化手法，如：缓存「sub trees」的公共部分，并在改变树结构时使用GlobalKey；
4.尽量减小 rebuilt 范围，*如：某个 Widget 因使用了「Inherited Widget」，导致频繁 rebuilt，可以将真正依赖「Inherited Widget」的部分提取出来，封装成更小的独立 Widget，并尽量将该独立 Widget 推向树的叶子节点，以便减小 rebuilt 时受影响的范围。

StatefulWidget

有状态 Widget

StatefulWidget本身是不可变，状态在State中。

源码

abstract class StatefulWidget extends Widget {



  const StatefulWidget({ Key? key }) : super(key: key);



  @override

  StatefulElement createElement() => StatefulElement(this);



  @protected

  @factory

  State createState(); 

}

createElement

StatefulElement的对应Element 为StatefulElement

createState

实际上是「Stateful Widget」对应的「Stateful Element」被添加到 Element Tree 时，伴随「Stateful Element」的初始化，createState方法被调用。从后文可知一个 Widget 实例可以对应多个 Element 实例 (也就是同一份配置信息 (Widget) 可以在 Element Tree 上不同位置配置多个 Element 节点)，因此，createState方法在「Stateful Widget」生命周期内可能会被调用多次。

另外，需要注意的是配有GlobalKey的 Widget 对应的 Element 在整个 Element Tree 中只有一个实例。

State

生命周期：

1. 在对应的(Stateful Element)被挂载 (mount) 到树上时，通过StatefulElement.constructor –> StatefulWidget.createState创建 State 实例

State._emelent就是对应的Element 实例，State与Element绑定关系一经确定，在整个生命周期内不会再变了 (Element 对应的 Widget 可能会变，但对应的 State 永远不会变)，期间，Element可以在树上移动，但上述关系不会变

2. 
   

   StatefulElement 在挂载过程中接着会调用State.initState，子类可以重写该方法执行相关的初始化操作 (此时可以引用context、widget属性)；

   
   


3. 
   

   同样在挂载过程中会调用State.didChangeDependencies，该方法在 State 依赖的对象 (如：「Inherited Widget」) 状态发生变化时也会被调用，*子类很少需要重写该方法，*除非有非常耗时不宜在build中进行的操作，因为在依赖有变化时build方法也会被调用；

   
   


4. 
   

   State 初始化已完成，其build方法此后可能会被多次调用，在状态变化时 State 可通过setState方法来触发其子树的重建；

   
   


5. 
   

   此时，「element tree」、「renderobject tree」、「layer tree」已构建完成，完整的 UI 应该已呈现出来。此后因为变化，「element tree」中「parent element」可能会对树上该位置的节点用新配置 (Widget) 进行重建，当新老配置 (oldWidget、newWidget)具有相同的「runtimeType」&&「key」时，framework 会用 newWidget 替换 oldWidget，并触发一系列的更新操作 (在子树上递归进行)。同时，State.didUpdateWidget方法被调用，子类重写该方法去响应 Widget 的变化；

   
   


6. 
   

   在 UI 更新过程中，任何节点都有被移除的可能，State 也会随之移除，(如上一步中「runtimeType」||「key」不相等时)。此时会调用State.deactivate方法，由于被移除的节点可能会被重新插入树中某个新的位置上，故子类重写该方法以清理与节点位置相关的信息 (如：该 State 对其他 element 的引用)、同时，不应在该方法中做资源清理；

   
   

重新插入操作必须在当前帧动画结束之前

7. 当节点被重新插入树中时，State.build方法被再次调用；


8. 对于在当前帧动画结束时尚未被重新插入的节点，State.dispose方法被执行，State 生命周期随之结束，此后再调用State.setState方法将报错。子类重写该方法以释放任何占用的资源。

源码

void setState(VoidCallback fn) {

    assert(fn != null);

    assert(() {

      if (_debugLifecycleState == _StateLifecycle.defunct) {

        throw FlutterError.fromParts([

          ErrorSummary('setState() called after dispose(): $this'),

          ErrorDescription(

            'This error happens if you call setState() on a State object for a widget that '

            'no longer appears in the widget tree (e.g., whose parent widget no longer '

            'includes the widget in its build). This error can occur when code calls '

            'setState() from a timer or an animation callback.',

          ),

          ErrorHint(

            'The preferred solution is '

            'to cancel the timer or stop listening to the animation in the dispose() '

            'callback. Another solution is to check the "mounted" property of this '

            'object before calling setState() to ensure the object is still in the '

            'tree.',

          ),

          ErrorHint(

            'This error might indicate a memory leak if setState() is being called '

            'because another object is retaining a reference to this State object '

            'after it has been removed from the tree. To avoid memory leaks, '

            'consider breaking the reference to this object during dispose().',

          ),

        ]);

      }

      if (_debugLifecycleState == _StateLifecycle.created && !mounted) {

        throw FlutterError.fromParts([

          ErrorSummary('setState() called in constructor: $this'),

          ErrorHint(

            'This happens when you call setState() on a State object for a widget that '

            "hasn't been inserted into the widget tree yet. It is not necessary to call "

            'setState() in the constructor, since the state is already assumed to be dirty '

            'when it is initially created.',

          ),

        ]);

      }

      return true;

    }());

    final Object? result = fn() as dynamic;

    assert(() {

      if (result is Future) {

        throw FlutterError.fromParts([

          ErrorSummary('setState() callback argument returned a Future.'),

          ErrorDescription(

            'The setState() method on $this was called with a closure or method that '

            'returned a Future. Maybe it is marked as "async".',

          ),

          ErrorHint(

            'Instead of performing asynchronous work inside a call to setState(), first '

            'execute the work (without updating the widget state), and then synchronously '

           'update the state inside a call to setState().',

          ),

        ]);

      }

      // We ignore other types of return values so that you can do things like:

      //   setState(() => x = 3);

      return true;

    }());

    _element!.markNeedsBuild();

  }

分析：

1. _debugLifecycleState == _StateLifecycle.defunct 在State.dispose后不能调用setState


2. _debugLifecycleState == _StateLifecycle.created && !mounted 在 State 的构造方法中不能调用setState


3. if (result is Future) setState方法的回调函数 (fn) 不能是异步的 (返回值为Future)

通过setState方法之所以能更新 UI，是在其内部调用_element.markNeedsBuild()

若State.build方法依赖了自身状态会变化的对象，如：ChangeNotifier、Stream或其他可以被订阅的对象，需要确保在initState、didUpdateWidget、dispose

等 3 方法间有正确的订阅 (subscribe) 与取消订阅 (unsubscribe) 的操作：
1.在initState中执行 subscribe；
2.如果关联的「Stateful Widget」与订阅有关，在didUpdateWidget中先取消旧的订阅，再执行新的订阅；
3.在dispose中执行 unsubscribe。

在State.initState方法中不能调用BuildContext.dependOnInheritedWidgetOfExactType，但State.didChangeDependencies会随之执行，在该方法中可以调用。

文章内容参考：http://www.jb51.net/article/221…

跟我学flutter系列：
跟我学flutter：我们来举个例子通俗易懂讲解dart 中的 mixin
跟我学flutter：我们来举个例子通俗易懂讲解异步（一）ioslate
跟我学flutter：我们来举个例子通俗易懂讲解异步（二）ioslate循环机制

跟我学flutter：在国内如何发布自己的Plugin 或者 Package

跟我学flutter：Flutter雷达图表（一）如何使用kg_charts

跟我学flutter：细细品Widget（一）Widget&Element初识

企业级篇目：
跟我学企业级flutter项目：用bloc手把手教你搭建用户认证系统
跟我学企业级flutter项目：dio网络框架增加公共请求参数&header
跟我学企业级flutter项目：如何用dio封装一套企业级可扩展高效的网络层
跟我学企业级flutter项目：如何封装一套易用，可扩展的Hybrid混合开发webview
跟我学企业级flutter项目：手把手教你制作一款低耦合空页面widget

正文

今天的文章简短地揭示了 Dart 语言所提供的很酷的特性。更多时候，这些选项对于简单的应用程序是不必要的，但是当你想要通过简单、清晰和简洁来改进你的代码时，这些选项是一个救命稻草。

考虑到这一点，我们走吧。

Cascade 级联

Cascades (.., ?..) 允许你对同一个对象进行一系列操作。这通常节省了创建临时变量的步骤，并允许您编写更多流畅的代码。

var paint = Paint();

paint.color = Colors.black;

paint.strokeCap = StrokeCap.round;

paint.strokeWidth = 5.0;



//above block of code when optimized

var paint = Paint()

  ..color = Colors.black

  ..strokeCap = StrokeCap.round

  ..strokeWidth = 5.0;

Abstract 抽象类

使用 abstract 修饰符定义一个 _abstract 抽象类(无法实例化的类)。抽象类对于定义接口非常有用，通常带有一些实现。

// This class is declared abstract and thus

// can't be instantiated.

abstract class AbstractContainer {

  // Define constructors, fields, methods...



  void updateChildren(); // Abstract method.

}

Factory constructors 工厂建造者

在实现不总是创建类的新实例的构造函数时使用 factory 关键字。

class Logger {

  String name;

  Logger(this.name);

  factory Logger.fromJson(Map<String, Object> json) {

    return Logger(json['name'].toString());

  }

}

Named 命名构造函数

使用命名构造函数为一个类实现多个构造函数或者提供额外的清晰度:

class Points {

  final double x;

  final double y;



  //unnamed constructor

  Points(this.x, this.y);



  // Named constructor

  Points.origin(double x,double y)

      : x = x,

        y = y;



  // Named constructor

  Points.destination(double x,double y)

      : x = x,

        y = y;

}

Mixins 混合物

Mixin 是在多个类层次结构中重用类代码的一种方法。

要实现 implement mixin，创建一个声明没有构造函数的类。除非您希望 mixin 可以作为常规类使用，否则请使用 mixin 关键字而不是类。

若要使用 mixin，请使用后跟一个或多个 mixin 名称的 with 关键字。

若要限制可以使用 mixin 的类型，请使用 on 关键字指定所需的超类。

class Musician {}



//creating a mixin

mixin Feedback {

  void boo() {

    print('boooing');

  }



  void clap() {

    print('clapping');

  }

}



//only classes that extend or implement the Musician class

//can use the mixin Song

mixin Song on Musician {

  void play() {

    print('-------playing------');

  }



  void stop() {

    print('....stopping.....');

  }

}



//To use a mixin, use the with keyword followed by one or more mixin names

class PerformSong extends Musician with Feedback, Song {

  //Because PerformSong extends Musician,

  //PerformSong can mix in Song

  void awesomeSong() {

    play();

    clap();

  }



  void badSong() {

    play();

    boo();

  }

}



void main() {

  PerformSong().awesomeSong();

  PerformSong().stop();

  PerformSong().badSong();

}

Typedefs

类型别名ー是指代类型的一种简明方式。通常用于创建在项目中经常使用的自定义类型。

typedef IntList = List<int>;

List<int> i1=[1,2,3]; // normal way.

IntList i2 = [1, 2, 3]; // Same thing but shorter and clearer.



//type alias can have type parameters

typedef ListMapper<X> = Map<X, List<X>>;

Map<String, List<String>> m1 = {}; // normal way.

ListMapper<String> m2 = {}; // Same thing but shorter and clearer.

Extension 扩展方法

在 Dart 2.7 中引入的扩展方法是一种向现有库和代码中添加功能的方法。

//extension to convert a string to a number

extension NumberParsing on String {

  int customParseInt() {

    return int.parse(this);

  }



  double customParseDouble() {

    return double.parse(this);

  }

}



void main() {

  //various ways to use the extension



  var d = '21'.customParseDouble();

  print(d);



  var i = NumberParsing('20').customParseInt();

  print(i);

}

可选的位置参数

通过将位置参数包装在方括号中，可以使位置参数成为可选参数。可选的位置参数在函数的参数列表中总是最后一个。除非您提供另一个默认值，否则它们的默认值为 null。

String joinWithCommas(int a, [int? b, int? c, int? d, int e = 100]) {

  var total = '$a';

  if (b != null) total = '$total,$b';

  if (c != null) total = '$total,$c';

  if (d != null) total = '$total,$d';

  total = '$total,$e';

  return total;

}



void main() {

  var result = joinWithCommas(1, 2);

  print(result);

}

unawaited_futures

当您想要启动一个 Future 时，建议的方法是使用 unawaited

否则你不加 async 就不会执行了

import 'dart:async';



Future doSomething() {

  return Future.delayed(Duration(seconds: 5));

}



void main() async {

  //the function is fired and awaited till completion

  await doSomething();



  // Explicitly-ignored

  //The function is fired and forgotten

  unawaited(doSomething());

}

end.

彩虹系列

通过动画控制绘制的结束点，就可以让贝塞尔曲线动起来。例如下面的动图展示的效果，看起来像搭了一个滑滑梯一样。实际上就是用7条贝塞尔曲线实现的，我们使用了 Animation 对象的值来控制绘制的结束点，从而实现了对应的动画效果。

具体源码如下，其中控制绘制结束点就是在动画过程中修改循环的次数，即t <= (100 * animationValue).toInt()；这句代码，其中 animationValue 是动画控制器当前值，范围时从0-1。

class AnimationBezierPainter extends CustomPainter {

  AnimationBezierPainter({required this.animationValue});

  final double animationValue;

  @override

  void paint(Canvas canvas, Size size) {

    final lineWidth = 6.0;

    paint.strokeWidth = lineWidth;

    paint.style = PaintingStyle.stroke;

    final colors = [

      Color(0xFFE05100),

      Color(0xFFF0A060),

      Color(0xFFE0E000),

      Color(0xFF10F020),

      Color(0xFF2080F5),

      Color(0xFF104FF0),

      Color(0xFFA040E5),

    ];



    final lineNumber = 7;

    for (var i = 0; i < lineNumber; ++i) {

      paint.color = colors[i % colors.length];

      _drawAnimatedLines(canvas, paint, size, size.height / 4 + i * lineWidth);

    }

  }



  @override

  bool shouldRepaint(covariant CustomPainter oldDelegate) {

    return true;

  }



  _drawRainbowLines(Canvas canvas, Paint paint, Size size, yPos) {

    var yGap = 60.0;

    var p0 = Offset(0, yPos - yGap / 2);

    var p1 = Offset(size.width * 2 / 3, yPos - yGap);

    var p2 = Offset(size.width / 3, yPos + yGap);

    var p3 = Offset(size.width, yPos + yGap * 1.5);

    var path = Path();

    path.moveTo(p0.dx, p0.dy);

    for (var t = 1; t <= (100 * animationValue).toInt(); t += 1) {

      var curvePoint =

          BezierUtil.get3OrderBezierPoint(p0, p1, p2, p3, t / 100.0);



      path.lineTo(curvePoint.dx, curvePoint.dy);

    }

    canvas.drawPath(path, paint);

  }

}

我们修改曲线的控制点还可以实现下面的效果，大家有兴趣可以自己尝试一下。

弹簧动画

用多个贝塞尔曲线首尾相接，在垂直方向叠起来就能画出一条弹簧了，然后我们更改弹簧的间距和高度（曲线的数量）就能做出弹簧压下去和弹起来的动画效果了。

这部分的代码如下所示：

@override

void paint(Canvas canvas, Size size) {

  var paint = Paint()..color = Colors.black54;

  final lineWidth = 2.0;

  paint.strokeWidth = lineWidth;

  paint.style = PaintingStyle.stroke;



  final lineNumber = 20;

  // 弹簧效果

  final yGap = 2.0 + 16.0 * animationValue;

  for (var i = 0; i < (lineNumber * animationValue).toInt(); ++i) {

    _drawSpiralLines(

        canvas, paint, size, size.width / 2, size.height - i * yGap, yGap);

  }

}



_drawSpiralLines(Canvas canvas, Paint paint, Size size, double xPos,

    double yPos, double yGap) {

  final xWidth = 160.0;

  var p0 = Offset(xPos, yPos);

  var p1 = Offset(xPos + xWidth / 2 + xWidth / 4, yPos - yGap);

  var p2 = Offset(xPos + xWidth / 2 - xWidth / 4, yPos - 3 * yGap);

  var p3 = Offset(xPos, yPos - yGap);

  var path = Path();

  path.moveTo(p0.dx, p0.dy);

  for (var t = 1; t <= 100; t += 1) {

    var curvePoint =

        BezierUtil.get3OrderBezierPoint(p0, p1, p2, p3, t / 100.0);



    path.lineTo(curvePoint.dx, curvePoint.dy);

  }

  canvas.drawPath(path, paint);

}

复杂立体感动画

通过多条贝塞尔图形组成的曲线往往会有立体的效果，而立体的效果动起来的时候就会感觉是3D 动画一样，实际上通过贝塞尔曲线是能够绘制出一些3D 效果的动画的，比如下面这个效果，就感觉像在三维空间飞行一样（如果配上背景图移动会更逼真）。这里实际使用了4组贝塞尔曲线来实现，当然实际还可以画一些有趣的图形，比如说画一条鱼。这个源码比较长，就不贴了，有兴趣的可以自行去下载源码（注：本篇之后的 Flutter版本升级到了2.10.3）：绘图相关源码。

总结

可以看到，通过动画控制贝赛尔曲线动起来的效果还是挺有趣的。而且，我们还可以根据之前动画相关的篇章做一些更有趣的效果出来。这种玩法可以用在一些特殊的加载动画或是做一些比较酷炫的特效上面，增添 App 的趣味性。

Dart中类的类型

Dart是支持基于mixin继承机制的面向对象语言，所有对象都是一个类的实例，而除了 Null以外的所有的类都继承自Object类。 基于mixin的继承意味着尽管每个类（top class Object? 除外）都只有一个超类，一个类的代码可以在其它多个类继承中重复使用。

以上这段是官方文档的说明，在实际使用中，由于mixin的加入，使得Dart中类的使用和其它语言有所不同。Dart中类的类型有三种，分别是：

• class：声明一个类，提供具体的成员变量和方法实现。


• abstract class：声明一个抽象类，抽象类将无法被实例化。抽象类常用于声明接口方法、有时也会有具体的方法实现。


• mixin：声明一个Mixin类，与抽象类一样无法被实例化，是一种在多重继承中复用某个类中代码的方法模式，可以声明接口方法或有具体的方法实现。

1. 每一个类都隐式地定义了一个接口并实现了该接口，这个接口包含所有这个类的成员变量以及这个类所实现的其它接口。


2. 如果想让抽象类同时可被实例化，可以为其定义工厂构造函数。具体内容可以参考：抽象类的实例化


3. mixin关键字在Dart 2.1中才被引用支持。早期版本中的代码通常使用 abstract class代替

从上述内容可以看出，mixin是后面才被引入的，与abstract class有些通用的地方，可以理解为abstract class的升级版。它相对于abstract class说，可以同时引入多个Mixin，并且可以通过on关键字来限制使用范围。

类相关关键字的使用

而对上述这些类型的使用，又有extends, with, implements, on这几个关键字：

• extends：继承，和其它语言的继承没什么区别。


• with：使用Mixin模式混入一个或者多个Mixin类。


• implements：实现一个或多个接口并实现每个接口定义的API。


• on：限制Mixin的使用范围。

针对这几个关键字的使用，我做了一张表进行总结：

样例说明

针对上面的内容，我举几个例子，可以复制代码到DartPad中进行验证：

类混入类或者抽象类（class with class）

class Animal {

  String name = "Animal";

}

abstract class Flyer {

  String name = "Flyer";

  void fly() => print('$name can fly!');

}

abstract class Eater extends Animal {

  void eat() => print('I can Eat!');

}



// 同时混入class和abstract class

abstract class Bird with Animal, Flyer {}

class Bird1 with Animal, Flyer {}



// 只支持无任何继承和混入的类，Eater继承自Animal，所以它不支持被混入。

// 报错：The class 'Eater' can't be used as a mixin because it extends a class other than 'Object'.

// class Bird with Eater { 

// }



main() {

  Bird1().fly();  // Flyer can fly!

}

类继承抽象类并混入Mixin

class Animal {

  String name = "Animal";

}



mixin Flyer {

  String name = "Flyer";

  void fly() => print('$name can fly!');

}



abstract class Eater extends Animal {

  @override

  String get name => "Eater";

  void eat() => print('$name can Eat!');

}



// 类继承抽象类并混入Mixin

class Bird extends Eater with Flyer {  }



main() {

  // 因为with（混入）的优先级比extends（继承）更高，所以打印出来的是Flyer而不是Eater

  Bird().fly(); // Flyer can fly!

  Bird().eat(); // Flyer can Eat!

}

类继承抽象类并混入Mixin的同时实现接口

class Biology {

  void breathe() => print('I can breathe');

}



class Animal {

  String name = "Animal";

}



// 这里设置实现了Biology接口，但是mixin与abstract class一样并不要求实现接口，声明与实现均可。

// on关键字限制混入Flyer的类必须继承自Animal或它的子类

mixin Flyer on Animal implements Biology {

  @override

  String get name => "Flyer";

  void fly() => print('$name can fly!');

}



abstract class Eater extends Animal {

  @override

  String get name => "Eater";

  void eat() => print('$name can Eat!');

}



// 类继承抽象类并混入Mixin的同时实现接口

// 注意关键字的使用顺序，依次是extends -> with -> implements

class Bird extends Eater with Flyer implements Biology {

  // 后面使用了`implements Biology`，所以子类必须要实现这个类的接口

  @override

  void breathe() => print('Bird can breathe!');

}



main() {

  // 因为with（混入）的优先级比extends（继承）更高，所以打印出来的是Flyer而不是Eater

  Bird().fly(); // Flyer can fly!

  Bird().eat(); // Flyer can Eat!

  Bird().breathe(); // Bird can breathe!

}

混入mixin的顺序问题

abstract class Biology {

  void breathe() => print('I can breathe');

}



mixin Animal on Biology {

  String name = "Animal";

  @override

  void breathe() {

    print('$name can breathe!');

    super.breathe();

  }

}



mixin Flyer on Animal {

  @override

  String get name => "Flyer";

  void fly() => print('$name can fly!');

}



/// mixin的顺序问题：

/// with后面的Flyer必须在Animal后面，否则会报错：

/// 'Flyer' can't be mixed onto 'Biology' because 'Biology' doesn't implement 'Animal'.

class Bird extends Biology with Animal, Flyer {

  @override

  void breathe() {

    print('Bird can breathe!');

    super.breathe();

  }

}



main() {

  Bird().breathe(); 

  /*

   * 上述代码执行，依次输出：

   * Bird can breathe!

   * Flyer can breathe!

   * I can breathe

   * */

}

这里的顺序问题和运行出来的结果会让人有点费解，但是可以这样理解：Mixin语法糖, 本质还是类继承. 继承可以复用代码, 但多继承会导致代码混乱。 Java为了解决多继承的问题, 用了interface, 只有函数声明而没有实现(后面加的default也算语法糖了)。以A with B, C, D为例，实际是A extends D extends C extends B， 所以上面的Animal必须在Flyer前面，否则就变成了Animal extends Flyer，会出现儿子给爹当爹的混乱问题。

mixin的底层本质只是猜测，并没有查看语言底层源码进行验证.

总结

从上述样例可以看出，三种类结构可以同时存在，关键字的使用有前后顺序：extends -> mixins -> implements。
另外需要注意的是相同方法的优先级问题，这个有两种情况：

1. 同时被extends，with，implements时，混入（with）的优先级比继承（extends）要高，而implements只提供接口，不会被调用。


2. with多个Mixin时，则会调用距离with关键字最远Mixin中的方法。

当然，如果当前使用类重写了该方法，就会优先调用当前类中的方法。

参考资料

• Dart官方文档


• Dart之Mixin详解


• Flutter 基础 | Dart 语法 mixin：对mixin的使用场景进行了很好的说明

什么是Flutter Modular？

随着应用项目发展和变得越来越复杂，保持代码和项目结构可维护和可复用越来越难。Modular提供了一堆适配Flutter的解决方案来解决这些问题，比如依赖注入，路由系统和“一次性单例”系统（也就是说，当注入模块超出范围时，模块化自动配置注入模块）。

Modular的依赖注入为任何状态管理系统提供了开箱即用的支持，管理你应用的内存。

Modular也支持动态路由和相对路由，像在Web一样。

Modular结构

Modular结构由分离和独立的模块组成，这些模块将代表应用程序的特性。
每个模块都位于自己的目录中，并控制自己的依赖关系、路由、页面、小部件和业务逻辑。因此，您可以很容易地从项目中分离出一个模块，并在任何需要的地方使用它。

Modular支柱

这是Modular关注的几个方面：

• 自动内存管理


• 依赖注入


• 动态和相对路由


• 代码模块化