Java网络编程

intro_233

已于 2022-12-01 22:57:20 修改

阅读量237

点赞数

文章标签：学习

于 2022-10-19 10:48:11 首次发布

本文链接：https://blog.youkuaiyun.com/m0_63884042/article/details/127302916

版权

一、网络编程

1、IP地址

ipconfig可用于查看本机的ip地址

ping ip地址可用于检查网络是否连同

特殊ip地址：127.0.0.1，是回送地址，可以代表本机地址，一般用来测试使用

2、InetAddress

Java提供了InetAddress类来代表IP地址，InetAddress下还有两个子类：Inet4Address(ipv4)、Inet6Address(ipv6)

static InetAddress getByName(String host):根据主机名称确定主机IP地址，主机名称可以是机器名称，也可以是IP地址和域名

String getHostName():获取此IP地址的主机名称

String getHostAddress():返回IP地址字符串

public class test {
    public static void main(String args[]) throws UnknownHostException{
        InetAddress add=InetAddress.getByName("surface-go2");//这里也可以是ip地址
        String name=add.getHostName();
        String ip=add.getHostAddress();

        System.out.println("主机名"+":"+name);
        System.out.println("ip地址"+"："+ip);
    }
}

3、端口

端口：设备上应用程序的唯一标识

端口号：用两个字节表示的整数，范围是0-65535。其中0-1023用于一些知名网络服务和应用，普通的应用程序需使用1024以上的端口号。如果端口号被其他应用程序占用，会导致当前程序启动失败

4、UDP发送和接收数据

DatagramSocket()：绑定到本地地址和一个随机的端口号

send(DatagramPacket dp)：发送数据报

close()：关闭套接字

UDP发送数据步骤：

创建发送端的Socket对象（DatagramSocket()）

创建数据并打包（DatagramPacket(byte[] buf, int length, InetAddress address, int port)）

调用DatagramSocket对象方法发送数据（send(DatagramPacket dp)）

关闭发送端（close()）

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

public class test {
    public static void main(String args[]) throws IOException{
        //throws声明：如果一个方法内部的代码会抛出检查异常（checked exception），
        //而方法自己又没有完全处理掉或并不能确定如何处理这种异常，
        //则javac保证你必须在方法的签名上使用throws关键字声明这些可能抛出的异常，表明该方法将不对这些异常进行处理，
        //而由该方法的调用者负责处理，否则编译不通过。
        InetAddress add=InetAddress.getByName("surface-go2");

        DatagramSocket ds=new DatagramSocket();

        byte[] arr="hello,world".getBytes();
        int len=arr.length;
        int port=10000;

        DatagramPacket dp=new DatagramPacket(arr, len,add,port);
        //或写成DatagramPacket dp=new 
        //DatagramPacket(arr,arr.length,InetAddress.getByName("surface-go2"),10000);

        ds.send(dp);

        ds.close();

    }
}

UDP接收数据步骤：

创建接收端的Socket对象（DatagramSocket()）

创建一个数据包用于接收数据（DatagramPacket(byte[] buf, int length)）Data

调用DatagramSocket方法接收数据（void recevie(DatagramPacket dp)）

解析数据包，并且把数据在控制台显示（byte[] getData() int getLength()）

关闭数据端（void close())

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

public class test2{
    public static void main(String[] args) throws IOException{
        DatagramSocket ds=new DatagramSocket(10000);

        byte[] arr=new byte[1000];
        DatagramPacket dp=new DatagramPacket(arr, arr.length);

        ds.receive(dp);

        byte[] data=dp.getData();

        String dataString=new String(data,0,dp.getLength());

        ds.close();
        System.out.println(dataString);
    }
}

实现简单信息发送

public class Test1 {
    public static void main(String[] args) throws Exception{
        DatagramSocket client=new DatagramSocket(10086);
        
        BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
        String line;
        while((line=bReader.readLine())!=null){
            if(line.equals("886")){
                break;
            }
            byte[] data=line.getBytes();
            DatagramPacket dp=new DatagramPacket(data, data.length, InetAddress.getByName("localhost"), 8080);
            client.send(dp);
        }
        client.close();
    }
}

public class Test2 {
    public static void main(String[] args) throws Exception{
        DatagramSocket client=new DatagramSocket(8080);
        while(true){
            byte[] data=new byte[1024];
            DatagramPacket dp=new DatagramPacket(data,data.length);

            client.receive(dp);

            System.out.println(new String(dp.getData(),0,dp.getLength()));
        }
        //client.close();
    }
}

5、TCP发送和接收数据

TCP发送数据步骤：

创建客户端Socket对象

获取输出流，写数据（OutputStream getOutputStream()）

释放资源（close()）

TCP接收数据步骤：

创建服务器端SeverSocket对象

package demo5;

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

public class client {
    public static void main(String[] args) throws Exception{
        Socket socket = null;
        OutputStream oStream = null;

        try {
            socket = new Socket(InetAddress.getByName("localhost"),8080);
            oStream = socket.getOutputStream();

            oStream.write("hello,world".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(oStream!=null){
                try {
                    oStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package demo5;

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

public class sever {
    public static void main(String[] args) throws Exception{
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream iStream = null;

        try {
            serverSocket = new ServerSocket(8080);
            socket = serverSocket.accept();
            iStream = socket.getInputStream();
            byte[] temp = new byte[1024];
            iStream.read(temp);
            String data = new String(temp,0,temp.length);
            System.out.println(data);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(iStream!=null){
                try {
                    iStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(socket!=null){
                try {
                    socket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if(serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

实现简单通信程序

package demo5;

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.*;

public class client {
    public static void main(String[] args) throws Exception{
        Socket socket = new Socket(InetAddress.getByName("localhost"),8080);
        OutputStream oStream = socket.getOutputStream();
        PrintStream printStream = new PrintStream(oStream);
        Scanner scanner = new Scanner(System.in);
        String line;
        while(true){
            line = scanner.nextLine();
            if(line.equals("end")){
                break;
            }
            printStream.println(line);//必须是println，否则sever无法按行读取
        }
        scanner.close();
        oStream.close();
        socket.close();
    }
}

package demo5;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class sever {
    public static void main(String[] args) throws Exception{
        ServerSocket serverSocket = new ServerSocket(8080);
        Socket socket = serverSocket.accept();
        InputStream iStream = socket.getInputStream();
        BufferedReader bReader = new BufferedReader(new InputStreamReader(iStream));
        String line;
        while((line=bReader.readLine())!=null){
            System.out.println("客户端："+line);
        }
        bReader.close();
        socket.close();
        serverSocket.close();
    }
}

多线程通信

Recive.java

package demo3;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Receive implements Runnable{
    private DatagramSocket dSocket;
    private String from;
    
    public Receive(String from,int port){
        this.from=from;

        try {
            dSocket=new DatagramSocket(port);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }

    @Override
    public void run(){
        try {
            while(true){
                byte[] data=new byte[1024*60];
                DatagramPacket dPacket=new DatagramPacket(data, data.length);
                dSocket.receive(dPacket);
                String mes=new String(dPacket.getData(),0,dPacket.getLength());
                System.out.println(this.from+":"+mes);
                if(mes.equals("end")){
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        dSocket.close();
    }
}

Send.java

package demo3;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Send implements Runnable{
    private DatagramSocket dSocket;
    private int toPort;
    private String toIP;

    public Send(String ip,int toport,int port){
        this.toIP=ip;
        this.toPort=toport;
        try {
            dSocket=new DatagramSocket(port);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run(){
        try {
            BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
            String line;
            while(true){
                line=bReader.readLine();
                DatagramPacket dPacket=new DatagramPacket(line.getBytes(), line.length(), InetAddress.getByName(this.toIP),this.toPort);
                dSocket.send(dPacket);
                if(line.equals("end")){
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        dSocket.close();
    }
}

talker1.java

package demo3;

public class talker1 {
    public static void main(String[] args){
        new Thread(new Send("localhost",9999,7777)).start();;
        new Thread(new Receive("talker2", 8888)).start();;
    }
}

talker2.java

package demo3;

public class talker2 {
    public static void main(String[] args){
        new Thread(new Receive("talker1", 9999)).start();
        new Thread(new Send("localhost", 8888, 5555)).start();
    }
}