狂神java网络编程

网络编程

计算机网络是指将**地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，

实现资源共享**和信息传递的计算机系统

网络编程的目的：

无线电台…传播交流信息，数据交换。通信

网络编程中有两个主要的问题
。如何准确的定位到网络上的一台或者多台主机
。找到主机之后如何进行通信
ip地址：计算机名字。
端口：发送到qq还是微信。

ip地址 hostname

ip地址：inetAddress类

互联网协议（ip）地址。InetAddress类无构造方法
1.常用方法摘要
byte[] getAddress()
返回此 InetAddress 对象的原始 IP 地址。
static InetAddress getByName(String host)
在给定主机名的情况下确定主机的 IP 地址。
String getHostAddress()
返回 IP 地址字符串（以文本表现形式）。
String getHostName()
获取此 IP 地址的主机名。
static InetAddress getLocalHost()
返回本地主机。
127.0.0.1：本机地址，主要用于测试。别名：Localhost
注意：端口号前面的那玩意、以及电脑名称，还有网址都表示ip。

package network;

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

public class ip地址01 {



        public static void main(String[] args) throws UnknownHostException {
            //InetAdress类表示IP地址

            //获取本机IP
            InetAddress ip = InetAddress.getLocalHost();// ADMINISTRATOR/192.xxx.xxx.xxx
            System.out.println(ip);
            //获得主机名
            System.out.println(ip.getHostName());// ADMINISTRATOR
            //获得IP地址
            System.out.println(ip.getHostAddress());// 192.xxx.xxx.xxx
            //getLocalHost=getHostName+getHostAddress
            System.out.println(InetAddress.getByName("localhost"));
        }
    }

端口 port

• 端口表示计算机的一个程序进程：
• 端口号如果被一个应用程序占用了，那么其他的应用程序就无法再使用这个端口号了。被规定0 ~ 065535
• 我们使用IP地址加端口号，就可以保证数据准确无误地发送到对方计算机的指定软件上了。
• • 不同的进程有不同的端口号！用来区分软件。
• 1024以下的端口号不要去占用，因为系统有可能会随时征用。端口号本身又分为TCP端口和UDP端口，TCP的8888端口和UDP的8888端口是完全不同的两个端口。TCP端口和UDP端口都有65536个\

InetSocketAddress类

(类实现 IP 套接字地址（IP 地址 + 端口号）)

1. 构造方法摘要
   InetSocketAddress(InetAddress addr, int port)
   根据 IP 地址和端口号创建套接字地址。
   InetSocketAddress(int port)
   创建套接字地址，其中 IP 地址为通配符地址，端口号为指定值。
   InetSocketAddress(String hostname, int port)
   根据主机名和端口号创建套接字地址。

2. 常用方法摘要
   InetAddress getAddress()
   获取 InetAddress。
   String getHostName()
   获取 hostname。
   int getPort()
   获取端口号。

import java.net.InetAddress;
import java.net.InetSocketAddress;

public class TestPort {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1",8082);
        System.out.println(inetSocketAddress);
        //返回主机名
        System.out.println(inetSocketAddress.getHostName());
        //获得InetSocketAddress的端口
        System.out.println(inetSocketAddress.getPort());
        //返回一个InetAddress对象（IP对象）
        InetAddress address = inetSocketAddress.getAddress();
        System.out.println(address);
    }
}

通信协议

协议：约定，就好比我们现在说的是普通话。

**网络通信协议：**速率，传输码率，传输控制……

大事化小：分层！

TCP/IP协议簇：实际上是一组协议

重要：

TCP：用户传输协议

UDP：用户数据报协议

TCP UDP对比

TCP：打电话

连接，稳定

三次握手 四次挥手

最少需要三次，保证稳定连接！

A：我要走了（类似于分手）

B：你真的要走了吗？

B：你真的真的要走了吗？

A：我真的要走了

在客户端、服务端之间

传输完成，释放连接，效率低

UDP：发短信（发导弹）

不连接，不稳定。

客户端、服务端：没有明确的界限

DDOS：洪水攻击！（饱和攻击）

tcp实现聊天

（先启动服务端）
客户端发送到服务端
客户端：java.net.Socket 类表示。创建Socket对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
服务端：java.net.ServerSocket 类表示。创建ServerSocket对象，相当于开启一个服务，并等待客户端的连接。

ServerSocket类

与socket是孪生兄弟，表示服务端的socket。
ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。
构造方法摘要
public ServerSocket(int port) ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。

ServerSocket server = new ServerSocket(6666);

package network;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
//服务端
//
public class 通信协议 {
    public static void main(String[] args) {
        ServerSocket  server=null;
        Socket socket=null;
        InputStream ip=null;
        ByteArrayOutputStream bo=null;

        try {//一个地址
             server=new ServerSocket(9999);
            //等待客户端连接
            socket=server.accept();//侦听并接受连接，返回一个新的Socket对象，用于和客户端实//现通信。该方法会一直阻塞直到建立连接。
            //读取客户端
          ip=socket.getInputStream();
            //管道流
           bo=new ByteArrayOutputStream();
              byte[] bufferr=new byte[1024];
              int len;
              while ((len=ip.read(bufferr))!=-1)
              {
                      bo.write(bufferr,0,len);
              }
            System.out.println(bo.toString());


        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            //关闭流
            if (bo != null) {
                try {
                    bo.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (ip != null) {
                try {
                    ip.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (server != null) {
                try {
                    server.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

}

Socket类

两台设备连接到桥梁。

1. 该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。
   public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。

2. public InputStream getInputStream() ： 返回此套接字的输入流。

3. 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
   关闭生成的InputStream也将关闭相关的Socket。

4. public OutputStream getOutputStream() ： 返回此套接字的输出流。

5. 如果此Socket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
   关闭生成的OutputStream也将关闭相关的Socket。
   public void close() ：关闭此套接字。

6. 一旦一个socket被关闭，它不可再使用。
   关闭此socket也将关闭相关的InputStream和OutputStream 。

Socket client = new Socket("127.0.0.1", 6666);

package network;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

//客户端
public class tcp实现聊天 {
    public static void main(String[] args) {
        InetAddress serverIP=null;
        Socket socke=null;
        OutputStream ops=null;


        try { //知道地址，要知道服务器地址，创建一个socket连接
             serverIP = InetAddress.getByName("127.0.0.1");
            //端口号
            Socket socket = new Socket();
            int port=9999;
           //创建一个socket连接
            socke=new Socket(serverIP,port);
            //发送消息IO流
             ops=socke.getOutputStream();

            ops.write("你好，2022年7月11日17:01:40".getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(socke!=null)
            {
                try {
                    socke.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if(ops!=null)
            {
                try {
                    ops.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

}

tcp文件传输

package network;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
              //客户端
public class tcp文件上传 {
    public static void main(String[] args) throws IOException {
        //创建一个socket连接
        Socket socket = null;

            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);

        //创建一个输出流
        OutputStream os=socket .getOutputStream();
        //文件流
        FileInputStream fis = new FileInputStream(new File("D:\\javad\\java_______________code\\javaAgain\\src\\network\\1657009591744.png"));
        int len;
        byte[]buffer=new byte[1024];
        while((len=fis.read(buffer))!=-1)
        {
            os.write(buffer,0,len);
        }
        socket.shutdownOutput();
        InputStream ips = socket.getInputStream();
        ByteArrayOutputStream BAOS=new ByteArrayOutputStream();
        byte[]buffer2=new byte[2014];
        int len2;
        while((len2=ips.read(buffer2))!=-1)
        {
            BAOS.write(buffer2,0,len2);
        }
        BAOS.close();
        fis.close();
        os.close();
        socket.close();
    }
}

package network;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

//服务端
public class tcp文件接受 {
    public static void main(String[] args) throws IOException {
       //创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
    //监听客户的连接
        Socket socket=serverSocket.accept();//阻塞式监听，等待与用户连接
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.png"));
        byte[]buffer=new byte[1024];
      int len=0;
        while((len=is.read(buffer))!=-1)
        {
            fos.write(buffer,0,len);
        }
        OutputStream os=socket.getOutputStream();
        os.write("我接受玩了".getBytes(StandardCharsets.UTF_8));
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

Tomcat

Tomcat是常见的免费的web服务器.
阿帕奇安装包·Tomcat服务器 S：Java后台开发!
8080是tomcat默认使用的端口号

UDP

发短信：不用连接，需要知道对方的地址.

DatagramSocket

（1）构造方法摘要
protected DatagramSocket()构造数据报套接字并将其绑定到本地主机上的任何可用端口。
protected DatagramSocket(int port)构造数据报套接字并将其绑定到本地主机上的指定端口。
protected DatagramSocket(int port, InetAddress laddr)创建一个数据报套接字，绑定到指定的本地地址。

DatagramPacket

DatagramPacket(byte[] buf, int offset, int length)构造一个 DatagramPacket用于接收指定长度的数据报包到缓冲区中。
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)构造用于发送指定长度的数据报包到指定主机的指定端口号上。
byte[] getData() 返回数据报包中的数据。
InetAddress getAddress() 返回该数据报发送或接收数据报的计算机的IP地址。
int getLength() 返回要发送的数据的长度或接收到的数据的长度。

//不需要连接服务器

public class UdpClientDemo01{

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

        //1、建立一个Socket

        DatagramSocket socket = new DatagramSocket();



        //2、建一个包

        String msg = "你好啊，服务器!";

        //发送给谁

        InetAddress localhost = InetAddress.getByName("localhost");

        int port = 9090;



        //数据，数据的长度起始，要发送给谁

        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);



        //3、发送一个包

        socket.send(packet);



        //4、关闭流

        socket.close();

    }

}

接收端

//还是要等待客户端的连接！

public class UdpServerDemo01 {

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

        //开发端口

        DatagramSocket socket = new DatagramSocket(9090);

        //接收数据包

        byte[] buffer = new byte[1024];

        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);   //接收



        socket.receive(packet); //阻塞接收



        System.out.println(packet.getAddress().getHostAddress());

        System.out.println(new String(packet.getData(), 0, packet.getLength()));



        //关闭连接

        socket.close();

    }

}

循环发送

public class UdpSenderDemo01 {

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

        DatagramSocket socket = new DatagramSocket(8888);



        //准备数据：控制台读取 System.in



        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));



        while (true){

            String data = reader.readLine();

            byte[] datas = data.getBytes();

            DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));



            socket.send(packet);

            if (data.equals("bye")){

                break;

            }



        }



        socket.close();

    }

}

public class UdpReceiveDemo01 {

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

        DatagramSocket socket = new DatagramSocket(6666);



        //准备接收包裹

        byte[] container = new byte[1024];



        while (true){

            DatagramPacket packet = new DatagramPacket(container, 0, container.length);

            socket.receive(packet); //阻塞式接收包裹



            //断开连接 byte

            byte[] data = packet.getData();

            String receiveData = new String(data, 0, data.length);

            System.out.println(receiveData);



            if (receiveData.equals("bye")){

                break;

            }



        }

        socket.close();

    }

}

package com.kuang.lesson4;

import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=abaaba&password=123");
        System.out.println(url.getProtocol());  //协议
        System.out.println(url.getHost());  //主机ip
        System.out.println(url.getPort());  //端口
        System.out.println(url.getPath());  //文件地址
        System.out.println(url.getFile());  //文件全路径
        System.out.println(url.getQuery()); //参数
    }
}

下载文件

package com.kuang.lesson4;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class UrlDown {
    public static void main(String[] args) throws Exception{
        //1.下载地址
        URL url = new URL("http://localhost:8080/shuaige/SecretFile.txt");

        //2.连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("SecretFile.txt");

        byte[] buffer = new byte[1024];
        int len;
        while((len=inputStream.read(buffer))!=-1){
            fos.write(buffer, 0, len);  //写出这个数据
        }

        fos.close();
        inputStream.close();
        urlConnection.disconnect(); //断开连接

    }
}

与老师交流（多线程）

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

public class UDPSender implements Runnable{
    //创建一个socket
    DatagramSocket socket=null;
    //创建一个流 用于录入键盘的数据
    BufferedReader bfr=null;
    //发送数据目的地的IP
    private String toIP;
    //发送数据目的地的端口
    private int toPort;

    public UDPSender(String toIP, int toPort) {
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            socket=new DatagramSocket();//创建一个socket
        } catch (SocketException e) {
            e.printStackTrace();
        }
        bfr=new BufferedReader(new InputStreamReader(System.in));//从键盘录入数据到流中
    }

    @Override
    public void run() {
        while (true){//循环发送数据
            try {
                String msg = bfr.readLine();//从流中读取数据
                byte[] buffer = msg.getBytes();
                InetAddress inet = InetAddress.getByName(toIP);
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length, inet, toPort);
                socket.send(packet);
                //如果发送了拜拜，则退出发送
                if(msg.equals("拜拜")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //释放资源
        if(socket!=null){
            socket.close();
        }
        if (bfr!=null){
            try {
                bfr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

接收方：

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

public class UDPReceiver implements Runnable{
    //创建一个socket
    DatagramSocket socket=null;
    //接收方自己所在的端口
    private int fromPort;
    //数据发送者的姓名
    private String msgFrom;

    public UDPReceiver(int fromPort,String msgFrom) {
        this.fromPort = fromPort;
        this.msgFrom=msgFrom;
        try {
            socket=new DatagramSocket(fromPort);//创建一个socket
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true){//循环接收
            try {
                byte[] buffer = new byte[1024 * 8];
                DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
                socket.receive(packet);
                String msg = new String(packet.getData(), 0, packet.getLength());
                System.out.println(msgFrom+":"+msg);
                if (msg.equals("拜拜")){//如果接收到的数据为拜拜，则退出接收
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //释放资源
        socket.close();
    }
}

学生
public class Student {
    public static void main(String[] args) {
        new Thread(new UDPSender("127.0.0.1",8888)).start();
        new Thread(new UDPReceiver(7777,"老师")).start();
    }
}
老师
public class Teacher {
    public static void main(String[] args) {
        new Thread(new UDPSender("127.0.0.1",7777)).start();
        new Thread(new UDPReceiver(8888,"学生")).start();
    }
}

URL

统一资源定位符：定位资源的，定位互联网上的某一个资源。
DNS域名解析 www.baidu.com xxx.x.xx.xx
域名只是为了好记忆。映射成ip地址。
协议：//ip地址：端口/项目名/资源
<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

1. 构造方法摘要
   URL(String spec)根据 String 表示形式创建 URL 对象。
   URL(String protocol, String host, int port, String file) 根据指定协议名、主机名、端口号和文件名创建 URL 对象。
   URL(String protocol, String host, String file) 根据指定的协议名、主机名和文件名创建 URL。

常用方法摘要

String getProtocol()获取此 URL的协议名称。
String getHost() 获取此 URL 的主机名。
int getPort() 获取此 URL 的端口号。
String getPath() 获取此 URL 的文件路径。
String getFile()获取此 URL 的文件名。
String getQuery()获取此 URL的查询部分。
URLConnection openConnection() 返回一个URLConnection实例，表示与URL引用的远程对象的URL 。

URLConnection类中又有一个方法：
InputStream getInputStream() 返回从此打开的连接读取的输入流。

import java.net.MalformedURLException;
import java.net.URL;

public class Test {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/index.jsp?username=Tom&password=123456");
        System.out.println(url.getProtocol());//获取协议名
        System.out.println(url.getHost());//获取主机名
        System.out.println(url.getPort());//获取端口号
        System.out.println(url.getPath());//获取文件路径
        System.out.println(url.getFile());//获取文件名
        System.out.println(url.getQuery());//获取查询名
    }
}

网络下载

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class Test {
    public static void main(String[] args) throws IOException {
        //下载地址
        URL url = new URL("https://img.t.sinajs.cn/t6/style/images/global_nav/WB_logo.png?id=1404211047727");
        //连接到这个资源 HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        InputStream is = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("weibo.jpg");
        byte[] buffer = new byte[1024];
        int len=0;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        //释放资源
        urlConnection.disconnect();//断开连接
        is.close();
        fos.close();
    }
}