SpringMVC核心流程,主要在doDispatch方法中

• 1、用户发送请求，被SpringMvc的DispatcherServlet捕获到
• 2、DispatcherServlet对获取到的URL进行解析，得到统一定位符URI，然后根据URI调用HandlerMapping获得Handler对象以及跟handler相关的拦截器，最后以HandlerExecutionChain对象形式返回。
• 3、DispatcherServlet根据返回的Handler选择合适的HandlerAdapter，如果找到了HandlerAdapter,在之前就会执行preHandler方法
• 4、提取request中的模型数据，填充Handler入参，开始执行Handler
  • 在填充的过程中，SpringMvc会做一些操作：
    • HttpMessageConvert ： 将消息转换成一个对象，将对象转换成指定的响应信息。
    • 数据转换： 比如将String转换成Integer等
    • 数据格式化： 日期格式化等
    • 数据验证： 验证数据的有效性，包括长度、类型等等，验证结果存储到BindingResult或者Error中。
• 5、Handler执行完成后，像DispatcherServlet返回一个ModelAndView。
• 6、根据返回的ModelAndView选择一个合适的ViewResolver返回给DispatcherServlet
• 7、ViewResolveModel和View来渲染视图
• 8、将渲染结果返回给客户端

处理关键

• DispatcherServlet的HandlerMapping集合中根据请求的URL匹配每一个handlerMapping对象中的某个handler,匹配成功后将会返回这个handler的处理连接handlerExecutorChain对象，而这个对象中包括多个handlerInterceptor。
• HandlerInterceptor中包含三个方法
  • preHandler，在Handler执行之前调用。
  • postHandler，在Handler执行之后调用。
  • afterComplete，在view渲染完成后，dispatchServlet返回之前调用。
• 当preHandler返回false时，请求将在执行afterComplete后直接返回，不会执行handler。

首先有几个类需要声明,ModelAndView、HandlerExecutionChain、HandlerMapping、HandlerMethod、HandlerAdapter。

• 1、HandlerMethod(org.springframework.web.method.HandlerMethod)，这个类为中存放了某个bean对象和该bean对象的某个要处理的Method对象。
• 2、HandlerMapping,作用为通过request对象，获取对应的HandlerMethod对象。
• 3、HandlerExecutionChain作用为通过加入Interceptor拦截器包装HandlerMapping返回的HandlerMethod对象。让待处理的方法对象与拦截器称为一个整体,即执行链。
• 4、ModelAndView,顾名思义。Model即MVC的M，View即MVC的V。其对象存放的正是数据与视图信息。
• 5、HandlerAdapter:作用为具体处理HandlerMethod,即通过它调用某个方法。

接口

• ArrayList ： 继承自List接口
• LinkedList ： 继承自List和Deque接口

存储结构

• ArrayList ：底层用数组进行存储
• LinkedList ： 底层用双链表进行存储

优点

• ArrayList ： 访问速度快，插入和删除比较慢 ，需要移动元素
• LinkedList ： 访问比较慢，插入和删除比较快 ， 需要链式查询

顶级接口：

• Collection
  
• Map
  

顶级类：

• Collections

接口描述

• Collection ： 不提供直接子类继承，只提供继承的子接口（List和Set）

  • List : 有序的Collection，控制元素的插入位置，和通过索引访问List数据，允许相同的Key。

    • Verctor
      • Stack
    • ArrayList

    • LinkedList( 也继承自 Deque)

    • ArrayList和LinkedList对比

  • Set ： 不保存重复数据

    • HashSet
      • LinkedHashSet
    • SortedSet
      • TreeSet
    • EnumSet
  • Queue
    • DeQue
      • LinkedList
    • PriorityQueue
• Map
  • EnumMap
  • HashMap
    • LinkedHashMap
  • IdentityMap
  • HashTable
    • Properties
  • SortedMap
    • TreeMap
  • WeakHashMap

[TOC]

获取uuid和二维码：

• 在公众号输入8，即可返回二维码图片；
  • 生成uuid；
  • 生成二维码；
  • redis中保存要登陆用户的信息；
  • 返回二维码。

后台守护进程：

• 开启一个守护线程：
  • 获取redis中保存的用户信息；
  • 判断如果未登陆则继续执行以下操作，如果已经登陆了，返回，不做任何操作。
  • loginService.login()
    • 代码登陆逻辑，如果登陆了，将状态setAlive置为已经登陆，若未登陆，sleep1秒继续。
    • 将联系人信息保存到redis中
  • webWxInit()
    • 获取user信息，并保存到数据库。
    • 获取用户的联系人信息，并保存到数据库；
    • 获取SyncKeyBean信息，并保存到数据库；
  • wxStatusNotify()
    • 微信通知状态改变，手机端提示网页端登陆成功。
  • startReceiving()
    • 开启消息接收。
    • 开启新线程：
      • syncCheck() 检查是否有新消息
        • 状态为0(收到正常报文)：
          • webWxSync() 联网获取新消息；
            • 通过初始化过去的SyncKey参数进行获取，返回成功后，要把新返回的SyncKey保存到数据库中，下次用新SyncKey进行获取新信息。
            • 对获取到的新信息进行操作。 MsgCenter.produceMsg();
            • 保存消息到数据库。
  • webWxGetContact() 获取好友列表
  • WebWxBatchGetContact()
  • setUserInfo() 缓存本次好友信息。
  • CheckLoginStatusThread开启登陆状态线程。

2017.09.04

做好微信机器人，在微信公众平台界面发送8将返回一个二维码，扫码登陆后即可开启机器人。
机器人功能： //TODO

* 集成聊天机器人功能。
* 备份聊天记录。
* 爬取所有用户，并分析用户联系人的男女比例，整合头像。
* 爬取公众号文章。
* 撤回消息备份
* 关键词监听
* 消息搜索
* 信息分析
* 查看/删除文件[文件名] e.g. 查看文件[123345234.mp3]
* 撤回附件列表 (查看都有哪些保存在电脑中的已撤回附件)
* 清空附件列表 (清空已经保存在电脑中的附件)
* 添加关键词[关键词] e.g. 设置关键词[在不在]
* 删除关键词[关键词] e.g. 删除关键词[在不在]
* 清空关键词 清空已经设置的所有关键词
* 查看关键词 查看目前设置的关键词
* 添加签到口令#公众号:签到口令# e.g. 添加签到口令#招商银行信用卡:签到#
* 删除签到口令#公众号# e.g. 删除签到口令#招商银行信用卡#
* 查看签到口令 查看已经存在的公众和和对应的签到口令
* 清空签到口令 清空所有签到口令
* 截图 截取当前屏幕发送到文件助手
* 添加自动回复#针对的关键词:回复内容# e.g.添加自动回复#在不在:我现在有事情，待会儿回复你#
* 删除自动回复#针对的关键词# e.g.删除自动回复#在不在#
* 清空自动回复 清空所有的自定义回复规则
* 关闭自动回复
* 打开自动回复
* 退出程序

备份聊天功能：

* 发送 “开启**回复” 即可回复 ** 信息
  后台将配置记录到sql中，并缓存到redis中。

myisam和innodb不同之处

• 1事务的支持不同：
  • innodb支持事务；
  • myisam不支持事务；
• 2锁粒度
  • indodb行锁应用
  • myisam表锁
• 3存储空间
  • innodb既缓存索引文件又缓存数据文件；
  • myisam只缓存索引文件。
• 4存储结构
  • myisam数据文件的扩展名为.myd myData，索引文件的扩展名是.myi myIndex
  • innodb所有的表都保存在同一个数据文件里面 即为 .ibd
• 统计记录行数
  • myisam保存表的总行数，select count(*) from table 会直接取出该值
  • innodb没有保存表的中行书，select count(*) from table 就会遍历整个表，消耗相当大。

定义

HashMap实现了Map接口，继承自AbstactMap。其中Map接口定义了键映射到值的规则。
public class HashMap
extends AbstractMap
implements Map, Cloneable, Serializable

注意

* HashMap: 它根据键的hashCode值存储数据，大多数情况下可以直接定位到他的值，因此有很乖的访问速度，但是遍历的顺序是不确定的，HashMap最多只允许一条记录为null，允许多条记录的值为null，HashMap不是线程安全的，即任意时刻有多线程同时写HashMap可能会导致数据不一致问题。
* HashTable: HashTable是遗留类，很多映射的功能和HashMap类似，但是他是继承自Dictionary类，并且是线程安全的，任何时间只有一个线程能写hashTable。
* ConcurrentHashMap：
* LinkedHashMap: 是HashMap的一个自雷，保存了插入顺序，在用iterator遍历LinkedHashMap时，先得到的肯定是新插入的，也可以在构造式带参数，按照访问次数进行排序。
* TreeMap: TreeMap实现了SortMap接口，能够把保存的记录根据键排序，默认是按照键值升序排序，也可以指定排序的比较器，在使用TreeMap时，key必须实现Comparable接口或者在构造TreeMap传入自定义的Comparator，否则会在运行时抛出ClassCastExeption。

构造函数

• HashMap()：默认构造器，构造一个初始容量为10和默认加载银子为0.75的空HashMap
• HashMap(int initialCapacity):构造一个指定容量的和默认加载银子为0.75的空HashMap
• HashMap(int initialCapacity, float loadFactor)： 构造一个指定初始容量和加载银子的空HashMap；
  其中initialCapacity不能小于0，当它大于1 << 30的时候，它就等于1 << 30
  if (initialCapacity > MAXIMUM_CAPACITY)

        initialCapacity = MAXIMUM_CAPACITY;
  

初始容量：代表哈希表中通的数量，
加载因子： 代表哈希表在自动增加之前可以达到的尺度。

数据结构

列表散列：

数组+链表+红黑树(jdk8中增加红黑树)

HashMap的底层实现还是数组，只不过数组的每一项都是一条链，其中initialCapacity参数代表了该数组额长度。

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

 /**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

Node

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

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;    //用来定位数组索引位置
    final K key;
    V value;
    Node<K,V> next;   //链表的下一个node
    Node(int hash, K key, V value, Node<K,V> next) { ... }
    public final K getKey(){ ... }
    public final V getValue() { ... }
    public final String toString() { ... }
    public final int hashCode() { ... }
    public final V setValue(V newValue) { ... }
    public final boolean equals(Object o) { ... }
}

Node是HashMap的一个内部类，实现了Map.Entry接口，本质是一个映射（键值对）。

HashMap就是使用哈希表来存储的，哈希表为解决冲突，可以采用开放地址法和链地址法等来解决问题，java中HashMap采用了链地址法，简单来说就是数组加链表的结合。在每个数组元素都是一个链表结构，当数据被hash后，得到数组下标，把数据放在对应下标元素的链表上，例如：
map.put("name","earyant")
系统将”name”这个key的HashCode()方法得到其hashCode值，然后再通过Hash算法的后两步运算（高位运算和取模运算）来定位该键值对应的存储位置，有时候两个key会定位到相同的位置，表示发生了Hash碰撞，当然hash算法计算结果越分散均匀，Hash碰撞的概率就越小，map存取效率就会更高。
如果哈希桶数很大，即使较差的hash算法也会比较分散，如果哈希桶数组很小，就很容易发生碰撞。

容量

在理解Hash和扩容流程之前，我们得先了解下HashMap的几个字段。从HashMap的默认构造函数源码可知，构造函数就是对下面几个字段进行初始化，源码如下：

1
2
3
4

int threshold;             // 所能容纳的key-value对极限
final float loadFactor;    // 负载因子
int modCount;
int size;

• size：实际存在的键值对数量
• threshold：length*loadFactor
• modCount：记录HashMap内部结构发生裱花的次数，主要用于迭代的快速失败，内部结构变化指的是结构发生变化，比如put，但是某个key对应的value值被覆盖部署于结构变化。

在HashMap中，哈希桶数组table的长度length大小必须为2的n次方(一定是合数)，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数，具体证明可以参考http://blog.csdn.net/liuqiyao_01/article/details/14475159，Hashtable初始化桶大小为11，就是桶大小设计为素数的应用（Hashtable扩容后不能保证还是素数）。HashMap采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。

这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。本文不再对红黑树展开讨论，想了解更多红黑树数据结构的工作原理可以参考。
http://blog.csdn.net/v_july_v/article/details/6105630。

方法

• 确定哈希桶数组索引位置。
  不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步，

  1 2 3 4 5 6 7 8 9 10 11

  // 方法一： static final int hash(Object key) { //jdk1.8 & jdk1.7 int h; // h = key.hashCode() 为第一步 取hashCode值 // h ^ (h >>> 16) 为第二步 高位参与运算 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } // 方法二： static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的 return h & (length-1); //第三步 取模运算 }

  但是，模运算的消耗还是比较大的，在HashMap中是这样做的：调用方法二来计算该对象应该保存在table数组的哪个索引处。

这个方法非常巧妙，它通过h & (table.length -1)来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，这是HashMap在速度上的优化。当length总是2的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。

• put方法
  

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

 1   public V put(K key, V value) {
 2     // 对key的hashCode()做hash
 3     return putVal(hash(key), key, value, false, true);
 4 }
 5
 6 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 7                boolean evict) {
 8     Node<K,V>[] tab; Node<K,V> p; int n, i;
 9     // 步骤①：tab为空则创建
10     if ((tab = table) == null || (n = tab.length) == 0)
11         n = (tab = resize()).length;
12     // 步骤②：计算index，并对null做处理
13     if ((p = tab[i = (n - 1) & hash]) == null)
14         tab[i] = newNode(hash, key, value, null);
15     else {
16         Node<K,V> e; K k;
17         // 步骤③：节点key存在，直接覆盖value
18         if (p.hash == hash &&
19             ((k = p.key) == key || (key != null && key.equals(k))))
20             e = p;
21         // 步骤④：判断该链为红黑树
22         else if (p instanceof TreeNode)
23             e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
24         // 步骤⑤：该链为链表
25         else {
26             for (int binCount = 0; ; ++binCount) {
27                 if ((e = p.next) == null) {
28                     p.next = newNode(hash, key,value,null);
                        //链表长度大于8转换为红黑树进行处理
29                     if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
30                         treeifyBin(tab, hash);
31                     break;
32                 }
                    // key已经存在直接覆盖value
33                 if (e.hash == hash &&
34                     ((k = e.key) == key || (key != null && key.equals(k))))                                            break;
36                 p = e;
37             }
38         }
40         if (e != null) { // existing mapping for key
41             V oldValue = e.value;
42             if (!onlyIfAbsent || oldValue == null)
43                 e.value = value;
44             afterNodeAccess(e);
45             return oldValue;
46         }
47     }

48     ++modCount;
49     // 步骤⑥：超过最大容量 就扩容
50     if (++size > threshold)
51         resize();
52     afterNodeInsertion(evict);
53     return null;
54 }

扩容（resize）

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

    1 void resize(int newCapacity) {   //传入新的容量
    2     Entry[] oldTable = table;    //引用扩容前的Entry数组
 3     int oldCapacity = oldTable.length;
 4     if (oldCapacity == MAXIMUM_CAPACITY) {  //扩容前的数组大小如果已经达到最大(2^30)了
 5         threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
 6         return;
 7     }
 8
 9     Entry[] newTable = new Entry[newCapacity];  //初始化一个新的Entry数组
10     transfer(newTable);                         //！！将数据转移到新的Entry数组里
11     table = newTable;                           //HashMap的table属性引用新的Entry数组
12     threshold = (int)(newCapacity * loadFactor);//修改阈值
13 }

这里就是使用一个容量更大的数组来代替已有的容量小的数组，transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里。

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

1 void transfer(Entry[] newTable) {
 2     Entry[] src = table;                   //src引用了旧的Entry数组
 3     int newCapacity = newTable.length;
 4     for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
 5         Entry<K,V> e = src[j];             //取得旧Entry数组的每个元素
 6         if (e != null) {
 7             src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
 8             do {
 9                 Entry<K,V> next = e.next;
10                 int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
11                 e.next = newTable[i]; //标记[1]
12                 newTable[i] = e;      //将元素放在数组上
13                 e = next;             //访问下一个Entry链上的元素
14             } while (e != null);
15         }
16     }
17 }

感谢参考

参考

原文链接在此

mark，有很多地方还是需要学习的。

跟随大神学习SpringCloud的时候，在使用docker部署时，遇到了提供者注册不到eureka上去，教程地址在此

之后我搜了下docker进程间通信找到了一个解决办法：

我弄了一整天也是一直注册不进去，后来又搜了搜docker进程间通信，发现一个方法，
eureka-server部署的时候给一个名字： docker run —name eureka-server -p 8761:8761
server-hi中部署使用link参数 docker run —link eureka-server（server部署时赋予的名字）:eureka-server(配置中写的地址) ……
注册不进去的可以试试。