ES6之变量的解构赋值(Destructuring) ES6中解构赋值主要分为6类，分别为 数组解构赋值 、对象解构赋值 、字符串解构赋值 、数值和布尔值解构赋值 、函数参数解构赋值 。什么是解构？在ES6中允许按照一定的模式从数组和对象中提取值，然后对变量进行赋值，这被称为解构(Destructuring)数组解构赋值数组的解构赋值时，等号的右边必须是数组，否则将会报错。只要数据结构具有Iterator借口，则都可以采用数组形式的解构赋值。let [a, b, c] = [1, 2, 3]; a // 1 b // 2 c // 3这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值。下面是一些常见的解构例子：let [f, [[k], y]] = [1, [[2], 3]]; f // 1 k // 2 y // 3 let [ , ,t] = ["php", "java", "go"]; t // go let [x, ,y] = ["php", "java", "go"]; x // php y // go let [k, ...t] = [1, 2, 3, 4]; k // 1 t // [2, 3, 4] let [x, y, ...z] = ["php"]; x // php y // undefined z // []当解构不成功，变量的值就等于undefined。下面代码中，f均解构不成功，为undefined。let [f] = []; let [k, f] = [1];Set结构也可以使用数组的解构赋值，如下：let [x, y, z] = new Set(["php", "java", "go"]); x // php y // java z // go还有一种情况是部分解构成功，如下：let [x, y] = [1, 2, 3]; x // 1 y // 2 let [a, [b], c] = [1, [2, 3], 4] a // 1 b // 2 c // 4以上情况是不完全解构，即等号左边的模式只能匹配一部分等号右边的数组。但是这种情况下，结构依然可以成功。let [f] = 1; let [f] = false; let [f] = NaN; let [f] = undefined; let [f] = null; let [f] = {};以上语句都会报错，因为等号右边的值或是转为对象以后不具备iterator接口（前五个表达式），或是本事就不具备Iterator接口（最后一个表达式）数组解构赋值中允许指定 默认值 ，如：let [f = true] = []; f // true let [a, b = 'x'] = ['y']; a // y b // x let [a, b = 'c'] = ['k', undefined]; a // k b // c let [x = 1] = [undefined]; x // 1 let [x = 1] = [null]; x // null let [x = 1, y = x] = []; // x = 1, y = 1 let [x = 1, y = x] = [2]; // x = 2, y = 2 let [x = 1, y = x] = [1, 2]; // x = 1, y = 2 let [x = y, y = 1] = []; // 报错：ReferenceError最后一个表达式之所以报错，是因为x引用了默认值y时，y还没有被声明。注：ES6内部使用严格相等运算符(===)判断一个位置是否有值。如果一个数组成员不严格等于undefined,默认值是无法生效的。对象解构赋值对象的解构与数组有一个重要的不同：数组的元素是按次序排列的，变量的取值是由它的位置决定的；而对象的属性没有次序，变量必须与属性同名才能取到正确的值。示例如下：let {f, b} = {f: "AA", b: "KK"}; // f --> AA b --> KK let {c} = {f: "AA", b: "KK"}; // c --> undefined如果变量名与属性名不一致，必须用如下的形式：let {f: b} = {f: 'AA', b: 'CC'}; // b --> AA let obj = {hello: 'AA', world: 'CC'}; let {hello: h, world: w} = obj; // h --> hello w --> world hello --> error: hello is not defined对象的解构赋值的内部机制是先找到同名属性，然后再赋值给对应的变量。真正被赋值的是后者，而不是前者。对象解构也可以指定默认值：let {x = 3} = {}; // x --> 3 let {x, y = 5} = {x: 1}; // x --> 1 y --> 5 let {x : y = 3} = {}; // y --> 3 let {x : y = 3} = {y : 5}; // y --> 5 let {x = 3} = {x : undefined}; // x --> 3 let {x = 3} = {x : null}; // x --> null默认值生效的条件是对象的属性值严格等于undefined如果解构模式是嵌套的对象，而且子对象所在的父属性不存在，那么将会报错，如下：let {f: {bo}} = {bc: "bucc"}以上代码报错的原因是因为f此时等于undefined，再取子属性就会报错。如果将一个已经声明的变量用于解构赋值，必须非常小心。 常见的错误如下：// 错误的写法 let x; {x} = {x : 1}; // SyntaxError: syntax error // 正确的写法 let x; ({x} = {x : 1});以上代码中第一部分会报错，是因为JavaScript引擎会将{ x }理解成一个代码块，从而发生语法错误。只有不将大括号写在行首，避免JavaScript将其解释为代码块，才能解决这个问题。解构赋值允许等号左边的模式之中不放置任何变量名。虽然此类表达式毫无意义，但是语法合法，且可以正常执行：({} = [true, false]); ({} = 'abc'); ({} = []);由于数组本质是特殊的对象，因为可以对数组进行对象属性的解构：let arr = [1, 2, 3]; let {0: first, [arr.length - 1]: last} = arr; // first --> 1 last --> 3字符串解构赋值字符串在进行解构赋值时，字符串被转换成了一个类似数组的对象：let [a, b, c, d, e] = 'hello'; // a -->h a -->e a -->l a -->l a -->o类似数组的对象都有一个length的属性，因为还可以对这个属性进行解构赋值：let {length : len} = 'hello'; // len --> 5数值和布尔值解构赋值在数值和布尔值解构赋值时，如果等号右边是数值或布尔值，则会先转为对象。let {toString:s} = 123; s === Number.prototype.toString; // true let {toString:s} = true; s === Boolean.prototype.toString; // true解构赋值的规则是，只要等号右边的值不是对象或数组，就先将其转为对象。let {prop: x} = undefined; // TypeError let {prop: y} = null; // TypeError函数参数解构赋值函数的参数也可以使用解构赋值。function add([x, y]) { return x + y; } add([3, 2]); // 5 [[1,2],[3,4]].map(([a, b]) => a + b); //  [3, 7]函数参数的解构也可以使用默认值：// 示例一 function move ({x = 0, y = 0} = {}) { return [x, y] } move({x: 3, y: 9}); // [3, 9] move({x: 3}); // [3, 0] move({}); // [0, 0] move(); // [0, 0] // 示例二 function move({x, y} = {x : 0, y : 0}) { return [x, y]; } move({x: 3, y: 9}); // [3, 9] move({x: 3}); // [3, undefined] move({}); // [undefined, undefined] move(); // [0, 0]关于圆括号的问题解构赋值虽然很方便，但是解析起来并不容易。对于编译器来说，一个式子到底是模式还是表达式，没有办法从一开始就知道，必须解析到（或解析不到）等号才能知道。ES6规则是只要有可能导致解构的歧义，就不得使用圆括号。但是这个在实际中并不那么容易判断，且处理起来相当的麻烦。所以也建议，只要有可能就不要在模式中放置圆括号。不能使用圆括号的情况情况一：变量声明语句let [(a)] = [1]; // 错误 let {x : (c)} = {};// 错误 let ({x : c}) = [1];// 错误 let {(x : c)} = [1];// 错误 let {(x) : c} = [1];// 错误 let {o : ({p:p})} = {o: {p: 2}};// 错误类似以上代码语句都会报错，因为它们都是变量声明语句，模式不能使用圆括号。情况二：函数参数函数参数也属于变量声明，因此不能使用圆括号function f ([(z)]) { return z; }// 错误 function f ([z, (x)]) {return x; }// 错误情况三：赋值语句的模式// 将整个模式放入圆括号之中导致报错 ({p : a}) = {p: 4};// 错误 ([a]) = [5];// 错误 // 将一部分模式放入圆括号之中导致报错 [({p: a}), {x: c}] = [{}, {}];// 错误可以使用圆括号的情况可以使用圆括号的情况只有一种：赋值语句的非模式部分可以使用圆括号。[(b)] = [3]; // 正确 ({p: (d)} = {});// 正确 [(parseInt.prop)] = [3];// 正确以上三个语句均执行正确，因为他们的都是赋值语句，而不是声明的语句，另外它们的圆括号都不属于模式的一部分。用途变量的解构赋值用途很多：交换变量的值let x = 1; let y = 2; [x, y] = [y, x];从函数返回多个值函数只能返回一个值，如果要返回多个值，只能将它们放在数组或对象里面返回。// 返回一个数组 function test1() { return [1, 2, 3]; } let [a, b, c] = test1(); // 返回一个对象 function test2() { return { a: 2, b: 6 }; } let {a, b} = test2();函数参数的定义解构赋值可以方便的将一组参数与变量名对应起来// 参数是一组有序的值 function f1([x, y, z]) { ... } f1([1, 2, 3]); // 参数是一组无序的值 function f2({x, y, z}}) { ... } f2({z: 8, x: 6, y: 4});提取JSON数据let jsonData = { id: 2, name: 'LiMing', data: [867, 22] } let {id, name, data: nums} = jsonData; console.log(id, name, nums); // 2， "LiMing"， [867, 22]函数参数的默认值jQuery.ajax = function (url, { async = true, cache = true, complate = function(){} }) { // do stuff } 遍历Map结构任何部署了Iterator接口的对象都可以用for...of 循环遍历。Map结构原生支持Iterator接口，配合变量的解构赋值获取键名和键值就非常方便。let map = new Map(); map.set('one', 'hello'); map.set('two', 'world'); for(let [key , value] of map) { console.log(key, value); } // 获取键名 for(let [key] of map) { console.log(key); } // 获取键值 for(let [, value] of map) { console.log(value); }输入模块的指定方法:加载模块时往往需要指定输入的方法。解构赋值使得输入语句非常清晰：const {SourceMapConsumer, SourceNode} = require("source-map");

Flutter 2.0空安全之数据模型（Model）空安全适配技巧 数据模型（Model）空安全适配主要以下两种情况：含有命令构造函数的模型含有命名工厂构造函数的模型含有命令构造函数的模型含有命令构造函数的模型的空安全适配技巧：适配前：///数据模型 class ItemModel { int totalCount; List<Item> resultList; ItemModel.fromJson(Map<String, dynamic> json) { totalCount = json['totalCount']; if (json['resultList'] != null) { resultList = new List<Item>(); json['resultList'].forEach((v) { resultList.add(new Item.fromJson(v)); }); } } Map<String, dynamic> toJson() { final Map<String, dynamic> data = new Map<String, dynamic>(); data['totalCount'] = this.totalCount; if (this.resultList != null) { data['resultList'] = this.resultList.map((v) => v.toJson()).toList(); } return data; } }适配之前首先要和后端服务协商好，在数据模型中那些字段可空，那些字段是不为空的。以上代码中假如：totalCount字段是一定会有数据，resultList字段是不能保证有数据，那么我们可以这样来适配：适配后：///数据模型 class ItemModel { late int totalCount; List<Item>? resultList; //命名构造方法 ItemModel.fromJson(Map<String, dynamic> json) { totalCount = json['totalCount']; if (json['resultList'] != null) { resultList = new List<Item>.empty(growable: true); json['resultList'].forEach((v) { resultList!.add(new Item.fromJson(v)); }); } } Map<String, dynamic> toJson() { final Map<String, dynamic> data = new Map<String, dynamic>(); data['totalCount'] = this.totalCount; data['resultList'] = this.resultList!.map((v) => v.toJson()).toList(); return data; } }对于一定会下发的字段我们通过late来修饰为延迟初始化的字段以方便访问对于不能保证一定会下发的字段，我们通过?将其修饰为可空的变量含有命名工厂构造函数的模型命名工厂构造函的数据模型也是比较常见的数据模型之一，有命名工厂构造函的数据模型的空安全适配技巧如下：适配前：class ResponseResult { /// 成功标记 true：成功；false：失败 bool status; /// 消息 String info; /// 数据 dynamic data; ResponseResult({this.status, this.info, this.data}); factory ResponseResult.fromJson(Map<String, dynamic> json) { return ResponseResult( status: json['status'], info: json['info'], data: json['data'] ); } @override String toString() { return 'ResponseResult{status: $status, info: $info, data: $data}'; } Map<String, dynamic> toJson () { Map<String, dynamic> _m = new Map<String, dynamic>(); _m["status"] = this.status; _m["info"] = this.info; _m["data"] = this.data; return _m; } }含有命名工厂构造函数的模型通常需要有自己的构造函数，构造函数通常采用可选参数，所以在进行适配时首先要明确哪些字段一定不为空，哪些字段可空，确认好之后就可以进行下面适配了：适配后：class ResponseResult { /// 成功标记 true：成功；false：失败 bool status; /// 消息 String? info; /// 数据 dynamic? data; ResponseResult({required this.status, this.info, this.data}); factory ResponseResult.fromJson(Map<String, dynamic> json) { return ResponseResult( status: json['status'], info: json['info'], data: json['data'] ); } @override String toString() { return 'ResponseResult{status: $status, info: $info, data: $data}'; } Map<String, dynamic> toJson () { Map<String, dynamic> _m = new Map<String, dynamic>(); _m["status"] = this.status; _m["info"] = this.info; _m["data"] = this.data; return _m; } }对于可空的字段通过?进行修饰对于不可空的字段，需要在构造方法中在对应的字段前面添加required修饰符来表示这个参数是必传参数

使用WebView出现net::ERR_CLEARTEXT_NOT_PERMITTED 开发应用时（在Android11.0【Android API 30】环境下）使用Webview插件加载页面出现如下图情况: 用模拟器尝试了下其他几个版本，发现8.0版本以下的都是可以正常显示网页的，于是上网查了下原因是说从Android9.0（也就是API 28）开始，默认情况下禁用明文支持。所以url无法在webview中加载。解决办法就是在AndroidManifest中application节点内添加android:usesCleartextTraffic="true"，如下:<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.baikeyang.blog"> <application android:label="blog" android:icon="@mipmap/ic_launcher" android:usesCleartextTraffic="true"> ...... </application> </manifest> 添加完成该项配置后，重启运行项目，网页就会正常显示，如下： 如果添加完配置刷新没有效果，clean一下项目，然后重新启动运行就可以了。

Flutter 2.0空安全之自定义Widge适配 自定义Widget的空安全适配分两种情况：Widget的空安全适配State的空安全适配Widget的空安全适配对于自定的Widget无论是页面的某控件还是整个页面，通常都会为Widget定义一些属性。在进行空安全适配时要对属性进行一下分类：可空的属性：通过?进行修饰不可空的属性：在构造函数中设置默认值或者通过 required 进行修饰class WebView extends StatefulWidget { String? url; final String? statusBarColor; final String? title; final bool? hideAppBar; final bool backForbid; WebView( {this.url, this.statusBarColor, this.title, this.hideAppBar, this.backForbid = false}) ...上述示例是WebView模块进行空安全适配后的效果。提示：如果构造方法中使用了 @required 那么需要改成 required 。State的空安全适配State的空安全适配主要是根据它的成员变量是否可空进行分类：可空的变量：通过 ? 进行修饰不可空的变量：可采用以下两种方式进行适配：定义时初始化；使用 late 修饰为延时变量下面是项目中的State适配了空安全后的主要代码效果可以参考下：class _TravelPageState extends State<TravelPage> with TickerProviderStateMixin { late TabController _controller; //延时初始 List<TravelTab> tabs = []; //定义时初始化 ... @override void initState() { super.initState(); _controller = TabController(length: 0, vsync: this); ...

Flutter 2.0空安全之手动关闭/开启 Flutter 2默认启用了空安全，所以通过Flutter 2创建的项目是已经开启了空安全的检查的，另外，也可以可以通过下面命令来查看你的Flutter SDK版本：flutter doctor那么，如何手动开启和关闭空区安全的？environment: sdk: ">=2.12.0 <3.0.0" //sdk >=2.12.0表示开启空安全检查提示：一旦项目开启了空安全检查，那么你的代码包括项目所依赖的三方插件必须是要支持空安全的否则是无法正常编译的。开启空安全之后，然后运行下项目你会看到很多的报错，然后定位到报错的文件，对项目进行空安全适配。如果想关闭空安全检查，可以将SDK的支持范围调整到2.12.0以下即可，如：environment: sdk: ">=2.7.0 <3.0.0"

Flutter 2.0空安全之最小必备知识 Flutter 2.0空安全之最小必备知识从Flutter 2开始，Flutter便在配置中默认启用了空安全，通过将空检查合并到类型系统中，可以在开发过程中捕获这些错误，从而防止再生产环境导致的崩溃。{dotted startColor="#ff6c6c" endColor="#1989fa"/}什么是空安全时至今日，空安全已经是一个屡见不鲜的话题，目前像主流的编程语言Kotlin、Swift、Rust 等都对空安全有自己的支持。Dart从2.12版本开始支持了空安全，通过空安全开发人员可以有效避免null错误崩溃。空安全性可以说是Dart语言的重要补充，它通过区分可空类型和非可空类型进一步增强了类型系统。引入空安全的好处可以将原本运行时的空值引用错误将变为编辑时的分析错误；增强程序的健壮性，有效避免由Null而导致的崩溃；跟随Dart和Flutter的发展趋势，为程序的后续迭代不留坑；空安全最小必备知识空安全的原则引入空安全前后Dart类型系统的变化可空（?）类型的使用延迟初始化（late）的使用空值断言操作符（!）的使用空安全的原则Dart 的空安全支持基于以下三条核心原则：默认不可空：除非您将变量显式声明为可空，否则它一定是非空的类型；渐进迁移：您可以自由地选择何时进行迁移，多少代码会进行迁移；完全可靠：Dart 的空安全是非常可靠的，意味着编译期间包含了很多优化，如果类型系统推断出某个变量不为空，那么它 永远 不为空。当您将整个项目和其依赖完全迁移至空安全后，您会享有健全性带来的所有优势——更少的 BUG、更小的二进制文件以及更快的执行速度。引入空安全前后Dart类型系统的变化在引入空安全前Dart的类型系统是这样的： 这意味着在之前，所有的类型都可以为Null，也就是Nul类型被看作是所有类型的子类。在引入空安全之后： 可以看出，最大的变化是将Null类型独立出来了， 这意味着Null不在是其它类型的子类型，所以对于一个非Null类型的变量传递一个Null值时会报类型转换错误 。提示：在使用了空安全的Flutter或Dart项目中你会经常看到 ?.、!、late 的大量应用，那么他们分别是什么又改如何使用呢？请看下文的分析可空（?）类型的使用我们可以通过将 ? 跟在类型的后面来表示它后面的变量或参数可接受Null：class CommonModel { String? firstName; //可空的成员变量 int getNameLen(String? lastName /*可空的参数*/) { int firstLen = firstName?.length ?? 0; int lastLen = lastName?.length ?? 0; return firstLen + lastLen; } }对于可空的变量或参数在使用的时候需要通过Dart 的避空运算符 ?. 来进行访问，否则会抛出编译错误。当程序启用空安全后，类的成员变量默认是不可空的，所以对于一个非空的成员变量需要指定其初始化方式class CommonModel { List names=[];//定义时初始化 final List colors;//在构造方法中初始化 late List urls;//延时初始化 CommonModel(this.colors); ...延迟初始化（late）的使用对于无法在定义时进行初始化，并且又想避免使用 ?. ，那么延迟初始化可以帮到你。通过 late 修饰的变量，可以让开发者选择初始化的时机，并且在使用这个变量时可以不用 ?. 。 late List urls;//延时初始化 setUrls(List urls){ this.urls=urls; } int getUrlLen(){ return urls.length; }延时初始化虽然能为我们编码带来一定便利，但如果使用不当会带来空异常的问题，所以在使用的时候一定保证赋值和访问的顺序，切莫颠倒。扩展： 延迟初始化（late）使用范式在Flutter中State的 initState 方法中初始化的一些变量是比较适合使用late来进行延时初始化的，因为在Widget生命周期中 initState 方法是最先执行的，所以它里面初始化的变量通过 late 修饰后既能保障使用时的便利，又能防止空异常，下面就来看下具体的用法：class _SpeakPageState extends State<SpeakPage> with SingleTickerProviderStateMixin { String speakTips = '长按说话'; String speakResult = ''; late Animation<double> animation; late AnimationController controller; @override void initState() { controller = AnimationController( super.initState(); vsync: this, duration: Duration(milliseconds: 1000)); animation = CurvedAnimation(parent: controller, curve: Curves.easeIn) ..addStatusListener((status) { if (status == AnimationStatus.completed) { controller.reverse(); } else if (status == AnimationStatus.dismissed) { controller.forward(); } }); } ...空值断言操作符（!）的使用当我们排除变量或参数的可空的可能后，可以通过 ! 来告诉编译器这个可空的变量或参数不可空，这对我们进行方法传参或将可空参数传递给一个不可空的入参时特别有用： Widget get _listView { return ListView( children: <Widget>[ _banner, Padding( padding: EdgeInsets.fromLTRB(7, 4, 7, 4), child: LocalNav(localNavList: localNavList), ), if (gridNavModel != null) Padding( padding: EdgeInsets.fromLTRB(7, 0, 7, 4), child: GridNav(gridNavModel: gridNavModel!)), Padding( padding: EdgeInsets.fromLTRB(7, 0, 7, 4), child: SubNav(subNavList: subNavList)), if (salesBoxModel != null) Padding( padding: EdgeInsets.fromLTRB(7, 0, 7, 4), child: SalesBox(salesBox: salesBoxModel!)), ], ); }上述代码是根据gridNavModel与salesBoxModel模块数据是否为空时动态创建的列表，在确保变量不为空的情况下使用了空值断言操作符!。除此之外， ! 还有一个常见的用处：bool isEmptyList(Object object) { if (object is! List) return false; return object.isEmpty; }用在这里表示取反，上述代码等价于：bool isEmptyList(Object object) { if (!(object is List)) return false; return object.isEmpty; }

SpringBoot手动控制启动定时任务 在SpringBoot中启动定时任务只需要添加注解 @EnableScheduling 即可搞定，package cn.org.kcis; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.scheduling.annotation.EnableScheduling; @SpringBootApplication @EnableScheduling public class StartApplication { public static void main(String[] args) { SpringApplication.run(StartApplication.class, args); } } 然后再Job类上面添加 @Component 和 @Scheduled在任务的类上写@Component在任务方法上写@Scheduledpackage cn.org.kcis.xian.task; import cn.org.kcis.xian.controller.IndexController; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.springframework.stereotype.Component; import org.springframework.scheduling.annotation.Scheduled; /** * @Author : BaiKeyang * @Date : Created in 2020/7/16 11:27 * @Description: * @Modified By: * @Version: $ */ @Component public class ScheduledService { private static final Logger log = LogManager.getLogger(IndexController.class); // 表示每隔1小时执行 @Scheduled(cron = "0 0 */1 * * ?") public void test1(){ log.error("=====>>>>>test1 {}",System.currentTimeMillis()); } // 表示每隔3分钟执行 @Scheduled(cron = "0 */3 * * * ?") public void test2(){ log.error("=====>>>>>test2 {}",System.currentTimeMillis()); } // 表示每天15分、45分 执行 @Scheduled(cron = "0 15/30 * * * ?") public void test3(){ log.error("=====>>>>>test3 {}",System.currentTimeMillis()); } // 每天的上午8点到20点执行 @Scheduled(cron = "0 0 8-20 * * ?") public void test6(){ log.error("=====>>>>>test6 {}",System.currentTimeMillis()); } // 表示每天8点30分执行 @Scheduled(cron = "0 0,30 0,8 ? * ? ") public void test7() { log.error("=====>>>>>test7 {}",System.currentTimeMillis()); } // 表示每天凌晨1点执行 @Scheduled(cron = "0 0 1 * * ?") public void test8() { log.error("=====>>>>>test8 {}",System.currentTimeMillis()); } // 表示每隔3秒 @Scheduled(fixedRate = 3000) public void test4() { log.info("=====>>>>>test4{}", System.currentTimeMillis()); } // 表示方法执行完成后5秒 @Scheduled(fixedDelay = 5000) public void test5() { log.info("=====>>>>>test5{}",System.currentTimeMillis()); } } 启动项目后，注解的方法都会根据配置的cron表达式、fixedDelay和fixedRate 参数值去开始运行。如果需要手动的去启动定时任务，再在上面定义实现了ThreadPoolTaskScheduler的实例：package cn.org.kcis; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; @SpringBootApplication @EnableScheduling public class StartApplication { public static void main(String[] args) { SpringApplication.run(StartApplication.class, args); } @Bean public ThreadPoolTaskScheduler threadPoolTaskScheduler () { return new ThreadPoolTaskScheduler(); } } 创建任务类，注入 ThreadPoolTaskScheduler ，通过 threadPoolTaskScheduler.schedule() 来创建、启动定时任务，并将任务保存，以便于下次关闭；package cn.org.kcis.xian.task; import cn.hutool.core.util.StrUtil; import cn.org.kcis.xian.controller.IndexController; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; import org.springframework.scheduling.support.CronTrigger; import org.springframework.stereotype.Component; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ScheduledFuture; /** * @Author : BaiKeyang * @Date : Created in 2020/7/16 11:27 * @Description: * @Modified By: * @Version: $ */ @Component public class ScheduledService { private static final Logger log = LogManager.getLogger(IndexController.class); @Autowired ThreadPoolTaskScheduler threadPoolTaskScheduler; Map<String, ScheduledFuture<?>> futureMap; public void start (String key) { if(StrUtil.isNotEmpty(key)) { if(futureMap == null){ futureMap = new HashMap<>(); } if("test".equals(key)) { ScheduledFuture<?> future1 = threadPoolTaskScheduler.schedule(new myTask1(), new CronTrigger("0/1 * * * * ?")); futureMap.put("task1", future1); } else if("server".equals(key)) { ScheduledFuture<?> future2 = threadPoolTaskScheduler.schedule(new myTask2(), new CronTrigger("0 */3 * * * ?")); futureMap.put("task2", future2); } else if("ps".equals(key)) { ScheduledFuture<?> future2 = threadPoolTaskScheduler.schedule(new myTask3(), new CronTrigger("0 */1 * * * ?")); futureMap.put("task3", future2); } } } // 关闭指定的定时任务 public String stop (String key) { if(futureMap != null && StrUtil.isNotEmpty(key) && futureMap.get(key) != null) { futureMap.get(key).cancel(true); } System.out.println("定时任务已关闭"); return "定时任务已关闭"; } private class myTask1 implements Runnable { @Override public void run() { System.out.println("test" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); } } private class myTask2 implements Runnable { @Override public void run() { log.error("=====>>>>>服务可用性扫描 {}",System.currentTimeMillis()); } } private class myTask3 implements Runnable { @Override public void run() { log.error("=====>>>>>数据同步 {}",System.currentTimeMillis()); } } } 在外部通过Controller调用来实现手动开启/关闭某个任务的操作：package cn.org.kcis.xian.controller; import cn.org.kcis.xian.task.ScheduledService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @Author : BaiKeyang * @Date : Created in 2020/2/4 17:37 * @Description: * @Modified By: * @Version: $ */ @RestController(value = "demoController") public class HelloController { @Autowired ScheduledService scheduledService; @RequestMapping(value = "/run") public String run(String key) { scheduledService.start(key); return "定时任务已启动"; } @RequestMapping(value = "/stop") public String stop(String key) { scheduledService.stop(key); return "定时任务已关闭"; } } 通过上面的方式，这样就实现了SpringBoot中手动控制定时任务的效果了。

Flutter 音频播放 在Flutter中目前使用比较多的音频插件就是audioplayers啦。 插件地址：audioplayers 在项目的pubspec.yaml中引入audioplayers插件：dependencies: flutter: sdk: flutter ...... # 引入audioplayers插件:当前官方最新版本为0.20.1 audioplayers: ^0.20.1初始化AudioPlayer ：AudioPlayer player = new AudioPlayer ();开始播放 ：开始播放音频player.play('http://image.bkybk.com/bg.m4a');暂停播放 ：音频播放对象在播放状态才能暂停，在其它状态调用此方法无任何作用player.pause();继续播放 ：音频播放对象在暂停状态才能恢复播放，在其它状态调用此方法无任何作用。player.resume();停止播放 ：停止播放音频，音频播放对象在播放或暂停状态才能停止播放，在其它状态调用此方法无任何作用。停止播放后如果需要继续播放，则需调用play方法重新开始播放。// 方法1 player.stop(); // 方法2 player.setReleaseMode(ReleaseMode.STOP); player.release();指定播放位置 ：跳到指定位置播放音频// 从音频的 96 秒开始播放 player.seek(new Duration(milliseconds: 96000))设置音量 ：设置播放音量的大小// 设置音量 30 player.setVolume(0.3)上面是关于AudioPlayer在项目中常用的声明、方法和配置，下面是关于AudioPlayer插件的具体使用：// 引入包 import 'package:audioplayers/audioplayers.dart'; import 'package:flutter/material.dart'; class AudioPage extends StatefulWidget { @override _AudioPageState createState() => _AudioPageState(); } class _AudioPageState extends State<AudioPage> { String totalTime = ''; String goTime = ''; String playState = ''; double _sliderValue = 30; bool isPlay = false; // 音频列表 List _playList = [ 'http://bkybk.com/static/data/bg.mp3', 'http://image.bkybk.com/bg.m4a' ]; // 初始化AudioPlayer AudioPlayer advancedPlayer = AudioPlayer(); @override void initState() { // TODO: implement initState print('------------initState---------------'); super.initState(); advancedPlayer.onDurationChanged.listen((Duration d) { setState(() { totalTime = d.toString(); playState = '正在播放'; }); }); advancedPlayer.onPlayerCompletion.listen((event) { setState(() { playState = '播放已完成'; }); }); advancedPlayer.onAudioPositionChanged.listen((p) async { // p参数可以获取当前进度，也是可以调整的，比如p.inMilliseconds setState(() { goTime = p.toString(); }); }); // 代码中引发意外错误时调用此函数。 advancedPlayer.onPlayerError.listen((msg) { print('audioPlayer error : $msg'); // setState(() { // playerState = PlayerState.stopped; // duration = Duration(seconds: 0); // position = Duration(seconds: 0); // }); }); } /// 当依赖的State对象改变时会调用 /// a 在第一次构建widget时，在initState()之后立即调用此方法 /// b 如果StatefulWidget依赖于InheritedWidget，那么当 当前的State所依赖InheritedWidget中的变量改变时会再次调用它 /// 拓展：InheritedWidget可以高效的将数据在Widget树中向下传递、共享； @override void didChangeDependencies() { print('--------------didChangeDependencies--------------'); super.didChangeDependencies(); } @override void dispose() { // TODO: implement dispose super.dispose(); advancedPlayer.stop(); advancedPlayer.dispose(); } @override Widget build(BuildContext context) { String? localFilePath; String? localAudioCacheURI; return new Scaffold( appBar: AppBar( title: Text('Audio 组件演示'), leading: GestureDetector( onTap: () { Navigator.pop(context); }, child: Icon(Icons.arrow_back), ), ), body: Container( child: Column( mainAxisAlignment: MainAxisAlignment.center, children: [ Expanded( child: ListView( children: [ ElevatedButton( onPressed: () => play(advancedPlayer, 0), child: Text('播放音乐1')), ElevatedButton( onPressed: () => play(advancedPlayer, 1), child: Text('播放音乐2')), ElevatedButton( onPressed: () => pause(advancedPlayer), child: Text('暂停')), ElevatedButton( onPressed: () => stop(advancedPlayer), child: Text('停止')), ElevatedButton( onPressed: () => skip(advancedPlayer, 96300), child: Text('从96秒播放')), ElevatedButton( onPressed: () => resume(advancedPlayer), child: Text('继续播放')), Text('音频总长：$totalTime'), Text('当前播放：$goTime'), Text('播放状态：$playState'), Text('调整音量：'), Slider( min: 0, max: 100, value: _sliderValue, onChanged: (v) { setState(() { _sliderValue = v; }); setVolume(advancedPlayer, v); }, ), ElevatedButton( onPressed: () { countFunction(advancedPlayer); }, child: Text('其他常用(控制台输出)')) ], ), ) ], ), ), ); } countFunction(AudioPlayer audioPlayer) { setState(() { _count++; }); // 获取当前播放状态 PlayerState ps = audioPlayer.state; print(ps); // 判断目标是否为本地资源 bool isLocal = audioPlayer.isLocalUrl("http://image.bkybk.com/bg.m4a"); print(isLocal); // 设置音量 audioPlayer.setVolume(0.23); } /** * 设置音量 */ setVolume(AudioPlayer audioPlayer, double value) { audioPlayer.setVolume(value / 100); } /** * 开始播放音频 */ play(AudioPlayer audioPlayer, int index) async { if (isPlay) { // 当音乐正在播放时，先停止当前播放； int stopResult = await audioPlayer.stop(); if (stopResult == 1) { isPlay = false; int playResult = await audioPlayer.play(_playList[index], volume: 0.3); if (playResult == 1) { // success print('play success'); setState(() { isPlay = true; playState = '正在加载资源......'; }); } else { print('play failed'); } } } else { int playResult = await audioPlayer.play(_playList[index], volume: 0.3); if (playResult == 1) { // success print('play success'); setState(() { isPlay = true; playState = '正在加载资源......'; }); } else { print('play failed'); } } } /** * 暂停播放音频 */ pause(AudioPlayer audioPlayer) async { // 音频播放对象在播放状态才能暂停，在其它状态调用此方法无任何作用 int result = await audioPlayer.pause(); if (result == 1) { // success print('pause success'); setState(() { isPlay = false; playState = '播放暂停'; }); } else { print('pause failed'); } } /** * 停止播放音频 */ stop(AudioPlayer audioPlayer) async { // 停止播放音频，音频播放对象在播放或暂停状态才能停止播放，在其它状态调用此方法无任何作用。 // 停止播放后如果需要继续播放，则需调用play方法重新开始播放。 // 停止播放的方法一： int stopResult = await audioPlayer.stop(); // 停止播放的方法二： // audioPlayer.setReleaseMode(ReleaseMode.STOP); // int stopResult = await audioPlayer.release(); if (stopResult == 1) { setState(() { isPlay = false; playState = '播放停止'; }); } else { print('release failed'); } super.deactivate(); } /** * 跳到指定位置播放音频 */ skip(AudioPlayer audioPlayer, int startMilliseconds) async { // 跳到指定位置播放音频，音频播放对象在播放或暂停状态才能跳到指定播放音频，在其它状态调用此方法无任何作用。 int result = await audioPlayer.seek(new Duration(milliseconds: startMilliseconds)); if (result == 1) { print('go to success'); // await audioPlayer.resume(); } else { print('go to failed'); } } /** * 恢复播放音频 */ resume(AudioPlayer audioPlayer) async { // 音频播放对象在暂停状态才能恢复播放，在其它状态调用此方法无任何作用。 int result = await audioPlayer.resume(); if (result == 1) { print('resume success'); // await audioPlayer.resume(); } else { print('resume failed'); } } } 代码的实际运行效果：

Eclipse 安装lombok插件的方法 从 官网下载lombok.jar双击下载的lombok.jar： 选择Eclipse: 勾选Eclipse，点击 【安装/更新】 按钮: 安装完成： 安装完成后，在Eclipse的目录中会出现安装好的lombok.jar，打开eclipse.ini： 在eclipse.ini的后面追加 -javaagent:盘符:\Eclipse安装目录\lombok.jar 内容，例如-javaagent:E:\Soft\Eclipse\lombok.jar： 在eclipse.ini中追加完成后保存文件，重启Eclipse。如过安装成功但是@Data等注解无效，项目仍旧报错的话，清理项目 project–>clean 勾选项目，点击

Spring Boot处理Multipart文件上传 Spring Boot采用Servlet 3 javax.servlet.http.Part API来支持文件上传。默认情况下，Spring Boot配置Spring MVC在单个请求中只处理每个文件最大1Mb，最多10Mb的文件数据。你可以覆盖那些值，也可以设置临时文件存储的位置（比如，存储到/tmp文件夹下）及传递数据刷新到磁盘的阀值（通过使用MultipartProperties类暴露的属性）。如果你需要设置文件不受限制，可以设置spring.http.multipart.max-file-size属性值为-1。当你想要接收multipart编码文件数据作为Spring MVC控制器（controller）处理方法中被@RequestParam注解的MultipartFile类型的参数时，multipart支持就非常有用了。更多详情可参考MultipartAutoConfiguration：// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // package org.springframework.boot.autoconfigure.web.servlet; import javax.servlet.MultipartConfigElement; import javax.servlet.Servlet; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication; import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication.Type; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.multipart.MultipartResolver; import org.springframework.web.multipart.commons.CommonsMultipartResolver; import org.springframework.web.multipart.support.StandardServletMultipartResolver; @Configuration @ConditionalOnClass({Servlet.class, StandardServletMultipartResolver.class, MultipartConfigElement.class}) @ConditionalOnProperty( prefix = "spring.servlet.multipart", name = {"enabled"}, matchIfMissing = true ) @ConditionalOnWebApplication( type = Type.SERVLET ) @EnableConfigurationProperties({MultipartProperties.class}) public class MultipartAutoConfiguration { private final MultipartProperties multipartProperties; public MultipartAutoConfiguration(MultipartProperties multipartProperties) { this.multipartProperties = multipartProperties; } @Bean @ConditionalOnMissingBean({MultipartConfigElement.class, CommonsMultipartResolver.class}) public MultipartConfigElement multipartConfigElement() { return this.multipartProperties.createMultipartConfig(); } @Bean( name = {"multipartResolver"} ) @ConditionalOnMissingBean({MultipartResolver.class}) public StandardServletMultipartResolver multipartResolver() { StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver(); multipartResolver.setResolveLazily(this.multipartProperties.isResolveLazily()); return multipartResolver; } }其中，MultipartProperties中可以看到Spring MVC的默认单个请求中只处理每个文件最大1Mb，最多10Mb的文件数据// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // package org.springframework.boot.autoconfigure.web.servlet; import javax.servlet.MultipartConfigElement; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.web.servlet.MultipartConfigFactory; import org.springframework.util.StringUtils; @ConfigurationProperties( prefix = "spring.servlet.multipart", ignoreUnknownFields = false ) public class MultipartProperties { private boolean enabled = true; private String location; private String maxFileSize = "1MB"; private String maxRequestSize = "10MB"; private String fileSizeThreshold = "0"; private boolean resolveLazily = false; public MultipartProperties() { } public boolean getEnabled() { return this.enabled; } public void setEnabled(boolean enabled) { this.enabled = enabled; } public String getLocation() { return this.location; } public void setLocation(String location) { this.location = location; } public String getMaxFileSize() { return this.maxFileSize; } public void setMaxFileSize(String maxFileSize) { this.maxFileSize = maxFileSize; } public String getMaxRequestSize() { return this.maxRequestSize; } public void setMaxRequestSize(String maxRequestSize) { this.maxRequestSize = maxRequestSize; } public String getFileSizeThreshold() { return this.fileSizeThreshold; } public void setFileSizeThreshold(String fileSizeThreshold) { this.fileSizeThreshold = fileSizeThreshold; } public boolean isResolveLazily() { return this.resolveLazily; } public void setResolveLazily(boolean resolveLazily) { this.resolveLazily = resolveLazily; } public MultipartConfigElement createMultipartConfig() { MultipartConfigFactory factory = new MultipartConfigFactory(); if (StringUtils.hasText(this.fileSizeThreshold)) { factory.setFileSizeThreshold(this.fileSizeThreshold); } if (StringUtils.hasText(this.location)) { factory.setLocation(this.location); } if (StringUtils.hasText(this.maxRequestSize)) { factory.setMaxRequestSize(this.maxRequestSize); } if (StringUtils.hasText(this.maxFileSize)) { factory.setMaxFileSize(this.maxFileSize); } return factory.createMultipartConfig(); } }

Flutter页面生命周期理解与分析 在Flutter的页面生命周期，着重分析StatefulWidget这个组件。因为无状态的组件StatelessWidget只有createElement 与 build两个生命周期方法，相对比较好理解，这里就不在赘述了。StatefulWidget的生命周期方法按照时期顺序不同，可以分为三组，分别为：初始化时期、更新时期、销毁时期1. 初始化时期的方法 createState：当我们构建一个新的StatefulWidget时，这个会立即调用；并且这个方法必须被覆盖 initState：这是创建Widget时调用的除构造方法外的第一个方法； 类似于Android的：onCreate() 与 IOS 的 viewDidLoad();在这个方法中通常会做一些初始化，比如channel的初始化，监听器的初始化等2. 更新时期的方法 didChangeDependencies：当依赖的State对象改变时会调用。在第一次构建widget时，在initState()之后立即调用此方法；如果StatefulWidget依赖于InheritedWidget，那么当当前的State所依赖InheritedWidget中的变量改变时会再次调用它拓展：InheritedWidget可以高效的将数据在Widget树中向下传递、共享；build：每个State都需要实现的一个方法，这是一个必须实现的方法，在这里实现你要呈现的页面内容，它会在didChangeDependencies()之后立即调用。另外当调用setState后也会再次调用该方法。didUpdateWidget：这是一个不常用到的生命周期方法，当父组件需要重新绘制时才会调用；该方法会携带一个oldWidget参数，可以将与当前的Widget进行对比以便执行一些额外的逻辑，如if(oldWidget.xxx != widget.xxx) {...}3. 销毁时期的方法 deactivate：很少使用，在组件被移除的时候调用dispose之前调用 dispose：通常，组件被销毁时调用。通常在方法中执行一些资源的释放工作，比如监听器的卸载、channel的销毁等下面是关于Flutter生命周期的一个具体的代码理解，我在每个方法上面也做了注释，方便理解学习：import 'package:flutter/material.dart'; /// Flutter Widget的生命周期重点讲解StatefulWidget的生命周期 /// 因为无状态的widget StatelessWidget只有createElement 与 build两个生命周期方法 /// StatefulWidget的生命周期方法按照时期不同可以分为三组： /// 1、初始化时期 /// createState、initState /// 2、更新时期 /// didChangeDependencies、build、didUpdateWidget /// 3、销毁期 /// deactivate、dispose class WidgetLifecycle extends StatefulWidget { // 当我们构建一个新的StatefulWidget时，这个会立即调用 // 并且这个方法必须被覆盖 @override _WidgetLifecycleState createState() => _WidgetLifecycleState(); } class _WidgetLifecycleState extends State<WidgetLifecycle> { int _count = 0; /// 这是创建Widget时调用的除构造方法外的第一个方法 /// 类似于Android的：onCreate() 与 IOS 的 viewDidLoad(); /// 在这个方法中通常会做一些初始化，比如channel的初始化，监听器的初始化等 @override void initState() { // TODO: implement initState print('------------initState---------------'); super.initState(); } /// 当依赖的State对象改变时会调用 /// a 在第一次构建widget时，在initState()之后立即调用此方法 /// b 如果StatefulWidget依赖于InheritedWidget，那么当 当前的State所依赖InheritedWidget中的变量改变时会再次调用它 /// 拓展：InheritedWidget可以高效的将数据在Widget树中向下传递、共享； @override void didChangeDependencies() { print('--------------didChangeDependencies--------------'); super.didChangeDependencies(); } /// 每个State都需要实现的一个方法 /// 这是一个必须实现的方法，在这里实现你要呈现的页面内容 /// 它会在didChangeDependencies()之后立即调用 /// 另外当调用setState后也会再次调用该方法 @override Widget build(BuildContext context) { print('--------------build-------------'); return Scaffold( appBar: AppBar( title: Text('Flutter页面生命周期'), leading: GestureDetector( onTap: () { Navigator.pop(context); }, child: Icon(Icons.arrow_back), ), ), body: Center( child: Column( children: [ ElevatedButton( onPressed: () { setState(() { _count++; }); }, child: Text( '点我', style: TextStyle(fontSize: 26), )), Text('$_count') ], ), ), ); } /// 这是一个不常用到的生命周期方法，当父组件需要重新绘制时才会调用； /// 该方法会携带一个oldWidget参数，可以将与当前的Widget进行对比以便执行一些额外的逻辑，如 /// if(oldWidget.xxx != widget.xxx) {...} @override void didUpdateWidget(covariant WidgetLifecycle oldWidget) { print('--------------didUpdateWidget--------------'); super.didUpdateWidget(oldWidget); } /// 很少使用，在组件被移除的时候调用dispose之前调用 @override void deactivate() { print('-------------deactivate--------------'); super.deactivate(); } /// 通常，组件被销毁时调用 /// 通常在方法中执行一些资源的释放工作，比如监听器的卸载、channel的销毁等 @override void dispose() { print('------------dispose-------------'); super.dispose(); } }

SpringBoot在配置文件中使用随机数 在一些特殊的情况下，我们需要有些参数每次被加载时不是一个固定的值，比如密钥、服务端口等。在Spring Boot的属性配置文件中，可以通过使用${random}配置来产生随机的int值、long值 或 String字符串，这样我们就可以很容易的通过配置随机生成属性，而不是在程序中通过编码来实现这些逻辑啦。${random}的配置方式主要有以下几种：#随机字符串 com.baikeyang.blog.value=${random.value} #随机int com.baikeyang.blog.number=${random.int} #随机long com.baikeyang.blog.bignubmer=${random.long} #10以内的随机数 com.baikeyang.blog.test1=${random.int(10)} #10~20的随机数 com.baikeyang.blog.test2=${random.int[10,20]}