Java基础 - 网络编程 - InetAddress类、Socket（TCP）举例使用

文章目录

InetAddress类

相关方法代码举例 Socket

基本介绍基本介绍2应用案例（TCP字节流）应用案例2（TCP字节流）

注意（结束标记）应用案例3（TCP字符流）

注意（结束标记）应用案例4

InetAddress类相关方法

获取本机InetAddress对象 getLocalHost根据指定主机名/域名获取ip地址对象 getByName获取InetAddress对象的主机名 getHostName获取InetAddress对象的地址 getHostAddress 代码举例

package com.tao.api;

import java.net.InetAddress;
import java.net.UnknownHostException;


public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        //1.获取本机的InetAddress 对象
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);          //DESKTOP-9SSM1P3/192.168.16.1

        //2.根据指定主机名，获取 InetAddress对象
        InetAddress byName = InetAddress.getByName("DESKTOP-9SSM1P3");
        System.out.println(byName);             //DESKTOP-9SSM1P3/192.168.16.1

        //3.根据域名返回 InetAddress对象，比如 www.baidu.com
        InetAddress byName1 = InetAddress.getByName("www.baidu.com");
        System.out.println(byName1);            //www.baidu.com/220.181.38.150

        //4.通过 InetAddress 对象，获取对应的地址
        String hostAddress = byName1.getHostAddress();  //IP 220.181.38.150
        System.out.println("对应的IP为：" + hostAddress);                //220.181.38.150

        //5.通过 InetAddress 对象，获取对应的主机名/或者域名
        String hostName = byName1.getHostName();
        System.out.println("对应的域名为：" + hostName);                   //www.baidu.com


    }
}

Socket 基本介绍

套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准。通信的两端都要有Socket，是两台机器间通信的端点网络通信其实就是Socket间的通信Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

基本介绍2

基于客户端——服务端的网络通信底层使用的是TCP/IP协议应用场景举例：客户端发送数据，服务端接受并显示控制台基于Socket的TCP编程

应用案例（TCP字节流）

编写一个服务器端，和一个客户端服务器端在 9999端口监听客户端连接到服务器端，发送“hello，server”，然后退出服务器端接收到客户端发送的信息，输出，并退出

两个程序：服务端，客户端

package com.tao.socket;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;


public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
//        思路
//        1.连接服务端（ip，端口）
        //解读：
        //连接本机（服务端）的9999端口，如果连接成功，返回Socket对象
        InetAddress localHost = InetAddress.getLocalHost();
        
        //localHost可以直接换成主机名D-9xxxxxx
        Socket socket = new Socket(localHost, 9999);
        System.out.println("客户端 socket返回 = " + socket.getClass());

//        2.连接上后，生成Socket，通过socket.getOutputStream()
        //得到 和 socket对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();

//        3.通过输出流，写入数据到 数据通道
        outputStream.write("hello,server".getBytes());

//        4.关闭流
        outputStream.close();
        socket.close();
        System.out.println("客户端退出了");
    }
}

package com.tao.socket;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;


public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
//        思路
//        1.在本机的9999端口监听，等待连接
        //在本机9999端口监听，等待连接
        //细节：要求在本机没有其他服务在监听9999
        //细节：这个 ServerSocket 可以通过 accept（） 返回多个Socket[多个客户端连接服务器的并发](多并发)
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在监听9999，等待连接...");

//        2.当没有客户端连接9999端口时，程序会阻塞，等待连接
        //如果有客户端连接，则会返回Socket对象，程序继续
        Socket accept = serverSocket.accept();
        System.out.println("服务器端 socket = " + serverSocket.getClass());
        System.out.println("有目标客户端连接，程序继续....");

//        3.通过socket.getInputStream()读取客户端写入到数据通道的数据，并显示
        InputStream inputStream = accept.getInputStream();

//        4.IO读取
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1){
            System.out.println(new String(buf, 0,readLen)); //根据读取到的实际长度，显示内容
        }

//        5.关闭流和socket
        inputStream.close();
        accept.close();     //socket
        serverSocket.close();
    }
}

应用案例2（TCP字节流）

编写一个服务器端，和一个客户端服务器端在 5000 端口监听客户端连接到服务器端，发送“hello，server”，并接受服务器端回发的“hello，client”，再退出服务器端接收到客户端发送的信息，输出，并发送“hello，client”，再退出

服务器端

package com.tao.test;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;


public class Server_ {
    public static void main(String[] args) throws IOException {
        //生成ServerSoket对象监视端口5000
        ServerSocket serverSocket = new ServerSocket(5000);

        //当我们没有连接服务器时，我们阻塞这个程序，accept
        System.out.println("等待目标客户端连接...");
        Socket socket = serverSocket.accept();

        //从数据通道接收数据
        System.out.println("正在接受数据...");
        System.out.println("接收到数据：");
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];
        int readLen = 0;
        while ((readLen = inputStream.read(buf)) != -1){
            System.out.println(new String(buf,0,readLen));
        }

        //发送数据到数据通道
        System.out.println("正在写入数据到数据通道...");

        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());



        //关闭流
        serverSocket.close();
        socket.close();
        inputStream.close();
        outputStream.close();
        System.out.println("服务器端已关闭....");
    }
}

客户端

package com.tao.test;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;


public class Client_ {
    public static void main(String[] args) throws IOException {
        //Socket连接服务器和端口
        //获得本机的ip和端口
        InetAddress localHost = InetAddress.getLocalHost();

        //socket对象插入端口
        Socket socket = new Socket(localHost, 5000);
        System.out.println("服务器已连接...正在监听5000端口");

        //把数据写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,server".getBytes());

        socket.shutdownOutput();
        //接收服务端数据，并读写
        //IO读取
        System.out.print("读取到数据：");
        InputStream inputStream = socket.getInputStream();
        byte[] buf = new byte[1024];    //每次读取1024字节
        int readLen = 0;    //读取的长度
        while ((readLen = inputStream.read(buf)) != - 1){
            //从buf的第0个字节读到readLen
            System.out.println(new String(buf,0,readLen));
        }

        System.out.println("客户端已关闭...");

        //关闭流
        socket.close();
        outputStream.close();
        inputStream.close();
    }
}

注意（结束标记）

写完数据后shutduwn

socket.shutdownOutput();

应用案例3（TCP字符流）

编写一个服务端，和一个客户端服务端在 9999 端口监听客户端连接到服务端，发送“hello，server”，并接受服务端回发的“hello,client”，再退出服务端接收到客户端发送的信息，输出，并发送“hello，client”，再退出注意（结束标记）

writer.newline();	//换行符,注意需要使用readLine()

package com.tao.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;


public class SocketTCP03Server {
    public static void main(String[] args) throws IOException {
        //生成ServerSoket对象监视端口5000
        ServerSocket serverSocket = new ServerSocket(5000);

        //当我们没有连接服务器时，我们阻塞这个程序，accept
        System.out.println("等待目标客户端连接...");
        Socket socket = serverSocket.accept();

        //从数据通道接收数据
        System.out.println("正在接受数据...");
        System.out.print("接收到数据：");
        InputStream inputStream = socket.getInputStream();
        //4.IO读取，字符流
        //使用InputStreamReader 将 inputStream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);  //输出


//        byte[] buf = new byte[1024];
//        int readLen = 0;
//        while ((readLen = inputStream.read(buf)) != -1){
//            System.out.println(new String(buf,0,readLen));
//        }

        //发送数据到数据通道
        System.out.println("正在写入数据到数据通道...");

        OutputStream outputStream = socket.getOutputStream();
        //使用字符输出流的方式回复信息
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,client字符流");
        bufferedWriter.newline();   //插入一个换行符，表示回复内容的结束
        bufferedWriter.flush();     //注意，需要手动的flush
//        outputStream.write("hello,client".getBytes());



        //关闭流
        serverSocket.close();
        socket.close();
        inputStream.close();
        outputStream.close();
        System.out.println("服务器端已关闭....");
    }
}

package com.tao.socket;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;


public class SocketTCP03Client {
    public static void main(String[] args) throws IOException {
        //Socket连接服务器和端口
        //获得本机的ip和端口
        InetAddress localHost = InetAddress.getLocalHost();

        //socket对象插入端口
        Socket socket = new Socket(localHost, 5000);
        System.out.println("服务器已连接...正在监听5000端口");

        //把数据写入到数据通道
        OutputStream outputStream = socket.getOutputStream();
        //使用字符流
//        outputStream.write("hello,server".getBytes());
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server字符流");
        bufferedWriter.newline();//插入一个换行符，表示写入的内容结束，表示写入的内容结束，注意，要求对方使用readLine（）！！！！
        bufferedWriter.flush();//如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
//        socket.shutdownOutput();

        //接收服务端数据，并读写
        //IO读取
        System.out.print("读取到数据：");
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
//        byte[] buf = new byte[1024];    //每次读取1024字节
//        int readLen = 0;    //读取的长度
//        while ((readLen = inputStream.read(buf)) != - 1){
//            //从buf的第0个字节读到readLen
//            System.out.println(new String(buf,0,readLen));
//        }

        System.out.println("客户端已关闭...");

        //关闭流
        socket.close();
        outputStream.close();
        inputStream.close();
    }
}

应用案例4

编写一个服务端，和一个客户端服务器端在 9999端口监听客户端连接到服务端，发送一张图片 d:qie.png服务器端接收到客户端发送的图片，保存到 src 下，发送“收到图片”再退出客户端接收到服务端发送的“收到图片”，再退出该程序要求使用StreamUtils.java

说明：使用BufferedInputStream 和 BufferedOutputStream 字节流

服务器端

package com.tao.upload;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;



public class TCPFileUploadServer {
    public static void main(String[] args) throws Exception {

        //1.监视端口
        System.out.println("正在监听9999...");
        ServerSocket serverSocket = new ServerSocket(9999);

        //2.等待连接
        Socket socket = serverSocket.accept();

        //3.读取客户端发送的数据
        //通过Socket得到输入流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamtoByteArray(bis);

        //4.将得到 bytes 数组，写入到指定的路径，就得到一个文件了
        String destFilePath = "src\qie2.png";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();

        //向客户端回复“收到图片”
        //通过socket 获取到输出流（字符）
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到图片...");
        writer.flush(); //把内容刷新到数据通道
        socket.shutdownOutput();        //设置写入结束标记
        //关闭其他资源
        socket.close();
        serverSocket.close();
        bis.close();

        writer.close();
        System.out.println("服务端结束");
    }
}

客户端

package com.tao.upload;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;


public class TCPFileUploadClient {
    public static void main(String[] args) throws Exception {

        //连接服务器和端口
//        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        InetAddress localHost = InetAddress.getLocalHost();
        Socket socket = new Socket(localHost, 9999);

        //创建读取磁盘文件的输入流
        String filePath = "d:\jing.jpg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //bytes 就是filePath对应的字节数组
        byte[] bytes = StreamUtils.streamtoByteArray(bis);

        //通过socket获取到输出流，将bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);   //将文件对应的字节数组的内容，写入到数据通道
        bis.close();
        socket.shutdownOutput();    //设置写入数据的结束标记

        //接收从服务端回复的消息
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils的方法，直接将 inputStream 读取到的内容转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
        //关闭相关的流
        bos.close();
        socket.close();
        inputStream.close();
        System.out.println("客户端结束");
    }
}

Java基础 - 网络编程 - InetAddress类、Socket（TCP）举例使用

Java相关栏目本月热门文章