code
stringlengths 30
403k
| size
int64 31
406k
| license
stringclasses 10
values |
|---|---|---|
---
title: "Apache Asia Roadshow 2010归来"
wordpress_id: 1111
wordpress_url: http://www.wsria.com/?p=1111
date: 2010-08-15 00:06:37 +08:00
tags:
- apache
---
<h2>一、什么是Apache Roadshow？</h2>
是Apache基金会组织的一次以开源为主题的巡演。
<strong>参考日程</strong>：<a href="http://roadshowasia.52ac.com/openconf.php">http://roadshowasia.52ac.com/openconf.php</a>
<h2>二、我的日程</h2>
昨晚和群里面的dd(Tux)联系好了，互相留了电话号码；
早上7:30就起床（和上班一样），然后11路环保公交再换乘两次地铁终于冒着40°桑拿天于9:03到达会场——复旦大学行政楼；去年也曾去过一次复旦只不过是在新闻学院参加Wordpress举办的WordCamp，还认识了朋友<a href="http://whatmakeshua.com" target="_blank">皮蛋</a>和<a href="http://shawphy.com/" target="_blank">小飞</a>。
到了学院门口和dd(Tux)通了电话，这小子已经到了……然后到了一楼大厅看到已经来了不少人，都是20多岁的年轻人……
先来一张本次路演的牌子：
<a href="http://www.kafeitu.me/files/2010/08/Apache-Roadshow-2010-1.png"><img class="size-medium wp-image-1113 " title="Apache Roadshow 2010-1" src="http://www.kafeitu.me/files/2010/08/Apache-Roadshow-2010-1-261x300.png" alt="Apache Roadshow 201 LOGO" width="261" height="300" /></a>
<p style="text-align: center;"></p>
<a href="http://www.kafeitu.me/files/2010/08/Apache-Roadshow-2010-me.png"><img class="size-medium wp-image-1114" title="Apache Roadshow 2010-me" src="http://www.kafeitu.me/files/2010/08/Apache-Roadshow-2010-me-267x300.png" alt="我在Apache Roadshow 2010会场" width="267" height="300" /></a>
随后去报到、注册，这里面还有一个小插曲，本来是没有注册的人没有T恤、饭票的，但是有一个购书可以立即注册的机会，在大厅有几个童鞋负责卖书（真会找商机），看到《开源软件之道》这本书就有了想买的欲望，大致看了一下内容还可以就花了30大洋拿下这本书……买了书人家告诉俺说你可以注册了，也就是可以领取T恤和饭票了，我想还不错……30元买一本书、一件T恤外加一顿午餐……呵呵，言归正传
此行的目的我最关注的当然是<a href="http://www.juvenxu.com/" target="_blank">Juven</a>关于Maven的演讲也趁次机会瞅瞅传说中的群主，其次是关于企业RIA的介绍和Java的未来发展
<!--more-->
上午10:00准时开始本次巡演，首先由Apache基金会的J Aaron Farr介绍Apache开源之道，这里有一个惊喜，本人E文烂反正不好……勉强看懂英文文档……让我意想不到的是J Aaron Farr的中文竟然说的比较流利虽然有一些词语要用英文，但是已经是天上掉馅饼的事情了……J Aaron Farr说他一直在香港，好像有3年了吧
<a href="http://www.kafeitu.me/files/2010/08/apache-way-1.png"><img class="size-medium wp-image-1116" title="apache way-1" src="http://www.kafeitu.me/files/2010/08/apache-way-1-300x135.png" alt="J Aaron Farr简述The Apache Way" width="300" height="135" /></a>
<a href="http://www.kafeitu.me/files/2010/08/apache-way-2.png"><img class="size-medium wp-image-1117" title="apache way-2" src="http://www.kafeitu.me/files/2010/08/apache-way-2-300x223.png" alt="apache way-2" width="300" height="223" /></a>
之后就是上海市软件行业协会开源软件专业委员会一个XX博士倡议上海的高校高开源项目，最后是：Jason Gartner: Open Source and Business和Tim Ellison: Open Source Java and its Future
*******************************午饭时间*******************************
复旦餐厅做的牛排不错……哈哈
<h2>三、Juven关于Maven的演讲</h2>
听Juven演讲Maven是此行的主要目的，中午和dd一起吃完饭后去了演讲的教室……哎怀念老师讲课我睡觉的日子了
在上午的环节结束的时候和Juven认识了一下（和他握手肉感十足）
很认真的听了Juven的Maven演讲，但是由于时间不足（只有45分钟演讲和10分钟的讨论时间）讲的东西不多，都是概念性的东西，不过在这种场合也不适合讲解一下实际的东东……主要是介绍Apache的开源项目，Maven作为活跃度前三名的一个项目当然少不了
演讲期间我用相机录制了视频，不过由于本人的相机本身不是很好再加上没有摄影底子导致快门高了所以视频有些模糊，不过可以等Juven把PPT上传了对照一下……嘿嘿
如果需要视频的话可以回复本文留下Email地址，我会把视频发送到你的邮箱，附件存放在QQ中转站，不过有效期我会在失效前续期。
培训完了之后和Juven的合影，本人长的蟋蟀，别K俺：
<a href="http://www.kafeitu.me/files/2010/08/me-and-juven.png"><img class="size-medium wp-image-1122" title="me and juven" src="http://www.kafeitu.me/files/2010/08/me-and-juven-263x300.png" alt="me and juven" width="263" height="300" /></a>
<h2>四、其他演讲</h2>
听完了Juven的Maven演讲又去听了IBM的Wei Huang讲的：Enterprise Open RIA Solution - Introduction to Dojo Advanced Features，和Jing Lv讲的：Towards new world of Java - JDK7 features and Harmony Select
Dojo这个东西在刚刚接触Ajax的时候研究了一些，但是由于业界说Dojo的速度慢和当时对于Dojo的侵入性原因放弃了，所以后来开始了Ajax框架的使用，从Prototype到现在的jQuery
关于<em>JDK7 features and Harmony的演讲：</em>关于<a href="http://harmony.apache.org/" target="_blank">Harmony</a>我是第一次听到，同样也是Apache的一个开源项目，只不过这次是一个开源的JDK……抢了SUN的活所以一直未能拿到SUN（如今的Oracle）的License，严格来说这个真的不能算是演讲，介绍了一点点JDK7的新特性后就是开始为Harmony打广告了……但是结果是很多人都不敢使用，原因很简单，如下：
<ol>
<li>迁移后万一和SUN的JDK不兼容怎么办？</li>
<li>更新速度落后于SUN的JDK</li>
<li>性能方面是否能和SUN保持平衡或者超越，要不然没有理由让我们迁移</li>
<li>支持Harmony的企业毕竟不多，所以底子还太薄，虽然像Google的Andriod、IBM等公司使用了一些Harmony的功能但是那只是借鉴或者是抽取，并不能代表他们就支持……</li>
</ol>
所以综合来说目前还是不可能转移。
<h2>五、总结</h2>
感谢Apache和上海软件开源协会组织的这次路演让技术人员有了一个小范围的交流与分享平台，同样也在本次路演中认识了几个在业界的朋友，也见到了Maven群主Juven大仙。
不过想这样的演讲都是纯概念性的东西，如果只想了解一下或许符合你的胃口，希望以后能有专项的技术交流，比如Apache的个个子项目的应用或者企业中一些公共性的问题。
更多关于本次路演的照片请访问我的Picasa相册：<a href="http://picasaweb.google.com/yanhonglei/ApacheAsiaRoadshow2010">http://picasaweb.google.com/yanhonglei/ApacheAsiaRoadshow2010</a> | 4,358 | MIT |
# xzh-curl
:panda_face:针对百度熊掌号新接口请求封装（号主页展现、春笋计划优站扶持）
熊掌号项目已凉，号主页站点资讯存量内容会展示在更多tab下，新提交的不再进入
小时、天级、周级收录都还在，之前获得的权益也都保留，功能都在资源平台-移动专区
## 文件说明
`xzhome.php` 为号主页展现接口
`newgood.php` 为春笋计划优站扶持接口
使用前请确保你有对应的资格，没有提交了也没用 😜
## 使用方式
1、获取对应需要的文件，放到网站的可执行目录中
2、补全对应的参数
`$secret` 自定义验证需要的参数，防止接口泄露所用，注意保密
以下配置信息见：[https://ziyuan.baidu.com/xzh/home/index](https://ziyuan.baidu.com/xzh/home/index)
`$appid` 您的熊掌号唯一识别ID
`token` 在搜索资源平台申请的推送用的准入密钥
3、请求方式和传参
请求方式未作限制，`Get`和`Post`都可以
传参的问题说一下，参数顺序无所谓，具体如下：
* 号主页展现接口
```php
Get：xzhome.php?secret=test&url=https://qq52o.me/2530.html
Post：xzhome.php
url = https://qq52o.me/2530.html
secret = test
```
* 春笋计划优站扶持
```php
Get：newgood.php?url[]=https://qq52o.me/2530.html&url[]=https://qq52o.me/2529.html&secret=test
Post：newgood.php
url[] = https://qq52o.me/2530.html
url[] = https://qq52o.me/2529.html
secret = test
```
## 注意
确保网站进行了页面改造，并有如下`JSON-LD`代码
```javascript
<script type="application/ld+json">
{
"@context": "https://ziyuan.baidu.com/contexts/cambrian.jsonld",
"@id": "https://www.example.com/******",
"appid": "1583219371373511",
"title": "页面标题******",
"images": [
"https://www.example.com/***/pic1.png",
"https://www.example.com/***/pic2.png",
"https://www.example.com/***/pic3.png"
], //请在此处添加希望在搜索结果中展示图片的url，可以添加0个、1个或3个url
"pubDate": "2017-06-15T08:00:01" // 需按照yyyy-mm-ddThh:mm:ss格式编写时间，字母T不能省去
}
</script>
```
## 开源协议
[Apache-2.0](https://github.com/sy-records/xzh-curl/blob/master/LICENSE) | 1,622 | Apache-2.0 |
# MLCKit
MLCKit封装一些常用的iOS方法。
分成Cache、Category、Color、Document、Font、LocalFolder、Location、Macro、Photos、Proxy、Scan、TableView、UI、Utility等子pods。
Swift版本是[LCSKit](https://github.com/mlcldh/LCSKit)，功能基本相同。
## Cache
缓存管理类，基于YYCache。
提供了两个单例分别保存在Documents、Library文件夹，另外提供实例来设置自定义路径。
支持对缓存数据的同步/异步读取、设置。
```objective-c
/**单例，存放在Documents文件夹内，app设置里面清理缓存不可以删除的缓存*/
+ (instancetype)coreCache;
/**单例，存放在Library文件夹内，app设置里面清理缓存可以删除的缓存*/
+ (instancetype)simpleCache;
/**非单例，普通实例，自定义缓存路径，当path路径和coreCache、simpleCache重复时，返回nil*/
+ (instancetype)cacheWithPath:(NSString *)path;
```
`pod 'MLCKit/Cache'`
## Category
Category里面是常用类目，有URL编解码、UIView的点击回调、UIControl的点击block回调等。
### NSObject
使用归档、反归档进行序列化、反序列化的话，可以下面的方法：
```objective-c
@interface NSObject (MLCKit)
/**反序列化*/
- (void)mlc_setValuesWithCoder:(NSCoder *)aDecoder;
/**序列化*/
- (void)mlc_encodeWithCoder:(NSCoder *)aCoder;
/**转换成json字符串*/
- (NSString *)mlc_JSONString;
@end
```
### NSArray
```objective-c
@interface NSArray (MLCKit)
/**将数组的view根据先后顺序，根据相同间距连接起来*/
- (void)mlc_combineViewsWithAxis:(UILayoutConstraintAxis)axis withFixedSpacing:(CGFloat)fixedSpacing;
/**将数组的view根据先后顺序，根据数组fixedSpacings的间距连接起来*/
- (void)mlc_combineViewsWithAxis:(UILayoutConstraintAxis)axis withFixedSpacings:(NSArray <NSNumber *>*)fixedSpacings;
/**将数组的view根据先后顺序，数组的view的中心位置等间距*/
- (void)mlc_distributeViewsEqualCenterSpacingWithAxis:(UILayoutConstraintAxis)axis leadCenterSpacing:(CGFloat)leadCenterSpacing tailCenterSpacing:(CGFloat)tailCenterSpacing;
@end
```
### NSDate
```objective-c
@interface NSDate (MLCKit)
/**当前日期在当前日历的年*/
- (NSInteger)mlc_year;
/**当前日期在当前日历的月*/
- (NSInteger)mlc_month;
/**当前日期在当前日历的日*/
- (NSInteger)mlc_day;
/**当前日期在当前日历的组成成份，成份有年、月、日、时、分、秒、星期等等*/
- (NSDateComponents *)mlc_components:(NSCalendarUnit)unitFlags;
/**当前日期在农立的组成成份，成份有年、月、日、时、分、秒、星期等等*/
- (NSDateComponents *)mlc_chineseComponents:(NSCalendarUnit)unitFlags;
/**是否是今天*/
- (BOOL)mlc_isToday;
/**是否是昨天*/
- (BOOL)mlc_isYesterday;
/**和日期date是否是同一年*/
- (BOOL)mlc_isSameYearWithDate:(NSDate *)date;
/**当前日期的基础上，增加天数，天数可以是负数*/
- (NSDate *)mlc_dateByAddingDays:(NSInteger)days;
/**当前日期的基础上，增加月数，月数可以是负数*/
- (NSDate *)mlc_dateByAddingMonths:(NSInteger)months;
/**当前日期的基础上，增加年数，年数可以是负数*/
- (NSDate *)mlc_dateByAddingYears:(NSInteger)years;
/**格式化后的字符串*/
- (NSString *)mlc_stringWithFormat:(NSString *)format;
@end
```
### NSString
使用URL编解码的话，可以使用下面的方法：
```objective-c
@interface NSString (MLCKit)
/**URL编码*/
- (NSString *)mlc_urlEncode;
/**URL解码*/
- (NSString *)mlc_urlDecode;
/**使用SHA1计算hash*/
- (NSString *)mlc_sha1String;
/**将json字符串转换成字典或数组等*/
- (id)mlc_JSONObject;
@end
```
### UIControl
通过block获取UIControl及其子类的事件回调。UIControl的子类有UIButton、UISwitch、UISlider、UISegmentedControl、UIPageControl、UITextField、UIDatePicker等。
```objective-c
@interface UIControl (MLCKit)
/**点击回调*/
@property (nonatomic, copy) void(^mlc_touchUpInsideBlock)(void);
/**添加事件*/
- (void)mlc_addActionForControlEvents:(UIControlEvents)controlEvents handler:(void(^)(id sender))handler;
/**移除某些类型的所有事件*/
- (void)mlc_removeAllActionsForControlEvents:(UIControlEvents)controlEvents;
/**移除所有事件*/
- (void)mlc_removeAllActions;
@end
```
### UIView
通过block获取UIView及其子类的手势回调；移除某一些约束。
```objective-c
/**手势类型枚举 */
typedef NS_ENUM(NSInteger, MLCGestureRecognizerType) {
MLCGestureRecognizerTypeTap = 0,//
MLCGestureRecognizerTypeLongPress = 1,//
MLCGestureRecognizerTypePan = 2,//
MLCGestureRecognizerTypeSwipe = 3,//
MLCGestureRecognizerTypeRotation = 4,//
MLCGestureRecognizerTypePinch = 5,//
};
@interface UIView (MLCKit)
/**添加手势及其回调*/
- (UIGestureRecognizer *)mlc_addGestureRecognizerWithType:(MLCGestureRecognizerType)type handler:(void(^)(UIGestureRecognizer *recognizer))handler;
/**移除某些类型手势及其回调*/
- (void)mlc_removeGestureRecognizersWithType:(MLCGestureRecognizerType)type;
/**移除所有手势及其回调*/
- (void)mlc_removeAllGestureRecognizers;
/**移除自己的某一些约束*/
- (void)mlc_removeConstraintsWithFirstItem:(id)firstItem firstAttribute:(NSLayoutAttribute)firstAttribute;
/**移除firstItem是自己的某一些约束*/
- (void)mlc_removeConstraintsWithFirstAttribute:(NSLayoutAttribute)firstAttribute secondItem:(id)secondItem;
/**添加约束*/
- (void)mlc_addConstraintWithFirstAttribute:(NSLayoutAttribute)firstAttribute relation:(NSLayoutRelation)relation secondItem:(id)secondItem secondAttribute:(NSLayoutAttribute)secondAttribute multiplier:(CGFloat)multiplier constant:(CGFloat)constant;
/**返回离两个view最近的父视图*/
- (instancetype)mlc_closestCommonSuperview:(UIView *)view;
/**加部分圆角*/
- (void)mlc_becomeRoundedbyRoundingCorners:(UIRectCorner)corners cornerRadius:(CGFloat)cornerRadius;
- (void)mlc_becomeRoundedbyRoundingCorners:(UIRectCorner)corners cornerRadius:(CGFloat)cornerRadius size:(CGSize)size;
@end
```
### UIViewController
```objective-c
@interface UIViewController (MLCKit)
/**弹出alert*/
- (void)mlc_showAlertWithTitle:(NSString *)title message:(NSString *)message actionTitle:(NSString *)actionTitle handler:(void (^)(void))handler;
/**弹出confirm，一个选项*/
- (void)mlc_showConfirmWithTitle:(NSString *)title message:(NSString *)message confirmTitle:(NSString *)confirmTitle confirmHandler:(void (^)(void))confirmHandler cancelTitle:(NSString *)cancelTitle cancelHandler:(void (^)(void))cancelHandler;
/**弹出confirm，多个选项*/
- (void)mlc_showConfirmWithTitle:(NSString *)title message:(NSString *)message optionTitles:(NSArray<NSString *> *)optionTitles optionsHandler:(void (^)(NSInteger index))optionsHandler cancelTitle:(NSString *)cancelTitle cancelHandler:(void (^)(void))cancelHandler;
/**弹出prompt，一个输入框*/
- (void)mlc_showPromptWithTitle:(NSString *)title message:(NSString *)message configurationHandler:(void (^)(UITextField *textField))configurationHandler resultHandler:(void (^)(BOOL isCancel, NSString *result))resultHandler;
/**弹出prompt，多个输入框*/
- (void)mlc_showPromptWithTitle:(NSString *)title message:(NSString *)message textFieldCount:(NSInteger)textFieldCount configurationHandler:(void (^)(UITextField *textField, NSInteger index))configurationHandler resultHandler:(void (^)(BOOL isCancel, NSArray<NSString *> *results))resultHandler;
@end
```
`pod 'MLCKit/Category'`
## Color
颜色相关。
```objective-c
/**将UIColorPickerViewController协议方法通过block回调出来*/
API_AVAILABLE(ios(14.0))
@interface MLCColorPickerViewControllerManager : NSObject<UIColorPickerViewControllerDelegate>
/***/
@property (nonatomic, weak, readonly) UIColorPickerViewController *pickerViewController;
/**选取回调*/
@property (nonatomic, copy) void(^didSelectColorHandler)(void);
/**完成回调*/
@property (nonatomic, copy) void(^didFinishHandler)(void);
/**初始化方法*/
- (instancetype)initWithPickerViewController:(UIColorPickerViewController *)pickerViewController;
@end
```
`pod 'MLCKit/Color'`
## Document
文件相关。
```objective-c
/**将UIDocumentPickerViewController协议方法通过block回调出来*/
@interface MLCDocumentPickerViewControllerManager : NSObject<UIDocumentPickerDelegate>
/***/
@property (nonatomic, weak, readonly) UIDocumentPickerViewController *pickerViewController;
/**选取回调*/
@property (nonatomic, copy) void(^didPickDocumentsHandler)(NSArray<NSURL *> *urls);
/**取消回调*/
@property (nonatomic, copy) void(^wasCancelledHandler)(void);
/**初始化方法*/
- (instancetype)initWithPickerViewController:(UIDocumentPickerViewController *)pickerViewController;
@end
```
`pod 'MLCKit/Document'`
## Font
字体相关。
```objective-c
/**将UIFontPickerViewController协议方法通过block回调出来*/
API_AVAILABLE(ios(13.0))
@interface MLCFontPickerViewControllerManager : NSObject<UIFontPickerViewControllerDelegate>
/***/
@property (nonatomic, weak, readonly) UIFontPickerViewController *pickerViewController;
/**选取回调*/
@property (nonatomic, copy) void(^didPickFontHandler)(void);
/**取消回调*/
@property (nonatomic, copy) void(^didCancelHandler)(void);
/**初始化方法*/
- (instancetype)initWithPickerViewController:(UIFontPickerViewController *)pickerViewController;
@end
```
`pod 'MLCKit/Font'`
## LocalFolder
LocalFolder里面有查看app沙盒文件的视图控制器。
如果想查看整个app沙盒文件，可以如下调用：
```objective-c
NSString *folderPath = NSHomeDirectory();
MLCLocalFolderViewController *localFolderVC = [[MLCLocalFolderViewController alloc]initWithFolderPath:folderPath];
[self.navigationController pushViewController:localFolderVC animated:YES];
```
`pod 'MLCKit/LocalFolder'`
## Location
```objective-c
/**定位管理*/
@interface MLCLocationManager : NSObject
/**单例*/
+ (instancetype)sharedInstance;
/**更新位置回调*/
@property (nonatomic, copy) BOOL(^didUpdateLocationsHandler)(NSArray<CLLocation *> *locations);
/**失败回调*/
@property (nonatomic, copy) void(^didFailHandler)(NSError *error);
/**开始更新位置*/
- (void)startUpdatingLocation;
/**停止更新位置*/
- (void)stopUpdatingLocation;
@end
```
`pod 'MLCKit/Location'`
## Macro
Macro里有只在Debug环境下打印NSLog，还有weakify、strongify。
`pod 'MLCKit/Macro'`
## Photos
相册、相机相关。
### 权限
#### 相册权限
判断相册权限，可以如下调用：
```objective-c
[MLCPhotoPermissionManager requestPermissionWithSourceType:(UIImagePickerControllerSourceTypePhotoLibrary) sourceTypeUnavailableHandler:^{
NSLog(@"当前设备没有相册功能");
} isNotDeterminedHandler:^{
NSLog(@"相册权限之前还未处理");
} handler:^(BOOL success, BOOL isLimited) {
if (success) {
NSLog(@"已经获得相册权限");
if (isLimited) {
NSLog(@"读取相册受限");
}
} else {
NSLog(@"相册权限被拒绝");
}
}];
```
判断相册权限，并且在权限被拒绝时弹出alert提醒，可以如下调用：
```objective-c
[MLCPhotoPermissionManager requestPermissionWithSourceType:(UIImagePickerControllerSourceTypePhotoLibrary) handler:^(BOOL isLimited) {
NSLog(@"已经获得相册权限");
if (isLimited) {
NSLog(@"读取相册受限");
}
} fromViewController:self];
```
#### 相机权限
判断相机权限，可以如下调用：
```objective-c
[MLCPhotoPermissionManager requestPermissionWithSourceType:(UIImagePickerControllerSourceTypeCamera) sourceTypeUnavailableHandler:^{
NSLog(@"当前设备没有相机功能");
} isNotDeterminedHandler:^{
NSLog(@"相机权限之前还未处理");
} handler:^(BOOL success, BOOL isLimited) {
if (success) {
NSLog(@"已经获得相机权限");
if (isLimited) {
NSLog(@"读取受限");
}
} else {
NSLog(@"相机权限被拒绝");
}
}];
```
判断相机权限，并且在权限被拒绝时弹出alert提醒，可以如下调用：
```objective-c
[MLCPhotoPermissionManager requestPermissionWithSourceType:(UIImagePickerControllerSourceTypeCamera) handler:^(BOOL isLimited) {
NSLog(@"已经获得相机权限");
} fromViewController:self];
```
### PHPickerViewController
MLCPHPickerViewControllerManager将PHPickerViewController的协议方法回调改成了block回调：
```objective-c
/**将PHPickerViewController协议方法通过block回调出来*/
API_AVAILABLE(ios(14))
@interface MLCPHPickerViewControllerManager : NSObject<PHPickerViewControllerDelegate>
/***/
@property (nonatomic, weak, readonly) PHPickerViewController *pickerViewController;
/**选取回调*/
@property (nonatomic, copy) void(^didFinishPickingHandler)(NSArray<PHPickerResult *> *results);
/**初始化方法*/
- (instancetype)initWithPickerViewController:(PHPickerViewController *)pickerViewController;
@end
```
### UIImagePickerController
MLCImagePickerControllerManager将UIImagePickerController的协议方法回调改成了block回调：
```objective-c
/**
* 将UIImagePickerController部分协议方法通过block回调出来
* 想扩展到更多部分协议方法的话，可以继承该类
*/
@interface MLCImagePickerControllerManager : NSObject<UINavigationControllerDelegate, UIImagePickerControllerDelegate>
/***/
@property (nonatomic, weak, readonly) UIImagePickerController *pickerViewController;
/**选取回调*/
@property (nonatomic, copy) void(^didFinishPickingMediaHandler)(NSDictionary<UIImagePickerControllerInfoKey,id> *info);
/**点击回调*/
@property (nonatomic, copy) void(^didCancelHandler)(void);
/**初始化方法*/
- (instancetype)initWithPickerViewController:(UIImagePickerController *)pickerViewController;
/**
*将自己从pickerViewController上移除
*继承时使用
*/
- (void)clearSelfFromPickerViewController;
@end
```
`pod 'MLCKit/Photos'`
## Proxy
通过使用代理对象，解决循环引用问题。
比如在UIViewController中，使用NSTimer指定target为UIViewController时，使用WKUserContentController的addScriptMessageHandler方法指定target为UIViewController时，容易出现循环引用问题。一些开发者在viewWillAppear、viewWillDisappear或viewDidAppear、viewDidDisappear进行操作，但这种操作较为麻烦。
使用MLCProxy的话，可以如下调用：
```objective-c
_timer = [NSTimer timerWithTimeInterval:interval target:[MLCProxy proxyWithTarget:self] selector:@selector(pollLastNotice) userInfo:nil repeats:YES];
```
```objective-c
[configuration.userContentController addScriptMessageHandler:(id <WKScriptMessageHandler>)[MLCProxy proxyWithTarget:self] name:@"log"];
```
`pod 'MLCKit/Proxy'`
## Scan
Scan里面有扫码二维码视图控制器MLCScanQRCodeViewController，还有识别二维码的方法。
## TableView
里面封装了UITableView下拉刷新、加载更多等的处理，将UITableView的代理回调改成使用block回调。
## UI
UI里面是UI控件。
### MLCGradientLayerView
layerClass是CAGradientLayer的。
### MLCLabelView
在UILabel外面包一层。
`pod 'MLCKit/UI'`
## Utility
Utility里面是工具类。
### MLCDeviceUtility
MLCDeviceUtility封装获取设备信息的方法。
```objective-c
/**设备相关工具类*/
@interface MLCDeviceUtility : NSObject
/**app版本号*/
+ (NSString *)appVersion;
/**app构建版本号*/
+ (NSString *)appBuildVersion;
/**app名字*/
+ (NSString *)appName;
/**app的bundle ID*/
+ (NSString *)bundleIdentifier;
/**IDFA，广告标示符*/
+ (NSString *)idfa;
/**广告跟踪是否开启*/
+ (BOOL)advertisingTrackingEnabled;
/**IDFV*/
+ (NSString *)identifierForVendor;
/**IDFA或IDFV，IDFA能获取到就返回IDFA*/
+ (NSString *)idfaOrIdfv;
/***/
+ (NSString *)machine;
/**是否越狱*/
+ (BOOL)isJailbroken;
/**运营商名字*/
+ (NSString *)carrierName;
/**蜂窝网络类型*/
+ (NSString *)currentRadioAccessTechnology;
/**电池状态*/
+ (UIDeviceBatteryState)batteryStauts;
/**电池电量*/
+ (float)batteryLevel;
/**总内存大小*/
+ (unsigned long long)totalMemorySize;
/**当前可用内存大小*/
+ (unsigned long long)availableMemorySize;
/**已使用内存大小*/
+ (unsigned long long)usedMemory;
/**总磁盘容量*/
+ (unsigned long long)totalDiskSize;
/**可用磁盘容量*/
+ (unsigned long long)availableDiskSize;
/**IP地址*/
+ (NSString *)deviceIPAdress;
/**连接的WIFI名称(SSID)*/
+ (NSString *)wifiName;
/**状态栏高度*/
+ (CGFloat)statusBarHeight;
/**安全区域，iOS 11以下的返回UIEdgeInsetsMake(20, 0, 0, 0)*/
+ (UIEdgeInsets)safeAreaInsets;
@end
```
### MLCFileUtility
```objective-c
/**文件相关工具类*/
@interface MLCFileUtility : NSObject
/**获取Document文件目录*/
+ (NSString*)documentDirectoryPath;
/**获取Temp文件目录*/
+ (NSString*)temporaryDirectoryPath;
/**获取Home文件目录*/
+ (NSString*)homeDirectoryPath;
/**获取Cache文件目录*/
+ (NSString*)cachesDirectoryPath;
/**创建目录*/
+ (BOOL)creatDirectoryWithPath:(NSString *)path;
/**删除目录或文件*/
+ (BOOL)removeItemAtPath:(NSString *)path;
/**移动文件*/
+ (BOOL)moveItemAtPath:(NSString *)srcPath toPath:(NSString *)dstPath error:(NSError **)error;
/**拷贝文件*/
+ (BOOL)copyItemAtPath:(NSString *)srcPath toPath:(NSString *)dstPath error:(NSError **)error;
/** 获取文件或者文件夹大小(单位：B) */
+ (unsigned long long)sizeAtPath:(NSString *)path;
@end
```
### MLCNotificationUtility
```objective-c
/**通知工具类*/
@interface MLCNotificationUtility : NSObject
/**
注册通知
@param delegate UNUserNotificationCenterDelegate
**/
+ (void)registerNotificationWithDelegate:(id)delegate;
/**远程推送设备token字符串*/
+ (NSString *)remoteNotificationDeviceTokenStringWithDeviceToken:(NSData *)deviceToken;
@end
```
### MLCOpenUtility
```objective-c
/**打开相关工具类*/
@interface MLCOpenUtility : NSObject
/**让UIApplication打开链接*/
+ (void)openURL:(NSURL*)url completionHandler:(void (^)(BOOL success))completion;
/**打电话*/
+ (void)callWithTelephoneNumber:(NSString*)telephoneNumber;
/**发邮件*/
+ (void)sendEmail:(NSString*)email;
/**发短信*/
+ (void)sendShortMessage:(NSString*)shortMessage;
/**跳转到app设置页面*/
+ (void)openSettings;
@end
```
`pod 'MLCKit/Utility'`
# 安装
### CocoaPods
1. 需要MLCKit所有功能的，在 Podfile 中添加 `pod 'MLCKit'`。
2. 执行 `pod install` 或 `pod update`。
3. 导入 相应头文件。
# 系统要求
该项目最低支持 `iOS 8.0`。 | 15,622 | MIT |
<!--
* @Author: sam.hongyang
* @LastEditors: sam.hongyang
* @Description: 更新日志
* @Date: 2019-03-04 15:51:21
* @LastEditTime: 2019-07-29 11:53:48
-->
### 1.0.3 2019-07-29 11:53:26
> feat: 新增微前端模版下载功能
### 1.0.2 2019-07-24 14:43:18
> feat: 完善微前端配置
### 1.0.1 2019-07-20
> feat: 增加微前端配置
### 1.0.0 2019-03-05 14:28:43
> chore: 熟悉相关模块的用法
### 1.0.0 2019-03-04 17:04:42
> ci: 搭建工程目录，尝试 `commander` 模块的使用 | 407 | MIT |
编写一个程序，执行一个**异步**的对文件系统的操作：读取一个文件，并且在终端（标准输出 stdout）打印出这个文件中的内容的行数。类似于执行 `cat file | wc -l` 这个命令。
所要读取的文件的完整路径会在命令行第一个参数提供。
----------------------------------------------------------------------
# 提示
这个题目的答案*几乎*和前一个问题一样，但是你需要用更加**符合 Node.js 的风格**的方式解决：异步。
你将要使用 `fs.readFile()` 方法，而不是 `fs.readFileSync()`，并且你需要从你所传入的回调函数中去收集数据（这些数据会作为第二参数传递给你的回调函数），而不是使用方法的返回值。想要学习更多关于回调函数的知识，请查阅：https://github.com/maxogden/art-of-node#callbacks。
记住，我们习惯中的 Node.js 回调函数都有像如下所示的特征：
```js
function callback (err, data) { /* ... */ }
```
所以，你可以通过检查第一个参数的真假值来判断是否有错误发生。如果没有错误发生，你会在第二个参数中获取到一个 `Buffer` 对象。和 `readFileSync()` 一样，你可以传入 'utf8' 作为它的第二个参数，然后把回调函数作为第三个参数，这样，你得到的将会是一个字符串，而不是 Buffer。
`fs` 模块的文档可以通过使用你的浏览器访问如下路径来查看：
{rootdir:/node_apidoc/fs.html}
---------------------------------------------------------------------- | 819 | MIT |
col
===
过滤控制字符
## 补充说明
**col命令** 是一个标准输入文本过滤器，它从标注输入设备读取文本内容，并把内容显示到标注输出设备。在许多UNIX说明文件里，都有RLF控制字符。当我们运用shell特殊字符`>`和`>>`，把说明文件的内容输出成纯文本文件时，控制字符会变成乱码，col命令则能有效滤除这些控制字符。
### 语法
```
col(选项)
```
### 选项
```
-b：过滤掉所有的控制字符，包括RLF和HRLF；
-f：滤掉RLF字符，但允许将HRLF字符呈现出来；
-x：以多个空格字符来表示跳格字符；
-l<缓冲区列数>：预设的内存缓冲区有128列，用户可以自行指定缓冲区的大小。
```
<!-- Linux命令行搜索引擎：https://jaywcjlove.github.io/linux-command/ --> | 396 | Apache-2.0 |
---
sidebar: auto
---
# 指南 :rocket:
## 开始使用
### NPM
通过 npm 或 yarn 安装
```bash
npm install vue-showdown
# 或者
yarn add vue-showdown
```
在你的 JS 文件中引入
```js
// 作为 Vue 插件引入
import Vue from 'vue'
import VueShowdown from 'vue-showdown'
// Vue.use() 的第二个参数是可选的
Vue.use(VueShowdown, {
// 设置 showdown 默认 flavor
flavor: 'github',
// 设置 showdown 默认 options （会覆盖上面 flavor 的 options）
options: {
emoji: false,
},
})
// 或者： 作为 Vue 组件引入
import Vue from 'vue'
import { VueShowdown } from 'vue-showdown' // 记得引入 vue-showdown 的 esm 文件，即 vue-showdown.esm.js
Vue.component('VueShowdown', VueShowdown)
```
接下来，你就可以在你的单文件组件中通过`VueShowdown`来使用了
```vue
<!-- 通过 props 来设置 options -->
<VueShowdown
markdown="## markdown text"
flavor="github"
:options="{ emoji: true }"/>
```
::: tip 提示
同 vue 一样，vue-showdown 同样提供了 [UMD](https://github.com/umdjs/umd), [CommonJS](http://wiki.commonjs.org/wiki/Modules/1.1) 和 [ES Module](http://exploringjs.com/es6/ch_modules.html) 版本。查看 [Vue 文档](https://vuejs.org/v2/guide/installation.html#Terms) 获取更多细节。
:::
### Browser
在 `vue.js` 后面直接通过 `<script>` 引入。然后可以将 `vue-showdown` 直接作为 Vue 组件使用。
```html
<body>
<div id="#app">
<vue-showdown markdown="## markdown text"/>
</div>
<script src="https://unpkg.com/[email protected]/dist/vue.min.js"></script>
<script src="https://unpkg.com/[email protected]/dist/showdown.min.js"></script>
<script src="https://unpkg.com/[email protected]/dist/vue-showdown.min.js"></script>
<script>
new Vue({
el: '#app'
})
</script>
</body>
```
## 插件选项
```js
import Vue from 'vue'
import VueShowdown from 'vue-showdown'
Vue.use(VueShowdown, {
// 在这里设置插件选项
})
```
### flavor
设置 showdown 的默认 flavor。查看[文档](https://github.com/showdownjs/showdown#flavors)。
- 类型： `string`
- 默认值： `null`
- 可能的值： `'original', 'vanilla', 'github'`
::: tip
这里的 `flavor` 将会通过 `showdown.setFlavor()` 设置为全局 flavor。
:::
### options
设置 showdown 的默认 options。查看[文档](https://github.com/showdownjs/showdown#valid-options)。
- type: `Object`
- default: `{}`
::: tip
这里的 `options` 将会通过 `showdown.setOption()` 设置为全局 options。
注意这里的 `showdown.setOption()` 将会在 `showdown.setFlavor()` 之后调用，意味着将会覆盖 flavor 本身的默认配置。
:::
## 组件 Props
### markdown
输入的原始 markdown 代码。
- 类型： `string`
- 默认值： `null`
```vue
<VueShowdown markdown="# Hello, world!"/>
<!-- 渲染为 -->
<div>
<h1>Hello, world!</h1>
</div>
```
### tag
用来包裹 markdown 渲染结果的 HTML 标签。与 [vue-router 的 tag](https://router.vuejs.org/api/#tag) 作用相同。
- 类型： `string`
- 默认值： `'div'`
```vue
<VueShowdown markdown="# Hello, world!" tag="span"/>
<!-- 渲染为 -->
<span>
<h1>Hello, world!</h1>
</span>
```
### flavor
设置 showdown 的 flavor。查看 [文档](https://github.com/showdownjs/showdown#flavors)。
- 类型： `string`
- 默认值： `null`
- 可用的值： `'original', 'vanilla', 'github'`
::: tip
如果你通过 props 设置 `flavor`，那么所有的 options 都会被重置为 flavor 的默认值，这意味着你通过 `Vue.use()` 设置的默认 options 也将被覆盖。
:::
### options
设置 showdown 的 options。查看 [文档](https://github.com/showdownjs/showdown#valid-options)。
- 类型： `Object`
- 默认值： `{}`
::: tip 提示
通过 props 设置的 options 将会覆盖通过 `Vue.use()` 设置的默认 options。
:::
### extensions
设置 showdown 的 extensions。查看 [文档](https://github.com/showdownjs/showdown#extensions)。
- 类型： `[Object, Array]`
- 默认值： `null`
::: tip 提示
前往章节 [进阶用法 - Extensions](./#extensions-2) 查看使用细节。
:::
### vueTemplate <Badge text="v2.4.0+"/>
将解析后的 HTML 字符串当作 Vue 模板，允许你在 Markdown 中使用 Vue 模板语法。
- 类型： `Boolean`
- 默认值： `false`
::: warning 注意
如果你设置该 prop 为 `true`，你需要使用 Vue 完整版（运行时 + 编译器），因为我们需要在客户端编译模板。查看 [运行时 + 编译器 vs. 只包含运行时](https://cn.vuejs.org/v2/guide/installation.html#%E8%BF%90%E8%A1%8C%E6%97%B6-%E7%BC%96%E8%AF%91%E5%99%A8-vs-%E5%8F%AA%E5%8C%85%E5%90%AB%E8%BF%90%E8%A1%8C%E6%97%B6)。
当你有类似 [#5](https://github.com/meteorlxy/vue-showdown/issues/5) 的需求时，可以尝试使用该功能。
:::
## 进阶用法
### Showdown library
你可以从 `vue-showdown` 中导入 `showdown` ，以便进行进阶配置。
```js
import Vue from 'vue'
import VueShowdown, { showdown } from 'vue-showdown'
showdown.setFlavor('github')
Vue.use(VueShowdown)
```
::: tip
如果你在通过 `vue-showdown` 引入 `showdown` 时 (`import { showdown } from 'vue-showdown'`) 发生错误，你可以尝试以下方式：
- 设置 alias，将 `vue-showdown` 指向 `vue-showdown.esm.js`。如果你使用 webpack ，那么就类似于 `vue.esm.js` 的设置：
```js
resolve: {
alias: {
'vue$': 'vue/dist/vue.esm.js',
'vue-showdown$': 'vue-showdown/dist/vue-showdown.esm.js',
},
}
```
或者你直接引入 `vue-showdown.esm.js` 文件：
```js
import { showdown } from 'vue-showdown/dist/vue-showdown.esm'
```
- 通过 `VueShowdown.showdown` 使用 `showdown`:
```js
import VueShowdown from 'vue-showdown'
const showdown = VueShowdown.showdown
```
- 直接引入 `showdown` 。由于 `vue-showdown` 依赖于 `showdown` 运行，所以在你通过 `npm install vue-showdown` 安装 `vue-showdown` 后，你就可以直接使用 `showdown`：
```js
import showdown from 'showdown'
```
:::
### Extensions
根据 [showdown extensions 官方文档](https://github.com/showdownjs/showdown/wiki/extensions)，目前无法设置全局默认 extensions。
所以目前只能通过 `VueShowdown` 组件的 `extensions` prop 来传入 extensions。
```vue
<template>
<VueShowdown
markdown="## markdown text"
:extensions="[myExt]"/>
</template>
<script>
export default {
data () {
return {
myExt: () => [{
type: 'lang',
regex: /markdown/g,
replace: 'showdown',
}],
}
},
}
</script>
```
或者，你可以通过 `showdown.extension()` 全局注册 extensions，然后在 `extension` prop 中直接通过注册的名称引入。
```js
import Vue from 'vue'
import VueShowdown, { showdown } from 'vue-showdown'
// OR:
// import showdown from 'showdown'
// import VueShowdown from 'vue-showdown'
showdown.extension('myext', () => [{
type: 'lang',
regex: /markdown/g,
replace: 'showdown',
}])
Vue.use(VueShowdown)
```
```vue
<template>
<VueShowdown
markdown="## markdown text"
:extensions="['myext']"/>
</template>
``` | 5,751 | MIT |
---
title: 常见问题 QA
category: 其它
order: 1
---
> 持续更新中...
> 如有问题可以到 <https://github.com/alibaba/ice/issues/new> 反馈
## ICE 的浏览器兼容策略是什么
由于 ICE 优先使用 React 16+，其需要的最低 IE 版本为 11，如果您需要在以下的版本使用，您可能需要引入一些 polyfill 来支持 `Map`, `Set` 等特性。参考[React 官网说明](https://reactjs.org/blog/2017/09/26/react-v16.0.html#javascript-environment-requirements)。
以下代码可以帮助你在低版本 IE 下自动跳转到我们提供的提示浏览器升级页面。当然您也可以使用自定义的浏览器升级页面。
```
<!--[if lt IE 11]>
<script>location.href = "//www.taobao.com/markets/tbhome/ali-page-updater"; </script>
<![endif]-->
```
添加如上代码后，如果使用 IE11 及以下浏览器访问页面，则会自动跳转到统一引导升级浏览器的页面。
## WebStorm/IDEA 编辑器卡顿现象
由于项目在安装依赖后，产生文件夹 `node_modules` 含有较多的碎小文件，编辑器在索引文件引起的卡顿。
WebStorm 中尤为明显，可通过 exclude `node_modules` 目录，不需要检索该文件夹下的内容。
## 如何设置网页在浏览器 Tab 上面的 Icon (favicon)
细心的同学可能会看到页面在浏览器 Tab 上面会有自定义的 Icon：
如果你想要在自己站点上面加上这个 Icon 可以按照如下步骤添加：
1. 准备一个 Icon，文件格式可以为 `.png` 或者 `.ico`，正方形，分辨率可以是 32x32px 或者 64x64px 文件体积要求尽可能小。
2. 上传 CDN 拿到一个 url 或者在自己服务器配置静态资源服务
3. 在 HTML 页面 `<head>` 标签里面添加如下代码：`<link rel="shortcut icon" href="your-icon-url">`
这样就添加成功啦！
## 如何在页面显示原始的 HTML 内容
出于安全方面的考虑，React 默认会将节点中 html 代码进行转义，比如：
```jsx
class Demo extends Component {
render() {
const content = 'hello <span>world</span>';
return <div>{content}</div>;
}
}
// 输出 hello <span>world</span>
```
如上，`<span>` 标签并不会在页面上被解析，而是被当成字符串输出了。React 提供了 `dangerouslySetInnerHTML` 属性帮助我们进行类似 `innerHTML` 的操作：
```jsx
class Demo extends Component {
render() {
const content = 'hello <span>world</span>';
return <div dangerouslySetInnerHTML={{ __html: content }} />;
}
}
// 输出 hello world
```
更多内容请参考 [Dangerously Set innerHTML](https://reactjs.org/docs/dom-elements.html#dangerouslysetinnerhtml)
## 之前创建的项目，遇到如下报错怎么办
这是由于 ES6 Modules 的标准在物料中不兼容导致的。您可以把 `src/navs.js` 中最后一行修改为：
```js
export const headerNavs = transform([
...autoGenHeaderNavs,
...customHeaderNavs,
]);
export const asideNavs = transform([...autoGenAsideNavs, ...customAsideNavs]);
``` | 2,155 | MIT |
---
title: 注册 Azure Functions 绑定扩展
description: 了解如何根据你的环境注册 Azure Functions 绑定扩展。
services: functions
documentationcenter: na
author: craigshoemaker
manager: jeconnoc
ms.service: azure-functions
ms.devlang: multiple
ms.topic: reference
origin.date: 02/25/2019
ms.date: 06/03/2019
ms.author: v-junlch
ms.openlocfilehash: e9f7bb95d04b523dfd17d3e8af43e216292ed970
ms.sourcegitcommit: 9e839c50ac69907e54ddc7ea13ae673d294da77a
ms.translationtype: HT
ms.contentlocale: zh-CN
ms.lasthandoff: 06/04/2019
ms.locfileid: "66491491"
---
# <a name="register-azure-functions-binding-extensions"></a>注册 Azure Functions 绑定扩展
在 Azure Functions 版本 2.x 中，[绑定](./functions-triggers-bindings.md)以独立于函数运行时的包的形式提供。 虽然 .NET 函数通过 NuGet 包访问绑定，但扩展捆绑包允许其他函数通过配置设置访问所有绑定。
请考虑以下与绑定扩展相关的项：
- 除了[使用 Visual Studio 2019 创建 C# 类库](#local-csharp)时，否则绑定扩展未在 Functions 1.x 中显式注册。
- 默认情况下支持 HTTP 和计时器触发器，不需要扩展。
下表指明了何时以及如何注册绑定。
| 开发环境 |注册<br/> Functions 1.x 中注册 |注册<br/> Functions 2.x 中注册 |
|-------------------------|------------------------------------|------------------------------------|
|Azure 门户|自动|自动|
|非 .NET 语言或本地 Azure Core Tools 开发|自动|[使用 Azure Functions Core Tools 和扩展捆绑包](#local-development-with-azure-functions-core-tools-and-extension-bundles)|
|使用 Visual Studio 2019 的 C# 类库|[使用 NuGet 工具](#c-class-library-with-visual-studio-2019)|[使用 NuGet 工具](#c-class-library-with-visual-studio-2019)|
|使用 Visual Studio Code 的 C# 类库|不适用|[使用 .NET Core CLI](#c-class-library-with-visual-studio-code)|
## <a name="local-development-with-azure-functions-core-tools-and-extension-bundles"></a>使用 Azure Functions Core Tools 和扩展捆绑包进行本地开发
[!INCLUDE [functions-core-tools-install-extension](../../includes/functions-core-tools-install-extension.md)]
<a name="local-csharp"></a>
## <a name="c-class-library-with-visual-studio-2019"></a>使用 Visual Studio 2019 的 C# 类库
在 Visual Studio 2019 中，可使用 [Install-Package](https://docs.microsoft.com/nuget/tools/ps-ref-install-package) 命令从包管理器控制台安装包，如以下示例所示：
```powershell
Install-Package Microsoft.Azure.WebJobs.Extensions.ServiceBus -Version <TARGET_VERSION>
```
用于给定绑定的包的名称在该绑定的参考文章中提供。 有关示例，请参阅[服务总线绑定参考文章的“包”部分](functions-bindings-service-bus.md#packages---functions-1x)。
将示例中的 `<TARGET_VERSION>` 替换为特定包版本，例如 `3.0.0-beta5`。 在 [NuGet.org](https://nuget.org) 上的单个包页上列出了有效版本。与 Functions 运行时 1.x 或 2.x 对应的主版本在绑定的参考文章中指定。
## <a name="c-class-library-with-visual-studio-code"></a>使用 Visual Studio Code 的 C# 类库
在“Visual Studio Code” 中，可在 .NET Core CLI 中，通过命令提示符使用 [dotnet add package](https://docs.microsoft.com/dotnet/core/tools/dotnet-add-package) 命令来安装包，如以下示例所示：
```terminal
dotnet add package Microsoft.Azure.WebJobs.Extensions.ServiceBus --version <TARGET_VERSION>
```
.NET Core CLI 只能用于 Azure Functions 2.x 开发。
用于给定绑定的包的名称在该绑定的参考文章中提供。 有关示例，请参阅[服务总线绑定参考文章的“包”部分](functions-bindings-service-bus.md#packages---functions-1x)。
将示例中的 `<TARGET_VERSION>` 替换为特定包版本，例如 `3.0.0-beta5`。 在 [NuGet.org](https://nuget.org) 上的单个包页上列出了有效版本。与 Functions 运行时 1.x 或 2.x 对应的主版本在绑定的参考文章中指定。
## <a name="next-steps"></a>后续步骤
> [!div class="nextstepaction"]
> [Azure Functions 触发器和绑定示例](./functions-bindings-example.md)
<!-- Update_Description: wording update --> | 3,161 | CC-BY-4.0 |
---
title: 关键插件 Pod 的调度保证
content_type: concept
---
<!-- overview -->
<!--
In addition to Kubernetes core components like api-server, scheduler, controller-manager running on a master machine
there are a number of add-ons which, for various reasons, must run on a regular cluster node (rather than the Kubernetes master).
Some of these add-ons are critical to a fully functional cluster, such as metrics-server, DNS, and UI.
A cluster may stop working properly if a critical add-on is evicted (either manually or as a side effect of another operation like upgrade)
and becomes pending (for example when the cluster is highly utilized and either there are other pending pods that schedule into the space
vacated by the evicted critical add-on pod or the amount of resources available on the node changed for some other reason).
-->
除了在主机上运行的 Kubernetes 核心组件（如 api-server 、scheduler 、controller-manager）之外，还有许多插件，由于各种原因，
必须在常规集群节点（而不是 Kubernetes 主节点）上运行。
其中一些插件对于功能完备的群集至关重要，例如 Heapster、DNS 和 UI。
如果关键插件被逐出（手动或作为升级等其他操作的副作用）或者变成挂起状态，群集可能会停止正常工作。
关键插件进入挂起状态的例子有：集群利用率过高；被逐出的关键插件 Pod 释放了空间，但该空间被之前悬决的 Pod 占用；由于其它原因导致节点上可用资源的总量发生变化。
<!-- body -->
<!--
### Marking pod as critical
-->
### 标记关键 Pod
<!--
To be considered critical, the pod has to run in the `kube-system` namespace (configurable via flag) and
* Have the priorityClassName set as "system-cluster-critical" or "system-node-critical", the latter being the highest for entire cluster. Alternatively, you could add an annotation `scheduler.alpha.kubernetes.io/critical-pod` as key and empty string as value to your pod, but this annotation is deprecated as of version 1.13 and will be removed in 1.14.
-->
要将 pod 标记为关键性（critical），pod 必须在 kube-system 命名空间中运行（可通过参数配置）。
同时，需要将 `priorityClassName` 设置为 `system-cluster-critical` 或 `system-node-critical` ，后者是整个群集的最高级别。
或者，也可以为 Pod 添加名为 `scheduler.alpha.kubernetes.io/critical-pod`、值为空字符串的注解。
不过，这一注解从 1.13 版本开始不再推荐使用，并将在 1.14 中删除。 | 1,941 | CC-BY-4.0 |
---
title: Docker 容器内 Java 应用发生 OutOfMemoryError 堆内存空间不足时, 容器无法重启应用
date: 2020-03-12 10:34:13
description: 在一次生产环境部署时发现 docker 容器设置了 --restart always, 容器里应用发生 OutOfMemoryError 错误时没有重启容器.
categories: [Docker篇]
tags: [Docker]
---
<!-- more -->
## 背景
在一次生产环境部署 elasticsearch 节点时 docker 容器设置了 --restart always,
此时 elasticsearch 的一个节点发生了 java.lang.OutOfMemoryError: Java heap space
容器并没有重启
elasticsearch 已经设置了 -Xms -Xmx
## 解释
JVM堆内存超出xmx限制，并抛java.lang.OutOfMemoryError: Java heap space异常。堆内存爆了之后，JVM和java进程会继续运行，并不会crash
## 解决
当JVM出现 OutOfMemoryError，要让 JVM 自行退出, 这样容器就会触发重启
添加新的 jvm 配置: ExitOnOutOfMemoryError and CrashOnOutOfMemoryError
该配置支持 jdk8u92 版本及其之后的版本
地址: https://www.oracle.com/technetwork/java/javase/8u92-relnotes-2949471.html
oracle 官网的原话:
New JVM Options added: ExitOnOutOfMemoryError and CrashOnOutOfMemoryError
Two new JVM flags have been added:
ExitOnOutOfMemoryError - When you enable this option, the JVM exits on the first occurrence of an out-of-memory error. It can be used if you prefer restarting an instance of the JVM rather than handling out of memory errors.
CrashOnOutOfMemoryError - If this option is enabled, when an out-of-memory error occurs, the JVM crashes and produces text and binary crash files (if core files are enabled).
ExitOnOutOfMemoryError: 启用此选项时，JVM在第一次出现内存不足错误时退出。如果您希望重新启动JVM实例而不是处理内存不足错误，则可以使用它。
CrashOnOutOfMemoryError: 如果启用此选项，则在发生内存不足错误时，JVM崩溃并生成文本和二进制崩溃文件（如果启用了核心文件）。
加上配置
> ES_JAVA_OPTS = "-XX:+ExitOnOutOfMemoryError" | 1,492 | MIT |
---
layout: post
category: "video"
title: "视频相关paper"
tags: [video, 视频, tcc, ]
---
目录
<!-- TOC -->
- [视频分类](#%e8%a7%86%e9%a2%91%e5%88%86%e7%b1%bb)
- [视频表示学习](#%e8%a7%86%e9%a2%91%e8%a1%a8%e7%a4%ba%e5%ad%a6%e4%b9%a0)
- [Dense Predictive Coding](#dense-predictive-coding)
- [TCC](#tcc)
- [应用](#%e5%ba%94%e7%94%a8)
<!-- /TOC -->
## 视频分类
AAAI 2018
[Multimodal Keyless Attention Fusion for Video Classification](http://iiis.tsinghua.edu.cn/~weblt/papers/multimodal-keyless-attention.pdf)
Multimodal Representation意思是多模式表示，在行为识别任务上，文章采用了视觉特征（Visual Features，包含RGB特征 和 flow features）；声学特征（Acoustic Feature）；前面两个特征都是针对时序，但是时序太长并不适合直接喂到LSTM，所以作者采用了分割的方法（Segment-Level Features），将得到的等长的Segment喂到LSTM。
优点：多模态信息融合方法优化: 两路model分别lstm+attention,再concat ,能得到多模态 互补识别效果,train model 效果优于early fusion/later fusion
CVPR 2018
[Attention Clusters: Purely Attention Based Local Feature Integration for Video Classification](http://cn.arxiv.org/abs/1711.09550)
多组attention参数有效引入diversity,能学习到不同的注意力模式
不同component用各自attention(通过线性变换映射到另一个空间，相当于加约束),再concat
temporal action proposal: actionness score（精彩不精彩，二分类），然后取出分布连续且值比较高的片段，然后找边界（boundary aware network），然后加一些多尺度(action pyramid network)
[Quo Vadis, Action Recognition? A New Model and the Kinetics Dataset](https://arxiv.org/abs/1705.07750v1)
利用膨胀3D卷积网络(I3D)将视频的帧间差值做处理,再采用CNN进行分类。
AdaIN
style transfer: AdaIN(自适应示例正则化)，两个目标：纹理一致性+语义一致性（类似GAN）
## 视频表示学习
### Dense Predictive Coding
[Video Representation Learning by Dense Predictive Coding](https://arxiv.org/abs/1909.04656)
近期来自 VGG 的高质量工作，因为没有在主会议发表所以没有引起大范围关注，但保持了一贯低调又实用的风格。本文提出了一种新型的自监督学习（self-supervised learning）方法 Dense Predictive Coding，学习视频的时空表征，在动作识别任务（UCF101 和 HMDB51 数据集）上获得了 state-of-the-art 的正确率，并且用无需标注的自监督学习方法在视频动作识别上达到了 ImageNet 预训练的正确率。
自监督学习是利用无标注的数据设计代理任务（proxy task），使网络从中学到有意义的数据表征。本文设计的代理任务是预测未来几秒的视频的特征，并且用对比损失（contrastive loss）使得预测的特征和实际的特征相似度高，却不必要完全相等。因为在像素级别（pixel-level）预测未来的帧容易受到大量随机干扰如光照强度、相机移动的影响，而在特征级别（feature-level）做回归（regression）则忽视了未来高层特征的不可预测性（如视频的未来发展存在多种可能）。
文中的设计促使网络学习高层语义特征，避免了网络拘泥于学习低层特征。作者在不带标注的 Kinetics400 上训练了自监督任务（Dense Predictive Coding），然后在 UCF101 和 HMDB51 上测试了网络所学权重在动作识别上的正确率。
Dense Predictive Coding 在 UCF101 数据集上获得了 75.7% 的 top1 正确率，超过了使用带标注的 ImageNet 预训练权重所获得的 73.0% 正确率。该研究结果证明了大规模自监督学习在视频分类上的有效性。
### TCC
[使用时间循环一致性学习 (TCC) 理解视频内容](https://mp.weixin.qq.com/s/xocs_UI5HzgFZtTPWABRKw)
[Temporal Segment Networks: Towards Good Practices for Deep Action Recognition](https://arxiv.org/abs/1608.00859)
[https://sites.google.com/view/temporal-cycle-consistency/home](https://sites.google.com/view/temporal-cycle-consistency/home)
[https://github.com/google-research/google-research/tree/master/tcc](https://github.com/google-research/google-research/tree/master/tcc)
## 应用
[用AI实现动画角色的姿势迁移，Adobe等提出新型「木偶动画」](https://mp.weixin.qq.com/s/5snO8CYpc01CCky9WT6SrQ)
[Neural Puppet: Generative Layered Cartoon Characters](https://arxiv.org/pdf/1910.02060v1.pdf) | 2,926 | Apache-2.0 |
# 12.1.2. 执行日期检查和时间计算
[![chrono-badge]][chrono] [![cat-date-and-time-badge]][cat-date-and-time]
使用 [`DateTime::checked_add_signed`] 计算并显示两周之后的日期和时间，使用 [`DateTime::checked_sub_signed`] 计算并显示前一天的日期。如果无法计算出日期和时间，这些方法将返回 None。
可以在 [`chrono::format::strftime`] 中找到适用于 [`DateTime::format`] 的转义序列。
```rust,edition2018
{{ #include ../../../examples/datetime/duration/examples/checked.rs }}
```
[`chrono::format::strftime`]: https://docs.rs/chrono/*/chrono/format/strftime/index.html
[`DateTime::checked_add_signed`]: https://docs.rs/chrono/*/chrono/struct.Date.html#method.checked_add_signed
[`DateTime::checked_sub_signed`]: https://docs.rs/chrono/*/chrono/struct.Date.html#method.checked_sub_signed
[`DateTime::format`]: https://docs.rs/chrono/*/chrono/struct.DateTime.html#method.format
{{#include ../../links.md}} | 816 | Apache-2.0 |
# FileScanner [  ](https://bintray.com/haydar-android/maven/FileScanner/_latestVersion) <a href='https://bintray.com/haydar-android/maven/FileScanner?source=watch' alt='Get automatic notifications about new "FileScanner" versions'><img src='https://www.bintray.com/docs/images/bintray_badge_color.png'></a>
## Android SD卡扫描某类文件(.mp3、.mp4...)
### 使用方法
``` gradlew
compile 'io.haydar.filescanner:filescannercore:1.1'
```
### 描述
FileScanner是一个扫描Android /storage/emulated/0/目录中指定格式的文件。扫描结果会保存在FileScanner数据库中。
### 注意
``` xml
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
必须得申请权限
### API
``` java
FileScanner.getInstance(Context).clear();
```
清除数据库信息
``` java
FileScanner.getInstance(this).setType(String).start(FileScanner.ScannerListener())
```
setType设置要查找文件的格式(.mp3)
start开始扫描，会自动根据数据库是否为空来进行全盘扫描还是增量扫描
```java
ArrayList<FileInfo> fileInfoArrayList= FileScanner.getInstance(MainActivity.this).getAllFiles();
```
获得扫描的文件
### 使用方法
``` java
private void fileScanner() {
FileScanner.getInstance(this).clear();
FileScanner.getInstance(this).setType(".png").start(new FileScanner.ScannerListener() {
/**
* 扫描开始
*/
@Override
public void onScanBegin() {
Log.d(TAG, "onScanBegin: ");
}
/**
* 扫描结束
*/
@Override
public void onScanEnd() {
Log.d(TAG, "onScanEnd: ");
ArrayList<FileInfo> fileInfoArrayList= FileScanner.getInstance(MainActivity.this).getAllFiles();
for (FileInfo fileInfo : fileInfoArrayList) {
Log.d(TAG, "fileScanner: "+fileInfo.getFilePath());
}
}
/**
* 扫描进行中
* @param paramString 文件夹地址
* @param progress 扫描进度
*/
@Override
public void onScanning(String paramString, int progress) {
Log.d(TAG, "onScanning: " + progress);
}
/**
* 扫描进行中，文件的更新
* @param info
* @param type SCANNER_TYPE_ADD：添加；SCANNER_TYPE_DEL：删除
*/
@Override
public void onScanningFiles(FileInfo info, int type) {
Log.d(TAG, "onScanningFiles: info=" + info.toString());
}
});
}
``` | 2,585 | MIT |
---
title: Java 复习提纲
date: 2019-01-10 00:00:00
tags:
- Java
categories:
- review
---
* 垃圾回收 `System.gc()`
## Chapter 01
* 数据类型
类型|容量（bit）|范围|包装器
:-|:-|:-|:-
boolean|1|true\false|Boolean
char|16|Unicode|Character
byte|8|$[-128,127]$|Byte
short|16|$[-2^{15},2^{15}-1]$|Short
int|32|$[-2^{31},2^{31}-1]$|Integer
Long|64|$[-2^{63},2^{63}-1]$|Long
float|32|$3.4*10^{38}$|Long
double|64|$1.7*10^{308}$|Double
void|-|-|Void
* 自动类型转换
* byte,short,char—> int —> long—> float —> double
* 数据类型转换`int a = (int)3.14159`
* Package
* Import
* Class
* Field
* Method
* Object
* Constract and Initialization
* Access Control
* Java修饰符
* 访问控制修饰符 : default, public , protected, private
* 非访问控制修饰符 : final, abstract, static, synchronized
* 继承
* 在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
* 利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。
* Java 源程序与编译型运行区别
* 一个类可以包含以下类型变量：
* 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
* 局部变量声明在方法、构造方法或者语句块中；
* 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
* 访问修饰符不能用于局部变量；
* 局部变量只在声明它的方法、构造方法或者语句块中可见；
* 局部变量是在栈上分配的。
* 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
* 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
* 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
* 类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
* 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
* 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
* 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
* 静态变量在第一次被访问时创建，在程序结束时销毁。
* 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
* 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
* 静态变量可以通过：ClassName.VariableName的方式访问。
* 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
* 实例变量
* 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
* 当一个对象被实例化之后，每个实例变量的值就跟着确定；
* 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
* 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
* 实例变量可以声明在使用前或者使用后；
* 访问修饰符可以修饰实例变量；
* 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
* 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
* 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
* 一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。
* 源文件声明规则
* 一个源文件中只能有一个public类
* 一个源文件可以有多个非public类
* 源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
* 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
* 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
* import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
* 接口
* 在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
* 接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。
* 继承关键字
* 继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
* extends关键字
* 在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
* implements关键字
* 使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
* super 与 this 关键字
* super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
* this关键字：指向自己的引用。
* final关键字
* final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
* 声明类：
* final class 类名 {//类体}
* 声明方法：
* 修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
* 构造器
* 子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
* 如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
* Java 抽象类
* 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
* 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
* 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
* 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
* 在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
* 抽象方法
* 如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。
* Abstract关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。
* 抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。
* 声明抽象方法会造成以下两个结果：
* 如果一个类包含抽象方法，那么该类必须是抽象类。
* 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
* 继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。
1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
4. 构造方法，类方法（用static修饰的方法）不能声明为抽象方法。
5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
Java 接口
* 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
* 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
* 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
* 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
* 接口与类相似点：
* 一个接口可以有多个方法。
* 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
* 接口的字节码文件保存在 .class 结尾的文件中。
* 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
* 接口与类的区别：
* 接口不能用于实例化对象。
* 接口没有构造方法。
* 接口中所有的方法必须是抽象方法。
* 接口不能包含成员变量，除了 static 和 final 变量。
* 接口不是被类继承了，而是要被类实现。
* 接口支持多继承。
* 接口特性
* 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
* 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
* 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
* 抽象类和接口的区别
1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
## Chapter 02 OOP
* Object
* Class
* Abstraction
* Inheritance
* Polymorphism
* `finalilze();`
* `Abstraction`
* `interface`
* `implements`
## Chapter 03 Exception
* 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
* 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
* 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
* Exception 类的层次
* 所有的异常类是从 java.lang.Exception 类继承的子类。
* Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。
* Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。
* Error 用来指示运行时环境发生的错误。
## Chapter 04 Java I/O
``` java
File file = new File("filePath/fileName");
System.out.println(file.exists());
System.out.println(file.isFile());
File[] files = file.listFlies(filter);
System.out.println(files.length);
Arrays.sort(files,comparator);
```
* Stream
* Byte stream
* java.io.InputStream
* `int read() //read a byte`
* java.io.OutputStream
* `void write(int b)`
* `void write(byte[] b)`
* FileInputStream, FileOutputStream
* PipedInputStream, PipedOutputStream
* ByteArrayInputStream, ByteArrayOutputStream
* BufferedInputStream, BufferedOutputStream
* ObjectInputStreamm ObjectOutputStream
* Character stream
* java.io.Reader
* `int read() //read a char`
* java.io.Writer
* `void write(int b)`
* `void write(char[] c)`
* FileReader, FileWriter
* PipedReader, PipedWriter
* BufferedReader, BufferedWriter
* InpputStreamReader, OutputStreamWriter
* Bridge
* InputStreamReader
* OutputStreamWriter
* FileInputStream
* ``` java
FileInputStream fis = FileInputStream(file);
int res = fis.read(); //IOException
fis.available(); //是否可用
fis.close();
```
```
```
* FileOutputStream
* ``` java
file.createNewFile()
fos.write(2);
fos.write('a');
```
```
```
* FileReader
* FileWriter
* ```java
FileWriter w = new FileWriter(new File("a.txt"),true);
w.write("Hanyuu".toCharArray());
w.flush();
```
* InputStreamReader
* OutputStreamReader
* PrintStream
* DataInputStream, DataOutputStream
* PrintWriter
* Scanner
* java.util.Scanner
* BufferedInputStream, BufferedOutputStream
* `BufferedInputStream bufferedInput = new BufferedInputStream(new FileInputStream(filename));`
* ``` java
public void testBufferedInput() {
try {
/**
* 建立输入流 BufferedInputStream, 缓冲区大小为8
* buffer.txt内容为
* abcdefghij
*/
InputStream in = new BufferedInputStream(new FileInputStream(new File("buff.txt")), 8);
/*从字节流中读取5个字节*/
byte [] tmp = new byte[5];
in.read(tmp, 0, 5);
System.out.println("字节流的前5个字节为: " + new String(tmp));
/*标记测试*/
in.mark(6);
/*读取5个字节*/
in.read(tmp, 0, 5);
System.out.println("字节流中第6到10个字节为: " + new String(tmp));
/*reset*/
in.reset();
System.out.printf("reset后读取的第一个字节为: %c" , in.read());
} catch (Exception e) {
e.printStackTrace();
}
}
```
```
* InputStreamReader
* OutputStreamReader
* System.in
* System.out
* System.err
* DataOutputStream
* DataInputStream
```
## Chapter 05 Collection
* Arrays
* java.util.Arrays
* `Arrays.sort()`
* `Arrays.fill(String[],String)`
* `Array.hashCode(String)`
* Collection
* `Set<E> //non-repeat`
* `SortedSet<E>`
* `List<E>`
* `Quene<E>`
* Map
* `HashMap<K,V>`
``` java
HashMap<Integer,String> map = new HashMap<Integer,String>();
map.put(0,"Hanyuu");
String name = map.get(0);
map.remove(0);
Set keySet = map.keySet();
Collection valueSet = map.values();
Set entrySet = map.entrySet();
```
* `SortedMap<K,V>`
* Iterator
* Seqential and Linear
* Use Array as Backend
* Varible Length
* Methods
``` java
add(Object)
add(int index,Object)
remove(Object)
get(int)
set(int)
indexOf(Objects)
clear()
Size()
toArray()
```
* ArrayList
* `ArrayList<String> list = new ArrayList<String>();`
* `ArrayList<String> list = new ArrayList<String>(100);`
* `list.ensureCapacity(1000)`
* LinkedList
``` java
LinkdList<String> list = new LinkedList<String>();
list.add("Hanyuu");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
```
## Chapter 07 UI
* java.jwt
* javax.swing
* `JFrame frame = new JFrame(String //title);`
* `frame.getContentPane().add(BorderLayout.EAST,button);`
* `frame.setSize(300,400);`
* `frame.setVisible(true);`
* `frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);`
* `Container cp = frame.getContentPane();`
* `cp.setLayout(new FloatLayout());`
* `cp.add(new JPanel)();`
* `JButton button = new JButton("Okey");`
* `JComboBox`
* `JCheckBox`
* `JPanel`
* `pnel.setLayout(new FLowLayout(FlowLayout.LEFT));`
* `JPanel //container`
* `JPanle = new JPanel();`
* `panel.add(new JTextField("Hanyuu"));`
* `JSplistPane`
* `JScrollPane`
* `Graphics`
* `JLabel`
* `getText();`
* `setText();`
* `setIcon();`
* `JTextField`
* `JCheckBox`
* `JTextArea`
* `JRadioButton`
* 事件侦听
* ActionLinstener
``` java
public class Action implements ActionListener{
public void actionPerformed(ActionEvent event){
//TODO...
}
}
JButton exp = new JButton();
exp.addActionLintener(new Action());
```
## Chapter 08 Multi-thread
1. `runnable` interface
``` java
public class Task implements Runnable{
public void run(){
//TODO...
}
}
public static void main(String[] args){
Thread thread = new Thread(new Task(),"Thread name");
thread.start();
}
```
2. Thread
``` java
public class HanyuuThread extends Thread{
public void run(){
//TODO...
}
}
public static void main(String[] args){
HanyuuThread hanyuu = new HanyuuThread();
hanyuu.setName("Hanyuu");
hanyuu.statrt();
}
```
* `Thread.sleep(int)`
* `String Thread.currentThread().getName();`
* `join`
* `interrupt()`
* `yield()`
> yield意味着放手，放弃，投降。一个调用yield()方法的线程告 诉虚拟机它乐意让其他线程占用自己的位置。这表明该线程没 有在做一些紧急的事情。注意，这仅是一个暗示，并不能保证 不会产生任何影响。 \
Yield告诉当前正在执行的线程把运行机会交给线程池中拥有相 同优先级的线程。\
Yield不能保证使得当前正在运行的线程迅速转换到可运行的状态。\
它仅能使一个线程从运行状态转到可运行状态，而不是等待或阻塞状态
* `notify()`/`notifyAll()`
* notifyAll() wakes all waiting thread, thus, all waiting thread turn to Ready
* notify() only wakes one of waiting thread, others remain blocked
* `sleep()`
* java.lang.Thread`
* `wait()`
* `java.lang.Object`
* Each object has a wait method, inherited from java.lang.Object
* wait() method ask current thread to give up exclusive control
* wait() method give other thread a chance to visit the object
* wait() / wait(long timeout)
* wait() / notifyAll() / notify()
* The object must be locked before visit these methods
* They can be used in synchronized method of an object
* Or obj.wait() / obj.notifyAll() / obj.notify() in synchorized(obj){…}
* Otherwise: java.lang.IllegalMonitorStateException
* `synchronized`
``` java
public class Hanyuu{
public synchronized void onlyOne(){
//TODO...
}
public synchronized void threadSafty(){
//TODO...
}
}
```
## Chapter 09 Java & XML
## Chapter 10 JDBC
* Record
* Field
* Table
* Entity
* Relations
* DataBase
* Primary key
* Foreign key
* Select
* `SELECT nameA FROM tableA`
* `SELECT nameA FROM tableA WHERE name > 2`
* `SELECT nameA FROM tableA WHERE (name > 2 AND name < 10) OR name >300`
* `SELECT * FROM tableA WHERE name IN ('Hanyuu','Inari')`
* `SELECT * FROM tableA WHERE date BETWEEN 'Jan-01-2019' AND 'Jan-02-2019'`
* `SELECT * FROM tableA WHERE name LIKE '%an%'`
* `SELECT * FROM tableA ORDER BY name DESC/ASC`
* `SELECT COUNT(DISTINCT name) FROM tableA`
* Insert
* `INSERT INTO tableA (name,Date) VALUES ('Inari','Jan-01-2019')`
* Retireval
* Update
* `UPDATE tableA SET date = 'Jan-01-2019' WEHERE name = 'Hanyuu'`
* Delete
* `DELETE FROM tableA WHERE name = 'Inari'`
> 你知道为什么SQL语句大家都选择大写嘛？（hhh）
``` java
package SQL;
import java.sql.*;
import javax.sql.*;
public class SQL {
public static void main(String[] args) {
// ResultSet rs;
// Statement statement;
// Connection connection;
Connection connection = null;
Statement statement = null;
ResultSet rs = null;
try {
//注册驱动程序
Class.forName("com.mysql.cj.jdbc.Driver");
//创建JDBC连接
String dbURL = "jdbc:mysql://localhost:3306/Hanyuu?user=Hanyuu&password=Hanyuu&useSSL=false&serverTimezone=GMT";
connection = DriverManager.getConnection(dbURL);
//创建statement
String sqlQuery = "SELECT DISTINCT bookname FROM bookstore";
statement = connection.createStatement();
rs = statement.executeQuery(sqlQuery);
while (rs.next()) {
System.out.println(rs.getString("bookname"));
}
String nsqlQuery = "SELECT * FROM bookstore";
rs = statement.executeQuery(nsqlQuery);
//执行查询语句
ResultSetMetaData rsmd = rs.getMetaData();
for (int i = 1; i <= rsmd.getColumnCount(); ++i) {
System.out.println(rsmd.getColumnName(i)+'\t');
}
} catch (ClassNotFoundException e) {
System.out.println("无驱动类");
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
rs.close();
statement.close();
connection.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
```
* 构建Prepared statement
``` java
String sql = "INSERT INTO tableA (id,name,sorce) VALUES (?,?,?)";
PreparedStatement s =connection.prepareStatement(sql);
//add a record
s.setInt(1,0000);
s.setString(2,"Hanyuu");
s.setInt(3,60);
s.addBatch();
s.clearParameters();
s.executeBatch();
s.cleatBatch();
```
## Chapter 11 Java network Programming
* IP address
* IPv4
* IPv6
* IP
* Host name
* Domain Name
* DNS
``` java
try{
//get InetAddress
InetAddress iAddress = InetAddress.getLocalHost();
//get local IP
String IP = iAddress.getHostAddress().toString();
//get local host name
String hostName = iAddress.getHostName().toString();
System.out.println("IP address"+IP);
System.out.println("Host name"+hostName);
}
catch (UnknownHostException e){
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
}
```
* 通过主机名获取所有IP
``` java
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Iterator;
public class getLocal {
public static void main(String[] args) {
try {
InetAddress ia=InetAddress.getLocalHost();
System.out.println(ia.getHostAddress());
System.out.println(ia.getAddress());
System.out.println(ia.getHostName());
String hostName=InetAddress.getLocalHost().getHostName();
ArrayList<String> allIP=new ArrayList<String>();
if (hostName.length()>0)
{
InetAddress[] addresses=InetAddress.getAllByName(hostName);
for (int i=0;i<addresses.length;i++){
allIP.add(addresses[i].getHostAddress().toString());
}
}
for (Iterator iter=allIP.iterator();((Iterator) iter).hasNext();){
System.out.println(ier.next().toString());
}
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
}
```
* Constructor localhost InetAddress
``` java
InetAddress addr = InetAddress.getByName(null);
InetAddress addr = InetAddress.getByName("127.0.0.1");
InetAddress addr = InetAddress.getByName("localhost");
InetAddress addr = InetAddress.getLocalHost();
byte[] IP = {(byte)127,(byte)0,(byte)0,(byte)1};
```
* Web server
* FTP server
* Mail server
* Port 1-1024 is occupied by system
* client
``` java
//构建客户端socket
Socket client = new Socket("hanyuu.ml",8080);
//构建客户端socket（通过InetAddress）
InetAddress address = InetAddress.getByName("Hanyuu.ml");
Socket client = new Socket(address,8080);
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
is.close();
os.close();
```
Example
``` java
Socket socket = new Socket(ip,8008);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()),true);
out.print("Hi");
Thread.sleep(1000);
out.println("Hello");
socket.close();
```
* server
``` java
//创建服务端的ServerSocket监听客户请求
ServerSocket server = new ServerSocket(8080);
//客户端阻塞，等待连接
Socket serverSocket = server.accept();
```
Example
```java
try{
ButteredReader in =new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()),true);
while(true){
String str = in.readLine();
if (str!=null && str.equals("Hi")) out.println("Hi, here is server.");
}catch(Exception e){
e.printStackTrace();
}finally{
socket.close();
server.close();
}
}
```
* TCP
* UDP
* read a web page
``` java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
public class conn {
public static void main(String[] args) {
try{
URL coseURL = new URL("http://cose.seu.edu.cn");
URLConnection connection =coseURL.openConnection();
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String html = in.readLine();
while(html!=null){
System.out.println(html);
html=in.readLine();
}
}catch (Exception e){
}
}
}
``` | 19,343 | MIT |
---
layout: post
title: spring boot项目自定义数据源，mybatisplus分页、逻辑删除无效解决方法
date: 2021-04-16 14:26:00 +0800
img: /assets/img/head.png # Add image post (optional)
tags: [java] # add tag
---
### Spring Boot项目中数据源的配置可以通过两种方式实现：
1.application.yml或者application.properties配置
2.注入DataSource及SqlSessionFactory两个Bean
### 通过第二种方式配置数据源则按照MybatisPlus官方文档使用分页及逻辑删除插件会无效，解决思路是在初始化SqlSessionFactory将插件设置进去
```java
/**
* 逻辑删除插件
*/
@Bean
public GlobalConfig globalConfig(){
GlobalConfig globalConfig=new GlobalConfig();
GlobalConfig.DbConfig dbConfig=new GlobalConfig.DbConfig();
dbConfig.setLogicDeleteValue("Y");
dbConfig.setLogicNotDeleteValue("N");
globalConfig.setDbConfig(dbConfig);
globalConfig.setSqlInjector(new LogicSqlInjector());
return globalConfig;
}
/**
* 分页插件
*/
@Bean
public PaginationInterceptor paginationInterceptor(){
PaginationInterceptor paginationInterceptor=new PaginationInterceptor();
paginationInterceptor.setDialectType(DbType.MYSQL.getDb());
return paginationInterceptor;
}
@Bean(name = "sqlSessionFactory")
public SqlSessionFactory sqlSessionFactory()throws Exception{
logger.info("初始化SqlSessionFactory");
String mapperLocations="classpath:mybatis/mapper/**/*.xml";
String configLocation="classpath:mybatis/mybatis-config.xml";
MybatisSqlSessionFactoryBean sqlSessionFactory=new MybatisSqlSessionFactoryBean();
sqlSessionFactory.setDataSource(dataSource()); //数据源
ResourcePatternResolver resolver=new PathMatchingResourcePatternResolver();
sqlSessionFactory.setMapperLocations(resolver.getResources(mapperLocations));
sqlSessionFactory.setConfigLocation(resolver.getResource(configLocation));
sqlSessionFactory.setTypeAliasesPackage("com.innjoy.pms.order.infrastructure.domain.model");
sqlSessionFactory.setGlobalConfig(globalConfig());
sqlSessionFactory.setPlugins(new Interceptor[]{paginationInterceptor()});
return sqlSessionFactory.getObject();
}
``` | 1,961 | MIT |
---
order: 7
title:
zh-CN: 附加额外数据
en-US: Append Extra Data
---
## zh-CN
为一个文件上传请求追加一个`FormData`实例。请查看开发者工具中的 Network 标签。
## en-US
Append an extra `FormData` instance to a file upload request. Please checkout the 'Network' tab in the developer tool.
```jsx
import { Upload } from 'choerodon-ui/pro';
const props = {
headers: {
'Access-Control-Allow-Origin': '*',
},
action: 'https://www.mocky.io/v2/5cc8019d300000980a055e76',
multiple: true,
accept: ['.deb', '.txt', '.pdf', 'image/*'],
uploadImmediately: false,
data: {
key1: 'value1',
key2: 'value2',
},
onUploadSuccess: response => console.log(response),
};
ReactDOM.render(
<div>
<Upload {...props} />
</div>,
mountNode,
);
``` | 733 | MIT |
<properties
pageTitle="Azure Management API 証明書のアップロード | Azure Microsoft"
description="Azure クラシック ポータルの Management API 証明書をアップロードする方法について説明します。"
services="cloud-services"
documentationCenter=".net"
authors="Thraka"
manager="timlt"
editor=""/>
<tags
ms.service="na"
ms.workload="tbd"
ms.tgt_pltfrm="na"
ms.devlang="na"
ms.topic="article"
ms.date="04/18/2016"
ms.author="adegeo"/>
# Azure Management API Management 証明書のアップロード
Azure のサービス管理 API に対する認証は、管理証明書で行うことができます。これらの証明書は、各種 Azure サービスの構成とデプロイメントを自動化するために、今後多くのプログラムおよびツール (Visual Studio、Azure SDK など) で使用されることになります。**これは Azure クラシック ポータルにのみ適用されます**。
>[AZURE.WARNING] ご注意ください。 これらの種類の証明書を使用して認証する場合、関連付けられているサブスクリプションを管理できます。
Azure の証明書の詳細 (自己署名証明書の作成を含む) については、[こちら](cloud-services/cloud-services-certs-create.md#what-are-management-certificates)をご覧ください。
クライアント コードの認証に [Azure Active Directory](/services/active-directory/) を使用することで自動化を図ることもできます。
## 管理証明書のアップロード
管理証明書 (公開キーのみを含んだ .cer ファイル) を作成したら、それをポータルにアップロードすることができます。ポータルで証明書が使用可能な状態になると、対になる証明書 (秘密キー) を持つすべての人が、Management API を経由して接続し、そのサブスクリプションに関連付けられているリソースにアクセスすることができます。
1. [Azure クラシック ポータル](http://manage.windowsazure.com)にログインします。
2. ポータルの左側にある **[設定]** をクリックします (必要に応じて下へスクロールしてください)。
3. **[管理証明書]** タブをクリックします。
4. **[アップロード]** ボタンをクリックします。
5. ダイアログの情報を入力し、確認のための**チェックマーク**をクリックします。
## 次のステップ
サブスクリプションへの管理証明書の関連付けはこれで完了です。対になる証明書がローカルにインストールされていれば、プログラムから [Service Management REST API](https://msdn.microsoft.com/library/azure/mt420159.aspx) に接続し、同じサブスクリプションに関連付けられているさまざまな Azure リソースを自動化できます。
<!---HONumber=AcomDC_0511_2016--> | 1,870 | CC-BY-3.0 |
#### 目录介绍
- 01.使用Intent
- 02.使用文件共享
- 03.使用Messenger
- 04.使用AIDL
- 05.使用ContentProvider
- 06.使用Socket
### 好消息
- 博客笔记大汇总【16年3月到至今】，包括Java基础及深入知识点，Android技术博客，Python学习笔记等等，还包括平时开发中遇到的bug汇总，当然也在工作之余收集了大量的面试题，长期更新维护并且修正，持续完善……开源的文件是markdown格式的！同时也开源了生活博客，从12年起，积累共计N篇[近100万字，陆续搬到网上]，转载请注明出处，谢谢！
- **链接地址：https://github.com/yangchong211/YCBlogs**
- 如果觉得好，可以star一下，谢谢！当然也欢迎提出建议，万事起于忽微，量变引起质变！
### 01.使用Intent
- 1.Activity，Service，Receiver 都支持在 Intent 中传递 Bundle 数据，而 Bundle 实现了 Parcelable 接口，可以在不同的进程间进行传输。
- 2.在一个进程中启动了另一个进程的 Activity，Service 和 Receiver ，可以在 Bundle 中附加要传递的数据通过 Intent 发送出去。
### 02.使用文件共享
- 1.Windows 上，一个文件如果被加了排斥锁会导致其他线程无法对其进行访问，包括读和写；而 Android 系统基于 Linux ，使得其并发读取文件没有限制地进行，甚至允许两个线程同时对一个文件进行读写操作，尽管这样可能会出问题。
- 2.可以在一个进程中序列化一个对象到文件系统中，在另一个进程中反序列化恢复这个对象（**注意**：并不是同一个对象，只是内容相同。）。
- 3.SharedPreferences 是个特例，系统对它的读 / 写有一定的缓存策略，即内存中会有一份 ShardPreferences 文件的缓存，系统对他的读 / 写就变得不可靠，当面对高并发的读写访问，SharedPreferences 有很多大的几率丢失数据。因此，IPC 不建议采用 SharedPreferences。
### 03.使用Messenger
- Messenger 是一种轻量级的 IPC 方案，它的底层实现是 AIDL ，可以在不同进程中传递 Message 对象，它一次只处理一个请求，在服务端不需要考虑线程同步的问题，服务端不存在并发执行的情形。
- 服务端进程：
- 服务端创建一个 Service 来处理客户端请求，同时通过一个 Handler 对象来实例化一个 Messenger 对象，然后在 Service 的 onBind 中返回这个 Messenger 对象底层的 Binder 即可。
```java
public class MessengerService extends Service {
private static final String TAG = MessengerService.class.getSimpleName();
private class MessengerHandler extends Handler {
/**
* @param msg
*/
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case Constants.MSG_FROM_CLIENT:
Log.d(TAG, "receive msg from client: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]");
Toast.makeText(MessengerService.this, "receive msg from client: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]", Toast.LENGTH_SHORT).show();
Messenger client = msg.replyTo;
Message replyMsg = Message.obtain(null, Constants.MSG_FROM_SERVICE);
Bundle bundle = new Bundle();
bundle.putString(Constants.MSG_KEY, "我已经收到你的消息，稍后回复你！");
replyMsg.setData(bundle);
try {
client.send(replyMsg);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
private Messenger mMessenger = new Messenger(new MessengerHandler());
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
}
```
- 客户端进程：
- 首先绑定服务端 Service ，绑定成功之后用服务端的 IBinder 对象创建一个 Messenger ，通过这个 Messenger 就可以向服务端发送消息了，消息类型是 Message 。如果需要服务端响应，则需要创建一个 Handler 并通过它来创建一个 Messenger（和服务端一样），并通过 Message 的 replyTo 参数传递给服务端。服务端通过 Message 的 replyTo 参数就可以回应客户端了。
```Java
public class MainActivity extends AppCompatActivity {
private static final String TAG = MainActivity.class.getSimpleName();
private Messenger mGetReplyMessenger = new Messenger(new MessageHandler());
private Messenger mService;
private class MessageHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case Constants.MSG_FROM_SERVICE:
Log.d(TAG, "received msg form service: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]");
Toast.makeText(MainActivity.this, "received msg form service: msg = [" + msg.getData().getString(Constants.MSG_KEY) + "]", Toast.LENGTH_SHORT).show();
break;
default:
super.handleMessage(msg);
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
public void bindService(View v) {
Intent mIntent = new Intent(this, MessengerService.class);
bindService(mIntent, mServiceConnection, Context.BIND_AUTO_CREATE);
}
public void sendMessage(View v) {
Message msg = Message.obtain(null,Constants.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString(Constants.MSG_KEY, "Hello! This is client.");
msg.setData(data);
msg.replyTo = mGetReplyMessenger;
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
protected void onDestroy() {
unbindService(mServiceConnection);
super.onDestroy();
}
private ServiceConnection mServiceConnection = new ServiceConnection() {
/**
* @param name
* @param service
*/
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = new Messenger(service);
Message msg = Message.obtain(null,Constants.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString(Constants.MSG_KEY, "Hello! This is client.");
msg.setData(data);
//
msg.replyTo = mGetReplyMessenger;
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
/**
* @param name
*/
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
}
```
- **注意：**客户端和服务端是通过拿到对方的 Messenger 来发送 Message 的。
- 客户端通过 bindService onServiceConnected 而服务端通过 message.replyTo 来获得对方的 Messenger 。Messenger中有一个Hanlder以串行的方式处理队列中的消息。不存在并发执行，因此我们不用考虑线程同步的问题。
### 04.使用AIDL
- Messenger 是以串行的方式处理客户端发来的消息，如果大量消息同时发送到服务端，服务端只能一个一个处理，所以大量并发请求就不适合用Messenger，而且Messenger只适合传递消息，不能跨进程调用服务端的方法。
- AIDL 可以解决并发和跨进程调用方法的问题，要知道Messenger本质上也是AIDL，只不过系统做了封装方便上层的调用而已。
#### 4.1 AIDL文件支持的数据类型
- *基本数据类型*；
- *String* 和 *CharSequence*
- [](http://images.cnitblog.com/blog/497634/201311/08083111-591e2833f8a34264b0dad417f4188e35.jpg)
- *ArrayList* ，里面的元素必须能够被 AIDL 支持；
- *HashMap* ，里面的元素必须能够被 AIDL 支持；
- *Parcelable* ，实现 Parcelable 接口的对象；
**注意：如果 AIDL 文件中用到了自定义的 Parcelable 对象，必须新建一个和它同名的 AIDL 文件。**
- *AIDL* ，AIDL 接口本身也可以在 AIDL 文件中使用。
#### 4.2 服务端
- 服务端创建一个 Service 用来监听客户端的连接请求，然后创建一个 AIDL 文件，将暴露给客户端的接口在这个 AIDL 文件中声明，最后在 Service 中实现这个 AIDL 接口即可。
#### 4.3客户端
- 绑定服务端的 Service ，绑定成功后，将服务端返回的 Binder 对象转成 AIDL 接口所属的类型，然后就可以调用 AIDL 中的方法了。客户端调用远程服务的方法，被调用的方法运行在服务端的 Binder 线程池中，同时客户端的线程会被挂起，如果服务端方法执行比较耗时，就会导致客户端线程长时间阻塞，导致 ANR 。客户端的 onServiceConnected 和 onServiceDisconnected 方法都在 UI 线程中。
### 05.使用ContentProvider
- 用于不同应用间数据共享，和 Messenger 底层实现同样是 Binder 和 AIDL，系统做了封装，使用简单。
- 系统预置了许多 ContentProvider ，如通讯录、日程表，需要跨进程访问。使用方法：继承 ContentProvider 类实现 6 个抽象方法，这六个方法均运行在 ContentProvider 进程中，除 onCreate 运行在主线程里，其他五个方法均由外界回调运行在 Binder 线程池中。ContentProvider 的底层数据，可以是 SQLite 数据库，可以是文件，也可以是内存中的数据。
- 详见代码：
```
public class BookProvider extends ContentProvider {
private static final String TAG = "BookProvider";
public static final String AUTHORITY = "com.jc.ipc.Book.Provider";
public static final Uri BOOK_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/book");
public static final Uri USER_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/user");
public static final int BOOK_URI_CODE = 0;
public static final int USER_URI_CODE = 1;
private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
static {
sUriMatcher.addURI(AUTHORITY, "book", BOOK_URI_CODE);
sUriMatcher.addURI(AUTHORITY, "user", USER_URI_CODE);
}
private Context mContext;
private SQLiteDatabase mDB;
@Override
public boolean onCreate() {
mContext = getContext();
initProviderData();
return true;
}
private void initProviderData() {
//不建议在 UI 线程中执行耗时操作
mDB = new DBOpenHelper(mContext).getWritableDatabase();
mDB.execSQL("delete from " + DBOpenHelper.BOOK_TABLE_NAME);
mDB.execSQL("delete from " + DBOpenHelper.USER_TABLE_NAME);
mDB.execSQL("insert into book values(3,'Android');");
mDB.execSQL("insert into book values(4,'iOS');");
mDB.execSQL("insert into book values(5,'Html5');");
mDB.execSQL("insert into user values(1,'haohao',1);");
mDB.execSQL("insert into user values(2,'nannan',0);");
}
@Nullable
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
Log.d(TAG, "query, current thread"+ Thread.currentThread());
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI" + uri);
}
return mDB.query(table, projection, selection, selectionArgs, null, null, sortOrder, null);
}
@Nullable
@Override
public String getType(Uri uri) {
Log.d(TAG, "getType");
return null;
}
@Nullable
@Override
public Uri insert(Uri uri, ContentValues values) {
Log.d(TAG, "insert");
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI" + uri);
}
mDB.insert(table, null, values);
// 通知外界 ContentProvider 中的数据发生变化
mContext.getContentResolver().notifyChange(uri, null);
return uri;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
Log.d(TAG, "delete");
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI" + uri);
}
int count = mDB.delete(table, selection, selectionArgs);
if (count > 0) {
mContext.getContentResolver().notifyChange(uri, null);
}
return count;
}
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
Log.d(TAG, "update");
String table = getTableName(uri);
if (table == null) {
throw new IllegalArgumentException("Unsupported URI" + uri);
}
int row = mDB.update(table, values, selection, selectionArgs);
if (row > 0) {
getContext().getContentResolver().notifyChange(uri, null);
}
return row;
}
private String getTableName(Uri uri) {
String tableName = null;
switch (sUriMatcher.match(uri)) {
case BOOK_URI_CODE:
tableName = DBOpenHelper.BOOK_TABLE_NAME;
break;
case USER_URI_CODE:
tableName = DBOpenHelper.USER_TABLE_NAME;
break;
default:
break;
}
return tableName;
}
}
```
- DBOpenHelper代码如下所示
```java
public class DBOpenHelper extends SQLiteOpenHelper {
private static final String DB_NAME = "book_provider.db";
public static final String BOOK_TABLE_NAME = "book";
public static final String USER_TABLE_NAME = "user";
private static final int DB_VERSION = 1;
private String CREATE_BOOK_TABLE = "CREATE TABLE IF NOT EXISTS "
+ BOOK_TABLE_NAME + "(_id INTEGER PRIMARY KEY," + "name TEXT)";
private String CREATE_USER_TABLE = "CREATE TABLE IF NOT EXISTS "
+ USER_TABLE_NAME + "(_id INTEGER PRIMARY KEY," + "name TEXT,"
+ "sex INT)";
public DBOpenHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(CREATE_BOOK_TABLE);
db.execSQL(CREATE_USER_TABLE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}
}
```
- 测试代码
```java
public class ProviderActivity extends AppCompatActivity {
private static final String TAG = ProviderActivity.class.getSimpleName();
private TextView displayTextView;
private Handler mHandler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_provider);
displayTextView = (TextView) findViewById(R.id.displayTextView);
mHandler = new Handler();
getContentResolver().registerContentObserver(BookProvider.BOOK_CONTENT_URI, true, new ContentObserver(mHandler) {
@Override
public boolean deliverSelfNotifications() {
return super.deliverSelfNotifications();
}
@Override
public void onChange(boolean selfChange) {
super.onChange(selfChange);
}
@Override
public void onChange(boolean selfChange, Uri uri) {
Toast.makeText(ProviderActivity.this, uri.toString(), Toast.LENGTH_SHORT).show();
super.onChange(selfChange, uri);
}
});
}
public void insert(View v) {
ContentValues values = new ContentValues();
values.put("_id",1123);
values.put("name", "三国演义");
getContentResolver().insert(BookProvider.BOOK_CONTENT_URI, values);
}
public void delete(View v) {
getContentResolver().delete(BookProvider.BOOK_CONTENT_URI, "_id = 4", null);
}
public void update(View v) {
ContentValues values = new ContentValues();
values.put("_id",1123);
values.put("name", "三国演义新版");
getContentResolver().update(BookProvider.BOOK_CONTENT_URI, values , "_id = 1123", null);
}
public void query(View v) {
Cursor bookCursor = getContentResolver().query(BookProvider.BOOK_CONTENT_URI, new String[]{"_id", "name"}, null, null, null);
StringBuilder sb = new StringBuilder();
while (bookCursor.moveToNext()) {
Book book = new Book(bookCursor.getInt(0),bookCursor.getString(1));
sb.append(book.toString()).append("\n");
}
sb.append("--------------------------------").append("\n");
bookCursor.close();
Cursor userCursor = getContentResolver().query(BookProvider.USER_CONTENT_URI, new String[]{"_id", "name", "sex"}, null, null, null);
while (userCursor.moveToNext()) {
sb.append(userCursor.getInt(0))
.append(userCursor.getString(1)).append(" ,")
.append(userCursor.getInt(2)).append(" ,")
.append("\n");
}
sb.append("--------------------------------");
userCursor.close();
displayTextView.setText(sb.toString());
}
}
```
### 06.使用Socket
> Socket起源于 Unix，而 Unix 基本哲学之一就是“一切皆文件”，都可以用“打开 open –读写 write/read –关闭 close ”模式来操作。Socket 就是该模式的一个实现，网络的 Socket 数据传输是一种特殊的 I/O，Socket 也是一种文件描述符。Socket 也具有一个类似于打开文件的函数调用： Socket()，该函数返回一个整型的Socket 描述符，随后的连接建立、数据传输等操作都是通过该 Socket 实现的。
> 常用的 Socket 类型有两种：流式 Socket（SOCK_STREAM）和数据报式 Socket（SOCK_DGRAM）。流式是一种面向连接的 Socket，针对于面向连接的 TCP 服务应用；数据报式 Socket 是一种无连接的 Socket ，对应于无连接的 UDP 服务应用。
- Socket 本身可以传输任意字节流。谈到Socket，就必须要说一说 TCP/IP 五层网络模型：
- 应用层：规定应用程序的数据格式，主要的协议 HTTP，FTP，WebSocket，POP3 等；
- 传输层：建立“端口到端口” 的通信，主要的协议：TCP，UDP；
- 网络层：建立”主机到主机”的通信，主要的协议：IP，ARP ，IP 协议的主要作用：一个是为每一台计算机分配 IP 地址，另一个是确定哪些地址在同一子网；
- 数据链路层：确定电信号的分组方式，主要的协议：以太网协议；
- 物理层：负责电信号的传输。
- **Socket 是连接应用层与传输层之间接口（API）。**
- [](https://github.com/astaxie/build-web-application-with-golang/raw/master/zh/images/8.1.socket.png?raw=true)
#### 5.1Client 端代码：
- 代码如下所示
```
public class TCPClientActivity extends AppCompatActivity implements View.OnClickListener{
private static final String TAG = "TCPClientActivity";
public static final int MSG_RECEIVED = 0x10;
public static final int MSG_READY = 0x11;
private EditText editText;
private TextView textView;
private PrintWriter mPrintWriter;
private Socket mClientSocket;
private Button sendBtn;
private StringBuilder stringBuilder;
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_READY:
sendBtn.setEnabled(true);
break;
case MSG_RECEIVED:
stringBuilder.append(msg.obj).append("\n");
textView.setText(stringBuilder.toString());
break;
default:
super.handleMessage(msg);
}
}
};
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.tcp_client_activity);
editText = (EditText) findViewById(R.id.editText);
textView = (TextView) findViewById(R.id.displayTextView);
sendBtn = (Button) findViewById(R.id.sendBtn);
sendBtn.setOnClickListener(this);
sendBtn.setEnabled(false);
stringBuilder = new StringBuilder();
Intent intent = new Intent(TCPClientActivity.this, TCPServerService.class);
startService(intent);
new Thread(){
@Override
public void run() {
connectTcpServer();
}
}.start();
}
private String formatDateTime(long time) {
return new SimpleDateFormat("(HH:mm:ss)").format(new Date(time));
}
private void connectTcpServer() {
Socket socket = null;
while (socket == null) {
try {
socket = new Socket("localhost", 8888);
mClientSocket = socket;
mPrintWriter = new PrintWriter(new BufferedWriter(
new OutputStreamWriter(socket.getOutputStream())
), true);
mHandler.sendEmptyMessage(MSG_READY);
} catch (IOException e) {
e.printStackTrace();
}
}
// receive message
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
while (!isFinishing()) {
try {
String msg = bufferedReader.readLine();
if (msg != null) {
String time = formatDateTime(System.currentTimeMillis());
String showedMsg = "server " + time + ":" + msg
+ "\n";
mHandler.obtainMessage(MSG_RECEIVED, showedMsg).sendToTarget();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Override
public void onClick(View v) {
if (mPrintWriter != null) {
String msg = editText.getText().toString();
mPrintWriter.println(msg);
editText.setText("");
String time = formatDateTime(System.currentTimeMillis());
String showedMsg = "self " + time + ":" + msg + "\n";
stringBuilder.append(showedMsg);
}
}
@Override
protected void onDestroy() {
if (mClientSocket != null) {
try {
mClientSocket.shutdownInput();
mClientSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
super.onDestroy();
}
}
```
#### 5.2 Server 端代码
- 代码如下所示
```java
public class TCPServerService extends Service {
private static final String TAG = "TCPServerService";
private boolean isServiceDestroyed = false;
private String[] mMessages = new String[]{
"Hello! Body!",
"用户不在线！请稍后再联系！",
"请问你叫什么名字呀？",
"厉害了，我的哥！",
"Google 不需要科学上网是真的吗？",
"扎心了，老铁！！！"
};
@Override
public void onCreate() {
new Thread(new TCPServer()).start();
super.onCreate();
}
@Override
public void onDestroy() {
isServiceDestroyed = true;
super.onDestroy();
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
private class TCPServer implements Runnable {
@Override
public void run() {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(8888);
} catch (IOException e) {
e.printStackTrace();
return;
}
while (!isServiceDestroyed) {
// receive request from client
try {
final Socket client = serverSocket.accept();
Log.d(TAG, "=============== accept ==================");
new Thread(){
@Override
public void run() {
try {
responseClient(client);
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private void responseClient(Socket client) throws IOException {
//receive message
BufferedReader in = new BufferedReader(
new InputStreamReader(client.getInputStream()));
//send message
PrintWriter out = new PrintWriter(
new BufferedWriter(
new OutputStreamWriter(
client.getOutputStream())),true);
out.println("欢迎来到聊天室！");
while (!isServiceDestroyed) {
String str = in.readLine();
Log.d(TAG, "message from client: " + str);
if (str == null) {
return;
}
Random random = new Random();
int index = random.nextInt(mMessages.length);
String msg = mMessages[index];
out.println(msg);
Log.d(TAG, "send Message: " + msg);
}
out.close();
in.close();
client.close();
}
}
```
### 其他介绍
#### 01.关于博客汇总链接
- 1.[技术博客汇总](https://www.jianshu.com/p/614cb839182c)
- 2.[开源项目汇总](https://blog.csdn.net/m0_37700275/article/details/80863574)
- 3.[生活博客汇总](https://blog.csdn.net/m0_37700275/article/details/79832978)
- 4.[喜马拉雅音频汇总](https://www.jianshu.com/p/f665de16d1eb)
- 5.[其他汇总](https://www.jianshu.com/p/53017c3fc75d)
#### 02.关于我的博客
- github：https://github.com/yangchong211
- 知乎：https://www.zhihu.com/people/yczbj/activities
- 简书：http://www.jianshu.com/u/b7b2c6ed9284
- csdn：http://my.csdn.net/m0_37700275
- 喜马拉雅听书：http://www.ximalaya.com/zhubo/71989305/
- 开源中国：https://my.oschina.net/zbj1618/blog
- 泡在网上的日子：http://www.jcodecraeer.com/member/content_list.php?channelid=1
- 邮箱：[email protected]
- 阿里云博客：https://yq.aliyun.com/users/article?spm=5176.100- 239.headeruserinfo.3.dT4bcV
- segmentfault头条：https://segmentfault.com/u/xiangjianyu/articles
- 掘金：https://juejin.im/user/5939433efe88c2006afa0c6e | 25,921 | Apache-2.0 |
# CsprojModifier
CsprojModifier は Unity Editor が .csproj を生成する際に追加の処理を行うことで、Visual Studio や Rider のような IDE での開発体験を向上させます。
CsprojModifier は次の特徴を備えています:
- 生成された .csproj に追加のプロジェクトを `Import` 要素で追加する
- 生成された .csproj に Analzyer の参照を追加する
- 2020.2 以降で Rider または Visual Studio Code を利用している場合には無効
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
## Table of Contents
- [Works with](#works-with)
- [Install](#install)
- [Features](#features)
- [生成された .csproj に追加のプロジェクトを `Import` 要素で追加する](#%E7%94%9F%E6%88%90%E3%81%95%E3%82%8C%E3%81%9F-csproj-%E3%81%AB%E8%BF%BD%E5%8A%A0%E3%81%AE%E3%83%97%E3%83%AD%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E3%82%92-import-%E8%A6%81%E7%B4%A0%E3%81%A7%E8%BF%BD%E5%8A%A0%E3%81%99%E3%82%8B)
- [例](#%E4%BE%8B)
- [追加のプロジェクトファイル (.props, .targets) の内容を直接 .csproj に追加する](#%E8%BF%BD%E5%8A%A0%E3%81%AE%E3%83%97%E3%83%AD%E3%82%B8%E3%82%A7%E3%82%AF%E3%83%88%E3%83%95%E3%82%A1%E3%82%A4%E3%83%AB-props-targets-%E3%81%AE%E5%86%85%E5%AE%B9%E3%82%92%E7%9B%B4%E6%8E%A5-csproj-%E3%81%AB%E8%BF%BD%E5%8A%A0%E3%81%99%E3%82%8B)
- [生成された .csproj に Analzyer の参照を追加する](#%E7%94%9F%E6%88%90%E3%81%95%E3%82%8C%E3%81%9F-csproj-%E3%81%AB-analzyer-%E3%81%AE%E5%8F%82%E7%85%A7%E3%82%92%E8%BF%BD%E5%8A%A0%E3%81%99%E3%82%8B)
- [使用方法](#%E4%BD%BF%E7%94%A8%E6%96%B9%E6%B3%95)
- [License](#license)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
## Works with
- Unity Editor 2019.4 (LTS) or later
- Visual Studio 2019 or Rider
## Install
Package Manager から git 経由でインストールします。
```
https://github.com/Cysharp/CsprojModifier.git?path=src/CsprojModifier/Assets/CsprojModifier
```
## Features
### 生成された .csproj に追加のプロジェクトを `Import` 要素で追加する
任意の追加のプロジェクトファイル (.props や .target) を生成された .csproj に `Import` 要素を使用して追加します。これによりプロジェクトにファイルを追加したり、参照を追加したりが可能になります。
**注意:** .csproj は Visual Studio や Rider のような IDE でのみ使用され、 Unity Editor での実際のビルドには使用されません
#### 例
例えば、次のような `YourAwesomeApp.DesignTime.props` というファイルを作成し、インポートすることで [BannedApiAnalyzer](https://github.com/dotnet/roslyn-analyzers/tree/main/src/Microsoft.CodeAnalysis.BannedApiAnalyzers) を使用できます。
```xml
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Analyzer Include="Assets/Plugins/Editor/Analyzers/Microsoft.CodeAnalysis.BannedApiAnalyzers.dll" />
<Analyzer Include="Assets/Plugins/Editor/Analyzers/Microsoft.CodeAnalysis.CSharp.BannedApiAnalyzers.dll" />
</ItemGroup>
<ItemGroup>
<AdditionalFiles Include="$(ProjectDir)\BannedSymbols.txt" />
</ItemGroup>
</Project>
```
[BannedApiAnalyzer](https://github.com/dotnet/roslyn-analyzers/tree/main/src/Microsoft.CodeAnalysis.BannedApiAnalyzers) は BannedSymbols.txt が `AdditionalFiles` としてプロジェクトに追加されていることを期待しているため、これによってうまく機能するようになります。
#### 追加のプロジェクトファイル (.props, .targets) の内容を直接 .csproj に追加する
挿入位置として `Append Content` または `Prepend Content` を指定した場合、CsProjModifier は XML を読み込んで要素を直接 .csproj に注入します。
```xml
<!-- * Example: `Prepend: MyApp.Unity.props` -->
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<!--MyApp.Unity.props:HASH-->
<Import Project="MyApp.Unity.props" />
<!-- .csproj content generated by Unity Editor -->
<!-- ... -->
</Project>
<!-- * Example: `Prepend Content: MyApp.Unity.props` -->
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<!--MyApp.Unity.props:HASH-->
<ItemGroup>
<!-- ... -->
<!-- ... -->
<!-- ... -->
</ItemGroup>
<!-- .csproj content generated by Unity Editor -->
<!-- ... -->
</Project>
```
### 生成された .csproj に Analzyer の参照を追加する
**注意**: Rider または Visual Studio Code を Unity 2020.2 以降で使用している場合にはこの機能は無効となります。IDE での Roslyn Analyzer は Unity Editor によってサポートされます。
[Roslyn Analyzer は Unity 2020.2 以降でサポートされました](https://docs.unity3d.com/Manual/roslyn-analyzers.html)。しかしながら、現在 Roslyn Analyzer は .csproj に追加されず、コンパイル時にのみ使用されます。
この拡張は `Analyzer` 要素を .csproj プロジェクトファイルが生成される際に追加します。その結果、Visual Studio でコード編集時にも Roslyn Analyzer の恩恵を受けることができます。(もちろん、2020.2 以前にも対応します)
#### 使用方法
[Unity 2020.2 と同様の方法で Roslyn Analyzer をプロジェクトに追加します](https://docs.unity3d.com/Manual/roslyn-analyzers.html)
- Roslyn Analyzer ライブラリを追加する
- Plugin インスペクターですべてのターゲットプラットフォームからチェックを外す
- `RoslynAnalyzer` アセットラベルをライブラリに付与する
## License
MIT License | 4,438 | MIT |
---
title: "Apache Storm チュートリアル: Storm 入門 |Microsoft Docs"
description: "HDInsight での Apache Storm および Storm Starter サンプルを使用したビッグ データ分析の概要 Storm を使用してデータをリアルタイムに処理する方法について説明します。"
keywords: "Apache Storm, Apache Storm チュートリアル, ビッグ データの分析, Storm Starter"
services: hdinsight
documentationcenter:
author: Blackmist
manager: jhubbard
editor: cgronlun
tags: azure-portal
ms.assetid: 6f93f7ff-0736-4708-80ef-4289dae532a9
ms.service: hdinsight
ms.devlang: java
ms.topic: article
ms.tgt_pltfrm: na
ms.workload: big-data
ms.date: 09/07/2016
ms.author: larryfr
translationtype: Human Translation
ms.sourcegitcommit: 2ea002938d69ad34aff421fa0eb753e449724a8f
ms.openlocfilehash: 6576c388b8ade43205d56c0d6de2ef553ea5f61e
---
# <a name="apache-storm-tutorial-get-started-with-the-storm-starter-samples-for-big-data-analytics-on-hdinsight"></a>Apache Storm チュートリアル: Storm Starter サンプルを使用した HDInsight でのビッグ データ分析の概要
Apache Storm は、データ ストリームの処理を目的とし、スケーラビリティとフォールト トレランスに優れた、分散型のリアルタイム計算システムです。 Microsoft Azure HDInsight の Storm を使用して、Storm でリアルタイムで ビッグ データ分析を実行するクラウドベースの Storm クラスターを作成できます。
> [!NOTE]
> この記事の手順では、Windows ベースの HDInsight クラスターを作成します。 HDInsight クラスターで Linux ベースの Storm を作成する手順については、「 [Apache Storm チュートリアル: Storm Starter サンプルを使用した HDInsight でのビッグ データ分析の概要](hdinsight-apache-storm-tutorial-get-started-linux.md)
>
>
## <a name="prerequisites"></a>前提条件
[!INCLUDE [delete-cluster-warning](../../includes/hdinsight-delete-cluster-warning.md)]
Apache Storm チュートリアルを正常に完了するには、次の条件を満たす必要があります。
* **Azure サブスクリプション**。 [Azure 無料試用版の取得](https://azure.microsoft.com/documentation/videos/get-azure-free-trial-for-testing-hadoop-in-hdinsight/)に関するページを参照してください。
### <a name="access-control-requirements"></a>アクセス制御の要件
[!INCLUDE [access-control](../../includes/hdinsight-access-control-requirements.md)]
## <a name="create-a-storm-cluster"></a>Storm クラスターを作成する
HDInsight の Storm では、ログ ファイルとクラスターに送信されるトポロジを格納する Azure Blob Storage を使用します。 次の手順を使用して、クラスターに使用する Azure ストレージ アカウントを作成します。
1. [Azure Portal][preview-portal] にサインインします。
2. **[新規]**、**[データ分析]**、**[HDInsight]** の順にクリックします。
3. **クラスター名**を入力します。 クラスターを使用できる場合は、**クラスター名**の横に緑色のチェック マークが表示されます。
4. 複数のサブスクリプションがある場合は、**[サブスクリプション]** エントリを選択し、クラスターで使用する Azure サブスクリプションを選択します。
5. **[クラスターの種類の選択]** を使用して **Storm** クラスターを選択します。 **[オペレーティング システム]** で [Windows] を選択します。 **[Cluster Tier (クラスター階層)]** に [STANDARD (標準)] を選択します。 最後に、選択ボタンを使用してこれらの設定を保存します。
6. **[リソース グループ]**では、ドロップダウン リストを使用して既存のリソース グループの一覧を表示し、クラスターを作成するグループを選択できます。 または、**[新規]** をクリックし、新しいリソース グループの名前を入力します。 新しいグループ名を使用できる場合は、緑のチェック マークが表示されます。
7. **[資格情報]** を選択し、**[クラスターのログイン ユーザー名]** と **[クラスターのログイン パスワード]** を入力します。 最後に、**[選択]** をクリックして資格情報を設定します。 このドキュメントではリモート デスクトップは使用しないため、無効にしておくことができます。
![[クラスターの資格情報] ブレード](./media/hdinsight-apache-storm-tutorial-get-started/clustercredentials.png)
8. **[データ ソース]** では、エントリを選択して既存のデータ ソースを選択するか、新しいデータ ソースを作成できます。
![[データ ソース] ブレード](./media/hdinsight-apache-storm-tutorial-get-started/datasource.png)
現在、HDInsight クラスターのデータ ソースとして Azure ストレージ アカウントを選択できます。 次の説明を参照して、 **[データ ソース]** ブレードのエントリを理解してください。
* **[選択方法]**: サブスクリプションのストレージ アカウントを参照可能にする場合は、**[すべてのサブスクリプションから]** を設定します。 既存のストレージ アカウントの **[ストレージ名]** と **[アクセス キー]** を入力する場合は、**[アクセス キー]** を設定します。
* **[新規作成]**: これを使用して、新しいストレージ アカウントを作成します。 表示されたフィールドに、ストレージ アカウントの名前を入力します。 名前を使用できる場合は、緑色のチェック マークが表示されます。
* **[既定のコンテナーの選択]**: これを使用して、クラスターで使用する既定のコンテナーの名前を入力します。 任意の名前を入力できますが、コンテナーが特定のクラスターで使用されていることを簡単に認識できるように、クラスターと同じ名前を使用することをお勧めします。
* **[場所]**: ストレージ アカウントが存在するリージョン、またはストレージ アカウントの作成先のリージョン。
> [!IMPORTANT]
> 既定のデータ ソースの場所を選択すると、HDInsight クラスターの場所も設定されます。 クラスターと既定のデータ ソースは、同じリージョンに存在する必要があります。
>
>
* **[選択]**: これを使用してデータ ソースの構成を保存します。
9. **[ノード価格レベル]** を選択して、このクラスターのために作成されるノードに関する情報を表示します。 既定では、worker ノードの数は **4** に設定されています。 これを **1** に設定します。このチュートリアルではこの数で十分であり、クラスターのコストが削減されます。 クラスターの推定コストがブレードの下部に表示されます。
![[ノード価格レベル] ブレード](./media/hdinsight-apache-storm-tutorial-get-started/nodepricingtiers.png)
**[選択]** をクリックして、**[ノード価格レベル]** 情報を保存します。
10. **[オプションの構成]**を選択します。 このブレードでは、クラスターのバージョンを選択し、その他のオプションの設定 (**Virtual Network** への参加など) を構成できます。
![[オプションの構成] ブレード](./media/hdinsight-apache-storm-tutorial-get-started/optionalconfiguration.png)
11. **[スタート画面にピン留めする]** が選択されていることを確認し、**[作成]** をクリックします。 これでクラスターが作成され、Azure ポータルのスタート画面にクラスター用のタイルが追加されます。 アイコンはクラスターがプロビジョニング中であることを示し、プロビジョニングが完了すると、[HDInsight] アイコンを表示するように変化します。
| プロビジョニング中 | プロビジョニング完了 |
| --- | --- |
|  | |
> [!NOTE]
> クラスターが作成されるまで、通常は約 15 分かかります。 プロビジョニング プロセスをチェックするには、スタート画面のタイルまたはページの左側の **[通知]** エントリを使用します。
>
>
## <a name="run-a-storm-starter-sample-on-hdinsight"></a>HDInsight での Storm Starter サンプルの実行
この Apache Storm チュートリアルでは、GitHub で Storm Starter サンプルを使用したビッグ データ分析の概要について説明します。
HDInsight クラスターの各 Storm には、クラスターで Storm トポロジをアップロードし実行するために使用する Storm ダッシュボードが付属しています。 各クラスターには、Storm ダッシュボードから直接実行できるトポロジのサンプルも付属しています。
### <a name="a-idconnectaconnect-to-the-dashboard"></a><a id="connect"></a>ダッシュボードへの接続
ダッシュボードは、**clustername** がクラスターの名前である **https://<clustername>.azurehdinsight.net//** にあります。 スタート画面でクラスターを選択し、ブレードの上部にある **[ダッシュボード]** リンクを選択することで、ダッシュボードへのリンクを見つけることもできます。
> [!NOTE]
> ダッシュボードに接続すると、ユーザー名とパスワードを入力するように求められます。 これはクラスターの作成時に使用した管理者の名前 (**admin**) とパスワードです。
>
>
Storm ダッシュボードが読み込まれると、 **[トポロジの送信]** フォームが表示されます。
**[トポロジの送信]** フォームを使用して、Storm トポロジが含まれている .jar ファイルをアップロードし、実行できます。 また、これにはクラスターに付属しているいくつかの基本的なサンプルも含まれています。
### <a name="a-idrunarun-the-word-count-sample-from-the-storm-starter-project-in-github"></a><a id="run"></a>GitHub の Storm Starter プロジェクトからワードカウント サンプルを実行する
クラスターに付属しているサンプルには、ワードカウント トポロジのいくつかのバリエーションが含まれます。 これらのサンプルには、センテンスをランダムに出力する**スパウト**と各センテンスを個別の単語に分割し、各単語が発生した回数をカウントする**ボルト**が含まれています。 これらのサンプルは、Apache Storm の一部である [Storm Starter サンプル](https://github.com/apache/storm/tree/master/examples/storm-starter)で提供されています。
次の手順に従って、Storm Starter サンプルを実行します。
1. **[Jar ファイル]** ドロップダウンから **[StormStarter - WordCount]** を選択します。 これで、このサンプル用のパラメーターが **[クラス名]** フィールドと **[追加のパラメーター]** フィールドに入力されます。
* **クラス名** - トポロジを送信する .jar ファイル内のクラス。
* **追加パラメーター** - トポロジに必要なすべてのパラメーター。 この例では、フィールドに、送信したトポロジのわかりやすい名前を指定しています。
2. **[送信]**をクリックします。 しばらくすると、 **[結果]** フィールドにジョブの送信に使用したコマンドとコマンドの結果が表示されます。 **[エラー]** フィールドには、トポロジの送信時に発生したエラーが表示されます。
> [!NOTE]
> 結果はトポロジが完了したことを示しません - **Storm トポロジがいったん開始されると、停止するまで実行されます。** ワードカウント トポロジは、ランダムなセンテンスを生成し、停止されるまで各単語の出現回数を計算します。
>
>
### <a name="a-idmonitoramonitor-the-topology"></a><a id="monitor"></a>トポロジの監視
Storm UI を使用してトポロジを監視できます。
1. Storm ダッシュボードの上部で、 **[Storm UI]** を選択します。 クラスターの情報と実行中のすべてのトポロジに関する概要情報が表示されます。
上記のページで、トポロジがアクティブな状態だった時間、使用されているワーカー、エグゼキュータ、タスクの数を確認できます。
> [!NOTE]
> **[名前]** 列には、前に **[追加パラメーター]** フィールドで指定した名前が含まれています。
>
>
2. **[トポロジの概要]** で、**[名前]** 列の **[wordcount]** エントリを選択します。 これにより、トポロジの詳細が表示されます。
このページには、次の情報が表示されます。
* **トポロジの統計** - 時間枠で整理された、トポロジのパフォーマンスに関する基本的な情報。
> [!NOTE]
> 特定の時間枠を選択すると、ページの他のセクションに表示される情報の時間枠に変更されます。
>
>
* **スパウト** - 各スパウトによって返された最後のエラーを含む、スパウト関する基本的な情報。
* **ボルト** - ボルトに関する基本的な情報。
* **トポロジの構成** - トポロジの構成に関する詳細情報。
このページには、トポロジで実行できるアクションも表示されます。
* **アクティブ化** - アクティブ化が解除されたトポロジの処理を再開します。
* **アクティブ化の解除** - 実行中のトポロジを一時停止します
* **再調整** - トポロジの並列処理を調整します。 クラスターのノード数を変更した場合は、実行中のトポロジを再調整する必要があります。 この操作で、クラスター内のノード数の増減に合わせて、トポロジの並列処理を調整できます。 詳細については、「 [Understanding the parallelism of a Storm topology (Storm トポロジの並列処理)](http://storm.apache.org/documentation/Understanding-the-parallelism-of-a-Storm-topology.html)」を参照してください。
* **強制終了** - 指定したタイムアウト後に Storm トポロジを停止します。
3. このページで、**[スパウト]** または **[ボルト]** セクションからエントリを選択します。 選択したコンポーネントに関する情報が表示されます。
このページには次の情報が表示されます。
* **スパウト / ボルトの統計** - 時間枠で整理された、コンポーネントのパフォーマンスに関する基本的な情報。
> [!NOTE]
> 特定の時間枠を選択すると、ページの他のセクションに表示される情報の時間枠に変更されます。
>
>
* **入力の統計** (ボルトのみ) - ボルトによって使用されるデータを生成するコンポーネントに関する情報。
* **出力の統計** - このボルトによって出力されるデータに関する情報。
* **エグゼキュータ** - このコンポーネントのインスタンスに関する情報。
* **エラー** - このコンポーネントで生成されたエラー。
4. スパウトまたはボルトの詳細を表示したら、**[エグゼキュータ]** セクションの **[ポート]** 列でエントリを選択して、コンポーネントの特定のインスタンスの詳細を表示します。
2015-01-27 14:18:02 b.s.d.task [INFO] Emitting: split default ["with"]
2015-01-27 14:18:02 b.s.d.task [INFO] Emitting: split default ["nature"]
2015-01-27 14:18:02 b.s.d.executor [INFO] Processing received message source: split:21, stream: default, id: {}, [snow]
2015-01-27 14:18:02 b.s.d.task [INFO] Emitting: count default [snow, 747293]
2015-01-27 14:18:02 b.s.d.executor [INFO] Processing received message source: split:21, stream: default, id: {}, [white]
2015-01-27 14:18:02 b.s.d.task [INFO] Emitting: count default [white, 747293]
2015-01-27 14:18:02 b.s.d.executor [INFO] Processing received message source: split:21, stream: default, id: {}, [seven]
2015-01-27 14:18:02 b.s.d.task [INFO] Emitting: count default [seven, 1493957]
このデータから、 **seven** という単語が 1,493,957 回発生したことがわかります。 これは、このトポロジが開始されてから発生した回数です。
### <a name="stop-the-topology"></a>トポロジを停止する
ワードカウント トポロジの **[トポロジの概要]** ページに戻り、**[トポロジのアクション]** セクションで **[強制終了]** を選択します。 メッセージが表示されたら、トポロジを停止するまでの待機秒数として「10」を入力します。 タイムアウト期間後は、ダッシュボードの **[Storm UI]** セクションにアクセスしても、トポロジは表示されません。
## <a name="delete-the-cluster"></a>クラスターを削除する
[!INCLUDE [delete-cluster-warning](../../includes/hdinsight-delete-cluster-warning.md)]
## <a name="summary"></a>概要
この Apache Storm チュートリアルでは、Storm Starter を使用して、HDInsight クラスターで Storm を作成する方法と、Storm ダッシュボードを使用して Storm トポロジをデプロイ、監視、管理する方法について説明しました。
## <a name="a-idnextanext-steps"></a><a id="next"></a>次のステップ
* **HDInsight Tools for Visual Studio** - HDInsight ツールでは、前述の Storm ダッシュボードのように、Visual Studio を使用して Storm トポロジを送信、監視、管理できます。 また HDInsight ツールは、C# Storm のトポロジを作成する機能を提供しており、クラスター上にデプロイし、実行できるトポロジ サンプルを含んでいます。
詳細については、「 [HDInsight Tools for Visual Studio を使用して Hive クエリを実行する](hdinsight-hadoop-visual-studio-tools-get-started.md)」を参照してください。
* **サンプル ファイル** - HDInsight Storm クラスターでは、**%STORM_HOME%\contrib** ディレクトリにいくつかの例が用意されています。 次の例がそれぞれ含まれます。
* ソース コード - storm-starter-0.9.1.2.1.5.0-2057-sources.jar など
* Java ドキュメント - storm-starter-0.9.1.2.1.5.0-2057-javadoc.jar など
* 例 - storm-starter-0.9.1.2.1.5.0-2057-jar-with-dependencies.jar など
'jar' コマンドを使用して、ソース コードまたは Java ドキュメントを抽出します。 たとえば、'jar -xvf storm-starter-0.9.1.2.1.5.0.2057-javadoc.jar' のように指定します。
> [!NOTE]
> Java ドキュメントは Web ページで構成されます。 抽出後、ブラウザーを使用して **index.html** ファイルを表示します。
>
>
これらのサンプルにアクセスするには、HDInsight クラスターの Storm のリモート デスクトップを有効にし、**%STORM_HOME%\contrib** からファイルをコピーする必要があります。
* 次のドキュメントには、HDInsight の Storm と使用できるその他のサンプルの一覧が含まれています。
* [HDInsight 上の Storm に関するトポロジ例](hdinsight-storm-example-topology.md)
[apachestorm]: https://storm.incubator.apache.org
[stormdocs]: http://storm.incubator.apache.org/documentation/Documentation.html
[stormstarter]: https://github.com/apache/storm/tree/master/examples/storm-starter
[stormjavadocs]: https://storm.incubator.apache.org/apidocs/
[azureportal]: https://manage.windowsazure.com/
[hdinsight-provision]: hdinsight-provision-clusters.md
[preview-portal]: https://portal.azure.com/
<!--HONumber=Nov16_HO3--> | 12,594 | CC-BY-3.0 |
# 网络模块
> 涉及到的头文件 `libnap.h`
<br/>
网络模块包括 net(工具类)，tcpclient(客户端类)，tcpserver(服务端类)，tcpseraccept(服务端accept类)，napcom(协议类)。所有的类都是线程不安全类，在多线程中操作这些资源都需要加锁。
> 详细类定义请见 `src/net.h`
<br/>
<br/>
## 客户端使用流程
```c++
/*
初始化net库，如果没有初始化可能会发生很多异常。初始化只需要在整个程序里初始化一次即可
*/
net::init();
/*
连接 192.168.1.1：8087
注意 tcpclient 不允许复制，也不允许赋值。
转移所有权请使用 std::move();
*/
tcpclient client(8087, "192.168.1.1");
/*
尝试连接，如果失败返回false
*/
if (client->connect() == false){
cout<<"connect fail";
return false;
}
/*
获取连接的napcom对象，通过该对象进行数据传输
*/
napcom* communicate = client.communicate();
```
<br/>
<br/>
## 服务端使用流程
```c++
using namespace nap;
/*
初始化net库，如果没有初始化会发生通信错误。初始化只需要在整个程序里初始化一次即可
*/
net::init();
/*
创建 tcpserver 对象，监听8087端口
*/
tcpserver server(8087);
/*
尝试绑定端口，如果失败返回false
*/
if (server->bind() == false){
cout<<"bind fail";
return false;
}
/*
尝试监听端口，如果失败返回false
*/
if (server->listen() == false){
cout<<"bind fail";
return false;
}
while(true){
/*
开始等待客户端连接
返回一个pair对象
第一个值(link.first) : bool 连接是否有效
第一个值(link.second) : tcpseraccept tcpseraccept对象
*/
std::pair<bool,tcpseraccept> link = server->accept();
//aupto link = server->accept(); 也可以使用这句
/*
*/
if (link.first){
/*
获取tcpseraccept对象进行操作
*/
tcpseraccept acc = std::move(link.second);
/*
获取客户端的IP和端口
*/
uint16_t port = acc.port();
binstream ip = acc.ip();
/*
获取连接的napcom对象，通过该对象进行数据传输
*/
napcom* communicate = acc.communicate();
}
}
```
<br/>
<br/>
## napcom类的使用
```c++
napcom* napcom = // .....
binstream str("test string a");
auto ret = napcom->sendpackage(str);
if (ret != napcom::ret::success){
cout<<"send packet fail";
return false;
}
binstream recv;
auto ret2 = napcom->recvpackage(recv);
if (ret2 != napcom::ret::success){
cout<<"send packet fail";
return false;
}
/*
注意，recvpackage和sendpackage都是阻塞函数。
*/
```
<br/>
<br/>
## 枚举napcom::ret的使用
```c++
enum class ret {
success, //成功
mecismsend, //过长的发送数据 单个包只允许发送 64KB
ruined, //被损毁的网络套接字(协议异常或网络断开)
};
/*
这是该枚举的定义。位于net.h的napcom类内。
success 操作成功
mecismsend 发送包过长
ruined 被毁坏的链接，通常是对端关闭了连接，或者网络连接断开，接收超时等。
*/
int error = net::lastError();
//使用 net::lastError() 可以获取最后一次的错误码
``` | 2,365 | Apache-2.0 |
---
title: "Farsite 板条箱销售现已向公众开放"
date: 2021-12-02T21:57:40+08:00
lastmod: 2021-12-02T16:45:40+08:00
draft: false
authors: ["Paul"]
description: "太空探索游戏 Farsite 已向公众开放其 NFT 板条箱销售。具有不同价格的不同板条箱赋予玩家对船只、蓝图、模块或额外信用的所有权。此次销售需要一个连接的带有 ETH 的 Metamask 钱包，因为价格从 0.05 ETH 开始，最昂贵的可用板条箱价格为 0.35 ETH。"
featuredImage: "farsite-crate-sales-now-open-to-public.png"
tags: ["Digital Collectibles","数字收藏品","Play to Earn"]
categories: ["news"]
news: ["数字收藏品"]
weight:
lightgallery: true
pinned: false
recommend: false
recommend1: false
---
太空探索游戏 Farsite 已向公众开放其 NFT 板条箱销售。具有不同价格的不同板条箱赋予玩家对船只、蓝图、模块或额外信用的所有权。此次销售需要一个连接的带有 ETH 的 Metamask 钱包，因为价格从 0.05 ETH 开始，最昂贵的可用板条箱价格为 0.35 ETH。
<!--more--> | 677 | MIT |
---
layout: post
title: "springcloud - 注册中心eureka"
subtitle: "搭建eureka及配置"
date: 2019-08-08 11:10
author: "LQFGH"
header-img: "img/spring-cloud-bg.png"
header-mask: 0.3
catalog: true
tags:
- springcloud
---
***
[TOC]
------
> 今天主要就来说说怎么不使用IDE的向导搭建一个 `eureka` ，还有注册中心的基本配置
###### 创建一个简单的 `maven` 项目
###### 添加 `eureka-server` 依赖
> `eureka` 服务端需要添加 `spring-cloud-starter-eureka-server` 依赖
>
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.feng.cloud</groupId>
<artifactId>eureka-server</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencyManagement>
<dependencies>
<!--spring cloud依赖管理-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Dalston.SR1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--spring boot依赖管理-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>1.5.9.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!--eureka-server服务端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<executable>true</executable>
</configuration>
</plugin>
</plugins>
</build>
</project>
```
###### 创建启动类
> 启动类中最主要的部分是添加 `@EnableEurekaServer` 说明这是注册中心
>
```java
package com.feng.eureka;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
* @author Lee
*/
@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServerApplication.class,args);
}
}
```
###### 创建配置文件 `bootstrap.yml`
> 配置的作用会用注释说明
>
```yml
server:
port: 7000
spring:
application:
name: eureka-server
eureka:
instance:
hostname: ${spring.cloud.client.ipAddress} #eureka服务端的实例名称
client:
register-with-eureka: false #不向注册中心注册自己，设置为false
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #被客户端注册的地址
server:
enable-self-preservation: false #是否启动自我保护机制，测试环境应该关闭自我保护机制，服务失效90秒被自动移除。生产环境应该开启自我保护机制，即使服务失效
eviction-interval-timer-in-ms: 3000 #检查失效时间
```
###### 将服务注册到 `eureka`
> 接下来我们创建一个新的 `spring boot` 项目，用于注册到注册中心
>
> 若想将服务注册到 `eureka` 只需要在配置中添加如下配置
>
```yml
eureka:
client:
service-url:
defaultZone: http://localhost:7000/eureka/
```
###### 修改注册到注册中心实例的显示地址和实例名称
> 如果客户端使用默认的实例名字，那么实例的名字就是这个样子的，而且当鼠标放到上面的时候右下角显示的地址是 `localhost` ，那么怎么将localhost改为服务部署的IP地址，并且将注册到注册中心的实例名称自定义呢。
>
> 将客户端的配置添加 `eureka.instance.prefer-ip-address` 属性
>
```yml
eureka:
client:
service-url:
defaultZone: http://localhost:7000/eureka/
instance:
prefer-ip-address: true # 显示实例的ip地址
```
> 接下来添加配置实例id `instance-id`,显示自定义实例名称
>
```yml
eureka:
client:
service-url:
defaultZone: http://localhost:7000/eureka/
instance:
prefer-ip-address: true # 显示实例的ip地址
instance-id: boot-provider
```
> 发现图中客户端实例的名称变成了我们自定义的名称 `boot-provider`
>
###### 修改客户端实例的 `info` 信息
> 当我们点击实例名称的超链接想要查看客户端实例的信息时，发现响应的时404页面
>
> 首先客户端添加依赖 `spring-boot-starter-actuator` 服务健康监控,关于健康控监控多余的东西在这里就不作
> 介绍了.
>
> 添加 `maven` 的 `resource` 插件
```yml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
```
```xml
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<configuration>
<delimiters>
<!-- 表示取resources中以$*$的信息被解析 -->
<delimiter>$</delimiter>
</delimiters>
</configuration>
</plugin>
```
> 配置 `info` 客户端实例的 `info` 信息
>
> 可以自定义一些键值对.由于上面配置了 `maven` 的 `resource` 插件,$*$的属性将会被解析
>
```yml
info:
app.name: boot-provider
company.name: spring-eureka
author: feng
build.artifactId: $project.artifactId$
buid.version: $project.version$
```
> 这些都配置完发现点可以显示 `info` 的信息了
>
###### eureka 集群配置
> 我这里为了搭建集群环境,重新建了三个注册中心项目
>
> 为了更接近真实环境,我将 `hosts` 文件做下修改,不同的注册中心分别对应不同的域名
>
```txt
127.0.0.1 eureka7001server.com
127.0.0.1 eureka7002server.com
127.0.0.1 eureka7003server.com
```
> `eureka-server-7001` 配置
>
```yml
# eureka 端口号
server:
port: 7001
# 服务名称
spring:
application:
name: eureka-server
eureka:
instance:
hostname: ${spring.cloud.client.ipAddress} #eureka服务端的实例名称
client:
register-with-eureka: false #false表示不向注册中心注册自己。
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url: #注册中心的地址
defaultZone: http://eureka7002server.com:7002/eureka/,http://eureka7003server.com:7003/eureka/
server:
enable-self-preservation: false #是否启动自我保护机制
```
> `eureka-server-7002` 配置
>
```yml
server:
port: 7002
spring:
application:
name: eureka-server
eureka:
instance:
hostname: ${spring.cloud.client.ipAddress} #eureka服务端的实例名称
client:
register-with-eureka: false #false表示不向注册中心注册自己。
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url:
defaultZone: http://eureka7001server.com:7001/eureka/,http://eureka7003server.com:7003/eureka/
server:
enable-self-preservation: false
```
> `eureka-server-7003` 配置
>
```yml
server:
port: 7003
spring:
application:
name: eureka-server
eureka:
instance:
hostname: ${spring.cloud.client.ipAddress} #eureka服务端的实例名称
client:
register-with-eureka: false #false表示不向注册中心注册自己。
fetch-registry: false #false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要去检索服务
service-url:
defaultZone: http://eureka7002server.com:7002/eureka/,http://eureka7001server.com:7001/eureka/
server:
enable-self-preservation: false
```
> 客户端实例注册
>
```yml
eureka:
client:
service-url:
defaultZone: http://eureka7001server.com:7001/eureka/,http://eureka7002server.com:7002/eureka/,http://eureka7003server.com:7003/eureka/
```
> **最终效果**
>
> 由于篇幅原因,我这里只放出 `eureka-server-7001` 的截图
>
> 我们发现最终注册中心会互相注册 | 7,713 | Apache-2.0 |
# java.lang.IllegalStateException
**目录**
<!-- vim-markdown-toc GFM -->
* [Case 1](#case-1)
* [出错堆栈](#出错堆栈)
* [出错代码](#出错代码)
* [崩溃分析](#崩溃分析)
* [解决方案](#解决方案)
<!-- vim-markdown-toc -->
## Case 1
### 出错堆栈
```
05-09 09:41:27.356 1128-1128/org.mazhuang.multicastdemo E/AndroidRuntime: FATAL EXCEPTION: main
Process: org.mazhuang.multicastdemo, PID: 1128
java.lang.IllegalStateException: The content of the adapter has changed but ListView did not receive a notification. Make sure the content of your adapter is not modified from a background thread, but only from the UI thread. Make sure your adapter calls notifyDataSetChanged() when its content changes. [in ListView(2131165270, class android.widget.ListView) with Adapter(class android.widget.SimpleAdapter)]
at android.widget.ListView.layoutChildren(ListView.java:1618)
at android.widget.AbsListView.onLayout(AbsListView.java:2161)
at android.view.View.layout(View.java:17548)
at android.view.ViewGroup.layout(ViewGroup.java:5614)
at android.widget.LinearLayout.setChildFrame(LinearLayout.java:1741)
at android.widget.LinearLayout.layoutVertical(LinearLayout.java:1585)
at android.widget.LinearLayout.onLayout(LinearLayout.java:1494)
at android.view.View.layout(View.java:17548)
at android.view.ViewGroup.layout(ViewGroup.java:5614)
at android.widget.FrameLayout.layoutChildren(FrameLayout.java:323)
at android.widget.FrameLayout.onLayout(FrameLayout.java:261)
at android.view.View.layout(View.java:17548)
at android.view.ViewGroup.layout(ViewGroup.java:5614)
at android.support.v7.widget.ActionBarOverlayLayout.onLayout(ActionBarOverlayLayout.java:443)
at android.view.View.layout(View.java:17548)
at android.view.ViewGroup.layout(ViewGroup.java:5614)
at android.widget.FrameLayout.layoutChildren(FrameLayout.java:323)
at android.widget.FrameLayout.onLayout(FrameLayout.java:261)
at android.view.View.layout(View.java:17548)
at android.view.ViewGroup.layout(ViewGroup.java:5614)
at android.widget.LinearLayout.setChildFrame(LinearLayout.java:1741)
at android.widget.LinearLayout.layoutVertical(LinearLayout.java:1585)
at android.widget.LinearLayout.onLayout(LinearLayout.java:1494)
at android.view.View.layout(View.java:17548)
at android.view.ViewGroup.layout(ViewGroup.java:5614)
at android.widget.FrameLayout.layoutChildren(FrameLayout.java:323)
at android.widget.FrameLayout.onLayout(FrameLayout.java:261)
at com.android.internal.policy.DecorView.onLayout(DecorView.java:727)
at android.view.View.layout(View.java:17548)
at android.view.ViewGroup.layout(ViewGroup.java:5614)
at android.view.ViewRootImpl.performLayout(ViewRootImpl.java:2383)
at android.view.ViewRootImpl.performTraversals(ViewRootImpl.java:2110)
at android.view.ViewRootImpl.doTraversal(ViewRootImpl.java:1287)
at android.view.ViewRootImpl$TraversalRunnable.run(ViewRootImpl.java:6363)
at android.view.Choreographer$CallbackRecord.run(Choreographer.java:873)
at android.view.Choreographer.doCallbacks(Choreographer.java:685)
at android.view.Choreographer.doFrame(Choreographer.java:621)
at android.view.Choreographer$FrameDisplayEventReceiver.run(Choreographer.java:859)
at android.os.Handler.handleCallback(Handler.java:754)
at android.os.Handler.dispatchMessage(Handler.java:95)
at android.os.Looper.loop(Looper.java:163)
at android.app.ActivityThread.main(ActivityThread.java:6337)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:880)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:770)
```
### 出错代码
```java
new Thread() {
@Override
public void run() {
// ...
mData.add(data);
MainActivity.this.runOnUiThread(() -> {
mAdapter.notifyDataSetChanged();
}
// ...
}
}.start();
```
### 崩溃分析
根据出错堆栈里的关键提示：
```
The content of the adapter has changed but ListView did not receive a notification. Make sure the content of your adapter is not modified from a background thread, but only from the UI thread. Make sure your adapter calls notifyDataSetChanged() when its content changes.
```
更新 Adapter 里的数据并 notifyDataSetChanged 需要在 UI 线程里进行。如果在子线程里更新了数据，而在 UI 线程里稍后更新代码，就有可能在一个时间差内数据与界面状态不一致，从而导致崩溃。
### 解决方案
在 UI 线程里面更新 Adapter 里的数据，并 notifyDataSetChanged，即：
```java
new Thread() {
@Override
public void run() {
// ...
MainActivity.this.runOnUiThread(() -> {
mData.add(data);
mAdapter.notifyDataSetChanged();
}
// ...
}
}.start();
``` | 4,871 | Apache-2.0 |
# 1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree
> [Leetcode link](https://leetcode.com/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/)
## 解题思路
题目给了我们两棵一模一样的树，并且将一个指针 `target` 指向了原树的其中一个节点，要求我们找到拷贝树上对应的节点
这种题目一般用 bfs 或者 dfs 来求解，一种简单的思路就是：
- 遍历拷贝的树，当遇到与 `target` 指针指向的值一样的树节点的时候，返回拷贝树对应的节点指针
<br />
但是这个思路有一个限制条件，就是树上不能有两个值相同的节点。
所以在这里我们用同时遍历两棵树的方法，详情见代码：
### C++
```cpp
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* getTargetCopy(TreeNode* original, TreeNode* cloned, TreeNode* target) {
TreeNode* res = nullptr;
dfs(original, cloned, target, res);
return res;
}
// 记得这里的 res 需要使用引用，因为我们需要记录 res 指针存放的地址
void dfs(TreeNode* original, TreeNode* cloned, TreeNode* target, TreeNode*& res) {
// 如果已经找到了 res，就没必要继续下去了
if(original == nullptr || res != nullptr) {
return;
}
// 当原树的节点等于目标节点的时候，拷贝树的对应节点就是我们的解
if(original == target) {
res = cloned;
return ;
}
dfs(original->left, cloned->left, target, res);
dfs(original->right, cloned->right, target, res);
}
};
``` | 1,363 | MIT |
# node-pagesplit
a page spliter, like ThinkPHP Page.class
# demo (express)
/demo/test.js
```javascript
router.get('/page', function (req, res) {
var totalRows = 51; //模拟从数据库中查询得到的总记录数
var listRows = 10; //每页显示的数量
var pg = new Page(req, totalRows, listRows);
//得到相应的查询参数，实现分页功能
var sql = "select * from db limit " + pg.firstRow + "," + pg.listRows + ";";
var data = sql + "<br/>" + pg.show();//前端分页代码
res.send(data);
});
```
# demo (http)
```javascript
var http = require('http');
var url = require('url');
var querystring = require('querystring');
var Page = require('pagesplit');
http.createServer(function (req,res) {
if(req.url == '/favicon.ico'){
return res.end();
}
res.setHeader('Content-Type', 'text/html');
//添加两个express才有的属性
let u = url.parse(req.url);
req.originalUrl = u.pathname;
req.query = querystring.parse(u.query);
var totalRows = 51; //模拟从数据库中查询得到的总记录数
var listRows = 10; //每页显示的数量
var pg = new Page(req, totalRows, listRows);
//得到相应的查询参数，实现分页功能
var sql = "select * from db limit " + pg.firstRow + "," + pg.listRows + ";";
var data = sql + "<br/>" + pg.show();//前端分页代码
res.end(data);
}).listen(3000);
console.log('localhost:3000');
```
# 转为bootstrap风格
```html
<div class="" id="page" style="display: none">
<!-- 分页代码 -->
<%- page %>
</div>
<script>
//将后台产生的分页代码转成bootstrap风格显示
var page = $('.page');
page.addClass('btn-group pull-right');
page.children('a').addClass('btn btn-default btn-sm');
page.find('.current').addClass('btn btn-primary btn-sm');
$('#page').show(); // 等添加完属性转为bootstrap风格后再显示
</script>
``` | 1,695 | MIT |
資源|預設限制|上限
---|---|---
每一[訂用帳戶](../articles/billing-buy-sign-up-azure-subscription.md)的核心 <sup>1</sup>|20|10,000
每一訂用帳戶的[共同管理員](../articles/billing-add-change-azure-subscription-administrator.md)|200|200
每一訂用帳戶的[儲存體帳戶](../articles/storage/storage-create-storage-account.md)|100|100
每一訂用帳戶的[雲端服務](../articles/cloud-services/fundamentals-application-models.md#tellmecs)|20|200
每一訂用帳戶的[區域網路](http://msdn.microsoft.com/library/jj157100.aspx)|10|500
每一訂用帳戶的 SQL Database 伺服器|6|150
每一訂閱的 DNS 伺服器|9|100
每一訂用帳戶的保留 IP|20|100
每個訂用帳戶的 ExpressRoute 專用電路|10|25
每一訂用帳戶託管服務的憑證|400|400
每一訂用帳戶的[同質群組](../articles/virtual-network/virtual-networks-migrate-to-regional-vnet.md)|256|256
[Batch](https://azure.microsoft.com/services/batch/) 帳戶 (每一區域的每一訂用帳戶)|1|50
每一訂用帳戶的警示規則|250|250
<sup>1</sup>雖然只使用部分核心，在計算核心限制時，仍會將超小型執行個體視為一個核心。
<!---HONumber=AcomDC_0211_2016--> | 845 | CC-BY-3.0 |
<!--
* @Author: codytang
* @Date: 2020-07-10 22:06:46
* @LastEditTime: 2020-07-13 14:38:20
* @LastEditors: codytang
* @Description: README
-->
# Ticket Purchase [](https://travis-ci.org/cody1991/ticket-purchase)
## Demo 地址
https://cody1991.github.io/ticket-purchase/?front=50&back=100&step=2&block=4&refundRate=0.1&sleepMax=50
运行结果
---
https://cody1991.github.io/ticket-purchase
运行结果
## URL 参数使用
| 参数名 | 说明 | 参数值 |
| --------------- | -------------------------------- | --------------- |
| displayUsersLen | 展示用户行为列表的最大值 | > 0, 默认 25 |
| sleepMax | 模拟每次购票用户等待时间的最大值 | > 0, 默认 100ms |
| refundRate | 用户退票的概率 | >= 0, 默认 0.2 |
| block | 区块数 | > 0, 默认 2 |
| front | 第一排的座位数量 | > 0, 默认 2 |
| back | 最后一排的座位数量 | > 0, 默认 20 |
| step | 每排递增的数量 | != 0, 默认 1 |
## 任务列表
- Other
- [x] 新增算法的流程图
- [x] 展示演唱会的位置使用 canvas 绘制（现在座位太多的话很卡，先简单处理，座位数太多的时候隐藏）
- Class
- [x] User: 购票用户信息与行为
- [x] Seats: 演唱会座位信息
- [x] AdvancedSeas: 继承 Seats，优化购票算法
- Views
- [x] Helloworld: 简单的项目介绍
- [x] DisplaySeats: 展示演唱会座位
- [x] DisplayUsers: 展示用户购票
- [x] 展示 n 排 n 座
- [x] 展示在第几个区域
- [x] Intro: 演唱会现况
- Deploy (Github Pages)
- [x] 手动构建: `sh ./deploy.sh`
- [x] 自动构建: 接入 `Travis CI`
- Algorithm
- [x] purchase ticket by order 按顺序购票，无太多逻辑
- [x] 支持退票
- [x] 随机购票
- [x] 邻座分配（只考虑横向的邻座）
## 流程图
 | 1,693 | MIT |
# 2021-12-10
共 0 条
<!-- BEGIN WEIBO -->
<!-- 最后更新时间 Fri Dec 10 2021 23:09:10 GMT+0800 (China Standard Time) -->
<!-- END WEIBO --> | 134 | MIT |
---
layout: post
title: "中共如何用民主騙人 | 明居正「透視中國」【0059】SinoInsider 20191223"
date: 2019-12-23T01:15:16.000Z
author: 透視中國
from: https://www.youtube.com/watch?v=ToDk26g3-LI
tags: [ 透視中國 ]
categories: [ 透視中國 ]
---
<!--1577063716000-->
[中共如何用民主騙人 | 明居正「透視中國」【0059】SinoInsider 20191223](https://www.youtube.com/watch?v=ToDk26g3-LI)
------
<div>
#明居正 #透視中國 #2020中國展望立即訂購：「2020中國展望：中共政局對美中港台的衝擊」https://bit.ly/393yhr7透視文章：https://tw.sinoinsider.com/research/訂閱會員：https://tw.sinoinsider.com/membership/精準分析：https://tw.sinoinsider.com/predictive/臉書：https://www.facebook.com/mingsinoinsider/推特：https://twitter.com/SinoInsider要瞭解有關解決方案的更多信息，請聯繫我們。https://tw.sinoinsider.com/#Contact-us
</div> | 680 | MIT |
End of preview. Expand
in Dataset Viewer.
- Downloads last month
- 64