19.2 TCP程序设计基础

1、InetAddress类
　　java.net包中的inetAddress类是与IP地址相关的类，利用该类可以获取IP地址、主机地址等信息。
InetAddress类的常用方法如下：

方法	返回值	说明
getByName(String host)	InetAddress	获取与Host相对应的InetAddress对象
getHostAddress()	String	获取InetAddress对象所包含的IP地址
getHostName()	String	获取此IP地址的主机名
getLocalHost()	InetAddress	返回本地主机的InetAddress对象

　　注意：InetAddress类的方法会抛出UnknownHostException异常，所以必须进行异常处理。这个异常在主机不存在或网络连接错误时发生。

2、ServerSocket类

　　java.net包中的ServerSocket类用于表示服务器套接字，其主要功能是等待来自网络上的“请求”，它可通过制定的端口来等待连接的套接字。服务器套接字依次可以与一个套接字连接。如果多台客户机同时提出连接请求，服务器套接字会将请求连接的客户机存入队列中，然后从中取出一个套接字，与服务器新建的套接字连接起来。若请求连接数大于最大容纳数，则多出的连接请求被拒绝。队列的默认大小是50.
　　ServerSocket类的构造方法都抛出IOException异常，分别有以下几种形式：
　　　　ServerSocket():创建非绑定服务器套接字
　　　　ServerSocket(int port):创建绑定到特定端口的服务器套接字
　　　　ServerSocket(int port, int backlog):利用指定的backlog创建服务器套接字并将其绑定到指定的本地端口号
　　　　ServerSocket(int prot, int backlog, InetAddress bindAddress):使用指定的端口、侦听backlog和要绑定到的本地IP地址创建服务器。这种情况适用于极端及上有多块网卡和多个IP地址的情况，用于可以明确规定ServerSocket在哪块网卡或IP地址上等待客户的连接请求。
ServerSocket类的常用方法如下：

方法	返回值	说  明
accept()	Socket	等待客户机的连接。若连接，则创建一套接字
isBound()	boolean	判断ServerSocket的绑定状态
getInetAddress()	InetAddress	返回此服务器套接字的本地地址
isClosed()	boolean	返回服务器套接字的关闭状态
close()	void	关闭服务器套接字
bind(SocketAddress endpoint)	void	将ServerSocket绑定到特定地址（IP地址和端口号）
getInetAddress()	int	返回服务器套接字等待的端口号

　　调用ServerSocket类的accept()方法会返回一个和客户端Socket对象向连接的Socket对象，服务器的Socket对象使用getOutputStream()方法获得的输出流将指向客户端Socket对象使用getInputStream()方法获得的那个输入流；同样，服务器端的Socket对象使用getInputStream()方法获得的输入流将指向客户端Socket对象使用getOutputStream()方法获得的那个输出流。也就是说，当服务器向输出流协议信息时，客户端通过相应的输入流就能读取，反之亦然。
　　注意：（1）、accept()方法会阻塞线程的继续执行，知道接收到客户的呼叫。如果没有客户呼叫服务器，那么System.out.print(“连接中”)语句将不会执行。语句如果没有客户请求，accept()方法没有发生阻塞，肯定是程序出现了问题。通常是使用了一个还在被其它程序占用的端口号，ServerSoket绑定没有成功。
　　           （2）、当一台机器上安装了多个网络应用程序时，很可能指定的端口号已被占用。还可能遇到以前运行良好的网络程序突然运行不了的情况，这种情况很可能也是由于端口被别的程序韩勇了。此时可以运行netstat -an来查看该程序锁使用的端口号是否被占用。

3、相关参考例子

package com.lzw;

import java.io.*;
import java.net.*;

public class MyTcp { // 创建类MyTcp
    private BufferedReader reader; // 创建BufferedReader对象
    private ServerSocket server; // 创建ServerSocket对象
    private Socket socket; // 创建Socket对象socket
    
    void getserver() {
        try {
            server = new ServerSocket(8998); // 实例化Socket对象
            System.out.println("服务器套接字已经创建成功"); // 输出信息
            while (true) { // 如果套接字是连接状态
                System.out.println("等待客户机的连接"); // 输出信息
                socket = server.accept(); // 实例化Socket对象
                reader = new BufferedReader(new InputStreamReader(socket
                        .getInputStream())); // 实例化BufferedReader对象
                getClientMessage(); // 调用getClientMessage()方法
            }
        } catch (Exception e) {
            e.printStackTrace(); // 输出异常信息
        }
    }
    
    private void getClientMessage() {
        try {
            while (true) { // 如果套接字是连接状态
                if (reader.ready()) {
                    // 获得客户端信息
                    System.out.println("客户机:" + reader.readLine());
                }
            }
        } catch (Exception e) {
            e.printStackTrace(); // 输出异常信息
        }
        try {
            if (reader != null) {
                reader.close(); // 关闭流
            }
            if (socket != null) {
                socket.close(); // 关闭套接字
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) { // 主方法
        MyTcp tcp = new MyTcp(); // 创建本类对象
        tcp.getserver(); // 调用方法
    }
}

package com.lzw;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;

import javax.swing.*;
import javax.swing.border.*;

public class MyClien extends JFrame { // 创建类继承JFrame类
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private PrintWriter writer; // 声明PrintWriter类对象
    Socket socket; // 声明Socket对象
    private JTextArea ta = new JTextArea(); // 创建JtextArea对象
    private JTextField tf = new JTextField(); // 创建JtextField对象
    Container cc; // 声明Container对象
    
    public MyClien(String title) { // 构造方法
        super(title); // 调用父类的构造方法
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        cc = this.getContentPane(); // 实例化对象

        final JScrollPane scrollPane = new JScrollPane();
        scrollPane.setBorder(new BevelBorder(BevelBorder.RAISED));
        getContentPane().add(scrollPane, BorderLayout.CENTER);
        scrollPane.setViewportView(ta);
        cc.add(tf, "South"); // 将文本框放在窗体的下部
        tf.addActionListener(new ActionListener() {
            // 绑定事件
            public void actionPerformed(ActionEvent e) {
                // 将文本框中信息写入流
                writer.println(tf.getText());
                // 将文本框中信息显示在文本域中
                ta.append(tf.getText() + '
');
                ta.setSelectionEnd(ta.getText().length());
                tf.setText(""); // 将文本框清空
            }
        });
    }
    
    private void connect() { // 连接套接字方法
        ta.append("尝试连接
"); // 文本域中提示信息
        try { // 捕捉异常
            socket = new Socket("127.0.0.1", 8998); // 实例化Socket对象
            writer = new PrintWriter(socket.getOutputStream(), true);
            ta.append("完成连接
"); // 文本域中提示信息
        } catch (Exception e) {
            e.printStackTrace(); // 输出异常信息
        }
    }
    
    public static void main(String[] args) { // 主方法
        MyClien clien = new MyClien("向服务器送数据"); // 创建本例对象
        clien.setSize(200, 200); // 设置窗体大小
        clien.setVisible(true); // 将窗体显示
        clien.connect(); // 调用连接方法
    }
}

package com.lzw;

import java.net.*;

public class MyHost {
    public static void main(String args[]) {
        InetAddress ip = null;
        
        try {
            ip = InetAddress.getByName("localhost");// 修改为指定的主机名称
            System.out.println("主机名：" + ip.getHostName());
            System.out.println("主机IP地址：" + ip.getHostAddress());
            System.out.println("本机IP地址："
                    + InetAddress.getLocalHost().getHostAddress());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        
    }
}

package com.lzw;

import java.io.*;
import java.net.*;

/**
 * @author Administrator
 */
public class ComputerServer {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(8001);
            while (!ss.isClosed()) {
                Socket s = ss.accept();
                InputStream ips = s.getInputStream();
                OutputStream ops = s.getOutputStream();
                String str = "欢迎进入程序
2．编写TCP服务器程序，"
                        + "实现创建一个在8001端口上等待的ServerSocket"
                        + "对象，当接收到一个客户机的连接请求后，"
                        + "程序从与客户机建立了连接的Socket对象中获得输入输出"
                        + "流。通过输出流向客户机发送信息。";
                ops.write(str.getBytes());
                byte[] buf = new byte[1024];
                int len = 0;
                if (ips.available() > 0)
                    len = ips.read(buf);
                System.out.println(new String(buf, 0, len));
                ips.close();
                ops.close();
                s.close();
            }
            ss.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.lzw;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;

import javax.swing.*;

public class TestClient extends JFrame {
    
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private JTextArea textArea;
    private JTextField portField;
    private JTextField hostField;
    
    /**
     * Launch the application
     * 
     * @param args
     */
    public static void main(String args[]) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    TestClient frame = new TestClient();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
    
    /**
     * Create the frame
     */
    public TestClient() {
        super();
        setBounds(100, 100, 500, 212);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        final JPanel panel = new JPanel();
        panel.setLayout(new BoxLayout(panel, BoxLayout.X_AXIS));
        getContentPane().add(panel, BorderLayout.NORTH);
        
        final JLabel label = new JLabel();
        label.setText("连接主机：");
        panel.add(label);
        
        hostField = new JTextField();
        hostField.setText("localhost");
        panel.add(hostField);
        
        final JLabel label_1 = new JLabel();
        label_1.setText("端口：");
        panel.add(label_1);
        
        portField = new JTextField();
        portField.setText("8001");
        panel.add(portField);
        
        final JButton button = new JButton();
        button.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                final String hostName = hostField.getText();
                String portNum = portField.getText();
                final int port = Integer.parseInt(portNum);
                new Thread() {
                    public void run() {
                        try {
                            final InetAddress host = InetAddress.getByName(hostName);
                            Socket socket = new Socket(host, port);
                            final InputStream is = socket.getInputStream();
                            InputStreamReader reader=new InputStreamReader(is);
                            int data = 0;
                            while ((data=reader.read()) != -1) {
                                textArea.append((char)data+"");
                                textArea.revalidate();
                                Thread.sleep(100);
                            }
                        } catch (Exception e1) {
                            textArea.append(e1.toString());
                            e1.printStackTrace();
                        }
                    }
                }.start();
                
            }
        });
        button.setText("连接");
        panel.add(button);
        
        final JScrollPane scrollPane = new JScrollPane();
        getContentPane().add(scrollPane, BorderLayout.CENTER);
        
        textArea = new JTextArea();
        textArea.setLineWrap(true);
        scrollPane.setViewportView(textArea);
    }
}

package com.lzw;

//服务器端程序
import java.awt.*;
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.List;

import javax.swing.*;

public class TCPServer extends JFrame {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private ServerSocket ss = null;
    private boolean bStart = false;
    
    private JTextArea taContent = new JTextArea();
    
    private int index = 0;
    
    List<Client> clients = new ArrayList<Client>();
    
    public void launchFrame() {
//        Container con = this.getContentPane();
        taContent.setEditable(false);
        
        taContent.setBackground(Color.DARK_GRAY);
        taContent.setForeground(Color.YELLOW);
        this.add(taContent);
        this.setSize(300, 350);
        this.setLocation(400, 200);
        this.setTitle("TCP Server");
        this.setVisible(true);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        tcpMonitor();
    }
    
    public void tcpMonitor() {
        try {
            ss = new ServerSocket(8888);
            bStart = true;
        } catch (IOException e) {
            
            e.printStackTrace();
        }
        
        try {
            while (bStart) {
                index++;
                Socket s = ss.accept();
                Client c = new Client(s);
                clients.add(c);
                
                taContent.append(s.getInetAddress().getHostAddress()
                        + " connected " + index + " clients
");
                new Thread(c).start();
                
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                ss.close();
            } catch (IOException e) {
                
                e.printStackTrace();
            }
        }
        
    }
    
    public static void main(String args[]) {
        TCPServer ts = new TCPServer();
        ts.launchFrame();
    }
    
    private class Client implements Runnable {
        DataInputStream dis = null;
        DataOutputStream dos = null;
        
        Socket s = null;
        boolean bStart = false;
        
        Client(Socket s) {
            this.s = s;
            try {
                dis = new DataInputStream(s.getInputStream());
                dos = new DataOutputStream(s.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
            
            bStart = true;
        }
        
        public void sendToEveryClient(String str) {
            try {
                dos.writeUTF(str);
                dos.flush();
                
            } catch (IOException e) {
                index--;
                clients.remove(this);
                taContent.append(s.getInetAddress().getHostAddress()
                        + " exited " + index + " clients
");
                System.out.println("对方退出了！我从List里面去掉了！");
            }
        }
        
        public void run() {
            try {
                while (bStart) {
                    String str = dis.readUTF();
                    System.out.println(str);
                    for (int i = 0; i < clients.size(); i++) {
                        Client c = clients.get(i);
                        c.sendToEveryClient(str);
                    }
                }
            } catch (EOFException e) {
                clients.remove(this);
                taContent.append(s.getInetAddress().getHostAddress()
                        + " exited " + clients.size() + " clients
");
                System.out.println("client closed");
            } catch (SocketException e) {
                System.out.println("client closed");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (s != null)
                        s.close();
                    if (dis != null)
                        dis.close();
                    if (dos != null)
                        dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
    }
    
}

package com.lzw;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;

import javax.swing.*;

public class TCPClient extends JFrame {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    TextArea taContent = new TextArea();
    JTextField tfTxt = new JTextField(20);
    
    JButton send = new JButton("发送");
    JButton connect = new JButton("连接");
    JButton clear = new JButton("清空");
    
    boolean live = false;
    JPanel p1 = new JPanel();
    JPanel p2 = new JPanel();
    
    Socket s = null;
    DataOutputStream dos = null;
    DataInputStream dis = null;
    
    boolean bConnected = false;
    
    Thread t = new Thread(new RecToServer());
    
    public void launchFrame() {
        
        taContent.setEditable(false);
        
        p2.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 5));
        p2.add(send);
        p2.add(connect);
        p2.add(clear);
        
        Container con = this.getContentPane();
        
        con.add(taContent, "North");
        con.add(tfTxt, "Center");
        con.add(p2, "South");
        
        this.setSize(300, 350);
        this.setLocation(400, 200);
        this.setTitle("Chat Client");
        
        this.setVisible(true);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        connect.addActionListener(new Connect());
        send.addActionListener(new SendMsg());
        clear.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                taContent.setText("");
            }
        });
    }
    
    public void connectToServer() {
        try {
            
            s = new Socket("127.0.0.1", 8888);
            dos = new DataOutputStream(s.getOutputStream());
            dis = new DataInputStream(s.getInputStream());
            
            bConnected = true;
            
        } catch (BindException e) {
            System.out.println("找不到指定的服务器");
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
    public void disConnect() {
        try {
            if (s != null) {
                s.close();
            }
            
            if (dos != null) {
                dos.close();
            }
            if (dis != null) {
                dis.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String args[]) {
        TCPClient tc = new TCPClient();
        tc.launchFrame();
    }
    
    private class Connect implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            if (e.getActionCommand() == "连接") {
                
                connectToServer();
                try {
                    t.start();
                } catch (IllegalThreadStateException ex) {
                    
                }
                
                connect.setText("断开连接");
                
            } else if (e.getActionCommand() == "断开连接") {
                disConnect();
                connect.setText("连接");
            }
            
        }
    }
    
    private class SendMsg implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            if (connect.getActionCommand() == "连接") {
                JOptionPane.showMessageDialog(TCPClient.this,
                        "没有找到指定的服务器", "错误提示", 1);
            } else {
                String str = tfTxt.getText();
                tfTxt.setText("");
                
                try {
                    dos.writeUTF(str);
                    dos.flush();
                } catch (SocketException ex) {
                    System.out.println("没有找到指定的服务器");
                    JOptionPane.showMessageDialog(TCPClient.this,
                            "没有找到指定的服务器", "错误提示", 1);
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
            
        }
    }
    
    private class RecToServer implements Runnable {
        public void run() {
            try {
                while (bConnected) {
                    String str = dis.readUTF();
                    // System.out.println(str);
                    
                    taContent.append(str + "
");
                }
            } catch (SocketException e) {
                System.out.println("服务器已关闭");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}