Include: Modularity using design patterns, Fault tolerance and Component based development in the below java program.

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.lang.reflect.Member;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.ArrayList;

import java.util.List;

import java.util.HashMap;

import java.util.Map;

import java.util.UUID;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import MemberDetails.Observer;

import MemberDetails.Subject;

public class MemberServer {

private JFrame frame;

private JTextField idField;

private JTextField ipField;

private JTextField portField;

private JLabel statusLabel;

private static ServerSocket serverSocket;

private boolean isRunning;

private List members = new ArrayList<>();

public interface ServerInterface {

void startServer();

}

// Frame 1

public MemberServer() {

frame = new JFrame("Member Server");

frame.setLayout(new BorderLayout());

JPanel panel = new JPanel();

panel.setLayout(null);

JLabel idLabel = new JLabel("ID:");

idLabel.setBounds(10, 10, 100, 25);

panel.add(idLabel);

idField = new JTextField();

idField.setBounds(120, 10, 165, 25);

panel.add(idField);

JLabel ipLabel = new JLabel("IP Address:");

ipLabel.setBounds(10, 40, 100, 25);

panel.add(ipLabel);

ipField = new JTextField();

ipField.setBounds(120, 40, 165, 25);

panel.add(ipField);

JLabel portLabel = new JLabel("Port:");

portLabel.setBounds(10, 70, 100, 25);

panel.add(portLabel);

portField = new JTextField();

portField.setBounds(120, 70, 165, 25);

panel.add(portField);

// Start Server Button

JButton startButton = new JButton("Start Server");

startButton.setBounds(50, 110, 125, 25);

startButton.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

Frame2 frame = new Frame2();

frame.setVisible(true);

frame.setSize(500, 200);

frame.setResizable(false);

startServer();

}

});

panel.add(startButton);

// Quit Button

JButton quitButton = new JButton("Quit");

quitButton.setBounds(200, 110, 125, 25);

;

quitButton.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

System.exit(0);

}

});

panel.add(quitButton);

statusLabel = new JLabel();

statusLabel.setBounds(10, 140, 275, 25);

panel.add(statusLabel);

frame.add(panel, BorderLayout.CENTER);

frame.pack();

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setVisible(true);

frame.setSize(500, 200);

frame.setResizable(false);

}

// Frame 2

public class Frame2 extends JFrame {

public Frame2() {

setTitle("Member Server P2");

setSize(500, 200);

setLocationRelativeTo(null);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

}

// Start Server

private void startServer() {

String id = idField.getText();

String ip = ipField.getText();

int port = Integer.parseInt(portField.getText());

if (id.isEmpty() || ip.isEmpty() || port <= 0) {

statusLabel.setText("Please enter a valid ID, IP address, and port.");

return;

}

String uniqueId = UUID.randomUUID().toString();

statusLabel.setText("Server started with ID: " + uniqueId);

isRunning = true;

new Thread(new Runnable() {

@Override

public void run() {

try {

ServerSocket serverSocket = new ServerSocket(port);

while (isRunning) {

Socket socket = serverSocket.accept();

// process incoming connection from member

BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

String id = in.readLine();

String ip = socket.getInetAddress().getHostAddress();

int port = socket.getPort();

// add member to server

Member member = new Member(id, ip, port);

members.add(member);

System.out.println("Member " + id + "has joined the server");

}

} catch (IOException e) {

statusLabel.setText("Error starting server: " + e.getMessage());

}

}

}).start();

}

public interface Subject {

void registerObserver(Observer observer);

void removeObserver(Observer observer);

void notifyObservers();

}

public class Server implements Subject {

private List members = new ArrayList<>();

private List observers = new ArrayList<>();

private Member coordinator;

@Override

public void registerObserver(Observer observer) {

observers.add(observer);

}

@Override

public void removeObserver(Observer observer) {

observers.remove(observer);

}

@Override

public void notifyObservers() {

for (Observer observer : observers) {

observer.notifyUpdate();

}

}

public void addMember(Member member) {

if (members.isEmpty()) {

coordinator = member;

coordinator.informCoordinator();

} else {

member.receiveMembers(getMemberDetails());

broadcastMessage(member.getName() + " has joined the group.");

}

members.add(member);

notifyObservers();

}

public void removeMember(Member member) {

members.remove(member);

if (member.equals(coordinator)) {

coordinator = null;

electNewCoordinator();

notifyObservers();

}

broadcastMessage(member.getName() + " has left the group.");

}

private void electNewCoordinator() {

if (members.size() > 0) {

coordinator = members.get(0);

broadcastMessage(coordinator.getName() + " is now the new coordinator.");

coordinator.informCoordinator();

}

}

public List getMembers() {

return members;

}

private Map getMemberDetails() {

Map memberDetails = new HashMap<>();

for (Member member : members) {

memberDetails.put(member.getName(), new MemberDetails(member.getIpAddress(), member.getPort()));

}

return memberDetails;

}

}

public void broadcastMessage(String message) {

for (Member member : members) {

member.receiveBroadcastMessage(message);

}

}

public void sendPrivateMessage(Member sender, String recipientName, String message) {

for (Member member : members) {

if (member.getName().equals(recipientName)) {

member.receivePrivateMessage(sender.getName(), message);

return;

}

}

}

public void handleUnresponsiveMember(Member member) {

members.remove(member);

broadcastMessage(member.getName() + " is unresponsive.");

}

}

public interface Observer {

void notifyUpdate();

}

// Setters and getters

public class Member implements Observer {

private String name;

private String ipAddress;

private int port;

private Server server;

public Member(String name, String ipAddress, int port) {

this.name = name;

this.ipAddress = ipAddress;

this.port = port;

}

@Override

public void notifyUpdate() {

System.out.println("The server has been updated.");

}

public void joinGroup(Server server) {

server.addMember(this);

}

public void leaveGroup(Server server) {

server.removeMember(this);

}

public void receiveMembers(Map memberDetails) {

members.clear();

members.addAll(memberDetails.values());

}

public void informCoordinator() {

System.out.println("I am the new coordinator.");

}

public void receiveBroadcastMessage(String message) {

System.out.println("[" + name + "] " + message);

}

public void receivePrivateMessage(String senderName, String message) {

System.out.println("[Private message from " + senderName + " to " + name + "] " + message);

}

public String getName() {

return name;

}

public String getIpAddress() {

return ipAddress;

}

public int getPort() {

return port;

}

}

class MemberDetails {

private String ipAddress;

private int port;

public MemberDetails(String ipAddress, int port) {

this.ipAddress = ipAddress;

this.port = port;

}

public String getIpAddress() {

return ipAddress;

}

public int getPort() {

return port;

}

public static void main(String[] args) {

new MemberServer();

}

}