easy-chat-server

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Accept {
}

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AcceptMapping {
    String value() default "";
}

//基于spring框架 扫描带有自定义注解的类缓存起来
@Component
public class AcceptPostProcess implements InitializingBean, ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void afterPropertiesSet() {
        String[] beanNames = applicationContext.getBeanNamesForAnnotation(Accept.class);
        try {
            for (String beanName : beanNames) {
                String baseUrl = "";
                Object bean = applicationContext.getBean(beanName);
                Class<?> clazz = bean.getClass();
                if (clazz.isAnnotationPresent(AcceptMapping.class)) {
                    AcceptMapping acceptMapping = clazz.getAnnotation(AcceptMapping.class);
                    baseUrl = acceptMapping.value();
                }

                Method[] methods = clazz.getMethods();
                for (Method method : methods) {
                    if (!method.isAnnotationPresent(AcceptMapping.class)) {
                        continue;
                    }
                    AcceptMapping acceptMapping = method.getAnnotation(AcceptMapping.class);
                    String regex = ("/" + baseUrl + acceptMapping.value()).replaceAll("/+", "/");
                    Pattern pattern = Pattern.compile(regex);

                    AcceptRespository.addBean(new AcceptBean(bean, method, pattern));
                    System.out.println("mapping " + regex + "," + method);
                }

            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

//通过反射技术，根据入参的messageUrl字段找到对应的accept并且执行方法
@Component
public class AcceptInvoke<T extends ChatMessage> {

    public Response invoke(JSONObject param, ChannelHandlerContext ctx) throws Exception {
        String messageType = param.getString("messageUrl");
        if (StringUtils.isEmpty(messageType)) {
            throw new RuntimeException("messageUrl字段不能为空");
        }
        AcceptBean acceptBean = getAcceptBean(messageType);
        Method method = acceptBean.getMethod();
        if (acceptBean == null) {
            throw new RuntimeException("message路径不正确");
        }

        Class<?>[] paramTypes = method.getParameterTypes();
        Object[] paramValues = new Object[paramTypes.length];
        Map<String, Integer> paramMap = acceptBean.getParamIndexMapping();
        //容器启动时已经做过判断了，这里只有两种入参 ChatMessage和 ChannelHandlerContext
        if (paramMap.containsKey(ChannelHandlerContext.class.getName())) {
            int index = paramMap.get(ChannelHandlerContext.class.getName());
            paramValues[index] = ctx;
        }
        Class<T> c = getClass(acceptBean.getMethod());
        if (paramMap.containsKey(c.getName())) {
            int index = paramMap.get(c.getName());
            paramValues[index] = JSON.toJavaObject(param, c);
        }
        //反射执行方法
        Object result = method.invoke(acceptBean.getAccept(),paramValues);
        if (result != null) {
            if (!(result instanceof Response)) {
                throw new RuntimeException("返回类必须为Response");
            }
        }
        return (Response) result;
    }


    private AcceptBean getAcceptBean(String messageUrl) {
        List<AcceptBean> acceptBeans = AcceptRespository.getAcceptBeans();

        if (CollectionUtils.isEmpty(acceptBeans)) {
            return null;
        }
        messageUrl = messageUrl.replaceAll("/+", "/");
        for (AcceptBean acceptBean : acceptBeans) {
            try {
                Matcher matcher = acceptBean.getPattern().matcher(messageUrl);
                if (!matcher.matches()) {
                    continue;
                }
                return acceptBean;
            } catch (Exception e) {
                throw e;
            }
        }
        return null;
    }

    private Class getClass(Method method) {
        Class<?>[] paramTypes = method.getParameterTypes();
        for (Class<?> c : paramTypes) {
            if (ChatMessage.class.isAssignableFrom(c)) {
                return c;
            }
        }
        throw new RuntimeException("accept方法参数不正确");
    }
}

@AcceptMapping(value = "/chat")
@Accept
@Component
public class ChatAccept {

    @Autowired
    private ChatService singleChatService;

    /**
     * 单聊
     * @param msg
     */
    @AcceptMapping(value = "/single")
    public void singleChat(SingleMsg msg){
        singleChatService.singleChat(msg);
    }

    /**
     * 群聊
     * @param msg
     */
    @AcceptMapping(value = "/group")
    public void groupChat(GroupChatMsg msg){
        singleChatService.groupChat(msg);
    }

}