Socket example using Java 5

Question

Last year I posted 4 programs that provided a simple client server using both stream sockets and NIO. I decided as an exercise in using Java 5 to port that code and try to use as many of the new features as possible. The following code is very long and does what all the previous example programs did. In replies do not repost the whole of this message.
It provides a simple chat like client and server. The user can request either a stream connection or a NIO connection or provide one of their own.
//========================== MsgSwitch.java ===========================//
package pkwnet.msgswitch;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.util.logging.Handler;
* main class for message switch
* command line arguments are
* -p port number for server
* -s run server
* -a server ip address including port for client
* -i idle timer in seconds
* -n use NIO
* -c specify connection class
public class MsgSwitch {
    static private int errors = 0;
    static private String address = "127.0.0.1:6060";
    static private String connectionClass = "pkwnet.msgswitch.StreamConnection";
    static public void main(String [] args) {
        int port = 6060;
        int idleTime = 600;
        boolean server = false;
        boolean nio = false;
        Logger logger = Logger.getLogger("msgswitch");
        for(String arg : args) {
            if(arg.startsWith("-a")) {
                address = arg.substring(2);
            } else if(arg.startsWith("-p")) {
                port = argToInt(arg);
                server = true;
            } else if(arg.startsWith("-i")) {
                idleTime = argToInt(arg);
            } else if (arg.startsWith("-s")) {
                server = true;
            } else if (arg.startsWith("-c")) {
                connectionClass = arg.substring(2);
            } else if (arg.startsWith("-n")) {
                connectionClass = "pkwnet.msgswitch.NIOConnection";
            } else {
                String err = "unknown argument=" + arg;
                logger.severe(err);
                System.err.println(err);
                errors++;
        if (errors == 0) {
            if (server) {
                new Server().listen(port,idleTime, nio);
            } else {
                new Client().start(address, nio);
        } else {
            fail(errors + " errors encountered", null);
    static private int argToInt(String arg) {
        int val = 0;
        try {
            val = Integer.parseInt(arg.substring(2));
        } catch (NumberFormatException e) {
            String err = "invalid argument format: " + arg;
            Logger.getLogger("msgswitch").severe(err);
            System.err.println(err);
            errors++;
        return val;
    static public void fail(String err, Throwable e) {
        String msg = "Operation terminated: " + err;
        Logger.getLogger("msgswitch").log(Level.SEVERE, msg, e);
        System.err.println(msg);
        System.exit(12);
    static public Connection getConnection() {
        Connection conn = null;
        try {
            conn = (Connection) Class.forName(connectionClass).newInstance();
        } catch (Exception e) {
            fail ("connection class error", e);
        return conn;
    static public void logCaller(Logger logger, Level level) {
        String text = "CALLED";
        if (logger.isLoggable(level)) {
            try {
                throw new Exception("logging stack");
            } catch (Exception e) {
                StackTraceElement [] st = e.getStackTrace();
                if (st.length > 1) {
                    text += formatElement(st[1]);
                if (st.length >2) {
                    text += formatElement(st[2]);
            logger.log(level, text);
    static private String formatElement(StackTraceElement ste) {
        return "\n    " + ste.getClassName() + "." + ste.getMethodName()
            + "(" + ste.getFileName() + ":" + ste.getLineNumber() + ")";
//================= Client.java =============================================//
package pkwnet.msgswitch;
* a simple Swing chat GUI using Java 5 and sockets.
* @author PKWooster
* @version 1.0 August 31,2005
import javax.swing.JFrame;
import javax.swing.JTextField;
import javax.swing.JTextArea;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JMenu;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JDialog;
import javax.swing.SwingUtilities;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.BorderLayout;
import static java.awt.BorderLayout.*;
client GUI class
public class Client extends JFrame implements ConnectionListener {
     // swing GUI components
     private JTextField userText = new JTextField(40);
     private JTextArea sessionLog = new JTextArea(24,40);
     private JTextField statusText = new JTextField(40);
     private JPanel outPanel = new JPanel();
     private JScrollPane sessionLogScroll = new JScrollPane(sessionLog);
     private JMenuBar menuBar = new JMenuBar();
     private JMenuItem startItem = new JMenuItem("Start");
     private JMenuItem hostItem = new JMenuItem("Host");
     private JMenuItem aboutItem = new JMenuItem("About");
     private JMenuItem abortItem = new JMenuItem("Abort");
     private JMenuItem exitItem = new JMenuItem("Exit");
     private JMenu fileMenu = new JMenu("File");
     private JMenu helpMenu = new JMenu("Help");
     private Container cp;
     private String address;
    private Connection connection;
    private boolean sendReady = false;
    private boolean nio = false;
     Client() {
    public void start(String address, boolean nio) {
        this.address = address;
        this.nio = nio;
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                runClient();
    private void runClient() {   
        connection = MsgSwitch.getConnection();
        connection.addConnectionListener(this);
          buildMenu();
          cp = getContentPane();
          sessionLog.setEditable(false);
          outPanel.add(new JLabel("Send: "));
          outPanel.add(userText);
          // enter on userText causes transmit
          userText.addActionListener(new ActionListener(){
               public void actionPerformed(ActionEvent evt){userTyped(evt);}
          cp.setLayout(new BorderLayout());
          cp.add(outPanel,NORTH);
          cp.add(sessionLogScroll,CENTER);
          cp.add(statusText,SOUTH);
          setStatus("Closed");
          addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent evt) {
                mnuExit();
          pack();
        setVisible(true);
* attempt to send the contents of the user text field
    private void userTyped(ActionEvent evt) {
        if (sendReady) {
            String txt = evt.getActionCommand()+"\n";
            userText.setText("");
            toSessionLog("> ", txt);
            sendReady = false;
            connection.send(txt);
* append text to the session log
     private void toSessionLog(String prefix, String txt) {
          sessionLog.append(prefix + txt);
          sessionLog.setCaretPosition(sessionLog.getDocument().getLength() ); // force last line visible
* build the standard menu bar
     private void buildMenu()
          JMenuItem item;
          // file menu
          startItem.addActionListener(new ActionListener()
          {public void actionPerformed(ActionEvent e){mnuStart();}});
          fileMenu.add(startItem);
          hostItem.addActionListener(new ActionListener()
          {public void actionPerformed(ActionEvent e){mnuHost();}});
          fileMenu.add(hostItem);
          exitItem.addActionListener(new ActionListener()
          {public void actionPerformed(ActionEvent e){mnuExit();}});
          fileMenu.add(exitItem);
          menuBar.add(fileMenu);
          helpMenu.add(aboutItem);
          aboutItem.addActionListener(new ActionListener()
          {public void actionPerformed(ActionEvent e){mnuAbout();}});
          menuBar.add(helpMenu);
          setJMenuBar(menuBar);
* start and stop communications from start menu
     private void mnuStart() {
        if(connection.getState() ==  Connection.State.CLOSED) {
            connection.connect(address);
        } else {
            connection.disconnect();
*  prompt user for host in form address:port
    private void mnuHost() {
          String txt = JOptionPane.showInputDialog("Enter host address:port", connection.getAddress());
          if (txt == null)return;
        address = txt;
     private void mnuAbout() {
          JDialog dialog = new JDialog(this, "About Client");
          JTextField text = new JTextField("Simple character client");
        dialog.getContentPane().add(text);
        dialog.pack();
        dialog.setVisible(true);
     // exit menu
     private void mnuExit() {
        exit();
    private void exit() {
          connection.disconnect();
          System.exit(0);
     private void setStatus(String st) {
        statusText.setText(st);
     private void setStatus(Connection.State state) {
        switch(state) {
            case OPENED:
                startItem.setText("Stop");
                setStatus("Connected to "+address);
                break;
            case CLOSED:
                startItem.setText("Start");
                setStatus("Disconnected");
                break;
            case OPENING:
                setStatus("Connecting to "+address);
                startItem.setText("Abort");
                break;
            case CLOSING:
                setStatus("Disconnecting from "+address);
                startItem.setText("Abort");
                break;
    public void stateChanged(final ConnectionEvent event) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                setStatus(event.getState());
    public void dataAvailable(final ConnectionEvent event) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                setStatus(event.getState());
                String txt = event.getData();
                if (txt == null) {
                    txt = "$null$";
                toSessionLog("< ", txt + "\n");   
    public void sendAllowed(final ConnectionEvent event) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                setStatus(event.getState());
                sendReady = true;
    public void accept(ConnectionEvent event) {
//========================== Server.java ===============================//
package pkwnet.msgswitch;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
* a simple message switch using stream based socket i/o
* a very simple text message switching program
* user commands start with $ and consist of blank seperated arguments
* other lines sent by the user are forwarded
* $on nickname targets
*    sign on as nickname, sending to targets
* $to targets
*    change target list, reports current value
* $list nicknames
*    list status of specified nicknames
* $list
*    list all connected users
* $off
*    sign off
* @author PKWooster
* @version 1.0 September 1, 2005
public class Server {
    private ConcurrentHashMap<String, User> perUser = new ConcurrentHashMap<String,User>();
    private Timer idleTimer;
    private Connection conn;
    public void listen(int port, final int idleTime, boolean nio) {
        idleTimer = new Timer();
        idleTimer.scheduleAtFixedRate(new TimerTask(){public void run(){oneSec();}},0,1000);
        conn = MsgSwitch.getConnection();
        conn.addConnectionListener(new ConnectionListener() {
            public void stateChanged(ConnectionEvent event) {
            public void dataAvailable(ConnectionEvent event) {
            public void sendAllowed(ConnectionEvent event) {
            public void accept(ConnectionEvent event) {
                Connection uconn = event.getConnection();
                new User(uconn, perUser, idleTime);
        conn.listen(port);
        idleTimer.cancel();
    private void oneSec() {
        Collection<User> uc = perUser.values();
        for(User u : uc) {
            u.oneSec();
//================= User.java  ==============================================//
package pkwnet.msgswitch;
import java.io.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;
import java.util.logging.Level;
* defines the processing for a message switch user
* @author PKWooster
* @version 1.0 June 15,2004
public class User implements ConnectionListener {
    private ConcurrentHashMap<String, User> perUser;
    private String name;
    private String address;
    private boolean signedOn = false;
    private String[] targets;
    private AtomicInteger remainingTime;
    private int idleTime;
    Connection conn;
    Logger logger;
  * construct a user, link it to its connection and put it in the perUser table
    User(Connection conn, ConcurrentHashMap<String,User>p, int idle) {
        this.conn = conn;
        logger = Logger.getLogger("msgswitch.user");
        conn.addConnectionListener(this);
        address = conn.getAddress();
        logger.info("creating user " + address);
        perUser = p;
        idleTime = idle;
        remainingTime = new AtomicInteger(idleTime);
        rename(address);
        targets = new String[0];
* process state changes
    public void stateChanged(ConnectionEvent event) {
        if(event.getState() == Connection.State.CLOSED) {
            close(false);
* data is available, process commands and forward other data.
    public void dataAvailable(ConnectionEvent event) {
        String msg = event.getData();
        if (msg.startsWith("$")) {
            doCommand(msg);
        } else {
            forward(msg);
        remainingTime.set(idleTime);
* do nothing for sendAllowed events
    public void sendAllowed(ConnectionEvent event) {
* do nothing for accept events
    public void accept(ConnectionEvent event) {
* called once per second by the server main thread.
    public void oneSec() {
        if(idleTime != 0 && 1 > remainingTime.decrementAndGet()) {
            close(true);
* send a message
    private void send(String msg) {
        conn.send(msg);
        remainingTime.set(idleTime);
* forward data messages to other users
* @param txt the message to send
    private void forward(String txt) {
        txt = name+": "+txt + "\n";
        if(0 < targets.length) {
            for(String target :targets) {
                User user = perUser.get(target);
                if(user != null) {
                    user.send(txt);
        } else {
            for (User user : perUser.values()) {
                if (user != this) {
                    user.send(txt);
* execute command messages, commands start with a $
* and contain arguments delimited by white space.
* @param command the command string
    private void doCommand(String command) {
        boolean good = false;
        command = command.substring(1).trim();
        if(command.length() > 0) {
            String [] args = command.split("\\s+");
            if(args[0].equals("on")) {
                good = signOn(args);
            } else if(args[0].equals("off")) {
                good = signOff(args);
            } else if(args[0].equals("list")) {
                good = listUsers(args);
            } else if(args[0].equals("to")) {
                good = setTargets(args,1);
            } else if(args[0].equals("idle")) {
                good = setIdle(args);
            if(!good) {
                send("invalid command=" + command + "\n");
* sign on command
    private boolean signOn(String [] args) {
        boolean good = false;
        if(args.length >1) {
            String nm = args[1];
            logger.info("signing on as: " + nm);
            if(rename(nm)) {
                conn.setName(name);
                send("Signed on as " + name + "\n");
                signedOn = true;
                good = true;
                setTargets(args,2);
            } else {
                send("name="+nm+" already signed on\n");
        return good;
* set forwarding targets
    private boolean setTargets(String [] args, int start) {
        if(start < args.length) {
            targets = new String[args.length-start];
            System.arraycopy(args, start, targets, 0, targets.length);
        String str = "to=";
        for(String target : targets) {
            str += (target + " ");
        send(str+"\n");
        return true;
* set idle timeout
    private boolean setIdle(String[] args) {
        try {
            idleTime = new Integer(args[1]).intValue();
            remainingTime.set(idleTime);
            send("idle time set to "+idleTime+"\r\n");
            return true;
        } catch(NumberFormatException exc) {
            return false;
* sign off
    private boolean signOff(String [] args) {
        close(true);
        return true;
* list connected users
    private boolean listUsers(String [] args) {
        TreeSet<String> allUsers = new TreeSet<String>(perUser.keySet());
        HashSet<String> t = new HashSet<String>(Arrays.asList(targets));
        LinkedList<String> users;
        String response = "On,Target,Nickname\n";
        if(args.length < 2) {
            users = new LinkedList<String>(allUsers);
        } else {
            users = new LinkedList<String>();
            for (int i = 1; i < args.length; i++) {
                users.add(args);
for(String username : users) {
if(username.equals(name)) {
response += "*,";
} else {
response += (allUsers.contains(username) ? "y," : "n,");
response += (t.contains(username) ? "y," : "n,");
response += (username + "\n");
send(response);
return true;
* rename this user, first we attempt to add the new name then we remove
* the old one. Both names will be registered for a short while.
* @param newname the new name for this user
* @return true if the rename was successful
private boolean rename(String newname) {
boolean b = false;
logger.info("rename name="+name+" newname="+newname);
if (name != null && name.equals(newname)) {
b = true;
} else if (null == perUser.putIfAbsent(newname, this)) {
if (name != null) {
perUser.remove(name);
name = newname;
b = true;
return b;
* delete from perUser and close our connection
private void close(boolean disconnect) {
logger.info("closing user "+name);
perUser.remove(name);
if (disconnect) {
conn.disconnect();
//====================== Connection.java ===============================//
package pkwnet.msgswitch;
import java.util.HashSet;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Logger;
import java.util.logging.Level;
public abstract class Connection {
public enum State {CLOSED, OPENING, OPENED, CLOSING}
private HashSet<ConnectionListener> listeners = new HashSet<ConnectionListener>();
private State state = State.CLOSED;
private String host = "127.0.0.1";
private int port = 6060;
private String name = "unconnected";
public Connection() {
public abstract void listen(int port);
public abstract void connect(String address);
public abstract void disconnect();
public abstract void send(String message);
public void addConnectionListener(ConnectionListener listener) {
listeners.add(listener);
public void removeConnectionListener(ConnectionListener listener) {
listeners.remove(listener);
protected void fireDataAvailable(String data) {
for (ConnectionListener listener : listeners) {
listener.dataAvailable(new ConnectionEvent(this, state, data));
private void fireStateChanged() {
for (ConnectionListener listener : listeners) {
listener.stateChanged(new ConnectionEvent(this, state));
protected void fireSendAllowed() {
for (ConnectionListener listener : listeners) {
listener.sendAllowed(new ConnectionEvent(this, state));
protected void fireAccept(Connection conn) {
for (ConnectionListener listener : listeners) {
listener.accept(new ConnectionEvent(this, conn));
protected void setState(State state) {
if (this.state != state) {
this.state = state;
fireStateChanged();
public State getState() {
return state;
protected void setAddress(String address) {
          int n = address.indexOf(':');
          String pt = null;
setName(address);
if(n == 0) {
               host = "127.0.0.1";
               pt = address.substring(1);
          else if(n < 0) {
               host = address;
               port = 5050;
          } else {
host = address.substring(0,n);
               pt = address.substring(n+1);
if (pt != null) {
try {
port = Integer.parseInt(pt);
} catch (NumberFormatException e) {
port = -1;
public String getName() {
return name;
public void setName(String value) {
name = value;
public String getAddress() {
return host + ":" + port;
public String getHost() {
return host;
public void setPort(int value) {
port = value;
public int getPort() {
return port;
//=================== ConnectionEvent.java ================================//
package pkwnet.msgswitch;
public class ConnectionEvent extends java.util.EventObject {
private final String data;
private final Connection.State state;
private final Connection conn;
public ConnectionEvent(Object source, Connection.State state, String data, Connection conn) {
super(source);
this.state = state;
this.data = data;
this.conn = conn;
public ConnectionEvent(Object source, Connection.State state, String data) {
this(source, state, data, null);
public ConnectionEvent(Object source, Connection.State state) {
this(source, state, null, null);
public ConnectionEvent(Object source, Connection conn) {
this(source, conn.getState(), null, conn);
public Connection.State getState() {
return state;
public String getData() {
return data;
public Connection getConnection() {
return conn;
//============================ ConnectionListener.java ===================//
package pkwnet.msgswitch;
public interface ConnectionListener extends java.util.EventListener {
public void stateChanged(ConnectionEvent event);
public void dataAvailable(ConnectionEvent event);
public void sendAllowed(ConnectionEvent event);
public void accept(ConnectionEvent event);
//============================ StreamConnection.java ===================//
package pkwnet.msgswitch;
import java.net.Socket;
import java.net.ServerSocket;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Logger;
import java.util.logging.Level;
* provides stream socket i/o of character strings
* @author PKWooster
* @version 1.0 September 1, 2005
public class StreamConnection extends Connection {
private Socket sock;
private BufferedReader in;
private BufferedWriter out;
private Thread recvThread = null;
private Thread sendThread = null;
protected LinkedBlockingQueue<String> sendQ;
Logger logger;
public StreamConnection() {
super();
logger = Logger.getLogger("msgswitch.stream");
sendQ = new LinkedBlockingQueue<String>();
* open a socket and start i/o threads
public void connect(String ipAddress) {
setAddress(ipAddress);
try {
sock = new Socket(getHost(), getPort());
connect(sock);
} catch (IOException e) {
logger.log(Level.SEVERE, "Connection failed to=" + ipAddress, e);
private void connect(Socket sock) {
this.sock = sock;
String ipAddress = getAddress();
try {
in = new BufferedReader(new InputStreamReader(sock.getInputStream()));
out = new BufferedWriter(new OutputStreamWriter(sock.getOutputStream()));
recvThread = new Thread(new Runnable() {
public void run() {
doRecv();
},"Recv." + getName());
sendThread = new Thread(new Runnable() {
public void run() {
doSend();
},"Send."+getName());
sendThread.start();
recvThread.start();
setState(State.OPENED);
} catch(IOException e) {
logger.log(Level.SEVERE, "Connection failed to="+ipAddress, e);
public void listen(int port) {       
StreamConnection sconn;
setPort(port);
try {
ServerSocket ss = new ServerSocket(port);
while(true) {
Socket us = ss.accept();
sconn = new StreamConnection();
String ipAddress = us.getInetAddress() + ":" + us.getPort();
sconn.setAddress(ipAddress);
sconn.connect(us);
fireAccept(sconn);
} catch(Exception e) {
logger.log(Level.SEVERE, "listen failed", e);
* close the socket connection
public void disconnect() {
logger.fine("disconnect sock=" + sock + " state="+ getState());
if(getState() == State.OPENED) {
setState(State.CLOSING);
try {
sock.shutdownOutput();
} catch(IOException ie) {
logger.log(Level.SEVERE, "showdown failed", ie);
} else if(getState() != State.CLOSED) {
try {
sock.close();
} catch(Exception e) {
logger.log(Level.SEVERE, "close failed", e);
if (sendThread.isAlive()) {
sendThread.interrupt();
sendQ.clear();
setState(State.CLOSED);
public void send(String message) {
if (getState() == State.OPENED) {
try {
sendQ.put(message);
} catch(InterruptedException e) {
logger.log(Level.SEVERE, "sendQ put interrupted", e);
setState(State.CLOSING);
disconnect();
* sets the public name of this connection
public void setName(String name) {
super.setName(name);
if (sendThread != null) {
try {
recvThread.setName("recv." + name);
sendThread.setName("send." + name);
} catch(Exception e) {
logger.log(Level.SEVERE, "nameing threads failed", e);
* the main loop for the send thread
private void doSend() {
String msg;
boolean running = true;
while (running) {
if (sendQ.size() == 0) {
fireSendAllowed();
try {
msg = sendQ.take();
out.write(msg);
out.flush();
} catch(Exception e) {
if (getState() == State.OPENED) {
logger.log(Level.SEVERE, "write failed", e);
setState(State.CLOSING);
disconnect();
running = false;
* the main loop for the receive thread
private void doRecv() {
String inbuf;
while (getState() == State.OPENED) {
try {
inbuf = in.readLine();
} catch(Exception e) {
if (getState() == State.OPENED) {
logger.log(Level.SEVERE, "readline failed", e);
inbuf = null;
if(inbuf == null) {
logger.fine("null received on: " + getAdd

Answer 1

Here are three of them:
NIO server
NIO client
Multithreaded server
The stream based client example seems to have been deleted, probably lost in the troll wars. I also posted a new Simple multithreaded server that uses the same protocol. As the client is missing, I'll repost it.