黑马程序员-java基础之网络编程

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------

 

网络编程

网络模型：

       OSI参考模型

       TCP/IP参考模型

两种模型图解

开发处于传输层和应用层，而编程人员需要做的是传输层，数据传送，先经过逐层封包后通过物理层发送到另外一台机器，再通过逐层解包，完成数据的读取

网络通信的步骤

1找到ip地址

2明确端口号

3利用Socket进行数据的传输

网络通讯三要素

ip地址：

       它是网络中的设备标识

       不易记忆，可用主机名表示，两者存在映射关系，如常用的www.baidu.com

       本地回环地址:127.0.0.1,主机名为：localhost 用于测试网卡

在java中用InetAddress类封装ip地址存放在java.net包中

代码示例通过主机名获取ip地址

import java.net.*;

class  IPDemo{

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

        //通过名称(ip字符串or主机名)来获取一个ip对象。

    InetAddress ip= InetAddress.getByName("localhost");       System.out.println("addr:"+ip.getHostAddress());

        System.out.println("name:"+ip.getHostName());

    }

}

端口号：

数据要进行传输就要发送到指定端口。为了标示不同的应用程序，所以给这些网络应用程序都用数字进行标示，这个标识就叫端口。

传输协议：

       通讯的规则

       常见协议

       UDP：

              特点：

面向无连接

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

因面向无连接，当对方不在时就会丢失数据，是不可靠的协议

无需建立连接，速度快

TCP：

              特点

                     面向连接，在连接建立后才能形成传输数据的通道，进行数据的传输

                     在连接中数据大小不受限制，可以进行大数据量的传输

                     通过三次握手完成连接：

                            第一次：问你在吗

                            第二次：回我在呢

                            第三次：我知道了

                     必须建立连接，会导致效率不如UDP。

Socket

概述：套接字又称插座，为网络服务提供的一种机制，通信的两端都必须要有Socket，网络通信其实就是数据在Socket间进行传输。

UDP传输：

通过DatagramSocket和DatagramPacket来进行传输

DatagramSocket 中封装了Socket所以可以用来通信

DatagramPacket 数据包在构造时可以定义是接受数据还是发送数据，数据包大小不能超过64K

通过UDP传输方式，发送一段数据

思路：

      1建立udp的socket服务。

       2将要发送的数据封装到数据包中。

3通过udp的socket服务将数据包发送出去。

4关闭socket服务。

      

代码示例

import java.net..*;

public class UDPSendDemo

{

 

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

{

             

              //1,udpsocket服务。使用DatagramSocket对象。

              DatagramSocket ds = new DatagramSocket(8888);

             

              //2,将要发送的数据封装到数据包中。

              String str = "哥们来了！";

              //使用DatagramPacket将数据封装到的该对象包中。

              byte[] buf = str.getBytes();

             

              DatagramPacket dp =

new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10000);

             

             

              //3，通过udp的socket服务将数据包发送出去。使用send方法。

              ds.send(dp);

             

              //4，关闭资源。

              ds.close();

             

             

       }

}

定义一个接收端应用程序

思路：

       定义udpsocket服务

       定义一个数据包存储接受到的字节数据，因为数据包对象中有更多功能可以提取信息

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

       4通过数据包对象的特有功能，将这些数据取出

       5关闭资源

代码示例

public class UDPReceDemo

{

 

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

{

 

      

              //1,建立udp socket服务。

              DatagramSocket ds = new DatagramSocket(10000);

             

             

              //2,创建数据包。

              byte[] buf = new byte[1024];

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

             

              //3,使用接收方法将数据存储到数据包中。

              ds.receive(dp);//阻塞式的。

             

              //4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。

              String ip = dp.getAddress().getHostAddress();

              int port = dp.getPort();

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

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

             

              //5,关闭资源。

              ds.close();

             

       }

 

}

小练习-编写一个聊天程序

import java.net.*;

import java.io.*;

class Send implements Runnable

{

       private DatagramSocket ds;

      

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

{

                            byte[] buf = line.getBytes();

              DatagramPacket dp =

              new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10001);

                            ds.send(dp);

                           

                            if("886".equals(line))

                                   break;

                     }

                     ds.close();

              }

catch (Exception e)

{

       throw RuntimeException();

              }

}

}

class Rece implements Runnable

{

 

       private DatagramSocket ds;

 

       public Rece(DatagramSocket ds)

{

              this.ds = ds;

       }

 

       public void run()

{

              try

{

                     while (true)

{

 

                            // 2,创建数据包。

                            byte[] buf = new byte[1024];

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

 

                            // 3,使用接收方法将数据存储到数据包中。

                            ds.receive(dp);// 阻塞式的。

 

                     // 4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。

                            String ip = dp.getAddress().getHostAddress();

                            int port = dp.getPort();

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

                           

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

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

                                   System.out.println(ip+"....退出聊天室");

                            }

 

                     }

              catch (Exception e)

{

       throw RuntimeException();

 

              }

 

       }

 

}

class ChatDemo

{

 

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

{

 

             

              DatagramSocket send = new DatagramSocket();

             

              DatagramSocket rece = new DatagramSocket(10001);

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

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

             

        }

 

}

TCP传输

分为客户端和服务端

客户端Socket 服务端ServerSocket

创建TCP客户端基本思路

1客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常

2连接成功，说明客户端与服务端建立了通道，那么通过io流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream方法和getOutputStream方法获取即可

3与服务端通信结束后，关闭Socket

步骤：

       创建Socket服务，并指定要连接的主机端口，通路一建立就会产生Socket流，通过对应方法获取

       获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Scoket的输入流

       通过输出流的write方法将要发送的数据写入到流中

       关闭资源

创建TCP服务端

基本思路

1服务端需要明确它要处理的数据是从哪个端口进入的

       2当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象对客户端通过IO流进行数据传输

       3当该客户端访问结束时，关闭该客户端

代码示例

import java.io.*;

import java.net.*;

class SocketDemo

{

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

{

      

              Socket socket = new Socket("192.168.1.100",10002);

              OutputStream out = socket.getOutputStream();  

              out.write("哥们又来了!".getBytes());

             

                           

              //读取服务端返回的数据,使用socket读取流。

              InputStream in = socket.getInputStream();

              byte[] buf = new byte[1024];

              int len = in.read(buf);

              String  text = new String(buf,0,len);

              System.out.println(text);

             

              //关闭资源。

              socket.close();

             

      

       }

 

}

class ServerDemo2

{

 

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

{

             

             

              //1创建服务端对象。

              ServerSocket ss = new ServerSocket(10002);

             

              //2,获取连接过来的客户端对象。

              Socket s = ss.accept();

             

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

             

              //3，通过socket对象获取输入流，要读取客户端发来的数据

              InputStream in = s.getInputStream();

             

              byte[] buf = new byte[1024];

             

              int len = in.read(buf);

              String text = new String(buf,0,len);

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

             

             

             

              //使用客户端socket对象的输出流给客户端返回数据

              OutputStream out = s.getOutputStream();

              out.write("收到".getBytes());

             

              s.close();

              ss.close();

             

       }

 

}

小练习-上传文件

代码示例

public class UploadClient

{

 

      

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

{

 

             

              File file = new File("c:\\1.txt");

              System.out.println(file.exists());

                           

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

             

              BufferedReader bufr =

                            new BufferedReader(new FileReader(file));

             

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

             

              String line = null;

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

                    

                     out.println(line);

              }

             

              //告诉服务端，客户端写完了。

              s.shutdownOutput();

BufferedReader bufIn= = new BufferedReader(newInputStreamReader(s.getInputStream()));

             

              String str = bufIn.readLine();

              System.out.println(str);

             

              bufr.close();

              s.close();

             

       }

 

}

class TCPServer

{

 

      

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

{

             

             

              ServerSocket ss = new ServerSocket(10005);

             

              Socket s = ss.accept();

             

              System.out.println(s.getInetAddress().getHostAddress()+".....connected");

             

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

             

              BufferedWriter bufw = new BufferedWriter(new FileWriter("c:\\2.txt"));

             

              String line = null;

             

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

{

                    

                     bufw.write(line);

                     bufw.newLine();

                     bufw.flush();

              }

             

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

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

              bufw.close();

              s.close();

              ss.close();

       }

 

}

客户端并发访问

一个客户端连接上后，服务端执行具体流体时，这时另外一个客户端来访问就只能等待，在实际开发中，往往都是同时处理多个客户端请求，为了让多个客户端可以同时并发的访问服务端，服务端应将每个客户端都封装到一个单独的线程中，这样，就可以同时处理多个客户端请求了

代码示例-客户端并发访问

public class UploadPicClient

{

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

{

 

              //1,创建客户端socket。

              Socket s = new Socket("192.168.1.100",10006);

             

              //2,读取客户端要上传的图片文件。

              FileInputStream fis = new FileInputStream("c:\\1.bmp");

             

              //3,获取socket输出流，将读到图片数据发送给服务端。

              OutputStream out = s.getOutputStream();

             

              byte[] buf = new byte[1024];

             

              int len = 0;

             

              while((len=fis.read(buf))!=-1){

                     out.write(buf,0,len);

              }

             

              //告诉服务端说：这边的数据发送完毕。让服务端停止读取。

              s.shutdownOutput();

             

             

              //读取服务端发回的内容。              

              InputStream in  = s.getInputStream();

              byte[] bufIn = new byte[1024];

              int lenIn = in.read(buf);

              String text = new String(buf,0,lenIn);

              System.out.println(text);

             

              fis.close();

              s.close();

             

       }

 

}

public class UploadTask implements Runnable

{

 

       private static final int SIZE = 1024*1024*5;

       private Socket s;

 

       public  UploadTask(Socket s)

{

              this.s = s;

       }

       public void run()

{

              int count = 0;

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

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

             

              try

{

 

              // 读取客户端发来的数据。

              InputStream in = s.getInputStream();

 

              // 将读取到数据存储到一个文件中。

              File dir = new File("c:\\pic");

              if (!dir.exists()) {

                     dir.mkdirs();

              }

              File file = new File(dir, ip + ".jpg");

              //如果文件已经存在于服务端

              while(file.exists())

{

                     file = new File(dir,ip+"("+(++count)+").jpg");

              }

             

              FileOutputStream fos = new FileOutputStream(file);

 

              byte[] buf = new byte[1024];

 

              int len = 0;

 

              while ((len = in.read(buf)) != -1)

{

                     fos.write(buf, 0, len);

              }

                           

                    

              // 获取socket输出流，将上传成功字样发给客户端。

              OutputStream out = s.getOutputStream();

              out.write("上传成功".getBytes());

 

              fos.close();

              s.close();

              }

catch(IOException e)

{

                     throw RuntimeException("上传失败")

            }

 

       }

 

}

class UploadPicServer

{

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

{

              //创建tcp的socket服务端。

              ServerSocket ss = new ServerSocket(10006);

             

              while(true)

{

                     Socket s = ss.accept();               

                    

                     new Thread(new UploadTask(s)).start();           

                    

              }

      

       }

 

}

域名解析：

              因为IP地址难以记忆，所以一般访问时都是输入的主机名去进行访问，这时会去进行域名解析，其会先去本地的hosts文件中寻找对应的映射，如果有，则直接返回请求，如果没有则会去公网上去寻找对应的映射。找到后将主机名对应的IP地址返回给本机，

利用这一特点，我们可以在hosts文件中输入对应的映射关系，将IP地址改为本机的回环地址，这样就可以用来屏蔽掉一些恶意网址。

--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------