Mysql实用示例：

返回id集合的字符串，用逗号隔开：id1,id2,id3,...,idn

1

SELECT GROUP_CONCAT(id) FROM t1

注意：长度超过1024时，会被截断

查询某个字段出现N次的数据

1
2
3
4
5

SELECT 
uid,COUNT(uid) AS num 
FROM gzszf_meeting_notice_org_staff 
WHERE meetingId='318' AND isDelet=0 
GROUP BY uid HAVING num>N

批量插入

1. 数据量大的时候，先忽略掉索引，结束后再恢复，可以提高速度

   1 2	SHOW VARIABLES LIKE 'log_bin_trust_function_creators'; SET GLOBAL log_bin_trust_function_creators=1;

背景介绍

React 只是 DOM 的一个抽象层，并不是 Web 应用的完整解决方案。有两个方面，它没涉及。

• 代码结构

• 组件之间的通信

对于大型的复杂应用来说，这两方面恰恰是最关键的。因此，只用 React 没法写大型应用。

你可能不需要Redux

首先明确一点，Redux 是一个有用的架构，但不是非用不可。事实上，大多数情况，你可以不用它，只用 React 就够了。

简单说，如果你的UI层非常简单，没有很多互动，Redux 就是不必要的，用了反而增加复杂性。

• 用户的使用方式非常简单

• 用户之间没有协作

• 不需要与服务器大量交互，也没有使用 WebSocket

• 视图层（View）只从单一来源获取数据

• [ ] 上面这些情况，都不需要使用 Redux。

Redux 的适用场景：多交互、多数据源。

• 用户的使用方式复杂
• 不同身份的用户有不同的使用方式（比如普通用户和管理员）
• 多个用户之间可以协作
• 与服务器大量交互，或者使用了WebSocket
• View要从多个来源获取数据

从组件角度看，如果你的应用有以下场景，可以考虑使用 Redux。

• 某个组件的状态，需要共享
• 某个状态需要在任何地方都可以拿到
• 一个组件需要改变全局状态
• 一个组件需要改变另一个组件的状态

chunkFilename

chunkFilename和webpack.optimize.CommonsChunkPlugin插件的作用差不多，都是用来将公共模块提取出来，但是用法不一样，这里主要介绍chunkFilename的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

entry:{
    main:__dirname + '/app/main.js',
    index:__dirname + '/app/index.js'      
},
output:{
    path:__dirname + '/public', //通过HtmlWebpackPlugin插件生成的html文件存放在这个目录下面
    filename:'/js/[name].js', //编译生成的js文件存放到根目录下面的js目录下面,如果js目录不存在则自动创建
    /*
     * chunkFilename用来打包require.ensure方法中引入的模块,如果该方法中没有引入任何模块则不会生成任何chunk块文件
     * 比如在main.js文件中,require.ensure([],function(require){alert(11);}),这样不会打包块文件
     * 只有这样才会打包生成块文件require.ensure([],function(require){alert(11);require('./greeter')})
     * 或者这样require.ensure(['./greeter'],function(require){alert(11);})
     * chunk的hash值只有在require.ensure中引入的模块发生变化,hash值才会改变
     * 注意:对于不是在ensure方法中引入的模块,此属性不会生效,只能用CommonsChunkPlugin插件来提取
     * */
    chunkFilename:'js/[chunkhash:8].chunk.js'
},

如果开了web-dev-server服务器，当require.ensure方法中引入的模块发生变化,网站中加载的chunk.js文件的hash值会自动变化,而不需要手动重新打包或者重新运行web-dev-server。因为它会自动重新编译,但现有的chunk.js文件的hash并不会更新，只是网站中加载的chunk.js文件更新了。如图:

另外特别注意:

如果某个文件只是引入了依赖的模块，却没有调用模块exports出来的方法，则该依赖模块里的代码不会执行，但网站还是会加载该chunk文件,如果exports的不是方法，而是其他类型的数据，则该依赖模块里的代码会执行。

js类的写法

ES5标准：

写法一：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//定义
var AsyncMessage = function (orgid, orgddkey, msgtype){
	var _this = this;
	_this.orgid = orgid;
	_this.orgddkey = orgddkey;
	_this.msgtype = msgtype || 'oa';
	_this.access_token = '';
	
	return {
		getDingAccessToken : function (){
			console.log('我是getDingAccessToken');
		},
		sendAsyncMsg : function (){
			console.log('我是sendAsyncMsg');
		},
		sendDingMsg : function () {
			console.log('我是sendDingMsg');
		}
	}
}
//调用
var mainMessage = new AsyncMessage('abcde','C7wDa_u3qa','ding');
mainMessage.sendDingMsg();

写法二：

1
2
3
4
5
6
7
8
9
10
11

//通过构造函数
function Point(x, y) {
  this.x = x;
  this.y = y;
}
Point.prototype.toString = function () {
  return '(' + this.x + ', ' + this.y + ')';
};
var p = new Point(1, 2);

ES6标准

引入了 Class（类）这个概念

类和模块的内部，默认就是严格模式

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

//定义类
class Point {
  /*构造函数*/
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
  
  //方法与方法之间不需要逗号
  toString() {
    //......
  }
  
  toValue() {
    //.....
  }
}
// 等同于
Point.prototype = {
  constructor() {},
  toString() {},
  toValue() {},
};

深到骨子里的成熟，是从不做着3件事

真正的成熟，就是一个不断与过去傻逼的自己 Say Byebye的过程；成熟是一社会人的必经之路，它和年龄无关，和阅历有关。

一个人对人接物的态度，早已不经意间暴露了他的成熟度。判断自己是否成熟，就看看自己是否告别了曾经的这三种行为。

轻易下结论

人际交谈中，我们常常有一个致命的恶习，就是喜欢假设对方的意图。

成熟的态度，就是不要妄加评论，调查取证后，再去下结论。

盲目追求合群

一个群体的价值观，常常会让一些人渐渐迷失自己，从而最终按照大家眼中“正常”的方式来生活、工作、处理事情。

然而，一个成熟的人，不会盲目地追求合群；相反地，他会客观分析，综合自身的因素，做出理性的判断。

过分注重他人看法

人到底要不要这么注重别人的看法，要不要这么把自己当回事？

越是牛人，越没有架子；越是大神，越接地气，这不仅是因为他们明白谦卑的重要，更因为他们知道，职业没有优越性，
不必把自己太当回事。俗话说的好：世界离开了谁，都照样转。

与其花时间关注别人的评论和眼光，不如抓紧修炼自身的技能，让自己变得更好。

人到了成熟之年，应能摆脱轻浮，锻炼出稳定的理智。不管幸与不幸，都能奋发有为。一个人阅历的广度，
经历的厚度，悟性的高度，都决定了成熟的程度。

事件背景：同步组织人员数据

任务描述：

业务系统中的 单位、部门、人员、身份 来源于统一认证组织机构人员管控平台

原来方案：

自定义一个日期 startTime ，从 startTime 到当前的这段时间内的所有数据变动（增删改），
打成压缩包发送过来、解压、处理数据、删除压缩包

• 优点：统一认证组织机构人员管控平台上的数据保证正确性，其它系统从日志来，所有的操作都有记录

• 缺点：

  • startTime到当前时间如果过长会造成数据量很大，同步失败
  • 即使时间间隔短，但如果在该时间段内的数据量很大，同步也会失败
  • 后台的定时任务来拉取，例如10分钟拉取一次，当从统一认证组织机构人员管理平台接入的业务系统很多时，服务器压力很大
  • 数据丢失后，想要恢复一般在晚上，增加了运维成本

推荐方案：

因统一认证组织机构人员管理平台的数据库与业务系统的数据库在同一个数据库集群中，所以直接从认证组织机构人员库来拉取数据
在业务系统中建立视图

注：以下均是在 浏览器的 ES6 环境中

1. 避免在块级作用域内声明函数，如果确实需要，也应写成函数表达式，而不是函数声明语句

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   //函数声明语句 { let a = 'secret'; function f() { return a; } } //函数表达式 { let a = 'secret'; let f = function () { return a; } }

多端同时登录

1.概述

session多端登录，就是保持session的一致性。由于session是唯一的，所以要保持session的唯一性，可以将session存放在一个地方，到时候大家取的时候，统一从一个地方取session，这样就保持了session的一致。

2.实现session的方法

其实就是将session存放在一个地方，大家存取就好了。至于其他都是附加的，原理就是酱紫。一般实现的方法有：

1）nfs文件共享系统，让不同项目访问同一个共享的文件。

2）存放在mysql。

3）存放在内存数据库，比如redis，memcache等。

4）基于cookie的共享。这个需要域名统一。

3.关于redis的session共享，其他类似

1)php.ini里面存放得有session的存放地址，可以将session的地址改成redis存放session的地址。session.save_path
但是一般这种服务器端会有访问控制。所以可以参考第二种方法

2)重写session，通过php代码更改session的存放路径什么的。php有相关的session重写的类。

同一浏览器，登录多个用户

背景：在同一个浏览器里登录两个用户，第二个用户会把第一个用户的信息覆盖掉（使用session获取用户信息）

原因：存入session的key是同一个

解决方案：

在后台将登陆信息放入session时，创建不同的key。session.setAttribute(“用户名+key”, user);

即时通讯系统中如何实现：多端（PC、mobile）同时在线

参考：http://blog.csdn.net/zhuweisky/article/details/50553427

多终端同时登录，当一个终端修改密码后，其它终端如何处理？

目前有一个项目，同时允许Web端，Moible端，Pad端登录。当同时登录后，现在Web端修改了用户密码后，按道理说Mobile端及Pad端再操作时用户身份要立即失效，必须退出并重新登录验证后才有效。
如何实现通知其它终端立即失效呢？

如果是移动客户端的话，我觉得可以主动推送通知。 网页端的么，想了一个方案1 .把所有已登录的用户保存在一块内存中，用户的每个操作都要另外检验这个内存中是否有该用户的数据，如果没有，就强制重新登录。当有一个用户修改了密码以后，就对当前所有登录这个用户名的账号清掉他的数据，此时，他再操作就要求重新登录了。

UDP使用的是 DatagramSocket对象 和 DatagramPacket 对象

UdpDemo.java ：client(客户端)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

/*
 需求：通过udp传输方式，将一段数据发送出去.
 思路：
 1、建立udpsocket服务
 2、提供数据，并将数据封装到数据包中
 3、通过socket服务的发送功能，将数据包发出去
 4、关闭资源
*/
import java.net.*;
class   UdpSend
{
    public static void main(String[] args) throws Exception
    {
        //1.创建udp服务，通过DatagramSocket对象
        DatagramSocket ds = new DatagramSocket(8888);//用8888端口发送
        //2.确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress, int port)
        byte[] buf = "udp ge men lai le".getBytes();
        DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);
        //3.通过socket服务奖数据包发送出去，通过send方法
        ds.send(dp);
        4.关闭资源
        ds.close();
    }
}

服务器 (server)

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

/* 需求：定义一个应用程序，用于接受upd传输的数据并处理 1.定义udp socket服务：通常会监听一个端口，其实就是给这个接受网络应用程序定义数字标识， 方便于明确哪些数据过来该应用程序可以处理。 2.定义一个数据包，因为要存储接收到的字节数据， 因为数据包对象中有更多功能可以提取字节数据中的不同数据信息. 3.通过socket服务的receive方法将受到的数据存入已定义的数据包中。 4.通过数据包对象的特有功能，将这些不同数据取出，打印在控制台上， 5.关闭资源 */ import java.net.*; class UdpRec { public static void main(String[] args) throws Exception { //1.创建udp socket 服务 DatagramSocket ds = new DatagramSocket(10000); //2.定义数据包，用于存储数据. byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf,buf.length); //3.通过服务的receive方法将收到的数据存入数据包中. ds.receive(dp); //阻塞式方法 //4.通过数据包的方法获取其中的数据. String ip = dp.getAddress().getHostAddress(); String data = new String(dp.getData(),0,dp.getLength()); int port = dp.getPort(); System.out.println(ip + "::" + data + "::" + port); //5.关闭资源. ds.close(); } }

UDP发送端：键盘录入数据

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

import java.net.*; import java.io.*; class UdpSend2 { public static void main(String[] args) throws Exception { DatagramSocket ds = new DatagramSocket(); BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); String line = null; while(line=bufr.readLine() != null) { if("886".equals(line)) break; byte[] buf = line.getBytes(); DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254",10001)); ds.send(dp); } ds.close(); } }

接收端

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

import java.net.*; class UdpRec2 { public static void main(String[] args) throws Exception { DatagramSocket ds = new DatagramSocket(10001); while(trew) { byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf,buf.length); ds.receive(dp); String ip = dp.getAddress().getHostAddress(); String data = new String(dp.getData(),0,dp.getLength()); int port = dp.getPort(); System.out.println(ip + "::" + data + "::" + port); } // 一般都不关的ds.close(); } }

UDP聊天

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

/* 编写一个聊天程序：ChatDemo.java 有收数据的部分，和发数据的部分。 这两部分需要同时执行，那就需要用到多线程技术 一个线程控制收，一个线程控制发 因为收和发动作是不一致的，所以要定义两个run方法. 而且这两个方法要封装到不同的类中. */ import java.net.*; import java.io.*; class Send implements Runnable { public DatagramSocket ds; private Send(DatagramSocket ds) { this.ds = ds; } public void run() { try { BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); String line = null; while((line=bufr.readLine()) != null) { if("886".equals(line)) break; byte[] buf = line.getBytes(); DatagramPacket dp = new DatagramPacket(buf,buf.length;InetAddress.getByName("192.168.1-254"),10002); ds.send(dp); } } catch (Exception e) { throw new RuntimeException("发送端失败！"); } } } /*接收端*/ class Rece implements Runnable { public DatagramSocket ds; private Rece(DatagramSocket ds) { this.ds = ds; } public void run() { try { while(true) { byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf,buf.length); ds.receive(dp); String ip = dp.getAddress().getHostAddress(); String data = new String(dp.getData(),0,dp.getLength()); int port = dp.getPort(); System.out.println(ip + ":" + data + ":" + port); } } catch (Exception e) { throw new RuntimeException("接收端失败！"); } } } class ChatDemo { public static void main(String[] args) throws Exception { DatagramSocket sendSocket = new DatagramSocket(); DatagramSocket receSocket = new DatagramSocket(10002); new Thread(new Send(sendSocket)).start(); new Thread(new Rece(receSocket)).start(); } }

TCP使用的是 Socket 和 ServerSocket

TCP 传输：使用的是 Socket 和ServerSocket

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

/* 演示tcp传输 1.tcp分客户端和服务端 2.客户端对应的对象是socket 服务端对应的对象是ServerSocket */ /* 客户端： 通过查阅socket对象，发现在该对象建立时，就可以去连接制定主机， 因为tcp是面向连接的，所以在建立socket服务时， 就要有服务端存在，并连接成功，形成通路后，在该通道进行数据传输 步骤： 1.创建Socket服务，并制定要连接的主机和端口 */ import java.io.*; import java.net.*; class TcpClient { public static void main(String[] args) throws Exception { //创建客户端的socket服务(包含输入流和输出流)，指定目的主机和端口 Socket s = new Socket("192.168.1.254",10003); //为了发送数据，应该获取socket流中的输出流 OutputStream out = s.getOutputStream(); out.write("tcp ge men lai le".getBytes()); s.close(); } } /* 需求：定义断电接受数据并打印在控制台上 服务端： 1.建立服务端的socket服务，ServerSocket(); 并监听一个端口； 2.获取连接过来的客户端对象 通过ServerSocket的accept方法。没有连接就会等，所以这个方法是阻塞式的 3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据， 并打印在控制台 4.关闭服务端。（可选） */ class TcpServer { puyblic static void main(String[] args) { //建立服务端的socket服务，并监听一个端口 ServerSocket ss = new ServerSocket(10003); //通过accept方法获取连接过来的客户端对象。 Socket s = ss.accept(); String ip = s.getInetAddress().getHostAddress(); System.out.println(ip + "......connected"); //获取客户端发送过来的数据，那么要使用客户端对象的读取流方法来读取数据 InputStream in = s.getInputStream(); byte[] buf = new byte[1024]; int len = in.read(buf); System.out.println(new String(buf,0,len)); s.close();//关闭客户端 ss.close();//可选 } }

演示tcp的传输客户端和服务端的互访

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

/* 需求：客户端给服务端发送数据，服务端收到后，给客户端发送信息 */ /* 客户端： 1.建立socket服务，指定要连接的主机和端口 2.获取socket流中的输出流，将数据谢到该流中。通过网络发送给服务端. 3.获取socket流中的输入流，将服务端反馈的数据获取到并打印。 4.关闭客户端资源 */ class TcpClient2 { public static void main(String[] args) throws Exception { Socket s = new Socket("192.168.1.254",10004); OutputString out = s.getOutputStream(); out.write("服务端：你好".getBytes()); InputStream in = s.getInputStream(); byte[] buf = new byte[1024]; int len = in.read(buf); System.out.println(new String(buf,0,len)); s.close(); } } /*服务端*/ class TcpServer2 { public static void main(String[] args) throws Exception { ServerSocket ss = new ServerSocket(10004); Socket s = ss.accept(); String ip = s.getInetAddress().getHostAddress(); System.out.println(ip+"......connected"); InputSream in = s.getInputStream(); byte[] buf = new bute[1024]; int len = in.read(buf); System.out.println(new String(buf,0,len)); OutputSream out = s.getOutputSream(); out.write("哥们收到".getBytes()); s.close(); ss.close(); } }

TCP练习：文本转换服务器

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

/*
需求：建立一个文本转换服务器
客户端给服务端发送文本，服务端将文本转换成大写再返回给客户端
而且客户端可以不断的进行文本转换，当客户端输入over时，转换结束
分析：
客户端：
既然是操作设备上数据，那么就可以使用io的操作规律来思考
源：键盘录入
目的：网络设备，网络输出流
而且操作的是文本数据，可以选择字符流。
步骤：
1.建立服务
2.获取键盘录入
3.将数据发送给服务端
4.获取服务端返回的大写数据。
5.结束，关资源
都是文本数据，可以使用字符流进行操作，同时为了提高效率，加入缓冲
*/
import java.io.*;
import java.net.*;
class TransClient
{
    public static void main(String[] args) throws Exception
    {
        Socket s = new Socket("192.168.1.254",10005);
        
        //定义读取键盘数据的流对象
        BufferedReader bufr =
            new BufferedReader(new InputStreamReader(System.in));
            
         //定义目的，将数据写入到socket输出流，发给服务端
         //BufferedWriter bufOut =
            //new BufferedWriter(new OutputSteamWriter(s.getOutputStream()));
         PrintWriter out = PrinterWriter(s.getOutputStream());
         
         //定义一个socket读取流，读取服务端返回的大写信息
         //BufferedReader bufIn = 
            //new BufferedReader(new InputSteamReader(s.getInputStream()));
         
         String len = null;
         while((line=bufr.readLine()) != null)
         {
            bufOut.write(line);
            if("over".equals(line))
                break;
                
            //bufOut.writer(line);
            //bufOut.newLine();//注意①
            //bufOut.flush();  //注意①
            out.println(line);
            String str = bufIn.readLine();
            System.out.println("server:" + str);
         }
         bufr.close();
         s.close();
    }
}
/*
服务端：
源：socket读取流
目的：socket输出流
都是文本，装饰
*/
class TransServer
{
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(10005);
        Socket s = ss.accept();
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip + ".....connetced");
        
        //读取socket读取流中的数据
        BufferedReader bufIn = 
            BufferedReader(new InputSteamReader(s.getInputStream()));
            
         //目的: socket输出流，将大写数据写入到socket输出流，并发送给客户端
         //BufferedWriter bufOut = 
            //BufferedWriter(new OutputStreamWriter(s.getOutputSream()));
         //PrintWriter里既可以接输入流，也可以接输出流，还带换行和自动刷新,true对println是有效的刷新
         PrintWriter out = new PrintWriter(s.getOutputSream(),true);
         
         String line = null;
         while((line=bufIn.readLine()) != null)
         {
            System.out.println(line);
            //bufOut.write(line.toUpperCase());
            //bufOut.newLine();//注意①
            //bufOut.flush(); //注意①
            out.println(line.toUperCase());
         }
         s.close();
         ss.close();
    }
}
/*
该例子出现的问题：
现象：客户端和服务端都在莫名的等待这是为什么呢？
因为客户端和服务端都有阻塞式的方法，这些方法没有读到结束标记就会一直等，
而导致两端，都在等待.
*/

TCP 复制文件