今天最好的表现，是明天最低的要求。

1
2

META-INF/MANIFEST.MF  
com/xxx/xxx/xxx.class

这样spring是扫描不到的
我将test.jar解压，重新执行

1
2

cd test
jar cvf test.jar *

这样重新生成的目录结构就是

1
2
3
4
5

META-INF/MANIFEST.MF
com/
com/xxx
com/xxx/xxx/
com/xxx/xxx/xxx.class

如果是使用eclipse导出勾选Add directory entries即可。

今天最好的表现，是明天最低的要求。

在将map的结果集传递给reduce之前对数据进行了分组（类似于对K2做了group by）

执行步骤

map任务处理

• 读取输入文件内容，解析成key、value对。对输入文件的每一行，解析成key、value对。每一个键值对调用一次map函数。
• 写自己的逻辑，对输入的key、value处理，转换成新的key、value输出。
• 对输出的key、value进行分区。
• 对不同分区的数据，按照key进行排序、分组。相同key的value放到一个集合中。
• (可选)分组后的数据进行归约。

reduce任务处理

• 对多个map任务的输出，按照不同的分区，通过网络copy到不同的reduce节点。
• 对多个map任务的输出进行合并、排序。写reduce函数自己的逻辑，对输入的key、value处理，转换成新的key、value输出。
• 把reduce的输出保存到文件中。

今天最好的表现，是明天最低的要求。

元数据

NameNode

• 是整个文件系统的管理节点。它维护着整个文件系统的文件目录树，文件/目录的元信息和每个文件对应的数据块列表。接收用户的操作请求。
• 文件包括：
  • fsimage:元数据镜像文件。存储某一时段NameNode内存元数据信息。
  • edits:操作日志文件。
• fstime:保存最近一次checkpoint的时间
• 以上这些文件是保存在linux的文件系统中。

  NameNode工作特点

1. Namenode始终在内存中保存metedata，用于处理“读请求”
2. 到有“写请求”到来时，namenode会首先写editlog到磁盘，即向edits文件中写日志，成功返回后，才会修改内存，并且向客户端返回
3. Hadoop会维护一个fsimage文件，也就是namenode中metedata的镜像，但是fsimage不会随时与namenode内存中的metedata保持一致，而是每隔一段时间通过合并edits文件来更新内容。Secondary namenode就是用来合并fsimage和edits文件来更新NameNode的metedata的。

SecondaryNameNode

• HA的一个解决方案。但不支持热备。配置即可。
• 执行过程：从NameNode上下载元数据信息（fsimage,edits），然后把二者合并，生成新的fsimage，在本地保存，并将其推送到NameNode，替换旧的fsimage.
• 默认在安装在NameNode节点上，但这样…不安全！

secondary namenode的工作流程

1. secondary通知namenode切换edits文件
2. secondary从namenode获得fsimage和edits(通过http)
3. secondary将fsimage载入内存，然后开始合并edits
4. secondary将新的fsimage发回给namenode
5. namenode用新的fsimage替换旧的fsimage

DataNode

• 提供真实文件数据的存储服务。
• 文件块（block）：最基本的存储单位。对于文件内容而言，一个文件的长度大小是size，那么从文件的０偏移开始，按照固定的大小，顺序对文件进行划分并编号，划分好的每一个块称一个Block。HDFS默认Block大小是128MB，以一个256MB文件，共有256/128=2个Block.
  不同于普通文件系统的是，HDFS中，如果一个文件小于一个数据块的大小，并不占用整个数据块存储空间
• Replication。多复本。默认是三个。 hdfs-site.xml的dfs.replication属性

HDFS

读过程

初始化FileSystem，然后客户端(client)用FileSystem的open()函数打开文件
FileSystem用RPC调用元数据节点，得到文件的数据块信息，对于每一个数据块，元数据节点返回保存数据块的数据节点的地址。
FileSystem返回FSDataInputStream给客户端，用来读取数据，客户端调用stream的read()函数开始读取数据。
DFSInputStream连接保存此文件第一个数据块的最近的数据节点，data从数据节点读到客户端(client)
当此数据块读取完毕时，DFSInputStream关闭和此数据节点的连接，然后连接此文件下一个数据块的最近的数据节点。
当客户端读取完毕数据的时候，调用FSDataInputStream的close函数。
在读取数据的过程中，如果客户端在与数据节点通信出现错误，则尝试连接包含此数据块的下一个数据节点。
失败的数据节点将被记录，以后不再连接。

写过程

初始化FileSystem，客户端调用create()来创建文件
FileSystem用RPC调用元数据节点，在文件系统的命名空间中创建一个新的文件，元数据节点首先确定文件原来不存在，并且客户端有创建文件的权限，然后创建新文件。
FileSystem返回DFSOutputStream，客户端用于写数据，客户端开始写入数据。
DFSOutputStream将数据分成块，写入data queue。data queue由Data Streamer读取，并通知元数据节点分配数据节点，用来存储数据块(每块默认复制3块)。分配的数据节点放在一个pipeline里。Data Streamer将数据块写入pipeline中的第一个数据节点。第一个数据节点将数据块发送给第二个数据节点。第二个数据节点将数据发送给第三个数据节点。
DFSOutputStream为发出去的数据块保存了ack queue，等待pipeline中的数据节点告知数据已经写入成功。
当客户端结束写入数据，则调用stream的close函数。此操作将所有的数据块写入pipeline中的数据节点，并等待ack queue返回成功。最后通知元数据节点写入完毕。
如果数据节点在写入的过程中失败，关闭pipeline，将ack queue中的数据块放入data queue的开始，当前的数据块在已经写入的数据节点中被元数据节点赋予新的标示，则错误节点重启后能够察觉其数据块是过时的，会被删除。失败的数据节点从pipeline中移除，另外的数据块则写入pipeline中的另外两个数据节点。元数据节点则被通知此数据块是复制块数不足，将来会再创建第三份备份。

HDFS shell

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

1，Hadoop fs –fs [local | <file system URI>]：声明hadoop使用的文件系统，如果不声明的话，使用当前配置文件配置的，按如下顺序查找：hadoop jar里的hadoop-default.xml->$HADOOP_CONF_DIR下的hadoop-default.xml->$HADOOP_CONF_DIR下的hadoop-site.xml。使用local代表将本地文件系统作为hadoop的DFS。如果传递uri做参数，那么就是特定的文件系统作为DFS。

2，hadoop fs –ls <path>：等同于本地系统的ls，列出在指定目录下的文件内容，支持pattern匹配。输出格式如filename(full path)   <r n>  size.其中n代表replica的个数，size代表大小（单位bytes）。

3，hadoop fs –lsr <path>：递归列出匹配pattern的文件信息，类似ls，只不过递归列出所有子目录信息。

4，hadoop fs –du <path>：列出匹配pattern的指定的文件系统空间总量（单位bytes），等价于unix下的针对目录的du –sb <path>/*和针对文件的du –b <path> ，输出格式如name(full path)  size(in bytes)。

5，hadoop fs –dus <path>：等价于-du，输出格式也相同，只不过等价于unix的du -sb。

6，hadoop fs –mv <src> <dst>：将制定格式的文件 move到指定的目标位置。当src为多个文件时，dst必须是个目录。

7，hadoop fs –cp <src> <dst>：拷贝文件到目标位置，当src为多个文件时，dst必须是个目录。

8，hadoop fs –rm [-skipTrash] <src>：删除匹配pattern的指定文件，等价于unix下的rm <src>。

9，hadoop fs –rmr [skipTrash] <src>：递归删掉所有的文件和目录，等价于unix下的rm –rf <src>。

10，hadoop fs –rmi [skipTrash] <src>：等价于unix的rm –rfi <src>。

11，hadoop fs –put <localsrc> … <dst>：从本地系统拷贝文件到DFS。

12，hadoop fs –copyFromLocal <localsrc> … <dst>：等价于-put。

13，hadoop fs –moveFromLocal <localsrc> … <dst>：等同于-put，只不过源文件在拷贝后被删除。

14，hadoop fs –get [-ignoreCrc] [-crc] <src> <localdst>：从DFS拷贝文件到本地文件系统，文件匹配pattern，若是多个文件，则dst必须是目录。

15，hadoop fs –getmerge <src> <localdst>：顾名思义，从DFS拷贝多个文件、合并排序为一个文件到本地文件系统。

16，hadoop fs –cat <src>：展示文件内容。

17，hadoop fs –copyToLocal [-ignoreCrc] [-crc] <src> <localdst>：等价于-get。

18，hadoop fs –mkdir <path>：在指定位置创建目录。

19，hadoop fs –setrep [-R] [-w] <rep> <path/file>：设置文件的备份级别，-R标志控制是否递归设置子目录及文件。

20，hadoop fs –chmod [-R] <MODE[,MODE]…|OCTALMODE> PATH…：修改文件的权限，-R标记递归修改。MODE为a+r,g-w,+rwx等，OCTALMODE为755这样。

21，hadoop fs -chown [-R] [OWNER][:[GROUP]] PATH…：修改文件的所有者和组。-R表示递归。

22，hadoop fs -chgrp [-R] GROUP PATH…：等价于-chown … :GROUP …。

23，hadoop fs –count[-q] <path>：计数文件个数及所占空间的详情，输出表格的列的含义依次为：DIR_COUNT,FILE_COUNT,CONTENT_SIZE,FILE_NAME或者如果加了-q的话，还会列出QUOTA,REMAINING_QUOTA,SPACE_QUOTA,REMAINING_SPACE_QUOTA。

今天最好的表现，是明天最低的要求。

• 关闭防火墙
• 修改ip
• 修改hostname
• 设置ssh自动登录
• 安装jdk
• 安装hadoop

防火墙

CentOS 6.5关闭防火墙
[root@localhost ~]#servcie iptables stop –临时关闭防火墙
[root@localhost ~]#chkconfig iptables off –永久关闭防火墙

CentOS 7.2关闭防火墙
CentOS 7.0默认使用的是firewall作为防火墙，这里改为iptables防火墙步骤。
firewall-cmd –state #查看默认防火墙状态（关闭后显示notrunning，开启后显示running）
[root@localhost ~]#firewall-cmd –state
not running

systemctl stop firewalld.service #停止firewall
systemctl disable firewalld.service #禁止firewall开机启动

修改ip

vim /etc/sysconfig/network-script/ifcfg-eth0
BOOTPROTO=static
IPADDR=192.168.137.3
NETMASK=255.255.255.0
GATEWAY=192.168.137.1
DNS1=8.8.8.8
DNS2=8.8.4.4

安装jdk

下载linux版的jdk，使用xshell上传到虚拟机。

tar -zxvf jdk-7u80-linux-x64.tar.gz
mv jdk1.7.0_80/ /usr/local/
vim /etc/profile
export JAVA_HOME=/usr/local/jdk1.7.0_80　　
export JRE_HOME=/usr/local/jdk1.7.0_80/jre
　export PATH=$PATH:/usr/local/jdk1.7.0_80/bin
　export CLASSPATH=./:/usr/local/jdk1.7.0_80/lib:/usr/local/jdk1.7.0_80/jre/lib

1.准备Linux环境
1.0点击VMware快捷方式，右键打开文件所在位置 -> 双击vmnetcfg.exe -> VMnet1 host-only ->修改subnet ip 设置网段：192.168.1.0 子网掩码：255.255.255.0 -> apply -> ok
回到windows –> 打开网络和共享中心 -> 更改适配器设置 -> 右键VMnet1 -> 属性 -> 双击IPv4 -> 设置windows的IP：192.168.1.110 子网掩码：255.255.255.0 -> 点击确定
在虚拟软件上 –My Computer -> 选中虚拟机 -> 右键 -> settings -> network adapter -> host only -> ok
1.1修改主机名
vim /etc/sysconfig/network

    NETWORKING=yes     HOSTNAME=itcast01    ###1.2修改IP    两种方式：    第一种：通过Linux图形界面进行修改（强烈推荐）        进入Linux图形界面 -> 右键点击右上方的两个小电脑 -> 点击Edit connections -> 选中当前网络System eth0 -> 点击edit按钮 -> 选择IPv4 -> method选择为manual -> 点击add按钮 -> 添加IP：192.168.1.119 子网掩码：255.255.255.0 网关：192.168.1.1 -> apply    第二种：修改配置文件方式（屌丝程序猿专用）        vim /etc/sysconfig/network-scripts/ifcfg-eth0        DEVICE="eth0"        BOOTPROTO="static"           ###        HWADDR="00:0C:29:3C:BF:E7"        IPV6INIT="yes"        NM_CONTROLLED="yes"        ONBOOT="yes"        TYPE="Ethernet"        UUID="ce22eeca-ecde-4536-8cc2-ef0dc36d4a8c"        IPADDR="192.168.1.44"       ###        NETMASK="255.255.255.0"      ###        GATEWAY="192.168.1.1"        ###1.3修改主机名和IP的映射关系    vim /etc/hosts    192.168.1.44    itcast011.4关闭防火墙    #查看防火墙状态    service iptables status    #关闭防火墙    service iptables stop    #查看防火墙开机启动状态    chkconfig iptables --list    #关闭防火墙开机启动    chkconfig iptables off1.5重启Linux    reboot

2.安装JDK
2.1上传

2.2解压jdk    #创建文件夹    mkdir /usr/java    #解压    tar -zxvf jdk-7u55-linux-i586.tar.gz -C /usr/java/2.3将java添加到环境变量中    vim /etc/profile    #在文件最后添加    export JAVA_HOME=/usr/java/jdk1.7.0_55    export PATH=$PATH:$JAVA_HOME/bin    #刷新配置    source /etc/profile

3.安装Hadoop
3.1上传hadoop安装包

3.2解压hadoop安装包    mkdir /cloud    #解压到/cloud/目录下    tar -zxvf hadoop-2.2.0.tar.gz -C /cloud/3.3修改配置文件（5个）    第一个：hadoop-env.sh    #在27行修改    export JAVA_HOME=/usr/java/jdk1.7.0_55    第二个：core-site.xml    <configuration>        <!-- 指定HDFS老大（namenode）的通信地址 -->        <property>                <name>fs.defaultFS</name>                <value>hdfs://itcast01:9000</value>        </property>        <!-- 指定hadoop运行时产生文件的存储路径 -->        <property>                <name>hadoop.tmp.dir</name>                <value>/cloud/hadoop-2.2.0/tmp</value>        </property>    </configuration>    第三个：hdfs-site.xml    <configuration>        <!-- 设置hdfs副本数量 -->        <property>                <name>dfs.replication</name>                <value>1</value>        </property>    </configuration>    第四个：mapred-site.xml.template 需要重命名： mv mapred-site.xml.template mapred-site.xml    <configuration>        <!-- 通知框架MR使用YARN -->        <property>                <name>mapreduce.framework.name</name>                <value>yarn</value>        </property>    </configuration>    第五个：yarn-site.xml    <configuration>        <!-- reducer取数据的方式是mapreduce_shuffle -->        <property>            <name>yarn.nodemanager.aux-services</name>            <value>mapreduce_shuffle</value>        </property>    </configuration>3.4将hadoop添加到环境变量    vim /etc/profile    export JAVA_HOME=/usr/java/jdk1.7.0_55    export HADOOP_HOME=/cloud/hadoop-2.2.0    export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin    source /etc/profile3.5格式化HDFS（namenode）第一次使用时要格式化    hadoop namenode -format3.6启动hadoop    先启动HDFS    sbin/start-dfs.sh    再启动YARN    sbin/start-yarn.sh3.7验证是否启动成功    使用jps命令验证    27408 NameNode    28218 Jps    27643 SecondaryNameNode    28066 NodeManager    27803 ResourceManager    27512 DataNode    http://192.168.1.44:50070  (HDFS管理界面)    在这个文件中添加linux主机名和IP的映射关系    C:\Windows\System32\drivers\etc\hosts    192.168.1.119    itcast    http://192.168.1.44:8088 （MR管理界面）

4.配置ssh免登陆
生成ssh免登陆密钥
cd ~，进入到我的home目录
cd .ssh/

ssh-keygen -t rsa （四个回车）执行完这个命令后，会生成两个文件id_rsa（私钥）、id_rsa.pub（公钥）将公钥拷贝到要免登陆的机器上cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys或ssh-copy-id -i localhost 

5.hdfs基本使用

1.0查看帮助    hadoop fs -help <cmd>1.1上传    hadoop fs -put <linux上文件> <hdfs上的路径>1.2查看文件内容    hadoop fs -cat <hdfs上的路径>1.3查看文件列表    hadoop fs -ls /1.4下载文件    hadoop fs -get <hdfs上的路径> <linux上文件>

6.MapReduce示例

hadoop为我们提供了mr的示例程序，存放在/hadoop/hadoop-2.2.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.2.0.jar

安装hadoop2.4.1
注意：hadoop2.x的配置文件$HADOOP_HOME/etc/hadoop
伪分布式需要修改5个配置文件
3.1配置hadoop
第一个：hadoop-env.sh
vim hadoop-env.sh

    #第27行    export JAVA_HOME=/usr/java/jdk1.7.0_65第二个：core-site.xml    <!-- 制定HDFS的老大（NameNode）的地址 -->    <property>        <name>fs.defaultFS</name>        <value>hdfs://itcast01:9000</value>    </property>    <!-- 指定hadoop运行时产生文件的存储目录 -->    <property>        <name>hadoop.tmp.dir</name>        <value>/itcast/hadoop-2.4.1/tmp</value>    </property>第三个：hdfs-site.xml    <!-- 指定HDFS副本的数量 -->    <property>        <name>dfs.replication</name>        <value>1</value>    </property>第四个：mapred-site.xml (mv mapred-site.xml.template mapred-site.xml)    mv mapred-site.xml.template mapred-site.xml    vim mapred-site.xml    <!-- 指定mr运行在yarn上 -->    <property>        <name>mapreduce.framework.name</name>        <value>yarn</value>    </property>第五个：yarn-site.xml    <!-- 指定YARN的老大（ResourceManager）的地址 -->    <property>        <name>yarn.resourcemanager.hostname</name>        <value>itcast01</value>    </property>    <!-- reducer获取数据的方式 -->    <property>        <name>yarn.nodemanager.aux-services</name>        <value>mapreduce_shuffle</value>    </property>3.2将hadoop添加到环境变量vim /etc/proflie    export JAVA_HOME=/usr/java/jdk1.7.0_65    export HADOOP_HOME=/itcast/hadoop-2.4.1    export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbinsource /etc/profile3.3格式化namenode（是对namenode进行初始化）    hdfs namenode -format (hadoop namenode -format)3.4启动hadoop    先启动HDFS    sbin/start-dfs.sh    再启动YARN    sbin/start-yarn.sh3.5验证是否启动成功    使用jps命令验证    27408 NameNode    28218 Jps    27643 SecondaryNameNode    28066 NodeManager    27803 ResourceManager    27512 DataNode    http://192.168.8.118:50070 （HDFS管理界面）    http://192.168.8.118:8088 （MR管理界面）

遇到的问题

启动hdfs，datanode无法启动。
可以看到datanode日志文件报错hadoop-root-datanode-localhost.localdomain.log
org.apache.hadoop.ipc.RemoteException(org.apache.hadoop.hdfs.server.protocol.DisallowedDatanodeException): Datanode denied communication with namenode: DatanodeRegistration(0.0.0.0, storageID=DS-1492551125-127.0.0.1-50010-1522922793693, infoPort=50075, ipcPort=50020, storageInfo=lv=-47;cid=CID-0a985653-165f-4fed-8366-d5552fe4abd9;nsid=150074941;c=0)at org.apache.hadoop.hdfs.server.blockmanagement.DatanodeManager.registerDatanode(DatanodeManager.java:739)

解决：
修改hosts文件 vim /etc/hosts
添加 192.168.138.3 localhost
解决办法二：
在namenode的hdfs-site.xml 里面添加

1
2
3
4

<property>
<name>dfs.namenode.datanode.registration.ip-hostname-check</name>
<value>false</value>
</property>

网上给出的错误原因：
错误和原来的hosts中的“127.0.0.1 localhost”没有关系，是增加了的“192.168.1.101 localhost”解决了问题。原因在于RSA没有给局域网ip（192.168.1.101）授权，造成data node没有正常启动。

项目启动后http://192.168.137.3:50070页面内的`Browse the filesystem`无法访问

解决：
点击Browse the filesystem浏览器中的地址栏为http://localhost:50075/browseDirectory.jsp?namenodeInfoPort=50070&dir=/&nnaddr=192.168.137.3:9000
很明显是地址不对，但是用鼠标指着Browse the filesystem显示的地址是对的，说明在browseDirectory.jsp做了一次页面跳转。
将地址手动修改为192.168.137.3:50075后可以正常访问。
猜测：
browseDirectory.jsp这个页面内namenode随机选择了一个datanode的地址做跳转，对于namenode来说，单机模式的datanode地址就是localhost。
我自己配置的时候并没有配置主机名，主机默认就是localhost。
修改：
配置主机名
vim /etc/sysconfig/network
NETWORKING=yes
HOSTNAME=gengry ###
配置主机名和ip对应关系
vim /etc/hosts
192.168.137.3 gengry
配置windows的hosts
192.168.137.3 gengry
重启hadoop，再次访问，正常。

今天最好的表现，是明天最低的要求。

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

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by CHG on 2017-02-23 20:20.
 */
public class PrintABC {
    int count = 0; //打印次数
    Lock lock = new ReentrantLock();  //可重写锁
    Condition conditionA = this.lock.newCondition();
    Condition conditionB = this.lock.newCondition();
    Condition conditionC = this.lock.newCondition();

    public class PrintA implements Runnable {
        @Override
        public void run() {
            while (true)
                if (count < 15) {
                    lock.lock();
                    System.out.print("A");
                    try {
                        conditionB.signal();  //线程b唤醒,因为a打印完应该打印b
                        conditionA.await();  //线程a进入等待队列
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }

                }
        }
    }

    public class PrintB implements Runnable {
        @Override
        public void run() {
            while (true)
                if (count < 15) {
                    lock.lock();
                    System.out.print("B");
                    try {
                        conditionC.signal();
                        conditionB.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }

                }
        }
    }

    public class PrintC implements Runnable {
        @Override
        public void run() {
            while (true)
                if (count < 15) {
                    lock.lock();
                    System.out.println("C" + count);
                    count++;//打印完c后,count++
                    try {
                        conditionA.signal();
                        conditionC.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }

                }
        }
    }

    public static void main(String[] args) {
        PrintABC printABCD = new PrintABC();
        new Thread(printABCD.new PrintA()).start();
        new Thread(printABCD.new PrintB()).start();
        new Thread(printABCD.new PrintC()).start();

    }

}

今天最好的表现，是明天最低的要求。

ReentranLock

高版本的jdk中已经对synchronized做了足够多的优化，普通的场景下它的性能已经非常接近ReentrantLock。所以一些简单的场景不必过分纠结这两者之间的性能问题。
下面这个例子反而使用synchronized的耗时小于使用ReentrantLock。

可重入

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

public class ReenterLock implements Runnable {
    //可重入锁的使用
    public static ReentrantLock lock = new ReentrantLock();
    public static int i = 0;
    @Override
    public void run() {
        for(int j=0; j<1000000;j++){
            //加锁
            lock.lock();
            try{
                i++;
            }finally {
                //释放锁
                lock.unlock();
            }
        }
    }

/*  @Override
    public void run() {
        for(int j=0; j<1000000;j++) {
            synchronized (this){
                i++;
            }
        }
    }*/

    public static void main(String[] args) throws InterruptedException {
        long time1 = System.currentTimeMillis();
        ReenterLock tl = new ReenterLock();
        Thread t1 = new Thread(tl);
        Thread t2 = new Thread(tl);
        t1.start();t2.start();
        t1.join();t2.join();
        long time2 = System.currentTimeMillis();
        System.out.println(i);
        System.out.println(time2-time1);
    }
}

如果在一个线程中多次使用了加锁操作，就需要有对应数量的释放锁操作。

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

@Override
    public void run() {
        for(int j=0; j<1000000;j++){
            //加锁
            lock.lock();
lock.lock();
            try{
                i++;
            }finally {
                //释放锁
                lock.unlock();
lock.unlock();
            }
        }
    }

下面我们加两次锁，只释放一次锁执行一下。

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

@Override
    public void run() {
        for(int j=0; j<1000000;j++){
            //加锁
            lock.lock();
lock.lock();
            try{
                i++;
            }finally {
                //释放锁
                lock.unlock();
            }
        }
    }

就会发现程序卡住了，一直没有执行结束

我们通过使用jdk的两个命令来看看发生了什么

通过jps获取到这个进程的id
通过jstack看看这个进程的栈信息
可以看到Thread-1处于waiting状态一直在等在某种条件，就是等待另一个线程释放锁。
所在了第13行，也就是lock.lock();

可中断

在加锁的同时可以去响应中断，如果发生了死锁，或者意料之外的情况，在一个锁上卡了很久，还是有办法把这个线程唤醒，不至于永久性的卡死下去。

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

public class ReenterLockInt implements Runnable {
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();
    int lock;
    /*
    * 控制加锁顺序，方便构成死锁
    * */
    public ReenterLockInt(int lock){
        this.lock = lock;
    }

    @Override
    public void run() {
        try{
            if(lock == 1){
                lock1.lockInterruptibly();  //代表可中断的加锁
                try{
                    Thread.sleep(500);
                }catch (InterruptedException e){}
                lock2.lockInterruptibly();
            }else{
                lock2.lockInterruptibly();
                try{
                    Thread.sleep(500);
                }catch (InterruptedException e){}
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(lock1.isHeldByCurrentThread()){
                lock1.unlock();
            }
            if(lock2.isHeldByCurrentThread()){
                lock2.unlock();
            }
            System.out.println(Thread.currentThread().getId()+":线程退出。");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReenterLockInt r1 = new ReenterLockInt(1);
        ReenterLockInt r2 = new ReenterLockInt(2);
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();t2.start();
        Thread.sleep(1000);
    }
}

上面这段代码，发生了死锁，程序无法正常结束。通过jstack可以看到发现了一个死锁。

实现是个守护线程，来触发死锁后的中断

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

public class DeadLockChecker {

    private final static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
    final static Runnable deadlockCheck = new Runnable() {
        @Override
        public void run() {
            while (true){
                long[] deadlockedThreadIds = mbean.findDeadlockedThreads();
                if(deadlockedThreadIds != null){
                    ThreadInfo[] threadInfos = mbean.getThreadInfo(deadlockedThreadIds);
                    for (Thread t : Thread.getAllStackTraces().keySet()){
                        for(int i = 0;i<threadInfos.length; i++){
                            if(t.getId() == threadInfos[i].getThreadId()){
                                t.interrupt();
                            }
                        }
                    }
                }
                try {
                    Thread.sleep(5000);
                }catch (InterruptedException e){
                }
            }
        }
    };

    public static void check(){
        Thread t = new Thread(deadlockCheck);
        t.setDaemon(true);  //设置为守护线程
        t.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11

public static void main(String[] args) throws InterruptedException {
       ReenterLockInt r1 = new ReenterLockInt(1);
       ReenterLockInt r2 = new ReenterLockInt(2);
       Thread t1 = new Thread(r1);
       Thread t2 = new Thread(r2);
       t1.start();t2.start();
       Thread.sleep(1000);
//开启死锁检测
       DeadLockChecker.check();
   }

可限时

使用lock.trylock(5,TimeUtil.SECOND)的方式获取锁。可以设置一个时间阈值，可以避免无限等待。

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

public class TimeLock implements Runnable{
    public static ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        try{
            if(lock.tryLock(5, TimeUnit.SECONDS)){
                System.out.println(Thread.currentThread().getId()+":get lock successed");
                Thread.sleep(6000);
            }else{
                System.out.println(Thread.currentThread().getId()+":get lock failed");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
    public static void main(String[] args) {
        TimeLock tl = new TimeLock();
        Thread t1 = new Thread(tl);
        Thread t2 = new Thread(tl);
        t1.start();
        t2.start();
    }
}

公平锁

公平锁会保证获取锁的先到先得。公平锁不会产生饥饿问题，但是公平锁的性能要差很多，默认是非公平的。
可以通过构造方法指定为公平锁。

Condition

概念

类似于Object.wait()和Object.notify()与ReentrantLock结合使用。
Condition的执行方式，是当在线程1中调用await方法后，线程1将释放锁，并且将自己沉睡，等待唤醒，
线程2获取到锁后，开始做事，完毕后，调用Condition的signal方法，唤醒线程1，线程1恢复执行。

主要接口

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

public class ReenterLockCondition implements Runnable {
    public static ReentrantLock  lock = new ReentrantLock();
    public static Condition condition = lock.newCondition();
    @Override
    public void run() {
        try{
            lock.lock();
            condition.await();
            System.out.println("Thread is going on");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ReenterLockCondition tl = new ReenterLockCondition();
        Thread t1 = new Thread(tl);
        t1.start();
        Thread.sleep(2000);
        lock.lock();
        condition.signal();
        lock.unlock();

    }
}

API

await()方法会使当前线程等待，同时释放当前锁，当其他线程使用signal()时或者signalAll()方法时，线程会重新或得锁并继续执行。或者当线程中断时，也能跳出等待，这和Object.wait()方法类似。
awaitUninterruptibly() 和 await()基本相同，但是它并不会在等待的过程中响应中断。
signal()方法用于唤醒一个等待中的线程，相对的signalAll会唤醒所有等待中的线程，和Object.notify()类似。

Semaphore 信号量

锁是排他的，临界区只能有一个线程占用。
信号量是一种共享锁，信号量是许可若干个线程进入临界区，超过许可的上线就必须等待。
如果信号量的许可线程为1，就可以当成是排他锁。

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

public class SemapDemo implements Runnable{
    final Semaphore semp = new Semaphore(5);
    @Override
    public void run() {
        try{
            semp.acquire();
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getId()+":done");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            semp.release();
        }
    }

    public static void main(String[] args) {
        ExecutorService exec = Executors.newFixedThreadPool(20);
        final SemapDemo semapDemo  = new SemapDemo();
        for (int i=0; i<20; i++){
            exec.submit(semapDemo);
        }
    }
}

主要接口

acquire()
acquireUninterruptibly()
tryAcquire()
tryAcquire(long timeout, TimeUnit unit)
release()

ReadWriteLock

加锁之后，并行度就降为1，只有一个线程可以进入。我们需要通过操作对访问临界区的行为进行划分，当几个线程都是读取数据时，我们是不需要加锁的。

ReadWriteLock中的read线程都是无等待的并发。ReadWriteLock的实现ReentrantReadWriteLock，使用方法和ReentrantLock类似。

1
2

public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

CountDownLatch

概念

倒数计时器
一种典型的场景就是火箭发射器，在火箭发射前，为了保证万无一失，往往需要对各个设备、仪表进行检查，它是一个点火线程，等待所有检查完工后，再执行。

主要接口

static final CountDownLatch end = new CountDownLatch(10);
end.countDown();
end.await();

线程完成既定目标后执行end.countDown();
当计数器为零后 等待的主线程end.await() 继续执行。

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

public class CountDownLatchDemo implements Runnable {
    static final CountDownLatch end = new CountDownLatch(10);
    static final CountDownLatchDemo demo = new CountDownLatchDemo();
    @Override
    public void run() {
        try {
//模拟检查任务
            Thread.sleep(new Random().nextInt(10)*1000);
            System.out.println("check complete");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            end.countDown();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ExecutorService exec = Executors.newFixedThreadPool(10);
        for(int i=0; i<10; i++){
            exec.submit(demo);
        }
//等待检查
        end.await();
//发射火箭
        System.out.println("fire!");
        exec.shutdown();
    }
}

CyclicBarrier

相当于一个循环的CountDownLatch

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

public class CyclicBarrierDemo {
    public static class Solder implements Runnable{
        private String soldier;
        private final CyclicBarrier cyclic;
        Solder(CyclicBarrier cyclic,String soldierName){
            this.cyclic = cyclic;
            this.soldier = soldierName;
        }
        @Override
        public void run() {
            try{
                cyclic.await();
                doWork();
                cyclic.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } finally {

            }
        }
        void doWork(){
            try{
                Thread.sleep(Math.abs(new Random().nextInt()%10000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(soldier+":任务完成");
        }
    }
    public static class BarrierRun implements Runnable{
        boolean flag;
        int N;
        public BarrierRun( boolean flag,int N){
            this.flag = flag;
            this.N = N;
        }
        @Override
        public void run() {
            if(flag){
                System.out.println("司令：[士兵"+N+"个，任务完成！]");
            }else{
                System.out.println("司令：[士兵"+N+"个，集合完成！]");
                flag = true;
            }
        }
    }
    public static void main(String[] args) {
        final int N = 10;
        Thread[] allSoldier = new Thread[N];
        boolean flag = false;
        CyclicBarrier cyclic = new CyclicBarrier(N,new BarrierRun(flag,N));
        System.out.println("集合队伍！");
        for(int i=0;i<N;i++){
            System.out.println("士兵"+i+"报道！");
            allSoldier[i] = new Thread(new Solder(cyclic,"士兵"+i));
            allSoldier[i].start();
//            if(i==5){
//                allSoldier[0].interrupt();
//            }
        }
    }
}

LockSupport

提供线程阻塞原语。

主要接口

LockSupport.park();
LockSupport.unpark();

今天最好的表现，是明天最低的要求。

数据库其实就是一个普通的计算机系统，为我们提供某种服务。
我们对数据库功能的抽闲可以将数据库功能抽象成三个部分

• 用户API
• 关系代数和事物引擎
• K-V存储

关系型数据库底层也是K-V模型的，但是他为我们提供了更高层的服务，这些服务牺牲了运算速度实现了原子性，一致性，隔离性。
但是有些时候我们需要效率，关系型数据库成了系统的瓶颈。我们需要把速度拿回来，所以一些K-V数据库就产生了，其实就是去掉了关系代数和事物引擎将K-V存储和关于K-V的API暴露给了用户,这就是Nosql，Nosql放弃了事物提高了速度。
但是人们发现最简单的K-V存储好像什么事情都干不了，需要我们处理的事情太多了，就产生了newSql，为我们处理了关系代数模型和事物引擎的一部分功能。

Key-Value存储

本质就是映射，按照key找value。

映射的关键特性 扩展

• 是否支持范围查找
• 是否能够处理更新
• 读写性能指标
• 是否面向磁盘结构
• 并行指标
• 内存占用
• Etc…

常见的数据结构

• 排序数组
• 排序链表
• 跳表
• B tree
• LSM tree
• HashMap
• Fractal Tree
• Red-Black-tree
• COLA
• Etc…

关系代数

primary key:id user_id name

按照key找value， Primary Key:id 按照id查找其他数据。

但是如果按照user_id查看记录，则需要遍历所有记录。效率为O(n)

二级索引

二级索引就是同样也是个K-V映射表 key为user_id,value为主键id。
如果二级索引为Hash结构，效率就下降为0(1),如果是二分查找 Tree，效率为O(logN)
这样查询 先按user_id查找到id，在通过id查找到数据。

如果按照多条件查询 where user_id = 1 and name = ‘tom’
如果按照刚才的索引查找，但是如果user_id为1的记录有一万条，我们就需要遍历一万条记录。

组合索引

扩展阅读
扩展阅读
使用 user_id和name作为key，主键id作为value。

事物简介

事物的核心是锁和并发

• 优势：方便理解
• 劣势：性能较低

事物其实就是帮助程序员人脑来理解程序到底是怎么运转的。人脑永远是串行的。把一个逻辑整理成第一步，第二步，第三步…
但是这要的程序只能在单机单线程中执行。
而现实生活中很多事情都是有先后的，例如我们从bob账户中取钱，我们查询账户余额为100，但我们真的去做减的时候，bob账户中的钱已经被别人取走了。
人脑不能很好的理解并发的概念，所以就设计了一种模式，就是事物，让我们方便理解并发，但是降低了性能。

容易理解的模型性能都不好，性能好的模型都不容易理解 – 这就是生活。

事物单元

其实数据库的DDL操作都可以拆分成两个操作，insert 是先查询再插入，update 先查询再更新， delete 先查询再删除，只有select是一个查询操作。
每次查询的时候都把数据锁上，锁的概念：在线程上面维持一个对这个访问的独占权，其他线程不能再访问它了。
事物所覆盖的所有数据都会被这个线程独占。
但是如果都用这么重量级的锁，那性能就太低了，所以事物为我们提供了四种隔离界别

• 未提交读
• 提交读
• 可重复读
• 序列化

这些也是单独的事物单元

• 商品要建立一个基于GMT_Modified的索引
• 从数据库中读取一行记录
• 向数据库中写入一行记录，同事更新这行记录的所有索引
• 删除整张表
• Etc…

一组事物单元，是顺序执行的，第一个事物单元结束后，第二个事物单元才开始执行。
如果两个事物单元没有任何关系的话，A事物操作bob账户，B事物操作tom账户，两个事物是可以并行的。
如果两个事物共享同一份数据，事物没有办法并行。

事物产生原因

扩展阅读

事物单元之间的Happen-before关系（数据的四种冲突）

• 读写
• 写度
• 读读
• 写写

问题

• 如何能以最快的速度完成
• 又能保证上面四种操作的逻辑顺序

mvcc Multi-Version Concurrency Control 多版本并发控制

SQL引擎

现在主流的数据库都在使用CBO（基于成本的优化）进行系统的操作。

分布式存储

多级K-V存储

关键特性

• 可运维
• 高性能
• 可以比较容易的扩容
• 核心数据结构还是hash和树，部分case针对多机做了一点优化。

代表性组件

• mongoDB -> mongos服务器
• Hbase -> region server + client jar包
• DRDS(TDDL) -> tddl规则引擎组件

分布式结构可以理解成map套map的过程，先查询数据在哪个单机，再做单机查询。

路由

规则引擎：有状态的数据应该按照什么规则进行写入和读取
例如：对pk % 3 —> DB0,DB1,DB2

本质来说还是个查找的过程

• hash
  • O(1)效率
  • 不支持范围查询（按时间这样的查询条件就比较困难）
  • 不需要频繁调整数据分布

• Tree
  • 主要是 B Tree
  • O(logN)效率
  • 支持范围查询
  • 需要频繁分裂和合并

• Hash
  • Id%n
  • 最普通的hash
  • 如果id%3 -> id%4 总共会走80%的数据发生移动，最好的情况是倍分id%3 -> id%6,这时候会有50%的数据发生移动
  • 数据移动本身就是个要了亲命的事

• hash
  • 一致性hash 只要解决数据的扩容和缩容的问题
  • 虚拟节点
    • 解决热点问题，只需要调整对应关系疾苦
    • 解决n->n+1问题，规则可以规定只移动需要移动的数据
    • 方案相对复杂
    • 一般推荐使用简单方案开始，使用n->2n方案扩容
    • 只有需要的情况下，在考虑平滑的扩展到虚拟节点方案。

• B-Tree
  • Hbase使用的切分方法
    • 支持范围查询
    • 对于发部分场景来说，引导列都是pk.userid一类的单值查询，用树相对复杂。
    • 需要频繁的进行切分和合并操作 –region server的恶梦
    • 固定节点情况下，跨度相对较大，查询效率可能会进一步降低

一致性

寻求一种能够保证，在给定多台计算机，并且他们相互之间由网络相互连通，中间的数据没有拜占庭将军问题（数据不会被伪造）的前提下（P Partition tolerance 分区容忍性）能够做到一下两种特性的方法：

• 数据的每次成功写入，数据不会丢失，并且按照写入的顺序排列 （C Consistency 一致性）
• 给定安全级别，保证服务的可用性，并尽可能减少机器的消耗（A Availability 可用性）
  • 数据的可用性
  • 服务的可用性 （响应时间，例如500ms）

无主机方案

• Dynamo/cassandra/Paxos:gossip ,W+R>N (W>N-R) N(node) w(write) r(read)
• 所有节点可写，不存在单点故障
• 读数据的最新版本，需要将所有节点的数据都读出来合并一次

有主机方案（Raft）

主从配置

• Mysql MongoDB Oracle+fibreChannel
• 只有一个节点可写，切换时存在短暂leader election过程，会出现短暂不可写。
• 数据一致性比较好控制，读最新数据只需要读主机就可以，一致性读性能较好。

实际系统需要考虑的问题

• 有些机器负担写任务，因此读压力可能不均衡，因此必须有权重设置。
• 单个节点挂掉的时候，TCP超时会导致业务APP的线程花费更多的时间来处理单个请求，这样会降低APP的处理能力，导致雪崩。
• 因为突发情况，导致数据库请求书增加，数据库相应变慢，导致雪崩。

数据库实践

单机优化原则

• 二分查找效率>全表遍历
  • 选择合适的索引
• 内存读写>SSD读写>磁盘读写
  • 将物理读（磁盘读）换成逻辑读（内存读）
• 减少锁冲突
  • 尽可能通过业务设计，将更新变成插入，来减少加锁去锁的操作
• 减少临时表使用
  • 减少多维度排序

分布式系统优化原则

• 减少跨机网络交互
  • 尽可能带sharding key
  • 分页优化（google一下）
• 减少数据读写热点
  • 切分颗粒度尽可能细（用户颗粒度好于省份）
• 减少锁开销
  • 尽可能规避分布式事物

总结

沈询所有资源的索引（会不断更新）

• 尽一切可能利用单机资源
  • 单机事物
  • 单机join
• 好的存储模型
  • 尽可能走内存
  • 尽可能将以此要查询到的数据物理的放在一起
  • 通过合理的数据冗余，减少走网络的次数
  • 合理并行提升响应时间
  • 读取数据瓶颈，可以通过加slave节点解决
  • 写入瓶颈，用规则sharding和扩容来解决

警惕 InnoDB 和 MyISAM 创建 Hash 索引陷阱

今天最好的表现，是明天最低的要求。

就在工作2年，写了2年程序的时候，我觉得自己太蔫儿了，程序猿嘛，更愿意低头做事而不是抬头说话，于是决定辞职去做了半年多销售，就为了练练嘴。现在我还清晰地记得打第一个推销电话的时候，我提前写好了稿子，紧张得面红耳赤，拨通电话就照着稿子念，等我念完了发现对方早挂了。不过就这样一点点地磨过来了，拿了个年度销售冠军，然后毅然辞职，又跑去写程序了。乔丹曾说过：“如果没有去打棒球的话，都不知道自己有多么地爱篮球”。我也借用这句话：如果没有跑去做销售的话，都不知道自己有多么地爱代码。

我算是比较幸运，把自己的爱好作为了职业，可以亲手将一个产品从无到有地打造出来的喜悦感还是非常满足的。虽然很多时候都是解决需求、改bug这些枯燥的事情吧，这就好像你喜欢玩游戏，但是职业化地一遍又一遍地重复一个游戏也是很郁闷的。我还有一个爱好就是摄影，我绝不去做职业摄影师，保持这个爱好就是爱好，纯玩儿。

曾有一个段子说：一个妹子问一个程序猿如何让一帮不爱说话的程序猿活跃起来，那个程序猿说了一句PHP是最好的语言。。。很多程序猿都喜欢站队，所谓站队就是自己在玩某某语言的时候，就会觉得这个语言很强大，自然而然地就站了队了。

我们的身边充斥着写java的看不上写.net的，写c的看不上一切，node异军突起，python批评ruby垃圾性能，高富帅swift从天而降，PHP是最强语言等等。。。

十二年前，我刚工作的时候，写医疗软件，用VB写界面，用VC写功能封装dll，当时觉得VB，VC太强了，结果现在它们基本都死了。

同样的还有：

我写过Dephi，死了。。

我写过asp，死了。。

我写过塞班，死了。。

我们更应当做的是跳出语言的框框，编程注重的是思想，而非语言。

有人不屑于C#的lambda表达式，认为这就是个语法糖。其实你可以把它看作为将冗余的循环判断重构为一句话，IT行业很多时候都是在给其他行业做提升效率的工作，轮到我们自己为啥就不能提升下开发效率呢，程序猿挺苦逼了，吃块糖咋了？

有人不屑于.net的闭源，但是微软正在把很多.net的东西开源了，反观oracle跟Google的java官司有一种oracle要玩死java的赶脚啊。

有人不屑于java的呆板，但是java不计其数的开源框架支撑这个古老而又现代的帝国。

有人不屑于js就是个脚本，但是node异军突起，正在逐步向后端深入。

跳出语言的框框吧，作为一枚程序猿，我们更应该重视的并不是语言本身，语言只是一个工具罢了。

有一篇鸡汤说：两个人在工地搬砖，有人问他们你们在干嘛，一个说我在搬砖，另一个说我在建造大楼。几年后说搬砖的人还在搬砖，而说建造大楼的人通过进修一点点做到工程师了。

这虽然是一篇鸡汤，但是确实说明白了一个道理，就是你的思想决定了你的行动，影响了你的结果。当然对于程序猿更是如此了，因为我们是码农，没了思想就是一个搬砖的。

举个例子：如果有一天pm告诉你，要做一个朋友圈这样的产品，你会怎么做？

初级程序员会怎么做？

1、建立用户表、用户朋友圈发的内容表、点赞评价表，然后做表表关联。

高级一点的程序猿还会想到什么？

2、图片要做压缩吧，现在手机动不动1000多w像素，一张图片好几m，不压缩的话先不说服务器压力，用户刷新一下朋友圈这个月的流量就没了的话，一定会马上删应用骂街的。

3、图片要分布式存储吧，CDN引入的问题。

4、辣么多表做关联，响应的问题，并发的问题，缓存怎么搞。

5、数据量大了的话，分库拆库是否要提前计划好。

6、发朋友圈要有消息通知吗？如何做？

7、数据量大了之后用多表关联的方式是否还合适？

还有一些也许pm并没有说到的细节呢？

8、朋友圈一定就是9张图片吗，以后会不会要求增加呢，当年微博还要求必须140个字呢，现在也没限制了，如果你数据表只是设计了9个图片字段的话。。。

9、图片是否要预留加入ps、美颜等功能的考虑呢？

10、用户选择图片的时候是否可以多选，选择图片的列表是不是应该按照时间倒序排列？

11、pm只说了发朋友圈，那么修改删除呢？

12、评论、点赞修改了删除呢？删除后已发出的消息怎么办？

如果你只考虑第1的话，那么不好意思，你就是在搬砖呢。

如果你考虑了2-7的话，恭喜你是一个合格的程序猿。

只有考虑到了8-12，才是那个不仅仅在搬砖的程序猿。

有人会说了8-12这些应该是pm做的事情啊，pm没说就不做啊。还是那句话，如果pm告诉你什么你就做什么的话，那就是在搬砖，只是在完成工作罢了，而不是在打造一款真正的产品。

以上，就是我这个十二年的老程序猿的碎碎念。

作者：williamnet
链接：https://www.jianshu.com/p/072b262cd089
来源：简书

今天最好的表现，是明天最低的要求。

App端部分功能使用h5页面实现，但是偶尔用户反映会有广告。也就是请求被第三方劫持了插入了广告，所以决定全业务切https。在nginx配置https将https的请求转发的tomcat的http端口。
但是发现一个问题就是h5页面的资源和ajax请求失败，原因是url中的协议和端口号不对应。

1

String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

结果是协议为http，端口号为 https的端口号，导致静态资源加载、ajax请求失败。
http://****:6443/**** 无法请求到服务器。

解决问题

nginx配置

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

upstream ******{
           server 127.0.0.1:8680 weight=1 fail_timeout=600s;
           server 127.0.0.1:8980 weight=1;
    }

 server {
        listen       80;
        server_name *******;

        charset utf-8;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            #root   html;
            #index  index.html index.htm;
            #proxy_pass  **********;
                proxy_redirect off;
                proxy_set_header Host $host;
                proxy_set_header Host $host:80;
                #proxy_set_header X-Real-IP $remote_addr;
                #proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                client_max_body_size 10m;
                client_body_buffer_size 128k;
                proxy_connect_timeout 300;
                proxy_send_timeout 300;
                proxy_read_timeout 300;
                proxy_buffer_size 4k;
                proxy_buffers 4 32k;
                proxy_busy_buffers_size 64k;
                proxy_temp_file_write_size 64k;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        access_log  logs/access_http.log;

    }

    server {
        listen       6443 ssl;
        server_name  **********;
        error_log /usr/local/nginx/logs/error_debug debug; 
        ssl_certificate      /usr/local/nginx/ssl/pn.crt;
        ssl_certificate_key  /usr/local/nginx/ssl/pn.key;
    
        ssl_session_cache    shared:SSL:1m;
        ssl_session_timeout  5m;
    
        ssl_ciphers  HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers  on;
    
        location / {  
            #add_header From /;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_set_header Host $http_host;
           proxy_set_header X-Forwarded-Proto https;
           proxy_redirect off;
           proxy_connect_timeout      240;
           proxy_send_timeout         240;
           proxy_read_timeout         240;
 #  proxy_pass *********;  
#proxy_set_headerHost$http_host;
#proxy_set_headerX-Real-IP   $remote_addr;
#proxy_set_headerX-Forwarded-For $proxy_add_x_forwarded_for;
#proxy_set_header   Cookie $http_cookie; 
#client_max_body_size1000m; 
        } 
      access_log  logs/apkaccess.log;
    }

tomcat server.xml配置

在tomcat的标签中加入

1
2
3
4
5
6

<Valve className="org.apache.catalina.valves.RemoteIpValve"  
                  remoteIpHeader="x-forwarded-for"  
                  remoteIpProxiesHeader="x-forwarded-by"  
                  protocolHeader="x-forwarded-proto"  
                  httpsServerPort="6443"
            />

解释分析

nginx中的核心配置为,这几项配置，会在请求头中设置这几个参数。

1
2
3
4

proxy_set_header       Host $host;  
proxy_set_header  X-Real-IP  $remote_addr;  
proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;  
proxy_set_header X-Forwarded-Proto  $scheme;

我们随便写一个接口，获取请求头。

1
2
3
4
5
6

@RequestMapping(value = "/ggggggg",method=RequestMethod.GET)
@ResponseBody
public Object ggggggg( HttpServletRequest request) throws ParseException {
Enumeration enumeration = request.getHeaderNames();
return null;
}

经过debug我们可以看到 request的请求头中已经加入了这几个参数

配置tomcat后可以查看request获取的协议和端口号信息。

tomcat的配置文件其实就是指定tomcat如何将http请求包装成request对象。我们打开tomcat的api看一看RemoteIpValve这个类。
tomcat API

public class RemoteIpValve
extends ValveBase
Tomcat port of mod_remoteip, this valve replaces the apparent client remote IP address and hostname for the request with the IP address list presented by a proxy or a load balancer via a request headers (e.g. “X-Forwarded-For”).
Another feature of this valve is to replace the apparent scheme (http/https) and server port with the scheme presented by a proxy or a load balancer via a request header (e.g. “X-Forwarded-Proto”).

这样tomcat会从请求头中获取这几个参数，实例化request。
如果https走的是443端口则不用设置 httpsServerPort默认值为443。我这里https走的是6443，所以需要配置。

参考文档

http://blog.csdn.net/vfush/article/details/51086274
https://www.cnblogs.com/gentoo/archive/2012/10/13/2722463.html
http://blog.csdn.net/newtelcom/article/details/50782950
http://blog.csdn.net/RKun595/article/details/71012484

今天最好的表现，是明天最低的要求。

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

[
  {
    "$id": "1",
    "$type": "SourceTree.Api.Host.Identity.Model.IdentityAccount, SourceTree.Api.Host.Identity",
    "Authenticate": true,
    "HostInstance": {
      "$id": "2",
      "$type": "SourceTree.Host.Atlassianaccount.AtlassianAccountInstance, SourceTree.Host.AtlassianAccount",
      "Host": {
        "$id": "3",
        "$type": "SourceTree.Host.Atlassianaccount.AtlassianAccountHost, SourceTree.Host.AtlassianAccount",
        "Id": "atlassian account"
      },
      "BaseUrl": "https://id.atlassian.com/"
    },
    "Credentials": {
      "$id": "4",
      "$type": "SourceTree.Model.BasicAuthCredentials, SourceTree.Api.Account",
      "Username": "",
      "Email": null
    },
    "IsDefault": false
  }
]

今天最好的表现，是明天最低的要求。

仍然使用中国科学技术大学镜像站下载mysql。
最新版本的mysql。
这里下载的mysql是二进制包，没有使用linux的包管理工具。

阅读mysql安装文档

通过百度打开mysql的官网，找到mysql5.7GA的文档。

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

shell> groupadd mysql
shell> useradd -r -g mysql -s /bin/false mysql
shell> cd /usr/local
shell> tar zxvf /path/to/mysql-VERSION-OS.tar.gz
shell> ln -s full-path-to-mysql-VERSION-OS mysql
shell> cd mysql
shell> mkdir mysql-files
shell> chown mysql:mysql mysql-files
shell> chmod 750 mysql-files
shell> bin/mysqld --initialize --user=mysql 
shell> bin/mysql_ssl_rsa_setup              
shell> bin/mysqld_safe --user=mysql &
# Next command is optional
shell> cp support-files/mysql.server /etc/init.d/mysql.server

安装

使用xshell工具通过ssh连接到centos，ssh协议支持xftp协议，可以将本地的文件上传到虚拟机中的centos中。

创建用户及相关

将mysql目录及其子目录的所有者设置为mysql

1
2
3
4
5
6
7
8
9
10

mv mysql-5.7.21-linux-glibc2.12-x86_64 mysql
cd /usr/local
ln -s /home/mysql/mysql mysql
cd /home/mysql
mkdir mysql-data
mkdir mysql-logs
mkdir mysql-tmp
chown mysql:mysql -R mysql/
# 初始化mysql的data文件夹
[root@localhost mysql]# ./bin/mysqld  --initialize --user=mysql --basedir=/home/mysql/mysql --datadir=/home/mysql/mysql-data

mysql配置文件

将下面的配置复制到 /etc/my.cnf中

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

[client]
default_character_set = utf8
port = 3306
#这个路径需要和mysqld中socket的路径相同
socket = /tmp/mysql.sock

[mysqld]
basedir = /home/mysql/mysql
datadir = /home/mysql/mysql-data
user = mysql
port = 3306
server_id = 1
character_set_server = utf8
socket = /tmp/mysql.sock
pid-file = /tmp/mysql.pid
log-bin = /home/mysql/mysql-logs/bin_log  # 二进制日志，用户主从复制
relay-log = /home/mysql/mysql-logs/relay_log  #从mysql的IO thread将主的bin_log复制到这个文件
log-error = /home/mysql/mysql-logs/mysql_error.log
explicit_defaults_for_timestamp = true
expire_logs_days = 10
max_binlog_size = 100M
binlog-do-db =    #复制数据库名称
binlog-ignore-db = mysql #忽略二进制日志的数据库名

配置启动脚本

1

shell> cp support-files/mysql.server /etc/init.d/mysql.server

启动mysql

1

service mysql start

报错
MySQL.2018-02-06T06:07:04.427707Z mysqld_safe error: log-error set to '/home/mysql/mysql-logs/mysql_error.log', however file don't exists. Create writable for user 'mysql'

需要手动建立error_log文件

1
2

touch /home/mysql/mysql-logs/mysql_error.log
service mysql start

mysql已正常启动，可以使用mysql/bin目录下的mysql和之前记录的默认密码登录mysql
为root账户设置密码

1

alter user 'root'@'localhost' identified by 'root';

把mysql注册成开机启动的服务

1

chkconfig --add mysql

加入环境变量

修改/etc/profile文件使其永久性生效，并对所有系统用户生效，在文件末尾加上如下两行代码
PATH=$PATH:/home/mysql/mysql:/home/mysql/mysql/bin
export PATH
最后：执行 命令source /etc/profile或 执行点命令 ./profile使其修改生效，执行完可通过echo $PATH命令查看是否添加成功。

配置账户

登录mysql配置一个可以远程访问的账户

1
2

GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'myuser' WITH GRANT OPTION;
FLUSH PRIVILEGES

暂时关闭防火墙，否则外面访问不了
systemctl stop firewalld.service

使用Navicat连接mysql

使用账户myuser 密码 myuser登录，
第一次登录没有成功，在本地用myuser登录一下mysql就可以用navicat连接上了。

今天最好的表现，是明天最低的要求。

公司线上使用阿里云的mysql数据库，一直是单点，也是系统中最大的瓶颈。因为开始考虑的是单点，所以第一个负责人将RDS的配置设置的很高，造成了特别大的资源浪费。平时cpu的内存的使用率都特别低。
现在的负责人觉得RDS高配置很浪费，做了降配处理，春节前活动直接被查询宕机。所以现在需要考虑优化方案

方案一

直接使用阿里云的RDS配置主从，RDS自动支持读写分离，简单易用，能用钱解决的问题都是小问题，暂定也是使用这个方案。

方案二

使用阿里云的ECS自己搭建mysql的集群。配置mysql读写分离，高可用，防止单点故障造成直接宕机。
虽然定的方案是使用RDS，但是我还是在本地搭建一下这个环境，以备不时之需。

安装VMware

此步骤略过。

安装Centos

下载Centos的ISO包，但是官网的速度简直是巨慢无比无法忍受，可以在中国的镜像站下载。
可以从我的博客国内开源镜像站获取开源镜像站
推荐使用中国科学技术大学。
页面中可以Ctrl+f搜索centos快速定位。在文件目录下找到centos官方推荐使用的最新版本。CentOS7

CentOS-7-x86_64-DVD-1708.iso 标准安装版，一般下载这个就可以了
CentOS-7-x86_64-NetInstall-1708.iso 网络安装镜像
CentOS-7-x86_64-Everything-1708.iso 对完整版安装盘的软件进行补充，集成所有软件。
CentOS-7-x86_64-LiveGNOME-1708.iso GNOME桌面版
CentOS-7-x86_64-LiveKDE-1708.iso KDE桌面版
CCentOS-7-x86_64-LiveKDE-1708-livecd.iso 光盘上运行的系统，类拟于winpe

安装

新手最简单安装一路继续，安装成功后登陆。

配置网络，在安装完虚拟就后一般会自动生成两个网络适配器，这个可以删除也可以自定义，但是本次我们使用默认生成的VMware Network Adapter VMnet8

现在需要将可以上网的网卡的网络共享给虚拟机的网络适配器。

现在看VMware Network Adapter VMnet8的属性，可以看到为他生成了ip地址。

根据这个信息配置，虚拟机的虚拟网络（编辑->虚拟网络编辑器）

配置

虚拟机启动默认网络是不自动开启的，编辑网络的配置文件


重启network服务，已经获取到ip地址，测试实体机可以ping通。


开启ssh外网连接。

重启centos。
使用xshell连接。

http://blog.csdn.net/bao19901210/article/details/51917641
http://blog.csdn.net/u012961566/article/details/70237548
http://blog.csdn.net/djcode/article/details/78621772

今天最好的表现，是明天最低的要求。

By default use of @EnableWebMvc or automatically registers Bean Validation support in Spring MVC through the LocalValidatorFactoryBean when a Bean Validation provider such as Hibernate Validator is detected on the classpath.

注意 需要检验的bean需要被 context:component-scan 扫描到

如果不指定校验器，classpath内有hibernate validoter，spring会默认使用它。

1
2
3
4
5
6
7
8
9
10
11

@ApiOperation(value="提交商城订单",tags="商城")
@Auth
@RequestMapping(value = "/submitMallOrder",method=RequestMethod.POST)
@ResponseBody
public Object submitMallOrder(@RequestBody @Valid MallOrderInfosVO mallOrderInfoVO, BindingResult binding) {
if(binding.hasErrors()){
return ResultMessage.getValidFail(new HashMap<String,Object>()).setBindingResult(binding);
}
Map<String,Object> result = mallOrderInfoService.submitMallOrder(mallOrderInfoVO);
return ResultMessage.newInstance().setCode(MapUtils.getInteger(result, "code")).setMessage(MapUtils.getString(result, "message")).setData(MapUtils.getObject(result, "data"));
}

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

package com.jsz.peini.bean.mall;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

import javax.validation.Valid;
import javax.validation.constraints.DecimalMin;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.Range;

import io.swagger.annotations.ApiModelProperty;

public class MallOrderInfosVO {

@NotNull
@Size(min=1)
@Valid
@ApiModelProperty("商城订单列表")
public ArrayList<MallSellerOrderInfoVo> sellerOrderInfoVos;

@NotNull
@DecimalMin("0.00")
@ApiModelProperty("订单总额")
public BigDecimal totalMoney;

//@NotNull
//@Range(min=1,max=3)
//@ApiModelProperty("支付方式 0金币；1微信；2支付宝")
//public Integer payType;

@ApiModelProperty("如果是通过购物车提交的订单，传过来购物车的id")
public List<Integer> mallShopCartIds;

@NotNull
@ApiModelProperty("收货地址id")
public Integer mallAddressId;

public ArrayList<MallSellerOrderInfoVo> getSellerOrderInfoVos() {
return sellerOrderInfoVos;
}

public void setSellerOrderInfoVos(ArrayList<MallSellerOrderInfoVo> sellerOrderInfoVos) {
this.sellerOrderInfoVos = sellerOrderInfoVos;
}

public BigDecimal getTotalMoney() {
return totalMoney;
}

public void setTotalMoney(BigDecimal totalMoney) {
this.totalMoney = totalMoney;
}

//public Integer getPayType() {
//return payType;
//}
//
//public void setPayType(Integer payType) {
//this.payType = payType;
//}

public List<Integer> getMallShopCartIds() {
return mallShopCartIds;
}

public void setMallShopCartIds(List<Integer> mallShopCartIds) {
this.mallShopCartIds = mallShopCartIds;
}

public Integer getMallAddressId() {
return mallAddressId;
}

public void setMallAddressId(Integer mallAddressId) {
this.mallAddressId = mallAddressId;
}
}

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

package com.jsz.peini.bean.mall;

import java.math.BigDecimal;
import java.util.ArrayList;

import javax.validation.Valid;
import javax.validation.constraints.DecimalMin;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.Range;

import io.swagger.annotations.ApiModelProperty;

public class MallSellerOrderInfoVo {

@NotNull
@ApiModelProperty("店铺id")
private Integer sellerId;
@NotNull
@DecimalMin("0.00")
@ApiModelProperty("金额合计")
private BigDecimal totalMoney;
@NotNull
@DecimalMin("0.00")
@ApiModelProperty("商品总价")
private BigDecimal goodsMoney;
@NotNull
@DecimalMin("0")
@ApiModelProperty("支付金额")
private BigDecimal payMoney;
@NotNull
@DecimalMin("0")
@ApiModelProperty("快递费用")
private BigDecimal expressPrice;
@NotNull
@DecimalMin("0")
@ApiModelProperty("积分补贴")
private BigDecimal scoreMoney;
@NotNull
@DecimalMin("0")
@ApiModelProperty("积分消耗")
private Integer scoreUse;
@NotNull
@Min(1)
@ApiModelProperty("购买件数")
private Integer buyNum;

@NotNull
@Range(min=0,max=3)
@ApiModelProperty("发票类型 0:不要发票 1:个人 2:企业 ")
private Integer invoiceType;
@Length(max=200)
@ApiModelProperty("发票抬头")
private String invoiceTitle;
@Length(max=200)
@ApiModelProperty("留言")
private String leaveMsg;

@NotNull
@ApiModelProperty("收货人")
private String receiveUser;

@NotNull
@ApiModelProperty("收货电话")
private String receiveTel;
@Length(max=200)
@NotNull
@ApiModelProperty("收货地址")
private String receiveAddress;

@Size(min=1)
@ApiModelProperty("商品订单列表")
@Valid
private ArrayList<MallGoodsOrderInfoVO> mallGoodsOrderInfoVOs;
public Integer getSellerId() {
return sellerId;
}
public void setSellerId(Integer sellerId) {
this.sellerId = sellerId;
}
public BigDecimal getTotalMoney() {
return totalMoney;
}
public void setTotalMoney(BigDecimal totalMoney) {
this.totalMoney = totalMoney;
}
public BigDecimal getPayMoney() {
return payMoney;
}
public void setPayMoney(BigDecimal payMoney) {
this.payMoney = payMoney;
}
public BigDecimal getExpressPrice() {
return expressPrice;
}
public void setExpressPrice(BigDecimal expressPrice) {
this.expressPrice = expressPrice;
}
public BigDecimal getScoreMoney() {
return scoreMoney;
}
public void setScoreMoney(BigDecimal scoreMoney) {
this.scoreMoney = scoreMoney;
}

public Integer getScoreUse() {
return scoreUse;
}
public void setScoreUse(Integer scoreUse) {
this.scoreUse = scoreUse;
}
public Integer getBuyNum() {
return buyNum;
}
public void setBuyNum(Integer buyNum) {
this.buyNum = buyNum;
}
public Integer getInvoiceType() {
return invoiceType;
}
public void setInvoiceType(Integer invoiceType) {
this.invoiceType = invoiceType;
}
public String getInvoiceTitle() {
return invoiceTitle;
}
public void setInvoiceTitle(String invoiceTitle) {
this.invoiceTitle = invoiceTitle;
}
public String getLeaveMsg() {
return leaveMsg;
}
public void setLeaveMsg(String leaveMsg) {
this.leaveMsg = leaveMsg;
}
public String getReceiveUser() {
return receiveUser;
}
public void setReceiveUser(String receiveUser) {
this.receiveUser = receiveUser;
}
public String getReceiveTel() {
return receiveTel;
}
public void setReceiveTel(String receiveTel) {
this.receiveTel = receiveTel;
}
public String getReceiveAddress() {
return receiveAddress;
}
public void setReceiveAddress(String receiveAddress) {
this.receiveAddress = receiveAddress;
}
public ArrayList<MallGoodsOrderInfoVO> getMallGoodsOrderInfoVOs() {
return mallGoodsOrderInfoVOs;
}
public void setMallGoodsOrderInfoVOs(ArrayList<MallGoodsOrderInfoVO> mallGoodsOrderInfoVOs) {
this.mallGoodsOrderInfoVOs = mallGoodsOrderInfoVOs;
}
public BigDecimal getGoodsMoney() {
return goodsMoney;
}
public void setGoodsMoney(BigDecimal goodsMoney) {
this.goodsMoney = goodsMoney;
}



}

一个完整实例
http://blog.csdn.net/vbirdbest/article/details/72620957

今天最好的表现，是明天最低的要求。

http://blog.csdn.net/djcode/article/details/78621772

读写分离 mybatis插件
https://gitee.com/qiangzigege/MyRWSplit

mysql半同步方案

今天最好的表现，是明天最低的要求。

今天最好的表现，是明天最低的要求。

今天最好的表现，是明天最低的要求。

为客户端提供api接口，返回json数据，规定好了返回的字段，但是当使用Mybatis时如果使用map作为返回值，如果数据库中的值为null，则不会在map中生成对应的key。
有的时候一些必要的字段，想要添加上这些key需要使用实体bean作为返回值，但是很多时候，表中的字段很多，很多业务务求只需要部分字段，用表生成bean不适用，单独定义一个bean又嫌麻烦，用map需要在查询之后再补key，很难受。
今天看mybatis官方文档，突然看到一个设置，用来解决这个问题。
没事多看看官方文档，会有意想不到的收获。

配置

Mybatis官方文档

Mybatis官方文档的目录结构很清楚，我们本次需要关注的是 Configuration XML中的setting

callSettersOnNulls
Specifies if setters or map’s put method will be called when a retrieved value is null. It is useful when you rely on Map.keySet() or null value initialization. Note primitives such as (int,boolean,etc.) will not be set to null.
true | false
默认 false

XML配置

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

<!-- mybatis configuration -->
<?xml version="1.0" encoding="UTF-8" ?>  
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
 "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="callSettersOnNulls" value="true"/>  <!-- 配置属性值为true-->
    </settings>
<plugins>
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <property name="dialect" value="mysql" />
            <property name="rowBoundsWithCount" value="true"/>
            <property name="pageSizeZero" value="true" />
            <property name="reasonable" value="false" />
        </plugin>
</plugins>
</configuration>

1
2
3
4
5
6
7

<!--spring configuration xml-->
<bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:spring-mybatis.xml" />
<property name="mapperLocations" value="classpath*:com/***/***/mapping/*/*.xml" />
<property name="typeAliasesPackage" value="com.***.bean" />
</bean>

java配置

mybatis配置文件中的set属性其实对应的是org.apache.ibatis.session.Configuration中的变量。
例如：

1
2
3
4
5
6
7
8
9
10
11

protected boolean safeRowBoundsEnabled;
protected boolean safeResultHandlerEnabled = true;
protected boolean mapUnderscoreToCamelCase;
protected boolean aggressiveLazyLoading;
protected boolean multipleResultSetsEnabled = true;
protected boolean useGeneratedKeys;
protected boolean useColumnLabel = true;
protected boolean cacheEnabled = true;
protected boolean callSettersOnNulls;
protected boolean useActualParamName = true;
protected boolean returnInstanceForEmptyRow;

1
2
3
4
5
6
7
8
9
10

DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
TransactionFactory transactionFactory =
  new JdbcTransactionFactory();
Environment environment =
  new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(BlogMapper.class);
configuration.setCallSettersOnNulls = true;
SqlSessionFactory sqlSessionFactory =
  new SqlSessionFactoryBuilder().build(configuration);

业务代码

1
2
3
4
5
6
7
8

@Auth
@RequestMapping(value = "/sdfs",method= RequestMethod.POST)
@ResponseBody
public Object sdfs (){
    List<Map<String,Object>> dd = awardBaseMapper.getUserSignStatuss();
    System.out.println(dd);
    return dd;
}

1
2
3
4

public interface AwardBaseMapper {
@Select("select * from user_sign")
    List<Map<String,Object>> getUserSignStatuss();
}

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

[
{
"sign_year_week":4,
"sign_year_day":23,
"sign_year_month":0,
"user_id":"cfeb266707c94b8a92d00c8c05d8b1f7",
"sign_week_day":3,
"award_ticket_id":null,
"id":7,
"sign_award":"未获取到奖励。",
"sign_type_index":1,
"sign_year":2018,
"award_type":2,
"sign_time":"2018-01-23 16:56:19"
},
{
"sign_year_week":5,
"sign_year_day":30,
"sign_year_month":0,
"user_id":"1e11281446b84655813ad08fd9da32a1",
"sign_week_day":3,
"award_ticket_id":-1,
"id":8,
"sign_award":null,
"sign_type_index":1,
"sign_year":2018,
"award_type":2,
"sign_time":"2018-01-30 09:25:43"
}
]

上面可见，返回的json串中已经携带了null值的key。不同版本中的属性差异还是挺大的，官网现在是3.4.6，我用的3.2.6中很多属性就没有，如果需要使用新特性，需要升级mybatis版本。

后记

• 最后在提醒下，对于map中null值引发的空指针问题，可以很好的用 apache commons包中MapUtils解决，可以减少很多不必要的bug。
• 给客户端返回的json数据中，数组，集合，字典，对象不要有null值，如果是null需要put一个空HashMap或ArrayList，否则客户端反序列化会异常。

今天最好的表现，是明天最低的要求。