Java笔记6 网络编程<1>Socket、UDP

23天-01-网络编程(概述)

l  网络编程

Ø  网络模型

Ÿ   OSI参考模型。

Ÿ   TCP/IP参考模型

Ø  网络通信要素

Ÿ   IP地址

Ÿ   端口号

Ÿ   传输协议

l  网络参考模型

l  网络通信的要素

Ø  IP地址

Ÿ   网络中设备标识

Ÿ   不易记忆，可用主机名

Ÿ   本地回环地址：127.0.0.1 主机名：localhost

l  端口号

Ø  用于表示进程的逻辑地址，不同进程的标识

Ø  有效端口：0~65535，其中0~1024系统使用或保留端口。

l  传输协议

Ø  通讯的规则

Ø  常见协议：TCP,UDP

 

 

23天-05-网络编程(TCP和UDP)

l  TCP和UDP

Ø  UDP

Ÿ   间数据及源和目的封装成数据包，不需要建立连接。

Ÿ   每个数据包的大小限制在64kb内。

Ÿ   因无连接，是不可靠协议。

Ÿ   不需要建立连接，速度快。

Ø  TCP

Ÿ   建立连接，形成传输数据的通道。

Ÿ   在连接中进行大量数据传输。

Ÿ   通过是那次握手完成连接。

Ÿ   必须建立连接，效率稍低。

 

 

23天-06-网络编程(Socket)

l  Socket

Ø  Socket就是wie网络服务提供的一种机制。

Ø  通信的两端都有Socket。

Ø  网络通信其实就是Socket间的通信。

Ø  数据在两个Socket间通过IO传输。

 

 

23天-07-网络编程(Udp-发送端)

需求：通过udp传输方式，将一段文字数据发送出去。

思路：

1.      建立udpsocket服务。

2.      提供数据，并将数据封装到数据包中。

3.      通过socket服务的发送功能，将数据包发送出去。

4.      关闭资源。

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

 

public class UdpSend {

 

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

       //1.建立udp服务，通过DatagramSocket对象。

       DatagramSocket ds = new DatagramSocket();

       //2.确定数据，并封装成数据包，DatagramPackage(byte[]buf,int length,InetAddress address,intport)

       //byte[] buf = "udpge menlai l".getBytes();//方式<1>

       //DatagramPacket dp =new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10001);//方式<1>

       /*---方式2：键盘录入发送*/

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

       String line = null;

       while((line=bufr.readLine())!=null){

           if("886".equals(line)){

              break;                  

           }

           byte[] buff = line.getBytes();

           DatagramPacket dp = new DatagramPacket(buff,buff.length,InetAddress.getByName("127.0.0.1"),10001);

           ds.send(dp);

       }

       /*---方式2：键盘录入发送--*/

      

       //3.通过socket服务，将已有的数据阿伯发送出去。通过send方法。

    //  ds.send(dp);//方式<1>

       //4.关闭资源。

       ds.close();

    }

 

}

 

 

23天-08-网络编程(Udp-接收端)

需求：定义一个运用程序，用于接收udp协议传输的数据并处理。

思路：

1.      定义udpsocket服务。通常会见厅一个端口，其实就是给这个接收网络应用程序定义数字标识，方便于明确哪些数据过来应用程序可以处理。

2.      定义一个数据包，因为要储存接收到的字节数据。

3.      通过socket服务的receive方法将接收到的数据存入已定义好的数据包中。

4.      通过数据包的特有功能，将这些不同的数据取出，打印在控制台上。

5.      关闭资源。

import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

 

public class UdpReceive {

 

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

       //1.建立udp socket。建立端点。

       DatagramSocket ds = new DatagramSocket(10001);

       //2.定义数据包，用于存储数据。

       byte[] buf =newbyte[1024];

       DatagramPacket dp = new DatagramPacket(buf, buf.length);

       //3.通过服务的receive方法将收到的数据存入数据包中。

       while(true){

           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);         

       }

    }

}

 

 

23天-10-网络编程(UDP-聊天)

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;

 

class Send implements Runnable {

    private DatagramSocketds;

    public Send(DatagramSocket ds){

       this.ds = ds;

    }

   

    public void run() {

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

       String line = null;

       try {

           while((line=bufr.readLine())!=null){

              if("886".equals(line)){

                  break;

              }

              byte[] buf = line.getBytes();

              DatagramPacket dp = new DatagramPacket(buf, buf.length,InetAddress.getByName("127.0.0.1"),10002);

              ds.send(dp);

           }

       } catch (IOException e) {

           throw new RuntimeException("发送数据失败");

       }     

    }

}

 

class Rece implements Runnable{

    DatagramSocket ds;

    public Rece(DatagramSocket ds){

       this.ds = ds;

    }

 

    @Override

    public void run() {

       try {

           while(true){

              byte[] buf =newbyte[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());

              System.out.println(ip+"::"+data);

           }

       } catch (IOException e) {

           throw new RuntimeException("接收失败");

       }

    }  

}

 

public class ChatSend {

    /**

     * 编写一个聊天程序

     * 有收数据的部分和发数据的部分。

     * 这两部分需要同时进行。

     * 那就需要用到多线程技术。

     * 一个线程控制收，一个线程控制发。

     *

     * 因为收和发动作是不一致的，所以要定义两个run方法。

     * 而且这两个方法要封装到不同的类中。

     */

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

       DatagramSocket sendSocket = new DatagramSocket();

       DatagramSocket receSocket = new DatagramSocket(10002);

      

       new Thread(new Send(sendSocket)).start();

       new Thread(new Rece(receSocket)).start();

    }

}

 

 

23天-11-网络编程(TCP传输)

l  TCP传输

Ø  Socket和ServerSocket

Ø  建立客户端和服务端

Ø  建立连接之后，通过Socket中的IO流进行数据的传输

Ø  关闭Socket。

同样，客户端和服务器端是两个独立的运用程序。

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.UnknownHostException;

 

/**

 * 演示Tcp传输

 *

 *1.tcp分客户端和服务器端。

 * 2.客户端对应的对象时Socket，，服务器端对应的对象时ServerSocket。

 *

 * 客户端：

 * 通过查阅 Socket对象，发现在该对象建立时，就可以去连接指定主机，。

 * 因为tcp是面向连接的，所以在建立Socket服务时，就要有服务器端存在，

 * 并连接成功。形成通路后，在该通道上进行数据的传输。

 *

 * 步骤：

 * 1.穿件Socket服务，并指定要连接的主机和端口。

 *

 * */

 

class TcpClient{

      

       publicstatic void main(String[] args) throws UnknownHostException, IOException{

              //1.创建客户端的socket服务，指定目的主机端口号。

              Sockets = new Socket("127.0.0.1",10003);

              //2.为了发送数据应该获取socket流中的输出流。

              OutputStreamout = s.getOutputStream();

              out.write("tcpge men lai l".getBytes());

              s.close();

       }

      

}

/**

 *需求：定义端点接收数据并打印子啊控制台上。

 *服务端：

 *1.建立服务端的socket服务。serversocket()，并监听一个端口。

 *2.获取连接过来的客户端对象。通过ServerSocket的accept方法。

 *没有连接就会等待，所以这个方法时阻塞制的。

 *3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，

 *并获取该客户端对象的读取刘来读取发送过来的数据。并打印在控制台上。

 *4.关闭服务端。（可选）

 * */

 

class TcpServer{

       publicstatic void main(String[] args) throws IOException{

              //1.建立服务端Socket服务，兵谏亭一个端口。

              ServerSocketss = new ServerSocket(10003);

              //2.通过accept方法获取连接过来的客户端对象。

              Sockets = ss.accept();

             

              Stringip = s.getInetAddress().getHostAddress();

              System.out.println(ip+"...connected");

              //3.获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。

              InputStreamin = s.getInputStream();

             

              byte[]buf= new byte[1024];

              intlen = in.read(buf);

              System.out.println(newString(buf,0,len));

              s.close();

              ss.close();

       }

}

//在DOS命令行中编译完成后，先启动TcpServer，后启动TcpClient，服务器端能

//接收到客户端的数据。

 

 

23天-12-网络编程(TCP传输2)

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

/*

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

 * 需求：客户端给服务端发送数据，服务端接收后，给客户端反馈信息。

 *

 * 客户端：

 * 1.建立Socket服务，指定要连接的主机和端口。

 * 2.获取socket流中的输出流，将数据写入到该流中，通过网络发送给服务端。

 * 3.获取socket流中的输入流，将服务端反馈的数据读取到，并打印。

 * 4.关闭资源。

 * */

import java.net.UnknownHostException;

 

class TcpClient2{

    public static void main(String[] args)throws UnknownHostException,IOException{

       Socket s = new Socket("127.0.0.1",10004);

       OutputStream out = s.getOutputStream();

       out.write("服务端，你好".getBytes());

      

       InputStream in = s.getInputStream();

       byte[] buf =newbyte[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 IOException{

       ServerSocket ss = new ServerSocket(10004);

       Socket s = ss.accept();

      

       String ip = s.getInetAddress().getHostAddress();

       System.out.println(ip+"...connected");

       InputStream in = s.getInputStream();

       byte[] buf =newbyte[1024];

       int len = in.read(buf);

       System.out.println(new String(buf,0,len));

      

       OutputStream out = s.getOutputStream();

       out.write("哥们收到，你好".getBytes()); 

    }

}

//上述程序的客户端和服务器端能简单地收发数据，但是只能运行一次。

 

 

23天-13-网络编程(TCP练习)

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.net.ServerSocket;

import java.net.Socket;

 

/*

 * 需求：建立一个文本转换服务器。

 * 客户端给服务端发送文本，服务端会将文本转换为大写返回给客户端。

 * 而且客户端可以不断地进行文本转换，当官客户端输入over时，转换结束。

 *

 * 分析：

 * 客户端：

 * 既然是操作设备上的数据，那么可以用io技术，并按照io的操规律作来思考。

 * 源：键盘录入。

 * 目的：网络设备，网络输出流。

 * 而且操作时文本数据，可以选择字符流。

 *

 * 步骤：

 * 1.建立服务。

 * 2.获取键盘录入。

 * 3.将数据发给服务端。

 * 4.后去服务端返回到额大写数据。

 * 5.结束，关闭资源。

 *

 * 都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。

 * */

 

class TransClient{

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

       Socket s = new Socket("127.0.0.1",10005);

       //定义读取键盘数据的流对象。

       BufferedReader bufr =

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

       //定义目的，将数据写入到socket输出流，发送服务端。

       BufferedWriter bufw =

           new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));//<1>

      

       //定义一个socket读取流，读取服务端返回的大写信息。

       BufferedReader bufIn =

           new BufferedReader(new InputStreamReader(s.getInputStream()));

      

       String line = null;

       while((line=bufr.readLine())!=null){

           if("over".equals(line)){

              break;

           }

           bufw.write(line);//<2>

           bufw.newLine();//无此结束标记，服务端，无法判断客户端发送数据是否一//行结束。<2>

           bufw.flush();//写入懂啊缓冲区，要刷新才能写入数据。<2>

          

           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+"...connected");

      

       //读取socket读取流中的数据。

       BufferedReader bufIn =

           new BufferedReader(new InputStreamReader(s.getInputStream()));

       //目的：socket输出流。将大写数据写入到socket输出流，并发送给客户端。

       BufferedWriter bufOut =

           new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));//<3>

       String line = null;

       while((line=bufIn.readLine())!=null){

           bufOut.write(line.toUpperCase());//<4>

           bufOut.newLine();//不能少，要不客户端读取不到数据。<4>

           bufOut.flush();//<4>

       }     

    }

}

/*

 * 钙离子出现的问题。

 * 现象：客户端和服务端豆子啊莫名地等待。

 * 为什么呢？

 * 因为客户端和服务端都有阻塞式方法，这些方法没有读到结束标记，那么

 * 就会一直等待，从而导致两端都一直在等待。

 * */

/*

 * 方法改进：

 * 将标记处替换：

 *<1>、<3>处替换为：PrintWriterpw = new *PrintWriter(s.getOutputStream(),true);

 * <2>、<4>处替换为：out.println(line.toUpperCase());

 * */