Creating a Whatsapp Clone - Part XV - Transcript.pdf

Creating a WhatsApp Clone - Part XV
Next we’ll jump to the websocket package which is the last package

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Bean
public ServletServerContainerFactoryBean createWebSocketContainer() {
ServletServerContainerFactoryBean container =
new ServletServerContainerFactoryBean();
container.setMaxTextMessageBufferSize(8192);
container.setMaxBinaryMessageBufferSize(8192);
return container;
}
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry
registry) {
registry.addHandler(myHandler(), "/socket");
}
@Bean
public WebSocketHandler myHandler() {
AppSocket
First we need to configure the web socket.

We do this by implementing the WebSocketConfigurer and using the annotations on the class to indicate its purpose

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Bean
return container;
}
@Override
registry) {
}
@Bean
AppSocket
We define the socket so we can define the packet size to 8kb. We can set a larger size but generally keeping packets small is a good practice

return container;
}
@Override
registry) {
}
@Bean
return new AppSocket();
}
@Bean
public TaskScheduler taskScheduler() {
return new ConcurrentTaskScheduler(Executors.
newSingleThreadScheduledExecutor());
}
AppSocket
The AppSocket class is bound to the /socket URL in this line of code

return container;
}
@Override
registry) {
}
@Bean
return new AppSocket();
}
@Bean
public TaskScheduler taskScheduler() {
return new ConcurrentTaskScheduler(Executors.
newSingleThreadScheduledExecutor());
}
}
AppSocket
This is the thread used to process the websocket connections. We can allocate more thread resources based on need

import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
public class AppSocket extends TextWebSocketHandler {
private static Logger log =
Logger.getLogger(AppSocket.class.getName());
private static final Map<String, List<WebSocketSession>> clients =
new HashMap<>();
@Autowired
private UserService users;
private static boolean sendToToken(String token, String json) {
List<WebSocketSession> ws = clients.get(token);
WebSocketSession currentSocket = null;
try {
if(ws != null) {
TextMessage t = new TextMessage(json);
List<WebSocketSession> removeQueue = null;
for(WebSocketSession w : ws) {
currentSocket = w;
if(currentSocket.isOpen()) {
AppSocket
Next lets go to AppSocket

The app socket is an implementation of TextWebSocketHandler which handles text messages. Since all our messages are JSON this makes more sense.

import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
new HashMap<>();
@Autowired
try {
if(ws != null) {
currentSocket = w;
AppSocket
I cache the currently active connections here. This isn’t a good approach in the long term. A better approach would be redis for this sort of caching. But for an initial app
this can work fine

new HashMap<>();
@Autowired
try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
AppSocket
We need access to the UsersService so we can send a message to a group or user.

new HashMap<>();
@Autowired
try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
} else {
if(removeQueue == null) {
removeQueue = new ArrayList<>();
}
removeQueue.add(w);
}
AppSocket
This method sends JSON to a websocket based on the user token and returns true if it succeeded.

new HashMap<>();
@Autowired
try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
} else {
}
removeQueue.add(w);
}
AppSocket
We get the sessions for the given client

try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
} else {
}
removeQueue.add(w);
}
}
if(removeQueue != null) {
for(WebSocketSession w : removeQueue) {
ws.remove(w);
}
AppSocket
If he has a webservice sessions

try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
} else {
}
removeQueue.add(w);
}
}
ws.remove(w);
}
AppSocket
We create a text message with the JSON

try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
} else {
}
removeQueue.add(w);
}
}
ws.remove(w);
}
}
} else {
AppSocket
We loop over all the websocket connections one by one

try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
} else {
}
removeQueue.add(w);
}
}
ws.remove(w);
}
}
} else {
AppSocket
If a connection is open we send the message there and return

try {
if(ws != null) {
currentSocket = w;
w.sendMessage(t);
return true;
} else {
}
removeQueue.add(w);
}
}
ws.remove(w);
}
}
} else {
AppSocket
Otherwise we add the socket to the remove queue. We don’t want to remove in the middle of the loop to prevent an exception.

}
removeQueue.add(w);
}
}
ws.remove(w);
}
}
} else {
log.warning("No WS connections for token: " + token);
}
} catch(IOException err) {
log.log(Level.SEVERE, "Exception during sending message", err);
if(currentSocket != null && ws != null) {
ws.remove(currentSocket);
if(ws.isEmpty()) {
clients.remove(token);
}
}
}
return false;
AppSocket
We remove all the defunct websockets from the queue in this line

removeQueue.add(w);
}
}
ws.remove(w);
}
}
} else {
log.warning("No WS connections for token: " + token);
}
} catch(IOException err) {
log.log(Level.SEVERE, "Exception during sending message", err);
if(currentSocket != null && ws != null) {
ws.remove(currentSocket);
if(ws.isEmpty()) {
clients.remove(token);
}
}
}
return false;
}
public static void sendUserTyping(String token, String id,
AppSocket
For all the cases where sending via the socket didn't work we return false

"","authorId":"" + id + ""}");
}
public static boolean sendMessage(String token, String json) {
return sendToToken(token, json);
}
@Override
protected void handleTextMessage(WebSocketSession session,
TextMessage message) throws Exception {
JsonParser parser = JsonParserFactory.getJsonParser();
Map<String, Object> m = parser.parseMap(message.getPayload());
String type = (String)m.get("t");
if(type != null) {
if(type.equals("init")) {
String token = (String)m.get("tok");
Number time = (Number)m.get("time");
List<WebSocketSession> l = clients.get(token);
if(l == null) {
l = new ArrayList<>();
clients.put(token, l);
}
l.add(session);
return;
AppSocket
This method handles the incoming text packets

public static boolean sendMessage(String token, String json) {
return sendToToken(token, json);
}
@Override
if(type != null) {
if(l == null) {
}
l.add(session);
return;
}
} else {
String typing = (String)m.get("typing");
AppSocket
First we need to parse the JSON into a map

@Override
if(type != null) {
if(l == null) {
}
l.add(session);
return;
}
} else {
String sentTo = (String)m.get("sentTo");
if(typing != null) {
String authorId = (String)m.get("authorId");
users.userTyping(authorId, sentTo, true);
AppSocket
If a message has a type it’s probably an init message

@Override
if(type != null) {
if(l == null) {
}
l.add(session);
return;
}
} else {
AppSocket
init messages allow us to add a websocket to our cache of connections so we can push a message back into the websocket when we need to send a server notification

}
l.add(session);
return;
}
} else {
} else {
String id = (String)m.get("id");
if(id == null) {
users.sendMessage(sentTo, m);
} else {
users.sendJSONTo(sentTo, message.getPayload());
}
}
}
}
AppSocket
Otherwise we test if this is a “user typing" event in which case we send a typing message onward

}
l.add(session);
return;
}
} else {
} else {
String id = (String)m.get("id");
if(id == null) {
users.sendMessage(sentTo, m);
} else {
users.sendJSONTo(sentTo, message.getPayload());
}
}
}
}
AppSocket
Finally we send the message as JSON to the users in the group or the specific user. This invokes the code we saw in the user service class

@Override
public void handleTransportError(WebSocketSession wss,
Throwable thrwbl) throws Exception {
log.log(Level.SEVERE, "Error during transport", thrwbl);
}
@Override
public void afterConnectionClosed(WebSocketSession wss, CloseStatus cs)
throws Exception {
for(String s : clients.keySet()) {
List<WebSocketSession> wl = clients.get(s);
for(WebSocketSession w : wl) {
if(w == wss) {
wl.remove(w);
if(wl.isEmpty()) {
clients.remove(s);
}
return;
}
}
}
}
AppSocket
When a connection is closed we loop over the existing list and purge it of the dead connection

@Override
public void afterConnectionClosed(WebSocketSession wss, CloseStatus cs)
throws Exception {
for(String s : clients.keySet()) {
List<WebSocketSession> wl = clients.get(s);
for(WebSocketSession w : wl) {
if(w == wss) {
wl.remove(w);
if(wl.isEmpty()) {
clients.remove(s);
}
return;
}
}
}
}
@Override
public boolean supportsPartialMessages() {
return false;
}
}
AppSocket
For simplicity we don't support partial messages which shouldn’t be necessary for small 8kb messages. With that the class is done

Creating a Whatsapp Clone - Part XV - Transcript.pdf

Recommended

Recommended

More Related Content

Similar to Creating a Whatsapp Clone - Part XV - Transcript.pdf

Similar to Creating a Whatsapp Clone - Part XV - Transcript.pdf (20)

More from ShaiAlmog1

More from ShaiAlmog1 (20)

Recently uploaded

Recently uploaded (20)

Creating a Whatsapp Clone - Part XV - Transcript.pdf