对于一个java web程序来说或多或少都要使用ServletAPI，websocket也不会例外。但是
websocket实用注解的方式来完成服务端配置，使用的协议也是WebSocket，这和之前的基于Ajax方式的轮询和长连接方式都不相同，所以访问ServletAPI方式也有所不同，那我们怎么才能让websocket访问到ServletAPI呢？
WebSocket有一个Configurator（该类的完整路劲javax.websocket.server.ServerEndpointConfig.Configurator）类，我们可以通过继承这个类，重写其中的方法(modifyHandshake)，然后通过注解的方式配置，达到我们访问ServletAPI的目的。下面我以websocket获取HttpSession为例演示，具体代码如下：
继承Configurator类
         publicclass MyConfiguratorextendsConfigurator
 {
 
        @Override
        publicvoid modifyHandshake(ServerEndpointConfig sec,
                HandshakeRequest request,HandshakeResponse response) {
                    //获取HttpSession
                    HttpSession httpSession =(HttpSession)request.getHttpSession();
                    //保存HttpSession到UserProperties中
                    sec.getUserProperties().put("httpSession", httpSession);
        }
    
}
 
配置websocket类，并在该类中获取已经存放的httpSession
@ServerEndpoint(value="server",configurator=MyConfigurator.class)
publicclass Server {
    @OnOpen
    publicvoid start(Session session){
        //注意两种Session的区别，参数中Session是websocket的session，用这个//session可以获取UserProperties，再通过该对象获取已经存入其中的HttpSession对象
        HttpSession httpSession =(HttpSession)session.getUserProperties().get("httpSession");
        //然后至于你怎么使用该httpSession对象那就要看你的目的了。
    }
}
 

spring的websocket访问时403

注：仅支持关闭sockjs的情况，如果需要开启sockjs，那么以下内容就不用看了 

先说解决方案，在配置websocket的xml语句块中：



<websocket:handlers allowed-origins="*">
</websocket:handlers>

添加allowed-origins属性，具体值看自己的需要，如有多个用 “,”隔开。

原因：下面是spring在初始化websocket的相关代码



class HandlersBeanDefinitionParser implements BeanDefinitionParser {

    private static final String SOCK_JS_SCHEDULER_NAME = "SockJsScheduler";

    private static final int DEFAULT_MAPPING_ORDER = 1;


    @Override
    public BeanDefinition parse(Element element, ParserContext context) {
        Object source = context.extractSource(element);
        CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
        context.pushContainingComponent(compDefinition);

        String orderAttribute = element.getAttribute("order");
        int order = orderAttribute.isEmpty() ? DEFAULT_MAPPING_ORDER : Integer.valueOf(orderAttribute);

        RootBeanDefinition handlerMappingDef = new RootBeanDefinition(WebSocketHandlerMapping.class);
        handlerMappingDef.setSource(source);
        handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        handlerMappingDef.getPropertyValues().add("order", order);
        String handlerMappingName = context.getReaderContext().registerWithGeneratedName(handlerMappingDef);

        RuntimeBeanReference sockJsService = WebSocketNamespaceUtils.registerSockJsService(
                element, SOCK_JS_SCHEDULER_NAME, context, source);

        HandlerMappingStrategy strategy;
        // 以下为主要代码
        if (sockJsService != null) {
            strategy = new SockJsHandlerMappingStrategy(sockJsService);
        }
        else {
            RuntimeBeanReference handshakeHandler = WebSocketNamespaceUtils.registerHandshakeHandler(element, context, source);
            Element interceptorsElement = DomUtils.getChildElementByTagName(element, "handshake-interceptors");
            ManagedList<? super Object> interceptors = WebSocketNamespaceUtils.parseBeanSubElements(interceptorsElement, context);
            String allowedOriginsAttribute = element.getAttribute("allowed-origins");
            List<String> allowedOrigins = Arrays.asList(StringUtils.tokenizeToStringArray(allowedOriginsAttribute, ","));
            interceptors.add(new OriginHandshakeInterceptor(allowedOrigins));
            strategy = new WebSocketHandlerMappingStrategy(handshakeHandler, interceptors);
        }

        ManagedMap<String, Object> urlMap = new ManagedMap<String, Object>();
        urlMap.setSource(source);
        for (Element mappingElement : DomUtils.getChildElementsByTagName(element, "mapping")) {
            strategy.addMapping(mappingElement, urlMap, context);
        }
        handlerMappingDef.getPropertyValues().add("urlMap", urlMap);

        context.registerComponent(new BeanComponentDefinition(handlerMappingDef, handlerMappingName));
        context.popAndRegisterContainingComponent();
        return null;
    }
    // 其他代码已省略

}

应该可以看到，如果开启sockjs则不会执行else代码块中代码，那么为了执行else代码块就必须关闭sockjs。所以该方式仅支持关闭sockjs。 

在 websocket:handlers 标签添加 allowed-origins属性以后，会在生成默认拦截器时，将allowed-origins的值注入，这样就可以解决访问时出现403的错误。

注：也可以通过写配置类的方式，不过其他人都写得很详细了，在这里就不在多说。更加详细的说明请见springmvc官方文档，上面写得很清楚，这里贴出来仅仅是因为自己还不是很熟悉，官方文档写道很清楚的。

http://blog.csdn.net/z719725611/article/details/52400404
写的很好

Jitsi默认使用XMPP协议的BOSH和http进行绑定

也可以使用websocket进行和服务器的绑定

jitsi-meet下的config.js设置如下
ar config = {
    hosts: {
        domain: 'meet.example.loc',
        focus: 'focus.meet.example.loc',
        muc: 'conference.meet.example.loc'
    },

    // BOSH URL. FIXME: use XEP-0156 to discover it.
    bosh: '//meet.example.loc/http-bind',
    // Websocket URL
    websocket: 'wss://meet.example.loc/xmpp-websocket',

2.prosody配置文件上启用websocket
modules_ enabled = {

"websocket";

"smacks";

}

全局设置
consider_ websocket_ secure = true;

cross_ domain_ websocket = true;

think_ websocket_ secure = true;

smacks_ max_ unacked_ stanzas = 5;

smacks_ hibernation_ time = 60;

smacks_ max_ hibernated_ sessions = 1;

smacks_ max_ old_ sessions = 1;

component_ interfaces = { "0.0.0.0" };


3.nginx设置
location = /xmpp-websocket {

proxy_ pass http://127.0.0.1 :5280/xmpp-websocket?prefix=$prefix&$args;

proxy_ http_ version 1.1;

proxy_ set_ header Upgrade $http_ upgrade;

proxy_ set_ header Connection "upgrade";

proxy_ set_ header Host $http_ host;

tcp_ nodelay on;

}