[网络协议]网络编程基本

一，IP（简单了解）

电脑--->IP

软件--->端口

资源--->URL

* IP:定位（计算机，路由器，通讯设备）的一个节点
* InetAdress:
* 1.getLocalHost:本机
* 2.getByName:根据域名DNS或IP地址得到IP
*
* 两个成员方法：
* 1.getHostAdress:返回地址
* 2.getHostName；返回计算机名

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

/**
 * IP:定位（计算机，路由器，通讯设备）的一个节点
 * InetAdress:
 * 1.getLocalHost:本机
 * 2.getByName:根据域名DNS或IP地址得到IP
 *
 * 两个成员方法：
 * 1.getHostAdress:返回地址
 * 2.getHostName；返回计算机名
 */
public class IPTest {
    public static void main(String[] args) throws UnknownHostException {
        //使用getLocalHost方法创建InetAddress对象
        InetAddress addr=InetAddress.getLocalHost();
        System.out.println(addr.getHostAddress());
        System.out.println(addr.getHostName());//输出计算机名
        //根据域名得到InetAddress对象
        addr=InetAddress.getByName("www.163.com");
        System.out.println(addr.getHostAddress());//返回服务器的IP
        System.out.println(addr.getHostName());//
        //根据IP得到InetAddress对象
        addr=InetAddress.getByName("222.243.41.21");
        System.out.println(addr.getHostAddress());//返回IP
        System.out.println(addr.getHostName());//输出IP
    }
}

二，端口

1.查看端口的方法（在cmd中）

*查看所有端口：netstat -ano

*查看指定端口：netstat -ano | findstr "5353"

*查看指定进程：tasklist | findstr "808"

*查看具体程序：使用任务管理器查看PID

2.端口的一些方法

* 端口
* 1.不同的软件有不同的端口，可以用于区分软件
* 2.用两个字节表示 0-65535
* 3.同一个协议端口不能冲突
* 4.定义端口越大越好

* 构造器
* new InetSocketAddress(地址或域名,端口)
* 常用方法
* getAddress()
* getHostName()
* getPort()

import java.net.InetSocketAddress;

/**
 * 端口
 * 1.不同的软件有不同的端口，可以用于区分软件
 * 2.用两个字节表示 0-65535
 * 3.同一个协议端口不能冲突
 * 4.定义端口越大越好
 */

public class PortTest {
    public static void main(String[] args) {
        InetSocketAddress socketAddress=new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress1=new InetSocketAddress("localhost",9000);
        System.out.println(socketAddress.getHostName());
        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress1.getAddress());
        System.out.println(socketAddress1.getPort());
        System.out.println(socketAddress.getPort());
    }
}

三，URL

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

public class URLTest {
    public static void main(String[] args) throws MalformedURLException {
        URL url=new URL("http://www.baidu.com:80/index.html?uname=shsxt&age=18#a");
        //获取四个值
        System.out.println("协议："+url.getProtocol());//http
        System.out.println("域名lip："+url.getHost());//www.baidu.com
        System.out.println("端口："+url.getPort());//80
        System.out.println("请求资源："+url.getFile());// /index.html?uname=shsxt&age=18
        System.out.println("请求资源2："+url.getPath());//   /index.html
        //参数
        System.out.println("参数："+url.getQuery());//uname=shsxt&age=18
        //锚点
        System.out.println("锚点："+url.getRef());//a
    }
}

四，TCP

ServerSocket----->accept

Socket----->accept

用IO流进行连接，更安全，但是效率低

/**
 * 创建服务器流程：
 * 1.指定端口 使用ServerSocket创建服务器
 * 2.阻塞式等待连接 accept
 * 3.操作
 * 4.释放资源
 */
public class Sever {
    public static void main(String[] args) throws Exception {
        System.out.println("-----Server-----");
        //1.指定端口 使用ServerSocket创建服务器
        ServerSocket server = new ServerSocket(8008);
        //2.阻塞式等待连接 accept
        Socket client=server.accept();
        System.out.println("一个客户端建立了连接");
        //操作
        DataInputStream dis=new DataInputStream(client.getInputStream());
        String str=dis.readUTF();
        String[] strings=str.split("&");
        for(String info:strings){
            String[] str2=info.split("=");
            if(str2[0].equals("cli")){
                System.out.println("账号："+str2[1]);
            }else if(str2[0].equals("pad")){
                System.out.println("密码："+str2[1]);
            }
        }
        //释放
        dis.close();
        client.close();
    }
}

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.Socket;

/**
 * 基本步骤
 * 1.建立连接：使用Socket创建客户端+服务期地址和端口
 * 2.操作
 * 3.释放
 */
public class Client {
    public static void main(String[] args) throws Exception{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入账号：");
        String cli=br.readLine();
        System.out.println("请输入密码：");
        String pad=br.readLine();
        //1.建立连接：使用Socket创建客户端+服务期地址和端口
        Socket client=new Socket("localhost",8008);
        //2.操作
        DataOutputStream dos=new DataOutputStream(client.getOutputStream());
        dos.writeUTF("cli="+cli+"&"+"pad="+pad);
        dos.flush();
        //释放
        dos.close();
        client.close();
    }
}

五，UDP

DatagramSocket

DatagramPacket? ? ? ? ? ?send和receive

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

/**
 * 发送端
 * 1.使用DatagramSocket 指定端口 创建发送端
 * 2.准备数据（一定要转成字节数组）
 * 3.封装成DatagramPacket包裹，指定目的地
 * 4.发送包裹send（DatagramPacket p）
 * 5.释放资源
 */
public class UdpTest01 {
    public static void main(String[] args) throws Exception{
        System.out.println("发送方启动中...");
        // 1.使用DatagramSocket 指定端口 创建发送端
        DatagramSocket client=new DatagramSocket(8888);
        // 2.准备数据（一定要转成字节数组）
        String data="我想放假！！！";
        byte[] datas=data.getBytes();
        // 3.封装成DatagramPacket包裹，指定目的地
        DatagramPacket packet=new DatagramPacket(datas,0,datas.length,
                new InetSocketAddress("localhost",9999));
        //4.发送包裹send（DatagramPacket p）
        client.send(packet);
        //5.释放资源
        client.close();
    }
}

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

/**
 * 接收端
 * 1.使用DatagramSocket 指定端口 创建接收端
 * 2.准备容器 封装成DatagramPacket包裹
 * 3.阻塞接收包裹receive（DatagramPacket p）
 * 4.分析数据
 * byte[] getData();
 *        getlength();
 * 5.释放资源
 */
public class UpdTest02 {

    public static void main(String[] args) throws Exception{
        System.out.println("接收方启动中...");
        //1.使用DatagramSocket 指定端口 创建接收端
        DatagramSocket serve=new DatagramSocket(9999);
        //2.准备容器 封装成DatagramPacket包裹
        byte[] container=new byte[1024*60];
        DatagramPacket packet=new DatagramPacket(container,0,container.length);
        // 3.阻塞接收包裹receive（DatagramPacket p）
        serve.receive(packet);//阻塞式
        // 4.分析数据
        //byte[] getData();
        //getlength();
        byte[] datas=packet.getData();
        int len=packet.getLength();
        System.out.println(new String(datas,0,len));
        // 5.释放资源
        serve.close();
    }
}

六，综合应用

手写聊天室（可群发，可私聊）

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

/**
 * 使用多线程封装发送端
 */
public class OopSent implements Runnable{
    private BufferedReader br;
    private DataOutputStream dos;
    private Socket client;
    private boolean flag=true;
    private String cli;
    private String name;
    public OopSent(Socket client,String name){
        this.client=client;
        this.name=name;
        br=new BufferedReader(new InputStreamReader(System.in));
        try {
            dos=new DataOutputStream(client.getOutputStream());
            sent(name);
        } catch (IOException e) {
            this.reslse();
        }
    }
    public String getstr(){
        try {
            cli=br.readLine();
        } catch (IOException e) {
            reslse();
        }
        return cli;
    }
    //发送
    public void sent(String cli) {
        try {
            dos.writeUTF(cli);
            dos.flush();

        } catch (IOException e) {
            reslse();
        }
    }
    public void run() {
        while(flag){
            String cli=getstr();
            if(!cli.equals("")) {
                sent(cli);
            }
        }
    }
    //释放
    private void reslse() {
        this.flag = false;
        Util.close(dos, client);
    }
}

import loc.UdpReceive;

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

public class QClient {
    public static void main(String[] args) throws Exception{
        System.out.println("----client----");
        Socket client=new Socket("localhost",9001);
        System.out.println("请输入名称：");
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String name=br.readLine();
        new Thread(new OopSent(client,name)).start();
        new Thread(new OopRerver(client,name)).start();
    }
}

import java.io.Closeable;
import java.io.IOException;
import java.util.Arrays;

/**
 * 工具类
 * 释放资源
 */
public class Util {
    public static void close(Closeable... targets){
        for(Closeable target:targets){
            if(target!=null){
                try {
                    target.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class OopRerver implements Runnable{
    private DataInputStream dis;
    private Socket client;
    private boolean flag=true;
    private String cli;
    private String name;
    public OopRerver(Socket client,String name){
        this.client=client;
        this.name=name;
        try {
            dis=new DataInputStream(client.getInputStream());
        } catch (IOException e) {
            this.reslse();
        }
    }
    //接收
    public String rerver(){

        try {
            cli=dis.readUTF();
        } catch (IOException e) {
            reslse();
        }
        return cli;
    }
    public void run() {
        while(flag){
            cli=rerver();
            if(!cli.equals("")){
                System.out.println(cli);
            }
        }
    }
    //释放
    private void reslse() {
        this.flag = false;
        Util.close(dis,client);
    }
}

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

/**
 * 使用多线程封装发送端
 */
public class OopSent implements Runnable{
    private BufferedReader br;
    private DataOutputStream dos;
    private Socket client;
    private boolean flag=true;
    private String cli;
    private String name;
    public OopSent(Socket client,String name){
        this.client=client;
        this.name=name;
        br=new BufferedReader(new InputStreamReader(System.in));
        try {
            dos=new DataOutputStream(client.getOutputStream());
            sent(name);
        } catch (IOException e) {
            this.reslse();
        }
    }
    public String getstr(){
        try {
            cli=br.readLine();
        } catch (IOException e) {
            reslse();
        }
        return cli;
    }
    //发送
    public void sent(String cli) {
        try {
            dos.writeUTF(cli);
            dos.flush();

        } catch (IOException e) {
            reslse();
        }
    }
    public void run() {
        while(flag){
            String cli=getstr();
            if(!cli.equals("")) {
                sent(cli);
            }
        }
    }
    //释放
    private void reslse() {
        this.flag = false;
        Util.close(dos, client);
    }
}