前言

假设你想获取当前时间，那么你肯定看过这样的代码

public static void main(String[] args) {



    Date date = new Date(System.currentTimeMillis());

    System.out.println(date.getYear());

    System.out.println(date.getMonth());

    System.out.println(date.getDate());

}

获取年份，获取月份，获取..日期？
运行一下

121

9

27

怎么回事？获取年份，日期怎么都不对,点开源码发现

/**

 * Returns a value that is the result of subtracting 1900 from the

 * year that contains or begins with the instant in time represented

 * by this <code>Date</code> object, as interpreted in the local

 * time zone.

 *

 * @return  the year represented by this date, minus 1900.

 * @see     java.util.Calendar

 * @deprecated As of JDK version 1.1,

 * replaced by <code>Calendar.get(Calendar.YEAR) - 1900</code>.

 */

@Deprecated

public int getYear() {

    return normalize().getYear() - 1900;

}

原来是某个对象值 减去了 1900，注释也表示，返回值减去了1900，难道我们每次获取年份需要在 加上1900？注释也说明了让我们 用Calendar.get()替换，并且该方法已经被废弃了。点开getMonth()也是一样,返回了一个0到11的值。getDate()获取日期？不应该是getDay()吗？老外的day都是sunday、monday,getDate()才是获取日期。再注意到这些api都是在1.1的时候被废弃了，私以为是为了消除getYear减去1900等这些歧义。收~

Calendar 日历类

public static void main(String[] args) {



    Calendar calendar =  Calendar.getInstance();

    int year = calendar.get(Calendar.YEAR);

    int month = calendar.get(Calendar.MONTH);

    int dom = calendar.get(Calendar.DAY_OF_MONTH);

    int doy = calendar.get(Calendar.DAY_OF_YEAR);

    int dow = calendar.get(Calendar.DAY_OF_WEEK);

    int dowim = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);

    System.out.println(year+"年"+ month+"月");

    System.out.println(dom+"日");

    System.out.println(doy+"日");

    System.out.println(dow+"日");

    System.out.println(dowim);

}

打印(运行时间2021年10月27日 星期三 晴)

2021年9月

27日

300日

4日

4

问：月份怎么是上个月的？
答：是为了计算方便，月是0到11之间的值。
问：计算方便？
答：比如月份从1月开始，增加一个月，12月+1=13,没有13月。假设取余，(12+1)=1 正好为1月，那11月增加一个月，(11+1)=0,这就有问题了。所以为了计算方便1月，返回了0值。date.getMonth()也是一个道理。 问：那下面的DAY_OF_XXX 又是什么意思？
答：猜！根据结果猜。
Calendar.DAY_OF_MONTH 在这个月 的这一天
Calendar.DAY_OF_YEAR 在这一年 的这一天
Calendar.DAY_OF_WEEK 在这一周 的这一天
Calendar.DAY_OF_WEEK_IN_MONTH 在这一个月 这一天在 第几周
到这里 Calendar.DAY_OF_WEEK 为什么是 4 ，你肯定也猜到了
Calendar.HOUR
Calendar.HOUR_OF_DAY
Calendar.SECOND
...其他的 你肯定也会用了

LocalDate 本地日期类

LocalDate localDate = LocalDate.now();

System.out.println("当前日期："+localDate.getYear()+" 年 "+localDate.getMonthValue()+" 月 "+localDate.getDayOfMonth()+"日" );



//结果

当前日期：2021 年 10 月 27日

也可以通过 LocalDate.of(年，月，日)去构造

LocalDate pluslocalDate = localDate.plusDays(1);//增加一天

LocalDate pluslocalDate = localDate.plusYears(1);//增加一年

其他api

LocalDate.isBefore(LocalDate);

LocalDate.isAfter();

LocalDate.isEqual();

也就是对两个日期的判断，是在前、在后、或者相等。

LocalTime 本地时间类

LocalTime localTime = LocalTime.now();

System.out.println("当前时间："+localTime.getHour()+"h "+localTime.getSecond()+"m "+localTime.getMinute()+"s" );

LocalDate和LocalTime 都有类似作用的api
LocalDate.plusDays(1) 增加一天
LocalTime.plusHours(1) 增加一小时 等等~
其他api

LocalTime.isBefore(LocalTime);

LocalTime.isAfter();

对两个时间的判断。肯定碰到过一个需求，今天离活动开始时间还剩多少天。

LocalDateTime 本地日期时间类

public final class LocalDateTime ...{

    

    private final LocalDate date;



    private final LocalTime time;

}

LocalDateTime = LocalDate + LocalTime 懂的都懂

Instant 类

Instant 是瞬间，某一时刻的意思

Instant.ofEpochMilli(System.currentTimeMillis())

Instant.now()

通过Instant可以创建一个 “瞬间” 对象，ofEpochMilli()可以接受某一个“瞬间”，比如当前时间，或者是过去、将来的一个时间。
比如，通过一个“瞬间”创建一个LocalDateTime对象

LocalDateTime now = LocalDateTime.ofInstant(

    Instant.ofEpochMilli(System.currentTimeMillis()),ZoneId.systemDefault());



System.out.println("当前日期："+now.getYear()+" 年 "+now.getMonthValue()+" 月 "+now.getDayOfMonth()+"日" )

Period 类

Period 是 时期，一段时间 的意思
Period有个between方法专门比较两个 日期 的

LocalDate startDate = LocalDateTime.ofInstant(

    Instant.ofEpochMilli(1601175465000L), ZoneId.systemDefault()).toLocalDate();//1601175465000是2020-9-27 10:57:45

Period p  =  Period.between(startDate,  LocalDate.now());



System.out.println("目标日期距离今天的时间差："+p.getYears()+" 年 "+p.getMonths()+" 个月 "+p.getDays()+" 天" );



//目标日期距离今天的时间差：1 年 1 个月 1 天

看一眼源码

public static Period between(LocalDate startDateInclusive, LocalDate endDateExclusive) {

    return startDateInclusive.until(endDateExclusive);

}



public Period until(ChronoLocalDate endDateExclusive) {

    LocalDate end = LocalDate.from(endDateExclusive);

    long totalMonths = end.getProlepticMonth() - this.getProlepticMonth();  // safe

    int days = end.day - this.day;

    if (totalMonths > 0 && days < 0) {

        totalMonths--;

        LocalDate calcDate = this.plusMonths(totalMonths);

        days = (int) (end.toEpochDay() - calcDate.toEpochDay());  // safe

    } else if (totalMonths < 0 && days > 0) {

        totalMonths++;

        days -= end.lengthOfMonth();

    }

    long years = totalMonths / 12;  // safe

    int months = (int) (totalMonths % 12);  // safe

    return Period.of(Math.toIntExact(years), months, days);

}

他只接受两个LocalDate对象，对时间的计算，算好之后返回Period对象

Duration 类

Duration 是 期间 持续时间 的意思 上代码

LocalDateTime end = LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis()), ZoneId.systemDefault());

LocalDateTime start = LocalDateTime.ofInstant(Instant.ofEpochMilli(1601175465000L), ZoneId.systemDefault());

Duration duration = Duration.between(start, end);



System.out.println("开始时间到结束时间，持续了"+duration.toDays()+"天");

System.out.println("开始时间到结束时间，持续了"+duration.toHours()+"小时");

System.out.println("开始时间到结束时间，持续了"+duration.toMillis()/1000+"秒");

可以看到between也接受两个参数，LocalDateTime对象，源码是对两个时间的计算，并返回对象。

对象转换

再贴点api

//long -> LocalDateTime

LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault())



//String -> LocalDateTime

DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

LocalDateTime.parse("2021-10-28 00:00:00", dateTimeFormatter1);



//LocalDateTime -> long

LocalDateTime对象.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();



//LocalDateTime -> String

DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

LocalDateTime对象.format(dateTimeFormatter1)

对象转换几乎都涵盖了，里面有个时区对象，这个一般用默认时区。

总结

用LocalDate、LocalTime、LocalDateTime代替了Date类。Date管日期，Time管时间
LocalDateTime = LocalDate + LocalTime
Period 只能用LocalDate
Duration 持续时间，所以LocalDate、LocalTime、LocalDateTime 都能处理
至于Calendar 日历类，这里面的api，都是针对日历的，比如这个月的第一天是星期几。
总体来说，都是api的使用，非常清晰，废弃date.getMonth()等，使用localDate.getMonthValue()来获取几月，更易理解，更易贴合使用。代码都贴在了github上了

Flutter 与原生之间的通信依赖灵活的消息传递方式

• 
  

  应用的Flutter部分通过平台通道（platform channel）将消息发送到其应用程序的所在的宿主（iOS或Android）应用（原生应用）

  
  


• 
  

  宿主监听平台通道，并接收该消息。然后它会调用该平台的 API，并将响应发送回客户端，即应用程序的 Flutter 部分

  
  

Flutter 与原生存在三种交互方式

• 
  

  MethodChannel：用于传递方法调用（method invocation）通常用来调用 native 中某个方法

  
  


• 
  

  BasicMessageChannel：用于传递字符串和半结构化的信息，这个用的比较少

  
  


• 
  

  EventChannel：用于数据流（event streams）的通信。有监听功能，比如电量变化之后直接推送数据给flutter端

  
  

三种 Channel 之间互相独立，各有用途，但它们在设计上却非常相近。每种 Channel 均有三个重要成员变量：

• 
  

  name: String类型，代表 Channel 的名字，也是其唯一标识符

  
  


• 
  

  messager：BinaryMessenger 类型，代表消息信使，是消息的发送与接收的工具

  
  


• 
  

  codec: MessageCodec 类型或 MethodCodec 类型，代表消息的编解码器

  
  

具体使用

• 首先分别创建 Native 工程和 Flutter Module。我这里是以 iOS 端和 Flutter 通信为例，创建完 iOS 工程后，需要通过 CocoaPods 管理 Flutter Module。

• 然后在 iOS 工程里面创建 Podfile ，然后引入 Flutter Module ，具体代码如下：

platform :ios,'11.0'

inhibit_all_warnings!



#flutter module 文件路径

flutter_application_path = '../flutter_module' 

load File.join(flutter_application_path, '.ios', 'Flutter', 'podhelper.rb')



target 'Native_iOS' do



install_all_flutter_pods(flutter_application_path)



end

注意： flutter_application_path 这个是 Flutter 工程的路径，我是原生项目和 Flutter在一个目录下

• 最后在终端 pod install 一下，看是否能正常引入 Flutter Module。这样就可以在iOS工程里面导入#import <Flutter/Flutter.h>

一、MethodChannel的使用

这里写的代码实现了以下功能

1.实现了点击原生页面的按钮跳转到 Flutter 页面，在 Flutter 点击返回按钮能正常返回原生页面

2.实现在Flutter页面点击当前电量，从原生界面传值到 Flutter 页面

原生端代码

@property (nonatomic, strong)FlutterEngine *flutterEngine;



@property (nonatomic, strong)FlutterViewController *flutterVC;



@property (nonatomic, strong)FlutterMethodChannel *methodChannel;



- (void)viewDidLoad {

    [super viewDidLoad];



    //隐藏了原生的导航栏

    self.navigationController.navigationBarHidden = YES;



    UIButton *btn = [[UIButton alloc] initWithFrame:CGRectMake(100, 100, 80, 80)];

    btn.backgroundColor = [UIColor redColor];

    [btn addTarget:self action: @selector(onBtnClick) forControlEvents:UIControlEventTouchUpInside];

    [self.view addSubview:btn];



    self.flutterVC = [[FlutterViewController alloc] initWithEngine:self.flutterEngine nibName:nil bundle:nil];

    //创建channel

    self.methodChannel = [FlutterMethodChannel methodChannelWithName:@"methodChannel" binaryMessenger:self.flutterVC.binaryMessenger];



}



- (void)onBtnClick {



    //告诉Flutter对应的页面

    //Method--方法名称，arguments--参数

    [self.methodChannel invokeMethod:@"EnterFlutter" arguments:@""];

    

    //push进入Flutter页面

    [self.navigationController pushViewController:self.flutterVC animated:YES];



    __weak __typeof(self) weakSelf = self;

    //监听Flutter发来的事件

    [self.methodChannel setMethodCallHandler:^(FlutterMethodCall * _Nonnull call, FlutterResult  _Nonnull result) {

        //响应从Flutter页面发送来的方法

        if ([call.method isEqualToString:@"exit"]) {

            [weakSelf.flutterVC.navigationController popViewControllerAnimated:YES];

        } else if ([call.method isEqualToString:@"getBatteryLevel"]) {

            //传值回Flutter页面

            [weakSelf.methodChannel invokeMethod:@"BatteryLevel" arguments:@"60%"];

        }

    }];

}



//创建引擎，真正在项目中，引擎可以定义为一个单例。这样处理防止在原生里面存在多引擎，是非常占有内存的

- (FlutterEngine *)flutterEngine {

    if (!_flutterEngine) {

        FlutterEngine * engine = [[FlutterEngine alloc] initWithName:@"flutterEngin"];

        if (engine.run) {

            _flutterEngine = engine;

        }

    }

    return _flutterEngine;

}

Flutter 端代码

class _MyHomePageState extends State<MyHomePage> {



  String batteryLevel = '0%';

  //定义通道

  final MethodChannel _methodhannel =

      const MethodChannel('com.pages.your/native_get');



  @override

  void initState() {

    super.initState();

    

     //Flutter端监听发送过来的数据

    _methodhannel.setMethodCallHandler((call) {

      if (call.method == 'EnterFlutter') {

        print(call.arguments);

      } else if (call.method == 'BatteryLevel') {

        batteryLevel = call.arguments;

      }

      setState(() {});

      return Future(() {});

    });

  }



  @override

  Widget build(BuildContext context) {

    return Scaffold(

      appBar: AppBar(

        title: Text(widget.title),

      ),

      body: Center(

        child: Column(

          children: [

            ElevatedButton(

              onPressed: () {

                //发送消息给原生

                _methodhannel.invokeListMethod('exit');

              },

              child: Text('返回'),

            ),

            ElevatedButton(

              onPressed: () {

              //发送消息给原生

                _oneChannel.invokeListMethod('getBatteryLevel');

              },

              child: Text('当前电量${batteryLevel}'),

            ),

          ],

        ),

      ),

    );

  }

}

二、BasicMessageChannel的使用

它是可以双端通信的，Flutter 端可以给 iOS 发送消息，iOS 也可以给 Flutter 发送消息。这段代码实现了在 Flutter 中的 TextField 输入文字，在 iOS 端能及时输出。

原生端代码

需要在上面代码的基础上增加 MessageChannel ，并接收消息和发送消息

@property (nonatomic, strong) FlutterBasicMessageChannel *messageChannel;



self.messageChannel = [FlutterBasicMessageChannel messageChannelWithName:@"messgaeChannel" binaryMessenger:self.flutterVC.binaryMessenger];



[self.messageChannel setMessageHandler:^(id _Nullable  message, FlutterReply  _Nonnull callback) {



        NSLog(@"收到Flutter的：%@",message);

    }];

Flutter 端代码

//需要创建和iOS端相同名称的通道

final messageChannel =

    const BasicMessageChannel("messgaeChannel", StandardMessageCodec());

监听消息

messageChannel.setMessageHandler((message) {

  print('收到来自iOS的$message');

  return Future(() {});

});

发送消息

messageChannel.send(str);

三、EventChannel的使用

只能是原生发送消息给 Flutter 端，例如监听手机电量变化，网络变化，传感器等。

我这里在原生端实现了一个定时器，每隔一秒发送一个消息给 Flutter 端，模仿这个功能。

原生端代码

记得所在的类要实现这个协议 FlutterStreamHandler

//定义属性

//通道

@property (nonatomic, strong) FlutterEventChannel *eventChannel;

//事件回调

@property (nonatomic, copy) FlutterEventSink events;

//用于计数

@property (nonatomic, assign) NSInteger count;



//初始化通道

self.eventChannel = [FlutterEventChannel eventChannelWithName:@"eventChannel" binaryMessenger:self.flutterVC.binaryMessenger];



[self.eventChannel setStreamHandler:self];



//调用创建定时器

[self createTimer];



//创建定时器

- (void)createTimer {



    NSTimer *timer = [NSTimer scheduledTimerWithTimeInterval:1 target:self selector: @selector(timeStart) userInfo:nil repeats:YES];

}



//发送消息

- (void)timeStart{



    self.count += 1;

    NSDictionary *dic = [NSDictionary dictionaryWithObject:@(self.count) forKey:@"count"];

    if (self.events != nil) {

        self.events(dic);

    }

}



//代表通道已经建好，原生端可以发送数据了

- (FlutterError* _Nullable)onListenWithArguments:(id _Nullable)arguments eventSink:(FlutterEventSink)eventSink {



    self.events = eventSink;

    return nil;

}



//代表Flutter端不再接收

- (FlutterError* _Nullable)onCancelWithArguments:(id _Nullable)arguments {



    self.events = nil;

    return nil;

}

Flutter 端代码

//创建通道

final EventChannel eventChannel = const EventChannel('eventChannel');



//开始监听数据

eventChannel.receiveBroadcastStream().listen((event) {

  print(event.toString());

});

以上就是iOS原生和Flutter通信的三种方式，消息传递是异步的，这确保了用户界面在消息传递时不会被挂起。

复制和粘贴这个功能，一般系统都自带，简单的按几个键就能完成。但是有时候我们想要自己在应用中集成这个功能，或者想在用户复制文字后不使用粘贴操作，就让复制的内容直接出现在我们的应用中。想要实现该功能，就可以用我今天介绍的几个插件。

screen_capturer

这个方法是用来截取屏幕的。本来想写一期介绍截屏插件的，但是找了一圈只找到这个适用于桌面端，只写这一个插件篇幅又太短，所以直接加了进来。

安装🛠

点击screen_capturer获取最新版本。以下是在编写本文章时的最新版本：

screen_capturer: ^0.1.0

使用🥟

该插件的主体是 ScreenCapturer.instance ，其下有3个方法：isAccessAllowed 、requestAccess 和 capture。

isAccessAllowed 和 requestAccess仅在 macOS中适用，分别用来检测和申请截图的权限。

await ScreenCapturer.instance.requestAccess();  // 申请权限

bool _isAllowed = await ScreenCapturer.instance.isAccessAllowed ();  // 检测是否拥有权限

我们截图的目的是把图片显示出来，所以在正式截图前先定义个图片路径的参数：

String _image;

接下来介绍截图的主要方法 capture，该方法可以传递2个参数：

• String? imagePath：该属性为必填，传递一个图片保存的路径和名称


• bool silent：设置是否开启截屏的提示音

String _imageName = '${DateTime.now().millisecondsSinceEpoch}.png';  // 设置图片名称

String _imagePath = 'C:\\Users\\ilgnefz\\Pictures\\$_imageName';  // 设置图片保存的路径

CapturedData? _capturedData = await ScreenCapturer.instance.capture(imagePath: _imagePath);

if (_capturedData != null) {

  _image = _capturedData.imagePath;

  setState(() {});

} else {

  BotToast.showText(text: '截图被取消了');

}

通过运行可以发现，这里调用的其实是系统的截图功能，然后将截取的图片进行了保存。和windows自带的截图又有些差别，自带的只会将截图保存到剪切板中。

screen_text_extractor

安装🛠

点击screen_text_extractor获取最新版本。以下是在编写本文章时的最新版本：

screen_text_extractor: ^0.1.0

使用🥟

该插件的主体是 ScreenTextExtractor.instance ，其下有7个方法：

1. isAccessAllowed：检测是否有进行相关操作的权限，仅macOS


2. requestAccess：申请进行相关操作的权限，仅macOS


3. extractFromClipboard：从剪切板提取内容


4. extractFromScreenSelection：从选择的屏幕提取


5. simulateCtrlCKeyPress：模拟 Ctrl + c ，返回一个布尔值

前面4个仅macOS使用的方法和screen_capturer一样，这里就不多赘述。后面3个方法将会返回一个 Future 的 ExtractedData 对象。

我们先定义一个String对象用来显示获取到的内容：

String _text = '获取的内容将会在这里🤪';

获取剪切板内容

ExtractedData data = await ScreenTextExtractor.instance.extractFromClipboard();

_text = data.text;

setState((){});

我们先在 windows 中按 windows键 + v 来调出剪切板，清空

使用该方法看一下：

我们将会得到一个空白的内容。为了更好的用户体验，我们可以添加个条件。

if (data.text!.isEmpty) {

  BotToast.showText(text: '剪切板什么都没有🤨');

} else {

  _text = data.text!;

  setState(() {});

}

我们现在复制一段内容：

然后看看效果：

获取成功😀，但是剪切板除了能存储文本，还是能存储图片的。

但是ExtractedData只有个text属性，我们来看下会发生什么：

直接为空了😶

获取选区内容

ExtractedData data = await ScreenTextExtractor.instance.extractFromScreenSelection(

  useAccessibilityAPIFirst: false, // 使用辅助功能API，仅macOS

);

if (data.text!.isEmpty) {

  BotToast.showText(text: '剪切板什么都没有🤨');

} else {

  _text = data.text!;

  setState(() {});

}

👻该方法如果是在windows端，返回的就是extractFromClipboard()方法的结果，在macOS端和Linux端暂时无法演示😪

pasteboard

安装🛠

点击pasteboard获取最新版本。以下是在编写本文章时的最新版本：

pasteboard: ^0.0.2

使用🥟

该插件中的 Pasteboard 对象一共拥有4个方法：

• image：复制图片


• file：复制文件/文本


• writeImage：粘贴图片


• writeFile：粘贴文件/文本

复制粘贴文本

当然，第一步先定义一个用来存储结果的变量：

String _text = '还没粘贴任何内容';

定义一个文本控制器，用来获取输入的内容：

final TextEditingController _controller = TextEditingController();

接下来使用 pasteboard 来实现复制和粘贴的功能：

• 
  

  复制文本

  
  

  void _copyText() async {
  
    if (_controller.text.isEmpty) {
  
      BotToast.showText(text: '啥都没输入，你要我复制什么🥴');
  
    } else {
  
      final lines = const LineSplitter().convert(_controller.text);
  
      await Pasteboard.writeFiles(lines);
  
    }
  
  }
  

  
  


• 
  

  粘贴文本

  
  

  void _pastText() async {
  
    final results = await Pasteboard.files();
  
    if (results.isNotEmpty) {
  
      _text = result.toString();
  
      setState(() {});
  
    } else {
  
      BotToast.showText(text: '我什么都不能给你，因为我也咩有😭');
  
    }
  
  }
  

  
  

我们先来试一下，不用复制直接直接粘贴会发生什么。此时我的剪切板有一条内容：

来看看效果：

我们可以发现，它并不能读取我们剪切板的内容。试下复制再粘贴：

通过测试可以知道，最终的结果是一个数组。我们再来看看剪切板有没有记录：

这里其实用的是上面同一张图，因为没有变化所以就没再截图了。

通过以上内容，我们可以发现，pasteboard 的复制粘贴是和系统隔开的。

复制粘贴文件

其实代码可以不用修改，但是为了更好的显示，我们还是修改以下：

void _pastText() async {

  final results = await Pasteboard.files();

  if (results.isNotEmpty) {

    _text = '';

    for (final result in results) {

      _text += '$result\n';

    }

    setState(() {});

  } else {

    BotToast.showText(text: '我什么都不能给你，因为我也咩有😭');

  }

}

在这里，我使用了 url_launcher 插件，用来打开系统的文件浏览器。代码如下：

void _openExplorer() async {

  const _filePath = r'C:\Users\ilgnefz\Pictures';

  final Uri _uri = Uri.file(_filePath);

  await launch(_uri.toString());

}

来看看效果：

图片本质上也是文件，可以直接使用上面的方法进行复制粘贴。所以关于图片的方法就不讲解了

（🤫ps: 其实是我使用官方例子的方法，用Base64图片进行测试，发现无法得到想要的结果。使用了官方的例子也是一样。复制图片的方法需要传递一个Uint8List参数，虽然可以使用其他方法转换，但是就变得麻烦了。以后我会出一篇关于用 CustomPaint 绘制图片的文章，里面会用到将图片转换成Uint8List对象的方法）。

clipboard

安装🛠

点击clipboard获取最新版本。以下是在编写本文章时的最新版本：

clipboard: ^0.1.3

使用🥟

该插件拥有4个方法：

• controlC：模仿 cttr + c 键，复制


• controlC：模仿 cttr + v 键，粘贴


• copy：复制


• paste：粘贴

先来看看前面两个方法：

void _useCtrC() async {

  if (_controller.text.isEmpty) {

    BotToast.showText(text: '啥都没输入，你要我复制什么🥴');

  } else {

    await FlutterClipboard.controlC(_controller.text);

  }

}



void _useCtrV() async {

  ClipboardData result = await FlutterClipboard.controlV();

  _text = result.text.toString();

  setState(() {});

}

使用 controlV 会返回一个 ClipboardData 对象。

后面两个方法和前面的唯一不同，就是返回的是一个 String 对象：

void _useCopy() async {

  if (_controller.text.isEmpty) {

    BotToast.showText(text: '啥都没输入，你要我复制什么🥴');

  } else {

    await FlutterClipboard.copy(_controller.text);

  }

}



void _usePaste() async {

  _text = await FlutterClipboard.paste();

  setState(() {});

}

我们打开系统的剪切板可以发现，以上复制的内容都会被记录。我们试一下不按复制看能不能直接读取剪切板的信息进行粘贴：

试试 paste 方法：

🛫OK，以上就是这篇文章的全部内容，仅针对插件的当前版本，并不能保证适用于以后插件用法的更新迭代。

最后，感谢 leanflutter 和 Mixin Network 两个团队还有 samuelezedi 对以上插件的开发和维护😁。本应用代码已上传至 github 和 gitee，有需要的可以下载下来查看学习。

前言

Flutter 是 Google 开源的应用开发框架，仅通过一套代码就能构建支持Android、iOS、Windows、Linux等多平台的应用。Flutter的性能非常高，拥有120fps的刷新率，也是目前非常流行的跨平台UI开发框架。

本专栏为大家收集了Github上近70个优秀开源库，后续也将持续更新。希望可以帮助大家提升搬砖效率，同时祝愿Flutter的生态越来越完善🎉🎉。

正文

一、🚀 轮子介绍

• 名称：awesome_dialog


• 概述：一个简单易用的内置动画弹窗


• 出版商：marcos930807@gmail.com


• 仓库地址：awesomeDialogs


• 推荐指数： ⭐️⭐️⭐️⭐️


• 常用指数： ⭐️⭐️⭐️⭐️


• 效果预览：

二、⚙️ 安装及使用

dependencies:

  awesome_dialog: ^2.1.2

import 'package:awesome_dialog/awesome_dialog.dart';

三、🔧 常用属性

四、🗂 示例

1.带有点击动画的按钮

AnimatedButton(

    color: Colors.cyan, 

    text: '这是一个带有点击动画的按钮', 

    pressEvent: () {},

)

2.固定宽度并带有确认 / 取消按钮的提示框

AnimatedButton(

    text: '固定宽度并带有确认 / 取消按钮的提示框',

    pressEvent: () {

        AwesomeDialog(

            context: context,

            dialogType: DialogType.INFO_REVERSED,

            borderSide: const BorderSide(

                color: Colors.green,

                width: 2,

                ),

            width: 380,

            buttonsBorderRadius: const BorderRadius.all(

                Radius.circular(2),

                ),

            btnCancelText: '不予理会',

            btnOkText: '冲啊！',

            headerAnimationLoop: false,

            animType: AnimType.BOTTOMSLIDE,

            title: '提示',

            desc: '一个1级bug向你发起挑衅，是否迎战？',

            showCloseIcon: true,

            btnCancelOnPress: () {},

            btnOkOnPress: () {},

        ).show();

});

3.自定义按钮样式的问题对话框

AnimatedButton(

    color: Colors.orange[700],

    text: '具有自定义按钮样式的问题对话框',

    pressEvent: () {

        AwesomeDialog(

            context: context,

            dialogType: DialogType.QUESTION,

            headerAnimationLoop: false,

            animType: AnimType.BOTTOMSLIDE,

            title: '触发额外剧情',

            desc: '发现一名晕倒在草丛的路人，你会？',

            buttonsTextStyle: const TextStyle(color: Colors.black),

            btnCancelText: '拿走他的钱袋',

            btnOkText: '救助',

            showCloseIcon: true,

            btnCancelOnPress: () {},

            btnOkOnPress: () {},

        ).show();

});

4.无按钮的信息提示框

AnimatedButton(

    color: Colors.grey,

    text: '无按钮的信息提示框',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        headerAnimationLoop: true,

        animType: AnimType.BOTTOMSLIDE,

        title: '提示',

        desc:

        '你救下路人，意外发现他是一位精通Flutter的满级大佬，大佬为了向你表示感谢，赠送你了全套Flutter的学习资料...',

    ).show();

});

5.警示框

AnimatedButton(

    color: Colors.orange,

    text: '警示框',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        dialogType: DialogType.WARNING,

        headerAnimationLoop: false,

        animType: AnimType.TOPSLIDE,

        showCloseIcon: true,

        closeIcon: const Icon(Icons.close_fullscreen_outlined),

        title: '警告',

        desc: '意外发现bug的窝点,你准备？',

        btnCancelOnPress: () {},

        onDissmissCallback: (type) {

            debugPrint('Dialog Dissmiss from callback $type');

        },

        btnCancelText: '暂且撤退',

        btnOkText: '发起战斗',

        btnOkOnPress: () {},

    ).show();

});

6.错误提示框

AnimatedButton(

    color: Colors.red,

    text: '错误提示框',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        dialogType: DialogType.ERROR,

        animType: AnimType.RIGHSLIDE,

        headerAnimationLoop: true,

        title: '挑战失败',

        desc: '你寡不敌众，败下阵来，（回到出生点后，拿出大佬赠送的全套学习资料，立志学成后报仇血恨... ）',

        btnOkOnPress: () {},

        btnOkIcon: Icons.cancel,

        btnOkColor: Colors.red,

    ).show();

});

7.成功提示框

AnimatedButton(

    color: Colors.green,

    text: '成功提示框',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        animType: AnimType.LEFTSLIDE,

        headerAnimationLoop: false,

        dialogType: DialogType.SUCCES,

        showCloseIcon: true,

        title: '挑战成功',

        desc: '经过三天三夜的苦战，你成功消灭了所有的bug',

        btnOkOnPress: () {

            debugPrint('OnClcik');

        },

        btnOkIcon: Icons.check_circle,

        onDissmissCallback: (type) {

            debugPrint('Dialog Dissmiss from callback $type');

        },

    ).show();

});

8.不带顶部动画的弹窗

AnimatedButton(

    color: Colors.cyan,

    text: '不带顶部动画的弹窗',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        headerAnimationLoop: false,

        dialogType: DialogType.NO_HEADER,

        title: 'No Header',

        desc:'Dialog description here...',

        btnOkOnPress: () {

            debugPrint('OnClcik');

        },

        btnOkIcon: Icons.check_circle,

    ).show();

});

9.自定义内容弹窗

AnimatedButton(

    color: Colors.purple,

    text: '自定义内容弹窗',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        animType: AnimType.SCALE,

        dialogType: DialogType.INFO,

        body: const Center(

            child: Text(

                    'If the body is specified, then title and description will be ignored, this allows to further customize the dialogue.',

                    style: TextStyle(fontStyle: FontStyle.italic),

                   ),

              ),

        title: 'This is Ignored',

        desc: 'This is also Ignored',

    ).show();

});

10.自动隐藏弹窗

AnimatedButton(

    color: Colors.grey,

    text: '自动隐藏弹窗',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        dialogType: DialogType.INFO,

        animType: AnimType.SCALE,

        title: 'Auto Hide Dialog',

        desc: 'AutoHide after 2 seconds',

        autoHide: const Duration(seconds: 2),

    ).show();

});

11.测试弹窗

AnimatedButton(

    color: Colors.blue,

    text: '测试弹窗',

    pressEvent: () {

        AwesomeDialog(

        context: context,

        keyboardAware: true,

        dismissOnBackKeyPress: false,

        dialogType: DialogType.WARNING,

        animType: AnimType.BOTTOMSLIDE,

        btnCancelText: "Cancel Order",

        btnOkText: "Yes, I will pay",

        title: 'Continue to pay?',

        desc:'Please confirm that you will pay 3000 INR within 30 mins. Creating orders without paying will create penalty charges, and your account may be disabled.',

        btnCancelOnPress: () {},

        btnOkOnPress: () {},

    ).show();

});

12.文本输入弹窗

AnimatedButton(

    color: Colors.blueGrey,

    text: '带有文本输入框的弹窗',

    pressEvent: () {

        late AwesomeDialog dialog;

        dialog = AwesomeDialog(

        context: context,

        animType: AnimType.SCALE,

        dialogType: DialogType.INFO,

        keyboardAware: true,

        body: Padding(

            padding: const EdgeInsets.all(8.0),

            child: Column(

            children: <Widget>[

                Text('Form Data',

                    style: Theme.of(context).textTheme.headline6,),

                const SizedBox(height: 10,),

                Material(

                    elevation: 0,

                    color: Colors.blueGrey.withAlpha(40),

                    child: TextFormField(

                        autofocus: true,

                        minLines: 1,

                        decoration: const InputDecoration(

                        border: InputBorder.none,

                        labelText: 'Title',

                        prefixIcon: Icon(Icons.text_fields),

                        ),

                    ),

                ),

                const SizedBox(height: 10,),

                Material(

                    elevation: 0,

                    color: Colors.blueGrey.withAlpha(40),

                    child: TextFormField(

                        autofocus: true,

                        keyboardType: TextInputType.multiline,

                        minLines: 2,

                        maxLines: null,

                        decoration: const InputDecoration(

                        border: InputBorder.none,

                        labelText: 'Description',

                        prefixIcon: Icon(Icons.text_fields),

                        ),

                    ),

                ),

                const SizedBox(height: 10,),

                AnimatedButton(

                    isFixedHeight: false,

                    text: 'Close',

                    pressEvent: () {

                        dialog.dismiss();

                    },

                )

            ],),

        ),

    )..show();

});

0-1 knapsack

Problem Statement

Given the weights and profits of ‘N’ items, we are asked to put these items in a knapsack that has a capacity ‘C’. The goal is to get the maximum profit from the items in the knapsack. Each item can only be selected once, as we don’t have multiple quantities of any item.

Items: { Apple, Orange, Banana, Melon }

Weights: { 2, 3, 1, 4 }

Profits: { 4, 5, 3, 7 }

Knapsack capacity: 5

Output: 10

暴力解法

每个 Item 都可以放或者不放，可以对每个元素一次进行递归

export function bruteforce(

  profits: number[],

  weights: number[],

  capacity: number

) {

  const recursive = (i: number, c: number, p: number): number => {

    if (i >= profits.length) return p;



    return Math.max(

      c + weights[i] > capacity

        ? p

        : recursive(i + 1, c + weights[i], p + profits[i]),

      recursive(i + 1, c, p)

    );

  };



  const ans = recursive(0, 0, 0);

  return ans;

}

时间复杂度：O(2n)

空间复杂度：O(n)

Top-Down DP

稍微变一个 recursive 的逻辑，recursive 函数表示，把 0~i 范围内的 Item 装入 capacity 为 c 的背包中，能够获得的最大的 profit

可以看到有重复的分支，我们需要做的就是在这个基础上记忆

export function topDown(

  profits: number[],

  weights: number[],

  capacity: number

) {

  const dp: Record<string, number> = {};



  const recursive = (i: number, c: number, p: number): number => {

    if (i >= profits.length) return p;



    const key = `${i}_${c}`;



    if (dp[key]) {

      return dp[key];

    }



    const ans = Math.max(

      c - weights[i] >= 0

        ? recursive(i + 1, c - weights[i], p + profits[i])

        : p,

      recursive(i + 1, c, p)

    );



    return (dp[key] = ans);

  };



  const ans = recursive(0, capacity, 0);

  return ans;

}

时间复杂度：O(n * c)，因为记忆化后，最多有 n * c 个子问题

空间复杂度：O(n * c + n)

Bottom-Up DP

dp 记录对于前 i 个元素，当 capacity 为 c 时，能获得的最大 profit，那么

dp[i][c] = max (

	// 不取当前元素

	dp[i-1][c], 

	// 取当前元素

	profits[i] + dp[i-1][c-weights[i]]

)

图解如下：

export function bottomUp(

  profits: number[],

  weights: number[],

  capacity: number

) {

  const N = profits.length;

  const dp: number[][] = new Array(N)

    .fill(0)

    .map(() => new Array(capacity + 1).fill(0));



  // 初始化

  for (let i = 0; i < N; i++) dp[i][0] = 0;

  for (let c = 0; c <= capacity; c++) {

    if (weights[0] <= c) dp[0][c] = profits[0];

  }



  // dp

  for (let i = 1; i < N; i++) {

    for (let c = 1; c <= capacity; c++) {

      dp[i][c] = Math.max(

        dp[i - 1][c],

        c < weights[i] ? 0 : profits[i] + dp[i - 1][c - weights[i]]

      );

    }

  }



  return dp[N - 1][capacity];

}

时间复杂度：O(n * c)

空间复杂度：O(n * c)

Bottom-Up DP 优化

在计算第 i 个元素的过程中，只需要用到前一次的 dp[c] and dp[c-weight[i]] ，所以，在空间复杂度上我们可以做优化，可以使用同一个数组进行前后两次的记忆

如果 capacity 从 c ~ 0 ，而不是 0 ~ c 循环，去修改 dp[i][c ~ capacity]，可以确保 dp[i][0 ~ c-1] 的值是前一次的，但是，如果按照之前的反过来，计算 dp[i][c] 的时候，dp[i][0 ~ c-1] 已经变成第 i 次的值在存储，所以行不通

export function bottomUp2(

  profits: number[],

  weights: number[],

  capacity: number

) {

  const N = profits.length;

  const dp: number[] = new Array(capacity + 1).fill(0);



  // 初始化

  for (let c = 0; c <= capacity; c++) {

    if (weights[0] <= c) dp[c] = profits[0];

  }



  // dp

  for (let i = 1; i < N; i++) {

    for (let c = capacity; c >= 0; c--) {

      dp[c] = Math.max(

        dp[c],

        c < weights[i] ? 0 : profits[i] + dp[c - weights[i]]

      );

    }

  }



  return dp[capacity];

}

起因

虽然在去年跳槽前有刷过一段时间的力扣，但是一直都没有将自己的刷题的过程记录下来。直到2021年5月，掘金举办了一个Java 刷题打卡的活动，我才开始将自己的第一篇刷题文章发布在掘金👇

后面掘金又举办了2021年6月更文挑战活动，活动大奖要求有 30 篇文章，最终这次活动中我输出了 23 篇力扣刷题的文章。

至今为止，我在掘金上已发表了 124 个力扣题解，有兴趣的话可以关注我的专栏：力扣刷题

我是怎么做的？

1. 代码存储

为了更方便的调试代码以及存储自己写的测试用例，所以我在Github上建了一个私人库用于存储代码。这样做的好处就是：随时随地获取你的历史代码、而且可以保留自己写的测试用例。我非常推荐你也使用仓库来存储自己的解题代码！

2.模仿和总结

刚开始刷题的时候我只会简单的暴力求解，所以在提交第一题的时候击败率连 10% 都不到，后来通过看官方题解发现了可以使用 HashMap 用空间换取时间（因 HashMap 中链表节点超过8时会转为红黑树）。

所以在刚开始很长一段时间我都是 题目看完 -> 思考15分钟，没有思路 -> 看官方题解，但经过了一段时间后我发现自己的提升很小。就像是一种脑子会了，手没会的感觉，下次碰到类似的题目还是不会做。

后来经过不断的摸索，我刷题的步骤大概是这样的：

1. 看题目，列出题目中的重点


2. 想清楚解题的关键和思路（碰到链表或二叉树相关的题目，我一般都会在草稿纸上画一下）


3. 实在不会的可以看一下官方题解，但是不抄官方的代码


4. 运行调试：写好代码后，将力扣的测试用例写在main方法中测试（像一些二叉树的题目就需要根据官方的二叉树数组自己转为 TreeNode 了）


5. 提交代码，然后再在本地调试不通过的测试用例（一般来说需要调试二十分钟左右，不要着急！）


6. 直到通过所有的测试用例

经过这段时间的刷题，我也有了一些小感悟：

• 算法的本质就是利用空间换区时间


• 有时候看到数据结构就能猜到用什么算法：例如碰到 二叉树 就会想到 递归、碰到 截取字符串 会想到 滑动窗口、碰到大问题可以分解的情况会想到 动态规划


• 使用 HashMap 替代数组或链表，可有效降低时间复杂度


• 遍历链表时一般都需要临时指针指向头结点


• ......

我收获了什么？

虽然刷题碰到的一些算法在实际业务中无法很好落地，但是刷题能够对数据结构有更深刻的理解、调试能力的提升（先将步骤分解，然后寻找非预期的输入或输出）、锻炼思维能力、以及对代码执行的效率更敏感了（减少时间复杂度）。

实际项目如何运用？

下面我举得这个例子就可以很好的体现：递归算法的运用和提高执行效率。

在常见的业务系统中，不可避免的会需要动态菜单和权限的功能。动态菜单本质上是一个 树，而某个菜单路由下面的权限就像是树中的 叶子节点。但是数据库并不能够存储树这样的结构，那怎么办呢？

常规的树形结构的路由菜单如下所示：

设计的数据库表如下所示：

parentId：表示父节点的Id  

menuType：当类型为 C 标识为路由下的权限，即二叉树中的叶子节点

实际业务需要将查找出来的列表转为树形结构返回给前端，这怎么实现呢？大致的思路如下所示：

    /**

     * list转为树结构

     */

    private List<MenuBO> list2Tree(List<MenuBO> list, Integer pId) {

        List<MenuBO> tree = new ArrayList<>();

        Iterator<MenuBO> it = list.iterator();

        while (it.hasNext()) {

            MenuBO m = it.next();

            if (m.getParentId() == pId) {

                tree.add(m);

                // 已添加的元素删除掉

                it.remove();

            }

        }

        // 寻找子元素

        tree.forEach(n -> n.setChildren(list2Tree(list, n.getId())));

        return tree;

    }

这段代码的注释比较清楚，就是找到原列表中所有 pid 相同的元素放入新列表，并将新列表设为孩子节点，直到所有节点都遍历完成。又因为一行记录只会成为树中的一个节点，故每个元素只需遍历一次。所以再将元素放入到新列表后，就在原列表中将此元素移除。算法复杂度从 O(N*logN) 变为了 0(N)，大大提升了执行效率。

总结

去年的这个时候我是零基础开始刷题的，刚开始写一个中等难度的题目需要一两个小时，再加上写完题目后还要输出一篇文章，一般都要搞到凌晨左右。但现在我简单题已经可以重拳出击了，中等难度的题目解题的时间更少了，至于困难题还是需要看题解。

从我一年多刷题的经历来看，我总结出来两句话：

1. 万事开头难


2. 实践才是检验真理的唯一标准！

所以行动起来吧！就现在！

最后我想感谢一下稀土掘金！来这里不仅能刷沸点段子，还能写文章拿奖品。不得不说，掘金的活动实在是太多了（PS：奖品也很多）！

每次新建Flutter项目，是我最痛苦的时间，每次去pub仓库找库，再复制粘贴到 pubspec.yaml ，再执行 flutter pub get 。这套操作往往需要重复十几次。毕竟Flutter大到路由，状态管理，小到工具类，国际化都需要库来支持，等找齐这些东西，终于可以准备开发的时候，半天已经过去了。

所幸，我在pub仓库发现了它，GetX，这玩意是真的牛皮，使用它大大小小开发了四五个项目后，确定了稳定性和性能后，决定进行分享一波。

本文只是简单分享，GetX没有官方文档，只有github的README，所以我结合自己的经验，整理了一份。

github

gitee

GetX为何物？

• 
  

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

  
  


• 
  

  GetX 有3个基本原则：

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


• 
  

  GetX 并不臃肿，却很轻量。如果你只使用状态管理，只有状态管理模块会被编译，其他没用到的东西都不会被编译到你的代码中。它拥有众多的功能，但这些功能都在独立的容器中，只有在使用后才会启动。

  
  

GetX能干什么？

GetX包含的功能：

• 状态管理


• 路由


• 国际化


• 工具类


• IDE拓展


• 工程化Cli


• ......

GetX的优点？

对于一个菜鸟来说，它最大的优点当然是 简单易上手

举几个例子：

状态管理

创建一个 Controller 管理你的状态变量

class Controller extends GetxController{

  var count = 0.obs;

  increment() => count++;

}

然后直接使用

class Home extends StatelessWidget {



  @override

  Widget build(context) {



    // 使用Get.put()实例化你的类，使其对当下的所有子路由可用。

    final Controller c = Get.put(Controller());



    return Scaffold(

      // 使用Obx(()=>每当改变计数时，就更新Text()。

      appBar: AppBar(title: Obx(() => Text("Clicks: ${c.count}"))),



      // 用一个简单的Get.to()即可代替Navigator.push那8行，无需上下文！

      body: Center(child: ElevatedButton(

              child: Text("Go to Other"), onPressed: () => Get.to(Other()))),

      floatingActionButton:

          FloatingActionButton(child: Icon(Icons.add), onPressed: c.increment));

  }

}



class Other extends StatelessWidget {

  // 你可以让Get找到一个正在被其他页面使用的Controller，并将它返回给你。

  final Controller c = Get.find();



  @override

  Widget build(context){

     // 访问更新后的计数变量

     return Scaffold(body: Center(child: Text("${c.count}")));

  }

}

你只需要 put 一个 Controller 后，再将 widget 包裹在 Obx 中，这样就将 count 绑定在了你的 widget 中，只要 count 发生改变， widget 就很跟着更新。

注意，Controller是与Widget解耦的，只有进行了put才会进行绑定，所以是局部状态还是全局状态完全由你自己决定。

路由

GetX的路由最大的特点就是，不需要 context ，直接使用即可

导航到新页面

Get.to(NextScreen());

用别名导航到新页面。

Get.toNamed('/details');

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

Get.back();

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

Get.off(NextScreen());

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

Get.offAll(NextScreen());

国际化

GetX的国际化尤其简单，我们只需要新建一个 Translations 类

import 'package:get/get.dart';



class Messages extends Translations {

  @override

  Map<String, Map<String, String>> get keys => {

        'zh_CN': {

          'hello': '你好 世界',

        },

        'de_DE': {

          'hello': 'Hallo Welt',

        }

      };

}

并且将你的 MaterialApp 更改为 GetMaterialApp ，并绑定上刚刚创建的 Translations 类。

不用担心，GetMaterialApp支持所有MaterialApp的接口，它们是兼容的

return GetMaterialApp(

    translations: Messages(), // 你的翻译

    locale: Locale('zh', 'CN'), // 将会按照此处指定的语言翻译

    fallbackLocale: Locale('en', 'US'), // 添加一个回调语言选项，以备上面指定的语言翻译不存在

);

然后直接使用

Text('title'.tr);

是的，你只需要在字符串后面加上 .tr 即可使用国际化功能

GetX Cli是何物？

GetX Cli是一个命令行脚本，类似vue cli，但更强大一些，它可以做到：

• 创建项目


• 项目工程化


• 生成Model


• 生成page


• 生成view


• 生成controller


• 自定义controller模板


• 生成翻译文件


• ......

想要使用GetX Cli，你需要安装dart环境或者Flutter环境

然后直接安装即可使用

pub global activate get_cli 

# or

flutter pub global activate get_cli

创建项目

get create project:my_project

这个命令会调用 flutter create ，然后再执行 get init

项目工程化

get init

生成page

get create page:home

生成controller

get create controller:dialogcontroller on home

生成view

get create view:dialogview on home

生成model

get generate model on home with assets/models/user.json

更多详细命令去看文档吧

IDE拓展

• getx_template：一键生成每个页面必需的文件夹、文件、模板代码等等
  
  
  
  • Android Studio/Intellij插件
  
  
  
  


• GetX Snippets：输入少量字母，自动提示选择后，可生成常用的模板代码
  
  
  
  • Android Studio/Intellij扩展
  
  
  • VSCode扩展
  
  
  
  

结语

祝大家在编程路上飞黄腾达，越走越远。

file_selector

安装🛠

点击file_selector获取最新版本。以下是在编写本文章时的最新版本：

file_selector: ^0.8.4+1

👻注意：在开发 macOS 端的程序时，还需要额外的操作，具体可以查看这里

了解🧩

在 file_selector 插件中，我们需要了解对象 XTypeGroup 和方法 openFiles。

XTypeGroup的作用是使用给定的标签和文件扩展名创建一个新组，没有提供任何类型选项的组表示允许任何类型。

XTypeGroup 可以传入5个参数：

• String? label：用来自己作区分


• List<String>? extensions：过滤非描述的后缀文件，默认加载全部类型的文件


• List<String>? mimeTypes：主要针对 Linux 系统下的文件类型


• List<String>? macUTIs：主要针对 mac 系统下的文件类型


• List<String>? webWildCards：主要针对网页开发时的类型

openFile 方法返回一个 XFile 对象，可以传入3个参数：

• List acceptedTypeGroups = const []：接受的类型组，传入一个XTypeGroup列表


• String? initialDirectory：初始化文件夹。打开文件对话框以加载文件并返回文件路径


• String? confirmButtonText：弹窗“打开”按钮的显示文字

openFiles 方法返回 XFile 对象列表，传入的参数和 openFile 一样。

使用🥩

选择的文件我们最后需要读取出来，读取需要接受一个 String 类型的路径：

String path = '';

这里先以选择图片为例，我们需要先定义一个 XTypeGroup 对象：

final xType = XTypeGroup(label: '图片', extensions: ['jpg', 'png']);

选择单张图片

打开弹窗选取单个文件，使用 openFile 方法：

final XFile? file = await openFile(acceptedTypeGroups: [xType]);

将获取到的 XFile 对象的路径值传给 path。当然，并不是每次打开弹窗都会选择图片，所以需要判断一下：

if (file != null) {

  path = file.path;

  setState((){});

} else {

  BotToast.showText(text: '你不选择图片打开干啥😤');

}

openFile 方法中还有两个属性，我们修改试一下：

final XFile? file = await openFile(

  acceptedTypeGroups: [xType],

  initialDirectory: r'C:\Users\ilgnefz\Pictures',

  confirmButtonText: '嘿嘿嘿',

);

initialDirectory 属性貌似没用😕去看了官方的例子，也没用到过这个参数，以后就忽略它吧。

选择多张图片

选取多张图片，我们就需要定义一个路径的数组了：

final List<String> paths = []

XTypeGroup 对象和刚才的一样就行，重要的是使用 openFiles 方法：

final List<XFile> files = await openFiles(acceptedTypeGroups: [xType]);

将获取到的文件路径列表赋值给 paths:

if (file != null) {

  paths.addAll(files.map((e) => e.path).toList());

  setState((){});

} else {

  BotToast.showText(text: '你不选择图片打开干啥😤');

}

好了，来看看效果如何

读取文本文件

读取文本文件，我们需要获取文件的名称和内容：

final String title = '';

final String content = '';

再更改一下 XTypeGroup 对象就行：

final XTypeGroup xType = XTypeGroup(label: '文本', extensions: ['txt']);

final XFile? file = await openFile(acceptedTypeGroups: [xType]);

将获取到的 XFile 对象的属性赋值给我们定义的对象：

if (file != null) {

  title = file.name;

  content = await file.readAsString();

  setState((){});

} else {

  BotToast.showText(text: '打开了个寂寞🙄');

}

存储文本文件

存储文本需要用到 XFile 对象中的 fromData 方法。让我们来看看这个方法中需要传入什么参数：

• Uint8List bytes：存储的主要内容


• String? mimeType：文件的 mine 类型


• String? name：文件名？测试了毫无用处😑


• int? length：不知道是什么的长度，反正无法截取内容😑


• DateTime? lastModified：最后修改文件的时间


• String? path：文件保存的路径？测试了毫无效果😑


• CrossFileTestOverrides? overrides：覆盖CrossFile的某些方法用来测试

（以上几个参数要是有朋友测试出来了，可以告知一下😁）

在存储文本文件前，我们需要先知道应该存储在哪个文件夹：

final String? path = await getSavePath();

然后再把 XFile.fromData 需要的参数放进去：

if (path != null) {

  // 将内容编码成utf8

  final Uint8List fileData = const Utf8Encoder().convert(content);

  const String fileMimeType = 'text/plain';

  final XFile xFile = XFile.fromData(

    fileData,

    mimeType: fileMimeType,

    name: title,

  );

  await xFile.saveTo(path);

} else {

  BotToast.showText(text: '给你个眼神自己体会😑');

}

获取文件夹路径

读取文件夹路径需要使用 getDirectoryPath 方法：

final String? path = await getDirectoryPath();

if (path != null) {

  title = '目录';

  content = path;

  setState((){});

}

file_picker

安装🛠

点击file_picker获取最新版本。以下是在编写本文章时的最新版本：

file_picker: ^4.5.1

使用🥩

先定义一个默认的路径：

String path = '';

选择单个文件

选择单个文件需要用到 pickFiles 方法，该方法可以传入10个参数：

• String? dialogTitle：弹窗的标题


• String? initialDirectory：初始化的文件夹


• FileType type = FileType.any：文件的类型


• List<String>? allowedExtensions：允许的文件后缀名称


• dynamic Function(FilePickerStatus)? onFileLoading：监听文件选择的状态


• bool allowCompression = true：是否允许压缩


• bool allowMultiple = false：是否允许选择多个文件


• bool withData = false：如果为true，选取的文件将在内存中立即以“Uint8List”的形式提供其字节数据，如果您选择它进行服务器上传或类似操作，这将很有用。但是，请记住，如果您允许多个选择或选择大文件，则在 IO（iOS 和 Android）上启用此功能可能会导致内存不足问题。请改用 [withReadStream]。在 web 上默认为 true，其他为 false


• bool withReadStream = false：拾取的文件将以 [Stream<List>] 的形式提供其字节数据，这对于上传和处理大文件很有用


• bool lockParentWindow = false：是否将子窗口（文件选择器窗口）一直停留在 Flutter 窗口的前面，直到它关闭（如模态窗口）。此参数仅适用于 Windows

FilePickerResult? result = await FilePicker.platform.pickFiles();

if (result != null) {

  File file = File(result.files.single.path!);

  path = file.path;

  setState((){});

}

我们试着添加一些参数：

FilePickerResult? result = await FilePicker.platform.pickFiles(

  dialogTitle: '我的地盘我做主',

  initialDirectory: r'C:\Users\ilgnefz\Pictures\Saved Pictures',

  type: FileType.image,

);

initialDirectory 又没起作用😑

选择多个文件

定义一个接受所有路径的数组：

final List<String> paths = [];

FilePickerResult? result = await FilePicker.platform.pickFiles(

  allowMultiple: true,

);

if (result != null) {

  paths = result.files.map((e) => e.path!).toList();

 	setState((){});

}

读取文件信息

通过以上的方法，我们会得到一个 PlatformFile 对象：

FilePickerResult? result = await FilePicker.platform.pickFiles();

PlatformFile file = result.files.single;

该对象有以下几个属性：

• name：文件名称


• size：文件大小，以字节为单位


• bytes：此文件的字节数据。如果您想操作其数据或轻松上传到其他地方，则特别有用。 在常见问题解答中查看此处 一个关于如何使用它在网络上上传的示例。


• extension：文件后缀


• path：文件路径


• identifier：原始文件的平台标识符，是指 Android 上的 Uri 和 iOS 上的 NSURL。其他为null


• readStream：将文件内容转换成流读取

存储文件

存储文件需要使用 saveFile 方法，该方法有可以传入6个参数：

• String? dialogTitle：同 pickFiles 方法


• String? fileName：存储文件的名字


• String? initialDirectory：同 pickFiles 方法


• FileType type = FileType.any：同 pickFiles 方法


• List ? allowedExtensions：同 pickFiles 方法


• bool lockParentWindow = false：同 pickFiles 方法

String? outputFile = await FilePicker.platform.saveFile();

(⊙o⊙)…这个方法连保存内容的参数都没有，诶！就是玩😄。官方说这个方法没有实际意义。

获取文件夹路径

获取文件夹需要使用 getDirectoryPath 方法，可以传入3个参数：

• String? dialogTitle：同 pickFiles 方法


• bool lockParentWindow = false：同 pickFiles 方法


• String? initialDirectory：同 pickFiles 方法

final String title = '';

final String content = '';

String? dir = await FilePicker.platform.getDirectoryPath();

if (path != null) {

  title = '目录';

  content = path;

  setState((){});

}

🛫OK，以上就是这篇文章的全部内容，仅针对插件的当前版本，并不能保证适用于以后插件用法的更新迭代。

最后，感谢 flutter 团队和 miguelpruivo 对以上插件的开发和维护😁。本应用代码已上传至 github 和 gitee，有需要的可以下载下来查看学习。

在我用的大部分桌面端中，发送本地悬浮通知的软件可以说是屈指可数。但是，这不妨碍到我们学习✊，奋斗说不定以后就能用到呢！

在选择该使用哪些插件开发桌面端的时候，由 lijy91 主导的 LeanFlutter 可以说是帮了很大的忙，有需要的可以自己去看看。

接下来要介绍的两个发送通知的插件，也是从 LeanFlutter 下的 awesome-flutter-desktop 仓库中找的。

local_notifier

安装🛠

点击local_notifier获取最新版本。以下是在编写本文章时的最新版本：

local_notifier: ^0.1.1

👻注意：在开发 Linux 端的程序时，还需要额外的操作，具体可以查看这里

使用🍖

要想实现发送通知的功能，需要用到一个实例化的 LocalNotifier 对象：

final localNotifier = LocalNotifier.instance;

如果你想全局使用，可以把该行代码放到一个自定义的全局类里。

要想编辑想发送的内容，需要用到 LocalNotification 类。实例化该类可以传入5个参数：

• String? identifier：用来当做通用唯一识别码


• required String title：发送通知的标题，一般是软件名称


• String? subtitle：发送的通知内容的标题


• String? body：发送的内容的主体


• bool silent = false：在发送通知时是否静音

final notification = LocalNotification(

  identifier: '12345',

  title: '古诗鉴赏从',

  subtitle: '桃夭 - 佚名〔先秦〕',

  body: '桃之夭夭，灼灼其华。之子于归，宜其室家。\n桃之夭夭，有蕡其实。之子于归，宜其家室。\n桃之夭夭，其叶蓁蓁。之子于归，宜其家人。',

  silent: false,

);

localNotifier.notify(notification);

现在我们就能愉快地发送一条自定义的通知了🎉

我们发现，其中其实只有title参数是必传的，我们就试一下只传入这个参数：

final notification = LocalNotification(

  title: '古诗鉴赏从',

);

localNotifier.notify(notification);

我们发现，只传 title 参数，它会自动将 title 的参数值赋值给 subtitle，而 body 参数会以“新通知”代替。
好了，以上就是 local_notifier 目前的全部功能，如果你只是简单的发送一条提示使用该插件完全够用。

win_toast

安装🛠

点击win_toast获取最新版本。以下是在编写本文章时的最新版本：

win_toast: ^0.0.2

使用🍖

在全局使用该插件，需要在app初始化时初始化。在某个页面使用，只要在页面初始化时初始化就行。

初始化时需要传递3个参数：

• required String appName：程序名称


• required String productName：产品名称


• required String companyName：公司名称

await WinToast.instance().initialize(

  appName: '第一个Desktop应用',

  productName: '第一个Desktop应用',

  companyName: 'Hiden Intelligence',

);

没写过原生，插件作者贴出Pick a unique AUMID that will identify your Win32 app告诉我们为什么要填这些内容👀，想了解的可以看一下。

要想发送一条通知，需要使用 showToast 方法，该方法有5个参数可以传：

• 
  

  required ToastType type：传入toast显示的类型，一共有8种：

  
  
  
  
  • imageAndText01至imageAndText04
  
  
  • text01至text04
  
  
  
  

  至于这些类型的异同，可以点这里👀

  
  


• 
  

  required String title：通知显示的标题

  
  


• 
  

  String subtitle = ''：通知显示的主要内容

  
  


• 
  

  String imagePath = ''：选择 imageAndText 类型时，要显示的图片

  
  


• 
  

  List actions = const []：显示通知中的按钮

  
  

使用text类型

先定义几个变量和常量：

Toast? toast;

final List<String> _title = 'Shining For One Thing(《一闪一闪亮星星》影视剧歌曲) - 赵贝尔';

final List<String> _subtitle = 'I fall in love\nI see your love\n遇见你才发现\n我在等你到来';

final List<String> _actione = ['上一首', '播放/暂停', '下一首'];

先来看看只传入文字的 text01 类型：

toast = await WinToast.instance().showToast(

  type: ToastType.text01,

  title: _title,

  actions: _actione,

);

👻注意：当使用 ToastType.text01 或 ToastType.imageAndText01 时不能传入 subtitle 参数。

再来看看只传入文字的 text02 类型：

toast = await WinToast.instance().showToast(

  type: ToastType.text02,

  title: _title,

  subtitle: _subtitle,

  actions: _actione,

);

用了一下 ToastType.text03 和 ToastType.text04，发现显示的效果和 ToastType.text02 没有差别。大家可以自己试试。

使用imageAndText类型

修改一下常量的值（非必要）：

Toast? toast;

final List<String> _title = '又下雨了，你的心情怎么样？';

final List<String> _subtitle = '偷偷告诉你，明天就天晴了😏\n好雨知时节，当春乃发生。随风潜入夜，润物细无声。野径云俱黑，江船火独明。晓看红湿处，花重锦官城。';

final List<String> _actione = ['不开森😭', '只想睡觉🥱', '非常高兴😃'];

还需要传入一张图片，目前无法得知应该传入图片的路径怎么填，所以先准备一张资源图片传入它的相对路径：

final String _imagePath = 'assets/images/pdx.jpg';

来看看 imageAndText01 类型：

toast = await WinToast.instance().showToast(

  type: ToastType.imageAndText01,

  title: _titles * 3,

  imagePath: _imagePath,

  actions: _action,

);

😲嗯？我们传入的图片怎么没显示？换个网络图片的链接试试：

final String _imagePath = 'https://gitee.com/ilgnefz/image-house/raw/master/images/pdx.jpg';

发现效果还是一样的。通过查看文档里的第一个链接中的例子，可以发现，这里需要传入图片的绝对路径。

那在 Flutter 中怎么获取文件的绝对路径呢🤔？当然，可以直接在 Android Studio 中选中图片点右键的 Copy Path，但是程序被打包安装后就不一定在这个位置了。学过Node.js，在里面获取文件的绝对路径要用到 Path 模块，那么 Flutter 是否也用同样的插件。打开 pub.dev 搜索，还真有。复制到 pubspec.yaml 进行安装，报错，告诉我们 Flutter Desktop 中已经集成了该插件，但是版本不一样。😀那不就好办了，第一步导入：

import 'package:path/path.dart' as path;

path 中没有 __dirname 方法，可以通过path. 查看提示，发现有一个 current的方法。虽然我们不知道这个方法是干什么的，但也不妨试试。修改 imagePath 为如下代码：

final String _imagePath = path.join(path.current, 'assets/images/pdx.jpg');

成功🎉🎉🎉🎉🎉

接下来使用 imageAndText02 类型来看看：

toast = await WinToast.instance().showToast(

  type: ToastType.imageAndText02,

  title: _titles,

  subtitle: _subtitle,

  imagePath: _imagePath,

  actions: _action,

);

imageAndText03 和 imageAndText04 显示的效果也和 imageAndText02 无差别，这里就不放图了。

大家可能已经发现，通知中的3个按钮是由 actions 参数决定的，但是这个参数传入的是 String 类型，那我们要怎么才能获取到用户对这些按钮的点击事件呢？

前期我们定义了一个toast对象用来赋值，接下来就要用到这个参数：

if (toast != null) {

  toast.eventStream.listen((event) {

    if (event is ActivatedEvent) {

      print(event);

    }

  });

}

在这里我们会获得一个 event 对象，通过打印会发现该对象下面只有一个属性actionIndex，返回的是 int? 类型。通过该属性，我们就可以获取到用户点击的是第几个按钮：

WinToast.instance().bringWindowToFront(); // 用户点击后关闭弹窗通知

BotToast.showText(text: '你当前的状态是${_action[event.actionIndex!]}');

知道了用户点击的是哪个按钮，接下来编写事件的代码就容易了。

🛫OK，以上就是这篇文章的全部内容，仅针对插件的当前版本，并不能保证适用于以后插件用法的更新迭代。本人只处于对代码的实践部分，如某些内容的概念或叫法出错还请指正🙏。

最后，感谢 lijy91 和 boyan01 对以上插件的维护和开发😁。本程序相关代码已上传至 github 和 gitee，有需要的可以下载下来查看学习。

先上效果图

源码
github.com/woshiwzy/Ca…

实现原理：

1.继承LinearLayout

2.重写onLayout，onMeasure 方法

3.利用ValueAnimator 实施动画

4.在动画回调中requestLayout 实现动画效果

思路：

1.用Bounds 对象记录每一个CardView 对象的初始位置，当前位置，运动目标位置

2.点击时计算出对应的view以及可能会产生关联运动的View的运动的目标位置，从当前位置运动到目标位置，然后以这2个位置作为动画参数实施ValueAnimator动画，在动画回调中触发onLayout，达到动画的效果。

重写adView 方法，确保新添加的在这里确保所有的子view 都有一个初始化的bounds位置

   @Override

    public void addView(View child, ViewGroup.LayoutParams params) {

        super.addView(child, params);

        Bounds bounds = getBunds(getChildCount());

    }

确保每个子View的测量属性宽度填满父组件

    boolean mesured = false;

    @Override

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        if (mesured == true) {//只需要测量一次

            return;

        }

        mesured = true;

        int childCount = getChildCount();

        int rootWidth = getWidth();

        int rootHeight = getHeight();

        if (childCount > 0) {

            View child0 = getChildAt(0);

            int modeWidth = MeasureSpec.getMode(child0.getMeasuredWidth());

            int sizeWidth = MeasureSpec.getSize(child0.getMeasuredWidth());



            int modeHeight = MeasureSpec.getMode(child0.getMeasuredHeight());

            int sizeHeight = MeasureSpec.getSize(child0.getMeasuredHeight());



            if (childCount > 0) {

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

                    View childView = getChildAt(i);

                    childView.measure(MeasureSpec.makeMeasureSpec(sizeWidth, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(sizeHeight, MeasureSpec.EXACTLY));

                    int top = (int) (i * (sizeHeight * carEvPercnet));

                    getBunds(i).setTop(top);

                    getBunds(i).setCurrentTop(top);

                    getBunds(i).setLastCurrentTop(top);

                    getBunds(i).setHeight(sizeHeight);

                }



            }



        }

    }

重写onLayout 方法是关键，是动画触发的主要目的，这里layout参数并不是写死的，而是计算出来的（通过ValueAnimator 计算出来的）

@Override

    protected void onLayout(boolean changed, int sl, int st, int sr, int sb) {

        int childCount = getChildCount();

        if (childCount > 0) {

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

                View view = getChildAt(i);

                int mWidth = view.getMeasuredWidth();

                int mw = MeasureSpec.getSize(mWidth);

                int l = 0, r = l + mw;

                view.layout(l, getBunds(i).getCurrentTop(), r, getBunds(i).getCurrentTop() + getBunds(i).getHeight());

            }

        }

    }

源码

github：
github.com/woshiwzy/Ca…

一、前言

• 观察者模式
  
  
  
  • 作用：定义了一个一对多的依赖关系，让一个或多个观察者对象监听一个主题对象。这样一来，当被观察者状态发生改变时，需要通知相应的观察者，使这些观察者对象能够自动更新。
  
  
  • 核心操作：
    
    
    
    • 观察者（订阅者）添加或删除对 被观察者（主题）的状态监听
    
    
    • 被观察者（主题）状态改变时，将事件通知给所有观察者，观察者执行响应逻辑
    
    
    
    
  
  
  
  

二、使用观察者模式

• 例子：监听股票价格变动


• 重点：使用 Java API 或 自定义实现 观察者模式

1、使用 Java API 实现观察者模式

Java 标准库中提供了通用观察者模式的 API，分别是：

• java.util.Observable：被观察者（主题）
  
  
  
  • setChanged()：标记状态更新
  
  
  • addObserver()：添加观察者
  
  
  • deleteObserver()：删除观察者
  
  
  • countObservers()：获取观察者数量
  
  
  • notifyObservers()：通知所有观察者
  
  
  • notifyObservers(Object arg)：通知所有观察者（携带参数 arg）
  
  
  
  


• java.util.Observer：观察者（订阅者）

利用 Java API，可以实现监听股票价格变动这个功能：

import java.util.Observable

import java.util.Observer



/**

 * 被观察者（主题）

 *

 * @author GitLqr

 */

class StockSubject : Observable() {

    fun changeStockPrice(price: Int) {

        this.setChanged() // 标识状态更新

        this.notifyObservers(price) // 通知所有观察者当前股票价格

    }

}



/**

 * 观察者（订阅者）

 *

 * @author GitLqr

 */

class StockDisplay(val name: String) : Observer {

    override fun update(o: Observable?, price: Any?) {

        println("$name receive stock price : $price") // 注意 price 的类型是 Any?

    }

}



// 使用

val subject = StockSubject()

subject.addObserver(StockDisplay("observer 1"))

subject.addObserver(StockDisplay("observer 2"))

subject.changeStockPrice(200)



// 输出

// observer 2 receive stock price : 200

// observer 1 receive stock price : 200

注意：在主题中通过 notifyObservers() 方法通知订阅者之前，需要先调用 setChanged() 标识状态更新，才能正常通知给订阅者，这是使用 Java API 实现观察者模式时需要注意的一点。

Java 提供的 API 已经涵盖了观察者模式的完整实现，所以我们在使用的时候，只需要关注业务本身，而不用自己去做模式的具体实现，但是呢，Java 提供的 API 是一种通用实现，从上面的例子中可以注意到，StockDisplay.update(o: Observable?, price: Any?) 中的 price 参数类型是 Any? ，这就会有以下几个问题：

• 参数判断：因为参数类型是 Any?，所以开发中不得不对 参数是否为空 以及 参数的实际类型 做判断。


• 通知入口单一：实际业务需求会更加复杂，而 java.util.Observer 只有唯一一个通知入口 update(o: Observable?, arg: Any?)，所以我们不得不在该方法中分离响应逻辑，比如股票价格升降，这会让代码显得臃肿。

2、自定义实现观察者模式

虽然 Java 提供了现成的观察者模式 API，但是实际开发中，我们通常还是会自定义实现观察者模式，以便更好的控制代码结构：

/**

 * 回调接口（解耦业务通知入口）

 *

 * @author GitLqr

 */

interface StockUpdateListener {

    fun onRise(price: Int)

    fun onFall(price: Int)

}



/**

 * 被观察者（主题）

 *

 * @author GitLqr

 */

class StockSubject {

    val listeners = mutableSetOf<StockUpdateListener>()

    var price: Int = 0



    fun subscribe(observer: StockUpdateListener) {

        listeners.add(observer)

    }



    fun unsubscribe(observer: StockUpdateListener) {

        listeners.remove(observer)

    }



    fun changeStockPrice(price: Int) {

        val isRise = price > this.price

        listeners.forEach { if (isRise) it.onRise(price) else it.onFall(price) }

        this.price = price

    }

}



/**

 * 观察者（订阅者）

 *

 * @author GitLqr

 */

class StockDisplay : StockUpdateListener {

    override fun onRise(price: Int) {

        println("The latest stock price has rise to $price")

    }



    override fun onFall(price: Int) {

        println("The latest stock price has fell to $price")

    }

}



// 使用

val subject = StockSubject()

subject.subscribe(StockDisplay())

subject.changeStockPrice(200) // The latest stock price has rise to 200

可见，自定义实现观察者模式，可以让代码结构变得更加简单直观。

三、改良观察者模式

• 例子：监听股票价格变动


• 重点：委托属性 Delegates.observable()

Kotlin 标准库引入了可被观察的委托属性，可通过 xxx by Delegates.observable() 的方式，用来监听 xxx 属性的改变，于是可以用来改良上面的自定义观察者模式：

import kotlin.properties.Delegates



/**

 * 观察者模式改良：使用委托属性监听值变化后通知

 *

 * @author GitLqr

 */

class StockSubject {

    val listeners = mutableSetOf<StockUpdateListener>()



    var price: Int by Delegates.observable(0) { prop, old, new ->

        val isRise = new > old

        listeners.forEach { if (isRise) it.onRise(price) else it.onFall(price) }

    }



    fun subscribe(observer: StockUpdateListener) {

        listeners.add(observer)

    }



    fun unsubscribe(observer: StockUpdateListener) {

        listeners.remove(observer)

    }



    // fun changeStockPrice(price: Int) { ... }

}



// 使用

val subject = StockSubject()

subject.subscribe(StockDisplay())

subject.price = 250 // The latest stock price has rise to 200

使用 Delegates.observable() 之后，StockSubject 相比之前减少了一个 changeStockPrice() 方法。使用上，一旦对 price 属性赋值，就可以触发通知，显然，这对使用者更加友好了（直观，少记一个方法）。

四、补充

前面说到，Kotlin 标准库引入可被观察的委托属性，除了 Delegates.observable() 之外，还有
Delegates.vetoable() 也很实用，当我们不希望被监控的属性被随意修改时，就可以用它来否决属性赋值：

import kotlin.properties.Delegates



var value: Int by Delegates.vetoable(0) { prop, old, new ->

    // 新值大于0时，才给属性赋值

    new > 0

}



// 使用

value = 1

println(value) // 1

value = -1

println(value) // 1（没能赋值成功）

在一个类中，为了不让外界访问到某些属性和方法，通常将其设置为private，用正常的方式（对象名.属性名，对象名.方法名）将无法访问此属性与方法，但有没有其他方法可以访问呢？答案是有的，这就是java反射带来的便利。利用反射访问类的私有属性及方法如下：

/**  * @Description: 反射  * @author: Mr_VanGogh  */

public class Reflect {

 

    private String name;

    private int age;

 

    private Reflect(int age) {

        this.age = age;

    }

 

    private void speak(String name) {

        System.out.println("My name is" + name);

    }

 

    public Reflect(String name) {

        this.name = name;

    }

}

首先，我们要了解三个反射包中的类：

• Constructor：代表类的单个构造方法，通过Constructor我们可执行一个类的某个构造方法（有参或者无参）来创建对象时。


• Method：代表类中的单个方法，可以用于执行类的某个普通方法，有参或无参，并可以接收返回值。


• Field：代表类中的单个属性，用于set或get属性


• AccessibleObject：以上三个类的父类，提供了构造方法，普通方法，和属性的访问控制的能力。

使用Class类中的方法可以获得该类中的所有Constructor对象，Method对象，和Field对象。但是任然无法访问私有化的构造方法，普通方法，和私有属性，此时我们可以使用他们继承父类(AccessibleObject)中的setAccessible（）方法，来设置或取消访问检查，以达到访问私有对象的目的。

public static void main(String[] args)  throws Exception {

 

        Reflect reflect = new Reflect("a");

 

        Method[] methods = Reflect.class.getMethods();

        Field[] fields = Reflect.class.getDeclaredFields();

 

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

            fields[i].setAccessible(true);

            System.out.println(fields[i].getName());

        }

 

        for (int j = 0; j < methods.length; j ++) {

            methods[j].setAccessible(true);

            System.out.println(methods[j].getName());

 

            methods[j].invoke(reflect);

            System.out.println(methods[j].getName());

        }

    }

这样，我们就获得了私有属性的值

当然，凡事有利就有弊，然后我们再来说一下java反射的优缺点；

优点：

• 能够运行时动态获取类的实例，大大提高了系统的灵活性和扩展性；


• 与java动态编译相结合，可以实现无比强大的功能。

缺点：

• 使用反射的性能较低；


• 使用反射来说相对不安全；


• 破坏了类的封装性，可以通过反射来获取这个类的属性，和私有方法。

Q：private修饰的方法可以通过反射访问，那么private的意义是什么？

A：

1、Java的private修饰符不是为了绝对安全设计的，而是对用户常规使用Java的一种约束。就好比饭店厨房门口挂着“闲人免进”的牌子，但是你还是能够通过其他方法进去。

2、从外部对对象进行常规调用时，能够看到清晰的类结构

快慢指针是双指针的一种典型用法，通常控制两个指针以不同的速度移动来解决问题。采用快慢指针解决问题往往都很巧妙。本文我们通过分析几个例子来学习快慢指针的用法，并分析其本质，最终达到方便记忆、灵活使用的目的。

接下来我们先看四个例子：判断链表是否有环、寻找链表中环的入口、寻找链表的中间结点、寻找链表的倒数第 n 个结点。

判断链表是否有环

题目（来源Leetcode）

“给你一个链表的头结点 head ，判断链表中是否有环。

如果链表中有某个结点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。”

环形链表：leetcode-cn.com/problems/li…

分析

这道题有两种常见解法：1. 哈希表 2. 快慢指针。我们主要分析快慢指针的解法：

我们定义两个指针：一个移动的慢叫慢指针，一个移动的快叫快指针。慢指针在链表中一次移动一个结点，快指针在链表中一次移动两个结点，如果两个指针最终相遇了，说明有环；如果快指针顺利到达了链表的终点说明没有环。

相遇：快指针 = 慢指针；到达终点：快指针的下一个结点为Null。

要想理解这个解决办法需要先了解：Floyd 判圈算法。

Floyd 判圈算法又称为龟兔赛跑算法（Tortoise and Hare Algorithm）。乌龟跑得慢、兔子跑得快。乌龟和兔子在赛跑，如果存在环的话，兔子必然会追上乌龟（乌龟被套圈了）。

我们把乌龟比作慢指针、兔子比作快指针同时在链表中移动。跑步和指针移动不太相同的是，跑步的路程是连续的，快指针一次移动两个结点是不连续的。又反过来想一下如果链表中存在环，那最小的环也需要两个结点，所以对于是否有环来说快指针一次移动两个结点也是不会错过任何一个环的。而且环的结点不管是奇数还是偶数个，快指针也最终会和慢指针在某个结点重合。

答案

基于上面的分析我们给出代码如下：

func hasCycle(head *ListNode) bool {

    if head == nil || head.Next == nil { // 如果链表有0个或者1个结点，则链表不存在环

        return false

    }

    slowPoint, fastPoint := head, head.Next // 定义快慢指针

    for fastPoint != slowPoint { // 如果快慢指针相等则结束循环，证明有环

        if fastPoint == nil || fastPoint.Next == nil { // 如果快指针到达终点或者终点前的倒数第一个结点，说明没有环

            return false

        }

        slowPoint = slowPoint.Next

        fastPoint = fastPoint.Next.Next

    }

    return true

}

寻找链表中环的入口

题目（来源Leetcode）

“给定一个链表的头结点 head ，返回链表开始入环的第一个结点。 如果链表无环，则返回 null。

如果链表中有某个结点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。”

环形链表 II：leetcode-cn.com/problems/li…

分析

这道题和上题一样，通常有哈希表、快慢指针两种解法。我们主要分析快慢指针的解法：

我们定义两个指针：一个移动的慢叫慢指针，一个移动的快叫快指针。慢指针在链表中一次移动一个结点，快指针在链表中一次移动两个结点，如果两个指针最终相遇了，说明有环；如果快指针顺利到达了链表的终点说明没有环。

当有环存在时，我们假设快慢指针在 D 点相遇。a 代表入环之前的长度，b 代表慢指针进入环后又走了b的长度，c 代表环余下的长度。指针的指向是圆的顺时针方向。

1. 如果快指针和慢指针在 D 点相遇，此时快指针比慢指针多走了 n 圈，也就是 n*(b+c) 的长度。


2. 此时快指针走过的距离是 a+n*(b+c)+b，慢指针走过的距离是 a+b。


3. 因为快指针每次走两步，慢指针每次走一步，所以快指针走过的距离永远是慢指针的两倍，所以 a+n* (b+c)+b=2(a+b)*


4. 上述公式可以推导出a = (n-1)*(b+c)+c，也就是a的长度是恰好是 n-1 圈环的长度加上从 D 点到相遇点的距离。

根据上面的推论，当快慢指针相遇之后，我们再申请一个指针从链表的头部开始，每次移动一个结点，同时慢指针一次移动一个结点，这两个指针最终的相遇点就是环的入口点。

答案

func detectCycle(head *ListNode) *ListNode {

    slowPoint, fastPoint := head, head

    for fastPoint != nil && fastPoint.Next != nil { // 如果快指针到达终点或者终点前的倒数第一个结点，说明没有环。

        slowPoint = slowPoint.Next

        fastPoint = fastPoint.Next.Next

        if fastPoint == slowPoint { // 如果快慢指针相等，说明有环，后面开始寻找环的入口。

            delectPoint := head

            for delectPoint != slowPoint { // 慢指针和从头开始的delectPoint指针相等，则说明当前结点就是环的入口。

                delectPoint = delectPoint.Next

                slowPoint = slowPoint.Next

            }

            return delectPoint

        }

    }

    return nil

}

寻找链表的中间结点

题目（来源Leetcode）

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

链表的中间结点：leetcode-cn.com/problems/mi…

分析

这道题有多种解法，但是快慢指针的解法十分巧妙。我们定义两个指针：一个移动的慢叫慢指针，一个移动的快叫快指针。慢指针在链表中一次移动一个结点，快指针在链表中一次移动两个结点。因为快指针移动的距离始终是慢指针的两倍，所以当快指针移动到链表尾部时，慢指针刚好在链表中间位置。

答案

func middleNode(head *ListNode) *ListNode {

    slowPoint, fastPoint := head, head

    for fastPoint!= nil && fastPoint.Next != nil{

        slowPoint = slowPoint.Next

        fastPoint = fastPoint.Next.Next

    }

    return slowPoint

}

寻找链表的倒数第 N 个结点

题目

给你一个链表，找到链表的倒数第 n 个结点并返回。

分析

这道题有多种解法，但是快慢指针的解法十分巧妙。我们定义两个指针：两个指针每次移动一个结点。我们让其中一个指针先移动 n 个结点，先移动的这个指针我们叫它快指针，另外一个叫慢指针。然后两个指针同时移动。因为移动速度相同所以两个指针之间的距离始终是 n ，当快指针到达链表尾部时，慢指针刚好指向了链表的倒数第 n 个结点。

这里叫“快慢指针”有点牵强，感觉叫前后指针更合适，不过为了方便记忆就先归为快慢指针吧。

答案

func findNthFromEnd(head *ListNode, n int) *ListNode {

    fastPoint,slowPoint := node,node

    for i:=0; i<n+1; i++{

        fastPoint  = fastPoint.Next

    }

    for fastPoint != nil {

        fastPoint=  fastPoint.Next

        slowPoint = slowPoint.Next

    }

    return slowPoint

}

总结

本文我们介绍了快慢指针的常见用法：

1. 利用 Floyd 判圈算法找环。


2. 利用 Floyd 判圈算法找环的入口。


3. 寻找链表的中间结点。


4. 寻找链表的倒数第 n 个结点。

在 Floyd 判圈算法中，把判断环的问题抽象成两个指针围绕环运动最终会相遇的问题，通过环形跑道这个生动场景解决了问题；在寻找链表中间节点时，利用两个指针的速度差，使一个指针运动的距离始终是另外一个指针的一半，用指针的速度、路程解决了问题；在寻找链表倒数第 n 个节点时，让相同速度的两个指针始终保持 n 的相对距离，把链表问题抽象成了距离问题。

这几种方法都是把算法问题抽象成了两个指针的距离、速度问题，最终通过数学公式推导得出结论。推而广之，我们以后遇到链表的相关问题也可以采用类似的方式去抽象问题，推导解决办法。

前言

Android开发发展到今天已经相当成熟了，各种架构大家也都耳熟能详，如MVC,MVP,MVVM等，其中MVVM更是被官方推荐，成为Android开发中的显学。

不过软件开发中没有银弹，MVVM架构也不是尽善尽美的，在使用过程中也会有一些不太方便之处，而MVI可以很好的解决一部分MVVM的痛点。

本文主要包括以下内容

1. MVC,MVP,MVVM等经典架构介绍


2. MVI架构到底是什么?


3. MVI架构实战

需要重点指出的是,标题中说MVI架构是MVVM的进阶版是指MVI在MVVM非常相似，并在其基础上做了一定的改良，并不是说MVI架构一定比MVVM适合你的项目

各位同学可以在分析比较各个架构后，选择合适项目场景的架构

经典架构介绍

MVC架构介绍

MVC是个古老的Android开发架构，随着MVP与MVVM的流行已经逐渐退出历史舞台，我们在这里做一个简单的介绍,其架构图如下所示：



MVC架构主要分为以下几部分

1. 视图层（View）：对应于xml布局文件和java代码动态view部分


2. 控制层（Controller）：主要负责业务逻辑，在android中由Activity承担，同时因为XML视图功能太弱，所以Activity既要负责视图的显示又要加入控制逻辑，承担的功能过多。


3. 模型层（Model）：主要负责网络请求，数据库处理，I/O的操作，即页面的数据来源

由于android中xml布局的功能性太弱,Activity实际上负责了View层与Controller层两者的工作，所以在android中mvc更像是这种形式：



因此MVC架构在android平台上的主要存在以下问题：

1. Activity同时负责View与Controller层的工作，违背了单一职责原则


2. Model层与View层存在耦合，存在互相依赖，违背了最小知识原则

MVP架构介绍

由于MVC架构在Android平台上的一些缺陷，MVP也就应运而生了,其架构图如下所示



MVP架构主要分为以下几个部分

1. View层：对应于Activity与XML,只负责显示UI,只与Presenter层交互，与Model层没有耦合


2. Presenter层： 主要负责处理业务逻辑，通过接口回调View层


3. Model层：主要负责网络请求，数据库处理等操作，这个没有什么变化

我们可以看到，MVP解决了MVC的两个问题，即Activity承担了两层职责与View层与Model层耦合的问题

但MVP架构同样有自己的问题

1. Presenter层通过接口与View通信，实际上持有了View的引用


2. 但是随着业务逻辑的增加，一个页面可能会非常复杂，这样就会造成View的接口会很庞大。

MVVM架构介绍

MVVM 模式将 Presenter 改名为 ViewModel，基本上与 MVP 模式完全一致。

唯一的区别是，它采用双向数据绑定（data-binding）：View的变动，自动反映在 ViewModel，反之亦然

MVVM架构图如下所示：



可以看出MVVM与MVP的主要区别在于,你不用去主动去刷新UI了，只要Model数据变了，会自动反映到UI上。换句话说，MVVM更像是自动化的MVP。

MVVM的双向数据绑定主要通过DataBinding实现，不过相信有很多人跟我一样，是不喜欢用DataBinding的，这样架构就变成了下面这样

1. View观察ViewModle的数据变化并自我更新,这其实是单一数据源而不是双向数据绑定，所以其实MVVM的这一大特性我其实并没有用到


2. View通过调用ViewModel提供的方法来与ViewMdoel交互

小结

1. MVC架构的主要问题在于Activity承担了View与Controller两层的职责，同时View层与Model层存在耦合


2. MVP引入Presenter层解决了MVC架构的两个问题，View只能与Presenter层交互，业务逻辑放在Presenter层


3. MVP的问题在于随着业务逻辑的增加，View的接口会很庞大，MVVM架构通过双向数据绑定可以解决这个问题


4. MVVM与MVP的主要区别在于,你不用去主动去刷新UI了，只要Model数据变了，会自动反映到UI上。换句话说，MVVM更像是自动化的MVP。


5. MVVM的双向数据绑定主要通过DataBinding实现，但有很多人(比如我)不喜欢用DataBinding，而是View通过LiveData等观察ViewModle的数据变化并自我更新,这其实是单一数据源而不是双向数据绑定

MVI架构到底是什么?

MVVM架构有什么不足?

要了解MVI架构，我们首先来了解下MVVM架构有什么不足

相信使用MVVM架构的同学都有如下经验，为了保证数据流的单向流动，LiveData向外暴露时需要转化成immutable的，这需要添加不少模板代码并且容易遗忘，如下所示

class TestViewModel : ViewModel() {

    //为保证对外暴露的LiveData不可变，增加一个状态就要添加两个LiveData变量

    private val _pageState: MutableLiveData<PageState> = MutableLiveData()

    val pageState: LiveData<PageState> = _pageState

    private val _state1: MutableLiveData<String> = MutableLiveData()

    val state1: LiveData<String> = _state1

    private val _state2: MutableLiveData<String> = MutableLiveData()

    val state2: LiveData<String> = _state2

    //...

}

如上所示，如果页面逻辑比较复杂，ViewModel中将会有许多全局变量的LiveData,并且每个LiveData都必须定义两遍，一个可变的，一个不可变的。这其实就是我通过MVVM架构写比较复杂页面时最难受的点。

其次就是View层通过调用ViewModel层的方法来交互的，View层与ViewModel的交互比较分散，不成体系

小结一下，在我的使用中，MVVM架构主要有以下不足

1. 为保证对外暴露的LiveData是不可变的，需要添加不少模板代码并且容易遗忘


2. View层与ViewModel层的交互比较分散零乱，不成体系

MVI架构是什么?

MVI 与 MVVM 很相似，其借鉴了前端框架的思想，更加强调数据的单向流动和唯一数据源,架构图如下所示



其主要分为以下几部分

1. Model: 与MVVM中的Model不同的是，MVI的Model主要指UI状态（State）。例如页面加载状态、控件位置等都是一种UI状态


2. View: 与其他MVX中的View一致，可能是一个Activity或者任意UI承载单元。MVI中的View通过订阅Model的变化实现界面刷新


3. Intent: 此Intent不是Activity的Intent，用户的任何操作都被包装成Intent后发送给Model层进行数据请求

单向数据流

MVI强调数据的单向流动，主要分为以下几步：

1. 用户操作以Intent的形式通知Model


2. Model基于Intent更新State


3. View接收到State变化刷新UI。

数据永远在一个环形结构中单向流动，不能反向流动：

上面简单的介绍了下MVI架构，下面我们一起来看下具体是怎么使用MVI架构的

MVI架构实战

总体架构图

我们使用ViewModel来承载MVI的Model层，总体结构也与MVVM类似,主要区别在于Model与View层交互的部分

1. Model层承载UI状态，并暴露出ViewState供View订阅，ViewState是个data class,包含所有页面状态


2. View层通过Action更新ViewState，替代MVVM通过调用ViewModel方法交互的方式

MVI实例介绍

添加ViewState与ViewEvent

ViewState承载页面的所有状态，ViewEvent则是一次性事件，如Toast等,如下所示

data class MainViewState(val fetchStatus: FetchStatus, val newsList: List<NewsItem>)  



sealed class MainViewEvent {

    data class ShowSnackbar(val message: String) : MainViewEvent()

    data class ShowToast(val message: String) : MainViewEvent()

}

1. 我们这里ViewState只定义了两个，一个是请求状态，一个是页面数据


2. ViewEvent也很简单，一个简单的密封类，显示Toast与Snackbar

ViewState更新

class MainViewModel : ViewModel() {

    private val _viewStates: MutableLiveData<MainViewState> = MutableLiveData()

    val viewStates = _viewStates.asLiveData()

    private val _viewEvents: SingleLiveEvent<MainViewEvent> = SingleLiveEvent()

    val viewEvents = _viewEvents.asLiveData()



    init {

        emit(MainViewState(fetchStatus = FetchStatus.NotFetched, newsList = emptyList()))

    }



    private fun fabClicked() {

        count++

        emit(MainViewEvent.ShowToast(message = "Fab clicked count $count"))

    }



    private fun emit(state: MainViewState?) {

        _viewStates.value = state

    }



    private fun emit(event: MainViewEvent?) {

        _viewEvents.value = event

    }

}

如上所示

1. 我们只需定义ViewState与ViewEvent两个State,后续增加状态时在data class中添加即可，不需要再写模板代码


2. ViewEvents是一次性的，通过SingleLiveEvent实现，当然你也可以用Channel当来实现


3. 当状态更新时，通过emit来更新状态