JAVASE学习笔记第23天

网络编程（概述）

1、

 

2、两个主键的程序进行通讯的条件：

 

a)       找到对方的IP

b)       数据发送到对方指定的应用程序上。为了标识这些应用程序，所以给这些网络应用程序都用数字进行了标识。这些数字被称为了端口。（逻辑端口）

c)       定义通信规则。这个通讯规则就是协议

国际组织定义了通用的协议：TCP/IP

网络编程（网络模型）

1，网络模型

OSI参考模型

TCP/IP参考模型

 

2，网络通讯要素

IP地址：InetAddress

网络中设备的标识

不容易记忆，可以使用主机名

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

 

端口号

用于标识进程的逻辑地址，不同的进程有不同的标识

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

 

传输协议

通讯规则

常见的有：TCP、IP

 

3、TCP/IP参考模型

 

应用层  Http 、FTP

传输层  TCP 、UDP

网际层  IP

数据链路层

物理层

 

网络编程（IP地址）

/**

InetAddress常用的方法：

1，publicstatic InetAddress getByName(String host)

                             throwsUnknownHostException

在给定主机名的情况下确定主机的 IP 地址                        

 

2，publicString getHostAddress()

返回 IP 地址字符串（以文本表现形式）。

 

3、publicstatic InetAddress getLocalHost()

                                throwsUnknownHostException

返回本地主机

 

4、publicString getHostName()

获取此 IP 地址的主机名

*/

 

importjava.net.*;

 

class Demo1

{

public static void main(String[] args)throwsUnknownHostException

{

        //返回本地主机

        InetAddress i = InetAddress.getLocalHost();

        System.out.println(i.toString());

 

        //主机地址

        System.out.println(i.getHostAddress());

        System.out.println(i.getHostName());

 

        //百度的例子

        InetAddress ia =InetAddress.getByName("www.baidu.com");

        System.out.println(ia.getHostAddress());

        System.out.println(ia.getHostName());

}

}

网络编程（TCP/UDP）(记住)

1,UDP：

l  将数据及源目的封装成数据包，不需要建立连接。

l  每个数据包的大小限制在64K内

l  因为没有连接，所以是不可靠协议

l  不需要建立连接，速度快

l  常见的例子：视频会议

 

2，TCP

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

l  在连接中进行大数据量的传输

l  通过三次握手完成连接，是可靠协议（

（三次握手：

1，小李你收到了吗

2，小张我收到了

3，小李我知道你收到了）

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

l  常见的例子：下载。

 

网络编程（Socket）

1、Socket其实就是网络应用程序，可以理解为码头。

2、Socket是为网络服务提供的一种机制。

3、通信两端都有Socket

4、网络通信其实就是Socket之间的通讯。

5、数据在两个Socket之间通过IO传输。

 

 

 

查看本机IP/怎么查看本机IP地址

·         

有许多新手朋友，还不知道怎么查看本机IP，更不知道查看IP地址的命令是什么？其实，想要查看本地IP其实非常简单，只需要在cmd命令提示符中输入：ipconfig 命令，下面将为你详细的介绍怎么查看本机IP地址的详细步骤和方法。

 

 

 

 

 

 

 

网络编程（udp发送端和接收端）

/**

网络应用程序数据的传输

*/

 

/*

UDP发送端（思路很重要）

 

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

思路：

1，建立udpsocket服务

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

public DatagramPacket(byte[] buf,

                      int length,

                      InetAddress address,

                      int port)

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

4，关闭资源。

 

*/

 

import java.net.*;

 

class UdpSend

{

       publicstatic void main(String[] args)throws Exception

       {

              //建立udpsocket对象

              DatagramSocketds = new DatagramSocket(9999);

 

              //提供数据，并将数据封装到数据包中

              byte[]buf="udpsend fa song guo lai le".getBytes();

              DatagramPacketdp =newDatagramPacket(buf,buf.length,InetAddress.getByName("219.226.121.172"),10000);

 

              //通过socket服务发送

              ds.send(dp);

 

              //关闭资源

              ds.close();           

       }

}

 

/**

UDP接收端

 

需求：定义一个应用程序，用于接受UDP协议传输的协议并处理

 

思路：

1，定义udpsocket服务

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

3，通过socket服务的receive方法将接收到的数据存储到数据包中

4，通过数据包的特有的功能，可以将数据包不同的数据取出

5，关闭资源。

*/

 

class UdpReceive

{

       publicstatic void main(String[] args)throws Exception

       {

              //创建udpsocket服务对象

              DatagramSocketds =new DatagramSocket(10000);

 

              //定义数据包

              byte[]buf=new byte[1024];

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

 

              //通过receive方法接收数据

              ds.receive(dp);

 

              //通过数据包中的方法获取其中的数据

              Stringip = dp.getAddress().getHostAddress();

             

              Stringdata = new String(dp.getData(),0,dp.getLength());

             

              intport =dp.getPort();

 

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

 

              //关闭资源

              ds.close();

       }

}

 

 

 

网络编程（udp键盘录入方式数据）

/**

键盘录入数据的发送和接收

 

发送：

1，有Socket服务

2，有数据,数据封装打包

3，发送数据

4，关闭资源

 

接收：

1，创建Socket服务

2，定义一个字节数组，用来存放字节数据，创建一个数据包，将传进来的数据放入到数据包中

3，接收数据

4，将接收到的数据打印出来

5，关闭资源

*/

 

//一般有net包就有io包

import java.net.*;

import java.io.*;

 

//send

class UdpSend3

{

       publicstatic void main(String[] args)throws Exception

       {

              //创建Socket服务,可以指定端口，也可以不指定

              DatagramSocketds=new DatagramSocket();

             

              //键盘录入数据

              BufferedReaderbufr=

                     newBufferedReader(new InputStreamReader(System.in));

 

              Stringline=null;

 

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

              {

                     //控制条件

                     if(line.equals("888"))

                            break;

 

                     byte[]buf=line.getBytes();

                     //并将数据进行封装

                     DatagramPacketdp=

                            newDatagramPacket(buf,buf.length,InetAddress.getByName("localhost"),10000);

                    

                     //发送数据

                     ds.send(dp);

              }

              ds.close();

       }

}

 

//Receive

 

class UdpReceive3

{

       publicstatic void main(String[] args)throws Exception

       {

              //1，创建Socket服务

              DatagramSocketds=new DatagramSocket(10000);

 

              //2,创建一个字节数据，给包，创建一个包，用来接收字节数据

              byte[]buf=new byte[1024];

              DatagramPacketdp=

                     newDatagramPacket(buf,buf.length);

 

              //接收数据

              ds.receive(dp);

 

              //打印数据

              Stringip=dp.getAddress().getHostAddress();

              Stringdata =new String(dp.getData(),0,dp.getLength());

 

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

       }

}

 

 

 

网络编程（简单的聊天工具）

/*

需求：编写一个简单的聊天工具

分析：

有接收数据和发送数据两个部分，这两个部分同时执行。

那么就要用到多线程的技术，一个线程控制接收，一个线程控制发送。

 

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

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

 

*/

 

//发送

class Send implements Runnable

{

       privateDatagramSocket ds;

       publicSend(DatagramSocket ds)

       {

              this.ds=ds;   

       }

 

       publicvoid run()

       {

              try

              {

                     BufferedReaderbufr=

                            newBufferedReader(new InputStream(System.in));

 

                     Stringline=null;

 

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

                            if("888".equals(line))

                                          break;

                            byte[]buf=line.getBytes();

                            DatagramPacketdp=

                                   newDatagramPacket(buf,buf.length,InetAddress.getByName("169.254.138.255"),10000);

 

                            ds.send(dp);               

                     }            

              }

              catch(Exception e)

              {

                     thrownew RuntimeException("发送失败");

              }

              finally

              {

                     ds.close();

              }

       }

}

 

//接收

class Receive implements Runnable

{

       privateDatagramSocket ds;

       Receive(DatagramSocketds)

       {

              this.ds=ds;

       }

 

       publicstatic void run()

       {

              try

              {

                     while(true)

                     {

                            byte[]buf=new byte[1024];

                            DatagramPacketdp =

                                   newDatagramPacket(buf,buf.length);

                           

                            ds.receive(dp);

 

                            Stringip=dp.getAddress().getHostAddress();

                            Stringdata=dp.getData(buf,0,dp.getLength());

 

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

                     }                   

              }

              catch(Exception e)

              {

                     thrownew RuntimeException("接收失败");

              }

       }

}

 

//主线程

class Demo4

{

       publicstatic void main(String[] args)

       {

              DatagramSocketsend_ds=new DatagramSocket();

              DatagramSocketreceive_ds=new DatagramSocket(10000);

 

              Sendsend=new Send(send_ds);

              Receivereceive=new Receive(receive_ds);

             

              Threadsend_ts=new Thread(send);

              Threadreceive_ts=new Thread(receive);

 

              send_ts.start();

              receive_ts.start();

       }

}

 

网络编程（Tcp传输）

/*

需求：演示TCP的传输的客户端和服务端的互访。

也就是，客户端给服务端发送数据，服务端收到后，给客户端反馈信息。

 

客户端：

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

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

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

4，关闭客户端资源。

*/

import java.net.*;

import java.io.*;

 

class TcpCilent

{

       publicstatic void main(String[] args)throws Exception

       {

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

 

              OutputStreamout=s.getOutputStream();

              out.write("客户端说：服务端，你好！".getBytes());

 

              InputStreamin =s.getInputStream();

 

              byte[]buf=new byte[1024];

 

              intlen=in.read(buf);

 

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

 

              s.close();      

       }

}

 

class TcpServer

{

       publicstatic void main(String[] args)throws Exception

       {

              ServerSocketss = new ServerSocket(10004);

 

              Sockets=ss.accept();

 

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

              InputStreamin =s.getInputStream();

 

              byte[]buf=new byte[1024];

              intlen=in.read(buf);

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

 

              s.close();

 

              ss.close();

       }

}

 

网络编程（Tcp传输的练习）

/**

需求：

建立一个文本转换服务器。

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

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

 

分析：

客户端：

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

源：键盘录入

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

 

步骤：

1，建立服务

2，获取键盘录入

3，将数据发送个服务端

4，服务端将大写的数据返回给客户端

5，结束，关闭资源。

 

提示：

出现的现象是：客户端和服务端都在莫名的等待。

为什么呢？

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

所以一直等待。而且导致两端都在等待。

 

*/

import java.io.*;

import java.net.*;

 

//客户端

class TransCilent

{

       publicstatic void main(String[] args)throws Exception

       {

              //建立服务

              Sockets =new Socket("localhost",10004);

 

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

              BufferedReaderbufr =

                     newBufferedReader(new InputStreamReader(System.in));

 

              //定义目的，将数据写入到Socket输出流，发给服务端

              //BufferedWriterbufOut=

                     //newBufferedWriter(new OutputStreamWriter(s.getOutputStream()));

                    

                     //可以用这句话代替

                     PrintWriterout =new PrintWriter(s.getOutputStream(),true);

 

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

              BufferedReaderbufIn=

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

 

              Stringline=null;

             

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

              {

                     if("over".equals(line))

                            break;

 

              //    bufOut.write(line);

                     //bufOut.newLine();//这就是结束标记

                     //bufOut.flush();

 

                     out.println(line);

 

                     Stringstr = bufIn.readLine();

                     System.out.println("server:"+str);

              }

              bufr.close();        

              s.close();

       }

}

 

//服务端

/*

源：socket读取流

目的：socket输出流

*/

class TransServer

{

       publicstatic void main(String[] args)throws Exception

       {//建立服务

              ServerSocketss = new ServerSocket(10004);

 

              //获取客户端服务

              Sockets =ss.accept();

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

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

 

              //读取Socket读取流中的数据

              BufferedReaderbufIn=

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

 

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

              //BufferedWriterbufOut=

                     //newBufferedWriter(new OutputStreamWriter(s.getOutputStream()));

 

                     PrintWriterout =new PrintWriter(s.getOutputStream(),true);

                           

 

              Stringline=null;

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

              {

                     //bufOut.write(line.toUperCase());

                     //bufOut.newLine();

                     //bufOut.flush();

                     System.out.println(line);

                     out.println(line.toUpperCase());

              }

              s.close();

              ss.close();

       }

}

 

网络编程（Tcp复制文件）

 

/*

复制文件的例子：

*/

import java.net.*;

import java.io.*;

 

//客户端

class TextCilent

{

       publicstatic void main(String[] args)throws Exception

       {

              //建立socket连接

              Sockets=new Socket("localhost",10004);

 

              //读取数据

              BufferedReaderbufr=

                     newBufferedReader(new FileReader("Demo1.java"));

 

              //目的是网络输出流

              PrintWriterout = new PrintWriter(s.getOutputStream(),true);

 

              Stringline=null;

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

              {

                     out.write(line);

              }

              s.shutdownOutput();//关闭socket

 

              //服务端告诉上传成功，建立一个socket输入流对象

              BufferedReaderbufIn=

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

 

              Stringstr =bufIn.readLine();

              System.out.println(str);

 

              //关闭资源

              bufIn.close();

              s.close();

       }

}

 

//服务端

class TextServer

{

       publicstatic void main(String[] args)throws Exception

       {

              //建立socket对象

              ServerSocketss =new ServerSocket(10004);

 

              //接受客户端的socket对象

              Sockets=ss.accept();

              //看是否连接成功

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

              System.out.println(ip+"。。。。connect");

 

              //源是socket输入流

              BufferedReaderbufIn=

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

 

              //目的是文件

              PrintWriterout=new PrintWriter(new FileWriter("server.txt"),true);

 

              //读

              Stringline=null;

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

              {

                     out.println(line);

              }

 

              PrintWriterpw = new PrintWriter(s.getOutputStream(),true);

              pw.println("上传成功");

 

              out.close();

              s.close();

              ss.close();

       }

}