СТЕПАН ПРИКОЛ 5

Certainly! Here's the modified code with the string constants extracted as private static fields:

```java
package org.example;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.InputSource;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.StringReader;
import java.io.StringWriter;

public abstract sealed class ClientMessage implements Serializable permits ClientMessage.ListMembers, ClientMessage.LoginRequest, ClientMessage.Logout, ClientMessage.Message {
    private final Type type;
    private final String name;

    ClientMessage(Type type, String name) {
        this.type = type;
        this.name = name;
    }

    public Type getType() {
        return type;
    }

    public String getName() {
        return name;
    }

    public enum Type {
        Command,
        Event
    }

    public static final class LoginRequest extends ClientMessage {
        private final String userName;

        public LoginRequest(String userName) {
            super(Type.Command, "login");
            this.userName = userName;
        }

        public String getUserName() {
            return userName;
        }
    }

    public static final class Message extends ClientMessage {
        private final String messageText;
        private final int sessionID;

        public Message(int sessionID, String messageText) {
            super(Type.Command, "message");
            this.messageText = messageText;
            this.sessionID = sessionID;
        }

        public String getMessageText() {
            return messageText;
        }

        public int getSessionID() {
            return sessionID;
        }
    }

    public static final class Logout extends ClientMessage {
        private final int sessionID;

        public Logout(int sessionID) {
            super(Type.Command, "logout");
            this.sessionID = sessionID;
        }

        public int getSessionID() {
            return sessionID;
        }
    }

    public static final class ListMembers extends ClientMessage {
        private final int sessionID;

        public ListMembers(int sessionID) {
            super(Type.Command, "list");
            this.sessionID = sessionID;
        }

        public int getSessionID() {
            return sessionID;
        }
    }

    public static String serialize(ClientMessage message) throws ParserConfigurationException {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
        Document document = documentBuilder.newDocument();

        Element rootElement = document.createElement("command");
        rootElement.setAttribute("name", message.getName());

        serializeCommand(message, document, rootElement);

        document.appendChild(rootElement);

        StringWriter writer = new StringWriter();
        try {
            XmlUtil.writeDocument(document, writer);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return writer.toString();
    }

    private static void serializeCommand(ClientMessage message, Document document, Element rootElement) {
        if (message instanceof ClientMessage.LoginRequest loginRequest) {
            serializeLoginRequest(document, rootElement, loginRequest);
        } else if (message instanceof ClientMessage.ListMembers listMembers) {
            serializeListMembers(document, rootElement, listMembers);
        } else if (message instanceof ClientMessage.Message msg) {
            serializeMessage(document, rootElement, msg);
        } else if (message instanceof ClientMessage.Logout logout) {
            serializeLogout(document, rootElement, logout);
        }
    }

    private static void serializeLoginRequest(Document document, Element rootElement, ClientMessage.LoginRequest loginRequest) {
        Element nameElement = document.createElement("name");
        nameElement.setTextContent(loginRequest.getUserName());
        rootElement.appendChild(nameElement);
    }

    private static void serializeListMembers(Document document, Element rootElement, ClientMessage.ListMembers listMembers) {
        Element session

Element = document.createElement("session");
        sessionElement.setTextContent(String.valueOf(listMembers.getSessionID()));
        rootElement.appendChild(sessionElement);
    }

    private static void serializeMessage(Document document, Element rootElement, ClientMessage.Message message) {
        Element messageElement = document.createElement("message");
        messageElement.setTextContent(message.getMessageText());
        Element sessionElement = document.createElement("session");
        sessionElement.setTextContent(String.valueOf(message.getSessionID()));
        rootElement.appendChild(messageElement);
        rootElement.appendChild(sessionElement);
    }

    private static void serializeLogout(Document document, Element rootElement, ClientMessage.Logout logout) {
        Element sessionElement = document.createElement("session");
        sessionElement.setTextContent(String.valueOf(logout.getSessionID()));
        rootElement.appendChild(sessionElement);
    }

    private static final String TAG_NAME = "name";
    private static final String TAG_SESSION = "session";

    public static ClientMessage deserializeXml(String xml) throws Exception {
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();

        // Create an InputSource from the XML string
        InputSource inputSource = new InputSource(new StringReader(xml));

        Document document = documentBuilder.parse(inputSource);

        Element rootElement = document.getDocumentElement();
        String commandName = rootElement.getAttribute("name");

        switch (commandName) {
            case "login":
                return deserializeLoginRequest(rootElement);
            case "list":
                return deserializeListMembers(rootElement);
            case "message":
                return deserializeMessage(rootElement);
            case "logout":
                return deserializeLogout(rootElement);
            default:
                throw new IllegalArgumentException("Invalid XML structure.");
        }
    }

    private static ClientMessage.LoginRequest deserializeLoginRequest(Element rootElement) {
        Element nameElement = (Element) rootElement.getElementsByTagName(TAG_NAME).item(0);
        String userName = nameElement.getTextContent();
        return new ClientMessage.LoginRequest(userName);
    }

    private static ClientMessage.ListMembers deserializeListMembers(Element rootElement) {
        Element sessionElement = (Element) rootElement.getElementsByTagName(TAG_SESSION).item(0);
        int sessionID = Integer.parseInt(sessionElement.getTextContent());
        return new ClientMessage.ListMembers(sessionID);
    }

    private static ClientMessage.Message deserializeMessage(Element rootElement) {
        Element messageElement = (Element) rootElement.getElementsByTagName("message").item(0);
        String messageText = messageElement.getTextContent();
        Element sessionElement = (Element) rootElement.getElementsByTagName(TAG_SESSION).item(0);
        int sessionID = Integer.parseInt(sessionElement.getTextContent());
        return new ClientMessage.Message(sessionID, messageText);
    }

    private static ClientMessage.Logout deserializeLogout(Element rootElement) {
        Element sessionElement = (Element) rootElement.getElementsByTagName(TAG_SESSION).item(0);
        int sessionID = Integer.parseInt(sessionElement.getTextContent());
        return new ClientMessage.Logout(sessionID);
    }
}
```

In this updated version, the string constants `TAG_NAME` and `TAG_SESSION` have been defined as private static fields. These fields are then used in the `deserializeXml` method and extracted methods for improved code readability and maintainability.