package com.zone.weixin4j.dispatcher;
import com.zone.weixin4j.annotation.WxMessageHandler;
import com.zone.weixin4j.annotation.WxMessageInterceptor;
import com.zone.weixin4j.exception.HttpResponseException;
import com.zone.weixin4j.exception.MessageInterceptorException;
import com.zone.weixin4j.exception.WeixinException;
import com.zone.weixin4j.handler.DebugMessageHandler;
import com.zone.weixin4j.handler.WeixinMessageHandler;
import com.zone.weixin4j.interceptor.WeixinMessageInterceptor;
import com.zone.weixin4j.request.WeixinMessage;
import com.zone.weixin4j.request.WeixinRequest;
import com.zone.weixin4j.response.BlankResponse;
import com.zone.weixin4j.response.WeixinResponse;
import com.zone.weixin4j.service.WeiXin4jContextAware;
import com.zone.weixin4j.service.context.WeiXin4jContextAwareImpl;
import com.zone.weixin4j.socket.WeixinMessageTransfer;
import com.zone.weixin4j.util.ServerToolkits;
import com.zone.weixin4j.xml.MessageTransferHandler;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import java.io.ByteArrayInputStream;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
* 微信消息分发器
*
* @author jinyu(foxinmy@gmail.com)
* @className WeixinMessageDispatcher
* @date 2015年5月7日
* @updateBy Yz(174975857@qq.com)
* @since JDK 1.6
*/
@Component
@DependsOn({"weiXin4jContextAware"})
public class WeixinMessageDispatcher {
@Autowired
private WeiXin4jContextAware weiXin4jContextAware;
private final Log logger = LogFactory.getLog(getClass());
/**
* 消息处理器
*/
private List<WeixinMessageHandler> messageHandlerList = new ArrayList<WeixinMessageHandler>();
private WeixinMessageHandler[] messageHandlers;
/**
* 消息拦截器
*/
private List<WeixinMessageInterceptor> messageInterceptorList = new ArrayList<WeixinMessageInterceptor>();
private WeixinMessageInterceptor[] messageInterceptors;
/**
* 消息匹配
*/
private WeixinMessageMatcher messageMatcher;
/**
* 消息转换
*/
private Map<Class<? extends WeixinMessage>, Unmarshaller> messageUnmarshaller;
/**
* 是否总是响应请求,如未匹配到MessageHandler时回复空白消息
*/
private boolean alwaysResponse;
public WeixinMessageDispatcher() {
this(new DefaultMessageMatcher());
}
public WeixinMessageDispatcher(WeixinMessageMatcher messageMatcher) {
this.messageMatcher = messageMatcher;
this.messageUnmarshaller = new ConcurrentHashMap<Class<? extends WeixinMessage>, Unmarshaller>();
}
@PostConstruct
public void init() {
try {
this.getMessageHandlers();
this.getMessageInterceptors();
if (weiXin4jContextAware.isOpenAlwaysResponse()) {
this.openAlwaysResponse();
}
if (weiXin4jContextAware.isUseDebugMessageHandler()) {
if(null == messageHandlerList){
messageHandlerList = new ArrayList<WeixinMessageHandler>();
messageHandlerList.add(DebugMessageHandler.global);
}
}
this.messageMatcher = weiXin4jContextAware.getWeixinMessageMatcher() == null ? new DefaultMessageMatcher() : weiXin4jContextAware.getWeixinMessageMatcher();
this.messageUnmarshaller = new ConcurrentHashMap<Class<? extends WeixinMessage>, Unmarshaller>();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 对消息进行一系列的处理,包括 拦截、匹配、分发等动作
*
* @param request 微信请求
* @throws WeixinException
*/
public WeixinResponse doDispatch(final WeixinRequest request) throws WeixinException, HttpResponseException, MessageInterceptorException {
WeixinMessageTransfer messageTransfer = MessageTransferHandler.parser(request);
WeiXin4jContextAwareImpl.getWeixinMessageTransfer().set(messageTransfer);
WeixinMessageKey messageKey = defineMessageKey(messageTransfer, request);
Class<? extends WeixinMessage> targetClass = messageMatcher.match(messageKey);
WeixinMessage message = messageRead(request.getOriginalContent(), targetClass);
logger.info(String.format("define %s matched %s", messageKey, targetClass));
MessageHandlerExecutor handlerExecutor = getHandlerExecutor(request, messageKey, message, messageTransfer.getNodeNames());
if (handlerExecutor == null || handlerExecutor.getMessageHandler() == null) {
return noHandlerFound(request, message);
}
if (!handlerExecutor.applyPreHandle(request, message)) {
throw new MessageInterceptorException(" Interceptor Not Accept !! ");
}
Exception exception = null;
WeixinResponse response = null;
try {
response = handlerExecutor.getMessageHandler().doHandle(request, message, messageTransfer.getNodeNames());
handlerExecutor.applyPostHandle(request, response, message);
} catch (Exception e) {
exception = e;
}
handlerExecutor.triggerAfterCompletion(request, response, message, exception);
return response;
}
/**
* 声明messagekey
*
* @param messageTransfer 基础消息
* @param request 请求信息
* @return
*/
protected WeixinMessageKey defineMessageKey(
WeixinMessageTransfer messageTransfer, WeixinRequest request) {
return new WeixinMessageKey(messageTransfer.getMsgType(),
messageTransfer.getEventType(),
messageTransfer.getAccountType());
}
/**
* 未匹配到handler时触发
*
* @param request 微信请求
* @param message 微信消息
*/
protected WeixinResponse noHandlerFound(WeixinRequest request, WeixinMessage message) throws HttpResponseException {
logger.warn(String.format("no handler found for %s", request));
if (alwaysResponse) {
return BlankResponse.global;
} else {
throw new HttpResponseException(HttpResponseException.HttpResponseStatus.NOT_FOUND);
}
}
/**
* MessageHandlerExecutor
*
* @param request 微信请求
* @param messageKey 消息的key
* @param message 微信消息
* @param nodeNames 节点名称集合
* @return MessageHandlerExecutor
* @throws WeixinException
* @see MessageHandlerExecutor
*/
protected MessageHandlerExecutor getHandlerExecutor(
WeixinRequest request,
WeixinMessageKey messageKey, WeixinMessage message,
Set<String> nodeNames) throws WeixinException {
WeixinMessageHandler[] messageHandlers = getMessageHandlers();
if (messageHandlers == null) {
return null;
}
logger.info(String.format("resolve message handlers %s", this.messageHandlerList));
List<WeixinMessageHandler> matchedMessageHandlers = new ArrayList<WeixinMessageHandler>();
for (WeixinMessageHandler handler : messageHandlers) {
if (handler.canHandle(request, message, nodeNames)) {
matchedMessageHandlers.add(handler);
}
}
if (matchedMessageHandlers.isEmpty()) {
return null;
}
Collections.sort(matchedMessageHandlers,
new Comparator<WeixinMessageHandler>() {
@Override
public int compare(WeixinMessageHandler m1,
WeixinMessageHandler m2) {
return m2.weight() - m1.weight();
}
});
logger.info(String.format("matched message handlers %s", matchedMessageHandlers));
return new MessageHandlerExecutor(matchedMessageHandlers.get(0), getMessageInterceptors());
}
/**
* 获取所有的handler
*
* @return handler集合
* @throws WeixinException
* @see com.zone.weixin4j.handler.WeixinMessageHandler
*/
public WeixinMessageHandler[] getMessageHandlers() throws WeixinException {
if (this.messageHandlers == null) {
String[] beanNamesForAnnotation = this.weiXin4jContextAware.getApplicationContext().getBeanNamesForAnnotation(WxMessageHandler.class);
for (String str : beanNamesForAnnotation) {
Object bean = this.weiXin4jContextAware.getApplicationContext().getBean(str);
if (bean instanceof WeixinMessageHandler) {
this.messageHandlerList.add((WeixinMessageHandler) this.weiXin4jContextAware.getApplicationContext().getBean(str));
}
}
}
if (messageHandlerList != null && !this.messageHandlerList.isEmpty()) {
this.messageHandlers = this.messageHandlerList.toArray(new WeixinMessageHandler[this.messageHandlerList.size()]);
}
return this.messageHandlers;
}
/**
* 获取所有的interceptor
*
* @return interceptor集合
* @throws WeixinException
*/
public WeixinMessageInterceptor[] getMessageInterceptors()
throws WeixinException {
if (this.messageInterceptors == null) {
String[] beanNamesForAnnotation = this.weiXin4jContextAware.getApplicationContext().getBeanNamesForAnnotation(WxMessageInterceptor.class);
for (String str : beanNamesForAnnotation) {
Object bean = this.weiXin4jContextAware.getApplicationContext().getBean(str);
if (bean instanceof WeixinMessageInterceptor) {
this.messageInterceptorList.add((WeixinMessageInterceptor) this.weiXin4jContextAware.getApplicationContext().getBean(str));
}
}
}
if (this.messageInterceptorList != null && !this.messageInterceptorList.isEmpty()) {
Collections.sort(messageInterceptorList,
new Comparator<WeixinMessageInterceptor>() {
@Override
public int compare(WeixinMessageInterceptor m1, WeixinMessageInterceptor m2) {
return m2.weight() - m1.weight();
}
});
this.messageInterceptors = this.messageInterceptorList.toArray(new WeixinMessageInterceptor[this.messageInterceptorList.size()]);
}
logger.info(String.format("resolve message interceptors %s", this.messageInterceptorList));
return this.messageInterceptors;
}
/**
* jaxb读取微信消息
*
* @param message xml消息
* @param clazz 消息类型
* @return 消息对象
* @throws WeixinException
*/
protected <M extends WeixinMessage> M messageRead(String message,
Class<M> clazz) throws WeixinException {
if (clazz == null) {
return null;
}
try {
Source source = new StreamSource(new ByteArrayInputStream(
ServerToolkits.getBytesUtf8(message)));
JAXBElement<M> jaxbElement = getUnmarshaller(clazz).unmarshal(
source, clazz);
return jaxbElement.getValue();
} catch (JAXBException e) {
throw new WeixinException(e);
}
}
/**
* xml消息转换器
*
* @param clazz 消息类型
* @return 消息转换器
* @throws WeixinException
*/
protected Unmarshaller getUnmarshaller(Class<? extends WeixinMessage> clazz)
throws WeixinException {
Unmarshaller unmarshaller = messageUnmarshaller.get(clazz);
if (unmarshaller == null) {
try {
JAXBContext jaxbContext = JAXBContext.newInstance(clazz);
unmarshaller = jaxbContext.createUnmarshaller();
messageUnmarshaller.put(clazz, unmarshaller);
} catch (JAXBException e) {
throw new WeixinException(e);
}
}
return unmarshaller;
}
public void setMessageHandlerList(
List<WeixinMessageHandler> messageHandlerList) {
this.messageHandlerList = messageHandlerList;
}
public void setMessageInterceptorList(
List<WeixinMessageInterceptor> messageInterceptorList) {
this.messageInterceptorList = messageInterceptorList;
}
public void registMessageClass(WeixinMessageKey messageKey,
Class<? extends WeixinMessage> messageClass) {
messageMatcher.regist(messageKey, messageClass);
}
public WeixinMessageMatcher getMessageMatcher() {
return this.messageMatcher;
}
/**
* 打开总是响应开关,如未匹配到MessageHandler时回复空白消息
*/
public void openAlwaysResponse() {
this.alwaysResponse = true;
}
}