To serialize and deserialize the `ClientMessage` class using DOM parser, you can use the following implementation:

```java
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

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

public class ClientMessageSerializer {

    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());

        switch (message.getType()) {
            case Command -> serializeCommandMessage(document, rootElement, message);
            case Event -> serializeEventMessage(document, rootElement, message);
        }

        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 serializeCommandMessage(Document document, Element rootElement, ClientMessage message) {
        if (message instanceof ClientMessage.LoginRequest) {
            ClientMessage.LoginRequest loginRequest = (ClientMessage.LoginRequest) message;
            Element nameElement = document.createElement("name");
            nameElement.setTextContent(loginRequest.getUserName());
            rootElement.appendChild(nameElement);
        } else if (message instanceof ClientMessage.Message) {
            ClientMessage.Message messageCommand = (ClientMessage.Message) message;
            Element messageElement = document.createElement("message");
            messageElement.setTextContent(messageCommand.getMessageText());
            Element sessionElement = document.createElement("session");
            sessionElement.setTextContent(String.valueOf(messageCommand.getSessionID()));
            rootElement.appendChild(messageElement);
            rootElement.appendChild(sessionElement);
        } else if (message instanceof ClientMessage.Logout) {
            ClientMessage.Logout logoutCommand = (ClientMessage.Logout) message;
            Element sessionElement = document.createElement("session");
            sessionElement.setTextContent(String.valueOf(logoutCommand.getSessionID()));
            rootElement.appendChild(sessionElement);
        } else if (message instanceof ClientMessage.ListMembers) {
            ClientMessage.ListMembers listMembersCommand = (ClientMessage.ListMembers) message;
            Element sessionElement = document.createElement("session");
            sessionElement.setTextContent(String.valueOf(listMembersCommand.getSessionID()));
            rootElement.appendChild(sessionElement);
        }
    }

    private static void serializeEventMessage(Document document, Element rootElement, ClientMessage message) {
        // Not implemented in the example
    }

    public static ClientMessage deserialize(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" -> {
                String userName = getElementTextContent(rootElement, "name");
                return new ClientMessage.LoginRequest(userName);
            }
            case "message" -> {
                String messageText = getElementTextContent(rootElement, "message");
                int sessionID = Integer.parseInt(getElementTextContent(rootElement, "session"));
                return new ClientMessage.Message(sessionID, messageText);
            }
            case "logout" -> {
                int sessionID = Integer.parseInt(getElementTextContent(rootElement, "session"));
                return new ClientMessage.Logout(sessionID);
            }
            case "list" -> {
                int sessionID = Integer.parseInt(get

ElementTextContent(rootElement, "session"));
                return new ClientMessage.ListMembers(sessionID);
            }
        }

        throw new IllegalArgumentException("Invalid XML structure.");
    }

    private static String getElementTextContent(Element element, String tagName) {
        NodeList nodeList = element.getElementsByTagName(tagName);
        if (nodeList.getLength() > 0) {
            return nodeList.item(0).getTextContent();
        }
        return null;
    }

    public static void main(String[] args) throws Exception {
        // Example serialization
        ClientMessage.LoginRequest loginRequest = new ClientMessage.LoginRequest("USER_NAME");
        String loginXml = serialize(loginRequest);
        System.out.println("Login Request XML: " + loginXml);

        ClientMessage.ListMembers listMembers = new ClientMessage.ListMembers(123456);
        String listXml = serialize(listMembers);
        System.out.println("List Members XML: " + listXml);

        ClientMessage.Message message = new ClientMessage.Message(123456, "Hello!");
        String messageXml = serialize(message);
        System.out.println("Message XML: " + messageXml);

        ClientMessage.Logout logout = new ClientMessage.Logout(123456);
        String logoutXml = serialize(logout);
        System.out.println("Logout XML: " + logoutXml);

        // Example deserialization
        ClientMessage deserializedMessage = deserialize(loginXml);
        System.out.println("Deserialized Login Request: " + deserializedMessage);

        deserializedMessage = deserialize(listXml);
        System.out.println("Deserialized List Members: " + deserializedMessage);

        deserializedMessage = deserialize(messageXml);
        System.out.println("Deserialized Message: " + deserializedMessage);

        deserializedMessage = deserialize(logoutXml);
        System.out.println("Deserialized Logout: " + deserializedMessage);
    }
}
```

This code provides serialization and deserialization methods for the `ClientMessage` class using DOM parser. The `serialize` method serializes a `ClientMessage` object into XML, and the `deserialize` method parses an XML string and returns the corresponding `ClientMessage` object. The `main` method includes example usage of serialization and deserialization for different types of `ClientMessage` instances.