Java基础日记———网路编程

原创 2015年07月09日 11:22:00

一.概述
1.网络模型:OSI参考模型和TCP/IP模型如图:
这里写图片描述

2.网络通信三要素:IP地址,端口号,传输协议
(1)IP地址
    a、它是网络中的设备标识
    b、不易记忆,可用主机名表示,两者存在映射关系
    c、本机回环地址:127.0.0.1,主机名为:localhost。
(2)端口号:
    a、用于标识进程的逻辑地址,不用进程的标识。
    b、有效端口:0 ~65535,系统使用或保留的端口是:0~ 1024。
(3)传输协议:
    即通信规则,包含TCP和UDP协议
    ①UDP:是面向无连接,明确了对方的端口,无论在不在网上,只管传输,不在就会丢失数据。只求速度,应用于网络视频会议和聊天等应用程序中。
    ②TCP:是面向连接的,必须连接成功才能传输数据,应用于下载等程序。
3、通信的步骤:
    ①找到IP地址
    ②数据要发送到对象指定应用程序,为标识这些应用程序,所以给这些网络应用程序都用数字标识,为方便称呼这个数字,叫做端口,即逻辑端口。
    ③定义通信规则,称之为协议。国际组织定义了通用协议,即TCP/IP。
注意:必须要有数字标识才能将数据发送到应用程序上。
二.网络编程详解
1.基础详解
(1)IP地址:java中对应的是InetAddress类,存在于java.net包中。
InetAddress类:
     ①无构造函数,可通过getLocalHost()方法获取InetAddress对象,此方法是静态的,返回本类对象。
              InetAddress i = InetAddress.getLocalHost();
     ②方法摘要:
            static InetAddress getByName(String host):获取指定主机的IP和主机名。(最好用ip地址去获取,主机名需要解析)
           static InetAddress[] getAllByName(String host):在给定主机名的情况下,根据系统上配置的名称服务返回IP地址所组成的数组。返回对象不唯一时,用此方法。
            String getHostAddress():返回IP地址字符串文本形式,以IP地址为主。
           String getHostName():返回IP地址主机名。
     (3)需求:获取任意一台主机的IP地址对象:
          功能:返回InetAddress对象
          对于任意主机,需要指定传入主机名的参数
          注意:如果IP地址和对应的主机名,这种映射关系没有在网络上,就不会解析成功,返回的还是指定的IP。

代码示例:

    import java.net.*;
    class  IPDemo 
    {
          public static void main(String[] args) throws Exception 
         {
                  InetAddress ia = InetAddress.getByName("lenovo-PC");
                  System.out.println("address:"+ia.getHostAddress());
                  System.out.println("name:"+ia.getHostName());
           }
}
(2)URL和URLConnection
①URL:
    URI:范围更大,条形码也包含于此范围
    URL:范围较小,即域名
方法:
    a.构造函数:URL(String protocol,String host,int port,String file);//根据指定 protocol、host、port号和 file 创建 URL对象。
    b.String getProtocol();//获取协议名称
    c.String getHost();//获取主机名
    d.int getPort();//获取端口号
    e.String getFile();//获取URL文件名
    f.String getPath();//获取此URL的路径部分
    g.String getQuery();//获取此URL的查询部,客户端传输的特定信息
注:一般输入网址,是不带端口号的,此时可进行获取,通过获取网址返回的port,若port为-1,则分配一个默认的80端口,如
    int port = getPort();
    if(port == -1)
          port = 80;
②URLConnection
方法:
    a.URLConnection openConnection();//用URL调用此方法,返回一个 URLConnection 对象,它表示到 URL 所引用的远程对象的连接。
    b.InputStream getInputStream();//获取输入流
    c.OutputStream getOutputStream();//获取输出流
2.传输协议
(1)Socke
   a、它被称之为插座,相当于港口一样,是网络服务提供的一种机制。
b、通信两端都要有Socket,才能建立服务。
     c、网络通信其实就是Socket间的通信,数据在两个Socket间通过IO传输。
(2)UDP
协议特点:
     ①面向无连接,即将数据及源和目的封装成数据包中,不建立链接的发送
     ②每个数据包的大小限制在64K之内
     ③因无连接,是不可靠的协议
     ④不建立连接,速度快。
使用的类与方法:
     ① 通过类DatagramSocket,此类表示用发送和接收数据包的套接字,即Socket。
     ②创建 UDPSocket发送服务对象 DatagramSocket(),不指定端口。DatagramSocket(int port),指定端口。
     ③发送:void send(DatagramPacket p)
     ④接收:void receive(DatagramPacket p)
       其中DatagramPacket:数据报包用来实现无连接包投递服务的,每条报文仅根据该包中包含的信息从一台机器路由到另一台机器中。凡是带地址(InetAddress)的都是用于发送包的。
具体实现步骤:
   ①发送数据:
          a、建立UDPSocket服务,在此无需指定端口,也可以将端口加入。如果不指定的话,系统会随机分配一个端口,如第一次运行时端口为1093,那么第二次就会顺延为1094,再运行会一直顺延,因为之前的端口还没有得到释放,所以会顺延端口号值。
          b、提供数据,并将数据封装到数据包中
          c、通过socket服务的发送功能,将数据包发送出去
          d、关闭资源
    ②接收数据:
          a、定义UDPSocket服务。通常会监听一个端口,其实就是给这个接收网路应用程序定义数字标识,方便于明确哪些数据过来该应用程序可以处理。
          b、定义一个数据包,用来存储接收到的字节数据,因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
          c、通过socket服务的receive方法接收到的数据存入已定义好的数据包中
          d、通过数据包对象的特有功能,将这些不同的数据取出,打印在控制台上
          e、关闭资源
    在定义接收数据的方法中,仍会在DatagramSocket构造函数中传入DatagramPacket的参数,这是因为收到的数据太多,需要解析,通过将数据封装成对象,易于解析,所以需要传入参数。
注意:
     ①发送端与接收端是两个独立的运行程序。
     ②在发送端,要在数据包对象中明确目的地IP及端口。
     ③在接收端,要指定监听的端口。

代码示例:
需求:通过udp传输方式,将一段文字数据发送出去。,
定义一个udp发送端。
思路: ①建立updsocket服务。
②提供数据,并将数据封装到数据包中。
③通过socket服务的发送功能,将数据包发出去。
④关闭资源。

class  UdpSend //发送
{
 public static void main(String[] args) throws Exception
 {
  //1,创建udp服务。通过DatagramSocket对象。
  DatagramSocket ds = new DatagramSocket(8888);
  //2,确定数据,并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, 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();
 }
}
需求: 定义一个应用程序,用于接收udp协议传输的数据并处理的。 
定义udp的接收端。
思路:
①定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。
 方便于明确哪些数据过来该应用程序可以处理。
②定义一个数据包,因为要存储接收到的字节数据。 
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
③通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
④通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
⑤关闭资源。
class  UdpRece
{
 public static void main(String[] args) throws Exception
 {
  //1,创建udp socket,建立端点。
  DatagramSocket ds = new DatagramSocket(10000);
  while(true)
  {
  //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();
     }
}
(3)TCP
协议特点:
     ①面向连接,在建立连接后,形成传输数据的通道
     ②在连接中进行大数据量的传输
     ③通过三次握手完成连接,是可靠的协议 (三次握手:第一次本方发送请求,第二次对方确认连接,第三次本方再次确认连接成功。)
     ④必须建立连接,效率稍慢
使用的方法和类:    
    ①创建客户端对象:
              Socket():创建空参数的客户端对象,一般用于服务端接收数据
              Socket(String host,int port),指定要接收的IP地址和端口号
    ②创建服务端对象:ServerSocket(int port):指定接收的客户端的端口
    ③Socket accept():监听并接受到此套接字的连接
    ④void shutdownInput():此套接字的输入流至于“流的末尾”
    ⑤void shutdownOutput():禁用此套接字的输出流
    ⑥InputStream getInputStream():返回此套接字的输入流,Socket对象调用
    ⑦OutputStream getOutputStream():返回套接字的输出流,Socket对象调用
实现步骤:   
客户端:
    通过查阅Socket对象的API文档,发现在该对象在建立时,就可去连接指定主机,因为TCP是面向连接的,所以在建立Socket服务时,就要有服务端存在,并连接成功,形成通路后,再通过该通道进行数据的传输。
     ①创建Socket服务,并指定要连接的主机端口。通路一建立,就会产生Socket流(包括输入流和输出流),通过方法获取
     ②为了发送数据,应获取Socket中的输出流,如果要接收服务端的反馈信息,还需要获取Socket的输入流
     ③通过输出流的write()方法将要发送的数据写入到流中
     ④关闭Socket流资源
服务端:
    服务器套接字等待请求通过网络传入。它基于该请求执行某些操作,然后可能向请求者返回结果。需监听一个端口。
     ①建立服务端的Socket服务,并监听一个端口。通过ServerSocet带端口参数的构造函数
     ②获取连接过来的客户对象,通过ServerSocket的accept()方法,此方法是阻塞式的,如果服务端没有连接到就会一直等待
     ③客户端如果发过来数据,则服务端要使用对应的客户端对象,并获取到该客户端对象的读取流读取发过来的数据,并输出到指定目的地。
     ④关闭服务端(可选)。一般服务端是常开的,因为在实际应用中,随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流,避免某一个客户端长时间占用服务器端。

代码示例:
需求:给服务端发送给一个文本数据。
步骤:
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,获取连接过来的客户端对象。
 通过ServerSokcet的 accept方法。没有连接就会等,所以这个方法阻塞式的。
3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流来读取发过来的数据。
 并打印在控制台。
4,关闭服务端。(可选)
class  TcpServer
{
 public static void main(String[] args) throws Exception
 {
  //建立服务端socket服务。并监听一个端口。
  ServerSocket ss = new ServerSocket(10003);
  //通过accept方法获取连接过来的客户端对象。
  while(true)
  {
      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();
     }
}   
三.应用练习
(1)需求:
编写一个聊天程序。 
有收数据的部分,和发数据的部分。
这两部分需要同时执行。
那就需要用到多线程技术。
一个线程控制收,一个线程控制发。

因为收和发动作是不一致的,所以要定义两个run方法。
而且这两个方法要封装到不同的类中。
使用UDP协议。

代码示例:

  import java.io.*;
    import java.net.*;
    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"),10002); 
            ds.send(dp);
            if("886".equals(line))
             break;
       }
  }
  catch (Exception e)
  {
   throw new RuntimeException("发送端失败");
  }
 }
}

class Rece implements Runnable
{
 private DatagramSocket ds;
 public 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());
    if("886".equals(data))
    {
         System.out.println(ip+"....离开聊天室");
         break;
    }
        System.out.println(ip+":"+data);
       }
  }
  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();
 }
}
(2)用TCP客户端并发上传图片
①一对一(单线程)上传的思路:
客户端
    a、服务端点。
    b、读取客户端已有的图片数据
    c、通过Socket输出流将数据发给服务端
    d、读取服务端反馈信息。
    e、关闭
服务端
    a、服务端服务,并监听窗口
    b、获取客户端对象,并获取客户ip
    c、读取客户端输入流数据
    d、写入文件
    e、用客户端输出流反馈信息
    f、关流
②单线程的服务端有个局限性。当A客户端连接上以后,被服务端获取到。服务端执行具体流程。这时B客户端连接,只能等待。因为服务端还没有处理完A客户端的请求。还没有循环回来执行下一次accept方法。所以,暂时获取不到B客户端对象。
    那么为了可以让多个客户端同时并发访问服务端。服务端最好就是将每个客户端封装到一个单独的线程中,这样,就可以同时处理多个客户端请求。
如何定义线程呢?
    只要明确了每一个客户端要在服务端执行的代码,将该代码存入run方法即可。

代码示例:

    /*
需求:并发上传图片
*/
import java.io.*;
import java.net.*;
//客户端
class  PicClient
{
 public static void main(String[] args) throws Exception
 {
  //对传入的值进行判断
  if (args.length!=1)
  {
   System.out.println("请指定一个图片文件!");
   return;
  }
  File file=new File(args[0]);
  //对文件路径进行判断
  if (!(file.exists()&&file.isFile()))
  {
   System.out.println("你上传的文件有问题,非文件或者不存在!");
   return;
  }
  //判断是否是图片文件
  if (!file.getName().endsWith(".jpg"))
  {
   System.out.println("图片格式错误,请重新选择!");
   return;
  }
  //对文件大小进行判断
  if (file.length()>1024*1024*5)
  {
   System.out.println("你上传的文件过大,居心叵测!");
   return;
  }
  //创建服务
  Socket s=new Socket("localhost",10000);
  //读取图片数据
  FileInputStream fis=new FileInputStream(file);  
  //用Socket服务输出流写入数据
  OutputStream out =s.getOutputStream();
  BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));
  byte[] buf=new byte[1024];
  int len=0;
  while ((len=fis.read(buf))!=-1)
  {
   out.write(buf,0,len);
  }
  //结束标记,表示文件数据已经上传完了
  s.shutdownOutput();
  String info=in.readLine();//读取返回信息
  System.out.println(info);
  fis.close();//关流
  s.close();
 }
}

//服务端
class PicServer
{
 public static void main(String[] args)throws Exception
 {
  //创建服务,监听端口
  ServerSocket ss=new ServerSocket(10000);

  while (true)
  {
   //获取客户端对象
   Socket s=ss.accept();
   //客户端执行线程
   new Thread(new PicThread(s)).start();
  }
    //ss.close();
 }
}
//利用多线程实现并发上传
class PicThread implements Runnable
{
 private Socket s;
 PicThread(Socket s)
 {
  this.s=s;
 }
 public void run()
 {
  int count=1;
  //获取客户端ip
  String ip=s.getInetAddress().getHostAddress();
  try
  {  
   System.out.println(ip+"  connected.....");

   //通过客户端的读取流读取数据
   InputStream in=s.getInputStream();
   //文件保存路径
   File dir =new File("C:\\Users\\asus\\Desktop");
   //文件名
   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);
   }
   //将收到图片数据的信息返回给客户端
   OutputStream out=s.getOutputStream();   
   out.write("上传成功!".getBytes());
   fos.close();//关流
   s.close();
  }
  catch (Exception e)
  {
   throw new RuntimeException(ip+"图片上传失败");
  }
 }
}
(3)客户端和服务的浏览器演示
    浏览器是一个标准的客户端,它可以对服务端传送过来的数据消息进行解析,把符合应用层协议的消息部分解析后,将头信息拆包掉,传送到应用层,只保留了正确的正文主题部分显示在主体部分上。
    而由于使用java编译是在传输层和网际层处理的,所以,会接受到全部的消息,包含了头消息。而浏览器处于应用层,已将发送来的头消息去除,只留下了主体信息。
示例:
    自定义服务器,用浏览器访问。

代码示例:

演示客户端和服务端。
1,
客户端:浏览器 (telnet)
服务端:自定义。
2,
客户端:浏览器。
服务端:Tomcat服务器。
3,
客户端:自定义。(图形界面)
服务端:Tomcat服务器。
import java.net.*;
import java.io.*;
class ServerDemo
{
 public static void main(String[] args) throws Exception
 {
  ServerSocket ss = new ServerSocket(11000);
  Socket s = ss.accept();
  System.out.println(s.getInetAddress().getHostAddress());
  InputStream in = s.getInputStream();
  byte[] buf = new byte[1024];
  int len = in.read(buf);
  System.out.println(new String(buf,0,len));
  PrintWriter out = new PrintWriter(s.getOutputStream(),true);
  out.println("<font color='red' size='2'>客户端你好</font>");
  s.close();
  ss.close();
 }
}

黑马程序员————学习日记【3】 【Java基础编程2】

------- android培训、java培训、期待与您交流! ----------   一、循环结构   1、 while:先判断条件,只有条件满足才执行循环体 do whil...

黑马程序员——JAVA基础---网路编程---概述,UDP/TCP对应Socket,小知识点

第一讲. 概述 网络通信要素:IP(本地回环地址 127.0.0.1 ,主机名localhost), 端口(0~65535),  协议 网络层次:OSI参考模型,7层参考模型;TCP/IP的参考模型:...

黑马程序员---java基础---7网路编程

---------------------- ASP.Net+Android+IOS">http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发...

Java基础<十八>---> 网路编程

--------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流! --------------- 第一  概述 一、概述: 1、网络模型:OSI参考模...

Java基础日记———多线程

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- 一.概述 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程...

Java基础日记———Map

——<a href=”http://www.itheima.com” target=”blank”>Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! ——- 一....

Java基础日记———异常

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- 一.概述 (1)异常:就是程序在运行时出现不正常情况。 异常由来:问题也是现实生活中一个具体的事物...

Java基础日记———String

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-一.概述 Java中万物皆对象。 字符串是一个特殊的对象。 字符串一旦初始化就不可以...

Java基础日记———IO流(下)

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——- 一.概述 1.File: 用来将文件或者文件夹封装成对象。 方便对文件与文件夹的属...

Java基础日记———Java的三大特性(下)

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-一.继承 1.继承概述: (1)提高了代码的复用性。 (2)让类与类之间产生了关系。有了这个关系,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java基础日记———网路编程
举报原因:
原因补充:

(最多只允许输入30个字)