code
stringlengths 30
403k
| size
int64 31
406k
| license
stringclasses 10
values |
|---|---|---|
### 变更历史
版本|变更内容|变更时间|变更人员
:-: | :-: | :-: | :-:
v0.01|初稿|2018-07-24|wuxw
### 本页内容
1. [协议说明](#协议说明)
2. [下游系统交互说明](#下游系统交互说明)
3. [订单类型说明](#订单类型说明)
4. [加密说明](#加密说明)
5. [状态说明](#状态说明)
6. [数据格式约定](#数据格式约定)
### 协议说明
1. 协议结构
父元素名称|参数名称|约束|类型|长度|描述|取值说明
:-: | :-: | :-: | :-: | :-: | :-: | :-:
-|orders|1|Object|-|订单节点|-
-|business|1|Array|-|业务节点|-
2. 订单节点结构
父元素名称|参数名称|约束|类型|长度|描述|取值说明
:-: | :-: | :-: | :-: | :-: | :-: | :-:
-|orders|1|Object|-|订单节点|-
orders|appId|1|String|10|系统ID|由中心服务提供
orders|transactionId|1|String|30|交互流水|appId+'00'+YYYYMMDD+10位序列
orders|userId|1|String|30|用户ID|已有用户ID
orders|orderTypeCd|1|String|4|订单类型|查看订单类型说明
orders|requestTime|1|String|14|请求时间|YYYYMMDDhhmmss
orders|remark|1|String|200|备注|备注
orders|sign|?|String|64|签名|查看加密说明
orders|attrs|?|Array|-|订单属性|-
attrs|specCd|1|String|12|规格编码|由中心服务提供
attrs|value|1|String|50|属性值|
orders|response|1|Object|-|返回结果节点|-
response|code|1|String|4|返回状态|查看状态说明
response|message|1|String|200|返回状态描述|-
3. 业务节点结构
父元素名称|参数名称|约束|类型|长度|描述|取值说明
:-: | :-: | :-: | :-: | :-: | :-: | :-:
-|business|?|Array|-|业务节点|-
business|serviceCode|1|String|50|业务编码|由中心服务提供
business|serviceName|1|String|50|业务名称|由中心服务提供
business|remark|1|String|200|备注|
business|datas|1|Object|-|数据节点|不同的服务下的节点不一样
business|attrs|?|Array|-|业务属性|-
attrs|specCd|1|String|12|规格编码|由中心服务提供
attrs|value|1|String|50|属性值|
business|response|1|Object|-|返回结果节点|-
response|code|1|String|4|返回状态|查看状态说明
response|message|1|String|200|返回状态描述|-
4. 报文样例
请求报文：
```
{
"orders": {
"appId": "1234567890",
"transactionId": "123456789000201804090123456789",
"userId": "1234567890",
"orderTypeCd": "Q",
"requestTime": "20180409224736",
"remark": "备注",
"sign": "这个服务是否要求MD5签名",
"attrs": [{
"specCd": "配置的字段ID",
"value": "具体值"
}]
},
"business": [{
"serviceCode": "服务编码",
"serviceName": "服务编码名称",
"remark": "备注",
"datas": {
},
"attrs": [{
"specCd": "配置的字段ID",
"value": "具体值"
}]
}]
}
```
返回报文：
```
{
"orders": {
"transactionId": "123456789000201804090123456789",
"responseTime": "20180409224736",
"sign": "这个服务是否要求MD5签名",
"response": {//这个是centerOrder 返回的状态结果
"code": "1999",
"message": "具体值"
}
},
"business":[{//这个是相应的业务系统返回的结果，（受理为空，查询时不为空）
"response": {
"code": "0000",
"message": "具体值"
}
}]
}
```
### 下游系统交互说明
与下游系统交互主要分为三个过程，分别为 Business过程，Instance过程，作废过程
1. Business过程指先将数据存放至中间表中（叫做business表），表明动作 是新增（ADD）还是删除（DEL）。
请求协议为：
```
{
"orders": {
"transactionId": "100000000020180409224736000001",
"requestTime": "20180409224736",
"orderTypeCd": "订单类型,查询,受理",
"dataFlowId": "20020180000001",
"businessType": "Q"
},
"business": {
"bId": "12345678",
"serviceCode": "querycustinfo",
"serviceName": "查询客户",
"remark": "备注",
"datas": {
"params": {
}
}
}
}
```
返回协议为：
```
{
"transactionId": "100000000020180409224736000001",
"responseTime": "20180409224736",
"businessType": "B",
"bId": "12345678",
"orderTypeCd": "",
"dataFlowId": "",
"serviceCode": "",
"response": {
"code": "1999",
"message": "具体值"
}
}
```
2. Instance过程指将中间表中的数据根据动作分析增加删除或修改业务表中的数据。
请求协议为：
```
{
"orders": {
"transactionId": "100000000020180409224736000001",
"requestTime": "20180409224736",
"orderTypeCd": "订单类型,查询,受理",
"dataFlowId": "20020180000001",
"businessType": "I"
},
"business": {
"bId": "12345678",
"serviceCode": "save.user.userInfo"
}
}
```
返回协议为：
```
{
"transactionId": "100000000020180409224736000001",
"responseTime": "20180409224736",
"businessType": "I",
"bId": "12345678",
"orderTypeCd": "",
"dataFlowId": "",
"serviceCode": "",
"response": {
"code": "1999",
"message": "具体值"
}
}
```
3. 作废过程指 当某个下游系统失败的情况下，判断是Business过程失败还是Instance过程失败
如果是Business过程失败，则放弃发送Instance过程直接返回，如果Instance过程失败，则发起作废业务数据过程。
请求协议为：
```
{
"orders": {
"transactionId": "100000000020180409224736000001",
"requestTime": "20180409224736",
"orderTypeCd": "订单类型,查询,受理",
"dataFlowId": "20020180000001",
"businessType": "DO"
},
"business": {
"bId": "12345678",
"serviceCode": "save.user.userInfo"
}
}
```
返回协议为：
```
{
"transactionId": "100000000020180409224736000001",
"responseTime": "20180409224736",
"businessType": "DO",
"bId": "12345678",
"orderTypeCd": "",
"dataFlowId": "",
"serviceCode": "",
"response": {
"code": "1999",
"message": "具体值"
}
}
```
### 订单类型说明
订单类型|说明
:-:|:-:
Q|查询类
### 加密说明
1. 请求sign说明
外系统请求centerService 服务时，sign 的生成：
```
inStr = transactionId + appId+business（内容）+security_code(系统分配);
DigestUtils.md5Hex(inStr.getBytes("UTF-8"));
```
2. CenterService服务返回时 sign生成：
```
inStr = transactionId + responseTime+business（内容）+security_code(系统分配);
DigestUtils.md5Hex(inStr.getBytes("UTF-8"));
```
注意：当传入AppId 不正确，或者请求报文解密失败的情况下，返回sign 不做加密处理，其值为空
3. 请求报文加密：
如果http post 请求时header 中有 ENCRYPT 并且值为ON，时启用密文传输方式，即请求报文和返回报文都为密文，如果没有 ENCRYPT 或 值不为ON 则明文传输。
加密代码参考：
```
/**
* 加密
* @param data
* @param publicKey
* @param keySize
* @return
* @throws Exception
*/
public static byte[] encrypt(byte[] data, PublicKey publicKey, int keySize)
throws Exception
{
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING", "BC");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
int blockSize = (keySize >> 3) - 11;
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
int i = 0;
while (inputLen - offSet > 0) {
byte[] buf;
if (inputLen - offSet > blockSize) {
buf = cipher.doFinal(data, offSet, blockSize);
}else {
buf = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(buf, 0, buf.length);
++i;
offSet = i * blockSize;
}
byte[] result = out.toByteArray();
return result;
}
/**
* 加载公钥
* @param keyData
* @return
* @throws Exception
*/
public static PublicKey loadPubKey(String keyData)
throws Exception
{
return loadPemPublicKey(keyData, "RSA");
}
/**
* 加载公钥
* @param privateKeyPem
* @param algorithm
* @return
* @throws Exception
*/
public static PrivateKey loadPrivateKeyPkcs8(String privateKeyPem, String algorithm)
throws Exception
{
String privateKeyData = privateKeyPem.replace("-----BEGIN PRIVATE KEY-----", "");
privateKeyData = privateKeyData.replace("-----END PRIVATE KEY-----", "");
privateKeyData = privateKeyData.replace("\n", "");
privateKeyData = privateKeyData.replace("\r", "");
byte[] decoded = Base64.getDecoder().decode(privateKeyData.getBytes());
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(decoded);
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
return keyFactory.generatePrivate(pkcs8KeySpec);
}
//加密
reqJson = new String(encrypt(resJson.getBytes("UTF-8"), loadPubKey(“公钥”)
, 2048)),"UTF-8");
```
其中 keySize 如果设置要重新设置则 http post header 中传ENCRYPT_KEY_SIZE来设置 不传则去默认值，默认值配置在映射表中，key为 KEY_DEFAULT_DECRYPT_KEY_SIZE
4. 返回报文解密
如果http post 请求时header 中有 ENCRYPT 并且值为ON，时启用密文传输方式。
解密代码参考
```
/**
* 解密
* @param data
* @param privateKey
* @param keySize
* @return
* @throws Exception
*/
public static byte[] decrypt(byte[] data, PrivateKey privateKey, int keySize)
throws Exception
{
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING", "BC");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
int blockSize = keySize >> 3;
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
byte[] buf = new byte[blockSize];
int len = 0;
while ((len = byteArrayInputStream.read(buf)) > 0) {
byteArrayOutputStream.write(cipher.doFinal(buf, 0, len));
}
return byteArrayOutputStream.toByteArray();
}
/**
* 加载私钥
* @param keyData
* @return
* @throws Exception
*/
public static PrivateKey loadPrivateKey(String keyData) throws Exception {
return loadPrivateKeyPkcs8(keyData, "RSA");
}
/**
* 加载私钥
* @param privateKeyPem
* @param algorithm
* @return
* @throws Exception
*/
public static PrivateKey loadPrivateKeyPkcs8(String privateKeyPem, String algorithm)
throws Exception
{
String privateKeyData = privateKeyPem.replace("-----BEGIN PRIVATE KEY-----", "");
privateKeyData = privateKeyData.replace("-----END PRIVATE KEY-----", "");
privateKeyData = privateKeyData.replace("\n", "");
privateKeyData = privateKeyData.replace("\r", "");
byte[] decoded = Base64.getDecoder().decode(privateKeyData.getBytes());
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(decoded);
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
return keyFactory.generatePrivate(pkcs8KeySpec);
}
//解密
resJson = new String(decrypt(reqJson.getBytes("UTF-8"), “私钥”
, 2048)),"UTF-8");
```
<font color=red size=4 face="黑体">说明：加密和解密的公钥和私钥，由centerService提供。</font>
### 状态说明
状态编码|说明
:-:|:-:
0000|成功
1999|未知失败
1998|系统内部错误
1997|调用下游系统超时
### 数据格式约定
格式符号|说明
:-:|:-:
?|0..1
星 | 0..n
+|1..n
1|1
[>回到首页](home) | 9,117 | Apache-2.0 |
[[English Template / 英文模板](./ISSUE_TEMPLATE.md)]
## 我正在提交...
- [ ] 错误报告
- [ ] 功能要求
## 当前行为是什么?
...
## 如果当前行为是错误, 请提供重现的步骤, 如果可能, 请提供问题的最小演示
...
## 预期的行为是什么?
...
## 改变行为的动机 / 用例是什么?
...
## 请告诉我们您的环境:
<!-- 浏览器版本, Node.js 版本, 依赖... -->
... | 250 | MIT |
---
layout: post
title: "杨佳案一审刑事判决书"
date: 2008-10-21
author: 爱德布克
from: http://www.ideobook.com/637/yangjia-case-judgment/
tags: [ 智识 ]
categories: [ 智识 ]
---
<article class="post-entry clearfix post-637 post type-post status-publish format-standard has-post-thumbnail hentry category-miscellaneous">
<div class="post-entry-thumbnail">
<img alt="杨佳案一审刑事判决书" src="http://www.ideobook.com/img/yangjia.jpg"/>
</div>
<!-- /blog-entry-thumbnail -->
<div class="post-entry-text clearfix">
<header>
<h1>
杨佳案一审刑事判决书
</h1>
<ul class="post-entry-meta">
<li>
By:
<a href="http://www.ideobook.com/about-ideobook/" title="查看 爱德布克 的作者主页">
爱德布克
</a>
. 2008-10-21.
<a href="http://www.ideobook.com/372/post-views-count/" title="统计说明">
5,763
</a>
</li>
</ul>
</header>
<div class="post-entry-content">
<p>
<strong>
上海市第二中级人民法院刑事判决书
</strong>
（2008)沪二中刑初字第99号
</p>
<p>
公诉机关：上海市人民检察院第二分院。
</p>
<p>
被告人：杨佳，男，1980年8月27日出生于北京市，汉族，中专文化程度，无业，户籍所在地北京市东城区前圆恩寺胡同17号，住北京市朝阳区慧忠里407楼1单元152号。因本案于2008年7月1日被刑事拘留，同年7月7日被逮捕。现羁押于上海市看守所。
</p>
<p>
辩护人：谢有明、谢晋，上海名江律师事务所律师。
</p>
<p>
上海市人民检察院第二分院以沪检二分刑诉[2008]123号起诉书指控被告人杨佳犯故意杀人罪，于2008年7月17日向本院提起公诉。本院依法组成合议庭，于同年8月26日公开开庭审理了本案。上海市人民检察院第二分院指派副检察长袁汉钧、代理检察员陈宏、倪伟出庭支持公诉，被告人杨佳及其辩护人谢有明、谢晋，证人林玮、顾海奇到庭参加诉讼。现已审理终结。
<br/>
<span id="more-637">
</span>
<br/>
上海市人民检察院第二分院指控，2007年10月5日晚，被告人杨佳在沪骑一辆无牌照自行车而受到上海市公安局闸北分局（以下简称“闸北公安分局”）芷江西路派出所（以下简称“芷江西路派出所”）巡逻民警询问和盘查。之后，杨佳向公安机关投诉并提出赔偿精神损失费人民币一万元等要求。闸北公安分局派员疏导劝解。杨佳因要求未被接受，而决意对闸北公安分局民警行凶报复。
</p>
<p>
2008年6月26日，杨佳来沪后购买了“鹰达”牌单刃刀（刀全长29厘米，其中刀刃长17厘米）、催泪喷射器、防毒面具、汽油、铁锤、手套等犯罪工具。
</p>
<p>
同年7月1日上午9时40分许，杨佳携带上述犯罪工具，至本市天目中路578号闸北公安分局办公大楼门前，投掷装有汽油的啤酒瓶引起燃烧，并趁保安员灭火之际，杨佳头戴防毒面具闯入闸北公安分局办公大楼。在闸北公安分局办公大楼底层大厅等处，杨佳先用刀砍击保安员顾建明头部，继而持刀分别猛刺正在工作且赤手空拳、毫无防备的民警方福新、倪景荣、张义阶、张建平的头、颈、胸腹等要害部位，致四名民警当场受伤倒地。之后，杨佳沿消防楼梯至九楼至十一楼途中，又持刀先后猛刺、猛砍赤手空拳且猝不及防的民警徐维亚、王凌云、李坷的头、胸腹等要害部位，致徐维亚、李坷当场受伤倒地，并致王凌云受伤。杨佳继续冲上二十一楼后，又持刀刺伤正在等候电梯的民警吴钰骅，并闯入2113室行凶，致民警李伟受伤，被在场民警林玮等人当场捕获。
</p>
<p>
民警方福新、倪景荣、张义阶、张建平、徐维亚、李坷虽经急送医院抢救，终因失血性休克而于案发当日死亡。民警王凌云、李伟构成轻伤。民警吴钰骅、保安员顾建明构成轻微伤。
</p>
<p>
上海市人民检察院第二分院针对上述指控的事实，向本院提供了被害人的陈述、证人证言、有关书证、物证和录像资料，公安机关的《现场勘查笔录》、《尸体检验报告》、《鉴定书》，司法科学技术研究所的《司法鉴定中心鉴定意见书》，被告人杨佳的供述等证据。上海市人民检察院第二分院认为，被告人杨佳因其无理要求未被公安机关接受，携带犯罪工具，闯入公安机关办公场所，持刀连续故意杀害六名民警，还致其他毫无防备的三名民警和一名保安员受伤，其行为已触犯《中华人民共和国刑法》第二百三十二条，应当以故意杀人罪追究刑事责任。
</p>
<p>
被告人杨佳以辩护人申请传唤薛耀、陈银桥、吴钰骅等证人出庭作证未获法庭准许，诉讼程序有失公正为由，拒绝回答法庭审理中的讯问和发问；对控辩双方宣读或出示的证据不发表意见，也没有为自己作辩护。
</p>
<p>
被告人杨佳的辩护人当庭宣读了2008年7月29日会见杨佳的笔录，请求法庭播放了芷江西路派出所对杨佳盘查时的相关录音、录像等视听资料，并经法庭同意，申请法庭传唤证人顾海奇出庭作证，据此提出如下辩护意见：
</p>
<p>
1、芷江西路派出所民警对杨佳的盘查缺乏法律依据，且不能排除杨佳在接受盘查的过程中遭公安人员殴打的可能性，而警方对杨佳的投诉处置不当是引起本案发生的重要因素。
</p>
<p>
2、杨佳认为，闸北公安分局警务督察支队民警吴钰骅对杨佳的投诉处理不当。杨欲对吴进行报复伤害，其间遭到其他被害人的阻拦。被害人的死亡是出于杨佳的意料之外，且杨佳未对保安人员实施加害。因此，杨佳的行为构成故意伤害罪，不构成故意杀人罪。
</p>
<p>
3、参与部分侦查工作的闸北公安分局的侦查人员，与本案被害人是同事，没有依照《中华人民共和国刑事诉讼法》第二十八条之规定进行回避，因此，所收集的证人证言不能作为定案的证据。
</p>
<p>
4、杨佳很有可能存在精神方面的异常，具有精神疾病，故有必要对其精神状态和刑事责任能力重新进行鉴定和评定。
</p>
<p>
此外，辩护人还以杨佳案发前表现良好，到案后有一定的悔罪表现等为由，请求法庭对杨佳慎用极刑。
</p>
<p>
公诉人答辩认为：
</p>
<p>
1、被告人杨佳使用足以致人死亡的尖刀，朝被害人的要害部位连续刺戳，其追求的是非法剥夺他人生命的目的，且在被制服后声称“够本”，充分表明杨佳有杀人的故意。
</p>
<p>
2、参与本案侦查工作的闸北公安分局侦查人员，与本案没有利害关系，不存在需要回避的情形，因此所收集的相关证人证言合法有效。
</p>
<p>
3、司法鉴定科学技术研究所司法鉴定中心及参与对杨佳作精神状态鉴定和刑事责任能力评定的人员均具有法定资质，因此，其鉴定结论具有法律效力。
</p>
<p>
4、公安人员对杨佳骑无牌照自行车进行盘查合法有据，杨佳被盘查一节不能成为杨对被害人行凶，造成六人死亡、四人受伤的理由。
</p>
<p>
5、杨佳以极其残忍的手段非法剥夺六名无辜民警的生命，还致其他三名民警和一名保安员受伤，社会危害特别严重，且无法定或酌定从轻处罚情节，依法应予严惩。
</p>
<p>
经审理查明，被告人杨佳于2007年10月5日晚骑一辆无牌照自行车途经本市芷江西路、普善路路口时，受到芷江西路派出所巡逻民警依法盘查，由于杨佳不配合，被带至派出所询问，以查明其所骑自行车的来源。杨佳因对公安民警的盘查不满，通过电子邮件、电话等方式多次向公安机关投诉。闸北公安分局派员对杨佳进行了释明和劝导。杨在所提要求未被公安机关接受后，又提出补偿人民币一万元。杨因投诉要求未获满足，遂起意行凶报复。
</p>
<p>
2008年6月26日，杨来沪后购买了单刃尖刀、防毒面具、催泪喷射器等工具，并制作了若干个汽油燃烧瓶。
</p>
<p>
同年7月1日上午9时40分许，杨佳携带上述作案工具至本市天目中路578号闸北公安分局北大门前投掷燃烧瓶，并戴防毒面具，持尖刀闯入该分局底楼接待大厅，朝门内东侧办公桌前打电话的保安员顾建明头部砍击。随后，杨闯入大厅东侧的治安支队值班室，分别朝正在办公的方福新、倪景荣、张义阶、张建平等四位民警的头面、颈项、胸、腹等部位捅刺、砍击。接着，杨沿大楼北侧消防楼梯至第9层，在消防通道电梯口处遇见正在下楼的民警徐维亚后，持尖刀朝徐的头、颈、胸、腹等部位捅刺。后杨佳继续沿大楼北侧消防楼梯上楼，在第9至10层楼梯处遇见下楼的民警王凌云，杨即用尖刀朝王的右肩背、右胸等部位捅刺。杨佳至 11楼后，在1101室门外持尖刀朝民警李坷的头、胸等部位捅刺。此后，杨佳沿大楼北侧消防楼梯至第21层，在大楼北侧电梯口朝正在等候电梯的民警吴钰骅胸部捅刺。吴钰骅被刺后退回2113办公室。杨闯入该室持刀继续对民警实施加害。室内的民警李伟、林玮、吴钰骅等人遂与之搏斗，并与闻讯赶来的容侃敏、孔中卫、陈伟、黄兆泉等民警将杨佳制服。其间，民警李伟右侧面部被刺伤。
</p>
<p>
被害人方福新、张义阶、李坷、张建平因被锐器戳刺胸部伤及肺等致失血性休克，被害人倪景荣被锐器戳刺颈部伤及血管、气管等致失血性休克，被害人徐维亚被锐器戳刺胸腹部伤及肺、肝脏等致失血性休克，经抢救无效而相继死亡。被害人李伟外伤致面部遗留两处缝创，长度累计达9.9厘米，并伤及右侧腮腺；被害人王凌云外伤致躯干部遗留缝创，长度累计大于15厘米，右手食指与中指皮肤裂伤伴伸指肌键断裂，李、王两人均构成轻伤；被害人吴钰骅外伤致右上胸部软组织裂创长为3厘米；被害人顾建明外伤致头皮裂创长为5.1厘米，吴、顾两人均构成轻微伤。
</p>
<p>
以上事实，有公诉人、辩护人当庭举证并经法庭质证，本院予以确认的下列证据证实：
</p>
<p>
1、被害人顾建明（上海市保安服务总公司闸北区公司保安员）2008年7月2日陈述称：”2008年7月1日上午10时许，我听见天目西路大门外有人在喊：‘有人放火，快报警呀。’我一听有人放火就往外看，看到分局围墙右侧处有两处明火，其中一处火势相当大。我想打电话到指挥中心汇报情况。我刚拨完电话还未通话，有一个人对我说了一句：‘你敢打电话，’接着就举起右手向我头部敲过来，我用手一摸血流出来了。这个人当时戴着一个防毒面具，身高1.70米左右，上身穿浅色衣服，右手拿了一把刀，刀长约十几公分，宽5、6公分。我回头看到他右手拿着刀冲进底楼治安支队值班室，一会儿的功夫，就看到民警倪景荣从值班室走出来，全身是血，到了底楼女厕所门口仰面躺在地上，一动也不动了。接着，又看到那个砍伤我的人出治安值班室大门后左转朝分局电梯方向走去。这时，有人对我说104室门口还有一个人躺着，我走近一看是民警张义阶，当时他也是仰面躺在地上，全身是血。”
</p>
<p>
2、被害人王凌云（闸北公安分局交警支队民警）2008年7月1日陈述称：”2008年7月1日上午9时45分左右，我从10楼的楼梯处向下走，刚走了几步，听到9楼发出几声尖叫声。于是我快步朝下走，看到一持刀男子由下往上冲上来，没说一句话，就挥刀朝我的胸、头部劈来。我胸部先被刺中一刀，即朝后退回到10楼的木门处，而这男子冲上来，用刀刺中我的右后背。我用手去抓他的刀，结果右手食指被刺伤。当我退回到10楼的楼面，遇到浑身是血的徐维亚。当时我遇到这名持刀男子时，他戴一副防毒面具，是黑色的。此人身高1.73米，体形较结实，上身穿淡颜色的短袖T恤。”
</p>
<p>
3、被害人吴钰骅（闸北公安分局警务督察支队民警）2008年7月2日陈述称：“2008年7月1日9时30分至10时之间，我准备外出工作，到电梯间时，看见在2112室门口有一个人，头戴防毒面具，穿淡色衣服，我就问了他一句‘你在干什么？’，那个人就突然向我猛扑过来，右手横握刺刀刺我右胸部。我赶紧后退，他转身朝2112室跑去。我回到自己的办公室告诉同事自己被刺了，并打电话给分局的指挥中心。不久，那个蒙面的人持刀推门而入并行凶。我的同事就拿起椅子将他围住，最后将他制服。”
</p>
<p>
4、被害人李伟（身份同上）2008年7月2日陈述称：“2008年7月1日9时45分许，我在自己办公室2113室工作，同事吴钰骅冲进来说：‘我被人捅了一刀。’这时，突然冲进来一男青年，头戴防毒面具，穿一件白色短袖圆领衫，右手举一把尖刀，向我们冲了上来。这时，我们的纪委副书记孔中卫和其他人也冲进来。我和同事林玮、孔中卫合力将他夹住，他右手拿刀朝我头上砍来，我的右脸侧被刀划伤。这时同事们都围上来，将这名男青年制服。”
</p>
<p>
5、证人童佳骏（系被害人顾建明的同事）2008年7月1日陈述称：”2008年7月1日上午，我在天目中路578号巡视时，听到一声玻璃瓶砸碎的声音，还发现分局正门东北处的花坛烧起来，地上有砸碎的深咖啡色的玻璃瓶，旁边站着一名男子。于是，我就问他：‘你在干什么？’他没有回答我，而是迎面朝我大步走来。我准备去叫几个保安来制止他，这名男子就用玻璃瓶砸我。我退到警卫室旁边，同时叫另外几个保安打110报警。此时，我看见民警倪景荣倒在女厕所门口的地上，身下有很多血。我还看到顾建明捂着头部，并对我说：‘我头上也被刺了一刀。’这名男子身上背了一只黑色小方包。”
</p>
<p>
6、证人佘长富、石金根、惠立生（均系顾建明的同事）、陶文瑾（闸北公安分局临时工）于2008年7月1日、2日分别作了陈述，其内容证实一头戴面具，手持尖刀的男子杀害倪景荣等四名民警的事实经过。这四名证人的证言与前述被害人陈述及证人证言能相互印证。
</p>
<p>
7、证人黄骏远（闸北公安分局交警支队民警）2008年7月1日陈述称：“今天上午9时40分许，我的同事徐维亚离开办公室后不久，我就听到几声惨叫，我出去看见一个男子头上戴了一个深色的防毒面具，上身穿白色T恤衫，右手拿了一把类似匕首的刀具，刀身约长20厘米左右。此人正从9楼的消防通道往 10楼走来。等我拿了警棍出来，看见民警柏伟良在9楼电梯处扶着我的同事王凌云，王凌云的警服上有很多血，左手托住右手，对我说他的手不行了。”
</p>
<p>
8、证人柯璟（身份同上）2008年7月1日陈述称：“2008年7月1日上午9时40分许，我和同事徐维亚、仓定骏、王凌云等都在办公室工作，徐维亚准备下楼，我也走了出去。我听见楼梯口处传来嘈杂声，看见从9楼冲上来一个男子，头戴像防毒面具一样的面罩，中等身材，右手持一把长约20多公分的匕首。后我在1101室外楼道上碰到李坷，告诉他有一个持刀的男子戴面具冲上来。李坷叫我到他办公室去坐一会儿。后来我听到李坷叫‘你干什么？’,接着外面很吵。后我打开门看见李坷倒在地上，身上和地上都是血。”
</p>
<p>
9、证人乔军（身份同上）2008年7月7日陈述称：”2008年7月1日上午，我在905室办公，突然黄骏远进办公室讲：‘有人杀人了。’我听后立即冲出去，跑到9楼楼梯口处，看见王凌云捂着肩处的伤口蹲在地上，我见他伤的不是太重就继续往上跑，跑到11楼见李坷倒在1101室门口，地下都是血。”
</p>
<p>
10、证人孔中卫（闸北公安分局纪委副书记）2008年7月1日陈述称：”7月1日9时45分左右，我在吴钰骅办公室门口，看见吴身上有血迹，左手捂在右胸口处。后我看到一个男子，身高170厘米左右，他左手拿着喷雾器，右手拿着一把刀，穿白色汗衫，深色长裤，脚下穿一双运动鞋，头上带着头罩，手上还戴着手套。他一边对民警使用喷雾器一边挥刀。在我们的合力下，用椅子将该男子顶在墙面上，之后缴下刀和喷雾器，然后把他拷起来。制服该男子后，由特警队的同志带了出去。他当时说‘我够本了，你们一枪崩了我吧。”
</p>
<p>
11、证人黄兆泉、容侃敏、陈伟（均为闸北公安分局警务督察支队民警）于2008年7月1日、2日分别作了陈述，其内容分别印证了被害人吴钰骅、李伟的陈述和证人孔中卫的证言。
</p>
<p>
12、证人林玮（闸北公安分局警务督察支队民警）就被告人杨佳在闸北公安分局21楼向民警行凶一节当庭作证，其证言内容与孔中卫、黄兆泉、容侃敏、陈伟等人的证言内容基本一致。此外，林玮还当庭指认了杨佳就是被当场制服并被摘下面具的那个男子，林玮还对从杨佳处查获的尖刀、防毒面具、喷射器进行了辨认并予确认。
</p>
<p>
13、公诉人当庭播放的闸北公安分局北大门口、底楼接待大厅、该分局治安支队值班室的监控录像显示，被告人杨佳在该分局大门口外投掷汽油燃烧瓶后，头戴防毒面具，手持尖刀闯入接待大厅和治安支队值班室，先后对保安人员顾建明及民警方福新、倪景荣、张义阶、张建平实施了加害的全部过程。
</p>
<p>
14、上海市公安局（2008）沪公刑技痕勘字第0069号、（2008)沪公闸刑技勘字第1841号《现场勘查笔录》记载：
</p>
<p>
现场位于南星路东面，天目中路南侧的天目中路600号闸北政法大楼内。位于天目中路578号系闸北公安分局北大门（门朝北）、位于大统路199号系闸北公安分局南大门（门朝东南）。中心现场位于该大楼的一楼、九楼、十楼、十一楼、二十一楼，勘查按中心向外围的顺序进行。
</p>
<p>
对一楼勘查：闸北公安分局北大门接待大厅内靠西侧通道处（距大厅玻璃门260厘米、距西墙90厘米）地面上有一处110厘米*80厘米的血迹。从北大门接待大厅向东经接待休息室至治安支队值班室的地面上有大小不等成趟点状血迹。在接待休息室内有四排接待椅子，在部分椅子上有血迹；室内的西北墙角距地面 110厘米高度的墙面上有擦拭状血迹；在治安值班室靠南墙处办公桌的桌面、本子、电话机等物品上均有点状血迹。值班室门口内侧地面上有两只翻倒的椅子，木椅上下均有血迹；在值班室靠门西墙处距地面90厘米高度的墙面上有擦血。
</p>
<p>
从北大门接待大厅北侧消防电梯通道至北侧电梯大厅的地面上有成趟点状血迹，从大厅的走道靠东墙处距地面110厘米高度的墙面上有擦拭状血迹；在距北侧消防电梯垂直距离429厘米、距接待大厅玻璃门930厘米通向北侧电梯大厅的走道上有一倒卧的木椅，木椅上有大量血迹。从北大门接待大厅向西的走道上、地面上、向南至闸北区政法大楼底楼大厅及大厅内羽毛球场地面上、向南经7号走道至闸北公安分局南大门底楼大厅地面上、再向北经警苑文化展示厅至大楼北侧电梯大厅及南侧消防通道地面上均有点状血迹。
</p>
<p>
对九楼勘查：在九楼北侧消防电梯口地面上发现有血迹，该血迹向东经北侧消防电梯延伸至九楼北侧电梯大厅处。
</p>
<p>
对十楼勘查：在九楼通向十楼的消防电梯上发现有成趟的点状血迹，在通向十楼楼梯通道靠东墙侧距地面150厘米高度墙面上有擦拭状血迹。在十楼北侧电梯大厅中央距离南面电梯门180厘米、距1006室房门300厘米的地面上有一处血迹，该血迹由北向南经1006室延伸至交警支队综合科科长室，在该科长室西墙处距地面1的厘米高度的墙面上有擦拭状血迹。
</p>
<p>
对十一楼勘查：在十一楼北侧消防电梯通道地面上有大量血迹，该血迹由西向东延伸至1101室腰门处，在距地面120厘米高度的腰门上有擦拭状血迹，该血迹在由腰门处向南延伸至十一楼北侧电梯口，在北侧电梯大厅的北墙处距地面130厘米高度墙面上有擦血。
</p>
<p>
对二十一楼勘查：在位于大楼西面2110室门口与南侧电梯之间的地面上有一处60厘米*50厘米的血迹，该血迹由北向西南延伸至2113室督察队办公室，在督察队办公室地面上有较多点状血迹，室内中央有一张椭圆形会议桌，在会议桌上有一只“onePolar”腰包，室内共有六把办公椅倒地。督察队办公室北墙下由西向东放着三人沙发、电视柜。在电视柜南侧地面上有鹰达牌剔骨刀一把（刀全长29厘米，刀柄长12厘米，刀刃长17厘米，刀刃最宽平面5厘米，刀背宽0.8厘米，刀上有血迹）、橡皮手套一只（在剔骨刀下）、榔头一把（全长33厘米，锤面2.6厘米*2.6厘米）、望远镜一副、望远镜套一只、警用催泪喷射器一支、摩托罗拉手机一部、霖碧矿泉水瓶一瓶、红柄折叠式水果刀一把。在室内东墙下有一跑步机，在跑步机上有一只“3M”面具，面具上有血迹。
</p>
<p>
另外，在底楼至二楼楼梯地面上、四楼至五楼楼梯地面上、十楼至二十一楼楼梯地面上均发现有点状血迹分布。
</p>
<p>
对外围现场勘查：由北大门接待大厅玻璃门至分局北侧围墙大门（天目中路578号）处地面上有成趟点状血迹。在南北高架天目路乌镇路下匝道的停车场内（紧靠北侧铁栅栏）有一处110厘米/140厘米棕色酒瓶玻璃碎片，该碎片距2号桥墩510厘米，其中破碎瓶口上有用绳子捆扎的白色布片。在分局北侧围墙大门向东670厘米处的人行道花坛之间的空地上有一堆110厘米/45厘米的烧灼过的酒瓶玻璃碎片，两侧花坛围墙及花木有烧灼痕。在天目中路538弄1号有一扇铁门，在铁门距地面100厘米高度处的栅栏上有一根70厘米的登山杖，在该门下方地面上有一只“3M”包装袋。在南星路北站医院正门北侧10米处的人行道上有一辆东西方向停放的捷安特自行车。
</p>
<p>
公安机关对现场勘查后，对现场及相关物证予以照相、录像的方法固定，提取了血迹及痕迹。另外，还依法提取涉案物证：其中在二十一楼督察队办公室提取了 “onePolar”腰包一只、沾满血迹的“鹰达”牌剔骨刀一把、榔头一把、望远镜一副、望远镜套一只、催泪喷射器一支、摩托罗拉手机一部、霖碧矿泉水瓶一瓶、红柄折叠式水果刀一把、“3M‘’面具一只；在南北高架下匝道的停车场内提取了破碎瓶口及碎片；在闸北公安分局东侧人行道花坛之间提取烧灼过的酒瓶玻璃碎片；在天目中路538弄1号铁门上及地面上分别提取登山杖一根、“3M”面具包装袋一只。
</p>
<p>
15、上海市公安局物证鉴定中心沪公刑技物字（2008)0091号《检验报告》的结论为：
</p>
<p>
(1）不能排除嫌疑人杨佳左手食指、左手中指、右手拇指、右手中指、右手腕内侧、杨佳汗衫右上臂前端、汗衫上臂处血迹、杨佳裤子左前口袋处、后右口袋处血迹、现场刀柄上的血迹及闸北公安分局大堂、一楼至二十一楼的消防楼梯、通道、电梯门口、地面上等处的血迹为犯罪嫌疑人杨佳所留。
</p>
<p>
(2）不能排除1楼治安值班室值班本上血迹、1楼治安值班室台上烟蒂、1楼大厅椅子上血迹、1楼大厅标牌3处墙上血迹、嫌疑人杨佳汗衫左肩上血迹为被害人张义阶所留。
</p>
<p>
(3）不能排除1楼治安值班室地上血迹、1楼大厅提取的鞋子底部血迹、1楼大厅标牌1处地面血迹、1楼大厅进门楼梯处血迹、嫌疑人杨佳左脚鞋子鞋尖处血迹、天目中路578号门大堂走道12号标牌处血迹为被害人倪景荣所留。
</p>
<p>
(4）不能排除1楼大厅过道标牌8处地面血迹、3M面罩上血迹1、天目中路578号门大堂走道7号标牌处血迹为被害人方福新所留。
</p>
<p>
(5）不能排除嫌疑人杨佳裤子前右裤下缘血迹、电梯口血迹、督察办公室5号标牌处血迹、督察办公室6号标牌处血迹、督察办公室7号标牌处血迹、督察办公室4号标牌处血迹、刀尖上血迹、嫌疑人杨佳的右脚鞋子鞋尖处血迹、嫌疑人右脚鞋子外侧鞋帮处血迹为被害人李伟所留。
</p>
<p>
(6）不能排除10楼消防楼梯处血迹、9至10楼消防楼梯处血迹、9楼消防通道门口处血迹为被害人王凌云所留。
</p>
<p>
(7）不能排除11楼消防楼梯口处血迹、11楼消防通道与走廊交汇处血迹、11楼1104室门口处血迹、11楼电梯口处血迹、1105室门口血迹、1104室至1101室走廊之间的门上的血迹、11楼消防栓旁墙上的血迹、3M面罩上血迹4为被害人李坷所留。
</p>
<p>
(8）不能排除刀刃处血迹、刀身根部血迹（有字面）、天目中路578号门大堂走道1号标牌处血迹、天目中路578号门大堂走道2号标牌处血迹为被害人张建平所留。
</p>
<p>
(9）不能排除10楼1005室门口血迹、10楼电梯门口白色毛巾上血迹、10楼电梯门口格子状花纹毛巾上血迹、10楼1006室门口血迹、10楼消防通道门口血迹、10楼消防通道楼梯口血迹、9楼消防通道电梯口处血迹、9楼消防通道入口处血迹、1006室门内地面血迹、1006室室内过道血迹、 1006室综合科科长室内血迹、3M面罩上血迹5为被害人徐维亚所留。
</p>
<p>
16、上海市公安局沪公刑技法检字(2008)00293号《尸体检验报告》确认：
</p>
<p>
死者方福新左胸部于左乳头处下第四一第五肋间由胸骨至左腋前线处有长为16厘米的缝合创口，创缘整齐、创壁较光滑、创腔无组织间桥，相应处胸廓壁肋间呈洞状创口，创道深及左胸腔、左肺，左侧胸腔有积血，左肺下叶有贯穿性创口。
</p>
<p>
死者李坷头面、颈项部：左额部有长为4厘米的皮肤划创，左唇处有长为2厘米的皮肤划创，左下领处有长为3厘米的皮肤划创，此三处均仅深及皮下，创缘整齐、创腔无组织间桥。躯干、四肢部：右胸于锁骨中线第三肋处有长为5厘米的缝合创口，深及胸腔；右腋前线第三一第四肋间有长为8.5厘米的缝合创口，深及胸腔；右乳头下由胸骨旁线至腋中线处有长21厘米的缝合创口，深及胸腔。右胸腔有积血，右肺上叶见贯穿性损伤，右肺动静脉裂伤。左手拇指近节腹侧有长为 3.5厘米的缝合创口，左手食指近侧指间关节腹侧有长为3厘米的缝合创口。以上创口均创缘整齐、创壁较光滑、创腔组织间桥不明显。
</p>
<p>
死者张建平头面、颈项部：左颈部有长为9厘米的缝合创口，深及头皮下。躯干、四肢部：左肩背部有长21厘米的缝合创口，深及肌肉层；左乳头上由第二肋间有长13厘米的缝合创口，深及胸腔。右乳头下锁骨中线至腋中线处有长18厘米的缝合创口，深及胸腔，其下有长为3厘米的缝合创口，深及胸腔；右腋中线第六一第七肋间有长为7.5厘米的缝合创口，深及胸腔。两侧胸腔有积血，以右侧为重，右肺下叶有贯穿性创口，探查隔肌右侧以及其下肝脏有破裂。以上创口均创缘整齐、创壁较光滑、创腔组织间桥不明显。
</p>
<p>
死者倪景荣颏部见有长6.5厘米的皮瓣创。颏下至左颈部见长9厘米的创口，创腔内见颈静脉、颈动脉多处血管破裂，甲状软骨断裂深及气管腔，创腔内相应颈部肌肉断裂。创口具有创缘整齐、创壁光滑、创腔内未见组织间桥等特点。
</p>
<p>
死者张义阶左腋前见长为11厘米的创口，深达左侧胸腔，左胸腔积血，左肺有破裂口。左腋下平乳头处见长3厘米的创口，深达肌层。左手无名指末节掌侧见长1.5厘米的创口。左膝关节前侧见0.4*1.2厘米、1*1.5厘米的表皮剥脱。右踩关节内侧上方见2.3厘米的创口。以上创口具有创缘整齐、创壁光滑、创腔内未见组织间桥等特点。
</p>
<p>
死者徐维亚头面、颈项部：前额部有长5厘米的缝合创口，深及皮下；左颊至左颞有长为14厘米的缝合创口，深及肌层。两处创口均创缘整齐、创壁光滑、创腔内未见组织间桥。躯干、四肢部：左颈下有长为1厘米的缝合创口。右胸第二肋、锁骨中线处有长为2厘米的缝合创口。右胸及腹部有呈倒“L”型缝合创口：于右乳下右腋前线左至剑突出处长为18厘米，剑突处至脐处纵形长为28厘米，深及胸腹，探查胸腔、腹腔积血，左侧肺脏、肝脏均有破裂口。右腋中线第六肋间有长为2厘米的缝合创口。两侧腹股沟有长为1一2厘米的缝合创口，并伴有皮下淤血。左上肢1*2一4*5厘米的散在皮下出血斑，左上臂略肿胀。右肘关节处有长为12厘米的缝合创口。左股下段外侧有3/5厘米皮下出血。以上创口均创缘整齐、创壁较光滑、创腔内未见组织间桥的特点。
</p>
<p>
结论为：
</p>
<p>
被害人方福新、李坷、张建平、张义阶系被他人用锐器戳刺胸部伤及肺等致失血性休克死亡；倪景荣系被他人用锐器戳刺颈部伤及血管、气管等致失血性休克死亡；徐维亚系被他人用锐器戳刺胸腹部伤及肺脏、肝脏等致失血性休克而死亡。
</p>
<p>
17、上海市公安局损伤伤残鉴定中心沪公刑技伤字(2008)01899号、01900号、01901号、01902号《鉴定书》分别确认：
</p>
<p>
被鉴定人李伟外伤致面部遗留两处缝创，长度累计达9.9厘米，并伤及右侧腮腺，参照《人体轻伤鉴定标准（试行）)）第十四条、第十二条（四）规定，构成轻伤；
</p>
<p>
被鉴定人王凌云外伤致躯干部遗留缝创，长度累计大于15厘米，右手食指与中指皮肤裂伤伴伸指肌腹断裂，经清创缝合并修复伸指肌键，参照《人体轻伤鉴定标准（试行）》第二十八条及第二十一条之规定，构成轻伤；
</p>
<p>
被鉴定人吴钰骅外伤致右上胸部软组织裂创长为3厘米，创深未达胸腔，参照《人体轻微伤的鉴定》4.2规定，构成轻微伤；
</p>
<p>
被鉴定人顾建明外伤致头皮裂创长为5.1厘米，参照《人体轻微伤的鉴定》3.2规定，构成轻微伤。
</p>
<p>
18、证人李秀英、李金英（均为本市梅园招待所服务员）于2008年7月1日所作的陈述笔录及其辨认笔录证实，被告人杨佳于2008年6月26日入住本市长安路33号梅园招待所202一2房间。
</p>
<p>
19、江玉英（上海张小泉刀剪总店营业员）2008年7月2日陈述称：”2008年6月29日下午4点多钟，有一个男的来我柜台前说要买刀。他自己看中并买了一把标价160元的鹰达牌料理刀。”
</p>
<p>
证人江玉英在作上述陈述的当天对公安人员出示的一组十张照片进行了辨认，确认该组照片中8号（杨佳）即为2008年6月29日下午来其商店购买刀具的人。
</p>
<p>
20、证人陈舟（上海滁全经贸有限公司员工）2008年7月2日陈述称：“我们单位生产并销售防毒面具，牌子是‘3M’的。2008年6月28日下午 4时许，有个叫‘行天下’的人上网求购防毒面具，并留了我的手机号。6月30日中午11时许，他用13162590196的电话打我手机，告诉我来取 6800型面具的货，我称可以。当日下午，此人以1,224元的价格从我处购买一个6800型防毒面具。”
</p>
<p>
证人陈舟在作上述陈述的当天对公安人员出示的一组十张照片进行了辨认，确认该组照片中的8号（杨佳）即为2008年6月30日下午前往约定的地点向其购买防毒面具的人。
</p>
<p>
21、上海市公安局（2008）沪公刑技痕勘字第0069号、（2008)沪公闸刑技勘字第1841号《现场勘查笔录》记载：
</p>
<p>
梅园招待所位于大统路西侧、长安路北侧的长安路33号，中心现场位于该招待所二楼的202一2室。室内床上有一个蓝色的旅行袋、一个标有“3M”字样的白色防毒面具盒子、一把兆升牌强力剪刀、一把标有“鹰达料理庖丁”字样的刀具盒及各类发票（刀具发票、防毒面具发票等）。
</p>
<p>
22、上海市公安局编号为4008930、4008932(（扣押物品、文件清单》连同《现场勘查笔录》证实，公安人员在对本案案发现场及被告人杨佳在梅园招待所的暂住处提取了“鹰达”牌单刃刀、”3M”防毒面具、催泪喷射器、铁锤、标有“3M”字样的白色防毒面具盒子等相关物证，被告人杨佳在相关清单中以物品持有人的身份签名捺印。
</p>
<p>
23、证人薛耀（芷江西路派出所民警）2008年7月21日陈述称：”2007年10月5日晚8时30分左右，有一个男子骑一辆自行车沿芷江西路由东向西到普善路时，我看见他骑得很慢，四处张望。因为当时芷江西路附近失窃自行车的情况比较多，我就将其拦下检查。该男子将自行车停下后，我发现他的自行车没有牌证，于是我就问他自行车来源。他说自行车是租来的，我让他出示租车凭证，他拒绝提供，并说我无权检查，且限制了他的人身自由。过了大约二十分钟左右，他才拿出一张纸说是租赁凭证，我说天黑看不清，叫他把凭证交给我。他拒绝，只用手举着一张纸。我说看不清楚，他说我连字也看不清，做什么警察，并开始拨打‘114’查询上海市公安局督察队电话，我告诉了他我的警号，将闸北公安分局督察队电话告诉他。他拨打了督察队电话，投诉我限制他的人身自由，并对我的身份表示怀疑。后来我呼叫当班的警长陈银桥增援。过了一会，陈银桥带了三四个民警过来，向该男子了解情况。该男子将我检查他自行车的事情告诉了陈银桥。陈银桥说现在自行车横在马路当中影响交通，希望该男子到派出所解决纠纷。该男子表示不愿到派出所，经解释后才坐上警车到了芷江西路派出所，自行车由社保队员骑回派出所。我先疏导当时围观的群众，在我回到芷江西路派出所时，看见民警高铁军在对该男子做解释工作，该男子说高铁军向其吐唾沫，并冲到派出所门口，高铁军就去拦他，他抓住高铁军的手。后来我和陈银桥、高铁军将该男子架进里面的工作区域，让他坐在椅子上，并由陈银桥、高铁军继续做解释工作。我就上二楼叫值班民警给我作笔录，然后将当时记录我执法过程的录音复制到派出所电脑里。整个过程大概半个小时。我后来回到一楼，看见分局督察队吴钰骅仍在对该男子做解释工作。我就向当晚值班所长寿绪光汇报了这件事。吴钰骅也向我询问了有关情况。我除了将该男子架进派出所的工作区域之外，没有接触过该男子。我肯定没有动手打过该男子。”
</p>
<p>
24、证人陈银桥（身份同上）2008年7月21日陈述称：”2007年10月5日晚我是值班警长，我接到薛耀请求增援，立即赶至芷江西路、普善路路口，看见有十多名群众在围观。我走过去看见一个男青年坐在自行车上，民警薛耀向我陈述要检查该男青年自行车来源，因为自行车没有牌照，但该男青年不配合。我问该男青年自行车凭证，该男青年说他不相信民警薛耀的身份，我回答：‘你现在应该相信我是民警了吧，请将自行车凭证给我看看。’他就拿出一张纸说是租车单，并在手里晃了晃。我说：‘你这样晃，我根本看不见，你拿给我看。’该男青年仍然不肯，于是我们劝他回芷江西路派出所询问情况。后来他坐警车去派出所，自行车由社保队员骑回派出所。到了派出所后，我和高铁军向该男青年做解释工作，告知民警依法可以盘查他自行车来源，他突然说高铁军用唾沫吐他脸，并说有口臭。后来该男青年说他要走了，就朝派出所门口走去，高铁军拦他，他一下子扳高铁军手指。我看见他打民警就与高铁军等人将该男青年架进派出所内工作区域，让他坐下。我又向他作解释教育工作。几分钟后，我将该男青年交值班民警处理，我就离开到街面巡逻了。”
</p>
<p>
25、证人陈红彬（身份同上）2008年7月3日陈述称：”2007年10月5日晚，我所的值班人员查实杨佳骑的自行车处于正常状态，进行解释后让杨佳自行离开。但是杨佳声称有民警在执勤过程中对其进行了殴打，拒绝离开派出所。后所内值班人员接到杨佳母亲的电话，通话中要求协助对杨佳进行说服、疏导，之后杨佳自行离开。事后杨佳通过信访、市公安局督察部门投诉我所民警。派出所为了妥善处置此事，就多次电话联系杨佳及其母亲，进行解释和疏导工作，但是杨佳及其母亲声称派出所在执勤过程中存在过错，要求派出所对杨佳进行赔偿。
</p>
<p>
之后，派出所在2007年10月中旬派民警周英赴北京进行疏导工作，并提出支付给杨佳300元钱补偿他的长途电话费，但是杨佳拒绝接受，并提出要求赔偿一万元人民币的无理要求。后杨佳及其母亲还是通过信访途径继续投诉我所民警。在正常信访回复之后，2008年3月间，所里再次派民警顾海奇赴北京与杨佳及其母亲见面并进行疏导工作，但是杨佳及其母亲提出还要派出所出具没有打人的书面证明等无理要求。因为我所民警在处置过程中没有任何过错，就拒绝了杨佳及其母亲的无理要求。”
</p>
<p>
26、证人顾海奇（芷江西路派出所民警）就其根据芷江西路派出所领导的指示，前往北京同被告人杨佳及其母亲就执法依据进行解释和疏导的事实向法庭作了陈述，其陈述内容与陈红彬的证言内容基本一致。
</p>
<p>
27、公诉人当庭出示了被告人杨佳于2007年10月25日通过电子邮件的方式向上海市公安局有关部门发送的投诉信并予以宣读。该投诉信中的内容结合相关证人的证言可以证实杨佳接受盘查的事实。
</p>
<p>
28、法庭当庭播放由本院根据辩护人的申请，依法向公安机关调取的芷江西路派出所在对杨佳实施盘查过程中形成的录音及监控录像，该视听资料反映了民警在对杨佳实施盘查时的对话内容以及杨佳被带至芷江西路派出所接受进一步盘查的事实。
</p>
<p>
29、公诉人和辩护人当庭分别宣读了被告人杨佳于2008年7月1日、11日分别接受公安、公诉机关讯问的供述笔录及同年7月29日同辩护人会见的笔录。杨佳在该三份笔录中就其持刀对方福新、倪景荣等实施加害的事实均作了供认。
</p>
<p>
此外，公诉人宣读的司法鉴定科学技术研究所司法鉴定中心出具的司鉴中心[2008]精鉴字第205号《司法鉴定科学技术研究所司法鉴定中心鉴定意见书》确认，被鉴定人杨佳无精神病，在本案中应评定为具有完全刑事责任能力。
</p>
<p>
关于杨佳是否加害过保安人员。经查，被害人顾建明受伤的时间与方福新、倪景荣、张义阶、张建平等四名民警遇害的时间基本相同，顾受到不法侵害的地点处于闸北公安分局治安支队值班室外，顾头部的创口系锐器作用所致，且顾建明确认对其加害者为一头戴防毒面具，手持尖刀的人，而童佳骏、佘长富等证人的证言证实当时一头戴防毒面具，手持尖刀的人在底楼接待大厅行凶时，顾建明也同时受了伤。证人吴钰骅、李伟、孔中卫、林玮均证实抓获杨佳时，杨头戴防毒面具，手持尖刀。以上事实足以证明顾建明头部的伤系被告人杨佳行为所致。杨佳认为其没有加害保安人员，与事实不符。
</p>
<p>
关于闸北公安分局侦查人员参与本案部分侦查工作，所收集的相关证人证言是否合法。经查，本案发生后，由上海市公安局立案并负责侦查，闸北公安分局侦查人员虽参与收集相关证人证言，但没有证据证明上述侦查人员和本案有利害关系或者其他关系，可能影响公正处理案件的事实存在，故辩护人关于闸北公安分局侦查人员收集的证人证言违反《中华人民共和国刑事诉讼法》第二十八条之规定，相关证人证言不能作为定案证据的辩护意见，缺乏事实和法律依据。
</p>
<p>
关于司法鉴定科学技术研究所司法鉴定中心出具的对杨佳作案时的精神状态和刑事责任能力的鉴定结论是否有效。经查，司法鉴定科学技术研究所司法鉴定中心及参与对杨佳作精神状态鉴定和刑事责任能力评定的人员均具有法定资质，鉴定结论具有法律效力，且与本案的其他证据互相印证，应予采信。辩护人没有提供杨佳精神状态异常，具有精神疾病的相关依据。因此，辩护人申请重新鉴定的意见，理由不足，本院不予准许。
</p>
<p>
关于本案的起因。被告人杨佳因对公安人员就其所骑无牌照的自行车依法进行盘查及处理结果不满，而起意行凶报复的事实，证据确实、充分。辩护人提出，不能排除公安人员在盘查杨佳时，对杨实施殴打的意见，没有证据支持。
</p>
<p>
本院认为，被告人杨佳为泄愤报复，经预谋，携带尖刀等作案工具闯入公安机关，并持尖刀朝数名公安民警及保安人员连续捅刺，造成六人死亡，两人轻伤，两人轻微伤的严重后果，其行为已构成故意杀人罪。公诉机关指控的罪名成立。杨佳持刀刃长达10余厘米的单刃尖刀对公安民警及保安人员的头、颈、胸、腹等要害部位连续猛刺，《尸体检验报告》证实被害人胸腹部的创口深达胸腔、腹腔，上述事实和证据足以证明杨佳具有非法剥夺他人生命的主观故意，其行为符合我国刑法第二百三十二条故意杀人罪的构成要件。故辩护人提出杨佳的行为仅构成故意伤害罪的理由不能成立。被告人杨佳故意杀人罪行极其严重，社会危害极大，且无法定或酌情从轻处罚情节，应依法惩处。为维护社会治安秩序，保障公民的人身权利不受侵犯，依照《中华人民共和国刑法》第二百三十二条、第五十七条第一款和第六十四条之规定，判决如下：
</p>
<p>
一、被告人杨佳犯故意杀人罪，判处死刑，剥夺政治权利终身。
</p>
<p>
二、作案工具予以没收。
</p>
<p>
如不服本判决，可在接到判决书的第二日起十日内，通过本院或者直接向上海市高级人民法院提出上诉。书面上诉的，应当提交上诉状正本一份，副本一份。
</p>
<p>
审判长王智刚
<br/>
审判员叶建民
<br/>
人民陪审员孙国瑛
</p>
<p>
二〇〇八年九月一日
</p>
<p>
书记员赵晖兵
<br/>
书记员李琼
</p>
</div>
<!-- /post-entry-content -->
<footer class="post-entry-footer">
<p>
Categorized:
<a href="http://www.ideobook.com/category/miscellaneous/" rel="category tag">
万象通讯 · MISCELLANEOUS
</a>
</p>
</footer>
<!-- /post-entry-footer -->
<footer class="post-entry-footer">
<p>
如果您喜欢本站文章，
<a href="http://www.ideobook.com/subscription/">
请订阅我们的电子邮件
</a>
，以便及时获取更新通知。
</p>
<p>
好书推荐:
<a href="https://amzn.to/2BLHdBY">
脱销多年新近重印的四卷本奥威尔文集 The Collected Essays, Journalism, and Letters of George Orwell: Volume 1
</a>
,
<a href="https://amzn.to/32VpT9o">
2
</a>
,
<a href="https://amzn.to/2pk1FHp">
3
</a>
,
<a href="https://amzn.to/32WV0RW">
4
</a>
.
</p>
</footer>
<div class="boxframe" id="commentsbox">
<div class="comments-area clearfix" id="comments">
<div class="comment-respond" id="respond">
<h3 class="comment-reply-title" id="reply-title">
Leave a Reply
<small>
<a href="/637/yangjia-case-judgment/#respond" id="cancel-comment-reply-link" rel="nofollow" style="display:none;">
<span class="wpex-icon-remove-sign">
</span>
</a>
</small>
</h3>
</div>
<!-- #respond -->
</div>
<!-- /comments -->
</div>
<!-- /commentsbox -->
</div>
<!-- /post-entry-text -->
</article> | 19,415 | MIT |
---
layout: post
title: "【LIVE】2021/05/07 | 今晚四哥開無雙"
date: 2021-05-07T17:34:10.000Z
author: 好青年荼毒室 - 哲學部
from: https://www.youtube.com/watch?v=-ls1DfMI23g
tags: [ 好青年荼毒室 ]
categories: [ 好青年荼毒室 ]
---
<!--1620408850000-->
[【LIVE】2021/05/07 | 今晚四哥開無雙](https://www.youtube.com/watch?v=-ls1DfMI23g)
------
<div>
好青年荼毒室網頁: https://corrupttheyouth.net/Instagram: https://www.instagram.com/corrupttheyouthFacebook: https://www.facebook.com/corrupttheyouthPatreon會員計劃: https://www.patreon.com/corrupttheyouth?fan_landing=true課金：https://streamelements.com/se-2114863/tip
</div> | 569 | MIT |
---
title: 什么是计算机视觉？
titleSuffix: Azure Cognitive Services
description: 使用计算机视觉服务，你可以访问用于处理图像并返回信息的高级算法。
services: cognitive-services
author: Johnnytechn
manager: nitinme
ms.service: cognitive-services
ms.subservice: computer-vision
ms.topic: overview
ms.date: 10/16/2020
ms.author: v-johya
ms.custom:
- seodec18
- cog-serv-seo-aug-2020
keywords: computer vision, computer vision applications, computer vision service
ms.openlocfilehash: 4cd82bac4ee9b328979d4527162ccaf05c3bb9b4
ms.sourcegitcommit: 6f66215d61c6c4ee3f2713a796e074f69934ba98
ms.translationtype: HT
ms.contentlocale: zh-CN
ms.lasthandoff: 10/16/2020
ms.locfileid: "92128761"
---
# <a name="what-is-computer-vision"></a>什么是计算机视觉？
[!INCLUDE [TLS 1.2 enforcement](../../../includes/cognitive-services-tls-announcement.md)]
使用 Azure 的计算机视觉服务，你可以访问高级算法，这些算法根据你感兴趣的视觉功能处理图像并返回信息。 例如，计算机视觉可以确定图像是否包含成人内容、查找特定的品牌或物体或查找人脸。
可使用客户端库 SDK 或直接调用 REST API 来创建计算机视觉应用程序。 此页广泛地介绍了计算机视觉的功能。
## <a name="computer-vision-for-digital-asset-management"></a>用于数字资产管理的计算机视觉
计算机视觉可以支持许多数字资产管理 (DAM) 方案。 DAM 是组织、存储和检索富媒体资产以及管理数字权利和权限的业务流程。 例如，公司可能希望基于可见徽标、面部、物体、颜色等来分组和标识图像。 或者，你可能希望自动[生成图像的标题](./Tutorials/storage-lab-tutorial.md)，并附加关键字，使其可供搜索。 有关使用认知服务、Azure 认知搜索和智能报表的一体式 DAM 解决方案，请参阅 GitHub 上的[知识挖掘解决方案加速器指南](https://github.com/Azure-Samples/azure-search-knowledge-mining)。 有关其他 DAM 示例，请参阅[计算机视觉解决方案模板](https://github.com/Azure-Samples/Cognitive-Services-Vision-Solution-Templates)存储库。
<!--Not available in MC: Optical Character Recognition (OCR)-->
## <a name="analyze-images-for-insight"></a>通过分析图像来获取见解
可以分析图像，以便提供有关视觉特性和特征的见解。 下表中的所有特性由[分析图像](https://dev.cognitive.azure.cn/docs/services/56f91f2d778daf23d8ec6739/operations/56f91f2e778daf14a499e1fa) API 提供。 按[快速入门](#next-steps)的说明开始操作。
### <a name="tag-visual-features"></a>标记视觉特性
根据数千个可识别对象、生物、风景和操作识别并标记图像中的视觉特征。 如果标记含混不清或者不常见，API 响应会做出提示，阐明上下文或标记。 标记并不局限于主体（如前景中的人员），还包括设置（室内或室外）、家具、工具、植物、动物、附件、小配件等。 [标记视觉特性](concept-tagging-images.md)
### <a name="detect-objects"></a>检测物体
对象检测类似于添加标记，但 API 返回应用于每个标记的边框坐标。 例如，如果图像包含狗、猫和人，检测操作将列出这些对象及其在图像中的坐标。 可以使用此功能进一步处理图像中各对象之间的关系。 当图像中有多个相同标记的实例时，还会通知你。 [检测物体](concept-object-detection.md)
### <a name="detect-brands"></a>检测品牌
根据一个包含数千全球徽标的数据库，确定图像或视频中的商业品牌。 可以使用此功能来执行特定的操作，例如，发现哪些品牌在社交媒体上最受欢迎，或者哪些品牌在社交产品排名上最靠前。 [检测品牌](concept-brand-detection.md)
### <a name="categorize-an-image"></a>对图像分类
使用具有父/子遗传层次结构的[类别分类](Category-Taxonomy.md)对整个图像进行标识和分类。 类别可单独使用或与我们的新标记模型结合使用。<br/>目前，英语是唯一可以对图像进行标记和分类的语言。 [对图像分类](concept-categorizing-images.md)
### <a name="describe-an-image"></a>描述图像
使用完整的句子，以人类可读语言生成整个图像的说明。 计算机视觉算法可根据图像中标识的对象生成各种说明。 分别对这些说明进行评估并生成置信度分数。 然后将返回置信度分数从高到低的列表。 [描述图像](concept-describing-images.md)
### <a name="detect-faces"></a>检测人脸
检测图像中的人脸，提供每个检测到的人脸的相关信息。 计算机视觉返回每个检测到的人脸的坐标、矩形、性别和年龄。<br/>计算机视觉提供了[人脸](/cognitive-services/face/)服务功能的子集。 可以使用“人脸”服务进行更详细的分析，如面部识别和姿势检测。 [检测人脸](concept-detecting-faces.md)
### <a name="detect-image-types"></a>检测图像类型
检测图像特征，例如图像是否为素描，或者图像是剪贴画的可能性。 [检测图像类型](concept-detecting-image-types.md)
### <a name="detect-domain-specific-content"></a>检测特定于域的内容
使用域模型来检测和标识图像中特定领域的内容，例如名人和地标。 例如，如果图像中包含人物，则计算机视觉可以使用针对名人的域模型来确定图像中检测到的人物是否为已知名人。 [检测特定领域的内容](concept-detecting-domain-content.md)
### <a name="detect-the-color-scheme"></a>检测颜色方案
分析图像中的颜色使用情况。 计算机视觉可以确定图像是黑白的还是彩色的，而对于彩色图像，又可以确定主色和主题色。 [检测颜色方案](concept-detecting-color-schemes.md)
### <a name="generate-a-thumbnail"></a>生成缩略图
分析图像的内容，生成该图像的相应缩略图。 计算机视觉首先生成高质量缩略图，然后通过分析图像中的对象来确定“感兴趣区域”。 然后，计算机视觉会裁剪图像以满足感兴趣区域的要求。 可以根据用户需求，使用与原始图像的纵横比不同的纵横比显示生成的缩略图。 [生成缩略图](concept-generating-thumbnails.md)
### <a name="get-the-area-of-interest"></a>获取感兴趣区域
分析图像内容，以返回“感兴趣区域”的坐标。 计算机视觉并没有裁剪图像和生成缩略图，而是返回该区域的边框坐标，因此，进行调用的应用程序可以根据需要修改原始图像。 [获取感兴趣区域](concept-generating-thumbnails.md#area-of-interest)
## <a name="moderate-content-in-images"></a>管理图像中的内容
可以使用计算机视觉[检测图像中的成人内容](concept-detecting-adult-content.md)，并返回不同分类的置信度分数。 可以在滑尺上设置标记内容的阈值，以适应首选项。
<!--Not available in MC: Optical Character Recognition (OCR)-->
## <a name="image-requirements"></a>图像要求
计算机视觉可以分析符合以下要求的图像：
- 图像必须以 JPEG、PNG、GIF 或 BMP 格式显示
- 图像的文件大小必须不到 4 兆字节 (MB)
- 图像的尺寸必须大于 50 x 50 像素
- 对于读取 API，图像的尺寸必须介于 50 x 50 和 10000 x 10000 像素之间。
## <a name="data-privacy-and-security"></a>数据隐私和安全性
与所有认知服务一样，使用计算机视觉服务的开发人员应该了解 Microsoft 针对客户数据的政策。 请参阅 Microsoft 信任中心上的[“认知服务”页面](https://www.trustcenter.cn)来了解详细信息。
## <a name="next-steps"></a>后续步骤
按照快速入门指南操作，完成计算机视觉入门：
- [快速入门：计算机视觉 .NET 客户端库](./quickstarts-sdk/client-library.md?pivots=programming-language-csharp)
- [快速入门：计算机视觉 Python 客户端库](./quickstarts-sdk/client-library.md?pivots=programming-language-python)
- [快速入门：计算机视觉 Java 客户端库](./quickstarts-sdk/client-library.md?pivots=programming-language-java) | 4,686 | CC-BY-4.0 |
# scp 命令
`scp`是 SSH 提供的一个客户端程序，用来在两台主机之间加密传送文件（即复制文件）。
## 简介
`scp`是 secure copy 的缩写，相当于`cp`命令 + SSH。它的底层是 SSH 协议，默认端口是22，相当于先使用`ssh`命令登录远程主机，然后再执行拷贝操作。
`scp`主要用于以下三种复制操作。
- 本地复制到远程。
- 远程复制到本地。
- 两个远程系统之间的复制。
使用`scp`传输数据时，文件和密码都是加密的，不会泄漏敏感信息。
## 基本语法
`scp`的语法类似`cp`的语法。
```bash
$ scp source destination
```
上面命令中，`source`是文件当前的位置，`destination`是文件所要复制到的位置。它们都可以包含用户名和主机名。
```bash
$ scp user@host:foo.txt bar.txt
```
上面命令将远程主机（`user@host`）用户主目录下的`foo.txt`，复制为本机当前目录的`bar.txt`。可以看到，主机与文件之间要使用冒号（`:`）分隔。
`scp`会先用 SSH 登录到远程主机，然后在加密连接之中复制文件。客户端发起连接后，会提示用户输入密码，这部分是跟 SSH 的用法一致的。
用户名和主机名都是可以省略的。用户名的默认值是本机的当前用户名，主机名默认为当前主机。注意，`scp`会使用 SSH 客户端的配置文件`.ssh/config`，如果配置文件里面定义了主机的别名，这里也可以使用别名连接。
`scp`支持一次复制多个文件。
```bash
$ scp source1 source2 destination
```
上面命令会将`source1`和`source2`两个文件，复制到`destination`。
注意，如果所要复制的文件，在目标位置已经存在同名文件，`scp`会在没有警告的情况下覆盖同名文件。
## 用法示例
**（1）本地文件复制到远程**
复制本机文件到远程系统的用法如下。
```bash
# 语法
$ scp SourceFile user@host:directory/TargetFile
# 示例
$ scp file.txt remote_username@10.10.0.2:/remote/directory
```
下面是复制整个目录的例子。
```bash
# 将本机的 documents 目录拷贝到远程主机，
# 会在远程主机创建 documents 目录
$ scp -r documents username@server_ip:/path_to_remote_directory
# 将本机整个目录拷贝到远程目录下
$ scp -r localmachine/path_to_the_directory username@server_ip:/path_to_remote_directory/
# 将本机目录下的所有内容拷贝到远程目录下
$ scp -r localmachine/path_to_the_directory/* username@server_ip:/path_to_remote_directory/
```
**（2）远程文件复制到本地**
从远程主机复制文件到本地的用法如下。
```bash
# 语法
$ scp user@host:directory/SourceFile TargetFile
# 示例
$ scp remote_username@10.10.0.2:/remote/file.txt /local/directory
```
下面是复制整个目录的例子。
```bash
# 拷贝一个远程目录到本机目录下
$ scp -r username@server_ip:/path_to_remote_directory local-machine/path_to_the_directory/
# 拷贝远程目录下的所有内容，到本机目录下
$ scp -r username@server_ip:/path_to_remote_directory/* local-machine/path_to_the_directory/
$ scp -r user@host:directory/SourceFolder TargetFolder
```
**（3）两个远程系统之间的复制**
本机发出指令，从远程主机 A 拷贝到远程主机 B 的用法如下。
```bash
# 语法
$ scp user@host1:directory/SourceFile user@host2:directory/SourceFile
# 示例
$ scp user1@host1.com:/files/file.txt user2@host2.com:/files
```
系统将提示你输入两个远程帐户的密码。数据将直接从一个远程主机传输到另一个远程主机。
## 配置项
**（1）`-c`**
`-c`参数用来指定文件拷贝数据传输的加密算法。
```bash
$ scp -c blowfish some_file your_username@remotehost.edu:~
```
上面代码指定加密算法为`blowfish`。
**（2）`-C`**
`-C`参数表示是否在传输时压缩文件。
```bash
$ scp -c blowfish -C local_file your_username@remotehost.edu:~
```
**（3）`-F`**
`-F`参数用来指定 ssh_config 文件，供 ssh 使用。
```bash
$ scp -F /home/pungki/proxy_ssh_config Label.pdf root@172.20.10.8:/root
```
**（4）`-i`**
`-i`参数用来指定密钥。
```bash
$ scp -vCq -i private_key.pem ~/test.txt root@192.168.1.3:/some/path/test.txt
```
**（5）`-l`**
`-l`参数用来限制传输数据的带宽速率，单位是 Kbit/sec。对于多人分享的带宽，这个参数可以留出一部分带宽供其他人使用。
```bash
$ scp -l 80 yourusername@yourserver:/home/yourusername/* .
```
上面代码中，`scp`命令占用的带宽限制为每秒 80K 比特位，即每秒 10K 字节。
**（6）`-p`**
`-p`参数用来保留修改时间（modification time）、访问时间（access time）、文件状态（mode）等原始文件的信息。
```bash
$ scp -p ~/test.txt root@192.168.1.3:/some/path/test.txt
```
**（7）`-P`**
`-P`参数用来指定远程主机的 SSH 端口。如果远程主机使用默认端口22，可以不用指定，否则需要用`-P`参数在命令中指定。
```bash
$ scp -P 2222 user@host:directory/SourceFile TargetFile
```
**（8）`-q`**
`-q`参数用来关闭显示拷贝的进度条。
```bash
$ scp -q Label.pdf mrarianto@202.x.x.x:.
```
**（9）`-r`**
`-r`参数表示是否以递归方式复制目录。
**（10）`-v`**
`-v`参数用来显示详细的输出。
```bash
$ scp -v ~/test.txt root@192.168.1.3:/root/help2356.txt
``` | 3,369 | MIT |
# WARNING: This repository is no longer maintained :warning:
> 本项目不再维护，如有需要，请邮件联系
# fis3-deploy-i18n-ejs
A FIS3 plugin to generate html file with i18n data on deploy stage.
[](https://github.com/tonyc726/fis3-deploy-i18n-ejs)
[](https://travis-ci.org/tonyc726/fis3-deploy-i18n-ejs)
[](https://github.com/semantic-release/semantic-release)
[](https://github.com/facebook/jest)
[](https://github.com/tonyc726/fis3-deploy-i18n-ejs)
> Thanks for [fis3-deploy-i18n-template](https://github.com/foio/fis3-deploy-i18n-template)
在前端的工程构建工具[FIS3](http://fis.baidu.com/)发布阶段，将所有拥有`isHtmlLike: true`的文件包含的多语言标记替换成指定内容，并生成文件的插件。
## 使用说明
### 如何安装
```shell
yarn add fis3-deploy-i18n-ejs -D
# OR
npm install fis3-deploy-i18n-ejs -D
```
### 默认配置
```javascript
/**
* @type {Object} DEFAULT_CONFIG - 插件默认配置
* @property {string} [open='<%'] - ejs模板的起始标识符
* @property {string} [close='%>'] - ejs模板的结束标识符
* @property {string} [dist='i18n/$lang/$file'] - 编译后的输出路径，相对于release的根目录，其中`$lang`代表语言文件夹，`$file`代表编译的文件
* @property {string} [templatePattern=''] - 需要做多语言处理文件subpath的glob规则，默认为所有html文件
* @property {string} [defaultLangName=''] - 默认语言名字，如果匹配默认语言，该语言的输出将自动去除dist中的`$lang`部分
* @property {string} [i18nPattern='translations/*.{js,json}'] - 多语言文件的glob规则
* @property {string} [ignorePattern=''] - 需要忽略编译的glob规则
* @property {string} [noKeepSubPathPattern=''] - 不需要保持原有目录结构输出的glob规则
* @property {function} [onLangFileParse=noop] - 在读取多语言文件后的自定义处理函数，其返回值会与当前读取的文件内容合并
*/
{
open: '<%',
close: '%>',
dist: 'i18n/$lang/$file',
templatePattern: '',
defaultLangName: '',
i18nPattern: 'translations/*.{js,json}',
ignorePattern: '',
noKeepSubPathPattern: '',
/**
* @desc 多语言文件处理函数
* @param {string} i18nFileJSONClone - 语言文件内容(JSON格式)的拷贝对象
* @param {string} fileLangName - 当前语言文件对应的语言名字
* @param {string} defaultLangName - 默认语言名字
* @return {object} 处理以后的文件内容
*
* @example
* onLangFileParse(i18nFileJSONClone, fileLangName, defaultLangName) {},
*/
onLangFileParse: noop,
}
```
## 参考示例
> 具体的实验可以参考这个项目[fis3-examples](https://github.com/tonyc726/fis3-examples)。
### 项目目录结构
```
# project root path
│
├── i18n-folder # 文件名及语言名
│ ├── en.json
│ ├── zh.json
│ └── ...
│
├── template-folder
│ ├── index.html
│ ├── ...
│ └── sub-folder
│ ├── detail.html
│ └── ...
│
├── fis-conf.js
│
└── package.json
```
### 配置`fis-conf.js`中`fis3-deploy-i18n-ejs`相关的内容
```javascript
// ------ translations ------
fis.match('/i18n-folder/**', {
release: false,
});
// ------ templates ------
fis.match('/template-folder/(**)/(*.html)', {
release: '/$1/$2',
});
// ------ deploy ------
fis.match('**', {
deploy: [
fis.plugin('i18n-folder', {
open: '<%',
close: '%>',
dist: '$lang/$file',
defaultLangName: 'zh',
templatePattern: '',
i18nPattern: 'i18n-folder/*.json',
ignorePattern: '',
noKeepSubPathPattern: '',
onLangFileParse() {},
}),
],
});
```
### `i18n-folder`中的文件内容示例
i18n-folder/en.json
```
{
"hello": "hello",
"world": "world"
}
```
i18n-folder/zh.json
```
{
"hello": "你好",
"world": "世界"
}
```
### `template-folder`待转换的模板文件夹
#### `template-folder/index.html`
```
<html>
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<p><%= hello %></p>
<p><%= world %></p>
</body>
</html>
```
#### `template-folder/sub-floder/detail.html`
```
<html>
<head>
<meta charset="UTF-8">
<title>detail</title>
</head>
<body>
<p><%= hello %></p>
<p><%= world %></p>
</body>
</html>
```
### 输出结果
#### 语言为`zh`的输出结果：
> 默认语言为`zh`，所以输出的文件去除`$lang`层级的目录，即
- `dist/index.html`
```
<html>
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<p>你好</p>
<p>世界</p>
</body>
</html>
```
- `dist/sub-folder/detail.html`
```
<html>
<head>
<meta charset="UTF-8">
<title>detail</title>
</head>
<body>
<p>你好</p>
<p>世界</p>
</body>
</html>
```
#### 语言为`en`的输出结果：
- `dist/en/index.html`
```
<html>
<head>
<meta charset="UTF-8">
<title>index</title>
</head>
<body>
<p>hello</p>
<p>world</p>
</body>
</html>
```
- `dist/en/sub-folder/detail.html`
```
<html>
<head>
<meta charset="UTF-8">
<title>detail</title>
</head>
<body>
<p>hello</p>
<p>world</p>
</body>
</html>
```
## 参考
- [node-project-kit](https://github.com/tonyc726/node-project-kit) - 快速创建项目的模板
- [glob](https://github.com/isaacs/node-glob) - 使用 glob 语法获取匹配文件的工具
- [ejs](https://www.npmjs.com/package/ejs) - 模板引擎
## License
Copyright © 2017-present. This source code is licensed under the MIT license found in the
[LICENSE](https://github.com/tonyc726/fis3-deploy-i18n-ejs/blob/master/LICENSE) file.
---
Made by Tony ([blog](https://itony.net)) | 5,224 | MIT |
# 2021-07-15
共 15 条
<!-- BEGIN ZHIHUVIDEO -->
<!-- 最后更新时间 Thu Jul 15 2021 22:07:12 GMT+0800 (China Standard Time) -->
1. [买一整只乳猪回家烤，烤到手腕酸得动不了……](https://www.zhihu.com/zvideo/1360916447506702336)
1. [外交部回应 BBC 记者非正常离任：他跑什么呢](https://www.zhihu.com/zvideo/1360702099882409984)
1. [老饭骨糖醋鱼 + 万能糖醋汁分享，毫无保留，就是实在](https://www.zhihu.com/zvideo/1360648280272162818)
1. [美国女子强撸一只狐狸,狐狸被撸得哈哈大笑](https://www.zhihu.com/zvideo/1359825254311931904)
1. [外交部记者会现场，BBC 制片人来发难，华春莹现场反驳打脸](https://www.zhihu.com/zvideo/1360964384177623042)
1. [它将超越比特币，2 年白嫖 1500 万用户！](https://www.zhihu.com/zvideo/1360902623068131328)
1. [我的减肥心得](https://www.zhihu.com/zvideo/1360900933279346688)
1. [沙盘推演：长征分裂危机！德胜大大的至暗时刻！北上南下之争](https://www.zhihu.com/zvideo/1360915311202476032)
1. [德国大叔在长沙为聋哑人开了一家无声面包店！给他 1 万个赞！](https://www.zhihu.com/zvideo/1360704485145411584)
1. [中伊协定签署 - 布热津斯基 97 年的预言成真](https://www.zhihu.com/zvideo/1360906395223638016)
1. [杨紫粉丝拒绝欢瑞：演过《香蜜沉沉烬如霜》的杨紫，有更高的追求](https://www.zhihu.com/zvideo/1360670763129815040)
1. [自制自助饮料机，清凉奶爸牌，给娃一个能玩的「冷饮站」](https://www.zhihu.com/zvideo/1360627701703847936)
1. [米莱狄战令限定皮肤视频爆料！](https://www.zhihu.com/zvideo/1360697360184569856)
1. [衡东县鹤祥村陈博荣立一等功。活着的一等功超人般的存在！](https://www.zhihu.com/zvideo/1360498323309367296)
1. [叶刘淑仪质问 BBC 主持人：你去过新疆吗，你亲眼看到压迫了吗？](https://www.zhihu.com/zvideo/1360887673188614145)
<!-- END ZHIHUVIDEO --> | 1,343 | MIT |
---
title: Azure オンデマンド メディア エンコーダーの概要 | Microsoft Docs
description: Azure Media Services には、クラウド内のメディア エンコーディングに使用できる複数のオプションが用意されています。 この記事では、Azure オンデマンド メディア エンコーダーの概要を説明します。
services: media-services
documentationcenter: ''
author: juliako
manager: femila
editor: ''
ms.service: media-services
ms.workload: media
ms.tgt_pltfrm: na
ms.devlang: na
ms.topic: article
ms.date: 06/25/2019
ms.author: juliako
ms.openlocfilehash: d6e64ed7476b3f9fd5427c2f3d26855bc4d5f97d
ms.sourcegitcommit: 77afc94755db65a3ec107640069067172f55da67
ms.translationtype: HT
ms.contentlocale: ja-JP
ms.lasthandoff: 01/22/2021
ms.locfileid: "98695765"
---
# <a name="overview-of-azure-on-demand-media-encoders"></a>Azure オンデマンド メディア エンコーダーの概要
[!INCLUDE [media services api v2 logo](./includes/v2-hr.md)]
> [!NOTE]
> Media Services v2 には新機能は追加されません。 <br/>最新のバージョンである [Media Services v3](../latest/index.yml) をご確認ください。 また、[v2 から v3 への移行ガイダンス](../latest/migrate-v-2-v-3-migration-introduction.md)を参照してください。
Azure Media Services には、クラウド内のメディア エンコーディングに使用できる複数のオプションが用意されています。
Media Services を使い始める場合、コーデックとファイル形式の違いを理解することが重要です。
コーデックは圧縮/展開アルゴリズムを実装するソフトウェアで、ファイル形式は圧縮されたビデオを保持するコンテナーです。
Media Services には動的パッケージ化機能があり、アダプティブ ビットレート MP4 またはSmooth Streamingでエンコードされたコンテンツを、Media Services でサポートされるストリーミング形式 (MPEG DASH、HLS、Smooth Streaming) でそのまま配信できます。つまり、これらのストリーミング形式に再度パッケージ化する必要がありません。
Media Services アカウントの作成時に、**既定** のストリーミング エンドポイントが **停止** 状態でアカウントに追加されます。 コンテンツのストリーミングを開始し、ダイナミック パッケージと動的暗号化を活用するには、コンテンツのストリーミング元のストリーミング エンドポイントが **実行中** 状態である必要があります。 ストリーミング エンドポイントの課金は、エンドポイントが **実行中** 状態のときに発生します。
Media Services では、次のオンデマンド エンコーダーがサポートされています。
* [メディア エンコーダー スタンダード](media-services-encode-asset.md#media-encoder-standard)
この記事には、オンデマンド メディア エンコーダーの簡単な説明と、詳しい情報を提供する記事のリンクが含まれています。
既定では、1 つの Media Services アカウントにつき、同時に 1 つのアクティブなエンコーディング タスクを実行できます。 エンコード ユニットを予約して、複数のエンコード タスク (購入したエンコード予約ユニットごとに 1 つ) を同時に実行できます。 詳細については、「 [エンコード ユニットの拡大/縮小](media-services-scale-media-processing-overview.md)」を参照してください。
## <a name="media-encoder-standard"></a>メディア エンコーダー スタンダード
### <a name="how-to-use"></a>使用方法
[メディア エンコーダー スタンダードを使用したエンコード方法](media-services-dotnet-encode-with-media-encoder-standard.md)
### <a name="formats"></a>形式
[形式とコーデック](media-services-media-encoder-standard-formats.md)
### <a name="presets"></a>プリセット
Media Encoder Standard は、 [ここ](./media-services-mes-presets-overview.md)で説明されているエンコーダーのプリセット文字列のいずれかを使用して構成されます。
### <a name="input-and-output-metadata"></a>入力メタデータと出力メタデータ
エンコーダーの入力メタデータの説明は [ここ](media-services-input-metadata-schema.md)にあります。
エンコーダーの出力メタデータの説明は [ここ](media-services-output-metadata-schema.md)にあります。
### <a name="generate-thumbnails"></a>サムネイルを生成する
詳細については、「 [サムネイルを生成する](media-services-advanced-encoding-with-mes.md)」をご覧ください。
### <a name="trim-videos-clipping"></a>動画をトリミングする (クリッピング)
詳細については、「 [動画をトリミングする (クリッピング)](media-services-advanced-encoding-with-mes.md#trim_video)」をご覧ください。
### <a name="create-overlays"></a>オーバーレイを作成する
詳細については、「 [オーバーレイを作成する](media-services-advanced-encoding-with-mes.md#overlay)」をご覧ください。
### <a name="see-also"></a>関連項目
[Media Services ブログ](https://azure.microsoft.com/blog/2015/07/16/announcing-the-general-availability-of-media-encoder-standard/)
### <a name="known-issues"></a>既知の問題
入力ビデオにクローズド キャプションが含まれない場合でも、出力アセットには空の TTML ファイルが含まれます。
## <a name="media-services-learning-paths"></a>Media Services のラーニング パス
[!INCLUDE [media-services-learning-paths-include](../../../includes/media-services-learning-paths-include.md)]
## <a name="provide-feedback"></a>フィードバックの提供
[!INCLUDE [media-services-user-voice-include](../../../includes/media-services-user-voice-include.md)]
## <a name="related-articles"></a>関連記事
* [Media Encoder Standard のプリセットをカスタマイズし、高度なエンコード タスクを実行する](media-services-custom-mes-presets-with-dotnet.md)
* [クォータと制限](media-services-quotas-and-limitations.md)
<!--Reference links in article-->
[1]: https://azure.microsoft.com/pricing/details/media-services/ | 3,946 | CC-BY-4.0 |
本文適用於 App Service (Web Apps、API Apps、Mobile Apps、邏輯應用程式)；對於雲端服務，請參閱<a href="/develop/net/common-tasks/custom-dns/">在 Azure 中設定自訂網域名稱</a>。
> [AZURE.NOTE]**如需「使用流量管理員將流量負載平衡到 Web 應用程式」的指示**，請使用本文頂端的選取器來選取流量管理員專屬步驟。
>
> **自訂網域名稱無法搭配免費的 Web 應用程式使用**。您必須將 Web 應用程式設定為 [**共用**]、[**基本**] 或 [**標準**] 模式，但這可能會變更您的訂用帳戶費用。如需詳細資訊，請參閱 <a href=/pricing/details/web-sites/">Web Apps 定價詳細資料</a>。
<!---HONumber=Oct15_HO3--> | 408 | CC-BY-3.0 |
## Taro-start
Taro 小程序通用模板， 开箱即用
## 安装、开发、构建
```bash
# install with yarn
yarn install
# 开发
npm run dev
# 构建
npm run build:weapp
# 构建指定环境
# npm run build:weapp -- --env=$value
npm run build:weapp -- --env=test
```
## 快速创建页面/组件
```bash
# 页面
npm run create:page mine
npm run create:page order/list
# 组件
npm run create:comp button
```
## 目录结构
```bash
.
├─ config # 脚手架配置
│ ├─ dev.js
│ ├─ index.js
│ └─ prod.js
├─ dist # 项目输出目录
├─ src
│ ├─ analysis # 第三方统计分析
│ ├─ api # 请求接口统一管理
│ ├─ assets # 资源统一管理
│ │ └─ images # 图片资源
│ │ ├─ tabbar # tabbar 的图标
│ │ └─ ...
│ ├─ components # 组件
│ │ ├─ ... # 组件入口文件
│ │ └─ index.ts
│ ├─ config # 项目开发配置
│ │ └─ index.ts
│ ├─ constants # 公用常量统一管理
│ │ ├─ events # 自定义时间 CODE 的枚举
│ │ └─ store-key.ts # 本地存储 KEY
│ ├─ hooks # 自定义 hooks
│ │ ├─ check-login.ts # 操作前校验是否登录
│ │ ├─ geocoder.ts # 地理信息获取
│ │ ├─ index.ts # 自定义 hooks 入口文件
│ │ ├─ input.ts # 监听处理输入值
│ │ └─ list.ts # 列表
│ ├─ models # 公用、业务模块接口定义
│ ├─ pages # 页面目录. 尽量按模块划分
│ │ ├─ account
│ │ │ ├─ login
│ │ │ └─ welcome
│ │ ├─ home
│ │ ├─ mine
│ │ └─ started
│ ├─ reducers # redux 状态管理的 reducers
│ │ ├─ account.ts # 帐号信息
│ │ └─ debug.ts # 调试
│ ├─ request
│ │ ├─ index.ts # 网络请求函数封装
│ │ ├─ interceptors.ts # 请求、响应拦截
│ │ └─ type.ts # 相关类型、接口定义
│ ├─ router
│ │ ├─ index.ts # 路由相关函数 & 页面路径配置
│ │ └─ path.ts # 页面路径配置
│ ├─ store # 全局状态
│ │ └─ index.ts # 入口文件
│ ├─ styles
│ │ ├─ index.scss # 样式入口文件
│ │ └─ var.scss # 全局样式变量
│ ├─ sub-pages # 分包
│ ├─ uma # 友盟统计
│ ├─ utils # 工具类
│ │ ├─ verification # 表单校验类
│ │ ├─ index.t # 常用工具函数
│ │ └─ qqmap-wx-jssdk.js # 腾讯地图 SDK
│ ├─ app.scss # 全局样式
│ ├─ app.tsx # 项目入口文件
│ ├─ sitemap.json # 站点配置. 面向爬虫
│ └─ index.html # H5 的开始文件
├─ .eslintignore # eslint 校验忽略规则配置
├─ .eslintrc # eslint 校验配置
├─ package.json
├─ project.config.json # 项目配置
├─ README.md
├─ tsconfig.json
└─ yarn.lock
```
## 推荐规范
### 命名
**文件后缀**
普通 JS 文件的后缀为 `.ts`, 页面和组件文件的后缀为 `.tsx`
**目录、文件命名**
全部采用小写方式， 以中划线分隔。
例: scripts, retina-sprites.scss, data.js, actionsheet.ts, actionsheet.tsx
**css 变量命名规范**
统一使用kebab-case(小写短横线)命名规范。
```html
<!-- tsx 文件 -->
<view className="app-home-taro">
</view>
<!-- 样式文件 -->
.app-home-taro {}
```
**js 变量命名规范**
统一使用camelCase（小写驼峰式）命名规范。
```js
let myName = 'zhangsanfeng';
```
### 属性书写
- 少于2个, 一行书写
- 超过2个则每个写一行, 最后一个尖括号占一行
```html
<!-- 少于 2 个 -->
<MenuItem :url="item.url" :actived="item.actived"></MenuItem>
<!-- 3 个以上 -->
<MenuItem
:key="item.id"
:url="item.url"
:isLast="item.isLast"
:actived="item.actived"
>{item.label}</MenuItem>
```
## 组件组织
- 基础 UI 组件统一放在 `src/components`, 并且通过 `src/components` 入口文件对外导出
- 页面业务组件放在对于页面下的 components 文件.
## 生命周期的对比
| 小程序 | Taro |
|-|-:|
| Page.onLoad | useEffect |
| onShow | useDidShow |
| onHide | useDidHide |
| onReady | useEffect |
| onUnload | useEffect |
| onError | ? |
| App.onLaunch | useEffect |
| Component.created | useEffect |
| attached | useEffect |
| ready | useEffect |
| detached | useEffect |
| moved | 保留 | | 3,818 | MIT |
---
title: "Swift で開発した Web アプリケーションを Amazon EC2 Container Services (ECS) にデプロイする"
description: "#swiftlang で開発した Web アプリケーションを Amazon EC2 Container Services (ECS) にデプロイする方法について調査しました"
date: 2016-03-04 22:50
public: true
tags: circleci, swift, swifton, amazon, aws, ecs
alternate: true
ogp:
og:
image:
"": 2016-03-04-swift-webapp-on-ecs/serverspec.png
type: image/png
width: 732
height: 481
---
## TL;DR
Swift で Web アプリケーションを開発するのは、とても楽しいです 🤘
[Amazon EC2 Container Services] にもデプロイして稼働させることができるので、軽量な [Docker] イメージを自動的にビルドし、高速にデプロイする方法を調査しました。
こちらにサンプルプロジェクトを公開しましたので、よかったら参考にしてみて下さい :point_down:
- https://github.com/ngs/Swifton-TodoApp
- https://hub.docker.com/r/atsnngs/docker-swifton-example/
- https://circleci.com/gh/ngs/Swifton-TodoApp
また、こちらの内容を、弊社 Oneteam のミーティングスペースで行った [Tokyo Server-Side Swift Meetup] で発表しました。
参照: https://one-team.com/blog/ja/2016-03-07-swift-meetup/
以下は、その資料です。
<script async class="speakerdeck-embed" data-id="4b85bc7092b342318e4fcf76f62170e6" data-ratio="1.33333333333333" src="//speakerdeck.com/assets/embed.js"></script>
READMORE
## Swift の Web フレームワーク
Swift 言語が [オープンソース] になってから、いくつかの Web アプリケーションフレームワークがでてきました。
- [Kitsura](https://developer.ibm.com/swift/products/kitura/)
- [Nest](https://github.com/nestproject/Nest)
- [Perfect](http://perfect.org/)
- [Slimane](https://github.com/noppoMan/Slimane)
- [Swifton]
## Swifton
どれが一番良いのかは、まだ判断できていませんが、今回は Swift で作った Ruby on Rails 風のフレームワーク [Swifton] を使って、サンプルアプリケーションを動かしてみました。
インターフェイスは、とても簡単に理解できます:
```swift
import Swifton
import Curassow
class MyController: ApplicationController {
override init() {
super.init()
action("index") { request in
return self.render("Index")
// renders Index.html.stencil in Views directory
}
}
}
let router = Router()
router.get("/", MyController()["index"])
serve { router.respond($0) }
```
## Swifton TodoApp
Swifton は、ToDo 管理のサンプルアプリケーションを公開しています: [necolt/Swifton-TodoApp]
このプロジェクトは、既に Dockerfile と Heroku の設定 (`app.json` と `Procfile`) を含んでいます。
これらは、問題なく動作し、これを元に開発が始められます。ただ、本番運用を考慮すると、Heroku ではなく、なじみのある、Amazon EC2 Container Service (ECS) を使いたいと思いました。
## 大きな Docker イメージ
前途のとおり、このプロジェクトは Dockerfile を含んでおり、ECS でも動作が可能な Docker イメージをビルドすることができます。
しかし、このイメージには、コンテナ内部で Swift ソースコードをビルドするための依存ライブラリが含まれており、イメージサイズで 326 MB、仮想サイズで 893.2 MB もの容量を消費します。
```
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
<none> <none> sha256:c35f9 30 seconds ago 893.2 MB
```
参照: https://hub.docker.com/r/atsnngs/docker-swifton-example/tags/
そこで、バイナリは Docker ビルドの外で行い、最小限の資材で構成するイメージを CircleCI で構築することを、ためしてみました。
## CircleCI の Ubuntu 14.04 Trusty コンテナ
Swift ランタイムは、Trusty Ubuntu (14.04) でビルドされた、開発スナップショットを使います。
https://swift.org/download/#latest-development-snapshots
それに合わせて、パブリックベータとして提供されている、CircleCI の Trusty コンテナを採用しました。
http://blog.circleci.com/trusty-image-public-beta/
## 継続ビルドのための必須ソフトウェア
まず、`swift build` を実行するために、以下のソフトウェアをインストールする必要があります。
```sh
sudo apt-get install libicu-dev clang-3.6 jq
# jq は AWS CLI の応答を調査するために使います。
sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-3.6 100
sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-3.6 100
# See: https://goo.gl/hSfhjE
```
## Swifton アプリケーションを実行するための資材
- Swift ランタイムの共有ライブラリ: `usr/lib/swift/linux/*.so`
- アプリケーションのバイナリ
- Stencil テンプレート
上記が必要なので、不要なファイルは `.dockerignore` ファイルで無視し、Docker イメージのビルド時間を節約します。
```
*
!Views
!swift/usr/lib/swift/linux/*.so
!.build/release/Swifton-TodoApp
```
## Dockerfile
Dockerfile はこんな感じです。[オリジナル] に比べて、とても簡素です。
```sh
FROM ubuntu:14.04
MAINTAINER a@ngs.io
RUN apt-get update && apt-get install -y libicu52 libxml2 curl && \
apt-get clean && \
rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
ENV APP_DIR /var/www/app
RUN mkdir -p ${APP_DIR}
WORKDIR ${APP_DIR}
ADD . ${APP_DIR}
RUN ln -s ${APP_DIR}/swift/usr/lib/swift/linux/*.so /usr/lib
EXPOSE 8000
CMD .build/release/Swifton-TodoApp
```
この Dockerfile によって、イメージサイズを 88 MB、仮想サイズを 245.8 MB (27.5%) へ削減することができました。
```
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
<none> <none> sha256:0d31d 30 seconds ago 245.8 MB
```
## Docker イメージをテストする
[Serverspec] を使って、Docker イメージを安心して利用できるよう、テストします。
以下の記事に、CircleCI で Docker コンテナをテストする、いくつかのコツと、モンキーパッチを紹介しています。
https://ja.ngs.io/2015/09/26/circleci-docker-serverspec/
こんな感じで、ToDo アプリのテストを書きました:
```ruby
require 'spec_helper'
describe port(8000) do
it { should be_listening }
end
describe command('curl -i -s -H \'Accept: text/html\' http://0.0.0.0:8000/') do
its(:exit_status) { is_expected.to eq 0 }
its(:stdout) { is_expected.to contain 'HTTP/1.1 200 OK' }
its(:stdout) { is_expected.to contain '<h1>Listing Todos</h1>' }
end
1.upto(2) do|n|
describe command("curl -i -s -H \'Accept: text/html\' http://0.0.0.0:8000/todos -d \'title=Test#{n}\'") do
its(:exit_status) { is_expected.to eq 0 }
its(:stdout) { is_expected.to contain 'HTTP/1.1 302 FOUND' }
its(:stdout) { is_expected.to contain 'Location: /todos' }
end
end
describe command('curl -i -s -H \'Accept: text/html\' http://0.0.0.0:8000/todos') do
its(:exit_status) { is_expected.to eq 0 }
its(:stdout) { is_expected.to contain 'HTTP/1.1 200 OK' }
its(:stdout) { is_expected.to contain '<h1>Listing Todos</h1>' }
its(:stdout) { is_expected.to contain '<td>Test1</td>' }
its(:stdout) { is_expected.to contain '<td>Test2</td>' }
its(:stdout) { is_expected.to contain '<td><a href="/todos/0">Show</a></td>' }
its(:stdout) { is_expected.to contain '<td><a href="/todos/1">Show</a></td>' }
end
```
## ECS にデプロイする
ECS にデプロイするまえに、Docker イメージをレジストリに転送 (push) する必要があります。
```sh
$ docker tag $DOCKER_REPO "${DOCKER_REPO}:b${CIRCLE_BUILD_NUM}"
$ docker push "${DOCKER_REPO}:b${CIRCLE_BUILD_NUM}"
```
ここでは、詳しい、ECS 環境の構築方法は解説しません、[AWS ECS ドキュメンテーション] を参照して下さい。
[デプロイスクリプト]は、ビルドプロセスのデプロイステップの中で実行されます。
このスクリプトは、以下の操作を [AWS コマンドライン インターフェイス] を用いて行います。
- タスク定義 (Task Definition) JSON を [ERB テンプレート] からレンダリングします。
- タスク定義を、更新、もしくは作成し、`swifton-example-production:123` の様な形式の最新リビジョンを取得します。
- サービスを、新しいタスク定義で更新、もしくは、それを用いて作成します。
デプロイすると、ウェブブラウザで、以下の様に ToDo サンプルアプリケーションが確認できると思います。
ぜひ、Swift での Web アプリケーション開発を楽しんで下さい！もし何かあれば、フィードバックよろしくお願いします。
https://github.com/ngs/Swifton-TodoApp
[swifton]: https://github.com/necolt/Swifton
[オープンソース]: https://github.com/apple/swift
[オリジナル]: https://github.com/necolt/Swifton-TodoApp/blob/master/Dockerfile
[necolt/swifton-todoapp]: https://github.com/necolt/Swifton-TodoApp
[amazon ec2 container services]: https://aws.amazon.com/ecs/
[docker]: https://www.docker.com/
[serverspec]: http://serverspec.org/
[デプロイスクリプト]: https://github.com/ngs/Swifton-TodoApp/blob/master/script/ecs-deploy-services.sh
[erb テンプレート]: https://github.com/ngs/Swifton-TodoApp/blob/master/script/ecs-deploy-services.sh
[aws ecs ドキュメンテーション]: http://docs.aws.amazon.com/ja_jp/AmazonECS/latest/developerguide/ECS_GetStarted.html
[aws コマンドライン インターフェイス]: https://aws.amazon.com/cli/
[tokyo server-side swift meetup]: http://connpass.com/event/27667/ | 7,358 | MIT |
---
layout: post
title: "「ベルーナオリジナルおせち舞」など10月22日より本格販売"
header_image: "/img/belluna_header.jpg"
header_image_alt: "ベルーナおせち"
thumbnail: "http://www28.a8.net/svt/bgt?aid=141025515268&wid=003&eno=01&mid=s00000009463001011000&mc=1"
date: 2014-10-25 22:20:00 +0900
updatedDate: 2014-10-25 22:20:00 +0900
categories: recommend
keywords: "ベルーナ"
---
どうも。管理人です。
本日のおせちニュースはこちら。
<!-- more -->
## [ベルーナグルメ友の会、「ベルーナオリジナルおせち舞」など10月22日より本格販売 / CNET Japan](http://japan.cnet.com/release/30084367/)
株式会社ベルーナが展開するグルメ専門通販「ベルーナグルメ友の会」では、冷凍ではなく冷蔵でお届けする『ベルーナオリジナルおせち舞（冷蔵和三段重）』など、2015年正月に向けたおせち商品を10月22日より本格販売を開始するようです。
通販でのおせちといえば、冷凍のものでお届けされてそのまま常温などで自宅で解凍するというのが主流でありますが、最近では冷蔵でお届けされて、解凍の手間いらずといったものも増えているようですね。
ベルーナグルメ友の会では、2015年のお正月に向けてオリジナルの生おせち『ベルーナオリジナルおせち舞（冷蔵和三段重）』を販売とのことです。
<a href="http://px.a8.net/svt/ejp?a8mat=2BYNZF+4FK8G2+210M+BWGDT&a8ejpredirect=http%3A%2F%2Fbelluna-gourmet.com%2F02%2F012101%2Fpg%2Fosechi%2Fyui%2F" target="_blank">
<img border="0" alt="" src="http://im.belluna.jp/gourmet/02/012101/pg/osechi/140829/yui_1.jpg"></a>
<img border="0" width="1" height="1" src="http://www13.a8.net/0.gif?a8mat=2BYNZF+4FK8G2+210M+BWGDT" alt="">
<a href="http://px.a8.net/svt/ejp?a8mat=2BYNZF+4FK8G2+210M+BWGDT&a8ejpredirect=http%3A%2F%2Fbelluna-gourmet.com%2F01%2F012101%2Fd%2FNE164%2F5000785%2Fgoods_detail%2F" target="_blank">
<img border="0" alt="" src="http://im.belluna.jp/gourmet/ph/G/7498/437498/DLARGE.JPG"></a>
<img border="0" width="1" height="1" src="http://www10.a8.net/0.gif?a8mat=2BYNZF+4FK8G2+210M+BWGDT" alt="">
<a href="http://px.a8.net/svt/ejp?a8mat=2BYNZF+4FK8G2+210M+BWGDT&a8ejpredirect=http%3A%2F%2Fbelluna-gourmet.com%2F01%2F012101%2Fd%2FNE164%2F5000798%2Fgoods_detail%2F" target="_blank">
<img border="0" alt="" src="http://im.belluna.jp/gourmet/ph/G/7504/437504/DLARGE.JPG"></a>
<img border="0" width="1" height="1" src="http://www10.a8.net/0.gif?a8mat=2BYNZF+4FK8G2+210M+BWGDT" alt="">
<a href="http://px.a8.net/svt/ejp?a8mat=2BYNZF+4FK8G2+210M+BWGDT&a8ejpredirect=http%3A%2F%2Fbelluna-gourmet.com%2F01%2F012101%2Fd%2FNE164%2F5000798%2Fgoods_detail%2F" target="_blank">
≪早期特典付≫ベルーナオリジナルおせち特大５０ｃｍ和洋中一段重【１２月３１日お届け】
</a>
こちらの「ベルーナオリジナルおせち特大５０ｃｍ和洋中一段重」など圧巻ですね！
<a href="http://px.a8.net/svt/ejp?a8mat=2BYNZF+4FK8G2+210M+64Z8X" target="_blank">
<img border="0" width="125" height="125" alt="" src="http://www23.a8.net/svt/bgt?aid=141025515268&wid=003&eno=01&mid=s00000009463001031000&mc=1"></a>
<img border="0" width="1" height="1" src="http://www18.a8.net/0.gif?a8mat=2BYNZF+4FK8G2+210M+64Z8X" alt="">
ではでは。 | 2,619 | MIT |
---
title: css 动画性能浅谈
date: 2018-03-31
author: Stick
tag: CSS
banner: /img/2.jpg
meta:
- name: description
content:
- name: keywords
content: css css3 动画性能 回流 重绘 前端
---
## 场景
图中的两种动画有什么区别
<!-- more -->
## 分析
第一种动画并不会动, 因为 `top`, `left` 值并没有发生变化
第二种动画会动, 因为 `translate` 是计算偏移值
那如果我们把第一种动画改成下面这样
```css
@keyframes move {
50% {
top: 10px;
left: 30px;
}
}
```
**现在这两种动画还有什么区别呢? 哪个性能好?**
我们先了解两个概念,`回流(reflow)` `重绘(repaint)`
`reflow`: 当元素的几何属性(`height`, `width` 等等)发生变化时, 相关元素都会重新渲染, 这个过程叫做回流
`repaint`: 当元素只需要更新样式属性, 而不影响布局的时候(比如换个背景色), 页面只会重绘这单个元素, 这个过程叫做重绘
那么我们看上面的场景, 第一种动画, 在发生回流操作, 第二种动画只是在重绘, 当然这个场景, 元素是绝对定位, 只会引起自己的重绘, 不会引起页面其他部分重新布局.
当我们设计一个动画的时候, 最好使用 `transform` 去实现, 因为 `transform` 不会发生回流, 我们还可以为此开启硬件加速, 当发生 `3D` 转换的时候, 浏览器会开启硬件加速, 我们可以为此做一个小 trick
```css
@keyframes move {
50% {
transform: translate(100px, 300px, 0)
/* 引起 3d 变换, 开启硬件加速 */
}
}
```
::: tip
硬件加速的开启也是比较耗性能的, 移动端尤其明显, 当我们开启硬件加速的时候, 最好为元素人为加上较高的 `z-index` 属性, 原因见[https://w3ctrain.com/2015/12/15/smoother-animation/](https://w3ctrain.com/2015/12/15/smoother-animation/)
::: | 1,202 | MIT |
---
layout: post
title: "老狗与小狗——陈丹青和木心的故事"
date: 2020-09-13T07:41:06.000Z
author: 老虎庙私家电视台
from: https://www.youtube.com/watch?v=Sh59kz9vWPg
tags: [ 老虎庙 ]
categories: [ 老虎庙 ]
---
<!--1599982866000-->
[老狗与小狗——陈丹青和木心的故事](https://www.youtube.com/watch?v=Sh59kz9vWPg)
------
<div>
陈丹青获2015年度公和人物奖。本片是在乌镇举办的颁奖典礼上陈丹青发表的获奖感言。历届公和人物获奖名单如下：2012年度公和人物：张平宜、寇延丁、加措活佛、何三畏、张思之2013年度公和人物：（暂停一期）2014年度公和人物：卢百可（美）、张世和（老虎庙）、应宪、翁永凯2015年度公和人物：陈丹青2016年度公和人物：陈浩武
</div> | 449 | MIT |
---
title: 开发简介
icon: debug
date: 2019-12-27
category: 基础
---
开发是根据用户要求建造出合理程序的过程。过程一般是用某种程序设计语言来实现的。通常采用开发工具可以进行开发。
<!-- more -->
## 小团队的具体分工
对于小团队而言，经典的划分主要还分为三个板块
### UI 设计
UI 即 User Interface (用户界面) 的简称。泛指用户的操作界面。UI 设计主要指界面的样式，美观程度。而使用上，对软件的人机交互、操作逻辑、界面美观的整体设计则是同样重要的另一个门道。
UI 可以让软件变得有个性有品味，还要让软件的操作变得舒适、简单、自由，充分体现软件的定位和特点。
::: tip
在开发中，UI 设计主要指**界面元素设计**和**交互设计**两部分。
:::
### 前端开发
前端开发是创建 Web 页面或 App 等前端界面呈现给用户的过程。前端开发通过 HTML，CSS 及 JavaScript 以及衍生出来的各种技术、框架、解决方案，来实现互联网产品的用户界面交互。
::: tip
在开发中，前端开发直接**使用 UI 设计提供的素材**并参照 UI 设计提供的**界面图与交互逻辑**对其设想进行**实现**。
:::
### 后端开发
根据正在处理的应用程序的大小和范围，后端开发人员要做的事情有很大的不同。在 Web 开发世界中，大多数后端开发人员从事于构建他们正在工作的应用程序背后的实际逻辑。其负责是网站后台逻辑的设计和实现还有用户及网站的数据的保存和读取。
::: tip
在开发中，后端开发提供与其他服务器**交互数据**，为用户**检索或转换数据**并**对用户数据加以收集与储存**。
:::
## 公司开发
::: note
如果从职位细分的话，可以分出产品、交互、设计、开发、测试、策划、运营、维护等。
:::
### 产品设计
产品设计对应产品经理，一般负责整体内容的构思，这一过程可能还包括用户和市场调研，确定要做的产品的功能、大致交互格式，也就是将成品的草稿设计出来，
### 设计师
设计师主要和产品设计合作，对一个 App 或者网站的大致页面布局、交互流程进行设计，并提供大致的页面切图，交互流程文档等。
### 交互
交互一般负责具体交互流程的细节，会逐步细化，考虑用户习惯，操作的步骤以及长度。综合考量整个交互设计对用户体验以及流失率、活跃程度的影响。
### 开发
在实际的大型公司发开产品的过程中，开发直接就可以拿到页面的设计图以及完善的交互流程文档，开发的工作就是去实现相应的页面与动画。
在这一过程中，前端和后端约定接口和参数，前端负责 App 或网站，后端负责服务器上的数据存储与服务。
### 测试
通常情况下，测试和开发会完全分开，测试人员在未参与开发的情况下模拟用户，在不同情况下进行测试，以确保产品不会出现问题。
这里常见的测试有风险测试、压力测试与异常行为测试等。测试软件是否有安全漏洞，是否可承担大量的访问以及是否在一些非常规交互下可以正常工作。
### 运营
一般一款产品需要宣发和后续的持续运营，一般就通过偏市场方向的策划和运营进行相关设计，并指导开发进行相关活动的编写与上线。
### 运维
一款产品的后端存储可能需要定期的备份与维护，同时软件后端部署的服务器可能要定期的修复漏洞与升级，就需要有专门的人员来进行这一工作， | 1,487 | MIT |
---
title: Azure 儲存體帳戶清單
description: 使用 Azure Toolkit for Eclipse 來管理您的儲存體帳戶設定
services: ''
documentationcenter: java
author: rmcmurray
manager: wpickett
editor: ''
ms.service: multiple
ms.workload: na
ms.tgt_pltfrm: multiple
ms.devlang: Java
ms.topic: article
ms.date: 08/11/2016
ms.author: robmcm
---
<!-- Legacy MSDN URL = https://msdn.microsoft.com/library/azure/dn205108.aspx -->
# Azure 儲存體帳戶清單
Azure 儲存體帳戶可讓下載位置用於您的 JDK、應用程式伺服器和任意元件，以及在使用快取時用於儲存狀態。Eclipse 維護一份已知儲存體帳戶清單，可供 Eclipse 工作區中的專案使用。若要開啟用來管理 Eclipse 中該清單的 [儲存體帳戶] 對話方塊，請依序按一下 [視窗] 和 [喜好設定]，展開 [Azure]，然後按一下 [儲存體帳戶]。
下圖顯示 [儲存體帳戶] 對話方塊。
![][ic719496]
您也可以在使用儲存體帳戶的下列對話方塊上，從 [帳戶] 連結開啟這個對話方塊：
* [伺服器組態] 對話方塊的 [JDK] 索引標籤。
* [伺服器組態] 對話方塊的 [伺服器] 索引標籤。
* [加入元件] 對話方塊。
* [快取] 屬性對話方塊。
## 使用發行設定檔匯入您的儲存體帳戶
1. 在 [儲存體帳戶] 對話方塊中，按一下 [從發行設定檔匯入]
2. (如果您已將發行設定檔儲存至本機電腦，則略過這個步驟)。 在 [匯入訂用帳戶資訊] 對話方塊中，按一下 [下載發行設定檔]。如果您尚未登入 Azure 帳戶，系統會提示您登入。然後會提示您儲存 Azure 發行設定檔(您可以忽略登入頁面上所顯示的產生指示，這是由 Azure 入口網站提供給 Visual Studio 使用者的指示)。 請將其儲存至本機電腦。
3. 同樣在 [匯入訂用帳戶資訊] 對話方塊中，按一下 [瀏覽] 按鈕，選取您先前在本機儲存的發行設定檔，然後按一下 [開啟]。
4. 按一下 [確定] 關閉 [匯入訂用帳戶資訊] 對話方塊。
## 建立新的儲存體帳戶
1. 在 [儲存體帳戶] 對話方塊中，按一下 [加入]。
2. 在 [加入儲存體帳戶] 對話方塊中，按一下 [新增]。
3. 在 [新增儲存體帳戶] 對話方塊中，指定下列值：
* 儲存體帳戶名稱。
* 儲存體帳戶的位置。
* 儲存體帳戶的描述。
* 儲存體帳戶所屬的訂用帳戶。
4. 按一下 [確定] 關閉 [新增儲存體帳戶] 對話方塊。
建立儲存體帳戶可能需要幾分鐘的時間。建立後，請按一下 [確定] 關閉 [加入儲存體帳戶] 對話方塊，新的儲存體帳戶會隨即加入可用的儲存體帳戶清單中。
## 將現有的儲存體帳戶加入清單中
1. 如果您還沒有 Azure 儲存體帳戶，請遵循上一節＜建立新的儲存體帳戶＞中所列的步驟，建立一個帳戶。(您也可以在 [Azure 管理入口網站][Azure 管理入口網站]中，建立新的儲存體帳戶)。
2. 在 [儲存體帳戶] 對話方塊中，按一下 [加入]。
3. 在 [加入儲存體帳戶] 對話方塊中，輸入 [名稱] 和 [存取金鑰] 的值。這必須是現有 Azure 儲存體帳戶的帳戶名稱和存取金鑰。使用 [Azure 管理入口網站][Azure 管理入口網站]的 [儲存體] 區段可檢視您的儲存體帳戶名稱和金鑰。您的 [加入儲存體帳戶] 對話方塊將會類似如下。
![][ic719497]
4. 按一下 [確定] 關閉 [加入儲存體帳戶] 對話方塊。
## 修改儲存體帳戶以使用新的存取金鑰
1. 在 [儲存體帳戶] 對話方塊中，按一下您要編輯的儲存體帳戶，然後按一下 [編輯]。
2. 在 [編輯儲存體帳戶存取金鑰] 對話方塊中，修改 [存取金鑰] 值。
3. 按一下 [確定] 關閉 [編輯儲存體帳戶存取金鑰] 對話方塊。
## 從 Eclipse 所維護的清單中移除儲存體帳戶
1. 在 [儲存體帳戶] 對話方塊中，按一下您要編輯的儲存體帳戶，然後按一下 [移除]。
2. 出現提示時，按一下 [確定] 以移除儲存體帳戶。
> [!NOTE]
> 透過 [儲存體帳戶] 對話方塊移除儲存體帳戶，只會將其從可在 Eclipse 中檢視的儲存體帳戶清單中移除，而不會從您的 Azure 訂用帳戶中移除此儲存體帳戶。此外，當 Eclipse 重新載入您訂用帳戶的詳細資料之後，該儲存體帳戶可能會再次出現於清單中。
>
>
## 另請參閱
[適用於 Eclipse 的 Azure 工具組][適用於 Eclipse 的 Azure 工具組]
[安裝 Azure Toolkit for Eclipse][安裝 Azure Toolkit for Eclipse]
[在 Eclipse 中為 Azure 建立 Hello World 應用程式][在 Eclipse 中為 Azure 建立 Hello World 應用程式]
如需如何搭配使用 Azure 與 Java 的詳細資訊，請參閱 [Azure Java 開發人員中心][Azure Java 開發人員中心]。
<!-- URL List -->
[Azure Java 開發人員中心]: http://go.microsoft.com/fwlink/?LinkID=699547
[適用於 Eclipse 的 Azure 工具組]: http://go.microsoft.com/fwlink/?LinkID=699529
[Azure 管理入口網站]: http://go.microsoft.com/fwlink/?LinkID=512959
[在 Eclipse 中為 Azure 建立 Hello World 應用程式]: http://go.microsoft.com/fwlink/?LinkID=699533
[安裝 Azure Toolkit for Eclipse]: http://go.microsoft.com/fwlink/?LinkId=699546
[What's New in the Azure Toolkit for Eclipse]: http://go.microsoft.com/fwlink/?LinkID=699552
<!-- IMG List -->
[ic719496]: ./media/azure-toolkit-for-eclipse-azure-storage-account-list/ic719496.png
[ic719497]: ./media/azure-toolkit-for-eclipse-azure-storage-account-list/ic719497.png
<!---HONumber=AcomDC_0817_2016--> | 3,085 | CC-BY-3.0 |
---
title: '给 Antd Table 组件编写缩进指引线、子节点懒加载等功能'
date: '2021-03-01'
spoiler: ''
---
在业务需求中，有时候我们需要基于 antd 之类的组件库定制很多功能，本文就以我自己遇到的业务需求为例，一步步实现和优化一个树状表格组件，这个组件会支持：
- ✨ 每个层级**缩进指示线**
- ✨ 远程**懒加载**子节点
- ✨ 每个层级支持**分页**
本系列分为两篇文章，这篇只是讲这些业务需求如何实现。
而下一篇，我会讲解怎么给**组件**也设计一套简单的**插件机制**，来解决代码耦合，难以维护的问题。
代码已经发布在 [react-antd-treetable](https://github.com/sl1673495/react-antd-treetable)，欢迎 Star~
## 功能实现
### 层级缩进线
antd 的 [Table 组件](https://3x.ant.design/components/table-cn/#components-table-demo-dynamic-settings) 默认是没有提供这个功能的，它只是支持了树状结构：
```js
const treeData = [
{
function_name: `React Tree Reconciliation`,
count: 100,
children: [
{
function_name: `React Tree Reconciliation2`,
count: 100
}
]
}
]
```
展示效果如下：
可以看出，在展示**大量的函数堆栈**的时候，没有缩进线就会很难受了，业务方也确实和我提过这个需求，可惜之前太忙了，就暂时放一边了。😁
参考 VSCode 中的缩进线效果，可以发现，缩进线是和节点的层级紧密相关的。
比如 `src` 目录对应的是第一级，那么它的子级 `client` 和 `node` 就只需要在 td 前面绘制一条垂直线，而 `node` 下的三个目录则绘制两条垂直线。
```
第 1 层： | text
第 2 层： | | text
第 3 层： | | | text
```
只需要在自定义渲染单元格元素的时候，得到以下两个信息。
1. 当前节点的层级信息。
2. 当前节点的父节点是否是展开状态。
所以思路就是对数据进行一次**递归处理**，把**层级**写在节点上，并且要把**父节点的引用**也写上，之后再通过传给 `Table` 的 `expandedRowKeys` 属性来维护表格的展开行数据。
这里我是直接改写了原始数据，如果需要保证原始数据干净的话，也可以参考 React Fiber 的思路，构建一颗替身树进行数据写入，只要保留原始树节点的引用即可。
```js
/**
* 递归树的通用函数
*/
const traverseTree = (
treeList,
childrenColumnName,
callback
) => {
const traverse = (list, parent = null, level = 1) => {
list.forEach(treeNode => {
callback(treeNode, parent, level);
const { [childrenColumnName]: next } = treeNode;
if (Array.isArray(next)) {
traverse(next, treeNode, level + 1);
}
});
};
traverse(treeList);
};
function rewriteTree({ dataSource }) {
traverseTree(dataSource, childrenColumnName, (node, parent, level) => {
// 记录节点的层级
node[INTERNAL_LEVEL] = level
// 记录节点的父节点
node[INTERNAL_PARENT] = parent
})
}
```
之后利用 Table 组件提供的 `components` 属性，自定义渲染 `Cell` 组件，也就是 td 元素。
```js
const components = {
body: {
cell: (cellProps) => (
<TreeTableCell
{...props}
{...cellProps}
expandedRowKeys={expandedRowKeys}
/>
)
}
}
```
之后，在自定义渲染的 Cell 中，只需要获取两个信息，只需要根据层级和父节点的展开状态，来决定绘制几条垂直线即可。
```js
const isParentExpanded = expandedRowKeys.includes(
record?.[INTERNAL_PARENT]?.[rowKey]
)
// 只有当前是展示指引线的列 且父节点是展开节点 才会展示缩进指引线
if (dataIndex !== indentLineDataIndex || !isParentExpanded) {
return <td className={className}>{children}</td>
}
// 只要知道层级 就知道要在 td 中绘制几条垂直指引线 举例来说：
// 第 2 层： | | text
// 第 3 层： | | | text
const level = record[INTERNAL_LEVEL]
const indentLines = renderIndentLines(level)
```
这里的实现就不再赘述，直接通过绝对定位画几条垂直线，再通过对 `level` 进行循环时的下标 `index` 决定 `left` 的偏移值即可。
效果如图所示：
### 远程懒加载子节点
这个需求就需要用比较 hack 的手段实现了，首先观察了一下 Table 组件的逻辑，只有在有 `children` 的子节点上才会展示「展开更多」的图标。
所以思路就是，和后端约定一个字段比如 `has_next`，之后预处理数据的时候先遍历这些节点，加上一个假的占位 `children`。
之后在点击展开的时候，把节点上的这个假 `children` 删除掉，并且把通过改写节点上一个特殊的 `is_loading` 字段，在自定义渲染 Icon 的代码中判断，并且展示 `Loading Icon`。
又来到递归树的逻辑中，我们加入这样的一段代码：
```js
function rewriteTree({ dataSource }) {
traverseTree(dataSource, childrenColumnName, (node, parent, level) => {
if (node[hasNextKey]) {
// 树表格组件要求 next 必须是非空数组才会渲染「展开按钮」
// 所以这里手动添加一个占位节点数组
// 后续在 onExpand 的时候再加载更多节点 并且替换这个数组
node[childrenColumnName] = [generateInternalLoadingNode(rowKey)]
}
})
}
```
之后我们要实现一个 `forceUpdate` 函数，驱动组件强制渲染：
```js
const [_, forceUpdate] = useReducer((x) => x + 1, 0)
```
再来到 `onExpand` 的逻辑中：
```js
const onExpand = async (expanded, record) => {
if (expanded && record[hasNextKey] && onLoadMore) {
// 标识节点的 loading
record[INTERNAL_IS_LOADING] = true
// 移除用来展示展开箭头的假 children
record[childrenColumnName] = null
forceUpdate()
const childList = await onLoadMore(record)
record[hasNextKey] = false
addChildList(record, childList)
}
onExpandProp?.(expanded, record)
}
function addChildList(record, childList) {
record[childrenColumnName] = childList
record[INTERNAL_IS_LOADING] = false
rewriteTree({
dataSource: childList,
parentNode: record
})
forceUpdate()
}
```
这里 `onLoadMore` 是用户传入的获取更多子节点的方法，
流程是这样的：
1. 节点展开时，先给节点写入一个正在加载的标志，然后把子数据重置为空。这样虽然节点会变成展开状态，但是不会渲染子节点，然后强制渲染。
2. 在加载完成后赋值了新的子节点 `record[childrenColumnName] = childList` 后，我们又通过 `forceUpdate` 去强制组件重渲染，展示出新的子节点。
需要注意，我们递归树加入逻辑的所有逻辑都在 `rewriteTree` 中，所以对于加入的新的子节点，也需要通过这个函数递归一遍，加入 `level`, `parent` 等信息。
新加入的节点的 `level` 需要根据父节点的 `level` 相加得出，不能从 1 开始，否则渲染的缩进线就乱掉了，所以这个函数需要改写，加入 `parentNode` 父节点参数，遍历时写入的 `level` 都要加上父节点已有的 `level`。
```js
function rewriteTree({
dataSource,
// 在动态追加子树节点的时候 需要手动传入 parent 引用
parentNode = null
}) {
// 在动态追加子树节点的时候 需要手动传入父节点的 level 否则 level 会从 1 开始计算
const startLevel = parentNode?.[INTERNAL_LEVEL] || 0
traverseTree(dataSource, childrenColumnName, (node, parent, level) => {
parent = parent || parentNode;
// 记录节点的层级
node[INTERNAL_LEVEL] = level + startLevel;
// 记录节点的父节点
node[INTERNAL_PARENT] = parent;
if (node[hasNextKey]) {
// 树表格组件要求 next 必须是非空数组才会渲染「展开按钮」
// 所以这里手动添加一个占位节点数组
// 后续在 onExpand 的时候再加载更多节点 并且替换这个数组
node[childrenColumnName] = [generateInternalLoadingNode(rowKey)]
}
})
}
```
自定义渲染 `Loading Icon` 就很简单了：
```js
// 传入给 Table 组件的 expandIcon 属性即可
export const TreeTableExpandIcon = ({
expanded,
expandable,
onExpand,
record
}) => {
if (record[INTERNAL_IS_LOADING]) {
return <IconLoading style={iconStyle} />
}
}
```
功能完成，看一下效果：
## 每个层级支持分页
这个功能和上一个功能也有点类似，需要在 `rewriteTree` 的时候根据外部传入的是否开启分页的字段，在符合条件的时候往子节点数组的末尾加入一个**占位 Pagination 节点**。
之后在 `column` 的 `render` 中改写这个节点的渲染逻辑。
改写 `record`：
```js
function rewriteTree({
dataSource,
// 在动态追加子树节点的时候 需要手动传入 parent 引用
parentNode = null
}) {
// 在动态追加子树节点的时候 需要手动传入父节点的 level 否则 level 会从 1 开始计算
const startLevel = parentNode?.[INTERNAL_LEVEL] || 0
traverseTree(dataSource, childrenColumnName, (node, parent, level) => {
// 加载更多逻辑
if (node[hasNextKey]) {
// 树表格组件要求 next 必须是非空数组才会渲染「展开按钮」
// 所以这里手动添加一个占位节点数组
// 后续在 onExpand 的时候再加载更多节点 并且替换这个数组
node[childrenColumnName] = [generateInternalLoadingNode(rowKey)]
}
// 分页逻辑
if (childrenPagination) {
const { totalKey } = childrenPagination;
const nodeChildren = node[childrenColumnName] || [];
const [lastChildNode] = nodeChildren.slice?.(-1);
// 渲染分页器，先加入占位节点
if (
node[totalKey] > nodeChildren?.length &&
// 防止重复添加分页器占位符
!isInternalPaginationNode(lastChildNode, rowKey)
) {
nodeChildren?.push?.(generateInternalPaginationNode(rowKey));
}
}
})
}
```
改写 `columns`：
```js
function rewriteColumns() {
/**
* 根据占位符 渲染分页组件
*/
const rewritePaginationRender = (column) => {
column.render = function ColumnRender(text, record) {
if (
isInternalPaginationNode(record, rowKey) &&
dataIndex === indentLineDataIndex
) {
return <Pagination />
}
return render?.(text, record) ?? text
}
}
columns.forEach((column) => {
rewritePaginationRender(column)
})
}
```
来看一下实现的分页效果：
## 重构和优化
随着编写功能的增多，逻辑被耦合在 Antd Table 的各个回调函数之中，
- **指引线**的逻辑分散在 `rewriteColumns`, `components`中。
- **分页**的逻辑被分散在 `rewriteColumns` 和 `rewriteTree` 中。
- **加载更多**的逻辑被分散在 `rewriteTree` 和 `onExpand` 中
至此，组件的代码行数也已经来到了 `300` 行，大概看一下代码的结构，已经是比较混乱了：
```js
export const TreeTable = (rawProps) => {
function rewriteTree() {
// 🎈加载更多逻辑
// 🔖 分页逻辑
}
function rewriteColumns() {
// 🔖 分页逻辑
// 🏁 缩进线逻辑
}
const components = {
// 🏁 缩进线逻辑
}
const onExpand = async (expanded, record) => {
// 🎈 加载更多逻辑
}
return <Table />
}
```
有没有一种机制，可以让代码**按照功能点聚合**，而不是散落在各个函数中？
```js
// 🔖 分页逻辑
const usePaginationPlugin = () => {}
// 🎈 加载更多逻辑
const useLazyloadPlugin = () => {}
// 🏁 缩进线逻辑
const useIndentLinePlugin = () => {}
export const TreeTable = (rawProps) => {
usePaginationPlugin()
useLazyloadPlugin()
useIndentLinePlugin()
return <Table />
}
```
没错，就是很像 `VueCompositionAPI` 和 `React Hook` 在逻辑解耦方面所做的改进，但是在这个回调函数的写法形态下，好像不太容易做到？
下一篇文章，我会聊聊如何利用自己设计的**插件机制**来优化这个组件的耦合代码。
## 感谢大家
欢迎关注 ssh，前端潮流趋势、原创面试热点文章应有尽有。
记得关注后加我好友，我会不定期分享前端知识，行业信息。2021 陪你一起度过。
 | 9,256 | MIT |
---
title: 'Azure AD Connect: FAQ | Microsoft Docs'
description: "このページでは、Azure AD Connect についてよく寄せられる質問を紹介します。"
services: active-directory
documentationcenter:
author: billmath
manager: femila
editor: curtand
ms.assetid: 4e47a087-ebcd-4b63-9574-0c31907a39a3
ms.service: active-directory
ms.workload: identity
ms.tgt_pltfrm: na
ms.devlang: na
ms.topic: article
ms.date: 08/08/2016
ms.author: billmath
translationtype: Human Translation
ms.sourcegitcommit: 2ea002938d69ad34aff421fa0eb753e449724a8f
ms.openlocfilehash: d0433f7f2e88dcbf5e0969f0a6c8d2689816b2d1
---
# <a name="azure-ad-connect-faq"></a>Azure AD Connect の FAQ
## <a name="general-installation"></a>一般的なインストール
**Q: Azure AD のグローバル管理者が 2FA を有効化している場合、インストールを実行できますか。**
2016 年 2 月以降のビルドでは、これがサポートされています。
**Q: Azure AD Connect を無人インストールする方法はありますか。**
インストール ウィザードを使用して Azure AD Connect をインストールする場合にのみサポートされます。 サイレント モードでの無人インストールはサポートされていません。
**Q: ドメインに接続できないフォレストがあります。Azure AD Connect をインストールにはどうすればよいですか。**
2016 年 2 月以降のビルドでは、これがサポートされています。
**Q: AD DS の正常性エージェントはサーバー コアで稼働しますか。**
はい。 エージェントをインストールした後、次の PowerShell コマンドレットを使用して登録プロセスを実行できます。
`Register-AzureADConnectHealthADDSAgent -Credentials $cred`
## <a name="network"></a>ネットワーク
**Q: ファイアウォールやネットワーク デバイスなど、ネットワーク上で接続を開ける最大時間を制限するものがあります。Azure AD Connect を使用する場合、クライアント側のタイムアウトしきい値はどのくらいにすればいいでしょうか。**
すべてのネットワーク ソフトウェアや物理デバイスなど、接続を開ける最大時間を制限するものは、Azure AD Connect クライアントがインストールされているサーバーと Azure Active Directory 間の接続に対して少なくとも 5 分 (300 秒) のしきい値を使用する必要があります。 これは、以前リリースされたすべての Microsoft Identity 同期ツールにも適用されます。
**Q: SLD (シングル ラベル ドメイン) はサポートされていますか。**
いいえ、Azure AD Connect は、SLD を使用するオンプレミスのフォレスト/ドメインはサポートしていません。
**Q: 「ドット形式」の NetBios 名はサポートされていますか。**
いいえ、Azure AD Connect では、NetBios 名にピリオド (.) が含まれているオンプレミスのフォレスト/ドメインはサポートしていません。
## <a name="federation"></a>フェデレーション
**Q: Office 365 の証明書を更新するように求める電子メールを受け取った場合はどうすればいいですか。**
[証明書の更新](active-directory-aadconnect-o365-certs.md) に関する記事に記載されているガイダンスに従って、証明書を更新してください。
**Q: O365 証明書利用者の "証明書利用者の自動更新" を設定しました。トークン署名証明書が自動的にロールオーバーされるときに、何か必要な操作はありますか。**
[証明書の更新](active-directory-aadconnect-o365-certs.md)に関する記事に記載されているガイダンスに従ってください。
## <a name="environment"></a>環境
**Q: Azure AD Connect のインストール後のサーバー名の変更はサポートされていますか。**
いいえ。 サーバー名を変更すると、同期エンジンが SQL データベースに接続できなくなり、サービスを開始できなくなります。
## <a name="identity-data"></a>ID データ
**Q: Azure AD の UPN (userPrincipalName) 属性がオンプレミスの UPN と一致しません。なぜでしょうか。**
次の記事を参照してください。
* [Office 365、Azure、Intune におけるユーザー名が、オンプレミスの UPN または代替ログイン ID と一致しない](https://support.microsoft.com/en-us/kb/2523192)
* [異なるフェデレーション ドメインを使用するようにユーザー アカウントの UPN を変更した後、Azure Active Directory 同期ツールによって変更が同期されない](https://support.microsoft.com/en-us/kb/2669550)
また、「 [Azure AD Connect 同期サービスの機能](active-directory-aadconnectsyncservice-features.md)」に記載された手順に従って、同期エンジンによる userPrincipalName の更新が許可されるように Azure AD を構成することもできます。
## <a name="custom-configuration"></a>カスタム構成
**Q: Azure AD Connect 用の PowerShell コマンドレットのドキュメントはどこにありますか。**
このサイトに記載されているコマンドレットを除き、Azure AD Connect で使用されている PowerShell コマンドレットは、ユーザーによる使用をサポートしていません。
**Q: *Synchronization Service Manager* の [サーバーのエクスポート/インポート] を使用して、サーバー間で構成を移動できますか。**
いいえ。 このオプションはすべての構成設定を取得しないため、使用すべきではありません。 代わりに、2 台目のサーバーでウィザードを使用して基本構成を作成し、同期ルール エディターを使用して PowerShell スクリプトを生成し、サーバー間でカスタム ルールを移動してください。 詳細については、「 [カスタム構成をアクティブ サーバーからステージング サーバーに移動する](active-directory-aadconnect-upgrade-previous-version.md#move-custom-configuration-from-active-to-staging-server)」をご覧ください。
## <a name="troubleshooting"></a>トラブルシューティング
**Q: Azure AD Connect に関するヘルプを参照する方法を教えてください。**
[Microsoft サポート技術情報 (KB) の検索](https://www.microsoft.com/en-us/Search/result.aspx?q=azure%20active%20directory%20connect&form=mssupport)
* Azure AD Connect のサポートに関する一般的な破損時補償の技術的な解決策について、Microsoft サポート技術情報 (KB) を検索してください。
[Microsoft Azure Active Directory フォーラム](https://social.msdn.microsoft.com/Forums/azure/en-US/home?forum=WindowsAzureAD)
* このコミュニティで技術的な質問と回答を検索して参照したり、 [こちら](https://social.msdn.microsoft.com/Forums/azure/en-US/newthread?category=windowsazureplatform&forum=WindowsAzureAD&prof=required)をクリックして独自の質問を行ったりできます。
[Azure AD Connect のカスタマー サポート](https://manage.windowsazure.com/?getsupport=true)
* このリンクを使用して、Azure Portal からサポートを受けることができます。
<!--HONumber=Nov16_HO3--> | 4,262 | CC-BY-3.0 |
---
title: WizardData 元素 （Visual Studio 模板） |Microsoft 文档
ms.custom: ''
ms.date: 11/04/2016
ms.technology:
- vs-ide-general
ms.topic: conceptual
f1_keywords:
- http://schemas.microsoft.com/developer/vstemplate/2005#WizardData
helpviewer_keywords:
- WizardData element [Visual Studio Templates]
- <WizardData> element [Visual Studio Templates]
ms.assetid: d0403a16-5d07-4fe5-b474-19ae3d9fd3ab
author: gregvanl
ms.author: gregvanl
manager: douge
ms.workload:
- vssdk
ms.openlocfilehash: 6685c09e463b50f1fd856c65eadc09555a6dedb9
ms.sourcegitcommit: 6a9d5bd75e50947659fd6c837111a6a547884e2a
ms.translationtype: MT
ms.contentlocale: zh-CN
ms.lasthandoff: 04/16/2018
ms.locfileid: "31140110"
---
# <a name="wizarddata-element-visual-studio-templates"></a>WizardData 元素（Visual Studio 模板）
指定自定义 XML
\<VSTemplate >
\<WizardData >
## <a name="syntax"></a>语法
```
<WizardData>
<!-- XML to pass to the custom wizard extension -->
...
</WizardData>
```
## <a name="attributes-and-elements"></a>特性和元素
以下各部分描述了特性、子元素和父元素。
### <a name="attributes"></a>特性
无。
### <a name="child-elements"></a>子元素
无。
### <a name="parent-elements"></a>父元素
|元素|描述|
|-------------|-----------------|
|[VSTemplate](../extensibility/vstemplate-element-visual-studio-templates.md)|必需的元素。<br /><br /> 包含项目模板、 项模板或初学者工具包的所有元数据。|
## <a name="text-value"></a>文本值
文本值是可选的。
此文本指定要传递给指定的自定义向导扩展的自定义 XML [WizardExtension](../extensibility/wizardextension-element-visual-studio-templates.md)元素。
## <a name="remarks"></a>备注
此元素中，可以指定任何 XML。 XML 将可作为参数传递到自定义向导扩展插件，允许此扩展可以使用此元素的内容。 对此数据不进行任何验证。
内容`WizardData`元素会被传递，保持不变，作为参数中的参数的字符串字典内`IWizard.RunStarted`方法。 参数的名称为 $WizardData$。
## <a name="example"></a>示例
下面的示例演示的标准项目模板的元数据[!INCLUDE[csprcs](../data-tools/includes/csprcs_md.md)]Windows 应用程序。
```
<VSTemplate Version="3.0.0" Type="Item"
xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
<TemplateData>
<Name>MyTemplate</Name>
<Description>Template using IWizard extension</Description>
<Icon>TemplateIcon.ico</Icon>
<ProjectType>CSharp</ProjectType>
</TemplateData>
<TemplateContent>
<Project File="MyTemplate.csproj">
<ProjectItem>Form1.cs<ProjectItem>
<ProjectItem>Form1.Designer.cs</ProjectItem>
<ProjectItem>Program.cs</ProjectItem>
<ProjectItem>Properties\AssemblyInfo.cs</ProjectItem>
<ProjectItem>Properties\Resources.resx</ProjectItem>
<ProjectItem>Properties\Resources.Designer.cs</ProjectItem>
<ProjectItem>Properties\Settings.settings</ProjectItem>
<ProjectItem>Properties\Settings.Designer.cs</ProjectItem>
</Project>
</TemplateContent>
<WizardExtension>
<Assembly>MyWizard, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, Custom=null</Assembly>
<FullClassName>MyWizard.CustomWizard</FullClassName>
</WizardExtension>
<WizardData>
<!-- XML to pass to the custom wizard extension -->
</WizardData>
</VSTemplate>
```
## <a name="see-also"></a>另请参阅
[Visual Studio 模板架构参考](../extensibility/visual-studio-template-schema-reference.md)
[创建项目和项模板](../ide/creating-project-and-item-templates.md)
[WizardExtension 元素 （Visual Studio 模板）](../extensibility/wizardextension-element-visual-studio-templates.md)
[如何：使用向导来处理项目模板](../extensibility/how-to-use-wizards-with-project-templates.md) | 3,595 | CC-BY-4.0 |
## 数组去重
1. 遍历数组，一一比较，比较到相同的就删除后面的
2. 遍历数组，一一比较，比较到相同的，跳过前面重复的，不相同的放入新数组
3. 任取一个数组元素放入新数组，遍历剩下的数组元素任取一个，与新数组的元素一一比较，如果有不同的，放入新数组。
4. 遍历数组，取一个元素，作为对象的属性，判断属性是否存在
```javascript
alert("hello world");
```
### 删除后面重复的
```javascript
/*1. 删除后面重复的：*/
function ov1(arr){
var a1=((new Date).getTime());
for(var i=0;i<arr.length;i++){
for(var j=i+1;j<arr.length;j++){
if(arr[i]===arr[j]){
arr.splice(j,1);
j--;
}
}
}
console.info((new Date).getTime()-a1);
console.log(arr)
return arr.sort(function(a,b){
return a-b;
});
}
```
### 相同则跳出循环
```javascript
/*2. 这个是常规的方法，比较好理解，如果相同则跳出循环*/
function ov2(a) {
var a1=((new Date).getTime());
var b = [], n = a.length, i, j;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++){
if (a[i] === a[j]){
j=false;break;
}
}
if(j)b.push(a[i]);
}
console.info((new Date).getTime()-a1);
console.log(b)
return b.sort(function(a,b){
return a-b
});
}
```
### 放入新数组
```javascript
/*3. 这个我花了好长时间明白的，这里j循环虽然继续了，但是i值已经改变了。就等于是一个新的i循环：*/
function ov3(a) {
var a1=((new Date).getTime());
var b = [], n = a.length, i, j;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++){
if (a[i] === a[j])j=++i
}
b.push(a[i]);
}
console.info((new Date).getTime()-a1);
console.log(b)
return b.sort(function(a,b){return a-b});
}
```
### 保证数组的唯一性
```javascript
/*4. 保证新数组中的都是唯一的*/
function ov4(ar){
var a1=((new Date).getTime());
var m=[],f;
for(var i=0;i<ar.length;i++){
f=true;
for(var j=0;j<m.length;j++){
if(ar[i]===m[j]){f=false;break;};
}
if(f)m.push(ar[i])
}
console.info((new Date).getTime()-a1);
console.log(m);
return m.sort(function(a,b){return a-b});
}
```
### 判断属性是否存在
```javascript
/*5. 用对象属性*/
function ov5(ar){
var a1=(new Date).getTime();
var m,n=[],o= {};
for (var i=0;(m= ar[i])!==undefined;i++){
if (!o[m]){
n.push(m);o[m]=true;
}
}
console.info((new Date).getTime()-a1);
console.log(n);
return n.sort(function(a,b){return a-b});;
}
```
#### 输出以上的结果
```javascript
window.status='Hello'
var str = "1232412589534545331543456751349587"
var arr1 = str.split(''),
arr2 = str.split(''),
arr3 = str.split(''),
arr4 = str.split(''),
arr5 = str.split('');
ov1(arr1);
ov2(arr2);
ov3(arr3);
ov4(arr4);
ov5(arr5);
``` | 2,547 | MIT |
Package Control 安装
<!-- 参考 -->
<!-- https://packagecontrol.io/browse/popular -->
<!-- http://www.cnblogs.com/hykun/p/sublimeText3.html -->
<!-- http://www.cnblogs.com/lhb25/p/sublime-text-package-manager.html -->
Emmet
SublimeLinter
SideBarEnhancements
TrailingSpaces
SublimeCodeIntel
BracketHighlighter
HTML5
Gist
<!-- https://packagecontrol.io/packages/DocBlockr -->
<!-- http://qianduanblog.com/post/sublime-text-3-plugin-docblockr-javascript-comments-specification.html -->
DocBlockr
<!-- http://www.cnblogs.com/owenChen/archive/2012/12/28/2837450.html -->
<!-- 简直太爽了 -->
Git
GitGutter
P
IMESupport 必装啊 !!! 神器
Emmet Css Snippets
JSFormat ctrl + alt + f
CSScomb ctrl + shift + c
Autoprefixer CSS3属性后 Tab
Alignment ctrl + alt + a
HTML-CSS-JS Prettify ctrl + shift + h
[Color Highlighter](https://github.com/Monnoroch/ColorHighlighter) 也是小神器
- 安装后增加 user preference
- ```Javascript
{
"argb": true,
"icons_all": true,
"ha_style": "Filled"
}
``` | 999 | MIT |
---
layout: post
title: "RocketMQ 系列 消息有序"
subtitle: '消息中间件基本问题'
author: "lichao"
header-img: "img/post-bg-rwd.jpg"
catalog: true
tags:
- rocket_mq
---
RocketMQ 的顺序消息需要满足 2 点：
1. Producer 端保证发送消息有序，且发送到同一个队列。
2. Consumer 端保证消费同一个队列。
## 生产端
RocketMQ 可以严格的保证消息有序。但这个顺序，不是全局顺序，只是分区（queue）顺序。要全局顺序只能一个分区。
但是同一条 queue 里面，RocketMQ 的确是能保证 FIFO 的。
确保消息放到同一个 queue 中，需要使用 MessageQueueSelector。
```
String body = dateStr + " Hello RocketMQ " + orderList.get(i);
Message msg = new Message("TopicTestjjj", tags[i % tags.length], "KEY" + i, body.getBytes());
//确保同一个订单号的数据放到同一个queue中
SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
@Override
public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
Long id = (Long) arg;
long index = id % mqs.size();
return mqs.get((int)index);
}
}, orderList.get(i).getOrderId());//订单id
```
## 消费端
需要使用 MessageListenerOrderly 来消费数据。
MessageListenerOrderly 与 MessageListenerConcurrently 区别:
* MessageListenerOrderly: 有序消费，同一队列的消息同一时刻只能一个线程消费，可保证消息在同一队列严格有序消费
* MessageListenerConcurrently:并发消费
```
public class ConsumerInOrder {
public static void main(String[] args) throws MQClientException {
DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("please_rename_unique_group_name_3");
consumer.setNamesrvAddr("10.11.11.11:9876;10.11.11.12:9876");
/**
* 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费<br>
* 如果非第一次启动，那么按照上次消费的位置继续消费
*/
consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
consumer.subscribe("TopicTestjjj", "TagA || TagC || TagD");
consumer.registerMessageListener(new MessageListenerOrderly() {
Random random = new Random();
@Override
public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
context.setAutoCommit(true);
System.out.print(Thread.currentThread().getName() + " Receive New Messages: " );
for (MessageExt msg: msgs) {
System.out.println(msg + ", content:" + new String(msg.getBody()));
}
try {
//模拟业务逻辑处理中...
TimeUnit.SECONDS.sleep(random.nextInt(10));
} catch (Exception e) {
e.printStackTrace();
}
return ConsumeOrderlyStatus.SUCCESS;
}
});
consumer.start();
System.out.println("Consumer Started.");
}
}
``` | 2,705 | Apache-2.0 |
---
sidebar_position: 3
---
## 配置缺省feature
```java
featureDefaults.put(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
featureDefaults.put(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS, false);
FEATURE_DEFAULTS = Collections.unmodifiableMap(featureDefaults);
```
## JsonComponentModule
Jackson Module，通过InitializingBean来注册各种JsonComponent，比如
+ JsonSerializer
+ JsonDeserializer
+ KeyDeserializer
最终组建的Module会被注册到ObjectMapperBuilder
```java
private void addJsonBeans(ListableBeanFactory beanFactory) {
// 查找所有JsonComponent类型的Bean
Map<String, Object> beans = beanFactory.getBeansWithAnnotation(JsonComponent.class);
private void addJsonBean(Object bean) {
MergedAnnotation<JsonComponent> annotation = MergedAnnotations
.from(bean.getClass(), SearchStrategy.TYPE_HIERARCHY).get(JsonComponent.class);
// 从annatation中提取type和scope，type代表serialize类型，scope代表是key还是value
Class<?>[] types = annotation.getClassArray("type");
Scope scope = annotation.getEnum("scope", JsonComponent.Scope.class);
private void addJsonBean(Object bean, Class<?>[] types, Scope scope) {
if (bean instanceof JsonSerializer) {
addJsonSerializerBean((JsonSerializer<?>) bean, scope, types);
}
private <T> void addJsonSerializerBean(JsonSerializer<T> serializer, JsonComponent.Scope scope, Class<?>[] types) {
// 从Generic中提取类型参数
Class<T> baseType = (Class<T>) ResolvableType.forClass(JsonSerializer.class, serializer.getClass())
.resolveGeneric();
// 调用jackson提供的addSerializer和addKeySerializer添加
addBeanToModule(serializer, baseType, types,
(scope == Scope.VALUES) ? this::addSerializer : this::addKeySerializer);
```
## JacksonObjectMapperConfiguration
ObjectMapper: 如果不存在则创建缺省ObjectMapper
```java
@Bean
@Primary
@ConditionalOnMissingBean
ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
return builder.createXmlMapper(false).build();
```
## ParameterNamesModuleConfiguration
ParameterNamesModule: 通过反射来获取参数名字
`java.lang.reflect.Parameter`
## JacksonObjectMapperBuilderConfiguration
Jackson2ObjectMapperBuilder：Scope是prototype，并且通过Jackson2ObjectMapperBuilderCustomizer来定制
```java
/**
A builder used to create ObjectMapper instances with a fluent API.
It customizes Jackson's default properties with the following ones:
MapperFeature.DEFAULT_VIEW_INCLUSION is disabled
DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES is disabled
It also automatically registers the following well-known modules if they are detected on the classpath:
jackson-datatype-jdk8 : support for other Java 8 types like java.util.Optional
jackson-datatype-jsr310 : support for Java 8 Date & Time API types
*/
private void customizeDefaultFeatures(ObjectMapper objectMapper) {
if (!this.features.containsKey(MapperFeature.DEFAULT_VIEW_INCLUSION)) {
configureFeature(objectMapper, MapperFeature.DEFAULT_VIEW_INCLUSION, false);
}
if (!this.features.containsKey(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)) {
configureFeature(objectMapper, DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
}
```
## Jackson2ObjectMapperBuilderCustomizerConfiguration
### StandardJackson2ObjectMapperBuilderCustomizer
定制JacksonProperties，Features，Modules等
```java
if (this.jacksonProperties.getTimeZone() != null) {
builder.timeZone(this.jacksonProperties.getTimeZone());
}
configureFeatures(builder, FEATURE_DEFAULTS);
configureFeatures(builder, this.jacksonProperties.getSerialization());
Collection<Module> moduleBeans = getBeans(this.applicationContext, Module.class);
builder.modulesToInstall(moduleBeans.toArray(new Module[0]));
``` | 3,679 | Apache-2.0 |
# rookie
Spring-Boot 后端项目练习
## 目的
熟悉Spring Boot常用组件，了解开发流程。
# 项目记录起步
## 1. 项目框架搭建
使用maven管理各种依赖，那么首先就需要先创建一个maven项目，并且将这个初创建的项目作为整个工程的最顶层目录。然后以此为基础，创建几个常用的模块，模块之间相互依赖。
### 1. 构建聚合工程
**（聚合工程 = 父工程 + 子工程（模块））**
子工程之间是平级的模块，子模块如果要使用资源，必须构建依赖。
> 1. 聚合工程里可以分为顶级项目（顶级工程、父工程）与子工程，这两者的关系其实就是父子继承的关系
> 子工程在maven里称之为模块（module），模块之间是平级，是可以相互依赖的。
> 2. 子模块可以使用顶级工程里所有的资源（依赖），子模块之间如果要使用资源，必须构建依赖（构建关系）
> 3. 一个顶级工程是可以由多个不同的子工程共同组合而成。
1. 先创建maven的顶层结构 `rookie-star`。作为父级结构，设置他的pom文件，加上如下配置
```xml
<!--最外层顶层项目，使用的打包方式-->
<packaging>pom</packaging>
<!--指定项目编码方式，执行Java版本-->
<properties>
<project.build.sourceEnconding>UTF-8</project.build.sourceEnconding>
<project.reporting.outputEnconding>UTF-8</project.reporting.outputEnconding>
<java.version>1.8</java.version>
</properties>
```
2. 分别创建`rookie-common`，`rookie-pojo`，`rookie-mapper`，`rookie-service`，`rookie-api`几个模块，他们之间的相互依赖关系可以描述为
```
// 依次向后依赖
api -> service -> mapper -> pojo -> common
```
3. 因此，在各自的对应`pom`文件中需要引入依赖关系。举个栗子，如下为`api`模块的`pom`文件。
```xml
<dependency>
<!--
api -> service -> mapper -> pojo -> common
依次向后依赖
-->
<groupId>com.rookie</groupId>
<artifactId>rookie-service</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
```
### 2. 安装各个模块
1. 在父工程中的`maven`管理中，使用`install`安装各个子模块
### 3. 测试
1. `rookie-api`中创建`yml`文件
2. 在rookie-api中新建一个主启动类
3. 同理，新建一个`controller`。
4. 使用`maven`父工程安装`install`一下。然后启动项目，在浏览器输入`localhost:8080/hello`就能够看到页面正常显示`Hello World` 了。
## 2. 配置数据源，整合HikariCP
1. 父工程项目中引入`mysql`和`mybatis`驱动
```xml
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.41</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.0</version>
</dependency>
```
2. `rookie-api`中配置`application.yml`
```yaml
spring:
# profiles:
# active: dev
datasource: # 数据源的相关配置
type: com.zaxxer.hikari.HikariDataSource # 数据源类型：HikariCP
driver-class-name: com.mysql.jdbc.Driver # mysql驱动
url: jdbc:mysql://localhost:3306/rookie-star?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true
username: root
password: root
hikari:
connection-timeout: 30000 # 等待连接池分配连接的最大时长（毫秒），超过这个时长还没可用的连接则发生SQLException， 默认:30秒
minimum-idle: 5 # 最小连接数
maximum-pool-size: 20 # 最大连接数
auto-commit: true # 自动提交
idle-timeout: 600000 # 连接超时的最大时长（毫秒），超时则被释放（retired），默认:10分钟
pool-name: DateSourceHikariCP # 连接池名字
max-lifetime: 1800000 # 连接的生命时长（毫秒），超时而且没被使用则被释放（retired），默认:30分钟 1800000ms
connection-test-query: SELECT 1
servlet:
multipart:
max-file-size: 512000 # 文件上传大小限制为500kb
max-request-size: 512000 # 请求大小限制为500kb
############################################################
#
# mybatis 配置
#
############################################################
mybatis:
type-aliases-package: com.rookie.pojo # 所有POJO类所在包路径，需要创建对应的文件夹
mapper-locations: classpath:mapper/*.xml # mapper映射文件，需要创建mapper文件夹
# configuration:
# log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
```
## 3. MyBaties逆向生成工具
使用逆向生成工具生成数据库mapper以及一些pojo
1. 父工程中引入通用mapper逆向工具
```xml
<!--通用mapper逆向工具-->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.1.5</version>
</dependency>
```
2. 在yml中引入通用mapper配置
```yml
############################################################
#
# mybatis mapper配置
#
############################################################
mapper:
mappers: com.rookie.my.mapper.MyMapper
not-empty: false
identity: MYSQL
```
3. 引入MyMapper接口类
```java
package com.rookie.my.mapper;
import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;
/**
* 继承自己的MyMapper
*/
public interface MyMapper<T> extends Mapper<T>, MySqlMapper<T> {
}
```
4. **使用逆向工具需要注意，重新生成的`xml`文件是一种追加的方式，每次生成完了最好去检查一下**
## 4. 基于通用Mapper基于Rest编写api接口
### 4.1 如果使用通用Mapper请注意：
1. **在启动类上加上如下注释**
2. 其中`@MapperScan(basePackages = "com.rookie.mapper")`来自 `import tk.mybatis.spring.annotation.MapperScan;`
```java
@SpringBootApplication
// 使用通用mapper的这个包就是tk开头的这个，需要指明这些包是在哪里
// 扫描 mybatis 通用 mapper 所在的包
@MapperScan(basePackages = "com.rookie.mapper")
public class RookieApplication {
public static void main(String[] args) {
SpringApplication.run(RookieApplication.class, args);
}
}
```
3. 在service模块中添加相应逻辑，使用mapper操作数据库。注意，在Service的实现类上面要添加注解表明这是一个Bean，`@Service`
4. 在api模块中添加测试StuFooController，访问数据库中的stu表，查询数据。记得添加`@RestController`注解
# 1.1 实现单体电商项目核心功能
- 用户注册与登录
- Cookie 与 Session
- 集成 Swagger2 api
- 分类设计与实现
- 首页商品推荐
- 商品搜索与分页
- 商品详情与评论渲染
- 购物车与订单
- 微信与支付宝支付
## 1. 用户注册登录流程
### 1. 用户名注册
1. 首先创建一个`UserService`接口，用来定义用户相关的方法
```java
public interface UserService {
// 用户注册的时候需要先去检查数据库中是否有这个用户存在了
public boolean queryUsernameIsExist(String username);
// UserBO 相当于是根据从前端取到的用户名称、密码构造一个新的用户
public Users createUser(UserBO userBO);
}
```
2. 在`UserServiceImpl`中实现接口中的两个方法
1. 其中查询是否存在的方法需要以`Propagation.SUPPORTS`的事务传播级别
2. 创建用户的事务传播级别为`Propagation.REQUIRED`，创建失败需要回滚
3. 自定义响应数据结构 `RookieJsonResult`，前端接受此类数据（json object)后，可自行根据业务去实现相关功能
4. 其中为了设置全局唯一的用户ID，引入了`org.n3r.idworder`包
5. 为了设置时间，也引入了`DateUtil`类
6. 为了加密用户的密码，我们引入了`MD5Utils`
7. 引入性别枚举
8. 前端到后端的参数使用`UserBO`进行传递
9. 使用`postman`测试`api`层`PassportController`的功能是否正常
### 2. 邮箱注册
### 3. 手机号注册
## 2. 集成 Swagger2 API
> 为了减少程序员撰写文档的时间，使用`Swagger2`，只需要通过代码就能生成文档API提供给前端人员对接
```xml
<!-- swagger2 配置 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.4.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.4.0</version>
</dependency>
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>swagger-bootstrap-ui</artifactId>
<version>1.6</version>
</dependency>
```
1. 在`api`模块创建`config`包，创建`Swagger2.java`对象，做相关配置
2. 做好配置启动项目后，在网页中查看`http://localhost:8088/swagger-ui.html`，就能看到一份文档了。`http://localhost:8088/doc.html`也可以
3. 要想忽略某一个Controller，在他对应的类上方加上`@ApiIgnore`即可
4. 给Controller类加上接口注解，`@Api(value = "注册登录", tags = {"用户注册登录的相关接口"})`
5. 给类中某一个接口加上注解，`@ApiOperation(value = "判断用户是否存在", notes = "判断用户是否存在", httpMethod = "GET")` httpMethod要与下方请求方法相互匹配
6. 对上面的请求参数，我们也可以加上注释，在`UserBO`类中。使用`@ApiModel`和`@ApiModelProperty`
```java
@ApiModel(value = "用户对象BO", description = "从客户端，由用户传入的数据封装在此entity中")
public class UserBO {
@ApiModelProperty(value = "用户名", name = "username", example = "Allen", required = true)
private String username;
@ApiModelProperty(value = "密码", name = "password", example = "123456", required = true)
private String password;
@ApiModelProperty(value = "确认密码", name = "confirmPassword", example = "123456", required = true)
private String confirmPassword;
```
## 3. 实现跨域配置，实现前后端联调配置
配置`config`目录下的`CorsConfig`文件，使得前后端联通
## 4. 用户登录功能
1. `service`层`UserService`中添加相应方法，然后到`Controller`中写一下用户`login`的`controller`
2. 登录后要隐藏掉用户的一些属性，使用`controller`中的`setNullProperty`方法实现
3. 引入`CookieUtils`和`JsonUtils`工具类，在`login`和`regist`中设置`cookie`，实现用户信息在页面显示
## 5. 聚合日志框架
### 1. 移除默认的日志
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<!--排除这个日志jar包-->
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
```
### 2. 添加日志框架的依赖
```xml
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.21</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.21</version>
</dependency>
```
### 3. 创建 `log4j.properties` 并且放到资源文件目录下面 `src/main/resource` ，在 api 层
```properties
log4j.rootLogger=DEBUG,stdout,file
log4j.additivity.org.apache=true
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.threshold=INFO
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%-5p %c{1}:%L - %m%n
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.DatePattern='.'yyyy-MM-dd-HH-mm
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
log4j.appender.file.Threshold=INFO
log4j.appender.file.append=true
log4j.appender.file.File=/workspaces/logs/rookie-api/rookie.log
```
### 4. 使用
```java
final static Logger logger = LoggerFactory.getLogger(HelloController.class);
```
### 5. 使用 AOP 进行日志打印
1. 先在 pom 中引入相应的依赖
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
```
2. 在 api 层中加入 aspect 包，编写切面逻辑
```java
/**
* 切面表达式：
* execution 代表所要执行的表达式主体
* 第一处 * 代表方法返回类型 *代表所有类型
* 第二处 包名代表aop监控的类所在的包
* 第三处 .. 代表该包以及其子包下的所有类方法
* 第四处 * 代表类名，*代表所有类
* 第五处 *(..) *代表类中的方法名，(..)表示方法中的任何参数
*
*/
@Around("execution(* com.rookie.service.impl..*.*(..))")
public Object recordTimeLog(ProceedingJoinPoint joinPoint) throws Throwable{
...
}
```
## 6. 用户退出登录需要清除 cookie
使用到的接口就是 logout
```java
@ApiOperation(value = "用户退出登录", notes = "用户退出登录", httpMethod = "POST")
@PostMapping("/logout")
public RookieJsonResult logout(@RequestParam String userId,
HttpServletRequest request,
HttpServletResponse response) {
// 使用 Cookie 工具进行清除 Cookie名字
CookieUtils.deleteCookie(request, response, "user");
// TODO 生成用户token，存入redis会话
// TODO 同步购物车数据
return RookieJsonResult.ok();
}
```
## 7. 开启 mybatis 日志 sql 打印
方便在开发测试的时候，及时通过打印出的 sql 语句来分析问题
```yml
# mybatis 的配置中添加
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
```
# 1.2 订单、支付、购物车等
## 1. 首页轮播图
### 1. IndexController
在第一个方法，**一定记得要返回 json 形式的对象给前端！！！！！！！**
```java
@ApiOperation(value = "获取首页轮播图列表", notes = "获取首页轮播图列表", httpMethod = "GET")
@GetMapping("/carousel")
// 返回值一定要使用 RookieJsonResult
public RookieJsonResult carousel() {
List<Carousel> result = carouselService.queryAll(YesOrNo.YES.type);
return RookieJsonResult.ok(result);
}
```
### 2. 加载与渲染大分类，实现一个懒加载的方式，只有当用户鼠标移过来才进行加载
商品左侧分类导航栏，实现一种鼠标划过来才进行加载的方式
### 3. 自定义 mapper 实现懒加载子分类展示
1. 通用 mapper 无法实现复杂的查询，自己编写 SQL 查询语句，根据父分类 id 查询子分类列表
2. 创建了新的自定义的 mapper 以及对应的 mapper.xml
## 2. 实现首页商品推荐
1. `ctrl alt o` 删除没有用到的包
2. 前后端在 `ItemInfoVO` 中对应的名字要相互对应上，不然前端就拿不到这个数据
```java
// 后端
public class ItemInfoVO {
private Items item;
private List<ItemsImg> itemImgList;
private List<ItemsSpec> itemSpecList;
private ItemsParam itemParams;
}
// 前端 item.html 659 行，几个值要对应起来
var item = itemInfo.item;
var itemImgListTemp = itemInfo.itemImgList;
var itemSpecListTemp = itemInfo.itemSpecList;
this.itemParams = itemInfo.itemParams;
```
## 3. 实现商品评价
### 1. Spring Boot 整合 mybatis - pagehelper
1. 引入分页插件依赖
```xml
<!--pagehelper -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>1.2.12</version>
</dependency>
```
2. 配置 yml
```yaml
# 分页插件配置
pagehelper:
helperDialect: mysql
supportMethodsArguments: true
```
3. 使用分页插件，在查询前使用分页插件，原理：统一拦截 sql ，为其提供分页功能
```java
// ItemServiceImpl中查询前使用的分页
/**
* page: 第几页
* pageSize: 每页显示条数
*/
PageHelper.startPage(page, pageSize);
```
4. 分页数据封装到 `PagedGridResult.java` 传给前端
```java
PageInfo<?> pageList = new PageInfo<>(list);
PagedGridResult grid = new PagedGridResult();
grid.setPage(page);
grid.setRows(list);
grid.setTotal(pageList.getPages());
grid.setRecords(pageList.getTotal());
```
### 2. 评价区域，对用户信息进行脱敏
引入工具类 `DesensitizationUtil.java`
```java
import sun.applet.Main;
/**
* 通用脱敏工具类
* 可用于：
* 用户名
* 手机号
* 邮箱
* 地址等
*/
public class DesensitizationUtil {
private static final int SIZE = 6;
private static final String SYMBOL = "*";
public static void main(String[] args) {
String name = commonDisplay("慕课网");
String mobile = commonDisplay("13900000000");
String mail = commonDisplay("admin@imooc.com");
String address = commonDisplay("北京大运河东路888号");
System.out.println(name);
System.out.println(mobile);
System.out.println(mail);
System.out.println(address);
}
/**
* 通用脱敏方法
* @param value
* @return
*/
public static String commonDisplay(String value) {
if (null == value || "".equals(value)) {
return value;
}
int len = value.length();
int pamaone = len / 2;
int pamatwo = pamaone - 1;
int pamathree = len % 2;
StringBuilder stringBuilder = new StringBuilder();
if (len <= 2) {
if (pamathree == 1) {
return SYMBOL;
}
stringBuilder.append(SYMBOL);
stringBuilder.append(value.charAt(len - 1));
} else {
if (pamatwo <= 0) {
stringBuilder.append(value.substring(0, 1));
stringBuilder.append(SYMBOL);
stringBuilder.append(value.substring(len - 1, len));
} else if (pamatwo >= SIZE / 2 && SIZE + 1 != len) {
int pamafive = (len - SIZE) / 2;
stringBuilder.append(value.substring(0, pamafive));
for (int i = 0; i < SIZE; i++) {
stringBuilder.append(SYMBOL);
}
if ((pamathree == 0 && SIZE / 2 == 0) || (pamathree != 0 && SIZE % 2 != 0)) {
stringBuilder.append(value.substring(len - pamafive, len));
} else {
stringBuilder.append(value.substring(len - (pamafive + 1), len));
}
} else {
int pamafour = len - 2;
stringBuilder.append(value.substring(0, 1));
for (int i = 0; i < pamafour; i++) {
stringBuilder.append(SYMBOL);
}
stringBuilder.append(value.substring(len - 1, len));
}
}
return stringBuilder.toString();
}
}
```
## 4. 实现商品搜索
1. 需要自定义相关的 sql
2. 在搜索栏的搜索和在分类栏的搜索分开来进行，逻辑上是一样的
## 5. 实现收货地址相关
1. 收货地址的新增、修改、删除、设置默认等
2. 先从 `AddressService` 层开始设计，然后实现 `AddressServiceImpl`，再根据前端的接口，设计 `AddressController`
## 6. 确认订单（待发货部分应该有一个后台管理系统，由卖家发货，暂时没有，后面可以以一个分支的方式补上来）
> **流程:** 用户 ——> 选择商品——>加入购物车——>订单结算——>选择支付方式——>支付
## 7. 创建订单
1. 创建订单过程中的减库存操作可能会造成超卖，先使用数据库乐观锁来实现，后期**使用分布式锁（zookeeper redis）**
## 8. 微信支付
1. 账号和密码是在 `github` 上面找的
2. 需要同步更新到前端代码的 `wxpay.html` 的189行
```java
headers.add("imoocUserId", "6567325-1528023922");
headers.add("password", "342r-t450-gr4r-456y");
```
3. 要使用到内网穿透，以便使得本地的订单状态在支付之后能够和支付中心的一致
4. 使用到的工具就是 `natapp`（注意这个工具开启之后，免费的可能公网地址会变，所以不得行的时候就去修改 `BaseController` 中的 `payReturnUrl` ）
5. 这一部分的重点在于 `OrderServiceImpl.java` 中的 `createOrder()` 方法，其中包含了很多步骤
6. 在 `OrdersController` 中调用了创建订单的方法
## 9. 支付宝支付
1. 同样需要在前端代码中修改 `alipayTempTransit.html` 118 119 行的账号和密码，同上
## 10. 定时任务
1. `@Scheduled(default = " ")` 中间的字符串在这个网站可以在线生成 `https://cron.qqe2.com/`
2. 启动类开启 `@EnableScheduling // 开启定时任务`
3. 定时任务有弊端
```java
/**
* 使用定时任务关闭超期未支付订单，会存在的弊端：
* 1. 会有时间差，程序不严谨
* 10:39下单，11:00检查不足1小时，12:00检查，超过1小时多余21分钟
* 2. 不支持集群
* 单机没毛病，使用集群后，就会有多个定时任务
* 解决方案：只使用一台计算机节点，单独用来运行所有的定时任务
* 3. 会对数据库全表搜索，及其影响数据库性能：select * from order where orderStatus = 10;
* 定时任务，仅仅只适用于小型轻量级项目，传统项目
*
* 后续会涉及到消息队列：MQ-> RabbitMQ, RocketMQ, Kafka, ZeroMQ...
* 延时任务（队列）
* 10:12分下单的，未付款（10）状态，11:12分检查，如果当前状态还是10，则直接关闭订单即可
*/
```
# （阶段1.3）用户中心
1. 用户个人信息维护
2. 用户头像上传
3. 用户收货地址
4. 用户订单管理
5. 用户评论模块
## 1. 用户中心
1. 在 controller 层下面再新建一层用于存放用户中心相关，方便今后服务拆分等~
在 `CenterUserServiceImpl` 中的 `queryUserInfo` 返回给前端的是用户的所有信息，我们需要将密码隐去
### 1. 查询用户信息
```java
@Transactional(propagation = Propagation.SUPPORTS)
@Override
public Users queryUserInfo(String userId) {
Users user = usersMapper.selectByPrimaryKey(userId);
// 因为返回给前端的是用户全部信息，所以这里将密码隐去
user.setPassword(null);
return user;
}
```
### 2. 修改用户信息
1. 从前端传递到后端的用户中心的用户信息经由 `CenterUserBO` 传递
2. 在 `CenterUserController` 进行更新操作后得到的用户信息需要做一些隐藏，即 `setNullProperty` 的操作
### 3. 使用 hibernate 验证用户信息
1. `CenterUserBO`
```java
@ApiModel(value="用户对象", description="从客户端，由用户传入的数据封装在此entity中")
public class CenterUserBO {
@ApiModelProperty(value="用户名", name="username", example="json", required = false)
private String username;
@ApiModelProperty(value="密码", name="password", example="123456", required = false)
private String password;
@ApiModelProperty(value="确认密码", name="confirmPassword", example="123456", required = false)
private String confirmPassword;
@NotBlank(message = "用户昵称不能为空")
@Length(max = 12, message = "用户昵称不能超过12位")
@ApiModelProperty(value="用户昵称", name="nickname", example="杰森", required = false)
private String nickname;
@Length(max = 12, message = "用户真实姓名不能超过12位")
@ApiModelProperty(value="真实姓名", name="realname", example="杰森", required = false)
private String realname;
@Pattern(regexp = "^(((13[0-9]{1})|(15[0-9]{1})|(18[0-9]{1}))+\\d{8})$", message = "手机号格式不正确")
@ApiModelProperty(value="手机号", name="mobile", example="13999999999", required = false)
private String mobile;
@Email
@ApiModelProperty(value="邮箱地址", name="email", example="imooc@imooc.com", required = false)
private String email;
@Min(value = 0, message = "性别选择不正确")
@Max(value = 2, message = "性别选择不正确")
@ApiModelProperty(value="性别", name="sex", example="0:女 1:男 2:保密", required = false)
private Integer sex;
@ApiModelProperty(value="生日", name="birthday", example="1900-01-01", required = false)
private Date birthday;
}
```
2. 对应的 `Controller` 也要加上相应注解，`@Valid`，还有 `BindingResult`
```java
@PostMapping("update")
public RookieJsonResult update(
@ApiParam(name = "userId", value = "用户 id", required = true)
@RequestParam String userId,
@RequestBody @Valid CenterUserBO centerUserBO,
BindingResult result,
HttpServletRequest request,
HttpServletResponse response) {}
```
## 2. 上传头像
1. 先定义一个上传后文件的保存地址，暂时保存在 `F:\rookie-faces`
2. 用户上传头像的位置，使用文件分隔符来分割。避免在不同操作系统下面的错误
### 1. 属性资源文件与类映射（避免前面的那个地址在不同环境下来回切换，直接写到配置文件中）
1. 使用配置文件来配置上述那个上传后的文件保存地址
2. `resources` 目录下创建一个配置文件，`file.imageUserFaceLocation=F:\\rookie-faces`
3. 创建 `FileUpload.java` 获得文件上传的位置，并在 `Controller` 中注入这个类之后就可以获得配置的文件保存位置了。
```java
@Component
@ConfigurationProperties(prefix = "file")
@PropertySource("classpath:file-upload-dev.properties")
public class FileUpload {
private String imageUserFaceLocation;
public String getImageUserFaceLocation() {
return imageUserFaceLocation;
}
public void setImageUserFaceLocation(String imageUserFaceLocation) {
this.imageUserFaceLocation = imageUserFaceLocation;
}
}
```
### 2. 为静态资源提供网络映射服务
1. `WebMvcConfig.java`
```java
// 实现静态资源的映射
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**")
.addResourceLocations("classpath:/META-INF/resources/") // 映射swagger2
.addResourceLocations("file:F:\\rookie-faces\\"); // 映射本地静态资源
```
2. 测试的映射地址
```
http://localhost:8088/1908017YR51G1XWH/face-1908017YR51G1XWH.png
```
### 3. 更新用户头像到数据库
**文件上传，一定要对文件格式进行验证！**
1. 由于浏览器可能存在缓存，所以在更新用户头像的时候，后端带上一个时间戳，让浏览器能够及时刷新新上传的头像。
2. `CenterUserController.uploadFace()` 方法，可以好好研究一下这个地方
3. **为防止被恶意上传非图片文件，需要在后端对文件后缀进行判断**
```java
// CenterUserController.uploadFace() 中
//为防止后门，要判断一下上传的图片的格式
if (!suffix.equalsIgnoreCase("png") &&
!suffix.equalsIgnoreCase("jpg") &&
!suffix.equalsIgnoreCase("jpeg")) {
return RookieJsonResult.errorMap("图片格式不正确");
}
```
4. 限制上传文件的大小
```yaml
spring:
servlet:
multipart:
max-file-size: 5120000 # 限制上传的文件大小为500 kb
max-request-size: 512000 # 请求大小为500 kb
```
**并捕获异常**
```java
@RestControllerAdvice
public class CustomExceptionHandler {
// 上传问价超过 500 k， 捕获异常 MaxUploadSizeExceededException
@ExceptionHandler(MaxUploadSizeExceededException.class)
public RookieJsonResult handlerUploadFaceMax(MaxUploadSizeExceededException ex) {
return RookieJsonResult.errorMsg("文件大小不能超过500kb，请压缩或降低质量后再上传！");
}
}
```
## 3. 订单管理
**订单与订单状态是一对一的，订单与订单商品是一对多的**
自定义查询语句
```sql
SELECT
od.id as orderId,
od.created_time as createTime,
od.pay_method as payMethod,
od.real_pay_amount as realPayAmount,
od.post_amount as postAmount,
os.order_status as orderStatus,
oi.item_id as itemId,
oi.item_name as itemName,
oi.item_img as itemImg,
oi.item_spec_name as itemSpecName,
oi.buy_counts as buyCounts,
oi.price as price
FROM
orders od
LEFT JOIN
order_status os
on od.id = os.order_id
LEFT JOIN
order_items oi
ON od.id = oi.order_id
WHERE
od.user_id = '1908017YR51G1XWH'
AND
od.is_delete = 0
ORDER BY
od.updated_time ASC
```
### 1. 嵌套查询分页有 bug，官方 `pagehelper/Mybatis-PageHelper` 有讲
重新修改 `OrderMapperCustom.xml`
### 2. 遇到一个 bug
写完一个模块发现所有模块提示 `Result Maps collection does not contain value for` 误，把报错模块检查一边全都没有问题，重新检查新建模块是发现问题
使用 `mybatis` 的 `association` 关联查询，程序设计应该是返回实体类，一时大意写成 `resultMap`，改回 `resultType` 所有问题解决 | 22,308 | Apache-2.0 |
---
title: 検証ツールの調査
description: 検証ツールの調査
ms.assetid: d36e041f-efa5-450f-b4de-c84c4880e44d
keywords:
- WDK の動的検証ツール
- WDK の静的検証ツール
ms.date: 04/20/2017
ms.localizationpriority: medium
ms.openlocfilehash: 187eaaef53bc8030b91e19142f5db4ce79d52b16
ms.sourcegitcommit: fb7d95c7a5d47860918cd3602efdd33b69dcf2da
ms.translationtype: MT
ms.contentlocale: ja-JP
ms.lasthandoff: 06/25/2019
ms.locfileid: "67360933"
---
# <a name="survey-of-verification-tools"></a>検証ツールの調査
次の検証ツールは、WDK で説明されているし、ドライバー開発者およびテスト担当者による使用は推奨します。 これらは、その通常使用する順序に表示されます。
### <a name="span-idassoonasthecodecompilesspanspan-idassoonasthecodecompilesspanas-soon-as-the-code-compiles"></a><span id="as_soon_as_the_code_compiles"></span><span id="AS_SOON_AS_THE_CODE_COMPILES"></span>コードをコンパイルするようになります
- [Code Analysis for Drivers](code-analysis-for-drivers.md)はコンパイル時に実行する静的検証ツールです。 Windows Driver Kit にドライバー固有の拡張機能を提供する、[コード分析ツール](https://go.microsoft.com/fwlink/p/?linkid=226836)Microsoft Visual Studio Ultimate 2012。
[Code Analysis for Drivers](code-analysis-for-drivers.md) C/C++ で記述され、管理されているドライバーを確認できますコード。 調査いないドライバーの各関数のコード、独立して、ドライバーをビルドすると、すぐに実行できるようにします。 比較的短時間で実行し、いくつかのリソースを使用します。
基本的な機能、[コード分析ツール](https://go.microsoft.com/fwlink/p/?linkid=226836)戻り値をオンにしないなどの一般的なコーディング エラーを検出します。 ドライバー固有の機能は、コーディング エラーのコピーの IRP で初期化されていないフィールドをルーチンの終わりまでに変更された IRQL が復元に失敗するより微妙なドライバーを検出します。
<!-- -->
- [Static Driver Verifier](static-driver-verifier.md) (SDV) はコンパイル時に実行され、C と C++ で記述されたカーネル モード ドライバーのコードを確認する静的検証ツールです。 WDK に含まれているし、Visual Studio Ultimate 2012 から、または MSBuild を使用して、Visual Studio コマンド プロンプト ウィンドウから開始できます。
一連のインターフェイスの規則とオペレーティング システムのモデルに基づいて、Static Driver Verifier は、Windows オペレーティング システムのカーネルのドライバーが正しく対話するかどうかを決定します。 Static Driver Verifier は非常に詳細な--ドライバーのソース コード内のすべての到達可能なパスをについて説明し、シンボリックに実行します。 そのため、ドライバーのテストの他の従来のメソッドを使用して検出されないバグを検索します。
### <a name="span-idwhenthedriverrunsspanspan-idwhenthedriverrunsspanwhen-the-driver-runs"></a><span id="when_the_driver_runs"></span><span id="WHEN_THE_DRIVER_RUNS"></span>ドライバーを実行すると
ドライバーは組み込まれており、明らかなエラーなしで実行するいるとすぐには、次の動的検証ツールを使用します。
- [チェック済みの Windows ビルド](checked-build-of-windows.md)します。 検証ツールでは技術的には、Windows のチェック ビルドでは、ドライバーを実行する際に役立つ他のツールとテストではないエラーを検出します。 ドライバーの開発とテストでは、カーネル デバッガーと共にチェック ビルドを使った実行を標準の手法として含める必要があります。
- [Driver Verifier](driver-verifier.md)は特に Windows ドライバー用に記述された、動的検証ツールです。 これには、いくつかのドライバーで同時に実行できる複数のテストが含まれます。 Driver Verifier は非常に効率的でドライバー開発者が発生したドライバーで重大なバグを見つけ出すためにし、テスト担当者は、ドライバーは、開発またはテスト環境で実行されるたびに実行する Driver Verifier を構成します。 Driver Verifier は、Windows 2000 および以降のバージョンの Windows に含まれます。 ドライバーのドライバーの検証を有効にすると、ドライバーでも複数のテストを実行する必要があります。 Driver Verifier は、単独での静的検証ツールを使用して検出しにくい特定のドライバーのバグを検出できます。 これらの種類のバグの例については、次のとおりです。
- **カーネル プールのバッファー オーバーランです。** 検証済みのドライバーは、メモリ バッファーをプールに割り当て、Driver Verifier はそれらにアクセス可能なメモリのページに保護します。 ドライバーが、バッファーの末尾のメモリを使用しようとすると、ドライバーの検証ツールにバグ チェックが発行されます。
- **メモリを使用して、それを解放した後。** 特別なプールのメモリ ブロックは、独自のメモリ ページを使用してし、他の割り当てメモリ ページを共有しないでください。 ドライバーはプールのメモリ ブロックを解放して、すると、対応するメモリ ページからアクセス可能なようになります。 ドライバーがそれを解放した後、そのメモリを使用しようとすると、すぐに、ドライバーがクラッシュします。
- **管理者特権での IRQL での実行中にページング可能なメモリを使用します。** 検証済みのドライバーがディスパッチで IRQL を発生させる\_レベル、または以降では、Driver Verifier トリム、システムのワーキング セットからすべてのページング可能なメモリをシステム メモリ負荷をシミュレートします。 ページング可能な仮想アドレスのいずれかを使用すると、ドライバーがクラッシュします。
- **低リソース シミュレーション。** リソース不足の条件下でシステムをシミュレートするには、Driver Verifier はドライバーによって Api が呼び出されるさまざまなオペレーティング システムのカーネルにフェールバックできます。
- **メモリ リークが発生します。** Driver Verifier は、ドライバーによって行われるメモリ割り当てを追跡し、アンロードされたドライバーを取得する前に、メモリが解放されるようにします。
- **I/O 操作を完了するか取り消される時間がかかりすぎています。** Driver Verifier の状態に対応するため、ドライバーのロジックをテストできます\_PENDING から値を返す[**保留**](https://docs.microsoft.com/windows-hardware/drivers/ddi/content/wdm/nf-wdm-iocalldriver)します。
- **DDI 準拠の確認。** (Windows 8 以降で使用可能)Driver Verifier には、一連のドライバーとオペレーティング システムのカーネル インターフェイスの適切な相互作用をチェックするデバイス ドライバー インターフェイス (DDI) ルールが適用されます。 これらの規則は、Static Driver Verifier は、ドライバーのソース コードの分析に使用されるルールに対応します。 Driver Verifier には、DDI 準拠の検査が有効になっているときにエラーが検出されると、実行[Static Driver Verifier](static-driver-verifier.md)エラーの原因となった同じ規則を選択します。 Static Driver Verifier は、ドライバーのソース コードの不具合の原因を見つけるのに役立ちます。
- [Application Verifier](application-verifier.md)はユーザー モード アプリケーションと C と C++ で記述されたドライバーの動的検証ツールです。 マネージ コードは検証されません。 Application Verifier は、WDK に含まれていませんが、ダウンロードしてインストールしてから、 [Microsoft ダウンロード センター](https://go.microsoft.com/fwlink/p/?linkid=11573)します。 | 4,416 | CC-BY-4.0 |
---
title: 包含檔案
description: 包含檔案
services: vpn-gateway
author: cherylmc
ms.service: vpn-gateway
ms.topic: include
ms.date: 03/12/2020
ms.author: cherylmc
ms.custom: include file
ms.openlocfilehash: 34e841a5f17d589c4fbef54a4a8674a99ac6c640
ms.sourcegitcommit: a43a59e44c14d349d597c3d2fd2bc779989c71d7
ms.translationtype: MT
ms.contentlocale: zh-TW
ms.lasthandoff: 11/25/2020
ms.locfileid: "96025480"
---
必須符合下列需求，才能成功建立裝置通道：
* 裝置必須是執行 Windows 10 企業版或教育版1809或更新版本的已加入網域電腦。
* 通道只能針對 Windows 內建 VPN 解決方案進行設定，並使用與電腦憑證驗證的 IKEv2 建立。
* 每個裝置只能設定一個裝置通道。
1. 使用 [點對站 VPN 用戶端](../articles/vpn-gateway/point-to-site-how-to-vpn-client-install-azure-cert.md) 文章，在 Windows 10 用戶端上安裝用戶端憑證。 憑證必須在本機電腦存放區中。
1. 使用 [這些指示](/windows-server/remote/remote-access/vpn/vpn-device-tunnel-config#vpn-device-tunnel-configuration)，建立 VPN 設定檔，並在本機系統帳戶的內容中設定裝置通道。
### <a name="configuration-example-for-device-tunnel"></a>裝置通道的設定範例
設定虛擬網路閘道並將用戶端憑證安裝在 Windows 10 用戶端的本機電腦存放區之後，請使用下列範例來設定用戶端裝置通道：
1. 複製下列文字，並將它儲存為 ***devicecert.ps1** _。
```
Param(
[string]$xmlFilePath,
[string]$ProfileName
)
$a = Test-Path $xmlFilePath
echo $a
$ProfileXML = Get-Content $xmlFilePath
echo $XML
$ProfileNameEscaped = $ProfileName -replace ' ', '%20'
$Version = 201606090004
$ProfileXML = $ProfileXML -replace '<', '<'
$ProfileXML = $ProfileXML -replace '>', '>'
$ProfileXML = $ProfileXML -replace '"', '"'
$nodeCSPURI = './Vendor/MSFT/VPNv2'
$namespaceName = "root\cimv2\mdm\dmmap"
$className = "MDM_VPNv2_01"
$session = New-CimSession
try
{
$newInstance = New-Object Microsoft.Management.Infrastructure.CimInstance $className, $namespaceName
$property = [Microsoft.Management.Infrastructure.CimProperty]::Create("ParentID", "$nodeCSPURI", 'String', 'Key')
$newInstance.CimInstanceProperties.Add($property)
$property = [Microsoft.Management.Infrastructure.CimProperty]::Create("InstanceID", "$ProfileNameEscaped", 'String', 'Key')
$newInstance.CimInstanceProperties.Add($property)
$property = [Microsoft.Management.Infrastructure.CimProperty]::Create("ProfileXML", "$ProfileXML", 'String', 'Property')
$newInstance.CimInstanceProperties.Add($property)
$session.CreateInstance($namespaceName, $newInstance)
$Message = "Created $ProfileName profile."
Write-Host "$Message"
}
catch [Exception]
{
$Message = "Unable to create $ProfileName profile: $_"
Write-Host "$Message"
exit
}
$Message = "Complete."
Write-Host "$Message"
```
1. 複製下列文字，並將它儲存為與 _ * devicecert.ps1 * * 位於相同資料夾的 _*_VPNProfile.xml_*_ 。 編輯下列文字以符合您的環境。
* `<Servers>azuregateway-1234-56-78dc.cloudapp.net</Servers> <= Can be found in the VpnSettings.xml in the downloaded profile zip file`
* `<Address>192.168.3.5</Address> <= IP of resource in the vnet or the vnet address space`
* `<Address>192.168.3.4</Address> <= IP of resource in the vnet or the vnet address space`
```
<VPNProfile>
<NativeProfile>
<Servers>azuregateway-1234-56-78dc.cloudapp.net</Servers>
<NativeProtocolType>IKEv2</NativeProtocolType>
<Authentication>
<MachineMethod>Certificate</MachineMethod>
</Authentication>
<RoutingPolicyType>SplitTunnel</RoutingPolicyType>
<!-- disable the addition of a class based route for the assigned IP address on the VPN interface -->
<DisableClassBasedDefaultRoute>true</DisableClassBasedDefaultRoute>
</NativeProfile>
<!-- use host routes(/32) to prevent routing conflicts -->
<Route>
<Address>192.168.3.5</Address>
<PrefixSize>32</PrefixSize>
</Route>
<Route>
<Address>192.168.3.4</Address>
<PrefixSize>32</PrefixSize>
</Route>
<!-- need to specify always on = true -->
<AlwaysOn>true</AlwaysOn>
<!-- new node to specify that this is a device tunnel -->
<DeviceTunnel>true</DeviceTunnel>
<!--new node to register client IP address in DNS to enable manage out -->
<RegisterDNS>true</RegisterDNS>
</VPNProfile>
```
1. 從 [Sysinternals](/sysinternals/downloads/psexec)下載 **PsExec** ，並將檔案解壓縮至 **C:\PSTools**。
1. 從系統管理員命令提示字元，執行下列命令來啟動 PowerShell：
```
PsExec.exe Powershell for 32-bit Windows
PsExec64.exe Powershell for 64-bit Windows
```
![螢幕擷取畫面顯示 [命令提示字元] 視窗，其中包含可啟動64位版 PowerShell 的命令。](./media/vpn-gateway-vwan-always-on-device/powershell.png)
1. 在 PowerShell 中，切換至 **devicecert.ps1** 和 **VPNProfile.xml** 所在的資料夾，然後執行下列命令：
```powershell
.\devicecert.ps1 .\VPNProfile.xml MachineCertTest
```
1. 執行 **rasphone**。
![螢幕擷取畫面顯示已選取 rasphone 的 [執行] 對話方塊。](./media/vpn-gateway-vwan-always-on-device/rasphone.png)
1. 尋找 [ **MachineCertTest** ] 專案，然後按一下 **[連接]**。
![螢幕擷取畫面顯示 [網路連線] 對話方塊，其中已選取 [MachineCertTest] 和 [連線] 按鈕。](./media/vpn-gateway-vwan-always-on-device/connect.png)
1. 如果連接成功，請重新開機電腦。 通道會自動連接。 | 4,986 | CC-BY-4.0 |
---
bg: "90/90-9.jpg"
title: "日本海縦貫22～津軽半島横断～"
layout: post
date: 2020-9-21 19:00:00 +9
categories: posts
tags: '旅行記'
author: mencha
---
[前回]( {% post_url 2020-9-18-nihonkai21 %}){:target="_blank"} の続き。
三厩駅から乗車した列車を津軽二股駅で下車。
<!--more-->
### 奥津軽いまべつ駅
津軽二股駅で降りたのは、この駅のすぐそばに北海道新幹線の奥津軽いまべつ駅があるから。
そして奥津軽いまべつ駅前からは津軽半島の西側にある津軽鉄道の津軽中里駅へ向かうバスが出ており、そちらに乗車するため。
田舎にいきなり巨大な駅があらわれます。利用客数は新幹線の駅の中で最小ですが、青函トンネルの入り口にあたるので緊急時の乗降場などといった意味合いもあるみたいです。
左端が津軽線、真ん中は線路が三本あります。
新幹線は標準軌という広めの線路幅、在来線が狭軌という狭めの線路幅で、青函トンネルは在来線の貨物列車も走るため両方の列車が走行できるように線路が三本敷かれています。
高架の部分が新幹線で、下が貨物列車。この先で線路は合流し、青函トンネルに入っていきます。
せっかくなのでご当地入場券を購入して駅構内に入ってみました。この駅は青森県にありますが、新青森～新函館北斗はJR北海道の管轄なので、JR北海道の駅名標。
数少ないこの駅停車の列車がやってきました。乗降客は数名、日本一さみしい新幹線駅ですよね。
北海道新幹線も今のままでは中途半端なので、作ってしまったからには札幌まで早く延伸すべき。
この後、津軽中里駅行きのバスに乗車。本数は少ないですが1200円で津軽半島を横断でき、周遊にはもってこいです。
ですがこの日の乗客は自分含めわずか2人…これは廃止もやむなしかな…
### 津軽中里駅
乗車時間は1時間ほど、津軽中里駅に到着しました。津軽鉄道の終着・始発駅です。
津軽鉄道は五所川原市の津軽五所川原駅と中泊町の津軽中里駅を結ぶ私鉄。私鉄としては日本最北に位置しており、冬季運行のストーブ列車で有名です。
全線非電化で車両は津軽21形という気動車。そう、日本全国で見られる新潟鐵工所の標準気動車です。
塗装はオレンジに緑が基本。こちらは「走れメロス」号でした。津軽鉄道の沿線である五所川原市金木は作家・太宰治の出身地であることから、太宰さん関連のものが駅や車両の随所に見受けられます。
この車両のほか、イベントやストーブ列車ではディーゼル機関車けん引の旧型客車も運行しています。
転車台もありますが、現役なのでしょうか？
とりあえず津軽中里駅から太宰さんの生家がある金木駅まで乗車します。所要時間は30分というところでしょうか。
### 金木駅
金木駅に到着。列車は金木駅でほぼ必ず行き違いをします。そして金木～津軽中里は自動閉塞ではないので、タブレット交換が行われます。
タブレットというのは通行手形みたいなもので、それを持っている列車のみその区間に入れるというもの。単線で列車が正面衝突しないようにするためです。
交換の様子を撮りたかったのですが忘れてました…
太宰のふるさと。
次回は太宰治の生家、斜陽館を訪れたときのこと。 | 2,314 | MIT |
# 资源路径
**学习目标**
* 能够知道相对路径和绝对路径的区别
---
当我们使用img标签显示图片的时候，需要指定图片的资源路径，比如:
```html
<img src="images/logo.png">
```
这里的src属性就是设置图片的资源路径的，资源路径可以分为**相对路径和绝对路径**。
### 1. 相对路径
> 从当前操作 html 的文档所在目录算起的路径叫做相对路径
**示例代码:**
```html
<!-- 相对路径方式1 -->
<img src="./images/logo.png">
<!-- 相对路径方式2 -->
<img src="images/logo.png">
```
### 2. 绝对路径
> 从根目录算起的路径叫做绝对路径，Windows 的根目录是指定的盘符，mac OS 和Linux 是/
**示例代码:**
```html
<!-- 绝对路径 -->
<img src="/Users/apple/Desktop/demo/hello/images/logo.png">
<img src="C:\demo\images\001.jpg">
```
**提示:**
一般都会使用相对路径，绝对路径的操作在其它电脑上打开会有可能出现资源文件找不到的问题
### 3. 小结
* 相对路径和绝对路径是 html 标签使用资源文件的两种方式，一般使用相对路径。
* 相对路径是从当前操作的 html 文档所在目录算起的路径
* 绝对
路径是从根目录算起的路径 | 687 | MIT |
# Checkbox 复选框
## 使用
在页面 `json` 中引入组件：
```json
// import in `page.json`:
"usingComponents": {
"oak-checkbox": "path/to/your/oakui/Checkbox/checkbox",
"oak-checkbox-group": "path/to/your/oakui/CheckboxGroup/checkbox-group"
}
```
## 代码演示
复选框
```html
<!-- use in `page.wxml` -->
<oak-checkbox-group value="{{selected}}" bind:change="onChangeGroup">
<oak-checkbox
wx:for="{{list}}"
wx:key="{{item.id}}"
ext-class="checkbox"
name="{{item}}"
>复选框 {{item.value}}</oak-checkbox>
</oak-checkbox-group>
```
设置最多选 N 项
```html
<!-- use in `page.wxml` -->
<oak-checkbox-group value="{{maxSelected}}" bind:change="onChangeMax" max="{{2}}">
<oak-checkbox
wx:for="{{list}}"
wx:key="{{item.id}}"
ext-class="checkbox"
name="{{item}}"
>复选框 {{item.value}}</oak-checkbox>
</oak-checkbox-group>
```
## APIS
| 属性 | 说明 | 类型 | 默认值 |
|-----------|-----------|-----------|-------------|
| value | 选中项 | `Object` | - |
| change | 事件绑定 | `Function` | - |
| max | 最大N项 | `Number` | - |
## 外部样式类
| 类名 | 说明 |
|-----------|-----------|
| ext-class | 作用于根节点 | | 1,128 | MIT |
# Just Enough Administration (JEA)
Just Enough Administration は、PowerShell のリモート処理によるロールベースの管理を可能にする WMF 5.0 の新機能です。 非管理者が特定のコマンド、スクリプト、および実行可能ファイルを管理者として実行できるようにすることで、既存の制約付きエンドポイント インフラストラクチャを拡張します。 これにより、環境における完全な権限を持つ管理者の数を削減し、セキュリティを向上させることができます。 JEA は PowerShell で管理するすべてのものに有効です。PowerShell で管理できるものは、JEA によって、より安全に管理できます。 Just Enough Administration の詳細については、[エクスペリエンス ガイド](http://aka.ms/JEA)をご覧ください。
従来の制約付きのエンドポイントとは異なり、JEA は強力で構成が容易です。 JEA のユーザー機能は詳細に制御でき、特定のコマンドに指定できるパラメーター セットや値も制限できます。 ユーザーの操作は、管理者操作を実行する権限を持つ 1 回限りの仮想アカウントのコンテキストで実行されます。 ユーザーが起動するコマンドは、セキュリティの監査ログに記録されます。
JEA は、特別に構成された制約付きエンドポイントをユーザーが作成できるようにすることによって機能します。 これらのエンドポイントには、いくつかの重要な特性があります。
1. これらのエンドポイントに接続するユーザーは、このリモート セッションの間にのみ存在する特権仮想アカウントとして実行します。 既定では、この仮想アカウントは、ビルトイン Administrator グループ、およびドメイン コントローラーのドメインの Administrator のメンバーです (注: これらのアクセス許可は構成可能です)。 1 人のユーザーとして接続し、特権を持つ別のユーザーとして実行することで、権限のないユーザーに対して、システム上の管理者権限を与えることなく、特定の管理タスクの実行を許可できます。
2. エンドポイントはロックダウンされています。 これは、PowerShell が言語なしのモードで実行されることを意味します。 特定のコマンド、スクリプト、および実行可能ファイルのみがユーザーに表示されます。
3. 接続している別のユーザーには、グループのメンバーシップに基づいて、一連の異なる機能が表示されます。 同じエンドポイントで、さまざまなロールにさまざまな機能を提供できます。
<!--HONumber=Oct16_HO1--> | 1,177 | CC-BY-4.0 |
---
title: Linux 运维问题
tags: [Linux]
---
### Inode 节点占满
查看磁盘占用：
$ df -i
Filesystem Inodes IUsed IFree IUse% Mounted on
/dev/vda1 1310720 1310720 0 100% /
tmpfs 983191 1 983190 1% /dev/shm
/dev/vdb 13107200 91566 13015634 1% /data
$ df -h
Filesystem Size Used Avail Use% Mounted on
/dev/vda1 20G 9.0G 9.8G 48% /
tmpfs 3.8G 0 3.8G 0% /dev/shm
/dev/vdb 197G 131G 57G 71% /data
找出文件数量最多的目录：
$ for i in /*; do echo $i; find $i | wc -l; done
删除文件：
$ find dir -type f -name '*' | xargs rm
$ find /var/spool/clientmqueue -type f -mtime +30 -exec rm -f {} \;
### 进程跑满
错误：
-bash: fork: retry: No child processes
查看进程数限制：
$ cat /proc/sys/kernel/pid_max
49152
调整限制：
$ echo 100000 > /proc/sys/kernel/pid_max
或者查看是否有无用的进程：
$ pstree -up
### 删除文件未释放磁盘占用
$ lsof | grep delete
$ find /proc/*/fd -ls | grep '(deleted)'
$ : > "/proc/$pid/fd/$fd"
``` sh
#!/bin/bash
delete_files=$(find /proc/*/fd -ls 2>/dev/null | grep '(deleted)' | awk '{print $11}')
for delete_file in ${delete_files}; do
echo "echom "" > ${delete_file}"
: > ${delete_file}
done
```
### 清除 cache
仅清除页面缓存（PageCache）
$ sync; echo 1 > /proc/sys/vm/drop_caches
清除目录项和inode
$ sync; echo 2 > /proc/sys/vm/drop_caches
清除页面缓存，目录项和inode
$ sync; echo 3 > /proc/sys/vm/drop_caches
当内存小于 90G 时自动清理：
``` bash
#!/bin/bash
#
# /etc/cron.hourly/drop_caches.sh
#
free_mem=$(free -g | awk '/^Mem/ {print $4}')
echo "$(date +"%Y-%m-%d-%T") - before free_mem: $free_mem" >> /root/drop_caches.log 2>&1
if [[ free_mem -lt 90 ]]; then
echo "$(date +"%Y-%m-%d-%T") - drop caches" >> /root/drop_caches.log 2>&1
sync; echo 1 > /proc/sys/vm/drop_caches
else
echo "$(date +"%Y-%m-%d-%T") - do nothing" >> /root/drop_caches.log 2>&1
fi
free_mem=$(free -g | awk '/^Mem/ {print $4}')
echo "$(date +"%Y-%m-%d-%T") - after free_mem: $free_mem" >> /root/drop_caches.log 2>&1
```
### messages
$ cat /var/log/messages
...
kernel: SLUB: Unable to allocate memory on node -1 (gfp=0x8020)
...
### 连接过多丢包
`/var/log/messages`
Jan 17 11:12:09 xxg-udw38 kernel: [107394376.115531] nf_conntrack: table full, dropping packet.
`/etc/sysctl.conf`
If the problem is caused by a large number of connections, try to increase the value of `net.ipv4.netfilter.ip_conntrack_max`:
``` sh
sysctl -w net.ip4.netfilter.ip_conntrack_max=655360 //RHEL 5
sysctl -w net.netfilter.nf_conntrack_max=655360 //RHEL 6+
```
To make the changes permanent, add the following in `/etc/sysctl.conf`:
``` sh
net.ip4.netfilter.ip_conntrack_max=655360 //RHEL 5
net.netfilter.nf_conntrack_max=655360 //RHEL 6+
```
As a general best practice, do not allow too many connections on a server. A conntrack consumes 400 bytes in the kernel (see /proc/slabinfo). This means tracking 655360 connections would consume 262MB of RAM.
``` sh
for i in `docker ps | awk 'NR>1 {print $NF}'`; do
echo $i;
docker exec $i cat /proc/sys/net/netfilter/nf_conntrack_count;
done
```
### overcommit_memory
* vm.overcommit_memory=0：只要有空闲的物理内存，就允许给进程分配
* vm.overcommit_memory=1：内核在分配的时候不做检查，进程真正使用的时候，在pagefault里可能会失败
* vm.overcommit_memory=2：允许分配超过所有物理内存和交换空间总和的内存，上限是 swap + 物理mem * ratio
* vm.overcommit_memory=2，vm.overcommit_ratio=90
查看参数：
$ sysctl vm.overcommit_memory
修改参数值：
$ sysctl -w vm.overcommit_ratio=90
文件：`/etc/sysctl.conf`
### ulimit
`ulimit` 控制 shell 程序资源
``` sh
ulimit [-aHS] \
[-c <core文件上限>] \
[-d <数据节区大小>] \
[-f <文件大小>] \
[-m <内存大小>] \
[-n <文件数目>] \
[-p <缓冲区大小>] \
[-s <堆栈大小>] \
[-t <CPU时间>] \
[-u <程序数目>] \
[-v <虚拟内存大小>]
```
* -H 设置硬件资源限制,是管理员所设下的限制.
* -S 设置软件资源限制,是管理员所设下的限制.
* -a 显示当前所有的资源限制.
* -u 进程数目:用户最多可启动的进程数目.
* -c size:设置core文件的最大值.单位:blocks
* -d size:设置程序数据段的最大值.单位:kbytes
* -f size:设置shell创建文件的最大值.单位:blocks
* -l size:设置在内存中锁定进程的最大值.单位:kbytes
* -m size:设置可以使用的常驻内存的最大值.单位:kbytes
* -n size:设置内核可以同时打开的文件描述符的最大值.单位:n
* -p size:设置管道缓冲区的最大值.单位:kbytes
* -s size:设置堆栈的最大值.单位:kbytes
* -t size:设置CPU使用时间的最大上限.单位:seconds
* -v size:设置虚拟内存的最大值.单位:kbytes
内核可以同时打开的文件描述符默认是1024，在高负载下要设置为更高，可以通过以下命令修改
$ ulimit -SHn 65535
ulimit只能做临时修改，重启后失效。
可以加入到 `/etc/rc.local` 文件，每次启动启用。
可以通过修改 `/etc/security/limits.conf` 永久调整 Linux 系统的最大进程数和最大文件打开数限制，
``` limits
#<domain> <type> <item> <value>
* soft nproc 11000
* hard nproc 11000
* soft nofile 655350
* hard nofile 655350
```
同样需要注意 `/etc/security/limits.d` 目录下的文件，目录下文件与 `/etc/security/limits.conf` 有相同 domain 的配置时，会覆盖 `/etc/security/limits.conf` 中的配置
cat /proc/29097/limits
prlimit -n4096 -p pid_of_process
https://stackoverflow.com/questions/3734932/max-open-files-for-working-process
### oom
* `/proc/$PID/oom_adj`: 有效值是 -16 到 15，越大越容易被 kill。
* `/proc/$PID/oom_score`: 综合进程的内存消耗量、CPU时间(utime + stime)、存活时间(uptime - start time)和oom_adj计算出的，消耗内存越多分越高，存活时间越长分越低
* `/proc/$PID/oom_score_adj`: 有效值是 -1000 到 1000，Linux 2.6.36 之后用于替换 `/proc/$PID/oom_adj`
[](https://learning-kernel.readthedocs.io/en/latest/mem-management.html)
[](https://github.com/Yhzhtk/note/issues/31)
[](https://dev.to/rrampage/surviving-the-linux-oom-killer-2ki9)
### keepalive
`/etc/sysctl.conf`
``` sysctl
# 空闲时长/发送心跳的周期 7200s
net.ipv4.tcp_keepalive_time=7200
# 探测包发送间隔 75s
net.ipv4.tcp_keepalive_intvl=75
# 达到 tcp_keepalive_time 后，没有接收到对方确认，继续发送探测包次数
net.ipv4.tcp_keepalive_probes=9
```
### 磁盘使用率
# df
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/vda1 20504188 4314736 15124852 23% /
tmpfs 16321844 0 16321844 0% /dev/shm
/dev/vdb 1548053708 1129305312 340088812 77% /data
# node
> 1129305312 / 1548053708
0.7295000852774031
> (1548053708 - 340088812) / 1548053708
0.7803120071077018
> 1548053708 - 1129305312 - 340088812
78659584
>
`df` 显示的 `Used + Available != 1K-blocks(total)`，这是因为 `ext2/3/4` 文件系统默认保留 `5%` 的的可用空间给 `root` 用户，这样即使磁盘使用率达到 100%，仍有系统组件和操作管理所需的工作空间
使用 `tune2fs -l /dev/vdb` 可用查看 Reserved block count 和其他文件系统的信息。
使用 `tune2fs -m <eserved-blocks-percentage> /dev/vdb` 调整保留块的百分比。
如果要计算使用率，可以使用 `(total - Available) / total` | 6,282 | MIT |
---
title: Python 简介
icon: info
time: 2020-6-7
category: Python
tag: Python
---
本节将简单介绍 Python 的历史。
<!-- more -->
Python 是 Guido van Rossum(“龟叔”) 在 1989 年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。
总的来说，这几种编程语言各有千秋。C 语言是可以用来编写操作系统的贴近硬件的语言，所以，C 语言适合开发那些追求运行速度、充分发挥硬件性能的程序。而 Python 是用来编写应用程序的高级编程语言。
当您用一种语言开始作真正的软件开发时，您除了编写代码外，还需要很多基本的已经写好的现成的东西，来帮助您加快开发进度。比如说，要编写一个电子邮件客户端，如果先从最底层开始编写网络协议相关的代码，那估计一年半载也开发不出来。高级编程语言通常都会提供一个比较完善的基础代码库，让您能直接调用，比如，针对电子邮件协议的 SMTP 库，针对桌面环境的 GUI 库，在这些已有的代码库的基础上开发，一个电子邮件客户端几天就能开发出来。
Python 就为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容，被形象地称作“内置电池(batteries included)”。用 Python 开发，许多功能不必从零编写，直接使用现成的即可。
除了内置的库外，Python 还有大量的第三方库，也就是别人开发的，供您直接使用的东西。当然，如果您开发的代码通过很好的封装，也可以作为第三方库给别人使用。
许多大型网站就是用 Python 开发的，例如 YouTube、Instagram，还有国内的豆瓣。很多大公司，包括 Google、Yahoo 等，甚至 NASA(美国航空航天局)都大量地使用 Python。
龟叔给 Python 的定位是“优雅”、“明确”、“简单”，所以 Python 程序看上去总是简单易懂，初学者学 Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。
总的来说，Python 的哲学就是简单优雅，尽量写容易看明白的代码，尽量写少的代码。如果一个资深程序员向您炫耀他写的晦涩难懂、动不动就几万行的代码，您可以尽情地嘲笑他。
那 Python 适合开发哪些类型的应用呢？
首选是网络应用，包括网站、后台服务等等；
其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；
另外就是把其他语言开发的程序再包装起来，方便使用。
最后说说 Python 的缺点。
任何编程语言都有缺点，Python 也不例外。优点说过了，那 Python 有哪些缺点呢？
第一个缺点就是运行速度慢，和 C 程序相比非常慢，因为 Python 是解释型语言，您的代码在执行时会一行一行地翻译成 CPU 能理解的机器码，这个翻译过程非常耗时，所以很慢。而 C 程序是运行前直接编译成 CPU 能执行的机器码，所以非常快。
但是大量的应用程序不需要这么快的运行速度，因为用户根本感觉不出来。例如开发一个下载 MP3 的网络应用程序，C 程序的运行时间需要 0.001 秒，而 Python 程序的运行时间需要 0.1 秒，慢了 100 倍，但由于网络更慢，需要等待 1 秒，您想，用户能感觉到 1.001 秒和 1.1 秒的区别吗？这就好比 F1 赛车和普通的出租车在北京三环路上行驶的道理一样，虽然 F1 赛车理论时速高达 400 公里，但由于三环路堵车的时速只有 20 公里，因此，作为乘客，您感觉的时速永远是 20 公里。
第二个缺点就是代码不能加密，这点跟前端广泛使用的 JS 相同。如果要发布您的 Python 程序，实际上就是发布源代码，这一点跟 C 语言不同，C 语言不用发布源代码，只需要把编译后的机器码(也就是您在 Windows 上常见的 xxx.exe 文件)发布出去。要从机器码反推出 C 代码是不可能的，所以，凡是编译型的语言，都没有这个问题，而解释型的语言，则必须把源码发布出去。
这个缺点仅限于您要编写的软件需要卖给别人挣钱的时候。好消息是目前的互联网时代，靠卖软件授权的商业模式越来越少了，靠网站和移动应用卖服务的模式越来越多了，后一种模式不需要把源码给别人。
再说了，现在如火如荼的开源运动和互联网自由开放的精神是一致的，互联网上有无数非常优秀的像 Linux 一样的开源代码，我们千万不要高估自己写的代码真的有非常大的“商业价值”。那些大公司的代码不愿意开放的更重要的原因是代码写得太烂了，一旦开源，就没人敢用他们的产品了。 | 1,955 | MIT |
---
title: "AlminでFluxアーキテクチャをやってみる"
author: azu
layout: post
date : 2017-03-17T19:33
category: JavaScript
tags:
- JavaScript
- Flux
- Almin
---
[Almin](https://github.com/almin/almin "Almin")でFluxアーキテクチャについてを見ていく話です。
AlminはいわゆるFluxライブラリ的なものですが、ドメイン駆動設計（DDD）を行うにあたって既存の[Redux](https://github.com/reactjs/redux "Redux")や[Flux](https://github.com/facebook/flux "Flux")では上手くレイヤー分けをやりにくい部分がありました。
この辺の経緯については以前スライドやドキュメントにまとめてあるので、以下を参照してください。
- [azu/large-scale-javascript: 複雑なJavaScriptアプリケーションを作るために考えること](https://github.com/azu/large-scale-javascript)
- [複雑なJavaScriptアプリケーションを考えながら作る話](http://azu.github.io/slide/2016/react-meetup/large-scale-javascript.html)
この記事では、実際のサンプルコードを見ていきながら、Flux的なデータフローについて見ていきます。
## Alminでカウンターアプリを作る
このサンプルでは[Almin](https://github.com/almin/almin "Almin")を使って次のようなカウンターアプリを作っていきます。
次に英語のチュートリアルもあるので参照してください。
- [Counter App · Almin.js](https://almin.js.org/docs/tutorial/counter/ "Counter App · Almin.js")
## Source Code
ソースコードは次の場所にあります。
- <https://github.com/almin/almin/tree/master/examples/counter>
```sh
git clone https://github.com/almin/almin.git
cd almin/example/counter
npm install
npm start
# manually open
open http://localhost:8080/
```
## ディレクトリ構造
最終的なディレクトリ構造を最初に見ておくとイメージがしやすいかもしれません。
データの流れとしては、Component -> UseCase -> Storeとなりますが、実装の順序はこの順序じゃなくても問題ありません。
```
src/
├── index.js
├── component
│ ├── App.js
│ └── Counter.js
├── usecase
│ └── IncrementalCounterUseCase.js
└── store
├── CounterState.js
└── CounterStore.js
```
Alminの構成要素については[Component of Almin](https://almin.js.org/docs/abstract/)を参照してみてください。
このサンプルでは、最小限の要素のみが登場しています。
- View
- ユーザーが自由に選ぶ
- ここではReactを選択
- Store
- アプリの状態（State）を保存する
- Stateが変わったことを（Viewへ）通知する
- UseCase
- ユーザーが行いたい処理の**流れ**を書く場所
他のライブラリと見比べてみると次のような形になります。
このサンプルは状態が1つしかないため、複数のStoreをまとめるStoreGroupや、
ロジックが殆どないためDomainといった要素は登場していません。
## カウンターの機能
1. ユーザーがボタンを押したら+1する
以上。
つまり、このカウンターは「ユーザーがボタンを押したら+1する」というUseCaseがあります。
## UseCase
カウンターの機能をUseCaseという形で実装します。
UseCaseとは、ユーザーとシステムのやり取りを対話的に書いたものです。
簡単にいえば、ユースケースにはユーザーがシステムとやり取りする手順を書いていきます。
カウンターの例では複雑な手順が出てこないため、ユーザーがUIを操作した時に行うアクションを書く場所と考えれば問題ありません。
> 1. ボタンを押したら+1する
基本的にAlminでは1 UseCase 1ファイル（クラス）として実装します。
これを実現する`IncrementalCounterUseCase.js`を作成します。
Alminの`UseCase`クラスを継承し、`execute()`メソッドに行いたい処理実装します。
```js
"use strict";
import { UseCase } from "almin";
export default class IncrementalCounterUseCase extends UseCase {
// UseCase should implement #execute method
execute() {
// Write the UseCase code
}
}
```
ここで行いたい処理というのは、カウンターを+1することです。
つまり、`IncrementalCounterUseCase`が実行されたときに、**CounterアプリのState**を更新したいわけです。
そのためには、まず**CounterアプリのState**を保持する場所が必要です。
ここでは、**CounterアプリのState**を**Store**という入れ物の中に実装します。
## Store
まずは、`CounterStore`という`Store`クラスを継承したものを作成します。
```js
"use strict";
import { Store } from "almin";
export class CounterStore extends Store {
constructor() {
super();
// receive event from UseCase, then update state
}
// return state object
getState() {
return {
count: 0
};
}
}
```
Alminの`Store`は`UseCase`から`dispatch`されたpayloadを受け取ることができます。
つまり次のような流れを実装します。
1. IncrementalCounterUseCaseが"increment" payloadをdispatchします
2. CounterStoreは"increment" payloadを受け取り、自分自身のstateを更新します
これはいわゆるFluxパターンです
Fluxでは次のような説明になります。
1. ActionCreatorで"increment" actionを作りdispatchします
2. CounterStoreは"increment" payloadを受け取り、自分自身のstateを更新します
## **UseCase** dispatch -> Store
`IncrementalCounterUseCase`に話を戻して、「"increment" payloadをdispatch」を実装します。
```js
"use strict";
import { UseCase } from "almin";
export default class IncrementalCounterUseCase extends UseCase {
// IncrementalCounterUseCase dispatch "increment" ----> Store
// UseCase should implement #execute method
execute() {
this.dispatch({
type: "increment"
});
}
}
```
`UseCase`クラスを継承したクラスは`this.dispatch(payload)`メソッド利用できます。
`payload`オブジェクトは`type`プロパティを持ったオブジェクトです。
次の`payload`は最小のものといえます。
```js
{
type: "type";
}
```
次のように`type`以外のプロパティも持たせることができます。
```js
{
type : "show",
value: "value"
}
```
つまり、先ほど実装した`IncrementalCounterUseCase`は、`"increment"`いう`type`のpayloadをdispatchしています。
## UseCase -> **Store** received
次は`CounterStore` が "increment" payloadを受け取れるようにします。
`Store`クラスを継承したクラスは、`this.onDispatch(function(payload){ })`メソッドが利用できます。
```js
import { Store } from "almin";
export class CounterStore extends Store {
constructor() {
super();
// receive event from UseCase, then update state
this.onDispatch(payload => {
console.log(payload);
/*
{
type: "increment"z
}
*/
});
}
getState() { /* stateを返す */ }
}
```
`Store#onDispatch`メソッドで、UseCaseがdispatchしたpayloadを受け取れます。
受け取ったら`CounterStore`のstateをアップデートします。
その前に、Alminでは多くの場合StoreがStateを別々のクラスとして実装しています。
つまり、`CouterStore`は`CounterState`のインスタンスをもつという形にしています。
**Store**
- dispatchや変更を監視、Stateを保持する層
**State**
- ステート！
## State
まずは`CounterState.js`を作成します。
State自体はただのJavaScriptで、Alminとして`State`のようなクラスは提供していません。
`CounterState`の目的は
- "payload"を受け取り、新しいStateを返す
```js
export default class CounterState {
/**
* @param {Number} count
*/
constructor({ count }) {
this.count = count;
}
reduce(payload) {
switch (payload.type) {
// Increment Counter
case "increment":
return new CounterState({
count: this.count + 1
});
default:
return this;
}
}
}
```
このパターンはどこかで見たことがあるかもしれません。
Reduxの **reducer** と呼ばれるものによく似たものを実装しています。
- [Reducers | Redux](http://redux.js.org/docs/basics/Reducers.html "Reducers | Redux")
- [Flux | Application Architecture for Building User Interfaces](https://facebook.github.io/flux/docs/flux-utils.html "Flux | Application Architecture for Building User Interfaces")
## Store -> State: NewState
最後に、`CounterStore`へStateを更新するコードをを追加したら完成です。
1. dispatchされたpayloadを受け取り、`CounterState`を更新を試みます
2. もし`CounterState`が更新されたなら, `CounterStore#emitChange`を叩き変更を通知します
3. `getState(){}`ではStateのインスタンスを返します
`Store`を継承したクラスは`this.emitChange()`メソッドを持っています。
これは、Storeを監視しているもの（主にView）に対して、Store（State）が変わったことを通知しています。
```js
"use strict";
import { Store } from "almin";
import CounterState from "./CounterState";
export class CounterStore extends Store {
constructor() {
super();
// initial state
this.state = new CounterState({
count: 0
});
// receive event from UseCase, then update state
this.onDispatch(payload => {
const newState = this.state.reduce(payload);
if (newState !== this.state) {
this.state = newState;
this.emitChange();
}
});
}
getState() {
return this.state;
}
}
```
### Side note: Testing
UseCase、Store、Stateと分かれているのでテストも書くのは簡単です。
次の場所にテストコードもあります。
- [almin/example/counter/test at master · almin/almin](https://github.com/almin/almin/tree/master/example/counter/test "almin/example/counter/test at master · almin/almin")
## View Integration
ここでは、Viewの例として[React](https://facebook.github.io/react/ "React")を使っています。
### App
`App.js`というコンポーネント、いわゆるContainer Componentを作成します。
次に`Context`オブジェクトを作成します。
`Context`オブジェクトとはStoreとUseCaseを繋ぐ役割をするものです。
次のように、StoreのインスタンスとDispatcherのインスタンスを渡して初期化しています。
ここではStoreが1つのみですが、Alminでは複数のStoreをまとめるStoreGroupというものも用意しています。
StoreGroupには `{ State名: Store }` というように対応関係のマッピングオブジェクトを渡します。
`StoreGroup#getState`で `{ State名: Store#getState()結果 }`が取得できます。
```js
import { Context, Dispatcher } from "almin";
import { CounterStore } from "../store/CounterStore";
// a single dispatcher
const dispatcher = new Dispatcher();
// a single store. if you want to use multiple, please use StoreGroup!
const store = new CounterStore();
// StoreGroupを
const storeGroup = new StoreGroup({
// stateName : store
counter: store
});
const appContext = new Context({
dispatcher,
store: storeGroup
});
```
```js
"use strict";
import React from "react";
import { Context, Dispatcher } from "almin";
import { CounterStore } from "../store/CounterStore";
// a single dispatcher
const dispatcher = new Dispatcher();
// a single store
const store = new CounterStore();
const appContext = new Context({
dispatcher,
store
});
import Counter from "./Counter";
export default class App extends React.Component {
constructor(...args) {
super(...args);
this.state = appContext.getState();
}
componentDidMount() {
// when change store, update component
const onChangeHandler = () => {
return requestAnimationFrame(() => {
this.setState(appContext.getState());
});
};
appContext.onChange(onChangeHandler);
}
render() {
/**
* Where is "CounterState" come from?
* It is a `key` of StoreGroup.
*
* ```
* const storeGroup = new StoreGroup({
* "counter": counterStore
* });
* ```
* @type {CounterState}
*/
const counterState = this.state.counter;
return <Counter counterState={counterState}
appContext={appContext}/>;
}
}
```
App.jsを見てみると、
```js
appContext.onChange(onChangeHandler);
```
これは、`CounterStore` が変更される(`emitChange()`を叩く)と`onChangeHandler`が呼ばれることを意味しています。
そして、`onChangeHandler` は`App` componentのState（ReactのState）を更新します。
### Counter component
後は、`counterState`をCounterComponent（実際にcountを表示するView）が受け取り、カウントの値を表示すれば完成です。
カウントを更新したい場合は、作成したIncrementalCounterUseCaseを`context.useCase(new IncrementalCounterUseCase()).execute(渡したい値);`で呼び出すことができます。
```js
context.useCase(new IncrementalCounterUseCase()).execute();
```
```js
"use strict";
import React from "react";
import IncrementalCounterUseCase from "../usecase/IncrementalCounterUseCase";
import { Context } from "almin";
import CounterState from "../store/CounterState";
export default class CounterComponent extends React.Component {
constructor(props) {
super(props);
}
incrementCounter() {
// execute IncrementalCounterUseCase with new count value
const context = this.props.appContext;
context.useCase(new IncrementalCounterUseCase()).execute();
}
render() {
// execute UseCase ----> Store
const counterState = this.props.counterState;
return (
<div>
<button onClick={this.incrementCounter.bind(this)}>Increment Counter</button>
<p>
Count: {counterState.count}
</p>
</div>
);
}
}
CounterComponent.propTypes = {
appContext: React.PropTypes.instanceOf(Context).isRequired,
counterState: React.PropTypes.instanceOf(CounterState).isRequired
};
```
これにより、一般的なFluxの一方こうのデータフローが次のようにできていることが分かります。
- React -> UseCase -> Store（State） -> React
## Alminとロガー
Alminはアプリケーションのログをキチンと取れるようにするという設計の思想があります。
そのため、`Context`にはAlminがやっていることを通知するイベントがあり、これを利用して殆どのログがとれます。
[almin-logger](https://github.com/almin/almin-logger "almin-logger")という開発用のロガーライブラリが用意されているので、これを先ほどのサンプルに入れて動かしてみます。
- [almin-logger](https://github.com/almin/almin-logger "almin-logger")
3行追加するだけで次のような、UseCaseの実装やそのUseCaseによるStoreの変更などがコンソールログとして表示されます。
```js
import ContextLogger from "almin-logger";
const logger = new ContextLogger();
logger.startLogging(appContext);
```
<iframe src="//giphy.com/embed/3og0ICodJBeY3BQk1y" width="480" height="392" frameBorder="0" class="giphy-embed" allowFullScreen></iframe><p><a href="http://giphy.com/gifs/3og0ICodJBeY3BQk1y">via GIPHY</a></p>
また、Reduxを使ったことがある人は[Redux DevTools](https://github.com/gaearon/redux-devtools "Redux DevTools")というブラウザ拡張で動く開発者ツールを使ったことがあるかもしれません。
この拡張実は任意のFluxライブラリと連携するAPIも公開されています。
- [Redux DevTools Extension](https://github.com/zalmoxisus/redux-devtools-extension "Redux DevTools Extension")
Alminでは[almin-devtools](https://github.com/almin/almin-devtools "almin-devtools")を使うことで、
[Redux DevTools](https://github.com/gaearon/redux-devtools "Redux DevTools")と連携できます。
ブラウザに[Redux DevTools](https://github.com/gaearon/redux-devtools "Redux DevTools")をインストールします。
- Chrome: [Chrome Web Store](https://chrome.google.com/webstore/detail/redux-devtools/lmhkpmbekcpmknklioeibfkpmmfibljd);
- Firefox: [Mozilla Add-ons](https://addons.mozilla.org/en-US/firefox/addon/remotedev/);
- Electron: [`electron-devtools-installer`](https://github.com/GPMDP/electron-devtools-installer)
そして、3行加えるだけで、Alminのログを[Redux DevTools](https://github.com/gaearon/redux-devtools "Redux DevTools")で見ることができます。（タイムマシーンデバッグなどはアプリ側でちゃんと実装しないと動かないので制限があります）
```js
import AlminDevTools from "almin-devtools";
const logger = new AlminDevTools(appContext);
logger.connect();
```
<iframe src="//giphy.com/embed/3ohzdEYLL9sEapqPUA" width="480" height="482" frameBorder="0" class="giphy-embed" allowFullScreen></iframe><p><a href="http://giphy.com/gifs/3ohzdEYLL9sEapqPUA">via GIPHY</a></p>
この辺のログ取ることによる開発時のメリットなどについては次の文章でまとめてあります。
- [azu/large-scale-javascript: 複雑なJavaScriptアプリケーションを作るために考えること](https://github.com/azu/large-scale-javascript "azu/large-scale-javascript: 複雑なJavaScriptアプリケーションを作るために考えること")
## おわりに
Alminで簡単なカウンターアプリを作成しました。
この例では典型的なFluxのパターンをAlminで行えていることが分かります。
実際のアプリケーションでは、StoreやUseCaseが1つだけというものはあまりないと思います。
TodoMVCの例では、CQRSやドメインモデルなどの要素も登場し、複数のUseCaseを実装していきます。
- [Todo App · Almin.js](https://almin.js.org/docs/tutorial/todomvc/ "Todo App · Almin.js")
Alminは元々ある程度複雑になるであろうアプリケーションのために作成しています。
ただし、複雑なアプリケーションの開発を支えるのは設計や開発方法が主で、ライブラリはその一部分に過ぎません。
そのため、小さく使おうと思えば[facebook/flux](https://github.com/facebook/flux "facebook/flux")や[Redux](https://github.com/reactjs/redux "Redux")などと使い勝手はそこまでは代わりません。
設計思想としてアプリケーションが大きくなることを前提としているので、
大きくなってきた時のレイヤリングのしやすさやログなど開発の補助の充実に力を入れています。
どれだけ短く書けるかよりも、どれだけ読みやすく書けて管理できるかの方がメインといえるかもしれません。
この辺の話は、次のスライドやリポジトリを見てみるとよいかもしれません。
- スライド: [複雑なJavaScriptアプリケーションを考えながら作る話](http://azu.github.io/slide/2016/react-meetup/large-scale-javascript.html "複雑なJavaScriptアプリケーションを考えながら作る話")
- [azu/large-scale-javascript: 複雑なJavaScriptアプリケーションを作るために考えること](https://github.com/azu/large-scale-javascript "azu/large-scale-javascript: 複雑なJavaScriptアプリケーションを作るために考えること") | 14,710 | MIT |
---
template: post
title: "【51锐评】辽宁私立学校倒闭，疯狂的教育私有化榨干了我们最后一分钱"
date: 2020-11-10
tags: shiping
image:
teaser: /202011/jiaoyusiyouhua1.jpg
excerpt_separator: <!--more-->
---
<div style="width:98%;padding:10px;background-color:black;color:white;margin:0;"><strong>编者按：</strong>令很多已经成家的工友头疼的一件事就是孩子的上学问题：孩子是接到身边来，还是留在老家上学？自己打工的城市有没有孩子上学的机会？平时夫妻两人都要上班，谁来照顾孩子？是去公立学校，还是私立学校？高昂的学费怎么凑？这些问题已经让我们够纠结了，但是更重要的问题还有一个：如今，咱们穷人的孩子还能通过教育找到出路吗？<br><br>
昨天，我们看到教育私有化为什么会导致我们<a href="/2020/11/09/shiping-yousheng/">在求学路上遇到越来越多坑人的事件</a>。今天，我们再来看看公共教育被瓦解和教育私有化对我们孩子的未来有什么影响。<br><br>
</div><br>
9月份，辽宁省阜新市两所学校突然倒闭，校长跑路，学生撕书，已经缴纳的高昂学费没有说法，而即将高考的高三学生茫然失措。
据报道，这两所学校名为辽宁阜新市博创学校、阜新市博创工贸中等职业技术学校，系私人办学，隶属北京砺仁投资控股（集团）股份有限公司。这个公司旗下学校涵盖了幼儿园、小学、初中、高中、中职，也就是这些年很火的K12教育。
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua1.jpg" width="98%"></div><br>
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua2.jpg" width="98%"></div><br>
学校倒闭的原因暂无确切消息，据说是资金链断裂。这个说法有道理，据上游新闻报道，阜新市博创工贸中等职业技术学校因借款合同纠纷被起诉有15起。
远在东北的学校倒闭，看起来和在南方打工的我们关系不大。但是这两所学校倒闭， 是教育私有化以来的恶劣现象之一，而我们同样也在承受着教育私有化的恶果。在深圳这种大城市，很多打工家庭也只能付出高昂的学费让孩子就读私立学校。**都说教育面前人人平等，但教育私有化告诉我们，有钱人比我们更平等。**
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua3.jpg" width="98%"></div><br>
<div style="text-align:center"><h3>一、恐怖的教育私有化</h3></div>
教育私有化，是上个世纪90年代以来教育产业化的诸多现象之一，即出现了大量的私立学校。
这里要注意，因为《中华人民共和国民办教育促进法》不允许设立实施义务教育的营利性民办学校，即不允许资本家开办小学和初中，因而许多地方民办学校是私立高中、私立职业学校、私立高等院校（大专、本科这些大学）。而私立高中、职校、高等院校因为要营利，收费是十分高昂的。
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua4.jpg" width="98%"></div><br>
例如民办高中，可能动辄学费数万一年。就比如有网友现身说法，他所在的三四线城市私立学校学费2.6万一年，相当于我们普工大半年的收入。
有人或许疑惑，“价格这么贵，为啥不去就读公立学校呢？”
因为**私立学校在建校之初，可以给出比公立学校高出数倍的待遇挖走优秀的老师，给招生老师大量的招生补贴，让他们尽可能招到好学生，给高分考生高昂奖金邀请他们到学校复读等，短时间内快速提高升学率。**因此，有不少地方的私立高中俨然有了垄断之势。比如在江西省余干县，公立高中根本无法与私立学校竞争了。
有人可能会说，“这也不是什么坏事呀，只要教学质量好就行。”
但是事实上，私立高中如果挤垮了一个地区的公立高中，当地家长就必须付出高昂的学费将孩子送到私立高中去，对普通家庭而言，无疑是一个沉重的负担。**更恶劣的是，私立学校开始坐地起价，大涨学费，同时降低教师的待遇，露出它追求利润最大化的真面目。**
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua5.jpg" width="98%"></div><br>
<div style="text-align:center"><h3>二、教育高投入，压在底层身上的大山</h3></div>
事实上，私立学校的主要收入来源，便是学费。在四川，有个私立K12教育集团，叫成实外，已在香港上市。截至2020年上半年，该集团总学费收入为7.6亿，占据了学校总收入的86.1%。当年该集团学生人数大概53000多人，平均下来，每个学生缴纳的学费应该超过1.4万。其他私立学校收入，应该也大同小异。就读成本之高，可见一斑。
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua6.jpg" width="98%"></div><br>
现在的孩子还有另外一个称呼，叫“吞金兽”，意思是这个孩子长大，需要花费无数金钱，教育、医疗、住房、结婚等各个方面都需要。而私立学校占据主导地位，受伤害最深的只能是最底层的家庭，也就是我们这些打工的。有钱人？他们读的虽然也是私立学校，但是是最好的私立学校。
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua7.jpg" width="98%"></div><br>
大家如果留心，就会发现老家的教育已经发生了很大变化。乡镇中学老师流失，生源萎缩。很多家庭从孩子上小学开始就送他们去县城读书了，其中花费，相比于以前多出了数倍不止。但为了让孩子接受更好的教育，许多父母咬咬牙也要让孩子去城里上学。
在广东，像深圳、广州这样的大城市里，公立学位十分紧张，打工家庭基本很难排得到，只能选择私立学校就读——这就意味着更高的投入。例如，根据上半年“深圳升学办”自媒体发布的一份“深圳市南山区私立小学学费排名表”，各小学收费从3000元～74000元不等。无论怎样，都远高于公立学校。同时，学费的差别背后，也是不同的阶级差别。
<div style="text-align:center;color:grey"><img src="/images/202011/jiaoyusiyouhua8.jpg" width="98%"></div><br>
中国的社会已经贫富差距非常大了，社会的不平等程度也很严重。而教育私有化，则将进一步加剧这一不平等。教育私有化，学校就是靠私人资本砸出来。有钱的上最好的学校，没钱的上最差的学校。长此以往，老板的孩子继续当老板，打工的孩子只能继续打工。
过去中国的社会主义革命，消灭了资本家、消灭了剥削者，希望建立一个人人平等的社会。而今天，一切仿佛都回到了解放前。工人的孩子出生就注定了不会有资本阶级孩子的那些机会。
咱们穷人很多都喜欢幻想以教育改变命运，因此大量扎钱进去，投资孩子的未来。我劝大家，还是不要浪费自己的血汗钱，浪费孩子的青春，逼他玩资产阶级这个游戏了。这套游戏只利于那些收入是我们的千万倍的资产阶级。我们的孩子，拼命参与竞争只会让竞争变得更加激烈，孩子更加辛苦，最后还是走不出资本家的套圈。只要我们没有钱，孩子最后也会成为一个打工的。
与其拼命扎钱给孩子买学历，不如拒绝这个游戏，教孩子认识真实社会，认识劳动创造了这个世界，认识劳动是光荣的。还有认识这个世界应属于我们，而不是属于那些因为钱多就可以买最好的教育和最高的学历的资产阶级富二代。无论是小学生的培训班还是昂贵的大专学历，我们都不要觉得必须上，不要幻想上了就有出路。我们应该给予我们的孩子一个真正的无产阶级教育，教他们认识只有团结起来夺回本应该属于我们的东西才会有出路。 | 3,690 | MIT |
# 中间件式框架简单实现
## 前言
熟悉`Node.js` `WEB`开发的小伙伴肯定知道，在`Node.js`世界里，基本所有`WEB`开发的框架都是基于中间件形式架构。中间件架构大部分以`HTTP`的生命周期切面来提供中间件的处理，既能在任何开发语言低成本实现，又能符合开发者操作思维，方便生态的扩展。
综上所诉，实现一个`Deno`的`WEB`框架，中间件式的框架是比较低成本和大众高接受度，本篇将基于`Koa.js`的洋葱模型中间件机制，集合上一章节里的 [5.8 原生Deno处理HTTP请求](https://github.com/chenshenhai/deno_note/blob/master/note/chapter_05/08.md)、 [5.9 原生Deno处理HTTP响应](https://github.com/chenshenhai/deno_note/blob/master/note/chapter_05/09.md) 和 [5.10 原生Deno实现稳定HTTP服务](https://github.com/chenshenhai/deno_note/blob/master/note/chapter_05/10.md) 打造一个健壮的 `Deno`版 `Koa.js`。
## 实现过程
- 提供一个可让中间件安全操作的`HTTP`上下文(`Context`)
- `Request`安全操作，限制中间件只能去取请求行、请求头和请求体三种数据
- `Response`安全操作
- 限制中间件只能设置响应状态、响应头和响应体操作
- 同时加上设置响应结束保护处理，防止响应设置提前结束，剩余中间件操作对响应数据的影响
- 提供中间件数据通信方法
- 数据通信的读、写、判断和清空处理
- 利用 [5.10 原生Deno实现稳定HTTP服务](https://github.com/chenshenhai/deno_note/blob/master/note/chapter_05/10.md) 的服务，创建一个`HTTP`安全上下文`SafeContext`
- 将 `SafeContext` 传入洋葱模型的处理中间件机制`compose`中
- 中间件结束和异常处理
## 具体实现
### 中间件内安全操作Context
#### 源码地址
[https://github.com/chenshenhai/deno_note/blob/master/demo/web/context.ts](https://github.com/chenshenhai/deno_note/blob/master/demo/web/context.ts)
#### 源码讲解
`./demo/web/context.ts`
```js
import { Context } from "./../server/context.ts";
import { Request, ReqGeneral } from "./../request/mod.ts";
import { Response } from "./../response/mod.ts";
/**
* 封装安全的HTTP请求操作类
* 只开放 getGeneral()、getHeaders()和getBodyStream 这三个方法
*/
class SafeRequest {
private _req: Request;
constructor(req: Request) {
this._req = req;
}
async getGeneral(): Promise<ReqGeneral> {
return await this._req.getGeneral();
}
async getHeaders(): Promise<Headers> {
return await this._req.getHeaders();
}
async getBodyStream(): Promise<Uint8Array> {
return await this._req.getBodyStream();
}
}
/**
* 封装安全的HTTP响应操作类
* 重新封装 4个原有Response的方法
* 保证响应结束后，禁止进行响应数据的设置，或者写操作
* setHeader(key: string, val: string): boolean;
* getHeaders(): Headers;
* setStatus(code: number): boolean;
* getStatus(): number;
* setBody(body: string): boolean;
* getBody(): string;
* 添加判断是否响应结束的方法
* isFinish(): boolean
* 添加设置响应结束的方法
* setFinish(): void
*/
class SafeResponse {
private _res: Response;
private _isFinish: boolean = false;
constructor(res: Response) {
this._res = res;
}
setHeader(key: string, val: string): boolean {
if (this.isFinish() === true) {
// 响应结束了，不再进行设置操作
return false;
}
return this._res.setHeader(key, val);
}
getHeaders(): Headers {
return this._res.getHeaders();
}
setStatus(status: number) {
if (this.isFinish() === true) {
// 响应结束了，不再进行设置操作
return false;
}
return this._res.setStatus(status);
}
getStatus(): number {
return this._res.getStatus();
}
setBody(body: string) {
if (this.isFinish() === true) {
// 响应结束了，不再进行设置操作
return false;
}
return this._res.setBody(body);
}
getBody(): string {
return this._res.getBody();
}
async flush(): Promise<number> {
if (this.isFinish() === true) {
// 响应结束了，不再进行TCP对象写操作
return -1;
}
return await this._res.flush();
}
isFinish() {
return this._isFinish;
}
setFinish() {
this._isFinish = true;
}
}
/**
* 封装安全的HTTP上下文操作类
* 基于 原有的 Context
* 加工原有的 Context.req 成为可安全请求操作对象 SafeRequest
* 加工原有的 Context.res 成为可安全响应操作对象 SafeResponse
* 添加上下文缓存数据的能力，保证在中间件里可以进行数据通信
* setData(key: string, val: any)
* getData(key: string): string
* cleanData()
* hasData(key: string): boolean
* deleteData(key: string)
*/
class SafeContext {
private _ctx: Context;
private _dataMap: {[key: string]: any} = {};
public req: SafeRequest;
public res: SafeResponse;
constructor(ctx: Context) {
this._ctx = ctx;
this.req = new SafeRequest(ctx.req);
this.res = new SafeResponse(ctx.res);
}
public setData(key: string, val: any) {
if (!this._dataMap) {
this._dataMap = {};
}
this._dataMap[key] = val;
}
public getData(key: string): string {
const dataMap = this._dataMap || {};
const val = dataMap[key];
return val;
}
public cleanData() {
this._dataMap = {};
}
public hasData(key: string): boolean {
const dataMap = this._dataMap || {};
return dataMap.hasOwnProperty(key);
}
public deleteData(key: string) {
if (this._dataMap) {
delete this._dataMap[key];
}
}
}
export { Context, SafeContext }
```
### 利用Koa.js洋葱模型
#### 源码地址
[https://github.com/chenshenhai/deno_note/blob/master/demo/web/compose.ts](https://github.com/chenshenhai/deno_note/blob/master/demo/web/compose.ts)
#### 洋葱模型讲解
本篇是实现一个`Deno`
版的`Koa.js`，因此就需要知道`Koa.js`框架洋葱模型的中间件机制原理。`Koa.js`的洋葱模型是基于`koa-compose`的`npm`模块来实现的。我之前已在 [Koa.js 设计模式-学习笔记-中间件引擎](https://github.com/chenshenhai/koajs-design-note/blob/master/note/chapter01/05.md) 详细讲解了，如果需要了解，可点击进入观看。
### 封装框架
#### 源码地址
[https://github.com/chenshenhai/deno_note/blob/master/demo/web/application.ts](https://github.com/chenshenhai/deno_note/blob/master/demo/web/application.ts)
#### 源码讲解
`./demo/web/application.ts`
```js
import { Context, SafeContext } from "./context.ts";
import { Server } from "./../server/mod.ts";
import { compose } from "./compose.ts";
const exit = Deno.exit;
class Application {
private _middlewares: Function[];
private _server: Server;
constructor() {
this._middlewares = [];
// 内置一个服务对象
this._server = new Server();
}
/**
* 注册使用中间件
* @param fn {Function}
*/
public use(fn: Function): void {
this._middlewares.push(fn);
}
/**
* 开始监听服务
* @param opts {Deno.ListenOptions} 监听地址和端口
* @param fn {Function} 监听执行后的回调
*/
public async listen(opts: Deno.ListenOptions, fn: Function) {
const that = this;
const server = this._server;
// 启动HTTP服务
server.createServer(async function(ctx: Context) {
const middlewares = that._middlewares;
try {
// 将HTTP服务生成的 HTTP上下文封装成一个安全操作的上下文
// 安全HTTP上下文限制了所有中间件能操作的范围
const sctx = new SafeContext(ctx);
// 等待执行所有中间件
await compose(middlewares)(sctx);
const body = sctx.res.getBody();
// 如果最后响应报文没有响应体，就默认设置404文案
if (!(body && typeof body === "string" && body.length > 0)) {
sctx.res.setBody("404 Not Found!");
}
// 最后写入响应数据
await ctx.res.flush();
} catch (err) {
that._onError(err, ctx);
}
});
server.listen(opts, fn);
}
/**
* 统一错误处理
* @param err {Error} 错误对象
* @param ctx {SafeContext} 当前HTTP上下文
*/
private async _onError(err: Error, ctx: Context) {
console.log(err);
if (ctx instanceof Context) {
// 出现错误，把错误堆栈打印到页面上
ctx.res.setBody(err.stack || 'Server Error');
ctx.res.setStatus(500);
await ctx.res.flush();
} else {
exit(1);
}
}
}
export { Application };
```
### 使用例子
`./demo/web/example.ts`
```ts
import { Application } from "./mod.ts";
const app = new Application();
const opts: Deno.ListenOptions = {
hostname: "127.0.0.1",
port: 3001
}
app.use(async function(ctx, next) {
console.log('action 001');
ctx.res.setBody("hello world! middleware-001");
await next();
console.log('action 006');
});
app.use(async function(ctx, next) {
console.log('action 002');
ctx.res.setBody("hello world! middleware-002");
ctx.res.setStatus(200);
// 提前设置结束
// 页面将会渲染 "hello world! middleware-002"
// 不会渲染 第三个中间件设置的响应体内容
ctx.res.setFinish();
await next();
// throw new Error('hello this is testing error')
console.log('action 005');
});
app.use(async function(ctx, next) {
console.log('action 003');
ctx.res.setBody("hello world! middleware-003");
await next();
console.log('action 004');
});
app.listen(opts, function() {
console.log("the web is starting")
});
```
#### 执行结果
```sh
deno run --allow-net example.ts
```
#### 结果显示
- 例子代码里，第二个中间件提前设置结束 `ctx.res.setFinish()`
- 页面将会渲染 "hello world! middleware-002"
- 不会渲染 第三个中间件设置的响应体内容
### 使用例子异常情况
#### 异常例子源码
```ts
import { Application } from "./mod.ts";
const app = new Application();
const opts: Deno.ListenOptions = {
hostname: "127.0.0.1",
port: 3001
}
app.use(async function(ctx, next) {
console.log('action 001');
ctx.res.setBody("hello world! middleware-001");
await next();
console.log('action 006');
});
app.use(async function(ctx, next) {
console.log('action 002');
ctx.res.setBody("hello world! middleware-002");
await next();
// 抛出异常
throw new Error('hello this is testing error')
console.log('action 005');
});
app.use(async function(ctx, next) {
console.log('action 003');
ctx.res.setBody("hello world! middleware-003");
await next();
console.log('action 004');
});
app.listen(opts, function() {
console.log("the web is starting")
});
```
#### 异常处理结果显示
## 测试
### 基准测试
- 安装测试工具 `npm i -g autocannon`
#### 发起100请求测试
- `autocannon http://127.0.0.1:3001/ -c 100`
- 就会出现以下结果
### 单元测试
- 测试服务
- [https://github.com/chenshenhai/deno_note/blob/master/demo/web/test_server.ts](https://github.com/chenshenhai/deno_note/blob/master/demo/web/test_server.ts)
- 单元测试核心
- [https://github.com/chenshenhai/deno_note/blob/master/demo/web/test.ts](https://github.com/chenshenhai/deno_note/blob/master/demo/web/test.ts) | 9,896 | MIT |
# Node Sass to Dart Sass
在 `v4.3.0`之前本项目都是基于`node-sass`进行构建的，但`node-sass`底层依赖 [libsass](https://github.com/sass/libsass)，导致很多用户安装的特别的困难，尤其是 windows 用户，它强制用户在`windows`环境中必须安装`python2`和`Visual Studio`才能编译成功。
所以为了解决这个问题，本项目在 [v4.3.0](https://github.com/PanJiaChen/vue-element-admin/pull/3040)修改为`dart-sass`进行构建，它能在保证性能的前提下大大简化用户的安装成本。通过这个 [issue](https://github.com/PanJiaChen/vue-element-admin/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)下面相关的评论就可以知道，安装 `node-sass` 是多么麻烦的一件事。
这里选择使用`dart-sass`还有一个更主要的原因，`sass`官方已经将`dart-sass`作为未来主要的的开发方向了，有任何新功能它都是会优先支持的，而且它已经在社区里稳定运行了很长的一段时间，基本没有什么坑了。`dart-sass`之所以容易安装，主要是因为它会被编译成纯 js，这样就可以直接在的 node 环境中使用。虽然这样它的运行速度会比基于 [libsass](https://github.com/sass/libsass)的慢一些些，但这些速度的差异几乎可以忽略不计。整个社区现在都在拥抱`dart-sass`，我们没有理由拒绝！而且它的确大大简化了用户的安装成本。
目前`vue-cli`在选择`sass`预处理的时候也会默认优先使用`dart-scss`，相关 [pr](https://github.com/vuejs/vue-cli/pull/3321)
相关的说明可以见该篇文章： [Announcing Dart Sass](https://sass-lang.com/blog/announcing-dart-sass)
具体 `dart-sass`性能评测可见：[Perf Report](https://github.com/sass/dart-sass/blob/master/perf.md)
## 升级方案
升级也非常的简单，只需要两个步骤
```bash
npm uninstall node-sass
npm install sass -S -D
```
具体可见该： [Pull Request](https://github.com/PanJiaChen/vue-element-admin/pull/3040)
## 不兼容
替换 `node-sass` 之后有一个地方需要注意，就是它不再支持之前 `sass` 的那种 `/deep/` 写法，需要统一改为 `::v-deep` 的写法。相关： [issue](https://github.com/vuejs/vue-cli/issues/3399)
具体 demo：
```css
.a {
/deep/ {
.b {
color: red;
}
}
}
/* 修改为 */
.a {
::v-deep {
.b {
color: red;
}
}
}
```
不管你是否使用`dart-sass`，我都是建议你使用`::v-deep`的写法，它不仅兼容了 css 的`>>>`写法，还兼容了 sass `/deep/`的写法。而且它还是 [vue 3.0 RFC](https://github.com/vuejs/rfcs/blob/scoped-styles-changes/active-rfcs/0023-scoped-styles-changes.md) 中指定的写法。
而且原本 `/deep/` 的写法也本身就被 Chrome 所废弃，你现在经常能在控制台中发现 Chrome 提示你不要使用`/deep/`的警告。
更多： [scope css 写法](https://vue-loader.vuejs.org/zh/guide/scoped-css.html#%E6%B7%B7%E7%94%A8%E6%9C%AC%E5%9C%B0%E5%92%8C%E5%85%A8%E5%B1%80%E6%A0%B7%E5%BC%8F) | 1,967 | MIT |
<properties
pageTitle="DocumentDB 限制與配額 | Microsoft Azure"
description="了解 DocumentDB 強制執行的限制和配額。檢閱使用 Azure 資料庫服務的配額。"
keywords="配額, 資料庫, Quotas, database, documentdb, azure, Microsoft azure"
services="documentdb"
authors="mimig1"
manager="jhubbard"
editor="cgronlun"
documentationCenter=""/>
<tags
ms.service="documentdb"
ms.workload="data-services"
ms.tgt_pltfrm="na"
ms.devlang="na"
ms.topic="article"
ms.date="12/14/2015"
ms.author="mimig"/>
# DocumentDB 限制與配額
下表說明 DocumentDB 強制執行的限制和配額。
[AZURE.INCLUDE [azure-documentdb-limits](../../includes/azure-documentdb-limits.md)]
<!---HONumber=AcomDC_1217_2015--> | 645 | CC-BY-3.0 |
---
title: 两轮博士申请+招RA，我学到了什么
date: 2021-04-23T15:00:00-04:00
last_modified_at: 2021-04-23T15:00:00-04:00
tags:
- 心理日常
toc: true
toc_sticky: false
---
Disclaimer: 本贴不是经验贴，是鼓励贴。
<!--more-->
想写这个帖子，是因为我加入博士lab后，最近开始招本科RA了。
看到RA申请者们交上来的材料，我才突然有实感地意识到phd申请到底是怎样的一种难度。我们lab还只是收到不到30份RA申请，选择成本还没有那么高（volunteer，只是本科RA）；大家都是从一个学校一个本科来的，所以不用考虑“出身”；材料只有简单的几道问题答案+cv/resume+成绩单，这我就已经看花眼了，看过第一遍根本记不住谁是谁。但是有一种扑面而来的感觉，所以我决定歇一下一会儿仔细再看一遍……（这个时候如果有人发邮件主动跟进的话，估计真的能给自己争取到更大的机会。）
而申phd的时候，1000字左右个人陈述，cv，三封推荐信，writing sample，大家来自不同国家不同专业不同学历，不同scale的成绩单，语言考试，往年还有GRE。然后就要决定要不要给这个学生4-5年几万几万的钱来培养。每个项目少说也能收到几十份申请吧，好一点的项目能接到高达1000份申请来争10个以下的名额（当时看到教授发推宣布数字时我已经吓傻了）。作为国际生更是钱少名额少。真的好tmd可怕。
我在申请者当中绝对算不上厉害的那种。第一轮申请全军覆没，第二轮也是将将上岸。两轮申请我少说也拿了20多封拒信吧，从最开始接到拒信就躺在床上大哭，到后来拿拒信拿到麻木：receive, open, 哦, archive。真是被虐习惯了就好……
那个时候每次接到拒信，看到人家说“你的材料真的很好，但是我们能接受的只有几个人，所以不得不拒绝很多也很好的学生…”，心里总是觉得“Yeah yeah yeah, 全是套话唬我的而已”。现在我才觉得，没准人家说的是真的，可能我也没那么差，真的就是运气不好不够“匹配”而已吧？当然如果我的材料各方面都更强，那我就不会成了被放弃的那个。但是全世界各方面都超强的申请者其实就只有那么几个，我就算是Tier 2, Tier 3，难道我就要直接放弃吗？
所以写这个贴子，是想和所有在学术圈中沉浮以及想进入学术圈的姐妹们说：
- 如果你今年申到了心仪的项目，恭喜你！！撒欢庆祝吧，因为真的好难啊
- 如果你今年没有申到，没关系！Been there, done that. 如果你像我一样不服气，就再试一年吧！
- 如果你是正在读博的前辈或读研的朋友，但是最近觉得有点消沉：你曾经也是被选中的人，要记得自己的能力、实力和潜力！继续加油啊
- 如果你是想要申研申博申RA的本科生，作为（相对来说的）弱鸡前辈我没有太多经验，只想鼓励你们加油啊！不要怕！我写这些并不是想要劝退，而是希望大家在明白现实的前提下，让自己的心更坚定一点。我们能上岸，你也能！
大家一起加油。
{% comment %}
Post: https://womenoverseas.com/t/topic/15551
{% endcomment %} | 1,401 | MIT |
## 定制主题
Zent 支持主题定制，目前仅支持组件库颜色的定制。
### 定制方法
Zent 的样式使用 [postcss](http://postcss.org/) 开发，我们提供了一个 postcss 的插件 [postcss-theme-variables](https://www.npmjs.com/package/postcss-theme-variables) 来支持主题定制。
有两种定制方式：
1. 通过在 Zent 仓库中修改配置，生成一份定制的 css 样式。
2. 直接在业务项目中引用 Zent 的 postcss 源文件并配置自定义主题，在业务项目打包过程中自动生成定制后的样式。
两种方式各有优劣。
第一种方式对业务项目是非侵入式的，样式的定制和业务项目完全独立，这种方案的问题是每次更新 Zent 组件库都要重新生成一份定制主题。
第二种方式对业务项目是侵入式的，需要修改业务项目的打包配置，支持 Zent 的 postcss 源文件，好处是更新 Zent 后不需要单独去重新生成定制主题。
我们的建议：如果你的项目使用 postcss 那么可以考虑方案2，否则推荐方案1。
#### 方案1
1. 克隆 Zent [源码](https://github.com/youzan/zent)并安装依赖
2. 在 `packages/zent` 目录下新建一个文件，例如 `custom-theme.js`，并设置要覆盖的主题颜色，颜色的名字及默认值请参考[色彩](colors)
3. 在 `packages/zent` 目录下面执行 `yarn theme custom-theme.js`
4. 定制的主题会生成在 `packages/zent/css` 目录下
```
/* custom-theme.js */
// 只自定义主色
module.exports = {
'theme-primary-1': '#72f',
'theme-primary-2': '#83f',
'theme-primary-3': '#95f',
'theme-primary-4': '#dbf',
'theme-primary-5': '#f7e8fd',
'theme-primary-6': '#f3eaff',
};
```
#### 方案2
首先，项目的样式文件里需要直接引入 Zent 的样式源文件，源文件在 `zent/assets` 目录下。
一般直接引入 `zent/assets/index.pcss` 即可，如果你希望只引入使用到的组件样式的话可以使用 [babel-plugin-zent](babel-plugin-zent) 的 `useRawStyle` 参数。
请参考如下配置，确保 postcss-theme-variables 这个插件配置正确，注意事项请看 [postcss-theme-variables 文档](https://www.npmjs.com/package/postcss-theme-variables)。
```
module.exports = {
plugins: [
require('postcss-easy-import')({
prefix: '_',
extensions: ['pcss', 'css']
}),
require('postcss-theme-variables')({
// ... your overrides here
vars: {
'theme-primary-1': '#72f',
'theme-primary-2': '#83f',
'theme-primary-3': '#95f',
'theme-primary-4': '#dbf',
'theme-primary-5': '#f7e8fd',
'theme-primary-6': '#f3eaff',
},
// precss variables starts with $
prefix: '$'
})
require('autoprefixer'),
require('precss'),
// 可选压缩
require('cssnano')({ safe: true })
]
};
```
<style>
img[alt="zent-theme"] {
width: 514px;
height: 319px;
}
</style> | 2,102 | MIT |
---
title: コンパイル エラー C3487
ms.date: 11/04/2016
f1_keywords:
- C3487
helpviewer_keywords:
- C3487
ms.assetid: 39bda474-4418-4a79-98bf-2b22fa92eaaa
ms.openlocfilehash: 01f8a1bd74ed2b7a3150afae5b46128c6f5b0ca2
ms.sourcegitcommit: 0ab61bc3d2b6cfbd52a16c6ab2b97a8ea1864f12
ms.translationtype: MT
ms.contentlocale: ja-JP
ms.lasthandoff: 04/23/2019
ms.locfileid: "62381151"
---
# <a name="compiler-error-c3487"></a>コンパイル エラー C3487
'return type': すべての return 式で同じ型を推測する必要があります: 以前は 'return type' でした。
ラムダでは、1 つの return ステートメントを含む場合を除き、戻り値の型を指定する必要があります。 ラムダに複数の return ステートメントが含まれる場合は、すべて同じ型である必要があります。
### <a name="to-correct-this-error"></a>このエラーを解決するには
- ラムダの後続の戻り値の型を指定します。 ラムダからのすべての戻り値が同じ型であるか、または戻り値の型に暗黙的に変換できることを確認します。
## <a name="example"></a>例
次の例では、ラムダの戻り値の型が一致しないため、C3487 が生成されます。
```
// C3487.cpp
// Compile by using: cl /c /W4 C3487.cpp
int* test(int* pi) {
// To fix the error, uncomment the trailing return type below
auto odd_pointer = [=]() /* -> int* */ {
if (*pi % 2)
return pi;
return nullptr; // C3487 - nullptr is not an int* type
};
return odd_pointer();
}
```
## <a name="see-also"></a>関連項目
[ラムダ式](../../cpp/lambda-expressions-in-cpp.md) | 1,198 | CC-BY-4.0 |
```yaml
changelog: true
```
## 2.23.0
`2022-04-08`
### 🆕 新增功能
- 增加图标相关插槽 ([#944](https://github.com/arco-design/arco-design-vue/pull/944))
- 增加 updateFile 方法，onBeforeUpload 支持返回 File ([#944](https://github.com/arco-design/arco-design-vue/pull/944))
- 优化初始图片显示逻辑 ([#944](https://github.com/arco-design/arco-design-vue/pull/944))
## 2.22.0
`2022-04-01`
### 🐛 问题修复
- 修复 onButtonClick 属性不可用的问题 ([#907](https://github.com/arco-design/arco-design-vue/pull/907))
## 2.18.1
`2022-03-07`
### 🐛 问题修复
- 修复上传进度计算错误的问题 ([#786](https://github.com/arco-design/arco-design-vue/pull/786))
- 修复上传中，取消按钮失效的问题 ([#786](https://github.com/arco-design/arco-design-vue/pull/786))
## 2.18.0-beta.2
`2022-02-25`
### 🐛 问题修复
- 修复使用插槽 `upload-item` 报错的问题 ([#715](https://github.com/arco-design/arco-design-vue/pull/715))
- 仅在文件类型为图片时生成初始预览图片 ([#706](https://github.com/arco-design/arco-design-vue/pull/706))
## 2.14.0
`2022-01-07`
### 🆕 新增功能
- 增加 imagePreview 属性，可以使用内置图片预览功能 ([#517](https://github.com/arco-design/arco-design-vue/pull/517))
- 当 `listType` 为图片类时，默认设置 accept 为 `image/*` ([#517](https://github.com/arco-design/arco-design-vue/pull/517))
- 增加 `showOnExceedLimit` 属性 ([#517](https://github.com/arco-design/arco-design-vue/pull/517))
## 2.13.0
`2021-12-31`
### 🆕 新增功能
- 增加 `show-link` 属性 ([#483](https://github.com/arco-design/arco-design-vue/pull/483))
## 2.12.1
`2021-12-24`
### 🐛 问题修复
- 修复照片墙模式错误的问题 ([#457](https://github.com/arco-design/arco-design-vue/pull/457))
## 2.12.0
`2021-12-24`
### 🐛 问题修复
- 修复按钮模式下 tip 没有显示的问题 ([#446](https://github.com/arco-design/arco-design-vue/pull/446))
- 修复 `upload` 组件的禁用样式不生效的 bug ([#430](https://github.com/arco-design/arco-design-vue/pull/430))
## 2.11.0
`2021-12-17`
### 🆕 新增功能
- 增加 `download` 属性 ([#418](https://github.com/arco-design/arco-design-vue/pull/418))
- 新增 `show-remove-buttoon` 、`show-retry-button`、`show-cancel-button` 属性 ([#396](https://github.com/arco-design/arco-design-vue/pull/396))
- 新增 `imageLoading` 属性 ([#396](https://github.com/arco-design/arco-design-vue/pull/396))
### 🐛 问题修复
- 修复上传中的图标位置不对的问题 ([#417](https://github.com/arco-design/arco-design-vue/pull/417))
- 修复拖拽上传文件夹时，`beforeUpload` 的第二个参数获取到的不是全部文件的问题 ([#417](https://github.com/arco-design/arco-design-vue/pull/417))
- 修复拖拽上传时，鼠标进入内部文字，拖拽样式闪动的问题 ([#417](https://github.com/arco-design/arco-design-vue/pull/417))
## 2.6.0
`2021-11-19`
### 🐛 问题修复
- 修复图片名过长时溢出的问题 ([#198](https://github.com/arco-design/arco-design-vue/pull/198))
- 修复照片墙模式，超出长度不能换行的问题 ([#198](https://github.com/arco-design/arco-design-vue/pull/198))
## 2.4.0
`2021-11-17`
### 🆕 新增功能
- 增加 `upload-button` 和 `upload-item` 插槽 ([#174](https://github.com/arco-design/arco-design-vue/pull/174))
- 增加 `success` 和 `error` 事件 ([#174](https://github.com/arco-design/arco-design-vue/pull/174))
- 增加 `on-click-button` 、`custom-icon`、`directory ` 属性 ([#174](https://github.com/arco-design/arco-design-vue/pull/174))
## 2.2.0
`2021-11-10`
### 🐛 问题修复
- 修复 `limit` 属性无效的问题 ([#123](https://github.com/arco-design/arco-design-vue/pull/123)) | 3,059 | MIT |
<!--
* @Descripttion:
* @version:
* @Author: matias tang
* @Date: 2020-09-25 15:48:30
* @LastEditors: matias tang
* @LastEditTime: 2020-09-25 15:49:01
-->
# 微信jsAPI支付
[微信jsAPI支付](https://pay.weixin.qq.com/wiki/doc/api/jsapi.php?chapter=7_1) | 249 | MIT |
---
layout: post
title: 2. First SpringMVC Application
subtitle:
date: 2021-04-14
author: Hao
header-img: img/post/post_bg_coffee.jpg
catalog: true
mathjax: true
tags:
- Spring MVC
---
上一篇我们介绍了 Spring MVC 的底层执行流程。为了更好的理解它，我们现在写 SpringMVC 的第一个程序。
## Hello SpringMVC
1、新建 Maven 工程，并引入以下依赖
```xml
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
</dependencies>
```
确保上述依赖在项目的打包文件中，如果没有，在 Project Structure 中的 Artifacts 中，添加一个 lib 文件夹，包含以上依赖
2、右键工程 Add Framework Support，添加 Web App 的支持
3、配置 web.xml 文件，注册 **DispatcherServlet**
```xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--1.注册DispatcherServlet-->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlet.xml</param-value>
</init-param>
<!--启动级别-1-->
<load-on-startup>1</load-on-startup>
</servlet>
<!--/ 匹配所有的请求；（不包括.jsp）-->
<!--/* 匹配所有的请求；（包括.jsp）-->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
```
4、因为 DispatcherServlet 要绑定一个 SpringMVC 的配置文件，所以我们编写这个配置文件，名称按照官方：[servletname]-servlet.xml
```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
```
5、在 Spring 配置文件中添加 **处理映射器**
```xml
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
```
6、添加 **处理器适配器**
```xml
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
```
7、添加 **视图解析器**
```xml
<!--视图解析器:DispatcherServlet给他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<!--前缀-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<!--后缀-->
<property name="suffix" value=".jsp"/>
</bean>
```
8、编写业务逻辑 **Controller**，要么实现 Controller 接口，要么增加注解；覆盖的方法需要返回一个ModelAndView，其中添加数据，封装视图
```java
// 这里先实现接口
public class HelloController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
//ModelAndView 模型和视图
ModelAndView mv = new ModelAndView();
//封装对象，放在ModelAndView中。Model
mv.addObject("msg","HelloSpringMVC!");
//封装要跳转的视图，放在ModelAndView中
mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
return mv;
}
}
```
9、将自己的类交给SpringIOC容器，注册bean
```xml
<!--Handler-->
<bean id="/hello" class="com.zhao.controller.HelloController"/>
```
10、写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面；
```jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>zhao</title>
</head>
<body>
${msg}
</body>
</html>
```
11、配置Tomcat 启动测试！
可能遇到的问题：访问出现404，排查步骤：
1. 查看控制台输出，看一下是不是缺少了什么jar包。
2. 如果jar包存在，显示无法输出，就在 IDEA 的 Project Structute 项目发布中，添加 lib 依赖！
3. 重启Tomcat 即可解决！
## 改用注解实现
通过上面配置的 Hello SpringMVC 代码，我们可以梳理 SpringMVC 具体的执行流程。虽然通过配置的方式 SpringMVC 已经帮我们做了很多事情，但在实际开发中通过注解更加高效，这才是 SpringMVC 的精髓。
1、像之前一样，新建 Maven 项目，导入 jar 包，添加 Web App 支持
2、由于Maven可能存在资源过滤的问题，我们配置 pom.xml
```xml
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
```
3、和之前一样配置 web.xml
```xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--1.注册servlet-->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc-servlet.xml</param-value>
</init-param>
<!-- 启动顺序，数字越小，启动越早 -->
<load-on-startup>1</load-on-startup>
</servlet>
<!--所有请求都会被springmvc拦截 -->
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
```
5、添加Spring MVC配置文件
在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
<context:component-scan base-package="com.zhao.controller"/>
<!-- 让Spring MVC不处理静态资源 -->
<mvc:default-servlet-handler />
<!--
支持mvc注解驱动
在spring中一般采用@RequestMapping注解来完成映射关系
要想使@RequestMapping注解生效
必须向上下文中注册DefaultAnnotationHandlerMapping
和一个AnnotationMethodHandlerAdapter实例
这两个实例分别在类级别和方法级别处理。
而annotation-driven配置帮助我们自动完成上述两个实例的注入。
-->
<mvc:annotation-driven />
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
id="internalResourceViewResolver">
<!-- 前缀 -->
<property name="prefix" value="/WEB-INF/jsp/" />
<!-- 后缀 -->
<property name="suffix" value=".jsp" />
</bean>
</beans>
```
6、创建Controller
编写一个Java控制类：HelloController
```java
@Controller
@RequestMapping("/HelloController")
public class HelloController {
//真实访问地址 : 项目名/HelloController/hello
@RequestMapping("/hello")
public String sayHello(Model model){
//向模型中添加属性msg与值，可以在JSP页面中取出并渲染
model.addAttribute("msg", "hello,SpringMVC");
//web-inf/jsp/hello.jsp
return "hello";
}
}
```
@Controller是为了让 Spring IOC 容器初始化时自动扫描到；
@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；
方法中声明Model类型的参数是为了把Action中的数据带到视图中；
方法返回的结果是视图的名称 hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。
7、创建视图层
在WEB-INF/ jsp目录中创建 hello.jsp ， 视图可以直接取出并展示从Controller带回的信息；
```jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>SpringMVC</title>
</head>
<body>
${msg}
</body>
</html>
```
8、配置Tomcat运行
**使用springMVC必须配置的三大件**
处理器映射器、处理器适配器、视图解析器
通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置
## 总结
本篇我们通过写 SpringMVC 的第一个程序，梳理了 SpringMVC 的执行流程。然后我们改用注解实现，大大简化了配置的难度。
参考自：
1. [狂神说SpringMVC02：第一个MVC程序](https://mp.weixin.qq.com/s?__biz=Mzg2NTAzMTExNg==&mid=2247483978&idx=1&sn=6711110a3b2595d6bb987ca02ee0a728&scene=19#wechat_redirect) | 8,763 | Apache-2.0 |
### 394. 字符串解码
> 题目
给定一个经过编码的字符串，返回它解码后的字符串。
编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。
你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。
此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像3a或2[4]的输入。
示例 1：
```
输入：s = "3[a]2[bc]"
输出："aaabcbc"
```
示例 2：
```
输入：s = "3[a2[c]]"
输出："accaccacc"
```
示例 3：
```
输入：s = "2[abc]3[cd]ef"
输出："abcabccdcdcdef"
```
示例 4：
```
输入：s = "abc3[cd]xyz"
输出："abccdcdcdxyz"
```
> 思路
使用栈，数字、[、字母都推到栈中，当遇到 ]，就取出栈中的数据，直到 [，这个时候再取出栈顶的数字，进行重复。最后把栈中的字符串拼起来。
> 代码
```js
/**
* @param {string} s
* @return {string}
*/
var decodeString = function (s) {
if (!s.length) return s;
let stack = [];
let i = 0;
let num = '';
while (i < s.length) {
const str = s.charAt(i);
if (str == ']') {
let _str = '';
let _preStr = stack.pop();
while (_preStr !== '[') {
_str = _preStr + _str;
_preStr = stack.pop();
}
let num = stack.pop();
_str = repeat(_str, Number(num));
stack.push(_str);
} else if (/\d/.test(str)) {
num += str;
} else {
if (str === '[') {
num && stack.push(num);
num = '';
}
stack.push(str);
}
i++;
}
let result = '';
while (stack.length) {
str = stack.pop();
result = str + result;
}
return result;
}
function repeat(s, n) {
let str = ''
for (let i = 0; i < n; i++) {
str += s;
}
return str;
}
```
> 复杂度分析
时间复杂度 : O(N)。
空间复杂度 : O(N)。
> 执行
执行用时：92 ms, 在所有 JavaScript 提交中击败了22.96%的用户。
内存消耗：37.8 MB, 在所有 JavaScript 提交中击败了12.22%的用户。
> 算法 | 1,732 | MIT |
---
title: "Scheduler の制限と既定値"
description: "Scheduler の制限と既定値"
services: scheduler
documentationcenter: .NET
author: derek1ee
manager: kevinlam1
editor:
ms.assetid: 88f4a3e9-6dbd-4943-8543-f0649d423061
ms.service: scheduler
ms.workload: infrastructure-services
ms.tgt_pltfrm: na
ms.devlang: dotnet
ms.topic: article
ms.date: 08/18/2016
ms.author: deli
translationtype: Human Translation
ms.sourcegitcommit: 2ea002938d69ad34aff421fa0eb753e449724a8f
ms.openlocfilehash: db6b1c196cb468f41c7a7ce34758de346b522abb
---
# <a name="scheduler-limits-and-defaults"></a>Scheduler の制限と既定値
## <a name="scheduler-quotas-limits-defaults-and-throttles"></a>Scheduler のクォータ、制限、既定値、調整
[!INCLUDE [scheduler-limits-table](../../includes/scheduler-limits-table.md)]
## <a name="the-x-ms-request-id-header"></a>x-ms-request-id ヘッダー
Scheduler サービスに対するすべての要求は、**x-ms-request-id**という名前の応答ヘッダーを返します。 このヘッダーには、要求を一意に識別する非透過の値が含まれています。
要求の形式が正しいにもかかわらず要求が常に失敗する場合は、この値を使用して Microsoft にエラーを報告することができます。 このとき、x-ms-request-id の値、要求が行われたおおよその時間、サブスクリプションの識別子、ジョブ コレクションやジョブのほかに、要求で試みた操作の種類もレポートに含めてください。
## <a name="see-also"></a>関連項目
[What is Scheduler? (Scheduler とは)](scheduler-intro.md)
[Azure Scheduler の概念、用語集、エンティティ階層構造](scheduler-concepts-terms.md)
[Azure ポータル内で Scheduler を使用した作業開始](scheduler-get-started-portal.md)
[Azure Scheduler のプランと課金](scheduler-plans-billing.md)
[Azure Scheduler REST API リファレンス](https://msdn.microsoft.com/library/mt629143)
[Azure Scheduler PowerShell コマンドレット リファレンス](scheduler-powershell-reference.md)
[Azure Scheduler の高可用性と信頼性](scheduler-high-availability-reliability.md)
[Azure Scheduler 送信認証](scheduler-outbound-authentication.md)
<!--HONumber=Nov16_HO3--> | 1,715 | CC-BY-3.0 |
### 数字图像处理领域中常见的几种色彩模式
在数字图像处理过程中，常见的几种色彩模式有RGB, HSL\HSV和YCrCb(YUV)
RGB: 通过对红(R), 绿(G), 蓝(B)三个颜色通道的变化和叠加来得到其它颜色．三个分量的范围都是[0, 255]
HSL\HSV: 将RGB色彩模式中的点在圆柱坐标系中进行表述，
分为色相(Hue), 饱和度(Saturation), 亮度(Lightness)\明度(Value)三个通道，
1. 色相(H): 色彩的基本属性，就是日常所说的颜色名称，如红色、黄色等, 取值范围为[0, 360)
2. 饱和度(S): 色彩的纯度，越高色彩越纯，低则逐渐变灰，取值范围[0, 100%]
3. 明度(V)，亮度(L): 像素灰度值的强度，亮度越高则图像越发白，否则图像越黑, 取值范围[0, 100%]
YCrCb:
1. Y:明亮度，像素灰度值的强度
2. Cr:红色值与亮度的差异
3. Cb:蓝色值与亮度的差异
Cr和Cb代表的是色度，描述影像色彩和饱和度，用于指定像素的颜色
在数字图像处理中，选择合适的色彩模式往往能达到事半功倍的效果
此处以Android平台上操作图像的亮度，对比度和饱和度来进行说明
1. 亮度：像素灰度值的强度，亮度越高则图像越发白，否则图像越黑；
2. 饱和度：色彩的纯度，越高色彩越纯越亮，低则逐渐变灰变暗；
3. 对比度：图像中像素之间的差异，对比度越高图像细节越突出，反之细节不明显
从上面的概念上来看，如果要操作图像的亮度和饱和度，那么在HSL\HSV色彩空间中进行是最方便的，
直接操作相应的分量即可；而对比度的操作可以直接在RGB色彩空间中进行．
在Android中，我们用ImageView显示一张图片
然后拿到ImageView内部的bitmap对象
```
(imageView.drawable as BitmapDrawable).bitmap
```
从bitmap中获取RGB数据
```
fun fetchRgbaFromBitmap(bitmap: Bitmap): IntArray {
val buffer = ByteBuffer.allocate(bitmap.byteCount).order(ByteOrder.nativeOrder())
bitmap.copyPixelsToBuffer(buffer)
val rgbaArr = buffer.array()
val rgba = IntArray(rgbaArr.size)
val count = rgbaArr.size / 4
for (i in 0 until count) {
rgba[i * 4] = rgbaArr[i * 4].toInt() and 0xff // R
rgba[i * 4 + 1] = rgbaArr[i * 4 + 1].toInt() and 0xff // G
rgba[i * 4 + 2] = rgbaArr[i * 4 + 2].toInt() and 0xff // B
rgba[i * 4 + 3] = rgbaArr[i * 4 + 3].toInt() and 0xff // A
}
return rgba
}
```
RGB色彩空间中调整对比度，调整对比度的算法很多，此处只是一个简单的处理：
1. R, G, B分量除255做归一化处理
2. ((归一化的分量 - 0.5) * 饱和度系数 + 0.5) * 255
核心代码:
```
val count = originBitmapRgba!!.size / 4
for (i in 0 until count) {
var r = originBitmapRgba!![i * 4]
var g = originBitmapRgba!![i * 4 + 1]
var b = originBitmapRgba!![i * 4 + 2]
val a = originBitmapRgba!![i * 4 + 3]
val cr = ((r / 255f) - 0.5f) * CONTRACT_RATIO
val cg = ((g / 255f) - 0.5f) * CONTRACT_RATIO
val cb = ((b / 255f) - 0.5f) * CONTRACT_RATIO
r = ((cr + 0.5f) * 255f).toInt()
g = ((cg + 0.5f) * 255f).toInt()
b = ((cb + 0.5f) * 255f).toInt()
val newColor = Color.rgb(
Util.clamp(r, 0, 255),
Util.clamp(g, 0, 255),
Util.clamp(b, 0, 255)
)
ColorUtils.setAlphaComponent(newColor, a)
tmpBitmapPixels!![i] = newColor
}
```
对比度系数CONTRACT_RATIO为1.5的效果
对比度系数CONTRACT_RATIO为3的效果，可以看到图像细节更突出，画面更有层次感
亮度和饱和度的调节也可以在RGB色彩空间中进行，有相应的算法，
此处先将RGB转化到HSL色彩空间，然后根据系数对用S分量和L分量进行调节即可
从RGB到HSL\HSV的转换算法如下(摘自百度百科)：
从HSL\HSV到RGB的转化算法，详情百度百科．．．
Android中RGB和HSL的相互转化，SDK已经帮我们实现好了, ColorUtils#RGBToHSL:
```
/**
* Convert RGB components to HSL (hue-saturation-lightness).
* <ul>
* <li>outHsl[0] is Hue [0 .. 360)</li>
* <li>outHsl[1] is Saturation [0...1]</li>
* <li>outHsl[2] is Lightness [0...1]</li>
* </ul>
*
* @param r red component value [0..255]
* @param g green component value [0..255]
* @param b blue component value [0..255]
* @param outHsl 3-element array which holds the resulting HSL components
*/
public static void RGBToHSL(@IntRange(from = 0x0, to = 0xFF) int r,
@IntRange(from = 0x0, to = 0xFF) int g, @IntRange(from = 0x0, to = 0xFF) int b,
@NonNull float[] outHsl)
```
ColorUtils#HSLToColor:
```
/**
* Convert HSL (hue-saturation-lightness) components to a RGB color.
* <ul>
* <li>hsl[0] is Hue [0 .. 360)</li>
* <li>hsl[1] is Saturation [0...1]</li>
* <li>hsl[2] is Lightness [0...1]</li>
* </ul>
* If hsv values are out of range, they are pinned.
*
* @param hsl 3-element array which holds the input HSL components
* @return the resulting RGB color
*/
@ColorInt
public static int HSLToColor(@NonNull float[] hsl)
```
调整饱和度核心代码：
```
val count = originBitmapRgba!!.size / 4
for (i in 0 until count) {
val r = originBitmapRgba!![i * 4]
val g = originBitmapRgba!![i * 4 + 1]
val b = originBitmapRgba!![i * 4 + 2]
val a = originBitmapRgba!![i * 4 + 3]
ColorUtils.RGBToHSL(r, g, b, hsl)
val s = hsl[1] * SATURATION_RATIO
hsl[1] = Util.clamp(s,0f, 1f)
val newColor = ColorUtils.HSLToColor(hsl)
ColorUtils.setAlphaComponent(newColor, a)
tmpBitmapPixels!![i] = newColor
}
```
饱和度系数SATURATION_RATIO为1.5的效果, 可以看到图像变亮变纯
饱和度系数SATURATION_RATIO为0.5的效果，可以看到图像变暗变灰
调整亮度核心代码：
```
val count = originBitmapRgba!!.size / 4
for (i in 0 until count) {
val r = originBitmapRgba!![i * 4]
val g = originBitmapRgba!![i * 4 + 1]
val b = originBitmapRgba!![i * 4 + 2]
val a = originBitmapRgba!![i * 4 + 3]
ColorUtils.RGBToHSL(r, g, b, hsl)
hsl[2] = hsl[2] * LIGHTNESS_RATIO
val newColor = ColorUtils.HSLToColor(hsl)
ColorUtils.setAlphaComponent(newColor, a)
tmpBitmapPixels!![i] = newColor
}
```
亮度系数LIGHTNESS_RATIO为1.5的效果, 可以看到图像整体发白
亮度系数LIGHTNESS_RATIO为0.5的效果，可以看到图像整体变黑了
 | 5,491 | Apache-2.0 |
---
title: "Azure Data Lake Store の間でのデータの移動 | Microsoft Docs"
description: "Azure Data Factory を使用して Azure Data Lake Store に、または Azure Data Lake Store からデータを移動する方法を説明します。"
services: data-factory
documentationcenter:
author: linda33wj
manager: jhubbard
editor: monicar
ms.assetid: 25b1ff3c-b2fd-48e5-b759-bb2112122e30
ms.service: data-factory
ms.workload: data-services
ms.tgt_pltfrm: na
ms.devlang: na
ms.topic: article
ms.date: 02/08/2017
ms.author: jingwang
translationtype: Human Translation
ms.sourcegitcommit: b2d1a740782a20a7c6b7b8cec8335a41f16231f5
ms.openlocfilehash: 5a6a14e5fc8f6915b34f9667c4294a46c8591633
ms.lasthandoff: 02/09/2017
---
# <a name="move-data-to-and-from-azure-data-lake-store-using-azure-data-factory"></a>Azure Data Factory を使用した Azure Data Lake Store との間でのデータの移動
この記事では、Azure Data Factory のコピー アクティビティを使用して、Azure Data Lake Store と別のデータ ストアの間でデータを移動する方法の概要を説明します。 この記事は、コピー アクティビティによるデータ移動の概要とサポートされるデータ ストアの組み合わせについて説明する、 [データ移動アクティビティ](data-factory-data-movement-activities.md) に関する記事に基づいています。
> [!NOTE]
> Azure Data Lake Store との間でデータを移動するには、コピー アクティビティを含むパイプラインを作成する前に Azure Data Lake Store アカウントを作成します。 Azure Data Lake Store の詳細については、 [Azure Data Lake Store の概要](../data-lake-store/data-lake-store-get-started-portal.md)に関する記事をご覧ください。
>
## <a name="supported-authentication-types"></a>サポートされている認証の種類
Azure Data Lake Store コネクタでは、**サービス プリンシパル**認証と**ユーザー資格情報**認証がサポートされています。 特にスケジュールされたデータ コピーについては前者を使用し、後者でのトークンの有効期限の動作を避けることをお勧めします。 構成の詳細については、「[Azure Data Lake Store のリンクされたサービスのプロパティ](#azure-data-lake-store-linked-service-properties)」を参照してください。
## <a name="copy-data-wizard"></a>データのコピー ウィザード
Azure Data Lake Store との間でデータをコピーするパイプラインを作成する最も簡単な方法は、データのコピー ウィザードを使用することです。 データのコピー ウィザードを使用してパイプラインを作成する簡単な手順については、「 [チュートリアル: コピー ウィザードを使用してパイプラインを作成する](data-factory-copy-data-wizard-tutorial.md) 」をご覧ください。
以下の例は、[Azure Portal](data-factory-copy-activity-tutorial-using-azure-portal.md)、[Visual Studio](data-factory-copy-activity-tutorial-using-visual-studio.md)、または [Azure PowerShell](data-factory-copy-activity-tutorial-using-powershell.md) を使用してパイプラインを作成する際に使用できるサンプルの JSON 定義です。 ここでは、Azure Data Lake Store と Azure BLOB Storage との間でデータをコピーする方法を示します。 ただし、任意のソースのデータを、サポートされている任意のシンクに**直接**コピーできます。 詳細については、「[コピー アクティビティを使用したデータの移動](data-factory-data-movement-activities.md)」の「サポートされるデータ ストアと形式」のセクションを参照してください。
## <a name="sample-copy-data-from-azure-blob-to-azure-data-lake-store"></a>サンプル: Azure BLOB から Azure Data Lake Store にデータをコピーする
次のサンプルは以下を示しています。
1. [AzureStorage](#azure-storage-linked-service-properties)型のリンクされたサービス。
2. [AzureDataLakeStore](#azure-data-lake-linked-service-properties)型のリンクされたサービス。
3. [AzureBlob](#azure-blob-dataset-type-properties) 型の入力[データセット](data-factory-create-datasets.md)。
4. [AzureDataLakeStore](#azure-data-lake-dataset-type-properties) 型の出力[データセット](data-factory-create-datasets.md)。
5. [BlobSource](#azure-blob-copy-activity-type-properties) と [AzureDataLakeStoreSink](#azure-data-lake-copy-activity-type-properties) を使用するコピー アクティビティを含む[パイプライン](data-factory-create-pipelines.md)。
このサンプルは、Azure BLOB ストレージから Azure Data Lake Store に時系列データを&1; 時間おきに コピーします。 これらのサンプルで使用される JSON プロパティの説明はサンプルに続くセクションにあります。
**Azure Storage のリンクされたサービス:**
```JSON
{
"name": "StorageLinkedService",
"properties": {
"type": "AzureStorage",
"typeProperties": {
"connectionString": "DefaultEndpointsProtocol=https;AccountName=<accountname>;AccountKey=<accountkey>"
}
}
}
```
**Azure Data Lake のリンクされたサービス:**
```JSON
{
"name": "AzureDataLakeStoreLinkedService",
"properties": {
"type": "AzureDataLakeStore",
"typeProperties": {
"dataLakeStoreUri": "https://<accountname>.azuredatalakestore.net/webhdfs/v1",
"servicePrincipalId": "<service principal id>",
"servicePrincipalKey": "<service principal key>",
"tenant": "<tenant info, e.g. microsoft.onmicrosoft.com>",
"subscriptionId": "<subscription of ADLS>",
"resourceGroupName": "<resource group of ADLS>"
}
}
}
```
> [!NOTE]
> 構成の詳細については、「[Azure Data Lake Store のリンクされたサービスのプロパティ](#azure-data-lake-store-linked-service-properties)」セクションの手順を参照してください。
>
**Azure BLOB の入力データセット:**
データは新しい BLOB から 1 時間おきに取得されます (頻度: 時間、間隔: 1)。 BLOB のフォルダー パスとファイル名は、処理中のスライスの開始時間に基づき、動的に評価されます。 フォルダー パスでは開始時間の年、月、日の部分を使用し、ファイル名では開始時間の時刻部分を使用します。 "external": "true" の設定により、このテーブルが Data Factory の外部にあり、Data Factory のアクティビティによって生成されたものではないことが Data Factory サービスに通知されます。
```JSON
{
"name": "AzureBlobInput",
"properties": {
"type": "AzureBlob",
"linkedServiceName": "StorageLinkedService",
"typeProperties": {
"folderPath": "mycontainer/myfolder/yearno={Year}/monthno={Month}/dayno={Day}",
"partitionedBy": [
{
"name": "Year",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "yyyy"
}
},
{
"name": "Month",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "MM"
}
},
{
"name": "Day",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "dd"
}
},
{
"name": "Hour",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "HH"
}
}
]
},
"external": true,
"availability": {
"frequency": "Hour",
"interval": 1
},
"policy": {
"externalData": {
"retryInterval": "00:01:00",
"retryTimeout": "00:10:00",
"maximumRetry": 3
}
}
}
}
```
**Azure Data Lake 出力データセット:**
このサンプルは Azure Data Lake Store にデータをコピーします。 新しいデータが&1; 時間おきに Data Lake Store にコピーされます。
```JSON
{
"name": "AzureDataLakeStoreOutput",
"properties": {
"type": "AzureDataLakeStore",
"linkedServiceName": "AzureDataLakeStoreLinkedService",
"typeProperties": {
"folderPath": "datalake/output/"
},
"availability": {
"frequency": "Hour",
"interval": 1
}
}
}
```
**コピー アクティビティのあるパイプライン:**
パイプラインには、入力データセットと出力データセットを使用するように構成され、1 時間おきに実行するようにスケジュールされているコピー アクティビティが含まれています。 パイプライン JSON 定義で、**source** 型が **BlobSource** に設定され、**sink** 型が **AzureDataLakeStoreSink** に設定されています。
```JSON
{
"name":"SamplePipeline",
"properties":
{
"start":"2014-06-01T18:00:00",
"end":"2014-06-01T19:00:00",
"description":"pipeline with copy activity",
"activities":
[
{
"name": "AzureBlobtoDataLake",
"description": "Copy Activity",
"type": "Copy",
"inputs": [
{
"name": "AzureBlobInput"
}
],
"outputs": [
{
"name": "AzureDataLakeStoreOutput"
}
],
"typeProperties": {
"source": {
"type": "BlobSource"
},
"sink": {
"type": "AzureDataLakeStoreSink"
}
},
"scheduler": {
"frequency": "Hour",
"interval": 1
},
"policy": {
"concurrency": 1,
"executionPriorityOrder": "OldestFirst",
"retry": 0,
"timeout": "01:00:00"
}
}
]
}
}
```
## <a name="sample-copy-data-from-azure-data-lake-store-to-azure-blob"></a>サンプル: Azure Data Lake Store から Azure BLOB にデータをコピーする
次のサンプルは以下を示しています。
1. [AzureDataLakeStore](#azure-data-lake-linked-service-properties)型のリンクされたサービス。
2. [AzureStorage](#azure-storage-linked-service-properties)型のリンクされたサービス。
3. [AzureDataLakeStore](#azure-data-lake-dataset-type-properties) 型の入力[データセット](data-factory-create-datasets.md)。
4. [AzureBlob](#azure-blob-dataset-type-properties) 型の出力[データセット](data-factory-create-datasets.md)。
5. [AzureDataLakeStoreSource](#azure-data-lake-copy-activity-type-properties) と [BlobSink](#azure-blob-copy-activity-type-properties) を使用するコピー アクティビティを含む[パイプライン](data-factory-create-pipelines.md)。
このサンプルは、Azure Data Lake Store から Azure BLOB に時系列データを&1; 時間おきにコピーします。 これらのサンプルで使用される JSON プロパティの説明はサンプルに続くセクションにあります。
**Azure Data Lake Store のリンクされたサービス:**
```JSON
{
"name": "AzureDataLakeStoreLinkedService",
"properties": {
"type": "AzureDataLakeStore",
"typeProperties": {
"dataLakeStoreUri": "https://<accountname>.azuredatalakestore.net/webhdfs/v1",
"servicePrincipalId": "<service principal id>",
"servicePrincipalKey": "<service principal key>",
"tenant": "<tenant info, e.g. microsoft.onmicrosoft.com>"
}
}
}
```
> [!NOTE]
> 構成の詳細については、「[Azure Data Lake Store のリンクされたサービスのプロパティ](#azure-data-lake-store-linked-service-properties)」セクションの手順を参照してください。
>
**Azure Storage のリンクされたサービス:**
```JSON
{
"name": "StorageLinkedService",
"properties": {
"type": "AzureStorage",
"typeProperties": {
"connectionString": "DefaultEndpointsProtocol=https;AccountName=<accountname>;AccountKey=<accountkey>"
}
}
}
```
**Azure Data Lake の入力データセット:**
**"external": true** の設定により、このテーブルが Data Factory の外部にあり、Data Factory のアクティビティによって生成されたものではないことが Data Factory サービスに通知されます。
```JSON
{
"name": "AzureDataLakeStoreInput",
"properties":
{
"type": "AzureDataLakeStore",
"linkedServiceName": "AzureDataLakeStoreLinkedService",
"typeProperties": {
"folderPath": "datalake/input/",
"fileName": "SearchLog.tsv",
"format": {
"type": "TextFormat",
"rowDelimiter": "\n",
"columnDelimiter": "\t"
}
},
"external": true,
"availability": {
"frequency": "Hour",
"interval": 1
},
"policy": {
"externalData": {
"retryInterval": "00:01:00",
"retryTimeout": "00:10:00",
"maximumRetry": 3
}
}
}
}
```
**Azure BLOB の出力データセット:**
データは新しい BLOB に 1 時間おきに書き込まれます (頻度: 時間、間隔: 1)。 BLOB のフォルダー パスは、処理中のスライスの開始時間に基づき、動的に評価されます。 フォルダー パスは開始時間の年、月、日、時刻の部分を使用します。
```JSON
{
"name": "AzureBlobOutput",
"properties": {
"type": "AzureBlob",
"linkedServiceName": "StorageLinkedService",
"typeProperties": {
"folderPath": "mycontainer/myfolder/yearno={Year}/monthno={Month}/dayno={Day}/hourno={Hour}",
"partitionedBy": [
{
"name": "Year",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "yyyy"
}
},
{
"name": "Month",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "MM"
}
},
{
"name": "Day",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "dd"
}
},
{
"name": "Hour",
"value": {
"type": "DateTime",
"date": "SliceStart",
"format": "HH"
}
}
],
"format": {
"type": "TextFormat",
"columnDelimiter": "\t",
"rowDelimiter": "\n"
}
},
"availability": {
"frequency": "Hour",
"interval": 1
}
}
}
```
**コピー アクティビティのあるパイプライン:**
パイプラインには、入力データセットと出力データセットを使用するように構成され、1 時間おきに実行するようにスケジュールされているコピー アクティビティが含まれています。 パイプライン JSON 定義で、**source** の型が **AzureDataLakeStoreSource** に設定され、**sink** の型が **BlobSink** に設定されています。
```JSON
{
"name":"SamplePipeline",
"properties":{
"start":"2014-06-01T18:00:00",
"end":"2014-06-01T19:00:00",
"description":"pipeline for copy activity",
"activities":[
{
"name": "AzureDakeLaketoBlob",
"description": "copy activity",
"type": "Copy",
"inputs": [
{
"name": "AzureDataLakeStoreInput"
}
],
"outputs": [
{
"name": "AzureBlobOutput"
}
],
"typeProperties": {
"source": {
"type": "AzureDataLakeStoreSource",
},
"sink": {
"type": "BlobSink"
}
},
"scheduler": {
"frequency": "Hour",
"interval": 1
},
"policy": {
"concurrency": 1,
"executionPriorityOrder": "OldestFirst",
"retry": 0,
"timeout": "01:00:00"
}
}
]
}
}
```
## <a name="azure-data-lake-store-linked-service-properties"></a>Azure Data Lake Store のリンクされたサービスのプロパティ
次の表では、Azure Data Lake Store のリンクされたサービスに固有の JSON 要素について説明します。**サービス プリンシパル**または**ユーザー資格情報**のいずれかの認証を選択できます。
| プロパティ | 説明 | 必須 |
|:--- |:--- |:--- |
| type | type プロパティを **AzureDataLakeStore** | はい |
| dataLakeStoreUri | Azure Data Lake Store アカウントの情報を指定します。 **https://[アカウント名].azuredatalakestore.net/webhdfs/v1** or **adl://[アカウント名].azuredatalakestore.net/** という形式で指定します。 | はい |
| subscriptionId | Data Lake Store が所属する Azure サブスクリプション ID。 | シンクでは必須 |
| resourceGroupName | Data Lake Store が所属する Azure リソース グループの名前。 | シンクでは必須 |
### <a name="using-service-principal-authentication-recommended"></a>サービス プリンシパル認証の使用 (推奨)
サービス プリンシパル認証を使用するには、最初に Azure Active Directory (AAD) でアプリケーション エンティティを登録して、Data Lake Store へのアクセス権を付与する必要があります。 その後、対応するアプリケーション ID、アプリケーション キー、およびテナント情報によって Azure Data Factory で以下のプロパティを指定して、Data Lake Store との間でデータをコピーできます。 これを設定して、必要な情報を取得する方法については、[サービス間認証](../data-lake-store/data-lake-store-authenticate-using-active-directory.md)に関するページをご覧ください。
> [!IMPORTANT]
> コピー ウィザードを使用する場合、フォルダー間を移動するには、サービス プリンシパルで少なくとも ADLS ルート ("/") に対する読み取りアクセス許可か、ADLS アカウントの閲覧者ロールが付与されている必要があります。 付与されていない場合、"提供された資格情報が無効" であることを示すエラーが表示されることがあります。
>
> サービス プリンシパルを AAD から新しく作成/更新した場合は、実際に有効になるまで数分間かかります。 まずサービス プリンシパルと ADLS ACL 構成を再確認し、「提供された資格情報が無効です」というエラーが解消されない場合、しばらく待ってからやり直してください。
>
| プロパティ | 説明 | 必須 |
|:--- |:--- |:--- |
| servicePrincipalId | アプリケーションのクライアント ID を取得します。 | はい |
| servicePrincipalKey | アプリケーションのキーを取得します。 | はい |
| テナント | アプリケーションが存在するテナントの情報 (ドメイン名またはテナント ID) を指定します。 Azure ポータルの右上隅にマウスを置くことで取得できます。 | はい |
**例: サービス プリンシパル認証の使用**
```json
{
"name": "AzureDataLakeStoreLinkedService",
"properties": {
"type": "AzureDataLakeStore",
"typeProperties": {
"dataLakeStoreUri": "https://<accountname>.azuredatalakestore.net/webhdfs/v1",
"servicePrincipalId": "<service principal id>",
"servicePrincipalKey": "<service principal key>",
"tenant": "<tenant info, e.g. microsoft.onmicrosoft.com>",
"subscriptionId": "<subscription of ADLS>",
"resourceGroupName": "<resource group of ADLS>"
}
}
}
```
### <a name="using-user-credential-authentication"></a>ユーザー資格情報認証の使用
また、以下のプロパティを指定することで、ユーザー資格情報認証を使用して、Data Lake Store との間でデータをコピーすることもできます。
| プロパティ | 説明 | 必須 |
|:--- |:--- |:--- |
| authorization | **Data Factory エディター**で **[承認する]** をクリックし、資格情報を入力すると、自動生成された承認 URL がこのプロパティに割り当てられます。 | はい |
| sessionId | OAuth 承認セッションの OAuth セッション ID。 各セッション ID は一意であり、1 回のみ使用できます。 Data Factory エディターを使用すると、この設定が自動的に生成されます。 | はい |
**例: ユーザー資格情報認証の使用**
```json
{
"name": "AzureDataLakeStoreLinkedService",
"properties": {
"type": "AzureDataLakeStore",
"typeProperties": {
"dataLakeStoreUri": "https://<accountname>.azuredatalakestore.net/webhdfs/v1",
"sessionId": "<session ID>",
"authorization": "<authorization URL>",
"subscriptionId": "<subscription of ADLS>",
"resourceGroupName": "<resource group of ADLS>"
}
}
}
```
#### <a name="token-expiration"></a>トークンの有効期限
**[承認する]** ボタンを使用して生成した承認コードは、いずれ有効期限が切れます。 さまざまな種類のユーザー アカウントの有効期限については、次の表を参照してください。 認証**トークンの有効期限が切れる**と、次のエラー メッセージが表示される場合があります: "資格情報の操作エラー: invalid_grant - AADSTS70002: 資格情報の検証中にエラーが発生しました。 AADSTS70008: 指定されたアクセス権の付与は期限が切れているか、失効しています。 トレース ID: d18629e8-af88-43c5-88e3-d8419eb1fca1 相関 ID: fac30a0c-6be6-4e02-8d69-a776d2ffefd7 タイムスタンプ: 2015-12-15 21-09-31Z"
| ユーザー タイプ | 有効期限 |
|:--- |:--- |
| Azure Active Directory で管理されていないユーザー アカウント (@hotmail.com, @live.com, など)。 |12 時間 |
| Azure Active Directory (AAD) で管理されているユーザー アカウント |スライスの最後の実行から&14; 日後。 <br/><br/>OAuth ベースのリンクされたサービスに基づいて、少なくとも 14 日間に 1 回スライスが実行する場合、90 日です。 |
このトークンの有効期限の前にパスワードを変更すると、トークンが即座に期限切れとなり、前述のエラーが表示されます。
このエラーを回避または解決するには、**トークンの有効期限が切れた**ときに、**[承認する]** ボタンを使用して再承認し、リンクされたサービスを再デプロイします。 次のセクションのコードを使用して、**sessionId** と **authorization** プロパティの値をプログラムで生成することもできます。
#### <a name="to-programmatically-generate-sessionid-and-authorization-values"></a>プログラムを使用して sessionId と authorization の値を生成するには
```csharp
if (linkedService.Properties.TypeProperties is AzureDataLakeStoreLinkedService ||
linkedService.Properties.TypeProperties is AzureDataLakeAnalyticsLinkedService)
{
AuthorizationSessionGetResponse authorizationSession = this.Client.OAuth.Get(this.ResourceGroupName, this.DataFactoryName, linkedService.Properties.Type);
WindowsFormsWebAuthenticationDialog authenticationDialog = new WindowsFormsWebAuthenticationDialog(null);
string authorization = authenticationDialog.AuthenticateAAD(authorizationSession.AuthorizationSession.Endpoint, new Uri("urn:ietf:wg:oauth:2.0:oob"));
AzureDataLakeStoreLinkedService azureDataLakeStoreProperties = linkedService.Properties.TypeProperties as AzureDataLakeStoreLinkedService;
if (azureDataLakeStoreProperties != null)
{
azureDataLakeStoreProperties.SessionId = authorizationSession.AuthorizationSession.SessionId;
azureDataLakeStoreProperties.Authorization = authorization;
}
AzureDataLakeAnalyticsLinkedService azureDataLakeAnalyticsProperties = linkedService.Properties.TypeProperties as AzureDataLakeAnalyticsLinkedService;
if (azureDataLakeAnalyticsProperties != null)
{
azureDataLakeAnalyticsProperties.SessionId = authorizationSession.AuthorizationSession.SessionId;
azureDataLakeAnalyticsProperties.Authorization = authorization;
}
}
```
コードで使用する Data Factory クラスの詳細については、「[AzureDataLakeStoreLinkedService Class](https://msdn.microsoft.com/library/microsoft.azure.management.datafactories.models.azuredatalakestorelinkedservice.aspx)」、「[AzureDataLakeAnalyticsLinkedService クラス](https://msdn.microsoft.com/library/microsoft.azure.management.datafactories.models.azuredatalakeanalyticslinkedservice.aspx)」、および「[AuthorizationSessionGetResponse クラス](https://msdn.microsoft.com/library/microsoft.azure.management.datafactories.models.authorizationsessiongetresponse.aspx)」をご覧ください。 このコードで使用されている WindowsFormsWebAuthenticationDialog クラスの **Microsoft.IdentityModel.Clients.ActiveDirectory.WindowsForms.dll** のバージョン **2.9.10826.1824** に参照を追加します。
## <a name="azure-data-lake-dataset-type-properties"></a>Azure Data Lake データセットの type プロパティ
データセットの定義に利用できる JSON のセクションとプロパティの完全一覧については、[データセットの作成](data-factory-create-datasets.md)に関する記事を参照してください。 データセット JSON の構造、可用性、ポリシーなどのセクションは、データセットのすべての型 (Azure SQL、Azure BLOB、Azure テーブルなど) でほぼ同じです。
**typeProperties** セクションは、データセットの型ごとに異なり、データ ストアのデータの場所や書式などに関する情報を提供します。 **AzureDataLakeStore** 型のデータセットの typeProperties セクションには、次のプロパティがあります。
| プロパティ | 説明 | 必須 |
|:--- |:--- |:--- |
| folderPath |Azure Data Lake Store のコンテナーとフォルダーのパス。 |はい |
| fileName |Azure Data Lake Store 内のファイルの名前。 fileName は省略可能で、大文字と小文字を区別します。 <br/><br/>fileName を指定すると、アクティビティ (コピーを含む) は特定のファイルで動作します。<br/><br/>fileName が指定されていない場合、コピーには入力データセットの folderPath のすべてのファイルが含まれます。<br/><br/>出力データセットに fileName が指定されていない場合、生成されるファイル名は次の形式になります: Data.<Guid>.txt (例: Data.0a405f8a-93ff-4c6f-b3be-f69616f1df7a.txt) |いいえ |
| partitionedBy |partitionedBy は任意のプロパティです。 これを使用し、時系列データに動的な folderPath と fileName を指定できます。 たとえば、1 時間ごとのデータに対して folderPath をパラメーター化できます。 詳細と例については、「 [partitionedBy プロパティの使用](#using-partitionedby-property) 」をご覧ください。 |なし |
| BlobSink の format | 次のファイル形式がサポートされます: **TextFormat**、**JsonFormat**、**AvroFormat**、**OrcFormat**、**ParquetFormat**。 形式の **type** プロパティをいずれかの値に設定します。 詳細については、[Text Format](#specifying-textformat)、[Json Format](#specifying-jsonformat)、[Avro Format](#specifying-avroformat)、[Orc Format](#specifying-orcformat)、[Parquet Format](#specifying-parquetformat) の各セクションを参照してください。 <br><br> ファイルベースのストア間で**ファイルをそのままコピー** (バイナリ コピー) する場合は、入力と出力の両方のデータセット定義で format セクションをスキップします。 |いいえ |
| compression | データの圧縮の種類とレベルを指定します。 サポートされる種類は **GZip**、**Deflate**、**BZip2**、**ZipDeflate** です。サポートされるレベルは **Optimal** と **Fastest** です。 詳細については、「[圧縮の指定](#specifying-compression)」セクションを参照してください。 |いいえ |
### <a name="using-partitionedby-property"></a>partitionedBy プロパティの使用
**partitionedBy** セクション、Data Factory マクロ、特定のデータ スライスの開始時刻と終了時刻を示すシステム変数の SliceStart と SliceEnd を使用して、時系列データの動的な folderPath と fileName を指定できます。
時系列データセット、スケジュール設定、スライスの詳細については、[データセットの作成](data-factory-create-datasets.md)に関する記事および[スケジュール設定と実行](data-factory-scheduling-and-execution.md)に関する記事をご覧ください。
#### <a name="sample-1"></a>サンプル 1
```JSON
"folderPath": "wikidatagateway/wikisampledataout/{Slice}",
"partitionedBy":
[
{ "name": "Slice", "value": { "type": "DateTime", "date": "SliceStart", "format": "yyyyMMddHH" } },
],
```
この例では、{Slice} は、指定された形式 (YYYYMMDDHH) で、Data Factory システム変数の SliceStart の値に置き換えられます。 SliceStart はスライスの開始時刻です。 folderPath はスライスごとに異なります。 例: wikidatagateway/wikisampledataout/2014100103 または wikidatagateway/wikisampledataout/2014100104
#### <a name="sample-2"></a>サンプル 2
```JSON
"folderPath": "wikidatagateway/wikisampledataout/{Year}/{Month}/{Day}",
"fileName": "{Hour}.csv",
"partitionedBy":
[
{ "name": "Year", "value": { "type": "DateTime", "date": "SliceStart", "format": "yyyy" } },
{ "name": "Month", "value": { "type": "DateTime", "date": "SliceStart", "format": "MM" } },
{ "name": "Day", "value": { "type": "DateTime", "date": "SliceStart", "format": "dd" } },
{ "name": "Hour", "value": { "type": "DateTime", "date": "SliceStart", "format": "hh" } }
],
```
この例では、SliceStart の年、月、日、時刻が folderPath プロパティと fileName プロパティで使用される個別の変数に抽出されます。
[!INCLUDE [data-factory-file-format](../../includes/data-factory-file-format.md)]
[!INCLUDE [data-factory-compression](../../includes/data-factory-compression.md)]
## <a name="azure-data-lake-copy-activity-type-properties"></a>Azure Data Lake のコピー アクティビティの type プロパティ
アクティビティの定義に利用できるセクションとプロパティの完全な一覧については、[パイプラインの作成](data-factory-create-pipelines.md)に関する記事を参照してください。 名前、説明、入力テーブル、出力テーブル、ポリシーなどのプロパティは、あらゆる種類のアクティビティで使用できます。
一方、アクティビティの typeProperties セクションで使用できるプロパティは、各アクティビティの種類によって異なります。 コピー アクティビティの場合、ソースとシンクの種類によって異なります
**AzureDataLakeStoreSource** の **typeProperties** セクションでは、次のプロパティがサポートされます。
| プロパティ | 説明 | 使用できる値 | 必須 |
| --- | --- | --- | --- |
| recursive |データをサブ フォルダーから再帰的に読み取るか、指定したフォルダーからのみ読み取るかを指定します。 |True (既定値)、False |いいえ |
**AzureDataLakeStoreSink** の **typeProperties** セクションでは、次のプロパティがサポートされます。
| プロパティ | 説明 | 使用できる値 | 必須 |
| --- | --- | --- | --- |
| copyBehavior |コピー動作を指定します。 |**PreserveHierarchy:** ターゲット フォルダー内でファイル階層を保持します。 ソース フォルダーに対するソース ファイルの相対パスと、ターゲット フォルダーに対するターゲット ファイルの相対パスが一致します。<br/><br/>**FlattenHierarchy**: ソース フォルダーのすべてのファイルがターゲット フォルダーの最初のレベルに作成されます。 ターゲット ファイルは、自動生成された名前で作成されます。<br/><br/>**MergeFiles:** ソース フォルダーのすべてのファイルを&1; つのファイルにマージします。 ファイル/Blob の名前を指定した場合、マージされたファイル名は指定した名前になります。それ以外は自動生成されたファイル名になります。 |いいえ |
[!INCLUDE [data-factory-structure-for-rectangualr-datasets](../../includes/data-factory-structure-for-rectangualr-datasets.md)]
[!INCLUDE [data-factory-type-conversion-sample](../../includes/data-factory-type-conversion-sample.md)]
[!INCLUDE [data-factory-column-mapping](../../includes/data-factory-column-mapping.md)]
## <a name="performance-and-tuning"></a>パフォーマンスとチューニング
Azure Data Factory には、大量の履歴データまたは増分運用データのロードで初期データ移動が計画されているかどうかに応じて、こうしたタスクのパフォーマンスを向上させるオプションが用意されています。 **コピー アクティビティ**に含まれる同時実行パラメーターは、さまざまなアクティビティ ウィンドウがどのように並行処理されるかを定義します。 **parallelCopies** パラメーターでは、1 つのアクティビティ実行の並列処理が定義されます。 最適なスループットを得られるように、Azure Data Factory でデータ移動パイプラインを設計するときに、こうしたパラメーターの使用を検討することが重要です。
Azure Data Factory でのデータ移動 (コピー アクティビティ) のパフォーマンスに影響する主な要因と、パフォーマンスを最適化するための各種方法については、「[コピー アクティビティのパフォーマンスとチューニングに関するガイド](data-factory-copy-activity-performance.md)」を参照してください。 | 24,973 | CC-BY-3.0 |
---
author: 郭于华
categories: [中國戰略分析]
date: 2018-01-30
from: http://zhanlve.org/?p=4227
layout: post
tags: [中國戰略分析]
title: 郭于华：希望的田野还是乡愁之地 ——《生存逻辑与治理逻辑》序
---
<div id="entry">
<div class="at-above-post addthis_tool" data-url="http://zhanlve.org/?p=4227">
</div>
<p>
</p>
<p>
<img alt="" class="aligncenter size-full wp-image-4231" height="175" sizes="(max-width: 175px) 100vw, 175px" src="http://zhanlve.org/wp-content/uploads/2018/01/e2a26c8985954ebs_1404721b6a8g86.jpg" srcset="http://zhanlve.org/wp-content/uploads/2018/01/e2a26c8985954ebs_1404721b6a8g86.jpg 175w, http://zhanlve.org/wp-content/uploads/2018/01/e2a26c8985954ebs_1404721b6a8g86-150x150.jpg 150w, http://zhanlve.org/wp-content/uploads/2018/01/e2a26c8985954ebs_1404721b6a8g86-144x144.jpg 144w" width="175"/>
</p>
<p>
</p>
<p>
<span style="font-size: 12pt;">
李洁在其博士论文基础上的研究专著《生存逻辑与治理逻辑》就要出版了。在当今时代农村社会的困境与其社会关注程度不成比例的情境下，这样一部著作或许不会成为吸引目光的畅销书，但却一定是重要和值得人们思考的学术成果。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
中国社会正处于大转型时期，而当代社会转型是从农村开始的，或者可以说农村改革是整个中国改革的发祥之地。李洁博士的研究以转型社会学的视角，运用口述历史方法，通过与农村改革亲历者们的互动、以深入细致的田野工作获得第一手宝贵材料，为读者讲述了一个安徽农村改革发端期的故事。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
长期以来，有关中国农村改革的结构性因素、动力机制、各层级之间的关系和张力等始终存在诸多不同的看法和争论：国家与农民谁是农村改革的真正推动者？分田到户、实行“联产承包责任制”究竟是底层农民的“伟大创举”？还是各级领导者抑或顶层的设计？市场经济到底姓资还是也可以姓社？一个社会主义的农业大国之转型，无疑是一个错综复杂充满变数和偶然性的艰难历程。如果没有结构-过程互构的视角，没有理论与实践并重的探索，没有自上而下与自下而上相结合的研究是难以回答上述问题的。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
李洁博士的研究通过对中国农村改革最早的发源地之一——安徽省农村改革实践的分析，试图回答这样一个关乎中国市场转型的源流问题：农村改革何以发生？如何发生？研究再现了集体化末期中国乡村社会的复杂面相与农村改革初期国家-农民关系的实践过程，力图恢复“历史”本身的多重面貌，致力于从普通人的日常生活中构建历史，并从中洞悉文明运作的逻辑。从她的论述中读者可以获知，中国农村改革并非简单的国家巨手推动抑或农民自下而上地发起，事实上，在各种权力关系与历史话语框架互相嵌套与掣肘的背景下，任何一方都不足以推进整个改革进程。在某些情境下，国家与农民甚至需要借助对方的话语和逻辑，以实现政策层面的灵活变通与国家统一治理的协同与自洽。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
本书的出版会进一步丰富我们对中国乡村社会权力运作逻辑和中国农村改革深层结构的理解，其意义不仅在于认识历史，也有助于理解现实并寻求农村发展的路径。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
当年改革初期的乡村变迁与今日农村的社会结构状态及农民的出路有着内在的关联。改革开放是旧体制走到尽头、不得不进行变革的行动；时至今日变革的脚步仍在行进之中。换句话说，在现代化、工业化、城市化进程中中国农村的出路何在？一直是困扰我们的难题；农村社会的转型步履维艰，仍是横亘于人们心头的思虑。不知起自何时，怀有乡愁，记住乡愁，成为已经城市化的人们的一种情怀，然而，思念寄于何乡何土却已然成了问题与困惑。在中国语境下，所谓乡愁，既有人们对故土田园生活方式的怀念，更有对农民困境和乡村凋敝的担忧。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
在中国快速城镇化的进程中，人们一边惊异于城市面积和人口的急剧扩张，一边又感叹着乡村精英的流失和乡村社会的凋敝，悲哀着乡愁无所寄托，并时常将其归因为城乡之间的人口流动。农村的留守儿童、留守老人、留守妇女问题越来越突显，且似乎的确是伴随着城市化进程而出现的。但如果我们将眼光放长远一点并用结构性视角去看待分析这些问题，就无法回避这样的思考：今日乡村的困境包括老人自杀率上升、儿童认知能力偏低 [1]、家庭生活不正常等等仅仅是由于人口流动、青壮年劳动力外出打工造成的吗？
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
人类社会从传统走向现代，通常是一个“农民终结”的趋势。“农民的终结”曾经是一个法国及西方国家的命题，而今天也是中国社会现代化的命题。我们不妨先看一下《农民的终结》的作者是在什么意义上讲“终结”的。他所说的终结并非指农村消失了，农业不存在了或居住在乡村的人不存在了。其书再版时（1984年）法国正在经历作者所言的“乡村社会的惊人复兴”，其表现为：（1）农业人口的外流仍在继续，同时乡村人口的外流却放缓了。1975年以后流动方向发生逆转，有些乡村地区的人口重新增加了。（2）农业劳动者在乡村社会中成为少数，工人、第三产业人员经常占大多数。（3）家庭与经营分离，从事多种就业活动的家庭经营成倍地增加。（4）通讯和交通网络进入乡村系统。（5）乡下人享有城市的一切物质条件和舒适，他们的生活方式城市化了（70年代完成的）。“法国社会的这个奇特的矛盾在任何其它国家中都看不到：乡村在生活方式上完全城市化了，但乡村和城市之间的差别仍然如此之大，以至于城市人一有可能就从城里溜走，仿佛只有这一点才赋予生活一种意义”。传统意义上自给自足的农民已经不存在了，当前在农村中从事家庭经营的是以营利和参与市场交换为生产目的的农业劳动者，这种家庭经营体从本质上说已属于一种“企业”，但较工业企业有其自身的特点和特殊的运行机制。永恒的“农民精神”在我们眼前死去了，同时灭亡的还有家族制和家长制。这是工业社会征服传统文明的最后一块地盘。于是“乡下人”——成为化石般的存在物。[2]
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
相较于其他国家的城市化过程，中国所面临的现实是农村趋于凋敝，而农民却并未“终结”。农民问题在中国社会转型过程中是最沉重也是最严峻的问题，我们可以从两个方面加以表述。其一是城市化制约：长久以来制度安排形成的结构性屏障限制了城市化的正常进程，农民作为国民人口的大多数、粮食商品率稳定在35%以下，是持续已久的现实。直到2011年底，中国城镇人口才首次超过农村人口，达到51.27%。而农民进入大城市的制度瓶颈依然存在，并且已经城镇化的农民在就业、生计、保障和后代可持续发展方面也依然存在困境。已故的三农问题专家陆学艺先生曾经批评到：“城市在扩张过程中需要绿化美化，在农村看到一棵大树很漂亮就要搬到城里去；连大树都城市化了，却不让农民城市化。”
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
其二是农民工困境：与城市化问题相关，改革开放三十多年来形成的农民工问题没有从根本上得以解决。相关统计数字显示，全国农民工总量已达2.7395亿，其中新生代农民工已成为这支流动大军的主体。[3] 我们可以新生代农民工为例，所谓“新生代”并非仅仅是年龄或代际概念，而是揭示了一种新的生产关系和新的身份认同交织在一个“世界工厂”时代的劳工群体。与其父辈相比，其自身鲜明的特点折射出“新生代”作为制度范畴，与乡村、城市、国家、资本所具有的不同于上一代的关系。他们受教育程度较高，不愿认命，有着更强烈的表达利益诉求和对未来更好生活的要求。而他们所面临的似乎无解的现实却是融不进的城市，回不去的乡村。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
难以化解的矛盾表现为新生代与旧体制之间的冲突：“旧体制”是指自改革开放以来形成并延续了30年之久的“农民工生产体制”，其中一个重要的面向就是“拆分型劳动力再生产制度”，其基本特征是将农民工劳动力再生产的完整过程分解开来：其中，“更新”部分如赡养父母、养育子嗣以及相关的教育、医疗、住宅、养老等保障安排交由他们所在乡村地区的老家去完成，而城镇和工厂只负担这些农民工个人劳动力日常“维持”的成本。[4] 这种特色体制造成并维持了农民工融入城市的困境，以及与之相伴的留守儿童、老人、女性的悲剧和每年“春运”的独特景观。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
上述困境让人无法不思考的问题是：什么是真正意义上的城市化？到底是谁的城市化？城市化的本质是什么？政府主导的城乡一体化格局如何实现？显而易见，只要人手不要人口，只要劳力不要农民的城市化不是真正的城市化和现代化。人们常说，中国的问题是农民的问题，意为农民、农村和农业是中国社会转型中最大最难的问题；人们也常说，农民的问题是中国的问题，这并非同义反复地强调，而是说所谓“三农”问题仅仅从农村和农业范围着手是无从解决的，农民问题是全局性的而且必须在整个社会的结构和制度中去思考和解决。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
从农民的概念出发，我们很容易理解，中国农民从来不是作为Farmer存在的，他们不是农业经营者或农业企业家，而是作为peasant 的小农，他们从事的只是家户经济。农民与其他社会群体的区别根本上不是从业的、职业的区别，而是社会身份、地位的差别。在中国语境下，无论将农民放在社会分层的什么位置上——工人阶级最亲密的同盟军也好，社会金字塔的最底层也罢，中国农民都不是劳动分工意义上的类别，而是社会身份和地位上的类别。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
从中国农民的结构位置看，农民在历史上一直处于被剥夺的位置，在特定时期甚至被剥夺殆尽。长久以来，他们总是社会变革的代价的最大承受者，却总是社会进步的最小获益者；其二等国民的待遇勿庸讳言。农村一直是被抽取的对象——劳动力、农产品、税费、资源（土地）。如同一片土地，永远被利用、被开采、被索取，没有投入，没有休养生息，只会越来越贫瘠。不难看出，农村今日之凋敝，并非缘起于市场化改革后的劳动力流动，农民作为弱势人群的种子早已埋下：传统的消失，宗族的解体，信仰的缺失，地方社会之不存，这些在半个多世纪之前已经注定。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
经历了长久的城市与农村的分隔状态，所谓城乡二元已经不止是一种社会结构，而且成为一种思维结构。剥离了农民的权利所进行的城镇化，是缺少主体及其自主选择权的城镇化。在这一过程中，农民的权利被忽略或被轻视，农民被作为丧失了主体性，自己过不好自己的日子，不能自主决策的弱者群体。解决农民问题，推进中国的城市化、现代化进程，必须给农民还权赋能（empower），即还他们本应具有的生存权、财产权和追求幸福的权利。如此，一些底层群体的悲剧，农民和农业的困境，以及乡村社会的颓败之势是否可以避免呢？
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
从已经走过三十多年的农村改革进程开始，梳理社会转型的历史脉络，李洁博士的努力对于我们如何从社会结构和制度层面思考解决农村问题乃至中国问题当有所启发。
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
2017年10月18日
</span>
</p>
<p>
<span style="font-size: 12pt;">
</span>
</p>
<p>
<span style="font-size: 12pt;">
[1] 美国斯坦福大学教授罗斯高（Scott Rozelle）研究团队，“农村教育行动计划”（Rural Education Action Program，REAP）见https://theinitium.com/article/20161206-dailynews-china-western-children/
</span>
</p>
<p>
<span style="font-size: 12pt;">
[2] [法]H. 孟德拉斯，《农民的终结》（19641984），李培林译，中国社会科学出版社，1991年。
</span>
</p>
<p>
<span style="font-size: 12pt;">
[3] See http://www.gov.cn/xinwen/2015-04/29/content_2854930.htm，登陆日期：2015-12-10.
</span>
</p>
<p>
<span style="font-size: 12pt;">
[4] 清华大学社会学系“新生代农民工研究课题组：困境与行动——新生代农民工与“农民工生产体制”的碰撞，《清华社会学评论》第六辑，2013年。
</span>
</p>
<p>
</p>
<p>
<span style="font-size: 12pt;">
出处：爱思想
</span>
</p>
<p>
</p>
<!-- AddThis Advanced Settings above via filter on the_content -->
<!-- AddThis Advanced Settings below via filter on the_content -->
<!-- AddThis Advanced Settings generic via filter on the_content -->
<!-- AddThis Share Buttons above via filter on the_content -->
<!-- AddThis Share Buttons below via filter on the_content -->
<div class="at-below-post addthis_tool" data-url="http://zhanlve.org/?p=4227">
</div>
<!-- AddThis Share Buttons generic via filter on the_content -->
</div> | 7,530 | MIT |
# Morn Boot Projects
[](https://search.maven.org/search?q=morn-boot-projects)
[](https://app.travis-ci.com/morn-team/morn-boot-projects)
[](https://www.codacy.com/gh/morn-team/morn-boot-projects/dashboard?utm_source=github.com&utm_medium=referral&utm_content=morn-team/morn-boot-projects&utm_campaign=Badge_Grade)
[](https://codecov.io/gh/morn-team/morn-boot-projects)
[](https://www.apache.org/licenses/LICENSE-2.0)
MornBoot是基于SpringBoot的标准API框架，致力于为JavaWeb项目提供标准化API。MornBoot初衷是提供简洁的、可拓展的通用功能实现，为SpringBoot项目提供一个良好的开端。MornBoot侧重于开发风格、标准、规范，提供开箱即用的优秀实践。
> 如果你的所有项目都使用同一套API开发，那么更新、维护将变得多么简单！
## Features
* “零配置”轻量级框架
* 相同API，不同结果呈现
* 极简风格代码，良好可读性
* 友好的IDE提示信息
## Getting Help
MornBoot没有强制依赖SpringBoot，你必须在项目中引入SpringBoot相关包，好处是你可以自由选择依赖版本。建议SpringBoot版本为2.1.X。
[ApplicationMessage]:https://github.com/morn-team/morn-boot-projects/wiki/ApplicationMessage-%E5%BA%94%E7%94%A8%E6%B6%88%E6%81%AF
[BeanEnhance]:https://github.com/morn-team/morn-boot-projects/wiki/BeanEnhance-%E5%AE%9E%E4%BE%8B%E5%A2%9E%E5%BC%BA
[CacheGroup]:https://github.com/morn-team/morn-boot-projects/wiki/CacheGroup-%E5%88%86%E7%BB%84%E7%BC%93%E5%AD%98
[Cipher]:https://github.com/morn-team/morn-boot-projects/wiki/Cipher-%E6%B6%88%E6%81%AF%E5%8A%A0%E5%AF%86
[ExceptionInterpreter]:https://github.com/morn-team/morn-boot-projects/wiki/ExceptionInterpreter-%E5%BC%82%E5%B8%B8%E8%A7%A3%E9%87%8A
[JpaAssist]:https://github.com/morn-team/morn-boot-projects/wiki/JpaAssist-JPA%E8%BE%85%E5%8A%A9
[JSON]:https://github.com/morn-team/morn-boot-projects/wiki/JSON-%E5%BA%8F%E5%88%97%E5%8C%96
[MessageQueue]:https://github.com/morn-team/morn-boot-projects/wiki/MessageQueue-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97
[MornBoot]:https://github.com/morn-team/morn-boot-projects
[Notify]:https://github.com/morn-team/morn-boot-projects/wiki/Notify-%E7%B3%BB%E7%BB%9F%E9%80%9A%E7%9F%A5
[OperationLog]:https://github.com/morn-team/morn-boot-projects/wiki/OperationLog-%E6%93%8D%E4%BD%9C%E6%97%A5%E5%BF%97
[ParamsValidation]:https://github.com/morn-team/morn-boot-projects/wiki/ParamsValidation-%E6%95%B0%E6%8D%AE%E6%A0%A1%E9%AA%8C
[PersistFunction]:https://github.com/morn-team/morn-boot-projects/wiki/PersistFunction-%E6%8C%81%E4%B9%85%E5%8C%96%E5%87%BD%E6%95%B0
[RestMessage]:https://github.com/morn-team/morn-boot-projects/wiki/RestMessage-REST%E6%B6%88%E6%81%AF
[SpringBoot]:https://spring.io/projects/spring-boot
## Quick Start
### Maven Dependency
最新版本: [](https://search.maven.org/search?q=morn-boot-projects)
```
<!--自动化配置-->
<dependency>
<groupId>site.morn.boot</groupId>
<artifactId>morn-boot-autoconfigure</artifactId>
<version>${morn.version}</version>
</dependency>
<!--核心库-->
<dependency>
<groupId>site.morn.boot</groupId>
<artifactId>morn-boot-core</artifactId>
<version>${morn.version}</version>
</dependency>
```
### 必要配置
SpringBootApplication
```
@EnableCaching // 开启缓存
```
## Reference
### Specification 规范
基于[SpringBoot][SpringBoot]提供常用业务组件的基础规范及组件，这些组件更类似优秀实践。
它们介于实际业务和Framework之间，同时这也是[MornBoot][MornBoot]框架的定位。 不同业务框架往往会开发各式各样的业务组件，功能大同小异，质量参差不齐，结构缺乏包容性。
[MornBoot][MornBoot]设计的初衷就是提供标准组件，替代这些业务组件，并提供足够高的扩展性以包容各种业务场景。
* [ApplicationMessage][ApplicationMessage]：应用消息
* [Notify][Notify]：系统通知
* [OperationLog][OperationLog]：操作日志
* [RestMessage][RestMessage]：REST消息
### CRUD 搬砖
主要提供`MVC`、`ORM`业务中，较为常见和基础的组件、规范。
* [CacheGroup][CacheGroup]：分组缓存
* [Cipher][Cipher]：消息加密
* [JSON][JSON]：序列化
* [ParamsValidation][ParamsValidation]：参数校验
* [PersistFunction][PersistFunction]：持久化函数
### Features 特性
主要提供[MornBoot][MornBoot]特有的特性、功能，[MornBoot][MornBoot]
中的许多组件依赖这些特性进行开发，部分特性拥有极高的扩展性，并不仅限于供[MornBoot][MornBoot]使用。部分特性的设计初衷就是让使用者依据自身业务框架进行补充和扩展。
* [BeanEnhance][BeanEnhance]：实例增强
* [ExceptionInterpreter][ExceptionInterpreter]：异常解释
### Framework 框架
主要提供主流开源框架的封装、扩展，提供更具业务化的组件，提升开发效率。这些组件并不是单纯的对框架进行使用，也提供了一些实践思路，和包容性的结构，以及对框架使用过程的优化和完善。
> 开源框架、中间件通常倾向于提高特性、功能、性能，而MornBoot则侧重提升框架使用体验和效率，并尽可能兼容足够多的框架能力。
* [JpaAssist][JpaAssist]：JPA辅助
* [MessageQueue][MessageQueue]：消息队列 | 4,639 | Apache-2.0 |
# bboss http负载均衡器使用指南
bboss http一个简单而功能强大的http/https负载均衡器模块，基于http/https协议实现客户端-服务端点到点的负载均衡和集群容灾功能，本文介绍其使用方法。
项目源码
https://github.com/bbossgroups/bboss-http
httpproxy 案例：基于apollo进行配置管理、节点自动发现、路由规则自动切换，源码地址
https://github.com/bbossgroups/httpproxy-apollo
# 1.负载均衡器特色
bboss http基于http/https协议实现客户端-服务端点到点的负载均衡和集群容灾功能，具有以下特色
```properties
1.服务负载均衡（目前提供RoundRobin负载算法）
2.服务健康检查
3.服务容灾故障恢复
4.服务自动发现（zk，etcd，consul，eureka，db，其他第三方注册中心）
5.本地地址清单与远程配置中心动态地址管理相结合，远程不可用时，采用本地地址
6.动态监听路由变化
7.分组服务管理
可以配置多组服务集群地址，每一组地址清单支持的配置格式：
http://ip:port
https://ip:port
ip:port（默认http协议）
多个地址用逗号分隔
8.服务安全认证（配置basic账号和口令）
9.服务采用http连接池
10.主备路由/异地灾备特色
10.1.负载均衡器主备功能，如果主节点全部挂掉，请求转发到可用的备用节点，如果备用节点也挂了，就抛出异常，如果主节点恢复正常，那么请求重新发往主节点
10.2. 异地灾备，服务采用异地灾备模式部署，服务优先调用本地，当本地服务全部挂掉，服务请求转发到异地服务，如果本地服务部分恢复或者全部恢复，那么请求重新发往本地服务
```
# 2.导入http负载均衡器
在工程中导入以下maven坐标即可
```xml
<dependency>
<groupId>com.bbossgroups</groupId>
<artifactId>bboss-http</artifactId>
<version>5.8.9</version>
</dependency>
```
如果是gradle工程，导入方法如下：
```groovy
implementation 'com.bbossgroups:bboss-http:5.8.9'
```
# 3.负载均衡组件
```java
org.frameworkset.spi.remote.http.HttpRequestProxy
```
## 3.1 负载均衡组件API
### 3.1.1 初始化http proxy
HttpRequestProxy.startHttpPools(Map configs); --通过在代码中设置参数，初始化httpproxy
HttpRequestProxy.startHttpPools(String configFile);--加载配置文件（classpath相对路径）中设置参数，初始化httpproxy
#### **1）加载配置文件启动示例**
```java
//加载配置文件，启动负载均衡器
HttpRequestProxy.startHttpPools("application.properties");
```
#### 2）加载Map属性配置启动负载均衡器示例
**简单的配置和启动**
```java
Map<String,Object> configs = new HashMap<String,Object>();
configs.put("http.health","/health.html");//health监控检查地址必须配置，否则将不会启动健康检查机制
//如果指定hosts那么就会采用配置的地址作为初始化地址清单
configs.put("http.hosts，","192.168.137.1:9200,192.168.137.2:9200,192.168.137.3:9200");
HttpRequestProxy.startHttpPools(configs);
```
**启动时指定服务发现机制**
```java
Map<String,Object> configs = new HashMap<String,Object>();
DemoHttpHostDiscover demoHttpHostDiscover = new DemoHttpHostDiscover();
configs.put("http.discoverService",demoHttpHostDiscover);//设置服务发现组件
configs.put("http.health","/health.html");//health监控检查地址必须配置，否则将不会启动健康检查机制
//如果指定hosts那么就会采用配置的地址作为初始化地址清单，后续通过discoverService服务发现的地址都会加入到清单中，去掉的服务也会从清单中剔除
configs.put("http.hosts，","192.168.137.1:9200,192.168.137.2:9200,192.168.137.3:9200");
HttpRequestProxy.startHttpPools(configs);
```
#### **3）加载apollo配置启动httpproxy**
指定apollo命名空间和配置参数变化监听器（自定义）
```java
/**
* 从apollo加载配置启动http proxy：
* 配置了两个连接池：default,schedule
* apollo namespace: application
* 服务地址变化发现监听器： org.frameworkset.http.client.AddressConfigChangeListener
*/
HttpRequestProxy.startHttpPoolsFromApollo("application","org.frameworkset.http.client.AddressConfigChangeListener");
```
指定apollo命名空间并监听服务节点及路由规则变化
```java
/**
* 1.服务健康检查
* 2.服务负载均衡
* 3.服务容灾故障恢复
* 4.服务自动发现（apollo，zk，etcd，consul，eureka，db，其他第三方注册中心）
* 配置了两个连接池：default,report
* 本示例演示基于apollo提供配置管理、服务自动发现以及灰度/生产，主备切换功能
*/
HttpRequestProxy.startHttpPoolsFromApolloAwaredChange("application");
```
### 3.1.2 调用服务API及示例
HttpRequestProxy.httpGetforString
HttpRequestProxy.httpXXX
HttpRequestProxy.sendXXX
提供了两套方法：一套方法是带服务组名称的方法，一套方法是不带服务组名称的方法（默认default服务组）
服务地址都是相对地址，例如：/testBBossIndexCrud，最终地址会被解析为
http://ip:port/testBBossIndexCrud 或者 https://ip:port/testBBossIndexCrud
默认服务组示例
```java
//以get方式发送请求
String data = HttpRequestProxy.httpGetforString("/testBBossIndexCrud");
//以get方式发送请求,将返回的json数据封装为AgentRule对象
AgentRule agentRule = HttpRequestProxy.httpGetforObject("/testBBossIndexCrud?id=1",AgentRule.class);
//以RequestBody方式，将params对象转换为json报文post方式推送到服务端，将相应json报文转换为AgentRule对象返回
AgentRule agentRule = HttpRequestProxy.sendJsonBody( params, "/testBBossIndexCrud",AgentRule.class);
//以post方式发送请求,将返回的json数据封装为AgentRule对象,方法第二个参数为保存请求参数的map对象
AgentRule data = HttpRequestProxy.httpPostForObject("/testBBossIndexCrud",(Map)null,AgentRule.class);
//以post方式发送请求,将返回的json数据封装为AgentRule对象List集合,方法第二个参数为保存请求参数的map对象
List<AgentRule> datas = HttpRequestProxy.httpPostForList("/testBBossIndexCrud",(Map)null,AgentRule.class);
//以post方式发送请求,将返回的json数据封装为AgentRule对象Set集合,方法第二个参数为保存请求参数的map对象
Set<AgentRule> dataSet = HttpRequestProxy.httpPostForSet("/testBBossIndexCrud",(Map)null,AgentRule.class);
//以post方式发送请求,将返回的json数据封装为AgentRule对象Map集合,方法第二个参数为保存请求参数的map对象
Map<String,AgentRule> dataMap = HttpRequestProxy.httpPostForMap("/testBBossIndexCrud",(Map)null,String.class,AgentRule.class);
```
指定服务组示例
```java
String data = HttpRequestProxy.httpGetforString("report","/testBBossIndexCrud");
AgentRule agentRule = HttpRequestProxy.httpGetforObject("report","/testBBossIndexCrud",AgentRule.class);
AgentRule agentRule = HttpRequestProxy.sendJsonBody("report", params, "/testBBossIndexCrud",AgentRule.class);
AgentRule data = HttpRequestProxy.httpPostForObject("report","/testBBossIndexCrud",(Map)null,AgentRule.class);
List<AgentRule> datas = HttpRequestProxy.httpPostForList("report","/testBBossIndexCrud",(Map)null,AgentRule.class);
Set<AgentRule> dataSet = HttpRequestProxy.httpPostForSet("report","/testBBossIndexCrud",(Map)null,AgentRule.class);
Map<String,AgentRule> dataMap = HttpRequestProxy.httpPostForMap("report","/testBBossIndexCrud",(Map)null,String.class,AgentRule.class);
```
## 3.2 http负载均衡器配置和启动
http负载均衡器配置非常简单，可以通过配置文件方式和代码方式对http负载均衡器进行配置
### 3.2.1 配置文件方式
在配置文件中添加以下内容-resources\application.properties
```properties
http.poolNames = default,schedule
##http连接池配置
http.timeoutConnection = 5000
http.timeoutSocket = 50000
http.connectionRequestTimeout=10000
http.retryTime = 0
http.maxLineLength = -1
http.maxHeaderCount = 200
http.maxTotal = 200
http.defaultMaxPerRoute = 100
http.soReuseAddress = false
http.soKeepAlive = false
http.timeToLive = 3600000
http.keepAlive = 3600000
http.keystore =
http.keyPassword =
# ssl 主机名称校验，是否采用default配置，
# 如果指定为default，就采用DefaultHostnameVerifier,否则采用 SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER
http.hostnameVerifier =
# 服务代理配置
# 服务全认证账号配置
http.authAccount=elastic
http.authPassword=changeme
# ha proxy 集群负载均衡地址配置
http.hosts=192.168.137.1:808,192.168.137.1:809,192.168.137.1:810
# https服务必须带https://协议头
#http.hosts=https://192.168.137.1:808,https://192.168.137.1:809,https://192.168.137.1:810
# 健康检查服务
http.health=/health
# 健康检查定时时间间隔，单位：毫秒，默认3秒
http.healthCheckInterval=3000
# 服务地址自动发现功能
http.discoverService=org.frameworkset.http.client.DemoHttpHostDiscover
# 定时运行服务发现方法时间间隔，单位：毫秒，默认10秒
http.discoverService.interval=10000
##告警服务使用的http连接池配置
schedule.http.timeoutConnection = 5000
schedule.http.timeoutSocket = 50000
schedule.http.connectionRequestTimeout=10000
schedule.http.retryTime = 0
schedule.http.maxLineLength = -1
schedule.http.maxHeaderCount = 200
schedule.http.maxTotal = 200
schedule.http.defaultMaxPerRoute = 100
schedule.http.soReuseAddress = false
schedule.http.soKeepAlive = false
schedule.http.timeToLive = 3600000
schedule.http.keepAlive = 3600000
schedule.http.keystore =
schedule.http.keyPassword =
# ssl 主机名称校验，是否采用default配置，
# 如果指定为default，就采用DefaultHostnameVerifier,否则采用 SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER
schedule.http.hostnameVerifier =
# 告警服务使用服务代理配置
# 服务全认证账号配置
schedule.http.authAccount=elastic
schedule.http.authPassword=changeme
# ha proxy 集群负载均衡地址配置
schedule.http.hosts=192.168.137.1:808,192.168.137.1:809,192.168.137.1:810
# https服务必须带https://协议头
# schedule.http.hosts=https://192.168.137.1:808,https://192.168.137.1:809,https://192.168.137.1:810
# 健康检查服务
schedule.http.health=/health
# 健康检查定时时间间隔，单位：毫秒，默认3秒
schedule.http.healthCheckInterval=3000
# 服务地址自动发现功能
schedule.http.discoverService=org.frameworkset.http.client.DemoHttpHostDiscover
# 定时运行服务发现方法时间间隔，单位：毫秒，默认10秒
schedule.http.discoverService.interval=10000
```
上面配置了default和schedule两组服务配置，每组包含两部分内容：
- http连接池配置
- 服务负载均衡配置
http连接池配置这里不着重说明，只介绍服务负载均衡相关配置
```properties
# 服务代理配置
# 服务全认证账号和口令配置
http.authAccount=elastic
http.authPassword=changeme
# ha proxy 集群负载均衡地址配置，初始地址清单，
# 还可以通过http.discoverService动态发现新的负载地址、移除关停的负载地址，也可以不配置初始地址
# 这样初始地址完全由http.discoverService对应的服务发现功能来提供
http.hosts=192.168.137.1:808,192.168.137.1:809,192.168.137.1:810
# https服务必须带https://协议头
#http.hosts=https://192.168.137.1:808,https://192.168.137.1:809,https://192.168.137.1:810
# 健康检查服务，服务端提供的一个监控服务检查地址，当服务节点不可用时，就会启动健康检查,根据healthCheckInterval参数，按一定的时间间隔探测health对应的服务是否正常，如果正常，那么服务即可用，健康检查线程停止（直到服务不可用时，再次启动检查机制），否则继续监测
http.health=/health
# 健康检查定时时间间隔，单位：毫秒，默认3秒
http.healthCheckInterval=3000
# 服务地址自动发现功能，必须继承抽象类org.frameworkset.spi.remote.http.proxy.HttpHostDiscover
# 实现抽象方法discover
http.discoverService=org.frameworkset.http.client.DemoHttpHostDiscover
```
org.frameworkset.http.client.DemoHttpHostDiscover的实现如下：
```java
package org.frameworkset.http.client;
import org.frameworkset.spi.assemble.GetProperties;
import org.frameworkset.spi.remote.http.ClientConfiguration;
import org.frameworkset.spi.remote.http.HttpHost;
import org.frameworkset.spi.remote.http.proxy.HttpHostDiscover;
import org.frameworkset.spi.remote.http.proxy.HttpServiceHostsConfig;
import java.util.ArrayList;
import java.util.List;
public class DemoHttpHostDiscover extends HttpHostDiscover {
private int count = 0;
@Override
protected List<HttpHost> discover(HttpServiceHostsConfig httpServiceHostsConfig,
ClientConfiguration configuration,
GetProperties context) {
//直接构造并返回三个服务地址的列表对象
List<HttpHost> hosts = new ArrayList<HttpHost>();
// https服务必须带https://协议头,例如https://192.168.137.1:808
HttpHost host = new HttpHost("192.168.137.1:808");
hosts.add(host);
if(count != 2) {//模拟添加和去除节点
host = new HttpHost("192.168.137.1:809");
hosts.add(host);
}
else{
System.out.println("aa");
}
host = new HttpHost("192.168.137.1:810");
hosts.add(host);
count ++;
return hosts;
}
/**
* 返回null或者false，忽略对返回的null或者空的hosts进行处理；
* 返回true，要对null或者空的hosts进行处理，这样会导致所有的地址不可用
*
* @return 默认返回null
*/
protected Boolean handleNullOrEmptyHostsByDiscovery(){
return null;
}
}
```
### 3.2.2 加载配置文件启动负载均衡器
```java
HttpRequestProxy.startHttpPools("application.properties");
```
### 3.2.3 代码方式配置和启动负载均衡器
#### 单集群
配置和启动
```java
Map<String,Object> configs = new HashMap<String,Object>();
configs.put("http.health","/health");//health监控检查地址必须配置，否则将不会启动健康检查机制
DemoHttpHostDiscover demoHttpHostDiscover = new DemoHttpHostDiscover();
configs.put("http.discoverService",demoHttpHostDiscover);//注册服务发现机制，服务自动发现（zk，etcd，consul，eureka，db，其他第三方注册中心）
//启动负载均衡器
HttpRequestProxy.startHttpPools(configs);
```
服务调用示例
```java
String data = HttpRequestProxy.httpGetforString("/testBBossIndexCrud");//获取字符串报文
Map data = HttpRequestProxy.httpGetforObject("/testBBossIndexCrud",Map.class);//获取对象数据
```
#### 多集群
配置和启动：两个集群default,report
```java
/**
* 1.服务健康检查
* 2.服务负载均衡
* 3.服务容灾故障恢复
* 4.服务自动发现（zk，etcd，consul，eureka，db，其他第三方注册中心）
* 配置了两个服务集群组：default,report
*/
Map<String,Object> configs = new HashMap<String,Object>();
configs.put("http.poolNames","default,report");
//default组配置
configs.put("http.health","/health");//health监控检查地址必须配置，否则将不会启动健康检查机制
DemoHttpHostDiscover demoHttpHostDiscover = new DemoHttpHostDiscover();
configs.put("http.discoverService",demoHttpHostDiscover);
//report组配置
configs.put("report.http.health","/health");//health监控检查地址必须配置，否则将不会启动健康检查机制
configs.put("report.http.discoverService","org.frameworkset.http.client.DemoHttpHostDiscover");
//启动负载均衡器
HttpRequestProxy.startHttpPools(configs);
```
服务调用
```java
String data = HttpRequestProxy.httpGetforString("/testBBossIndexCrud");//在default集群上执行请求，无需指定集群名称
String data = HttpRequestProxy.httpGetforString("report","/testBBossIndexCrud");//在report集群上执行请求
```
### 3.2.4 配置参数中使用环境变量
可以在配置参数中使用环境变量，环境变量引用方式：
简单方式
http.routing=#[area]
混合方式
http.routing=#[area]dddd#[sadfasdf]
需要在os(linux,unix,windows)中配置名称为area和sadfasdf的环境变量。
以http.routing为例进行说明。
为了避免配置文件混乱，可以将http.routing对应的值做成环境变量，配置文件中只需要引用环境变量名称即可：
```properties
http.routing=#[area]
#bboss支持混合模式的变量和常量拼接，例如
#http.routing=#[county]aaac#[area]
```
这样我们在os(linux,unix,windows)中配置名称为area的环境变量即可。
### 3.2.5 spring boot配置和使用http proxy
示例工程源码获取地址：https://github.com/bbossgroups/bestpractice/tree/master/springboot-starter
首先需要在工程中导入bboss spring boot starter的maven坐标：
```xml
<dependency>
<groupId>com.bbossgroups</groupId>
<artifactId>5.8.2</artifactId>
<version>5.8.2</version>
</dependency>
```
#### 3.2.5.1 单http服务池
在spring boot配置文件[application.properties](https://github.com/bbossgroups/bestpractice/tree/master/springboot-starter/resources/application.properties)中添加http proxy的配置参数
```properties
##es client http服务配置
spring.bboss.http.name=default
spring.bboss.http.timeoutConnection = 5000
spring.bboss.http.timeoutSocket = 5000
spring.bboss.http.connectionRequestTimeout=5000
spring.bboss.http.retryTime = 1
spring.bboss.http.maxLineLength = -1
spring.bboss.http.maxHeaderCount = 200
spring.bboss.http.maxTotal = 400
spring.bboss.http.defaultMaxPerRoute = 200
spring.bboss.http.soReuseAddress = false
spring.bboss.http.soKeepAlive = false
spring.bboss.http.timeToLive = 3600000
spring.bboss.http.keepAlive = 3600000
spring.bboss.http.keystore =
spring.bboss.http.keyPassword =
# ssl 主机名称校验，是否采用default配置，
# 如果指定为default，就采用DefaultHostnameVerifier,否则采用 SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER
spring.bboss.http.hostnameVerifier =
#每隔多少毫秒校验空闲connection，自动释放无效链接
# -1 或者0不检查
spring.bboss.http.validateAfterInactivity=2000
# 每次获取connection时校验连接，true，校验，false不校验，有性能开销，推荐采用
# validateAfterInactivity来控制连接是否有效
# 默认值false
spring.bboss.http.staleConnectionCheckEnabled=false
#* 自定义重试控制接口，必须实现接口方法
#* public interface CustomHttpRequestRetryHandler {
#* public boolean retryRequest(IOException exception, int executionCount, HttpContext context,ClientConfiguration configuration);
#* }
#* 方法返回true，进行重试，false不重试
spring.bboss.http.customHttpRequestRetryHandler=org.frameworkset.spi.remote.http.ConnectionResetHttpRequestRetryHandler
# 服务代理配置
# 服务全认证账号配置
spring.bboss.http.authAccount=elastic
spring.bboss.http.authPassword=changeme
# ha proxy 集群负载均衡地址配置
#spring.bboss.http.hosts=192.168.137.1:808,192.168.137.1:809,192.168.137.1:810
spring.bboss.http.hosts=192.168.137.1:9200
# 健康检查服务
spring.bboss.http.health=/
spring.bboss.http.healthCheckInterval=1000
# 服务地址自动发现功能
#spring.bboss.http.discoverService.serviceClass=com.test.DiscoverService
# 定时运行服务发现方法时间间隔，单位：毫秒，默认10秒
spring.bboss.http.discoverService.interval=10000
# handleNullOrEmptyHostsByDiscovery
#false，忽略对返回的null或者空的hosts进行处理
#true，要对null或者空的hosts进行处理，这样会导致所有的地址不可用
http.discoverService.handleNullOrEmptyHostsByDiscovery=false
```
服务调用示例
```java
/*
* Copyright 1999-2018 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.frameworkset.sqlexecutor;
import com.frameworkset.common.poolman.SQLExecutor;
import com.frameworkset.util.SimpleStringUtil;
import org.frameworkset.spi.boot.BBossStarter;
import org.frameworkset.spi.remote.http.HttpRequestProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* testCase必须和spring boot application启动类在同一个包路径下面，否则会报错：
* java.lang.IllegalStateException: Unable to find a @SpringBootConfiguration, you need to use @Context
* @author yinbp [122054810@qq.com]
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class BBossStarterTestCase {
@Autowired
private BBossStarter bbossStarterDefault;
private static Logger logger = LoggerFactory.getLogger(BBossStarterTestCase.class);
@Test
public void testMultiBBossESStarterDefault() throws Exception {
Map params = new HashMap();
params.put("testp","aaaaa");
params.put("dff","zzzz");
List<Map> datas = HttpRequestProxy.httpPostForList("default","/demoproject/file/getUserInfo.page",params,Map.class);
logger.info(SimpleStringUtil.object2json(datas));
}
@Test
public void testFirstQuery() throws Exception {
List<Map> datas = SQLExecutor.queryListWithDBName(Map.class,"default","select * from user");
logger.info(SimpleStringUtil.object2json(datas));
}
}
```
关键代码，需要在组件中导入starter组件：
```java
@Autowired
private BBossStarter bbossStarterDefault;
```
#### 3.2.5.2 多http服务池配置
在spring boot配置文件[application-multi.properties](https://github.com/bbossgroups/bestpractice/tree/master/springboot-starter/resources/application-multi.properties)中添加http proxy的配置参数
```properties
##es client http服务配置
spring.bboss.default.http.name=default
spring.bboss.default.http.timeoutConnection = 5000
spring.bboss.default.http.timeoutSocket = 5000
spring.bboss.default.http.connectionRequestTimeout=5000
spring.bboss.default.http.retryTime = 1
spring.bboss.default.http.maxLineLength = -1
spring.bboss.default.http.maxHeaderCount = 200
spring.bboss.default.http.maxTotal = 400
spring.bboss.default.http.defaultMaxPerRoute = 200
spring.bboss.default.http.soReuseAddress = false
spring.bboss.default.http.soKeepAlive = false
spring.bboss.default.http.timeToLive = 3600000
spring.bboss.default.http.keepAlive = 3600000
spring.bboss.default.http.keystore =
spring.bboss.default.http.keyPassword =
# ssl 主机名称校验，是否采用default配置，
# 如果指定为default，就采用DefaultHostnameVerifier,否则采用 SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER
spring.bboss.default.http.hostnameVerifier =
#每隔多少毫秒校验空闲connection，自动释放无效链接
# -1 或者0不检查
spring.bboss.default.http.validateAfterInactivity=2000
# 每次获取connection时校验连接，true，校验，false不校验，有性能开销，推荐采用
# validateAfterInactivity来控制连接是否有效
# 默认值false
spring.bboss.default.http.staleConnectionCheckEnabled=false
#* 自定义重试控制接口，必须实现接口方法
#* public interface CustomHttpRequestRetryHandler {
#* public boolean retryRequest(IOException exception, int executionCount, HttpContext context,ClientConfiguration configuration);
#* }
#* 方法返回true，进行重试，false不重试
spring.bboss.default.http.customHttpRequestRetryHandler=org.frameworkset.spi.remote.http.ConnectionResetHttpRequestRetryHandler
# 服务代理配置
# 服务全认证账号配置
spring.bboss.default.http.authAccount=elastic
spring.bboss.default.http.authPassword=changeme
# ha proxy 集群负载均衡地址配置
#spring.bboss.default.http.hosts=192.168.137.1:808,192.168.137.1:809,192.168.137.1:810
spring.bboss.default.http.hosts=10.13.11.117:8082
# 健康检查服务
spring.bboss.default.http.health=/
spring.bboss.default.http.healthCheckInterval=1000
# 服务地址自动发现功能
#spring.bboss.default.http.discoverService.serviceClass=com.test.DiscoverService
# 定时运行服务发现方法时间间隔，单位：毫秒，默认10秒
spring.bboss.default.http.discoverService.interval=10000
# handleNullOrEmptyHostsByDiscovery
#false，忽略对返回的null或者空的hosts进行处理
#true，要对null或者空的hosts进行处理，这样会导致所有的地址不可用
spring.bboss.default.http.discoverService.handleNullOrEmptyHostsByDiscovery=false
# 数据库数据源配置
spring.bboss.default.db.name = firstds
spring.bboss.default.db.user = root
spring.bboss.default.db.password = 123456
spring.bboss.default.db.driver = com.mysql.jdbc.Driver
spring.bboss.default.db.url = jdbc:mysql://10.13.11.117:3306/mysql
spring.bboss.default.db.usePool = true
spring.bboss.default.db.validateSQL = select 1
##second es client http服务配置
spring.bboss.second.http.name=second
spring.bboss.second.http.timeoutConnection = 5000
spring.bboss.second.http.timeoutSocket = 5000
spring.bboss.second.http.connectionRequestTimeout=5000
spring.bboss.second.http.retryTime = 1
spring.bboss.second.http.maxLineLength = -1
spring.bboss.second.http.maxHeaderCount = 200
spring.bboss.second.http.maxTotal = 400
spring.bboss.second.http.secondMaxPerRoute = 200
spring.bboss.second.http.soReuseAddress = false
spring.bboss.second.http.soKeepAlive = false
spring.bboss.second.http.timeToLive = 3600000
spring.bboss.second.http.keepAlive = 3600000
spring.bboss.second.http.keystore =
spring.bboss.second.http.keyPassword =
# ssl 主机名称校验，是否采用second配置，
# 如果指定为second，就采用secondHostnameVerifier,否则采用 SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER
spring.bboss.second.http.hostnameVerifier =
#每隔多少毫秒校验空闲connection，自动释放无效链接
# -1 或者0不检查
spring.bboss.second.http.validateAfterInactivity=2000
# 每次获取connection时校验连接，true，校验，false不校验，有性能开销，推荐采用
# validateAfterInactivity来控制连接是否有效
# 默认值false
spring.bboss.second.http.staleConnectionCheckEnabled=false
#* 自定义重试控制接口，必须实现接口方法
#* public interface CustomHttpRequestRetryHandler {
#* public boolean retryRequest(IOException exception, int executionCount, HttpContext context,ClientConfiguration configuration);
#* }
#* 方法返回true，进行重试，false不重试
spring.bboss.second.http.customHttpRequestRetryHandler=org.frameworkset.spi.remote.http.ConnectionResetHttpRequestRetryHandler
# 服务代理配置
# 服务全认证账号配置
spring.bboss.second.http.authAccount=elastic
spring.bboss.second.http.authPassword=changeme
# ha proxy 集群负载均衡地址配置
#spring.bboss.second.http.hosts=192.168.137.1:808,192.168.137.1:809,192.168.137.1:810
spring.bboss.second.http.hosts=10.13.11.117:8082
# 健康检查服务
spring.bboss.second.http.health=/
spring.bboss.second.http.healthCheckInterval=1000
# 服务地址自动发现功能
#spring.bboss.second.http.discoverService.serviceClass=com.test.DiscoverService
# 定时运行服务发现方法时间间隔，单位：毫秒，默认10秒
spring.bboss.second.http.discoverService.interval=10000
# handleNullOrEmptyHostsByDiscovery
#false，忽略对返回的null或者空的hosts进行处理
#true，要对null或者空的hosts进行处理，这样会导致所有的地址不可用
spring.bboss.second.http.discoverService.handleNullOrEmptyHostsByDiscovery=false
# 数据库数据源配置
spring.bboss.second.db.name = secondds
spring.bboss.second.db.user = root
spring.bboss.second.db.password = 123456
spring.bboss.second.db.driver = com.mysql.jdbc.Driver
spring.bboss.second.db.url = jdbc:mysql://10.13.11.117:3306/mysql
spring.bboss.second.db.usePool = true
spring.bboss.second.db.validateSQL = select 1
```
服务调用实例：
```java
/*
* Copyright 1999-2018 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.frameworkset.sqlexecutor;
import com.frameworkset.common.poolman.SQLExecutor;
import com.frameworkset.util.SimpleStringUtil;
import org.frameworkset.spi.boot.BBossStarter;
import org.frameworkset.spi.remote.http.HttpRequestProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* testCase必须和spring boot application启动类在同一个包路径下面，否则会报错：
* java.lang.IllegalStateException: Unable to find a @SpringBootConfiguration, you need to use @Context
* 多集群演示功能测试用例，spring boot配置项以spring.bboss.集群名称开头，例如：
* spring.bboss.db.firstds
* spring.bboss.db.secondds
* spring.bboss.http.default
* spring.bboss.http.second
* 两个集群通过 com.frameworkset.sqlexecutor.MultiSTartConfigurer
* 对应的配置文件为application-multi.properties文件
* @author yinbp [122054810@qq.com]
*/
@RunWith(SpringRunner.class)
@SpringBootTest
@ActiveProfiles("multi")
public class MultiBBossStartersTestCase {
@Autowired
private BBossStarter bbossStarterDefault;
private static Logger logger = LoggerFactory.getLogger(MultiBBossStartersTestCase.class);
@Test
public void testMultiBBossESStarterDefault() throws Exception {
Map params = new HashMap();
params.put("testp","aaaaa");
params.put("dff","zzzz");
List<Map> datas = HttpRequestProxy.httpPostForList("default","/demoproject/file/getUserInfo.page",params,Map.class);
logger.info(SimpleStringUtil.object2json(datas));
}
@Test
public void testMultiBBossESStarterSecond() throws Exception {
Map params = new HashMap();
params.put("testp","aaaaa");
params.put("dff","zzzz");
List<Map> datas = HttpRequestProxy.sendJsonBodyForList("second",params,"/demoproject/file/getUserInfo.page",Map.class);
logger.info(SimpleStringUtil.object2json(datas));
}
@Test
public void testFirstQuery() throws Exception {
List<Map> datas = SQLExecutor.queryListWithDBName(Map.class,"firstds","select * from user");
logger.info(SimpleStringUtil.object2json(datas));
}
@Test
public void testSecondQuery() throws Exception {
List<Map> datas = SQLExecutor.queryListWithDBName(Map.class,"secondds","select * from user");
logger.info(SimpleStringUtil.object2json(datas));
}
}
```
关键代码，需要在组件中导入starter组件：
```java
@Autowired
private BBossStarter bbossStarterDefault;
```
### 3.2.6 failAllContinue配置
failAllContinue配置
如果所有节点都被标记为不可用时，可以通过控制开关设置返回故障节点用于处理请求，如果请求能够被正常处理则将节点标记为正常节点 默认值true 非spring boot项目配置
http.failAllContinue = true
spring boot配置项
spring.bboss.http.failAllContinue = true
## 3.3 使用负载均衡器调用服务
使用负载均衡器调用服务，在指定服务集群组report调用rest服务/testBBossIndexCrud,返回json字符串报文，通过循环调用，测试负载均衡机制
```java
@Test
public void testGet(){
String data = HttpRequestProxy.httpGetforString("report","/testBBossIndexCrud");
System.out.println(data);
do {
try {
data = HttpRequestProxy.httpGetforString("report","/testBBossIndexCrud");
} catch (Exception e) {
e.printStackTrace();
}
try {
Thread.sleep(3000l);
} catch (Exception e) {
break;
}
try {
data = HttpRequestProxy.httpGetforString("report","/testBBossIndexCrud");
} catch (Exception e) {
e.printStackTrace();
}
try {
data = HttpRequestProxy.httpGetforString("report","/testBBossIndexCrud");
} catch (Exception e) {
e.printStackTrace();
}
// break;
}
while(true);
}
```
# 4.服务发现机制的两种工作模式
本文开头介绍了http负载均衡器服务发现支持从各种数据源获取和发现服务地址：
zookeeper，etcd，consul，eureka，db，其他第三方注册中心
为了支持第三方注册中心，服务发现机制的提供两种工作模式：
## **4.1 主动发现模式**
bboss通过调用http.discoverService配置的服务发现方法，定时从数据库和注册中心中查询最新的服务地址数据清单，本文上面介绍的http.discoverService就是一种主动定时发现模式
## **4.2 被动发现模式**
监听apollo，zookeeper，etcd，consul，eureka等配置中心中管理的服务节点地址清单数据变化，监听路由规则变化，更新本地服务器地址清单，适用于发布订阅模式,对应的api
```java
//当路由规则发生变化时，可以调用下面的api更新
HttpProxyUtil.changeRouting(String poolName,String newCurrentRounte) //切换服务组poolName对应的路由规则
//当服务节点发生变化时，可以调用下面的api更新
public static void handleDiscoverHosts(String poolName, List<HttpHost> hosts) //更新服务节点
//当路由规则和服务节点同时发生变化时，调用下面的api更新
/**
*
* @param poolName 服务组名称
* @param hosts 新的主机节点信息
* @param newCurrentRounte 新的路由组
*/
public static void handleDiscoverHosts(String poolName, List<HttpHost> hosts,String newCurrentRounte)
```
被动发现模式示例代码如下：
```java
//模拟被动获取监听地址清单
List<HttpHost> hosts = new ArrayList<HttpHost>();
// https服务必须带https://协议头,例如https://192.168.137.1:808
HttpHost host = new HttpHost("192.168.137.1:808");
hosts.add(host);
host = new HttpHost("192.168.137.1:809");
hosts.add(host);
host = new HttpHost("192.168.137.1:810");
hosts.add(host);
//将被动获取到的地址清单加入服务地址组report中，动态节点发现
HttpProxyUtil.handleDiscoverHosts("report",hosts);
//动态路由切换
HttpProxyUtil.changeRouting(String poolName,String newCurrentRounte)
```
## 4.3 基于apollo配置中心被动发现模式示例
首先定义一个apollo 监听器
```java
package org.frameworkset.http.client;
import com.ctrip.framework.apollo.ConfigChangeListener;
import com.ctrip.framework.apollo.enums.PropertyChangeType;
import com.ctrip.framework.apollo.model.ConfigChange;
import com.ctrip.framework.apollo.model.ConfigChangeEvent;
import org.frameworkset.spi.remote.http.HttpHost;
import org.frameworkset.spi.remote.http.proxy.HttpProxyUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
/**
* <p>Description: </p>
* <p></p>
* <p>Copyright (c) 2020</p>
* @Date 2020/8/2 20:07
* @author biaoping.yin
* @version 1.0
*/
public class AddressConfigChangeListener implements ConfigChangeListener {
private static Logger logger = LoggerFactory.getLogger(AddressConfigChangeListener.class);
private void handleDiscoverHosts(String _hosts,String poolName){
if(_hosts != null && !_hosts.equals("")){
String[] hosts = _hosts.split(",");
List<HttpHost> httpHosts = new ArrayList<HttpHost>();
HttpHost host = null;
for(int i = 0; i < hosts.length; i ++){
host = new HttpHost(hosts[i]);
httpHosts.add(host);
}
//将被动获取到的地址清单加入服务地址组report中
HttpProxyUtil.handleDiscoverHosts(poolName,httpHosts);
}
}
/**
* //模拟被动获取监听地址清单
* List<HttpHost> hosts = new ArrayList<HttpHost>();
* // https服务必须带https://协议头,例如https://192.168.137.1:808
* HttpHost host = new HttpHost("192.168.137.1:808");
* hosts.add(host);
*
* host = new HttpHost("192.168.137.1:809");
* hosts.add(host);
*
* host = new HttpHost("192.168.137.1:810");
* hosts.add(host);
* //将被动获取到的地址清单加入服务地址组report中
* HttpProxyUtil.handleDiscoverHosts("schedule",hosts);
*/
public void onChange(ConfigChangeEvent changeEvent) {
logger.info("Changes for namespace {}", changeEvent.getNamespace());
ConfigChange change = null;
for (String key : changeEvent.changedKeys()) {
if(key.equals("schedule.http.hosts")){//schedule集群
change = changeEvent.getChange(key);
logger.info("Found change - key: {}, oldValue: {}, newValue: {}, changeType: {}", change.getPropertyName(), change.getOldValue(), change.getNewValue(), change.getChangeType());
if(change.getChangeType() == PropertyChangeType.MODIFIED) {
String _hosts = change.getNewValue();
handleDiscoverHosts(_hosts, "schedule");
}
}
else if(key.equals("http.hosts")){//default集群
change = changeEvent.getChange(key);
logger.info("Found change - key: {}, oldValue: {}, newValue: {}, changeType: {}", change.getPropertyName(), change.getOldValue(), change.getNewValue(), change.getChangeType());
if(change.getChangeType() == PropertyChangeType.MODIFIED) {
String _hosts = change.getNewValue();
handleDiscoverHosts(_hosts, "default");
}
}
}
}
}
```
从apollo加载配置启动http proxy：
```java
@Before
public void startPool(){
// HttpRequestProxy.startHttpPools("application.properties");
/**
* 从apollo加载配置启动http proxy：
* 配置了两个连接池：default,schedule
* apollo namespace: application
* 服务地址变化发现监听器： org.frameworkset.http.client.AddressConfigChangeListener
*/
HttpRequestProxy.startHttpPoolsFromApollo("application","org.frameworkset.http.client.AddressConfigChangeListener");
}
@Test
public void testGet(){
String data = null;
try {
//服务调用
data = HttpRequestProxy.httpGetforString("schedule", "/testBBossIndexCrud");
}
catch (Exception e){
e.printStackTrace();
}
System.out.println(data);
do {
try {
data = HttpRequestProxy.httpGetforString("schedule","/testBBossIndexCrud");
} catch (Exception e) {
e.printStackTrace();
}
try {
Thread.sleep(3000l);
} catch (Exception e) {
break;
}
}
while(true);
}
```
Apollo配置使用参考文档：<https://esdoc.bbossgroups.com/#/apollo-config>
直接调用http proxy api监听路由变化和节点变化
```java
/**
* 1.服务健康检查
* 2.服务负载均衡
* 3.服务容灾故障恢复
* 4.服务自动发现（apollo，zk，etcd，consul，eureka，db，其他第三方注册中心）
* 配置了两个连接池：default,report
* 本示例演示基于apollo提供配置管理、服务自动发现以及灰度/生产，主备切换功能
*/
HttpRequestProxy.startHttpPoolsFromApolloAwaredChange("application");
```
# 5.主备和异地灾备配置和服务发现
主备和异地灾备配置和服务发现
地址格式配置，其中routing标识服务地址或者路由标记
ip:port|routing
例如：
```properties
#指定了每个地址对应的地区信息，可以按照地区信息进行路由
http.hosts=192.168.137.1:808|beijing,192.168.137.1:809|beijing,192.168.137.1:810|shanghai
```
指定beijing地区路由信息或者主节点标识信息
```properties
# 指定本地区信息，系统按地区部署时，指定地区信息，
# 不同的地区请求只路由到本地区（beijing）对应的服务器，shanghai的服务器作为backup服务器，
# 当本地(beijing)的服务器都不可用时，才将请求转发到可用的上海服务器
http.routing=beijing
```
指定shanghai地区路由信息或者主节点标识信息
```properties
# 指定本地区信息，系统按地区部署时，指定地区信息，
# 不同的地区请求只路由到本地区（shanghai）对应的服务器，beijing的服务器作为backup服务器，
# 当本地(shanghai)的服务器都不可用时，才将请求转发到可用的beijing服务器
http.routing=shanghai
```
为了避免配置文件混乱，可以将http.routing对应的值做成环境变量，配置文件中只需要引用环境变量名称即可：
```properties
http.routing=#[area]
#bboss支持混合模式的变量和常量拼接，例如
#http.routing=#[county]aaac#[area]
```
这样我们在os(linux,unix,windows)中配置名称为area的环境变量即可。
带路由信息的服务发现机制：可以动态变化服务地址的routing信息
```java
package org.frameworkset.http.client;
import org.frameworkset.spi.assemble.GetProperties;
import org.frameworkset.spi.remote.http.ClientConfiguration;
import org.frameworkset.spi.remote.http.HttpHost;
import org.frameworkset.spi.remote.http.proxy.HttpHostDiscover;
import org.frameworkset.spi.remote.http.proxy.HttpServiceHostsConfig;
import java.util.ArrayList;
import java.util.List;
public class DemoHttpHostDiscover extends HttpHostDiscover {
private int count = 0;
@Override
protected List<HttpHost> discover(HttpServiceHostsConfig httpServiceHostsConfig,
ClientConfiguration configuration,
GetProperties context) {
List<HttpHost> hosts = new ArrayList<HttpHost>();
HttpHost host = new HttpHost("192.168.137.1:808|beijing");
hosts.add(host);
if(count != 2) {//模拟添加和去除节点
host = new HttpHost("192.168.137.1:809|beijing");
hosts.add(host);
}
else{
System.out.println("aa");
}
//可以动态变化服务地址的routing信息，模拟改变路由信息
if(count > 10 && count < 15) {
host = new HttpHost("192.168.137.1:810|beijing");
}
else{
host = new HttpHost("192.168.137.1:810|shanghai");
}
hosts.add(host);
count ++;
return hosts;
}
/**
* 返回null或者false，忽略对返回的null或者空的hosts进行处理；
* 返回true，要对null或者空的hosts进行处理，这样会导致所有的地址不可用
*
* @return 默认返回null
*/
protected Boolean handleNullOrEmptyHostsByDiscovery(){
return null;
}
}
```
# 6.健康检查服务
可以通过http.health属性指定健康检查服务，服务为相对地址，不需要指定ip和端口，例如：
- 设置默认集群组健康服务
```java
configs.put("http.health","/health.html");//health监控检查地址必须配置，否则将不会启动健康检查机
```
- 设置特定集群组健康服务
```java
configs.put("report.http.health","/health.html");//health监控检查地址必须配置，否则将不会启动健康检查机
```
- 健康检查服务开启条件
http.healthCheckInterval必须大于0，单位毫秒，默认值-1,设置示例：
http.healthCheckInterval=1000
同时必须设置http.health健康检查服务，例如：
http.health=/health.html
**bboss以get方式发送http.health对应的健康检查服务请求，健康检查服务只需要响应状态码为200-300即认为服务节点健康可用**。
# 7.开发交流
bboss http交流QQ群：21220580,166471282
**bboss http微信公众号：**
<img src="https://static.oschina.net/uploads/space/2017/0617/094201_QhWs_94045.jpg" height="200" width="200"> | 35,527 | Apache-2.0 |
---
layout: post
title: 堆排序算法
categories: 算法与数据结构
date: 2018-08-07 20:02:17
keywords: 算法, 堆排序
---
啊噢，又开始写算法学习的笔记了。最近在准备面试的过程中又把这些常见的排序算法拿出来复习复习，既然这篇写到了堆排序，那么就代表堆排序算法的概念被我忘的差不多了，写篇博客加深记忆吧。
<!--more-->
在维基百科上看堆排序，上面有这么一张图，
可是原谅我概念真的忘的差不多了，所以理解不了这张图，于是我又找到另一个可视化的过程，一目了然，是别人放在github page上的一个[页面](https://bajdcc.github.io/html/heap.html)，地址就在[这里](https://bajdcc.github.io/html/heap.html)。所以本篇文章的堆排序的可视化动画，就参考这个吧。
堆排序（Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
通常堆是通过一维数组来实现的，在数组起始位置为0的情形中来看看堆节点的一些定义。
- 父节点i的左子节点在位置(2i + 1);
- 父节点i的右子节点在位置(2i + 2);
- 子节点i的父节点在floor((i - 1) / 2);
关于堆中节点的位置，有如上三个定义。
在堆的数据结构中，堆中的最大值总是位于根节点上。而堆中的一个很重要的操作就是最大堆调整(Max_Heapify)，即为将堆的末端子节点作调整，使得子节点永远小于父节点。
接下来看看这个关键的Max_Heapify最大堆调整的实现是怎样的：
```js
maxHeapify(start, end) {
// 建立父节点指标和子节点指标
let dad = start;
let son = dad * 2 + 1;
// 若子节点指标超过范围，则直接跳出函数
if (son >= end)
return;
// 先比较两个子节点的大小 选择最大的
if (son + 1 < end && this.array[son] < this.array[son + 1])
son++;
// 如果父节点小于子节点，交换父子节点的内容再继续子节点与孙节点的比较
if (this.array[dad] < this.array[son]) {
this.swap(dad, son);
this.maxHeapify(son, end);
}
}
```
在进行最大堆调整的操作时，我们传入初始和终止的两个索引，并且根据我们刚提到的堆节点的定义，建立父节点和子节点指标。接下来如果子节点的指标超过的终止索引的范围，则直接跳出函数。否则的话我们比较两个子节点的大小，选择大的节点进行接下来的操作。
在两个节点中选取完较大节点后，我们比较父节点与子节点，如果父节点小于子节点，那么交换父子节点的内容，再递归的比较子节点与孙节点，直到调整完成。
完整的堆排序算法（javascript实现）如下：
```js
/**
* 堆排序算法
*/
class HeapSort {
constructor(originalArray) {
// 拷贝数组，不修改原数组
this.array = [...originalArray];
}
swap(i, j) {
const temp = this.array[i];
this.array[i] = this.array[j];
this.array[j] = temp;
}
maxHeapify(start, end) {
// 建立父节点指标和子节点指标
let dad = start;
let son = dad * 2 + 1;
// 若子节点指标超过范围，则直接跳出函数
if (son >= end)
return;
// 先比较两个子节点的大小 选择最大的
if (son + 1 < end && this.array[son] < this.array[son + 1])
son++;
// 如果父节点小于子节点，交换父子节点的内容再继续子节点与孙节点的比较
if (this.array[dad] < this.array[son]) {
this.swap(dad, son);
this.maxHeapify(son, end);
}
}
sort() {
const len = this.array.length;
// 初始化 i从最后一个父节点开始调整
for (let i = Math.floor((len - 1) / 2); i >= 0; i--)
this.maxHeapify(i, len);
// 先将第一个元素和已排好的前一位做交换，再重新调整，直到排序完成
for (let i = len - 1; i > 0; i--) {
this.swap(0, i);
this.maxHeapify(0, i);
}
return this.array;
}
}
const array = [0, 9, 1, 8, 2, 7, 3, 6, 5, 4];
let heap = new HeapSort(array);
let res = heap.sort();
console.log(res);
```
sort函数里的两个for循环也要解释一下，第一个for循环，是堆的初始化，从最后一个父节点开始，调整整个数组的排序。而第二个for循环，是把第一个已经确定大小的元素和已经排好位的前一个元素做交换，再重新调整排序，直到整个排序完成。待for循环完成之后，整个数组也就呈从小到大的顺序了排好了。
理解完代码之后，再看看堆排序的时间复杂度，堆排序的平均时间复杂度，以及最优、最坏的时间复杂度都是O(nlog n)，而空间复杂度是O(1)，并且堆排序是一种不稳定排序。
文章中的源码在这里[堆排序算法源码](https://github.com/originalix/algorithm/blob/4cd004c0c96e39a35daa3e97171ad0bbea5e2f49/JavaScript/algorithms/sorting/heap-sort/HeapSort.js) | 3,157 | MIT |
---
title: dotnet list reference コマンド
description: dotnet list 参照コマンドは、プロジェクト間参照を列挙する便利なオプションを提供します。
ms.date: 06/26/2019
ms.openlocfilehash: 1f87ff89997cdaa6d0095a4db9f28a2e7cb7e6a9
ms.sourcegitcommit: 9b1ac36b6c80176fd4e20eb5bfcbd9d56c3264cf
ms.translationtype: HT
ms.contentlocale: ja-JP
ms.lasthandoff: 06/28/2019
ms.locfileid: "67421839"
---
# <a name="dotnet-list-reference"></a>dotnet list reference
**このトピックの対象: ✓** .NET Core 1.x SDK 以降のバージョン
<!-- todo: uncomment when all CLI commands are reviewed
[!INCLUDE [topic-appliesto-net-core-all](../../../includes/topic-appliesto-net-core-all.md)]
-->
## <a name="name"></a>name
`dotnet list reference` - プロジェクト間参照を列挙します。
## <a name="synopsis"></a>構文
`dotnet list [<PROJECT>|<SOLUTION>] reference [-h|--help]`
## <a name="description"></a>説明
`dotnet list reference` コマンドは、特定のプロジェクトまたはソリューションのプロジェクト参照を列挙する便利なオプションを提供します。
## <a name="arguments"></a>引数
* **`PROJECT | SOLUTION`**
参照の一覧取得に使うプロジェクトまたはソリューション ファイルを指定します。 指定されていない場合、コマンドではプロジェクト ファイルを現在のディレクトリで検索します。
## <a name="options"></a>オプション
* **`-h|--help`**
コマンドの短いヘルプを印刷します。
## <a name="examples"></a>使用例
* 指定したプロジェクトのプロジェクト参照を列挙する:
```console
dotnet list app/app.csproj reference
```
* 現在のディレクトリ内のプロジェクトのプロジェクト参照を列挙する:
```console
dotnet list reference
``` | 1,298 | CC-BY-4.0 |
> **当前版本**：[UWS 智能设备资源云存储 V1.0.0](zh-cn/ChangeLog/CapacityService_DeviceCloudStorage)
**更新时间**：{docsify-updated}
### 简介
>云存储服务用于存储智能设备的资源管理服务。智能互联设备可以通过此服务对文件、存储区进行操作。
![云存储Rest接口图片][CapacityService_DeviceCloudStorage_type]
**针对设备的服务**</br>
1、存储区管理：文件资源的存储是基于对存储区域的管理，存储区是保证后续文件可以上传、下载等操作的基础存储服务，使用云服务存储首先需要通过服务建立存储区。</br>
2、资源管理：存储云端的文件存储与获取资源服务能力。包括对文件信息的管理与文件资源内容的获取。</br>
**针对应用的服务**</br>
本服务针对应用只提供了文件的查看功能，可以查看智能互联设备上传的文件资源。</br>
### 应用场景
适用于智能互联设备文件上传与存储服务，为设备在云平台服务端建立存储空间，用于存储图片、文本等各种文件资源，为智能设备建立统一的云端设备存储服务。
## 公共结构
### accesskey
accesskey为接口头信息，术语公共信息每个请求、应答应该包含
参数名|类型|位置|说明
:-|:-:|:-:|:-
accessKey|String|Header|云存储accessKey，由AccesskeyId与加密密文两部分组成，</br>accessKey=AccesskeyId:密文，加密密文采用AES对称加密</br>密文 = base64 (AccesskeyId+body)</br>秘钥 = AccesskeySecret</br>Body为空时传空字符。
### BuckInfo
参数名|类型|说明
:-|:-:|:-
bucketId|int|id
bucketName|String|name
privilegeType|int|权限：0，私有；1，公共读
createTime|Data|创建时间
### BucketList
参数名|类型|说明
:-|:-:|:-
buckets|BucaketInfo[]|存储区列表
total|int|记录总数
nextMarker|int|下一页页码，第一页从0开始,最后一页或无数据返回时为-1
### FileInfo
参数名|类型|说明
:-|:-:|:-
fileId|long|id
fileName|String|name
privilegeType|int|权限：0，私有；1，公共读；2，缺省（同所在存储区权限）
fileSize|long|文件大小
bucketId|int|所属存储区id
creteTime|Data|创建时间
### FileList
参数名|类型|说明
:-|:-:|:-
infos|FileInfo[]|信息列表
total|int|文件记录总数
nextMarker|int|下一页页码，第一页从0开始,最后一页或无数据返回时为-1
## 接口清单
### 针对设备的服务
#### 创建存储区
> 1.主用户用来创建存储区，保证后续文件上传下载等文件存储功能；</br>
> 2.存储区名字智能为小写字母或数字或短横线，必须以小写字母或数字开通和结尾，长度在3~63个字符之间；</br>
> 3.存储区一旦创建后名字不能修改；</br>
> 4.同一用户下的存储区不能重名。</br>
##### 1、接口定义
?> **接入地址：** `/css/v1/createBucket`</br>
**HTTP Method：** POST
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketName|String|Body|必填|要创建的存储区名字
Privilege|int|Body|必填|权限：0，私有；1，公共读
accessKey|String|header|必填|用户主ak
**输出参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketInfo|BucketInfo|Body|必填|创建成功的存储区
##### 2、请求样例
**请求样例**
```
请求地址：http://*****/css/v1/createBucket
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
Body：
{
"bucketName":"haier099",
"privilegeType":1
}
```
**请求应答**
```
Body：
{
"bucketInfo":
{
"bucketId":123,
"bucketName":"haier099",
"createTime":"2017-01-12 19:49:39",
"privilegeType":1
},
"retCode":"00000",
"retInfo":"成功"
}
```
#### 查看存储区
> 1.根据存储区id查询存储区信息；</br>
> 2.存储区必须存在，且当前用户拥有访问权限
##### 接口定义
?> **接入地址：** `/css/v1/queryBucket/{bucketId}`</br>
**HTTP Method：** GET
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketId|int|url|必填|存储区ID
accessKey|String|header|必填|用户主ak
**输出参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketInfo|BucketInfo|Body|必填|
##### 2、请求样例
**请求样例**
```
接入地址：http://******/css/v1/queryBucket/107
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
```
**请求应答**
```
Body：
{
"bucketInfo":
{
"bucketId":107,
"bucketName":"haier009",
"createTime":"2017-01-10 18:41:30",
"privilegeType":1
},
"retCode":"00000",
"retInfo":"成功"
}
```
#### 修改存储区权限
> 1.根据存储区id修改存储区的权限，可选值为：0，私有；1，公共读；</br>
> 2.存储区必须存在，且当前用户拥有访问权限；权限值只能为0 or 1,其它值报错
##### 1、接口定义
?> **接入地址：** `/css/v1/modifyBucketACL/{bucketId}`</br>
**HTTP Method：** POST
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketId|int|url|必填|要修改的存储区ID
privilegeType|int|Body|必填|权限：</br> 0，私有；</br>1，公共读
acessKey|String|header|必填|用户主ak
**输出参数** ：标准输出参数
##### 2、请求样例
**请求样例**
```
接入地址：http://*********/css/v1/modifyBucketACL/123
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
Body：
{
"privilegeType":0
}
```
**请求应答**
```
Body：
{
"retCode": "00000",
"retInfo": "成功"
}
```
#### 删除存储区
> 1.根据存储区id删除该存储区，但需要里面没有文件。否则删除不了；</br>
> 2.存储区必须存在，且当前用户拥有访问权限；</br>
> 3.如果存储区里还有文件，则不能被删除，会抛出相应的异常信息</br>
##### 1、接口定义
?> **接入地址：** `/css/v1/deleteBucket/{bucketId}`</br>
**HTTP Method：** POST
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketId|int|url|必填|要删除的存储区ID
accessKey|String|header|必填|用户主ak
**输出参数** ：标准输出参数
##### 2、请求样例
**请求样例**
```
请求地址：http://***********/css/v1/deleteBucket/107
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
```
**请求应答**
```
Body：
{
"retCode": "00000",
"retInfo": "成功"
}
```
#### 获取存储区列表
> 1.根据当前用户的accessKey信息查询其创建的所有存储区；</br>
> 2.按照创建时间降序返回当前用户拥有所有权的存储区列表，超过一页翻页展示，每页20条
##### 1、接口定义
?> **接入地址：** `/css/v1/bucketList？pageNo={pageNo}`
**HTTP Method：** GET
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
pageNo|int|Param|必填|查询请求当前页码，从0开始
accessKey|String|header|必填|用户主ak
**输出参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketList|BucketList|Body|必填|
##### 2、请求样例
**请求样例**
```
请求地址：http://*******/css/v1/bucketList?pageNo=0
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
```
**请求应答**
```
Body：
{
"bucketList":
{
"buckets":
[
{
"bucketId":123,
"bucketName":"haier099",
"createTime":"2017-01-12 19:49:39",
"privilegeType":0
},
{
"bucketId":119,
"bucketName":"haiertestbucket",
"createTime":"2017-01-12 14:31:10",
"privilegeType":0
},
{
"bucketId":115,
"bucketName":"testasdf",
"createTime":"2017-01-12 14:01:56",
"privilegeType":0
},
{
"bucketId":111,
"bucketName":"testasd",
"createTime":"2017-01-12 13:56:29",
"privilegeType":0
},
{
"bucketId":105,
"bucketName":"haier007",
"createTime":"2017-01-10 17:25:19",
"privilegeType":0
},
{
"bucketId":101,
"bucketName":"haier005",
"createTime":"2017-01-10 16:48:45",
"privilegeType":1
},
{
"bucketId":83,
"bucketName":"haier001",
"createTime":"2017-01-06 14:54:08",
"privilegeType":1
},
{
"bucketId":81,
"bucketName":"enjoyfree12",
"createTime":"2017-01-06 11:23:25",
"privilegeType":1
},
{
"bucketId":77,
"bucketName":"enjoyfree11",
"createTime":"2017-01-06 11:16:16",
"privilegeType":1
},
{
"bucketId":73,
"bucketName":"enjoyfree8",
"createTime":"2017-01-05 18:49:26",
"privilegeType":1
},
{
"bucketId":71,
"bucketName":"enjoyfree7",
"createTime":"2017-01-05 18:38:34",
"privilegeType":1
},
{
"bucketId":69,
"bucketName":"enjoyfree6",
"createTime":"2017-01-05 18:37:21",
"privilegeType":1
},
{
"bucketId":67,
"bucketName":"enjoyfree5",
"createTime":"2017-01-05 18:36:33",
"privilegeType":1
},
{
"bucketId":65,
"bucketName":"enjoyfree4",
"createTime":"2017-01-05 18:34:40",
"privilegeType":1
},
{
"bucketId":63,
"bucketName":"enjoyfree3",
"createTime":"2017-01-05 18:33:58",
"privilegeType":1
},
{
"bucketId":61,
"bucketName":"enjoyfree2",
"createTime":"2017-01-05 18:16:42",
"privilegeType":1
},
{
"bucketId":59,
"bucketName":"enjoyfree1",
"createTime":"2017-01-05 17:54:17",
"privilegeType":1
},
{
"bucketId":57,
"bucketName":"enjoyfree",
"createTime":"2017-01-05 17:50:09",
"privilegeType":1
},
{
"bucketId":55,
"bucketName":"hello12131",
"createTime":"2017-01-05 17:37:11",
"privilegeType":0
}
],
"nextMarker":-1,
"total":19
},
"retCode":"00000",
"retInfo":"成功"
}
```
#### 获取存储区内文件
> 1.根据存储区id查询存储区里面的文件列表，按照文件创建时间降序排列，超过1页则翻页，每页20条，最多可以翻页到499页；</br>
> 2.存储区必须存在，且当前用户拥有访问权限
##### 1、接口定义
?> **接入地址：** `/css/v1/fileList/{bucketId}?pageNo={pageNo}`</br>
**HTTP Method：** GET
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
bucketId|int|url|必填|存储区ID
pageNo|int|Param|必填|查询请求当前页码，从0开始
accessKey|String|header|必填|用户主ak
**输出参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileList|FileList|Body||
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/fileList/119?pageNo=0
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
```
**请求应答**
```
Body：
{
"fileList":
{
"infos":
[
{
"bucketId":119,
"createTime":"2017-01-12 18:54:09",
"fileId":101844908215,
"fileName":"a.jpg",
"fileSize":845941,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"province":"q\u001C\u0001",
"userid":"12345",
"district":"\u0002q:",
"city":"R\u009B\u0002"
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 18:53:53",
"fileId":101843303252,
"fileName":"a.jpg",
"fileSize":845941,
"meta":
{
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 18:53:28",
"fileId":101840817636,
"fileName":"asa.jpg",
"fileSize":845941,
"meta":
{
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 18:52:14",
"fileId":101833419283,
"fileName":"a.jpg",
"fileSize":845941,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"province":"q\u001C\u0001",
"userid":"12345",
"district":"\u0002q:",
"city":"R\u009B\u0002"
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 17:50:06",
"fileId":101460633186,
"fileName":"a.jpg",
"fileSize":114391,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"province":"q\u001C\u0001",
"userid":"12345",
"district":"\u0002q:",
"city":"R\u009B\u0002"
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 17:32:54",
"fileId":101357479206,
"fileName":"a.jpg",
"fileSize":114391,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"province":"q\u001C\u0001",
"userid":"12345",
"district":"\u0002q:",
"city":"R\u009B\u0002"
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 17:29:34",
"fileId":101337486533,
"fileName":"a.jpg",
"fileSize":114391,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"province":"q\u001C\u0001",
"userid":"12345",
"district":"\u0002q:",
"city":"R\u009B\u0002"
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 17:28:33",
"fileId":101331317320,
"fileName":"a.jpg",
"fileSize":114391,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"province":"q\u001C\u0001",
"userid":"12345",
"district":"\u0002q:",
"city":"R\u009B\u0002"
},
"privilegeType":0
},
{
"bucketId":119,
"createTime":"2017-01-12 16:56:28",
"fileId":101138873157,
"fileName":"1.jpg",
"fileSize":879394,
"meta":
{
"city":"R\u009B"
},
"privilegeType":1
},
{
"bucketId":119,
"createTime":"2017-01-12 14:52:08",
"fileId":100392893042,
"fileName":"yuanminyuan.jpg",
"fileSize":108566,
"meta":
{
"city":"R\u009B"
},
"privilegeType":0
}
],
"nextMarker":-1,
"total":10
},
"retCode":"00000",
"retInfo":"成功"
}
```
#### 上传文件及meta信息
> 把一个本地文件上传到云存储服务的指定存储区中：</br>
> 1.存储区名字符合要求（具体参见创建存储区），如存储区存在，则上传文件到此存储区，如不存在，则自动创建此名字的存储区，权限为私有。</br>
> 2.文件名使用UTF-8编码，长度必须在1-100字符之间。不能包含/\|;*?"<>字符。</br>
> 3.文件大小范围为1-5Mbytes</br>
> 4.每条Meta信息包含key/value值对的json格式字符串，key不能为空，整个Meta信息的json字符串长度不能超过4000；key重复将导致value会被覆盖,</br>
> 目前预定义的meta的key有：</br>省，province;</br> 市,city；</br> 区县，district；</br> Mac标识，macid；</br> User标识，userid；</br> 其它meta的key可以自定义
##### 1、接口定义
?> **接入地址：** `/css/v1/uploadFile/{bucketName}`</br>
**HTTP Method：** POST
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
filename|String|Header|非必填|文件下载时的名字，此处不传或者填“”（任意个空格）则为本地文件名；</br>也可以在此重命名，重命名后的文件名需使用UTF-8编码，文件名整个长度（含后缀）在1-100字节之间。不能包含/\ |；*?"<>字符。</br>需要urlencode编码： `URLEncoder.encode(meta, "UTF-8")`。</br>另外，本地文件名暂时只支持英文字符，其他字符可能产生乱码问题。
privilegeType|int|Header|必填|权限信息
meta|String|Header|非必填|文件meta信息，传json,需要urlecdoe编码：`URLEncoder.encode(meta, "UTF-8")`
accessKey|String|Header|必填|用户主ak
file|File|Body|必填|文件
**输出参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileInfo|FileInfo|Body|是|
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/uploadFile/test-123
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
fileName: 青蛙王子.jpg
privilegeType: 1
meta:
{
"province":"qd",
"city":"qd",
"macid":"00-0C-29-55-56-B9",
"district":"hs",
"userid":"12345"
}
```
**请求应答**
```
Body：
{
"fileInfo":
{
"bucketId":123,
"createTime":"2017-01-12 20:26:45",
"fileId":102400553047,
"fileName":"RÙ\u008BP.jpg",
"fileSize":63550,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"userid":"12345",
"province":"qd",
"district":"hs",
"city":"qd"
},
"privilegeType":0
},
"retCode":"00000",
"retInfo":"成功"
}
```
#### 按meta搜索文件
> 1.文件上传时可以带有文件相关的meta信息。</br>
> 2.用户可以根据指定的meta值（多个是and的关系），上传时间（到天） ，把当前用户所有的存储文件中满足条件的文件列表搜索出来，超过一页分页显示，每页10条。</br>
> 3.只能在当前用户拥有所有权的文件中搜索，条件中可以输入多个meta值，它们是and的关系。超过一页则分页展示，每页10条，最多可以翻页到999页
##### 1、接口定义
?> **接入地址：** `/css/v1/fileListByMeta?pageNo={pageNo}`</br>
**HTTP Method：** POST
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
startTime|Data|Body|可选|开始时间，格式为yyy-MM-dd HH : mm:ss
endTime|Data|Body|可选|结束时间，格式为yyy-MM-dd HH : mm:ss
meta|Map|Body|可选|Meta信息
pageNo|int|Param|必填|差选请求当前页码，从0开始
accessKey|String|Header|必填|用户主ak
**输出参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileList|FileList|Body|必填|
MetaInfo类型的对象，包含属性：MAP<String,String> 属性值 描述文件相关信息
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/fileListByMeta?pageNo=0
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
Body：
{
"startTime":"2017-01-20",
"endTime":"2017-01-31",
"meta":
{
"macid":"00-0C-29-55-56-B9"
}
"meta":{}
}
```
**请求应答**
```
Body：
{
"fileList":
{
"infos":
[
{
"bucketId":209,
"createTime":"2017-01-23 15:12:39",
"fileId":195555933708,
"fileName":"a.jpg",
"fileSize":879394,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"userid":"12345",
"province":"山东省",
"district":"崂山区",
"city":"青岛市"
},
"privilegeType":0
},
{
"bucketId":209,
"createTime":"2017-01-23 15:12:10",
"fileId":195553017445,
"fileName":"b.jpg",
"fileSize":845941,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"userid":"12345",
"province":"山东省",
"district":"崂山区",
"city":"青岛市"
},
"privilegeType":0
},
{
"bucketId":219,
"createTime":"2017-01-23 14:19:50",
"fileId":195239095710,
"fileName":"a.jpg",
"fileSize":879394,
"meta":
{
"macid":"00-0C-29-55-56-B9",
"userid":"12345",
"province":"山东省",
"district":"崂山区",
"city":"青岛市"
},
"privilegeType":0
}
],
"nextMarker":-1,
"total":3
},
"retCode":"00000",
"retInfo":"成功"
}
```
#### 查看文件
> 1.查看文件概要信息，包含ID，名字，权限，大小，上传时间，meta值等；</br>
> 2.当前用户有文件的所有权
##### 1、接口定义
?> **接入地址：** `/css/v1/queryFile/{fileID}`</br>
**HTTP Method：** GET
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileID|long|url|必填|要查询的文件ID
accessKey|String|Header|必填|用户主ak
**输出参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileInfo|FileInfo|Body|必填|
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/queryFile/2900851854051
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
```
**请求应答**
```
Body：
{
"fileInfo":
{
"bucketId":105,
"createTime":"2017-01-10 20:37:28",
"fileId":2900851854051,
"fileName":"RÙ\u008BP.jpg",
"fileSize":63550,
"meta":
{
"w23":"qq",
"'f":"cc"
},
"privilegeType":0
},
"retCode":"00000",
"retInfo":"成功"
}
```
#### 修改文件权限
> 1.修改文件的权限，合法值为：0，私有，1，公共读，2，缺省（继承其存储区的权限）；</br>
> 2.当前用户有文件的所有权
##### 1、接口定义
?> **接入地址：** `/css/v1/modifyFileACL/{fileID}`</br>
**HTTP Method：** POST
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileID|long|url|必填|要修改的文件id
privilegeType|int|Body|必填|权限：0，私有；1，公共读,2,缺省
accessKey|String|Header|必填|用户主ak
**输出参数**： 标准输出参数
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/modifyFileACL/101844908215
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
Body：
{
"privilegeType":1
}
```
**请求应答**
```
Body：
{
"retCode": "00000",
"retInfo": "成功"
}
```
#### 删除文件
> 用户使用主ak，拥有文件的私有权限，删除文件
##### 1、接口定义
?> **接入地址：** `/css/v1/deleteFile/{fileID}`</br>
**HTTP Method：** POST
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileID|long|url|必填|要删除的文件ID
accessKey|String|Header|必填|用户主ak
**输出参数**： 标准输出参数
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/deleteFile/101844908215
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
```
**请求应答**
```
Body：
{
"retCode": "00000",
"retInfo": "成功"
}
```
### 针对应用的服务
#### 文件匿名下载
> 1.文件匿名下载，检查文件权限，如果文件为公共读，可以被用户下载；</br>
> 2.文件ID必须存在
##### 1、接口定义
?> **接入地址：** `/css/v1/anonymous/{fileID}`</br>
**HTTP Method：** GET
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileID|long|url|必填|文件id
**输出参数：** 标准输出参数
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/anonymous/102400553047
```
**请求应答：** 直接返回文件内容，如为图片则返回图片文件
#### 文件下载
> 把一个云存储中用所有权的文件下载下来；</br>
> 文件ID必须存在，且当前用户拥有其所有权限或者该文件权限为公共读
##### 1、接口定义
?> **接入地址：** `/css/v1/download/{fileID}`</br>
**HTTP Method：** GET
**输入参数**
参数名|类型|位置|必填|说明
:-|:-:|:-:|:-:|:-
fileID|long|url|必填|文件id
accessKey|String|Header|必填|用户主ak
**输出参数：** 标准输出参数
##### 2、请求样例
**请求样例**
```
接入地址：http://*******/css/v1/download/102604239767
Header：
accessKey: 1681314738825497:2K0MymVucAOQ==
```
**请求应答：** 直接返回文件内容，如为图片则返回图片文件
## 常见问题
[^-^]:常用图片注释
[CapacityService_DeviceCloudStorage_type]:_media/_CapacityService_DeviceCloudStorage/CapacityService_DeviceCloudStorage_type.png
[CapacityService_DeviceCloudStorage_liucheng]:_media/_CapacityService_DeviceCloudStorage/CapacityService_DeviceCloudStorage_liucheng.png | 20,895 | Apache-2.0 |
---
title: IntelliJ Platform SDK
redirect_from:
- /index.html
- /welcome.html
---
<!-- Copyright 2000-2020 JetBrains s.r.o. and other contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. -->
[](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
欢迎来到 _IntelliJ Platform_ SDK。这是通过创建插件，自定义语言支持，或构建自定义 IDE 来扩展 _IntelliJ Platform_ 的主要文档来源。
## 入门
* [**什么是 IntelliJ Platform？**](intellij_platform.md)
* [**关于这个指南**](about.md)
* [**关键主题**](key_topics.md)
* [**获取帮助**](getting_help.md)
* [**入门**](/basics/getting_started.md)
* [**有用的链接**](/appendix/resources/useful_links.md)
## 更新
最新的更改请参见[内容更新](content_updates.md)。 在 Twitter 上关注 [JBPlatform](https://twitter.com/JBPlatform/) 并访问 [JetBrains Platform 博客](https://blog.jetbrains.com/platform/)来获取最新公告。
升级你的插件到最新 platform 发行版？确保你检查了[不兼容的更改](/reference_guide/api_changes_list.md)以及[值得注意的更改和特性](/reference_guide/api_notable/api_notable.md)。
2020.1 将迎来[动态插件](/basics/plugin_structure/dynamic_plugins.md)。我们还发布了 2020 年的 IntelliJ Platform 路线图：[部分 I](https://blog.jetbrains.com/idea/2019/12/intellij-platform-roadmap-for-2020/) [部分 II](https://blog.jetbrains.com/idea/2020/01/intellij-based-ide-features-roadmap-for-2020/)
> **注意** 如果你的插件依赖 Java 功能并且是 2019.2 或更高版本，请确保遵循此[博客文章](https://blog.jetbrains.com/platform/2019/06/java-functionality-extracted-as-a-plugin/)中的步骤。
## 开源
这个指南是开源的，并且以 Apache 2.0 协议开源。源代码（作为 Markdown）被[托管在 GitHub 上](https://github.com/JetBrains/intellij-sdk-docs)。
请参见 [CONTRIBUTING.md](/CONTRIBUTING.md) 来获取有关如何在本地上托管文档与进行贡献的详细信息。
如果你在这个指南中遇到了 bug，或需要缺失内容的帮助，请参见[获取帮助](getting_help.md)。 | 1,715 | Apache-2.0 |
---
title: 换零钱的问题
date: 2020-08-15 14:00:00
tags: '算法'
categories:
- ['算法', '动态规划']
permalink: give-change
photo:
mathjax: true
---
## 简介
通过一系列面值的货币, 计算出某个金额能换成货币的方法
## 分析
对于货币的属性, 可以使用一个所有值都为整数且不重复的数组来表示所有的货币, 例如 $arr=[5, 10, 25]$
- 金额为 aim = 0, 则所有面值货币都不需要, 所以只有 1 种
- 金额为 aim = 3, 则所有组合都不符合, 所以只有 0 种
- 金额为 aim = 15, 则可以 3 个 5 或者 1 个 10, 1 个 5, 所以只有 2 种
<!-- more -->
### 穷举法
通过递归列举所有的值, 就是需要列举数组中的每一项为 0 到全部这过程中, 其余项组成剩余的数的方法数
例如 $arr=[1, 5, 10, 25], aim=1000$
- 用 0 个 1, 让剩下面额组成剩下的 100
- 用 1 个 1, 让剩下面额组成剩下的 999
- 用 2 个 1, 让剩下面额组成剩下的 998
- ...
- 用 1000 个 1, 让剩下面额组成剩下的 0
只要将以上的方法累加起来就是总方法数, 而上述流程剩下的面额符合递归的规则, 这样时间复杂度为 $O(aim^N)$ N 为货币队列的长度
### 剪枝
上述的穷举将所有的可能都进行计算, 在实际分析中, 可以了解到, 如果通过 5 和 10 计算到需要使用 1 和 25 组成剩下的数额时, 经常有重复数据存在, 例如
- 0 个 1 和 2 个 5, 这样需要 10 和 25 来组成剩下的 990
- 5 个 1 和 1 个 5, 这样也需要 10 和 25 来组成剩下的 990
可以知道后续的计算都是一样的, 这样就需要通过额外的记录来避免多余的计算
通过以上规律可以发现, 货币数组是固定的, 总金额是固定, 变化的是当前换算到的货币和剩下的金额, 于是就可以使用这两个变量组成二维数组来保存由剩下的货币换算剩下的金额所有的方法数
这样可以将时间复杂度降低到 $(N \times aim^2)$, N 为货币队列的长度, 额外空间复杂度为 $O(N \times aim)$
### 动态规划
由问题可以知道, 当需要 10 和 25 来组成剩下的 990 时, 所有的方法数是不变的, 也就是在该状态前所有的变化不会影响到后续的变化, 所以该问题的递归状态是无后效性的
可以通过如下规则找到类似该问题的无后效性的动态规划方法
- 通过明确可变参数代表一个递归状态, 这里指通过确定参数即可以确定返回值, 对应该问题的状态, 在固定的队列 arr 和金额 aim 中, 只要确定当前换算的货币和剩下的金额, 这样总会得到明确的结果
- 将上述的参数映射为状态集, 对应该问题就是通过二维数组表示在换了多少种货币, 剩余金额的时候总共有多少种方法
- 找到当前可以明确的最终状态, 对应该问题就是
- 在剩余金额为 0 时, 也就是不使用任何面额, 所以矩阵第一列的值 $dp[i][0], 0 \leq i \leq N$ 都为 1
- 仅使用某种货币的情况下, 也就是将剩余的金额换算成某一类货币, 所以需要在符合的金额位置设置为 1, 对应矩阵第一行的值 $dp[0][k \times arr[0]]=1, 0 \leq k \times arr[0] \leq aim, k \in N*$
- 找到执行过程方法, 对应该问题有多个逻辑
- 不使用 $arr[i]$ 货币, 只使用 $arr[0 \ddots i-1]$ 货币时, 方法数为 $dp[i-1][j]$
- 使用 1 张 $arr[i]$ 货币, 剩下的使用 $arr[0 \ddots i-1]$ 货币时, 方法数为 $dp[i-1][j-arr[i]]$
- 使用 2 张 $arr[i]$ 货币, 剩下的使用 $arr[0 \ddots i-1]$ 货币时, 方法数为 $dp[i-1][j-2 \times arr[i]]$
- 使用 k 张 $arr[i]$ 货币, 剩下的使用 $arr[0 \ddots i-1]$ 货币时, 方法数为 $dp[i-1][j-k \times arr[i]], 0 \leq k \times arr[i] \leq aim, k \in N*$
- 返回当前需要求的状态, 对应该问题知道这个状态就是 $dp[N-1][aim]$
在最差的情况下, 获取 $dp[i][j]$ 需要枚举 $dp[i-1][0 \ddots j]$ 上的所有值所以该解法处理的时间复杂度为 $O(N \times aim^2)$
从 1 到 k 遍历并且累加后得到的值其实就是 $dp[i][j-arr[i]]$ 的值, 所以可以将时间复杂度降低到 $O(N \times aim)$
## 实现
```java
public class Test {
static int coins(int[] arr, int aim) {
// 不符合的参数
if (arr == null || arr.length == 0 || aim < 0) {
return 0;
}
// 缓存数组, 进行记录, 避免重复计算
int[][] map = new int[arr.length + 1][aim + 1];
return process(arr, 0, aim, map);
}
static int process(int[] arr, int index, int aim, int[][] map) {
// 方法数
int res = 0;
if (index == arr.length) {
// 在计算当前货币的时候
// 判断能找出金额的时候返回 1 个方法
res = aim == 0 ? 1 : 0;
} else {
// 记录的值
int mapValue = 0;
// 在当前货币可以换的过程中
for (int i = 0; arr[index] * i <= aim; i ++) {
// 尝试获取之前的记录值
mapValue = map[index + 1][aim - arr[index] * i];
if (mapValue != 0) {
// 如果获取的记录为 -1, 则表示该缓存为 0 个方法, 返回
// 如果获取的记录不为 -1, 那就表示该缓存的方法, 返回
res += mapValue == -1 ? 0 : mapValue;
} else {
// 换下一个货币计算剩下的金额
res += process(arr, index + 1, aim - arr[index] * i, map);
}
}
}
// 将没有方法的设置为 -1 记录
map[index][aim] = res == 0 ? -1 : res;
return res;
}
static int getCoins(int[] arr, int aim) {
// 不符合的参数
if (arr == null || arr.length == 0 || aim < 0) {
return 0;
}
// 设置二维数组
int[][] dp = new int[arr.length][aim + 1];
// 当需要换的金额为 0 时, 所有的货币都只有一种方法, 就是不换
for (int i = 0; i < arr.length; i ++) {
dp[i][0] = 1;
}
// 当只用某种货币换的情况, 将可以换出来的金额对应的位置设置方法 1
for (int i = 1; arr[0] * i <= aim; i ++) {
dp[0][arr[0] * i] = 1;
}
// 总方法数
int num = 0;
for (int i = 1; i < arr.length; i ++) {
for (int j = 1; j <= aim; j ++) {
/*num = 0;
// 累计前一个货币从 1 到全部金额所有的方法数
for (int k = 0; j - arr[i] * k >= 0; k ++) {
num += dp[i - 1][j - arr[i] * k];
}
// 第 i 种货币在 j 金额的情况下的总方法数
dp[i][j] = num;*/
// 精简上面的步骤
// 循环累加前一个货币从 1 到全部金额所有的方法数可以简化为 dp[i][j - arr[i]]
dp[i][j] = dp[i - 1][j];
dp[i][j] += j - arr[i] >= 0 ? dp[i][j - arr[i]] : 0;
}
}
// 返回所有货币, 换金额的方法数
return dp[arr.length - 1][aim];
}
public static void main(String[] args) {
int[] arr = {1, 5, 10, 25};
System.out.println(coins(arr, 1000));
System.out.println(getCoins(arr, 1000));
}
}
```
## 结果
```sh
142511
142511
Process finished with exit code 0
``` | 4,913 | MIT |
# Android 网络层封装
作者：一直奔跑的熊猫
来源：CSDN
原文：https://blog.csdn.net/zhongwei123/article/details/80624364
版权声明：本文为博主原创文章，转载请附上博文链接！
## Android网络层重构设计 Rx+Retrofit+okhttp
公司app应用一直使用okhttp，虽然它确实好用，但是经年日久，使用时的不方便越来越多，比如重复代码过多，内存泄露不好控制，调用时参数过多等等。
还是决定痛下杀手，早点除掉这个顽疾。
So，有了这次网络层重新架构，感觉还算满意，现在列出一下过程：
### 1、接口封装
```java
/** 网络层工具类 */
public class AppConnecter {
public static int CONNNET_TIMEOUT = 30; // 超时设置
private static AppConnecter appConnecter; // 单例对象
private RequestInterface mServer; // Retrofit2网络接口
private String mInitServerUrl; // 请求域名中的主机名 如https://m.test.com
private final OkHttpClient client; // 实际的请求主体 OkHttpClient
// 初始化httpserver
private AppConnecter() {
OkHttpClient.Builder builder = new OkHttpClient().newBuilder(); // 创建OkHttpClient
try {
builder.sslSocketFactory(createSSLSocketFactory()); // 创建httpsClient
builder.hostnameVerifier(new TrustAllHostnameVerifier());
} catch (Exception e) {
}
builder.connectTimeout(CONNNET_TIMEOUT, TimeUnit.SECONDS); // 设置网络超时
builder.readTimeout(CONNNET_TIMEOUT, TimeUnit.SECONDS);
builder.addInterceptor(new RequestInterceptor()); // OkHttp请求拦截器
client = builder.build();
mInitServerUrl = "https://m.test.com";
mServer = getServer();
}
private RequestInterface getServer() {
Retrofit retrofit = new Retrofit.Builder().baseUrl(mInitServerUrl).client(client)
.addConverterFactory(ScalarsConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create()).build();
return retrofit.create(RequestInterface.class); // 自定义的网络接口
}
public static AppConnecter getInsatnce() { // 单例 不用多说
if (appConnecter == null) {
synchronized (AppConnecter.class) {
if (appConnecter == null) {
appConnecter = new AppConnecter();
}
}
}
return appConnecter;
}
// 用于切换网路请求的线程,observeOn是指定回调线程
Observable.Transformer schedulersTransformer() {
return new Observable.Transformer() {
@Override
public Observable call(Object observable) {
return ((Observable) observable).subscribeOn(Schedulers.io()).unsubscribeOn(Schedulers.io())
.observeOn(Schedulers.immediate());
}
};
}
/**
* 发送Post请求
*/
public Observable reqPostWithRx(String postUrl, Map postparams, PublishSubject lifecycleSubject) {
if (postparams == null) {
postparams = new HashMap<String, String>();
}
// 防止内存创建的Observable,当call返回true的时候,终止rx的所有消息发送
Observable<ActivityLifeCycleEvent> compareLifecycleObservable = lifecycleSubject
.takeFirst(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer.equals(ActivityLifeCycleEvent.STOP);
}
});
// 发送请求
return mServer.queryRxPostUrl(postUrl, postparams).compose(schedulersTransformer())
.takeUntil(compareLifecycleObservable);
}
/**
*发送Get请求
*/
public Observable reqGetWithRx(String url, Map<String, String> params, PublishSubject lifecycleSubject) {
if (params == null) {
params = new HashMap<String, String>();
}
//防止内存创建的Observable,当call返回true的时候,终止rx的所有消息发送
Observable<ActivityLifeCycleEvent> compareLifecycleObservable =
lifecycleSubject.takeFirst(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
boolean isStop = integer.equals(ActivityLifeCycleEvent.STOP);
return isStop;
}
});
//发送请求
return mServer.queryRxGetUrl(url, params).compose(schedulersTransformer()).takeUntil(compareLifecycleObservable);
}
}
```
这个类公布出来的就2个接口 ：
- reqGetWithRx (用于get)
- reqPostWithRx (用于post)
它们返回的对象都是 **Observable** (Rx的关键核心类)，用它可以做一系列的不同操作，什么排序，过滤等等，你想怎么弄它就怎么弄。它就是发送网络请求后，服务端返回的结果。
**compareLifecycleObservable** 这个对象，十分关键，它就是为了防止我们android中经常容易犯错的那个内存泄露而设置的。我们在activity基类中统一新建 **lifecycleSubject**。
> 它在哪使用呢？
就是在我们的本地界面activity finish的时候，
```java
public void finish() {
lifecycleSubject.onNext(ActivityLifeCycleEvent.STOP);
super.finish();
}
```
这样它就会帮我们把当前页面所有的请求finish掉，怎么样，省心吧！
### 2、RequestInterceptor
这个 RequestInterceptor，其实是OkHttp自带的拦截器，我们只要继承okhttp3.Interceptor就可以了。
然后覆盖它的intercept方法，在这个方法里，做一些针对URL的操作，比如**编码，签名，加密**等。
### 3、RequestInterface (自定义的网络接口)
```
public interface RequestInterface {
//结合RxJava的Post请求
@FormUrlEncoded
@POST("{url}")
Observable<String> queryRxPostUrl(@Path("url") String url, @FieldMap Map<String, String> params);
//结合RxJava的get请求
@GET("{url}")
Observable<String> queryRxGetUrl(@Path("url") String url, @QueryMap Map<String,String> params);
}
```
这样调用的时候，我们传的参数，只需要 与功能相关的接口名称与参数了。
### 4、Rx 网络回调订阅者 Subscriber
这个类主要是用于统一处理返回的字符串解析，我们给它加上泛型，就可以统一解析成需要的数据对象。
```java
public abstract class BaseSubscriber<T> extends Subscriber {
public final void onNext(final Object o) {
String result = (String) o;
//此处转换成我们需要的数据对象
Type type = ((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0];
final T bean = JSON.parseObject(result, type); //假定返回的数据是json格式
// ...
// onSuccess
// onFailed
// onError
}
}
```
### 5、在 Activity 基类中增加通用方法
```java
//BaseBean：自定义的数据对象基类
//ReqBean：自定义的网络请求参数对象
public <T extends BaseBean> void reqByGet(ReqBean reqBean, BaseSubscriber<T> reqCallBack) {
AppConnecter.getInsatnce().queryGetWithRx(reqBean.url, reqBean.getLastParams(), lifecycleSubject)
.subscribe(reqCallBack);
}
```
### 6、测试
做了这么多，终于到了享受的时候了，很简单，一句代码搞定：
```
String url = "/test/test.do";
reqByGet(new ReqBean(url, new String[][]{{"参数1", "参数值"}}), new BaseSubscriber<XxxBean>(){
@Override
public void onSuccess(XxxBean sKeyBean) {
//此处处理相关业务
}
@Override
public void onFailed(String code, String msg) {
//错误处理
}
});
```
大功告成了~~~~！
> 但其实它还是有明显的问题，大家有没有发现呢？
就是返回的 Observable，是依赖第三方框架的，这个东东要是以后替换或者升级时，Rx 改动了它，那就麻烦大了。
所以，最好的办法是自定义一个接口，来包装Observable。
---------------------
作者：woshifano
来源：CSDN
原文：https://blog.csdn.net/woshifano/article/details/46984729
版权声明：本文为博主原创文章，转载请附上博文链接！
## Android 网络层的封装
因为项目需要封装了其网络层，主要对其原来的模式进行改进，使用的回调的方式来进行网络的访问和返回结果的处理，还有就是在 View 层和网络层之间加了一个中间层，用来分配各种网络请求，这样就可以方便的调度和管理。
我就不拿原项目的代码来演示，自己写了一个 demo，首先是最底层，处理最基本的 Http 协议，里面包含一个 execute 方法，用来 Post 或者 Get 获取数据，这里为了方便我只写了一个 Get，可以根据具体需要进行改成Post 或者其他方法：
### 1. Request 方法封装
```java
import java.util.Map;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
public class RequestService {
private static final String DEFAULT_CHARSET = HTTP.UTF_8;
private static HttpClient simpleHttpClient = null;
// 连接超时设定
public final static int CONNECT_TIME_OUT = 10 * 1000;
// 连接池取连接超时设定
public final static int WAIT_TIME_OUT = 10 * 1000;
// 读超时设定
public final static int READ_TIME_OUT = 40 * 1000;
// 连接池容量设定
public final static int MAX_CONNECTION = 10;
private static void init() {
if (null == simpleHttpClient) {
HttpParams params = new BasicHttpParams();
HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(params, DEFAULT_CHARSET);
HttpProtocolParams.setUseExpectContinue(params, true);
ConnManagerParams.setTimeout(params, WAIT_TIME_OUT);
ConnManagerParams.setMaxTotalConnections(params, MAX_CONNECTION);
// 通信读超时时间
HttpConnectionParams.setSoTimeout(params, READ_TIME_OUT);
// 通信连接超时时间
HttpConnectionParams.setConnectionTimeout(params, CONNECT_TIME_OUT);
SchemeRegistry schReg = new SchemeRegistry();
schReg.register(new Scheme("http", PlainSocketFactory
.getSocketFactory(), 80));
// schReg.register(new Scheme("https",
// SSLSocketFactory.getSocketFactory(), 443));
ClientConnectionManager connectionManager = new ThreadSafeClientConnManager(params, schReg);
simpleHttpClient = new DefaultHttpClient(connectionManager, params);
}
}
protected static String get(String url, Map params) {
String json = "";
try {
init();
HttpGet httpGet = new HttpGet(url);
// todo set params
HttpResponse httpResponse;
httpResponse = simpleHttpClient.execute(httpGet);
if (httpResponse.getStatusLine().getStatusCode() == 200)
json = EntityUtils.toString(httpResponse.getEntity());
} catch (Exception e) {
log.error(TAG, "request (get) error: "+e.getMessagem, e);
}
return json;
}
}
```
### 2. 请求对象封装
可以看到这个 execute 方法的参数是 String url 和 Map<String,String> params，这样我们就需要一个POJO来构造这些参数。
```java
package com.example.callbacktest;
import java.util.HashMap;
import java.util.Map;
public class Request {
private String url;
private Map params;
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public Map getParams() {
return params;
}
public void setParams(Map params) {
this.params = params;
}
}
```
### 3. 请求对象工厂类
接下来是一个工厂类，这里用到了简单工厂模式，可以根据不同的参数很方便的创造出POJO的实例。
```java
import java.util.HashMap;
import java.util.Map;
public class NetworkFactory {
private static final String baseUrl = "http://contests.acmicpc.info/contests.json";
private static final String login = "/user/login.php";
private static final String reg = "/user/reg.php";
private static Request createRequest(Map requestParams, String apiUrl) {
String url = baseUrl + apiUrl;
Request request = new Request();
request.setUrl(url);
request.setParams(requestParams);
return request;
}
public static Request createLogin(String name, String pwd) {
Map requestParams = new HashMap();
requestParams.put("name", name);
requestParams.put("pwd", pwd);
return createRequest(requestParams, login);
}
public static Request createGo() {
Map requestParams = new HashMap();
return createRequest(requestParams, "");
}
}
```
### 4. 中间层
接下来是中间层，所有的网络方法都需要经过这里才能调用底层协议，在这里进行各种网络方法的调度和管理.
```java
import android.os.AsyncTask;
public class Network {
/**
* 这个方法运行在主线程中，在具体使用时需要自己将其运行在子线程中
* @param request
* @param callback
*/
public static void postOnUI(Request request, Callback callback) {
String json = RequestService.get(request.getUrl(), request.getMap());
if (json == "")
callback.onSuccess(json);
else
callback.onError();
}
/**
* 这个方法运行在子线程中，构造好回调函数，使用时只需要简单调用就可以
* @param request
* @param callback
*/
public static void postOnThread(Request request, Callback callback) {
new RequestAsyncTask(request, callback).get("");
}
/**
* 这个是不带回调的方法，使用时需要根据自己的需要进行判断返回值处理各种逻辑
* @param request
* @return
*/
public static String post(Request request) {
String json = RequestService.get(request.getUrl(), request.getMap());
return json;
}
/**
* AsyncTask
* @author ukfire
*
*/
static class RequestAsyncTask extends AsyncTask {
private Request request;
private Callback callback;
public RequestAsyncTask(Request request, Callback callback) {
this.request = request;
this.callback = callback;
}
@Override
protected String doInBackground(String... arg0) {
String json = "";
json = RequestService.get(request.getUrl(), request.getMap());
return json;
}
@Override
protected void onPostExecute(String result) {
super.onPostExecute(result);
if (result == "")
callback.onError();
else
callback.onSuccess(result);
}
}
}
```
### 5. 回调接口
自己定义回调接口，一般来说就是进行Success处理和Error处理，还可以进一步抽象.
```java
public interface Callback {
public void onError();
public void onSuccess(String json);
}
```
### 6. 实现回调接口
最后就是在主函数中进行调用，这里调用的是运行在子线程中的方法，只需要构造好Callback回调函数，简单调用即可.
```java
final Request request = NetworkFactory.createGo(); //构造POJO
btn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
Network.postOnThread(request, new Callback() {
@Override
public void onSuccess(String json) {
text.setText(json);
}
@Override
public void onError() {
text.setText("Error");
}
});
}
});
```
这样 View 层和底层中间就多了一个中间层，提供运行在不同线程的各种调用方法，使用时对其回调方法进行实现就可以了，最大的优点就是**方便调度和管理**。
## giffun 网络封装
### 1. Request 封装
```kotlin
/**
* 网络请求模式的基类，所有的请求封装都应该要继承此类。这里会提供网络模块的配置，以及请求的具体逻辑处理等。
*
* @author guolin
* @since 17/2/12
*/
abstract class Request {
private lateinit var okHttpClient: OkHttpClient
private val okHttpBuilder: OkHttpClient.Builder = OkHttpClient.Builder().addNetworkInterceptor(LoggingInterceptor())
private var callback: Callback? = null
private var params: Map<String, String>? = null
var getParamsAlready = false
var deviceName: String
var deviceSerial: String
init {
connectTimeout(10)
writeTimeout(10)
readTimeout(10)
deviceName = Utility.deviceName
deviceSerial = Utility.getDeviceSerial()
}
private fun build() {
okHttpClient = okHttpBuilder.build()
}
fun connectTimeout(seconds: Int) {
okHttpBuilder.connectTimeout(seconds.toLong(), TimeUnit.SECONDS)
}
fun writeTimeout(seconds: Int) {
okHttpBuilder.writeTimeout(seconds.toLong(), TimeUnit.SECONDS)
}
fun readTimeout(seconds: Int) {
okHttpBuilder.readTimeout(seconds.toLong(), TimeUnit.SECONDS)
}
/**
* 设置响应回调接口
* @param callback
* 回调的实例
*/
fun setListener(callback: Callback?) {
this.callback = callback
}
/**
* 组装网络请求后添加到HTTP发送队列，并监听响应回调。
* @param requestModel
* 网络请求对应的实体类
*/
fun <T : com.quxianggif.network.model.Response> inFlight(requestModel: Class<T>) {
build()
val requestBuilder = okhttp3.Request.Builder()
if (method() == GET && getParams() != null) {
requestBuilder.url(urlWithParam())
} else {
requestBuilder.url(url())
}
requestBuilder.headers(headers(Headers.Builder()).build())
when {
method() == POST -> requestBuilder.post(formBody())
method() == PUT -> requestBuilder.put(formBody())
method() == DELETE -> requestBuilder.delete(formBody())
}
okHttpClient.newCall(requestBuilder.build()).enqueue(object : okhttp3.Callback {
@Throws(IOException::class)
override fun onResponse(call: Call, response: Response) {
try {
if (response.isSuccessful) {
val body = response.body()
val result = if (body != null) {
body.string()
} else {
""
}
logVerbose(LoggingInterceptor.TAG, result)
val gson = GsonBuilder().disableHtmlEscaping().create()
val responseModel = gson.fromJson(result, requestModel)
response.close()
notifyResponse(responseModel)
} else {
notifyFailure(ResponseCodeException(response.code()))
}
} catch (e: Exception) {
notifyFailure(e)
}
}
override fun onFailure(call: Call, e: IOException) {
notifyFailure(e)
}
})
}
abstract fun url(): String
abstract fun method(): Int
abstract fun listen(callback: Callback?)
/**
* 构建和服务器身份认证相关的请求参数。
* @param params
* 构建参数的param对象
* @return 如果完成了身份认证参数构建返回true，否则返回false。
*/
fun buildAuthParams(params: MutableMap<String, String>?): Boolean {
if (params != null && AuthUtil.isLogin) {
val userId = AuthUtil.userId.toString()
val token = AuthUtil.token
params[NetworkConst.UID] = userId
params[NetworkConst.DEVICE_SERIAL] = deviceSerial
params[NetworkConst.TOKEN] = token
return true
}
return false
}
/**
* 根据传入的keys构建用于进行服务器验证的参数，并添加到请求头当中。
* @param builder
* 请求头builder
* @param keys
* 用于进行服务器验证的键。
*/
fun buildAuthHeaders(builder: Headers.Builder?, vararg keys: String) {
if (builder != null && keys.isNotEmpty()) {
val params = mutableListOf<String>()
for (i in keys.indices) {
val key = keys[i]
getParams()?.let {
val p = it[key]
if (p != null) {
params.add(p)
}
}
}
builder.add(NetworkConst.VERIFY, AuthUtil.getServerVerifyCode(*params.toTypedArray()))
}
}
/**
* Android客户端的所有请求都需要添加User-Agent: GifFun Android这样一个请求头。每个接口的封装子类可以添加自己的请求头。
* @param builder
* 请求头builder
* @return 添加完请求头后的builder。
*/
open fun headers(builder: Headers.Builder): Headers.Builder {
builder.add(NetworkConst.HEADER_USER_AGENT, NetworkConst.HEADER_USER_AGENT_VALUE)
builder.add(NetworkConst.HEADER_APP_VERSION, Utility.appVersion)
builder.add(NetworkConst.HEADER_APP_SIGN, Utility.appSign)
return builder
}
open fun params(): Map<String, String>? {
return null
}
/**
* 构建POST、PUT、DELETE请求的参数体。
*
* @return 组装参数后的FormBody。
*/
private fun formBody(): FormBody {
val builder = FormBody.Builder()
val params = getParams()
if (params != null) {
val keys = params.keys
if (!keys.isEmpty()) {
for (key in keys) {
val value = params[key]
if (value != null) {
builder.add(key, value)
}
}
}
}
return builder.build()
}
/**
* 当GET请求携带参数的时候，将参数以key=value的形式拼装到GET请求URL的后面，并且中间以?符号隔开。
* @return 携带参数的URL请求地址。
*/
private fun urlWithParam(): String {
val params = getParams()
if (params != null) {
val keys = params.keys
if (!keys.isEmpty()) {
val paramsBuilder = StringBuilder()
var needAnd = false
for (key in keys) {
if (needAnd) {
paramsBuilder.append("&")
}
paramsBuilder.append(key).append("=").append(params[key])
needAnd = true
}
return url() + "?" + paramsBuilder.toString()
}
}
return url()
}
/**
* 获取本次请求所携带的所有参数。
*
* @return 本次请求所携带的所有参数，以Map形式返回。
*/
private fun getParams(): Map<String, String>? {
if (!getParamsAlready) {
params = params()
getParamsAlready = true
}
return params
}
/**
* 当请求响应成功的时候，将服务器响应转换后的实体类进行回调。
* @param response
* 服务器响应转换后的实体类
*/
private fun notifyResponse(response: com.quxianggif.network.model.Response) {
callback?.let {
if (it is OriginThreadCallback) {
it.onResponse(response)
callback = null
} else {
GifFun.getHandler().post {
it.onResponse(response)
callback = null
}
}
}
}
/**
* 当请求响应失败的时候，将具体的异常进行回调。
* @param e
* 请求响应的异常
*/
private fun notifyFailure(e: Exception) {
callback?.let {
if (it is OriginThreadCallback) {
it.onFailure(e)
callback = null
} else {
GifFun.getHandler().post {
it.onFailure(e)
callback = null
}
}
}
}
companion object {
const val GET = 0
const val POST = 1
const val PUT = 2
const val DELETE = 3
}
}
```
#### 1.1 httpClient 初始化
```kotlin
init { // 默认参数设置
connectTimeout(10)
writeTimeout(10)
readTimeout(10)
deviceName = Utility.deviceName
deviceSerial = Utility.getDeviceSerial()
}
private fun build() { // 初始化
okHttpClient = okHttpBuilder.build()
}
```
#### 1.2 请求信息配置
- URL
```kotlin
abstract fun url(): String
```
- mehtod
```kotlin
abstract fun method(): Int
```
- header
```kotlin
/**
* 根据传入的keys构建用于进行服务器验证的参数，并添加到请求头当中。
* @param builder
* 请求头builder
* @param keys
* 用于进行服务器验证的键。
*/
fun buildAuthHeaders(builder: Headers.Builder?, vararg keys: String) {
if (builder != null && keys.isNotEmpty()) {
val params = mutableListOf<String>()
for (i in keys.indices) {
val key = keys[i]
getParams()?.let {
val p = it[key]
if (p != null) {
params.add(p)
}
}
}
builder.add(NetworkConst.VERIFY, AuthUtil.getServerVerifyCode(*params.toTypedArray()))
}
}
/**
* Android客户端的所有请求都需要添加User-Agent: GifFun Android这样一个请求头。每个接口的封装子类可以添加自己的请求头。
* @param builder
* 请求头builder
* @return 添加完请求头后的builder。
*/
open fun headers(builder: Headers.Builder): Headers.Builder {
builder.add(NetworkConst.HEADER_USER_AGENT, NetworkConst.HEADER_USER_AGENT_VALUE)
builder.add(NetworkConst.HEADER_APP_VERSION, Utility.appVersion)
builder.add(NetworkConst.HEADER_APP_SIGN, Utility.appSign)
return builder
}
```
- params
```kotlin
/**
* 构建和服务器身份认证相关的请求参数。
* @param params
* 构建参数的param对象
* @return 如果完成了身份认证参数构建返回true，否则返回false。
*/
fun buildAuthParams(params: MutableMap<String, String>?): Boolean {
if (params != null && AuthUtil.isLogin) {
val userId = AuthUtil.userId.toString()
val token = AuthUtil.token
params[NetworkConst.UID] = userId
params[NetworkConst.DEVICE_SERIAL] = deviceSerial
params[NetworkConst.TOKEN] = token
return true
}
return false
}
/**
* 构建POST、PUT、DELETE请求的参数体。
*
* @return 组装参数后的FormBody。
*/
private fun formBody(): FormBody {
val builder = FormBody.Builder()
val params = getParams()
if (params != null) {
val keys = params.keys
if (!keys.isEmpty()) {
for (key in keys) {
val value = params[key]
if (value != null) {
builder.add(key, value)
}
}
}
}
return builder.build()
}
/**
* 当GET请求携带参数的时候，将参数以key=value的形式拼装到GET请求URL的后面，并且中间以?符号隔开。
* @return 携带参数的URL请求地址。
*/
private fun urlWithParam(): String {
val params = getParams()
if (params != null) {
val keys = params.keys
if (!keys.isEmpty()) {
val paramsBuilder = StringBuilder()
var needAnd = false
for (key in keys) {
if (needAnd) {
paramsBuilder.append("&")
}
paramsBuilder.append(key).append("=").append(params[key])
needAnd = true
}
return url() + "?" + paramsBuilder.toString()
}
}
return url()
}
/**
* 获取本次请求所携带的所有参数。
*
* @return 本次请求所携带的所有参数，以Map形式返回。
*/
private fun getParams(): Map<String, String>? {
if (!getParamsAlready) {
params = params()
getParamsAlready = true
}
return params
}
```
#### 1.3 发起请求
```kotlin
/**
* 组装网络请求后添加到HTTP发送队列，并监听响应回调。
* @param requestModel
* 网络请求对应的实体类
*/
fun <T : com.quxianggif.network.model.Response> inFlight(requestModel: Class<T>) {
build()
val requestBuilder = okhttp3.Request.Builder()
if (method() == GET && getParams() != null) {
requestBuilder.url(urlWithParam())
} else {
requestBuilder.url(url())
}
requestBuilder.headers(headers(Headers.Builder()).build())
when {
method() == POST -> requestBuilder.post(formBody())
method() == PUT -> requestBuilder.put(formBody())
method() == DELETE -> requestBuilder.delete(formBody())
}
okHttpClient.newCall(requestBuilder.build()).enqueue(object : okhttp3.Callback {
@Throws(IOException::class)
override fun onResponse(call: Call, response: Response) {
try {
if (response.isSuccessful) {
val body = response.body()
val result = if (body != null) {
body.string()
} else {
""
}
logVerbose(LoggingInterceptor.TAG, result)
val gson = GsonBuilder().disableHtmlEscaping().create()
val responseModel = gson.fromJson(result, requestModel)
response.close()
notifyResponse(responseModel)
} else {
notifyFailure(ResponseCodeException(response.code()))
}
} catch (e: Exception) {
notifyFailure(e)
}
}
override fun onFailure(call: Call, e: IOException) {
notifyFailure(e)
}
})
}
```
#### 1.4 回调函数处理
实现返回数据的处理，或更新UI或抛出异常，或下文文件等等...
```kotlin
abstract fun listen(callback: Callback?)
/**
* 当请求响应成功的时候，将服务器响应转换后的实体类进行回调。
* @param response
* 服务器响应转换后的实体类
*/
private fun notifyResponse(response: com.quxianggif.network.model.Response) {
callback?.let {
if (it is OriginThreadCallback) {
it.onResponse(response)
callback = null
} else {
GifFun.getHandler().post {
it.onResponse(response)
callback = null
}
}
}
}
/**
* 当请求响应失败的时候，将具体的异常进行回调。
* @param e
* 请求响应的异常
*/
private fun notifyFailure(e: Exception) {
callback?.let {
if (it is OriginThreadCallback) {
it.onFailure(e)
callback = null
} else {
GifFun.getHandler().post {
it.onFailure(e)
callback = null
}
}
}
}
``` | 28,131 | MIT |
---
layout: post
title: "070 电影传奇（总策划：崔永元）-《战火中的青春》之《战争与爱情》"
date: 2020-10-09T04:35:26.000Z
author: 崔永元
from: https://www.youtube.com/watch?v=FsmsvQI9z5c
tags: [ 崔永元 ]
categories: [ 崔永元 ]
---
<!--1602218126000-->
[070 电影传奇（总策划：崔永元）-《战火中的青春》之《战争与爱情》](https://www.youtube.com/watch?v=FsmsvQI9z5c)
------
<div>
今天发布2004年4月播出的 电影传奇 “《战火中的青春》之《战争与爱情》”。解密不为人知的历史传奇和电影故事。《战火中的青春》是长春电影制片厂摄制的剧情电影。由王炎执导，庞学勤、王苏娅、林农等主演。于1959年12月1日上映。根据陆柱国小说《踏平东海万顷浪》改编，讲述了女扮男装的高山和雷振林的故事。崔永元拥有《电影传奇》授权 - 永久在全球的网络传播权。欢迎分享，严禁转载！请其他发布盗版《电影传奇》的朋友尽快删除！感恩您曾经的宣传。
</div> | 536 | MIT |
# Synchronizer学习
- 相关实现
```java
public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
// 线程排他比较依据
private transient Thread exclusiveOwnerThread;
protected final void setExclusiveOwnerThread(Thread thread) {
exclusiveOwnerThread = thread;
}
protected final Thread getExclusiveOwnerThread() {
return exclusiveOwnerThread;
}
}
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
/**
* CLH(Craig, Landin, and Hagersten) lock queue
*
* +------+ prev +-----+ +-----+
* head | | <---- | | <---- | | tail
* +------+ +-----+ +-----+
* waitStatus(用来判断当前及之后节点应该进行的操作):
* CANCELLED (1): 当前节点已被取消
* SIGNAL (-1): 下一个节点已被阻塞(park), 需激活(unpark)
* CONDITION(-2): 当前节点处在condition状态
* PROPAGATE(-3): 当前节点处在SharedReleased状态
* (0): None of the above
*/
static final class Node {
static {
try {
MethodHandles.Lookup l = MethodHandles.lookup();
NEXT = l.findVarHandle(Node.class, "next", Node.class);
PREV = l.findVarHandle(Node.class, "prev", Node.class);
THREAD = l.findVarHandle(Node.class, "thread", Thread.class);
WAITSTATUS = l.findVarHandle(Node.class, "waitStatus", int.class);
} catch (ReflectiveOperationException e) {
throw new ExceptionInInitializerError(e);
}
}
}
static {
try {
MethodHandles.Lookup l = MethodHandles.lookup();
STATE = l.findVarHandle(AbstractQueuedSynchronizer.class, "state", int.class);
HEAD = l.findVarHandle(AbstractQueuedSynchronizer.class, "head", Node.class);
TAIL = l.findVarHandle(AbstractQueuedSynchronizer.class, "tail", Node.class);
} catch (ReflectiveOperationException e) {
throw new ExceptionInInitializerError(e);
}
Class<?> ensureLoaded = LockSupport.class;
}
/*
* 子类需要实现的方法
*/
// 获取同步器(只能由一个线程获取)
protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); }
// 释放同步器(只能由一个线程获取)
protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); }
// 获取同步器(多个线程获取)
protected int tryAcquireShared(int arg) { throw new UnsupportedOperationException(); }
// 释放同步器(多个线程获取)
protected boolean tryReleaseShared(int arg) { throw new UnsupportedOperationException(); }
}
```
- 同步器使用方法
```java
// 实现方法
tryAcquire(int): boolean // 成功返回true
tryRelease(int): boolean // 成功返回true
tryAcquireShared(int): int // 负数失败，0-部分成功，正数成功部分
tryReleaseShared(int): int // 负数失败，0-部分成功, 正负数成功部分
isHeldExclusively(): boolean // 排他返回true
// 使用方式
/* 排他模式 */
public final void acquire(int arg);
public final void acquireInterruptibly(int arg);
public final boolean tryAcquireNanos(int arg, long nanosTimeout);
public final boolean release(int arg);
/* 共享模式 */
public final void acquireShared(int arg);
public final void acquireSharedInterruptibly(int arg);
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout);
public final boolean releaseShared(int arg);
```
- jdk实现示例
```java
// CountDownLatch
private static final class Sync extends AbstractQueuedSynchronizer {
Sync(int count) { setState(count); }
int getCount() { return getState(); }
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c - 1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
// Semaphore
abstract static class Sync extends AbstractQueuedSynchronizer {
Sync(int permits) { setState(permits); }
final int getPermits() { return getState(); }
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
}
// NonFair version
static final class NonfairSync extends Sync {
protected int tryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
// Fair version
static final class FairSync extends Sync {
protected int tryAcquireShared(int acquires) {
for (;;) {
if (hasQueuedPredecessors())
return -1;
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
``` | 5,918 | MIT |
#### 1. 考虑用静态工厂方法代替构造器
> 静态方法的
> *优势*
> 1. 有名称，便于理解
> 2. 不用每次都创建一个新对象
> 3. 可以返回类型的任何子类型对象
> 4. 创建参数化类型实例的时候，代码更加简洁
>*缺点*
> 1. 类如果不包含共有或者受保护的构造器，就不能被子类化
> 2. 与其他人静态方法无区别
#### 2. 遇到多个构造器时要考虑用构建器
#### 3. 用私有构造器或者枚举类型强化Singleton属性
>* 枚举类实现其实省略了private类型的构造函数
>* 枚举类的域(field)其实是相应的enum类型的一个实例对象
```java
//Define what the singleton must do.
public interface MySingleton {
public void doSomething();
}
private enum Singleton implements MySingleton {
/**
* The one and only instance of the singleton.
*
* By definition as an enum there MUST be only one of these and it is inherently thread-safe.
*/
INSTANCE {
@Override
public void doSomething() {
// What it does.
}
};
}
public static MySingleton getInstance() {
return Singleton.INSTANCE;
}
```
>https://stackoverflow.com/questions/23721115/singleton-pattern-using-enum-version
#### 4. 通过私有构造器强化不可实例化的能力
#### 5. 避免创建不必要的对象
#### 6. 消除过期的对象引用
#### 7. 避免使用 finalizer 方法
#### 8. 重写 equals 时请遵守通用约定
#### 9. 重写 equals 时总要重写 hashCode
#### 10. 始终重写 toString
#### 11. 谨慎重写 clone
#### 12. 考虑实现 Comparable 接口
#### 13. 使类和成员的可访问性最小化
#### 14. 在共有类中使用访问方法而非共有域
> 使用getter setter 方法
#### 15. 使可变性最小化
> 每个实例中包含的所有信息都必须在创建该实例的时候就提供，并在对象的整个生命周期(lifetime)內固定不变
#### 16. 符合优先于继承
> 继承打破了封装性
#### 17. 要么为继承而设计，并提供文档说明，要么就禁止继承
#### 18. 接口优于抽象类
> 现有的类可以很容易被更新，以实现新的接口
> 接口时定义mixin（混合类型) 的理想选择
> 接口允许我们构造非层次接口的类型框架
#### 19. 接口只用于定义类型
> 常量接口不满足次条件，常量接口是对接口的不良使用
#### 20. 类层次优于标签类
#### 21. 用函数对象表示策略
#### 22. 优先考虑静态成员类
> 嵌套类(nested class)
> * 静态成员类
> * 非静态成员类
> * 匿名类
> * 局部类
>
>除了第一种外 其他三种被称为内部类
#### 23. 请不要在新代码中使用原生态类型
#### 24. 消除非受检警告
#### 25. 列表优先于数组
> 数组与泛型相比，数组是协变的(covariant)、具体化的（reified）
#### 26. 优先考虑泛型
#### 27. 优先考虑泛型方法
#### 28. 利用有限制通配符来提升API的灵活性
#### 29. 优先考虑类型安全的异构容器
#### 30. 用 enum 代替 int 常量
> 枚举天生就不可变
####31. 用实例域代替序数
> 不要根据枚举的序数导出与关联的值，而是要将它保存在一个实例域
> ```java
>public enum Ensemble {
> SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5),
> SEXTET(6), ETPTET(7), OCTET(8), DOUBLE_QUARTET(8)
>
> private final int numberOfMusicians;
> Ensemble(int size) { this.numberOfMusicians = size; }
> public int numberOfMusicians() { return numberOfMusicians; }
>}
>```
#### 32. 用 EnumSet 代替位域
> 位域(bit field) 用OR位运算将几个常量合并到一个集合中
#### 33. 用 EnumMap 代替序数索引
#### 34. 用接口模拟可伸缩的枚举
#### 35. 注解优先于命名模式
#### 36. 坚持使用 Override 注解
#### 37. 用标记接口定义类型
> 标记接口 (marker interface) 没有包含方法声明的接口，而只是指明一个类实现了具有某种属性的接口
#### 38. 检查参数的有效性
#### 39. 必要时进行保护醒拷贝
#### 40. 谨慎设计方法签名
> * 谨慎地选择方法的名称
> * 不要过于追求提供便利的方法
> * 避免过长的参数列表
#### 41. 慎用重载
#### 42. 慎用可变参数
#### 43. 返回零长度的数组或者集合，而不是null
#### 44. 为所有导出的API元素编写文档注释
#### 45. 将局部变量的作用域最小化
> * 用到在声明
> * 声明时都应该包含一个初始化表达式
#### 46. for-each 循环优先于传统的 for 循环
#### 47. 了解和使用类库
#### 48. 如果需要精确的答案，请避免使用 float 和 double
> 使用 BigDecimal、int、long 进行货币计算
#### 49. 基本类型优先于装箱基本类型
#### 50. 如果其他类型更合适，则尽量避免使用字符串
> * 字符串不适合代替其他的值类型
> * 字符串不适合代替枚举类型
> * 字符串不适合代替聚集类型
> * 字符串也不适合代替能力表 (capabilities)
#### 51. 当心字符串连接的性能
#### 52. 通过接口引用对象
```java
// good
List<Subscriber> subscribers = new Vector<Subscriber>()
// bad
Vector<Subscriber> subscribers = new Vector<Subscriber>()
```
#### 53. 接口优先于反射机制
> 反射的弊端
> * 丧失了编译时类型检查的好处
> * 执行反射访问所需要的代码笨拙和冗长
> * 性能损失
#### 54. 谨慎地使用本地方法
> Java Native Interface (JNI) 允许调用本地方法(native method)
#### 55. 谨慎的进行优化
#### 56. 遵守普遍接受的命名惯例
#### 57. 只针对异常的情况才使用异常
#### 58. 对可恢复的情况使用受检异常，对编程错误使用运行时异常
> 三种可抛出错误(throwable)
> * 受检的异常（checked exception） 希望调用者能适当地恢复
> * 运行时异常 (runtime exception) 前提违例 (precondition violation)
> * 错误（error）
#### 59. 避免不必要地使用受检的异常
#### 60. 优先使用标准的异常
#### 61. 抛出与抽象相对应的异常
#### 62. 每个方法抛出的异常都要有文档
#### 63. 在细节消息中包含能捕获失败的信息
#### 64. 努力使失败保持原子性
> 失败方法调用应该使对象保持在被调用之前的状态
#### 65. 不要忽略异常
#### 66. 同步访问共享的可变数据
#### 67. 避免过度同步
#### 68. executor 和 task 优先于线程
#### 69. 并发工具优先于wait 和 notify
#### 70. 线程安全性的文档化
#### 71. 慎用延迟初始化
#### 72. 不要依赖线程调度器
#### 73. 避免使用线程组
#### 74. 谨慎地实现 Serializable 接口
#### 75. 考虑使用自定义序列化形式
#### 76. 保护性地编写 readObject 方法
#### 77. 对于实例控制，枚举类型优先于 readResolve
#### 78. 考虑用序列化代理代替序列化实例
> 为可序列化的类设计一个私有的静态嵌套类，精确地表示外围类的实例的逻辑状态。这个嵌套类被称作序列化代理(serialization proxy) | 4,114 | MIT |
# Hadoop-Mapreduce
## 1. MapReduce 介绍
MapReduce思想在生活中处处可见。或多或少都曾接触过这种思想。MapReduce的思想核心是“分而治之”，适用于大量复杂的任务处理场景（大规模数据处理场景）。
* Map负责“分”，即把复杂的任务分解为若干个“简单的任务”来并行处理。可以进行拆分的前提是这些小任务可以并行计算，彼此间几乎没有依赖关系。
* Reduce负责“合”，即对map阶段的结果进行全局汇总。
* MapReduce运行在yarn集群
1. ResourceManager
2. NodeManager
这两个阶段合起来正是MapReduce思想的体现。
还有一个比较形象的语言解释MapReduce:
我们要数图书馆中的所有书。你数1号书架，我数2号书架。这就是“Map”。我们人越多，数书就更快。
现在我们到一起，把所有人的统计数加在一起。这就是“Reduce”。
### 1.1. MapReduce 设计构思
MapReduce是一个分布式运算程序的编程框架，核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在Hadoop集群上。
MapReduce设计并提供了统一的计算框架，为程序员隐藏了绝大多数系统层面的处理细节。为程序员提供一个抽象和高层的编程接口和框架。程序员仅需要关心其应用层的具体计算问题，仅需编写少量的处理应用本身计算问题的程序代码。如何具体完成这个并行计算任务所相关的诸多系统层细节被隐藏起来,交给计算框架去处理：
Map和Reduce为程序员提供了一个清晰的操作接口抽象描述。MapReduce中定义了如下的Map和Reduce两个抽象的编程接口，由用户去编程实现.Map和Reduce,MapReduce处理的数据类型是<key,value>键值对。
* Map: `(k1; v1) → [(k2; v2)]`
* Reduce: `(k2; [v2]) → [(k3; v3)]`
一个完整的mapreduce程序在分布式运行时有三类实例进程：
1. `MRAppMaster` 负责整个程序的过程调度及状态协调
2. `MapTask` 负责map阶段的整个数据处理流程
3. `ReduceTask` 负责reduce阶段的整个数据处理流程
## 2. MapReduce 编程规范
> MapReduce 的开发一共有八个步骤, 其中 Map 阶段分为 2 个步骤，Shuffle 阶段 4 个步骤，Reduce 阶段分为 2 个步骤
##### Map 阶段 2 个步骤
1. 设置 InputFormat 类, 将数据切分为 Key-Value**(K1和V1)** 对, 输入到第二步
2. 自定义 Map 逻辑, 将第一步的结果转换成另外的 Key-Value（**K2和V2**） 对, 输出结果
##### Shuffle 阶段 4 个步骤
3. 对输出的 Key-Value 对进行**分区**
4. 对不同分区的数据按照相同的 Key **排序**
5. (可选) 对分组过的数据初步**规约**, 降低数据的网络拷贝
6. 对数据进行**分组**, 相同 Key 的 Value 放入一个集合中
> 一般情况下，如果对哪个数据字段做分区，就将这个字段作为K2，如果对哪个字段做排序，也作为K2，如果有两个字段分别需要作分区和排序，那就做一个JavaBean当做K2
##### Reduce 阶段 2 个步骤
7. 对多个 Map 任务的结果进行排序以及合并, 编写 Reduce 函数实现自己的逻辑, 对输入的 Key-Value 进行处理, 转为新的 Key-Value（**K3和V3**）输出
8. 设置 OutputFormat 处理并保存 Reduce 输出的 Key-Value 数据
## 3. WordCount
> 需求: 在一堆给定的文本文件中统计输出每一个单词出现的总次数
##### Step 1. 数据格式准备
1. 创建一个新的文件
```shell
cd /export/servers
vim wordcount.txt
```
2. 向其中放入以下内容并保存
```text
hello,world,hadoop
hive,sqoop,flume,hello
kitty,tom,jerry,world
hadoop
```
3. 上传到 HDFS
```shell
hdfs dfs -mkdir /wordcount/
hdfs dfs -put wordcount.txt /wordcount/
```
##### Step 2. Mapper
```java
// key就是K1，行的偏移量
// value就是V1，一行的数据
// 转换后的K2,V2结果形式为：
// hadoop 1
// hadoop 1
// hive 1
// ...
public class WordCountMapper extends Mapper<LongWritable,Text,Text,LongWritable> {
@Override
public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
String line = value.toString();
String[] split = line.split(",");
for (String word : split) {
context.write(new Text(word),new LongWritable(1));
}
}
}
```
##### Step 3. Reducer
```java
// 在reduce操作之前还有一个shuffle操作，将map得到的K2,V2转换为新的K2,V2（K2不变，V2转换成一个集合，集合中的值都是常量1），
// 新的K2,V2的结果形式为：
// hadoop <1,1>
// hive <1>
// ...
//
// reduce操作会将新的K2,V2转换为K3,V3，也就是最终的结果，结果形式为：
// hadoop 2
// hive 1
// ...
public class WordCountReducer extends Reducer<Text,LongWritable,Text,LongWritable> {
/**
* 自定义我们的reduce逻辑
* 所有的key都是我们的单词，所有的values都是我们单词出现的次数
*/
@Override
protected void reduce(Text key, Iterable<LongWritable> values, Context context) throws IOException, InterruptedException {
long count = 0;
for (LongWritable value : values) {
count += value.get();
}
context.write(key,new LongWritable(count));
}
}
```
##### Step 4. 定义主类, 描述 Job 并提交 Job
```java
// 主类的父类及实现接口固定
public class JobMain extends Configured implements Tool {
@Override
public int run(String[] args) throws Exception {
//super.getConf()获取到的就是main函数中的Configuration实例
Job job = Job.getInstance(super.getConf(), JobMain.class.getSimpleName());
//打包到集群上面运行时候，必须要添加以下配置，指定程序的main函数
job.setJarByClass(JobMain.class);
//第一步：读取输入文件解析成key，value对
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job,new Path("hdfs://192.168.52.250:8020/wordcount"));
//第二步：设置我们的mapper类
job.setMapperClass(WordCountMapper.class);
//设置我们map阶段完成之后的输出类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
//第三步，第四步，第五步，第六步，省略（也就是shuffle阶段的4个步骤：分区，排序，规约，分组）
//第七步：设置我们的reduce类
job.setReducerClass(WordCountReducer.class);
//设置我们reduce阶段完成之后的输出类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(LongWritable.class);
//第八步：设置输出类以及输出路径
job.setOutputFormatClass(TextOutputFormat.class);
//输出的目录不能存在，否则会报异常，所以需要判断目录是否存在，存在则主动删除
Path path = new Path("hdfs://192.168.52.250:8020/wordcount_out");
TextOutputFormat.setOutputPath(job, path);
FileSystem fileSystem = FileSystem.get(new URI("hdfs://192.168.52.250:8020"), new Configuration());
if(fileSystem.exist(path)){
fileSystem.delete(path, true);
}
boolean b = job.waitForCompletion(true);
return b?0:1;
}
/**
* 程序main函数的入口类
*/
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
Tool tool = new JobMain();
int run = ToolRunner.run(configuration, tool, args);
System.exit(run);
}
}
```
##### 常见错误
如果遇到如下错误
```text
Caused by: org.apache.hadoop.ipc.RemoteException(org.apache.hadoop.security.AccessControlException): Permission denied: user=admin, access=WRITE, inode="/":root:supergroup:drwxr-xr-x
```
直接将hdfs-site.xml当中的权限关闭即可
```xml
<property>
<name>dfs.permissions</name>
<value>false</value>
</property>
```
最后重启一下 HDFS 集群
##### 小细节
本地运行完成之后，就可以打成jar包放到服务器上面去运行了，实际工作当中，都是将代码打成jar包，开发main方法作为程序的入口，然后放到集群上面去运行
## 4. MapReduce 运行模式
##### 本地运行模式
1. MapReduce 程序是被提交给 LocalJobRunner 在本地以单进程的形式运行
2. 处理的数据及输出结果可以在本地文件系统, 也可以在hdfs上
3. 怎样实现本地运行? 写一个程序, 不要带集群的配置文件, 本质是程序的 `conf` 中是否有 `mapreduce.framework.name=local` 以及 `yarn.resourcemanager.hostname=local` 参数
4. 本地模式非常便于进行业务逻辑的 `Debug`, 只要在 `Eclipse` 中打断点即可
```java
configuration.set("mapreduce.framework.name","local");
configuration.set(" yarn.resourcemanager.hostname","local");
TextInputFormat.addInputPath(job,new Path("file:///F:\\传智播客大数据离线阶段课程资料\\3、大数据离线第三天\\wordcount\\input"));
TextOutputFormat.setOutputPath(job,new Path("file:///F:\\传智播客大数据离线阶段课程资料\\3、大数据离线第三天\\wordcount\\output"));
```
##### 集群运行模式
1. 将 MapReduce 程序提交给 Yarn 集群, 分发到很多的节点上并发执行
2. 处理的数据和输出结果应该位于 HDFS 文件系统
3. 提交集群的实现步骤: 将程序打成JAR包，然后在集群的任意一个节点上用hadoop命令启动
```shell
hadoop jar hadoop_hdfs_operate-1.0-SNAPSHOT.jar cn.itcast.hdfs.demo1.JobMain
```
## 5. MapReduce 分区
在 MapReduce 中, 通过我们指定分区, 会**将同一个分区的数据发送到同一个 Reduce 当中进行处理**
例如: 为了数据的统计, 可以把一批类似的数据发送到同一个 Reduce 当中, 在同一个 Reduce 当中统计相同类型的数据, 就可以实现类似的数据分区和统计等
其实就是相同类型的数据, 有共性的数据, 送到一起去处理。当有多个分区，多个reducer的时候会生成多个最终处理结果文件。
Reduce 当中默认的分区只有一个
##### Step 1. 定义 Mapper
这个 Mapper 程序不做任何逻辑, 也不对 Key-Value 做任何改变, 只是接收数据, 然后往下发送
```java
//K1是行偏移量，V1是一行的数据
//K2是一行的数据，V2是空值
//在进行分区计算的时候的原则：按照哪个字段分区，那就把这个字段包含在K1中
public class MyMapper extends Mapper<LongWritable,Text,Text,NullWritable>{
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
context.write(value,NullWritable.get());
}
}
```
##### Step 2. 自定义 Partitioner
主要的逻辑就在这里, 这也是这个案例的意义, 通过 Partitioner 将数据分发给不同的 Reducer
```java
/**
* 这里的输入类型与我们map阶段的输出类型相同，也就是K2,V2
*/
public class MyPartitioner extends Partitioner<Text,NullWritable>{
/**
* 返回值为分区编号，表示我们的数据要去到哪个分区
* 返回值只是一个分区的标记，标记所有相同的数据去到指定的分区
*/
@Override
public int getPartition(Text text, NullWritable nullWritable, int i) {
String result = text.toString().split("\t")[5];
if (Integer.parseInt(result) > 15){
return 1;
}else{
return 0;
}
}
}
```
##### Step 3. 定义 Reducer 逻辑
这个 Reducer 也不做任何处理, 将数据原封不动的输出即可
```java
public class MyReducer extends Reducer<Text,NullWritable,Text,NullWritable> {
@Override
protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
context.write(key,NullWritable.get());
}
}
```
##### Step 4. Main 入口
```java
public class PartitionMain extends Configured implements Tool {
public static void main(String[] args) throws Exception{
int run = ToolRunner.run(new Configuration(), new PartitionMain(), args);
System.exit(run);
}
@Override
public int run(String[] args) throws Exception {
Job job = Job.getInstance(super.getConf(), PartitionMain.class.getSimpleName());
job.setJarByClass(PartitionMain.class);
job.setInputFormatClass(TextInputFormat.class);
job.setOutputFormatClass(TextOutputFormat.class);
TextInputFormat.addInputPath(job,new Path("hdfs://192.168.52.250:8020/partitioner"));
TextOutputFormat.setOutputPath(job,new Path("hdfs://192.168.52.250:8020/outpartition"));
job.setMapperClass(MyMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
job.setOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
job.setReducerClass(MyReducer.class);
/**
* 设置我们的分区类，以及我们的reducetask的个数，注意reduceTask的个数一定要与我们的
* 分区数保持一致
*/
job.setPartitionerClass(MyPartitioner.class);
job.setNumReduceTasks(2);
boolean b = job.waitForCompletion(true);
return b?0:1;
}
}
```
## 6. MapReduce 中的计数器
计数器是收集作业统计信息的有效手段之一，用于质量控制或应用级统计。计数器还可辅助诊断系统故障。如果需要将日志信息传输到 map 或 reduce 任务， 更好的方法通常是看能否用一个计数器值来记录某一特定事件的发生。对于大型分布式作业而言，使用计数器更为方便。除了因为获取计数器值比输出日志更方便，还有根据计数器值统计特定事件的发生次数要比分析一堆日志文件容易得多。
hadoop内置计数器列表
| **MapReduce任务计数器** | **org.apache.hadoop.mapreduce.TaskCounter** |
| ----------------------- | ------------------------------------------------------------ |
| 文件系统计数器 | org.apache.hadoop.mapreduce.FileSystemCounter |
| FileInputFormat计数器 | org.apache.hadoop.mapreduce.lib.input.FileInputFormatCounter |
| FileOutputFormat计数器 | org.apache.hadoop.mapreduce.lib.output.FileOutputFormatCounter |
| 作业计数器 | org.apache.hadoop.mapreduce.JobCounter |
**每次mapreduce执行完成之后，我们都会看到一些日志记录出来，其中最重要的一些日志记录如下截图**
****
**所有的这些都是MapReduce的计数器的功能，既然MapReduce当中有计数器的功能，我们如何实现自己的计数器？？？**
> **需求：以以上分区代码为案例，统计map接收到的数据记录条数**
##### 第一种方式
**第一种方式定义计数器，通过context上下文对象可以获取我们的计数器，进行记录**
**通过context上下文对象，在map端使用计数器进行统计**
```java
public class PartitionMapper extends Mapper<LongWritable,Text,Text,NullWritable>{
//map方法将K1和V1转为K2和V2
@Override
protected void map(LongWritable key, Text value, Context context) throws Exception{
Counter counter = context.getCounter("MR_COUNT", "MyRecordCounter");
counter.increment(1L);
context.write(value,NullWritable.get());
}
}
```
**运行程序之后就可以看到我们自定义的计数器在map阶段读取了七条数据**
****
##### 第二种方式
**通过enum枚举类型来定义计数器**
统计reduce端数据的输入的key有多少个
```java
public class PartitionerReducer extends Reducer<Text,NullWritable,Text,NullWritable> {
public static enum Counter{
MY_REDUCE_INPUT_RECORDS,MY_REDUCE_INPUT_BYTES
}
@Override
protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
context.getCounter(Counter.MY_REDUCE_INPUT_RECORDS).increment(1L);
context.write(key, NullWritable.get());
}
}
```
****
## 7. MapReduce 排序和序列化
* 序列化 (Serialization) 是指把结构化对象转化为字节流
* 反序列化 (Deserialization) 是序列化的逆过程. 把字节流转为结构化对象. 当要在进程间传递对象或持久化对象的时候, 就需要序列化对象成字节流, 反之当要将接收到或从磁盘读取的字节流转换为对象, 就要进行反序列化
* Java 的序列化 (Serializable) 是一个重量级序列化框架, 一个对象被序列化后, 会附带很多额外的信息 (各种校验信息, header, 继承体系等）, 不便于在网络中高效传输. 所以, Hadoop 自己开发了一套序列化机制(Writable), 精简高效. 不用像 Java 对象类一样传输多层的父子关系, 需要哪个属性就传输哪个属性值, 大大的减少网络传输的开销
* Writable 是 Hadoop 的序列化格式, Hadoop 定义了这样一个 Writable 接口. 一个类要支持可序列化只需实现这个接口即可
* 另外 Writable 有一个子接口是 WritableComparable, WritableComparable 是既可实现序列化, 也可以对key进行比较, 我们这里可以通过自定义 Key 实现 WritableComparable 来实现我们的排序功能，默认是快速排序算法
数据格式如下
```text
a 1
a 9
b 3
a 7
b 8
b 10
a 5
```
要求:
* 第一列按照字典顺序进行排列
* 第一列相同的时候, 第二列按照升序进行排列
解决思路:
* 将 Map 端输出的 `<key,value>` 中的 key 和 value 组合成一个新的 key (newKey), value值不变
* 这里就变成 `<(key,value),value>`, 在针对 newKey 排序的时候, 如果 key 相同, 就再对value进行排序
##### Step 1. 自定义类型和比较器
```java
public class PairWritable implements WritableComparable<PairWritable> {
// 组合key,第一部分是我们第一列，第二部分是我们第二列
private String first;
private int second;
public PairWritable() {
}
public PairWritable(String first, int second) {
this.set(first, second);
}
/**
* 方便设置字段
*/
public void set(String first, int second) {
this.first = first;
this.second = second;
}
/**
* 反序列化
*/
@Override
public void readFields(DataInput input) throws IOException {
this.first = input.readUTF();
this.second = input.readInt();
}
/**
* 序列化
*/
@Override
public void write(DataOutput output) throws IOException {
output.writeUTF(first);
output.writeInt(second);
}
/*
* 重写比较器
*/
public int compareTo(PairWritable o) {
//每次比较都是调用该方法的对象与传递的参数进行比较，说白了就是第一行与第二行比较完了之后的结果与第三行比较，
//得出来的结果再去与第四行比较，依次类推
System.out.println(o.toString());
System.out.println(this.toString());
int comp = this.first.compareTo(o.first);
if (comp != 0) {
return comp;
} else { // 若第一个字段相等，则比较第二个字段
return Integer.valueOf(this.second).compareTo(
Integer.valueOf(o.getSecond()));
}
}
public int getSecond() {
return second;
}
public void setSecond(int second) {
this.second = second;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
@Override
public String toString() {
return "PairWritable{" +
"first='" + first + '\'' +
", second=" + second +
'}';
}
}
```
##### Step 2. Mapper
```java
public class SortMapper extends Mapper<LongWritable,Text,PairWritable,IntWritable> {
private PairWritable mapOutKey = new PairWritable();
private IntWritable mapOutValue = new IntWritable();
@Override
public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
String lineValue = value.toString();
String[] strs = lineValue.split("\t");
//设置组合key和value ==> <(key,value),value>
mapOutKey.set(strs[0], Integer.valueOf(strs[1]));
mapOutValue.set(Integer.valueOf(strs[1]));
context.write(mapOutKey, mapOutValue);
}
}
```
##### Step 3. Reducer
```java
public class SortReducer extends Reducer<PairWritable,IntWritable,Text,IntWritable> {
private Text outPutKey = new Text();
@Override
public void reduce(PairWritable key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
//迭代输出
for(IntWritable value : values) {
outPutKey.set(key.getFirst());
context.write(outPutKey, value);
}
}
}
```
##### Step 4. Main 入口
```java
public class SecondarySort extends Configured implements Tool {
@Override
public int run(String[] args) throws Exception {
Configuration conf = super.getConf();
conf.set("mapreduce.framework.name","local");
Job job = Job.getInstance(conf, SecondarySort.class.getSimpleName());
job.setJarByClass(SecondarySort.class);
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job,new Path("file:///L:\\大数据离线阶段备课教案以及资料文档——by老王\\4、大数据离线第四天\\排序\\input"));
TextOutputFormat.setOutputPath(job,new Path("file:///L:\\大数据离线阶段备课教案以及资料文档——by老王\\4、大数据离线第四天\\排序\\output"));
job.setMapperClass(SortMapper.class);
job.setMapOutputKeyClass(PairWritable.class);
job.setMapOutputValueClass(IntWritable.class);
job.setReducerClass(SortReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
boolean b = job.waitForCompletion(true);
return b?0:1;
}
public static void main(String[] args) throws Exception {
Configuration entries = new Configuration();
ToolRunner.run(entries,new SecondarySort(),args);
}
}
```
## 规约Combiner
##### 概念
每一个 map 都可能会产生大量的本地输出，Combiner 的作用就是对 map 端的输出先做一次合并，以减少在 map 和 reduce 节点之间的数据传输量，以提高网络IO 性能，是 MapReduce 的一种优化手段之一
- combiner 是 MR 程序中 Mapper 和 Reducer 之外的一种组件
- combiner 组件的父类就是 Reducer
- combiner 和 reducer 的区别在于运行的位置
- Combiner 是在每一个 maptask 所在的节点运行
- Reducer 是接收全局所有 Mapper 的输出结果
- combiner 的意义就是对每一个 maptask 的输出进行局部汇总，以减小网络传输量
##### 实现步骤
1. 自定义一个 combiner 继承 Reducer，重写 reduce 方法
2. 在 job 中设置 `job.setCombinerClass(CustomCombiner.class)`
combiner 能够应用的前提是不能影响最终的业务逻辑，而且，combiner 的输出 kv 应该跟 reducer 的输入 kv 类型要对应起来
## MapReduce案例-流量统计
### 需求一: 统计求和
统计每个手机号的上行数据包总和，下行数据包总和，上行总流量之和，下行总流量之和
分析：以手机号码作为key值，上行流量，下行流量，上行总流量，下行总流量四个字段作为value值，然后以这个key，和value作为map阶段的输出，reduce阶段的输入
##### Step 1: 自定义map的输出value对象FlowBean
```java
public class FlowBean implements Writable {
private Integer upFlow;
private Integer downFlow;
private Integer upCountFlow;
private Integer downCountFlow;
@Override
public void write(DataOutput out) throws IOException {
out.writeInt(upFlow);
out.writeInt(downFlow);
out.writeInt(upCountFlow);
out.writeInt(downCountFlow);
}
@Override
public void readFields(DataInput in) throws IOException {
this.upFlow = in.readInt();
this.downFlow = in.readInt();
this.upCountFlow = in.readInt();
this.downCountFlow = in.readInt();
}
public FlowBean() {
}
public FlowBean(Integer upFlow, Integer downFlow, Integer upCountFlow, Integer downCountFlow) {
this.upFlow = upFlow;
this.downFlow = downFlow;
this.upCountFlow = upCountFlow;
this.downCountFlow = downCountFlow;
}
public Integer getUpFlow() {
return upFlow;
}
public void setUpFlow(Integer upFlow) {
this.upFlow = upFlow;
}
public Integer getDownFlow() {
return downFlow;
}
public void setDownFlow(Integer downFlow) {
this.downFlow = downFlow;
}
public Integer getUpCountFlow() {
return upCountFlow;
}
public void setUpCountFlow(Integer upCountFlow) {
this.upCountFlow = upCountFlow;
}
public Integer getDownCountFlow() {
return downCountFlow;
}
public void setDownCountFlow(Integer downCountFlow) {
this.downCountFlow = downCountFlow;
}
@Override
public String toString() {
return "FlowBean{" +
"upFlow=" + upFlow +
", downFlow=" + downFlow +
", upCountFlow=" + upCountFlow +
", downCountFlow=" + downCountFlow +
'}';
}
}
```
##### Step 2: 定义FlowMapper类
```java
public class FlowCountMapper extends Mapper<LongWritable,Text,Text,FlowBean> {
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//1:拆分手机号
String[] split = value.toString().split("\t");
String phoneNum = split[1];
//2:获取四个流量字段
FlowBean flowBean = new FlowBean();
flowBean.setUpFlow(Integer.parseInt(split[6]));
flowBean.setDownFlow(Integer.parseInt(split[7]));
flowBean.setUpCountFlow(Integer.parseInt(split[8]));
flowBean.setDownCountFlow(Integer.parseInt(split[9]));
//3:将k2和v2写入上下文中
context.write(new Text(phoneNum), flowBean);
}
}
```
##### Step 3: 定义FlowReducer类
```java
public class FlowCountReducer extends Reducer<Text,FlowBean,Text,FlowBean> {
@Override
protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
//封装新的FlowBean
FlowBean flowBean = new FlowBean();
Integer upFlow = 0;
Integer downFlow = 0;
Integer upCountFlow = 0;
Integer downCountFlow = 0;
for (FlowBean value : values) {
upFlow += value.getUpFlow();
downFlow += value.getDownFlow();
upCountFlow += value.getUpCountFlow();
downCountFlow += value.getDownCountFlow();
}
flowBean.setUpFlow(upFlow);
flowBean.setDownFlow(downFlow);
flowBean.setUpCountFlow(upCountFlow);
flowBean.setDownCountFlow(downCountFlow);
//将K3和V3写入上下文中
context.write(key, flowBean);
}
}
```
##### Step 4: 程序main函数入口FlowMain
```java
public class JobMain extends Configured implements Tool {
//该方法用于指定一个job任务
@Override
public int run(String[] args) throws Exception {
//1:创建一个job任务对象
Job job = Job.getInstance(super.getConf(), "mapreduce_flowcount");
//如果打包运行出错，则需要加该配置
job.setJarByClass(JobMain.class);
//2:配置job任务对象(八个步骤)
//第一步:指定文件的读取方式和读取路径
job.setInputFormatClass(TextInputFormat.class);
//TextInputFormat.addInputPath(job, new Path("hdfs://node01:8020/wordcount"));
TextInputFormat.addInputPath(job, new Path("file:///D:\\input\\flowcount_input"));
//第二步:指定Map阶段的处理方式和数据类型
job.setMapperClass(FlowCountMapper.class);
//设置Map阶段K2的类型
job.setMapOutputKeyClass(Text.class);
//设置Map阶段V2的类型
job.setMapOutputValueClass(FlowBean.class);
//第三（分区），四 （排序）
//第五步: 规约(Combiner)
//第六步 分组
//第七步：指定Reduce阶段的处理方式和数据类型
job.setReducerClass(FlowCountReducer.class);
//设置K3的类型
job.setOutputKeyClass(Text.class);
//设置V3的类型
job.setOutputValueClass(FlowBean.class);
//第八步: 设置输出类型
job.setOutputFormatClass(TextOutputFormat.class);
//设置输出的路径
TextOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\flowcount_out"));
//等待任务结束
boolean bl = job.waitForCompletion(true);
return bl ? 0:1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
//启动job任务
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
```
### 需求二: 上行流量倒序排序（递减排序）
分析，以需求一的输出数据作为排序的输入数据，自定义FlowBean,以FlowBean为map输出的key，以手机号作为Map输出的value，因为MapReduce程序会对Map阶段输出的key进行排序
##### Step 1: 定义FlowBean实现WritableComparable实现比较排序
Java 的 compareTo 方法说明:
- compareTo 方法用于将当前对象与方法的参数进行比较。
- 如果指定的数与参数相等返回 0。
- 如果指定的数小于参数返回 -1。
- 如果指定的数大于参数返回 1。
例如：`o1.compareTo(o2);` 返回正数的话，当前对象（调用 compareTo 方法的对象 o1）要排在比较对象（compareTo 传参对象 o2）后面，返回负数的话，放在前面
~~~java
public class FlowBean implements WritableComparable<FlowBean> {
private Integer upFlow;
private Integer downFlow;
private Integer upCountFlow;
private Integer downCountFlow;
public FlowBean() {
}
public FlowBean(Integer upFlow, Integer downFlow, Integer upCountFlow, Integer downCountFlow) {
this.upFlow = upFlow;
this.downFlow = downFlow;
this.upCountFlow = upCountFlow;
this.downCountFlow = downCountFlow;
}
@Override
public void write(DataOutput out) throws IOException {
out.writeInt(upFlow);
out.writeInt(downFlow);
out.writeInt(upCountFlow);
out.writeInt(downCountFlow);
}
@Override
public void readFields(DataInput in) throws IOException {
upFlow = in.readInt();
downFlow = in.readInt();
upCountFlow = in.readInt();
downCountFlow = in.readInt();
}
public Integer getUpFlow() {
return upFlow;
}
public void setUpFlow(Integer upFlow) {
this.upFlow = upFlow;
}
public Integer getDownFlow() {
return downFlow;
}
public void setDownFlow(Integer downFlow) {
this.downFlow = downFlow;
}
public Integer getUpCountFlow() {
return upCountFlow;
}
public void setUpCountFlow(Integer upCountFlow) {
this.upCountFlow = upCountFlow;
}
public Integer getDownCountFlow() {
return downCountFlow;
}
public void setDownCountFlow(Integer downCountFlow) {
this.downCountFlow = downCountFlow;
}
@Override
public String toString() {
return upFlow+"\t"+downFlow+"\t"+upCountFlow+"\t"+downCountFlow;
}
@Override
public int compareTo(FlowBean o) {
return this.upCountFlow > o.upCountFlow ?-1:1;
}
}
~~~
##### Step 2: 定义FlowMapper
```java
public class FlowCountSortMapper extends Mapper<LongWritable,Text,FlowBean,Text> {
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
FlowBean flowBean = new FlowBean();
String[] split = value.toString().split("\t");
//获取手机号，作为V2
String phoneNum = split[0];
//获取其他流量字段,封装flowBean，作为K2
flowBean.setUpFlow(Integer.parseInt(split[1]));
flowBean.setDownFlow(Integer.parseInt(split[2]));
flowBean.setUpCountFlow(Integer.parseInt(split[3]));
flowBean.setDownCountFlow(Integer.parseInt(split[4]));
//将K2和V2写入上下文中
context.write(flowBean, new Text(phoneNum));
}
}
```
##### Step 3: 定义FlowReducer
```java
public class FlowCountSortReducer extends Reducer<FlowBean,Text,Text,FlowBean> {
@Override
protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
for (Text value : values) {
context.write(value, key);
}
}
}
```
##### Step 4: 程序main函数入口
```java
public class JobMain extends Configured implements Tool {
@Override
public int run(String[] strings) throws Exception {
//创建一个任务对象
Job job = Job.getInstance(super.getConf(), "mapreduce_flowcountsort");
//打包放在集群运行时，需要做一个配置
job.setJarByClass(JobMain.class);
//第一步:设置读取文件的类: K1 和V1
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job, new Path("hdfs://node01:8020/out/flowcount_out"));
//第二步：设置Mapper类
job.setMapperClass(FlowCountSortMapper.class);
//设置Map阶段的输出类型: k2 和V2的类型
job.setMapOutputKeyClass(FlowBean.class);
job.setMapOutputValueClass(Text.class);
//第三,四，五，六步采用默认方式(分区，排序，规约，分组)
//第七步 ：设置文的Reducer类
job.setReducerClass(FlowCountSortReducer.class);
//设置Reduce阶段的输出类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(FlowBean.class);
//设置Reduce的个数
//第八步:设置输出类
job.setOutputFormatClass(TextOutputFormat.class);
//设置输出的路径
TextOutputFormat.setOutputPath(job, new Path("hdfs://node01:8020/out/flowcountsort_out"));
boolean b = job.waitForCompletion(true);
return b?0:1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
//启动一个任务
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
```
### 需求三: 手机号码分区
在需求一的基础上，继续完善，将不同的手机号分到不同的数据文件的当中去，需要自定义分区来实现，这里我们自定义来模拟分区，将以下数字开头的手机号进行分开
```text
135 开头数据到一个分区文件
136 开头数据到一个分区文件
137 开头数据到一个分区文件
其他分区
```
##### 自定义分区
```java
public class FlowPartition extends Partitioner<Text,FlowBean> {
@Override
public int getPartition(Text text, FlowBean flowBean, int i) {
String line = text.toString();
if (line.startsWith("135")){
return 0;
}else if(line.startsWith("136")){
return 1;
}else if(line.startsWith("137")){
return 2;
}else{
return 3;
}
}
}
```
##### 作业运行设置
```java
job.setPartitionerClass(FlowPartition.class);
job.setNumReduceTasks(4);
```
##### 修改输入输出路径, 并放入集群运行
```java
TextInputFormat.addInputPath(job,new Path("hdfs://node01:8020/partition_flow/"));
TextOutputFormat.setOutputPath(job,new Path("hdfs://node01:8020/partition_out"));
```
## MapReduce的运行机制详解
### 1.1:MapTask 工作机制
整个Map阶段流程大体如上图所示。
简单概述：inputFile通过split被逻辑切分为多个split文件，通过Record按行读取内容给map（用户自己实现的）进行处理，数据被map处理结束之后交给OutputCollector收集器，对其结果key进行分区（默认使用hash分区），然后写入buffer，每个map task都有一个内存缓冲区，存储着map的输出结果，当缓冲区快满的时候需要将缓冲区的数据以一个临时文件的方式存放到磁盘，当整个map task结束后再对磁盘中这个map task产生的所有临时文件做合并，生成最终的正式输出文件，然后等待reduce task来拉数据
##### 详细步骤
1. 读取数据组件 **InputFormat** (默认 TextInputFormat) 会通过 `getSplits` 方法对输入目录中文件进行逻辑切片规划得到 `block`, 有多少个 `block`就对应启动多少个 `MapTask`.
2. 将输入文件切分为 `block` 之后, 由 `RecordReader` 对象 (默认是LineRecordReader) 进行**读取**, 以 `\n` 作为分隔符, 读取一行数据, 返回 `<key，value>`. Key 表示每行首字符偏移值, Value 表示这一行文本内容
3. 读取 `block` 返回 `<key,value>`, **进入用户自己继承的 Mapper 类中**，执行用户重写的 map 函数, RecordReader 读取一行这里调用一次
4. Mapper 逻辑结束之后, 将 Mapper 的每条结果通过 `context.write` 进行collect数据收集. 在 collect 中, 会先对其进行分区处理，默认使用 **HashPartitioner**
- > MapReduce 提供 `Partitioner` 接口, 它的作用就是根据 `Key` 或 `Value` 及 `Reducer` 的数量来决定当前的这对输出数据最终应该交由哪个 `Reduce task` 处理, 默认对 Key Hash 后再以 Reducer 数量取模. 默认的取模方式只是为了平均 Reducer 的处理能力, 如果用户自己对 Partitioner 有需求, 可以订制并设置到 Job 上
5. 接下来, 会将数据写入内存, 内存中这片区域叫做环形缓冲区, 缓冲区的作用是批量收集 Mapper 结果, 减少磁盘 IO 的影响. 我们的 **Key/Value 对以及 Partition 的结果都会被写入缓冲区**. 当然, 写入之前，Key 与 Value 值都会被序列化成字节数组
- > 环形缓冲区其实是一个数组, 数组中存放着 Key, Value 的序列化数据和 Key, Value 的元数据信息, 包括 Partition, Key 的起始位置, Value 的起始位置以及 Value 的长度. 环形结构是一个抽象概念
- > 缓冲区是有大小限制, 默认是 100MB. 当 Mapper 的输出结果很多时, 就可能会撑爆内存, 所以需要在一定条件下将缓冲区中的数据临时写入磁盘, 然后重新利用这块缓冲区. 这个从内存往磁盘写数据的过程被称为 Spill, 中文可译为溢写. 这个溢写是由单独线程来完成, 不影响往缓冲区写 Mapper 结果的线程. 溢写线程启动时不应该阻止 Mapper 的结果输出, 所以整个缓冲区有个溢写的比例 `spill.percent`. 这个比例默认是 0.8, 也就是当缓冲区的数据已经达到阈值 `buffer size * spill percent = 100MB * 0.8 = 80MB`, 溢写线程启动, 锁定这 80MB 的内存, 执行溢写过程. Mapper 的输出结果还可以往剩下的 20MB 内存中写, 互不影响
6. 当溢写线程启动后, 需要**对这 80MB 空间内的 Key 做排序 (Sort)**. 排序是 MapReduce 模型默认的行为, 这里的排序也是对序列化的字节做的排序
- > 如果 Job 设置过 Combiner, 那么现在就是使用 Combiner 的时候了. 将有相同 Key 的 Key/Value 对的 Value 加起来, 减少溢写到磁盘的数据量. Combiner 会优化 MapReduce 的中间结果, 所以它在整个模型中会多次使用
- > 那哪些场景才能使用 Combiner 呢? 从这里分析, Combiner 的输出是 Reducer 的输入, Combiner 绝不能改变最终的计算结果. Combiner 只应该用于那种 Reduce 的输入 Key/Value 与输出 Key/Value 类型完全一致, 且不影响最终结果的场景. 比如累加, 最大值等. Combiner 的使用一定得慎重, 如果用好, 它对 Job 执行效率有帮助, 反之会影响 Reducer 的最终结果
7. **合并溢写文件**, 每次溢写会在磁盘上生成一个临时文件 (写之前判断是否有 Combiner), 如果 Mapper 的输出结果真的很大, 有多次这样的溢写发生, 磁盘上相应的就会有多个临时文件存在. 当整个数据处理结束之后开始对磁盘中的临时文件进行 Merge 合并, 因为最终的文件只有一个, 写入磁盘, 并且为这个文件提供了一个索引文件, 以记录每个reduce对应数据的偏移量
##### 配置
| 配置 | 默认值 | 解释 |
| ---------------------------------- | -------------------------------- | -------------------------- |
| `mapreduce.task.io.sort.mb` | 100 | 设置环型缓冲区的内存值大小 |
| `mapreduce.map.sort.spill.percent` | 0.8 | 设置溢写的比例 |
| `mapreduce.cluster.local.dir` | `${hadoop.tmp.dir}/mapred/local` | 溢写数据目录 |
| `mapreduce.task.io.sort.factor` | 10 | 设置一次合并多少个溢写文件 |
### 1.2 :ReduceTask 工作机制
Picture3.png
Reduce 大致分为 copy、sort、reduce 三个阶段，重点在前两个阶段。copy 阶段包含一个 eventFetcher 来获取已完成的 map 列表，由 Fetcher 线程去 copy 数据，在此过程中会启动两个 merge 线程，分别为 inMemoryMerger 和 onDiskMerger，分别将内存中的数据 merge 到磁盘和将磁盘中的数据进行 merge。待数据 copy 完成之后，copy 阶段就完成了，开始进行 sort 阶段，sort 阶段主要是执行 finalMerge 操作，纯粹的 sort 阶段，完成之后就是 reduce 阶段，调用用户定义的 reduce 函数进行处理
##### 详细步骤
1. **`Copy阶段`**，简单地拉取数据。Reduce进程启动一些数据copy线程(Fetcher)，通过HTTP方式请求maptask获取属于自己的文件。
2. **`Merge阶段`**。这里的merge如map端的merge动作，只是数组中存放的是不同map端copy来的数值。Copy过来的数据会先放入内存缓冲区中，这里的缓冲区大小要比map端的更为灵活。merge有三种形式：内存到内存；内存到磁盘；磁盘到磁盘。默认情况下第一种形式不启用。当内存中的数据量到达一定阈值，就启动内存到磁盘的merge。与map 端类似，这也是溢写的过程，这个过程中如果你设置有Combiner，也是会启用的，然后在磁盘中生成了众多的溢写文件。第二种merge方式一直在运行，直到没有map端的数据时才结束，然后启动第三种磁盘到磁盘的merge方式生成最终的文件。
3. **`合并排序`**。把分散的数据合并成一个大的数据后，还会再对合并后的数据排序。
4. **`对排序后的键值对调用reduce方法`**，键相等的键值对调用一次reduce方法，每次调用会产生零个或者多个键值对，最后把这些输出的键值对写入到HDFS文件中。
### 1.3:Shuffle 过程
map 阶段处理的数据如何传递给 reduce 阶段，是 MapReduce 框架中最关键的一个流程，这个流程就叫 shuffle
shuffle: 洗牌、发牌 ——（核心机制：数据分区，排序，分组，规约，合并等过程）
Picture4.png
shuffle 是 Mapreduce 的核心，它分布在 Mapreduce 的 map 阶段和 reduce 阶段。一般把从 Map 产生输出开始到 Reduce 取得数据作为输入之前的过程称作 shuffle。
1. **`Collect阶段`**：将 MapTask 的结果输出到默认大小为 100M 的环形缓冲区，保存的是 key/value，Partition 分区信息等。
2. **`Spill阶段`**：当内存中的数据量达到一定的阀值的时候，就会将数据写入本地磁盘，在将数据写入磁盘之前需要对数据进行一次排序的操作，如果配置了 combiner，还会将有相同分区号和 key 的数据进行排序。
3. **`Merge阶段`**：把所有溢出的临时文件进行一次合并操作，以确保一个 MapTask 最终只产生一个中间数据文件。
4. **`Copy阶段`**：ReduceTask 启动 Fetcher 线程到已经完成 MapTask 的节点上复制一份属于自己的数据，这些数据默认会保存在内存的缓冲区中，当内存的缓冲区达到一定的阀值的时候，就会将数据写到磁盘之上。
5. **`Merge阶段`**：在 ReduceTask 远程复制数据的同时，会在后台开启两个线程对内存到本地的数据文件进行合并操作。
6. **`Sort阶段`**：在对数据进行合并的同时，会进行排序操作，由于 MapTask 阶段已经对数据进行了局部的排序，ReduceTask 只需保证 Copy 的数据的最终整体有效性即可。
Shuffle 中的缓冲区大小会影响到 mapreduce 程序的执行效率，原则上说，缓冲区越大，磁盘io的次数越少，执行速度就越快
缓冲区的大小可以通过参数调整, 参数：mapreduce.task.io.sort.mb 默认100M
## 案例: Reduce 端实现 JOIN
### 2.1. 需求
> 假如数据量巨大，两表的数据是以文件的形式存储在 HDFS 中, 需要用 MapReduce 程序来实现以下 SQL 查询运算
>
> ```sql
> select a.id,a.date,b.name,b.category_id,b.price from t_order a left join t_product b on a.pid = b.id
> ```
##### 商品表
| id | pname | category_id | price |
| ----- | ------ | ----------- | ----- |
| P0001 | 小米5 | 1000 | 2000 |
| P0002 | 锤子T1 | 1000 | 3000 |
##### 订单数据表
| id | date | pid | amount |
| ---- | -------- | ----- | ------ |
| 1001 | 20150710 | P0001 | 2 |
| 1002 | 20150710 | P0002 | 3 |
### 2.2 实现步骤
通过将关联的条件作为map输出的key，将两表满足join条件的数据并携带数据所来源的文件信息，发往同一个reduce task，在reduce中进行数据的串联
#### Step 1: 定义 Mapper
```java
public class ReduceJoinMapper extends Mapper<LongWritable,Text,Text,Text> {
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//1:判断数据来自哪个文件
FileSplit fileSplit = (FileSplit) context.getInputSplit();
String fileName = fileSplit.getPath().getName();
if(fileName.equals("product.txt")){
//数据来自商品表
//2:将K1和V1转为K2和V2,写入上下文中
String[] split = value.toString().split(",");
String productId = split[0];
context.write(new Text(productId), value);
}else{
//数据来自订单表
//2:将K1和V1转为K2和V2,写入上下文中
String[] split = value.toString().split(",");
String productId = split[2];
context.write(new Text(productId), value);
}
}
}
```
#### Step 2: 定义 Reducer
```java
public class ReduceJoinMapper extends Mapper<LongWritable,Text,Text,Text> {
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//1:判断数据来自哪个文件
FileSplit fileSplit = (FileSplit) context.getInputSplit();
String fileName = fileSplit.getPath().getName();
if(fileName.equals("product.txt")){
//数据来自商品表
//2:将K1和V1转为K2和V2,写入上下文中
String[] split = value.toString().split(",");
String productId = split[0];
context.write(new Text(productId), value);
}else{
//数据来自订单表
//2:将K1和V1转为K2和V2,写入上下文中
String[] split = value.toString().split(",");
String productId = split[2];
context.write(new Text(productId), value);
}
}
}
```
#### Step 3: 定义主类
```java
public class ReduceJoinReducer extends Reducer<Text,Text,Text,Text> {
@Override
protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
//1:遍历集合,获取V3 (first +second)
String first = "";
String second = "";
for (Text value : values) {
if(value.toString().startsWith("p")){
first = value.toString();
}else{
second += value.toString();
}
}
//2:将K3和V3写入上下文中
context.write(key, new Text(first+"\t"+second));
}
}
```
## 案例: Map端实现 JOIN
#### 3.1 概述
适用于关联表中有小表的情形.
使用分布式缓存,可以将小表分发到所有的map节点，这样，map节点就可以在本地对自己所读到的大表数据进行join并输出最终结果，可以大大提高join操作的并发度，加快处理速度
#### 3.2 实现步骤
先在mapper类中预先定义好小表，进行join
引入实际场景中的解决方案：一次加载数据库或者用
##### Step 1：定义Mapper
~~~java
public class MapJoinMapper extends Mapper<LongWritable,Text,Text,Text>{
private HashMap<String, String> map = new HashMap<>();
//第一件事情:将分布式缓存的小表数据读取到本地Map集合(只需要做一次)
@Override
protected void setup(Context context) throws IOException, InterruptedException {
//1:获取分布式缓存文件列表
URI[] cacheFiles = context.getCacheFiles();
//2:获取指定的分布式缓存文件的文件系统(FileSystem)
FileSystem fileSystem = FileSystem.get(cacheFiles[0], context.getConfiguration());
//3:获取文件的输入流
FSDataInputStream inputStream = fileSystem.open(new Path(cacheFiles[0]));
//4:读取文件内容, 并将数据存入Map集合
//4.1 将字节输入流转为字符缓冲流FSDataInputStream --->BufferedReader
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
//4.2 读取小表文件内容,以行位单位,并将读取的数据存入map集合
String line = null;
while((line = bufferedReader.readLine()) != null){
String[] split = line.split(",");
map.put(split[0], line);
}
//5:关闭流
bufferedReader.close();
fileSystem.close();
}
//第二件事情:对大表的处理业务逻辑,而且要实现大表和小表的join操作
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//1:从行文本数据中获取商品的id: p0001 , p0002 得到了K2
String[] split = value.toString().split(",");
String productId = split[2]; //K2
//2:在Map集合中,将商品的id作为键,获取值(商品的行文本数据) ,将value和值拼接,得到V2
String productLine = map.get(productId);
String valueLine = productLine+"\t"+value.toString(); //V2
//3:将K2和V2写入上下文中
context.write(new Text(productId), new Text(valueLine));
}
}
~~~
##### Step 2：定义主类
~~~java
public class JobMain extends Configured implements Tool{
@Override
public int run(String[] args) throws Exception {
//1:获取job对象
Job job = Job.getInstance(super.getConf(), "map_join_job");
//2:设置job对象(将小表放在分布式缓存中)
//将小表放在分布式缓存中
// DistributedCache.addCacheFile(new URI("hdfs://node01:8020/cache_file/product.txt"), super.getConf());
job.addCacheFile(new URI("hdfs://node01:8020/cache_file/product.txt"));
//第一步:设置输入类和输入的路径
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job, new Path("file:///D:\\input\\map_join_input"));
//第二步:设置Mapper类和数据类型
job.setMapperClass(MapJoinMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
//第八步:设置输出类和输出路径
job.setOutputFormatClass(TextOutputFormat.class);
TextOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\map_join_out"));
//3:等待任务结束
boolean bl = job.waitForCompletion(true);
return bl ? 0 :1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
//启动job任务
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
~~~
## 案例:求共同好友
### 4.1 需求分析
以下是qq的好友列表数据，冒号前是一个用户，冒号后是该用户的所有好友（数据中的好友关系是单向的）
~~~java
A:B,C,D,F,E,O
B:A,C,E,K
C:A,B,D,E,I
D:A,E,F,L
E:B,C,D,M,L
F:A,B,C,D,E,O,M
G:A,C,D,E,F
H:A,C,D,E,O
I:A,O
J:B,O
K:A,C,D
L:D,E,F
M:E,F,G
O:A,H,I,J
~~~
求出哪些人两两之间有共同好友，及他俩的共同好友都有谁？
### 4.2 实现步骤
##### 第一步：代码实现
**Mapper类**
~~~java
public class Step1Mapper extends Mapper<LongWritable,Text,Text,Text> {
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//1:以冒号拆分行文本数据: 冒号左边就是V2
String[] split = value.toString().split(":");
String userStr = split[0];
//2:将冒号右边的字符串以逗号拆分,每个成员就是K2
String[] split1 = split[1].split(",");
for (String s : split1) {
//3:将K2和v2写入上下文中
context.write(new Text(s), new Text(userStr));
}
}
}
~~~
**Reducer类:**
~~~java
public class Step1Reducer extends Reducer<Text,Text,Text,Text> {
@Override
protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
//1:遍历集合,并将每一个元素拼接,得到K3
StringBuffer buffer = new StringBuffer();
for (Text value : values) {
buffer.append(value.toString()).append("-");
}
//2:K2就是V3
//3:将K3和V3写入上下文中
context.write(new Text(buffer.toString()), key);
}
}
~~~
**JobMain:**
~~~java
public class JobMain extends Configured implements Tool {
@Override
public int run(String[] args) throws Exception {
//1:获取Job对象
Job job = Job.getInstance(super.getConf(), "common_friends_step1_job");
//2:设置job任务
//第一步:设置输入类和输入路径
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job, new Path("file:///D:\\input\\common_friends_step1_input"));
//第二步:设置Mapper类和数据类型
job.setMapperClass(Step1Mapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
//第三,四,五,六
//第七步:设置Reducer类和数据类型
job.setReducerClass(Step1Reducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
//第八步:设置输出类和输出的路径
job.setOutputFormatClass(TextOutputFormat.class);
TextOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\common_friends_step1_out"));
//3:等待job任务结束
boolean bl = job.waitForCompletion(true);
return bl ? 0: 1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
//启动job任务
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
~~~
##### 第二步：代码实现
**Mapper类**
```java
public class Step2Mapper extends Mapper<LongWritable,Text,Text,Text> {
/*
K1 V1
0 A-F-C-J-E- B
----------------------------------
K2 V2
A-C B
A-E B
A-F B
C-E B
*/
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//1:拆分行文本数据,结果的第二部分可以得到V2
String[] split = value.toString().split("\t");
String friendStr =split[1];
//2:继续以'-'为分隔符拆分行文本数据第一部分,得到数组
String[] userArray = split[0].split("-");
//3:对数组做一个排序
Arrays.sort(userArray);
//4:对数组中的元素进行两两组合,得到K2
/*
A-E-C -----> A C E
A C E
A C E
*/
for (int i = 0; i <userArray.length -1 ; i++) {
for (int j = i+1; j < userArray.length ; j++) {
//5:将K2和V2写入上下文中
context.write(new Text(userArray[i] +"-"+userArray[j]), new Text(friendStr));
}
}
}
}
```
**Reducer类:**
```java
public class Step2Reducer extends Reducer<Text,Text,Text,Text> {
@Override
protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
//1:原来的K2就是K3
//2:将集合进行遍历,将集合中的元素拼接,得到V3
StringBuffer buffer = new StringBuffer();
for (Text value : values) {
buffer.append(value.toString()).append("-");
}
//3:将K3和V3写入上下文中
context.write(key, new Text(buffer.toString()));
}
}
```
**JobMain:**
```java
public class JobMain extends Configured implements Tool {
@Override
public int run(String[] args) throws Exception {
//1:获取Job对象
Job job = Job.getInstance(super.getConf(), "common_friends_step2_job");
//2:设置job任务
//第一步:设置输入类和输入路径
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job, new Path("file:///D:\\out\\common_friends_step1_out"));
//第二步:设置Mapper类和数据类型
job.setMapperClass(Step2Mapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
//第三,四,五,六
//第七步:设置Reducer类和数据类型
job.setReducerClass(Step2Reducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
//第八步:设置输出类和输出的路径
job.setOutputFormatClass(TextOutputFormat.class);
TextOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\common_friends_step2_out"));
//3:等待job任务结束
boolean bl = job.waitForCompletion(true);
return bl ? 0: 1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
//启动job任务
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
```
# 案例：自定义InputFormat、OutputFormat，自定义分组
## 1. 自定义InputFormat合并小文件
### **1.1 需求**
无论hdfs还是mapreduce，对于小文件都有损效率，实践中，又难免面临处理大量小文件的场景，此时，就需要有相应解决方案
### **1.2 分析**
小文件的优化无非以下几种方式：
1、 在数据采集的时候，就将小文件或小批数据合成大文件再上传HDFS
2、 在业务处理之前，在HDFS上使用mapreduce程序对小文件进行合并
3、 在mapreduce处理时，可采用combineInputFormat提高效率
### **1.3 实现**
本节实现的是上述第二种方式
程序的核心机制：
自定义一个InputFormat
改写RecordReader，实现一次读取一个完整文件封装为KV
在输出时使用SequenceFileOutPutFormat输出合并文件
代码如下：
#### **自定义InputFromat**
~~~java
public class MyInputFormat extends FileInputFormat<NullWritable,BytesWritable> {
@Override
public RecordReader<NullWritable, BytesWritable> createRecordReader(InputSplit inputSplit, TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
//1:创建自定义RecordReader对象
MyRecordReader myRecordReader = new MyRecordReader();
//2:将inputSplit和context对象传给MyRecordReader
myRecordReader.initialize(inputSplit, taskAttemptContext);
return myRecordReader;
}
/*
设置文件是否可以被切割
*/
@Override
protected boolean isSplitable(JobContext context, Path filename) {
return false;
}
}
~~~
#### **自定义**RecordReader
~~~java
public class MyRecordReader extends RecordReader<NullWritable,BytesWritable>{
private Configuration configuration = null;
private FileSplit fileSplit = null;
private boolean processed = false;
private BytesWritable bytesWritable = new BytesWritable();
private FileSystem fileSystem = null;
private FSDataInputStream inputStream = null;
//进行初始化工作
@Override
public void initialize(InputSplit inputSplit, TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
//获取文件的切片
fileSplit= (FileSplit)inputSplit;
//获取Configuration对象
configuration = taskAttemptContext.getConfiguration();
}
//该方法用于获取K1和V1
/*
K1: NullWritable
V1: BytesWritable
*/
@Override
public boolean nextKeyValue() throws IOException, InterruptedException {
if(!processed){
//1:获取源文件的字节输入流
//1.1 获取源文件的文件系统 (FileSystem)
fileSystem = FileSystem.get(configuration);
//1.2 通过FileSystem获取文件字节输入流
inputStream = fileSystem.open(fileSplit.getPath());
//2:读取源文件数据到普通的字节数组(byte[])
byte[] bytes = new byte[(int) fileSplit.getLength()];
IOUtils.readFully(inputStream, bytes, 0, (int)fileSplit.getLength());
//3:将字节数组中数据封装到BytesWritable ,得到v1
bytesWritable.set(bytes, 0, (int)fileSplit.getLength());
processed = true;
return true;
}
return false;
}
//返回K1
@Override
public NullWritable getCurrentKey() throws IOException, InterruptedException {
return NullWritable.get();
}
//返回V1
@Override
public BytesWritable getCurrentValue() throws IOException, InterruptedException {
return bytesWritable;
}
//获取文件读取的进度
@Override
public float getProgress() throws IOException, InterruptedException {
return 0;
}
//进行资源释放
@Override
public void close() throws IOException {
inputStream.close();
fileSystem.close();
}
}
~~~
#### Mapper类:
~~~java
public class SequenceFileMapper extends Mapper<NullWritable,BytesWritable,Text,BytesWritable> {
@Override
protected void map(NullWritable key, BytesWritable value, Context context) throws IOException, InterruptedException {
//1:获取文件的名字,作为K2
FileSplit fileSplit = (FileSplit) context.getInputSplit();
String fileName = fileSplit.getPath().getName();
//2:将K2和V2写入上下文中
context.write(new Text(fileName), value);
}
}
~~~
#### 主类:
~~~java
public class JobMain extends Configured implements Tool {
@Override
public int run(String[] args) throws Exception {
//1:获取job对象
Job job = Job.getInstance(super.getConf(), "sequence_file_job");
//2:设置job任务
//第一步:设置输入类和输入的路径
job.setInputFormatClass(MyInputFormat.class);
MyInputFormat.addInputPath(job, new Path("file:///D:\\input\\myInputformat_input"));
//第二步:设置Mapper类和数据类型
job.setMapperClass(SequenceFileMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(BytesWritable.class);
//第七步: 不需要设置Reducer类,但是必须设置数据类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(BytesWritable.class);
//第八步:设置输出类和输出的路径
job.setOutputFormatClass(SequenceFileOutputFormat.class);
SequenceFileOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\myinputformat_out"));
//3:等待job任务执行结束
boolean bl = job.waitForCompletion(true);
return bl ? 0 : 1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
~~~
## 2. 自定义outputFormat
### **2.1** **需求**
现在有一些订单的评论数据，需求，将订单的好评与差评进行区分开来，将最终的数据分开到不同的文件夹下面去，数据内容参见资料文件夹，其中数据第九个字段表示好评，中评，差评。0：好评，1：中评，2：差评
### **2.2 分析**
程序的关键点是要在一个mapreduce程序中根据数据的不同输出两类结果到不同目录，这类灵活的输出需求可以通过自定义outputformat来实现
### **2.3 实现**
实现要点：
1、 在mapreduce中访问外部资源
2、 自定义outputformat，改写其中的recordwriter，改写具体输出数据的方法write()
#### **第一步**：自定义MyOutputFormat
**MyOutputFormat类:**
~~~java
public class MyOutputFormat extends FileOutputFormat<Text,NullWritable> {
@Override
public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
//1:获取目标文件的输出流(两个)
FileSystem fileSystem = FileSystem.get(taskAttemptContext.getConfiguration());
FSDataOutputStream goodCommentsOutputStream = fileSystem.create(new Path("file:///D:\\out\\good_comments\\good_comments.txt"));
FSDataOutputStream badCommentsOutputStream = fileSystem.create(new Path("file:///D:\\out\\bad_comments\\bad_comments.txt"));
//2:将输出流传给MyRecordWriter
MyRecordWriter myRecordWriter = new MyRecordWriter(goodCommentsOutputStream,badCommentsOutputStream);
return myRecordWriter;
}
}
~~~
**MyRecordReader类:**
~~~java
public class MyRecordWriter extends RecordWriter<Text,NullWritable> {
private FSDataOutputStream goodCommentsOutputStream;
private FSDataOutputStream badCommentsOutputStream;
public MyRecordWriter() {
}
public MyRecordWriter(FSDataOutputStream goodCommentsOutputStream, FSDataOutputStream badCommentsOutputStream) {
this.goodCommentsOutputStream = goodCommentsOutputStream;
this.badCommentsOutputStream = badCommentsOutputStream;
}
/**
*
* @param text 行文本内容
* @param nullWritable
* @throws IOException
* @throws InterruptedException
*/
@Override
public void write(Text text, NullWritable nullWritable) throws IOException, InterruptedException {
//1:从行文本数据中获取第9个字段
String[] split = text.toString().split("\t");
String numStr = split[9];
//2:根据字段的值,判断评论的类型,然后将对应的数据写入不同的文件夹文件中
if(Integer.parseInt(numStr) <= 1){
//好评或者中评
goodCommentsOutputStream.write(text.toString().getBytes());
goodCommentsOutputStream.write("\r\n".getBytes());
}else{
//差评
badCommentsOutputStream.write(text.toString().getBytes());
badCommentsOutputStream.write("\r\n".getBytes());
}
}
@Override
public void close(TaskAttemptContext taskAttemptContext) throws IOException, InterruptedException {
IOUtils.closeStream(goodCommentsOutputStream);
IOUtils.closeStream(badCommentsOutputStream);
}
}
~~~
#### **第二步**：自定义Mapper类
~~~java
public class MyOutputFormatMapper extends Mapper<LongWritable,Text,Text,NullWritable> {
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
context.write(value, NullWritable.get());
}
}
~~~
#### 第三步:主类JobMain
~~~java
public class JobMain extends Configured implements Tool {
@Override
public int run(String[] args) throws Exception {
//1:获取job对象
Job job = Job.getInstance(super.getConf(), "myoutputformat_job");
//2:设置job任务
//第一步:设置输入类和输入的路径
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job, new Path("file:///D:\\input\\myoutputformat_input"));
//第二步:设置Mapper类和数据类型
job.setMapperClass(MyOutputFormatMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
//第八步:设置输出类和输出的路径
job.setOutputFormatClass(MyOutputFormat.class);
MyOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\myoutputformat_out"));
//3:等待任务结束
boolean bl = job.waitForCompletion(true);
return bl ? 0 : 1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
~~~
## 3. 自定义分组求取topN
分组是mapreduce当中reduce端的一个功能组件，主要的作用是决定哪些数据作为一组，调用一次reduce的逻辑，默认是每个不同的key，作为多个不同的组，每个组调用一次reduce逻辑，我们可以自定义分组实现不同的key作为同一个组，调用一次reduce逻辑
### **3.1 需求**
有如下订单数据
| 订单id | 商品id | 成交金额 |
| ------------- | ------ | -------- |
| Order_0000001 | Pdt_01 | 222.8 |
| Order_0000001 | Pdt_05 | 25.8 |
| Order_0000002 | Pdt_03 | 522.8 |
| Order_0000002 | Pdt_04 | 122.4 |
| Order_0000002 | Pdt_05 | 722.4 |
| Order_0000003 | Pdt_01 | 222.8 |
现在需要求出每一个订单中成交金额最大的一笔交易
### **3.2 分析**
1、利用“订单id和成交金额”作为key，可以将map阶段读取到的所有订单数据按照id分区，按照金额排序，发送到reduce
2、在reduce端利用分组将订单id相同的kv聚合成组，然后取第一个即是最大值
### **3.3 实现**
#### **第一步:**定义OrderBean
定义一个OrderBean，里面定义两个字段，第一个字段是我们的orderId，第二个字段是我们的金额（注意金额一定要使用Double或者DoubleWritable类型，否则没法按照金额顺序排序）
~~~java
public class OrderBean implements WritableComparable<OrderBean>{
private String orderId;
private Double price;
public String getOrderId() {
return orderId;
}
public void setOrderId(String orderId) {
this.orderId = orderId;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return orderId + "\t" + price;
}
//指定排序规则
@Override
public int compareTo(OrderBean orderBean) {
//先比较订单ID,如果订单ID一致,则排序订单金额(降序)
int i = this.orderId.compareTo(orderBean.orderId);
if(i == 0){
i = this.price.compareTo(orderBean.price) * -1;
}
return i;
}
//实现对象的序列化
@Override
public void write(DataOutput out) throws IOException {
out.writeUTF(orderId);
out.writeDouble(price);
}
//实现对象反序列化
@Override
public void readFields(DataInput in) throws IOException {
this.orderId = in.readUTF();
this.price = in.readDouble();
}
}
~~~
#### 第二步: 定义Mapper类
~~~java
public class GroupMapper extends Mapper<LongWritable,Text,OrderBean,Text> {
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//1:拆分行文本数据,得到订单的ID,订单的金额
String[] split = value.toString().split("\t");
//2:封装OrderBean,得到K2
OrderBean orderBean = new OrderBean();
orderBean.setOrderId(split[0]);
orderBean.setPrice(Double.valueOf(split[2]));
//3:将K2和V2写入上下文中
context.write(orderBean, value);
}
}
~~~
#### **第三步:**自定义分区
自定义分区，按照订单id进行分区，把所有订单id相同的数据，都发送到同一个reduce中去
~~~java
public class OrderPartition extends Partitioner<OrderBean,Text> {
//分区规则: 根据订单的ID实现分区
/**
*
* @param orderBean K2
* @param text V2
* @param i ReduceTask个数
* @return 返回分区的编号
*/
@Override
public int getPartition(OrderBean orderBean, Text text, int i) {
return (orderBean.getOrderId().hashCode() & 2147483647) % i;
}
}
~~~
#### **第四步:**自定义分组
按照我们自己的逻辑进行分组，通过比较相同的订单id，将相同的订单id放到一个组里面去，进过分组之后当中的数据，已经全部是排好序的数据，我们只需要取前topN即可
~~~java
// 1: 继承WriteableComparator
public class OrderGroupComparator extends WritableComparator {
// 2: 调用父类的有参构造
public OrderGroupComparator() {
super(OrderBean.class,true);
}
//3: 指定分组的规则(重写方法)
@Override
public int compare(WritableComparable a, WritableComparable b) {
//3.1 对形参做强制类型转换
OrderBean first = (OrderBean)a;
OrderBean second = (OrderBean)b;
//3.2 指定分组规则
return first.getOrderId().compareTo(second.getOrderId());
}
}
~~~
#### 第五步:定义Reducer类
~~~java
public class GroupReducer extends Reducer<OrderBean,Text,Text,NullWritable> {
@Override
protected void reduce(OrderBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
int i = 0;
//获取集合中的前N条数据
for (Text value : values) {
context.write(value, NullWritable.get());
i++;
if(i >= 1){
break;
}
}
}
}
~~~
#### **第六步:**程序main函数入口
~~~java
public class JobMain extends Configured implements Tool {
@Override
public int run(String[] args) throws Exception {
//1:获取Job对象
Job job = Job.getInstance(super.getConf(), "mygroup_job");
//2:设置job任务
//第一步:设置输入类和输入路径
job.setInputFormatClass(TextInputFormat.class);
TextInputFormat.addInputPath(job, new Path("file:///D:\\input\\mygroup_input"));
//第二步:设置Mapper类和数据类型
job.setMapperClass(GroupMapper.class);
job.setMapOutputKeyClass(OrderBean.class);
job.setMapOutputValueClass(Text.class);
//第三,四,五,六
//设置分区
job.setPartitionerClass(OrderPartition.class);
//设置分组
job.setGroupingComparatorClass(OrderGroupComparator.class);
//第七步:设置Reducer类和数据类型
job.setReducerClass(GroupReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
//第八步:设置输出类和输出的路径
job.setOutputFormatClass(TextOutputFormat.class);
TextOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\mygroup_out"));
//3:等待job任务结束
boolean bl = job.waitForCompletion(true);
return bl ? 0: 1;
}
public static void main(String[] args) throws Exception {
Configuration configuration = new Configuration();
//启动job任务
int run = ToolRunner.run(configuration, new JobMain(), args);
System.exit(run);
}
}
~~~ | 61,238 | MIT |
---
layout: post
title: 《研磨设计模式》职责链模式-Chain Of Responsibility
categories: [设计模式]
description: 设计模式|职责链模式
keywords: 设计模式,职责链,Chain Of Responsibility
autotoc: true
comments: true
---
本文是《研磨设计模式》第二十三章节学习笔记。
本文讲述内容的完整代码实例见 <https://github.com/sunailian/TouchHigh>。
## 一、使用场景
OA审批，不同的权限审批不同金额；
### 不使用职责链模式的代码
```java
public class FeeRequest {
/**
* 提交经费申请给项目经理
*
* @Description
* @author sunhanbin
* @date 2015-8-4下午9:42:49
* @param user
* @param fee
* @return
*/
public String requsetToProjectManager(String user, double fee) {
String str = "";
if (fee < 500) {// 项目经理只能审批500元以内的
str = projectHandler(user, fee);
} else if (fee < 1000) {// 部门经理的权限在1000元以内
str = depMangagerHandler(user, fee);
} else if (fee >= 1000) {// 总经理的权限最大
str = generalManagerHandler(user, fee);
}
return str;
}
public String projectHandler(String user, double fee) {
String str = "";
if ("小李".equals(user)) {
str = "项目经理同意" + user + "聚餐费用" + fee + "的请求";
} else {
str = "项目经理不同意" + user + "聚餐费用" + fee + "的请求";
}
return str;
}
public String depMangagerHandler(String user, double fee) {
String str = "";
if ("小李".equals(user)) {
str = "部门经理同意" + user + "聚餐费用" + fee + "的请求";
} else {
str = "部门经理不同意" + user + "聚餐费用" + fee + "的请求";
}
return str;
}
public String generalManagerHandler(String user, double fee) {
String str = "";
if ("小李".equals(user)) {
str = "总经理同意" + user + "聚餐费用" + fee + "的请求";
} else {
str = "总经理不同意" + user + "聚餐费用" + fee + "的请求";
}
return str;
}
}
```
```java
public class Client {
public static void main(String[] args) {
FeeRequest request = new FeeRequest();
String ret1 = request.requsetToProjectManager("小李", 300);
System.out.println("ret1====>>>>>" + ret1);
String ret2 = request.requsetToProjectManager("小张", 300);
System.out.println("ret2====>>>>>" + ret2);
String ret3 = request.requsetToProjectManager("小李", 600);
System.out.println("ret3====>>>>>" + ret3);
String ret4 = request.requsetToProjectManager("小李", 6000);
System.out.println("ret4====>>>>>" + ret4);
}
}
```
## 二、职责链模式的定义
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求,知道有一个对象处理它为止。
- 职责链的基本思路就是：**动态构造流程步骤**；
- Handler：定义职责的接口，通常在这里定义处理请求的方法，可以在这里实现后继链；
- ConcreteHandler：职责实现类。实现在他范围内请求的处理，如果不处理，就继续转发请求给后继者；
- Client
```java
public abstract class Handler {
protected Handler successor;// 下一个继承者
/**
* 设置后继的职责对象
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午8:59:47
* @param successor
*/
public void setSuccessor(Handler successor) {
this.successor = successor;
}
/**
* 示意请求的方法，虽然这个示意方法是没有传入参数的
* 但是实际是可以传入参数的，根据具体需求来选择是否传入参数
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:00:19
*/
public abstract void handlerRequest();
}
```
```java
/**
* 具体的职责对象，用来处理具体的请求
*
* @Package com.guozha.oms.web.controller.user
* @Description: TODO
* @author sunhanbin
* @date 2015-8-5下午9:02:14
*/
public class ConcreteHandler extends Handler {
/**
* 根据某些判断条件去判断是否为当前等级来请求，如果不是则转发到下一节点。 这些判断条件可以看具体情况分析
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:02:14
*/
@Override
public void handlerRequest() {
boolean somecondition = false;
if (somecondition) {
// 属于自己的处理范围，就在这里处理
System.out.println("ConcreteHandler1 handle this request");
} else {
// 如果不是自己的处理范文，则判断是否还有后继对象，如果有，就转发请求给后继对象
// 如果没有，就什么都不做，自然结束
if (this.successor != null) {
this.successor.handlerRequest();
}
}
}
}
```
```java
public class Client {
public static void main(String[] args) {
Handler handler1 = new ConcreteHandler();
// Handler handler2=new ConcreteHandler2();
// 设置下一个处理节点（因为没有写ConcreteHandler2所以就注释了）
// handler1.setSuccessor(handler2);
handler1.handlerRequest();
}
}
```
### 使用职责链模式重写案例
```java
public abstract class Handler {
protected Handler successor = null;
/**
* 设置下一节点
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:13:37
* @param successor
*/
public void setSuccessor(Handler successor) {
this.successor = successor;
}
/**
* 处理餐费的申请
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:14:18
* @param user
* @param fee
* @return
*/
public abstract String handlerFeeRequest(String user, double fee);
}
```
```java
public class ProjectManager extends Handler {
/**
* 部门经理处理请求
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:15:09
* @param user
* @param fee
* @return
*/
@Override
public String handlerFeeRequest(String user, double fee) {
String str = "";
if (fee < 500) {
if ("小李".equals(user)) {
str = "项目经理同意" + user + "聚餐费用" + fee + "的请求";
} else {
str = "项目经理不同意" + user + "聚餐费用" + fee + "的请求";
}
} else {
if (successor != null) {
return successor.handlerFeeRequest(user, fee);
}
}
return str;
}
}
```
```java
public class DepManager extends Handler {
/**
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:19:11
* @param user
* @param fee
* @return
*/
@Override
public String handlerFeeRequest(String user, double fee) {
String str = "";
if (fee < 1000) {
if ("小李".equals(user)) {
str = "部门经理同意" + user + "聚餐费用" + fee + "的请求";
} else {
str = "部门经理不同意" + user + "聚餐费用" + fee + "的请求";
}
} else {
if (this.successor != null) {
successor.handlerFeeRequest(user, fee);
}
}
return str;
}
}
```
```java
public class GeneralManager extends Handler {
@Override
public String handlerFeeRequest(String user, double fee) {
String str = "";
if (fee >= 1000) {
if ("小李".equals(user)) {
str = "总经理同意" + user + "聚餐费用" + fee + "的请求";
} else {
str = "总经理不同意" + user + "聚餐费用" + fee + "的请求";
}
} else {
if (this.successor != null) {
successor.handlerFeeRequest(user, fee);
}
}
return str;
}
}
```
```java
public class Client {
public static void main(String[] args) {
// 组装职责链
Handler handler1 = new ProjectManager();
Handler handler2 = new DepManager();
Handler handler3 = new GeneralManager();
handler1.setSuccessor(handler2);
handler2.setSuccessor(handler3);
String ret = handler1.handlerFeeRequest("小李", 600);
System.out.println(ret);
}
}
```
当遇到多个请求时，怎么处理？
- 第一种方式是：可以在Handler类中新增方法，处理其他的请求。当然这种方法有弊端：每次新增请求都要新增方法，很不灵活；
- 第二种方法是：用一个通用的请求对象来封装请求传递的参数；然后定义一个通用的调用方法，这个方法不区分具体业务。所有的业务都是这个方法，在通用的请求对象中有业务的标记字段。
```java
public abstract class Handler {
protected Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
/**
* 通用的请求处理方法
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:37:18
* @param rm
* @return
*/
public Object handleRequest(RequestModel rm) {
if (successor != null) {
return this.successor.handleRequest(rm);
} else {
System.out.println("没有后续的处理节点了");
return false;
}
}
}
```
```java
public class ProjectManager extends Handler {
/**
* 处理请求
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:42:04
* @param rm
* @return
*/
public Object handleRequest(RequestModel rm) {
if (FeeRequestModel.FEE_TYPE.equals(rm.getType())) {
// 项目经理可以处理聚餐费用的申请
return handleFeeRequest(rm);
} else {
// 其他的，项目经理暂时不想处理
//~当然，其他的比如请假申请，肯定有同样的类继承自RequestModel
return super.handleRequest(rm);
}
}
/**
* 处理自身可以处理的业务
*
* @Description
* @author sunhanbin
* @date 2015-8-5下午9:44:04
* @param rm
* @return
*/
private Object handleFeeRequest(RequestModel rm) {
FeeRequestModel frm = (FeeRequestModel) rm;
String str = "";
if (frm.getFee() < 500) {
if ("小李".equals(frm.getUser())) {
str = "项目经理同意" + frm.getUser() + "聚餐费用" + frm.getFee() + "的请求";
} else {
str = "项目经理不同意" + frm.getUser() + "聚餐费用" + frm.getFee() + "的请求";
}
} else {
if (this.successor != null) {
successor.handleRequest(rm);
}
}
return str;
}
}
```
```java
/**
* 通用的请求对象
*
* @Package com.guozha.oms.web.controller.user
* @Description: TODO
* @author sunhanbin
* @date 2015-8-5下午9:35:18
*/
public class RequestModel {
public String type;
public RequestModel(String type) {
this.type = type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
```
```java
public class FeeRequestModel extends RequestModel {
public final static String FEE_TYPE = "fee";
private String user;
private double fee;
// 设置自身级别（业务类型）为：费用申请
// ~这里当然可以有其他的扩充类去继承RequestModel,然后把业务类型设置成其他
// ~当然这个业务类型可以放到父类去定义
public FeeRequestModel() {
super(FEE_TYPE);
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public double getFee() {
return fee;
}
public void setFee(double fee) {
this.fee = fee;
}
}
```
职责链模式的本质：**分离职责，动态组合** | 10,350 | MIT |
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
- [Step 4. 目次の表示](#step-4-%E7%9B%AE%E6%AC%A1%E3%81%AE%E8%A1%A8%E7%A4%BA)
- [目次の自動生成](#%E7%9B%AE%E6%AC%A1%E3%81%AE%E8%87%AA%E5%8B%95%E7%94%9F%E6%88%90)
- [プレビュー](#%E3%83%97%E3%83%AC%E3%83%93%E3%83%A5%E3%83%BC)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
# Step 4. 目次の表示
ここまででページ番号と章番号を表示できました。次は目次です。
## 目次の自動生成
Vivliostyle には `<h1>` 見出しをもとに目次を自動生成する機能があります。`<h1>` 以外の見出しが必要な場合は自分で目次を作ることもできますが、今回はこの機能を使ってみましょう。
vivliostyle.config.js に以下の記述を加えます。すると、一番最初のページに目次が表示されるようになります。
```js {highlight:[6,10,11]}
// vivliostyle.config.js
module.exports = {
// ...
entry: [
{ rel: 'contents', theme: 'theme_toc.css' },
'example/ch01.md',
'example/ch02.md',
],
toc: true,
tocTitle: '目次',
// ...
};
```
## プレビュー
続いて scss/theme_toc.scss という目次専用のスタイルファイルを作ります。ひとまず theme_print.scss と同様のスタイルを定義して、ページ番号をインクリメントしないようにしておきます。
```bash
$ touch scss/theme_toc.scss
```
```scss {highlight:['3-17']}
// scss/theme_toc.scss
@import 'theme_common';
@page {
marks: crop cross;
bleed: 3mm;
@top-left {
content: 'theme_print';
}
}
// ページ番号をインクリメントしない
@page :nth(1) {
counter-increment: none;
}
```
以下のような見た目になりました。
もうすこしシュッとした見た目にしてみましょう。まず、不要な部分を隠します。
```scss {highlight: ['7-27']}
// scss/theme_toc.scss
@import 'theme_common';
// ...
// 不要な部分を隠す
@page :left {
@top-left {
content: '';
}
}
@page :right {
@top-right {
content: '';
}
}
h1 {
display: none;
}
h2 {
text-indent: 0;
}
nav ol {
padding: 0;
list-style: none;
}
```
目次にも対応するページ番号と章番号を表示してみましょう。
```scss {highlight: ['7-18']}
// scss/theme_toc.scss
// ...
nav ol {
// ...
li a {
&::before {
content: '第 ' target-counter(attr(href url), chapter) ' 章';
margin-right: 1rem;
}
&::after {
content: target-counter(attr(href url), p);
float: right;
}
}
}
```
一気に本らしくなりましたね！
 | 2,145 | Apache-2.0 |
---
title: 将托管数据磁盘附加到 Windows VM - Azure
description: 如何使用 Azure 门户将托管数据磁盘附加到 Windows VM。
ms.service: virtual-machines-windows
ms.topic: how-to
origin.date: 02/06/2020
author: rockboyfor
ms.date: 09/07/2020
ms.testscope: yes
ms.testdate: 08/31/2020
ms.author: v-yeche
ms.subservice: disks
ms.openlocfilehash: 8eff4aa07618fe066970c119ca18095f76cdf6dc
ms.sourcegitcommit: 93309cd649b17b3312b3b52cd9ad1de6f3542beb
ms.translationtype: HT
ms.contentlocale: zh-CN
ms.lasthandoff: 10/30/2020
ms.locfileid: "93106125"
---
# <a name="attach-a-managed-data-disk-to-a-windows-vm-by-using-the-azure-portal"></a>使用 Azure 门户将托管数据磁盘附加到 Windows VM
本文介绍如何使用 Azure 门户将新的托管数据磁盘附加到 Windows 虚拟机 (VM)。 VM 的大小决定了可以附加的数据磁盘数量。 有关详细信息，请参阅[虚拟机的大小](../sizes.md)。
## <a name="add-a-data-disk"></a>添加数据磁盘
1. 转到 [Azure 门户](https://portal.azure.cn)以添加数据磁盘。 搜索并选择“虚拟机”。
2. 从列表中选择虚拟机。
3. 在“虚拟机”页上选择“磁盘” 。
4. 在“磁盘”页上选择“添加数据磁盘” 。
5. 在新磁盘的下拉列表中，选择“创建磁盘”。
6. 在“创建托管磁盘”页中，键入磁盘名称，并根据需要调整其他设置。 完成操作后，选择“创建” 。
7. 在“磁盘”页中，选择“保存”，以保存 VM 的新磁盘配置 。
8. 在 Azure 创建磁盘并将磁盘附加到虚拟机之后，新磁盘将出现在“数据磁盘”下的虚拟机磁盘设置中。
## <a name="initialize-a-new-data-disk"></a>初始化新的数据磁盘
1. 连接到 VM。
1. 在正在运行的 VM 中选择 Windows“开始”菜单，然后在搜索框中输入 **diskmgmt.msc** 。 此时会打开“磁盘管理”控制台 。
2. “磁盘管理”识别出新的未初始化磁盘，并显示“初始化磁盘”窗口 。
3. 请确保选择新磁盘，然后选择“确定”对其进行初始化 。
4. 新的磁盘显示为“未分配” 。 右键单击磁盘上任意位置，选择“新建简单卷”。 此时会打开“新建简单卷向导”窗口 。
5. 完成向导中的每一步，保留所有默认值，完成后，选择“完成” 。
6. 关闭“磁盘管理” 。
7. 此时出现一个弹出窗口，通知你需要先格式化新磁盘才能使用新磁盘。 选择“格式化磁盘” 。
8. 在“格式化新磁盘”窗口中，检查设置，然后选择“启动” 。
9. 此时出现一条警告，通知你格式化磁盘会擦除所有数据。 选择“确定” 。
10. 完成格式化后，选择“确定” 。
## <a name="next-steps"></a>后续步骤
- 还可以[使用 PowerShell 附加数据磁盘](attach-disk-ps.md)。
- 如果应用程序需要使用 *D:* 盘存储数据，可以 [更改 Windows 临时磁盘的驱动器号](change-drive-letter.md)。
<!-- Update_Description: update meta properties, wording update, update link --> | 1,777 | CC-BY-4.0 |
リソース| 既定の制限
---|---
サブスクリプションあたりのプロファイル数 | 100 <sup>1</sup>
プロファイルあたりのエンドポイント数| 200
<sup>1</sup> これらの制限値を大きくする必要がある場合は、サポートにお問い合せください。
<!---HONumber=Nov15_HO1--> | 163 | CC-BY-3.0 |
## attr()
<a href="www.baidu.com" class="attr">百度</a>
```html
<a href="www.baidu.com" class="attr">百度</a>
```
```css
a.attr:after {
content: "(" attr(href) ")";
}
```
## var()
<p class="var">这里的字体颜色是红色</p>
```html
<p class="var">这里的字体颜色是红色</p>
```
```css
:root {
--font-color-red: red; /* 自定义属性必须以--开始 */
}
p.var {
color: var(--font-color-red);
}
```
## calc()
<div class="calc">
<div class="calc-inner">宽度为100%-200px</div>
</div>
```html
<div class="calc">
<div class="calc-inner">宽度为100%-200px</div>
</div>
```
```css
.calc {
width: 100%;
border: 1px solid #dedede;
box-sizing: border-box;
}
.calc-inner {
width: calc(100% - 200px);
height: 50px;
background-color: aqua;
line-height: 50px;
text-align: center;
}
```
| 函数 | 描述 | css 版本 |
| ------ | -------------------------------------------------------------- | -------- |
| attr() | 返回选择元素的属性值。 | 2 |
| var() | 用于插入自定义的属性值。 | 3 |
| calc() | 允许计算 CSS 的属性值，比如动态计算长度值。 | 3 |
| rgb() | 使用红(R)、绿(G)、蓝(B)三个颜色的叠加来生成各式各样的颜色。 | 2 |
| rgba() | 使用红(R)、绿(G)、蓝(B)、透明度(A)的叠加来生成各式各样的颜色。 | 3 |
<style>
:root{
--font-color-red: red;
}
.attr:after{
content: "("attr(href)")"
}
p.var{
color: var(--font-color-red);
}
.calc{
width: 100%;
border: 1px solid #dedede;
box-sizing: border-box;
}
.calc-inner{
width: calc(100% - 200px);
height: 50px;
background-color: aqua;
line-height: 50px;
text-align: center;
}
</style> | 1,660 | MIT |
编号 : 29
难度 : <font color="orange">Medium</font>
# 题目 :
>Given two integers dividend and divisor, divide two integers without using multiplication, division and mod operator.
>
>Return the quotient after dividing dividend by divisor.
>
>The integer division should truncate toward zero.
>
>**Example 1**:
>>
>>**Input**: dividend = 10, divisor = 3
>>**Output**: 3
>
>**Example 2**:
>
>>**Input**: dividend = 7, divisor = -3
>>**Output**: -2
>
>**Note**:
>
>* Both dividend and divisor will be 32-bit signed integers.
>* The divisor will never be 0.
>* Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231, 231 − 1]. For the purpose of this problem, assume that your function returns 231 − 1 when the division result overflows.
# 解 :
```C#
public class Solution {
public int Divide(int dividend, int divisor) {
bool sign1 = dividend > 0;
bool sign2 = divisor > 0;
/* 因为负值的范围更大，所以全部使用负值进行计算 */
if(sign1)
dividend = -(dividend);
if(sign2)
divisor = -(divisor);
/* 返回值，也使用负值暂存 */
int ret = 0;
/* |dividend| > |dividend| */
while(dividend <= divisor)
{
/* 通过位运算将[除数的绝对值]进行放大
* 减少减法运算的次数
*/
int bigDivisor = divisor;
int temp = 1; // 放大了多少倍
while(bigDivisor >= dividend && bigDivisor >= Int16.MinValue)
{
bigDivisor <<= 1;
temp <<= 1;
}
/* 上面循环会多一次 */
if(bigDivisor < dividend)
{
bigDivisor >>= 1;
temp >>= 1;
}
/* 被除数减去该值 */
dividend -= bigDivisor;
ret -= temp;
}
/* 处理符号 */
if(sign1 == sign2)
{
if(ret != int.MinValue)
ret = -ret; // 恢复为正数
else
ret = int.MaxValue; // 溢出了
}
return ret;
}
}
```
# 分析 :
这道题要求实现32位有符号整数的除法运行，要求不能使用乘法运算符(`*`)、除法运算符(`/`)和模运算符(`%`)。
> 另外题目假设所属环境只能保存32位有符号整数，所以严格来讲不能使用`Int64`和`Uint32`
上述解法总体而言，是将除法转换为减法，非常简单，但是纯粹的使用减法一次次减去除数，运算次数太多，因此使用位运算将除数进行放大后再减。
由于负数的范围比正数多一，如果在运算过程中使用正数保存中间值，有可能溢出，因此使用负数来保存中间值，最后给结果添加正负号。
之前的题目我都使用`C++`解答，而上述解法我使用的是`C#`，这是因为**在`C++`中，负数的位左移运算是未定义行为(Undefined Behavior)**，并且**有符号数的位移运算都不建议使用**。
>在`C++`中，由于`bigDivisor`和`temp`是负数，因此不能进行左移运算。
>```C++
>while(bigDivisor >= dividend && bigDivisor >= Int16.MinValue)
>{
> bigDivisor <<= 1;
> temp <<= 1;
>}
>```` | 2,646 | MIT |
# 计算
## 算法
* **算法的性质**
正确性：的确可以解决指定的问题
确定性：任一算法都可以描述为一个由基本操作组成的序列
可行性：每一基本操作都可实现，且在常数时间内完成
有穷性：对于任何输入，经过有穷次基本操作，都可以得到输出。
* **判断一个算法是不是好算法的条件**：**正确、健壮、可读、效率**
## 有穷性
`Hailstone`序列，计算`Hailstone`序列的长度：
```c++
//
// Created by wangheng on 2020/5/9.
//
#include <iostream>
// 计算hailstone序列的长度
int hailstone(int n) {
int length = 1;
while (1 < n) {
(n % 2) ? n = 3 * n + 1 : n /= 2;
length++;
}
return length;
}
int main() {
int number;
std::cin >> number;
std::cout << hailstone(number) << std::endl;
return 0;
}
```
# 计算模型
## 问题规模
* 令T(n) = 用算法A求解某一问题规模为n的实例，所需的计算成本。在规模同为n的所有实例中，只关注最坏的情况。
* T(n)=算法输入规模为n的问题，所需要执行的基本操作次数。
## 图灵机
* 无限长纸带
* 有限种状态
* 字符的种类有限
* 读写头总是对准一个单元格
# 算法分析
## 级数
* $$1 + \frac{1}{2} + \frac{1}{3} + ... + \frac{1}{n} = O(\log{n})$$
* $$\log{1} + log{2} + \log{3} + ... + \log{n} = O(n \log{n})$$
* $$1 + 2 + ... + n = O(n^2)$$
* $$1^2 + 2^2 + ... + n^2 = O(n^3)$$
* $$1^3 + 2^3 + ... + n^3 = O(n^4)$$
幂方级数：比幂次高一阶
* $$a^0 + a^1 + a^2 + ... + a^n = O(a^n)$$
* 收敛级数的复杂度是$$O(1)$$
## 冒泡排序
```c++
//
// Created by wangheng on 2020/5/10.
//
#include <iostream>
void bubbleSort(int A[], int n);
void swap(int&, int&);
int main() {
int a[5] = {3, 6, 2, 1, 4};
bubbleSort(a, sizeof(a) / sizeof(a[0]));
for (auto iter : a)
std::cout << iter << ' ';
return 0;
}
void bubbleSort(int A[], int n) {
for (bool sorted = false; sorted = !sorted; n--) {
for (int i = 1; i < n; i++) {
if (A[i-1] > A[i]) {
sorted = false;
swap(A[i-1], A[i]);
}
}
}
}
void swap(int& a, int& b) {
int temp = a;
a = b;
b = temp;
}
```
## 快速排序
### 实现1
```c++
/*
* 快速排序——挖坑填坑法，先选一个基准（一般选数组的第一个数），然后将比这个数大的数全部放到它的
* 右边，比它小的数全部放到它的左边，然后再对左右分区重复，直到各区间只有一个数字。
*/
void swap(int &a, int &b) {
int temp = a;
a = b;
b = temp;
}
#include <iostream>
void quickSort(int A[], int begin, int end) {
// 如果区间只有一个元素，递归结束
if (begin < end) {
int temp = A[begin]; // 将区间的第一个数当做基准
int i = begin; // 指向最左位置
int j = end; // 指向最右位置
while (i < j) {
// 当右边的数大于基准数时，略过，继续向左查找
// 不满足条件时跳出循环，此时的j对应的元素是小于基准元素的
while (i < j && A[j] >= temp)
j--;
// 将右边小于等于基准元素的数填入左边相应位置
A[i] = A[j];
// 当左边的数小于等于基准数时，略过，继续向右查找
// 不满足条件时跳出循环，此时的i对应的元素是大于等于基准元素的
while (i < j && A[i] << temp)
i++;
// 将左边大于基准元素的数填入右边相应位置
A[j] = A[i];
}
// 将基准元素填入相应位置
A[i] = temp;
// 此时的i即为基准元素的位置
// 对基准元素的左边子区间进行相似的快速排序
quickSort(A, begin, i - 1);
//对基准元素的右边子区间进行相似的快速排序
quickSort(A, i + 1, end);
} else
return;
}
int main() {
int a[] = {9, 2, 3, 1, 8, 3, 4, 8, 3};
quickSort(a, 0, sizeof(a)/sizeof(a[0]) - 1);
for (auto iter : a)
std::cout << iter << ' ';
return 0;
}
```
### 实现2
```c++
//
// Created by wangheng on 2020/5/11.
//
void swap(int &a, int &b) {
int temp = a;
a = b;
b = temp;
}
#include <iostream>
void quickSort(int A[], int begin, int end) {
if (begin < end) {
int temp = A[begin];
int i = begin, j = end;
while (i < j) {
while (i < j && A[j] >= temp)
j--;
swap(A[i], A[j]);
while (i < j && A[i] <= temp)
i++;
swap(A[i], A[j]);
}
quickSort(A, begin, i - 1);
quickSort(A, i + 1, end);
}
}
int main() {
int a[] = {9, 2, 7, 1, 8, 13, 90, 6, 3, 0, 5, 33, 100, 11, 10, 34, 25, 77, 19, 18, 9, 8};
quickSort(a, 0, sizeof(a)/sizeof(a[0]) - 1);
for (auto iter : a)
std::cout << iter << ' ';
return 0;
}
```
## 归并排序(merge_sort)
```c++
/*
* title: 归并排序(merge_sort)
*/
#include <iostream>
#include <cstdlib>
// 将有序数组合并
void merge_sort_core(int arr[], int begin, int mid, int end) {
int i = begin, j = mid, k = 0;
int* temp = (int*)std::malloc(sizeof(int) * (end - begin));
for (; i < mid && j < end; temp[k++] = (arr[i]<arr[j]?arr[i++]:arr[j++]));
for (; i < mid; temp[k++]=arr[i++]);
for (; j < end; temp[k++]=arr[j++]);
for (i = begin, k = 0; i < end; arr[i++]=temp[k++]);
free(temp);
}
void merge_sort(int arr[], int begin, int end) {
if (end - begin < 2)
return;
int mid = (begin + end) >> 1; // 计算中点
merge_sort(arr, begin, mid); // 二分递归排序
merge_sort(arr, mid, end);
merge_sort_core(arr, begin, mid, end); // 将排好序的数组合并
}
int main() {
int a[] = {45, 32, 33, 23, 16, 2, 38, 7};
merge_sort(a, 0, sizeof(a)/sizeof(a[0]));
for (auto iter : a)
std::cout << iter << ' ';
return 0;
}
```
## 选择排序
```c++
/*
* 选择排序：每次循环找出最小（大）值的索引，然后将其放在未排序数组的第一位
*/
#include <iostream>
void selectionSort(int A[], int length) {
int minIndex = 0, temp;
for (int i = 0; i < length - 1; i++) {
minIndex = i;
for (int j = i + 1; j < length; j++) {
if (A[j] < A[minIndex])
minIndex = j;
}
temp = A[i];
A[i] = A[minIndex];
A[minIndex] = temp;
}
}
int main() {
int a[] = {9, 2, 7, 1, 8, 13, 90, 6, 3, 0, 5, 33, 100, 11, 10, 34, 25, 77, 19, 18, 9, 8};
selectionSort(a, sizeof(a)/sizeof(a[0]));
for (auto iter : a)
std::cout << iter << ' ';
return 0;
}
```
## 插入排序
```c++
//
// Created by wangheng on 2020/5/11.
//
#include <iostream>
void insertionSort(int A[], int length) {
int preIndex, current;
// i表示已排序个数
for (int i = 1; i < length; i++) {
preIndex = i - 1;
// 保存未排序部分的第一个元素值
current = A[i];
while (preIndex >= 0 && A[preIndex] > current) {
A[preIndex + 1] = A[preIndex];
preIndex--;
}
A[preIndex + 1] = current;
}
}
int main() {
int a[] = {9, 2, 7, 1, 8, 13, 90, 6, 3, 0, 5, 33, 100, 11, 10, 34, 25, 77, 19, 18, 9, 8};
insertionSort(a, sizeof(a)/sizeof(a[0]));
for (auto iter : a)
std::cout << iter << ' ';
return 0;
}
```
# 迭代与递归
## 减而治之
> 为求解一个大规模的问题，可以：
>
> 将其划分为两个子问题，其一**平凡**，另一**规模缩减** // 单调性
>
> 分别求解子问题
>
> 由子问题的解，得到原问题的解
```c++
// 递归求和
#include <iostream>
int sum(int A[], int n) {
return (n < 1) ? 0 : sum(A, n-1) + A[n-1];
}
int main() {
int a[] = {1,3,4,5};
std::cout << sum(a, sizeof(a)/sizeof(a[0]));
return 0;
}
```
**求解递归复杂度的两种方法：递归跟踪、递归方程。**
* 递归跟踪（适用于简单递归模式）：
检查每个递归实例，累计所需时间就是算法执行时间。
* 递归方程（适用于复杂递归模式）：
## 分而治之
> 为求解一个大规模的问题，可以：
>
> 将其划分为若干（通常两个）子问题，规模大体**相当**
>
> 分别求解子问题
>
> 由子问题的解，得到原问题的解
**二分递归求和：**
```c++
#include <iostream>
int sum(int A[], int lo, int hi) {
if (lo == hi) return A[lo];
int mid = (lo + hi) >> 1;
return sum(A, lo, mid) + sum(A, mid + 1, hi);
}
int main() {
int a[] = {1, 3, 7, 3};
std::cout << sum(a, 0, sizeof(a)/sizeof(a[0]) - 1);
return 0;
}
```
## 查找数组中最大两个值的索引
```c++
// 计算数组[a,b)中最大和次大的数的索引
// x1表示最大值索引，x2表示次大值索引
#include <iostream>
void swap(int& a, int& b) {
int c = a;
a = b;
b = c;
}
void max2(int A[], int lo, int hi, int& x1, int& x2) {
// 最终还剩2个元素
if (lo + 2 == hi) {
if (A[x1 = lo] < A[x2 = lo + 1]) {
swap(x1, x2);
}
return; // 必须return使递归结束
}
// 最终还剩3个元素
if (lo + 3 == hi) {
if (A[x1 = lo] < A[x2 = lo + 1]) {
swap(x1, x2);
}
if (A[lo + 2] > A[x2]) {
if (A[x2 = lo + 2] > A[x1]) {
swap(x1, x2);
}
}
return;
}
int mid = (lo + hi) / 2;
int x1L, x2L;
max2(A, lo, mid, x1L, x2L);
int x1R, x2R;
max2(A, mid, hi, x1R, x2R);
if (A[x1L] > A[x1R]) {
x1 = x1L, x2 = (A[x2L] > A[x1R]) ? x2L : x1R;
} else {
x1 = x1R, x2 = (A[x2R] > A[x1L]) ? x2R : x1L;
}
}
int main()
{
int A[] = {1,5,6,4,11,3,8,9,10};
int x1, x2;
max2(A, 0, sizeof(A)/sizeof(A[0]), x1, x2);
std::cout << x1 << '\t' << x2 << std::endl;
return 0;
}
```
# 动态规划
## `fibonacci`数列
`fibonacci`递归版
```c++
int fib(int n) {
return (2 > n) ? n : fib(n - 1) + fib(n - 2);
}
```
算法的时间复杂度为$O(n^2)$，复杂度过高
**颠倒计算方向：由自顶向下递归，为自底向上迭代**
`fibonacci`迭代版
```c++
long long fib(long long n) {
long long f = 1, g = 0; // 初始化定义fib(-1), fib(0)
while (0 < n--) { // 根据原始定义，通过n次加法和减法计算fib(n)
g += f; // 计算最新一项
f = g - f; // 更新前一项为原来的g
}
return g;
}
```
## 最长公共子序列
```c++
// 递归实现，时间复杂度O(n^2)
#include <iostream>
#include <cstring>
int LCS(const char *str1, const char *str2, int l1, int l2) {
if (l1 >= 0 && l2 >= 0) {
if (str1[l1] == str2[l2]) // 减而治之
return LCS(str1, str2, l1-1, l2-1) + 1;
else // 分而治之
return LCS(str1, str2, l1, l2 - 1) > LCS(str1, str2, l1 - 1, l2) ?
LCS(str1, str2, l1, l2 - 1) : LCS(str1, str2, l1 - 1, l2);
} else
return 0;
}
int main() {
const char *str1 = "program";
const char *str2 = "algorithm";
std::cout << LCS(str1, str2, std::strlen(str1) - 1, std::strlen(str2) - 1);
return 0;
}
```
递归实现，时间复杂度$$O(n^2)$$
```c++
/*
* 最长公共子序列(LCS)迭代，时间复杂度为O(m*n),m、n分别是两个字符串的长度
*/
#include <iostream>
#include <cstring>
int LCS(const char *str1, const char *str2) {
int l1 = std::strlen(str1);
int l2 = std::strlen(str2);
int map[l1+1][l2+1];
for (int i = 0; i <= l1; i++)
map[i][0] = 0;
for (int j = 0; j <= l2; j++)
map[0][j] = 0;
for (int row = 1; row <= l1; row++) {
for (int column = 1; column <= l2; column++) {
if (str1[row-1] == str2[column-1])
map[row][column] = map[row-1][column-1]+1;
else
map[row][column] = (map[row][column-1] > map[row-1][column] ?
map[row][column-1] : map[row-1][column]);
}
}
return map[l1][l2];
}
int main() {
const char *str1 = "university";
const char *str2 = "algorithm";
std::cout << LCS(str1, str2);
return 0;
}
```
# 课后习题
## 1-2
海岛高度$H = d * h / (d_1 - d_2) + h$
海岛距离$D = d * d_2 / (d_1 - d_2)$
```c++
float islandHeight(float d1, float d2, float d, float h) {
float pha = d1 - d2;
float shi = d * h;
return shi / pha + h;
}
```
```c++
float islandDistance(float d1, float d2, float d) {
float shi = d2 * d;
float pha = d1 - d2;
return shi / pha;
}
```
## 1-3
(a) 所有元素已经有序
(b) 
(c) 
(d) 所有元素处于完全逆序的状态
## 1-4
不能。对n个整数进行排序，至少要对每个元素访问一次，所以时间复杂度不可能低于$O(n)$
## 1-6
输入规模按$n = 10^9$人口计算，计算量为$n^2 = 10^{18}$
该电脑的计算能力按$10^9$计，则大致需要$10^{18-9}=10^9$秒 = 30年
## 1-8
> 试证明，在用对数函数界定渐进复杂度时，常底数的具体取值无所谓。
$$
f(n) = O(\log_an) = O(\frac{\log_bn}{\log_ba})=O((\frac{\ln b}{\ln a}) * \log_b n) = O(\log_b n)
$$
## 1-9
> 试证明，对于任何$\varepsilon > 0$，都有$\log n = O(n^{\varepsilon})$。
## 1-12
```c++
int countOnes(unsigned int n) {
int ones = 0;
while (0 < n) {
ones++;
n &= n - 1; // 清除当前最靠右的1
}
return ones;
}
```
## 1-17
> 试证明，若每个递归实例仅需使用常数规模的空间，则地递归算法所需的空间总量将线性正比于最大的递归深度。
根据递归跟踪分析方法， 在递归程序的执行过程中，系统必须动态地记录所有活跃的递归实例。在任何时刻，这些活跃的递归实例都可以按照调用关系，构成一个调用链，该程序执行期间所需的空间，主要用于维护上述的调用链。不难看出，根据题目所给的条件，这部分空间量应该线性正比于调用链的最大长度，亦即最大的递归深度。 | 11,744 | Apache-2.0 |
<!--
Filename: Valvulopathy.md
Project: /Users/shume/Developer/mnemosyne/docs/MMB/docs/c_CV
Author: shumez <https://github.com/shumez>
Created: 2019-04-03 17:26:4
Modified: 2019-09-05 15:48:1
-----
Copyright (c) 2019 shumez
-->
# Valvulopathy
## Intro
<!-- <h6 id='intro-def'>Definition</h6> -->
<!-- <h6 id='intro-eti'>Etiology</h6> -->
<!-- <h6 id='intro-epi'>Epidemiology</h6> -->
<!-- <h6 id='intro-cls'>Classification</h6> -->
<!-- <h6 id='intro-sx'>Sign and Symptom</h6> -->
<!-- <h6 id='intro-cmp'>Complication</h6> -->
<!-- <h6 id='intro-ex'>Examination</h6> -->
<!-- <h6 id='intro-dx'>Diagnosis</h6> -->
<!-- <h6 id='intro-tx'>Treatment</h6> -->
<!-- <h6 id='intro-prg'>Prognosis</h6> -->
<!-- <h6 id='intro-app'>Appendix</h6> -->
<table>
<tbody>
<tr>
<th rowspan="2">Sys</th>
<th>MR</th>
<td>Carey-Coombs</td>
</tr>
<tr>
<th>AS</th>
<td></td>
</tr>
<tr>
<th rowspan="2">Dia</th>
<th>MS</th>
<td><u>Graham-Steell</u></td>
</tr>
<tr>
<th>AR</th>
<td><u>Austin-Flint</u></td>
</tr>
</tbody>
</table>
過剰心音
<table>
<tbody>
<tr>
<td>EM</td>
<td>
<ul>
<li>AS</li>
<li>PS</li>
</ul>
</td>
</tr>
<tr>
<td>収縮中期クリック</td>
<td>
<ul>
<li>MVP</li>
</ul>
</td>
</tr>
<tr>
<td>Opening snap<br>
僧帽弁開放音</td>
<td>
<ul>
<li>MS</li>
</ul>
</td>
</tr>
<tr>
<td>心膜ノックオン</td>
<td>
<ul>
<li>CP</li>
</ul>
</td>
</tr>
</tbody>
</table>
聴診 姿勢
<table>
<tbody>
<tr>
<th>AoV</th>
<td>前傾姿勢</td>
</tr>
<tr>
<th>MV</th>
<td>左側臥位</td>
</tr>
</tbody>
</table>
<table>
<tbody>
<tr>
<td></td>
<td rowspan="2" align="center">S<sub>1</sub></td>
<td colspan="3" align="center">Sys</td>
<td rowspan="2" align="center">S<sub>2</sub></td>
<td colspan="3" align="center">Dia</td>
<td rowspan="2">S<sub>1</sub></td>
</tr>
<tr>
<td align="right">S<sub>4</sub></td>
<td>Ej</td>
<td></td>
<td align="right">Click</td>
<td>OS<br>
Knock</td>
<td>S<sub>3</sub></td>
<td></td>
</tr>
</tbody>
</table>
### VR
Valve Replacement 人工弁置換
<h6 id='vr-ind'>Indication</h6>
生体弁の適応
Wafarin が必要ない
- 易出血性(+)
- ≥ 70 y/o
- 挙児希望
生体弁 / 機械弁
<table>
<thead>
<tr>
<th></th>
<th>生体弁</th>
<th>機械弁</th>
</tr>
</thead>
<tbody>
<tr>
<th>耐久性</th>
<td align="center">(-)</td>
<td align="center">(+++)</td>
</tr>
<tr>
<th>Warfarin</th>
<td align="center">(+)<br>
3moのみ投与</td>
<td align="center">(++)</td>
</tr>
</tbody>
</table>
脳塞栓をきたしやすい心疾患
- **MS**
- AMI
- 感染性心内膜炎 IE
- AFib
<!-- <h6 id='-def'>Definition</h6> -->
<!-- <h6 id='-def'>Definition</h6> -->
<!-- <h6 id='-eti'>Etiology</h6> -->
<!-- <h6 id='-epi'>Epidemiology</h6> -->
<!-- <h6 id='-cls'>Classification</h6> -->
<!-- <h6 id='-sx'>Sign and Symptom</h6> -->
<!-- <h6 id='-cmp'>Complication</h6> -->
<!-- <h6 id='-ex'>Examination</h6> -->
<!-- <h6 id='-dx'>Diagnosis</h6> -->
<!-- <h6 id='-tx'>Treatment</h6> -->
<!-- <h6 id='-prg'>Prognosis</h6> -->
<!-- <h6 id='-app'>Appendix</h6> -->
## MS
Mitral Stenosis
<!-- <h6 id='ms-def'>Definition</h6> -->
<!-- <h6 id='ms-eti'>Etiology</h6> -->
<!-- <h6 id='ms-epi'>Epidemiology</h6> -->
<!-- <h6 id='ms-cls'>Classification</h6> -->
<!-- <h6 id='ms-sx'>Sign and Symptom</h6> -->
<h6 id='ms-cmp'>Complication</h6>
- 脳塞栓
<h6 id='ms-ex'>Examination</h6>
[ref](https://www.healio.com/cardiology/learn-the-heart/cardiology-review/topic-reviews/heart-murmurs)
- Murmur
- ↑S1
- Opening Snap
- 拡張期ランブル
- **前収縮期雑音**
- 重症例で**Graham-Steell** (拡張期灌水様雑音 肺高血圧になった場合のPR音)
<!-- <h6 id='ms-dx'>Diagnosis</h6> -->
<h6 id='ms-tx'>Treatment</h6>
MS ope適応
- NYHA:
- PTMC: NYHA ≥ II°
- OMC, MVR: NYHA ≥ III°
- M弁弁口面積 ≥ 1.5cm2
- 塞栓症の既往, 左房内血栓
- LA平均圧 ≥ 15mmHg
<!-- <h6 id='ms-prg'>Prognosis</h6> -->
<h6 id='ms-app'>Appendix</h6>
- LAP ≈ PAWP ≈ LVEDP ≤ 12mmHg
- 肺動脈P ≤ 20mmHg
- RAP ≤ 5mmHg
## MR
<!-- <h6 id='mr-def'>Definition</h6> -->
<h6 id='mr-eti'>Etiology</h6>
1. MVP / Marfan
2. 腱索断裂 / 乳頭筋断裂
3. RF
4. IE
5. ECD
6. 外傷性
<!-- <h6 id='mr-epi'>Epidemiology</h6> -->
<!-- <h6 id='mr-cls'>Classification</h6> -->
<!-- <h6 id='mr-sx'>Sign and Symptom</h6> -->
<!-- <h6 id='mr-cmp'>Complication</h6> -->
<h6 id='mr-ex'>Examination</h6>
- Murmur
<!-- <h6 id='mr-dx'>Diagnosis</h6> -->
<!-- <h6 id='mr-tx'>Treatment</h6> -->
<!-- <h6 id='mr-prg'>Prognosis</h6> -->
<!-- <h6 id='mr-app'>Appendix</h6> -->
## MVP
Mitral Valve Prolapse
<!-- <h6 id='mvp-def'>Definition</h6> -->
<!-- <h6 id='mvp-eti'>Etiology</h6> -->
<!-- <h6 id='mvp-epi'>Epidemiology</h6> -->
<!-- <h6 id='mvp-cls'>Classification</h6> -->
<!-- <h6 id='mvp-sx'>Sign and Symptom</h6> -->
<!-- <h6 id='mvp-cmp'>Complication</h6> -->
<h6 id='mvp-ex'>Examination</h6>
- Murmur
- 収縮中期 高音クリック音
∵ MV逸脱による高調
- SRM 後期
[ref](https://www.healio.com/cardiology/learn-the-heart/cardiology-review/topic-reviews/heart-murmurs)
<!-- <h6 id='mvp-dx'>Diagnosis</h6> -->
<!-- <h6 id='mvp-tx'>Treatment</h6> -->
<!-- <h6 id='mvp-prg'>Prognosis</h6> -->
<!-- <h6 id='mvp-app'>Appendix</h6> -->
## AS
Atrial Stenosis
<!-- <h6 id='as-def'>Definition</h6> -->
<h6 id='as-eti'>Etiology</h6>
- 動脈硬化
- **二尖弁**
<!-- <h6 id='as-epi'>Epidemiology</h6> -->
<!-- <h6 id='as-cls'>Classification</h6> -->
<h6 id='as-sx'>Sign and Symptom</h6>
- 狭心痛
- 心筋肥大 ⇒ ↑O2需要 ⇒ 狭心痛
- 平均余命: 5yrs
- 失神
- ↓Ao圧 ⇒ ↓脳血流量 ⇒ 失神
- 平均余命: 3yrs
- 心不全
- ↓LVのコンプライアンス ⇒ 心不全
- 平均余命: 2yrs
<!-- <h6 id='as-cmp'>Complication</h6> -->
<h6 id='as-ex'>Examination</h6>
弁口面積
<table>
<tbody>
<tr>
<th>正常</th>
<td>3 cm<sup>2</sup></td>
</tr>
<tr>
<th>軽度</th>
<td>≤ <u>1.5 cm</u><sup>2</sup>s</td>
</tr>
<tr>
<th>中等度</th>
<td>≤ 1.0 cm<sup>2</sup><br>
弁置換適応</td>
</tr>
<tr>
<th>高度</th>
<td>≤ 0.5 cm<sup>2</sup></td>
</tr>
</tbody>
</table>
<!-- <h6 id='as-dx'>Diagnosis</h6> -->
<h6 id='as-tx'>Treatment</h6>
1. 高度AS & S/S
2. 高度AS & Ope予定
高度AS :
- **圧較差 ≥ 40mHg**
- 弁口面積 ≤ 1.0
S/S :
- **狭心痛**
- 失神発作
- NYHA ≥ II°
- EF ≤ 50%
TAVI (Transcatheter Aortic Valve Implantation)
- Indication
- ≥ 80y/o
- 以前に開胸手術, 再開胸を避けるべき症例
- COPDなどの基礎疾患, 開胸AVRより侵襲の少ない方法を選ぶ場合
<!-- <h6 id='as-prg'>Prognosis</h6> -->
<!-- <h6 id='as-app'>Appendix</h6> -->
## AR
<!-- <h6 id='ar-def'>Definition</h6> -->
<!-- <h6 id='ar-eti'>Etiology</h6> -->
<!-- <h6 id='ar-epi'>Epidemiology</h6> -->
<!-- <h6 id='ar-cls'>Classification</h6> -->
<h6 id='ar-sx'>Sign and Symptom</h6>
- LV容量負荷↑ ⇒ 遠心性肥大
- 拡張期雑音
- 脈圧↑
- **心尖拍動の外側偏位**
<table>
<thead>
<tr>
<th colspan="2"><u>ある 昼, とあるママ, 出店で 不倫し, たい そう 愉快</u></th>
</tr>
</thead>
<tbody>
<tr>
<td>ある </td>
<td>AR（大動脈弁閉鎖不全症）</td>
</tr>
<tr>
<td>昼、 </td>
<td>Hill's sign</td>
</tr>
<tr>
<td>とあるママ、 </td>
<td>to and fro murmur</td>
</tr>
<tr>
<td>出店で </td>
<td>de Musset's sign（頭部のゆれ）</td>
</tr>
<tr>
<td>不倫し、 </td>
<td>Austin Flint雑音</td>
</tr>
<tr>
<td>たい </td>
<td>大脈</td>
</tr>
<tr>
<td>そう </td>
<td>速脈</td>
</tr>
<tr>
<td>愉快 </td>
<td>床→爪床部の毛細血管拍動（Quincke徴候）</td>
</tr>
</tbody>
</table>
<!-- <h6 id='ar-cmp'>Complication</h6> -->
<h6 id='ar-ex'>Examination</h6>
- Physical Examination
- 聴診
- **to-and-fro**
- 拡張期逆流性 DRM
- 収縮期駆出性 SEM
- **Austin-Flint** (MS)
<table>
<tbody>
<tr>
<th>速脈/大脈</th>
<td>
<ul>
<li>Corrigan's pulse</li>
<li>Water Hammer Pulse</li>
</ul>
</td>
</tr>
<tr>
<th>Quincke sign</th>
<td>
<ul>
<li>毛細血管の拍動</li>
</ul>
</td>
</tr>
<tr>
<th>Pistol shot</th>
<td>
<ul>
<li>大腿Aの速脈/大脈</li>
</ul>
</td>
</tr>
<tr>
<th>Taube 重複音</th>
<td>
<ul>
<li>大腿Aの雑音</li>
</ul>
</td>
</tr>
<tr>
<th>de Musset's sign</th>
<td>
<ul>
<li>拍動毎に頷くような所見</li>
</ul>
</td>
</tr>
<tr>
<th>拡張期漸減性雑音</th>
<td>
<ul>
<li>AoからLVに逆流</li>
</ul>
</td>
</tr>
<tr>
<th>拡張中期雑音</th>
<td>
<ul>
<li>逆流した血液によってMVが挙上<br>
⇒ <u>Austin Flint</u></li>
</ul>
</td>
</tr>
<tr>
<th>S<sub>3</sub></th>
<td>
<ul>
<li>LV容量負荷</li>
</ul>
</td>
</tr>
</tbody>
</table>
<!-- <h6 id='ar-dx'>Diagnosis</h6> -->
<!-- <h6 id='ar-tx'>Treatment</h6> -->
<!-- <h6 id='ar-prg'>Prognosis</h6> -->
<!-- <h6 id='ar-app'>Appendix</h6> -->
## TS
Tricuspid Stenosis
<!-- <h6 id='ts-def'>Definition</h6> -->
<!-- <h6 id='ts-eti'>Etiology</h6> -->
<!-- <h6 id='ts-epi'>Epidemiology</h6> -->
<!-- <h6 id='ts-cls'>Classification</h6> -->
<!-- <h6 id='ts-sx'>Sign and Symptom</h6> -->
<!-- <h6 id='ts-cmp'>Complication</h6> -->
<!-- <h6 id='ts-ex'>Examination</h6> -->
<!-- <h6 id='ts-dx'>Diagnosis</h6> -->
<!-- <h6 id='ts-tx'>Treatment</h6> -->
<!-- <h6 id='ts-prg'>Prognosis</h6> -->
<!-- <h6 id='ts-app'>Appendix</h6> -->
## TR
Tricuspid Regurgitation
<!-- <h6 id='tr-def'>Definition</h6> -->
<!-- <h6 id='tr-eti'>Etiology</h6> -->
<!-- <h6 id='tr-epi'>Epidemiology</h6> -->
<!-- <h6 id='tr-cls'>Classification</h6> -->
<!-- <h6 id='tr-sx'>Sign and Symptom</h6> -->
<!-- <h6 id='tr-cmp'>Complication</h6> -->
<!-- <h6 id='tr-ex'>Examination</h6> -->
<!-- <h6 id='tr-dx'>Diagnosis</h6> -->
<!-- <h6 id='tr-tx'>Treatment</h6> -->
<!-- <h6 id='tr-prg'>Prognosis</h6> -->
<!-- <h6 id='tr-app'>Appendix</h6> -->
## IE
Infectious Endocarditis 感染性心内膜炎
<!-- <h6 id='ie-def'>Definition</h6> -->
<h6 id='ie-eti'>Etiology</h6>
- 誘引 :
- 弁膜症
- **MR** / MVP
- AR
- AS
- PS
- 先天性
- VSD
- PDA
- ToF
**ASD : IEきたしにくい**
- 心筋症
- HOCM
- 開心術後
- 人口弁置換術後
- 急性 :
- 黄色ブドウ球菌
- 亜急性 :
- **緑色レンサ球菌** #1
- **腸球菌**
- 慢性 :
- 非細菌性
<!-- <h6 id='ie-epi'>Epidemiology</h6> -->
<!-- <h6 id='ie-cls'>Classification</h6> -->
<h6 id='ie-sx'>Sign and Symptom</h6>
- Murmur
- MR
- 塞栓
- Osler結節 / 眼底**Roth斑** / 出血斑 / **爪下線状出血**
- Janeway病変
<!-- <h6 id='ie-cmp'>Complication</h6> -->
<h6 id='ie-ex'>Examination</h6>
- L/D
- γ-globlin
- ↑FBG
- 血液培養
- MRI
- 感染性脳動脈瘤
<!-- <h6 id='ie-dx'>Diagnosis</h6> -->
<h6 id='ie-tx'>Treatment</h6>
- 緑連菌
- **PG**
手術適応
- 頻発塞栓
- 心不全悪化
- 内科的コントロール不能状態
- 真菌性心内膜炎
- 人工弁に伴う心内膜炎
- **膿瘍の形成**
<!-- <h6 id='ie-prg'>Prognosis</h6> -->
<h6 id='ie-app'>Appendix</h6>
<table>
<thead>
<tr>
<th colspan="2"><u>そうか ロス じゃ お寿 司ない</u></th>
</tr>
</thead>
<tbody>
<tr>
<td>そうか</td>
<td>爪下線状出血</td>
</tr>
<tr>
<td>ロス</td>
<td>Roth 斑</td>
</tr>
<tr>
<td>じゃ</td>
<td>Janeway 病変</td>
</tr>
<tr>
<td>お寿</td>
<td>Osler結節</td>
</tr>
<tr>
<td></td>
<td>感染性心内膜炎</td>
</tr>
</tbody>
</table>
<table>
<thead>
<tr>
<th></th>
<th>起因菌</th>
<th>age</th>
<th>onset</th>
<th>基礎疾患</th>
<th>合併症</th>
<th>死亡率</th>
<th>治療</th>
</tr>
</thead>
<tbody>
<tr>
<th>院内感染</th>
<td><ul>
<li>黄色ブドウ球菌</li>
<li>表皮ブドウ球菌</li>
<li>溶連菌</li>
</ul></td>
<td>高齢</td>
<td>急性</td>
<td><ul>
<li>人工弁 (≤ 2mo)</li>
<li>静脈内カテ</li>
</ul></td>
<td><ul>
<li>心筋炎</li>
<li>細菌塞栓</li>
</ul></td>
<td>(+++)</td>
<td>バンコマイシン</td>
</tr>
<tr>
<th>院外感染</th>
<td><ul>
<li>緑膿菌</li>
<li>腸球菌</li>
<li>大腸菌</li>
</ul></td>
<td>若年</td>
<td>亜急性</td>
<td><ul>
<li>人工弁 (≥ 2mo)</li>
<li>先天性心疾患</li>
</ul></td>
<td><ul>
<li>血栓塞栓症</li>
<li>FSGS</li>
</ul></td>
<td>(–)</td>
<td>PC-G</td>
</tr>
</tbody>
</table>
##
<!-- ## -->
<!-- <h6 id='-def'>Definition</h6> -->
<!-- <h6 id='-eti'>Etiology</h6> -->
<!-- <h6 id='-epi'>Epidemiology</h6> -->
<!-- <h6 id='-cls'>Classification</h6> -->
<!-- <h6 id='-sx'>Sign and Symptom</h6> -->
<!-- <h6 id='-cmp'>Complication</h6> -->
<!-- <h6 id='-ex'>Examination</h6> -->
<!-- <h6 id='-dx'>Diagnosis</h6> -->
<!-- <h6 id='-tx'>Treatment</h6> -->
<!-- <h6 id='-prg'>Prognosis</h6> -->
<!-- <h6 id='-app'>Appendix</h6> -->
<!-- <style type="text/css">
img{width: 50%; float: right;}
</style> --> | 12,201 | MIT |
## Goroutine调度器
goroutine和线程的区别
Runtime 和 OS 的关系
什么是M:N模型
GPM 是什么
g0 栈何用户栈如何切换
goroutine 如何退出
goroutine 调度时机有哪些
什么是workstealing
M 如何找工作
mian gorutine 如何创建
schedule 循环如何启动
schedule 循环如何运转
sysmon 后台监控线程做了什么
一个调度相关的陷阱
什么是 go shceduler
描述 scheduler 的初始化过程
- M: OS thread
- G: goroutine
- P: context for scheduling
```go
package main
import "fmt"
func main() {
/*
一个 goroutine 打印数字、另一个 goroutine 打印字母，观察打印结果
*/
//1.创建并启动子 goroutine, 执行printNum()
go printNum()
//2.主 goroutine 打印字母
for i := 0; i < 10; i++ {
fmt.Printf("主 goroutine 打印字母 X %d\n", i)
}
fmt.Println("main is over...")
}
func printNum() {
for i := 0; i < 10; i++ {
fmt.Printf("\t子 goroutine 中打印数字%d\n", i)
}
}
``` | 722 | Apache-2.0 |
---
title: "Azure IoT のセキュリティ アーキテクチャ | Microsoft Docs"
description: "脅威のモデル化を含む IoT のセキュリティ アーキテクチャのガイドラインと考慮事項"
services: iot-hub
documentationcenter:
author: YuriDio
manager: timlt
editor:
ms.assetid: 6c28b173-0d3c-415a-a9ea-02908ff87b3b
ms.service: iot-hub
ms.devlang: na
ms.topic: article
ms.tgt_pltfrm: na
ms.workload: na
ms.date: 10/17/2016
ms.author: yurid
translationtype: Human Translation
ms.sourcegitcommit: e223d0613cd48994315451da87e6b7066585bdb6
ms.openlocfilehash: 9327750b35476fd2a6eca379061a06842daf8d47
---
[!INCLUDE [iot-security-architecture](../../includes/iot-security-architecture.md)]
## <a name="see-also"></a>関連項目
IoT ソリューションのセキュリティ保護の詳細については、「[IoT デプロイのセキュリティ保護][lnk-security-deployment]」をご覧ください。
IoT Hub の機能を詳しく調べるには、次のリンクを使用してください。
* [IoT Gateway SDK を使用したデバイスのシミュレーション][lnk-gateway]
[lnk-security-deployment]: iot-hub-security-deployment.md
[lnk-gateway]: iot-hub-linux-gateway-sdk-simulated-device.md
<!--HONumber=Dec16_HO1--> | 996 | CC-BY-3.0 |
---
title: SQL Server Always On 可用性组概述
description: 本文介绍 Azure 虚拟机上的 SQL Server Always On 可用性组。
services: virtual-machines
documentationCenter: na
author: rockboyfor
editor: monicar
tags: azure-service-management
ms.assetid: 601eebb1-fc2c-4f5b-9c05-0e6ffd0e5334
ms.service: virtual-machines-sql
ms.topic: article
ms.tgt_pltfrm: vm-windows-sql-server
ms.workload: iaas-sql-server
origin.date: 01/13/2017
ms.date: 07/06/2020
ms.author: v-yeche
ms.custom: seo-lt-2019
ms.openlocfilehash: d5e84dd735b636d276546a26848aa2094f9e9a89
ms.sourcegitcommit: 89118b7c897e2d731b87e25641dc0c1bf32acbde
ms.translationtype: HT
ms.contentlocale: zh-CN
ms.lasthandoff: 07/03/2020
ms.locfileid: "85946224"
---
<!--Verified Redirect files-->
# <a name="introducing-sql-server-always-on-availability-groups-on-azure-virtual-machines"></a>Azure 虚拟机上的 SQL Server Always On 可用性组简介
[!INCLUDE[appliesto-sqlvm](../../includes/appliesto-sqlvm.md)]
本文介绍 Azure 虚拟机上的 SQL Server 可用性组。
Azure 虚拟机上的 AlwaysOn 可用性组类似于本地的 AlwaysOn 可用性组。 有关详细信息，请参阅 [Always On 可用性组 (SQL Server)](https://msdn.microsoft.com/library/hh510230.aspx)。
下图阐述了 Azure 虚拟机中完整 SQL Server 可用性组的各个部分。
Azure 虚拟机中可用性组的主要区别是这些虚拟机 (VM) 需要[负载均衡器](../../../load-balancer/load-balancer-overview.md)。 负载均衡器保存可用性组侦听器的 IP 地址。 如果有多个可用性组，则每个组都需要一个侦听程序。 一个负载均衡器可以支持多个侦听器。
此外，在 Azure IaaS VM 来宾故障转移群集上，我们建议每个服务器（群集节点）使用一个 NIC 和一个子网。 Azure 网络具有物理冗余，这使得在 Azure IaaS VM 来宾群集上不需要额外的 NIC 和子网。 虽然群集验证报告将发出警告，指出节点只能在单个网络上访问，但在 Azure IaaS VM 来宾故障转移群集上可以安全地忽略此警告。
若要增加冗余和高可用性，SQL Server VM 应位于相同的[可用性集](availability-group-manually-configure-prerequisites-tutorial.md#create-availability-sets)中。
<!--Not Available on or different [availability zones](/availability-zones/az-overview)-->
| | Windows Server 版本 | SQL Server 版本 | SQL Server 版本 | WSFC 仲裁配置 | 使用多区域进行灾难恢复 | 多子网支持 | 支持现有 AD | 使用具有多个区域的相同区域进行灾难恢复 | Dist-AG 支持，没有 AD 域 | Dist-AG 支持，没有群集 |
| :------ | :-----| :-----| :-----| :-----| :-----| :-----| :-----| :-----| :-----| :-----|
| [手动](availability-group-manually-configure-prerequisites-tutorial.md) | 全部 | 全部 | 全部 | 全部 | 是 | 是 | 是 | 是 | 是 | 是 |
| | | | | | | | | | | |
准备好在 Azure 虚拟机上生成 SQL Server 可用性组时，请参阅这些教程。
<!--Not Available on ## Manually with Azure CLI-->
<!--Not Available on ## Automatically with Azure Quickstart Templates-->
<!--Not Available on ## Automatically with an Azure Portal Template-->
## <a name="manually-in-the-azure-portal"></a>在 Azure 门户中手动操作
还可以自行创建虚拟机，不需模板。 首先完成先决条件，然后创建可用性组。 请参阅以下主题：
- [在 Azure 虚拟机上配置 SQL Server Always On 可用性组的先决条件](availability-group-manually-configure-prerequisites-tutorial.md)
- [创建 Always On 可用性组以提高可用性和灾难恢复能力](availability-group-manually-configure-tutorial.md)
## <a name="next-steps"></a>后续步骤
[在位于不同区域的 Azure 虚拟机上配置 SQL Server AlwaysOn 可用性组](availability-group-manually-configure-multiple-regions.md)
<!-- Update_Description: new article about availability group overview -->
<!--NEW.date: 07/06/2020--> | 3,048 | CC-BY-4.0 |
```java
package com.mashibing.juc.c_000;
import java.util.concurrent.TimeUnit;
public class T01_WhatIsThread {
private static class T1 extends Thread {
@Override
public void run() {
for(int i=0; i<10; i++) {
try {
TimeUnit.MICROSECONDS.sleep(1);
//注意这里线程sleep的时候会产生异常
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("T1");
}
}
}
public static void main(String[] args) {
//如果运行的是run方法，那么只有一个main线程,所以先输出T1,然后输出main
//new T1().run();
//如果运行的是start方法，那么有一个main线程,还有一个T1线程,所以输出T1，输出main同时进行
new T1().start();
for(int i=0; i<10; i++) {
try {
TimeUnit.MICROSECONDS.sleep(1);
//注意这里线程sleep的时候会产生异常
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("main");
}
}
}
```
```java
package com.mashibing.juc.c_000;
public class T02_HowToCreateThread {
static class MyThread extends Thread {
@Override
public void run() {
System.out.println("Hello MyThread!");
}
}
static class MyRun implements Runnable {
@Override
public void run() {
System.out.println("Hello MyRun!");
}
}
public static void main(String[] args) {
new MyThread().start();
new Thread(new MyRun()).start();
new Thread(()->{
System.out.println("Hello Lambda!");
}).start(); //lambda表达式
}
}
//请你告诉我启动线程的三种方式 1：Thread 2: Runnable 3:Executors.newCachedThrad
```
```java
package com.mashibing.juc.c_000;
public class T03_Sleep_Yield_Join {
public static void main(String[] args) {
// testSleep();
// testYield();
testJoin();
}
static void testSleep() {
new Thread(()->{
for(int i=0; i<100; i++) {
System.out.println("A" + i);
try {
// Thread.sleep()的意思是，当前线程暂停一段时间让给别的线程执行
Thread.sleep(500);
//TimeUnit.Milliseconds.sleep(500)
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
static void testYield() {
new Thread(()->{
for(int i=0; i<100; i++) {
System.out.println("A" + i);
if(i%10 == 0) Thread.yield();
}
}).start();
new Thread(()->{
for(int i=0; i<100; i++) {
System.out.println("------------B" + i);
if(i%10 == 0) Thread.yield();
}
}).start();
}
static void testJoin() {
Thread t1 = new Thread(()->{
for(int i=0; i<100; i++) {
System.out.println("A" + i);
try {
Thread.sleep(500);
//TimeUnit.Milliseconds.sleep(500)
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2 = new Thread(()->{
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0; i<100; i++) {
System.out.println("A" + i);
try {
Thread.sleep(500);
//TimeUnit.Milliseconds.sleep(500)
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t1.start();
t2.start();
}
}
```
```java
package com.mashibing.juc.c_000;
public class T04_ThreadState {
static class MyThread extends Thread {
@Override
public void run() {
System.out.println(this.getState());
for(int i=0; i<10; i++) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
}
}
}
public static void main(String[] args) {
Thread t = new MyThread();
System.out.println(t.getState());
t.start();
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(t.getState());
}
}
```
```
/**
这里开始讲synchronized
对某个对象加上锁
*/
这里锁定的是o这个对象，然后拿到这把锁就可以执行count--和println这段代码。注意锁的不是count--和println
package com.mashibing.juc.c_001;
public class T {
private int count = 10;
private Object o = new Object();
public void m() {
synchronized(o) { //任何线程要执行下面的代码，都必须先拿到o的锁
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
}
}
}
```
老师有一堂公开课叫做hashcode和markword。在jvm规范中没有规定synchronized怎么实现。
堆中的对象头上有两位记录对象是否被锁定了，这两位叫做markword。
```
/**
*/
package com.mashibing.juc.c_002;
public class T {
private int count = 10;
public void m() {
synchronized(this) { //前面的例子每次都要new一个对象这样非常的麻烦，所以有这种方式
就是synchronized(this)。任何线程要执行下面的代码，必须先拿到this的锁。锁定当前对象
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
}
}
}
```
```
/**
*/
package com.mashibing.juc.c_003;
public class T {
private int count = 10;
public synchronized void m() { //等同于在方法的代码执行时要synchronized(this)
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
}
}
```
```
/**
*/
package com.mashibing.juc.c_003;
public class T1 {
private int count = 10;
public synchronized void m() { //等同于在方法的代码执行时要synchronized(this)
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
}
public void n() {
count++;
}
}
```
```
/**
*/
package com.mashibing.juc.c_004;
public class T {
private static int count = 10;
public synchronized static void m() { //static方法等同于synchronized(T.class)
锁的是指向T字节码的class类的那个对象
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
}
public static void mm() {
synchronized(T.class) { //考虑一下这里synchronized(this)是否可以
count --;
}
}
}
```
```
package com.mashibing.juc.c_005;
public class T implements Runnable {
private /*volatile*/ int count = 100;
public /*synchronized*/ void run() {
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
}
public static void main(String[] args) {
T t = new T();
for(int i=0; i<100; i++) {
new Thread(t, "THREAD" + i).start();
}
}
}
synchronized既保证了原子性，又保证了可见性。所以只要加上了synchronized，那么就不用加上volatile了。
```
```
/**
* 同步和非同步方法是否可以同时调用？ 可以
* @author mashibing
*/
package com.mashibing.juc.c_007;
public class T {
public synchronized void m1() {
System.out.println(Thread.currentThread().getName() + " m1 start...");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " m1 end");
}
public void m2() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " m2 ");
}
public static void main(String[] args) {
T t = new T();
/*new Thread(()->t.m1(), "t1").start();
new Thread(()->t.m2(), "t2").start();*/
new Thread(t::m1, "t1").start();
new Thread(t::m2, "t2").start();
/*
//1.8֮ǰµÄд·¨
new Thread(new Runnable() {
@Override
public void run() {
t.m1();
}
});
*/
}
}
```
```
/**
模拟银行账户对业务写方法枷锁，对业读务方法不加锁，这样行不行？不行，脏读，dirtyread
*/
package com.mashibing.juc.c_008;
import java.util.concurrent.TimeUnit;
public class Account {
String name;
double balance;
public synchronized void set(String name, double balance) {
this.name = name;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.balance = balance;
}
public /*synchronized*/ double getBalance(String name) {
return this.balance;
}
public static void main(String[] args) {
Account a = new Account();
new Thread(()->a.set("zhangsan", 100.0)).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(a.getBalance("zhangsan"));
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(a.getBalance("zhangsan"));
}
}
输出:
如果业务逻辑允许脏读那么没有问题可以不加，顶多读到0.0。
如果业务逻辑不允许，那么就要对读方法加锁。
0.0 100.0
```
```
/**
这个例子就用来说明前一张图
*/
package com.mashibing.juc.c_010;
import java.util.concurrent.TimeUnit;
public class T {
synchronized void m() {
System.out.println("m start");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m end");
}
public static void main(String[] args) {
new TT().m();
}
}
class TT extends T {
@Override
synchronized void m() {
System.out.println("child m start");
super.m();
System.out.println("child m end");
}
}
```
所谓的可重入锁，自己拿到这把锁之后，就是不停的加锁，锁的是同一个对象。去掉一把锁头就减去1。
```java
/**
*=========》 程序在执行过程中，如果出现异常，默认情况锁会被释放《============
* 所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。
* 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适，
* 在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。
* 因此要非常小心的处理同步业务逻辑中的异常
* @author mashibing
*/
package com.mashibing.juc.c_011;
import java.util.concurrent.TimeUnit;
public class T {
int count = 0;
synchronized void m() {
System.out.println(Thread.currentThread().getName() + " start");
while(true) {
count ++;
System.out.println(Thread.currentThread().getName() + " count = " + count);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(count == 5) {
int i = 1/0; //此处抛出异常，锁将被释放，要想不被释放，可以在这里进行catch，然后让循环继续
System.out.println(i);
}
}
}
public static void main(String[] args) {
T t = new T();
Runnable r = new Runnable() {
@Override
public void run() {
t.m();
}
};
new Thread(r, "t1").start();
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(r, "t2").start();
}
}
```
```
synchronized的底层实现
JDK早期的synchronized,重量级,使用的是OS的锁，去找操作系统和内核申请锁。所以使用后来的改进
锁升级的概念：
我就是厕所所长 （一 二），老师写的文章介绍各种锁的。
sync (Object)，如果当只有一个线程访问的时候，没有给这个object加锁，markword 记录这个线程ID （这个时候叫做偏向锁，什么叫做偏向锁，你是我的第一个我偏向你点，效率非常高。）
偏向锁如果线程争用：偏向锁升级为 自旋锁，也就是while循环，循环等待，10次以后，还得不到这把锁，那么就升级为重量级锁 - OS
经过了锁升级的概念之后，synchronized并不比atom（原子操作）操作慢。
锁只能升级不能降级。
jvm没有规定synchronized，如何实现，我们上面说的这些都是hotspot的实现。
什么情况下用自旋锁，什么情况下系统锁？
执行时间短（加锁代码），线程数少，用自旋，
执行时间长，线程数多，用系统锁，os锁，其他等待线程是不占用cpu的。
synchronized锁的是一个对象，而不是一段代码。
偏向锁的意思就是记住线程号码，然后下次发现还是你的线程号码。
自旋锁，旁边自旋
重量级锁
为什么不能用String常量，Integer,Long，作为synchronized的锁对象？
所有字符串常量用的都是一个，一个线程锁定了字符串常量，而且这个常量是一个类库中的，也在你代码中的，就是两个都有，这个字符串常量，他们是同一份。那么如果类库锁定了，或者是我自己的线程锁定了。一个锁定了，另外一个就无法访问了。
要锁定一个对象，在这个对象的头部有两位，用来指定锁的类型。头部还记录了哪个线程
申请了这把锁。
偏向锁的概念就是当这个线程来的时候先不加锁，只是记录这个线程的id值。
那么我们就认为这个对象是这个线程独有。
下次再来申请这把锁的时候，就会倾向于这个线程，所以如果是原来的线程，那么
就偏向你，你就直接用吧，不要考虑加锁的问题。所以效率会很高。
如果两个线程来了就不会有偏向锁了，只有一个线程的时候是偏向锁。
如果新线程的id不是对象记录的，那么这个时候就会进行锁升级，这个时候首先是自旋锁。
自旋锁的意思就是一个线程已经拿到这把锁了，另外一个线程就在旁边转圈。循环 ，我能不能
拿到这把锁啊，我能不能拿到这把锁啊，然后循环，转10圈， 如果占用锁的线程释放了，那么正在转圈的
就可以拿到了。如果10圈还不行就
那么这个时候就开始申请重量级的锁了。这个时候就进入os的等待对列了。它就不在占用cpu时间了。
很多的Lock底层用的是CAS的操作。占用cpu时间
synchronize 是wait不占用cpu时间的。
```
```
# 阿里淘系面经
### 一面：
1、聊之前的项目经验，详细描述
2、Java知识体系中整体的集合框架
3、为什么hashmap在jdk8的时候要进行树化（泊松分布）
4、hashmap线程安全的方式（concurrenthashmap源码层次）
5、锁的分类
```
乐观锁、悲观锁、自旋锁、读写锁、排他锁、共享锁、分段锁的各种机制及实现方式
```
6、spring IOC的底层实现
```
XML、dom4j、工厂、单例
```
7、mysql索引的分类及实现机制
### 二面
1、介绍项目
2、线程池的创建方式、分类、应用场景、拒绝策略的场景
3、spring AOP的底层实现
```
动态代理、newProxyInstance、cglib、SAM
```
4、代理模式
```
静态代理、动态代理
```
5、详细介绍自己的设计模式
### 三面
1、千万级数据量的list找一个数据（抢红包案例）
### 四面
1、详细项目介绍
2、JVM内存管理
```
栈上分配->TLAB->新声代、老年代->可达性分析->GC算法->所有垃圾回收器及其优缺点和特点
那到底多大的对象会被直接扔到老年代
G1两个region不是连续的，而且之间还有可达的引用，我现在要回收其中一个，另一个会被怎么处理
CMS的并发预处理和并发可中断预处理
```
### 五面
1、百万级int数据量的一个array求和（fork/join）
### 六面
1、参加面试的是硕士，所以问了科研项目
### 七面
1、聊人生
```
```
/**
* volatile ¹Ø¼ü×Ö£¬Ê¹Ò»¸ö±äÁ¿ÔÚ¶à¸öÏ̼߳ä¿É¼û
* A BÏ̶߳¼Óõ½Ò»¸ö±äÁ¿£¬javaĬÈÏÊÇAÏß³ÌÖб£ÁôÒ»·Ýcopy£¬ÕâÑùÈç¹ûBÏß³ÌÐÞ¸ÄÁ˸ñäÁ¿£¬ÔòAÏß³Ìδ±ØÖªµÀ
* ʹÓÃvolatile¹Ø¼ü×Ö£¬»áÈÃËùÓÐÏ̶߳¼»á¶Áµ½±äÁ¿µÄÐÞ¸ÄÖµ
*
* ÔÚÏÂÃæµÄ´úÂëÖУ¬runningÊÇ´æÔÚÓÚ¶ÑÄÚ´æµÄt¶ÔÏóÖÐ
* µ±Ïß³Ìt1¿ªÊ¼ÔËÐеÄʱºò£¬»á°ÑrunningÖµ´ÓÄÚ´æÖжÁµ½t1Ï̵߳Ť×÷Çø£¬ÔÚÔËÐйý³ÌÖÐÖ±½ÓʹÓÃÕâ¸öcopy£¬²¢²»»áÿ´Î¶¼È¥
* ¶ÁÈ¡¶ÑÄڴ棬ÕâÑù£¬µ±Ö÷Ïß³ÌÐÞ¸ÄrunningµÄÖµÖ®ºó£¬t1Ï̸߳ÐÖª²»µ½£¬ËùÒÔ²»»áÍ£Ö¹ÔËÐÐ
*
* ʹÓÃvolatile£¬½«»áÇ¿ÖÆËùÓÐÏ̶߳¼È¥¶ÑÄÚ´æÖжÁÈ¡runningµÄÖµ
*
* ¿ÉÒÔÔĶÁÕâƪÎÄÕ½øÐиüÉîÈëµÄÀí½â
* http://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html
*
* volatile²¢²»Äܱ£Ö¤¶à¸öÏ̹߳²Í¬ÐÞ¸Ärunning±äÁ¿Ê±Ëù´øÀ´µÄ²»Ò»ÖÂÎÊÌ⣬Ҳ¾ÍÊÇ˵volatile²»ÄÜÌæ´úsynchronized
* @author mashibing
*/
package com.mashibing.juc.c_012_Volatile;
import java.util.concurrent.TimeUnit;
public class T01_HelloVolatile {
/*volatile*/ boolean running = true; //对比一下有无volatile的情况下，整个程序运行结果的区别。加上volatiile就能停止，否则就不能看到m end
void m() {
System.out.println("m start");
while(running) {
}
System.out.println("m end!");
}
public static void main(String[] args) {
T01_HelloVolatile t = new T01_HelloVolatile();
new Thread(t::m, "t1").start();
// lambda表达式 new Thread(new Runable(run())) {m()}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.running = false;
}
}
```
```
/**
* synchronized优化
* 同步代码块中的语句越少越好
* 比较m1和m2
* @author mashibing
*/
package com.mashibing.juc.c_016_LockOptimization;
import java.util.concurrent.TimeUnit;
public class FineCoarseLock {
int count = 0;
synchronized void m1() {
//do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
count ++;
//do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
void m2() {
//do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
//采用细粒度的锁，可以使线程争用时间变短，从而提高效率
synchronized(this) {
count ++;
}
//do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
有的时候还会进行锁的粗化，什么叫做锁的粗化，就是比如很多很细粒度的锁，那么就会导致争用，那么你还不如在稍微大的范围内使用锁，这个就是锁的粗话。
```
```java
/**
有些特别常见的操作总是需要加锁，加锁情况特别多，所以干脆java提供常见操作的类，
这个类内部就有所，不是synchronized重量锁，而是CAS号称无锁。
解决同样的问题的更搞笑的方法，使用AtomXXX类。
AtomXXX类本方法都是原子性的，单不能保证多个方法连续调用是原子性的。
*/
package com.mashibing.juc.c_018_00_AtomicXXX;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class T01_AtomicInteger {
/*volatile*/ //int count1 = 0; 这个不需要了
AtomicInteger count = new AtomicInteger(0);
/*synchronized 这个不需要了*/ void m() {
for (int i = 0; i < 10000; i++)
//if count1.get() < 1000
count.incrementAndGet(); //count1++
}
public static void main(String[] args) {
T01_AtomicInteger t = new T01_AtomicInteger();
List<Thread> threads = new ArrayList<Thread>();
for (int i = 0; i < 10; i++) {
threads.add(new Thread(t::m, "thread-" + i));
}
threads.forEach((o) -> o.start());
threads.forEach((o) -> {
try {
o.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(t.count);
}
}
```
CAS就是乐观锁的概念，synchronized悲观锁。
```
package com.mashibing.juc.c_018_00_AtomicXXX;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.LongAdder;
public class T02_AtomicVsSyncVsLongAdder {
static long count2 = 0L;
static AtomicLong count1 = new AtomicLong(0L);
static LongAdder count3 = new LongAdder();
public static void main(String[] args) throws Exception {
Thread[] threads = new Thread[1000];
for(int i=0; i<threads.length; i++) {
threads[i] =
new Thread(()-> {
for(int k=0; k<100000; k++) count1.incrementAndGet();
});
}
long start = System.currentTimeMillis();
for(Thread t : threads ) t.start();
for (Thread t : threads) t.join();
long end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("Atomic: " + count1.get() + " time " + (end-start));
//-----------------------------------------------------------
Object lock = new Object();
for(int i=0; i<threads.length; i++) {
threads[i] =
new Thread(new Runnable() {
@Override
public void run() {
for (int k = 0; k < 100000; k++)
synchronized (lock) {
count2++;
}
}
});
}
start = System.currentTimeMillis();
for(Thread t : threads ) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
System.out.println("Sync: " + count2 + " time " + (end-start));
//----------------------------------
for(int i=0; i<threads.length; i++) {
threads[i] =
new Thread(()-> {
for(int k=0; k<100000; k++) count3.increment();
});
}
start = System.currentTimeMillis();
for(Thread t : threads ) t.start();
for (Thread t : threads) t.join();
end = System.currentTimeMillis();
//TimeUnit.SECONDS.sleep(10);
System.out.println("LongAdder: " + count1.longValue() + " time " + (end-start));
}
static void microSleep(int m) {
try {
TimeUnit.MICROSECONDS.sleep(m);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
```
运行结果如下：
看上面的运行结果，为什么Atomic要比synchronized快？
atomic不需要加锁，synchronized可能申请重量级锁，操作系统锁，所以需要偏低。longAdder为什么要比其他两个都要快？因为有分段!
```
package com.mashibing.juc.c_018_01_Unsafe;
//import sun.misc.*;
import sun.misc.Unsafe;
public class HelloUnsafe {
static class M {
private M() {}
int i =0;
}
public static void main(String[] args) throws InstantiationException {
Unsafe unsafe = Unsafe.getUnsafe();
M m = (M)unsafe.allocateInstance(M.class);
m.i = 9;
System.out.println(m.i);
}
}
```
接下来讲一些基于CAS操作的新类型的锁，老类型的锁是synchronized。
```java
/*
reentrantlock可重入锁，用于替代synchronized
本利中由于m1锁定this，只有m1执行完毕的时候，m2才能执行
这里是复习synchronized最原始的语义
可重复的意思是，我对一个对象锁了一次之后还可以继续锁几次。
*/
package com.mashibing.juc.c_020;
import java.util.concurrent.TimeUnit;
public class T01_ReentrantLock1 {
synchronized void m1() {
for(int i=0; i<10; i++) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i);
if(i == 2) m2();
}
}
synchronized void m2() {
System.out.println("m2 ...");
}
public static void main(String[] args) {
T01_ReentrantLock1 rl = new T01_ReentrantLock1();
new Thread(rl::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//new Thread(rl::m2).start();
}
}
这个程序里面使用的是synchronized，synchronized必须是可重入的，否则父类的一个方法是synchronized那么子类无法调用父类方法，那就麻烦了，因为synchronized要调用synchronized，不可重入就死锁了。
```
```java
/**
可重复的意思是，我对一个对象锁了一次之后还可以继续锁几次。
ReentrantLock可以替换synchronized。ReentrantLock必须要手动上锁和解锁。
所以unlock必须写在try finally的finally中。
使用synchronized锁定的话，如果遇到异常，jvm就会自动释放锁，但是lock必须
手动释放锁。
*/
package com.mashibing.juc.c_020;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class T02_ReentrantLock2 {
Lock lock = new ReentrantLock();
void m1() {
try {
lock.lock(); //synchronized(this)
for (int i = 0; i < 10; i++) {
TimeUnit.SECONDS.sleep(1);
System.out.println(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
void m2() {
try {
lock.lock();
System.out.println("m2 ...");
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
T02_ReentrantLock2 rl = new T02_ReentrantLock2();
new Thread(rl::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(rl::m2).start();
}
}
```
```java
/**
* reentrantlock用于替代synchronized
* 由于m1锁定this,只有m1执行完毕的时候,m2才能执行
* 这里是复习synchronized最原始的语义
*
* 使用reentrantlock可以完成同样的功能
* 需要注意的是，必须要必须要必须要手动释放锁（重要的事情说三遍）
* 使用syn锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放
*
* 使用reentrantlock可以进行“尝试锁定”tryLock，这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
* @author mashibing
*/
package com.mashibing.juc.c_020;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class T03_ReentrantLock3 {
Lock lock = new ReentrantLock();
void m1() {
try {
lock.lock();
for (int i = 0; i < 3; i++) {
TimeUnit.SECONDS.sleep(1);
System.out.println(i);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
/**
* 使用tryLock进行尝试锁定，不管锁定与否，方法都将继续执行
* 可以根据tryLock的返回值来判定是否锁定
* 也可以指定tryLock的时间，由于tryLock(time)抛出异常，所以要注意unclock的处理，必须放到finally中
*/
void m2() {
/*
boolean locked = lock.tryLock();
System.out.println("m2 ..." + locked);
if(locked) lock.unlock();
*/
boolean locked = false;
try {
locked = lock.tryLock(5, TimeUnit.SECONDS);
System.out.println("m2 ..." + locked);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(locked) lock.unlock();
}
}
public static void main(String[] args) {
T03_ReentrantLock3 rl = new T03_ReentrantLock3();
new Thread(rl::m1).start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(rl::m2).start();
}
}
```
公平锁的概念
```
/**
* reentrantlock用于替代synchronized
* 由于m1锁定this,只有m1执行完毕的时候,m2才能执行
* 这里是复习synchronized最原始的语义
*
* 使用reentrantlock可以完成同样的功能
* 需要注意的是，必须要必须要必须要手动释放锁（重要的事情说三遍）
* 使用syn锁定的话如果遇到异常，jvm会自动释放锁，但是lock必须手动释放锁，因此经常在finally中进行锁的释放
*
* 使用reentrantlock可以进行“尝试锁定”tryLock，这样无法锁定，或者在指定时间内无法锁定，线程可以决定是否继续等待
*
* 使用ReentrantLock还可以调用lockInterruptibly方法，可以对线程interrupt方法做出响应，
* 在一个线程等待锁的过程中，可以被打断
*
* ReentrantLock还可以指定为公平锁,默认是非公平锁
*
* @author mashibing
*/
package com.mashibing.juc.c_020;
import java.util.concurrent.locks.ReentrantLock;
public class T05_ReentrantLock5 extends Thread {
private static ReentrantLock lock=new ReentrantLock(true); //参数为true表示为公平锁，请对比输出结果
public void run() {
for(int i=0; i<100; i++) {
lock.lock();
try{
System.out.println(Thread.currentThread().getName()+"获得锁");
}finally{
lock.unlock();
}
}
}
public static void main(String[] args) {
T05_ReentrantLock5 rl=new T05_ReentrantLock5();
Thread th1=new Thread(rl);
Thread th2=new Thread(rl);
th1.start();
th2.start();
}
}
上面的程序，如果没有设置true，也就是公平锁。那么就是大片的输出t1，然后t2.但是如果设置了true，那么就可以看到有t1和t2的交替的输出。但是也能在其中看到t1连着输出，或者t2连着输出这种。这是因为，当t1执行时间片到了，t2还没有进入线程队列，所以下一次拿到的还是t1,所以输出的就还是t1。
公平锁不能说完全的公平。不能说我执行完了就是你执行。
```
```
package com.mashibing.juc.c_020;
//这个程序讲解：CountDownLatch 倒数门栓的概念。就是倒数多少秒之后，这个门栓就打开了
import java.util.concurrent.CountDownLatch;
public class T06_TestCountDownLatch {
public static void main(String[] args) {
usingJoin();
usingCountDownLatch();
}
private static void usingCountDownLatch() {
Thread[] threads = new Thread[100];
// 就是等待这100个线程，然后这100个线程，执行完成了一个然后就减去1。直接最后全部完成减1,再继续后面的内容。 一个门栓，栓在哪里，什么时候结束，继续往后走。
CountDownLatch latch = new CountDownLatch(threads.length);
for(int i=0; i<threads.length; i++) {
threads[i] = new Thread(()->{
int result = 0;
for(int j=0; j<10000; j++) result += j;
latch.countDown(); //countDown本身就是原子的
});
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end latch");
}
private static void usingJoin() {
Thread[] threads = new Thread[100];
for(int i=0; i<threads.length; i++) {
threads[i] = new Thread(()->{
int result = 0;
for(int j=0; j<10000; j++) result += j;
});
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
for (int i = 0; i < threads.length; i++) {
try {
threads[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("end join");
}
}
```
```java
package com.mashibing.juc.c_020;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
//这一讲讲CyclicBarrier
// CyclicBarrier 另外一个同步工具。 栅栏CyclicBarrier 什么时候人满了，就把栅栏推到。
// 就像发令枪一样。循环的， 什么时候人满了，就把栅栏推到。然后再把栅栏立起来， 什么时候人满了，就把栅栏再次推到。就这样循环
public class T07_TestCyclicBarrier {
public static void main(String[] args) {
//CyclicBarrier barrier = new CyclicBarrier(20);
两个参数，第二个参数你不传递也可以，表示满人了之后，你什么也不做。第一个参数表示多少人。
CyclicBarrier barrier = new CyclicBarrier(20, () -> System.out.println("满人"));
/*CyclicBarrier barrier = new CyclicBarrier(20, new Runnable() {
@Override
public void run() {
System.out.println("满人，发车");
}
});*/
for(int i=0; i<100; i++) {
new Thread(()->{
try {
barrier.await();//在这里等待，来了一个人就等待，来了一个人再等待。
直到20个了，就开始运行后面的。
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
有些线程必须要等待其他线程也完成了才能接着往下走。
```
```java
package com.mashibing.juc.c_020;
import java.util.Random;
import java.util.concurrent.Phaser;
import java.util.concurrent.TimeUnit;
/*
Phaser 按照不同的阶段，对线程进行执行。
遗传算法里面有使用
CyclicBarrier是一个栅栏循环使用
MarriagePhaser 则是一个栅栏，接着一个栅栏，然后再接着一个栅栏，那么使用
*/
public class T08_TestPhaser {
static Random r = new Random();
static MarriagePhaser phaser = new MarriagePhaser();
static void milliSleep(int milli) {
try {
TimeUnit.MILLISECONDS.sleep(milli);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
phaser.bulkRegister(5);
for(int i=0; i<5; i++) {
final int nameIndex = i;
new Thread(()->{
Person p = new Person("person " + nameIndex);
p.arrive();
phaser.arriveAndAwaitAdvance();
p.eat();
phaser.arriveAndAwaitAdvance();
p.leave();
phaser.arriveAndAwaitAdvance();
}).start();
}
}
static class MarriagePhaser extends Phaser {
advance表示前进
所有的线程都满足第一个条件了，那么onAdvance自动调用
@Override
protected boolean onAdvance(int phase, int registeredParties) {
switch (phase) {
case 0:
System.out.println("所有人到齐了！");
return false;
case 1:
System.out.println("所有人吃完了！");
return false;
case 2:
System.out.println("所有人离开了！");
System.out.println("婚礼结束！");
return true;
default:
return true;
}
}
}
static class Person {
String name;
public Person(String name) {
this.name = name;
}
public void arrive() {
milliSleep(r.nextInt(1000));
System.out.printf("%s 到达现场！\n", name);
}
public void eat() {
milliSleep(r.nextInt(1000));
System.out.printf("%s 吃完!\n", name);
}
public void leave() {
milliSleep(r.nextInt(1000));
System.out.printf("%s 离开！\n", name);
}
}
}
```
接下来讲读写锁。
```
package com.mashibing.juc.c_020;
/*
ReentrantReadWriteLock 读写锁
*/
import java.util.Random;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class T10_TestReadWriteLock {
static Lock lock = new ReentrantLock();
private static int value;
static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
static Lock readLock = readWriteLock.readLock();
static Lock writeLock = readWriteLock.writeLock();
public static void read(Lock lock) {
try {
lock.lock();
Thread.sleep(1000);
System.out.println("read over!");
//模拟读取操作
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void write(Lock lock, int v) {
try {
lock.lock();
Thread.sleep(1000);
value = v;
System.out.println("write over!");
//模拟写操作
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
（1）//Runnable readR = ()-> read(lock);
（2） Runnable readR = ()-> read(readLock);
（1） //Runnable writeR = ()->write(lock, new Random().nextInt());
（2） Runnable writeR = ()->write(writeLock, new Random().nextInt());
for(int i=0; i<18; i++) new Thread(readR).start();
for(int i=0; i<2; i++) new Thread(writeR).start();
}
}
把（1）全打开运行和（2）全打开运行，分别测试执行时间。可以看到使用读写锁，效率非常高。
```
以后还写synchronized吗？前面讲了这么多的锁，我们以后写代码还使用synchronized吗？使用，以后上来还是使用synchronized，不要使用其他的锁。除非你要非常的追求效率。
```
package com.mashibing.juc.c_020;
/*
Semaphore信号量，信号灯。
只要信号灯亮了就可以执行。
*/
import java.util.concurrent.Semaphore;
public class T11_TestSemaphore {
public static void main(String[] args) {
//Semaphore s = new Semaphore(2);
如果写1，那么就是只有一个线程能够执行，然后另外的一个就要等着。如果是2那么就是两个线程都可以执行。
Semaphore s = new Semaphore(2, true);//第二个参数表示是否公平。
//公平就是有一个队列，大家在哪里等着，你新来的线程如果排队，那么就是公平，如果你不排队，那么就不公平
//允许一个线程同时执行
//Semaphore s = new Semaphore(1);
new Thread(()->{
try {
s.acquire();//阻塞方法，如果得不到，那么就停止到这里。拿到之后就减去1.
System.out.println("T1 running...");
Thread.sleep(200);
System.out.println("T1 running...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
s.release(); //release之后就加上1
}
}).start();
new Thread(()->{
try {
s.acquire();
System.out.println("T2 running...");
Thread.sleep(200);
System.out.println("T2 running...");
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
这个和线程池还是不同的，比如我new了一个线程池，线程池中有两个线程，那么就是只有两个线程。
但是我们的Semaphore是两个信号量，可以有多个线程，比如有100个线程，但是同时运行的只能有两个。
```
```
package com.mashibing.juc.c_020;
import java.util.concurrent.Exchanger;
/*
Exchanger 交换器。
这是一个容器里面可以有两个格子。exchanger.exchange 这个方法是阻塞的。
注意Exchanger 只能是两个线程。不可能多于两个线程。
*/
public class T12_TestExchanger {
static Exchanger<String> exchanger = new Exchanger<>();
public static void main(String[] args) {
new Thread(()->{
String s = "T1";
try {
s = exchanger.exchange(s);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + s);
}, "t1").start();
new Thread(()->{
String s = "T2";
try {
s = exchanger.exchange(s);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + s);
}, "t2").start();
}
}
```
实战JAVA高并发程序设计(第2版) 葛一鸣 这本书入门很好，多线程。
乐观锁 cas
悲观锁 synchronized
自旋锁cas
读写锁就是共享锁和排它锁
分段锁longaddr concurrenthashmap
良老师讲的concurrenthashmap公开课。很深入
synchronized要锁定一个对象的时候，上来的第一个状态是无锁。
然后接下来是偏向锁，只有一个线程占用这个对象的时候，这个时候对象
头部有两位用来记录锁的状态。只给这一个线程用这个时候就是偏向锁。
接下来是轻量级锁，然后最后就是重量级锁。
synchronized和reentrantlock的不同？
synchronized系统自动加锁和自动解锁。reentrantlock是手动加锁和手动解锁
reentrantlock可以有各种各样的condition，condition，代表不同的等待对象
reentrantlock底层是cas
synchronized底层是锁升级
```
package com.mashibing.juc.c_020;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
/*
接着讲LockSupport
*/
public class T13_TestLockSupport {
public static void main(String[] args) {
Thread t = new Thread(()->{
for (int i = 0; i < 10; i++) {
System.out.println(i);
if(i == 5) {
LockSupport.park();//当前线程停车，走到5的时候，就停车，停车场不就是park吗
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
LockSupport.unpark(t);//t这个线程请你不要停在哪里了，你继续向前运行吧
/*try {
TimeUnit.SECONDS.sleep(8);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("after 8 senconds!");
LockSupport.unpark(t);*/
}
}
LockSupport 当前线程阻塞。
以前想让当前线程阻塞就是用wait allwait等，你想用wait的话，一定是synchronized加载某个对象上。
原来叫醒一个线程，那么就使用notify叫醒线程，但是线程在线程阻塞队列里面。没法直接叫醒指定线程。但是LockSupport可以。
LockSupport不需要，LockSupport想什么时候停止就什么时候停止
```
研究一下这个函数 **TimeUnit.SECONDS.sleep(1);**
```
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 分析下面这个程序，能完成这个功能吗？
答：不能实现这个功能，我们发现，这个程序走到9也没有输出，然后卡在哪里了。我们想是因为没有加
volatile导致线程之间是不可见的。那么我们就给ArrayList添加一个volatile 所以有接下来的一段代码T02_WithVolatile
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class T01_WithoutVolatile {
List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T01_WithoutVolatile c = new T01_WithoutVolatile();
new Thread(() -> {
for(int i=0; i<10; i++) {
c.add(new Object());
System.out.println("add " + i);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1").start();
new Thread(() -> {
while(true) {
if(c.size() == 5) {
break;
}
}
System.out.println("t2 结束");
}, "t2").start();
}
}
```
```
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，
* 而且，如果在if 和 break之间被别的线程打断，得到的结果也不精确，
* 该怎么做呢？
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class T02_WithVolatile {
//添加volatile，使t2能够得到通知
//volatile List lists = new LinkedList();
//最开始老师讲的时候，使用的是上面的这段代码，当时没有去掉sleep所以感觉行了。但是后来去掉了sleep之后，就不可以了。
为什么这里加上了volatile解决不了前面说的问题。
因为如果这里加上了volatile实际上是对引用添加了volatile。那么这是在一个引用上添加了volatile，如果是在引用上添加了volatile，引用所指向的东西里面的属性改变了volatile是感知不到的。但是如果引用指向了另外的一个，那么才能感知到。所以
使用volatile是不能解决这个问题的，那么为什么看起来好了那？因为有sleep，在sleep(1)的时候，list的cout++执行。所以size改变了。所以看起来好像是行的。
volatile尽量修饰简单类型的值。如果是引用的话，这个引用对象里面的内容发生了改变。那么volatile是感知不到的。
volatile List lists = Collections.synchronizedList(new LinkedList<>());
// 要解决这个问题，就要使用同步，使用synchronized
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T02_WithVolatile c = new T02_WithVolatile();
new Thread(() -> {
for(int i=0; i<10; i++) {
c.add(new Object());
System.out.println("add " + i);
/*try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
}
}, "t1").start();
new Thread(() -> {
while(true) {
if(c.size() == 5) {
break;
}
}
System.out.println("t2 结束");
}, "t2").start();
}
}
```
```
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class T03_NotifyHoldingLock { //wait notify
//添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T03_NotifyHoldingLock c = new T03_NotifyHoldingLock();
final Object lock = new Object();
new Thread(() -> {
synchronized(lock) {
System.out.println("t2启动");
if(c.size() != 5) {//首先启动了观察者线程，如果不到5那么我就wait
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("t2 结束");
}
}, "t2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1启动");
synchronized(lock) {
for(int i=0; i<10; i++) {//添加直到5的时候，才notify
c.add(new Object());
System.out.println("add " + i);
if(c.size() == 5) {
lock.notify();
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "t1").start();
}
}
这里使用wait和notify做到，wait会释放锁，而notify不会释放锁。
你是wait了，wait之后会释放掉锁，然后将来你得到了锁之后才能继续运行。
但是notify通知你了让你别wait了，但是notify不会释放掉锁。所以尽管wait被叫醒了。但是wait拿不到锁，因为锁被notify一致的拿着。
wait会释放锁，而notify不会释放锁。wait停了，将来要在停的地方继续执行，wait要回来执行的时候，要拿到锁。这里是重点 重点
那么wait和notify怎么解决？向容器添加元素的那个线程，notify之后了，调用wait，进行等待。这样添加线程就会释放掉锁。然后
判断等于5的线程就会得到锁，然后向下继续执行。执行完成了也调用notify，让添加线程不要在等待了，你去继续执行。
```
```
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
*
* notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
* 整个通信过程比较繁琐
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class T04_NotifyFreeLock {
//添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T04_NotifyFreeLock c = new T04_NotifyFreeLock();
final Object lock = new Object();
new Thread(() -> {
synchronized(lock) {
System.out.println("t2启动");
if(c.size() != 5) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("t2 结束");
//通知t1继续执行
lock.notify();
}
}, "t2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1启动");
synchronized(lock) {
for(int i=0; i<10; i++) {
c.add(new Object());
System.out.println("add " + i);
if(c.size() == 5) {
lock.notify();
//释放锁，让t2得以执行
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "t1").start();
}
}
```
接下来就想办法使用CountDown解决这个问题？能解决吗？
```
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
*
* notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
* 整个通信过程比较繁琐
*
* 使用Latch（门闩）替代wait notify来进行通知
* 好处是通信方式简单，同时也可以指定等待时间
* 使用await和countdown方法替代wait和notify
* CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行
* 当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了
* 这时应该考虑countdownlatch/cyclicbarrier/semaphore
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class T05_CountDownLatch {
// 添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T05_CountDownLatch c = new T05_CountDownLatch();
CountDownLatch latch = new CountDownLatch(1);
new Thread(() -> {
System.out.println("t2启动");
if (c.size() != 5) {
try {
latch.await();
//也可以指定等待时间
//latch.await(5000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("t2 结束");
}, "t2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1启动");
for (int i = 0; i < 10; i++) {
c.add(new Object());
System.out.println("add " + i);
if (c.size() == 5) {
// 打开门闩，让t2得以执行
latch.countDown();
}
/*try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
//这段注释掉，问题马上就显现出来了。睡这一秒的时候看不出什么问题。但是如果不睡这一秒就出现问题了。
因为打印的太快了，前一个线程打印到5的时候，确实打开门闩，让t2得以执行，但是t1接着蹭蹭蹭往下跑继续打印。
那么t2尽管也开始继续了。但是打印的不够快。所以显示的还是t1的值。
那么如果我就是想要使用门栓，我还要解决这个问题？我该怎么解决？
用两个门栓。自己写，两个门栓的代码
}
}, "t1").start();
}
}
```
```
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
*
* notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
* 整个通信过程比较繁琐
*
* 使用Latch（门闩）替代wait notify来进行通知
* 好处是通信方式简单，同时也可以指定等待时间
* 使用await和countdown方法替代wait和notify
* CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行
* 当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了
* 这时应该考虑countdownlatch/cyclicbarrier/semaphore
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
//TODO park unpark
public class T06_LockSupport {
// 添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
T06_LockSupport c = new T06_LockSupport();
CountDownLatch latch = new CountDownLatch(1);
Thread t2 = new Thread(() -> {
System.out.println("t2启动");
if (c.size() != 5) {
LockSupport.park();
}
System.out.println("t2 结束");
}, "t2");
t2.start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1启动");
for (int i = 0; i < 10; i++) {
c.add(new Object());
System.out.println("add " + i);
if (c.size() == 5) {
LockSupport.unpark(t2);
}
/*try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
}
}, "t1").start();
}
}
同样如果我使用的是LockSupport.unpark和LockSupport.park也要使用两个才能解决。否则也会出现问题。
```
```
/**
* 曾经的面试题：（淘宝？）
* 实现一个容器，提供两个方法，add，size
* 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束
*
* 给lists添加volatile之后，t2能够接到通知，但是，t2线程的死循环很浪费cpu，如果不用死循环，该怎么做呢？
*
* 这里使用wait和notify做到，wait会释放锁，而notify不会释放锁
* 需要注意的是，运用这种方法，必须要保证t2先执行，也就是首先让t2监听才可以
*
* 阅读下面的程序，并分析输出结果
* 可以读到输出结果并不是size=5时t2退出，而是t1结束时t2才接收到通知而退出
* 想想这是为什么？
*
* notify之后，t1必须释放锁，t2退出后，也必须notify，通知t1继续执行
* 整个通信过程比较繁琐
*
* 使用Latch（门闩）替代wait notify来进行通知
* 好处是通信方式简单，同时也可以指定等待时间
* 使用await和countdown方法替代wait和notify
* CountDownLatch不涉及锁定，当count的值为零时当前线程继续运行
* 当不涉及同步，只是涉及线程通信的时候，用synchronized + wait/notify就显得太重了
* 这时应该考虑countdownlatch/cyclicbarrier/semaphore
* @author mashibing
*/
package com.mashibing.juc.c_020_01_Interview;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;
//TODO park unpark
public class T07_LockSupport_WithoutSleep {
// 添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
static Thread t1 = null, t2 = null;
public static void main(String[] args) {
T07_LockSupport_WithoutSleep c = new T07_LockSupport_WithoutSleep();
t1 = new Thread(() -> {
System.out.println("t1启动");
for (int i = 0; i < 10; i++) {
c.add(new Object());
System.out.println("add " + i);
if (c.size() == 5) {
LockSupport.unpark(t2);
LockSupport.park();
}
}
}, "t1");
t2 = new Thread(() -> {
//System.out.println("t2启动");
//if (c.size() != 5) {
LockSupport.park();
//}
System.out.println("t2 结束");
LockSupport.unpark(t1);
}, "t2");
t2.start();
t1.start();
}
}
```
```
package com.mashibing.juc.c_020_01_Interview;
// 使用Semaphore解决这个问题
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.LockSupport;
public class T08_Semaphore {
// 添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
static Thread t1 = null, t2 = null;
public static void main(String[] args) {
T08_Semaphore c = new T08_Semaphore();
Semaphore s = new Semaphore(1);
t1 = new Thread(() -> {
try {
s.acquire();
for (int i = 0; i < 5; i++) {
c.add(new Object());
System.out.println("add " + i);
}
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
t2.start();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
s.acquire();
for (int i = 5; i < 10; i++) {
System.out.println(i);
}
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t1");
t2 = new Thread(() -> {
try {
s.acquire();
System.out.println("t2 结束");
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t2");
t1.start();
}
}
```
作业：
到此为止，那么我就把这个淘宝的面试题全部讲完了。
接下来我们讲另外的一个题目，经典的生产者和消费者问题：
```
这是一个同步容器，多线程往里面装，多线程往出拿。
必须在get，put方法加上synchronized，否则添加了还没有cout++,取出来了还没有cout--，就出问题了。
/**
* 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
* 能够支持2个生产者线程以及10个消费者线程的阻塞调用
*
* 使用wait和notify/notifyAll来实现
*
* @author mashibing
*/
package com.mashibing.juc.c_021_01_interview;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
public class MyContainer1<T> {
final private LinkedList<T> lists = new LinkedList<>();
final private int MAX = 10; //最多10个元素
private int count = 0;
public synchronized void put(T t) {
while(lists.size() == MAX) { //想想为什么用while而不是用if？
因为如果这里使用的if，那么this.wait醒了之后，那么就会继续往下走，而不是回来先检查一下是不是满了。
所以就会出现问题，你醒了之后应该是先检查lists.size()==Max如果是就继续wait否则就生产，往里面放。
如果是if那么就不进行任何的判断，那么就会导致直接的往下面走，那么可已经满了，然后你还往里面添加内容。
你醒了的时候还要判断一遍，哥们你是不是还是满着的。
try {
this.wait(); //effective java
} catch (InterruptedException e) {
e.printStackTrace();
}
}
lists.add(t);
++count;
this.notifyAll(); //通知消费者线程进行消费
}
public synchronized T get() {
T t = null;
while(lists.size() == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
t = lists.removeFirst();
count --;
this.notifyAll(); //通知生产者进行生产
return t;
}
public static void main(String[] args) {
MyContainer1<String> c = new MyContainer1<>();
//启动消费者线程
for(int i=0; i<10; i++) {
new Thread(()->{
for(int j=0; j<5; j++) System.out.println(c.get());
}, "c" + i).start();
}
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//启动生产者线程
for(int i=0; i<2; i++) {
new Thread(()->{
for(int j=0; j<25; j++) c.put(Thread.currentThread().getName() + " " + j);
}, "p" + i).start();
}
}
}
```
注意前面的这段代码还是有问题的，什么问题，就是使用的是this.notifyAll()这个程序中有2个生产者，10个消费者。
那么当你this.notifyAll的时候，比如生产者this.notifyAll的时候，它不仅叫醒所有的消费者，还会叫醒其他的生产者，然后大家一
起抢这把锁，这样就会出现问题。为应该只是叫醒消费者，没有必要叫醒其他的生产者？所以我们接下来要实现的就是生产者叫醒
消费者，消费者只是叫醒生产者。
```
/**
这个也要背过。*****
* 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
* 能够支持2个生产者线程以及10个消费者线程的阻塞调用
*
* 使用wait和notify/notifyAll来实现
*
* 使用Lock和Condition来实现
* 对比两种方式，Condition的方式可以更加精确的指定哪些线程被唤醒
*
* @author mashibing
*/
package com.mashibing.juc.c_021_01_interview;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyContainer2<T> {
final private LinkedList<T> lists = new LinkedList<>();
final private int MAX = 10; //最多10个元素
private int count = 0;
private Lock lock = new ReentrantLock();
private Condition producer = lock.newCondition();
private Condition consumer = lock.newCondition();
public void put(T t) {
try {
lock.lock();
while(lists.size() == MAX) { //想想为什么用while而不是用if？
producer.await();
}
lists.add(t);
++count;
consumer.signalAll(); //通知消费者线程进行消费
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public T get() {
T t = null;
try {
lock.lock();
while(lists.size() == 0) {
consumer.await();
}
t = lists.removeFirst();
count --;
producer.signalAll(); //通知生产者进行生产
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
return t;
}
public static void main(String[] args) {
MyContainer2<String> c = new MyContainer2<>();
//启动消费者线程
for(int i=0; i<10; i++) {
new Thread(()->{
for(int j=0; j<5; j++) System.out.println(c.get());
}, "c" + i).start();
}
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//启动生产者线程
for(int i=0; i<2; i++) {
new Thread(()->{
for(int j=0; j<25; j++) c.put(Thread.currentThread().getName() + " " + j);
}, "p" + i).start();
}
}
}
```
```
/**
这个也要背过。*****
* 面试题：写一个固定容量同步容器，拥有put和get方法，以及getCount方法，
* 能够支持2个生产者线程以及10个消费者线程的阻塞调用
*
* 使用wait和notify/notifyAll来实现
*
* 使用Lock和Condition来实现
* 对比两种方式，Condition的方式可以更加精确的指定哪些线程被唤醒
*
* @author mashibing
*/
package com.mashibing.juc.c_021_01_interview;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyContainer2<T> {
final private LinkedList<T> lists = new LinkedList<>();
final private int MAX = 10; //最多10个元素
private int count = 0;
private Lock lock = new ReentrantLock();
private Condition producer = lock.newCondition();
private Condition consumer = lock.newCondition();
public void put(T t) {
try {
lock.lock();
while(lists.size() == MAX) { //想想为什么用while而不是用if？
producer.await();
}
lists.add(t);
++count;
consumer.signalAll(); //通知消费者线程进行消费
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public T get() {
T t = null;
try {
lock.lock();
while(lists.size() == 0) {
consumer.await();
}
t = lists.removeFirst();
count --;
producer.signalAll(); //通知生产者进行生产
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
return t;
}
public static void main(String[] args) {
MyContainer2<String> c = new MyContainer2<>();
//启动消费者线程
for(int i=0; i<10; i++) {
new Thread(()->{
for(int j=0; j<5; j++) System.out.println(c.get());
}, "c" + i).start();
}
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//启动生产者线程
for(int i=0; i<2; i++) {
new Thread(()->{
for(int j=0; j<25; j++) c.put(Thread.currentThread().getName() + " " + j);
}, "p" + i).start();
}
}
}
```
上面的所有程序都要自己写一遍。你自己写的时候你就发现你写不出来了。
读源码就是读别人的思路，不要读的特别仔细。比如为什么要n++，n--
我们要读spring的源代码，mybatis源码，netty的源代码的时候，发现数据结构的比较少。但是设计模式的非常多。
读代码的时候要尝试去画泳道图，读一个函数 画一个。
```
JUC:java.util.concurrent包名的简写,是关于并发编程的API
```
同步队列和等待队列 ：
同步队列是队列，里面实现了同步，多线程可以安全访问。
等待队列是一把锁，多个线程等待获取锁。
这是两个概念
老婆和老婆饼是不同的东西。
模板方法，就是我在父类里面定义了一个方法。但是我没有实现
我就是给子类去重写。模板是固定的，但是怎么实现是子类的事情。
当我这个执行过程执行到指定的方法的时候，就会去调用子类的方法。
这就是钩子函数，就像一个小钩子一样，钩这子类的实现。
**中间看到了25.56--42:50之间没有看，还有很多没有截图。所以这里图片序号要错开。**
接下来我们就讲ThreadLocal
```
/**
* ThreadLocal线程局部变量
*/
package com.mashibing.juc.c_022_RefTypeAndThreadLocal;
import java.util.concurrent.TimeUnit;
public class ThreadLocal1 {
volatile static Person p = new Person();
public static void main(String[] args) {
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(p.name);
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.name = "lisi";
}).start();
}
}
class Person {
String name = "zhangsan";
}
```
上面这段程序的输出是lisi
然后我们看如下的代码，我们使用ThreadLocal
```
/**
* ThreadLocal线程局部变量
*
* ThreadLocal是使用空间换时间，synchronized是使用时间换空间
* 比如在hibernate中session就存在与ThreadLocal中，避免synchronized的使用
*
* 运行下面的程序，理解ThreadLocal
*
* @author 马士兵
*/
package com.mashibing.juc.c_022_RefTypeAndThreadLocal;
import java.util.concurrent.TimeUnit;
public class ThreadLocal2 {
//volatile static Person p = new Person();
static ThreadLocal<Person> tl = new ThreadLocal<>();
public static void main(String[] args) {
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tl.get());
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
tl.set(new Person());
}).start();
}
static class Person {
String name = "zhangsan";
}
}
```
这段代码运行的结果是null。为什么会是null？
如果我们设置ThreadLocal的话，那么`ThreadLocal<Person> `里面的这个值是线程独有的。
为什么两个线程都向tl里面设置，但是却拿不到那？我们去看源代码
Spring的声明式事务管理，使用的就是ThreadLocal。
接下来讲java的四种引用 : 强软弱虚引用
m=null的意思就是m原来指向了一个new M()对象，然后m=null就是打断了这个引用，m指向任何的东西了。
上面我们就把强引用讲解完了，接下来我们讲解什么是软引用。
system.gc()是full gc
软引用主要用作缓存。比如从内存中读取一个大图片，从数据库中读取一大堆数据。这个时候就可以使用软引用。需要空间你就可以把我干掉。如果不需要那么我就缓存这。
接下来讲，虚引用。
```
/**
*
*
* 一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，
* 也无法通过虚引用来获取一个对象的实例。
* 为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。
* 虚引用和弱引用对关联对象的回收都不会产生影响，如果只有虚引用活着弱引用关联着对象，
* 那么这个对象就会被回收。它们的不同之处在于弱引用的get方法，虚引用的get方法始终返回null,
* 弱引用可以使用ReferenceQueue,虚引用必须配合ReferenceQueue使用。
*
* jdk中直接内存的回收就用到虚引用，由于jvm自动内存管理的范围是堆内存，
* 而直接内存是在堆内存之外（其实是内存映射文件，自行去理解虚拟内存空间的相关概念），
* 所以直接内存的分配和回收都是有Unsafe类去操作，java在申请一块直接内存之后，
* 会在堆内存分配一个对象保存这个堆外内存的引用，
* 这个对象被垃圾收集器管理，一旦这个对象被回收，
* 相应的用户线程会收到通知并对直接内存进行清理工作。
*
* 事实上，虚引用有一个很重要的用途就是用来做堆外内存的释放，
* DirectByteBuffer就是通过虚引用来实现堆外内存的释放的。
*
*/
package com.mashibing.juc.c_022_RefTypeAndThreadLocal;
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.LinkedList;
import java.util.List;
public class T04_PhantomReference {
//一个队列用来存储对象
private static final List<Object> LIST = new LinkedList<>();
//一个QUEUE里面全是引用
private static final ReferenceQueue<M> QUEUE = new ReferenceQueue<>();
public static void main(String[] args) {
//PhantomReference 虚幻的。
PhantomReference<M> phantomReference = new PhantomReference<>(new M(), QUEUE);
new Thread(() -> {
while (true) {
LIST.add(new byte[1024 * 1024]);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
Thread.currentThread().interrupt();
}
System.out.println(phantomReference.get());
}
}).start();
new Thread(() -> {
while (true) {
Reference<? extends M> poll = QUEUE.poll();
if (poll != null) {
System.out.println("--- 虚引用对象被jvm回收了 ---- " + poll);
}
}
}).start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
```
接下来讲解容器：
容器牵扯到数据结构，算法，容器的组织结构，高并发，所以这里是面试重灾区。
今天将如何使用，然后为线程池的使用做准备。
物理上存储只有两种一种是连续的array，另外一种就是不连续的链表。
逻辑上有很多种，比如树，既可以用array实现，又可以用链表实现。
Queue很大程度上是为了高并发做准备的。为什么有了List还要有Queue，就是为了高并发做准备。
Deque双端队列
最早的时候是HashTable，这里面的所有方法都是synchronized的。所以会导致性能问题
后来作者意识到了问题，所以就有了HashMap，这里面的所有的方法，都没有synchronized。
HashMap没有锁的东西，怎么能让它既能实现有所的功能，又能速度快。
Colletctions.synchronizedMap(New HashMap)
现在HashTable和Vector基本不用。
下面的几个程序都是上半部分是测试写的速度，下半部分测试读的效率。一个程序有两个功能。
```
package com.mashibing.juc.c_023_02_FromHashtableToCHM;
import java.util.Hashtable;
import java.util.UUID;
public class T01_TestHashtable {
static Hashtable<UUID, UUID> m = new Hashtable<>();
static int count = Constants.COUNT;
static UUID[] keys = new UUID[count];
static UUID[] values = new UUID[count];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
static {
for (int i = 0; i < count; i++) {
keys[i] = UUID.randomUUID();
values[i] = UUID.randomUUID();
}
}
static class MyThread extends Thread {
int start;
int gap = count/THREAD_COUNT;
public MyThread(int start) {
this.start = start;
}
@Override
public void run() {
for(int i=start; i<start+gap; i++) {
m.put(keys[i], values[i]);
}
}
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
Thread[] threads = new Thread[THREAD_COUNT];
for(int i=0; i<threads.length; i++) {
threads[i] =
new MyThread(i * (count/THREAD_COUNT));
}
for(Thread t : threads) {
t.start();
}
for(Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.out.println(end - start);
System.out.println(m.size());
//-----------------------------------
start = System.currentTimeMillis();
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
for (int j = 0; j < 10000000; j++) {
m.get(keys[10]);
}
});
}
for(Thread t : threads) {
t.start();
}
for(Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
end = System.currentTimeMillis();
System.out.println(end - start);
}
}
```
```
package com.mashibing.juc.c_023_02_FromHashtableToCHM;
//内部没有锁，所以多线程访问的时候会有问题。想插入100万，但是插入最终可能是92万。
import java.util.HashMap;
import java.util.UUID;
public class T02_TestHashMap {
static HashMap<UUID, UUID> m = new HashMap<>();
static int count = Constants.COUNT;
static UUID[] keys = new UUID[count];
static UUID[] values = new UUID[count];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
static {
for (int i = 0; i < count; i++) {
keys[i] = UUID.randomUUID();
values[i] = UUID.randomUUID();
}
}
static class MyThread extends Thread {
int start;
int gap = count/THREAD_COUNT;
public MyThread(int start) {
this.start = start;
}
@Override
public void run() {
for(int i=start; i<start+gap; i++) {
m.put(keys[i], values[i]);
}
}
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
Thread[] threads = new Thread[THREAD_COUNT];
for(int i=0; i<threads.length; i++) {
threads[i] =
new MyThread(i * (count/THREAD_COUNT));
}
for(Thread t : threads) {
t.start();
}
for(Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.out.println(end - start);
System.out.println(m.size());
}
}
```
```
package com.mashibing.juc.c_023_02_FromHashtableToCHM;
// 因为HashMap没有锁，所以会出现线程安全问题。所以，这里我们使用
Collections.synchronizedMap给这个HashMap添加上锁。
这样可以保证线程安全。
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class T03_TestSynchronizedHashMap {
static Map<UUID, UUID> m = Collections.synchronizedMap(new HashMap<UUID, UUID>());
static int count = Constants.COUNT;
static UUID[] keys = new UUID[count];
static UUID[] values = new UUID[count];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
static {
for (int i = 0; i < count; i++) {
keys[i] = UUID.randomUUID();
values[i] = UUID.randomUUID();
}
}
static class MyThread extends Thread {
int start;
int gap = count/THREAD_COUNT;
public MyThread(int start) {
this.start = start;
}
@Override
public void run() {
for(int i=start; i<start+gap; i++) {
m.put(keys[i], values[i]);
}
}
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
Thread[] threads = new Thread[THREAD_COUNT];
for(int i=0; i<threads.length; i++) {
threads[i] =
new MyThread(i * (count/THREAD_COUNT));
}
for(Thread t : threads) {
t.start();
}
for(Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.out.println(end - start);
System.out.println(m.size());
//-----------------------------------
start = System.currentTimeMillis();
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
for (int j = 0; j < 10000000; j++) {
m.get(keys[10]);
}
});
}
for(Thread t : threads) {
t.start();
}
for(Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
end = System.currentTimeMillis();
System.out.println(end - start);
}
}
```
```
package com.mashibing.juc.c_023_02_FromHashtableToCHM;
//多线程里面真正用的是这个，并发的。
提高效率主要提高在读上面，写上面未必要比前面的好，因为写的时候要进行大量的检查。但是读的效率比前面的都好。
关于效率你还是要真正的使用实测试。
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class T04_TestConcurrentHashMap {
static Map<UUID, UUID> m = new ConcurrentHashMap<>();
static int count = Constants.COUNT;
static UUID[] keys = new UUID[count];
static UUID[] values = new UUID[count];
static final int THREAD_COUNT = Constants.THREAD_COUNT;
static {
for (int i = 0; i < count; i++) {
keys[i] = UUID.randomUUID();
values[i] = UUID.randomUUID();
}
}
static class MyThread extends Thread {
int start;
int gap = count/THREAD_COUNT;
public MyThread(int start) {
this.start = start;
}
@Override
public void run() {
for(int i=start; i<start+gap; i++) {
m.put(keys[i], values[i]);
}
}
}
public static void main(String[] args) {
long start = System.currentTimeMillis();
Thread[] threads = new Thread[THREAD_COUNT];
for(int i=0; i<threads.length; i++) {
threads[i] =
new MyThread(i * (count/THREAD_COUNT));
}
for(Thread t : threads) {
t.start();
}
for(Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.out.println(end - start);
System.out.println(m.size());
//-----------------------------------
start = System.currentTimeMillis();
for (int i = 0; i < threads.length; i++) {
threads[i] = new Thread(()->{
for (int j = 0; j < 10000000; j++) {
m.get(keys[10]);
}
});
}
for(Thread t : threads) {
t.start();
}
for(Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
end = System.currentTimeMillis();
System.out.println(end - start);
}
}
```
上面讲的就是HashTable到CurrentHashMap的一个发展历程。
接下来我们要讲的是Vector到Queue的一个发展历程。
注意这个发展历程不是说这是一个完全取代的过程。本质就是synchronized一定比cas效率高吗？
不一定。要看并发量高低，要看被锁定代码的执行时间等等。
这些容器你要在使用的时候根据你的需求来选择的使用它。
有些比较简单的只有一个线程，那么你就应该使用HashMap,其他的先不要考虑。
就应该用HashMap,linklist，arraylist。高并发执行时间比较短，就应该用currentHashMap和currentQueue。但是代码执行时间长，线程不是非常多就该使用synchronized。应该是用压力测试决定使用哪种。
设计上有面向接口编程。为什么要面上接口编程。就是为了更灵活。比如用来存储数据，设计一个接口，提供一些方法，具体里面使用的那种容器，随时可以换掉。
同步容器类
1：Vector Hashtable ：早期使用synchronized实现
2：ArrayList HashSet ：未考虑多线程安全（未实现同步）
3：HashSet vs Hashtable StringBuilder vs StringBuffer
4：Collections.synchronized***工厂方法使用的也是synchronized
使用早期的同步容器以及Collections.synchronized***方法的不足之处，请阅读：
http://blog.csdn.net/itm_hadf/article/details/7506529
使用新的并发容器
http://xuganggogo.iteye.com/blog/321630
5：
```java
/**
* 有N张火车票，每张票都有一个编号
* 同时有10个窗口对外售票
* 请写一个模拟程序
*
* 分析下面的程序可能会产生哪些问题？
* 重复销售？超量销售？
*
*
* @author 马士兵
*/
package com.mashibing.juc.c_024_FromVectorToQueue;
import java.util.ArrayList;
import java.util.List;
public class TicketSeller1 {
//没有加锁，所以线程不安全。所以这个程序是有问题的。
static List<String> tickets = new ArrayList<>();
static {
for(int i=0; i<10000; i++) tickets.add("票编号：" + i);
}
public static void main(String[] args) {
for(int i=0; i<10; i++) {
new Thread(()->{
while(tickets.size() > 0) {
//
System.out.println("销售了--" + tickets.remove(0));
}
}).start();
}
}
}
```
```
/**
* 有N张火车票，每张票都有一个编号
* 同时有10个窗口对外售票
* 请写一个模拟程序
*
* 分析下面的程序可能会产生哪些问题？
*
verctor是线程安全的。但是你使用了线程安全的容易，却没有解决线程安全的问题!
为什么，以为1和2之间没有加锁。
* 使用Vector或者Collections.synchronizedXXX
* 分析一下，这样能解决问题吗？
*
*/
package com.mashibing.juc.c_024_FromVectorToQueue;
import java.util.Vector;
import java.util.concurrent.TimeUnit;
public class TicketSeller2 {
static Vector<String> tickets = new Vector<>();
static {
for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);
}
public static void main(String[] args) {
for(int i=0; i<10; i++) {
new Thread(()->{
while(tickets.size() > 0) {///////size加锁了
//但是这个两个锁之间没有加锁。
//那么要怎么能解决这个问题那？就是在这个两个加锁的操作外面加上一把锁头。
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("销售了--" + tickets.remove(0));//remove加锁了
}
}).start();
}
}
}
```
```
/**
* 有N张火车票，每张票都有一个编号
* 同时有10个窗口对外售票
* 请写一个模拟程序
*
* 分析下面的程序可能会产生哪些问题？
* 重复销售？超量销售？
*
* 使用Vector或者Collections.synchronizedXXX
* 分析一下，这样能解决问题吗？
*
* 就算操作A和B都是同步的，但A和B组成的复合操作也未必是同步的，仍然需要自己进行同步
* 就像这个程序，判断size和进行remove必须是一整个的原子操作
*
* @author 马士兵
*/
package com.mashibing.juc.c_024_FromVectorToQueue;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class TicketSeller3 {
static List<String> tickets = new LinkedList<>();
static {
for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);
}
public static void main(String[] args) {
for(int i=0; i<10; i++) {
new Thread(()->{
while(true) {
synchronized(tickets) {//这里加上一把锁头，然后让整个判断size和remove都
包含在一个锁里面。这样就能保证线程安全了。
但是这还不是效率最好的，什么样的是效率最好的？就是下面的Queue
if(tickets.size() <= 0) break;
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("销售了--" + tickets.remove(0));
}
}
}).start();
}
}
}
```
```
/**
* 有N张火车票，每张票都有一个编号
* 同时有10个窗口对外售票
* 请写一个模拟程序
*
* 分析下面的程序可能会产生哪些问题？
* 重复销售？超量销售？
*
* 使用Vector或者Collections.synchronizedXXX
* 分析一下，这样能解决问题吗？
*
* 就算操作A和B都是同步的，但A和B组成的复合操作也未必是同步的，仍然需要自己进行同步(注意这句话，重点)
* 就像这个程序，判断size和进行remove必须是一整个的原子操作
*
* 使用ConcurrentQueue提高并发性
*
*/
package com.mashibing.juc.c_024_FromVectorToQueue;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
public class TicketSeller4 {
static Queue<String> tickets = new ConcurrentLinkedQueue<>();
static {
for(int i=0; i<1000; i++) tickets.add("票 编号：" + i);
}
public static void main(String[] args) {
for(int i=0; i<10; i++) {
new Thread(()->{
while(true) {
String s = tickets.poll();//poll函数，从tickets中取值。当取不出来的时候返回null。poll获取Queue头部。
if(s == null) break;
else System.out.println("销售了--" + s);
}
}).start();
}
}
}
poll源码里面都是cas操作，都是无锁话的，效率比较高。
```
再次强调：多线程的程序，高并发的程序，要使用容器，多考虑Queue，少考虑List。
从上面就显示出verctor到Queue的。一个发展历程
接下来我们讲在多线程下经常使用的容器。
HashMap是没有排序的，但是TreeMap是使用红黑树，是有排序的
在JUC包中是有CurrentHashMap的，但是你找不到这个包里面有CurrentTreeMap，为什么？
因为CurrentHashMap底层，使用的都是都是CAS操作。如果用CAS操作实现CurrentTreeMap那么实现
非常复杂,CAS用在true上非常的复杂。所以就没有CurrentTreeMap但是我们又需要这个排序的Map那么怎么
实现这个功能？使用的就是CurrentSkipListMap，使用跳表结构。
跳动结构：
比如我要存储1,3,7,11,20,34,78,89,91,99,100，然后将来查找20。然后如果使用线性查找，那么时间复杂度
是o(n)效率低,如果要是树那么o(logN)效率高，但是CAS操作在tree树上面，非常的复杂。所以这两种结构都不
能满足我们的需求。在1,3,7,11,20,34,78,89,91,99,100上选择出一些关键的节点。如图，选出了1,11,78,99这
几个节点。如果这些节点很多的话，那么就再选择出一层1,78。然后如果我要查询20，那么就发现20确实在
1,78之间，所以继续去第二层查找，那么就发现在11,78之间，然后再去最后一行找到了20。注意，下面的三
行，无论是哪一行都是有序的，比如图上都是从小到大的。因此在JUC中提供了CurrentSkipListMap
```
/**
* http://blog.csdn.net/sunxianghuang/article/details/52221913
* http://www.educity.cn/java/498061.html
* 阅读concurrentskiplistmap
*/
package com.mashibing.juc.c_025;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.CountDownLatch;
public class T01_ConcurrentMap {
public static void main(String[] args) {
Map<String, String> map = new ConcurrentHashMap<>();//高并发无排序
//Map<String, String> map = new ConcurrentSkipListMap<>(); //高并发并且排序
//Map<String, String> map = new Hashtable<>();
//Map<String, String> map = new HashMap<>(); //Collections.synchronizedXXX
//TreeMap
Random r = new Random();
Thread[] ths = new Thread[100];
CountDownLatch latch = new CountDownLatch(ths.length);
long start = System.currentTimeMillis();
for(int i=0; i<ths.length; i++) {
ths[i] = new Thread(()->{
for(int j=0; j<10000; j++) map.put("a" + r.nextInt(100000), "a" + r.nextInt(100000));
latch.countDown();
});
}
Arrays.asList(ths).forEach(t->t.start());
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println(end - start);
System.out.println(map.size());
}
}
```
```
/**
* 写时复制容器 copy on write 注意叫做，写时复制
* 多线程环境下，写时效率低，读时效率高
* 适合写少读多的环境
*
* CopyOnWrite当我们需要往里面添加元素的时候，我们先把里面的东西复制出来。
*
* @author 马士兵
*/
package com.mashibing.juc.c_025;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
public class T02_CopyOnWriteList {
public static void main(String[] args) {
List<String> lists =
//new ArrayList<>(); //这个会出并发问题！
//new Vector();
new CopyOnWriteArrayList<>();
//还有一个 new CopyOnWriteArraySet<>();
Random r = new Random();
Thread[] ths = new Thread[100];
for(int i=0; i<ths.length; i++) {
Runnable task = new Runnable() {
@Override
public void run() {
for(int i=0; i<1000; i++) lists.add("a" + r.nextInt(10000));
}
};
ths[i] = new Thread(task);
}
runAndComputeTime(ths);
System.out.println(lists.size());
}
static void runAndComputeTime(Thread[] ths) {
long s1 = System.currentTimeMillis();
Arrays.asList(ths).forEach(t->t.start());
Arrays.asList(ths).forEach(t->{
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long s2 = System.currentTimeMillis();
System.out.println(s2 - s1);
}
}
```
```
package com.mashibing.juc.c_025;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class T03_SynchronizedList {
public static void main(String[] args) {
List<String> strs = new ArrayList<>();
List<String> strsSync = Collections.synchronizedList(strs);
}
}
```
```
package com.mashibing.juc.c_025;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
public class T04_ConcurrentQueue {
public static void main(String[] args) {
Queue<String> strs = new ConcurrentLinkedQueue<>();
for(int i=0; i<10; i++) {
strs.offer("a" + i); // 用来添加元素，通过返回值判断是否添加成功
list里面的add添加进去会抛出异常。而offer返回true/false
}
System.out.println(strs);
System.out.println(strs.size());
System.out.println(strs.poll());//取出之后删除
System.out.println(strs.size());
System.out.println(strs.peek());//取出之后不删除
System.out.println(strs.size());
//双端队列Deque
}
}
```
```
package com.mashibing.juc.c_025;
/*
注意LinkedBlockingQueue的put方法，如果满了，放不进去了，那么就会等待。
take方法，如果空了，就会等待。所以这个实现了一个生产者和消费者。
天生实现了生产者和消费者的模型
*/
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
public class T05_LinkedBlockingQueue {
static BlockingQueue<String> strs = new LinkedBlockingQueue<>();
static Random r = new Random();
public static void main(String[] args) {
new Thread(() -> {
for (int i = 0; i < 100; i++) {
try {
strs.put("a" + i); //如果满了，就会等待
TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "p1").start();
for (int i = 0; i < 5; i++) {
new Thread(() -> {
for (;;) {
try {
System.out.println(Thread.currentThread().getName() + " take -" + strs.take()); //如果空了，就会等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "c" + i).start();
}
}
}
```
注意park不是锁，只是阻塞当前线程，park我们前面讲过。
```
package com.mashibing.juc.c_025;
/*
ArrayBlockingQueue 是有界的
package com.mashibing.juc.c_025;
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
public class T06_ArrayBlockingQueue {
static BlockingQueue<String> strs = new ArrayBlockingQueue<>(10);
static Random r = new Random();
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
strs.put("a" + i);
}
//strs.put("aaa"); //满了就会等待，程序阻塞
//strs.add("aaa");//满了会报异常
//strs.offer("aaa");//满了不会报异常，会返回true，false
strs.offer("aaa", 1, TimeUnit.SECONDS);//多长时间内
System.out.println(strs);
}
}
```
Queue的子类BlockingQueue线程池需要用。
BlockingQueue重点在Blocking上，线程能够实现自动的阻塞。
LinkedBlockingQueue 无界的，链表实现，没有长度限制
ArrayBlockingQueue 有界的
DelayQueue 可以实现时间上的排序
SynchronusQueue 专门用于线程传递任务的
TransferQueue 前面各种各样Queue的组合，可以传递好多个任务。
消息队列MessageQueue本身就是一个大的生产者和消费者模型。
面试问题：List和Queue的区别在哪里？
添加了很多对线程友好的东西，比如BlockingQueue，add,offer,put,take,peek。
```
package com.mashibing.juc.c_025;
/*
也是一种阻塞的队列
按照等待时间的长度，从Queue中拿出，这个到底是按照时间长，还是时间短取出来？
要看compareTo的实现方法。
按时间进行任务调度。
比如一个小时之后我要干啥，两个小时之后我要干啥。
*/
import java.util.Calendar;
import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
public class T07_DelayQueue {
static BlockingQueue<MyTask> tasks = new DelayQueue<>();
static Random r = new Random();
static class MyTask implements Delayed {
String name;
long runningTime;
MyTask(String name, long rt) {
this.name = name;
this.runningTime = rt;
}
@Override
public int compareTo(Delayed o) {
if(this.getDelay(TimeUnit.MILLISECONDS) < o.getDelay(TimeUnit.MILLISECONDS))
return -1;
else if(this.getDelay(TimeUnit.MILLISECONDS) > o.getDelay(TimeUnit.MILLISECONDS))
return 1;
else
return 0;
}
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
@Override
public String toString() {
return name + " " + runningTime;
}
}
public static void main(String[] args) throws InterruptedException {
long now = System.currentTimeMillis();
MyTask t1 = new MyTask("t1", now + 1000);
MyTask t2 = new MyTask("t2", now + 2000);
MyTask t3 = new MyTask("t3", now + 1500);
MyTask t4 = new MyTask("t4", now + 2500);
MyTask t5 = new MyTask("t5", now + 500);
tasks.put(t1);
tasks.put(t2);
tasks.put(t3);
tasks.put(t4);
tasks.put(t5);
System.out.println(tasks);
for(int i=0; i<5; i++) {
System.out.println(tasks.take());
}
}
}
```
DelayQueue本质上就是一个PriorityQueue
```
package com.mashibing.juc.c_025;
//PriorityQueue 实现了排序，本质上是一个树的模型。一个二叉树，是一个小顶堆。最小的值先出来，然后是大的值。
import java.util.PriorityQueue;
public class T07_01_PriorityQueque {
public static void main(String[] args) {
PriorityQueue<String> q = new PriorityQueue<>();
q.add("c");
q.add("e");
q.add("a");
q.add("d");
q.add("z");
for (int i = 0; i < 5; i++) {
// for (int i = 0; i < q.size; i++)
不能这么写，因为拿出元素之后q.size会变化，所以拿不出所有元素。
System.out.println(q.poll());
}
}
}
```
```
package com.mashibing.juc.c_025;
/*
容量为0，不是用来装东西的，而是为了给另外一个线程下任务的。
本质和exchanger哪个容器一样
类似于golang里面的channel，哪种长度为0或者为1的channel
一个手交到另外一个手里面
*/
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
public class T08_SynchronusQueue { //容量为0
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> strs = new SynchronousQueue<>();
new Thread(()->{
try {
System.out.println(strs.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
strs.put("aaa"); //阻塞等待消费者消费
//strs.put("bbb");
//strs.add("aaa"); 会报错Queue full。
System.out.println(strs.size());
}
}
在整个JUC和线程池里面用处最大的一个
```
```
package com.mashibing.juc.c_025;
/*
TransferQueue,Transfer也是用来传递一些东西，有长度，可以装一些
*/
import java.util.concurrent.LinkedTransferQueue;
public class T09_TransferQueue {
public static void main(String[] args) throws InterruptedException {
LinkedTransferQueue<String> strs = new LinkedTransferQueue<>();
new Thread(() -> {
try {
System.out.println(strs.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
strs.transfer("aaa");
//strs.put("aaa");
put装完就走了
transfer装完等取走，等结果。
put是满了就等着，而transfer是来了就等着。
我要做一件事情，这个事情要有一个结果，有了一个结果我才能做下面的事情。
我付了账了，我要等着付账完成，才能给客户一个反馈。确认有人取走了这个订单，处理了这个订单。
SynchronousQueue只能是一个线程，但是TransferQueue是多个线程。
/*new Thread(() -> {
try {
System.out.println(strs.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();*/
}
}
```
接下来讲线程池，从一道面试题开始。
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
public class T01_00_Question {
public static void main(String[] args) {
//面试题：要求用线程顺序打印A1B2C3....Z26
}
}
难易程度：LockSupport cas BlockingQueque AtomicInteger sync-wait-notify lock-condition
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
//最简单的解法：
import java.util.concurrent.locks.LockSupport;
//Locksupport park 当前线程阻塞（停止）
//unpark(Thread t)
public class T02_00_LockSupport {
static Thread t1 = null, t2 = null;
public static void main(String[] args) throws Exception {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
t1 = new Thread(() -> {
for(char c : aI) {
System.out.print(c);
LockSupport.unpark(t2); //叫醒T2
LockSupport.park(); //T1阻塞
}
}, "t1");
t2 = new Thread(() -> {
for(char c : aC) {
LockSupport.park(); //t2阻塞
System.out.print(c);
LockSupport.unpark(t1); //叫醒t1
}
}, "t2");
t1.start();
t2.start();
}
}
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
// 华为的答案，华为想考你的就是这种
//说道notify和wait，它是离不开锁的。所以必须有synchronized。然后wait的时候会让出锁。
sleep和wait的区别是，sleep不释放锁。
public class T06_00_sync_wait_notify {
public static void main(String[] args) {
final Object o = new Object();
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
new Thread(()->{
synchronized (o) {
for(char c : aI) {
System.out.print(c);
try {
o.notify();
o.wait(); //让出锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
o.notify(); //必须，否则无法停止程序
}
}, "t1").start();
new Thread(()->{
synchronized (o) {
for(char c : aC) {
System.out.print(c);
try {
o.notify();
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
o.notify(); //必须，否则无法停止程序
为什么两个线程在循环的后面，必须要有这个notify。一定有一个线程，最后执行的是wait
所以如果不执行notify，那么就一定会死锁。
}
}, "t2").start();
}
}
//如果我想保证t2在t1之前打印，也就是说保证首先输出的是A而不是1，这个时候该如何做？
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
/*
怎么保证一个线程一定先于另外一个线程调用。也就是上面的问题。
如果我想保证t2在t1之前打印，也就是说保证首先输出的是A而不是1，这个时候该如何做？
可以使用本代码实现
*/
public class T07_00_sync_wait_notify {
private static volatile boolean t2Started = false;
//private static CountDownLatch latch = new C(1);
public static void main(String[] args) {
final Object o = new Object();
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
new Thread(()->{
//latch.await();
synchronized (o) {
while(!t2Started) {//自旋的
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//
for(char c : aI) {
System.out.print(c);
try {
o.notify();
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
o.notify();
}
}, "t1").start();
new Thread(()->{
synchronized (o) {
for(char c : aC) {
System.out.print(c);
//latch.countDown()
t2Started = true;
try {
o.notify();
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
o.notify();
}
}, "t2").start();
}
}
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
/*
*/
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class T08_00_lock_condition {
public static void main(String[] args) {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(()->{
try {
lock.lock();
for(char c : aI) {
System.out.print(c);
condition.signal();
condition.await();
}
condition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t1").start();
new Thread(()->{
try {
lock.lock();
for(char c : aC) {
System.out.print(c);
condition.signal();
condition.await();
}
condition.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t2").start();
}
}
```
```
/*
Condition本质是锁资源上不同的等待队列
*/
package com.mashibing.juc.c_026_00_interview.A1B2C3;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class T09_00_lock_condition {
public static void main(String[] args) {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
Lock lock = new ReentrantLock();
Condition conditionT1 = lock.newCondition();
Condition conditionT2 = lock.newCondition();
new Thread(()->{
try {
lock.lock();
for(char c : aI) {
System.out.print(c);
conditionT2.signal();
conditionT1.await();
}
conditionT2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t1").start();
new Thread(()->{
try {
lock.lock();
for(char c : aC) {
System.out.print(c);
conditionT1.signal();
conditionT2.await();
}
conditionT1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}, "t2").start();
}
}
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
/*
用来自旋锁
*/
public class T03_00_cas {
enum ReadyToRun {T1, T2}//像一个信号灯一样
//为什么要使用枚举类型。就是限定取两个值，为了方便。
static volatile ReadyToRun r = ReadyToRun.T1; //思考为什么必须volatile
public static void main(String[] args) {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
new Thread(() -> {
for (char c : aI) {
while (r != ReadyToRun.T1) {}//这种自旋的写法会占用CPU
System.out.print(c);
r = ReadyToRun.T2;
}
}, "t1").start();
new Thread(() -> {
for (char c : aC) {
while (r != ReadyToRun.T2) {}//这种自旋的写法会占用CPU
System.out.print(c);
r = ReadyToRun.T1;
}
}, "t2").start();
}
}
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
//这个和前面的程序类似
import java.util.concurrent.atomic.AtomicInteger;
public class T05_00_AtomicInteger {
static AtomicInteger threadNo = new AtomicInteger(1);
public static void main(String[] args) {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
new Thread(() -> {
for (char c : aI) {
while (threadNo.get() != 1) {}
System.out.print(c);
threadNo.set(2);
}
}, "t1").start();
new Thread(() -> {
for (char c : aC) {
while (threadNo.get() != 2) {}
System.out.print(c);
threadNo.set(1);
}
}, "t2").start();
}
}
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
/*
cas有人叫无锁，有人叫自旋锁
*/
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.locks.LockSupport;
public class T04_00_BlockingQueue {
static BlockingQueue<String> q1 = new ArrayBlockingQueue(1);
static BlockingQueue<String> q2 = new ArrayBlockingQueue(1);
public static void main(String[] args) throws Exception {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
new Thread(() -> {
for(char c : aI) {
System.out.print(c);
try {
q1.put("ok");
q2.take();//take不到就会阻塞在这里
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1").start();
new Thread(() -> {
for(char c : aC) {
try {
q1.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print(c);
try {
q2.put("ok");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t2").start();
}
}
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
/*
进程间通信，线程间通信，想象成为一个管道。
效率很低，里面有各种各样的同步。
*/
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
public class T10_00_PipedStream {
public static void main(String[] args) throws Exception {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
PipedInputStream input1 = new PipedInputStream();
PipedInputStream input2 = new PipedInputStream();
PipedOutputStream output1 = new PipedOutputStream();
PipedOutputStream output2 = new PipedOutputStream();
input1.connect(output2);
input2.connect(output1);
String msg = "Your Turn";
new Thread(() -> {
byte[] buffer = new byte[9];
try {
for(char c : aI) {
input1.read(buffer);//read是阻塞的
if(new String(buffer).equals(msg)) {
System.out.print(c);
}
output1.write(msg.getBytes());//write是阻塞的
}
} catch (IOException e) {
e.printStackTrace();
}
}, "t1").start();
new Thread(() -> {
byte[] buffer = new byte[9];
try {
for(char c : aC) {
System.out.print(c);
output2.write(msg.getBytes());
input2.read(buffer);
if(new String(buffer).equals(msg)) {
continue;
}
}
} catch (IOException e) {
e.printStackTrace();
}
}, "t2").start();
}
}
```
semaphore是不能完成这个功能，semaphore能控制线程的执行个数，但是不能控制哪个线程执行。
这个面试题考的不是并发，而是顺序问题。
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
//这个程序也不能实现这个面试题，文件的名称说不工作，老师讲课也说确实不能
import java.util.concurrent.Exchanger;
public class T12_00_Exchanger_Not_Work {
private static Exchanger<String> exchanger = new Exchanger<>();
public static void main(String[] args) {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
new Thread(()->{
for(int i=0; i<aI.length; i++) {
System.out.print(aI[i]);
try {
exchanger.exchange("T1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
new Thread(()->{
for(int i=0; i<aC.length; i++) {
try {
exchanger.exchange("T2");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print(aC[i]);
}
}).start();
}
}
```
```
package com.mashibing.juc.c_026_00_interview.A1B2C3;
// 这个程序能实现面试题的功能
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.TransferQueue;
public class T13_TransferQueue {
public static void main(String[] args) {
char[] aI = "1234567".toCharArray();
char[] aC = "ABCDEFG".toCharArray();
TransferQueue<Character> queue = new LinkedTransferQueue<Character>();
new Thread(()->{
try {
for (char c : aI) {
System.out.print(queue.take());
queue.transfer(c);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t1").start();
new Thread(()->{
try {
for (char c : aC) {
queue.transfer(c);
System.out.print(queue.take());
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "t2").start();
}
}
```
接下来我们讲线程池：
```
/**
* 认识Callable，对Runnable进行了扩展
* 对Callable的调用，可以有返回值
*/
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.concurrent.*;
public class T03_Callable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<String> c = new Callable() {
@Override
public String call() throws Exception {
return "Hello Callable";
}
};
ExecutorService service = Executors.newCachedThreadPool();
Future<String> future = service.submit(c); //异步
这个callable放到线程池之后，我的主线程该干啥就去干啥，所以这个就是异步的。
System.out.println(future.get());//阻塞
service.shutdown();
}
}
```
```
/**
* 假设你能够提供一个服务
* 这个服务查询各大电商网站同一类产品的价格并汇总展示
* @author 马士兵 http://mashibing.com
*/
package com.mashibing.juc.c_026_01_ThreadPool;
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class T06_01_CompletableFuture {
public static void main(String[] args) throws ExecutionException, InterruptedException {
long start, end;
/*start = System.currentTimeMillis();
priceOfTM();
priceOfTB();
priceOfJD();
end = System.currentTimeMillis();
System.out.println("use serial method call! " + (end - start));*/
start = System.currentTimeMillis();
CompletableFuture<Double> futureTM = CompletableFuture.supplyAsync(()->priceOfTM());
CompletableFuture<Double> futureTB = CompletableFuture.supplyAsync(()->priceOfTB());
CompletableFuture<Double> futureJD = CompletableFuture.supplyAsync(()->priceOfJD());
CompletableFuture.allOf(futureTM, futureTB, futureJD).join();
//还有anyof
CompletableFuture.supplyAsync(()->priceOfTM())
.thenApply(String::valueOf)
.thenApply(str-> "price " + str)
.thenAccept(System.out::println);
//链式的处理方式，lambda表达式方式
end = System.currentTimeMillis();
System.out.println("use completable future! " + (end - start));
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
}
private static double priceOfTM() {
delay();
return 1.00;
}
private static double priceOfTB() {
delay();
return 2.00;
}
private static double priceOfJD() {
delay();
return 3.00;
}
/*private static double priceOfAmazon() {
delay();
throw new RuntimeException("product not exist!");
}*/
private static void delay() {
int time = new Random().nextInt(500);
try {
TimeUnit.MILLISECONDS.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("After %s sleep!\n", time);
}
}
```
所以接下来我们就讲ThreadPoolExecutor
为什么阿里开发手册要求使用自定义线程池？接下来我们就讲解如何自定义线程池
默认情况下其实我们不使用上面的四种策略。我们一般都是自定义策略。使用MQ来记录没有处理好的任务。
如果MQ中有很多的没有处理的任务，那么就说明你要添加线程了，线程数量太少了，没有能力处理完任务。
Executor把线程的定义和线程的执行分开，这个接口主要用来做线程的执行的。在它的下面有把线程池生命周期定义完全的ExecutorService，,然后在下面就是AbstractExecutor，然后再下面就是ThreadPoolExecutor
```
对数据操作的工具类叫做arrays
对容器操作的工具类叫做collections
对线程池进行操作的工具类叫做Executors，Executors线程池的工厂。
为什么要有单线程的线程池？为什么不自己new一个线程直接执行
1、因为线程池有任务队列，不用我们自己写。
2、完成的生命周期的管理也是线程池提供。
3、SingleThreadExecutor 线程池里面只要一个线程，可以保证任务是串行，按照顺序执行。
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class T07_SingleThreadPool {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
for(int i=0; i<5; i++) {
final int j = i;
service.execute(()->{
System.out.println(j + " " + Thread.currentThread().getName());
});
}
}
}
```
这个就是newSingleThreadExecutor里面的实现如下图：
接下来讲CachePool
```
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class T08_CachedPool {
public static void main(String[] args) throws InterruptedException {
ExecutorService service = Executors.newCachedThreadPool();
System.out.println(service);
for (int i = 0; i < 2; i++) {
service.execute(() -> {
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
});
}
System.out.println(service);
TimeUnit.SECONDS.sleep(80);
System.out.println(service);
}
}
```
00:36:00
```
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class T07_SingleThreadPool {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor();
for(int i=0; i<5; i++) {
final int j = i;
service.execute(()->{
System.out.println(j + " " + Thread.currentThread().getName());
});
}
}
}
```
```
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class T08_CachedPool {
public static void main(String[] args) throws InterruptedException {
ExecutorService service = Executors.newCachedThreadPool();
System.out.println(service);
for (int i = 0; i < 2; i++) {
service.execute(() -> {
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
});
}
System.out.println(service);
TimeUnit.SECONDS.sleep(80);
System.out.println(service);
}
}
```
```
/**
* 线程池的概念
* nasa
*/
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class T09_FixedThreadPool {
public static void main(String[] args) throws InterruptedException, ExecutionException {
long start = System.currentTimeMillis();
getPrime(1, 200000);
long end = System.currentTimeMillis();
System.out.println(end - start);
final int cpuCoreNum = 4;
ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);
MyTask t1 = new MyTask(1, 80000); //1-5 5-10 10-15 15-20
MyTask t2 = new MyTask(80001, 130000);
MyTask t3 = new MyTask(130001, 170000);
MyTask t4 = new MyTask(170001, 200000);
Future<List<Integer>> f1 = service.submit(t1);
Future<List<Integer>> f2 = service.submit(t2);
Future<List<Integer>> f3 = service.submit(t3);
Future<List<Integer>> f4 = service.submit(t4);
start = System.currentTimeMillis();
f1.get();
f2.get();
f3.get();
f4.get();
end = System.currentTimeMillis();
System.out.println(end - start);
}
static class MyTask implements Callable<List<Integer>> {
int startPos, endPos;
MyTask(int s, int e) {
this.startPos = s;
this.endPos = e;
}
@Override
public List<Integer> call() throws Exception {
List<Integer> r = getPrime(startPos, endPos);
return r;
}
}
static boolean isPrime(int num) {
for(int i=2; i<=num/2; i++) {
if(num % i == 0) return false;
}
return true;
}
static List<Integer> getPrime(int start, int end) {
List<Integer> results = new ArrayList<>();
for(int i=start; i<=end; i++) {
if(isPrime(i)) results.add(i);
}
return results;
}
}
```
```
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class T10_ScheduledPool {
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
service.scheduleAtFixedRate(()->{//隔多长时间执行一次这个任务
try {
TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}, 0, 500, TimeUnit.MILLISECONDS);
}
}
```
```java
package com.mashibing.juc.c_026_01_ThreadPool;
import java.util.concurrent.*;
public class T14_MyRejectedHandler {
public static void main(String[] args) {
ExecutorService service = new ThreadPoolExecutor(4, 4,
0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory(),
new MyHandler());
}
static class MyHandler implements RejectedExecutionHandler {
// 如何自己实现一个RejectedHandler。
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
//log("r rejected")
//save r kafka mysql redis 存放到kafka和mysql和redis
//try 3 times
if(executor.getQueue().size() < 10000) {
//try put again();
}
}
}
}
```
```java
# ThreadPoolExecutor源码解析
### 1、常用变量的解释
```java
// 1. `ctl`，可以看做一个int类型的数字，高3位表示线程池状态，低29位表示worker数量(也就是多少个线程)
因为这两个值都要线程同步，所以把这两个值放到一个int里面，同步的时候效率高
AtomicInteger线程多，执行时间较短的时候，相对于synchronized的效率更加高一些。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 2. `COUNT_BITS`，`Integer.SIZE`为32，所以`COUNT_BITS`为29
private static final int COUNT_BITS = Integer.SIZE - 3;
// 3. `CAPACITY`，线程池允许的最大线程数。1左移29位，然后减1，即为 2^29 - 1
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
// 4. 线程池有5种状态，按大小排序如下：RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
// Packing and unpacking ctl
// 5. `runStateOf()`，获取线程池状态，通过按位与操作，低29位将全部变成0
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 6. `workerCountOf()`，获取线程池worker数量，通过按位与操作，高3位将全部变成0
private static int workerCountOf(int c) { return c & CAPACITY; }
// 7. `ctlOf()`，根据线程池状态和线程池worker数量，生成ctl值
private static int ctlOf(int rs, int wc) { return rs | wc; }
/*
* Bit field accessors that don't require unpacking ctl.
* These depend on the bit layout and on workerCount being never negative.
*/
// 8. `runStateLessThan()`，线程池状态小于xx
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
// 9. `runStateAtLeast()`，线程池状态大于等于xx
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
```
```
```java
### 2、构造方法
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
// 基本类型参数校验
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
// 空指针校验
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
// 根据传入参数`unit`和`keepAliveTime`，将存活时间转换为纳秒存到变量`keepAliveTime `中
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
```
```java
### 3、提交执行task的过程
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
// worker数量比核心线程数小，直接创建worker执行任务
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// worker数量超过核心线程数，任务直接进入队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 线程池状态不是RUNNING状态，说明执行过shutdown命令，需要对新加入的任务执行reject()操作。
// 这儿为什么需要recheck，是因为任务入队列前后，线程池的状态可能会发生变化。
if (! isRunning(recheck) && remove(command))
reject(command);
// 这儿为什么需要判断0值，主要是在线程池构造方法中，核心线程数允许为0
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 如果线程池不是运行状态，或者任务进入队列失败，则尝试创建worker执行任务。
// 这儿有3点需要注意：
// 1. 线程池不是运行状态时，addWorker内部会判断线程池状态
// 2. addWorker第2个参数表示是否创建核心线程
// 3. addWorker返回false，则说明任务执行失败，需要执行reject操作
else if (!addWorker(command, false))
reject(command);
}
```
```java
### 4、addworker源码解析
// 老师看这里的时候也感觉到源码很复杂，感觉比spring源代码还要复杂。它这里面有很多作者的小心思，你没有必要完全读懂这些小的心思。只要理解大体的思想就可以了。
（1）你添加线程往线程池队列里面，你要注意，你要知道同时会有，很多很多的线程往里面进行添加。
所以这里一定要进行同步。或者用lock或者用自旋，不会用synchronized
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
// 注意这里面使用了两个循环，一个外层循环，一个内层循环。这里要做的就是往里面添加一个线程。把worker的数量先加1.
// 外层自旋
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 这个条件写得比较难懂，我对其进行了调整，和下面的条件等价
// (rs > SHUTDOWN) ||
// (rs == SHUTDOWN && firstTask != null) ||
// (rs == SHUTDOWN && workQueue.isEmpty())
// 1. 线程池状态大于SHUTDOWN时，直接返回false
// 2. 线程池状态等于SHUTDOWN，且firstTask不为null，直接返回false
// 3. 线程池状态等于SHUTDOWN，且队列为空，直接返回false
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
// 内层自旋
for (;;) {
int wc = workerCountOf(c);
// worker数量超过容量，直接返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 使用CAS的方式增加worker数量。
// 若增加成功，则直接跳出外层循环进入到第二部分
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
// 线程池状态发生变化，对外层循环进行自旋
if (runStateOf(c) != rs)
continue retry;
// 其他情况，直接内层循环进行自旋即可
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 这里才是真真正正的起worker.
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
// worker的添加必须是串行的，因此需要加锁
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
// 这儿需要重新检查线程池状态
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// worker已经调用过了start()方法，则不再创建worker
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// worker创建并添加到workers成功
workers.add(w);
// 更新`largestPoolSize`变量
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 启动worker线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
// worker线程启动失败，说明线程池状态发生了变化（关闭操作被执行），需要进行shutdown相关操作
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
```
```java
### 5、线程池worker任务单元
private final class Worker
extends AbstractQueuedSynchronizer//AbstractQueuedSynchronizer本身就是一把锁，就可以同步任务。为什么它是一把锁啊？
implements Runnable
{
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
// 这儿是Worker的关键所在，使用了线程工厂创建了一个线程。传入的参数为当前worker
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
// 省略代码...
}
```
```java
### 6、核心线程执行逻辑-runworker
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
// 调用unlock()是为了让外部可以中断
w.unlock(); // allow interrupts
// 这个变量用于判断是否进入过自旋（while循环）
boolean completedAbruptly = true;
try {
// 这儿是自旋
// 1. 如果firstTask不为null，则执行firstTask；
// 2. 如果firstTask为null，则调用getTask()从队列获取任务。
// 3. 阻塞队列的特性就是：当队列为空时，当前线程会被阻塞等待
while (task != null || (task = getTask()) != null) {
// 这儿对worker进行加锁，是为了达到下面的目的
// 1. 降低锁范围，提升性能
// 2. 保证每个worker执行的任务是串行的
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
// 如果线程池正在停止，则对当前线程进行中断操作
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
// 执行任务，且在执行前后通过`beforeExecute()`和`afterExecute()`来扩展其功能。
// 这两个方法在当前类里面为空实现。
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
// 帮助gc
task = null;
// 已完成任务数加一
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 自旋操作被退出，说明线程池正在结束
processWorkerExit(w, completedAbruptly);
}
}
```
接下来我们讲WorkStealingPool：
```
/**
*/
package com.mashibing.juc.c_026_01_ThreadPool;
import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class T11_WorkStealingPool {
public static void main(String[] args) throws IOException {
ExecutorService service = Executors.newWorkStealingPool();
System.out.println(Runtime.getRuntime().availableProcessors());
service.execute(new R(1000));
service.execute(new R(2000));
service.execute(new R(2000));
service.execute(new R(2000)); //daemon
service.execute(new R(2000));
//由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出
System.in.read();
}
static class R implements Runnable {
int time;
R(int t) {
this.time = t;
}
@Override
public void run() {
try {
TimeUnit.MILLISECONDS.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(time + " " + Thread.currentThread().getName());
}
}
}
```
```java
package com.mashibing.juc.c_026_01_ThreadPool;
/*
ForkJoinPool把一个一个大任务切分成小的任务。
切完了之后最后要汇总的话。
先分叉，再汇总。
我们如何给ForkJoinPool定义任务，就是ForkJoinTask,使用这个来定义任务。
RecursiveAction 不带有返回值
RecursiveTask 带有返回值
*/
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
public class T12_ForkJoinPool {
static int[] nums = new int[1000000];
static final int MAX_NUM = 50000;
static Random r = new Random();
static {
for(int i=0; i<nums.length; i++) {
nums[i] = r.nextInt(100);
}
System.out.println("---" + Arrays.stream(nums).sum()); //stream api
}
static class AddTask extends RecursiveAction {
int start, end;
AddTask(int s, int e) {
start = s;
end = e;
}
@Override
protected void compute() {
if(end-start <= MAX_NUM) {
long sum = 0L;
for(int i=start; i<end; i++) sum += nums[i];
System.out.println("from:" + start + " to:" + end + " = " + sum);
} else {
int middle = start + (end-start)/2;
AddTask subTask1 = new AddTask(start, middle);
AddTask subTask2 = new AddTask(middle, end);
subTask1.fork();
subTask2.fork();
}
}
}
static class AddTaskRet extends RecursiveTask<Long> {
private static final long serialVersionUID = 1L;
int start, end;
AddTaskRet(int s, int e) {
start = s;
end = e;
}
@Override
protected Long compute() {
if(end-start <= MAX_NUM) {
long sum = 0L;
for(int i=start; i<end; i++) sum += nums[i];
return sum;
}
int middle = start + (end-start)/2;
AddTaskRet subTask1 = new AddTaskRet(start, middle);
AddTaskRet subTask2 = new AddTaskRet(middle, end);
subTask1.fork();
subTask2.fork();
return subTask1.join() + subTask2.join();
}
}
public static void main(String[] args) throws IOException {
/*ForkJoinPool fjp = new ForkJoinPool();
AddTask task = new AddTask(0, nums.length);
fjp.execute(task);*/
T12_ForkJoinPool temp = new T12_ForkJoinPool();
ForkJoinPool fjp = new ForkJoinPool();
AddTaskRet task = new AddTaskRet(0, nums.length);
fjp.execute(task);
long result = task.join();
System.out.println(result);
//System.in.read();
}
}
```
```
package com.mashibing.juc.c_026_01_ThreadPool;
/*
*/
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class T13_ParallelStreamAPI {
public static void main(String[] args) {
List<Integer> nums = new ArrayList<>();
Random r = new Random();
for(int i=0; i<10000; i++) nums.add(1000000 + r.nextInt(1000000));
//System.out.println(nums);
long start = System.currentTimeMillis();
nums.forEach(v->isPrime(v));
long end = System.currentTimeMillis();
System.out.println(end - start);
//使用parallel stream api
start = System.currentTimeMillis();
nums.parallelStream().forEach(T13_ParallelStreamAPI::isPrime);
/*
parallelStream 就是把nums这个集合中的元素进行拆分。把一个一个的任务拆分成子任务。
底层也是ForkJoinPool。
线程之间不需要同步的时候可以使用这个效率更加高。
*/
end = System.currentTimeMillis();
System.out.println(end - start);
}
static boolean isPrime(int num) {
for(int i=2; i<=num/2; i++) {
if(num % i == 0) return false;
}
return true;
}
}
```
# JMH Java准测试工具套件
## 什么是JMH
### 官网
http://openjdk.java.net/projects/code-tools/jmh/
## 创建JMH测试
1. 创建Maven项目，添加依赖
```java
<?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>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<encoding>UTF-8</encoding>
<java.version>1.8</java.version>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<groupId>mashibing.com</groupId>
<artifactId>HelloJMH2</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-core -->
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>1.21</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-generator-annprocess -->
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-generator-annprocess</artifactId>
<version>1.21</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
```
2. idea安装JMH插件 JMH plugin v1.0.3
3. 由于用到了注解，打开运行程序注解配置
> compiler -> Annotation Processors -> Enable Annotation Processing
4. 定义需要测试类PS (ParallelStream)
```java
package com.mashibing.jmh;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class PS {
static List<Integer> nums = new ArrayList<>();
static {
Random r = new Random();
for (int i = 0; i < 10000; i++) nums.add(1000000 + r.nextInt(1000000));
}
static void foreach() {
nums.forEach(v->isPrime(v));
}
static void parallel() {
nums.parallelStream().forEach(PS::isPrime);
}
static boolean isPrime(int num) {
for(int i=2; i<=num/2; i++) {
if(num % i == 0) return false;
}
return true;
}
}
```
5. 写单元测试
> 这个测试类一定要在test package下面
>
> ```java
> package com.mashibing.jmh;
>
> import org.openjdk.jmh.annotations.Benchmark;
>
> import static org.junit.jupiter.api.Assertions.*;
>
> public class PSTest {
> @Benchmark
> public void testForEach() {
> PS.foreach();
> }
> }
> ```
6. 运行测试类，如果遇到下面的错误：
```java
ERROR: org.openjdk.jmh.runner.RunnerException: ERROR: Exception while trying to acquire the JMH lock (C:\WINDOWS\/jmh.lock): C:\WINDOWS\jmh.lock (拒绝访问。), exiting. Use -Djmh.ignoreLock=true to forcefully continue.
at org.openjdk.jmh.runner.Runner.run(Runner.java:216)
at org.openjdk.jmh.Main.main(Main.java:71)
```
这个错误是因为JMH运行需要访问系统的TMP目录，解决办法是：
打开RunConfiguration -> Environment Variables -> include system environment viables
7. 阅读测试报告
## JMH中的基本概念
1. Warmup
预热，由于JVM中对于特定代码会存在优化（本地化），预热对于测试结果很重要
这个注解的两个参数，第一个iteration=1,time=3表示，执行一次，然后等三秒钟之后执行下面的
2. Mesurement
总共执行多少次测试
3. Timeout
4. Threads
线程数，由fork指定
5. Benchmark mode
基准测试的模式
6. Benchmark
测试哪一段代码
## Next
官方样例：
http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
disruptor不是我们平时所学的redis.不是我们平时所学的kafka
redis是用于集群。disruptor是单机的。
内存里面用来存放元素的一个高效率的队列。
# Disruptor
## 介绍
主页：http://lmax-exchange.github.io/disruptor/
源码：https://github.com/LMAX-Exchange/disruptor
GettingStarted: https://github.com/LMAX-Exchange/disruptor/wiki/Getting-Started
api: http://lmax-exchange.github.io/disruptor/docs/index.html
maven: https://mvnrepository.com/artifact/com.lmax/disruptor
## Disruptor的特点
对比ConcurrentLinkedQueue : 链表实现
JDK中没有ConcurrentArrayQueue
Disruptor是数组实现的
无锁，高并发，使用环形Buffer，直接覆盖（不用清除）旧的数据，降低GC频率
实现了基于事件的生产者消费者模式（观察者模式）
## RingBuffer 核心原理最重要的地方
环形队列
RingBuffer的序号，指向下一个可用的元素
采用数组实现，没有首尾指针
**对比ConcurrentLinkedQueue，用数组实现的速度更快。遍历的话，链表的效率一定比数组低。**
**但是jdk中没有ConcurrentAarryQueue。因为数组大小是固定的。所以添加一个元素就要拷贝。**
**disruptor作者想到了一个非常牛的办法，把数组的头部和尾部连接起来。**
**ConcurrentLinkedQueue这个要维护两个指针，一个头指针，一个尾指针。而disruptor**
**只需要维护一个东西就是sequence**，sequence代表我下一个有效的元素指在什么位置上。
> 假如长度为8，当添加到第12个元素的时候在哪个序号上呢？用12%8决定
>
> 当Buffer被填满的时候到底是覆盖还是等待，由Producer决定
>
> 长度设为2的n次幂，利于二进制计算，例如：12%8 = 12 & (8 - 1) pos = num & (size -1)
## Disruptor开发步骤 关键
1. 定义Event - 队列中需要处理的元素
2. 定义Event工厂，用于填充队列
> 这里牵扯到效率问题：disruptor初始化的时候，会调用Event工厂，对ringBuffer进行内存的提前分配
>
> GC产频率会降低。就是说disruptor为了追求效率，上来就new了很多你要处理的对象，并且赋了默认的初始值。然后将来真正有对象来的时候，那么就改变这个值。而不用从创建对象这一步开始了。所以这样就是提前进行了内存分配。降低了GC的频率。
3. 定义EventHandler（消费者），处理容器中的元素
## 事件发布模板
```java
long sequence = ringBuffer.next(); // Grab the next sequence
try {
LongEvent event = ringBuffer.get(sequence); // Get the entry in the Disruptor
// for the sequence
event.set(8888L); // Fill with data
} finally {
ringBuffer.publish(sequence);
}
```
## 使用EventTranslator发布事件
```java
//===============================================================
EventTranslator<LongEvent> translator1 = new EventTranslator<LongEvent>() {
@Override
public void translateTo(LongEvent event, long sequence) {
event.set(8888L);
}
};
ringBuffer.publishEvent(translator1);
//===============================================================
EventTranslatorOneArg<LongEvent, Long> translator2 = new EventTranslatorOneArg<LongEvent, Long>() {
@Override
public void translateTo(LongEvent event, long sequence, Long l) {
event.set(l);
}
};
ringBuffer.publishEvent(translator2, 7777L);
//===============================================================
EventTranslatorTwoArg<LongEvent, Long, Long> translator3 = new EventTranslatorTwoArg<LongEvent, Long, Long>() {
@Override
public void translateTo(LongEvent event, long sequence, Long l1, Long l2) {
event.set(l1 + l2);
}
};
ringBuffer.publishEvent(translator3, 10000L, 10000L);
//===============================================================
EventTranslatorThreeArg<LongEvent, Long, Long, Long> translator4 = new EventTranslatorThreeArg<LongEvent, Long, Long, Long>() {
@Override
public void translateTo(LongEvent event, long sequence, Long l1, Long l2, Long l3) {
event.set(l1 + l2 + l3);
}
};
ringBuffer.publishEvent(translator4, 10000L, 10000L, 1000L);
//===============================================================
EventTranslatorVararg<LongEvent> translator5 = new EventTranslatorVararg<LongEvent>() {
@Override
public void translateTo(LongEvent event, long sequence, Object... objects) {
long result = 0;
for(Object o : objects) {
long l = (Long)o;
result += l;
}
event.set(result);
}
};
ringBuffer.publishEvent(translator5, 10000L, 10000L, 10000L, 10000L);
```
## 使用Lamda表达式
```java
package com.mashibing.disruptor;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.util.DaemonThreadFactory;
public class Main03
{
public static void main(String[] args) throws Exception
{
// Specify the size of the ring buffer, must be power of 2.
int bufferSize = 1024;
// Construct the Disruptor
Disruptor<LongEvent> disruptor = new Disruptor<>(LongEvent::new, bufferSize, DaemonThreadFactory.INSTANCE);
// Connect the handler
disruptor.handleEventsWith((event, sequence, endOfBatch) -> System.out.println("Event: " + event));
// Start the Disruptor, starts all threads running
disruptor.start();
// Get the ring buffer from the Disruptor to be used for publishing.
RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
ringBuffer.publishEvent((event, sequence) -> event.set(10000L));
System.in.read();
}
}
```
## ProducerType生产者线程模式
> ProducerType有两种模式 Producer.MULTI和Producer.SINGLE
>
> 默认是MULTI，表示在多线程模式下产生sequence
>
> 如果确认是单线程生产者，那么可以指定SINGLE，效率会提升，因为不用加锁
>
> 如果是多个生产者（多线程），但模式指定为SINGLE，会出什么问题呢？消息覆盖
## 等待策略（满了之后如何进行等待）
1，(常用）BlockingWaitStrategy：通过线程阻塞的方式，等待生产者唤醒，被唤醒后，再循环检查依赖的sequence是否已经消费。
2，BusySpinWaitStrategy：线程一直自旋等待，可能比较耗cpu
3，LiteBlockingWaitStrategy：线程阻塞等待生产者唤醒，与BlockingWaitStrategy相比，区别在signalNeeded.getAndSet,如果两个线程同时访问一个访问waitfor,一个访问signalAll时，可以减少lock加锁次数.
4，LiteTimeoutBlockingWaitStrategy：与LiteBlockingWaitStrategy相比，设置了阻塞时间，超过时间后抛异常。
5，PhasedBackoffWaitStrategy：根据时间参数和传入的等待策略来决定使用哪种等待策略
6，TimeoutBlockingWaitStrategy：相对于BlockingWaitStrategy来说，设置了等待时间，超过后抛异常
7，（常用）YieldingWaitStrategy：尝试100次，然后Thread.yield()让出cpu
8. （常用）SleepingWaitStrategy : sleep
## 消费者异常处理
默认：disruptor.setDefaultExceptionHandler()
覆盖：disruptor.handleExceptionFor().with()
## 依赖处理
disruptor没有完，这个东西估计不会怎么用。那么这个先扔着。 | 134,194 | MIT |
# TextField
输入框组件，[demo](https://myronliu347.github.io/vue-carbon/#!/inputs)
----
## 用法
```html
<content-title>输入框</content-title>
<!--普通文本输入框-->
<form-list>
<text-field label="用户名" placeholder="请输入你的姓名" icon="account_box" :value.sync="user.name"></text-field>
<text-field label="电话" type="number" placeholder="请输入你的电话" icon="phone" :value.sync="user.phone"></text-field>
<text-field label="简介" type="textarea" :rows="3" icon="markunread" placeholder="info_outline" :value.sync="user.introduction"></text-field>
</form-list>
<content-title>浮动 label 的输入框</content-title>
<form-list>
<text-field label-float label="用户名" icon="account_box"></text-field>
<text-field label-float label="电话" type="number" icon="phone"></text-field>
<text-field label-float label="简介" type="textarea" :rows="3" icon="markunread"></text-field>
</form-list>
<content-title>没有图标</content-title>
<form-list>
<text-field label="用户名"></text-field>
<text-field label="电话" type="number"></text-field>
<text-field label="简介" type="textarea" :rows="3"></text-field>
</form-list>
```
```javascript
{
data () {
return {
user: {
name: "",
phone: "",
introduction: ""
}
}
}
}
```
## API
| 参数 | 说明 | 类型 | 可选值 | 默认值 |
| :---- | :---- | :---- | :---- | :---- |
| label | 标签文字 | String | | |
| labelFloat | 是否为浮动标签 | Boolean | true/false | false |
| icon | 图标 | String | material icons | |
| type | 输入框类型, 同等与 input标签的 type, 不过多了一个 textarea,可以为多行文本输入框 | String | input[type] / textarea | 'text' |
| focus | 是否获取焦点 | Boolean | true/false | false |
| placeholder | input标签的placehodler | String | | |
| rows | type设为 textarea 时，启用，设置默认显示的行数 | Number | | 0 |
| value | 输入框的值，input / textarea 的model，相当于绑定在 input[type=text] / textarea 上的 v-model | String | | |
## 事件
### input-change
当 value 改变的时候出发 input-change 事件， 新的value会作为参数。
这个事件是为了配合 vuex 使用，可以从 vuex 改变 value | 1,900 | MIT |
---
layout: post
title: 'Solr 支持MySQL导入二(1)'
date: 2018-10-01
author: 李新
tags: Solr
---
### (1). 创建Core
> Core类似于DB.
### (2). 添加相应依赖
> 导入MySQL数据到Solr前,需要添加相应的依赖
```
# 1.拷贝:
# solr-dataimporthandler-7.7.3.jar
# solr-dataimporthandler-extras-7.7.3.jar
# 到 ${TOMCAT}/webapps/solr/WEB-INF/lib/ 目录下
lixin-macbook:solr lixin$ cp solr-7.7.3/dist/solr-dataimporthandler-* apache-tomcat-8.5.54/webapps/solr/WEB-INF/lib/
# 2.下载mysql jar包拷贝到:${TOMCAT}/webapps/solr/WEB-INF/lib 目录下
cp mysql-connector-java-5.1.42.jar ~/Developer/solr/apache-tomcat-8.5.54/webapps/solr/WEB-INF/lib/
# 3.拷贝solr自带的分词器jar包到:${TOMCAT}/webapps/solr/WEB-INF/lib 目录下
# solr-7.7.3/contrib/analysis-extras/lucene-libs目录下,包含如下jar包内容:
# lucene-analyzers-icu-7.7.3.jar
# lucene-analyzers-morfologik-7.7.3.jar
# lucene-analyzers-opennlp-7.7.3.jar
# lucene-analyzers-smartcn-7.7.3.jar
# lucene-analyzers-stempel-7.7.3.jar
lixin-macbook:solr lixin$ cp -rf solr-7.7.3/contrib/analysis-extras/lucene-libs/*.jar apache-tomcat-8.5.54/webapps/solr/WEB-INF/lib/
```
### (3). 配置中文分词器(managed-schema)
> vi solr_home/core_example/conf/managed-schema
> 添加以下配置信息到managed-schema文件的</schema>节点之前
> 可参考: https://www.cnblogs.com/miye/p/10716338.html
```
<!-- 配置smartcn中文分词器 -->
<!-- text_smartcn代表分词器名称 -->
<fieldType name="text_smartcn" class="solr.TextField" positionIncrementGap="100">
<analyzer type="index">
<tokenizer class="org.apache.lucene.analysis.cn.smart.HMMChineseTokenizerFactory"/>
</analyzer>
<analyzer type="query">
<tokenizer class="org.apache.lucene.analysis.cn.smart.HMMChineseTokenizerFactory"/>
</analyzer>
</fieldType>
```
### (4). Field详解
> 参考: https://blog.csdn.net/mine_song/article/details/58065323
```
<field name="id" type="string" indexed="true" stored="true" required="true" multiValued="false" />
name: 指定域的名称(自定义)
type: 指定域的类型
indexed: 是否索引
是:(将分好的词进行索引,索引的目的,就是为了搜索)
否:不索引，也就是不对该field域进行搜索.
stored: 是否存储
是:在检索时:在搜索页面,以及查询条件都能显示该Field域的值.
否:在检索时:搜索页面,没法获取该field域的值(仅仅只能当作查询条件来使用).
required: 是否必须
multiValued: 是否多值,比如查询数据需要关联多个字段数据,一个Field存储多个值信息,必须将multiValued设置为true.
```
### (5). dynamicField配置详解
```
<dynamicField name="*_is" type="pint" indexed="true" stored="true" multiValued="true"/>
name为*_is,定义它的type为int,那么在使用这个字段的时候,任何以_is结果的字段都被认为符合这个定义
```
### (6). uniqueKey配置
> id是在Field标签中已经定义好的域名,**而且该域设置为required为true.一个managed-schema文件中必须有且仅有一个唯一键.**
```
<uniqueKey>id</uniqueKey>
```
### (7). copyField配置
> copyField复制域
> 比如:我们在搜索时比如输入:hello时，一篇文章分为:标题、简介、内容等很多字段,输入的关键字不可能只在一个域中进行检索,可能要在多个域中进行检索.所以出现copyField域,把多个域关联成一个域.
```
# 定义普通域
<field name="title" type="text_gen_sort" indexed="true" stored="true" multiValued="true"/>
<field name="author" type="text_gen_sort" indexed="true" stored="true" multiValued="false"/>
<field name="text" type="text_general" indexed="true" stored="false" multiValued="true"/>
# 定义复制域
# source : Field域的名称
# dest : 是目标域的名称
# 当检索text域时,会分别到:title和author域中进行检索
<copyField source="title" dest="text"/>
<copyField source="author" dest="text"/>
```
### (8). fieldType
> 域类型
```
<fieldType name="string" class="solr.StrField" sortMissingLast="true" />
<fieldType name="boolean" class="solr.BoolField" sortMissingLast="true"/>
<fieldType name="pint" class="solr.IntPointField" docValues="true"/>
<fieldType name="pfloat" class="solr.FloatPointField" docValues="true"/>
<fieldType name="plong" class="solr.LongPointField" docValues="true"/>
<fieldType name="pdouble" class="solr.DoublePointField" docValues="true"/>
<fieldType name="pints" class="solr.IntPointField" docValues="true" multiValued="true"/>
<fieldType name="pfloats" class="solr.FloatPointField" docValues="true" multiValued="true"/>
<fieldType name="plongs" class="solr.LongPointField" docValues="true" multiValued="true"/>
<fieldType name="pdoubles" class="solr.DoublePointField" docValues="true" multiValued="true"/>
<fieldType name="pdate" class="solr.DatePointField" docValues="true"/>
<fieldType name="pdates" class="solr.DatePointField" docValues="true" multiValued="true"/>
<fieldType name="binary" class="solr.BinaryField"/>
```
### (9). 分词器
```
<fieldType name="text_general" class="solr.TextField" positionIncrementGap="100">
<analyzer type="index">
<tokenizer class="solr.StandardTokenizerFactory"/>
<filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" />
<filter class="solr.LowerCaseFilterFactory"/>
</analyzer>
<analyzer type="query">
<tokenizer class="solr.StandardTokenizerFactory"/>
<filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" />
<filter class="solr.SynonymGraphFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/>
<filter class="solr.LowerCaseFilterFactory"/>
</analyzer>
</fieldType>
name : 指定域类型(fieldType)名称
class : 指定域对应的solr类型
analyzer : 指定分词器
type : index/query 分别指定搜索和索引时的分析器
tokenizer : 指定分词器
filter : 指定过滤器
``` | 5,027 | MIT |
---
layout: post
title: "CSAPP:Attack Lab"
date: 2021-07-28
author: ZhichenRen
categories: CSAPP
tags: CSAPP AttackLab
description: 前几天看完了CSAPP第三章，做了人生当中第一个像样的lab，纪念一下
---
# Attack Lab
## 简介
这个lab是利用缓冲区溢出来对程序进行攻击，让程序偏离正常运行，转而运行攻击者所希望的代码。
lab提供可执行程序ctarget与rtarget，前者为代码注入攻击(Code Injection Attack)所使用的可执行程序，后者为ROP(Return-Oriented Programming)所使用的可执行程序，区别仅在于rtarget开启了栈随机化并将栈区设置为不可执行。
可执行文件中包含如下test函数：
```c++
void test(){
int val;
val = getbuf();
printf("No exploit. Getbuf returned 0x%x\n", val);
}
```
该函数将调用getbuf函数：
```c++
unsigned getbuf(){
char buf[BUFFER_SIZE];
Gets(buf);
return 1;
}
```
这里的Gets()函数类似于库函数gets()，没有考虑输入的大小，因此可能出现缓冲区溢出的问题，我们可以利用这一漏洞改变程序的行为。
可执行文件中包含如下函数，我们需要利用缓冲区溢出漏洞依次执行这些函数：
```c++
//touch1函数没有输入参数，直接调用即可。
void touch1(){
vlevel = 1; /* Part of validation protocol */
printf("Touch1!: You called touch1()\n");
validate(1);
exit(0);
}
//touch2函数需要一个参数val，我们在进行攻击时需要设置参数再进行调用。
void touch2(unsigned val){
vlevel = 2; /* Part of validation protocol */
if (val == cookie) {
printf("Touch2!: You called touch2(0x%.8x)\n", val);
validate(2);
}
else {
printf("Misfire: You called touch2(0x%.8x)\n", val);
fail(2);
}
exit(0);
}
//touch3函数需要一个指针参数，我们应当将Cookie字符串存于某一个位置，并将其地址传入。
void touch3(char *sval){
vlevel = 3; /* Part of validation protocol */
if (hexmatch(cookie, sval)) {
printf("Touch3!: You called touch3(\"%s\")\n", sval);
validate(3);
}
else {
printf("Misfire: You called touch3(\"%s\")\n", sval);
fail(3);
}
exit(0);
}
//touch3函数将调用此函数用于Cookie字符串比较，此函数中的cbuf数组写入可能会破坏存于栈中的字符串
int hexmatch(unsigned val, char *sval)
{
char cbuf[110];
/* Make position of check string unpredictable */
char *s = cbuf + random() % 100;
sprintf(s, "%.8x", val);
return strncmp(sval, s, 9) == 0;
}
```
## Code Injection Attack
### Level 1
最简单的攻击，只需要改变getbuf返回的地址即可。使用gdb进入getbuf函数，发现其为buf分配了40Byte的栈空间，而超过40Byte的输入字符串则会覆盖其返回地址，因此我们只需在攻击字符串的前40Byte填上任意字符，在接下来的8Byte中填写touch1函数的返回值即可。
### Level 2
Level2需要跳转至touch2函数，这同样是通过修改存放在栈中的返回值实现的。区别在于touch2需要一个unsigned参数，也就是Cookie.txt中的16进制数，我们需要在跳转至touch2之间将其存放至%rdi（存放第一个参数的寄存器）中。
具体思路如下：
1. 修改栈顶返回值，跳转至栈中某一块被我们修改过的内存，这块内存中将存放需要执行的指令
2. 从跳转处开始执行指令，将Cookie存放至%rdi中
3. 将touch2函数的地址压栈，并通过ret跳转至touch2函数
所用到的汇编指令位于assembly/level2.s中，攻击字符串存放于solution/level2.txt中
### Level 3
Level3与Level2的主要区别如下：
- Level2中的touch2的参数为一个unsigned，攻击代码仅需传入立即数即可，而Level3中的touch3函数的参数为一个字符串指针，这意味着我们的攻击代码需要将Cookie转化为ASCII字符串并存放于内存中的指定位置
- Level3中的touch3函数将调用hexmatch函数，该函数将创建一个cbuf数组并在其随机位置写入内容，这有可能会覆盖我们存放在栈空间中的字符串，因此我们应当在栈的更高位存放字符串（我存放于test函数的缓冲区中）
具体思路如下：
1. 修改栈顶返回值，使ret跳转至注入的攻击代码，同时将字符串存放于test对应的栈帧中
2. 将存放字符串的地址放入%rdi中
3. 将touch3的地址压栈，使用ret跳转
## Return-Oriented Programming
rtarget可执行文件增加了栈随机化，且栈不可执行，因此代码注入攻击很难起到效果，使用ROP进行攻击。首先介绍一下gadget的概念，gadget是一小条指令序列，并且以ret(c3)结尾，例如：
```x86asm
0000000000400f15 <setval_210>:
400f15: c7 07 d4 48 89 c7 movl $0xc78948d4,(%rdi)
400f1b: c3 retq
```
这条指令虽然看上去没有什么作用，但是如果我们从0x400f18处开始执行，它就是48 89 c7，也就是movq %rax,%rdi。可以变得为我们所用。另外，紧随其后的ret语句可以让我们跳转至另一个gadget继续执行。因此，所谓的ROP攻击就是利用一连串的gadget来执行一些我们所需要的指令。由于代码区在内存中的位置是固定的且是可执行的，这就解决了上文提到的栈随机化与栈不可执行的问题。
### Level 2
了解了gadget的原理，这个attack也不是很困难。我们需要做的事情如下：
1. 将Cookie存放于内存中，通过pop指令来读取
2. 将读取到的Cookie存入%rdi中
3. 调用touch2函数
```x86asm
popq %rsp, %rax
ret
movq %rax,%rdi
ret
```
共需要两个gadget即可完成，攻击字符串存放于solutions/rop-2.txt中，gadget的信息存放于gadgets.txt中。
### Level 3
这个攻击是此lab中最复杂的一个，需要用到8个gadget，大致思路类似phase3与phase4的结合，用ROP的思想来完成我们在phase3所完成的事情。
大致思路如下：
1. 首先，我们需要把字符串存放于test的栈帧中
2. 然后我们需要获取字符串的起始地址，由于开启了栈随机化，我们无法直接给出这个地址，需要使用rsp与偏移量的方式来获取
3. 最后将字符串起始地址存放于%rdi中，调用touch3即可
我们希望执行的汇编代码如下：
```x86asm
popq %rax
ret
movq %rsp,%rdi
ret
lea (%rdi,%rax,1),%rdi
ret
```
其中每一个ret都将调用下一个gadget来执行对应的汇编代码。但是很不巧的是，我们能够利用的gadget库中没有能够帮助我们产生后两条指令的gadget，因此我们需要稍微绕一点路，将我们所想要执行的动作转化为gadget所支持的指令，如下：
```x86asm
popq %rax
ret
movl %eax,%edx
ret
movl %edx,%ecx
ret
movl %ecx,%esi
ret
movq %rsp,%rax
ret
movq %rax,%rdi
ret
lea (%rdi,%rsi,1) %rax
ret
movq %rax,%rdi
ret
```
最后根据指令的设计来计算movq %rsp,%rax指令与字符串起始位置的偏移量，本解法中为32，并将其写入栈中。
攻击字符串存放于solutions/rop-3.txt中。 | 4,129 | MIT |
---
title: "Apache Flink 是什么？"
---
<hr/>
<div class="row">
<div class="col-sm-12" style="background-color: #f8f8f8;">
<h2>
架构
<span class="glyphicon glyphicon-chevron-right"></span>
<a href="{{ site.baseurl }}/zh/flink-applications.html">应用</a>
<span class="glyphicon glyphicon-chevron-right"></span>
<a href="{{ site.baseurl }}/zh/flink-operations.html">运维</a>
</h2>
</div>
</div>
<hr/>
Apache Flink 是一个框架和分布式处理引擎，用于在*无边界和有边界*数据流上进行有状态的计算。Flink 能在所有常见集群环境中运行，并能以内存速度和任意规模进行计算。
接下来，我们来介绍一下 Flink 架构中的重要方面。
<!--
<div class="row front-graphic">
<img src="{{ site.baseurl }}/img/flink-home-graphic-update3.png" width="800px" />
</div>
-->
## 处理无界和有界数据
任何类型的数据都可以形成一种事件流。信用卡交易、传感器测量、机器日志、网站或移动应用程序上的用户交互记录，所有这些数据都形成一种流。
数据可以被作为 *无界* 或者 *有界* 流来处理。
1. **无界流** 有定义流的开始，但没有定义流的结束。它们会无休止地产生数据。无界流的数据必须持续处理，即数据被摄取后需要立刻处理。我们不能等到所有数据都到达再处理，因为输入是无限的，在任何时候输入都不会完成。处理无界数据通常要求以特定顺序摄取事件，例如事件发生的顺序，以便能够推断结果的完整性。
2. **有界流** 有定义流的开始，也有定义流的结束。有界流可以在摄取所有数据后再进行计算。有界流所有数据可以被排序，所以并不需要有序摄取。有界流处理通常被称为批处理
<div class="row front-graphic">
<img src="{{ site.baseurl }}/img/bounded-unbounded.png" width="600px" />
</div>
**Apache Flink 擅长处理无界和有界数据集** 精确的时间控制和状态化使得 Flink 的运行时(runtime)能够运行任何处理无界流的应用。有界流则由一些专为固定大小数据集特殊设计的算法和数据结构进行内部处理，产生了出色的性能。
通过探索 Flink 之上构建的 [用例]({{ site.baseurl }}/zh/usecases.html) 来加深理解。
## 部署应用到任意地方
Apache Flink 是一个分布式系统，它需要计算资源来执行应用程序。Flink 集成了所有常见的集群资源管理器，例如 [Hadoop YARN](https://hadoop.apache.org/docs/stable/hadoop-yarn/hadoop-yarn-site/YARN.html)、 [Apache Mesos](https://mesos.apache.org) 和 [Kubernetes](https://kubernetes.io/)，但同时也可以作为独立集群运行。
Flink 被设计为能够很好地工作在上述每个资源管理器中，这是通过资源管理器特定(resource-manager-specific)的部署模式实现的。Flink 可以采用与当前资源管理器相适应的方式进行交互。
部署 Flink 应用程序时，Flink 会根据应用程序配置的并行性自动标识所需的资源，并从资源管理器请求这些资源。在发生故障的情况下，Flink 通过请求新资源来替换发生故障的容器。提交或控制应用程序的所有通信都是通过 REST 调用进行的，这可以简化 Flink 与各种环境中的集成。
<!-- Add this section once library deployment mode is supported. -->
<!--
Flink 提供了两种应用程序部署模式，即 *框架模式* 和 *库模式*
* 在 **框架部署模式** 中，客户端将 Flink 应用程序提交到一个运行中的 Flink 服务中，由该服务负责执行提交的应用程序。这是大多数数据处理框架、查询引擎或数据库系统的通用部署模型。
* 在 **库部署模式中**，Flink 应用程序与 Flink 主可执行程序一起打包成 (Docker) 映像。另一个独立于作业的映像包含可执行的 Flink 工作程序。当从作业映像启动容器时，将启动 Flink 主进程并自动加载嵌入的应用程序。从工作镜像启动的容器，引导 Flink 工作进程自动连接到主进程。容器管理器（比如 Kubernetes）监控正在运行的容器并自动重启失败的容器。在这种模式下，你不需要在集群中安装和维护 Flink 服务。只需将 Flink 作为库打包到应用程序中。这种模型在部署微服务时非常流行。
<div class="row front-graphic">
<img src="{{ site.baseurl }}/img/deployment-modes.png" width="600px" />
</div>
-->
## 运行任意规模应用
Flink 旨在任意规模上运行有状态流式应用。因此，应用程序被并行化为可能数千个任务，这些任务分布在集群中并发执行。所以应用程序能够充分利用无尽的 CPU、内存、磁盘和网络 IO。而且 Flink 很容易维护非常大的应用程序状态。其异步和增量的检查点算法对处理延迟产生最小的影响，同时保证精确一次状态的一致性。
[Flink 用户报告了其生产环境中一些令人印象深刻的扩展性数字]({{ site.baseurl }}/zh/poweredby.html)
* 处理**每天处理数万亿的事件**,
* 应用维护**几TB大小的状态**, 和
* 应用**在数千个内核上运行**。
## 利用内存性能
有状态的 Flink 程序针对本地状态访问进行了优化。任务的状态始终保留在内存中，如果状态大小超过可用内存，则会保存在能高效访问的磁盘数据结构中。任务通过访问本地（通常在内存中）状态来进行所有的计算，从而产生非常低的处理延迟。Flink 通过定期和异步地对本地状态进行持久化存储来保证故障场景下精确一次的状态一致性。
<div class="row front-graphic">
<img src="{{ site.baseurl }}/img/local-state.png" width="600px" />
</div>
<hr/>
<div class="row">
<div class="col-sm-12" style="background-color: #f8f8f8;">
<h2>
架构
<span class="glyphicon glyphicon-chevron-right"></span>
<a href="{{ site.baseurl }}/zh/flink-applications.html">应用</a>
<span class="glyphicon glyphicon-chevron-right"></span>
<a href="{{ site.baseurl }}/zh/flink-operations.html">运维</a>
</h2>
</div>
</div>
<hr/> | 3,492 | Apache-2.0 |
---
title: 'JavaScript Weekly #578' # 不可修改
date: '2022-02-26' # 不可修改
categories: ['JavaScript Weekly'] # 不可修改
publish: true # 翻译完成后修改
---
<!--以上是预览信息，图片一张或限制百字左右，前者优先，全文请使用二级及以下标题-->
<!-- more -->
[学习 Rx.js 的基础知识](https://javascriptweekly.com/link/120266/web "frontendmasters.com") — 这个 JavaScript 库非常好用，Steve Kinney 在这个详细的视频课程里，介绍了使用它需要了解的内容 — 包括可观察对象、事件、间隔、计时器、运算符等。
[什么是原始值的包装对象？](https://javascriptweekly.com/link/120267/web "2ality.com") — Axel 博士谈到了 boolean 和 string 等基本类型如何关联包装类（例如 Boolean 和 String）。
[如何阅读 ECMAScript 规范](https://javascriptweekly.com/link/120299/web "timothygu.me") — 每次有一个新的 ECMAScript 规范我们都会链接到一篇文章 — 比如这个 ES2022 规范草案。但是谁会阅读如此复杂的文档呢？要不试试这篇？
## **简述:**
* 🟩 [Node 17.6.0](https://javascriptweekly.com/link/120268/web) 已经发布，[目前支持通过 HTTPS 加载 ES 模块](https://javascriptweekly.com/link/120269/web)。
* [Glitch](https://javascriptweekly.com/link/120270/web) 是一个简洁的在线应用程序构建环境，非常适合 JavaScript 应用程序，您现在可以将 Glitch 应用程序 [部署到 DigitalOcean](https://javascriptweekly.com/link/120271/web)。他们还与 [Fastly 合作](https://javascriptweekly.com/link/120272/web)。
* [6 分钟讲述 TypeScript 的 ▶️ 故事](https://javascriptweekly.com/link/120273/web)。如果你喜欢这种风格的话，还有 [异步 JavaScript 的 ▶️ 故事](https://javascriptweekly.com/link/120320/web) 也推荐给你！
## **版本更新:**
[Playwright 1.19](https://javascriptweekly.com/link/120301/web) — 浏览器自动化库。
[neo.mjs 3.2.5](https://javascriptweekly.com/link/120274/web) — Web Worker 增强的前端框架。
[Jasmine 4.0.1](https://javascriptweekly.com/link/120275/web) — JS 测试框架。
[Resemble.js 4.1](https://javascriptweekly.com/link/120276/web) — 图像分析和比较库。
[eva.js 1.2.7](https://javascriptweekly.com/link/120277/web) — 前端游戏引擎。
[History 5.3](https://javascriptweekly.com/link/120278/web) — 使用 JS 管理会话历史记录。
[qooxdoo 7.0](https://javascriptweekly.com/link/120279/web) — 我们上次提到的 SPA 框架是在 7 年前！
## 📒 文章 & 教程
[如何在离开页面时可靠地发送 HTTP 请求](https://javascriptweekly.com/link/120285/web "css-tricks.com") — 浏览器不保证会在页面更改时保留打开的 HTTP 请求，但还是会有一些缓解措施或替代方法（例如信标）。
[如何为 Web 开发文本编辑器](https://javascriptweekly.com/link/120286/web "www.smashingmagazine.com") — 一家公司的工程师正在构建基于浏览器的设计工具，他思考了一些有关制作可靠文本输入小部件的问题。
[3k+ 开发人员完成了 2022 年前端现状调查 — 轮到你了](https://javascriptweekly.com/link/120284/web "hubs.ly") — 我们也需要你！花 8 分钟点击调查，很快就能看到结果。
[未来的 JavaScript：查看记录和元组](https://javascriptweekly.com/link/120302/web "dev.to") — 两年前，我们提到 [记录和元组](https://javascriptweekly.com/link/120303/web) 提案（JS 的两个新的深度不可变的原始类型）在 TC39 达到了第 2 阶段。
[你可以在 JavaScript 中 `throw()` 任何东西（以及其他 `async`/`await` 注意事项）](https://javascriptweekly.com/link/120305/web "www.bennadel.com")。
▶[什么是_Responsible_ JavaScript？](https://javascriptweekly.com/link/120287/web "www.smashingmagazine.com") — JavaScript 的作者谈论了数据使用、用户体验、向后兼容性等主题（55 分钟。）
[如何使用 React Native 制作数据仪表板](https://javascriptweekly.com/link/120289/web "www.influxdata.com")
[如何在 Vue 中使用`nextTick()`](https://javascriptweekly.com/link/120306/web "dmitripavlutin.com") — `nextTick(callback)` 在 DOM 更新时执行回调。
[在 Next.js 中优化第三方脚本加载](https://javascriptweekly.com/link/120290/web)
▶[3 分钟内告诉你你应该知道的关于 Lodash 的 10 件事](https://javascriptweekly.com/link/120291/web)
[比较 Gatsby 和 Next.js](https://javascriptweekly.com/link/120292/web)
[使用 React、Hooks 和 Chakra-UI 实现一个生命游戏](https://javascriptweekly.com/link/120313/web)
## 🛠 代码 & 工具
[Screenshot：不依赖浏览器 — 原生截图库](https://javascriptweekly.com/link/120307/web "www.xata.io") — 使用 MediaDevices API 开发，但提供了一个更易于使用的抽象模式来让用户截取屏幕截图。 [GitHub 仓库](https://javascriptweekly.com/link/120308/web)。
[Stylo：JavaScript 的开源 WYSIWYG 富文本编辑器](https://javascriptweekly.com/link/120293/web "stylojs.com") — 轻量级，无依赖性，您可以配置默认工具栏以满足您应用的特定需求。
[Beam：一个由 Node.js 支持，受 GitHub 启发的团队留言板](https://javascriptweekly.com/link/120294/web "planetscale.com") — Beam 是一个留言板，灵感来自 GitHub 上用于团队交流的类似专有系统。 [GitHub 仓库](https://javascriptweekly.com/link/120295/web)。
[以更少的钱获得更多的云](https://javascriptweekly.com/link/120298/web "vultr.com") — Vultr 为开发人员提供低至每月 2.50 美元的云计算实例。使用此免费积分试用 Vultr 14 天。
[Stockfish.js：国际象棋引擎](https://javascriptweekly.com/link/120296/web "github.com") — Stockfish 是一种流行的国际象棋引擎，[通常用 C++ 编写](https://javascriptweekly.com/link/120297/web)，但该项目通过 WebAssembly 将其引入到了 JS 中。
😆 [Elevator.js：老式的 “滚动到顶部” 按钮](https://javascriptweekly.com/link/120309/web) — 只是有点好玩。
[enum-xyz：使用代理的 JavaScript 枚举](https://javascriptweekly.com/link/120310/web) — 一个有趣的想法。
---
> * 译文出自：[weekly-tracker](https://github.com/FEDarling/weekly-tracker) 项目，期待你的加入！
> * [查看原文](https://javascriptweekly.com/issues/578)对比阅读
> * 发现错误？[提交 PR](https://github.com/FEDarling/weekly-tracker/blob/main/weeklys/javascript_weekly/578)
> * 译者：[daodaolee](https://github.com/daodaolee)
> * 校对者：[daodaolee](https://github.com/daodaolee) | 4,797 | MIT |
<!--
* @Author: 石破天惊
* @email: shanshang130@gmail.com
* @Date: 2021-07-21 13:11:34
* @LastEditTime: 2021-07-28 17:02:31
* @LastEditors: 石破天惊
* @Description:
-->
# 滑动
要使用代码滑动到指定位置，非常简单：
### 第一步，获取LargeList的引用
```$js
<LargeList ref={ref=>(this._list = ref)} />
```
### 第二步，使用scrollTo方法
```$js
this._list && this._list.scrollTo({x:0,y:100}).then().catch();
```
### 可用滑动方法
scrollTo({x:number, y:number}, animated:boolean=true):Promise<void>
滑动到指定的偏移
scrollToIndexPath({section:number, row:number}, animated: boolean = true):Promise<void>
滑动到指定的IndexPath，如果row===-1，则表示滑动到相应的组头
# Javascript端监听滑动
### onScroll : ({nativeEvent:{contentOffset:{x:number, y:number}}})=>any
```$js
<LargeList onScroll={({nativeEvent:{contentOffset:{x, y}}})=>{
console.log("offset : x=", x, "y=", y);
}/>
```
注意：
* y值是有可能超出内容范围之外的
* 不要使用Animated.createAnimatedComponent，LargeList本身支持所有的Animated.View的属性，如果需要高性能的监听偏移，请使用下面的原生动画驱动
# 监听原生偏移值
### onNativeContentOffsetExtract : {x?:Animated.Value, y?:Animated.Value}
使用原生动画值监听滑动偏移，可以用作插值动画
```$js
_nativeOffset = {
y: new Animated.Value(0)
};
render(){
return <LargeList onNativeContentOffsetExtract={this._nativeOffset} />
}
``` | 1,204 | MIT |
---
layout: tutorial
title: JSONStore コレクションへのデータの追加
breadcrumb_title: JSONStore コレクションへのデータの追加
relevantTo: [reactnative]
weight: 1
downloads:
- name: Download React Native project
url: https://github.com/MobileFirst-Platform-Developer-Center/JSONStoreReactNative
---
<!-- NLS_CHARSET=UTF-8 -->
## React Native 開発環境のセットアップ
React Native 開発用にご使用のマシンをセットアップするには、React Native の[『Gettings Started』ページ](https://facebook.github.io/react-native/docs/getting-started.html)に記載されている手順に従います。
## React Native アプリケーションへの JSONStore SDK の追加
React Native 用の JSONStore SDK は、[npm](https://www.npmjs.com/package/react-native-mobilefirst-jsonstore) から React Native モジュールとして入手可能です。
### 新規 React Native プロジェクトの開始
1. 新規 React Native プロジェクトを作成します。
```bash
react-native init MyReactApp
```
2. MobileFirst SDK をアプリケーションに追加します。
```bash
cd MyReactApp
npm install react-native-ibm-mobilefirst-jsonstore --save
```
3. すべてのネイティブ依存関係をアプリケーションにリンクします。
```bash
react-native link
```
## JSONStore コレクションへのデータの追加
`App.js` 内で以下のパッケージをインポートする必要があります。
```javascript
import { JSONStoreCollection, WLJSONStore } from 'react-native-ibm-mobilefirst-jsonstore';
```
JSONStore コレクションにデータを追加するためのステップは以下の 3 つです。
1. 新規コレクションの作成。以下に示すように、`JSONStoreCollection` コンストラクターを呼び出すことで新規コレクションを作成できます。
```javascript
var favourites = new JSONStoreCollection('favourites');
```
2. コレクションのオープン。新規作成したコレクションで何かを行うには、そのコレクションを開く必要があります。 コレクションを開くには、WLJSONStore の `openCollections` API を呼び出します。 以下のサンプル・コードを参照してください。
```javascript
WLJSONStore.openCollections(['favourites']).then(data => { console.log(data); }).catch(err =>{ console.log(err); });
```
3. コレクションへのデータの追加。コレクションを開いた後で、内側または外側からデータ・トランザクションを開始します。 以下の API を使用して、開いたコレクションにデータを追加できます。
```javascript
var favCollection = new JSONStoreCollection('favourites');
favCollection.addData(myJsonData)
.then(data => {
console.log("Succesfully added data to collection!"));
.catch(err => {
console.log("Error while adding data to collection. Reason : " + err);
});
``` | 2,145 | Apache-2.0 |
---
title: 介绍如何将 Azure SignalR 服务与 ASP.NET 配合使用的快速入门
description: 有关如何使用 Azure SignalR 服务通过 ASP.NET 框架创建聊天室的快速入门。
author: sffamily
ms.service: signalr
ms.devlang: dotnet
ms.topic: quickstart
ms.date: 04/20/2019
ms.author: zhshang
ms.openlocfilehash: 2020ee02d236ca13431adb736d9f48171d33b4f3
ms.sourcegitcommit: 72f1d1210980d2f75e490f879521bc73d76a17e1
ms.translationtype: HT
ms.contentlocale: zh-CN
ms.lasthandoff: 06/14/2019
ms.locfileid: "67147418"
---
# <a name="quickstart-create-a-chat-room-with-aspnet-and-signalr-service"></a>快速入门：使用 ASP.NET 和 SignalR 服务创建聊天室
Azure SignalR 服务基于[适用于 ASP.NET Core 2.0 的 SignalR](https://docs.microsoft.com/aspnet/core/signalr/introduction)，后者**并非**与 ASP.NET SignalR 100% 兼容。 Azure SignalR 服务基于最新的 ASP.NET Core 技术重新实现了 ASP.NET SignalR 数据协议。 使用用于 ASP.NET SignalR 的 Azure SignalR 服务时，某些 ASP.NET SignalR 功能不再受支持，例如 Azure SignalR 在客户端重新连接时不重播消息。 另外，Forever Frame 传输和 JSONP 也不受支持。 若要使 ASP.NET SignalR 应用程序兼容 SignalR 服务，必须进行一些代码更改并确保所依赖库的版本正确。
请参阅[版本差异文档](https://docs.microsoft.com/aspnet/core/signalr/version-differences?view=aspnetcore-2.2)，获取在 ASP.NET SignalR 和 ASP.NET Core SignalR 之间进行的功能比较的完整列表。
本快速入门介绍如何从 ASP.NET 和 Azure SignalR 服务着手来创建类似的[聊天室应用程序](./signalr-quickstart-dotnet-core.md)。
[!INCLUDE [quickstarts-free-trial-note](../../includes/quickstarts-free-trial-note.md)]
## <a name="prerequisites"></a>先决条件
* [Visual Studio 2019](https://visualstudio.microsoft.com/downloads/)
* [.NET 4.6.1](https://www.microsoft.com/net/download/windows)
* [ASP.NET SignalR 2.4.1](https://www.nuget.org/packages/Microsoft.AspNet.SignalR/)
## <a name="sign-in-to-azure"></a>登录 Azure
使用 Azure 帐户登录到 [Azure 门户](https://portal.azure.com/)。
[!INCLUDE [Create instance](includes/signalr-quickstart-create-instance.md)]
ASP.NET SignalR 应用程序不支持无服务器模式。 对于 Azure SignalR 服务实例，请始终使用“默认”或“经典”。
也可根据[创建 SignalR 服务脚本](scripts/signalr-cli-create-service.md)中的说明，创建在本快速入门中使用的 Azure 资源。
## <a name="clone-the-sample-application"></a>克隆示例应用程序
在部署该服务时，让我们切换到使用代码。 克隆[来自 GitHub 的示例应用](https://github.com/aspnet/AzureSignalR-samples/tree/master/aspnet-samples/ChatRoom)，设置 SignalR 服务连接字符串，并在本地运行该应用程序。
1. 打开 git 终端窗口。 切换到要克隆示例项目的文件夹。
1. 运行下列命令以克隆示例存储库。 此命令在计算机上创建示例应用程序的副本。
```bash
git clone https://github.com/aspnet/AzureSignalR-samples.git
```
## <a name="configure-and-run-chat-room-web-app"></a>配置并运行聊天室 Web 应用
1. 启动 Visual Studio，并打开所克隆存储库的 *aspnet-samples/ChatRoom/* 文件夹中的解决方案。
1. 在打开了 Azure 门户的浏览器中，查找并选择所创建的实例。
1. 选择“密钥” 以查看 SignalR 服务实例的连接字符串。
1. 选择并复制主连接字符串。
1. 现在请在 web.config 文件中设置连接字符串。
```xml
<configuration>
<connectionStrings>
<add name="Azure:SignalR:ConnectionString" connectionString="<Replace By Your Connection String>"/>
</connectionStrings>
...
</configuration>
```
1. 需在 *Startup.cs* 中调用 `MapAzureSignalR({your_applicationName})` 而不是 `MapSignalR()`，传入连接字符串，使应用程序连接到服务，而不是自行托管 SignalR。 将 `{YourApplicationName}` 替换为应用程序的名称。 此名称是独一无二的名称，可以将此应用程序与其他应用程序区别开来。 可以使用 `this.GetType().FullName` 作为值。
```cs
public void Configuration(IAppBuilder app)
{
// Any connection or hub wire up and configuration should go here
app.MapAzureSignalR(this.GetType().FullName);
}
```
此外还需在使用这些 API 之前参考服务 SDK。 打开“工具”|“NuGet 包管理器”|“包管理器控制台”，然后运行以下命令：
```powershell
Install-Package Microsoft.Azure.SignalR.AspNet
```
除了这些更改，所有其他功能保持不变，你仍然可以使用已经熟悉的中心界面来编写业务逻辑。
> [!NOTE]
> 在实现时，Azure SignalR 服务 SDK 会公开用于协商的终结点 `/signalr/negotiate`。 它会在客户端尝试连接时返回特殊的协商响应，将客户端重定向到连接字符串中定义的服务终结点。
1. 按 **F5** 以调试模式运行项目。 可以看到应用程序在本地运行。 它现在会连接到 Azure SignalR 服务，而不是由应用程序自身来托管 SignalR 运行时。
[!INCLUDE [Cleanup](includes/signalr-quickstart-cleanup.md)]
> [!IMPORTANT]
> 删除资源组的操作不可逆，资源组以及其中的所有资源将被永久删除。 请确保不会意外删除错误的资源组或资源。 如果在现有资源组（其中包含要保留的资源）中为托管此示例而创建了相关资源，可从各自的边栏选项卡逐个删除这些资源，而不要删除资源组。
>
>
登录到 [Azure 门户](https://portal.azure.com)，并单击“资源组”。
在“按名称筛选...”文本框中键入资源组的名称 。 本快速入门的说明使用了名为“SignalRTestResources”的资源组 。 在结果列表中的资源组上，单击“...”，然后单击“删除资源组” 。
片刻之后，将会删除该资源组及其包含的所有资源。
## <a name="next-steps"></a>后续步骤
在本快速入门中，我们创建了一个新的 Azure SignalR 服务资源，并将其与 ASP.NET Web 应用配合使用。 接下来，需了解如何将 Azure SignalR 服务与 ASP.NET Core 配合使用，以便开发实时应用程序。
> [!div class="nextstepaction"]
> [将 Azure SignalR 服务与 ASP.NET Core 配合使用](./signalr-quickstart-dotnet-core.md) | 4,367 | CC-BY-4.0 |
## 如何生成 JSBridge 初始化时所需的参数及签名？
---
> 请先自行阅读：
>
> [《抖音开放平台开发文档 - 授权：JS 验证签名》](https://open.douyin.com/platform/doc/6850443440044410888)
你可根据官方文档的规则利用本库提供的 `MD5Utility` 工具类自行进行签名生成。
此外，本库还封装了直接生成参数及签名的扩展方法，下面给出一个示例：
```csharp
/* 以生成 sdk.config() 所需参数为例 */
var request = new Models.JSGetTicketRequest()
{
AccessToken = "抖音开放平台的 AccessToken"
};
var response = await client.ExecuteJSGetTicketAsync(request);
var paramMap = client.GenerateParametersForJSBridgeConfig(response.Data.Ticket, "https://example.com");
``` | 521 | MIT |
---
layout: post
title: "吴思：官家主义—关于我们是谁的土产说法（共识沙龙微信公益讲座）"
date: 2020-12-18T04:52:29.000Z
author: 共识沙龙
from: https://www.youtube.com/watch?v=Cjku_tI_oTY
tags: [ 共识沙龙 ]
categories: [ 共识沙龙 ]
---
<!--1608267149000-->
[吴思：官家主义—关于我们是谁的土产说法（共识沙龙微信公益讲座）](https://www.youtube.com/watch?v=Cjku_tI_oTY)
------
<div>
B站：https://space.bilibili.com/555412565Podcast: https://anchor.fm/consensussalonApple：https://podcasts.apple.com/de/podcast/%E5%85%B1%E8%AF%86%E6%B2%99%E9%BE%99/id1522222071
</div> | 487 | MIT |
<!-- YAML
added: v0.6.7
changes:
- version: v10.0.0
pr-url: https://github.com/nodejs/node/pull/12562
description: The `callback` parameter is no longer optional. Not passing
it will throw a `TypeError` at runtime.
- version: v7.0.0
pr-url: https://github.com/nodejs/node/pull/7897
description: The `callback` parameter is no longer optional. Not passing
it will emit a deprecation warning with id DEP0013.
- version: v7.0.0
pr-url: https://github.com/nodejs/node/pull/7831
description: The passed `options` object will never be modified.
- version: v5.0.0
pr-url: https://github.com/nodejs/node/pull/3163
description: The `file` parameter can be a file descriptor now.
-->
* `path` {string|Buffer|URL|number} 文件名或文件描述符。
* `data` {string|Buffer}
* `options` {Object|string}
* `encoding` {string|null} **默认值:** `'utf8'`。
* `mode` {integer} **默认值:** `0o666`。
* `flag` {string} 参阅[支持的文件系统标志][support of file system `flags`]。**默认值:** `'a'`。
* `callback` {Function}
* `err` {Error}
异步地将数据追加到文件，如果文件尚不存在则创建该文件。
`data` 可以是字符串或 [`Buffer`]。
```js
fs.appendFile('message.txt', '追加的数据', (err) => {
if (err) throw err;
console.log('数据已追加到文件');
});
```
如果 `options` 是字符串，则它指定字符编码：
```js
fs.appendFile('message.txt', '追加的数据', 'utf8', callback);
```
`path` 可以指定为已打开用于追加（使用 `fs.open()` 或 `fs.openSync()`）的数字型文件描述符。
文件描述符不会自动关闭。
```js
fs.open('message.txt', 'a', (err, fd) => {
if (err) throw err;
fs.appendFile(fd, '追加的数据', 'utf8', (err) => {
fs.close(fd, (err) => {
if (err) throw err;
});
if (err) throw err;
});
});
``` | 1,626 | CC-BY-4.0 |
# Angularを理解する
Angularフレームワークの機能を理解するために、次のことを学ぶ必要があります。
* コンポーネント
* テンプレート
* ディレクティブ
* 依存オブジェクト注入
このセクションのトピックでは、これらの機能と概念、およびそれらの使用方法について説明します。
## 前提知識
これらの開発者ガイドを最大限に活用するために、次のトピックを確認する必要があります。
* [Angularとは][AioGuideWhatIsAngular]。
* [チュートリアルを始める][AioStart]。
## Angularの基本を学ぶ
<div class="card-container">
<a href="guide/component-overview" class="docs-card" title="コンポーネント">
<section>コンポーネント</section>
<p>Angularのコンポーネントについて学びます。コンポーネントはAngular開発の重要な構成単位です。
<p class="card-footer">コンポーネント</p>
</a>
<a href="guide/template-syntax" class="docs-card" title="テンプレート">
<section>テンプレート</section>
<p>Angularテンプレートの構築方法について説明します。</p>
<p class="card-footer">テンプレート</p>
</a>
<a href="guide/built-in-directives" class="docs-card" title="ディレクティブ">
<section>ディレクティブ</section>
<p>Angularディレクティブについて学びます。ディレクティブは、Angularアプリケーションの要素に振る舞いを追加するクラスです。</p>
<p class="card-footer">ディレクティブ</p>
</a>
<a href="guide/dependency-injection" class="docs-card" title="依存オブジェクト注入">
<section>依存オブジェクト注入</section>
<p>依存オブジェクト注入について説明します。依存オブジェクトとは、クラスが特定の機能を実行するために必要なサービスまたはオブジェクトを指します。</p>
<p class="card-footer">依存オブジェクト注入</p>
</a>
<!-- <a href="guide/rendering-overview" class="docs-card" title="Angular service worker developer guide">
<section>Rendering</section>
<p>Learn how about server-side rendering and pre-rendering using Angular Universal.</p>
<p class="card-footer">Angular Universal</p>
</a> -->
</div>
<!-- links -->
[AioGuideWhatIsAngular]: guide/what-is-angular "What is Angular\? | Angular"
[AioStart]: start "Getting started with Angular | Angular"
<!-- external links -->
<!-- end links -->
@reviewed 2021-11-05 | 1,699 | MIT |
<properties
pageTitle="Cordova モバイル サービス プロジェクトの概要 (Visual Studio 接続済みサービス) | Microsoft Azure"
description="Visual Studio 接続済みサービスを使用して Azure Mobile Services に Cordova プロジェクトを接続した後の最初の手順について説明します。"
services="mobile-services"
documentationCenter=""
authors="mlhoop"
manager="douge"
editor=""/>
<tags
ms.service="mobile-services"
ms.workload="mobile"
ms.tgt_pltfrm="vs-getting-started"
ms.devlang="multiple"
ms.topic="article"
ms.date="01/05/2016"
ms.author="mlearned"/>
# Mobile Services の使用 (Cordova プロジェクト)
[AZURE.INCLUDE [mobile-service-note-mobile-apps](../../includes/mobile-services-note-mobile-apps.md)]
##最初の手順
これらの例で使用されているコードを実行するために行う必要がある最初のステップは、接続しているモバイル サービスの種類によります。
- JavaScript バックエンド モバイル サービスの場合は、TodoItem と呼ばれるテーブルを作成します。テーブルを作成するには、サーバー エクスプローラーの Azure ノード下でモバイル サービスを特定し、そのモバイル サービスのノードを右クリックしてコンテキスト メニューを開き、[**Create Table (テーブルの作成)**] を選択します。テーブル名として「TodoItem」と入力します。
- .NET バックエンド モバイル サービスの場合は、TodoItem テーブルは Visual Studio によって既にデフォルトのプロジェクト テンプレート内に作成されていますが、これを Azure に発行する必要があります。発行するには、ソリューション エクスプローラーでモバイル サービス プロジェクトのコンテキスト メニューを開き、[**Publish Web (Web の発行)**] を選択します。既定値を受け入れ、**[Publish (発行)]** を選択します。
##テーブルへの参照を作成する
次のコードは、TodoItem のデータを含むテーブルへの参照を取得します。この後でデータ テーブルの読み取りと更新の操作を実行する際に、TodoItem のデータを使用できます。モバイル サービスを作成すると、TodoItem テーブルが自動的に作成されます。
var todoTable = mobileServiceClient.getTable('TodoItem');
これらの例を使用するには、テーブルのアクセス許可を **[アプリケーション キーを持つユーザー]** に設定する必要があります。後で、認証を設定できます。詳細については、「[Add authentication to your Mobile Services app (Mobile Services アプリケーションに認証を追加する)](mobile-services-html-get-started-users.md)」を参照してください。
##テーブルに項目を追加する
新しい項目をデータ テーブルに挿入します。ID (文字列型の GUID) が新しい行のプライマリ キーとして自動的に作成されます。返された **Promise** オブジェクト上の [done](https://msdn.microsoft.com/library/dn802826.aspx) メソッドを呼び出し、挿入されたオブジェクトのコピーを取得して、エラーがあれば処理します。
function TodoItem(text) {
this.text = text;
this.complete = false;
}
var items = new Array();
var insertTodoItem = function (todoItem) {
todoTable.insert(todoItem).done(function (item) {
items.push(item)
});
};
##テーブルの読み取りまたはクエリを実行する
次のコードは、テーブルに対してテキスト フィールドでソートされたすべての項目を照会します。コードを追加して、success ハンドラーでクエリ結果を処理できます。この場合、項目のローカル配列が更新されます。
todoTable.orderBy('text')
.read().done(function (results) {
items = results.slice();
});
where メソッドを使用してクエリを変更できます。次の例では、完了した項目を除外します。
todoTable.where(function () {
return (this.complete === false);
})
.read().done(function (results) {
items = results.slice();
});
使用できる他のクエリ例については、「[query オブジェクト](http://msdn.microsoft.com/library/azure/jj613353.aspx)」を参照してください。
##テーブル項目を更新する
データ テーブルの行を更新します。このコードでは、モバイル サービスが応答すると、項目は一覧から削除されます。返された **Promise** オブジェクト上の [done](https://msdn.microsoft.com/library/dn802826.aspx) メソッドを呼び出し、挿入されたオブジェクトのコピーを取得して、エラーがあれば処理します。
todoTable.update(todoItem).done(function (item) {
// Update a local collection of items.
items.splice(items.indexOf(todoItem), 1, item);
});
##テーブル項目を削除する
**del** メソッドを使用してデータ テーブルの行を削除します。返された **Promise** オブジェクト上の [done](https://msdn.microsoft.com/library/dn802826.aspx) メソッドを呼び出し、挿入されたオブジェクトのコピーを取得して、エラーがあれば処理します。
todoTable.del(todoItem).done(function (item) {
items.splice(items.indexOf(todoItem), 1);
});
[モバイル サービスの詳細を確認する](https://azure.microsoft.com/documentation/services/mobile-services/)
<!---HONumber=AcomDC_0128_2016--> | 3,441 | CC-BY-3.0 |
---
title: 将拉取请求链接到议题
intro: 您可以将拉取请求链接到议题，以显示修复正在进行中，并在拉取请求被合并时自动关闭该议题。
redirect_from:
- /github/managing-your-work-on-github/managing-your-work-with-issues-and-pull-requests/linking-a-pull-request-to-an-issue
- /articles/closing-issues-via-commit-message
- /articles/closing-issues-via-commit-messages
- /articles/closing-issues-using-keywords
- /github/managing-your-work-on-github/closing-issues-using-keywords
- /github/managing-your-work-on-github/linking-a-pull-request-to-an-issue
- /issues/tracking-your-work-with-issues/creating-issues/linking-a-pull-request-to-an-issue
versions:
fpt: '*'
ghes: '*'
ghae: '*'
ghec: '*'
topics:
- Pull requests
shortTitle: 将 PR 链接到议题
---
{% note %}
**注：**当拉取请求指向仓库的*默认*分支时，将解析拉取请求说明中的特殊关键字。 但是，如果拉取请求的基础是*任何其他分支*，则将忽略这些关键字，不创建任何链接，并且合并拉取请求对议题没有影响。 **如果要使用关键字将拉取请求链接到议题，则拉取请求必须在默认分支上。**
{% endnote %}
## 关于链接的议题和拉取请求
You can link an issue to a pull request manually or using a supported keyword in the pull request description.
当您将拉取请求链接到拉取请求指向的议题，如果有人正在操作该议题，协作者可以看到。
将链接的拉取请求合并到仓库的默认分支时，其链接的议题将自动关闭。 有关默认分支的更多信息，请参阅“[更改默认分支](/github/administering-a-repository/changing-the-default-branch)”。
## 使用关键词将拉取请求链接到议题
您可以通过在拉取请求说明或提交消息中使用支持的关键词将拉取请求链接到议题。 拉取请求**必须**在默认分支上。
* close
* closes
* closed
* fix
* fixes
* fixed
* 解决
* resolves
* resolved
如果使用关键字在另一个拉取请求中引用拉取请求注释，则将链接拉取请求。 合并引用拉取请求也会关闭引用的拉取请求。
关闭关键词的语法取决于议题是否与拉取请求在同一仓库中。
| 链接的议题 | 语法 | 示例 |
| -------- | --------------------------------------------- | -------------------------------------------------------------- |
| 同一仓库中的议题 | *KEYWORD* #*ISSUE-NUMBER* | `Closes #10` |
| 不同仓库中的议题 | *KEYWORD* *OWNER*/*REPOSITORY*#*ISSUE-NUMBER* | `Fixes octo-org/octo-repo#100` |
| 多个议题 | 对每个议题使用完整语法 | `Resolves #10, resolves #123, resolves octo-org/octo-repo#100` |
Only manually linked pull requests can be manually unlinked. To unlink an issue that you linked using a keyword, you must edit the pull request description to remove the keyword.
您也可以在提交消息中使用关闭关键词。 议题将在提交合并到默认分支时关闭，但包含提交的拉取请求不会列为链接的拉取请求。
## 手动将拉取请求链接到议题
对仓库有写入权限的任何人都可以手动将拉取请求链接到议题。
您可以手动链接最多 10 个议题到每个拉取请求。 议题和拉取请求必须位于同一仓库中。
{% data reusables.repositories.navigate-to-repo %}
{% data reusables.repositories.sidebar-pr %}
3. 在拉取请求列表中，单击要链接到议题的拉取请求。
{% ifversion fpt or ghec or ghes > 3.4 or ghae-issue-6234 %}
4. 在右侧边栏的“Development（开发）”部分，单击 {% octicon "gear" aria-label="The Gear icon" %}。
{% else %}
4. 在右侧边栏中，单击 **Linked issues（链接的议题）**。 
{% endif %}
5. 单击要链接到拉取请求的议题。 
## 延伸阅读
- "[自动链接的引用和 URL](/articles/autolinked-references-and-urls/#issues-and-pull-requests)" | 2,948 | CC-BY-4.0 |
---
title: Azure Active Directory と Workday の統合のリファレンス
description: Workday による人事主導のプロビジョニングに関する技術的な詳細
services: active-directory
author: cmmdesai
manager: daveba
ms.service: active-directory
ms.subservice: app-provisioning
ms.topic: reference
ms.workload: identity
ms.date: 02/09/2021
ms.author: chmutali
ms.openlocfilehash: 2b1a43ee6b13d32c0eaed92538cf9c25405e061b
ms.sourcegitcommit: f28ebb95ae9aaaff3f87d8388a09b41e0b3445b5
ms.translationtype: HT
ms.contentlocale: ja-JP
ms.lasthandoff: 03/29/2021
ms.locfileid: "100104333"
---
# <a name="how-azure-active-directory-provisioning-integrates-with-workday"></a>Azure Active Directory のプロビジョニングと Workday の統合方法
ユーザーの ID のライフ サイクルを管理するために、[Azure Active Directory ユーザー プロビジョニング サービス](../app-provisioning/user-provisioning.md)と [Workday HCM](https://www.workday.com) を統合します。 Azure Active Directory では、次の 3 つの統合があらかじめ構築されています。
* [Workday からオンプレミスの Active Directory へのユーザー プロビジョニング](../saas-apps/workday-inbound-tutorial.md)
* [Workday から Azure Active Directory へのユーザー プロビジョニング](../saas-apps/workday-inbound-cloud-only-tutorial.md)
* [Workday Writeback](../saas-apps/workday-writeback-tutorial.md)
この記事では、統合のしくみと、さまざまな HR シナリオでプロビジョニング動作をカスタマイズする方法について説明します。
## <a name="establishing-connectivity"></a>接続の確立
### <a name="restricting-workday-api-access-to-azure-ad-endpoints"></a>Azure AD エンドポイントへの Workday API アクセスを制限する
Azure AD プロビジョニング サービスでは、基本認証を使用して Workday Web サービス API エンドポイントに接続します。
Azure AD プロビジョニング サービスと Workday の間の接続をさらにセキュリティで保護するため、指定された統合システム ユーザーが許可された Azure AD の IP 範囲からのみ Workday API にアクセスするように、アクセスを制限できます。 Workday 管理者と協力しながら、Workday テナントで次の構成を完了してください。
1. Azure パブリック クラウドの[最新の IP 範囲](https://www.microsoft.com/download/details.aspx?id=56519)をダウンロードします。
1. ファイルを開き、**AzureActiveDirectory** タグを検索します
>[!div class="mx-imgBorder"]
>
1. *addressPrefixes* 要素内に列記されているすべての IP アドレス範囲をコピーし、その範囲を使用して IP アドレス リストを作成します。
1. Workday 管理ポータルにログインします。
1. **[IP 範囲の管理]** タスクにアクセスして、Azure データセンターの新しい IP 範囲を作成します。 IP 範囲 (CIDR 表記を使用) をコンマ区切りのリストとして指定します。
1. **[認証ポリシーの管理]** タスクにアクセスして、新しい認証ポリシーを作成します。 認証ポリシーで、認証許可リストを使用して、Azure AD の IP 範囲と、この IP 範囲からのアクセスを許可するセキュリティ グループを指定します。 変更を保存します。
1. **[保留中のすべての認証ポリシーの変更をアクティブ化]** タスクにアクセスして、変更を確認します。
### <a name="limiting-access-to-worker-data-in-workday-using-constrained-security-groups"></a>制約付きセキュリティ グループを使用して Workday のワーカー データへのアクセスを制限する
[Workday 統合システムユーザーを構成](../saas-apps/workday-inbound-tutorial.md#configure-integration-system-user-in-workday)する既定の手順では、Workday テナントのすべてのユーザーを取得するためのアクセス権が付与されます。 統合シナリオによっては、特定の監督組織にのみ所属するユーザーが Get_Workers API 呼び出しによって返され、Workday Azure AD コネクタによって処理されるように、アクセスを制限する必要があります。
Workday 管理者と協力して制約付きの統合システム セキュリティ グループを構成することで、この要件を満たすことができます。 これを行う方法の詳細については、[こちらの Workday コミュニティの記事](https://community.workday.com/forums/customer-questions/620393)をご覧ください (*この記事にアクセスするには、Workday コミュニティのログイン資格情報が必要です*)
このように制約付きの ISSG (統合システム セキュリティ グループ) を使用してアクセスを制限する戦略は、次のシナリオで特に役立ちます。
* **フェーズ ロールアウトのシナリオ**:大規模な Workday テナントがあり、Workday から Azure AD への自動プロビジョニングを段階的にロールアウトする予定である。 このシナリオでは、Azure AD スコープ フィルターを使用して現在のフェーズのスコープに含まれないユーザーを除外するのではなく、スコープ内のワーカーだけが Azure AD に表示されるように制約付きの ISSG を構成することをお勧めします。
* **複数のプロビジョニング ジョブのシナリオ**:大規模な Workday テナントと、それぞれ異なる事業単位/部門/会社をサポートする複数の AD ドメインがある。 このトポロジをサポートするには、複数の Workday から Azure AD へのプロビジョニング ジョブを実行し、各ジョブで特定のワーカー セットをプロビジョニングします。 このシナリオでは、Azure AD スコープ フィルターを使用してワーカー データを除外するのではなく、関連するワーカー データだけが Azure AD に表示されるように制約付き ISSG を構成することをお勧めします。
### <a name="workday-test-connection-query"></a>Workday テスト接続クエリ
Workday への接続をテストするため、次の *Get_Workers* Workday Web サービス要求が Azure AD によって送信されます。
```XML
<!-- Test connection query tries to retrieve one record from the first page -->
<!-- Replace version with Workday Web Services version present in your connection URL -->
<!-- Replace timestamps below with the UTC time corresponding to the test connection event -->
<Get_Workers_Request p1:version="v21.1" xmlns:p1="urn:com.workday/bsvc" xmlns="urn:com.workday/bsvc">
<p1:Request_Criteria>
<p1:Transaction_Log_Criteria_Data>
<p1:Transaction_Date_Range_Data>
<p1:Updated_From>2021-01-19T02:28:50.1491022Z</p1:Updated_From>
<p1:Updated_Through>2021-01-19T02:28:50.1491022Z</p1:Updated_Through>
</p1:Transaction_Date_Range_Data>
</p1:Transaction_Log_Criteria_Data>
<p1:Exclude_Employees>true</p1:Exclude_Employees>
<p1:Exclude_Contingent_Workers>true</p1:Exclude_Contingent_Workers>
<p1:Exclude_Inactive_Workers>true</p1:Exclude_Inactive_Workers>
</p1:Request_Criteria>
<p1:Response_Filter>
<p1:As_Of_Effective_Date>2021-01-19T02:28:50.1491022Z</p1:As_Of_Effective_Date>
<p1:As_Of_Entry_DateTime>2021-01-19T02:28:50.1491022Z</p1:As_Of_Entry_DateTime>
<p1:Page>1</p1:Page>
<p1:Count>1</p1:Count>
</p1:Response_Filter>
<p1:Response_Group>
<p1:Include_Reference>1</p1:Include_Reference>
<p1:Include_Personal_Information>1</p1:Include_Personal_Information>
</p1:Response_Group>
</Get_Workers_Request>
```
## <a name="how-full-sync-works"></a>完全同期のしくみ
Workday 主導のプロビジョニングのコンテキストにおける **完全同期** とは、Workday からすべての ID をフェッチし、各ワーカー オブジェクトに適用するプロビジョニング ルールを決定するプロセスを指します。 完全同期は、初めてプロビジョニングを有効にしたときと、Azure portal または Graph API を使用して "*プロビジョニングを再開*" したときに行われます。
ワーカー データを取得するために、次の *Get_Workers* Workday Web サービス要求が Azure AD によって送信されます。 このクエリでは、Workday トランザクション ログから、完全同期の実行に対応する時点の有効日が指定されたすべてのワーカー エントリが検索されます。
```XML
<!-- Workday full sync query -->
<!-- Replace version with Workday Web Services version present in your connection URL -->
<!-- Replace timestamps below with the UTC time corresponding to full sync run -->
<!-- Count specifies the number of records to return in each page -->
<!-- Response_Group flags derived from provisioning attribute mapping -->
<Get_Workers_Request p1:version="v21.1" xmlns:p1="urn:com.workday/bsvc" xmlns="urn:com.workday/bsvc">
<p1:Request_Criteria>
<p1:Transaction_Log_Criteria_Data>
<p1:Transaction_Type_References>
<p1:Transaction_Type_Reference>
<p1:ID p1:type="Business_Process_Type">Hire Employee</p1:ID>
</p1:Transaction_Type_Reference>
<p1:Transaction_Type_Reference>
<p1:ID p1:type="Business_Process_Type">Contract Contingent Worker</p1:ID>
</p1:Transaction_Type_Reference>
</p1:Transaction_Type_References>
</p1:Transaction_Log_Criteria_Data>
</p1:Request_Criteria>
<p1:Response_Filter>
<p1:As_Of_Effective_Date>2021-01-19T02:29:16.0094202Z</p1:As_Of_Effective_Date>
<p1:As_Of_Entry_DateTime>2021-01-19T02:29:16.0094202Z</p1:As_Of_Entry_DateTime>
<p1:Count>30</p1:Count>
</p1:Response_Filter>
<p1:Response_Group>
<p1:Include_Reference>1</p1:Include_Reference>
<p1:Include_Personal_Information>1</p1:Include_Personal_Information>
<p1:Include_Employment_Information>1</p1:Include_Employment_Information>
<p1:Include_Organizations>1</p1:Include_Organizations>
<p1:Exclude_Organization_Support_Role_Data>1</p1:Exclude_Organization_Support_Role_Data>
<p1:Exclude_Location_Hierarchies>1</p1:Exclude_Location_Hierarchies>
<p1:Exclude_Cost_Center_Hierarchies>1</p1:Exclude_Cost_Center_Hierarchies>
<p1:Exclude_Company_Hierarchies>1</p1:Exclude_Company_Hierarchies>
<p1:Exclude_Matrix_Organizations>1</p1:Exclude_Matrix_Organizations>
<p1:Exclude_Pay_Groups>1</p1:Exclude_Pay_Groups>
<p1:Exclude_Regions>1</p1:Exclude_Regions>
<p1:Exclude_Region_Hierarchies>1</p1:Exclude_Region_Hierarchies>
<p1:Exclude_Funds>1</p1:Exclude_Funds>
<p1:Exclude_Fund_Hierarchies>1</p1:Exclude_Fund_Hierarchies>
<p1:Exclude_Grants>1</p1:Exclude_Grants>
<p1:Exclude_Grant_Hierarchies>1</p1:Exclude_Grant_Hierarchies>
<p1:Exclude_Business_Units>1</p1:Exclude_Business_Units>
<p1:Exclude_Business_Unit_Hierarchies>1</p1:Exclude_Business_Unit_Hierarchies>
<p1:Exclude_Programs>1</p1:Exclude_Programs>
<p1:Exclude_Program_Hierarchies>1</p1:Exclude_Program_Hierarchies>
<p1:Exclude_Gifts>1</p1:Exclude_Gifts>
<p1:Exclude_Gift_Hierarchies>1</p1:Exclude_Gift_Hierarchies>
<p1:Include_Management_Chain_Data>1</p1:Include_Management_Chain_Data>
<p1:Include_Transaction_Log_Data>1</p1:Include_Transaction_Log_Data>
<p1:Include_Additional_Jobs>1</p1:Include_Additional_Jobs>
</p1:Response_Group>
</Get_Workers_Request>
```
*Response_Group* ノードは、Workday からフェッチするワーカー属性を指定するために使用されます。 *Response_Group* ノードの各フラグの説明については、Workday の [Get_Workers API のドキュメント](https://community.workday.com/sites/default/files/file-hosting/productionapi/Human_Resources/v35.2/Get_Workers.html#Worker_Response_GroupType)をご覧ください。
*Response_Group* ノードに指定されるいくつかのフラグ値は、Workday Azure AD プロビジョニング アプリで構成された属性に基づいて計算されます。 フラグ値の設定に使用される条件については、"*サポートされているエンティティ*" に関するセクションを参照してください。
上記のクエリに対する Workday からの *Get_Workers* 応答には、ワーカー レコードの数とページ数が含まれています。
```XML
<wd:Response_Results>
<wd:Total_Results>509</wd:Total_Results>
<wd:Total_Pages>17</wd:Total_Pages>
<wd:Page_Results>30</wd:Page_Results>
<wd:Page>1</wd:Page>
</wd:Response_Results>
```
結果セットの次のページを取得するには、次の *Get_Workers* クエリで、*Response_Filter* のパラメーターとしてページ番号を指定します。
```XML
<p1:Response_Filter>
<p1:As_Of_Effective_Date>2021-01-19T02:29:16.0094202Z</p1:As_Of_Effective_Date>
<p1:As_Of_Entry_DateTime>2021-01-19T02:29:16.0094202Z</p1:As_Of_Entry_DateTime>
<p1:Page>2</p1:Page>
<p1:Count>30</p1:Count>
</p1:Response_Filter>
```
完全同期中に、Azure AD プロビジョニング サービスによって各ページが処理され、すべての有効なワーカーが反復処理されます。Workday からインポートされたワーカー エントリごとに、
* Workday から属性値を取得するために [XPATH 式](workday-attribute-reference.md)が適用されます。
* 属性マッピングと照合ルールが適用されます。
* ターゲット (Azure AD/AD) で実行する操作がサービスによって決定されます。
処理が完了すると、完全同期の開始に関連付けられているタイムスタンプがウォーターマークとして保存されます。 このウォーターマークは、増分同期サイクルの開始点として使用されます。
## <a name="how-incremental-sync-works"></a>増分同期のしくみ
完全同期の後、Azure AD プロビジョニング サービスによって `LastExecutionTimestamp` が保持され、それを使用して増分変更を取得するためのデルタ クエリが作成されます。 増分同期中は、次の種類のクエリが Azure AD から Workday に送信されます。
* [手動更新に対するクエリ](#query-for-manual-updates)
* [有効日が指定された更新と終了に対するクエリ](#query-for-effective-dated-updates-and-terminations)
* [将来の日付の雇用に対するクエリ](#query-for-future-dated-hires)
### <a name="query-for-manual-updates"></a>手動更新に対するクエリ
次の *Get_Workers* 要求によって、前回の実行と今回の実行時間の間に発生した手動更新が照会されます。
```xml
<!-- Workday incremental sync query for manual updates -->
<!-- Replace version with Workday Web Services version present in your connection URL -->
<!-- Replace timestamps below with the UTC time corresponding to last execution and current execution time -->
<!-- Count specifies the number of records to return in each page -->
<!-- Response_Group flags derived from provisioning attribute mapping -->
<Get_Workers_Request p1:version="v21.1" xmlns:p1="urn:com.workday/bsvc" xmlns="urn:com.workday/bsvc">
<p1:Request_Criteria>
<p1:Transaction_Log_Criteria_Data>
<p1:Transaction_Date_Range_Data>
<p1:Updated_From>2021-01-19T02:29:16.0094202Z</p1:Updated_From>
<p1:Updated_Through>2021-01-19T02:49:06.290136Z</p1:Updated_Through>
</p1:Transaction_Date_Range_Data>
</p1:Transaction_Log_Criteria_Data>
</p1:Request_Criteria>
<p1:Response_Filter>
<p1:As_Of_Effective_Date>2021-01-19T02:49:06.290136Z</p1:As_Of_Effective_Date>
<p1:As_Of_Entry_DateTime>2021-01-19T02:49:06.290136Z</p1:As_Of_Entry_DateTime>
<p1:Count>30</p1:Count>
</p1:Response_Filter>
<p1:Response_Group>
<p1:Include_Reference>1</p1:Include_Reference>
<p1:Include_Personal_Information>1</p1:Include_Personal_Information>
<p1:Include_Employment_Information>1</p1:Include_Employment_Information>
<p1:Include_Organizations>1</p1:Include_Organizations>
<p1:Exclude_Organization_Support_Role_Data>1</p1:Exclude_Organization_Support_Role_Data>
<p1:Exclude_Location_Hierarchies>1</p1:Exclude_Location_Hierarchies>
<p1:Exclude_Cost_Center_Hierarchies>1</p1:Exclude_Cost_Center_Hierarchies>
<p1:Exclude_Company_Hierarchies>1</p1:Exclude_Company_Hierarchies>
<p1:Exclude_Matrix_Organizations>1</p1:Exclude_Matrix_Organizations>
<p1:Exclude_Pay_Groups>1</p1:Exclude_Pay_Groups>
<p1:Exclude_Regions>1</p1:Exclude_Regions>
<p1:Exclude_Region_Hierarchies>1</p1:Exclude_Region_Hierarchies>
<p1:Exclude_Funds>1</p1:Exclude_Funds>
<p1:Exclude_Fund_Hierarchies>1</p1:Exclude_Fund_Hierarchies>
<p1:Exclude_Grants>1</p1:Exclude_Grants>
<p1:Exclude_Grant_Hierarchies>1</p1:Exclude_Grant_Hierarchies>
<p1:Exclude_Business_Units>1</p1:Exclude_Business_Units>
<p1:Exclude_Business_Unit_Hierarchies>1</p1:Exclude_Business_Unit_Hierarchies>
<p1:Exclude_Programs>1</p1:Exclude_Programs>
<p1:Exclude_Program_Hierarchies>1</p1:Exclude_Program_Hierarchies>
<p1:Exclude_Gifts>1</p1:Exclude_Gifts>
<p1:Exclude_Gift_Hierarchies>1</p1:Exclude_Gift_Hierarchies>
<p1:Include_Management_Chain_Data>1</p1:Include_Management_Chain_Data>
<p1:Include_Additional_Jobs>1</p1:Include_Additional_Jobs>
</p1:Response_Group>
</Get_Workers_Request>
```
### <a name="query-for-effective-dated-updates-and-terminations"></a>有効日が指定された更新と終了に対するクエリ
次の *Get_Workers* 要求によって、前回の実行と今回の実行時間の間に発生した、有効日が指定された更新が照会されます。
```xml
<!-- Workday incremental sync query for effective-dated updates -->
<!-- Replace version with Workday Web Services version present in your connection URL -->
<!-- Replace timestamps below with the UTC time corresponding to last execution and current execution time -->
<!-- Count specifies the number of records to return in each page -->
<!-- Response_Group flags derived from provisioning attribute mapping -->
<Get_Workers_Request p1:version="v21.1" xmlns:p1="urn:com.workday/bsvc" xmlns="urn:com.workday/bsvc">
<p1:Request_Criteria>
<p1:Transaction_Log_Criteria_Data>
<p1:Transaction_Date_Range_Data>
<p1:Effective_From>2021-01-19T02:29:16.0094202Z</p1:Effective_From>
<p1:Effective_Through>2021-01-19T02:49:06.290136Z</p1:Effective_Through>
</p1:Transaction_Date_Range_Data>
</p1:Transaction_Log_Criteria_Data>
</p1:Request_Criteria>
<p1:Response_Filter>
<p1:As_Of_Effective_Date>2021-01-19T02:49:06.290136Z</p1:As_Of_Effective_Date>
<p1:As_Of_Entry_DateTime>2021-01-19T02:49:06.290136Z</p1:As_Of_Entry_DateTime>
<p1:Page>1</p1:Page>
<p1:Count>30</p1:Count>
</p1:Response_Filter>
<p1:Response_Group>
<p1:Include_Reference>1</p1:Include_Reference>
<p1:Include_Personal_Information>1</p1:Include_Personal_Information>
<p1:Include_Employment_Information>1</p1:Include_Employment_Information>
<p1:Include_Organizations>1</p1:Include_Organizations>
<p1:Exclude_Organization_Support_Role_Data>1</p1:Exclude_Organization_Support_Role_Data>
<p1:Exclude_Location_Hierarchies>1</p1:Exclude_Location_Hierarchies>
<p1:Exclude_Cost_Center_Hierarchies>1</p1:Exclude_Cost_Center_Hierarchies>
<p1:Exclude_Company_Hierarchies>1</p1:Exclude_Company_Hierarchies>
<p1:Exclude_Matrix_Organizations>1</p1:Exclude_Matrix_Organizations>
<p1:Exclude_Pay_Groups>1</p1:Exclude_Pay_Groups>
<p1:Exclude_Regions>1</p1:Exclude_Regions>
<p1:Exclude_Region_Hierarchies>1</p1:Exclude_Region_Hierarchies>
<p1:Exclude_Funds>1</p1:Exclude_Funds>
<p1:Exclude_Fund_Hierarchies>1</p1:Exclude_Fund_Hierarchies>
<p1:Exclude_Grants>1</p1:Exclude_Grants>
<p1:Exclude_Grant_Hierarchies>1</p1:Exclude_Grant_Hierarchies>
<p1:Exclude_Business_Units>1</p1:Exclude_Business_Units>
<p1:Exclude_Business_Unit_Hierarchies>1</p1:Exclude_Business_Unit_Hierarchies>
<p1:Exclude_Programs>1</p1:Exclude_Programs>
<p1:Exclude_Program_Hierarchies>1</p1:Exclude_Program_Hierarchies>
<p1:Exclude_Gifts>1</p1:Exclude_Gifts>
<p1:Exclude_Gift_Hierarchies>1</p1:Exclude_Gift_Hierarchies>
<p1:Include_Management_Chain_Data>1</p1:Include_Management_Chain_Data>
<p1:Include_Additional_Jobs>1</p1:Include_Additional_Jobs>
</p1:Response_Group>
</Get_Workers_Request>
```
### <a name="query-for-future-dated-hires"></a>将来の日付の雇用に対するクエリ
上記のクエリのいずれかで将来の日付の雇用が返された場合は、次の *Get_Workers* 要求を使用して、新しい将来の日付の雇用に関する情報が取得されます。 新しい雇用の *WID* 属性を使用して参照が実行され、有効日が雇用の日時に設定されます。
```xml
<!-- Workday incremental sync query to get new hire data effective as on hire date/first day of work -->
<!-- Replace version with Workday Web Services version present in your connection URL -->
<!-- Replace timestamps below hire date/first day of work -->
<!-- Count specifies the number of records to return in each page -->
<!-- Response_Group flags derived from provisioning attribute mapping -->
<Get_Workers_Request p1:version="v21.1" xmlns:p1="urn:com.workday/bsvc" xmlns="urn:com.workday/bsvc">
<p1:Request_References>
<p1:Worker_Reference>
<p1:ID p1:type="WID">7bf6322f1ea101fd0b4433077f09cb04</p1:ID>
</p1:Worker_Reference>
</p1:Request_References>
<p1:Response_Filter>
<p1:As_Of_Effective_Date>2021-02-01T08:00:00+00:00</p1:As_Of_Effective_Date>
<p1:As_Of_Entry_DateTime>2021-02-01T08:00:00+00:00</p1:As_Of_Entry_DateTime>
<p1:Count>30</p1:Count>
</p1:Response_Filter>
<p1:Response_Group>
<p1:Include_Reference>1</p1:Include_Reference>
<p1:Include_Personal_Information>1</p1:Include_Personal_Information>
<p1:Include_Employment_Information>1</p1:Include_Employment_Information>
<p1:Include_Organizations>1</p1:Include_Organizations>
<p1:Exclude_Organization_Support_Role_Data>1</p1:Exclude_Organization_Support_Role_Data>
<p1:Exclude_Location_Hierarchies>1</p1:Exclude_Location_Hierarchies>
<p1:Exclude_Cost_Center_Hierarchies>1</p1:Exclude_Cost_Center_Hierarchies>
<p1:Exclude_Company_Hierarchies>1</p1:Exclude_Company_Hierarchies>
<p1:Exclude_Matrix_Organizations>1</p1:Exclude_Matrix_Organizations>
<p1:Exclude_Pay_Groups>1</p1:Exclude_Pay_Groups>
<p1:Exclude_Regions>1</p1:Exclude_Regions>
<p1:Exclude_Region_Hierarchies>1</p1:Exclude_Region_Hierarchies>
<p1:Exclude_Funds>1</p1:Exclude_Funds>
<p1:Exclude_Fund_Hierarchies>1</p1:Exclude_Fund_Hierarchies>
<p1:Exclude_Grants>1</p1:Exclude_Grants>
<p1:Exclude_Grant_Hierarchies>1</p1:Exclude_Grant_Hierarchies>
<p1:Exclude_Business_Units>1</p1:Exclude_Business_Units>
<p1:Exclude_Business_Unit_Hierarchies>1</p1:Exclude_Business_Unit_Hierarchies>
<p1:Exclude_Programs>1</p1:Exclude_Programs>
<p1:Exclude_Program_Hierarchies>1</p1:Exclude_Program_Hierarchies>
<p1:Exclude_Gifts>1</p1:Exclude_Gifts>
<p1:Exclude_Gift_Hierarchies>1</p1:Exclude_Gift_Hierarchies>
<p1:Include_Management_Chain_Data>1</p1:Include_Management_Chain_Data>
<p1:Include_Additional_Jobs>1</p1:Include_Additional_Jobs>
</p1:Response_Group>
</Get_Workers_Request>
```
## <a name="retrieving-worker-data-attributes"></a>ワーカー データ属性の取得
*Get_Workers* API では、ワーカーに関連付けられたさまざまなデータ セットが返されます。 Workday から取得されるデータ セットは、プロビジョニング スキーマで構成された [XPATH API 式](workday-attribute-reference.md)に応じて、Azure AD プロビジョニング サービスによって決定されます。 それに応じて、*Get_Workers* 要求の *Response_Group* のフラグが設定されます。
次の表に、特定のデータ セットを取得するために使用するマッピング構成に関するガイダンスを示します。
| \# | Workday エンティティ | 既定で含まれる | 既定以外のエンティティをフェッチするためにマッピングで指定する XPATH パターン |
|----|--------------------------------------|---------------------|-------------------------------------------------------------------------------|
| 1 | 個人データ | はい | wd:Worker\_Data/wd:Personal\_Data |
| 2 | 雇用データ | はい | wd:Worker\_Data/wd:Employment\_Data |
| 3 | 追加のジョブ データ | はい | wd:Worker\_Data/wd:Employment\_Data/wd:Worker\_Job\_Data\[@wd:Primary\_Job=0\]|
| 4 | 組織データ | はい | wd:Worker\_Data/wd:Organization\_Data |
| 5 | 管理チェーン データ | はい | wd:Worker\_Data/wd:Management\_Chain\_Data |
| 6 | 監督組織 | はい | 'SUPERVISORY' |
| 7 | [会社] | はい | 'COMPANY' |
| 8 | 事業単位 | いいえ | 'BUSINESS\_UNIT' |
| 9 | 事業単位の階層 | いいえ | 'BUSINESS\_UNIT\_HIERARCHY' |
| 10 | 会社の階層 | いいえ | 'COMPANY\_HIERARCHY' |
| 11 | Cost Center | いいえ | 'COST\_CENTER' |
| 12 | コスト センターの階層 | いいえ | 'COST\_CENTER\_HIERARCHY' |
| 13 | 資金 | いいえ | 'FUND' |
| 14 | 資金の階層 | いいえ | 'FUND\_HIERARCHY' |
| 15 | 贈与 | いいえ | 'GIFT' |
| 16 | 贈与の階層 | いいえ | 'GIFT\_HIERARCHY' |
| 17 | Grant | いいえ | 'GRANT' |
| 18 | 許可の階層 | いいえ | 'GRANT\_HIERARCHY' |
| 19 | 営業所の階層 | いいえ | 'BUSINESS\_SITE\_HIERARCHY' |
| 20 | マトリックス組織 | いいえ | 'MATRIX' |
| 21 | 支払いグループ | いいえ | 'PAY\_GROUP' |
| 22 | プログラム | いいえ | 'PROGRAMS' |
| 23 | プログラムの階層 | いいえ | 'PROGRAM\_HIERARCHY' |
| 24 | リージョン | いいえ | 'REGION\_HIERARCHY' |
| 25 | 場所の階層 | いいえ | 'LOCATION\_HIERARCHY' |
| 26 | アカウント プロビジョニング データ | いいえ | wd:Worker\_Data/wd:Account\_Provisioning\_Data |
| 27 | 身元調査データ | いいえ | wd:Worker\_Data/wd:Background\_Check\_Data |
| 28 | 特典の対象データ | いいえ | wd:Worker\_Data/wd:Benefit\_Eligibility\_Data |
| 29 | 手当登録データ | いいえ | wd:Worker\_Data/wd:Benefit\_Enrollment\_Data |
| 30 | キャリア データ | いいえ | wd:Worker\_Data/wd:Career\_Data |
| 31 | 報酬データ | いいえ | wd:Worker\_Data/wd:Compensation\_Data |
| 32 | 臨時職員の税務当局データ | いいえ | wd:Worker\_Data/wd:Contingent\_Worker\_Tax\_Authority\_Form\_Type\_Data |
| 33 | 育成項目データ | いいえ | wd:Worker\_Data/wd:Development\_Item\_Data |
| 34 | 従業員契約データ | いいえ | wd:Worker\_Data/wd:Employee\_Contracts\_Data |
| 35 | 従業員レビュー データ | いいえ | wd:Worker\_Data/wd:Employee\_Review\_Data |
| 36 | 受け取ったフィードバック データ | いいえ | wd:Worker\_Data/wd:Feedback\_Received\_Data |
| 37 | ワーカー目標データ | いいえ | wd:Worker\_Data/wd:Worker\_Goal\_Data |
| 38 | 写真データ | いいえ | wd:Worker\_Data/wd:Photo\_Data |
| 39 | 資格データ | いいえ | wd:Worker\_Data/wd:Qualification\_Data |
| 40 | 関係者データ | いいえ | wd:Worker\_Data/wd:Related\_Persons\_Data |
| 41 | 職務データ | いいえ | wd:Worker\_Data/wd:Role\_Data |
| 42 | スキル データ | いいえ | wd:Worker\_Data/wd:Skill\_Data |
| 43 | 継承プロファイル データ | いいえ | wd:Worker\_Data/wd:Succession\_Profile\_Data |
| 44 | 人材評価データ | いいえ | wd:Worker\_Data/wd:Talent\_Assessment\_Data |
| 45 | ユーザー アカウント データ | いいえ | wd:Worker\_Data/wd:User\_Account\_Data |
| 46 | ワーカー ドキュメント データ | いいえ | wd:Worker\_Data/wd:Worker\_Document\_Data |
>[!NOTE]
>表に示されている各 Workday エンティティは、Workday の "**ドメイン セキュリティ ポリシー**" によって保護されています。 適切な XPATH を設定した後にエンティティに関連付けられている属性を取得できない場合は、Workday 管理者に問い合わせて、プロビジョニング アプリに関連付けられている統合システム ユーザーに適切なドメイン セキュリティ ポリシーが構成されていることを確認してください。 たとえば、*スキル データ* を取得するには、*Get* アクセスが Workday ドメイン *Worker Data: Skills and Experience* で必要です。
次に、Workday 統合を拡張して特定の要件を満たす方法の例をいくつか示します。
**例 1**
Workday から次のデータ セットを取得し、それらをプロビジョニング ルールで使用するとします。
* コスト センター
* コスト センターの階層
* 支払いグループ
上記のデータ セットは、既定では含まれていません。 これらのデータ セットを取得するには、次の手順に従います。
1. Azure portal にログインし、Workday から AD または Azure AD へのユーザー プロビジョニングを開きます。
1. [プロビジョニング] ブレードで、マッピングを編集し、[詳細設定] セクションで Workday 属性の一覧を開きます。
1. 次の属性定義を追加し、それらを "必須" としてマークします。 これらの属性は、AD または Azure AD のどの属性にもマップされません。 これらは、コスト センター、コスト センターの階層、支払いグループの各情報を取得するようにコネクタに指示するシグナルとして機能します。
> [!div class="mx-tdCol2BreakAll"]
>| 属性名 | XPATH API 式 |
>|---|---|
>| CostCenterHierarchyFlag | wd:Worker/wd:Worker_Data/wd:Organization_Data/wd:Worker_Organization_Data[wd:Organization_Data/wd:Organization_Type_Reference/wd:ID[@wd:type='Organization_Type_ID']='COST_CENTER_HIERARCHY']/wd:Organization_Reference/@wd:Descriptor |
>| CostCenterFlag | wd:Worker/wd:Worker_Data/wd:Organization_Data/wd:Worker_Organization_Data[wd:Organization_Data/wd:Organization_Type_Reference/wd:ID[@wd:type='Organization_Type_ID']='COST_CENTER']/wd:Organization_Data/wd:Organization_Code/text() |
>| PayGroupFlag | wd:Worker/wd:Worker_Data/wd:Organization_Data/wd:Worker_Organization_Data[wd:Organization_Data/wd:Organization_Type_Reference/wd:ID[@wd:type='Organization_Type_ID']='PAY_GROUP']/wd:Organization_Data/wd:Organization_Reference_ID/text() |
1. *Get_Workers* 応答でコスト センターと支払いグループのデータ セットを入手できるようになったら、以下の XPATH 値を使用して、コスト センター名、コスト センター コード、支払いグループを取得できます。
> [!div class="mx-tdCol2BreakAll"]
>| 属性名 | XPATH API 式 |
>|---|---|
>| CostCenterName | wd:Worker/wd:Worker_Data/wd:Organization_Data/wd:Worker_Organization_Data/wd:Organization_Data[wd:Organization_Type_Reference/@wd:Descriptor='Cost Center']/wd:Organization_Name/text() |
>| CostCenterCode | wd:Worker/wd:Worker_Data/wd:Organization_Data/wd:Worker_Organization_Data/wd:Organization_Data[wd:Organization_Type_Reference/@wd:Descriptor='Cost Center']/wd:Organization_Code/text() |
>| PayGroup | wd:Worker/wd:Worker_Data/wd:Organization_Data/wd:Worker_Organization_Data/wd:Organization_Data[wd:Organization_Type_Reference/@wd:Descriptor='Pay Group']/wd:Organization_Name/text() |
**例 2**
あるユーザーに関連付けられている認定資格を取得するとします。 この情報は、*資格データ* セットの一部として入手できます。 このデータ セットを *Get_Workers* 応答の一部として取得するには、次の XPATH を使用します。
`wd:Worker/wd:Worker_Data/wd:Qualification_Data/wd:Certification/wd:Certification_Data/wd:Issuer/text()`
**例 3**
あるワーカーに割り当てられている *プロビジョニング グループ* を取得するとします。 この情報は、*アカウント プロビジョニング データ* セットの一部として入手できます。 このデータ セットを *Get_Workers* 応答の一部として取得するには、次の XPATH を使用します。
`wd:Worker/wd:Worker_Data/wd:Account_Provisioning_Data/wd:Provisioning_Group_Assignment_Data[wd:Status='Assigned']/wd:Provisioning_Group/text()`
## <a name="handling-different-hr-scenarios"></a>さまざまな HR シナリオの処理
### <a name="retrieving-international-job-assignments-and-secondary-job-details"></a>国際的なジョブの割り当てとセカンダリ ジョブの詳細の取得
既定で Workday コネクタによって取得されるのは、worker のプライマリ ジョブに関連付けられた属性です。 また、このコネクタでは、国際的なジョブの割り当てまたはセカンダリ ジョブに関連付けられた "*追加のジョブ データ*" を取得することもサポートされています。
国際的なジョブの割り当てに関連付けられた属性を取得するには、次の手順に従ってください。
1. Workday Web サービス API バージョン 30.0 以降を使用する Workday 接続 URL を設定します。 それに応じて、Workday プロビジョニング アプリで[適切な XPATH 値](workday-attribute-reference.md#xpath-values-for-workday-web-services-wws-api-v30)を設定します。
1. `Worker_Job_Data` ノードのセレクター `@wd:Primary_Job=0` を使用して、適切な属性を取得します。
* **例 1:** `SecondaryBusinessTitle` を取得するには、XPATH `wd:Worker/wd:Worker_Data/wd:Employment_Data/wd:Worker_Job_Data[@wd:Primary_Job=0]/wd:Position_Data/wd:Business_Title/text()` を使用します
* **例 2:** `SecondaryBusinessLocation` を取得するには、XPATH `wd:Worker/wd:Worker_Data/wd:Employment_Data/wd:Worker_Job_Data[@wd:Primary_Job=0]/wd:Position_Data/wd:Business_Site_Summary_Data/wd:Location_Reference/@wd:Descriptor` を使用します
## <a name="next-steps"></a>次の手順
* [Workday から Active Directory へのプロビジョニングを構成する方法を確認する](../saas-apps/workday-inbound-tutorial.md)
* [Workday への書き戻しを構成する方法を確認する](../saas-apps/workday-writeback-tutorial.md)
* [受信プロビジョニングのサポートされている Workday 属性に関する詳細情報](workday-attribute-reference.md) | 30,124 | CC-BY-4.0 |
---
title: 骨骼动画中的关节OffsetMatrix与Bindpose概念
tags: Animation
---
在骨骼动画中，绑定姿势扮演着一个重要的角色，还有每个节点的OffsetMatrix，而这些概念中有什么含义及关联呢，下面针对这点进行笔记，以作备忘。
<!--more-->
### 绑定姿势
* 建模人员始终以称为T Pose的姿势对3D模型进行建模，其中角色模型以某个姿势站立，而手和身体显示出类似T的图形， 建模者可以在T型姿势中对角色进行建模，以便装配者可以更轻松地装配角色。这有助于他们放置骨骼并更轻松地调整顶点权重和网格。将所有骨骼放置在3D模型中并开始蒙皮过程后，将保存骨骼的当前姿势。此姿势称为“绑定姿势”。名称显示了整个故事。绑定姿势是您开始将网格物体绑定到其相应骨架的姿势。
### 骨骼方向
* 骨骼方向 = 绑定姿势旋转 * 关键帧旋转。 由此，我们可以明显知道，关键帧的数据是相对于绑定姿势下的旋转变换数据，而非基于上一关键帧的相对旋转变换数据。
### 绑定矩阵(bind pose Matrix)
* 骨骼中，每个关系中绑定姿势下的全局变换矩阵。如果遍历骨骼/节点层次结构，将每个骨骼/节点的局部变换（Assimp中的mTransformation）应用于其子级，我们将获得每个骨骼/节点的全局变换。可以理解为此矩阵表征的是从骨骼空间到网格/模型空间的变换。
### OffsetMatrix
* 此矩阵，从意义上，称为inverseBindMatrix，更为合理，是该骨骼在绑定姿势下的全局变换的逆函数。换句话说，特定骨骼的此绑定矩阵的逆等于其offsetMatrix。它表征的是将模型上的顶点从世界空间上转换到骨骼空间。
### LocalMatrix
* 每个骨骼/关系相对于父节点的变换矩阵。
### 动画过程中的蒙皮计算
* 蒙皮的变换 = （M_keyframe * offsetMatrix * V_world). 其中B_keyframe是骨骼在某个目标位置的全局变换，例如由动画剪辑提供。
* 这种复合变换实际上是从绑定姿势（定义了网格顶点的位置）到M_keyframe的偏移量。当应用于顶点时，（M_keyframe * offsetMatrix）会将顶点从绑定位置“移动”到M_keyframe转换到的任何位置。
* 请注意，如果M_keyframe等于绑定变换（例如，根据上述骨骼的mTransformation：s计算得出），则（M_keyframe * offsetMatrix）是标识，并且顶点不会从绑定姿势的原始位置移动。
---
If you like it, don't forget to give me a star. :star2:
[](https://github.com/fwzhuang/fwzhuang.github.io) | 1,361 | MIT |
---
layout: post
title: "實拍廣東惠州打工階層現狀，貴在真實，超高清4k影像。4K Video （ULTRA HD）"
date: 2020-09-15T02:19:59.000Z
author: WilliamWorks Tv
from: https://www.youtube.com/watch?v=lATURv1cKts
tags: [ WilliamWorks Tv ]
categories: [ WilliamWorks Tv ]
---
<!--1600136399000-->
[實拍廣東惠州打工階層現狀，貴在真實，超高清4k影像。4K Video （ULTRA HD）](https://www.youtube.com/watch?v=lATURv1cKts)
------
<div>
了解最新的城中村资讯请看视频末尾，扫码后在视频下方留下QQ,微信等方式获取。 扫码支付后请记得留言，否则我无法及时联系到您，拒绝伸手党，未支付不接受咨询！打赏二维码视频链接：https://youtu.be/qaZFvgEOzho频道已开通小号，以防丢失请大家订阅我的备用频道：https://www.youtube.com/channel/UCzmDgVe5QUDqLoizCGd1l4Q
</div> | 570 | MIT |
**twbworld.github.io**
===========
[](https://github.com/twbworld/twbworld.GitHub.io/actions)
[](https://github.com/twbworld/twbworld.GitHub.io)
[](https://twbworld.github.io)
[](https://github.com/gohugoio/hugo)
[](https://github.com/wowchemy/wowchemy-hugo-modules)
[](https://github.com/wowchemy/starter-academic)
[](https://github.com/twbworld/twbworld.GitHub.io/blob/master/LICENSE)
[](https://www.codacy.com/gh/twbworld/twbworld.GitHub.io/dashboard?utm_source=github.com&utm_medium=referral&utm_content=twbworld/twbworld.GitHub.io&utm_campaign=Badge_Grade)
## 外部临时浏览本地
例: `hugo server -D --i18n-warnings --bind 127.0.0.1 -p 1314 --baseURL=http://127.0.0.1:1314`
> 在内网上访问`http://127.0.0.1:1314`浏览
1313端口,是hugo本地localhost默认的端口,所以这里另用了1314
## 生成本地;-D:草稿也强制生成页面;-d:指定生成文件的地方
例: `hugo -D -d dev`
> 运行`hugo -D -d dev`前,先删除dev下的文件`rm -rfv dev/*`
## 生成正式环境文件
例:`hugo`
> 运行`hugo`前,先删除public下的文件`rm -rfv public/*`
## 新建博客文章
例:`hugo new --kind post post/如何使用Hugo`
> `如何使用Hugo`是一个文件夹名,也默认了是文章标题,里面含有自动生成的`index.md`
## PS
- robots.txt等文件位于static下
- sitemap.xml会自动生成
- 在 `.github/workflows` 下存在 `CI/CD` 配置 , 可自动化发布 | 1,781 | MIT |
# 2021-07-12
共 230 条
<!-- BEGIN TOUTIAO -->
<!-- 最后更新时间 Mon Jul 12 2021 23:15:16 GMT+0800 (China Standard Time) -->
1. [女子遭咸猪手反手一耳光](https://so.toutiao.com/search?keyword=女子遭咸猪手反手一耳光)
1. [美舰擅闯中国西沙 中方警告驱离](https://so.toutiao.com/search?keyword=美舰擅闯中国西沙+中方警告驱离)
1. [多地通知：未接种疫苗将影响出行](https://so.toutiao.com/search?keyword=多地通知：未接种疫苗将影响出行)
1. [塔利班能在阿富汗正式执政吗](https://so.toutiao.com/search?keyword=塔利班能在阿富汗正式执政吗)
1. [邱毅已在厦门接种新冠疫苗](https://so.toutiao.com/search?keyword=邱毅已在厦门接种新冠疫苗)
1. [阿富汗政府军击退塔利班袭击](https://so.toutiao.com/search?keyword=阿富汗政府军击退塔利班袭击)
1. [赵立坚呵呵回应所谓美抗疫全球第一](https://so.toutiao.com/search?keyword=赵立坚呵呵回应所谓美抗疫全球第一)
1. [司机故意将越野车撞入店铺](https://so.toutiao.com/search?keyword=司机故意将越野车撞入店铺)
1. [梅姨案申军良祝贺郭刚堂找到儿子](https://so.toutiao.com/search?keyword=梅姨案申军良祝贺郭刚堂找到儿子)
1. [刺杀海地总统嫌犯称原任务是逮捕](https://so.toutiao.com/search?keyword=刺杀海地总统嫌犯称原任务是逮捕)
1. [美一名医生系刺杀海地总统核心人物](https://so.toutiao.com/search?keyword=美一名医生系刺杀海地总统核心人物)
1. [土耳其为何不想从阿富汗撤军](https://so.toutiao.com/search?keyword=土耳其为何不想从阿富汗撤军)
1. [面对德尔塔毒株 疫苗有效率暴跌](https://so.toutiao.com/search?keyword=面对德尔塔毒株+疫苗有效率暴跌)
1. [苏州一酒店坍塌致1死多人失联](https://so.toutiao.com/search?keyword=苏州一酒店坍塌致1死多人失联)
1. [牛弹琴：最近这几天全球气候很反常](https://so.toutiao.com/search?keyword=牛弹琴：最近这几天全球气候很反常)
1. [英国人：足球和生活已大于疫情](https://so.toutiao.com/search?keyword=英国人：足球和生活已大于疫情)
1. [海地总理：总统被刺杀前遭酷刑](https://so.toutiao.com/search?keyword=海地总理：总统被刺杀前遭酷刑)
1. [海地总统遇刺事件的3个关键角色](https://so.toutiao.com/search?keyword=海地总统遇刺事件的3个关键角色)
1. [河南“繁荣昌盛”四胞胎男婴出院](https://so.toutiao.com/search?keyword=河南“繁荣昌盛”四胞胎男婴出院)
1. [山东莘县现龙卷风 多辆汽车被掀翻](https://so.toutiao.com/search?keyword=山东莘县现龙卷风+多辆汽车被掀翻)
1. [王力宏直播刮胡子](https://so.toutiao.com/search?keyword=王力宏直播刮胡子)
1. [李彩桦祝艾莉洪世贤离婚11周年](https://so.toutiao.com/search?keyword=李彩桦祝艾莉洪世贤离婚11周年)
1. [《北辙南辕》口碑](https://so.toutiao.com/search?keyword=《北辙南辕》口碑)
1. [苏宁易购：聘任张近东为名誉董事长](https://so.toutiao.com/search?keyword=苏宁易购：聘任张近东为名誉董事长)
1. [奈雪包装成本占营收9.2%](https://so.toutiao.com/search?keyword=奈雪包装成本占营收9.2%)
1. [法国歧视中俄疫苗？俄外交部谴责](https://so.toutiao.com/search?keyword=法国歧视中俄疫苗？俄外交部谴责)
1. [跳水冠军陈艾森没有八块腹肌](https://so.toutiao.com/search?keyword=跳水冠军陈艾森没有八块腹肌)
1. [男子走路上突然“飞”起来意外身亡](https://so.toutiao.com/search?keyword=男子走路上突然“飞”起来意外身亡)
1. [外交部：加方应让孟晚舟早日回国](https://so.toutiao.com/search?keyword=外交部：加方应让孟晚舟早日回国)
1. [教授吃降压药辅导孩子作业](https://so.toutiao.com/search?keyword=教授吃降压药辅导孩子作业)
1. [索斯盖特：为点球大战的安排负责](https://so.toutiao.com/search?keyword=索斯盖特：为点球大战的安排负责)
1. [实习医生疑让女友冒充护士进病房](https://so.toutiao.com/search?keyword=实习医生疑让女友冒充护士进病房)
1. [曝CBA新赛季初期或采取外援赛会制](https://so.toutiao.com/search?keyword=曝CBA新赛季初期或采取外援赛会制)
1. [刘德华得知郭刚堂找到儿子后很开心](https://so.toutiao.com/search?keyword=刘德华得知郭刚堂找到儿子后很开心)
1. [华北这轮强降雨持续多久](https://so.toutiao.com/search?keyword=华北这轮强降雨持续多久)
1. [高校副校长十余年匿名诬告20余次](https://so.toutiao.com/search?keyword=高校副校长十余年匿名诬告20余次)
1. [袁泉的眼睛全是戏](https://so.toutiao.com/search?keyword=袁泉的眼睛全是戏)
1. [退役军人事务部：4种旧证将作废](https://so.toutiao.com/search?keyword=退役军人事务部：4种旧证将作废)
1. [中央气象台继续发布强对流天气黄警](https://so.toutiao.com/search?keyword=中央气象台继续发布强对流天气黄警)
1. [李明清任重庆市委常委](https://so.toutiao.com/search?keyword=李明清任重庆市委常委)
1. [以色列提供新冠疫苗加强针](https://so.toutiao.com/search?keyword=以色列提供新冠疫苗加强针)
1. [东京酒店贴“日本人专用”告示被批](https://so.toutiao.com/search?keyword=东京酒店贴“日本人专用”告示被批)
1. [大学生举报危害国家安全情况获奖](https://so.toutiao.com/search?keyword=大学生举报危害国家安全情况获奖)
1. [20年战争为阿富汗留下了什么](https://so.toutiao.com/search?keyword=20年战争为阿富汗留下了什么)
1. [9.9万台胞在大陆接种疫苗](https://so.toutiao.com/search?keyword=9.9万台胞在大陆接种疫苗)
1. [林郑月娥谈及家人时落泪](https://so.toutiao.com/search?keyword=林郑月娥谈及家人时落泪)
1. [维珍银河创始人抢先贝索斯上太空](https://so.toutiao.com/search?keyword=维珍银河创始人抢先贝索斯上太空)
1. [公交上抓小偷的警校生被记三等功](https://so.toutiao.com/search?keyword=公交上抓小偷的警校生被记三等功)
1. [男子不顾危险冲入洪水中救人](https://so.toutiao.com/search?keyword=男子不顾危险冲入洪水中救人)
1. [霍启刚夫妇现身黎明演唱会](https://so.toutiao.com/search?keyword=霍启刚夫妇现身黎明演唱会)
1. [英格兰队员颁奖仪式光速摘下奖牌](https://so.toutiao.com/search?keyword=英格兰队员颁奖仪式光速摘下奖牌)
1. [《失孤》原型郭刚堂找到儿子](https://so.toutiao.com/search?keyword=《失孤》原型郭刚堂找到儿子)
1. [东京奥运赛事酒店存在防疫漏洞](https://so.toutiao.com/search?keyword=东京奥运赛事酒店存在防疫漏洞)
1. [苏州酒店坍塌致1死 10人失联](https://so.toutiao.com/search?keyword=苏州酒店坍塌致1死+10人失联)
1. [美国公司涉嫌雇佣刺杀海地总统嫌犯](https://so.toutiao.com/search?keyword=美国公司涉嫌雇佣刺杀海地总统嫌犯)
1. [意大利队史第2次获得欧洲杯冠军](https://so.toutiao.com/search?keyword=意大利队史第2次获得欧洲杯冠军)
1. [星级酒店服务员用扫帚扫餐桌](https://so.toutiao.com/search?keyword=星级酒店服务员用扫帚扫餐桌)
1. [立陶宛搭建边境墙阻非法移民](https://so.toutiao.com/search?keyword=立陶宛搭建边境墙阻非法移民)
1. [美官员抵达海地调查总统遇刺案](https://so.toutiao.com/search?keyword=美官员抵达海地调查总统遇刺案)
1. [奥运会主办城市进入第四次紧急状态](https://so.toutiao.com/search?keyword=奥运会主办城市进入第四次紧急状态)
1. [申军良发文祝贺郭刚堂找到儿子](https://so.toutiao.com/search?keyword=申军良发文祝贺郭刚堂找到儿子)
1. [广西司机故意将越野车撞入店铺](https://so.toutiao.com/search?keyword=广西司机故意将越野车撞入店铺)
1. [郭台铭：洽购疫苗期间大陆没干涉](https://so.toutiao.com/search?keyword=郭台铭：洽购疫苗期间大陆没干涉)
1. [苏丹：希望被免除500亿美元外债](https://so.toutiao.com/search?keyword=苏丹：希望被免除500亿美元外债)
1. [关晓彤晒与妈妈合照](https://so.toutiao.com/search?keyword=关晓彤晒与妈妈合照)
1. [俄女子当街被打晕 儿子目睹全程](https://so.toutiao.com/search?keyword=俄女子当街被打晕+儿子目睹全程)
1. [土耳其为何不想阿富汗撤军](https://so.toutiao.com/search?keyword=土耳其为何不想阿富汗撤军)
1. [中纪委点名18名贪官](https://so.toutiao.com/search?keyword=中纪委点名18名贪官)
1. [邱毅已在大陆接种新冠疫苗](https://so.toutiao.com/search?keyword=邱毅已在大陆接种新冠疫苗)
1. [穆里尼奥：索斯盖特的换人我看不懂](https://so.toutiao.com/search?keyword=穆里尼奥：索斯盖特的换人我看不懂)
1. [斗鱼宣布终止与虎牙的合并协议](https://so.toutiao.com/search?keyword=斗鱼宣布终止与虎牙的合并协议)
1. [“德尔塔”会否惊扰全球金融市场](https://so.toutiao.com/search?keyword=“德尔塔”会否惊扰全球金融市场)
1. [董明珠竟是“全国违章最多的人”](https://so.toutiao.com/search?keyword=董明珠竟是“全国违章最多的人”)
1. [阿富汗乱局牵动地区局势](https://so.toutiao.com/search?keyword=阿富汗乱局牵动地区局势)
1. [《新闻联播》正直播](https://so.toutiao.com/search?keyword=《新闻联播》正直播)
1. [广西一司机故意冲撞越野车](https://so.toutiao.com/search?keyword=广西一司机故意冲撞越野车)
1. [美媒称美国抗疫全球第一 中方回应](https://so.toutiao.com/search?keyword=美媒称美国抗疫全球第一+中方回应)
1. [下班快加油 国内油价迎来三连涨](https://so.toutiao.com/search?keyword=下班快加油+国内油价迎来三连涨)
1. [阿富汗军阀将与政府军抵抗塔利班](https://so.toutiao.com/search?keyword=阿富汗军阀将与政府军抵抗塔利班)
1. [“英国足球流氓”殴打意大利球迷](https://so.toutiao.com/search?keyword=“英国足球流氓”殴打意大利球迷)
1. [今日收评：两市成交额创年内新高](https://so.toutiao.com/search?keyword=今日收评：两市成交额创年内新高)
1. [NBA总决赛：雄鹿大胜太阳扳回一城](https://so.toutiao.com/search?keyword=NBA总决赛：雄鹿大胜太阳扳回一城)
1. [白玉刚任山东省委常委](https://so.toutiao.com/search?keyword=白玉刚任山东省委常委)
1. [林郑月娥：希望逐步恢复与内地通关](https://so.toutiao.com/search?keyword=林郑月娥：希望逐步恢复与内地通关)
1. [博努奇成欧洲杯决赛最年长进球者](https://so.toutiao.com/search?keyword=博努奇成欧洲杯决赛最年长进球者)
1. [媒体：“板蓝根大王”没离世还在救](https://so.toutiao.com/search?keyword=媒体：“板蓝根大王”没离世还在救)
1. [英格兰3人罚失点球难破魔咒](https://so.toutiao.com/search?keyword=英格兰3人罚失点球难破魔咒)
1. [C罗5球1助获欧洲杯金靴](https://so.toutiao.com/search?keyword=C罗5球1助获欧洲杯金靴)
1. [美国说唱歌手直播中被枪杀](https://so.toutiao.com/search?keyword=美国说唱歌手直播中被枪杀)
1. [意大利球员庆祝夺冠时裤子掉了](https://so.toutiao.com/search?keyword=意大利球员庆祝夺冠时裤子掉了)
1. [王子文晒吴永恩下厨照](https://so.toutiao.com/search?keyword=王子文晒吴永恩下厨照)
1. [意大利点球胜英格兰夺欧洲杯冠军](https://so.toutiao.com/search?keyword=意大利点球胜英格兰夺欧洲杯冠军)
1. [上海一居民家发生爆炸致2死4伤](https://so.toutiao.com/search?keyword=上海一居民家发生爆炸致2死4伤)
1. [华北大暴雨原因](https://so.toutiao.com/search?keyword=华北大暴雨原因)
1. [河北暴雨市民抱树自救](https://so.toutiao.com/search?keyword=河北暴雨市民抱树自救)
1. [洱海坠机烈士儿子还在等父亲归家](https://so.toutiao.com/search?keyword=洱海坠机烈士儿子还在等父亲归家)
1. [美佛州塌楼事故遇难人数升至90人](https://so.toutiao.com/search?keyword=美佛州塌楼事故遇难人数升至90人)
1. [多纳鲁马扑出萨卡点球后面无表情](https://so.toutiao.com/search?keyword=多纳鲁马扑出萨卡点球后面无表情)
1. [直播：河南四胞胎男婴出院](https://so.toutiao.com/search?keyword=直播：河南四胞胎男婴出院)
1. [NBA五佳球：约翰逊隔扣塔克](https://so.toutiao.com/search?keyword=NBA五佳球：约翰逊隔扣塔克)
1. [英格兰罚丢点球三名球员遭种族歧视](https://so.toutiao.com/search?keyword=英格兰罚丢点球三名球员遭种族歧视)
1. [陈浩民老婆晒全家福庆祝结婚十周年](https://so.toutiao.com/search?keyword=陈浩民老婆晒全家福庆祝结婚十周年)
1. [曼奇尼洒泪：在英格兰的地盘夺冠了](https://so.toutiao.com/search?keyword=曼奇尼洒泪：在英格兰的地盘夺冠了)
1. [美说唱歌手直播中被枪杀](https://so.toutiao.com/search?keyword=美说唱歌手直播中被枪杀)
1. [蒙蒂：字母哥罚球数比我们队都多](https://so.toutiao.com/search?keyword=蒙蒂：字母哥罚球数比我们队都多)
1. [7月12日全国汽油最新售价](https://so.toutiao.com/search?keyword=7月12日全国汽油最新售价)
1. [南京发现1例阳性 系境外输入关联](https://so.toutiao.com/search?keyword=南京发现1例阳性+系境外输入关联)
1. [扬子江药业董事长徐镜人意外逝世](https://so.toutiao.com/search?keyword=扬子江药业董事长徐镜人意外逝世)
1. [居民楼上业主养花养草还修建池塘](https://so.toutiao.com/search?keyword=居民楼上业主养花养草还修建池塘)
1. [女子被酒店外卖机器人吓醒](https://so.toutiao.com/search?keyword=女子被酒店外卖机器人吓醒)
1. [央行降准释放1万亿元 钱将流向哪里](https://so.toutiao.com/search?keyword=央行降准释放1万亿元+钱将流向哪里)
1. [毛乌素沙漠即将消失](https://so.toutiao.com/search?keyword=毛乌素沙漠即将消失)
1. [香港女子闯政府总部还藏毒被捕](https://so.toutiao.com/search?keyword=香港女子闯政府总部还藏毒被捕)
1. [郑秀文助阵黎明演唱会](https://so.toutiao.com/search?keyword=郑秀文助阵黎明演唱会)
1. [钟声：盗用新闻自由之名闹剧当休矣](https://so.toutiao.com/search?keyword=钟声：盗用新闻自由之名闹剧当休矣)
1. [复星医药将销售台湾1000万剂疫苗](https://so.toutiao.com/search?keyword=复星医药将销售台湾1000万剂疫苗)
1. [艾莉洪世贤离婚11周年](https://so.toutiao.com/search?keyword=艾莉洪世贤离婚11周年)
1. [印度人口最多的邦拟推行二胎政策](https://so.toutiao.com/search?keyword=印度人口最多的邦拟推行二胎政策)
1. [曼奇尼执教意大利三年胜率72.9％](https://so.toutiao.com/search?keyword=曼奇尼执教意大利三年胜率72.9％)
1. [刺杀海地总统嫌犯为何躲台当局驻地](https://so.toutiao.com/search?keyword=刺杀海地总统嫌犯为何躲台当局驻地)
1. [误把空调开制热九旬老人中暑昏迷](https://so.toutiao.com/search?keyword=误把空调开制热九旬老人中暑昏迷)
1. [越南台资工厂1人确诊新冠](https://so.toutiao.com/search?keyword=越南台资工厂1人确诊新冠)
1. [美舰擅闯中国领海 中方警告驱离](https://so.toutiao.com/search?keyword=美舰擅闯中国领海+中方警告驱离)
1. [7月12日开盘：A股三大股指集体高开](https://so.toutiao.com/search?keyword=7月12日开盘：A股三大股指集体高开)
1. [扬子江药业董事长徐镜人在伊犁离世](https://so.toutiao.com/search?keyword=扬子江药业董事长徐镜人在伊犁离世)
1. [英格兰119分钟连换两人均罚丢点球](https://so.toutiao.com/search?keyword=英格兰119分钟连换两人均罚丢点球)
1. [北京大暴雨建议弹性或错峰上下班](https://so.toutiao.com/search?keyword=北京大暴雨建议弹性或错峰上下班)
1. [张雨绮李柄熹牵手逛街](https://so.toutiao.com/search?keyword=张雨绮李柄熹牵手逛街)
1. [多纳鲁马5次参加点球大战全部获胜](https://so.toutiao.com/search?keyword=多纳鲁马5次参加点球大战全部获胜)
1. [方媛带女儿回上海过暑假](https://so.toutiao.com/search?keyword=方媛带女儿回上海过暑假)
1. [孙杨重审宣判后首次发声](https://so.toutiao.com/search?keyword=孙杨重审宣判后首次发声)
1. [泸州两任市委书记两天内先后被查](https://so.toutiao.com/search?keyword=泸州两任市委书记两天内先后被查)
1. [中国的新冠疫苗之路](https://so.toutiao.com/search?keyword=中国的新冠疫苗之路)
1. [两名中国籍年轻女性在雅典失踪](https://so.toutiao.com/search?keyword=两名中国籍年轻女性在雅典失踪)
1. [面馆点粗点的面上了一碗“白素贞”](https://so.toutiao.com/search?keyword=面馆点粗点的面上了一碗“白素贞”)
1. [G20达成协议 世间再无避税天堂](https://so.toutiao.com/search?keyword=G20达成协议+世间再无避税天堂)
1. [全球日增确诊超40万](https://so.toutiao.com/search?keyword=全球日增确诊超40万)
1. [老戏骨吴毅将现身内地发廊](https://so.toutiao.com/search?keyword=老戏骨吴毅将现身内地发廊)
1. [德约温网夺冠 平费纳20冠纪录](https://so.toutiao.com/search?keyword=德约温网夺冠+平费纳20冠纪录)
1. [云南新增本土确诊9例 5人缅甸籍](https://so.toutiao.com/search?keyword=云南新增本土确诊9例+5人缅甸籍)
1. [郭刚堂妻子：不知道孩子怨恨我不](https://so.toutiao.com/search?keyword=郭刚堂妻子：不知道孩子怨恨我不)
1. [纽约地铁被淹 网民碰瓷中国被打脸](https://so.toutiao.com/search?keyword=纽约地铁被淹+网民碰瓷中国被打脸)
1. [小王子目睹英格兰丢冠：狂喜到绝望](https://so.toutiao.com/search?keyword=小王子目睹英格兰丢冠：狂喜到绝望)
1. [父母将3岁儿子给月嫂照顾后消失](https://so.toutiao.com/search?keyword=父母将3岁儿子给月嫂照顾后消失)
1. [刺杀海地总统嫌犯受雇于美国公司](https://so.toutiao.com/search?keyword=刺杀海地总统嫌犯受雇于美国公司)
1. [刺杀海地总统嫌犯：原任务是逮捕](https://so.toutiao.com/search?keyword=刺杀海地总统嫌犯：原任务是逮捕)
1. [本届欧洲杯助攻榜：祖贝尔4次居首](https://so.toutiao.com/search?keyword=本届欧洲杯助攻榜：祖贝尔4次居首)
1. [内塔尼亚胡一家离开以色列总理官邸](https://so.toutiao.com/search?keyword=内塔尼亚胡一家离开以色列总理官邸)
1. [吴磊骑行后胖了十斤](https://so.toutiao.com/search?keyword=吴磊骑行后胖了十斤)
1. [中国人口再生产类型实现历史性转变](https://so.toutiao.com/search?keyword=中国人口再生产类型实现历史性转变)
1. [最严重浒苔袭击青岛海面](https://so.toutiao.com/search?keyword=最严重浒苔袭击青岛海面)
1. [莱因克尔祝贺意大利夺冠](https://so.toutiao.com/search?keyword=莱因克尔祝贺意大利夺冠)
1. [发改委：东北全面振兴将形成新突破](https://so.toutiao.com/search?keyword=发改委：东北全面振兴将形成新突破)
1. [基耶利尼成欧洲杯决赛史最年长队长](https://so.toutiao.com/search?keyword=基耶利尼成欧洲杯决赛史最年长队长)
1. [马龙说刘国梁是最凶的教练](https://so.toutiao.com/search?keyword=马龙说刘国梁是最凶的教练)
1. [天穹将上演三星伴月奇观](https://so.toutiao.com/search?keyword=天穹将上演三星伴月奇观)
1. [总统遇刺折射海地困局](https://so.toutiao.com/search?keyword=总统遇刺折射海地困局)
1. [大量海地居民涌入美国大使馆](https://so.toutiao.com/search?keyword=大量海地居民涌入美国大使馆)
1. [美洲杯夺冠阿根廷获1000万美元奖金](https://so.toutiao.com/search?keyword=美洲杯夺冠阿根廷获1000万美元奖金)
1. [德尔塔毒株蔓延欧洲](https://so.toutiao.com/search?keyword=德尔塔毒株蔓延欧洲)
1. [演员白澍发布饰演吴邪免责声明](https://so.toutiao.com/search?keyword=演员白澍发布饰演吴邪免责声明)
1. [日媒报道文在寅访日 韩方表示遗憾](https://so.toutiao.com/search?keyword=日媒报道文在寅访日+韩方表示遗憾)
1. [徐州万人空巷吃伏羊](https://so.toutiao.com/search?keyword=徐州万人空巷吃伏羊)
1. [黎明演唱会上分享与女儿相处日常](https://so.toutiao.com/search?keyword=黎明演唱会上分享与女儿相处日常)
1. [梅西：将夺冠献给所有阿根廷人民](https://so.toutiao.com/search?keyword=梅西：将夺冠献给所有阿根廷人民)
1. [博努奇当选欧洲杯决赛全场最佳](https://so.toutiao.com/search?keyword=博努奇当选欧洲杯决赛全场最佳)
1. [哈尔滨有狼进村男子拿砖打狼](https://so.toutiao.com/search?keyword=哈尔滨有狼进村男子拿砖打狼)
1. [洪永城婚礼现场公布妻子怀孕喜讯](https://so.toutiao.com/search?keyword=洪永城婚礼现场公布妻子怀孕喜讯)
1. [下半年A股的机会在哪里](https://so.toutiao.com/search?keyword=下半年A股的机会在哪里)
1. [上海大爷70万手表掉进地铁轨道](https://so.toutiao.com/search?keyword=上海大爷70万手表掉进地铁轨道)
1. [费德勒发文祝贺德约温网夺冠](https://so.toutiao.com/search?keyword=费德勒发文祝贺德约温网夺冠)
1. [“英国流氓”殴打意大利球迷](https://so.toutiao.com/search?keyword=“英国流氓”殴打意大利球迷)
1. [太空稻种长成金灿灿的稻穗](https://so.toutiao.com/search?keyword=太空稻种长成金灿灿的稻穗)
1. [存百万变1元还被拘 银行算诬陷罪吗](https://so.toutiao.com/search?keyword=存百万变1元还被拘+银行算诬陷罪吗)
1. [北京丰台区行政区划调整](https://so.toutiao.com/search?keyword=北京丰台区行政区划调整)
1. [国内油价大概率“三连涨”](https://so.toutiao.com/search?keyword=国内油价大概率“三连涨”)
1. [荷兰弟新街拍](https://so.toutiao.com/search?keyword=荷兰弟新街拍)
1. [小S被女儿吐槽有双下巴](https://so.toutiao.com/search?keyword=小S被女儿吐槽有双下巴)
1. [商务部回应美将中国实体列“清单”](https://so.toutiao.com/search?keyword=商务部回应美将中国实体列“清单”)
1. [多地相继上调月最低工资标准](https://so.toutiao.com/search?keyword=多地相继上调月最低工资标准)
1. [女孩放弃港大奖学金去北大读马克思](https://so.toutiao.com/search?keyword=女孩放弃港大奖学金去北大读马克思)
1. [五台山突发洪水冲走数十辆汽车](https://so.toutiao.com/search?keyword=五台山突发洪水冲走数十辆汽车)
1. [医院未找家属签字手术致患者死亡](https://so.toutiao.com/search?keyword=医院未找家属签字手术致患者死亡)
1. [20国集团就税制改革达成协议](https://so.toutiao.com/search?keyword=20国集团就税制改革达成协议)
1. [消防员救出遭雨围困小孩 父亲跪谢](https://so.toutiao.com/search?keyword=消防员救出遭雨围困小孩+父亲跪谢)
1. [刘浩存妈妈的舞蹈机构疑致学员瘫痪](https://so.toutiao.com/search?keyword=刘浩存妈妈的舞蹈机构疑致学员瘫痪)
1. [哈尔滨三狼进村男子拿砖冲上去打狼](https://so.toutiao.com/search?keyword=哈尔滨三狼进村男子拿砖冲上去打狼)
1. [驻英使馆呼吁中国公民回国？假消息](https://so.toutiao.com/search?keyword=驻英使馆呼吁中国公民回国？假消息)
1. [印尼疫情致氧气短缺政府向中国求援](https://so.toutiao.com/search?keyword=印尼疫情致氧气短缺政府向中国求援)
1. [500元一瓶雪花啤酒贵吗？](https://so.toutiao.com/search?keyword=500元一瓶雪花啤酒贵吗？)
1. [东南小城三明的医改“突围”](https://so.toutiao.com/search?keyword=东南小城三明的医改“突围”)
1. [武汉大学录取分数线发布](https://so.toutiao.com/search?keyword=武汉大学录取分数线发布)
1. [媒体：总统遇刺折射海地困局](https://so.toutiao.com/search?keyword=媒体：总统遇刺折射海地困局)
1. [祝融号发回火星表面地貌影像](https://so.toutiao.com/search?keyword=祝融号发回火星表面地貌影像)
1. [越南胡志明市超市物资抢购一空](https://so.toutiao.com/search?keyword=越南胡志明市超市物资抢购一空)
1. [蒋丽莎晒全家福庆祝结婚十周年](https://so.toutiao.com/search?keyword=蒋丽莎晒全家福庆祝结婚十周年)
1. [女子当街拦车攻击路人被警方带走](https://so.toutiao.com/search?keyword=女子当街拦车攻击路人被警方带走)
1. [宋妍霏妈妈获《妈妈你真好看》冠军](https://so.toutiao.com/search?keyword=宋妍霏妈妈获《妈妈你真好看》冠军)
1. [中青年是购买临期食品的“主力军”](https://so.toutiao.com/search?keyword=中青年是购买临期食品的“主力军”)
1. [海地第一夫人遇袭后首次发声](https://so.toutiao.com/search?keyword=海地第一夫人遇袭后首次发声)
1. [海地总统遇刺案法官收死亡威胁](https://so.toutiao.com/search?keyword=海地总统遇刺案法官收死亡威胁)
1. [三伏天美食讲究](https://so.toutiao.com/search?keyword=三伏天美食讲究)
1. [“巴马丽琅”矿泉水含可能致癌物](https://so.toutiao.com/search?keyword=“巴马丽琅”矿泉水含可能致癌物)
1. [我国首个“太空电站”实验基地开工](https://so.toutiao.com/search?keyword=我国首个“太空电站”实验基地开工)
1. [湖南湘潭5名少年野泳溺亡](https://so.toutiao.com/search?keyword=湖南湘潭5名少年野泳溺亡)
1. [景区回应女子狠拽孔雀羽毛哄娃](https://so.toutiao.com/search?keyword=景区回应女子狠拽孔雀羽毛哄娃)
1. [杨丞琳连续七年零点为李荣浩庆生](https://so.toutiao.com/search?keyword=杨丞琳连续七年零点为李荣浩庆生)
1. [亚冠：国安0-4负川崎前锋遭5连败](https://so.toutiao.com/search?keyword=亚冠：国安0-4负川崎前锋遭5连败)
1. [暴雨天气安全避险指南](https://so.toutiao.com/search?keyword=暴雨天气安全避险指南)
1. [媒体：饱和式疫苗研发凸显人民至上](https://so.toutiao.com/search?keyword=媒体：饱和式疫苗研发凸显人民至上)
1. [前彰化县长卓伯源参选国民党主席](https://so.toutiao.com/search?keyword=前彰化县长卓伯源参选国民党主席)
1. [一年中最热的日子来了](https://so.toutiao.com/search?keyword=一年中最热的日子来了)
1. [教授趁妻儿移民与情人结婚被公诉](https://so.toutiao.com/search?keyword=教授趁妻儿移民与情人结婚被公诉)
1. [北京暴雨](https://so.toutiao.com/search?keyword=北京暴雨)
1. [维珍银河布兰森试飞太空](https://so.toutiao.com/search?keyword=维珍银河布兰森试飞太空)
1. [美团打车新版App上线](https://so.toutiao.com/search?keyword=美团打车新版App上线)
1. [嘴炮左腿胫骨低位骨折需接受手术](https://so.toutiao.com/search?keyword=嘴炮左腿胫骨低位骨折需接受手术)
1. [中纪委同日通报：4名厅级干部被查](https://so.toutiao.com/search?keyword=中纪委同日通报：4名厅级干部被查)
1. [男子向勾引妻子者泼热水获刑](https://so.toutiao.com/search?keyword=男子向勾引妻子者泼热水获刑)
1. [外媒：美军在叙利亚遭遇火箭弹袭击](https://so.toutiao.com/search?keyword=外媒：美军在叙利亚遭遇火箭弹袭击)
1. [阿联酋将暂停来自印尼阿富汗的航班](https://so.toutiao.com/search?keyword=阿联酋将暂停来自印尼阿富汗的航班)
1. [世界人工智能大会闭幕](https://so.toutiao.com/search?keyword=世界人工智能大会闭幕)
1. [梅西祝贺马丁内斯获金手套奖](https://so.toutiao.com/search?keyword=梅西祝贺马丁内斯获金手套奖)
1. [塔利班称不许利用阿富汗攻击中国等](https://so.toutiao.com/search?keyword=塔利班称不许利用阿富汗攻击中国等)
1. [朱亚文与《中国医生》原型合影](https://so.toutiao.com/search?keyword=朱亚文与《中国医生》原型合影)
1. [张杰晒健身照](https://so.toutiao.com/search?keyword=张杰晒健身照)
1. [英格兰发布欧洲杯决赛海报](https://so.toutiao.com/search?keyword=英格兰发布欧洲杯决赛海报)
1. [UFC嘴炮赛中断腿告负](https://so.toutiao.com/search?keyword=UFC嘴炮赛中断腿告负)
1. [专家：央行降准难改楼市运行趋势](https://so.toutiao.com/search?keyword=专家：央行降准难改楼市运行趋势)
1. [徐璐分享穿搭照秀长腿](https://so.toutiao.com/search?keyword=徐璐分享穿搭照秀长腿)
<!-- END TOUTIAO --> | 17,023 | MIT |
# 打开其他APP
> 需要加载的模块
```js
const eeui = app.requireModule('eeui');
```
## eeui.openOtherApp
> 打开常用第三方APP
```js
/**
* @param type APP
*/
eeui.openOtherApp(type)
```
### params 参数说明
| 属性名 | 类型 | 必须 | 描述 | 默认值 |
| --- | --- | :-: | --- | --- |
| type | `String` | √ | 要打开的APP：<br/>`wx`、`qq`、`alipay`、`jd` | - |
### 简单示例
```js
//示例
eeui.openOtherApp("wx");
```
## eeui.openOtherAppTo <Tag date="20191214" :value="['1.0.34+']"/>
> 打开其他第三方APP
```js
/**
* @param pkg Android：包名、iOS：url
* @param cls Android：启动页、iOS：url参数
* @param callback 回调事件
*/
eeui.openOtherAppTo(pkg, cls, callback(result))
```
| 属性名 | 类型 | 必须 | 描述 | 默认值 |
| --- | --- | :-: | --- | --- |
| pkg | `String` | √ | Android：包名、iOS：url | - |
| cls | `String` | √ | Android：启动页、iOS：url参数 | - |
### callback 回调`result`说明
```js
{
status: 'success', //状态，success、error
error: '错误详情',
}
```
### 简单示例
```js
//示例 - Android打开微信
eeui.openOtherAppTo("com.tencent.mm", "com.tencent.mm.ui.LauncherUI", function(result) {
if (result.status == "success") {
//打开成功
}else{
//打开失败
}
});
//示例 - iOS打开微信
eeui.openOtherAppTo("weixin", "", function(result) {
if (result.status == "success") {
//打开成功
}else{
//打开失败
}
});
``` | 1,292 | MIT |
## Maven项目的目录结构
> 在Java开发中，常用构建工具ant,maven和gradle, 其中maven相对主流；本文参考和总结自 http://blog.csdn.net/luanlouis/article/details/50492163, 对maven的理解看这一篇就够。@pDai
### 目录结构
> well,每个项目工程，都有非常繁琐的目录结构，每个目录都有不同的作用。请记住这一点，目录的划分是根据需要来的，每个目录有其特定的功能。目录本质上就是一个文件或文件夹路径而已。那么，我们换一个思路考虑：一个项目的文件结构需要组织什么信息呢？
让我们来看一下功能的划分：
### 如何修改默认的目录配置
在maven项目工程对应project的 pom.xml中，在`<project>--><build>`节点下，你可以指定自己的目录路径信息：
```xml
<build>
<!-- 目录信息维护,用户可以指定自己的目录路径 -->
<sourceDirectory>E:\intellis\maven-principle\phase-echo\src\main\java</sourceDirectory>
<scriptSourceDirectory>E:\intellis\maven-principle\phase-echo\src\main\scripts</scriptSourceDirectory>
<testSourceDirectory>E:\intellis\maven-principle\phase-echo\src\test\java</testSourceDirectory>
<outputDirectory>E:\intellis\maven-principle\phase-echo\target\classes</outputDirectory>
<testOutputDirectory>E:\intellis\maven-principle\phase-echo\target\test-classes</testOutputDirectory>
<!-- 注意，对resource而言，可以有很多个resource路径的配置，你只需要指定对应的路径是resource即可 -->
<resources>
<resource>
<directory>E:\intellis\maven-principle\phase-echo\src\main\resources</directory>
</resource>
</resources>
<!-- 注意，对resource而言，可以有很多个resource路径的配置，你只需要指定对应的路径是resource即可 -->
<testResources>
<testResource>
<directory>E:\intellis\maven-principle\phase-echo\src\test\resources</directory>
</testResource>
</testResources>
<directory>E:\intellis\maven-principle\phase-echo\target</directory>
</build>
```
### 依赖原则
#### 依赖路径最短优先原则
```html
A -> B -> C -> X(1.0)
A -> D -> X(2.0)
```
由于 X(2.0) 路径最短，所以使用 X(2.0)。
#### 声明顺序优先原则
```html
A -> B -> X(1.0)
A -> C -> X(2.0)
```
在 POM 中最先声明的优先，上面的两个依赖如果先声明 B，那么最后使用 X(1.0)。
#### 覆写优先原则
子 POM 内声明的依赖优先于父 POM 中声明的依赖。
### 解决依赖冲突
找到 Maven 加载的 Jar 包版本，使用 `mvn dependency:tree` 查看依赖树，根据依赖原则来调整依赖在 POM 文件的声明顺序。
## Maven 项目生命周期与构建原理
### Maven对项目生命周期的抽象--三大项目生命周期
> Maven从项目的三个不同的角度，定义了单套生命周期，三套生命周期是相互独立的，它们之间不会相互影响。
* 默认构建生命周期（Default Lifeclyle）: 该生命周期表示这项目的构建过程，定义了一个项目的构建要经过的不同的阶段。
* 清理生命周期(Clean Lifecycle): 该生命周期负责清理项目中的多余信息，保持项目资源和代码的整洁性。一般拿来清空directory(即一般的target)目录下的文件。
* 站点管理生命周期(Site Lifecycle) :向我们创建一个项目时，我们有时候需要提供一个站点，来介绍这个项目的信息，如项目介绍，项目进度状态、项目组成成员，版本控制信息，项目javadoc索引信息等等。站点管理生命周期定义了站点管理过程的各个阶段。
### maven对项目默认生命周期的抽象
Maven将其架构和结构的组织放置到了components.xml 配置文件中，该配置文件的路径是:
apache-maven-${version}\lib\maven-core-${version}.jar\META-INFO\plexus\conponents.xml文件中。其中，我们可以看到关于default生命周期XML节点配置信息：
```xml
<component>
<role>org.apache.maven.lifecycle.Lifecycle</role>
<implementation>org.apache.maven.lifecycle.Lifecycle</implementation>
<role-hint>default</role-hint>
<configuration>
<id>default</id>
<phases>
<phase>validate</phase>
<phase>initialize</phase>
<phase>generate-sources</phase>
<phase>process-sources</phase>
<phase>generate-resources</phase>
<phase>process-resources</phase>
<phase>compile</phase>
<phase>process-classes</phase>
<phase>generate-test-sources</phase>
<phase>process-test-sources</phase>
<phase>generate-test-resources</phase>
<phase>process-test-resources</phase>
<phase>test-compile</phase>
<phase>process-test-classes</phase>
<phase>test</phase>
<phase>prepare-package</phase>
<phase>package</phase>
<phase>pre-integration-test</phase>
<phase>integration-test</phase>
<phase>post-integration-test</phase>
<phase>verify</phase>
<phase>install</phase>
<phase>deploy</phase>
</phases>
</configuration>
</component>
```
Maven根据一个项目的生命周期的每个阶段，将一个项目的生命周期抽象成了如上图所示的23个阶段。而每一个阶段应该干什么事情由用户决定。换句话说，maven为每一个阶段设计了接口，你可以为每一阶段自己定义一个接口，进而实现对应阶段应该有的行为。
在经历这些生命周期的阶段中，每个阶段会理论上会有相应的处理操作。但是，在实际的项目开发过程中， 并不是所有的生命周期阶段都是必须的。
基于类似的约定，maven默认地为一些不同类型的maven项目生命周期的阶段实现了默认的行为。
Maven 在设计上将生命周期阶段的抽象和对应阶段应该执行的行为实现分离开，maven这些实现放到了插件中，这些插件本质上是实现了maven留在各个生命周期阶段的接口。
如下图所示，maven针对不同打包类型的maven项目的生命周期阶段绑定了对应的默认行为：
### Maven各生命阶段行为绑定
maven会根据Mojo功能的划分，将具有相似功能的Mojo放到一个插件中。并且某一个特定的Mojo能实现的功能称为 goal,即目标，表明该Mojo能实现什么目标。
例如，我们项目生命周期有两个阶段：compile 和 test-compile,这两阶段都是需要将Java源代码编译成class文件中，相对应地，compile和test-compiler分别被绑定到了org.apache.maven.plugin.compiler.CompilerMojo 和org.apache.maven.plugin.compiler.TestCompilerMojo上：
### 如何查看maven各个生命周期阶段和插件的绑定情况
maven默认实现上，会为各个常用的生命周期根据约定绑定特定的插件目标。maven将这些配置放置到了：
apache-maven-${version}\lib\maven-core-${version}.jar\META-INFO\plexus\default-binds.xml文件中，针对不同打包类型的项目，其默认绑定情况也会不一样，我们先看一下常用的jar包类型和war包类型的项目默认绑定情况：
```xml
<!-- jar包格式的项目生命周期各个阶段默认绑定情况 -->
<component>
<role>org.apache.maven.lifecycle.mapping.LifecycleMapping</role>
<role-hint>jar</role-hint>
<implementation>org.apache.maven.lifecycle.mapping.DefaultLifecycleMapping</implementation>
<configuration>
<lifecycles>
<lifecycle>
<id>default</id>
<!-- START SNIPPET: jar-lifecycle -->
<phases>
<!-- 插件绑定的格式： <plugin-groupid>:<plugin-artifactid>:<version>:goal -->
<process-resources>
org.apache.maven.plugins:maven-resources-plugin:2.6:resources
</process-resources>
<compile>
org.apache.maven.plugins:maven-compiler-plugin:3.1:compile
</compile>
<process-test-resources>
org.apache.maven.plugins:maven-resources-plugin:2.6:testResources
</process-test-resources>
<test-compile>
org.apache.maven.plugins:maven-compiler-plugin:3.1:testCompile
</test-compile>
<test>
org.apache.maven.plugins:maven-surefire-plugin:2.12.4:test
</test>
<package>
org.apache.maven.plugins:maven-jar-plugin:2.4:jar
</package>
<install>
org.apache.maven.plugins:maven-install-plugin:2.4:install
</install>
<deploy>
org.apache.maven.plugins:maven-deploy-plugin:2.7:deploy
</deploy>
</phases>
<!-- END SNIPPET: jar-lifecycle -->
</lifecycle>
</lifecycles>
</configuration>
</component>
<!-- war包格式的项目生命周期各个阶段默认绑定情况 -->
<component>
<role>org.apache.maven.lifecycle.mapping.LifecycleMapping</role>
<role-hint>war</role-hint>
<implementation>org.apache.maven.lifecycle.mapping.DefaultLifecycleMapping</implementation>
<configuration>
<lifecycles>
<lifecycle>
<id>default</id>
<!-- START SNIPPET: war-lifecycle -->
<phases>
<process-resources>
org.apache.maven.plugins:maven-resources-plugin:2.6:resources
</process-resources>
<compile>
org.apache.maven.plugins:maven-compiler-plugin:3.1:compile
</compile>
<process-test-resources>
org.apache.maven.plugins:maven-resources-plugin:2.6:testResources
</process-test-resources>
<test-compile>
org.apache.maven.plugins:maven-compiler-plugin:3.1:testCompile
</test-compile>
<test>
org.apache.maven.plugins:maven-surefire-plugin:2.12.4:test
</test>
<package>
org.apache.maven.plugins:maven-war-plugin:2.2:war
</package>
<install>
org.apache.maven.plugins:maven-install-plugin:2.4:install
</install>
<deploy>
org.apache.maven.plugins:maven-deploy-plugin:2.7:deploy
</deploy>
</phases>
<!-- END SNIPPET: war-lifecycle -->
</lifecycle>
</lifecycles>
</configuration>
</component>
```
### 项目中Run Package命令
加入Jacoo测试统计的插件, pre-test和post-test两个阶段：
```xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>${jacoco.version}</version>
<executions>
<execution>
<id>pre-test</id>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>post-test</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
<defaultGoal>compile</defaultGoal>
</build>
```
```text
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building cdc-common-config 1.0.1-RELEASE
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- jacoco-maven-plugin:0.7.7.201606060606:prepare-agent (pre-test) @ cdc-common-config ---
[INFO] argLine set to -javaagent:C:\\Users\\Z003MRZB\\.m2\\repository\\org\\jacoco\\org.jacoco.agent\\0.7.7.201606060606\\org.jacoco.agent-0.7.7.201606060606-runtime.jar=destfile=D:\\git_cdc2\\cdc-backend-services\\cdc-common-config\\target\\jacoco.exec
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ cdc-common-config ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO] Copying 5 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.5.1:compile (default-compile) @ cdc-common-config ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ cdc-common-config ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory D:\git_cdc2\cdc-backend-services\cdc-common-config\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.5.1:testCompile (default-testCompile) @ cdc-common-config ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-surefire-plugin:2.19.1:test (default-test) @ cdc-common-config ---
...
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] --- jacoco-maven-plugin:0.7.7.201606060606:report (post-test) @ cdc-common-config ---
[INFO] Loading execution data file D:\git_cdc2\cdc-backend-services\cdc-common-config\target\jacoco.exec
[INFO] Analyzed bundle 'cdc-common-config' with 1 classes
[INFO]
[INFO] --- maven-jar-plugin:2.6:jar (default-jar) @ cdc-common-config ---
[INFO] Building jar: D:\git_cdc2\cdc-backend-services\cdc-common-config\target\cdc-common-config-1.0.1-RELEASE.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:1.4.1.RELEASE:repackage (default) @ cdc-common-config ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 10.372 s
[INFO] Finished at: 2017-03-02T15:43:05+08:00
[INFO] Final Memory: 34M/497M
[INFO] ------------------------------------------------------------------------
```
## 参考
- [POM Reference](http://maven.apache.org/pom.html#Dependency_Version_Requirement_Specification) | 12,363 | MIT |
# 系统配置
基于centos7.4以上版本
service smb start
iptables -F
service docker start
# 初始化系统巨页
方法1:配置sysctl
```
echo 'vm.nr_hugepages=2048' >> /etc/sysctl.conf
sysctl -p
```
方法2:修改系统grub参数
```
vim /etc/default/grub
GRUB_CMDLINE_LINUX中增加：default_hugepagesz=2M hugepagesz=2M hugepages=2048 iommu=pt intel_iommu=on
grub2-mkconfig -o /boot/grub2/grub.cfg
reboot
```
# 绑定指定网口到dpdk模式（vfio）
```
sudo modprobe vfio-pci
sudo /usr/bin/chmod a+x /dev/vfio
sudo /usr/bin/chmod 0666 /dev/vfio/*
export NIC_PCIE_ADDR="0000:43:00.1"
sudo ifconfig $(ls /sys/bus/pci/devices/$NIC_PCIE_ADDR/net) down
sudo ./dpdk-devbind.py --bind=vfio-pci $(ls /sys/bus/pci/devices/$NIC_PCIE_ADDR/net)
sudo ./dpdk-devbind.py --status
```
# 绑定指定网口到dpdk模式（uio）（如果vfio不行就试试uio，23的板子使用uio是可以的）
```
export NIC_PCIE_ADDR="0000:43:00.1"
sudo ifconfig $(ls /sys/bus/pci/devices/$NIC_PCIE_ADDR/net) down
sudo modprobe uio
sudo insmod ../../build/dpdk/kmod/igb_uio.ko
sudo ./dpdk-devbind.py --bind=igb_uio $(ls /sys/bus/pci/devices/$NIC_PCIE_ADDR/net)
或：sudo ./dpdk-devbind.py --bind=igb_uio "00:14.0"
sudo ./dpdk-devbind.py --status
```
# 系统巨页默认已经挂载了，如果没有手动挂载一下
```
sudo mount -t hugetlbfs none /dev/huge
```
如果dpdk成功配置：
[root@localhost script]# sudo ./dpdk-devbind.py --status
Network devices using DPDK-compatible driver
============================================
0000:00:14.3 'Ethernet Connection I354 1f41' drv=igb_uio unused=igb,vfio-pci
Network devices using kernel driver
===================================
0000:00:14.0 'Ethernet Connection I354 1f41' if=eno1 drv=igb unused=igb_uio,vfio-pci
0000:00:14.1 'Ethernet Connection I354 1f41' if=eno2 drv=igb unused=igb_uio,vfio-pci
0000:00:14.2 'Ethernet Connection I354 1f41' if=eno3 drv=igb unused=igb_uio,vfio-pci *Active*
Other Crypto devices
====================
0000:00:0b.0 'Atom processor C2000 QAT 1f18' unused=igb_uio,vfio-pci
No 'Eventdev' devices detected
==============================
No 'Mempool' devices detected
=============================
No 'Compress' devices detected
==============================
[root@localhost script]# | 2,150 | Apache-2.0 |
---
nav:
title: 组件
path: /components
group:
path: /components/feedback
title: 反馈
---
## Notification 通知提醒框
全局展示操作反馈信息。
```tsx
/**
* title: 基础
* desc: 信息提醒反馈。
*/
import React, { useState } from 'react';
import { notification, Button } from '@weblif/fast-ui';
export default () => {
const openNotification = () => {
notification.open({
message: 'Notification Title',
description:
'This is the content of the notification. This is the content of the notification. This is the content of the notification.',
onClick: () => {
console.log('Notification Clicked!');
},
});
};
return (
<Button type="primary" onClick={openNotification}>
点击显示一个消息
</Button>
);
};
```
## API
- `notification.success(config)`
- `notification.error(config)`
- `notification.info(config)`
- `notification.warning(config)`
- `notification.warn(config)`
- `notification.open(config)`
- `notification.close(key: String)`
- `notification.destroy()`
config 参数如下：
| 参数 | 说明 | 类型 | 默认值 |
| --- | --- | --- | --- |
| bottom | 消息从底部弹出时，距离底部的位置，单位像素 | number | 24 |
| btn | 自定义关闭按钮 | ReactNode | - |
| className | 自定义 CSS class | string | - |
| closeIcon | 自定义关闭图标 | ReactNode | - |
| description | 通知提醒内容，必选 | ReactNode | - |
| duration | 默认 4.5 秒后自动关闭，配置为 null 则不自动关闭 | number | 4.5 |
| getContainer | 配置渲染节点的输出位置 | () => HTMLNode | () => document.body |
| icon | 自定义图标 | ReactNode | - |
| key | 当前通知唯一标志 | string | - |
| message | 通知提醒标题，必选 | ReactNode | - |
| placement | 弹出位置，可选 `topLeft` `topRight` `bottomLeft` `bottomRight` | string | `topRight` |
| style | 自定义内联样式 | [CSSProperties](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/e434515761b36830c3e58a970abf5186f005adac/types/react/index.d.ts#L794) | - |
| top | 消息从顶部弹出时，距离顶部的位置，单位像素 | number | 24 |
| onClick | 点击通知时触发的回调函数 | function | - |
| onClose | 当通知关闭时触发 | function | - |
还提供了一个全局配置方法，在调用前提前配置，全局一次生效。
- `notification.config(options)`
> 当你使用 `ConfigProvider` 进行全局化配置时，系统会默认自动开启 RTL 模式。(4.3.0+)
>
> 当你想单独使用，可通过如下设置开启 RTL 模式。
```js | pure
notification.config({
placement: 'bottomRight',
bottom: 50,
duration: 3,
rtl: true,
});
```
| 参数 | 说明 | 类型 | 默认值 | 版本 |
| --- | --- | --- | --- | --- |
| bottom | 消息从底部弹出时，距离底部的位置，单位像素 | number | 24 | |
| closeIcon | 自定义关闭图标 | ReactNode | - | |
| duration | 默认自动关闭延时，单位秒 | number | 4.5 | |
| getContainer | 配置渲染节点的输出位置 | () => HTMLNode | () => document.body | |
| placement | 弹出位置，可选 `topLeft` `topRight` `bottomLeft` `bottomRight` | string | `topRight` | |
| rtl | 是否开启 RTL 模式 | boolean | false | |
| top | 消息从顶部弹出时，距离顶部的位置，单位像素 | number | 24 | |
| maxCount | 最大显示数, 超过限制时，最早的消息会被自动关闭 | number | - | 4.17.0 |
## FAQ
### 为什么 notification 不能获取 context、redux 的内容和 ConfigProvider 的 `locale/prefixCls` 配置？
直接调用 notification 方法，antd 会通过 `ReactDOM.render` 动态创建新的 React 实体。其 context 与当前代码所在 context 并不相同，因而无法获取 context 信息。
当你需要 context 信息（例如 ConfigProvider 配置的内容）时，可以通过 `notification.useNotification` 方法会返回 `api` 实体以及 `contextHolder` 节点。将其插入到你需要获取 context 位置即可：
```tsx | pure
const [api, contextHolder] = notification.useNotification();
return (
<Context1.Provider value="Ant">
{/* contextHolder 在 Context1 内，它可以获得 Context1 的 context */}
{contextHolder}
<Context2.Provider value="Design">
{/* contextHolder 在 Context2 外，因而不会获得 Context2 的 context */}
</Context2.Provider>
</Context1.Provider>
);
```
**异同：**通过 hooks 创建的 `contextHolder` 必须插入到子元素节点中才会生效，当你不需要上下文信息时请直接调用。
### 静态方法如何设置 prefixCls ？
你可以通过 [`ConfigProvider.config`](</components/config-provider/#ConfigProvider.config()-4.13.0+>) 进行设置。 | 3,681 | MIT |
---
title: ES6入门
cover: https://img-blog.csdnimg.cn/1acaa223a1cd4f0ba4875ed67eb995a3.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAPGRpdiBjbGFzcz0n6b6Z5a6d5a6dJz4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
date: 2021-07-11
tags:
- ES6
categories:
- 技术笔记
---
::: tip 介绍
ES6 学习期间记录的一些文档<br>
:::
## es6 知识（常用）
#### let 和 const
创建变量新语法，替换 var
- const 适用于创建常量，不可修改
##### let ，const 于 var 的区别
- let 、const 自带块级作用域。
- 没有变量声明提升。
- 不允许重复声明。
- var 有变量声明提升，但是变量的赋值不可以提升，
- var 可以重复定义，后面定义的覆盖前面定义的。
#### 变量的解构赋值
- 数组的结构赋值
```js
let arr = [1, 2, 4, 3];
let [num1, num2, , num3] = arr;
console.log(num1); //1
console.log(num2); //2
console.log(num3); //3
```
- 对象的结构赋值
```js
let obj={
username:'limin',
userage:20;
}
let{
username:name,userage,sex='nan'
//可以换名，可以设置默认值
}=obj
console.log(name);//limin
console.log(userage);//20
console.log(sex);//nan
```
- 字符串的结构赋值
阮一冯[https://es6.ruanyifeng.com/#docs/destructuring#%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E8%A7%A3%E6%9E%84%E8%B5%8B%E5%80%BC]
- 函数参数的解构赋值
```js
var obj = {
name: "xiao",
};
function say({ name }) {
// let { name } = obj;相当于执行这一段代码
console.log(name);
}
say(obj);
```
#### 字符串的扩展
- 模板字符串 \${变量}
```js
let obj = {
name: "xiao",
};
let html = ` <div class="goods">${obj.name}</div>`;
console.log(html);
```
- 字符串拓展
```js
let str = "hello";
let newStr = str.padEnd(8, "a");
console.log(newStr); //helloaaa
//paddEnd 向后填充
//padStar 向前填充
//对原数据无影响
```
#### 数组的拓展
- flat(num) 数组的扁平化处理,num 为扁平次数，默认为 1，最多为 Infinity。不改变原数组
- flatMap（）映射加扁平化处理
- fill 根据指定数据对数组进行处理
#### 对象的拓展
- 属性的简洁表示法
```js
let name = "大白";
let age = 10;
let obj = {
name: name,
age: age,
say: function() {
console.log(this.name);
},
};
let obj1 = {
name,
age, //创建对象的时候如果属性值所代表的变量名和属性名相同则可以简写。
say() {
console.log(this.name);
}, //创建函数时候的function可以省略不写
};
console.log(obj);
console.log(obj1);
obj.say();
obj1.say();
```
#### 扩展运算符 ...
```js
let arr = [1, 2, 3, 4, 5];
let arr1 = [...arr];
arr1.push(6);
console.log(arr); //[1, 2, 3, 4, 5]
console.log(arr1); //[1, 2, 3, 4, 5,6]
let obj = {
a: 10,
b: 100,
};
let obj1 = {
...obj,
};
obj1.a = 100;
console.log(obj.a); //10
console.log(obj1.a); //100
//... 可以不影响原数组或对象，但作用只有一层，当数组或对象多层嵌套时内部的几层依旧会受到影像。
let goodArr = [
{
name: "手机",
price: 1000,
id: 1,
},
{
name: "电脑",
price: 2000,
id: 2,
},
{
name: "平板",
price: 3000,
id: 3,
},
];
let newArr = [...goodArr];
newArr[1].price = 2500;
console.log(newArr[1]); //2500
console.log(goodArr[1]); //2500 被改变
```
#### 新增的两种数据类型
##### symbol
- 不可与其他值进行运算，会报错。
- 通过 symbol(a).description 将 symbol 转换为字符串 a
#### set 和 map 数据结构
```js
const s = new Set(); //创建一个常量，set类似于一个数组
[2, 3, 4, 5, 2, 2].forEach(function(ele) {
s.add(ele); //add是set的一个方法，每次向set里添加一个新成员（ele）；
});
console.log(s); //{2,3,4,5}
//新建set
let news = new Set([1, 1, 2, 3, 4]);
//{1,2,3,4}
```
- set() 可以接受数组为参数
- set.size 返回 set 的长度
```js
let arr = [1, 1, 2, 2, 3, 3];
console.log([...new Set(arr)]);
//先使用set去重
//使用扩展运算符展开
//【】转换为数组
//数组的join方法可以实现字符串去重
```
- 详细属性方法见[https://es6.ruanyifeng.com/#docs/set-map]
#### Class 的基本语法
引入了 class 的概念，可以更简单的实现构造函数的一些功能
```js
//构造函数方法
function Point(x, y) {
this.x = x;
this.y = y;
}
Point.prototype.toString = function() {
return `(${this.x},${this.y})`;
};
let p = new Point(3, 4);
console.log(p);
console.log(p.toString());
//
//
//
//class
let _color = "red"; //将color属性设置到类外，方便修改，若在class内，则通过set对get进行修改时set会发生死循环。
class Point {
//除了constructor方法外的方法为共有方法，公有方法存储在原型当中。
z = 0; //定义·不可动态修改的属性
constructor(x, y) {
this.x = x;
this.y = y;
}
get color() {
return _color;
}
//给所有对象添加一个color属性，有一个默认值red
set color(new_value) {
_color = new_value;
} //set 于 get 相对应，每次修改 get 所赋值的属性时都会触发 set 。通过set来修改get的值。
tostring() {
return `(${this.x},${this.y})`;
}
//不同的公有方法间不需要用逗号隔开。
say() {
console.log("hello");
}
static SayHello() {
console.log("hi");
//静态方法,创建的实例不可调用
}
}
let p = new Point(1, 2);
console.log(p);
console.log(p.tostring());
p.say();
p.color = "blue";
console.log(p);
Point.SayHello(); //只有Class本身可以调用静态方法
```
#### Class 的继承
```js
class Point {
//这是一个父类
constructor(x, y) {
this.x = x;
this.y = y;
}
sayPoint() {
console.log(`我是坐标(${this.x},${this.y})`);
}
}
class ColorPoint extends Point {
//类继承的关键字 extends
constructor(x, y, color) {
super(x, y);
//当继承的类内部创建了新的 constructor，那么需要 super关键字来调用父级的 constructor，如果没有创建则不需要。
this.color = color;
}
}
let colorP = new ColorPoint(100, 200, "blue");
console.log(colorP);
colorP.sayPoint(); //我是坐标(100,200)
```
#### 函数的扩展
- 函数可以设置默认值
```js
function add(x = 20, y = 10) {
return x + y;
}
console.log(add(1, 2)); //3 当传入了参数，则默认值不生效
console.log(add()); //30 不传入参数，默认值生效
```
- rest 参数
- 函数的新写法，箭头函数
```js
let add = (x, (y = 20)); //左侧为参数，使用()包裹
=> x + y;
//右侧默认为使用{}包裹，当只有返回值时，{}以及return可以省略
```
- 函数的 this 指向
- 普通函数谁调用了函数就指向谁
- 箭头函数创建时就定义好了，一般指向 window ， 涉及到 this 需要注意（箭头函数的 this 指向当前作用域）
#### es6
#### 使用 webpack 编译打包 es6 模块语法
- 安装 nodejs（node）
- 安装命令行工具 gitbash
- 新建项目文件夹，在文件夹内执行 `npm init -y` 命令。将该文件夹变为 node 项目，从而可以让这个项目使用 npm 下载对应的包。
- 项目内安装 webpack 执行 `npm install webpack webpack-cli --save-dev` 指令 下载 webpack 包
- 在根目录下创建 index.html src/index.js （必须以 index 命名）
- index.js 引入相关模块
- 在命令行工具执行 `npx webpack` 指令，将 dist 文件夹生成的 main.js 文件引入项目。
```js
//模块导出一个变量
export let firstName = "龙宝";
```
```js
//模块导入变量
//当导入的模块属于js文件时可以省略后缀
import { firstName } from "./a.js"; //js后缀可以省略
console.log(firstName); //导出后，firstName变量就可以使用了
```
##### 模块的导入与导出
- 命名导出与默认导出
```js
//模块导出一个firstName 变量
//命名导出
//关键字 export
//可多次导出
export let firstName = "龙宝宝";
let lastName = "龙仔";
export { lastName };
export {
lastName as laName, //换名导出
};
//默认导出
//关键字 export default
let a = 10;
let b = 20;
let c = 10000;
export {
a,
b, //批量导出
};
export default c;
```
- 命名导入与默认导入
```js
//导入sy.js 所导出的变量
// 当模块是js文件可省略后缀
//1,命名导入
import { firstName } from "./sy";
console.log(firstName);
import * as all from "./sy";
console.log(all.a);
console.log(all.b);
console.log(all.lastName);
console.log(all.laName);
console.log(all.default);
//默认导入
import x from "./sy"; //默认导出时候任意命名
//* 表示导出所有
// as 为换名导出
//可用于剔除冗余代码
//导出后便可正常使用
```
##### promise
## promise 异步解决方案
#### 异步解决方案
```js
const promise = new Promise(function(resolve, reject) {
console.log("异步操作开始执行");
let a = 10;
setTimeout(() => {
//里面的内容是异步完成后执行的
a--;
if (a > 10) {
console.log("异步操作成功");
resolve("ok");
} else {
console.log("异步操作失败");
reject("出错了");
}
}, 2000);
});
promise
.then((res) => {
console.log("异步操作完毕，继续其他操作");
console.log(res); //ok
//res对应异步成功的参数
})
//可链式编写：执行结束后返回了 new Promise创造的实例
.catch((err) => {
console.log(err); //出错了
//err对应异步失败的参数
})
.finally("请求完成后再执行，不论是否成功");
//then 和 catch 是属于 Promise 原型下的公共方法，所以构造出的实例可以使用这两个方法
```
#### 实例
```js
//用promise 封装一个ajax get 请求插件
// new Promise(里的参数是一个有两个形参的函数)
let getPosts = (url) => {
return new Promise((resolve, reject) => {
let xhr = new XMLHttpRequest();
xhr.open("GET", url); //传递请求地址，达到插件效果
xhr.send();
xhr.onload = () => {
if (xhr.readyState === 4 && xhr.status === 200) {
resolve(JSON.parse(xhr.responseText)); //then 触发reslove
} else {
reject("chuo le"); //，catch 触发reject
}
};
});
};
getPosts("http://localhost:3008/posts")
.then((res) => {
console.log(res);
})
.catch((err) => {
console.log(err);
});
//依次输出有序的多个请求。一个请求报错会影响接下来的请求
getPosts("http://localhost:3008/posts/1")
.then((res) => {
console.log(res);
return getPosts("http://localhost:3008/posts/2");
})
.catch((err) => {
console.log(err);
})
.then((res) => {
console.log(res);
return getPosts("http://localhost:3008/posts/3");
})
.then((res) => {
console.log(res);
});
```
#### Promise.all
```js
// Promise.all 并发方法
const allP = Promise.all([
getPosts("http://localhost:3008/posts"),
getPosts("http://localhost:3008/posts/2"),
getPosts("http://localhost:3008/posts/3"),
]);
allP
.then((res) => {
console.log(res);
//全部成功时，获取到resolve函数的参数的集合
})
.catch((err) => {
console.log(err);
//有错误则一个也获取不到
});
```
#### Promise 的多个对象及其他
阮一冯[https://es6.ruanyifeng.com/#docs/promise]
### 基于 Promise 的 async
```js
const getPosts = async () => {
const res = await axios.get("http://localhost:3008/posts");
console.log(res.data);
};
getPosts();
//在异步函数外获取内部参数
const getPosts = async () => {
const res = await axios.get("http://localhost:3008/posts");
//await 后一般跟着promise
//async内的所有操作都需要在await后的代码完成后开始执行
return res.data;
//return 返回的值会成为then方法的res参数
};
getPosts()
.then((res) => {
console.log(res);
})
.catch((err) => {
console.log(err);
}); //通过catch可以获得错误信息。
``` | 8,886 | MIT |
---
layout: post
title: "CSS "
date: 2017-09-10 08:16:54
categories: HTML CSS
tags: HTML CSS Hack
---
* content
{:toc}
这里只列举一些使用比率较高的常用CSS Hack，且不考虑IE6以下的版本。若对其它更多Hack有兴趣，可Google或Baidu。
## 条件Hack
语法:
```
<!--[if <keywords>? IE <version>?]>
HTML代码块
<![endif]-->
```
取值:
`<keywords>`
if条件共包含6种选择方式：是否、大于、大于或等于、小于、小于或等于、非指定版本
- 是否：指定是否IE或IE某个版本。关键字：空
- 大于：选择大于指定版本的IE版本。关键字：gt（greater than）
- 大于或等于：选择大于或等于指定版本的IE版本。关键字：gte（greater than or equal）
- 小于：选择小于指定版本的IE版本。关键字：lt（less than）
- 小于或等于：选择小于或等于指定版本的IE版本。关键字：lte（less than or equal）
- 非指定版本：选择除指定版本外的所有IE版本。关键字：!
`<version>`
目前的常用IE版本为6.0及以上，推荐酌情忽略低版本，把精力花在为使用高级浏览器的用户提供更好的体验上
IE10及以上版本已将条件注释特性移除，使用时需注意。
说明:
用于选择IE浏览器及IE的不同版本
if条件Hack是HTML级别的（包含但不仅是CSS的Hack，可以选择任何HTML代码块）
实例:
```
<!--[if IE]>
<p>你在非IE中将看不到我的身影</p>
<![endif]-->
```
```
<!--[if gt IE 6]>
<style>
.test{color:red;}
</style>
<![endif]-->
```
## 属性级Hack
语法：
`selector{<hack>?property:value<hack>?;}`
取值：
- `_`：选择IE6及以下。连接线（中划线）（-）亦可使用，为了避免与某些带中划线的属性混淆，所以使用下划线（_)更为合适。
- `*`：选择IE7及以下。诸如：（+）与（#）之类的均可使用，不过业界对（*）的认知度更高
- `\9`：选择IE6+
- `\0`：选择IE8+和Opera15以下的浏览器
说明：
选择不同的浏览器及版本
尽可能减少对CSS Hack的使用。Hack有风险，使用需谨慎
通常如未作特别说明，本文档所有的代码和示例的默认运行环境都为标准模式。
实例:
```
.test {
color: #090\9; /* For IE8+ */
*color: #f00; /* For IE7 and earlier */
_color: #ff0; /* For IE6 and earlier */
}
```
## 选择符级Hack
语法:
`<hack> selector{ sRules }`
说明：
选择不同的浏览器及版本
尽可能减少对CSS Hack的使用。Hack有风险，使用需谨慎
通常如未作特别说明，本文档所有的代码和示例的默认运行环境都为标准模式。
一些CSS Hack由于浏览器存在交叉认识，所以需要通过层层覆盖的方式来实现对不同浏览器进行Hack的。
实例:
```
* html .test { color: #090; } /* For IE6 and earlier */
* + html .test { color: #ff0; } /* For IE7 */
.test:lang(zh-cmn-Hans) { color: #f00; } /* For IE8+ and not IE */
.test:nth-child(1) { color: #0ff; } /* For IE9+ and not IE */
``` | 1,804 | MIT |
---
title: 並存安裝 Reporting Services 和 Internet Information Services | Microsoft Docs
ms.date: 07/02/2017
ms.prod: reporting-services
ms.prod_service: reporting-services-native
ms.topic: conceptual
helpviewer_keywords:
- deploying [Reporting Services], IIS
ms.assetid: 9b651fa5-f582-4f18-a77d-0dde95d9d211
author: markingmyname
ms.author: maghan
ms.openlocfilehash: 991eefb50ec949098e132f17f2c18691f4822987
ms.sourcegitcommit: 9ece10c2970a4f0812647149d3de2c6b75713e14
ms.translationtype: HT
ms.contentlocale: zh-TW
ms.lasthandoff: 11/16/2018
ms.locfileid: "51813503"
---
# <a name="install-reporting-and-internet-information-services-side-by-side"></a>並存安裝 Reporting Services 和 Internet Information Services
[!INCLUDE[ssrs-appliesto](../../includes/ssrs-appliesto.md)] [!INCLUDE[ssrs-appliesto-2016-and-later](../../includes/ssrs-appliesto-2016-and-later.md)] [!INCLUDE[ssrs-appliesto-pbirsi](../../includes/ssrs-appliesto-pbirs.md)]
[!INCLUDE [ssrs-previous-versions](../../includes/ssrs-previous-versions.md)]
您可以在同一部電腦上安裝和執行 SQL Server Reporting Services (SSRS) 與 Internet Information Services (IIS)。 您所使用的 IIS 版本會決定必須處理的互通性問題。
|IIS 版本|問題|Description|
|-----------------|------------|-----------------|
|8.0, 8.5|適用於某個應用程式的要求被不同的應用程式所接受。<br /><br /> HTTP.SYS 會針對 URL 保留項目強制執行優先順序規則。 如果 URL 保留項目比另一個應用程式的 URL 保留項目更弱，傳送至具有相同虛擬目錄名稱而且共同監視通訊埠 80 之應用程式的要求可能無法送達預期的目標。|在特定條件底下，在 URL 保留項目配置中取代另一個 URL 端點的已註冊端點可能會收到適用於其他應用程式的 HTTP 要求。<br /><br /> 針對報表伺服器 Web 服務和 [!INCLUDE[ssRSWebPortal-Non-Markdown](../../includes/ssrswebportal-non-markdown-md.md)] 使用唯一的虛擬目錄名稱可協助您避免這項衝突。<br /><br /> 本主題將提供有關這個狀況的詳細資訊。|
## <a name="precedence-rules-for-url-reservations"></a>URL 保留項目的優先順序規則
在您處理 IIS 與 [!INCLUDE[ssRSnoversion](../../includes/ssrsnoversion-md.md)]之間的互通性問題之前，必須了解 URL 保留項目的優先順序規則。 優先順序規則可以歸納成為下列陳述式：具有更多明確定義值的 URL 保留項目會優先接收符合此 URL 的要求。
- 指定虛擬目錄的 URL 保留項目會比省略虛擬目錄的 URL 保留項目更明確。
- 指定單一位址 (透過 IP 位址、完整網域名稱、網路電腦名稱或主機名稱) 的 URL 保留項目會比萬用字元更明確。
- 指定強式萬用字元的 URL 保留項目會比弱式萬用字元更明確。
下列範例會顯示 URL 保留項目的範圍，從最明確到最不明確的順序排列：
|範例|要求|
|-------------|-------------|
|`https://123.234.345.456:80/reports`|如果網域名稱服務可以將 IP 位址解析成該主機名稱，則會收到所有傳送至 `https://123.234.345.456/reports` 或 `https://\<computername>/reports` 的所有要求。|
|`https://+:80/reports`|只要此 URL 包含 "reports" 虛擬目錄名稱，便接收傳送至適用於該電腦之任何 IP 位址或主機名稱的任何要求。|
|`https://123.234.345.456:80`|如果網域名稱服務可以將 IP 位址解析成該主機名稱，則會收到任何指定 `https://123.234.345.456` 或 `https://\<computername>` 的要求。|
|`https://+:80`|若為對應至 [全部指派] 的應用程式端點，便接收尚未由其他應用程式接收的要求。|
|`https://*:80`|若為對應至 [全未指派] 的應用程式端點，便接收尚未由其他應用程式接收的要求。|
發生連接埠衝突的其中一個指標是，您將會看到下列錯誤訊息：「System.IO.FileLoadException: 由於已有另一個處理序正在使用該檔案，所以無法存取該檔案。 (來自 HRESULT 的例外狀況: 0x80070020)。」
## <a name="url-reservations-for-iis-80-85-with-sql-server-reporting-services"></a>IIS 8.0、8.5 與 SQL Server Reporting Services 的 URL 保留項目
根據上一節所描述的優先順序規則，您可以開始了解針對 Reporting Services 和 IIS 所定義的 URL 保留項目如何提升互通性。 Reporting Services 會接收明確指定其應用程式之虛擬目錄名稱的要求。IIS 會接收所有其餘要求，然後您可以將這些要求導向至 IIS 處理模型內部執行的應用程式。
|應用程式|URL 保留項目|Description|要求接收|
|-----------------|---------------------|-----------------|---------------------|
|報表伺服器|`https://+:80/ReportServer`|通訊埠 80 的強式萬用字元，以及報表伺服器虛擬目錄。|在通訊埠 80 上接收指定報表伺服器虛擬目錄的所有要求。 報表伺服器 Web 服務會接收 https://\<電腦名稱>/reportserver 的所有要求。|
|入口網站|`https://+:80/Reports`|通訊埠 80 的強式萬用字元，以及 Reports 虛擬目錄。|在通訊埠 80 上接收指定 Reports 虛擬目錄的所有要求。 [!INCLUDE[ssRSWebPortal-Non-Markdown](../../includes/ssrswebportal-non-markdown-md.md)] 會接收 https://\<電腦名稱>/reports 的所有要求。|
|IIS|`https://*:80/`|通訊埠 80 的弱式萬用字元。|在通訊埠 80 上接收其他應用程式未接收的任何其餘要求。|
## <a name="side-by-side-deployments-of-sql-server-reporting-services-on-iis-80-85"></a>在 IIS 8.0、8.5 上並存部署 SQL Server Reporting Services
當 IIS 網站的虛擬目錄名稱與 Reporting Services 所使用的虛擬目錄名稱完全相同時，IIS 與 Reporting Services 之間就會發生互通性問題。 例如，假設您有下列組態：
- 指派至通訊埠 80 以及名為 "Reports" 之虛擬目錄的 IIS 網站。
- 以預設設定安裝的報表伺服器執行個體，其中 URL 保留項目也指定了通訊埠 80 而 [!INCLUDE[ssRSWebPortal-Non-Markdown](../../includes/ssrswebportal-non-markdown-md.md)] 應用程式也將 "Reports" 用於虛擬目錄名稱。
如果您採用此設定，則傳送至 https://\<電腦名稱>:80/reports 的要求將由 [!INCLUDE[ssRSWebPortal-Non-Markdown](../../includes/ssrswebportal-non-markdown-md.md)] 所接收。 安裝了報表伺服器執行個體之後，透過 IIS 中 Reports 虛擬目錄存取的應用程式將不會再接收要求。
如果您要執行舊版與新版 [!INCLUDE[ssRSnoversion](../../includes/ssrsnoversion-md.md)]的並存部署，可能會遇到上述路由傳送的問題。 這是因為所有 [!INCLUDE[ssRSnoversion](../../includes/ssrsnoversion-md.md)] 版本都會使用 "ReportServer" 和 "Reports" 當做報表伺服器與 [!INCLUDE[ssRSWebPortal-Non-Markdown](../../includes/ssrswebportal-non-markdown-md.md)] 應用程式的虛擬目錄名稱，因而增加您在 IIS 中設有 "reports" 和 "reportserver" 虛擬目錄的可能性。
為了確保所有應用程式都會接收要求，請遵循下列指導方針：
- 針對 Reporting Services 安裝，請使用 IIS 網站與 Reporting Services 在相同通訊埠上尚未使用的虛擬目錄名稱。 如果發生衝突，請以「僅限檔案」模式安裝 Reporting Services (使用「安裝」，但不要在安裝精靈中設定伺服器選項)，以便您可以在安裝完成之後設定虛擬目錄。 組態發生衝突的其中一個指標是，您將會看到下列錯誤訊息：System.IO.FileLoadException: 由於已有另一個處理序正在使用該檔案，所以無法存取該檔案。 (來自 HRESULT 的例外狀況: 0x80070020)。
- 針對手動設定的安裝，請在設定的 URL 中採用預設命名慣例。 如果您將 [!INCLUDE[ssRSCurrent](../../includes/ssrscurrent-md.md)] 安裝成具名執行個體，請在建立虛擬目錄時加入執行個體名稱。
## <a name="next-steps"></a>後續步驟
[設定報表伺服器 URL](../../reporting-services/install-windows/configure-report-server-urls-ssrs-configuration-manager.md)
[設定 URL](../../reporting-services/install-windows/configure-a-url-ssrs-configuration-manager.md)
[安裝 Reporting Services 原生模式報表伺服器](../../reporting-services/install-windows/install-reporting-services-native-mode-report-server.md)
更多問題嗎？ [請嘗試詢問 Reporting Services 論壇](https://go.microsoft.com/fwlink/?LinkId=620231) | 5,523 | CC-BY-4.0 |
## RESTful Api
目录
- 继承的基类说明
- 速率和参数配置
- 不需要速率控制设置
- Url权限配置
- 方法权限验证
- 返回数据格式修改
- 自定义code返回
- 解析Model首个报错信息
- 获取当前登录的用户信息
### 继承的基类说明
- 无需登录的控制器请全部继承 `api\controllers\OffAuthController`,注意Curd是改过的，不想用系统的Curd可直接继承 `yii\rest\ActiveController`
- 需登录的控制器请全部继承 `api\controllers\OnAuthController`,注意Curd是改过的，不想用系统的Curd可直接继承 `api\controllers\ActiveController`
### 速率和参数配置
> 可自行修改 `api/config/params.php` 配置
```
return [
// 是否开启api log 日志记录
'user.log' => true,
'user.log.noPostData' => [ // 安全考虑，不接收Post存储到日志的路由
'v1/site/login',
],
// token有效期是否验证 默认不验证
'user.accessTokenValidity' => false,
// api接口token有效期 默认2天
'user.accessTokenExpire' => 2 * 24 * 3600,
// 不需要token验证的方法
'user.optional' => [
],
// 速度控制 60 秒内访问 50 次，注意，数组的第一个不要设置1，设置1会出问题，一定要大于2
'user.rateLimit' => [50, 60],
// 默认分页数量
'user.pageSize' => 10,
];
```
### 不需要速率控制设置
找到 `common\models\api\AccessToken` 让其直接继承 `common\models\common\BaseModel` 即可
### Url权限配置
> 系统默认都是严格校验url方式注意在 `api/config/main.php的urlManager`里添加规则，否则访问都是404。
> 如果不想严格校验请在 urlManager 里面注释或删除 `'enableStrictParsing' => true,`
### 方法权限验证
> 在执行访问方法前系统会先调用 `checkAccess` 方法来检测该方法能不能被验证通过，可以在控制器内添加该方法来判断权限，如果不需要可忽略。下面是个例子，不想让外部访问 delete 和 index 方法
```
/**
* 权限验证
*
* @param string $action 当前的方法
* @param null $model 当前的模型类
* @param array $params $_GET变量
* @throws \yii\web\BadRequestHttpException
*/
public function checkAccess($action, $model = null, $params = [])
{
// 方法名称
if (in_array($action, ['delete', 'index']))
{
throw new \yii\web\BadRequestHttpException('权限不足');
}
}
```
### 返回数据格式修改
> 请自行修改 `api\behaviors\beforeSend` 行为
> 注意: 有些前端没有接触过状态码在Http头里面返回所以可以 在 beforeSend 数据处理后开启 `$response->statusCode = 200`;
### 自定义code返回
```
/**
* 返回json数据格式
*
* 注意：要符合http状态码 否则报错
*
* @param int $code 状态码
* @param string $message 返回的报错信息
* @param array|object $data 返回的数据结构
*/
api\controllers\ResultDataHelper::apiResult($code, $message, $data = []);
```
### 解析Model首个报错信息
```
/**
* 注意这里传递的变量一定是 `$model->getFirstErrors()` 的数据
*
* @param $fistErrors
* @return string
*/
$this->analyErr($model->getFirstErrors())
```
### 获取当前登录的用户信息
```
use common\models\member\MemberInfo;
$tokenModel = Yii::$app->user->identity;
$member = MemberInfo::findIdentity($tokenModel['member_id']);
``` | 2,335 | Apache-2.0 |