Java学习笔记十

网络编程:

一、osi和TCP协议对照:

二、通讯三要素：

三、InetAddress对象简述:

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

 public class IpClassDemo
 {
     public static void main(String[] args) throws UnknownHostException{
         demo();
     }

     public static void demo() throws UnknownHostException{
         //InetAddress没有构造方法,不能直接创建对象
         //获取本机
         InetAddress ip=InetAddress.getLocalHost();
         //获取其他主机
         ip=InetAddress.getByName("k01");
         System.out.println(ip.getHostAddress());
         System.out.println(ip.getHostName());
     }

 }

InetAddress

socket:套接字,网络编程的基础。发送端和接收端都需要socket。

四、UDP实现:首先Java封装了UDP所使用的socket对象-->DatagramSocket,可以简单的获取并加以使用。

UDP是协议,所以要完成通讯,还需要体现另外两个要素:ip和端口。

ip是在发送端使用,指定接收端的地址,端口是发送端和接收端数据交换的线程号

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

 public class UDPSendDemo {
     public static void main(String[] args) throws IOException{
         System.out.println("发送端启动...");
         sendemo();
     }

     public static void sendemo() throws IOException {
         /*使用UDP发送数据需要四步,
          * 1、建立发送端的socket服务,对于UDP协议来说就是创建DatagramSocket对象
          * 2、将数据封包,对于UDP协议来说使用的是DatagramPacket对象。！！！该对象还可以用于拆包数据
          * 3、使用socket服务发送:这里需要使用通讯协议的另外两个点-->1、接收端的ip，2、端口
          * 注意:传输的信息会被接收端的对应端口接收
          * 4、关闭socket服务
          */
         DatagramSocket ds=new DatagramSocket();

         String context="UDP发送演示";
         byte[] buf=context.getBytes();

         DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getByName("192.16.25.16"), 10000);

         ds.send(dp);

         ds.close();
     }
 }

UDP发送端演示

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

 public class UDPReceiveDemo {

     public static void main(String[] args) throws IOException {
         System.out.println("接收端启动...");
         receivedemo();
     }

     public static void receivedemo() throws IOException {
         /*使用UDP接收数据和发送过程类似
          * 1、建立发送端的socket服务,！！！需要明确端口号
          * 2、创建数据包,准备存储和解析数据
          * 3、使用socket的receive()接收数据存入准备好的解析对象中
          * 4、使用数据包的解析方法解析数据,即拆包.可以解析出发送端地址,端口,数据内容等信息
          * 5、关闭socket服务
          */
         DatagramSocket ds=new DatagramSocket(10000);

         byte[] buf=new byte[1024];
         DatagramPacket dp=new DatagramPacket(buf, buf.length);

         ds.receive(dp);            //阻塞式,在接收到信息之前一直阻塞
         String ip=dp.getAddress().getHostAddress();
         int port=dp.getPort();
         String context=new String(dp.getData(),0,dp.getLength());
         System.out.println("ip是"+ip+",端口是"+port+",内容是\""+context+"\"");

         ds.close();
     }

 }

UDP接收端演示

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

 public class UDPTest {
     /*这是UDP协议的聊天室,使用UDPSendTest2和UDPReceiveTest2,
      * 其实就是添加了多线程
      */
     public static void main(String[] args) throws IOException {
         DatagramSocket send=new DatagramSocket();
         DatagramSocket rece=new DatagramSocket(13419);
         UDPSendTest2 usend=new UDPSendTest2(send);
         UDPReceiveTest2 urece=new UDPReceiveTest2(rece);
         Thread t1=new Thread(usend);
         Thread t2=new Thread(urece);
         t1.start();
         t2.start();
     }

 }

UDP简单聊天室

 import java.io.BufferedReader;
 import java.io.InputStreamReader;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;

 public class UDPSendTest2 implements Runnable{
     private DatagramSocket ds;
     public UDPSendTest2(DatagramSocket ds){
         this.ds=ds;
     }
     public void run(){
         try{
             BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
             String line=null;
             while((line=br.readLine())!=null){
                 byte[] buf=line.getBytes();
                 DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getByName("172.25.14.5"), 13419);
                 ds.send(dp);
                 if(line.equals("886")){
                     break;
                 }
             }
             ds.close();
         }catch(Exception e){
         }
     }
 }

聊天室发送端

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

 public class UDPReceiveTest2 implements Runnable{
     private DatagramSocket ds;
     public UDPReceiveTest2(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 context=new String(dp.getData(),0,dp.getLength());
                 System.out.println("内容是:"+context);
                 if(context.equals("886")){
                     System.out.println("对方退出聊天");
                 }
             }
         }catch(Exception e){
         }
     }

 }

聊天室接收端

五、TCP实现:TCP协议比UDP复杂,在Java中表现在区分服务器端和客户端不同的socket对象。

服务器端-->ServerSocket

客户端---->Socket

 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.Socket;
 import java.net.UnknownHostException;

 public class TCPClientDemo {

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

     public static void demo() throws UnknownHostException, IOException {
         /*TCP传输客户端的建立过程:
          * 1、创建客户端socket服务,使用Socket对象
          *         建议:一旦创建该对象,就明确要连接的主机地址
          * 2、如果连接成功,会生成一个通道。在Java中表现为socket流,
          *   有输入流和输出流,对应的对象可以通过Socket对象获取
          *   getOutputStream()    --》获取输出流
          *      getInputStream()    --》获取输入流
          * 3、使用输出流发送数据,还可以接受服务器端反馈的数据
          * 4、关闭资源
          */
         Socket s=new Socket("172.25.14.9", 10002);
         OutputStream os=s.getOutputStream();
         os.write("TCP演示".getBytes());
         s.close();
     }

 }

TCP客户端演示

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class TCPServerDemo {

     public static void main(String[] args) throws IOException {
         /*TCP和UDP的一个不同是:TCP是面向连接的,
          * 就是说要先开启服务器端,在开启客户端,两端相连接才能通讯
          * 而UDP只要两端开启就可以通讯
          */
         demo();
     }

     public static void demo() throws IOException {
         /*
          * 建立TCP服务器端的过程
          * 1、建立服务器端的socket服务,使用ServerSocket对象
          *       ！！！ 注意：服务器端必须提供一个端口给客户端使用,否则无法连接
          * 2、获取正在连接的客户端socket对象,并使用该对象对应的通道,即socket流进行数据发送
          *      ！！！注意:这是因为  服务器端需要和多个客户端进行数据交换,这样可以保证数据不会传错
          * 3、关闭资源,包括客户端和服务器端。
          */
         ServerSocket ss=new ServerSocket(10002);

         //accept()是阻塞式,在服务器端开启后会一直阻塞,直到有传输数据进入才会执行下一步操作
         Socket s=ss.accept();
         InputStream is=s.getInputStream();

         BufferedReader br=new BufferedReader(new InputStreamReader(is));
         System.out.println(br.readLine());

         s.close();
         ss.close();
     }

 }

TCP服务器端演示

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.net.Socket;
 import java.net.UnknownHostException;

 public class TCPClientTest {

     public static void main(String[] args) throws UnknownHostException, IOException {
         //TCPTest是用TCP协议建立一个服务器端,对客户端传来的数据进行大小写转换,使用键盘录入
         demo();
     }

     public static void demo() throws UnknownHostException, IOException {
         Socket s=new Socket("172.25.14.9", 7999);
         OutputStream os=s.getOutputStream();
         PrintStream out=new PrintStream(os);

         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
         BufferedReader brIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
         String str=null;
         while((str=br.readLine())!=null){
             if(str.equals("over")){
                 break;
             }
             out.println(str);
             //上面一句相当于下面一句
             //out.print(str+"\r\n");
             //out.flush();
             String upperStr=brIn.readLine();
             System.out.println(upperStr);
         }

         s.close();
     }
 }

TCP大小写转换客户端

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class TCPServerTest {

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

     public static void demo() throws IOException {
         ServerSocket ss=new ServerSocket(7999);

         Socket s=ss.accept();
         InputStream is=s.getInputStream();

         BufferedReader br=new BufferedReader(new InputStreamReader(is));
         OutputStream os=s.getOutputStream();
         PrintStream out=new PrintStream(os,true);
         String str=null;
         while((str=br.readLine())!=null){
             out.println(str.toUpperCase());
         }
         s.close();
         ss.close();
     }

 }

TCP大小写转换服务器端

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.FileReader;
 import java.io.PrintStream;
 import java.net.Socket;
 import java.net.UnknownHostException;

 public class TCPUploadClient {

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

     public static void demo() throws UnknownHostException, IOException {
         Socket s=new Socket("172.25.14.4", 7999);
         OutputStream os=s.getOutputStream();
         PrintStream out=new PrintStream(os);

         BufferedReader br=new BufferedReader(new FileReader("D:\\2.txt"));
         String str=null;
         while((str=br.readLine())!=null){
             out.println(str);
         }

         //因为TCP两端都有阻塞式方法,为了结束通讯过程,Java的socket对象提供了TCP通讯结束标记,
         s.shutdownOutput();

         BufferedReader brIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
         String context=brIn.readLine();
         System.out.println(context);
         br.close();
         s.close();
     }
 }

TCP文本文件上传客户端

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.io.FileWriter;
 import java.io.PrintStream;

 public class TCPUploadServer {

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

     public static void demo() throws IOException {
         ServerSocket ss=new ServerSocket(7999);

         Socket s=ss.accept();
         String ip=s.getInetAddress().getHostAddress();
         System.out.println(ip+"....connect");
         InputStream is=s.getInputStream();

         BufferedReader br=new BufferedReader(new InputStreamReader(is));
         BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\1.txt"));
         OutputStream os=s.getOutputStream();
         PrintStream out=new PrintStream(os,true);
         String str=null;
         while((str=br.readLine())!=null){
             if(str.equals("over")){
                 break;
             }
             bw.write(str);
             bw.newLine();
             bw.flush();
         }
         out.println("get");
         bw.close();
         s.close();
         ss.close();
     }

 }

TCP文本文件上传服务器端

六、服务器和客户端

ip: