网络编程_概念_网络_端口_URL_TCP_UDP

最新推荐文章于 2023-11-22 17:16:04 发布

基金爱好者

最新推荐文章于 2023-11-22 17:16:04 发布

阅读量189

点赞数

本文链接：https://blog.csdn.net/qq_39588027/article/details/80245799

版权

一. 网络：将不同的区域的计算机连接到一起（局域网城域网互联网）

二. 地址：IP地址确定网络上一个绝对地址 | 位置 —->房子的地址

三. 端口号：区分计算机软件的 ->房子的房门 2个字节 0-65535 共65536个

1.在同一协议下端口号不能重复不同协议下可以重复
2.1024以下的端口号不要使用 80->http 21->ftp

四. 资源定位：URL —>统一资源定位符 URI —>统一资源

五. 数据的传输：

1.协议：TCP和UDP协议
TCP(transfer control protocal）：电话类似于三次握手面向连接安全可靠效率低下
UDP（UserDatagramProtocal）：短信非面向连接效率高
2.传输：
先封装
后拆封

类

InetAddress + InetSocketAddress

 一：
 1.InetAddress封装计算机的ip地址和DNS，没有端口。
 //  静态方法获取对象
 InetAddress.getLocalHost();
 InetAddress.getByName("www.baidu.com");
 InetAddress.getByName("223.87.1.58");
 //方法
 getHostAddress() 返回ip地址
 getHostName() 返回域名|本机为计算机名


 2.
package theChildOfGod.Net.IP;
/**
 * 没有封装端口
 */
import java.net.InetAddress;
import java.net.UnknownHostException;

public class Inet {

    public static void main(String[] args) {
        //使用getLocalHost方法创建InetAddress对象
        InetAddress addr = null;
        try {
            addr = addr.getLocalHost();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        System.out.println(addr.getHostAddress());
        //输出计算机名
        System.out.println(addr.getHostName()); 


        //根据域名得到InetAddress对象
        InetAddress addr1 = null;
        try {
            addr1 = addr1.getByName("www.baidu.com");
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        //返回baidu服务器的ip地址
        System.out.println(addr1.getHostAddress());


        //根据ip地址得到InetAddress对象
        InetAddress addr2 = null;
        try {
            addr2 = addr2.getByName("111.13.100.91");
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        //返回baidu服务器的ip地址
        System.out.println(addr2.getHostAddress());
        //输出ip而不是域名，如果这个IP地址不存在或DNS服务器不允许进行IP地址和域名的映射，
        //getHostName方法就直接返回这个IP地址
        System.out.println(addr2.getHostName());

    }
}

二：
1.InetSocketAddress
package theChildOfGod.Net.IP;

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

/**
 * 封装端口：在InetAddress基础上+端口
 *
 */
public class InetSocketDemo {

    public static void main(String[] args) throws UnknownHostException {
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 9999);
//      address = new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 9999);

        System.out.println(address.getHostName());
        System.out.println(address.getPort());
        System.out.println(address.getAddress());

        InetAddress addr = address.getAddress();
        System.out.println(addr.getHostAddress()); 
        System.out.println(addr.getHostName());

    }
}

URL
TCP:ServerSocket + Socket

package theChildOfGod.Net.TCP.Socket;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 1.创建客户端，必须指定服务器器+端口 此时就在连接  Socket(String host, int port)
 * 
 * 
 */
public class MyClient {

    public static void main(String[] args) throws UnknownHostException, IOException {
        //创建客户端 必须指定服务器+端口， 此时就在连接
        Socket client = new Socket("localhost", 8888);
        //接受数据

        /*BufferedReader br = new BufferedReader(
                new InputStreamReader(client.getInputStream()));

        String echo = br.readLine();//阻塞式方法
        System.out.println(echo);
        */
        DataInputStream dis = new DataInputStream(client.getInputStream());
        String echo = dis.readUTF();
        System.out.println(echo);
    }
}





package theChildOfGod.Net.TCP.Socket;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {

    public static void main(String[] args) throws IOException {
        //1.创建服务器 指定端口 ServerSocket(int port)
        ServerSocket server = new ServerSocket(8888);
        //2.接受客户端连接  阻塞式
        Socket socket = server.accept();
        System.out.println("+++++一个客户端建立连接++++");
        //3.发送数据
        String s = "欢迎使用";
        //输出流    

        /*BufferedWriter bw = new BufferedWriter(
                new OutputStreamWriter(socket.getOutaputStream()));

        bw.write(s);
        bw.newLine();
        bw.flush();
        */
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeUTF(s);
        dos.flush();
    }
}

UDP:DatagramSocket + DatagramPacket

package theChildOfGod.Net.UDP;
/**
 * 1.创建客户端+端口
 * 2.准备数据
 * 3.打包（发送的地点及端口）DatagramPacket(byte[] buf, int length, InetAddress, int Port)
 * 4.发送
 * 5.释放
 */
import java.io.IOException;
import java.net.DatagramPacket;
/**
 * 客户端
 * 1.创建客户端+端口
 * 2.准备数据
 * 3.打包（发送地点及端口）
 * 4.发送
 * 5.释放
 */
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class MyClient {

    public static void main(String[] args) throws IOException {
        //1.创建客户端+端口
        DatagramSocket client = new DatagramSocket(6666);
        //2.准备数据
        String s = "你收到我信息了吗？王娜！";
        byte [] data = s.getBytes();
        //3.打包（发送的地点及端口）DatagramPacket(byte[] buf, int length, InetAddress, int Port)
        DatagramPacket packet = new DatagramPacket(data, data.length, new InetSocketAddress("localhost", 8888));
        //4.发送
        client.send(packet);
        //5.释放
        client.close();
    }

}




package theChildOfGod.Net.UDP;

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

/**
 * 服务端
 * 1.创建服务器端+端口
 * 2.准备接受容器
 * 3.封装成包
 * 4.接受数据
 * 5.分析数据
 * 6.释放
 */
public class MyServer {

    public static void main(String[] args) throws IOException {
        //1.创建服务器端+端口
        DatagramSocket server = new DatagramSocket(8888);
        //2.准备接受容器
        byte [] container = new byte[1024];
        //3.封装成包DatagramSocket(byte[] buf, int length)
        DatagramPacket packet = new DatagramPacket(container, container.length);
        //4.接受数据
        server.receive(packet);
        //5.分析数据
        byte [] data = packet.getData();
        int len = packet.getLength();
        System.out.println(new String(data, 0, len));
        //6.释放
        server.close();
    }
}

package theChildOfGod.Net.UDP;
/**
 * 1.创建客户端+端口
 * 2.准备数据
 * 3.打包（发送的地点及端口）DatagramPacket(byte[] buf, int length, InetAddress, int Port)
 * 4.发送
 * 5.释放
 */
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
/**
 * 客户端
 * 1.创建客户端+端口
 * 2.准备数据  double -->字节数组
 * 3.打包（发送地点及端口）
 * 4.发送
 * 5.释放
 */
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

public class Client {

    public static void main(String[] args) throws IOException {
        //1.创建客户端+端口
        DatagramSocket client = new DatagramSocket(6666);
        //2.准备数据
        double num = 89.12;
        byte [] data = convert(num);
        //3.打包（发送的地点及端口）DatagramPacket(byte[] buf, int length, InetAddress, int Port)
        DatagramPacket packet = new DatagramPacket(data, data.length, new InetSocketAddress("localhost", 8888));
        //4.发送
        client.send(packet);
        //5.释放
        client.close();   
    }

    /**
     * 字节数组 数据源 +Data输出流
     * @param num
     * @return
     * @throws IOException 
     * @throws IOExpection
     */
    public static byte[] convert(double num) throws IOException {
        byte [] data = null;
        ByteArrayOutputStream  bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);
        dos.writeDouble(num);
        dos.flush();

        //获取数据
        data = bos.toByteArray();
        dos.close();

        return data;
    }
}



package theChildOfGod.Net.UDP;

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


/**
 * 服务端
 * 1.创建服务器端+端口
 * 2.准备接受容器
 * 3.封装成包
 * 4.接受数据
 * 5.分析数据  字节数组--->double
 * 6.释放
 *
 */
public class Server {

    public static void main(String[] args) throws IOException {
        //1.创建服务器端+端口
        DatagramSocket server = new DatagramSocket(8888);
        //2.准备接受容器
        byte [] container = new byte[1024];
        //3.封装成包DatagramSocket(byte[] buf, int length)
        DatagramPacket packet = new DatagramPacket(container, container.length);
        //4.接受数据
        server.receive(packet);
        //5.分析数据
        double data = convert(packet.getData());
        System.out.println(data);
        //6.释放
        server.close();
    }

    /**
     * 字节数组+Data 输入流
     * @param data
     * @return
     * @throws IOException 
     */
    public static double convert(byte[] data) throws IOException {
        DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data));
        double num = dis.readDouble();
        dis.close();
        return num;
    }
}