websocket 服务器端（tomcat)与 客户端（Android）配置搭建实现通信详解_android websocket客户端

服务端部署
在服务端src/websocket目录下新建一个.java文件，命名为chat.java,
注意事项：
1、利用@ServerEndpoint(“/ExampleSeverAndroid”)设定访问URL,此处websocket连接访问url为Http://localhost:8080/ExampleSeverAndroid.
2、重写websocket的@OnOpen、@OnClose、@OnMessage、@OnError方法
3、在与websocket.java同目录下新建Democonfig.java以实现websocket的配置调用方法。
chat.java源码(巨乱，很多无用代码，按需索取）：

package websocket;

import bean.MyMessage;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import dao.UserDao;
import util.StringUtil;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CopyOnWriteArraySet;
//import net.sf.json.JSONObject;

//import net.sf.json.JSONObject;
//该注解用来指定一个URI，客户端可以通过这个URI来连接到WebSocket。类似Servlet的注解mapping。无需在web.xml中配置。
@ServerEndpoint("/ExampleSeverAndroid")
public class Chat {
    //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;
    //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话，可以使用Map来存放，其中Key可以为用户标识
    private static CopyOnWriteArraySet<Chat> webSocketSet = new CopyOnWriteArraySet<Chat>();
    //与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;
    /**
     * 连接建立成功调用的方法
     * @param session  可选的参数。session为与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId){
        this.session = session;
        webSocketSet.add(this);     //加入set中
        addOnlineCount();           //在线数加1
        System.out.println("OPEN!" + getOnlineCount());

//        JSONObject msg = new JSONObject();
//        try {
//            msg.put("msg", "连接成功");
//            msg.put("status", "SUCCESS");
//            msg.put("userId", userId);
//            sendMessage(JSON.toJSONString(msg));
//        } catch (Exception e) {
//           //logger.debug("IO异常");
//        }
    }
    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose( @PathParam("userId") String userId){
        webSocketSet.remove(this);  //从set中删除
        subOnlineCount();           //在线数减1
        System.out.println("Close!" + getOnlineCount());
    }

    /**
     * 收到客户端消息后调用的方法
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message,  @PathParam("userId") String userId) {
        System.out.println("Message From Client:" + message);
        try {
            MyMessage myMessage = JSON.parseObject(message, MyMessage.class);
            String messageType = myMessage.getMessageType();
            //"MessageType"
            //"
            //朋友圈上传
            if(messageType.equals("post"))
            {    //朋友圈文案
                String messageContent = myMessage.getMessage();
                //图片base64转码字符串
                String messageImage = myMessage.getImage();
                //用户名
                //System.out.println("11111111111111");
                String messageusername = myMessage.getUsername();
                UserDao dao = new UserDao();
                dao.ImageAndText(messageusername,messageImage,messageContent);
             //评论上传
            }else if(messageType.equals("comment"))
            {
                String comment = myMessage.getComment();
                String time = myMessage.getTimestamp();
                UserDao dao = new UserDao();
                dao.Comment(myMessage.getUsername(),myMessage.getTimestamp(),myMessage.getComment());
            }
         //  System.out.println("");
            //广播当前朋友圈
            for(Chat item: webSocketSet){
                try {
                    UserDao dao = new UserDao();
                    List<String> share =  dao.GetShare();
                    String str = share.toString();
                   // System.out.println(str);
                    item.sendMessage(share.toString());
                } catch (IOException e) {
                    e.printStackTrace();
                    continue;
                }
            }

//            if("1".equals(messageType)){ //单聊
//                String recUser = myMessage.getUserId();//recUser：消息接收者
//               // sendInfo(messageContent,recUser,userId);//messageContent：输入框实际内容 recUser：消息接收者  userId 消息发送者
//            }else{ //群聊
//               // sendGroupInfo(messageContent,userId);//messageContent：输入框实际内容 userId 消息发送者
//            }
        } catch (Exception e) {
          //  logger.error("解析失败：{}", e);
        }
        //群发消息

    }

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

    /**
     * 这个方法与上面几个方法不一样。没有用注解，是根据自己需要添加的方法。
     * @param message
     * @throws IOException
     */
    public synchronized void sendMessage(String message) throws IOException{
       // this.session.getBasicRemote().sendText(message);
        this.session.getAsyncRemote().sendText(message);
    }

    /**
     * 群聊
     * message ： 消息内容，输入的实际内容，不是拼接后的内容
     * sendUser : 消息发送者
     */
    public  void sendGroupInfo(String message,String sendUser) throws IOException {
        JSONObject msgObject = new JSONObject();//msgObject 包含发送者信息的消息
        if (StringUtil.isNotEmpty(webSocketSet)) {
            for (Chat item : webSocketSet) {

                   // logger.info("回送消息:" + message);
                    //拼接返回的消息，除了输入的实际内容，还要包含发送者信息
                    msgObject.put("message",message);
                    msgObject.put("sendUser",sendUser);
                    item.sendMessage(JSON.toJSONString(msgObject));

            }
        }
    }

    /**
     * 单聊
     * message ： 消息内容，输入的实际内容，不是拼接后的内容
     * recUser : 消息接收者
     * sendUser : 消息发送者
     */
//    public void sendInfo( String message , String recUser,String sendUser) {
//        JSONObject msgObject = new JSONObject();//msgObject 包含发送者信息的消息
//        for (Chat item : webSocketSet) {
//            if (StringUtil.equals(item.userId, recUser)) {
//               // logger.info("给用户" + recUser + "传递消息:" + message);
//                //拼接返回的消息，除了输入的实际内容，还要包含发送者信息
//                msgObject.put("message",message);
//                msgObject.put("sendUser",sendUser);
//                item.sendMessage(JSON.toJSONString(msgObject));
//            }
//        }
//    }
    /**
     * 群聊
     * message ： 消息内容，输入的实际内容，不是拼接后的内容
     * sendUser : 消息发送者
     */
//    public  void sendGroupInfo(String message,String sendUser) {
//        JSONObject msgObject = new JSONObject();//msgObject 包含发送者信息的消息
//        if (StringUtil.isNotEmpty(webSocketSet)) {
//            for (Chat item : webSocketSet) {
//                if(!StringUtil.equals(item.userId, sendUser)) { //排除给发送者自身回送消息,如果不是自己就回送
//                    logger.info("回送消息:" + message);
//                    //拼接返回的消息，除了输入的实际内容，还要包含发送者信息
//                    msgObject.put("message",message);
//                    msgObject.put("sendUser",sendUser);
//                    item.sendMessage(JSON.toJSONString(msgObject));
//                }
//            }
//        }
//    }
    /**
     * Map/Set的key为自定义对象时，必须重写hashCode和equals。
     * 关于hashCode和equals的处理，遵循如下规则：
     * 1）只要重写equals，就必须重写hashCode。
     * 2）因为Set存储的是不重复的对象，依据hashCode和equals进行判断，所以Set存储的对象必须重写这两个方法。
     * 3）如果自定义对象做为Map的键，那么必须重写hashCode和equals。
     *
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Chat that = (Chat) o;
        return Objects.equals(session, that.session);
    }

    @Override
    public int hashCode() {
        return Objects.hash(session);
    }

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

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

    public static synchronized void subOnlineCount() {
        Chat.onlineCount--;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233

democonfig.java源码：

package websocket;

import javax.websocket.Endpoint;
import javax.websocket.server.ServerApplicationConfig;
import javax.websocket.server.ServerEndpointConfig;
import java.util.Set;

public class DemeConfig implements ServerApplicationConfig{
	//注解的方式 启动 
	public Set<Class<?>> getAnnotatedEndpointClasses(Set<Class<?>> scan) {
		System.out.println("-------------websoket start--------00---------");
		System.out.println("scan.size() = " + scan.size());
		
		return scan;  //必须要返回scan,否则会造成连接失败 
	}

	//接口方式启动  
	public Set<ServerEndpointConfig> getEndpointConfigs(
			Set<Class<? extends Endpoint>> arg0) {
	
		return null;
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

服务端完毕！

客户端（Android)

private static final String wsurl = "ws://192.168.0.115:8080/ExampleSeverAndroid";
 public  static  WebSocketConnection mConnect = new WebSocketConnection();
 //发送函数
 public static void sendMessage(String msg1) {
        if (mConnect.isConnected()) {
            mConnect.sendTextMessage(msg1);
        } else {
            Log.i(TAG, "no connection!!");
        }
    }
                     WebSocketOptions options = new WebSocketOptions();
                     options.setMaxMessagePayloadSize(1000000); //max size of message
                     options.setMaxFramePayloadSize(1000000); //max size of frame
                    mConnect.connect(wsurl, new WebSocketHandler() {
                      @Override
                      public void onOpen() {
                         System.out.println("open方法调用");
                         Log.i(TAG, "Status:Connect to " + wsurl);
                       }
                        @Override
                        public void onTextMessage(String payload) {
                            System.out.println("接受到消息");
                            System.out.println(payload);
                            JSONArray array = JSONArray.parseArray(payload);
                            mRecyclerView = findViewById(R.id.recyclerview);
                            //每次刷新前清空
                            mNewsList.clear();
                            for (int i = 0; i < array.size(); i++) {
                                News news = new News();
                                JSONObject jo = array.getJSONObject(i);
                                news.username = jo.getString("username");
                                //同时可以等于自己
                                if(!friends.contains(news.username)&&!login_username.equals(news.username))
                                    continue;
                                news.time = jo.getString("time");
                                news.text = jo.getString("text");
                                news.image = jo.getString("image");
                                news.comment = jo.getString("comment");
                                mNewsList.add(news);
                            }
                            mMyAdapter = new MyAdapter();
                            mRecyclerView.setAdapter(mMyAdapter);
                            LinearLayoutManager layoutManager = new LinearLayoutManager(MomentActivity.this);
                            mRecyclerView.setLayoutManager(layoutManager);

                        }

                        @Override
                        public void onClose(int code, String reason) {
                            Log.i(TAG, "Connection lost..");
                            System.out.println("关闭");
                        }
                    },options);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

Andriod 中发送时，需要另外开启一个线程，不能再主线程中执行 ，否则会报错：

 newThread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                JSONObject msg = new JSONObject();
                try {
                    msg.put("messageType", "get");
                    //线程睡眠，等websocketwriter创建后再执行sendMessage
                    Thread.sleep(500);
                    sendMessage(JSON.toJSONString(msg));
                    System.out.println("json 数据发送成功");
                } catch (Exception e) {
                    //logger.debug("IO异常");
                    System.out.println("异常"+e);
                }
            }
        });
        newThread1.start();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

移动端完毕！

文章及其草率与混乱，，需要摘取，，不要误导读者思路