网络编程

#UDP

* UDP是一种不可靠传输，它原理是将信息打包路由向指定IP地址，如果包被拦截也不会报异常，但是其省资源，大多数游戏都使用UDP

```java

//发送端

DatagramSocket ds = new DatagramSocket();  //创建一个发送端
String s = "你好"; //创建发送信息
byte[] b = s.getBytes();  //将字符串转换成字节
DatagramPacket dp = new DatagramPacket(b,b.length,InetAddress.getByName("127.0.0.1"),8888); //将发送信息打包，需要四个参，信息字节数组、字节长度、主机地址、设置端口号
ds.send(dp); //开始发送
ds.close();  //关流
//接收端
DatagramSocket ds = new DatagramSocket(8888); //创建一个接收端，接收指定端口号包，接收端要比发送端先打开等待包
byte[] b = new byte[1024]; //创建一个字节数组，预设大小
DatagramPacket dp = new DatagramPacket(b, b.length); //创建一个包
ds.receive(dp); //接收数据
String s = new String(dp.getData(),0,dp.getLength()); //将字节信息转换成字符串，dp.getLength()表示字符长度，不是字节长度
System.out.println(s);
ds.close(); //关流

```

#不停的发送与接收

```java

 //不停的发送

DatagramSocket ds = new DatagramSocket(); //创建一个发送端
while (true){  //不停的发送
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//创建一个标准输入流
    String s = br.readLine();  //接收输入信息
    if ("quit".equals(s)){  //判断，若输入quit就退出

        break;
    }
    byte[] b = s.getBytes();
    DatagramPacket dp = new DatagramPacket(b,b.length,InetAddress.getByName("127.0.0.1"),7777);
//打包
    ds.send(dp);
}
ds.close();
 //不停的接收

DatagramSocket ds = new DatagramSocket(7777); //创建一个接收端
while(true){ //不停的接收
    byte[] b = new byte[1024];
    DatagramPacket dp = new DatagramPacket(b, b.length);
    ds.receive(dp);
    String s = new String(dp.getData(),0,dp.getLength());
    System.out.println(s);
}

```

#TCP：可靠传输，它会在传输之前，让服务端与客户端建立连接，因此不会存在丢包，但是每个客户端都会创建一个连接会很耗资源

```java

public class NetDemo5 {
    public static void main(String[] args) {
        new Thread(new Send()).start();
        new Thread(new Receive()).start();
    }
}
class Send implements Runnable{
    public void run(){
         try
{
            System.out.println("客户端：");

            Socket
s = new Socket("127.0.0.1",8888);  //创建客户端
            OutputStream os
= s.getOutputStream();   //创建输出流
            os.write("我是客户端".getBytes());
  //向服务端发送消息
            InputStream is =
s.getInputStream();
            byte[] b = new byte[1024];
            int i = is.read(b);
            System.out.println(new
String(b,0,i));
            System.out.println("客户端结束");
            s.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Receive implements Runnable{
    public void
11f30
run(){
        try {
            System.out.println("服务端：");
            ServerSocket ss
= new ServerSocket(8888);//创建服务端
            Socket s = ss.accept();
   //获取客户端对象
            InputStream is =
s.getInputStream();
            byte[] b = new byte[1024];
            int i = is.read(b);
            System.out.println(new
String(b,0,i));
            OutputStream os
= s.getOutputStream();
            os.write("我是服务端".getBytes());
            System.out.println("服务端结束");
            ss.close();
            } catch (Exception
e) {
                e.printStackTrace();
            }
        }
    }

}

```
#上传
* 上传与下载原理都相同，只是输入输出相反了
```java

//创建一个客户端类
class Client{
    public void client() throws UnknownHostException, IOException{
        Socket s = null;
        OutputStream os = null;
        InputStream is = null;
        s = new Socket("127.0.0.1", 9999); //创建一个客户端，并指定服务端地址和端口
        System.out.println("我是客户端：");
        is = new FileInputStream("e:"+File.separator+"test"+File.separator+"金牛.jpg");  //创建一个输入流，读取指定文件数据
        os = s.getOutputStream();  //向服务端传输数据
        byte[] b = new byte[1024*1024];
        int len = 0;
        while ((len=is.read(b))!=-1){ //开始读取数据
            os.write(b,0,len); //开始传输
        }
        System.out.println("上传完成");
        s.close();  //关流
        is.close(); //关流
    }
} 

//创建一个服务端类
class Sever{
    public void sever() throws IOException{
        System.out.println("我是服务端：");
        ServerSocket ss = null;
        OutputStream os = null;
        InputStream is = null;
        Socket s = null;
        ss = new ServerSocket(9999);  //服务端接收端口
        s = ss.accept();  //等待客户端的请求
        os = new FileOutputStream("d:"+File.separator+"test"+File.separator+"金牛.jpg"); //创建一个输出流，将接收文件输出到指定文件
        is = s.getInputStream();   //接收数据
        byte[] b = new byte[1024*1024]; //缓冲区
        int len = 0; //保存字节长度
        while ((len=is.read(b))!=-1){ //开始读取数据
            os.write(b,0,len);   //开始输出到指定文件
        }
        System.out.println("上传完成");
        ss.close(); //关流
        os.close();    //关流
    }
}  

``` 

    在输出到指定文件时，一定要给保存数据的文件（不能只给个文件夹路径）

#多用户上传
* 重点：将服务端写进线程，每个用户上传信息时就开辟一个线程
```java
//客户端

public class NetClient {
    public static void main(String[] args) {
        new Thread(new NetCli()).start();
    }
}
class NetCli implements Runnable{
    public void run() {
        Socket s = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            s = new Socket("127.0.0.1",10086);
            is = new FileInputStream("e:"+File.separator+"test"+File.separator+"金牛.jpg");
            byte[] b = new byte[1024*1024];
            os = s.getOutputStream();
            int len = 0;
            while ((len=is.read(b)) != -1){
                os.write(b,0,len);
            }
            System.out.println("开始上传");
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
            try {
                is.close();
                s.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}  

//服务端

public class NetServer {
    public static void main(String[] args) {
        try {
            ServerSocket ss = new ServerSocket(10086);
            while(true){
                Socket s = ss.accept(); 
                new Thread(new NetSer(s)).start(); //每个客户都给创建一个线程
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
class NetSer implements Runnable{
    private Socket s;
    private static int i = 0;
    public NetSer() {
    }
    public NetSer(Socket s) throws IOException {
        this.s = s;
    }
    public void run(){
        InputStream is = null;
        OutputStream os = null;
        try {
                is = s.getInputStream(); //接收客户端数据
                byte[] b = new byte[1024*1024];
                int len = 0;
                os = new FileOutputStream("e:"+File.separator+"test"+File.separator+(++i)+".jpg");
                while ((len=is.read(b)) != -1)
                    os.write(b,0,len);
                System.out.println("上传完成！");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                os.close();
                s.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

```

    网络编程的核心就在于明白其上传与下载原理