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

Here's the refactored version of the code with maximum refactoring applied:

```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 sessionElement

 = 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 refactored version, string constants are extracted into private static variables, repeated code is extracted into separate methods, and appropriate naming conventions are applied. The code is now more readable, maintainable, and reusable.