DES加密算法探究【Java版本】

1、参考文章:
1.1对称加密算法;
1.2DES算法详细设计;
2、参考代码
2.1、DESUtils
2.2、Encryp-Demo
3.对称加密算法
3.1 定义

对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥（mi yue）一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。

3.2 优缺点

优点：算法公开、计算量小、加密速度快、加密效率高。

缺点：

（1）交易双方都使用同样钥匙，安全性得不到保证。

（2）每对用户每次使用对称加密算法时，都需要使用其他人不知道的惟一钥匙，这会使得发收信双方所拥有的钥匙数量呈几何级数增长，密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难，主要是因为密钥管理困难，使用成本较高。

3.3 常用对称加密算法

基于“对称密钥”的加密算法主要有DES、3DES（TripleDES）、AES、RC2、RC4、RC5和Blowfish等。本文只介绍最常用的对称加密算法DES、3DES（TripleDES）和AES。
3.4、DES加密算法的几种模式:
3.4.1、参考文章 ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
AES/CBC/NoPadding (128) 
AES/CBC/PKCS5Padding (128) 
AES/ECB/NoPadding (128) 
AES/ECB/PKCS5Padding (128) 
DES/CBC/NoPadding (56) 
DES/CBC/PKCS5Padding (56) 
DES/ECB/NoPadding (56) 
DES/ECB/PKCS5Padding (56) 
 
（DESede实际上是3-DES） 
DESede/CBC/NoPadding (168) 
DESede/CBC/PKCS5Padding (168) 
DESede/ECB/NoPadding (168) 
DESede/ECB/PKCS5Padding (168)

3.4.2:需要留意的坑:

由于加密时会自动填充到8字节(64bit),那么在我们进行字节数组到字串的转化过程中，可以把它填补的不可见字符改变了,所以解密时会导致异常,用base64解决

4、代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
package com.jm;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import org.apache.commons.codec.binary.Hex;
/**
 * @Createtime 2014年12月5日 14:22:00
 * @author Lxz
 * 
 */
public class DESUtil {
	/**
	 * UTF-8编码
	 */
	public static final String ENCODED_UTF8 = "UTF-8";
	/**
	 * GBK编码
	 */
	public static final String ENCODED_GBK = "GBK";
	/**
	 * GB2312编码
	 */
	public static final String ENCODED_GB2312 = "GB2312";
	/**
	 * ISO8859-1编码
	 */
	public static final String ENCODED_ISO88591 = "ISO8859-1";
	/**
	 * ASCII编码
	 */
	public static final String ENCODED_ASCII = "ASCII";
	/**
	 * UNICODE编码
	 */
	public static final String ENCODED_UNICODE = "UNICODE";
	/**
	 * CBC加密模式
	 */
	public static final String CIPHER_INSTANCE_CBC = "DES/CBC/PKCS5Padding";
	/**
	 * ECB加密模式
	 */
	public static final String CIPHER_INSTANCE_ECB = "DES/ECB/PKCS5Padding";
	
	/**
	 * DES加密
	 * 
	 * @param HexString
	 *            字符串（16位16进制字符串）
	 * @param keyStr
	 *            密钥16个1
	 * @throws Exception
	 */
	public static String ENCRYPTMethod(String HexString, String keyStr)
			throws Exception {
		String jmstr = "";
		try {
			byte[] theKey = null;
			//从给定的密钥中截取生成真正的密钥来源，保证加密解密算法的唯一性，避免数据的轻易可逆;
			String jqstr = getstrByte(keyStr).substring(0,8).toUpperCase();
			theKey = jqstr.getBytes(ENCODED_ASCII);
			//Ciper[名词]:零、暗号、密码本;
			//获取CIPHER_INSTANCE_CBC模式下的密码本;
			Cipher cipher = Cipher.getInstance(CIPHER_INSTANCE_CBC);
			//生成secrecKey;
			DESKeySpec desKeySpec = new DESKeySpec(theKey);
			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
			SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
			IvParameterSpec iv = new IvParameterSpec(theKey);
			cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
			byte[] theCph = cipher.doFinal(HexString.getBytes(ENCODED_GB2312));
			jmstr = toHexString(theCph).toUpperCase();
			jmstr = toHexString(theCph);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return jmstr;
	}
	
	public static String getstrByte(String str){
		if(null == str){
			throw new IllegalArgumentException(
			"str is null!");
		}
		MessageDigest messageDigest = getMessageDigest();
		byte[] digest;
		try {
			digest = messageDigest.digest(str.getBytes("ASCII"));
		} catch (UnsupportedEncodingException e) {
			throw new IllegalStateException("ASCII not supported!");
		}
		return new String(Hex.encodeHex(digest));
	}
	
	protected static final MessageDigest getMessageDigest() {
		String algorithm = "MD5";
		try {
			return MessageDigest.getInstance(algorithm);
		} catch (NoSuchAlgorithmException e) {
			throw new IllegalArgumentException("No such algorithm ["
					+ algorithm + "]");
		}
	}
	
	/**
	 * DES加密
	 * @param HexString 字符串（16位16进制字符串）
	 * @param keyStr 密钥16个1
	 * @param keyENCODED  Keybyte转换编码
	 * @param HexStringENCODED 要加密值的转换byte编码
	 * @param CipherInstanceType 需要加密类型
	 * @return
	 * @throws Exception
	 */
	public static String ENCRYPTMethod(String HexString, String keyStr,String keyENCODED,String HexStringENCODED,String CipherInstanceType)
			throws Exception {
		String jmstr = "";
		try {
			byte[] theKey = null;
			String jqstr = getstrByte(keyStr).substring(0,8).toUpperCase();
			theKey = jqstr.getBytes(keyENCODED);
			Cipher cipher = Cipher.getInstance(CipherInstanceType);
			DESKeySpec desKeySpec = new DESKeySpec(theKey);
			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
			SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
			IvParameterSpec iv = new IvParameterSpec(theKey);
			cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
			byte[] theCph = cipher.doFinal(HexString.getBytes(HexStringENCODED));
			jmstr = toHexString(theCph).toUpperCase();
			jmstr = toHexString(theCph);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return jmstr;
	}
	
	public static String toHexString(byte b[]) {
		StringBuffer hexString = new StringBuffer();
		for (int i = 0; i < b.length; i++) {
			String plainText = Integer.toHexString(0xff & b[i]);
			if (plainText.length() < 2)
				plainText = "0" + plainText;
			hexString.append(plainText);
		}
		return hexString.toString();
	}
	
	/**
	 * DES解密方法
	 * @param message 需要解密字符串
	 * @param key 解密需要的KEY
	 * @param keyENCODED  解密KEY转换编码
	 * @param HexStringENCODED  解密字符串转换编码
	 * @param CipherInstanceType 解密类型
	 * @return
	 * @throws Exception
	 */
	public static String decrypt(String message, String key,String keyENCODED,String HexStringENCODED,String CipherInstanceType) throws Exception {
		byte[] bytesrc = convertHexString(message);
		byte[] theKey = null;
		String jqstr = getstrByte(key).substring(0,
				8).toUpperCase();
		theKey = jqstr.getBytes(keyENCODED);
		Cipher cipher = Cipher.getInstance(CipherInstanceType);
		DESKeySpec desKeySpec = new DESKeySpec(theKey);
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
		SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
		IvParameterSpec iv = new IvParameterSpec(theKey);
		cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
		byte[] retByte = cipher.doFinal(bytesrc);
		return new String(retByte,HexStringENCODED);
	}
	
	/**
	 * DES解密方法,解密方法和加密方法应该是对称的;
	 * @param message
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static String decrypt(String message, String key) throws Exception {
       
		byte[] bytesrc = convertHexString(message);
		byte[] theKey = null;
		String jqstr = getstrByte(key).substring(0,
				8).toUpperCase();
		theKey = jqstr.getBytes(ENCODED_ASCII);
		Cipher cipher = Cipher.getInstance(CIPHER_INSTANCE_CBC);
		DESKeySpec desKeySpec = new DESKeySpec(theKey);
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
		SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
		IvParameterSpec iv = new IvParameterSpec(theKey);
		cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
		byte[] retByte = cipher.doFinal(bytesrc);
		return new String(retByte,ENCODED_GB2312);
	}
	public static byte[] convertHexString(String ss) {
		byte digest[] = new byte[ss.length() / 2];
		for (int i = 0; i < digest.length; i++) {
			String byteString = ss.substring(2 * i, 2 * i + 2);
			int byteValue = Integer.parseInt(byteString, 16);
			digest[i] = (byte) byteValue;
		}
		return digest;
	}
	
	public static void main(String[] args) throws Exception {
		String key = "27650099-564A-4869-99B3-363F8129C0CD";
		String value = "张三内部购房百分点办法对你表白";
		String jiami = value;
		System.out.println("加密数据:" + jiami);
		String a = ENCRYPTMethod(jiami, key).toUpperCase();
		System.out.println("加密后的数据为:" + a);
		String b = decrypt(a, key);
		System.out.println("解密后的数据:" + b);
	}
}

展开全文 >>

react结合d3.js和svg绘制条形统计图

最近学习了下D3.js并仿照别人的案例写了个小demo【参考文章》http://wiki.jikexueyuan.com/project/d3wiki/chart.html】，遇到了一些问题，在这里记录下:
1.遇到的一些坑:
(1.)D3.js中V3和V4的版本差别很大,所以一定要注意版本;
(2.)引用D3.js的js库文件的时候，应该通过npm安装库依赖，虽然D3.js不咋出名，但是npm还是可以安装它，安装命令是:
npm安装：npm install d3 前端导入：import * as d3 from 'd3';
(3.)react中css的解析和导入：
一：如果是通过create-react-app创建的项目，可以直接通过命令：

1
import './styles.css';

导入，可以参考蚂蚁金服的样式导入和操作；
二:非create-react-app项目，可以参考文章:
http://echizen.github.io/tech/2017/03-09-css-in-react
2.demo的源码：
animSVG.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import React, { Component } from 'react';
import * as SimulationData from './svgData';
import * as d3 from 'd3';
import './styles.css';
//需要注意的问题：v3和v4版本差别很大，需要高度注意;
class AnimSVG extends React.Component {
   
    render() {
        {/* 定义柱状图的颜色数组; */ }
        const colors = ["#39D1DE", "#1CDB62", "#1FE015", "#A7E51F", "#E3E312", "#EA6A1F", "#29A0E3"];
        {/* 画布大小 */ }
        var width = 400;
        var height = 400;
        {/* 在 body 里添加一个 SVG 画布 */ }
        var svg = d3.select("body")
            .append("svg")
            .attr("width", width)
            .attr("height", height);
        {/* 画布周边的空白 */ }
        var padding = { left: 30, right: 30, top: 20, bottom: 20 };
        {/* 定义一个数组 */ }
        var dataset = [10, 20, 30, 40, 33, 24, 12, 5];
        {/* x轴的比例尺 */ }
        var xScale = d3.scale.ordinal()
            .domain(d3.range(dataset.length))
            .rangeRoundBands([0, width - padding.left - padding.right]);
        {/* y轴的比例尺 */ }
        var yScale = d3.scale.linear()
            .domain([0, d3.max(dataset)])
            .range([height - padding.top - padding.bottom, 0]);
        {/* 定义x轴 */ }
        var xAxis = d3.svg.axis()
            .scale(xScale)
            .orient("bottom");
        {/* 定义y轴 */ }
        var yAxis = d3.svg.axis()
            .scale(yScale)
            .orient("left");
        {/* 矩形之间的空白间距的宽度; */ }
        var rectPadding = 4;
        //添加矩形元素
        var rects = svg.selectAll(".MyRect")
            .data(dataset)
            .enter()
            .append("rect")
            .attr("class", "MyRect")
            .attr("transform", "translate(" + padding.left + "," + padding.top + ")")
            .attr("x", function (d, i) {
                return xScale(i) + rectPadding / 2;
            })
            .attr("width", xScale.rangeBand() - rectPadding)
            .attr("y", function (d) {
                var min = yScale.domain()[0];
                return yScale(min);
            })
            .attr("height", function (d) {
                return 0;
            })
            .transition()
            .delay(function (d, i) {
                return i * 200;
            })
            .duration(2000)
            .ease("bounce")
            .style("fill", function (uselsssVO, index) {
                var currentColorIndex = index % (colors.length);
                return colors[currentColorIndex];
            })
            .attr("y", function (d) {
                return yScale(d);
            })
            .attr("height", function (d) {
                return height - padding.top - padding.bottom - yScale(d);
            });
        {/* 添加文字元素 */ }
        var texts = svg.selectAll(".MyText")
            .data(dataset)
            .enter()
            .append("text")
            .attr("class", "MyText")
            .attr("transform", "translate(" + padding.left + "," + padding.top + ")")
            .attr("x", function (d, i) {
                return xScale(i) + rectPadding / 2;
            })
            .attr("dx", function () {
                return (xScale.rangeBand() - rectPadding) / 2;
            })
            .attr("dy", function (d) {
                return 20;
            })
            .text(function (d) {
                return d;
            })
            .attr("y", function (d) {
                var min = yScale.domain()[0];
                return yScale(min);
            })
            .transition()
            .delay(function (d, i) {
                return i * 200;
            })
            .duration(2000)
            .ease("bounce")
            .attr("y", function (d) {
                return yScale(d);
            });
        {/* 添加x轴 */ }
        svg.append("g")
            .attr("class", "axis")
            .attr("transform", "translate(" + padding.left + "," + (height - padding.bottom) + ")")
            .call(xAxis); 
        {/* 添加y轴 */ }
        svg.append("g")
            .attr("class", "axis")
            .attr("transform", "translate(" + padding.left + "," + padding.top + ")")
            .call(yAxis);
        return (
            <svg xmlns="http://www.w3.org/2000/svg"></svg>
        );
    }
}
export default AnimSVG;

styles.css

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
.axis path,
.axis line {
    fill: none;
    stroke: black;
    shape-rendering: crispEdges;
}
.axis text {
    font-family: sans-serif;
    font-size: 11px;
}
.MyRect {
    fill: steelblue;
}
.MyText {
    fill: white;
    text-anchor: middle;
}

3.demo的效果:
这里写图片描述

展开全文 >>

POI实现excel的导入导出-[未采用反射实现的版本]

最近在做项目中遇到了使用POI导入导出excel的需求,所以在这里总结下，方便自己和朋友学习:
1.经典博客:
1.JavaWEB–POI之EXCEL操作、优化、封装详解系列（一）–概述与原理
2.公共POI导出Excel方法–java
3.Apache POI 实现对 Excel 文件读写
4.EasyPoi教程V1.0

2.原理:
原理如下图
这里写图片描述

3.代码:
POIController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package com.spring.boot.gp4zj.controller;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.spring.boot.gp4zj.service.POIService;
import cn.lz.cloud.common.service.ClazzNote;
import cn.lz.cloud.common.service.ServiceNote;
/**
 * 各种poi导入导出的请求控制模块;
 * 
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月16日@下午4:28:49
 */
@RestController
@RequestMapping("/poi")
@ClazzNote(desc = "excel文件", resource = "input", modName = "poi")
public class POIController {
	@Autowired
	private POIService poiService;
	// 获取考勤明细的excel文件;
	@RequestMapping("/getAttenceDetailExcel")
	@ServiceNote(desc = "获取考勤明细的excel", auth = ServiceNote.AUTH.CHECK)
	public void getAttenceDetailExcel(HttpServletResponse response) {
		poiService.getAttenceDetailExcel(response);
	}
	
	// 读取考勤明细的excel文件;
	@RequestMapping("/readAttenceDetailData")
	@ServiceNote(desc = "获取考勤明细的excel", auth = ServiceNote.AUTH.CHECK)
	public void readAttenceDetailData() {
		
	}
}

POIServiceImpl.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package com.spring.boot.gp4zj.service.impl;
import java.io.IOException;
import java.io.OutputStream;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.spring.boot.gp4zj.model.AttenceDetail;
import com.spring.boot.gp4zj.model.SimulationVO;
import com.spring.boot.gp4zj.service.AttenceDetailService;
import com.spring.boot.gp4zj.service.POIService;
import com.spring.boot.gp4zj.util.POIUtils;
import cn.lz.cloud.common.service.ResList;
/**
 * 获取excel的业务逻辑模块;
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月16日@下午4:47:09
 */
@Service
public class POIServiceImpl implements POIService {
	@Autowired
	private AttenceDetailService attenceDetailService;
	public void getAttenceDetailExcel(HttpServletResponse response) {
		// TODO Auto-generated method stub
		ResList<AttenceDetail>  list = attenceDetailService.selectAll(SimulationVO.getADSimulationVo());
		List<AttenceDetail> excelData = list.getList();
		HSSFWorkbook workbook = POIUtils.createExcel(excelData);
		OutputStream out = null;
		if (workbook != null) {
			try {
				String fileName = "Excel-" + String.valueOf(System.currentTimeMillis()).substring(4, 13) + ".xls";
				String headStr = "attachment; filename=\"" + fileName + "\"";
				response.setContentType("APPLICATION/OCTET-STREAM");
				response.setHeader("Content-Disposition", headStr);
				out = response.getOutputStream();
				workbook.write(out);
				out.flush();
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				try {
					out.flush();
					out.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
}

POIUtils.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
package com.spring.boot.gp4zj.util;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import com.spring.boot.gp4zj.model.AttenceDetail;
/**
 * Excel操作相关的工具类;
 * 
 * @author:JunZhou
 * @Company:LongZheng
 * @Email:1769676159@qq.com
 * @2018年1月16日@下午3:19:25
 */
public class POIUtils {
	public static void main(String[] args) {
		List<AttenceDetail> list = readExcel();
		/*for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i).toString());
		}*/
		System.out.println(list.get(0).toString());
	}
	/**
	 * 创建Excel
	 * 
	 * @param list
	 *            数据
	 */
	public static HSSFWorkbook createExcel(List<AttenceDetail> list) {
		// 创建一个Excel文件
		HSSFWorkbook workbook = new HSSFWorkbook();
		// 创建一个工作表
		HSSFSheet sheet = workbook.createSheet("考勤明细表");
		// 添加表头行
		HSSFRow hssfRow = sheet.createRow(0);
		// 设置单元格格式居中
		HSSFCellStyle cellStyle = workbook.createCellStyle();
		cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
		// 添加表头内容
		// -------第一行第0-2列---------
		HSSFCell headCell = hssfRow.createCell(0);
		headCell.setCellValue("考勤日期");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(1);
		headCell.setCellValue("考勤名称");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(2);
		headCell.setCellValue("员工编码");
		headCell.setCellStyle(cellStyle);
		// -----------------------
		headCell = hssfRow.createCell(3);
		headCell.setCellValue("出勤时长");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(4);
		headCell.setCellValue("加班时长");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(5);
		headCell.setCellValue("合计出勤时长");
		headCell.setCellStyle(cellStyle);
		// -----------------------
		headCell = hssfRow.createCell(6);
		headCell.setCellValue("报工单位");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(7);
		headCell.setCellValue("结算单位");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(8);
		headCell.setCellValue("创建人");
		headCell.setCellStyle(cellStyle);
		// -----------------------
		headCell = hssfRow.createCell(9);
		headCell.setCellValue("出勤人天");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(10);
		headCell.setCellValue("加班人天");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(11);
		headCell.setCellValue("合计人天");
		headCell.setCellStyle(cellStyle);
		// -----------------------
		headCell = hssfRow.createCell(12);
		headCell.setCellValue("是否删除汇总表");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(13);
		headCell.setCellValue("是否确认");
		headCell.setCellStyle(cellStyle);
		headCell = hssfRow.createCell(14);
		headCell.setCellValue("创建时间");
		headCell.setCellStyle(cellStyle);
		// -----------------------
		headCell = hssfRow.createCell(15);
		headCell.setCellValue("修改时间");
		headCell.setCellStyle(cellStyle);
		// 添加数据内容
		for (int i = 0; i < list.size(); i++) {
			hssfRow = sheet.createRow((int) i + 1);
			AttenceDetail attenceDetail = list.get(i);
			// 创建单元格，并设置值
			
			HSSFCell cell = hssfRow.createCell(0);
			cell.setCellValue(attenceDetail.getAttencedTime());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(1);
			cell.setCellValue(attenceDetail.getAttencerName());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(2);
			cell.setCellValue(attenceDetail.getAttencerCode());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(3);
			cell.setCellValue(attenceDetail.getWorkTimeLen());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(4);
			cell.setCellValue(attenceDetail.getExtraTimeLen());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(5);
			cell.setCellValue(attenceDetail.getTotalTimeLen());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(6);
			cell.setCellValue(attenceDetail.getApplyCompany());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(7);
			cell.setCellValue(attenceDetail.getPayCompany());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(8);
			cell.setCellValue(attenceDetail.getCreator());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(9);
			cell.setCellValue(attenceDetail.getWorkDayNum());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(10);
			cell.setCellValue(attenceDetail.getExtraDayNum());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(11);
			cell.setCellValue(attenceDetail.getTotalDayNum());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(12);
			cell.setCellValue(attenceDetail.getIsDelGather());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(13);
			cell.setCellValue(attenceDetail.getIsConfirmed());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(14);
			cell.setCellValue(attenceDetail.getCreateTime());
			cell.setCellStyle(cellStyle);
			cell = hssfRow.createCell(15);
			cell.setCellValue(attenceDetail.getEditTime());
			cell.setCellStyle(cellStyle);
		}
		/*// 保存Excel文件
		try {
			OutputStream outputStream = new FileOutputStream("D:/students.xls");
			workbook.write(outputStream);
			outputStream.close();
		} catch (Exception e) {
			e.printStackTrace();
		}*/
		return workbook;
	}
	
	/**
	 * 接收上传的excel并读取其中的信息;
	 */
	public static List<AttenceDetail> readExcel(){
        List<AttenceDetail> list = new ArrayList<AttenceDetail>();
        HSSFWorkbook workbook = null;
        try {
            // 读取Excel文件
            InputStream inputStream = new FileInputStream("D:/Excel-095968073.xls");
            workbook = new HSSFWorkbook(inputStream);
            inputStream.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 循环工作表
        for (int numSheet = 0; numSheet < workbook.getNumberOfSheets(); numSheet++) {
            HSSFSheet hssfSheet = workbook.getSheetAt(numSheet);
            if (hssfSheet == null) {
                continue;
            }
            // 循环行
            for (int rowNum = 1; rowNum <= hssfSheet.getLastRowNum(); rowNum++) {
                HSSFRow hssfRow = hssfSheet.getRow(rowNum);
                if (hssfRow == null) {
                    continue;
                }
                // 将单元格中的内容存入集合
                AttenceDetail attenceDetail = new AttenceDetail();
                HSSFCell cell = hssfRow.getCell(0);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setAttencedTime(cell.getStringCellValue());
                cell = hssfRow.getCell(1);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setAttencerName(cell.getStringCellValue());
                cell = hssfRow.getCell(2);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setAttencerCode(cell.getStringCellValue());
                //-------------------------------
                cell = hssfRow.getCell(3);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setWorkTimeLen(cell.getStringCellValue());
                
                cell = hssfRow.getCell(4);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setExtraTimeLen(cell.getStringCellValue());
                
                cell = hssfRow.getCell(5);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setTotalTimeLen(cell.getStringCellValue());
                
              //-------------------------------
                cell = hssfRow.getCell(6);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setApplyCompany(cell.getStringCellValue());
                
                cell = hssfRow.getCell(7);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setPayCompany(cell.getStringCellValue());
                
              //-------------------------------
                cell = hssfRow.getCell(8);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setCreator(cell.getStringCellValue());
               
                cell = hssfRow.getCell(9);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setWorkDayNum(cell.getStringCellValue());
                
                cell = hssfRow.getCell(10);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setExtraDayNum(cell.getStringCellValue());
              
                //-------------------------------
                cell = hssfRow.getCell(11);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setTotalDayNum(cell.getStringCellValue());
                
                cell = hssfRow.getCell(12);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setIsDelGather(cell.getStringCellValue());
                
                cell = hssfRow.getCell(13);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setIsConfirmed(cell.getStringCellValue());
                
                cell = hssfRow.getCell(14);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setCreateTime(cell.getStringCellValue());
              //-------------------------------
                cell = hssfRow.getCell(15);
                if (cell == null) {
                    continue;
                }
                attenceDetail.setEditTime(cell.getStringCellValue());
                list.add(attenceDetail);
            }
        }
        return list;
	}
}

这部份的代码由于没有采用反射实现，效率较高，但是代码冗余和灵活性不高，所以接下来将采用反射实现.。

展开全文 >>

Nginx实现文件下载限速的功能

同一时刻对服务器上文件的大量的高速访问，可能会极大的增加服务器的负担，为了缓解服务器的I/O负担，如果配置了nginx服务器，建议进行限速，具体实现如下:

首先在 http 段配置一个 limit_zone，然后在需要的地方使用 limit_conn 和 limit_rate 进行限速设置,如下一个简单的例子。

1
2
3
4
5
6
7
8
9
10
http {
  limit_zone one $binary_remote_addr 10m;
  server {
    location /files/ {
      limit_conn one 1;
      limit_rate_after 1000k;
      limit_rate 100k;
    }
  }
}

limit_zone，是针对每个IP定义一个存储session状态的容器。这个示例中定义了一个名叫one的10m大小的容器，这个名字会在后面的limit_conn中使用。
limit_conn one 1，限制在one中记录状态的每个IP只能发起一个并发连接。
limit_rate_after 1000k，在下载1000k后开始限速。
limit_rate 100k，对每个连接限速100k. 注意，这里是对连接限速，而不是对IP限速。如果一个IP允许三个并发连接，那么这个IP就是限速为limit_rate×3，在设置的时候要根据自己的需要做设置调整，要不然会达不到自己希望的目的。

展开全文 >>

幂等性[或者http幂等性]的理解


怎么理解幂等性


理解要点

幂等性是系统的接口对外一种承诺(而不是实现), 承诺只要调用接口成功,

外部多次调用对系统的影响是一致的

. 声明为幂等的接口会认为外部调用失败是常态, 并且

失败之后必然会有重试.

声明为幂等性的API，多次调用后对调用资源产生影响或作用结果和一次调用产生的结果是相同的，幂等性API强调安全，不会因为多次的重复调用对系统资源产生错误的操作，正在金融业务中尤为重要。

HTTP幂等方法，是指无论调用多少次都不会有不同结果的 HTTP 方法。不管你调用一次，还是调用一百次，一千次，结果都是相同的。


还是以之前的博文的例子为例。


  1. GET     /tickets       # 获取ticket列表
  2. GET     /tickets/12    # 查看某个具体的ticket
  3. POST    /tickets       # 新建一个ticket
  4. PUT     /tickets/12    # 更新ticket 12
  5. PATCH   /tickets/12    # 更新ticket 12
  6. DELETE  /tickets/12    # 删除ticekt 12


HTTP GET方法

HTTP GET方法，用于获取资源，不管调用多少次接口，结果都不会改变，所以是幂等的。


  1. GET     /tickets       # 获取ticket列表
  2. GET     /tickets/12    # 查看某个具体的ticket


只是查询数据，不会影响到资源的变化，因此我们认为它幂等。


值得注意，幂等性指的是作用于结果而非资源本身。怎么理解呢？例如，这个HTTP GET方法可能会每次得到不同的返回内容，但并不影响资源。


可能你会问有这种情况么？当然有咯。例如，我们有一个接口获取当前时间，我们就应该设计成


  1. GET     /service_time # 获取服务器当前时间


它本身不会对资源本身产生影响，因此满足幂等性。


HTTP POST方法

HTTP POST方法是一个非幂等方法，因为调用多次，都将产生新的资源。


  1. POST    /tickets       # 新建一个ticket


因为它会对资源本身产生影响，每次调用都会有新的资源产生，因此不满足幂等性。


HTTP PUT方法

HTTP PUT方法是不是幂等的呢？我们来看下


  1. PUT     /tickets/12    # 更新ticket 12


因为它直接把实体部分的数据替换到服务器的资源，我们多次调用它，只会产生一次影响，但是有相同结果的 HTTP 方法，所以满足幂等性。


HTTP PATCH方法

HTTP PATCH方法是非幂等的。HTTP POST方法和HTTP PUT方法可能比较好理解，但是HTTP PATCH方法只是更新部分资源，怎么是非幂等的呢?


因为，PATCH提供的实体则需要根据程序或其它协议的定义，解析后在服务器上执行，以此来修改服务器上的资源。换句话说，PATCH请求是会执行某个程序的，如果重复提交，程序可能执行多次，对服务器上的资源就可能造成额外的影响，这就可以解释它为什么是非幂等的了。


可能你还不能理解这点。我们举个例子


  1. PATCH   /tickets/12    # 更新ticket 12


此时，我们服务端对方法的处理是，当调用一次方法，更新部分字段，将这条ticket记录的操作记录加一，这次，每次调用的资源是不是变了呢，所以它是有可能是非幂等的操作。


HTTP DELETE方法

HTTP DELETE方法用于删除资源，会将资源删除。


  1. DELETE  /tickets/12    # 删除ticekt 12


调用一次和多次对资源产生影响是相同的，所以也满足幂等性。


如何设计符合幂等性的高质量RESTful API

HTTP GET方法 vs HTTP POST方法

也许，你会想起一个面试题。HTTP请求的GET与POST方式有什么区别？你可能会回答到：GET方式通过URL提交数据，数据在URL中可以看到；POST方式，数据放置在HTML HEADER内提交。但是，我们现在从RESTful的资源角度来看待问题，HTTP GET方法是幂等的，所以它适合作为查询操作，HTTP POST方法是非幂等的，所以用来表示新增操作。


但是，也有例外，我们有的时候可能需要把查询方法改造成HTTP POST方法。比如，超长（1k）的GET URL使用POST方法来替代，因为GET受到URL长度的限制。虽然，它不符合幂等性，但是它是一种折中的方案。


HTTP POST方法 vs HTTP PUT方法

对于HTTP POST方法和TTP PUT方法，我们一般的理解是POST表示创建资源，PUT表示更新资源。当然，这个是正确的理解。


但是，实际上，两个方法都用于创建资源，更为本质的差别是在幂等性。HTTP POST方法是非幂等，所以用来表示创建资源，HTTP PUT方法是幂等的，因此表示更新资源更加贴切。


HTTP PUT方法 vs HTTP PATCH方法

此时，你看会有另外一个问题。HTTP PUT方法和HTTP PATCH方法，都是用来表述更新资源，它们之间有什么区别呢？我们一般的理解是PUT表示更新全部资源，PATCH表示更新部分资源。首先，这个是我们遵守的第一准则。根据上面的描述，PATCH方法是非幂等的，因此我们在设计我们服务端的RESTful API的时候，也需要考虑。如果，我们想要明确的告诉调用者我们的资源是幂等的，我的设计更倾向于使用 HTTP PUT 方法。

    (完)
=

展开全文 >>

学习reflux的总结

最近学习reflux,总结一下，方便以后回顾.
参考资料,我觉得这个是极品，但是demo无法正常运行.
1.reflux的原理:
1.1reflux是对flux架构的实现[flux相当于java中的架构/思想]；
1.2reflux中的数据流是单向的;
2.reflux和flux的重点区别:
2.1flux中的action是一个标准的信息载体【dataer】，并不具备publisher的功能；
2.2flux中的action是一个publisher，并具备信息载体的功能;
2.3reflux中的action被发送出去之后，只有订阅【监听了】了action的store中的回调函数才会被调用；
2.4flux中档action被发送后，所有注册在dispatcher上的回调函数都将被触发、调用我们通过action中type进行switch后才能进行指定的操作，执行效率较低;
3.reflux的demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
action【action.js】
action中定义了组件的行，同时reflux中的action作为publisher存在，当action被触发【执行：action.actionName();】时将自动转发action[一般携带着数据]到订阅了[监听]该action的store中，该store中的onActionName()回调函数将会被调用;
----------
var Reflux = require('reflux');
var WorkLogActions = Reflux.createActions([
	'createHrWorkLog',
	'deleteHrWorkLog',
	'updateHrWorkLog',
	'retrieveHrWorkLog',
	'retrieveHrWorkLogPage',
	'initHrWorkLog',
	'retrieveEmpWorkLog',
	'retrieveEmpLoyee',
	'getCacheData'
]);
module.exports = WorkLogActions;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
store【WorkLogStore.js】
reflux中store作为publisher和subscriber存在，当接收到action后，将执行对应的onActionName()回调函数，并执行
this.fireEvent('retrieve', '', this);
或者storeA.trigger(3)发送事件和数据。当组件监听到后将执行监听回调函数，更新state从而驱动UI的更新;
----------
var Reflux = require('reflux');
var WorkLogActions = require('../action/WorkLogActions');
var Utils = require('../../../public/script/utils');
var MsgActions = require('../../../lib/action/MsgActions');
var WorkLogStore = Reflux.createStore({
	listenables: [WorkLogActions],
	filter: {},
	recordSet: [],
	startPage : 0,
	pageRow : 0,
	totalRow : 0,
	init: function() {
	},
	getServiceUrl: function(action)
	{
		return Utils.hrUrl+action;
	},
	fireEvent: function(operation, errMsg, self)
	{
		self.trigger({
			filter: self.filter,
			recordSet: self.recordSet,
			startPage: self.startPage,
			pageRow: self.pageRow,
			totalRow: self.totalRow,
			operation: operation,
			errMsg: errMsg
		});
		MsgActions.showError('hr_work_log', operation, errMsg);
	},
	onGetCacheData: function() {
		this.fireEvent('cache', '', this);
	},
	onRetrieveHrWorkLog: function(filter) {
		var self = this;
		var url = this.getServiceUrl('hr_work_log/retrieve');
		Utils.doRetrieveService(url, filter, self.startPage, self.pageRow, self.totalRow).then(function(result) {
			if(result.errCode==null || result.errCode=='' || result.errCode=='000000'){
				self.recordSet = result.object.list;
				self.startPage = result.object.startPage;
				self.pageRow = result.object.pageRow;
				self.totalRow = result.object.totalRow;
				self.filter = filter;
				self.fireEvent('retrieve', '', self);
			}
			else{
				self.fireEvent('retrieve', "处理错误["+result.errCode+"]["+result.errDesc+"]", self);
			}
		}, function(value){
			self.fireEvent('retrieve', "调用服务错误", self);
		});
	},
	onRetrieveHrWorkLogPage: function(filter, startPage, pageRow) {
		this.startPage = startPage;
		this.pageRow = pageRow;
		this.onRetrieveHrWorkLog( filter );
	},
	onInitHrWorkLog: function(filter) {
		if( this.recordSet.length > 0 ){
			if( Utils.compareTo(this.filter, filter) ){
				this.fireEvent('retrieve', '', this);
				return;
			}
		}
		this.onRetrieveHrWorkLog(filter);
	},
	onCreateHrWorkLog: function(workLog) {
		var self = this;
		var data = workLog;
		var url = this.getServiceUrl('hr_work_log/create');
		Utils.doCreateService(url, data).then(function(result) {
			if(result.errCode==null || result.errCode=='' || result.errCode=='000000'){
				result.object.perName = data.perName;
				result.object.staffCode = data.staffCode;
				result.object.deptName = data.deptName;
				self.recordSet.push(result.object);
				self.totalRow = self.totalRow + 1;
				self.fireEvent('create', '', self);
			}
			else{
				self.fireEvent('create', "处理错误["+result.errCode+"]["+result.errDesc+"]", self);
			}
		}, function(value){
			self.fireEvent('create', "调用服务错误", self);
		});
	},
	onUpdateHrWorkLog: function(workLog) {
		var url = this.getServiceUrl('hr_work_log/update');
		Utils.recordUpdate(this, workLog, url);
	},
	onDeleteHrWorkLog: function(uuid) {
		var url = this.getServiceUrl('hr_work_log/remove');
		Utils.recordDelete(this, uuid, url);
	}
});
module.exports = WorkLogStore;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
component【WorkLogPage.js】
component中监听store中发送的事件并更新state，驱动UI的更新
----------
'use strict';
import React from 'react';
import ReactDOM from 'react-dom';
import ReactMixin from 'react-mixin';
var Reflux = require('reflux');
import { Button, Table, Icon, Modal, Input } from 'antd';
const Search = Input.Search;
import ServiceMsg from '../../lib/Components/ServiceMsg';
import DimissTodoPage from './Components/DimissTodoPage';
var Common = require('../../public/script/common');
var Utils = require('../../public/script/utils');
var WorkLogStore = require('./data/WorkLogStore.js');
var WorkLogActions = require('./action/WorkLogActions');
import WorkLogFilter from './Components/WorkLogFilter';
import CreateWorkLogPage from './Components/CreateWorkLogPage';
import UpdateWorkLogPage from './Components/UpdateWorkLogPage';
import DetailsWorkLogPage from './Components/DetailsWorkLogPage';
var pageRows = 10;
var WorkLogPage = React.createClass({
    getInitialState: function () {
        return {
            workLogSet: {
                recordSet: [],
                startPage: 1,
                pageRow: 10,
                totalRow: 0,
                operation: '',
                errMsg: ''
            },
            action: 'query',
            workLog: null,
            loading: false,
            moreFilter: false,
            filterValue: '',
            filter: {},
        }
    },
    mixins: [Reflux.listenTo(WorkLogStore, "onServiceComplete")],
    onServiceComplete: function (data) {
        if (data.operation === 'cache') {
            var ff = data.filter.staffCode;
            if (ff === null || typeof (ff) === 'undefined' || ff === '') {
                ff = data.filter.perName;
                if (ff === null || typeof (ff) === 'undefined') {
                    ff = '';
                }
            }
            this.state.filterValue = ff;
            this.state.filter = data.filter;
            this.state.moreFilter = (data.filter.more === '1');
            if (this.state.moreFilter) {
                var mp = this.refs.WorkLogFilter;
                if (mp !== null && typeof (mp) !== 'undefined') {
                    mp.state.workLog = this.state.filter;
                }
            }
        }
        this.setState({
            loading: false,
            workLogSet: data
        });
    },
    // 第一次加载
    componentDidMount: function () {
        WorkLogActions.getCacheData();
    },
    handleQueryClick: function () {
        this.setState({ loading: true });
        this.state.filter.status = '1';
        this.state.filter.corpUuid = window.loginData.compUser.corpUuid;
        this.state.filter.more = (this.state.moreFilter ? '1' : '0');
        WorkLogActions.retrieveHrWorkLogPage(this.state.filter, this.state.workLogSet.startPage, pageRows);
    },
    showMoreFilter: function (event) {
        this.setState({ moreFilter: !this.state.moreFilter });
    },
    onChangePage: function (pageNumber) {
        this.state.workLogSet.startPage = pageNumber;
        this.handleQueryClick();
    },
    onShowSizeChange: function (current, pageSize) {
        pageRows = pageSize;
        this.handleQueryClick();
    },
    onChangeFilter: function (e) {
        this.setState({ filterValue: e.target.value });
    },
    onSearch: function (e) {
        this.state.filter = {};
        var filterValue = this.state.filterValue;
        if (Common.isIncNumber(filterValue)) {
            this.state.filter.staffCode = filterValue;
        }
        else {
            this.state.filter.perName = filterValue;
        }
        this.handleQueryClick();
    },
    onMoreSearch: function () {
        this.state.filter = this.refs.WorkLogFilter.state.workLog;
        this.handleQueryClick();
    },
    onClickDelete: function (workLog, event) {
        Modal.confirm({
            title: '删除确认',
            content: '是否删除选中的工作日志',
            okText: '确定',
            cancelText: '取消',
            onOk: this.onClickDelete2.bind(this, workLog)
        });
    },
    onClickDelete2: function (workLog) {
        this.setState({ loading: true });
        this.state.workLogSet.operation = '';
        WorkLogActions.deleteHrWorkLog(workLog.uuid);
    },
    handleCreate: function (e) {
        this.setState({ action: 'create' });
    },
    onClickDetails: function (workLog, event) {
        this.setState({ workLog: workLog, action: 'detail' });
    },
    onClickUpdate: function (workLog, event) {
        this.setState({ workLog: workLog, action: 'update' });
    },
    onGoBack: function (workLog) {
        this.setState({ action: 'query' });
        // 离职后处理
        if (workLog) {
            var chgType = workLog.chgType;
            if (chgType === '离职' || chgType === '辞退' || chgType === '开除') {
                this.refs.nextWindow.toggle();
                this.refs.nextWindow.initStaff(workLog);
            }
        }
    },
    render: function () {
        const columns = [
            {
                title: '员工编号',
                dataIndex: 'staffCode',
                key: 'staffCode',
                width: 140,
            },
            {
                title: '姓名',
                dataIndex: 'perName',
                key: 'perName',
                width: 140,
            },
            {
                title: '变更类型',
                dataIndex: 'chgType',
                key: 'chgType',
                width: 140,
                render: (text, record) => (Utils.getOptionName('HR系统', '工作变更类型', record.chgType, false, this)),
            },
            {
                title: '部门名称',
                dataIndex: 'deptName',
                key: 'deptName',
                width: 140,
            },
            {
                title: '调前说明',
                dataIndex: 'befMemo',
                key: 'befMemo',
                width: 140,
            },
            {
                title: '调后说明',
                dataIndex: 'aftMemo',
                key: 'aftMemo',
                width: 140,
            },
            {
                title: '生效日期',
                dataIndex: 'effectDate',
                key: 'effectDate',
                width: 140,
                render: (text, record) => (Common.formatDate(text, Common.dateFormat)),
            },
            {
                title: '更多操作',
                key: 'action',
                width: 70,
                render: (text, record) => (
                    <span>
                        <a href="#" onClick={this.onClickDetails.bind(this, record)} title='详情'><Icon type='bars' /></a>
                    </span>
                ),
            }
        ];
        /*
                        <a href="#" onClick={this.onClickUpdate.bind(this, record)} title='修改工作'><Icon type={Common.iconUpdate} /></a>
                        <span className="ant-divider" />
                    <a href="#" onClick={this.onClickDelete.bind(this, record)} title='删除工作'><Icon type={Common.iconRemove}/></a>
                    <span className="ant-divider" />
        */
        var recordSet = this.state.workLogSet.recordSet;
        var moreFilter = this.state.moreFilter;
        var visible = (this.state.action === 'query') ? '' : 'none';
        var pag = {
            showQuickJumper: true, total: this.state.workLogSet.totalRow, pageSize: this.state.workLogSet.pageRow,
            current: this.state.workLogSet.startPage, size: 'large', showSizeChanger: true, onShowSizeChange: this.onShowSizeChange, onChange: this.onChangePage
        };
        var contactTable =
            <div className='grid-page' style={{ overflow: 'hidden', display: visible }}>
                <div style={{ padding: '8px 0 0 0', height: '100%', width: '100%', overflowY: 'auto' }}>
                    <ServiceMsg ref='mxgBox' svcList={['hr_work_log/retrieve', 'hr_work_log/remove']} />
                    <WorkLogFilter ref="WorkLogFilter" moreFilter={moreFilter} />
                    <div style={{ margin: '8px 0 0 0' }}>
                        <div className='toolbar-table'>
                            <div style={{ float: 'left' }}>
                                <Button icon={Common.iconAdd} type="primary" title="增加工作变更信息" onClick={this.handleCreate} />
                                <Button icon={Common.iconRefresh} title="刷新数据" onClick={this.handleQueryClick} style={{ marginLeft: '4px' }} />
                            </div>
                            {
                                moreFilter ?
                                    <div style={{ textAlign: 'right', width: '100%' }}>
                                        <Button title="查询" onClick={this.onMoreSearch} loading={this.state.loading} style={{ marginRight: '5px' }}>查询</Button>
                                        <Button title="快速条件" onClick={this.showMoreFilter}>快速条件</Button>
                                    </div> :
                                    <div style={{ textAlign: 'right', width: '100%' }}>
                                        <Search placeholder="查询(员工编号/员工姓名)" style={{ width: Common.searchWidth }} value={this.state.filterValue} onChange={this.onChangeFilter} onSearch={this.onSearch} />
                                        <Button title="更多条件" onClick={this.showMoreFilter} style={{ marginLeft: '8px' }}>更多条件</Button>
                                    </div>
                            }
                        </div>
                    </div>
                    <div style={{ width: '100%', padding: '0 18px 8px 20px' }}>
                        <Table columns={columns} dataSource={recordSet} rowKey={record => record.uuid} loading={this.state.loading} pagination={pag} size="middle" bordered={Common.tableBorder} />
                    </div>
                </div>
            </div>;
        var page = null;
        if (this.state.action === 'create') {
            page = <CreateWorkLogPage ref='createPage' onBack={this.onGoBack} />;
        }
        else if (this.state.action === 'detail') {
            page = <DetailsWorkLogPage onBack={this.onGoBack} userUuid={this.state.workLog.userUuid} />
        }
        else if (this.state.action === 'update') {
            page = <UpdateWorkLogPage onBack={this.onGoBack} workLog={this.state.workLog} />
        }
        return (
            <div style={{ width: '100%', height: '100%' }}>
                {contactTable}
                {page}
                <DimissTodoPage ref="nextWindow" />
            </div>
        );
    }
});
module.exports = WorkLogPage;

展开全文 >>

create-reate-app项目中proxy代理的配置

最近在写react项目遇到了前后端交互跨域的问题，好在使用create-react-app这个脚手架【脚手架是什么？联想的建房子的时候搭建的脚手架的功能，构建一个房子的基本骨架，后续的搭建只要在这个架子下进行就好了，所以这里的脚手架的功能和现实中的类似:可以理解为脚手架是一个工具，它可以帮我们构建一个版本号为0的项目版本，这个版本中已经包含了项目开发的必要排至和结构分配，可以大大方便我们的开发】中已经包含了代理功能，
我们只要在package.json文件中添加如下配置就好了:
这里写图片描述

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
{
  "name": "myproject1",
  "version": "0.1.0",
  "private": true,
  "proxy": "http://localhost:9090",
  "dependencies": {
    "antd": "^3.0.3",
    "fetch": "^1.1.0",
    "flux": "^3.1.3",
    "react": "^15.4.1",
    "react-addons-css-transition-group": "^15.6.2",
    "react-dom": "^15.4.1",
    "react-router": "^3.0.0",
    "react-scripts": "1.0.17"
  },
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test --env=jsdom",
    "eject": "react-scripts eject"
  },
  "devDependencies": {
    "reqwest": "^2.0.5"
  }
}

调用的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import React from 'react';
import {Row, Col, BackTop} from 'antd';
class PCNewsDetails extends React.Component {
	constructor() {
		super();
		this.state = {
			newsItem:[
        {
          "uuid": "",
          "code": "",
          "age": 21,
          "className": "",
          "name": "",
          "major": "",
          "createTime": "",
          "editeTime":""
        }
      ]
		};
	};
	componentDidMount() {
    //this.setState({newsItem: json.object.list})
      var filter={
            object:{
              object:{
                'uuid':'11BG13AT4J4M4001'
              }
            }
          };
            var myFetchOptions = {
                       method: 'POST',
                       headers:{
                      'Content-Type':'application/json'
                      },
                      body:JSON.stringify(filter) };
        fetch("/mongo/student/selectByCondition", myFetchOptions).then(response => response.json()).then(json=>this.setState({newsItem: json.object.list}));
  };
	render() {
		return (
			<div>
				{console.log(this.state.newsItem[0].name)}
        网络请求测试.
			</div>
		);
	};
}
export default PCNewsDetails;

浅显的原理:
当浏览器检测到前端页面中发出的请求并非同域请求时，会自动请求proxy配置中的url,从而发送请求。

需要留意的坑:
注意在更改了配置文件后重启项目，因为热更新并不会更新对项目中配置文件的更改，如果不重启的话，package.json文件中的更改可能无法生效，将会报40错误.

展开全文 >>

react中router底层原理结合参考资料的分析

本文为我对react中router底层原理结合参考资料的分析:
1.路由是什么
个人理解:路由是访问各个组件的转发器;
路由的分类：路由分为一级路由和嵌套路由了;
路由的实现原理:
由UI = reducer(stateorproperty);可知，路由的底层原理还是状态或者属性改变驱动的；
可以理解为路由有一个location属性，通过浏览器可以改变Router的属性值，从而驱动属性进行渲染:
3.使用路由进行页面跳转会导致渲染效率的降低么?
答案是不会的，当通过嵌套路由首次 访问嵌套的组件的时候，被嵌套的子组件的父级组件也会进行加载渲染，此时父子组件的生命周期函数将被执行，但是首次访问但并未离开当前页面【顶级路由路径未改变的时候】，访问嵌套的其他组件的时候，会根据访问的路径加载指定的组件，此只会加载路径中体现变更部分的组件。
如下图所示:
1.首次访问的时候，路径匹配的组件的生命周期函数都将被执行[注意访问的路径是嵌套路由的路径]:
这里写图片描述
2.再次访问的时候，只会加载调用匹配路径中发生改变的部分的组件的生命周期函数:
这里写图片描述
3.（1.0）路由实际是一个组件，其中嵌套了所有的希望访问的可以访问的组件；
（2.0）通过路由访问的知识路径匹配的组件;
(3.0)当存在页面内无刷新内容变换的时候建议使用嵌套路由
4.路由使用的小案例:

root.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import React from 'react';
import ReactDOM from 'react-dom';
import Index from './index';
import ComponentList from './components/list';
import ComponentDetails from './components/details';
import ComponentDetails2 from './components/details2';
import {Router,Route,hashHistory} from 'react-router';
export default class Root extends React.Component{
  render(){
    return (
      //这里替换了之前的 Index，变成了程序的入口
      <Router history={hashHistory}>
        <Route component={Index} path="/">
          <Route component={ComponentDetails} path="details"></Route>
          <Route component={ComponentDetails2} path="details2"></Route>
        </Route>
        <Route component={ComponentList} path="list/:id"></Route>
      </Router>
    );
  };
}
ReactDOM.render(<Root/>, document.getElementById('example'));

index.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
var React = require('react');
var ReactDOM = require('react-dom');
import ComponentHeader from './components/header';
import ComponentFooter from './components/footer';
import BodyIndex from './components/bodyindex';
import 'antd/dist/antd.css';
export default class Index extends React.Component {
	constructor(props) {
 	 super(props);
 	 alert('父级组件中的构造函数被执行');
  }
	componentWillMount(){
		//定义你的逻辑即可
		alert('父级组件中的构造函数被执行');
		console.log("Index - componentWillMount");
	}
	componentDidMount(){
		console.log("Index - componentDidMount");
	}
	render() {
		/*
		var component;
		if (用户已登录) {
			component = <ComponentLoginedHeader/>
		}
		else{
			component = <ComponentHeader/>
		}
		*/
		return (
			<div>
				<ComponentHeader/>
				<BodyIndex userid={999} username={"Parry1"}/>
				<div>
					{this.props.children}
				</div>
				<ComponentFooter/>
			</div>
		);
	}
}

detail.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import React from 'react';
export default class ComponentDetails extends React.Component{
  constructor(props) {
    super(props);
    alert('子级组件中的构造函数被执行');
  }
  componentWillMount(){
    //定义你的逻辑即可
    alert('子级组件中的构造函数被执行');
    console.log("ComponentDetails - componentWillMount");
  }
  render(){
    return (
      <div>
        <h2>这里是嵌套在首页中的详细的页面，测试构造函数是否会被加载</h2>
      </div>
    );
  };
}

detail2.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import React from 'react';
export default class ComponentDetails extends React.Component{
  constructor(props) {
    super(props);
    alert('子级组件2中的构造函数被执行');
  }
  componentWillMount(){
    //定义你的逻辑即可
    alert('子级组件2中的构造函数被执行');
    console.log("ComponentDetails - componentWillMount");
  }
  render(){
    return (
      <div>
        <h2>这里是嵌套在首页中的详细的页面2，测试构造函数是否会被加载</h2>
      </div>
    );
  };
}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

最痛苦的事，<br><br>不是失败，<br><br>而是,我本可以!