没有合适的资源？快使用搜索试试~ 我知道了~

首页Pro-Java-Clustering-and-Scalability.pdf

Pro-Java-Clustering-and-Scalability.pdf

Java

cluster

需积分: 9 8 下载量 109 浏览量更新于2023-05-26 收藏 3.71MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

试读

142页

My name is Jorge Acetozi, and I’m a Brazilian software engineer who has worked for many years as a Java developer. During my career, I have been interested in subjects such as these: • Linux • Distributed systems • Testing automation • Continuous integration • Continuous delivery • Cloud computing • Virtualization • Containerization • Security Why the varied interests? I just didn’t feel that coding in Java only was enough for me professionally (although doing this while following best practices is not an easy task). I wanted to understand the entire process of creating software and delivering it to a production environment. So, some years ago I started a career as a DevOps engineer. After taking these two paths, I’ve noticed there are two types of software engineer. In the first group are developers who usually don’t feel excited by infrastructure subjects and merely want to write code following best practices. However, this means they are not able to maintain a production environment since it involves much more than just writing software code. In the second group are infrastructure people who usually hate writing software code (note that writing small scripts to automate infrastructure tasks are quite different than writing software code). On the other hand, these people are able to maintain a production environment because they understand the deployment process, how to monitor the servers, how to handle security issues, and so on. The software engineer I’m trying to become sits right in the middle of these types of developers and infrastructure folks. I’d like to be an excellent programmer who follows coding best practices, but I also want to be able to put code into production and maintain it.

资源详情

资源推荐

J. Acetozi, Pro Java Clustering and Scalability, DOI 10.1007/978-1-4842-2985-9_18

CHAPTER 18

Joining the Chat Room

When you join a chat room, some JavaScript code gets executed on the client side.

function connect() {

socket = new SockJS('/ws');

stompClient = Stomp.over(socket);

stompClient.connect({ 'chatRoomId' : chatRoomId }, stompSuccess,

stompFailure);

}

function stompSuccess(frame) {

enableInputMessage();

successMessage("Your WebSocket connection was successfully

established!")

stompClient.subscribe('/chatroom/connected.users',

updateConnectedUsers);

stompClient.subscribe('/chatroom/old.messages', oldMessages);

stompClient.subscribe('/topic/' + chatRoomId + '.public.messages',

publicMessages);

stompClient.subscribe('/user/queue/' + chatRoomId + '.private.

messages', privateMessages);

stompClient.subscribe('/topic/' + chatRoomId + '.connected.users',

updateConnectedUsers);

}

function stompFailure(error) {

errorMessage("Lost connection to WebSocket! Reconnecting in

10 seconds...");

disableInputMessage();

setTimeout(connect, 10000);

}

CHAPTER 18 ■ JOINING THE CHAT ROOM

100

First, the connect function is called, and a new WebSocket connection

is started using STOMP as a subprotocol. Note that you also add the header

'chatRoomId' : chatRoomId when you send the CONNECT frame because the

server must keep this information to ensure that it’s manipulating the correct

destination names.

If the handshake succeeds, then the stompSuccess function is called, and

the user subscribes to some destinations. Actually, the first two subscriptions are

executed only once on the server side, and they are used to get some initial data,

that is, his old conversation and the current connected users to this specific chat

room. This is the Java code executed when these two subscriptions happen:

@Controller

public class ChatRoomController {

@Autowired

private ChatRoomService chatRoomService;

@Autowired

private InstantMessageService instantMessageService;

@SubscribeMapping("/connected.users")

public List<ChatRoomUser> listChatRoomConnectedUsersOnSubscribe

(SimpMessageHeaderAccessor headerAccessor) {

String chatRoomId = headerAccessor.getSessionAttributes().get

("chatRoomId").toString();

return chatRoomService.findById(chatRoomId).getConnectedUsers();

}

@SubscribeMapping("/old.messages")

public List<InstantMessage> listOldMessagesFromUserOnSubscribe

(Principal principal, SimpMessageHeaderAccessor headerAccessor) {

String chatRoomId = headerAccessor.getSessionAttributes().get

("chatRoomId").toString();

return instantMessageService.findAllInstantMessagesFor

(principal.getName(), chatRoomId);

}

...

}

CHAPTER 18 ■ JOINING THE CHAT ROOM

101

The List<ChatRoomUser> list is fetched from Redis, and the

List<InstantMessage> list is fetched from Cassandra.

The @SubscribeMapping annotation is useful when users need to fetch the

initial data using the WebSocket connection.

The last three subscriptions in the JavaScript code are the following,

respectively:

• Execute the publicMessages function when a new message

arrives at the '/topic/' + chatRoomId + '.public.

messages' destination. This function will render a public

message in the user’s message panel.

• Execute the privateMessages function when a new

message arrives at the '/user/queue/' + chatRoomId

+ '.private.messages' destination. This function will

render a private message in the user’s message panel.

• Execute the updateConnectedUsers function when a

new message arrives at the '/topic/' + chatRoomId +

'.connected.users' destination. This function will update

the connected users in the user’s connected users panel.

18.1 WebSocket Reconnection Strategy

When the WebSocket connection is lost, the stompFailure function is executed,

and it will try to reestablish the connection every ten seconds. If it succeeds, then

everything explained earlier happens again. Because every message is stored in

Cassandra (regardless of being delivered through the WebSocket connection),

even if the user was offline while someone sent a message to him, when the user

reconnects, the message will be in the List<InstantMessage> list and will be

displayed in the user’s message panel.

18.2 WebSocket Events

Once the WebSocket connection is established or disconnected, an event is

triggered on the server side, and a system message is sent to every connected user

in the chat room informing them that someone has joined or left (Figure 18-1).

CHAPTER 18 ■ JOINING THE CHAT ROOM

102

The following is the code that handles these events on the server side:

@Component

public class WebSocketEvents {

@Autowired

private ChatRoomService chatRoomService;

@EventListener

private void handleSessionConnected(SessionConnectEvent event) {

SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.

wrap(event.getMessage());

String chatRoomId = headers.getNativeHeader("chatRoomId").

get(0);

headers.getSessionAttributes().put("chatRoomId", chatRoomId);

ChatRoomUser joiningUser = new ChatRoomUser(event.getUser().

getName());

chatRoomService.join(joiningUser, chatRoomService.

findById(chatRoomId));

}

Figure 18-1. System messages from admin

CHAPTER 18 ■ JOINING THE CHAT ROOM

103

@EventListener

private void handleSessionDisconnect(SessionDisconnectEvent event) {

SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.

wrap(event.getMessage());

String chatRoomId = headers.getSessionAttributes().

get("chatRoomId").toString();

ChatRoomUser leavingUser = new ChatRoomUser(event.getUser().

getName());

chatRoomService.leave(leavingUser, chatRoomService.

findById(chatRoomId));

}

Let’s take the SessionConnected event as an example and follow the entire

flow.

The handleSessionConnected method is called when a WebSocket connection

is created. Then, the chatRoomId value is obtained from the CONNECT frame headers,

and it’s stored in the user’s WebSocket session as an attribute. This is convenient

since from now every message the client sends doesn’t need to provide the

chatRoomId value, as it’s already stored in the user’s WebSocket session. Then, the

join method is called, passing joiningUser and chatRoom as parameters.

@Service

public class RedisChatRoomService implements ChatRoomService {

@Autowired

private SimpMessagingTemplate webSocketMessagingTemplate;

@Autowired

private ChatRoomRepository chatRoomRepository;

@Autowired

private InstantMessageService instantMessageService;

@Override

public ChatRoom join(ChatRoomUser joiningUser, ChatRoom chatRoom) {

chatRoom.addUser(joiningUser);

chatRoomRepository.save(chatRoom);

sendPublicMessage(SystemMessages.welcome(chatRoom.getId(),

joiningUser.getUsername()));

updateConnectedUsersViaWebSocket(chatRoom);

return chatRoom;

}

剩余141页未读，继续阅读

pro java clusering and scalability（原版无水印)

This is a programming book but with many interesting infrastructure discussions and tips. I have coded an entire chat application using the Spring Framework, WebSocket, Cassandra, Redis, RabbitMQ, and MySQL, and I discuss how you can horizontally scale this application implementing a WebSocket multinode architecture. In my opinion, this is what makes this book different from others. My objective when writing this book was to bring you a new experience by mixing a lot of development code with interesting and didactic infrastructure discussions. I’m sure you’ll really enjoy it!

请使用一趟聚类完成下面数据的聚类过程（r=30，基于曼哈顿距离）给出详细的步骤过程。记录号是否购车婚姻状况绩效成绩 1 yes single 125 2 no married 100 3 no single 70 4 yes married 120 5 no divorced 95 6 no married 65

然后，重复以上步骤，计算每个数据点到新的聚类中心的距离，重新分配簇，并计算新的聚类中心，直到聚类中心不再发生变化或者达到预定的迭代次数。重复以上步骤，直到聚类中心不再发生变化： ``` 是否购车婚姻...

粉丝: 8
资源: 83

上传资源快速赚钱

我的内容管理收起

我的资源快来上传第一个资源

我的收益

登录查看自己的收益

我的积分登录查看自己的积分

我的C币登录后查看C币余额

我的收藏

我的下载

下载帮助

会员权益专享

Pro-Java-Clustering-and-Scalability.pdf

pro java clusering and scalability（原版无水印)

Pro Java Clustering and Scalability 无水印pdf

Apress.Pro.Java.Clustering.and.Scalability.pdf

K-Means聚类算法java实现.pdf

机器学习入门与实战(scikit-learn和Keras)课件—聚类.pdf

【进阶】Scikit-Learn：K均值聚类算法

聚类分析：K-Means和层次聚类

Scikit-learn实现数据分类与聚类的深入探究

ModEx和Seed-Detective: 两种聚类技术的性能比较及其在数据集上的表现

聚类算法：K-means聚类与分析

Scikit-learn库中的聚类算法有哪些，请全部列举

kmeans聚类算法. parameters: ----------- k: int 聚类的数目. max_iterations

能换一种方法聚类吗，出来k-means和SpectralClustering聚类方法

K-means和相关性结合聚类

如何写一个基于K-means算法的红酒聚类

请使用一趟聚类完成下面数据的聚类过程（r=30，基于曼哈顿距离）给出详细的步骤过程。 记录号 是否购车 婚姻状况 绩效成绩 1 yes single 125 2 no married 100 3 no single 70 4 yes married 120 5 no divorced 95 6 no married 65

基于bert-base-chinese做kmeans文本聚类

python kmeans聚类_k-means+python︱scikit-learn中的KMeans聚类实现( + MiniBatchKMeans)

k-means聚类分析的聚类结果会一直变吗

K-Means++文本聚类的主要步骤

会员权益专享

最新资源

请使用一趟聚类完成下面数据的聚类过程（r=30，基于曼哈顿距离）给出详细的步骤过程。记录号是否购车婚姻状况绩效成绩 1 yes single 125 2 no married 100 3 no single 70 4 yes married 120 5 no divorced 95 6 no married 65