码仙♥
码仙♥

Java中的WecSocket

目录

零、码仙励志

一、WebSocket概述

1.为什么要用WebSocket

2.什么是WebSocket

3.最低支持要求

二、Tomcat实现WebSocket

1.简单实现

2.连接的时候传入参数

3.群聊演示

4.单聊演示

三、SpringBoot整合WebSocket

1.基于注解的方式

1.群聊演示

2.单聊演示

2.基于实现类的方式

1.简单实现

2.连接的时候传入参数

3.群聊演示

4.单聊演示

5.SockJs

3.基于STOMP协议的方式

1.后端代码

2.前端代码

四、参考文献

零、码仙励志

失败的是事，绝不应是人。

一、WebSocket概述

1.为什么要用WebSocket

传统的HTTP协议是无状态的，每次请求（request）都要由客户端（如 浏览器）主动发起，服务端进行处理后返回response结果，而服务端很难主动向客户端发送数据；这种客户端是主动方，服务端是被动方的传统Web模式 对于信息变化不频繁的Web应用来说造成的麻烦较小，而对于涉及实时信息的Web应用却带来了很大的不便，如带有即时通信、实时数据、订阅推送等功能的应 用。在WebSocket规范提出之前，开发人员若要实现这些实时性较强的功能，经常会使用折衷的解决方法：轮询（polling）和Comet技术。其实后者本质上也是一种轮询，只不过有所改进。

轮询是最原始的实现实时Web应用的解决方案。轮询技术要求客户端以设定的时间间隔周期性地向服务端发送请求，频繁地查询是否有新的数据改动。明显地，这种方法会导致过多不必要的请求，浪费流量和服务器资源。

Comet技术又可以分为长轮询和流技术。长轮询改进了上述的轮询技术，减小了无用的请求。它会为某些数据设定过期时间，当数据过期后才会向服务端发送请求；这种机制适合数据的改动不是特别频繁的情况。流技术通常是指客户端使用一个隐藏的窗口与服务端建立一个HTTP长连接，服务端会不断更新连接状态以保持HTTP长连接存活；这样的话，服务端就可以通过这条长连接主动将数据发送给客户端；流技术在大并发环境下，可能会考验到服务端的性能。

这两种技术都是基于请求-应答模式，都不算是真正意义上的实时技术；它们的每一次请求、应答，都浪费了一定流量在相同的头部信息上，并且开发复杂度也较大。

2.什么是WebSocket

WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，已被 W3C 定为标准。使用WebSocket 可以使得客户端和服务器之间的数据交换变得更加简单，它允许服务端主动向客户端推送数据。在 WebSocket 协议中，浏览器和服务器只需要完成一次握手，两者之间就可以直接创建持久性的连接，并进行双向数据传输。

WebSocket 使用了 HTTP/1.1 的协议升级特性，一个 WebSocket 请求首先使用非正常的 HTTP 请求以特定的模式访问一个 URL ，这个 URL 有两种模式，分别是 ws 和 wss ，对应 HTTP 协议中的 HTTP和HTTPS ，在请求头中有一个 Connection:Upgrade 字段，表示客户端想要对协议进行升级，另外还有一个 Upgrade:websocket 字段，表示客户端想要将请求协议升级为 WebSocket 协议。 这两个字段共同告诉服务器要将连接升级为 WebSocket 这样 一种全双工协议，如果服务端同意协议升级，那么在握手完成之后，文本消息或者其他二进制消息就可以同时在两个方向上进行发送，而不需要关闭和重建连接。 此时的客户端和服务端关系是对等的，它们可以互相向对方主动发送消 息。和传统的解决方案相比， WebSocket 主要有如下特点：

  1. WebSocket 使用时需要先创建连接，这使得 WebSocket 成为一种有状态的协议，在之后的通信过程中可以省略部分状态信息（例如身份认证等）。

  2. WebSocket 连接在端口 80 ( WS ）或者 443 ( wss ）上创建，与 HTTP 使用的端口相同，这样，基本上所有的防火墙都不会阻止 WebSocket 连接。

  3. WebSocket 使用 HTTP 协议进行握手，因此它可以自然而然地集成到网络浏览器和 HTTP 服务器中，而不需要额外的成本。

  4. 心跳消息（ping 和 pong）将被反复的发送，进而保持 WebSocket 连接一直处于活跃状态。

  5. 使用该协议，当消息启动或者到达的时候，服务端和客户端都可以知道。

  6. WebSocket 连接关闭时将发送一个特殊的关闭消息。

  7. WebSocket 支持跨域，可以避免 Ajax的限制。

  8. HTTP 规范要求浏览器将并发连接数限制为每个主机名两个连接，但是当我们使用 WebSocket 的时候，当握手完成之后，该限制就不存在了，因为此时的连接已经不再是 HTTP 连接了。

  9. WebSocket 协议支持扩展，用户可以扩展协议，实现部分自定义的子协议。

  10. 更好的二进制支持以及更好的压缩效果。

WebSocket 既然具有这么多优势，使用场景当然也是非常广泛的，例如：

  1. 在线股票网站。

  2. 即时聊天。

  3. 多人在线游戏。

  4. 应用集群通信。

  5. 系统性能实时监控。

3.最低支持要求

浏览器支持：所有的最新浏览器支持最新WebSocket规范(RFC 6455) ，从维基百科上介绍浏览器对WebSocket的支持如下表所示：

浏览器 Chrome Edge Firfox IE Opera Safari
最低版本 16 支持 11.0 10 12.10 6.0

移动端支持：移动端基本都支持websocket了，其实和浏览器版支持的版本一样，具体支持如下所示：

最低 android浏览器 Chrome 移动版 Firfox 移动版 Opera 移动版 Safari IOS版
最低版本 4.4 16 11.0 12.10 6.0

服务器支持：目前主流的web服务器都已经支持，具体版本如下表所示：

厂商 应用服务器 备注
IBM WebSphere WebSphere 8.0 以上版本支持，7.X 之前版本结合 MQTT 支持类似的 HTTP 长连接
甲骨文 WebLogic WebLogic 12c 支持，11g 及 10g 版本通过 HTTP Publish 支持类似的 HTTP 长连接
微软 IIS IIS 7.0+支持
Apache Tomcat Tomcat 7.0.5＋支持，7.0.2X 及 7.0.3X 通过自定义 API 支持
Apache Jetty Jetty 7.0＋支持

二、Tomcat实现WebSocket

引入websocket依赖


    javax.websocket
    javax.websocket-api
    1.1
    provided

建立一个用来跳转连接的页面

index.html




    
    Title


Easy
EasyPar
GroupChat
SingleChat

1.简单实现

服务端代码（Easy.java）

package com.mahaiwuji.socket;

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

@ServerEndpoint("/easy")
public class Easy {

    /**
     * 连接时执行
     *
     * @param session
     */
    @OnOpen
    public void onOPen(Session session) {
        System.out.println("连接成功");
    }

    /**
     * 收到消息时执行
     *
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) throws IOException {
        System.out.println(message);
        session.getBasicRemote().sendText("收到消息");
    }

    /**
     * 关闭时执行
     */
    @OnClose
    public void onClose(Session session) {
        System.out.println("连接关闭");
    }

    /**
     * 连接错误时执行
     *
     * @param session
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
    }

}

客户端代码（easy.html）




    
    Title



Easy

消息：

2.连接的时候传入参数

服务端代码(EasyPar.java)

package com.mahaiwuji.socket;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;

@ServerEndpoint("/easyPar/{username}/{sex}")
public class EasyPar {

    /**
     * 连接时执行
     *
     * @param session
     */
    @OnOpen
    public void onOPen(@PathParam("username") String username, @PathParam("sex") String sex, Session session) {
        System.out.println("连接成功");
        System.out.println(username);
        System.out.println(sex);
    }

    /**
     * 收到消息时执行
     *
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) throws IOException {
        System.out.println(message);
        session.getBasicRemote().sendText("收到消息");
    }

    /**
     * 关闭时执行
     */
    @OnClose
    public void onClose(Session session) {
        System.out.println("连接关闭");
    }

    /**
     * 连接错误时执行
     *
     * @param session
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
    }

}

客户端代码(easyPar.html)




    
    Title



EasyPar

消息：

3.群聊演示

服务端代码(GroupChat.java)

package com.mahaiwuji.socket;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

@ServerEndpoint("/groupChat/{username}")
public class GroupChat {

    // 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;
    // concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
    private static final Map users = new HashMap();

    // 与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;
    private String username;

    /**
     * 连接时执行
     *
     * @param username
     * @param session
     */
    @OnOpen
    public void onOPen(@PathParam("username") String username, Session session) {
        this.username = username;
        this.session = session;
        users.put(username, session); // 加入Map中
        System.out.println("用户登录:" + username);
        addOnlineCount(); // 在线数加1
        System.out.println("当前在线人数:" + onlineCount);
    }

    /**
     * 收到消息时执行
     *
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        boolean flag = sendMessageToAllUsers(username + ":" + message);
        if (flag) {
            System.out.println("群发成功");
        }
    }

    /**
     * 关闭时执行
     *
     * @param session
     */
    @OnClose
    public void onClose(Session session) {
        users.remove(username); // 从Map中删除
        System.out.println("用户退出:" + username);
        subOnlineCount(); // 在线数减1
        System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
    }

    /**
     * 连接错误时执行
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
    }

    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        GroupChat.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        GroupChat.onlineCount--;
    }

    /**
     * 群发
     *
     * @param message
     * @return
     */
    public boolean sendMessageToAllUsers(String message) {
        boolean allSendSuccess = true;
        Set usernames = users.keySet();
        Session session = null;
        for (String username : usernames) {
            try {
                session = users.get(username);
                if (session.isOpen()) {
                    session.getBasicRemote().sendText(message);
                } else {
                    System.out.println("客户端:" + username + ",已断开连接，发送消息失败");
                }
            } catch (IOException e) {
                System.out.println("群发失败");
                allSendSuccess = false;
            }
        }
        return allSendSuccess;
    }
}

客户端代码(groupchat.html)




    
    Title



GroupChat

消息：

4.单聊演示

引入json依赖


    com.alibaba
    fastjson
    1.2.47

服务端代码(SingleChat.java)

package com.mahaiwuji.socket;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSON;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@ServerEndpoint("/singleChat/{username}")
public class SingleChat {

    // 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;
    // concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
    private static final Map users = new HashMap();

    // 与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;
    private String username;

    /**
     * 连接时执行
     *
     * @param username
     * @param session
     */
    @OnOpen
    public void onOPen(@PathParam("username") String username, Session session) {
        this.username = username;
        this.session = session;
        users.put(username, session); // 加入Map中
        System.out.println("用户登录:" + username);
        addOnlineCount(); // 在线数加1
        System.out.println("当前在线人数:" + onlineCount);
    }

    /**
     * 收到消息时执行
     *
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println(message);
        JSONObject parseObject = JSONObject.parseObject(message);
        Object nameObject = parseObject.get("name");
        Object msgObject = parseObject.get("msg");
        String name = JSON.toJSONString(nameObject);
        String msg = JSON.toJSONString(msgObject);
        name = name.substring(1, name.length() - 1);
        msg = msg.substring(1, msg.length() - 1);
        System.out.println(name);
        System.out.println(msg);
        boolean flag = sendMessageToUser(name, username + "：" + msg);
        if (flag) {
            //发送成功以后让自己也能看到消息
            sendMessageToUser(username, "我：" + msg);
        } else {
            //发送失败给发送者提示
            sendMessageToUser(username, "给" + name + "发送消息失败");
        }
    }

    /**
     * 关闭时执行
     *
     * @param session
     */
    @OnClose
    public void onClose(Session session) {
        users.remove(username); // 从Map中删除
        System.out.println("用户退出:" + username);
        subOnlineCount(); // 在线数减1
        System.out.println("有一连接关闭！当前在线人数为" + getOnlineCount());
    }

    /**
     * 连接错误时执行
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
    }

    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    public static synchronized void addOnlineCount() {
        SingleChat.onlineCount++;
    }

    public static synchronized void subOnlineCount() {
        SingleChat.onlineCount--;
    }

    /**
     * 发送信息给指定用户
     *
     * @param username
     * @param message
     * @return
     */
    public boolean sendMessageToUser(String username, String message) {
        if (users.get(username) == null)
            return false;
        Session session = users.get(username);
        if (!session.isOpen()) {
            System.out.println("客户端:" + username + ",已断开连接，发送消息失败");
            return false;
        }
        try {
            session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            System.out.println("发送失败");
            return false;
        }
        return true;
    }

}

客户端代码(singlechat.html)




    
    Title



SingleChat

对方用户名：
消息：

三、SpringBoot整合WebSocket

1.基于注解的方式

启动类

AnnotationSocketApplication.java

package com.mahaiwuji;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AnnotationSocketApplication {

    public static void main(String[] args) {
        SpringApplication.run(AnnotationSocketApplication.class, args);
    }

}

引入websocket依赖


    org.springframework.boot
    spring-boot-starter-websocket

创建节点配置类

SocketConfig.java

package com.mahaiwuji.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class SocketConfig {
    //这个bean的注册,用于扫描带有@ServerEndpoint的注解成为websocket,如果你使用外置的tomcat就不需要该配置文件
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

建立一个用来跳转连接的页面

index.html




    
    Title


GroupChat
SingleChat

1.群聊演示

服务端代码(GroupChat.java)

package com.mahaiwuji.socket;

import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

@Component
@ServerEndpoint("/groupChat/{username}")
public class GroupChat {

    // 用来存放每个客户端对应的Session对象。
    private static final Map users = new HashMap();

    // 与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;
    private String username;

    /**
     * 连接时执行
     *
     * @param username
     * @param session
     */
    @OnOpen
    public void onOPen(@PathParam("username") String username, Session session) {
        this.username = username;
        this.session = session;
        users.put(username, session); // 加入Map中
        System.out.println("用户登录:" + username);
        System.out.println("当前在线人数:" + users.size());
    }

    /**
     * 收到消息时执行
     *
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        boolean flag = sendMessageToAllUsers(username + ":" + message);
        if (flag) {
            System.out.println("群发成功");
        }
    }

    /**
     * 关闭时执行
     *
     * @param session
     */
    @OnClose
    public void onClose(Session session) {
        users.remove(username); // 从Map中删除
        System.out.println("用户退出:" + username);
        System.out.println("有一连接关闭！当前在线人数为" + users.size());
    }

    /**
     * 连接错误时执行
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    /**
     * 群发
     *
     * @param message
     * @return
     */
    public boolean sendMessageToAllUsers(String message) {
        boolean allSendSuccess = true;
        Set usernames = users.keySet();
        Session session = null;
        for (String username : usernames) {
            try {
                session = users.get(username);
                if (session.isOpen()) {
                    session.getBasicRemote().sendText(message);
                } else {
                    System.out.println("客户端:" + username + ",已断开连接，发送消息失败");
                }
            } catch (IOException e) {
                System.out.println("群发失败");
                allSendSuccess = false;
            }
        }
        return allSendSuccess;
    }
}

客户端代码(groupchat.html)




    
    Title



GroupChat

消息：

2.单聊演示

引入json依赖


    com.alibaba
    fastjson
    1.2.47

服务端代码(SingleChat.java)

package com.mahaiwuji.socket;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@Component
@ServerEndpoint("/singleChat/{username}")
public class SingleChat {

    // 用来存放每个客户端对应的Session对象。
    private static final Map users = new HashMap();

    // 与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;
    private String username;

    /**
     * 连接时执行
     *
     * @param username
     * @param session
     */
    @OnOpen
    public void onOPen(@PathParam("username") String username, Session session) {
        this.username = username;
        this.session = session;
        users.put(username, session); // 加入Map中
        System.out.println("用户登录:" + username);
        System.out.println("当前在线人数:" + users.size());
    }

    /**
     * 收到消息时执行
     *
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println(message);
        JSONObject parseObject = JSONObject.parseObject(message);
        Object nameObject = parseObject.get("name");
        Object msgObject = parseObject.get("msg");
        String name = JSON.toJSONString(nameObject);
        String msg = JSON.toJSONString(msgObject);
        name = name.substring(1, name.length() - 1);
        msg = msg.substring(1, msg.length() - 1);
        System.out.println(name);
        System.out.println(msg);
        boolean flag = sendMessageToUser(name, username + "：" + msg);
        if (flag) {
            //发送成功以后让自己也能看到消息
            sendMessageToUser(username, "我：" + msg);
        } else {
            //发送失败给发送者提示
            sendMessageToUser(username, "给" + name + "发送消息失败");
        }
    }

    /**
     * 关闭时执行
     *
     * @param session
     */
    @OnClose
    public void onClose(Session session) {
        users.remove(username); // 从Map中删除
        System.out.println("用户退出:" + username);
        System.out.println("有一连接关闭！当前在线人数为" + users.size());
    }

    /**
     * 连接错误时执行
     *
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        System.out.println("发生错误");
        error.printStackTrace();
    }

    /**
     * 发送信息给指定用户
     *
     * @param username
     * @param message
     * @return
     */
    public boolean sendMessageToUser(String username, String message) {
        if (users.get(username) == null)
            return false;
        Session session = users.get(username);
        if (!session.isOpen()) {
            System.out.println("客户端:" + username + ",已断开连接，发送消息失败");
            return false;
        }
        try {
            session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            System.out.println("发送失败");
            return false;
        }
        return true;
    }

}

客户端代码(singlechat.html)




    
    Title



SingleChat

对方用户名：
消息：

2.基于实现类的方式

启动类

ImplementsSocketApplication.java

package com.mahaiwuji;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ImplementsSocketApplication {

    public static void main(String[] args) {
        SpringApplication.run(ImplementsSocketApplication.class, args);
    }

}

引入websocket依赖


    org.springframework.boot
    spring-boot-starter-websocket

创建节点配置类

SocketConfig.java

package com.mahaiwuji.config;

import com.mahaiwuji.interceptor.*;
import com.mahaiwuji.socket.*;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

/**
 * 通过实现WebSocketConfigurer接口，可以注册相应的WebSocket处理器、路径、允许域、SockJs支持。
 */
@Configuration
@EnableWebSocket
public class SocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    }
}

建立一个用来跳转连接的页面

index.html




    
    Title


Easy
EasyPar
GroupChat
SingleChat
SockJs

1.简单实现

服务端代码(Easy.java)

package com.mahaiwuji.socket;

import org.springframework.web.socket.*;

public class Easy implements WebSocketHandler {

    /**
     * 连接时执行
     *
     * @param webSocketSession
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
        System.out.println("连接成功");
    }

    /**
     * 收到消息时执行
     *
     * @param webSocketSession
     * @param webSocketMessage
     * @throws Exception
     */
    @Override
    public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage webSocketMessage) throws Exception {
        // 获取beforeHandshake中map放入的值
        String name = (String) webSocketSession.getAttributes().get("name");
        System.out.println(name);
        // 获取客户端发送的内容
        System.out.println(webSocketMessage);
        String text = (String) webSocketMessage.getPayload();
        System.out.println(text);
        // 给客户端发送消息
        webSocketSession.sendMessage(new TextMessage("收到消息"));
    }

    /**
     * 关闭时执行
     *
     * @param webSocketSession
     * @param closeStatus
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
        System.out.println("连接关闭");
    }

    /**
     * 连接错误时执行
     *
     * @param webSocketSession
     * @param throwable
     * @throws Exception
     */
    @Override
    public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
        System.out.println("发生错误");
    }

    /**
     * 是否处理部分消息，在连接前执行
     *
     * @return
     */
    @Override
    public boolean supportsPartialMessages() {
        System.out.println("supportsPartialMessages");
        return false;
    }
}

服务端拦截器代码(EasyInterceptor.java)

package com.mahaiwuji.interceptor;

import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import java.util.Map;

/**
 * HandshakeInterceptor接口是WebSocket连接握手过程的拦截器，通过实现该接口可以对握手过程进行管理。
 * 值得注意的是，beforeHandshake中的map与WebSocketSession中通过getAttributes();
 * 返回的Map是同一个Map，我们可以在其中放入一些用户的特定信息。
 */
public class EasyInterceptor implements HandshakeInterceptor {

    /**
     * 握手前,在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param map
     * @return
     * @throws Exception
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map map) throws Exception {
        //这里给map中放入一个值，在WebSocketSession中获取
        map.put("name", "码海无际");
        System.out.println("握手前");
        return true;
    }

    /**
     * 握手后,也在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param e
     */
    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        System.out.println("握手后");
    }
}

服务端节点配置类SocketConfig.java

package com.mahaiwuji.config;

import com.mahaiwuji.interceptor.*;
import com.mahaiwuji.socket.*;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

/**
 * 通过实现WebSocketConfigurer接口，可以注册相应的WebSocket处理器、路径、允许域、SockJs支持。
 */
@Configuration
@EnableWebSocket
public class SocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new Easy(), "/easy").addInterceptors(new EasyInterceptor()).setAllowedOrigins("*");
    }
}

客户端代码(easy.html)




    
    Title



Easy

消息：

2.连接的时候传入参数

服务端代码(EasyPar.java)

package com.mahaiwuji.socket;

import org.springframework.web.socket.*;

public class EasyPar implements WebSocketHandler {

    /**
     * 连接时执行
     *
     * @param webSocketSession
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
        System.out.println("连接成功");
    }

    /**
     * 收到消息时执行
     *
     * @param webSocketSession
     * @param webSocketMessage
     * @throws Exception
     */
    @Override
    public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage webSocketMessage) throws Exception {
        // 获取beforeHandshake中map放入的值
        String username = (String) webSocketSession.getAttributes().get("username");
        System.out.println(username);
        // 获取客户端发送的内容
        System.out.println(webSocketMessage);
        String text = (String) webSocketMessage.getPayload();
        System.out.println(text);
        // 给客户端发送消息
        webSocketSession.sendMessage(new TextMessage("收到消息"));
    }

    /**
     * 关闭时执行
     *
     * @param webSocketSession
     * @param closeStatus
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
        System.out.println("连接关闭");
    }

    /**
     * 连接错误时执行
     *
     * @param webSocketSession
     * @param throwable
     * @throws Exception
     */
    @Override
    public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
        System.out.println("发生错误");
    }

    /**
     * 是否处理部分消息，在连接前执行
     *
     * @return
     */
    @Override
    public boolean supportsPartialMessages() {
        System.out.println("supportsPartialMessages");
        return false;
    }
}

服务端拦截器代码(EasyParInterceptor.java)

package com.mahaiwuji.interceptor;

import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Map;

/**
 * HandshakeInterceptor接口是WebSocket连接握手过程的拦截器，通过实现该接口可以对握手过程进行管理。
 * 值得注意的是，beforeHandshake中的map与WebSocketSession中通过getAttributes();
 * 返回的Map是同一个Map，我们可以在其中放入一些用户的特定信息。
 */
public class EasyParInterceptor implements HandshakeInterceptor {

    /**
     * 握手前,在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param map
     * @return
     * @throws Exception
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map map) throws Exception {
        System.out.println("握手前");
        HttpServletRequest httpServletRequest = ((ServletServerHttpRequest) serverHttpRequest).getServletRequest();
        String username = httpServletRequest.getParameter("username");
        System.out.println(username);
        String sex = httpServletRequest.getParameter("sex");
        System.out.println(sex);
        //这里给map中放入一个值，在WebSocketSession中获取
        map.put("username", username);
        return true;
    }

    /**
     * 握手后,也在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param e
     */
    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        System.out.println("握手后");
    }
}

服务端节点配置类SocketConfig.java

在registerWebSocketHandlers方法中添加以下代码：

registry.addHandler(new EasyPar(), "/easyPar").addInterceptors(new EasyParInterceptor()).setAllowedOrigins("*");

客户端代码(easyPar.html)




    
    Title



EasyPar

消息：

3.群聊演示

服务端代码(GroupChat.java)

package com.mahaiwuji.socket;

import org.springframework.web.socket.*;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class GroupChat implements WebSocketHandler {

    // 用来存放每个客户端对应的Session对象。
    private static final Map users = new HashMap();

    /**
     * 连接时执行
     *
     * @param webSocketSession
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
        System.out.println("连接成功");
        String username = (String) webSocketSession.getAttributes().get("username");
        users.put(username, webSocketSession);
        System.out.println("登录用户:" + username);
        System.out.println("当前在线人数:" + users.size());
    }

    /**
     * 收到消息时执行
     *
     * @param webSocketSession
     * @param webSocketMessage
     * @throws Exception
     */
    @Override
    public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage webSocketMessage) throws Exception {
        // 获取beforeHandshake中map放入的值
        String username = (String) webSocketSession.getAttributes().get("username");
        System.out.println("发送消息用户:" + username);
        // 获取客户端发送的内容
        System.out.println(webSocketMessage);
        String message = (String) webSocketMessage.getPayload();
        System.out.println(message);
        boolean flag = sendMessageToAllUsers(username + ":" + message);
        if (flag) {
            System.out.println("群发成功");
        }
    }

    /**
     * 关闭时执行
     *
     * @param webSocketSession
     * @param closeStatus
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
        System.out.println("连接关闭");
        String username = (String) webSocketSession.getAttributes().get("username");
        users.remove(username);
        System.out.println("退出用户:" + username);
        System.out.println("当前在线人数:" + users.size());
    }

    /**
     * 连接错误时执行
     *
     * @param webSocketSession
     * @param throwable
     * @throws Exception
     */
    @Override
    public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
        System.out.println("发生错误");
    }

    /**
     * 是否处理部分消息，在连接前执行
     *
     * @return
     */
    @Override
    public boolean supportsPartialMessages() {
        System.out.println("supportsPartialMessages");
        return false;
    }

    /**
     * 群发
     *
     * @param message
     * @return
     */
    public boolean sendMessageToAllUsers(String message) {
        boolean allSendSuccess = true;
        Set usernames = users.keySet();
        WebSocketSession session = null;
        for (String username : usernames) {
            try {
                session = users.get(username);
                if (session.isOpen()) {
                    session.sendMessage(new TextMessage(message));
                } else {
                    System.out.println("客户端:" + username + ",已断开连接，发送消息失败");
                }
            } catch (IOException e) {
                System.out.println("群发失败");
                allSendSuccess = false;
            }
        }
        return allSendSuccess;
    }
}

服务端拦截器代码(GroupChatInterceptor.java)

package com.mahaiwuji.interceptor;

import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/**
 * HandshakeInterceptor接口是WebSocket连接握手过程的拦截器，通过实现该接口可以对握手过程进行管理。
 * 值得注意的是，beforeHandshake中的map与WebSocketSession中通过getAttributes();
 * 返回的Map是同一个Map，我们可以在其中放入一些用户的特定信息。
 */
public class GroupChatInterceptor implements HandshakeInterceptor {

    /**
     * 握手前,在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param map
     * @return
     * @throws Exception
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map map) throws Exception {
        System.out.println("握手前");
        HttpServletRequest httpServletRequest = ((ServletServerHttpRequest) serverHttpRequest).getServletRequest();
        String username = httpServletRequest.getParameter("username");
        System.out.println(username);
        //这里给map中放入一个值，在WebSocketSession中获取
        map.put("username", username);
        return true;
    }

    /**
     * 握手后,也在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param e
     */
    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        System.out.println("握手后");
    }
}

 服务端节点配置类SocketConfig.java

在registerWebSocketHandlers方法中添加以下代码：

registry.addHandler(new GroupChat(), "/groupChat").addInterceptors(new GroupChatInterceptor()).setAllowedOrigins("*");

客户端代码(groupchat.html)




    
    Title



GroupChat

消息：

4.单聊演示

引入json依赖


    com.alibaba
    fastjson
    1.2.47

服务端代码(SingleChat.java)

package com.mahaiwuji.socket;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.springframework.web.socket.*;

import javax.websocket.Session;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class SingleChat implements WebSocketHandler {

    // 用来存放每个客户端对应的Session对象。
    private static final Map users = new HashMap();

    /**
     * 连接时执行
     *
     * @param webSocketSession
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
        System.out.println("连接成功");
        String username = (String) webSocketSession.getAttributes().get("username");
        users.put(username, webSocketSession);
        System.out.println("登录用户:" + username);
        System.out.println("当前在线人数:" + users.size());
    }

    /**
     * 收到消息时执行
     *
     * @param webSocketSession
     * @param webSocketMessage
     * @throws Exception
     */
    @Override
    public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage webSocketMessage) throws Exception {
        // 获取beforeHandshake中map放入的值
        String username = (String) webSocketSession.getAttributes().get("username");
        System.out.println("发送消息用户:" + username);
        // 获取客户端发送的内容
        System.out.println(webSocketMessage);
        String message = (String) webSocketMessage.getPayload();
        System.out.println(message);
        // 解析客户端发送的内容
        JSONObject parseObject = JSONObject.parseObject(message);
        Object nameObject = parseObject.get("name");
        Object msgObject = parseObject.get("msg");
        String name = JSON.toJSONString(nameObject);
        String msg = JSON.toJSONString(msgObject);
        name = name.substring(1, name.length() - 1);
        msg = msg.substring(1, msg.length() - 1);
        System.out.println(name);
        System.out.println(msg);
        boolean flag = sendMessageToUser(name, username + "：" + msg);
        if (flag) {
            //发送成功以后让自己也能看到消息
            sendMessageToUser(username, "我：" + msg);
        } else {
            //发送失败给发送者提示
            sendMessageToUser(username, "给" + name + "发送消息失败");
        }
    }

    /**
     * 关闭时执行
     *
     * @param webSocketSession
     * @param closeStatus
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
        System.out.println("连接关闭");
        String username = (String) webSocketSession.getAttributes().get("username");
        users.remove(username);
        System.out.println("退出用户:" + username);
        System.out.println("当前在线人数:" + users.size());
    }

    /**
     * 连接错误时执行
     *
     * @param webSocketSession
     * @param throwable
     * @throws Exception
     */
    @Override
    public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
        System.out.println("发生错误");
    }

    /**
     * 是否处理部分消息，在连接前执行
     *
     * @return
     */
    @Override
    public boolean supportsPartialMessages() {
        System.out.println("supportsPartialMessages");
        return false;
    }

    /**
     * 发送信息给指定用户
     *
     * @param username
     * @param message
     * @return
     */
    public boolean sendMessageToUser(String username, String message) {
        if (users.get(username) == null)
            return false;
        WebSocketSession session = users.get(username);
        if (!session.isOpen()) {
            System.out.println("客户端:" + username + ",已断开连接，发送消息失败");
            return false;
        }
        try {
            session.sendMessage(new TextMessage(message));
        } catch (IOException e) {
            System.out.println("发送失败");
            return false;
        }
        return true;
    }
}

 服务端拦截器代码(SingleChatInterceptor.java)

package com.mahaiwuji.interceptor;

import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/**
 * HandshakeInterceptor接口是WebSocket连接握手过程的拦截器，通过实现该接口可以对握手过程进行管理。
 * 值得注意的是，beforeHandshake中的map与WebSocketSession中通过getAttributes();
 * 返回的Map是同一个Map，我们可以在其中放入一些用户的特定信息。
 */
public class SingleChatInterceptor implements HandshakeInterceptor {

    /**
     * 握手前,在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param map
     * @return
     * @throws Exception
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map map) throws Exception {
        System.out.println("握手前");
        HttpServletRequest httpServletRequest = ((ServletServerHttpRequest) serverHttpRequest).getServletRequest();
        String username = httpServletRequest.getParameter("username");
        System.out.println(username);
        //这里给map中放入一个值，在WebSocketSession中获取
        map.put("username", username);
        return true;
    }

    /**
     * 握手后,也在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param e
     */
    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        System.out.println("握手后");
    }
}

服务端节点配置类SocketConfig.java

在registerWebSocketHandlers方法中添加以下代码：

registry.addHandler(new SingleChat(), "/singleChat").addInterceptors(new SingleChatInterceptor()).setAllowedOrigins("*");

 客户端代码(singlechat.html)




    
    Title



SingleChat

对方用户名：
消息：

5.SockJs

什么是SockJs：有一些浏览器中缺少对WebSocket的支持，而SockJS是一个浏览器的JavaScript库，它提供了一个类似于网络的对象，SockJS提供了一个连贯的，跨浏览器的JavaScriptAPI，它在浏览器和Web服务器之间创建了一个低延迟、全双工、跨域通信通道。SockJS的一大好处在于提供了浏览器兼容性。即优先使用原生WebSocket，如果浏览器不支持WebSocket，会自动降为轮询的方式。

服务端代码(SockJs.java)

package com.mahaiwuji.socket;

import org.springframework.web.socket.*;

public class SockJs implements WebSocketHandler {

    /**
     * 连接时执行
     *
     * @param webSocketSession
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession webSocketSession) throws Exception {
        System.out.println("连接成功");
    }

    /**
     * 收到消息时执行
     *
     * @param webSocketSession
     * @param webSocketMessage
     * @throws Exception
     */
    @Override
    public void handleMessage(WebSocketSession webSocketSession, WebSocketMessage webSocketMessage) throws Exception {
        // 获取beforeHandshake中map放入的值
        String name = (String) webSocketSession.getAttributes().get("name");
        System.out.println(name);
        // 获取客户端发送的内容
        System.out.println(webSocketMessage);
        String text = (String) webSocketMessage.getPayload();
        System.out.println(text);
        // 给客户端发送消息
        webSocketSession.sendMessage(new TextMessage("收到消息la"));
    }

    /**
     * 关闭时执行
     *
     * @param webSocketSession
     * @param closeStatus
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession webSocketSession, CloseStatus closeStatus) throws Exception {
        System.out.println("连接关闭");
    }

    /**
     * 连接错误时执行
     *
     * @param webSocketSession
     * @param throwable
     * @throws Exception
     */
    @Override
    public void handleTransportError(WebSocketSession webSocketSession, Throwable throwable) throws Exception {
        System.out.println("发生错误");
    }

    /**
     * 是否处理部分消息，在连接前执行
     *
     * @return
     */
    @Override
    public boolean supportsPartialMessages() {
        System.out.println("supportsPartialMessages");
        return false;
    }
}

服务端拦截器代码(SockJsInterceptor.java)

package com.mahaiwuji.interceptor;

import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import java.util.Map;

/**
 * HandshakeInterceptor接口是WebSocket连接握手过程的拦截器，通过实现该接口可以对握手过程进行管理。
 * 值得注意的是，beforeHandshake中的map与WebSocketSession中通过getAttributes();
 * 返回的Map是同一个Map，我们可以在其中放入一些用户的特定信息。
 */
public class SockJsInterceptor implements HandshakeInterceptor {

    /**
     * 握手前,在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param map
     * @return
     * @throws Exception
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map map) throws Exception {
        //这里给map中放入一个值，在WebSocketSession中获取
        map.put("name", "码海无际");
        System.out.println("握手前");
        return true;
    }

    /**
     * 握手后,也在连接前执行,并且只在每次连接前执行
     *
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @param webSocketHandler
     * @param
     */
    @Override
    public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {
        System.out.println("握手后");
    }
}

 服务端节点配置类SocketConfig.java

在registerWebSocketHandlers方法中添加以下代码：

registry.addHandler(new SockJs(), "/sockJs").addInterceptors(new SockJsInterceptor()).setAllowedOrigins("*");
registry.addHandler(new SockJs(), "/sockJs").addInterceptors(new SockJsInterceptor()).setAllowedOrigins("*").withSockJS();

客户端代码(sockjs.html)




    
    Title



SockJs

消息：

3.基于STOMP协议的方式

1.后端代码

启动类

StompSocketApplication.java

package com.mahaiwuji;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class StompSocketApplication {

    public static void main(String[] args) {
        SpringApplication.run(StompSocketApplication.class, args);
    }

}

引入websocket依赖


    org.springframework.boot
    spring-boot-starter-websocket

创建节点配置类

WebSocketConfig.java

package com.mahaiwuji.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker  //注解开启STOMP协议来传输基于代理的消息，此时控制器支持使用@MessageMapping
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        //groupChatContent用来群聊，user用来单聊，单聊必须用user
        config.enableSimpleBroker("/groupChatContent", "/user");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        //用于群聊连接
        registry.addEndpoint("/groupChat").withSockJS();
        //用于群聊连接
        registry.addEndpoint("/singleChat").withSockJS();
    }

}

 创建实体类，用来传输数据

Chat.java

package com.mahaiwuji.pojo;

public class Chat {

    // 发送消息的用户名
    private String toUsername;
    // 接收消息的用户名
    private String fromUsername;
    // 发送的内容
    private String content;

    public String getToUsername() {
        return toUsername;
    }

    public void setToUsername(String toUsername) {
        this.toUsername = toUsername;
    }

    public String getFromUsername() {
        return fromUsername;
    }

    public void setFromUsername(String fromUsername) {
        this.fromUsername = fromUsername;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Chat{" +
                "toUsername='" + toUsername + '\'' +
                ", fromUsername='" + fromUsername + '\'' +
                ", content='" + content + '\'' +
                '}';
    }
}

创建与前端页面交互的Controller

ChatController.java

package com.mahaiwuji.controller;

import com.mahaiwuji.pojo.Chat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Controller;

@Controller
public class ChatController {

    @Autowired
    public SimpMessagingTemplate template;

    /**
     * 群聊
     *
     * @param chat
     */
    @MessageMapping("/sendGroupChat")
    public void sendGroupChat(Chat chat) {
        System.out.println(chat);
        //群聊使用convertAndSend方法，第一个参数为目的地，和js中订阅的目的地要一致
        template.convertAndSend("/groupChatContent", chat.getToUsername() + ":" + chat.getContent());
    }

    @MessageMapping("/sendSingleChat")
    public void sendSingleChat(Chat chat) {
        System.out.println(chat);
        // 单聊使用convertAndSendToUser方法
        // 第一个参数为用户id
        // 此时js中的订阅地址为"/user/" + 接收消息用户 + "/singleChatContent",其中"/user"是固定的
        // convertAndSendToUser底层调用了convertAndSend
        template.convertAndSendToUser(chat.getFromUsername(), "/singleChatContent", chat.getToUsername() + "：" + chat.getContent());
        //让自己也能看到消息
        template.convertAndSendToUser(chat.getToUsername(), "/singleChatContent", "我：" + chat.getContent());
    }
}

2.前端代码

建立一个用来跳转连接的页面

index.html




    
    Title


GroupChat
SingleChat

群聊页面

groupchat.html




    
    Title



GroupChat

消息：

单聊页面

singlechat.html




    
    Title



SingleChat

对方用户名：
消息：

四、参考文献

https://www.cnblogs.com/onlymate/p/9521327.html

https://www.jianshu.com/p/d79bf8174196

https://blog.csdn.net/huiyunfei/article/details/90719351

https://www.cnblogs.com/hhhshct/p/8849449.html

https://www.cnblogs.com/jmcui/p/8999998.html

https://blog.csdn.net/qq_35387940/article/details/93483678

https://www.jianshu.com/p/4ce6cb1310e6

《Spring Boot Vue全栈开发实战》- 王松

 

 

你可能感兴趣的:(Javase)

  • 【JavaSE】封装、继承与多态 泡芙冰淇淋ya JavaSEjava开发语言
    1、封装1.1简介在Javase中，封装（Encapsulation）是面向对象编程（OOP）的一个重要概念。封装的主要目的是隐藏对象的内部状态和信息，只提供必要的公共方法来访问和操作这些状态和信息。通过封装可以控制对对象内部数据的访问级别，并保护数据不被随意修改，从而提高代码的安全性和可维护性。1.2特点信息隐藏：对象的内部状态（即属性或数据成员）被隐藏起来，外部世界只能通过对象提供的方法来访问
  • JavaSE:4、流程控制 _Power_Y JavaSEjava算法开发语言
    1、代码块与作用域变量的使用范围，仅限于其定义时所处的代码块，也就是他的作用域。目前所说的变量均为局部变量publicclassMain{publicstaticvoidmain(String[]argv){inta=10;{intb=10;System.out.println(a);System.out.println(b);}System.out.println(a);//System.out
  • java中的ide、sdk是什么,javaee\javase\javame区别 极客Thomas idejavaeclipse
    ide：integrateddevelopmentenvironment集成开发环境简单的来说就是提供编译代码等一系列功能的开发环境比如：eclipsesdk：servicedevelopmentpack服务开发包简单来说就是一些封装的功能代码，做成了一个包，给我们可以直接调用比如jdk1.8jdkjavase（JavaPlatform，StandardEdition）标准版本，在电脑上运行jav
  • JavaSE项目--图书管理系统代码 码来码去（未来可期） Java学习java
    结构代码展示Book类代码packagecom.xszx.beans;//实体类publicclassBook{privateintid;privateStringname;privateintbsum;publicBook(){}publicBook(intid,Stringname,intbsum){this.id=id;this.name=name;this.bsum=bsum;}publi
  • JavaSE之static关键字 麦芒疯狂生长！ JavaSEjava开发语言
    不积跬步无以至千里，不积小流无已成江海一、认识static我们在学习一个关键字时，首先要关注这个关键字有什么用？我们为什么要学习它？这里给大家先介绍一下static都会出现在我们日常项目的哪些位置。static主要会出现在工具类和测试类当中，这里讲一下什么是JavaBean类、工具类和测试类。1、JavaBean类：用来描述一类事物的类，比如Student类、Teacher类、Dog类、Cat类等
  • 大二上学期详细学习计划 学会沉淀。 学习
    本学习完成目标：项目：书籍：《mysql必知必会》《java核心技术卷》（暂时）加强JavaSE的学习，掌握Java核心Mysql+sql（把牛客上的那50道sql语句题写完）git+maven完成springboot项目（跟着黑马敲）对于每天的Java学习进行记录算法：刷题（多去刷cf上的题，每周15道）针对最近比赛薄弱的地方加强练习（图论，字符串，动态规划，搜索）cf先上1400，牛客和atc
  • JavaSE：数据类型与变量 牛牪犇犇 javajava开发语言
    目录1.字面常量2.数据类型3.变量3.1变量概念3.2语法格式3.3整型变量3.3.1整型变量3.3.2长整型变量3.3.3短整形变量3.3.4字节型变量3.4浮点型变量3.4.1单精度浮点型3.4.2双精度浮点类型3.5字符型变量3.6布尔型变量3.7类型转换3.7.1自动类型转换(隐式)3.7.2强制类型转换(显式)3.8类型提升3.8字符串类型1.字面常量System.Out.printl
  • JavaSE第一课基本数据类型 走自己的路做自己 JavaSEJavaSE之基本的数据类型
    **基本数据类型**数据类型的分类1.数值2.非数值变量的声明与使用1.声明2.赋值3.声明时直接赋值变量命名的规则1.首字母2.其余部分运算符赋值运算符算术运算符自动类型转换强制类型转换关系运算符数据类型的分类1.数值整型:`byte,short,int,long`浮点型:`float,double`2.非数值布尔类型：`boolean字符：`char`字符串：`String`布尔类型的值只能为
  • JavaSE:1、程序代码基本结构 _Power_Y JavaSEjava开发语言
    1、固定模式publicclassMain{publicstaticvoidmain(String[]args){System.out.println("HelloWorld!");}}System.out.println是换行输出System.out.printf可以按照C语言方式输出System.out.print是正常输出2、注释行注释publicclassMain{publicstatic
  • JavaSE:3、运算符 _Power_Y JavaSEjava开发语言
    1、赋值运算符从右往左运算，左边是可赋值的目标，返回计算结果publicclassMain{publicstaticvoidmain(String[]argv){inta=10;intb=a=100;System.out.println(a);//输出100System.out.println(b);//输出100}}2、算术运算符+-*/%（1）加法支持字符串拼接，变量常量相加，隐式类型转换。类
  • Javase | 基本数据类型、引用数据类型 一只大皮卡丘 Java知识点-整合java开发语言
    目录：一、Java数据类型的分类？二、什么是基本数据类型？三、什么是引用数据类型？四、引用数据类型如何比较？五、基本数据类型和引用数据类型的区别？六、基本数据类型和引用数据类型的”数据存储“有何区别?一、Java数据类型的分类？Java中的数据类型可以分为两类：基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型和布尔型，它们在内存中占据固定的空间，并且可以直接进行算术运算、比较等操作
  • JavaEE简介 晚睡早起₍˄·͈༝·͈˄*₎◞ ̑̑ java-eejava
    JavaEE是java的企业级版本，可以用来开发BS结构应用程序。开发javaEE应用程序需要的工具：JDK(JavaSE环境)Web服务器(JavaEE环境)2.1.Tomcat服务器2.1.1.安装Tomcat服务器双击“apache-tomcat-8.5.55.exe”进行安装。安装完毕后，配置Tomcat环境变量。○CATALINA_HOME：Tomcat安装路径○PATH：%CATALI
  • Hadoop Common 之序列化机制小解 猫君之上 #ApacheHadoop
    1.JavaSerializable序列化该序列化通过ObjectInputStream的readObject实现序列化，ObjectOutputStream的writeObject实现反序列化。这不过此种序列化虽然跨病态兼容性强，但是因为存储过多的信息，但是传输效率比较低，所以hadoop弃用它。（序列化信息包括这个对象的类，类签名，类的所有静态，费静态成员的值，以及他们父类都要被写入）publ
  • Java SE 6 新特性: XML API 与 Web 服务 love_baobao Java基础类xmljavawebapi框架import
    JavaSE6做为一个开发平台，针对不同的应用开发需求，提供了各种各样的技术框架。XML处理框架是JDK6的重要组成部分之一。它为应用程序开发人员提供了一个统一的XML处理API。这种框架结构有两个作用：一方面，开发人员透过这些框架，可以透明的替换不同厂商提供的XML处理服务；另一方面，服务提供商可以透过这些框架，将自己的产品插入到JDK中。这种框架一般被称为ServiceProvider机制。J
  • Tomcat与JDK版本对应关系，Tomcat各版本特性 2401_84048671 程序员javatomcat开发语言
    ApacheTomcat8.xApacheTomcat7.xApacheTomcat6.xApacheTomcat是一个开源软件实现了JavaServlet和JavaServerPages技术。不同版本的Servlet和JSP规范可使用不同版本的ApacheTomcat。Tomcat与JDK版本对应关系为：|Servlet规格|JSP规范|EL规格|WebSocket规范|JASPIC规格|Apa
  • javase笔记3----正则表达式 芝奥小婷 笔记
    正则表达式简介正则表达式（RegularExpressions），是一个特殊的字符串，可以对普通的字符串进行校验检测等工作，校验一个字符串是否满足预设的规则。基本语法字符集合[]:表示匹配括号里的任意一个字符。[abc]:匹配a或者b或者c[^abc]:匹配任意一个字符，只要不是a,或b,或c就表示匹配成功[a-z]:表示匹配所有的小写字母的任意一个。[A-Za-z]:表示匹配所有的小写字母和大写
  • AccessControlFilter 和 javax.servlet.Filter 傻傻分不清楚？？看过来吧。 童龙辉 servlet
    目录一、概念1.1javax.servlet.Filter1.2AccessControlFilter二、区别2.1框架方面2.2用途方面2.3集成方面三、使用场景3.1javax.servlet.Filter3.2AccessControlFilter四、总结一、概念1.1javax.servlet.FilterJavaServlet规范的一部分，用于对请求和响应进行预处理和后处理。它在整个we
  • Java好资源网址推荐 学习&实践爱好者 Java学习编程资料java开发语言
    Java好资源网址推荐Java官方教程https://docs.oracle.com/javase/tutorial/index.htmlJavaDocumentationhttps://docs.oracle.com/en/java/JavaSELicensingUserManualhttps://www.oracle.com/java/technologies/javase/licensing
  • chapter01 Java语言概述 知识点Note 月下绯烟 Javajava开发语言
    JavaSEJavaEEJavaME大数据Java基础常用技术栈mysqlJDBCSSMspring+springmvc+mybatisLinuxnacosHadoopFlinkJAVAEE消息队列rabbitMQdocker数据库redisspringbootspringcloudsshstruts+spring+hibernate过时技术栈很少用JAVA虚拟机jvm分布式微服务高并发常见dos
  • 请解释JSP中的九大内置对象及其作用。什么是Java Web中的请求转发和重定向？它们有什么区别？ 计算机学长阿伟 javajava前端开发语言
    请解释JSP中的九大内置对象及其作用。JSP（JavaServerPages）中的九大内置对象（也称为隐式对象或自动对象）是JSP容器为每个页面提供的Java对象，这些对象在JSP页面被转换成Servlet时自动可用，无需显式声明。这些对象极大地简化了JSP页面的开发，因为它们提供了对Web应用程序中常见功能的直接访问。以下是九大内置对象及其作用的详细解释：request：javax.servle
  • Java环境搭建指南：从新手到专家的全方位教程！ 疾风终究没有归途 java入门java
    Java是一种广泛使用的编程语言，具有跨平台的特性，这意味着只要一次编写，就可以在支持Java的任何系统上运行，无论是Windows、MacOS还是Linux。要开始使用Java进行开发，首先需要搭建Java开发环境，这包括下载并安装JavaDevelopmentKit(JDK)以及配置相应的环境变量。具体步骤如下：选择和下载JDK了解和选择Java版本：Java有多个版本，如JavaSE、Jav
  • java后端未来学习之路 命z javajava后端学习
    最近找到了一篇文章，感觉是自己可以借鉴的，具体内容如下：首先，我个人比较推崇的学习方法是：先学java前端，也就是HTML，css，js，因为学习java以后肯定是往javaee方向发展的，学习完前端，在学习后端很多东西比计较容易理解！其中J2SE是关键，如果学好了javase部分，基础扎实了，后面进阶学习也比较轻松！补充说明一下：我觉得学习java比较合适的方法是先把所有的知识点过一遍，然后把所
  • 大厂高频面试题复习JAVA学习笔记-学习路线 addaduvyhup java开发语言
    对于应届生，要找到一份java工作，你得大概学会：java基础：javase、jvm、juc、gc、mysql、jdbc，计网计组Java微服务基础Maven→Gradle→Spring6→SpringMVC→MyBatis→MyBatisPlus→SSM->Redis7->SpringBoot2->SpringCloudjava微服务生态:Git-Docker-Elasticsearch→Zoo
  • javaSE (六)：IO 404_NOT_FOUND@ JavaSEjava算法开发语言
    目录一、File类●File类的构造方法●File类的常用方法二、输入及输出的概念三、输入流与输出流●流按着数据的传输方向分为：●从数据流编码格式上划分为：●InputStream和OutputStream的子类都是字节流●Reader和Writer的子类都是字符流四、字节流与字符流●字节流中常用类●字符流中常用类五、输入输出节点字节流●InputStream的基本方法●OutputStream的
  • Java运行时内存区域 benlocke Javajavajvmheapstack内存
    Java虚拟机（JavaSE7版）管理的内存包括以下几个运行时数据区域。1.程序计数器程序计数器（ProgramCounterRegister）是当前线程所执行的字节码的行号指示器。字节码解释器需要通过这个计数器的值来读取下一条执行的字节码指令，各种分支跳转、异常处理等。Java虚拟机的多线程是通过线程轮流切换并且分配时间片的方式来实现的，所以在任何一个moment，一个处理器都只会执行一条线程中
  • 【Java那些年系列-启航篇 01】史上最强JavaSE学习路线图 & 知识图谱 夏之以寒 Java那些年专栏JavaJavaSEJava学习路线Java知识图谱
    【Java那些年系列-启航篇01】史上最强JavaSE学习路线图&知识图谱作者名称：纸飞机-暖阳作者简介：专注于Java和大数据领域，致力于探索技术的边界，分享前沿的实践和洞见文章专栏：Java那些年专栏专栏介绍：本专栏涵盖了JavaSE从基础语法到面向对象编程，从异常处理到集合框架，从I/O流到多线程并发，再到网络编程和虚拟机内部机制等一系列编程要素个人感慨：市面上关于JavaSE的学习路线或知
  • 【Java那些年系列-启航篇 04】Java程序架构：深入理解类与对象的设计原则 夏之以寒 Java那些年专栏java架构类对象数据结构
    作者名称：纸飞机-暖阳作者简介：专注于Java和大数据领域，致力于探索技术的边界，分享前沿的实践和洞见文章专栏：Java那些年专栏专栏介绍：本专栏涵盖了JavaSE从基础语法到面向对象编程，从异常处理到集合框架，从I/O流到多线程并发，再到网络编程和虚拟机内部机制等一系列编程要素个人感慨：市面上关于JavaSE的学习路线或知识图谱很繁杂，学习起来比较费劲，Java知识体系非常庞大，刚接触阶段只需要
  • linux安装java -centos安装java -linux配置java环境变量 shuair 环境配置linuxjavacentos
    下载jdk推荐下载jdk-8u202-linux-x64.tar.gz下载页面：https://www.oracle.com/java/technologies/javase/javase8-archive-downloads.html下载时注意版本号，下载需要登录安装jdk#如果服务器中已存在openjdk等组件时，可以选择直接使用，或者卸载后安装自己下载的jdk#在/usr/local下创建j
  • 测试培训_02_JAVA介绍及安装配置 方步
    学习JAVA首先要安装JAVA虚拟机，就是平时说的JDK。安装时注意两点就行了一、记住安装的路径以及jre的路径二、配置环境变量JAVA_home和path安装好工具先来个小试牛刀，这一个程序耍耍。比如helloworld。这会涉及一些变量常量，数据类型等问题。正式开始了JAVA之旅。单独学习JAVASE需要记很多东西，所以应该从一开始养成学习编程语言的好习惯，拿一个单独的笔记本。步入一个行业，在
  • JavaSE基础学习day3--异常&&集合 yz不摆烂24124 学习java
    目录1.异常1.1异常概述1.2JVM的默认处理方案1.3异常处理1.4异常处理之try...catch...1.5Throwable的成员方法1.6编译时异常和运行时异常的区别1.7异常处理之throws1.8自定义异常1.9throws和throw的区别throwsthrow2.集合引入3.Collection3.1Collection的概述3.2Collection集合使用方法3.3集合的遍
  • 关于旗正规则引擎规则中的上传和下载问题 何必如此 文件下载压缩jsp文件上传
    文件的上传下载都是数据流的输入输出，大致流程都是一样的。 一、文件打包下载 1.文件写入压缩包 string mainPath="D:\upload\";     下载路径 string tmpfileName=jar.zip;        &n
  • 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析 bit1129 Stream
      以如下代码为例（SocketInputDStream）： Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
  • spark master web ui 端口8080被占用解决方法 daizj 8080端口占用sparkmaster web ui
    spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法：   1、cd SPARK_HOME/sbin   2、vi start-master.sh     3、定位到下面部分
  • oracle_执行计划_谓词信息和数据获取 周凡杨 oracle执行计划
      oracle_执行计划_谓词信息和数据获取(上) 一：简要说明 在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
  • spring中datasource配置 g21121 dataSource
    datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： http://baike.baidu.com/view/920062.htm   <!-- spring加载资源文件 --> <bean name="propertiesConfig" class="org.springframework.b
  • web报表工具FineReport使用中遇到的常见报错及解决办法（三） 老A不折腾 finereportFAQ报表软件
    这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、repeated column width is largerthan paper width： 这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
  • mysql 用户管理 墙头上一根草 linuxmysqluser
    1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
  • 关于使用Spring导致c3p0数据库死锁问题 aijuans springSpring 入门Spring 实例Spring3Spring 教程
    这个问题我实在是为整个 springsource 的员工蒙羞 如果大家使用 spring 控制事务，使用 Open Session In View 模式， com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
  • 百度词库联想 annan211 百度
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>RunJS</title&g
  • int数据与byte之间的相互转换实现代码 百合不是茶 位移int转bytebyte转int基本数据类型的实现
    在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来;   主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029   int转byte;   byte转int;   /** * 字节转成int,int转成字节 * @author Administrator *
  • 简单模拟实现数据库连接池 bijian1013 javathreadjava多线程简单模拟实现数据库连接池
    简单模拟实现数据库连接池 实例1： package com.bijian.thread; public class DB { //private static final int MAX_COUNT = 10; private static final DB instance = new DB(); private int count = 0; private i
  • 一种基于Weblogic容器的鉴权设计 bijian1013 javaweblogic
            服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： String vuser_id = "weblogic"; String vuse
  • 【RPC框架Hessian二】Hessian 对象序列化和反序列化 bit1129 hessian
     任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。   1. 定义三个POJO    Person类 package com.tom.hes
  • 【Hadoop十四】Hadoop提供的脚本的功能 bit1129 hadoop
    1. hadoop-daemon.sh 1.1 启动HDFS ./hadoop-daemon.sh start namenode ./hadoop-daemon.sh start datanode  通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
  • 中国互联网走在“灰度”上 ronin47 管理 灰度
    中国互联网走在“灰度”上（转） 文/孕峰   第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。   灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
  • java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 bylijinnan java
    public class PrintMatrixClockwisely { /** * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 例如：如果输入如下矩阵： 1 2 3 4 5 6 7 8 9
  • mongoDB 用户管理 开窍的石头 mongoDB用户管理
      1:添加用户    第一次设置用户需要进入admin数据库下设置超级用户（use admin）      db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]});    第一个参数用户的名字    第二个参数
  • [游戏与生活]玩暗黑破坏神3的一些问题 comsci 生活
        暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意      玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天      结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气   &nb
  • java 二维数组如何存入数据库 cuiyadll java
    using System; using System.Linq; using System.Text; using System.Windows.Forms; using System.Xml; using System.Xml.Serialization; using System.IO; namespace WindowsFormsApplication1 {
  • 本地事务和全局事务Local Transaction and Global Transaction(JTA) darrenzhu javaspringlocalglobaltransaction
    Configuring Spring and JTA without full Java EE http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ Spring doc -Transaction Management http://docs.spring.io/spri
  • Linux命令之alias - 设置命令的别名，让 Linux 命令更简练 dcj3sjt126com linuxalias
    用途说明 设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。   常用参数 格式：alias 格式：ali
  • yii2 restful web服务[格式响应] dcj3sjt126com PHPyii2
    响应格式 当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
  • MongoDB索引调优（2）——[十] eksliang mongodbMongoDB索引优化
    转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述       上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档     可以在嵌套文档的键上建立索引，方式与正常
  • 当滑动到顶部和底部时，实现Item的分离效果的ListView gundumw100 android
    拉动ListView，Item之间的间距会变大，释放后恢复原样； package cn.tangdada.tangbang.widget; import android.annotation.TargetApi; import android.content.Context; import android.content.res.TypedArray; import andr
  • 程序员用HTML5制作的爱心树表白动画 ini JavaScriptjqueryWebhtml5css
    体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" > <ti
  • 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版 kakajw ThinkPad预装改装windows 7windows 8
      该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！   缘由 小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
  • Nginx学习笔记 mcj8089 nginx
    一、安装nginx             1、在nginx官方网站下载一个包，下载地址是：  http://nginx.org/download/nginx-1.4.2.tar.gz      2、WinSCP(ftp上传工
  • mongodb 聚合查询每天论坛链接点击次数 qiaolevip 每天进步一点点学习永无止境mongodb纵观千象
    /* 18 */ { "_id" : ObjectId("5596414cbe4d73a327e50274"), "msgType" : "text", "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
  • java术语（PO/POJO/VO/BO/DAO/DTO） Luob. DAOPOJODTOpoVO BO
    PO(persistant object) 持久对象 在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作. VO(value object) 值对象 通
  • 算法复杂度 Wuaner Algorithm
    Time Complexity & Big-O： http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o http://bigocheatsheet.com/ http://www.sitepoint.com/time-complexity-algorithms/
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他