黑马程序员——java第二十三天：网络编程

------- android培训、java培训、期待与您交流！ ----------span> 

网络编程

有效端口：0—65535；系统端口：0—1024；

web端口：80；

Tomcat默认端口：8080；

MySql默认端口:3306

 

协议：tcp、udp

 

IP：网络地址；端口：程序端口；协议：通讯规则；

本地地址：127.0.0.1对应的主机名：localhost

 

javaWeb开发在应用层，

每个层都有特定的协议：传输层的协议为：TCP、UDP

                                          网际层协议为：IP

                                          应用层的协议为：FTP、HTTP

ip地址

网络程序组件类在：java.net包中。

用于描述IP的类InetAddress

       方法：

      

static InetAddress	getLocalHost() 返回本地主机。
static InetAddress	getByName(String host) 在给定主机名的情况下确定主机的 IP 地址。（主机名可以是机器名（如 "java.sun.com"），也可以是其 IP 地址的文本表示形式。如果提供字面值 IP 地址，则仅检查地址格式的有效性。）
static InetAddress[]	getAllByName(String host)             在给定主机名的情况下，根据系统上配置的名称服务返回其 IP 地址所组成的数组。
String	getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
String	getHostName()  获取此 IP 地址的主机名。

例子：

import java.net.*;

publicclass IpDemo {

 

   publicstaticvoid main(String[] args) throws Exception {

      //获取本地InetAddress对象，分别提取地址和主机名

      InetAddress i=InetAddress.getLocalHost();

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

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

      //获取网络InetAddress对象，分别提取地址（有可能地址不止一个所以getAllByName获取所有地址；getByName只能获取一个）和主机名

      InetAddress[] ia=InetAddress.getAllByName("www.sina.com.cn");

      for(InetAddress a:ia){

         System.out.println("ip地址:"+a.getHostAddress());

         System.out.println("主机名:"+a.getHostName());

      }

   }

}

 

 

 

TCP和UDP

UDP：面向无连接：

       将数据及原和目的封装成数据包中，不需要建立连接

       封装发送每个包并且每个包不可超过64k（超过则分装发送）

       因为无连接所以是不可靠的协议（不管你在不在线都可以发送）

       不需要建立连接，速度快

用UDP比如：聊天、视频。

 

TCP：面向连接

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

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

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

       必须建立连接，效率会稍低

用TCP比如：下载

Socket(插座)

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

通信的两端都有Socket（网络编程就是Socket编程）

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

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

 

UDP-发送端、接收端

类DatagramSocket：用来发送和就收数据报包的套接字（插座）

       方法：

             

void	receive(DatagramPacket p)             从此套接字接收数据报包。
void	send(DatagramPacket p)              从此套接字发送数据报包。

 

类DatagramPacket：数据报包用来实现无插座连接投递服务，每条报文仅根据该包中包含的信息从一台机器路由到另一台机器。

 

例子：

发送端：

 

定义一个udp发送端。

思路：

1，建立updsocket服务。

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

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

4，关闭资源。

 

import java.io.*;

import java.net.*;

 

//import java.util.Scanner;

publicclass UdpSend {

 

   publicstaticvoid main(String[] args) throws IOException {

      //1、创建udp服务，设置端口，通过DatagramSocket对象

      DatagramSocket ds=new DatagramSocket(6666);

//    Scanner sc=new Scanner(System.in);   

//    String str=sc.next(); 

      BufferedReader br=new BufferedReader(newInputStreamReader(System.in));

      String len=null;byte[] buf = null;

      while((len=br.readLine())!=null){

         if(len.equals("over"))

            break;

         buf=len.getBytes();

         //2、确定数据，并封装成数据包

         DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.100"),8888);

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

         ds.send(dp); 

      }        

//    sc.close();

      //4、关闭资源

      ds.close();     

   }

}

 

 

 

 

 

定义udp的接收端。

思路：

1，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。

       方便于明确哪些数据过来该应用程序可以处理。

 

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

因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

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

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

5，关闭资源。

接收端：

import java.io.IOException;

import java.net.*;

publicclass UdpReceive {

 

   publicstaticvoid main(String[] args) throws IOException {

      //1、创建udp socket,建立端点；

      DatagramSocket ds=new DatagramSocket(8888);

      while(true){

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

      byte[] ch=newbyte[1024*64];

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

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

      ds.receive(dp);

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

      InetAddress add=dp.getAddress();Stringaddress=add.getHostAddress();

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

//    if(data.equals("over"))

//       break;

      int port=dp.getPort();

      System.out.println("address="+address+".port"+port+'\r'+".data="+data);

      }

      //5、关闭资源

//    ds.close();

   }

}

 

 

 

 

TCP传输

1、TCP分客户端和服务器端

2、客户端对应的对象时Socket

服务端对应的对象是ServerSocket

 

类Socket：此类实现客户端套接字（套接字是两台机器间通信的断点）

构造方法1：Socket（）；构造方法创建一个流套接字，可以通过方法void connect（SocketAddress endpoint）；方法将此套接字连接到服务器。

 

构造方法2：Socket（InetAddress address，int port）：创建一个流套接字并找其连接到指定IP地址的指定端口。

 

客户端：

       通过查阅Socket对象，发现在该对象建立时，就可以去连接指定主机。因为tcp是面向连接的。所以在建立

Socket服务时，就要有服务端存在，并连接成功。形成通路后再该通道进行数据的传输。

 

步奏:

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

 

方法：

1、OutputStreamgetOutputStream（）；返回此套接字的输出流

2、InputStreamgetInputStream（）；返回此套接字的输入流。

 

服务端：

1、建立服务端的Socket服务。ServerSocket();并监听一个端口。

构造：ServerSocket（int port）创建绑定到特定端口的服务套接字。获取连接过来的客户端对象。

               ServerSocket(int port, int backlog)
          利用指定的 backlog(同时连接到服务器客户端的最大个数)创建服务器套接字并将其绑定到指定的本地端口号。

通过ServerSocket的accept方法，没有连接就等到，所以accept是阻塞式方法。

2、客户端如果发过来数据，那么服务端要获得并使用对应的客户端对象获取到该客户端对象的读取流来读取发过来的数据。

3、关闭服务端（可选操作）

 

例子：

import java.io.*;

import java.net.*;

//客户端：

class  TcpClient

{

       public static voidmain(String[] args) throws Exception 

       {

              //创建客户端的socket服务。指定目的主机和端口

              Socket s = newSocket("192.168.1.254",10003);

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

              OutputStream out= s.getOutputStream();

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

              s.close();

       }

}

 

服务端：

class  TcpServer

{

       public static voidmain(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 = newbyte[1024];

              int len =in.read(buf);

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

              s.close();//关闭客户端.

              }

              //ss.close();

       }

}

 

 

 

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

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

 

客户端：

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

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

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

4，关闭客户端资源。

class TcpClient2 

{

      public static voidmain(String[] args)throws Exception 

      {

             Socket s = newSocket("192.168.1.254",10004);

/*可代替

Socket s = new Socket()；

s.connect(newInetSocketAddress("192.168.1.254",10004));

*/

             OutputStream out =s.getOutputStream();

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

             

             InputStream in =s.getInputStream();

             byte[] buf = newbyte[1024];

             int len =in.read(buf);

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

             s.close();

      }

}

 

class TcpServer2

{

      public static voidmain(String[] args) throws Exception

      {

             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(newString(buf,0,len));

             OutputStream out =s.getOutputStream();

             Thread.sleep(10000);

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

             s.close();

             ss.close();

      }

}

 

 

 

注意事项：

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

客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。

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

 

分析：

客户端：

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

源：键盘录入。

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

而且操作的是文本数据。可以选择字符流。

 

步骤

1，建立服务。

2，获取键盘录入。

3，将数据发给服务端。

4，后去服务端返回的大写数据。

5，结束，关资源。

 

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

 

 

*/

import java.io.*;

import java.net.*;

class  TransClient

{

      public static voidmain(String[] args) throws Exception

      {

             Socket s = newSocket("192.168.1.254",10005);

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

             BufferedReaderbufr = 

                    newBufferedReader(new InputStreamReader(System.in));

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

             //BufferedWriterbufOut = 

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

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

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

             BufferedReaderbufIn = 

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

             String line =null;

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

             {

                    if("over".equals(line))

                           break;

                    out.println(line);

//                 bufOut.write(line);

//                 bufOut.newLine();//换行标记，作为发送标记

//                 bufOut.flush();//记得要把数据从缓冲区属性到流中。

                    String str=bufIn.readLine();

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

             }

             bufr.close();

             s.close();

      }

}

/*

 

服务端：

源：socket读取流。

目的：socket输出流。

都是文本，装饰。

 

 

 

*/

 

class  TransServer

{

      public static voidmain(String[] args) throws Exception

      {

             ServerSocket ss =new ServerSocket(10005);

             Socket s =ss.accept();

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

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

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

             BufferedReaderbufIn =

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

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

             //BufferedWriterbufOut = 

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

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

             String line =null;

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

             {

                    System.out.println(line);

                    out.println(line.toUpperCase());

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

//                 bufOut.newLine();

//                 bufOut.flush();

             }

             s.close();

             ss.close();

      }

}

 

 

/*

该例子出现的问题。

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

为什么呢？

因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等

而导致两端，都在等待。

文件拷贝—结束符

void	shutdownInput()（如果在套接字上调用  shutdownInput() 后从套接字输入流读取内容，则流将返回  EOF（文件结束符）。）             此套接字的输入流置于“流的末尾”。
void	shutdownOutput()（对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。）             禁用此套接字的输出流。

 

 

import java.io.*;

import java.net.*;

 

class  TextClient

{

      public static voidmain(String[] args) throws Exception

      {

             Socket s = newSocket("192.168.1.254",10006);

             BufferedReaderbufr = 

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

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

             String line =null;

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

             {

                    out.println(line);

             }

             s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.

             

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

             String str =bufIn.readLine();

             System.out.println(str);

             bufr.close();

             s.close();

      }

}

class  TextServer

{

      public static voidmain(String[] args) throws Exception

      {

             ServerSocket ss =new ServerSocket(10006);

             Socket s =ss.accept();

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

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

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

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

             String line =null;

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

             {

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

                           //break;

                    out.println(line);

             }

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

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

             out.close();

             s.close();

             ss.close();

      }

}

 

 

上传图片

/*

需求：上传图片。

 

 

 

*/

/*

客户端。

1，服务端点。

2，读取客户端已有的图片数据。

3，通过socket 输出流将数据发给服务端。

4，读取服务端反馈信息。

5，关闭。

 

*/

 

import java.io.*;

import java.net.*;

class PicClient

{

       publicstatic void main(String[] args)throws Exception 

       {

              Sockets = new Socket("192.168.1.254",10007);

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

              OutputStreamout = s.getOutputStream();

              byte[]buf = new byte[1024];

              intlen = 0;

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

              {

                     out.write(buf,0,len);

              }

              //告诉服务端数据已写完

              s.shutdownOutput();

              InputStream in = s.getInputStream();

              byte[]bufIn = new byte[1024];

              intnum = in.read(bufIn);

              System.out.println(newString(bufIn,0,num));

              fis.close();

              s.close();

       }

}

 

/*

服务端

*/

class PicServer

{

       publicstatic void main(String[] args) throws Exception

       {

              ServerSocketss = new ServerSocket(10007);

              Sockets = ss.accept();

              InputStreamin = s.getInputStream();

              FileOutputStreamfos = new FileOutputStream("server.bmp");

              byte[]buf = new byte[1024];

              intlen = 0;

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

              {

                     fos.write(buf,0,len);

              }

              OutputStreamout = s.getOutputStream();

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

              fos.close();

              s.close();

              ss.close();

       }

}

 

 

服务器多线程

/*

需求：上传图片。

*/

/*

客户端。

1，服务端点。

2，读取客户端已有的图片数据。

3，通过socket 输出流将数据发给服务端。

4，读取服务端反馈信息。

5，关闭。

 

*/

 

import java.io.*;

import java.net.*;

class PicClient

{

       publicstatic void main(String[] args)throws Exception 

       {

              if(args.length!=1)

              {

                     System.out.println("请选择一个jpg格式的图片");

                     return;

              }

              Filefile = 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;

              }

              Sockets = new Socket("192.168.1.254",10007);

              FileInputStreamfis = new FileInputStream(file);

              OutputStreamout = s.getOutputStream();

              byte[]buf = new byte[1024];

              intlen = 0;

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

              {

                     out.write(buf,0,len);

              }

              //告诉服务端数据已写完

              s.shutdownOutput();

              InputStreamin = s.getInputStream();

              byte[]bufIn = new byte[1024];

              intnum = in.read(bufIn);

              System.out.println(newString(bufIn,0,num));

              fis.close();

              s.close();

       }

}

 

/*

服务端

这个服务端有个局限性。当A客户端连接上以后。被服务端获取到。服务端执行具体流程。

这时B客户端连接，只有等待。

因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以

暂时获取不到B客户端对象。

那么为了可以让多个客户端同时并发访问服务端。

那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。

 

如何定义线程呢？

要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。

*/

class PicThread implements Runnable

{

       privateSocket s;

       PicThread(Sockets)

       {

              this.s= s;

       }

       publicvoid run()

       {

              intcount = 1;

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

              try

              {

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

                     InputStreamin = s.getInputStream();

                     Filedir =  new File("d:\\pic");

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

                     while(file.exists())

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

                     FileOutputStreamfos = new FileOutputStream(file);

                     byte[]buf = new byte[1024];

                     intlen = 0;

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

                     {

                            fos.write(buf,0,len);

                     }

                     OutputStreamout = s.getOutputStream();

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

                     fos.close();

                     s.close();

              }

              catch(Exception e)

              {

                     thrownew RuntimeException(ip+"上传失败");

              }

       }

}

class PicServer

{

       publicstatic void main(String[] args) throws Exception

       {

              ServerSocketss = new ServerSocket(10007);

              while(true)

              {

                     Sockets = ss.accept();

                     newThread(new PicThread(s)).start();

              

              }

              //ss.close();

       }

}

 

 

客户端并发登陆

/*

客户端通过键盘录入用户名。

服务端对这个用户名进行校验。

 

如果该用户存在，在服务端显示xxx，已登陆。

并在客户端显示 xxx，欢迎光临。

 

如果该用户存在，在服务端显示xxx，尝试登陆。

并在客户端显示 xxx，该用户不存在。

 

最多就登录三次。

*/

import java.io.*;

import java.net.*;

 

class LoginClient

{

       publicstatic void main(String[] args) throws Exception

       {

              Sockets = new Socket("192.168.1.254",10008);

              BufferedReaderbufr = 

                     newBufferedReader(new InputStreamReader(System.in));

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

              BufferedReaderbufIn =

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

              for(intx=0; x<3; x++)

              {

                     Stringline = bufr.readLine();

                     if(line==null)

                            break;

                     out.println(line);

                     Stringinfo = bufIn.readLine();

                     System.out.println("info:"+info);

                     if(info.contains("欢迎"))

                            break;

              }

              bufr.close();

              s.close();

       }

}

class UserThread implements Runnable

{

       privateSocket s;

       UserThread(Sockets)

       {

              this.s= s;

       }

       publicvoid run()

       {

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

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

              try

              {

                     for(intx=0; x<3; x++)

                     {

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

 

                            Stringname = bufIn.readLine();

                            if(name==null)

                                   break;

                            BufferedReaderbufr = new BufferedReader(new FileReader("user.txt"));

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

                            Stringline = null;

                            booleanflag = false;

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

                            {

                                   if(line.equals(name))

                                   {

                                          flag= true;

                                          break;

                                   }                           

                            }

                            

                            if(flag)

                            {

                                   System.out.println(name+",已登录");

                                   out.println(name+",欢迎光临");

                                   break;

                            }

                            else

                            {

                                   System.out.println(name+",尝试登录");

                                   out.println(name+",用户名不存在");

                            }

                     }

                     s.close();

              }

              catch(Exception e)

              {

                     thrownew RuntimeException(ip+"校验失败");

              }

       }

}

class LoginServer

{

       publicstatic void main(String[] args) throws Exception

       {

              ServerSocketss = new ServerSocket(10008);

              while(true)

              {

                     Sockets = ss.accept();

                     newThread(new UserThread(s)).start();

              }

       }

}

 

 

自定义浏览器-Tomcat服务端

传输层（Socket服务）

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.net.*;

class MyIEByGUI

{

       privateFrame f;

       privateTextField tf;

       privateButton but;

       privateTextArea ta;

       privateDialog d;

       privateLabel lab;

       privateButton okBut;

       MyIEByGUI()

       {

              init();

       }

       publicvoid init()

       {

              f= new Frame("my window");

              f.setBounds(300,100,600,500);

              f.setLayout(newFlowLayout());

              tf= new TextField(60);

              but= new Button("转到");

              ta= new TextArea(25,70);

              d= new Dialog(f,"提示信息-self",true);

              d.setBounds(400,200,240,150);

              d.setLayout(newFlowLayout());

              lab= new Label();

              okBut= new Button("确定");

              d.add(lab);

              d.add(okBut);

              f.add(tf);

              f.add(but);

              f.add(ta);

              myEvent();

              f.setVisible(true);

       }

       privatevoid  myEvent()

       {

              okBut.addActionListener(newActionListener()

              {

                     publicvoid actionPerformed(ActionEvent e)

                     {

                            d.setVisible(false);

                     }

              });

              d.addWindowListener(newWindowAdapter()

              {

                     publicvoid windowClosing(WindowEvent e)

                     {

                            d.setVisible(false);

                     }

              });

              tf.addKeyListener(newKeyAdapter()

              {

                     publicvoid keyPressed(KeyEvent e)

                     {

                            try

                            {

                                          if(e.getKeyCode()==KeyEvent.VK_ENTER)

                                   showDir();

                            }

                            catch(Exception ex)

                            {

                            }

                     

                     }

              });

              but.addActionListener(newActionListener()

              {

                     publicvoid actionPerformed(ActionEvent e)

                     {

                            try

                            {

                                   showDir();

                            }

                            catch(Exception ex)

                            {

                            }                    }

              });

              f.addWindowListener(newWindowAdapter()

              {

                     publicvoid windowClosing(WindowEvent e)

                     {

                            System.exit(0);    

                     }

              });

       }

       privatevoid showDir()throws Exception

       {

              ta.setText("");

              Stringurl = tf.getText();//http://192.168.1.254:8080/myweb/demo.html

              

              intindex1 = url.indexOf("//")+2;

              intindex2 = url.indexOf("/",index1);

              Stringstr = url.substring(index1,index2);

              String[]arr = str.split(":");

              Stringhost = arr[0];

              intport = Integer.parseInt(arr[1]);

              Stringpath = url.substring(index2);

              //ta.setText(str+"...."+path);

              Sockets = new Socket(host,port);

              

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

              out.println("GET"+path+" HTTP/1.1");

              out.println("Accept:*/*");

              out.println("Accept-Language:zh-cn");

              out.println("Host:192.168.1.254:11000");

              out.println("Connection:closed");

   //在请求头里空行标记

              out.println();

              out.println();

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

              Stringline = null;

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

              {

                     ta.append(line+"\r\n");

              }

              s.close();

       }

       publicstatic void main(String[] args) 

       {

              newMyIEByGUI();

       }

}

 

 

 

DOS命令访问服务器：telnet192.168.1.1（地址） 8080（端口）

自定义图形界面浏览器-Tomcat服务端

应用层（URLConnection封装）

URLConnection封装简化上面代码

类URL：

方法：

String	getFile()（例：/myweb/demo.html?name=zhangsan&age=30）             获取此URL的文件名。
String	getHost()             获取此URL的主机名（如果适用）。
String	getPath()（例：/myweb/demo.html）             获取此URL的路径部分。
int	getPort()获取此URL的端口号。 当端口为空时此方法返回-1.可以通过判断设定默认端口 Int por=getPort(); If(port==-1) Port=8080;
String	getProtocol()             获取此URL的协议名称。
String	getQuery() (例：name=zhangsan&age=30)             获取此URL的查询部分。
URLConnection	openConnection()             返回一个  URLConnection 对象，它表示到  URL 所引用的远程对象的连接。
InputStream	openStream() （内部封装openConnection().getInputStream() ）打开到此 URL 的连接并返回一个用于从该连接读入的 InputStream。

这些方法就省去了如上面例题中为了获取部分地址而切割String地址。

 

类URLConnection：（封装有socket对象）

它代表应用程序和 URL 之间的通信链接。此类的实例可用于读取和写入此 URL 引用的资源。通常，创建一个到 URL 的连接需要几个步骤：

openConnection()	connect()
对影响到远程资源连接的参数进行操作。	与资源交互；查询头字段和内容。

---------------------------->
时间

1. 通过在 URL 上调用     openConnection 方法创建连接对象。
2. 处理设置参数和一般请求属性。
3. 使用 connect     方法建立到远程对象的实际连接。
4. 远程对象变为可用。远程对象的头字段和内容变为可访问。    

经过此类的的解析拆包就不会有像上例题中的请求头代码了，只有有效的主体。（此对象走的是应用层，上例题中（Socket走的是传输层）

importjava.awt.*;

importjava.awt.event.*;

importjava.io.*;

importjava.net.*;

class  MyIEByGUI2

{

       private Frame f;

       private TextField tf;

       private Button but;

       private TextArea ta;

              privateDialog d;

       private Label lab;

       private Button okBut;

       MyIEByGUI2()

       {

              init();

       }

       public void init()

       {

              f = new Frame("mywindow");

              f.setBounds(300,100,600,500);

              f.setLayout(new FlowLayout());

              tf = new TextField(60);

              but = new Button("转到");

              ta = new TextArea(25,70);

              d = new Dialog(f,"提示信息-self",true);

              d.setBounds(400,200,240,150);

              d.setLayout(new FlowLayout());

              lab = new Label();

              okBut = new Button("确定");

              d.add(lab);

              d.add(okBut);

              f.add(tf);

              f.add(but);

              f.add(ta);

              myEvent();

              f.setVisible(true);

       }

       private void  myEvent()

       {

              okBut.addActionListener(newActionListener()

              {

                     public voidactionPerformed(ActionEvent e)

                     {

                            d.setVisible(false);

                     }

              });

              d.addWindowListener(newWindowAdapter()

              {

                     public voidwindowClosing(WindowEvent e)

                     {

                            d.setVisible(false);

                     }

              });

              tf.addKeyListener(new KeyAdapter()

              {

                     public voidkeyPressed(KeyEvent e)

                     {

                            try

                            {

                                          if(e.getKeyCode()==KeyEvent.VK_ENTER)

                                   showDir();

                            }

                            catch (Exception ex)

                            {

                            }

                     

                     }

              });

              but.addActionListener(newActionListener()

              {

                     public voidactionPerformed(ActionEvent e)

                     {

                            try

                            {

                                   showDir();

                            }

                            catch (Exception ex)

                            {

                            }

                     }

              });

              f.addWindowListener(newWindowAdapter()

              {

                     public voidwindowClosing(WindowEvent e)

                     {

                            System.exit(0);    

                     }

              });

       }

       private void showDir()throws Exception

       {

              ta.setText("");

              String urlPath =tf.getText();//http://192.168.1.254:8080/myweb/demo.html

              URL url = new URL(urlPath);

              URLConnection conn =url.openConnection();

              InputStream in =conn.getInputStream();

 

              byte[] buf = new byte[1024];

 

              int len = in.read(buf);

 

              ta.setText(new String(buf,0,len));

 

       }

 

       public static void main(String[] args) 

       {

              new MyIEByGUI2();

       }

}

 

 

域名解析

------- android培训、java培训、期待与您交流！ ----------详细请查看：http://edu.csdn.net

 

 

 

 ------- android培训、java培训、期待与您交流！ ----------详细请查看：http://edu.csdn.net