Java网络编程05(TCP和UDP)

发表于   |  

UDP使用的是 DatagramSocket对象 和 DatagramPacket 对象

UdpDemo.java ：client(客户端)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
 需求：通过udp传输方式，将一段数据发送出去.
 思路：
 1、建立udpsocket服务
 2、提供数据，并将数据封装到数据包中
 3、通过socket服务的发送功能，将数据包发出去
 4、关闭资源
*/
import java.net.*;
class   UdpSend
{
    public static void main(String[] args) throws Exception
    {
        //1.创建udp服务，通过DatagramSocket对象
        DatagramSocket ds = new DatagramSocket(8888);//用8888端口发送
        //2.确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress, int port)
        byte[] buf = "udp ge men lai le".getBytes();
        DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);
        //3.通过socket服务奖数据包发送出去，通过send方法
        ds.send(dp);
        4.关闭资源
        ds.close();
    }
}

服务器 (server)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
需求：定义一个应用程序，用于接受upd传输的数据并处理
1.定义udp socket服务：通常会监听一个端口，其实就是给这个接受网络应用程序定义数字标识，
方便于明确哪些数据过来该应用程序可以处理。
2.定义一个数据包，因为要存储接收到的字节数据，
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息.
3.通过socket服务的receive方法将受到的数据存入已定义的数据包中。
4.通过数据包对象的特有功能，将这些不同数据取出，打印在控制台上，
5.关闭资源
*/
import java.net.*;
class UdpRec
{
    public static void main(String[] args) throws Exception
    {
        //1.创建udp socket 服务
        DatagramSocket ds = new DatagramSocket(10000);
        //2.定义数据包，用于存储数据.
        byte[] buf = new byte[1024];
        DatagramPacket dp = new DatagramPacket(buf,buf.length);
        //3.通过服务的receive方法将收到的数据存入数据包中.
        ds.receive(dp); //阻塞式方法 
        //4.通过数据包的方法获取其中的数据.
        String ip = dp.getAddress().getHostAddress();
        String data = new String(dp.getData(),0,dp.getLength());
        int port = dp.getPort();
        
        System.out.println(ip + "::" + data + "::" + port);
        //5.关闭资源.
        ds.close();
    }
}

UDP发送端：键盘录入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.net.*;
import java.io.*;
class   UdpSend2
{
    public static void main(String[] args) throws Exception
    {
        DatagramSocket ds = new DatagramSocket();
        BufferedReader bufr = 
            new BufferedReader(new InputStreamReader(System.in));
        String line = null;
        while(line=bufr.readLine() != null)
        {
            if("886".equals(line))
                break;
                
            byte[] buf = line.getBytes();
            
            DatagramPacket dp = 
                new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254",10001));
                
            ds.send(dp);
        }
        ds.close();
    }
}

接收端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.net.*;
class UdpRec2
{
    public static void main(String[] args) throws Exception
    {
        DatagramSocket ds = new DatagramSocket(10001);
        while(trew)
        {
            byte[] buf = new byte[1024];
            DatagramPacket dp = new DatagramPacket(buf,buf.length);
            ds.receive(dp);
            String ip = dp.getAddress().getHostAddress();
            String data = new String(dp.getData(),0,dp.getLength());
            int port = dp.getPort();
            
            System.out.println(ip + "::" + data + "::" + port);
        }
       // 一般都不关的ds.close(); 
    }
}

UDP聊天

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/*
 编写一个聊天程序：ChatDemo.java
 有收数据的部分，和发数据的部分。
 这两部分需要同时执行，那就需要用到多线程技术
 一个线程控制收，一个线程控制发
 
 因为收和发动作是不一致的，所以要定义两个run方法.
 而且这两个方法要封装到不同的类中.
*/
import java.net.*;
import java.io.*;
class Send implements Runnable
{
    public DatagramSocket ds;
    private Send(DatagramSocket ds)
    {
        this.ds = ds;
    }
    public void run()
    {
        try
        {
            BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
            String line = null;
            while((line=bufr.readLine()) != null)
            {
                if("886".equals(line))
                    break;
                byte[] buf = line.getBytes();
                DatagramPacket dp = new DatagramPacket(buf,buf.length;InetAddress.getByName("192.168.1-254"),10002);
                ds.send(dp);
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException("发送端失败！");
        }
    }
}
/*接收端*/
class Rece implements Runnable
{
    public DatagramSocket ds;
    private Rece(DatagramSocket ds)
    {
        this.ds = ds;
    }
    public void run()
    {
        try
        {
            while(true)
            {
                byte[] buf = new byte[1024];
                DatagramPacket dp = new DatagramPacket(buf,buf.length);
                ds.receive(dp);
                
                String ip = dp.getAddress().getHostAddress();
                String data = new String(dp.getData(),0,dp.getLength());
                int port = dp.getPort();
                
                System.out.println(ip + ":" + data + ":" + port);
            }
        }
        catch (Exception e)
                {
                    throw new RuntimeException("接收端失败！");
                }
    }
}
class ChatDemo 
{
    public static void main(String[] args) throws Exception
    {
        DatagramSocket sendSocket = new DatagramSocket();
        DatagramSocket receSocket = new DatagramSocket(10002);
        
        new Thread(new Send(sendSocket)).start();
        new Thread(new Rece(receSocket)).start();
    }
}

TCP使用的是 Socket 和 ServerSocket

TCP 传输：使用的是 Socket 和ServerSocket

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/*
演示tcp传输
1.tcp分客户端和服务端
2.客户端对应的对象是socket
    服务端对应的对象是ServerSocket
*/
/*
客户端：
通过查阅socket对象，发现在该对象建立时，就可以去连接制定主机，
因为tcp是面向连接的，所以在建立socket服务时，
就要有服务端存在，并连接成功，形成通路后，在该通道进行数据传输
步骤：
1.创建Socket服务，并制定要连接的主机和端口
*/
import java.io.*;
import java.net.*;
class TcpClient
{
    public static void main(String[] args) throws Exception
    {
        //创建客户端的socket服务(包含输入流和输出流)，指定目的主机和端口
        Socket s = new Socket("192.168.1.254",10003);
        //为了发送数据，应该获取socket流中的输出流
        OutputStream out = s.getOutputStream();
        out.write("tcp ge men lai le".getBytes());
        s.close();
    }
}
/*
需求：定义断电接受数据并打印在控制台上
服务端：
1.建立服务端的socket服务，ServerSocket();
    并监听一个端口；
2.获取连接过来的客户端对象
    通过ServerSocket的accept方法。没有连接就会等，所以这个方法是阻塞式的
3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据，
    并打印在控制台
4.关闭服务端。（可选）
*/
class TcpServer
{
    puyblic static void main(String[] args)
    {
        //建立服务端的socket服务，并监听一个端口
        ServerSocket ss = new ServerSocket(10003);
        //通过accept方法获取连接过来的客户端对象。
        Socket s = ss.accept();
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip + "......connected");
        //获取客户端发送过来的数据，那么要使用客户端对象的读取流方法来读取数据
        InputStream in = s.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        
        System.out.println(new String(buf,0,len));
        
        s.close();//关闭客户端
        ss.close();//可选
    }
}

演示tcp的传输客户端和服务端的互访

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/*
需求：客户端给服务端发送数据，服务端收到后，给客户端发送信息
*/
/*
客户端：
1.建立socket服务，指定要连接的主机和端口
2.获取socket流中的输出流，将数据谢到该流中。通过网络发送给服务端.
3.获取socket流中的输入流，将服务端反馈的数据获取到并打印。
4.关闭客户端资源
*/
class TcpClient2
{
    public static void main(String[] args) throws Exception
    {
        Socket s = new Socket("192.168.1.254",10004);
        OutputString out = s.getOutputStream();
        out.write("服务端：你好".getBytes());
        
        InputStream in = s.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        System.out.println(new String(buf,0,len));
        s.close();
    }
}
/*服务端*/
class TcpServer2
{
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(10004);
        Socket s = ss.accept();
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip+"......connected");
        
        InputSream in = s.getInputStream();
        byte[] buf = new bute[1024];
        int len = in.read(buf);
        
        System.out.println(new String(buf,0,len));
        
        OutputSream out = s.getOutputSream();
        out.write("哥们收到".getBytes());
        s.close();
        ss.close();
    }
}

TCP练习：文本转换服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
/*
需求：建立一个文本转换服务器
客户端给服务端发送文本，服务端将文本转换成大写再返回给客户端
而且客户端可以不断的进行文本转换，当客户端输入over时，转换结束
分析：
客户端：
既然是操作设备上数据，那么就可以使用io的操作规律来思考
源：键盘录入
目的：网络设备，网络输出流
而且操作的是文本数据，可以选择字符流。
步骤：
1.建立服务
2.获取键盘录入
3.将数据发送给服务端
4.获取服务端返回的大写数据。
5.结束，关资源
都是文本数据，可以使用字符流进行操作，同时为了提高效率，加入缓冲
*/
import java.io.*;
import java.net.*;
class TransClient
{
    public static void main(String[] args) throws Exception
    {
        Socket s = new Socket("192.168.1.254",10005);
        
        //定义读取键盘数据的流对象
        BufferedReader bufr =
            new BufferedReader(new InputStreamReader(System.in));
            
         //定义目的，将数据写入到socket输出流，发给服务端
         //BufferedWriter bufOut =
            //new BufferedWriter(new OutputSteamWriter(s.getOutputStream()));
         PrintWriter out = PrinterWriter(s.getOutputStream());
         
         //定义一个socket读取流，读取服务端返回的大写信息
         //BufferedReader bufIn = 
            //new BufferedReader(new InputSteamReader(s.getInputStream()));
         
         String len = null;
         while((line=bufr.readLine()) != null)
         {
            bufOut.write(line);
            if("over".equals(line))
                break;
                
            //bufOut.writer(line);
            //bufOut.newLine();//注意①
            //bufOut.flush();  //注意①
            out.println(line);
            String str = bufIn.readLine();
            System.out.println("server:" + str);
         }
         bufr.close();
         s.close();
    }
}
/*
服务端：
源：socket读取流
目的：socket输出流
都是文本，装饰
*/
class TransServer
{
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(10005);
        Socket s = ss.accept();
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip + ".....connetced");
        
        //读取socket读取流中的数据
        BufferedReader bufIn = 
            BufferedReader(new InputSteamReader(s.getInputStream()));
            
         //目的: socket输出流，将大写数据写入到socket输出流，并发送给客户端
         //BufferedWriter bufOut = 
            //BufferedWriter(new OutputStreamWriter(s.getOutputSream()));
         //PrintWriter里既可以接输入流，也可以接输出流，还带换行和自动刷新,true对println是有效的刷新
         PrintWriter out = new PrintWriter(s.getOutputSream(),true);
         
         String line = null;
         while((line=bufIn.readLine()) != null)
         {
            System.out.println(line);
            //bufOut.write(line.toUpperCase());
            //bufOut.newLine();//注意①
            //bufOut.flush(); //注意①
            out.println(line.toUperCase());
         }
         s.close();
         ss.close();
    }
}
/*
该例子出现的问题：
现象：客户端和服务端都在莫名的等待这是为什么呢？
因为客户端和服务端都有阻塞式的方法，这些方法没有读到结束标记就会一直等，
而导致两端，都在等待.
*/

TCP 复制文件