Socket相关简单介绍二

Socket通信

TCP协议是面向连接、可靠的、有序的，以字节流的方式发送数据，基于TCP协议实现网络通信类。

客户端的Socket类
服务端的ServerSocket类

流程如下图：

基于TCP-Socket编程通信实现步骤

1、创建ServerSocket和Socket
2、打开连接到Socket的输入流和输出流
3、按照协议对Socket进行读写操作
4、关闭输入流和输出流、关闭Socket

服务器端

1、创建ServerSocket对象，建立监听端口。
2、通过accept()方法监听客户端请求。
3、连接建立后，通过输入流读取客户端发送的信息。
4、通过输出流向客户端发送响应信息。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

/*
 * 基于TCP协议的Socket通信，实现用户登陆
 * 服务器端
 */
public class Server {
    public static void main(String[] args) {
        try {
            //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
            ServerSocket serverSocket=new ServerSocket(8888);
            Socket socket=null;
            //记录客户端的数量
            int count=0;
            System.out.println("***服务器即将启动，等待客户端的连接***");
            //循环监听等待客户端的连接
            while(true){
                //调用accept()方法开始监听，等待客户端的连接
                socket=serverSocket.accept();
                //创建一个新的线程
                ServerThread serverThread=new ServerThread(socket);
                //启动线程
                serverThread.start();
                //设置线程的优先级，范围设置[1-10],默认位5
                serverThread.setRiority(4);
                count++;//统计客户端的数量
                System.out.println("客户端的数量："+count);
                InetAddress address=socket.getInetAddress();
                System.out.println("当前客户端的IP："+address.getHostAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多线程服务器

应用多线程来实现服务器与多客户端之间的通信
1、服务器端创建Socket，循环调用accept()等待客户端连接
2、客户端创建Socket并请求和服务器端连接
3、服务器端接收客户端请求，创建Socket与该客户建立专线连接
4、建立连接的两个socket在一个单独的线程上对话
5、服务器端继续等待新的连接

/*
 * 服务器线程处理类
 */
public class ServerThread extends Thread {
    // 和本线程相关的Socket
    Socket socket = null;

    public ServerThread(Socket socket) {
        this.socket = socket;
    }

    //线程执行的操作，响应客户端的请求
    public void run(){
        InputStream is=null;
        InputStreamReader isr=null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        try {
            //获取输入流，并读取客户端信息
            is = socket.getInputStream();
            isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            String info=null;
            while((info=br.readLine())!=null){//循环读取客户端的信息
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //获取输出流，响应客户端的请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("欢迎您！");
            pw.flush();//调用flush()方法将缓冲输出
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            //关闭资源
            try {
                if(pw!=null)
                    pw.close();
                if(os!=null)
                    os.close();
                if(br!=null)
                    br.close();
                if(isr!=null)
                    isr.close();
                if(is!=null)
                    is.close();
                if(socket!=null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端

1、创建Socket对象，指明需要连接的服务器的地址和端口号。
2、连接建立后，通过输出流向服务器端发送请求信息。
3、通过输入流获取服务器相应的信息
4、关闭相关资源

/*
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        try {
            //1.创建客户端Socket，指定服务器地址和端口
            Socket socket=new Socket("localhost", 8888);
            //2.获取输出流，向服务器端发送信息
            OutputStream os=socket.getOutputStream();//字节输出流
            PrintWriter pw=new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名：admin;密码：123");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //3.获取输入流，并读取服务器端的响应信息
            InputStream is=socket.getInputStream();
            BufferedReader br=new BufferedReader(new InputStreamReader(is));
            String info=null;
            while((info=br.readLine())!=null){
                System.out.println("我是客户端，服务器说："+info);
            }
            //4.关闭资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

基于UDP-Socket编程通信实现步骤

UDP协议（用户数据报协议）无连接、不可靠、无序的。
进行数据传输时，首先需要将要传输的数据定义成数据报(Datagram),在数据报中指明数据所要达到Socket(主机地址和端口号)，然后再将数据报发送出去。

相关操作类

DatagramPacket:表示数据报包
DatagramSocket:进行端到端通信的类

UDP服务端实现步骤

1、创建DatagramSocket,指定端口号。
2、创建DatagramPacket
3、接收客户端发送的数据信息
4、读取数据

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
 * 服务器端，实现基于UDP的用户登陆
 */
public class UDPServer {
    public static void main(String[] args) throws IOException {
        /*
         * 接收客户端发送的数据
         */
        //1.创建服务器端DatagramSocket，指定端口
        DatagramSocket socket=new DatagramSocket(8800);
        //2.创建数据报，用于接收客户端发送的数据
        byte[] data =new byte[1024];//创建字节数组，指定接收的数据包的大小
        DatagramPacket packet=new DatagramPacket(data, data.length);
        //3.接收客户端发送的数据
        System.out.println("****服务器端已经启动，等待客户端发送数据");
        socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
        //4.读取数据
        String info=new String(data, 0, packet.getLength());
        System.out.println("我是服务器，客户端说："+info);

        /*
         * 向客户端响应数据
         */
        //1.定义客户端的地址、端口号、数据
        InetAddress address=packet.getAddress();
        int port=packet.getPort();
        byte[] data2="欢迎您!".getBytes();
        //2.创建数据报，包含响应的数据信息
        DatagramPacket packet2=new DatagramPacket(data2, data2.length, address, port);
        //3.响应客户端
        socket.send(packet2);
        //4.关闭资源
        socket.close();
    }
}

UDP客户端实现步骤

1、定义发送信息
2、创建DatagramPacket,包含将要发送的信息
3、创建DatagramSocket
4、发送数据

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

/*
 * 客户端
 */
public class UDPClient {
    public static void main(String[] args) throws IOException {
        /*
         * 向服务器端发送数据
         */
        //1.定义服务器的地址、端口号、数据
        InetAddress address=InetAddress.getByName("localhost");
        int port=8800;
        byte[] data="用户名：admin;密码：123".getBytes();
        //2.创建数据报，包含发送的数据信息
        DatagramPacket packet=new DatagramPacket(data, data.length, address, port);
        //3.创建DatagramSocket对象
        DatagramSocket socket=new DatagramSocket();
        //4.向服务器端发送数据报
        socket.send(packet);

        /*
         * 接收服务器端响应的数据
         */
        //1.创建数据报，用于接收服务器端响应的数据
        byte[] data2=new byte[1024];
        DatagramPacket packet2=new DatagramPacket(data2, data2.length);
        //2.接收服务器响应的数据
        socket.receive(packet2);
        //3.读取数据
        String reply=new String(data2, 0, packet2.getLength());
        System.out.println("我是客户端，服务器说："+reply);
        //4.关闭资源
        socket.close();
    }
}

最后提示

多线程优先级

//设置线程的优先级，范围设置[1-10],默认位5
            serverThread.setRiority(4);

是否关闭输出流和输入流

对于同一个socket,如果关闭了输出流，则与该输出流关联的socket也会被关闭，所以一般不用关闭流，直接关闭socket即可。

使用TCP通信传输对象

ObjectOutStream oos = new ObjectOutStream();
User u  =new User("admin","123");
oos.writeObejct(u)

Socket编程传递文件

1、实体

public class User implements Serializable {
    private String userName;
    private String userId;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public User() {
    }

    ;

    public User(String userName, String userId) {
        this.userName = userName;
        this.userId = userId;
    }

    ;
}

2、客户端

OutputStream os=socket.getOutputStream();//字节输出流 
 PrintWriter pwPrintWriter = new PrintWriter(os);//将输出流包装成打印流 
ObjectOutputStream oos = new ObjectOutputStream(os); 
pwPrintWriter.write("用户名：Tom;密码：123"); //传入字符串 
User user = new User("Tom", "123");//传入对象 
oos.writeObject(user); 
pwPrintWriter.flush(); socket.shutdownOutput();
ObjectInputStream din =new ObjectInputStream(inputStream); 
//接收文件写出文件
FileOutputStream fos = new FileOutputStream("File/UDOClient1.txt");
byte[] buf=new byte[1024];
int len;
while ((len = din.read(buf,0,buf.length)) != -1) { fos.write(buf, 0, len); fos.flush(); } fos.close(); 
socket.shutdownInput();

3、服务端

ObjectInputStream is = new ObjectInputStream(socket.getInputStream());
User user = (User) is.readObject();
System.out.println("我是服务器，客户端说" + user.getUserName() + ":" + user.getUserId());
socket.shutdownInput();// 关闭输入流
outputStream = socket.getOutputStream();

file = new File("File/Client.txt"); 
fin = new FileInputStream(file);
byte[] sendByte = new byte[1024]; 
ObjectOutputStream obj=new ObjectOutputStream(outputStream);
int length;
while ((length = fin.read(sendByte, 0, sendByte.length))!=-1) { obj.write(sendByte, 0, length);
obj.flush(); }