websocketcometd源码阅读基于注解初始化(三)

配置例子

 <!-- CometD Servlet -->
  <servlet>
    <servlet-name>cometd</servlet-name>
    <servlet-class>org.cometd.annotation.server.AnnotationCometDServlet</servlet-class>
    <!--liqiang todo 600000-->
    <init-param>
      <param-name>maxProcessing</param-name>
      <param-value>600000</param-value>
    </init-param>
    <init-param>
      <param-name>timeout</param-name>
      <param-value>20000</param-value>
    </init-param>
    <init-param>
      <param-name>interval</param-name>
      <param-value>0</param-value>
    </init-param>
    <init-param>
      <param-name>maxInterval</param-name>
      <param-value>10000</param-value>
    </init-param>
    <init-param>
      <param-name>handshakeReconnect</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <param-name>maxLazyTimeout</param-name>
      <param-value>5000</param-value>
    </init-param>
    <init-param>
      <param-name>long-polling.multiSessionInterval</param-name>
      <param-value>2000</param-value>
    </init-param>
    <init-param>
      <param-name>services</param-name>
      <param-value>org.cometd.examples.ChatService</param-value>
    </init-param>
    <init-param>
      <param-name>ws.cometdURLMapping</param-name>
      <param-value>/cometd/*</param-value>
    </init-param>
    <!--容器启动时调用init方法初始化 而不是第一次调用时-->
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
  </servlet>

基于注解的使用例子

@Service("chat") //comted注解
public class ChatService {
    //保存用户信息 不同房间
    private final ConcurrentMap<String, Map<String, String>> _members = new ConcurrentHashMap<>();
    @Inject //comted注解注入
    private BayeuxServer _bayeux;
    @Session //comted注解注入
    private ServerSession _session;

    //初始化 "/chat/**", "/members/**" 渠道
    @Configure({"/chat/**", "/members/**"})
    protected void configureChatStarStar(ConfigurableServerChannel channel) {
        DataFilterMessageListener noMarkup = new DataFilterMessageListener(new NoMarkupFilter(), new BadWordFilter());
        channel.addListener(noMarkup);
        channel.addAuthorizer(GrantAuthorizer.GRANT_ALL);
    }
    //初始化 "/service/members" 渠道
    @Configure("/service/members")
    protected void configureMembers(ConfigurableServerChannel channel) {
        channel.addAuthorizer(GrantAuthorizer.GRANT_PUBLISH);
        channel.setPersistent(true);
    }

    /**
     * 渠道监听器
     * @param client
     * @param message
     */
    @Listener("/service/members")
    public void handleMembership(ServerSession client, ServerMessage message) {
        //获得消息
        Map<String, Object> data = message.getDataAsMap();
        //获得房间信息
        String room = ((String)data.get("room")).substring("/chat/".length());
        //获得房间的用户信息
        Map<String, String> roomMembers = _members.get(room);
        if (roomMembers == null) {
            Map<String, String> new_room = new ConcurrentHashMap<>();
            //加入房间
            roomMembers = _members.putIfAbsent(room, new_room);
            if (roomMembers == null) {
                roomMembers = new_room;
            }
        }
        Map<String, String> members = roomMembers;
        //获得房间的用户信息
        String userName = (String)data.get("user");
        //用户信息与clientId映射
        members.put(userName, client.getId());
        //添加监听器 此客户端断开连接后 告诉当前房间所有人连接词用户下线 以及清除连接信息
        client.addListener((ServerSession.RemovedListener)(s, m, t) -> {
            //清除此房间连接信息
            members.values().remove(s.getId());
            //通知所有用户
            broadcastMembers(room, members.keySet());
        });
        //建立连接后推送订阅者最新的成员名单
        broadcastMembers(room, members.keySet());
    }

    private void broadcastMembers(String room, Set<String> members) {
        // Broadcast the new members list 推送订阅此房间的所有用户告知用户下线
        ClientSessionChannel channel = _session.getLocalSession().getChannel("/members/" + room);
        channel.publish(members);
    }

    @Configure("/service/privatechat")
    protected void configurePrivateChat(ConfigurableServerChannel channel) {
        DataFilterMessageListener noMarkup = new DataFilterMessageListener(new NoMarkupFilter(), new BadWordFilter());
        channel.setPersistent(true);
        channel.addListener(noMarkup);
        channel.addAuthorizer(GrantAuthorizer.GRANT_PUBLISH);
    }

    @Listener("/service/privatechat")
    public void privateChat(ServerSession client, ServerMessage message) {
        Map<String, Object> data = message.getDataAsMap();
        String room = ((String)data.get("room")).substring("/chat/".length());
        Map<String, String> membersMap = _members.get(room);
        if (membersMap == null) {
            Map<String, String> new_room = new ConcurrentHashMap<>();
            membersMap = _members.putIfAbsent(room, new_room);
            if (membersMap == null) {
                membersMap = new_room;
            }
        }
        String[] peerNames = ((String)data.get("peer")).split(",");
        ArrayList<ServerSession> peers = new ArrayList<>(peerNames.length);

        for (String peerName : peerNames) {
            String peerId = membersMap.get(peerName);
            if (peerId != null) {
                ServerSession peer = _bayeux.getSession(peerId);
                if (peer != null) {
                    peers.add(peer);
                }
            }
        }

        if (peers.size() > 0) {
            Map<String, Object> chat = new HashMap<>();
            String text = (String)data.get("chat");
            chat.put("chat", text);
            chat.put("user", data.get("user"));
            chat.put("scope", "private");
            ServerMessage.Mutable forward = _bayeux.newMessage();
            forward.setChannel("/chat/" + room);
            forward.setId(message.getId());
            forward.setData(chat);

            // test for lazy messages
            if (text.lastIndexOf("lazy") > 0) {
                forward.setLazy(true);
            }

            for (ServerSession peer : peers) {
                if (peer != client) {
                    peer.deliver(_session, forward, Promise.noop());
                }
            }
            client.deliver(_session, forward, Promise.noop());
        }
    }

    class BadWordFilter extends JSONDataFilter {
        @Override
        protected Object filterString(ServerSession session, ServerChannel channel, String string) {
            if (string.contains("dang")) {
                throw new DataFilter.AbortException();
            }
            return string;
        }
    }
}

源码

<1>

org.cometd.annotation.server.AnnotationCometDServlet#init

   @Override
    public void init() throws ServletException {
        //<2>继承了comet 这里是先对comte进行初始化
        super.init();

        //基于注解方式初始化处理类对象的Processor  new ServerAnnotationProcessor(bayeuxServer);
        processor = newServerAnnotationProcessor(getBayeux());

        //获得servlet initParameter的Service配置
        String servicesParam = getInitParameter("services");
        if (servicesParam != null && servicesParam.length() > 0) {

            for (String serviceClass : servicesParam.split(",")) {
                //<3>创建处理类对象 也就是xml配置的chatServerce
                Object service = processService(processor, serviceClass.trim());
                services.add(service);
                //设置当前Service到requestAttribute
                registerService(service);
            }
        }
    }

    protected ServerAnnotationProcessor newServerAnnotationProcessor(BayeuxServer bayeuxServer) {
        return new ServerAnnotationProcessor(bayeuxServer);
    }

<3>

org.cometd.annotation.server.AnnotationCometDServlet#processService

    protected Object processService(ServerAnnotationProcessor processor, String serviceClassName) throws ServletException {
        try {
            //反射根据类的全名称创建类的对象
            Object service = newService(serviceClassName);
            //<4>初始化
            processor.process(service);
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Processed annotated service {}", service);
            }
            return service;
        } catch (Exception x) {
            LOGGER.warn("Failed to create annotated service " + serviceClassName, x);
            throw new ServletException(x);
        }
    }

    protected Object newService(String serviceClassName) throws Exception {
        return Loader.loadClass(getClass(), serviceClassName).newInstance();
    }

<4>

org.cometd.annotation.server.ServerAnnotationProcessor#process

  public boolean process(Object bean) {
        //<5>基于注解依赖注入主要处理 @Inject 和@Session注解
        boolean result = processDependencies(bean);
        //<11>根据@Configure注解的方法初始化channel
        result |= processConfigurations(bean);
        //<13>处理Subscription 订阅渠道
        result |= processCallbacks(bean);
        //<15>调用@PostConstruct 进行初始化操作
        result |= processPostConstruct(bean);
        return result;
    }

<5>

org.cometd.annotation.server.ServerAnnotationProcessor#processDependencies

 public boolean processDependencies(Object bean) {
        if (bean == null) {
            return false;
        }

        Class<?> klass = bean.getClass();
        //首选需要打了comted的@Service注解
        Service serviceAnnotation = klass.getAnnotation(Service.class);
        if (serviceAnnotation == null) {
            return false;
        }

        //容器中bean对象
        List<Object> injectables = new ArrayList<>(Arrays.asList(this.injectables));
        //默认增加是bayeuxServer 所以支持@Inject进行 bayeuxServer注入
        injectables.add(0, bayeuxServer);
        //<6>针对 bean的@Inject注解进行 注入
        boolean result = processInjectables(bean, injectables);
        //<7>针对Service初始化loaclSession 同时初始化一个serverSession与bayeuxServer模拟建立连接
        LocalSession session = findOrCreateLocalSession(bean, serviceAnnotation.value());
        //<10>session注入到bean 后续我们可以通过操作session发送消息
        result |= processSession(bean, session);
        return result;
    }

<6>

org.cometd.annotation.AnnotationProcessor#processInjectables

 protected boolean processInjectables(Object bean, List<Object> injectables) {
        boolean result = false;
        //遍历容器
        for (Object injectable : injectables) {
            result |= processInjectable(bean, injectable);
        }
        return result;
    }

    protected boolean processInjectable(Object bean, Object injectable) {
        boolean result = false;
        for (Class<?> c = bean.getClass(); c != Object.class; c = c.getSuperclass()) {
            //反射获得fields 获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
            Field[] fields = c.getDeclaredFields();
            for (Field field : fields) {
                //如果打了@Inject注解
                if (field.getAnnotation(Inject.class) != null) {
                    /**
                     * 如果是A.isAssignableFrom(B) 确定一个类(B)是不是继承来自于另一个父类(A)，一个接口(A)是不是实现了另外一个接口(B)，
                     * 或者两个类相同。主要，这里比较的维度不是实例对象，而是类本身，因为这个方法本身就是Class类的方法，判断的肯定是和类信息相关的。
                     */
                    if (field.getType().isAssignableFrom(injectable.getClass())) {
                        Object value = getField(bean, field);
                        if (value != null) {
                            if (LOGGER.isDebugEnabled()) {
                                LOGGER.debug("Avoid injection of field {} on bean {}, it's already injected with {}", field, bean, value);
                            }
                            continue;
                        }
                        //完成注入
                        setField(bean, field, injectable);
                        result = true;
                        if (LOGGER.isDebugEnabled()) {
                            LOGGER.debug("Injected {} to field {} on bean {}", injectable, field, bean);
                        }
                    }
                }
            }
        }

        //针对打在set方法上 的注入
        List<Method> methods = findAnnotatedMethods(bean, Inject.class);
        for (Method method : methods) {
            Class<?>[] parameterTypes = method.getParameterTypes();
            if (parameterTypes.length == 1) {
                if (parameterTypes[0].isAssignableFrom(injectable.getClass())) {
                    invokePrivate(bean, method, injectable);
                    result = true;
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("Injected {} to method {} on bean {}", injectable, method, bean);
                    }
                }
            }
        }
        return result;
    }

<7>

org.cometd.annotation.server.ServerAnnotationProcessor#findOrCreateLocalSession

private LocalSession findOrCreateLocalSession(Object bean, String name) {
        LocalSession session = sessions.get(bean);
        if (session == null) {
            //<8>创建一个Local session
            session = bayeuxServer.newLocalSession(name);
            //bean的名字作为key维护放入sessions
            LocalSession existing = sessions.putIfAbsent(bean, session);
            if (existing != null) {
                session = existing;
            } else {
                //<9>默认握手加入bayeuxServer
                session.handshake();
            }
        }
        return session;
    }

<8>

org.cometd.server.BayeuxServerImpl#newLocalSession

@Override
    public LocalSession newLocalSession(String idHint) {
        return new LocalSessionImpl(this, idHint);
    }

<9>

org.cometd.server.LocalSessionImpl#handshake

 @Override
    public void handshake(Map<String, Object> template, ClientSession.MessageListener callback) {
        if (_session != null) {
            throw new IllegalStateException("Method handshake() invoke multiple times for local session " + this);
        }

        ServerSessionImpl session = new ServerSessionImpl(_bayeux, this, _idHint);

        ServerMessage.Mutable hsMessage = newMessage();
        if (template != null) {
            hsMessage.putAll(template);
        }
        String messageId = newMessageId();
        hsMessage.setId(messageId);
        hsMessage.setChannel(Channel.META_HANDSHAKE);
        registerCallback(messageId, callback);

        doSend(session, hsMessage, Promise.from(hsReply -> {
            if (hsReply != null && hsReply.isSuccessful()) {
                _session = session;
                ServerMessage.Mutable cnMessage = newMessage();
                cnMessage.setId(newMessageId());
                cnMessage.setChannel(Channel.META_CONNECT);
                cnMessage.getAdvice(true).put(Message.INTERVAL_FIELD, -1L);
                cnMessage.setClientId(session.getId());
                doSend(session, cnMessage, Promise.from(cnReply -> {
                    // Nothing more to do.
                }, failure -> messageFailure(cnMessage, failure)));
            }
        }, failure -> messageFailure(hsMessage, failure)));
    }

<10>

org.cometd.annotation.server.ServerAnnotationProcessor#processSession

private boolean processSession(Object bean, LocalSession localSession) {
        ServerSession serverSession = localSession.getServerSession();

        boolean result = false;
        for (Class<?> c = bean.getClass(); c != Object.class; c = c.getSuperclass()) {
            Field[] fields = c.getDeclaredFields();
            for (Field field : fields) {
                if (field.getAnnotation(Session.class) != null) {
                    Object value = null;
                    if (field.getType().isAssignableFrom(localSession.getClass())) {
                        value = localSession;
                    } else if (field.getType().isAssignableFrom(serverSession.getClass())) {
                        value = serverSession;
                    }

                    if (value != null) {
                        setField(bean, field, value);
                        result = true;
                        if (LOGGER.isDebugEnabled()) {
                            LOGGER.debug("Injected {} to field {} on bean {}", value, field, bean);
                        }
                    }
                }
            }
        }

        List<Method> methods = findAnnotatedMethods(bean, Session.class);
        for (Method method : methods) {
            Class<?>[] parameterTypes = method.getParameterTypes();
            if (parameterTypes.length == 1) {
                Object value = null;
                if (parameterTypes[0].isAssignableFrom(localSession.getClass())) {
                    value = localSession;
                } else if (parameterTypes[0].isAssignableFrom(serverSession.getClass())) {
                    value = serverSession;
                }

                if (value != null) {
                    invokePrivate(bean, method, value);
                    result = true;
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("Injected {} to method {} on bean {}", value, method, bean);
                    }
                }
            }
        }
        return result;
    }

<11>

org.cometd.annotation.server.ServerAnnotationProcessor#processConfigurations

public boolean processConfigurations(Object bean) {
        if (bean == null) {
            return false;
        }

        Class<?> klass = bean.getClass();
        //首选需要打了@Service注解
        Service serviceAnnotation = klass.getAnnotation(Service.class);
        if (serviceAnnotation == null) {
            return false;
        }

        //首先需要打了打了@Configure的方法
        List<Method> methods = findAnnotatedMethods(bean, Configure.class);
        if (methods.isEmpty()) {
            return false;
        }

        for (Method method : methods) {
            Configure configure = method.getAnnotation(Configure.class);
            //@Configure配置的value为channelName
            String[] channels = configure.value();
            for (String channelName : channels) {
                //定义一个Initializer接口的匿名方法 内部会调用调用@Configure注解方法
                Initializer init = channel -> {
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("Configure channel {} with method {} on bean {}", channel, method, bean);
                    }
                    invokePrivate(bean, method, channel);
                };

                //<12>针对@Configure创建Channel
                MarkedReference<ServerChannel> initializedChannel = bayeuxServer.createChannelIfAbsent(channelName, init);

                //内部初始化成功会将marked设置为true
                if (!initializedChannel.isMarked()) {
                    //是否配置了configureIfExists 为true 默认false 如果为true则会调用打了@Configure的方法
                    if (configure.configureIfExists()) {
                        if (LOGGER.isDebugEnabled()) {
                            LOGGER.debug("Configure again channel {} with method {} on bean {}", channelName, method, bean);
                        }
                        init.configureChannel(initializedChannel.getReference());
                    } else if (configure.errorIfExists()) {
                        throw new IllegalStateException("Channel already configured: " + channelName);
                    } else {
                        if (LOGGER.isDebugEnabled()) {
                            LOGGER.debug("Channel {} already initialized. Not called method {} on bean {}", channelName, method, bean);
                        }
                    }
                }
            }
        }
        return true;
    }

<12>

org.cometd.server.BayeuxServerImpl#createChannelIfAbsent

  @Override
    public MarkedReference<ServerChannel> createChannelIfAbsent(String channelName, Initializer... initializers) {
        ChannelId channelId;
        boolean initialized = false;
        //尝试根据channelName获取 判断是否存在
        ServerChannelImpl channel = _channels.get(channelName);
        if (channel == null) {
            // Creating the ChannelId will also normalize the channelName.
            //尝试通过处理过的channelId获取
            channelId = new ChannelId(channelName);
            String id = channelId.getId();
            if (!id.equals(channelName)) {
                channelName = id;
                channel = _channels.get(channelName);
            }
        } else {
            channelId = channel.getChannelId();
        }

        //表示没有被初始化
        if (channel == null) {
            //新建一个channel
            ServerChannelImpl candidate = new ServerChannelImpl(this, channelId);
            //放入_channels
            channel = _channels.putIfAbsent(channelName, candidate);
            if (channel == null) {
                // My candidate channel was added to the map, so I'd better initialize it

                channel = candidate;
                if (_logger.isDebugEnabled()) {
                    _logger.debug("Added channel {}", channel);
                }

                try {
                    //通知 Initializer实现 可以对ServerChannelImpl做自定义配置
                    for (Initializer initializer : initializers) {
                        notifyConfigureChannel(initializer, channel);
                    }

                    //调用listeners中ChannelListener的configureChannel方法可以对channel进行自定义配置
                    for (BayeuxServer.BayeuxServerListener listener : _listeners) {
                        if (listener instanceof ServerChannel.Initializer) {
                            notifyConfigureChannel((Initializer)listener, channel);
                        }
                    }
                } finally {
                    channel.initialized();
                }
                //调用listeners中ChannelListener的channelAdded表示已经被初始化
                for (BayeuxServer.BayeuxServerListener listener : _listeners) {
                    if (listener instanceof BayeuxServer.ChannelListener) {
                        notifyChannelAdded((ChannelListener)listener, channel);
                    }
                }

                initialized = true;
            }
        } else {
            channel.resetSweeperPasses();
            // Double check if the sweeper removed this channel between the check at the top and here.
            // This is not 100% fool proof (e.g. this thread is preempted long enough for the sweeper
            // to remove the channel, but the alternative is to have a global lock)
            _channels.putIfAbsent(channelName, channel);
        }
        // Another thread may add this channel concurrently, so wait until it is initialized
        channel.waitForInitialized();
        return new MarkedReference<>(channel, initialized);
    }

<13>

org.cometd.annotation.server.ServerAnnotationProcessor#processCallbacks

 public boolean processCallbacks(Object bean) {
        if (bean == null) {
            return false;
        }

        Class<?> klass = bean.getClass();
        Service serviceAnnotation = klass.getAnnotation(Service.class);
        if (serviceAnnotation == null) {
            return false;
        }

        if (!Modifier.isPublic(klass.getModifiers())) {
            throw new IllegalArgumentException("Service class " + klass.getName() + " must be public");
        }
        //<7>根据打了Service的创建Session 如果创建过了就不会再创建
        LocalSession session = findOrCreateLocalSession(bean, serviceAnnotation.value());
        //<14>处理@@Listener注解往渠道新增监听器 监听渠道
        boolean result = processListener(bean, session);
        //处理Subscription  往渠道新增订阅器 订阅渠道
        result |= processSubscription(bean, session);
        //liqiangtodo @RemoteCall 好像也是监听的一种信息 处理类似RPC请求参考
        result |= processRemoteCall(bean, session);
        return result;
    }

<14>

org.cometd.annotation.server.ServerAnnotationProcessor#processListener

 private static final Class<?>[] signature = new Class<?>[]{ServerSession.class, ServerMessage.Mutable.class};
    private boolean processListener(Object bean, LocalSession localSession) {
        //这里主要是做个检查针对打了@Listener的方法不是public的则报错
        AnnotationProcessor.checkMethodsPublic(bean, Listener.class);

        boolean result = false;
        Method[] methods = bean.getClass().getMethods();
        for (Method method : methods) {
            if (method.getDeclaringClass() == Object.class) {
                continue;
            }

            Listener listener = method.getAnnotation(Listener.class);
            if (listener != null) {
                //获得@Listener 打了@Param的方法的value
                List<String> paramNames = processParameters(method);
                //检查方法的注入 必须注入signature的类型,以及@Param注解的变量必须是String
                AnnotationProcessor.checkSignaturesMatch(method, ListenerCallback.signature, paramNames);

                //@Listener监听的渠道名称
                String[] channels = listener.value();
                for (String channel : channels) {
                    ChannelId channelId = new ChannelId(channel);
                    if (channelId.isTemplate()) {
                        List<String> parameters = channelId.getParameters();
                        if (parameters.size() != paramNames.size()) {
                            throw new IllegalArgumentException("Wrong number of template parameters in annotation @" +
                                    Listener.class.getSimpleName() + " on method " +
                                    method.getDeclaringClass().getName() + "." + method.getName() + "(...)");
                        }
                        if (!parameters.equals(paramNames)) {
                            throw new IllegalArgumentException("Wrong parameter names in annotation @" +
                                    Listener.class.getSimpleName() + " on method " +
                                    method.getDeclaringClass().getName() + "." + method.getName() + "(...)");
                        }
                        channel = channelId.getRegularPart() + "/" + (parameters.size() < 2 ? ChannelId.WILD : ChannelId.DEEPWILD);
                    }

                    //渠道不存在的创建渠道
                    MarkedReference<ServerChannel> initializedChannel = bayeuxServer.createChannelIfAbsent(channel);
                    ListenerCallback listenerCallback = new ListenerCallback(localSession, bean, method, paramNames, channelId, channel, listener.receiveOwnPublishes());
                    //在渠道里面新增此监听器获取消息回调
                    initializedChannel.getReference().addListener(listenerCallback);

                    List<ListenerCallback> callbacks = listeners.get(bean);
                    if (callbacks == null) {
                        callbacks = new CopyOnWriteArrayList<>();
                        List<ListenerCallback> existing = listeners.putIfAbsent(bean, callbacks);
                        if (existing != null) {
                            callbacks = existing;
                        }
                    }
                    callbacks.add(listenerCallback);
                    result = true;
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("Registered listener for channel {} to method {} on bean {}", channel, method, bean);
                    }
                }
            }
        }
        return result;
    }

<15>

org.cometd.annotation.AnnotationProcessor#processPostConstruct

  protected boolean processPostConstruct(Object bean) {
        if (bean == null) {
            return false;
        }

        List<Method> postConstructs = findLifeCycleMethods(bean, PostConstruct.class);

        boolean result = false;
        for (Method method : postConstructs) {
            invokePrivate(bean, method);
            result = true;
        }

        return result;
    }