基于Vue2.x的自定义博客

最近闲来无事，就用Vue2.x模仿着自己的github博客手撸了一个博客，主要用到的技术有：VueX、Vue2.x、axios、iView、Router。最终的博客成果如下图：
在这里插入图片描述
在这里插入图片描述

博客架构图如下：
在这里插入图片描述

源码：https://gitee.com/Super_Jun/BlogDevByVue

开源说明：https://gitee.com/Super_Jun/BlogDevByVue/blob/master/README.md

我的朋友都去上海了，讨厌公司的用人套路，MMP，不开心，我也想去了。。。。。。

展开全文 >>

React和SpringBoot前后端分离开发模式下采用WebSocket实现单设备登录

首先介绍下，什么是单设备登录？
单设备登录可以理解为同一个应用某一时刻只允许单一用户使用处于登录状态。单设备登录可以类比QQ的踢出第二者登录模式，可以在一定的程度上保障账号的安全。

单设备登录的难点在哪？
单设备登录的难点在于如何主动、准确的推动消息到客户端。但是幸运的是我们可以通过WebSocket实现消息的准确推送，并且React中也有对应的WebSocket的Js依赖包可以使用。

下面将介绍详细的实现流程：
A、前端开发准备流程：
1、使用npm 安装正确的js依赖包：

1
npm install websockt

参考文章：阮一峰的WebSocket 教程

2、websocket前端实现代码：

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
 /**
  * 建立WS链接相关的方法;jSESSIONID:''
  * @param {*} wsUrl :建立webSocket链接的Url;
  */
  estabConnectWithWS(wsUrl) {
  const ws = new WebSocket(wsUrl);
  
  let result = "";
  ws.onopen = function (e) {
    console.log('连接上 ws 服务端了');
    ws.send(JSON.stringify({ flag: wsUrl, data: "Hello WebSocket!" }));
  }
  ws.onmessage = (msg)=> { 
      console.log('接收服务端发过来的消息: %o', msg); 
      var msgJson = JSON.parse(msg.data);
      result += msgJson.MsgBody + '\n';
      if (msgJson.MsgCode == "999999") {//多设备在线的异常发生时;
         window.location.href = '/#/';
      } else if (msgJson.MsgCode == "555555") {//用户退出系统的时候;
          ws.close();
          window.location.href = '/#/';
      }
      alert(msgJson.MsgBody);
  }; 
  ws.onclose = function (e) {
      console.log('ws 连接关闭了');
      console.log(e);
  }
  
}

主要步骤就是在登录校验通过后就建立和WebSocket服务终端的链接，并启动消息监听，在多用户登录的时候，前端弹出提示消息并跳转到登录页面，在用户执行退出操作的时候终断websocket链接并跳转到登录页面。

具体情境如下图所示：
这里写图片描述
B、websocket后端开发流程
1、在用户成功登录后创建session并存储用户的登录信息；
2、websocket客户端和websocket服务端握手成功之后，将第一步中的session中的数据放入WebSocketSession中，便于在MyWebSocketHandler中创建在线用户表，最终将根据在线用户表中的userId实现一对一的消息推送。
3、ws请求进入MyWebSocketHandler【ws处理】中，在ws链接建立的生命周期中进行合理的数据处理。

WebSocketInterceptor.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
package com.sds.socketInterceptor;
import java.io.IOException;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.server.HandshakeInterceptor;
import com.sds.enums.MsgEnum;
import com.sds.model.LoginerInfo;
import com.sds.model.WSMsg;
import com.sds.socketHandle.MyWebSocketHandler;
public class WebSocketInterceptor implements HandshakeInterceptor {
	@Override
	public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
			Map<String, Object> map) throws Exception {
		if (request instanceof ServletServerHttpRequest) {
			HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
			HttpSession session = servletRequest.getSession(false);
			if (session != null) {
				// 处理已经建立的链接;
				dealWithConnectioned(session);
				// 添加自定义的属性值到wobsocket中，便于进行访问控制，注意逻辑上的先后顺序;
				map.put("userInfo", session.getAttribute("userInfo"));
			}
		}
		return true;
	}
	@Override
	public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
			Exception exception) {
	}
	/**
	 * 处理多设备登录;
	 */
	public static boolean dealWithConnectioned(HttpSession userInfoStore) {
		boolean isConnectioned = false;
		LoginerInfo currentUserInfo = ((LoginerInfo) userInfoStore.getAttribute("userInfo"));
		String userId = null;
		if (null != currentUserInfo) {
			userId = ((LoginerInfo) userInfoStore.getAttribute("userInfo")).getUserId();
		} else {
			System.out.println("--CurrentUserInfo--Is----Null--");
		}
		Map<String, WebSocketSession> users = MyWebSocketHandler.users;
		if (null != users) {
			if (users.containsKey(userId)) {
				// 如果已经登录过，则推送"已登录过的提示"到客户端;
				// 客户端接受信息，请求退出系统的接口;
				// 清除session中保存的用户信息;
				WebSocketSession webSocketSession = users.get(userId);
				WSMsg wsMsg = new WSMsg(MsgEnum.FORCE_LOFOUT_MSG.getMsgCode(), MsgEnum.FORCE_LOFOUT_MSG.getMsgBody());
				TextMessage promptMsg = new TextMessage(wsMsg.getMsgJson());
				try {
					webSocketSession.sendMessage(promptMsg);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				// 从已登录用户列表中清除已经登录过的用户的信息记录;
				users.remove(userId);
				isConnectioned = true;
			}
		}
		return isConnectioned;
	}
}

MyWebSocketHandler.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
package com.sds.socketHandle;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import com.sds.enums.MsgEnum;
import com.sds.model.LoginerInfo;
import com.sds.model.WSMsg;
@Component
public class MyWebSocketHandler extends TextWebSocketHandler {
	// 在线用户列表
	public static final Map<String, WebSocketSession> users = new HashMap<String, WebSocketSession>();
	/**
	 * 连接已关闭，移除在Map集合中的记录
	 */
	@Override
	public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
		users.remove(getUserId(session));
	}
	@Override
	public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
		if (session.isOpen()) {
			session.close();
		}
		System.out.println("连接出错");
		users.remove(getUserId(session));
	}
	/**
	 * 连接建立成功之后，记录用户的连接标识，便于后面发信息
	 */
	@Override
	public void afterConnectionEstablished(WebSocketSession session) throws Exception {
		System.out.println("成功建立连接");
		String userId = getUserId(session);
		System.out.println(userId);
		if (userId != null) {
			users.put(userId, session);
			WSMsg wsMsg = new WSMsg(MsgEnum.CONNECTION_SUCCESS_MSG.getMsgCode(),
					MsgEnum.CONNECTION_SUCCESS_MSG.getMsgBody());
			TextMessage promptMsg = new TextMessage(wsMsg.getMsgJson());
			session.sendMessage(promptMsg);
		}
	}
	/**
	 * 处理收到的websocket信息
	 */
	@Override
	protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
	}
	/**
	 * 发送信息给指定用户
	 * 
	 * @param clientId
	 * @param message
	 * @return
	 */
	public boolean sendMessageToUser(String userId, String message) {
		if (users.get(userId) == null) {
			return false;
		}
		WebSocketSession session = users.get(userId);
		System.out.println("sendMessage:" + session);
		if (!session.isOpen()) {
			return false;
		}
		try {
			int count = 1;
			TextMessage textMessage = null;
			@SuppressWarnings("unused")
			String newMessage = "";
			// 循环向客户端发送数据
			// while (true) {
			newMessage = message + String.valueOf(count);
			textMessage = new TextMessage(message);
			session.sendMessage(textMessage);
			Thread.sleep(500);
			newMessage = "";
			// }
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		} catch (InterruptedException e) {
			e.printStackTrace();
			return false;
		}
	}
	/**
	 * 发送信息给指定用户的浏览器;
	 * 
	 * @param clientId
	 * @param message
	 * @return
	 */
	public boolean sendMessageToTargetFront(String userId, TextMessage message) {
		boolean isSendSuccessfully = true;
		WebSocketSession webSocketSession = users.get(userId);
		try {
			webSocketSession.sendMessage(message);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			isSendSuccessfully = false;
			e.printStackTrace();
		}
		return isSendSuccessfully;
	}
	/**
	 * 广播信息
	 * 
	 * @param message
	 * @return
	 */
	public boolean sendMessageToAllUsers(TextMessage message) {
		boolean allSendSuccess = true;
		Set<String> clientIds = users.keySet();
		WebSocketSession session = null;
		for (String clientId : clientIds) {
			try {
				session = users.get(clientId);
				if (session.isOpen()) {
					session.sendMessage(message);
				}
			} catch (IOException e) {
				e.printStackTrace();
				allSendSuccess = false;
			}
		}
		return allSendSuccess;
	}
	/**
	 * 获取用户标识
	 * 
	 * @param session
	 * @return
	 */
	private String getUserId(WebSocketSession session) {
		try {
			String userId = ((LoginerInfo) session.getAttributes().get("userInfo")).getUserId();
			return userId;
		} catch (Exception e) {
			return null;
		}
	}
}

源码：
React前端源码
SpringBoot后端源码

展开全文 >>

SpringBoot中Session监听器的使用

当需要统计应用的试试在线人数的时候，统计成功登录后创建的session的数量是最为准确的数据。SpringBoot通过SessionListener可以很方便的监听session的生命周期。在SpringBoot中监听session的步骤如下：
1、创建session监听器.

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
package com.sds.listenner;
import java.util.HashSet;
import javax.servlet.ServletContext;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
@WebListener
public class SessionListener implements HttpSessionListener, HttpSessionAttributeListener {
	public Logger logger = new Logger();
	@Override
	public void attributeAdded(HttpSessionBindingEvent httpSessionBindingEvent) {
		logger.info("--attributeAdded--");
		@SuppressWarnings("unused")
		HttpSession session = httpSessionBindingEvent.getSession();
		logger.info("key----:" + httpSessionBindingEvent.getName());
		logger.info("value---:" + httpSessionBindingEvent.getValue());
	}
	@Override
	public void attributeRemoved(HttpSessionBindingEvent httpSessionBindingEvent) {
		logger.info("--attributeRemoved--");
	}
	@Override
	public void attributeReplaced(HttpSessionBindingEvent httpSessionBindingEvent) {
		logger.info("--attributeReplaced--");
	}
	@Override
	public void sessionCreated(HttpSessionEvent event) {
		logger.info("---sessionCreated----");
		HttpSession session = event.getSession();
		ServletContext application = session.getServletContext();
		// 在application范围由一个HashSet集保存所有的session
		@SuppressWarnings("unchecked")
		HashSet<HttpSession> sessions = (HashSet<HttpSession>) application.getAttribute("sessions");
		if (sessions == null) {
			sessions = new HashSet<HttpSession>();
			application.setAttribute("sessions", sessions);
		}
		// 新创建的session均添加到HashSet集中
		sessions.add(session);
		// 可以在别处从application范围中取出sessions集合
		// 然后使用sessions.size()获取当前活动的session数，即为“在线人数”
		
		//添加新建的session到MySessionContext中;
		MySessionContext.AddSession(event.getSession());
	}
	@Override
	public void sessionDestroyed(HttpSessionEvent event) throws ClassCastException {
		logger.info("---sessionDestroyed----");
		HttpSession session = event.getSession();
		logger.info("deletedSessionId: " + session.getId());
		System.out.println(session.getCreationTime());
		System.out.println(session.getLastAccessedTime());
		ServletContext application = session.getServletContext();
		HashSet<?> sessions = (HashSet<?>) application.getAttribute("sessions");
		// 销毁的session均从HashSet集中移除
		sessions.remove(session);
		
		//添加新建的session到MySessionContext中;
        MySessionContext.DelSession(session);
	}
}

2、创建session处理工具类，里面需要一个静态的HashMap存储应用中登录后创建的有效的session.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.sds.listenner;
import java.util.HashMap;
import javax.servlet.http.HttpSession;
public class MySessionContext {
    private static HashMap<String, HttpSession> mymap = new HashMap<String, HttpSession>();
        public static synchronized void AddSession(HttpSession session) {
                if (session != null) {
                        mymap.put(session.getId(), session);
                     }
             }
         public static synchronized void DelSession(HttpSession session) {
                 if (session != null) {
                         mymap.remove(session.getId());
                     }
             }
         public static synchronized HttpSession getSession(String session_id) {
                if (session_id == null)
                     return null;
                 return mymap.get(session_id);
             }
}

Logger.java

1
2
3
4
5
6
7
package com.sds.listenner;
public class Logger {
	public void info(String info) {
		System.out.println(info);
	}
}

3、添加SessionListener到系统配置中:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.sds.cfg;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@Configuration
public class SessionConfiguration extends WebMvcConfigurerAdapter{
    //注册session监听器;
    @Bean
    public ServletListenerRegistrationBean<SessionListener> servletListenerRegistrationBean() {
        ServletListenerRegistrationBean<SessionListener> slrBean = new ServletListenerRegistrationBean<SessionListener>();
        slrBean.setListener(new SessionListener());
        return slrBean;
    }
}

原理：通过SessionListener监听session的创建和销毁，并在对应的session生命周期中从静态的HashMap【自定义的session容器】中添加或者删除对应的session，从而实现session的动态管理，提供准确的统计数据。

注意：在本例中提供了根据sessionId获取session的方法。

展开全文 >>

使用JSOUP爬取国家统计局的地理位置数据

最近因工作需要，我需要爬取国家统计局的最新统计数据。因此参照网上的例子使用JSOUP爬取了国家统计局的省、市、县、镇、村的数据。因为要爬取的数据较多，因此在里面使用了多线程的相关技术。下面首先讲解下多线程相关的东西。

首先理解下什么是线程池？
因为创建和销毁线程是一件非常耗费时间的工作，因此，如果线程可以再一定程度上复用，那么肯定可以再节省不少的时间。线程池的作用可以类比MYSQL中的连接池理解。
参考文章：Java常用四大线程池用法以及ThreadPoolExecutor详解

其次是多线程中的Future模式。
因为爬取的省份较多，因此需要多个线程并发执行，但是必须保证在IO操作的写操作执行前，所有的数据都已经爬取完毕。因此，必须使用多线程的Future模式，Future模式可以保证多个线程并发执行，并且可以通过future.get()方法在适当的地方进行线程堵塞，保证在结果输出前各个子线程已经执行结束。因为在调用到某个子线程的future.get()方法之前，各个子线程会继续并发执行，因此，调用future.get()方法阻塞主线程消耗的时间会非常的少，因此可以再一定的程度上节省时间开销。

1
2
3
4
5
6
      /**
 * 等待所有的子线程执行完毕
 */
for (Future future : futureList) {
	future.get();
}

Future模式的参考文章：Java多线程 - Future模式

最后讲述下说说Runnable与Callable的区别：
二者的实际异同为以下几点：
相同点：
1、 两者都是接口；（废话）
2、两者都可用来编写多线程程序；
3、两者都需要调用Thread.start()启动线程；
不同点：
1、两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
2、Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；
注意点：
Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

参考文章：说说Runnable与Callable

下面是使用Jsoup爬取国家统计局数据的具体代码：
这里写图片描述

源码：Jsoup爬取国家统计局的数据

展开全文 >>

SpringBoot中RabbitMQ的使用详解

最近在公司的代码里面看到RabbitMQ相关的代码，于是带着好奇心研究了下RabbitMQ.
RabbitMQ的核心是交换机和队列。
交换机的功能主要是接收消息并且转发到绑定的队列，交换机不存 储消息，在启用ack模式后，交换机找不到队列会返回错误。队列用于临时存储消息和转发消息。
交换机有四种类型：Direct, topic, Headers and Fanout。
Direct：direct 类型的行为是”先匹配, 再投送”. 即在绑定时设定一个 routing_key, 消息的routing_key 匹配时, 才会被交换器投送到绑定的队列中去.[精确匹配类型]
Topic：按规则转发消息（最灵活）[模式匹配]
Headers：设置header attribute参数类型的交换机
RabbitMQ的队列类型有两种，即时队列和延时队列【DelayQueue】。
即时队列：队列中的消息会被立即消费;
延时队列：队列中的消息会在指定的时间延时之后被消费。
下面将从即时队列和延时队列的具体实现来详解RabbitMQ.

即时队列详解：
DirectExchange：

DirectExchangeTest.java

1
2
3
4
@Test
	public void helloTest() throws Exception {
		helloSender.send();
	}

HelloSender.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.neo.rabbit.hello;
import java.util.Date;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class HelloSender {
	@Autowired
	private AmqpTemplate rabbitTemplate;
	public void send() {
		String context = "hello " + new Date()+" sender is JunZhou";
		System.out.println("Sender/this messag is send by zj : " + context);
		this.rabbitTemplate.convertAndSend("hello", context);
	}
}

HelloReceiver.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.neo.rabbit.hello;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = "hello")
public class HelloReceiver {
    @RabbitHandler
    public void process(String hello) {
        System.out.println("Receiver  : " + hello);
    }
}

RabbitConfig.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
package com.neo.rabbit;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//@Configuration这个注解是必须的，保证在基本类实例化之前该类已经被实例化
@Configuration
public class RabbitConfig {
	
	@Autowired
	@Qualifier("defaultDirectExchange")
	private DirectExchange exchange;
	//创建队列,注意加注解;
    @Bean
    public Queue hiQueue() {
        return new Queue("hello");
    }
    @Bean
    public Queue neoQueue() {
        return new Queue("neo");
    }
    @Bean
    public Queue objectQueue() {
        return new Queue("object");
    }
    
    //绑定队列;
    @Bean
	public Binding  helloBinding() {
		return BindingBuilder.bind(hiQueue()).to(exchange).with("hello");
	}
}

FanoutExchange：

FanoutExchangeTest.java

1
2
3
4
@Test
	public void fanoutSenderTest(){
		fanoutSender.send();
	}

FanoutSender .java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.neo.rabbit.fanout;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class FanoutSender {
	@Autowired
	private AmqpTemplate rabbitTemplate;
	
	public void send() {
		String context = "Sender from JunZhou 20180806 : hi, fanout msg ";
		System.out.println("Sender from JunZhou 20180806 : " + context);
//在fancout模式下，所有绑定到该交换机的队列均会收到交换机发出的消息，因此队列的名称会被忽略不计，因此`convertAndSend(exchangeName,queueName,Msg);`中的第二个参数可以用“”代替;		
this.rabbitTemplate.convertAndSend("fanoutExchange","", context);
	}
}

FanoutReceiverA .java……FanoutReceiverC .java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.neo.rabbit.fanout;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {
    @RabbitHandler
    public void process(String message) {
        System.out.println("fanout Receiver A  : " + message);
    }
}

FanoutRabbitConfig.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
package com.neo.rabbit;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FanoutRabbitConfig {
    @Bean
    public Queue AMessage() {
        return new Queue("fanout.A");
    }
    @Bean
    public Queue BMessage() {
        return new Queue("fanout.B");
    }
    @Bean
    public Queue CMessage() {
        return new Queue("fanout.C");
    }
    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }
    
    @Bean
    Binding bindingExchangeA() {
        return BindingBuilder.bind(AMessage()).to(fanoutExchange());
    }
    @Bean
    Binding bindingExchangeB() {
        return BindingBuilder.bind(BMessage()).to(fanoutExchange());
    }
    @Bean
    Binding bindingExchangeC() {
        return BindingBuilder.bind(CMessage()).to(fanoutExchange());
    }
}

TopicExchangeTest.java

1
2
3
4
5
6
@Test
	public void topicSenderTest(){
		//topicSender.send();
		//topicSender.send1();
		topicSender.send2();
	}

TopicSender .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
package com.neo.rabbit.topic;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class TopicSender {
	@Autowired
	private AmqpTemplate rabbitTemplate;
	public void send() {
		String context = "hi, i am message all";
		System.out.println("Sender : " + context);
		this.rabbitTemplate.convertAndSend("topicExchange", "topic.1", context);
	}
	public void send1() {
		String context = "hi, i am message 1";
		System.out.println("Sender : " + context);
		this.rabbitTemplate.convertAndSend("topicExchange", "topic.message", context);
	}
	public void send2() {
		String context = "hi, i am messages 2";
		System.out.println("Sender : " + context);
		this.rabbitTemplate.convertAndSend("topicExchange", "topic.messages", context);
	}
}

TopicReceiver .java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.neo.rabbit.topic;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = "topic.message")
public class TopicReceiver {
    @RabbitHandler
    public void process(String message) {
        System.out.println("Topic Receiver1  : " + message);
    }
}

TopicReceiver2 .java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.neo.rabbit.topic;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = "topic.messages")
public class TopicReceiver2 {
    @RabbitHandler
    public void process(String message) {
        System.out.println("Topic Receiver2  : " + message);
    }
}

TopicRabbitConfig .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
package com.neo.rabbit;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class TopicRabbitConfig {
    final static String message = "topic.message";
    final static String messages = "topic.messages";
    @Bean
    public Queue queueMessage() {
        return new Queue(TopicRabbitConfig.message);
    }
    @Bean
    public Queue queueMessages() {
        return new Queue(TopicRabbitConfig.messages);
    }
    @Bean
    TopicExchange exchange() {
        return new TopicExchange("topicExchange");
    }
    @Bean
    Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) {
        return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
    }
    @Bean
    Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) {
        return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");
    }
}

topic 和 direct 类似, 只是匹配上支持了”模式”, 在”点分”的 routing_key 形式中, 可以使用两个通配符:
“*”表示一个词.
“#”表示零个或多个词.

在上面的TopicExchange中，当调用send1()方法，执行this.rabbitTemplate.convertAndSend("topicExchange","topic.message", context);时，实际上只有两个队列,即采用with(“topic.#”);和with(“topic.message”);绑定的两个队列会接受到消息;

以上就是非常简单的即时队列的详解，线面是延时队列的详解。

延时队列有哪些用处呢？打个比方，加入用户下了单，但是在30分钟内没有支付我们就返回支付失败提示这个情景就可以采用延时队列来处理。
延时队列的原理图如下：
这里写图片描述

客户端：指具体往MQ发生消息端， 客户端将消息内容进行自定义包装， 将消息中附带目标队列名称。如：客户端向队列Q1发送字符串“hello” , 延时时间为60秒， 包装后修改为{“queueName”:”Q1”,”body”: “hello”}，此时，将消息发送到DLX死信队列，而非Q1队列，并将消息设置为60秒超时。

DLX：死信队列，用来存储有超时时间信息的消息， 并且可以设置当消息超时时，转发到另一个指定队列(此处设置转发到router), 死信队列无消费者，当接收到客户端消息之后，等待消息超时，将消息转发到指定的Router队列

Router: 转发队列，用来接收死信队列超时消息， 如上示例消息，在接收到之后，消费者将消息解析，获取queueName，body,再向所获取的queueName队列中发送一条消息，内容为body.

延时队列的具体实现代码如下：
DelaySendTest.java

1
2
3
4
5
6
7
8
@Test
	public void delaySendTest(){
		System.out.println("发送延迟消息...");
		QueueMessage message = new QueueMessage("app.queue.hello","测试延时消息...");
		message.setType(20);//20代表延时消息队列;
		message.setSeconds(600);//设置延时时间,单位为毫秒;
		messageQueueService.send(message);
	}

QueueMessage.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
package com.neo.rabbit.DelayMQ.Model;
import java.util.Date;
public class QueueMessage {
	private String exchange;
	private String queueName;
	private Integer type;
	private Integer group;
	private Date timestamp;
	private String message;
	private Integer status;
	private int retry = 0;
	private int maxRetry = 10;
	private int seconds = 1;
	public QueueMessage() {
		super();
	}
	
	public QueueMessage(String queueName, String message) {
		super();
		this.queueName = queueName;
		this.message = message;
		this.exchange = "default.direct.exchange";
		this.type = 10;
		this.group = 10;
		this.timestamp = new Date();
		this.status = 10;
	}
	public String getExchange() {
		return exchange;
	}
	public void setExchange(String exchange) {
		this.exchange = exchange;
	}
	public String getQueueName() {
		return queueName;
	}
	public void setQueueName(String queueName) {
		this.queueName = queueName;
	}
	public Integer getType() {
		return type;
	}
	public void setType(Integer type) {
		this.type = type;
	}
	public Integer getGroup() {
		return group;
	}
	public void setGroup(Integer group) {
		this.group = group;
	}
	public Date getTimestamp() {
		return timestamp;
	}
	public void setTimestamp(Date timestamp) {
		this.timestamp = timestamp;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
	public Integer getStatus() {
		return status;
	}
	public void setStatus(Integer status) {
		this.status = status;
	}
	public int getRetry() {
		return retry;
	}
	public void setRetry(int retry) {
		this.retry = retry;
	}
	public int getMaxRetry() {
		return maxRetry;
	}
	public void setMaxRetry(int maxRetry) {
		this.maxRetry = maxRetry;
	}
	public int getSeconds() {
		return seconds;
	}
	public void setSeconds(int seconds) {
		this.seconds = seconds;
	}
}

MessageException.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
package com.neo.rabbit.DelayMQ.exception;
public class MessageException extends RuntimeException{
	private static final long serialVersionUID = 140085406084367372L;
	private int code ;
	
	private String message;
	
	private String data;
	
	public MessageException() {
		super();
	}
	public MessageException(int code, String message) {
		super(message);
		this.code = code;
		this.message = message;
	}
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
	public String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}
	
}

DeafaultMessageServiceImpl.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
package com.neo.rabbit.DelayMQ.service.impl;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.neo.rabbit.DelayMQ.Model.QueueMessage;
import com.neo.rabbit.DelayMQ.exception.MessageException;
import com.neo.rabbit.DelayMQ.service.IMessageQueueService;
import com.neo.rabbit.DelayMQ.utils.JSONUtils;
import com.neo.rabbit.DelayMQ.utils.StringUtils;
@Service("deafaultMessageService")
public class DeafaultMessageServiceImpl implements IMessageQueueService{
	@Autowired
	private RabbitTemplate rabbitTemplate;
	
	@Override
	public void send(QueueMessage message) {
		this.checkMessage(message);
		if(message.getType() == 10){//即时消息
			this.sendMessage(message.getExchange(),message.getQueueName(),message.getMessage());
		}
		if(message.getType() == 20){//延时消息
			sendTimeMessage(message);
		}
	}
	
	//发送即时消息;
	private void sendMessage(String exchange,String queueName,String msg){
		rabbitTemplate.convertAndSend(exchange,queueName, msg);
	}
	
	//发送延时消息;
	public void sendTimeMessage(QueueMessage message) {
		int seconds = message.getSeconds();
		if(seconds <= 0){// 直接发送，无需进入死信队列
			sendMessage(message.getExchange(),message.getQueueName(), message.getMessage());
		}else{
			long times = seconds * 1000;//rabbit默认为毫秒级
			//这里需要字符定义延时处理器;
			MessagePostProcessor processor = new MessagePostProcessor(){
				@Override
				public Message postProcessMessage(Message message) throws AmqpException {
					message.getMessageProperties().setExpiration(times + "");
					return message;
				}
			};
			rabbitTemplate.convertAndSend("default.direct.exchange","default.dead.letter.queue", JSONUtils.toJson(message), processor);
		}
	}
	
	private void checkMessage(QueueMessage message){
		if (StringUtils.isNullOrEmpty(message.getExchange())) {
			throw new MessageException(10, "发送消息格式错误: 消息交换机(exchange)不能为空!");
		}
		if(message.getGroup() == null){
			throw new MessageException(10, "发送消息格式错误: 消息组(group)不能为空!");
		}
		if(message.getType() == null){
			throw new MessageException(10, "发送消息格式错误: 消息类型(type)不能为空!");
		}
		if(message.getStatus() == null){
			throw new MessageException(10, "发送消息格式错误: 消息状态(status)不能为空!");
		}
		if(StringUtils.isNullOrEmpty(message.getQueueName())){
			throw new MessageException(10, "发送消息格式错误: 消息目标名称(queueName)不能为空!");
		}
		if (StringUtils.isNullOrEmpty(message.getMessage())) {
			throw new MessageException(10, "发送消息格式错误: 消息内容(message)不能为空!");
		}
	}
}

QueueConfiguration.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
package com.neo.rabbit.DelayMQ.mqconfig;
import java.util.HashMap;
import java.util.Map;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class QueueConfiguration {
	/**
	 * 默认即时消息交换机
	 * @return
	 */
	@Bean("defaultDirectExchange")
	public DirectExchange defaultDirectExchange() {
		return new DirectExchange("default.direct.exchange", true, false);
	}
	
	
	/**
	 * 默认延迟消息死信队列
	 * @return
	 */
	@Bean
	public Queue defaultDeadLetterQueue() {
		Map<String, Object> arguments = new HashMap<>();
		arguments.put("x-dead-letter-exchange","default.direct.exchange");//设置交换机路由
		arguments.put("x-dead-letter-routing-key", "default.repeat.trade.queue");//设置转发队列名称
		Queue queue = new Queue("default.dead.letter.queue",true,false,false,arguments);
		return queue; 
	}
	@Bean
	public Binding  defaultDeadLetterBinding() {
		Binding bind = BindingBuilder.bind(defaultDeadLetterQueue()).to(defaultDirectExchange()).with("default.dead.letter.queue");
		return bind;
	}
	
	
	/**
	 * 默认延迟消息死信接受转发消息队列
	 * @return
	 */
	@Bean
	public Queue defaultRepeatTradeQueue() {
		Queue queue = new Queue("default.repeat.trade.queue",true,false,false);
		return queue; 
	}
	
	/**
	 * 转发队列和默认交换机的绑定;
	 * @return
	 */
	@Bean
	public Binding  defaultRepeatTradeBinding() {
		return BindingBuilder.bind(defaultRepeatTradeQueue()).to(defaultDirectExchange()).with("default.repeat.trade.queue");
	}
	
	@Bean
	public Queue helloQueue() {
		Queue queue = new Queue("app.queue.hello",true,false,false);
		return queue; 
	}
	
	@Bean
	public Binding  helloBinding() {
		return BindingBuilder.bind(helloQueue()).to(defaultDirectExchange()).with("app.queue.hello");
	}
}

TradeProcessor.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
package com.neo.rabbit.DelayMQ.receiver;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.neo.rabbit.DelayMQ.Model.QueueMessage;
import com.neo.rabbit.DelayMQ.service.IMessageQueueService;
import com.neo.rabbit.DelayMQ.utils.JSONUtils;
/**
 * 
 * @author victor
 * @desc 死信接收处理消费者
 */
@Component
@RabbitListener(queues = "default.repeat.trade.queue")
public class TradeProcessor {
	
	@Autowired
	private IMessageQueueService messageQueueService;
	@RabbitHandler
    public void process(String content) {
		System.out.println("-----------延时结束--------------");
		QueueMessage message = JSONUtils.toBean(content, QueueMessage.class);
		message.setType(10);
		messageQueueService.send(message);
    }
}

HelloProcessor.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.neo.rabbit.DelayMQ.receiver;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
@RabbitListener(queues = "app.queue.hello")
public class HelloProcessor {
	@RabbitHandler
    public void process(String content) {
		System.out.println("hello 接受消息：" + content);
    }
}

延时队列在可视化界面的表现形式为：
这里写图片描述

其实最终的原理非常简单：
归纳起来就是：客户端发送消息到指定的交换机，进入死信队列【死信队列没有消费者】，在死信队列里超时处理器等待消息超时，消息超时后转发消息给转发队列，转发队列的消息消费者监听到消息后进行对应的逻辑处理即可。

参考文章：
RabbitMQ详解
Rabbitmq集成,延时消息队列实现
SpringBoot应用之消息队列

源码：
rabbitmq延时队列和四种交换机模式下队列的简单实现

展开全文 >>

枚举实现单例的原理

最近因为工作需要需要实现单例模式，考虑到单例模式最简单的实现方式是枚举实现，因此研究了下枚举实现单例模式的原理，下面将从原理、详解两个步骤说明：
一：原理
1、单例模式利用了“()” 方法在类加载的过程中线程安全的实例化了一个实例；
【 “()” 是由编译器自动收集类中的所有类变量（static）的赋值动作和静态语句块（static{}）块中的语句合并产生的。因此，private static Singleton singleton = new Singleton();也会被放入到这个方法中。】
2、枚举类的构造器是private私有的，保障了内存中只有枚举的一个实例；
二：详解
1）、为什么说枚举实例是单例且线程安全的？
就拿枚举来说，其实Enum就是一个普通的类，它继承自`java.lang.Enum类。

1
2
3
public enum SingletonEnum{
			    SINGLETON;
			}
对Singleton进行反编译可以得到如下java类：

1
2
3
4
5
6
public final class SingletonEnum extends Enum<SingletonEnum> {
      public static final SingletonEnum SINGLETON;
      public static SingletonEnum[] values();
      public static SingletonEnum valueOf(String s);
      static {};
}

由反编译后的代码可知，SINGLETON被声明为 static 的【 public static final SingletonEnum SINGLETON<==>public static final SingletonEnum SINGLETON = New SingletonEnum （）;】，根据类加载过程可以知道虚拟机会保证一个类的() 方法在多线程环境中被正确的加锁、同步。所以，枚举实现是在实例化时是线程安全。
2）、如何保证枚举实例的单例？
首先

1
2
3
public enum SingletonEnum{
			    SINGLETON;
			}

的实质是：

1
2
3
4
5
public enum SingletonEnum{
			    SINGLETON;
			    ......
			    private SingletonEnum(){......}
			}

因此外部无法通过构造器创建枚举类的实例，这也是枚举类通常用来保存常量的一个原因之一。
其次，枚举类的实例会在类加载的时候线程安全的进行初始实例化，在类加载的时候，JVM会对()方法加锁，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。需要注意的是，其他线程虽然会被阻塞，但如果执行()方法的那条线程退出()方法后，其他线程唤醒后不会再次进入()方法。同一个类加载器下，一个类型只会初始化一次。
综上所述，枚举保证了枚举实例的线程安全和单例性;

参考文章：
浅谈使用单元素的枚举类型实现单例模式
java回顾篇—static和非static的区别
一个简单java程序的运行全过程
static关键字的四种用法

展开全文 >>

MySQL优化之------索引原理

最近大佬优化了一条SQL，讲100万条的数据查询速度从27s降低到了0.8S,因此研究了下MySQL优化的原理和方式。下面将从Mysql中索引的本质，原理等方面介绍下MySQL中的索引原理。

1、MySQL中数据的存储方式;

mysql的数据在磁盘上的存储：
A、数据块：
由多个磁盘block组成的块，存储引擎负责管理数据块。
磁盘是block块设备，数据在磁盘上的存放也是按照块存放的。
mysql读取表到内存的时候，也必然是按照一块一块的方式读取。假设 要查询的表在和其他表在都在同一个块内。加载块的时候除了读取要查询的表，其他表也一并被读取出来。
当一个块内的部分表被删除时，这是就是形成了碎片。这样会降低装载到内存的速度。
所以会生成一个块头，记录一个快内表的大小，有无空闲空间，空闲空间的位置。
B、散列文件组织：
人为将表分成多个部分，每个部分称为桶。根据行中的某个或某些字段做使用散列函数做哈希运算，运算结果属于某个范围的放在指定的桶中。多个桶组成一个表。
桶有可能溢出。所以要选定一个合适散列函数，让行平均在各个桶中。

2、什么是MySQL的索引;

引用块内容
MySQL官方对索引的定义为：索引(Index)是帮助MySQL高效获取数据的数据结构。我们可以简单理解为：快速查找排好序的一种数据结构。Mysql索引主要有两种结构：B+Tree索引和Hash索引。我们平常所说的索引，如果没有特别指明，一般都是指B树结构组织的索引(B+Tree索引)。索引也是一种数据，需要占用物理空间。B+Tree索引索引的数据结构如图所示：
这里写图片描述
3、MySQL中索引【hash和BTree】的实现原理;
……等我研究下两种算法再确定。
4、两种索引【hash和BTree】的区别和缺点；
一、BTree
BTree索引是最常用的mysql数据库索引算法，因为它不仅可以被用在=,>,>=,<,<=和between这些比较操作符上，而且还可以用于like操作符，只要它的查询条件是一个不以通配符开头的常量，例如：
select from user where name like ‘jack%’;
select from user where name like ‘jac%k%’;
如果一通配符开头，或者没有使用常量，则不会使用索引，例如：
select from user where name like ‘%jack’;
select from user where name like simply_name;
二、Hash
Hash索引只能用于对等比较，例如=,<=>（相当于=）操作符。由于是一次定位数据，不像BTree索引需要从根节点到枝节点，最后才能访问到页节点这样多次IO访问，所以检索效率远高于BTree索引。
但为什么我们使用BTree比使用Hash多呢？主要Hash本身由于其特殊性，也带来了很多限制和弊端：

  1. Hash索引仅仅能满足“=”,“IN”,“<=>”查询，不能使用范围查询。
  2. 联合索引中，Hash索引不能利用部分索引键查询。
    对于联合索引中的多个列，Hash是要么全部使用，要么全部不使用，并不支持BTree支持的联合索引的最优前缀，也就是联合索引的前面一个或几个索引键进行查询时，Hash索引无法被利用。
  3. Hash索引无法避免数据的排序操作
    由于Hash索引中存放的是经过Hash计算之后的Hash值，而且Hash值的大小关系并不一定和Hash运算前的键值完全一样，所以数据库无法利用索引的数据来避免任何排序运算。
  4. Hash索引任何时候都不能避免表扫描
    Hash索引是将索引键通过Hash运算之后，将Hash运算结果的Hash值和所对应的行指针信息存放于一个Hash表中，由于不同索引键存在相同Hash值，所以即使满足某个Hash键值的数据的记录条数，也无法从Hash索引中直接完成查询，还是要通过访问表中的实际数据进行比较，并得到相应的结果。
  5. Hash索引遇到大量Hash值相等的情况后性能并不一定会比BTree高
    对于选择性比较低的索引键，如果创建Hash索引，那么将会存在大量记录指针信息存于同一个Hash值相关联。这样要定位某一条记录时就会非常麻烦，会浪费多次表数据访问，而造成整体性能底下。

5、参考文章。
1、 mysql之mysql数据在磁盘的储存方式
2、索引的优缺点
3、什么是索引？Mysql目前主要的几种索引类型
4、MySQL的索引是什么？怎么优化？
5、深入理解MySQL索引原理和实现——为什么索引可以加速查询？
6、数据库索引系列四：索引算法Hash与BTree的区别
7、MySQL优化原理

展开全文 >>

Vue中v-if 与 v-show 的区别？

在切换 v-if 块时，Vue.js 有一个局部编译/卸载过程，因为 v-if 之中的模板也可能包括数据绑定或子组件。v-if 是真实的条件渲染，因为它会确保条件块在切换当中合适地销毁与重建条件块内的事件监听器和子组件。
v-if 也是惰性的：如果在初始渲染时条件为假，则什么也不做——在条件第一次变为真时才开始局部编译（编译会被缓存起来）。
相比之下，v-show 简单得多——元素始终被编译并保留，只是简单地基于 CSS 切换。
一般来说，v-if 有更高的切换消耗而 v-show 有更高的初始渲染消耗。因此，如果需要频繁切换 v-show 较好，如果在运行时条件不大可能改变 v-if 较好。

v-if 是动态添加，当值为 false 时，是完全移除该元素，即 dom 树中不存在该元素。
v-show 仅是隐藏 / 显示，值为 false 时，该元素依旧存在于 dom 树中。若其原有样式设置了 display: none 则会导致其无法正常显示。

参考文章:Vue.js 条件与循环

展开全文 >>

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>而是,我本可以!