TCP、UDP网络编程

一、网络通信基本点

两台机器要想相互进行通讯的话，必须具备的三个基本条件：
1、找到对方的ip地址（也就是逻辑地址）
2、数据发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行了标识，为了方便称呼这个数字，叫做“端口”。这里的“端口”叫做逻辑端口，不是物理上的那种“端口”（也就是逻辑上的入口）
3、定义通讯规则。这个通讯规则，成为网络协议，国际组织定义了通讯协议TCP/IP协议（也就是逻辑上的交流语言）。

二、端口号
1、概述：
自己知道，每一个通讯类程序都有自己的端口号，但是应该配置多少的端口号呢？0到65535之间，想用哪个用哪个。一般情况下：0到1024端口都是系统默认调用的，自己也可以使用，但是后期可能出现错误，自己要掂量着点！

2、疑惑：
那么网络应用程序是怎样自动进行端口的分配的呢？这里就是关键，实际上，网络应用程序在进行端口的匹配的时候，是自己进行检测的，如果自己想要使用的端口号被别的程序使用的话，那么只能往后顺延了。也就是进行+1处理。

三、网络模型
OSI（OpenSystemInterconnect）全称“开放系统互联”，是由IBM公司提出的，将网络分成了7个层次，从上到下依次是：
“应用层”
“表示层”
“会话层”
“传输层”
“网络层”
“数据链路层”
“物理层”

但是鉴于上面的分层比较复杂，所以TCP/IP协议将网络模型分成了四层，从上到下依次：
“应用层”（java web开发等应用）
“传输层”（自己现在正在这个层混呢！）
“网际层”（自己现在正在这个层混呢！）
“主机至网络层”（这个属于硬件级别）

四、TCP和UDP传输协议的不同
UDP：
1、将数据以及源和目的封装成数据包中，不需要建立连接。
2、每个数据包的大小限制在64k内。
3、因为是无连接的，所以是不可靠的协议。
4、不需要建立连接，速度快。
UDP协议传输因为不建立连接，所以不安全，虽然不安全，但是是效率高的，一般的“视频会议”什么的都是使用的UDP协议传输的，这是为了最大限度的提高效率而产生的一种协议。

TCP：
1、建立连接，形成传输数据的通道。
2、在连接中进行大数据量的传输。
3、通过三次握手完成链接，是可靠的协议。
4、必须建立连接，效率会低下一点儿。
常见的TCP协议的实际应用就是电话，如果没有建立连接的话，就不可能进行通讯，因为是安全的一种协议，所以为了保证双方的通话安全，还是是使用的tcp协议，虽然效率有点低。

五、“socket套接字”简介
1、概述：
首先自己要明白什么是socket？socket直译过来就是“插座”的意思，也就是链接两个端点的一条通路。自己要知道的是，所有的网络编程都是使用的socket编程，不管是客户端还是服务器端，都是使用的socket编程来实现的。

2、路由：
作为一个网络编程人员，大家都知道路由器，但是知道什么是路由么？首先上来一句话“路由到另一台机器上”这句话的意思就是：找到另一台机器！

六、InetAddress类简单介绍
1、常用方法：
想要获取自己想要网址的ip地址吗？这里有个跟ip地址有关的类是InteAddress类，里面的方法相当的不错，其中常用的几个：
getAddress();返回对象的原始ip地址
getAllByName(String host);返回一个地址的所有的ip地址内容
getByAddress(byte[] addr);给定的原始ip地址的情况下，返回InteAddress对象
getByName(String host);在给定主机的情况下，返回ip地址
还有很多详细的方法 ，都在自己的api文档中的InetAddress类中，自己可以详细的进行查询，相当的有意思的。

2、小程式演示：
下面小程式将常用方法都演示了。

public static void main(String[] args) throws UnknownHostException {
 InetAddress[] in=InetAddress.getAllByName("www.xiaomi.com");
 InetAddress ia=InetAddress.getLocalHost();
 //输出"www.xiaomi.com"的所有ip地址
 for(int i=0;i<in.length;i++){
  System.out.println("ip::"+in[i]);
 }
 //返回本机的名字
 String name=ia.getHostName();
 System.out.println("本机名称："+name);
 //返回本机原始的ip地址
 byte[] b=ia.getAddress();
 System.out.print("本机原始ip地址：");
 for(int j=0;j<b.length;j++){
  System.out.print(b[j]);
 }
 //返回www.baidu.com的ip地址
 InetAddress ia1=InetAddress.getByName("www.baidu.com");
 String name1=ia1.getHostAddress();
 System.out.println("\r\n"+name1);
 //返回此ip的哈希码
 int num=name1.hashCode();
 System.out.println(num);
}

七、UDPsocket套接字编程思想
1、UDP发送端：
进行socket编程的时候，首先需要自己确认的一点是“到底该使用UDP还是TCP？？？”自己这里先介绍一下UDP不安全通讯协议，下面介绍的是发送端的编程思想。
创建UDP发送端的过程如下：
程式需求（通过udp传输方式，发送端将一段文字发送出去）。
（1）、建立udpsocket（udp套接字）服务。
（2）、提供数据，然后将这些数据封装到数据包中。
（3）、通过socket服务终端中的“发送功能”，将数据包发送出去。
（4）、关闭socket资源。
下面是相应步骤代码：
//步骤一：创建socket服务。
DatagramSocket ds=new DatagramSocket();
//步骤二：将内容转换成字节数组，定义成数据包，并且将这个数据进行封装。
byte[] buf="hello ,nice to meet you!".getBytes();
DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.104"),10000);
//步骤三：发送数据包
ds.send(dp);
//步骤四：关闭socket
ds.close();
上面是一次发送的内容，可以将上面的代码加入到while循环中，然后可以循环的发送内容，就像发送一个文件一样。

 

2、UDP接收端：
需求：和前面定义的发送端相对应，这里需要接收发送端发送的一段数据包。
（1）、首先定义UDPsocket服务，使用DatagramSocket类创建对象，因为DatagramSocket既可以创建发送端，也可以创建接收端。通常会监听一个端口，因为发送端定义了像一个端口发送数据包的过程。其实就是给这个网络应用程序定义数字表示符，方便了明确哪些数据过来应该被程序接收。
（2）、定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中有更多地方法可以被调用，从而实现数据的被提取。
（3）、通过DatagramSocket服务中的receive方法，可以将数据存入已经事先定义好的数据包中。
（4）、通过数据包对象的特有方法，可以实现数据的取出，最后打印到自己想要的地方。
（5）、最后一步 ，关闭资源。
下面是相应步骤的代码：

byte[] buf=new byte[1024];    //自定义缓冲区
DatagramPacket dp=new DatagramPacket(buf,buf.length); //自定义本地准备存储数据的数据包
ds.receive(dp);  //只有DatagramSocket才可以使用自身的方法receive方法进行数据包的接受，这句换的意思是将接收到的数据包存放在dp这个自己定义的数据包中
String ip=dp.getAddress().getHostAddress();  //从数据包中获取ip地址
String data=new String(dp.getData(),0,dp.getLength()); //从数据包中获取数据内容
System.out.println("ip地址："+ip+"....对话："+data);  //在控制台进行打印

 

3、UDP发送和接收的小程式

class Sender implements Runnable{
 private DatagramSocket ds;  //需要进行传值操作才进行定义的一个变量引用
 public Sender(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){
    if(line.equals("over"))
     break;
    byte[] buf=line.getBytes(); //将line内容转换成byte数组
    DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.107"),10000);//将键盘输入的数据打包
    ds.send(dp);  //打包之后进行发送操作
   }
  }catch(Exception e){
   throw new RuntimeException("sender error");//抛出 异常
  }
 }
}
class Receiver implements Runnable{
 private DatagramSocket ds;
 public Receiver(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); //只有DatagramSocket才可以使用自身的方法receive方法进行数据包的接受，这句换的意思是将接收到的数据包存放在dp这个自己定义的数据包中
    String ip=dp.getAddress().getHostAddress();  //从数据包中获取ip地址
    String data=new String(dp.getData(),0,dp.getLength()); //从数据包中获取数据内容
    System.out.println("ip地址："+ip+"....对话："+data);  //在控制台进行打印
   }
  }catch(Exception e){
   throw new RuntimeException("receiver error"); //抛个异常
  }
 }
}
public class UDPchatDemo {
 public static void main(String[] args) throws SocketException {
  DatagramSocket sendSocket=new DatagramSocket(); //创建DatagramSocket对象，下面的这个对象之所以后面会跟上端口号
  DatagramSocket receSocket=new DatagramSocket(10000); //接收端监听的端口号是10000
  new Thread(new Sender(sendSocket)).start(); //传值操作，启动多线程
  new Thread(new Receiver(receSocket)).start();
 }

八、TCPsocket编程
客户端：Socket
服务器端：ServerSocket

1、客户端创建的基本套路：
（1）、创建客户端服务Socket s=new Socket("对方ip地址"，对方端口号);
（2）、通过api文档可以看到，客户端包含“输入流”和“输出流”，所以如果使用的是“输出流”，就是用OutputSteam out=s.getOutputStream();所以相应的out对象可以实现的内容就是write()方法，从而实现数据的“发送“功能。InputStream in=s.getInputStream();可以调用s对象的输入的功能，从而实现数据的”接受“功能。
（3）、假如自己需要的功能是一个”输出“的功能，然后，向数据包中写入数据，那么就可以使用out对象中的write()方法进行”写入操作“，这都是自己先开始学习过的内容了，相当的方便使用。
（4）、最后一步，别忘了关流，因为客户端会一直占用着系统的资源。
示例代码：

Socket s=new Socket("192.168.1.254",10000); //发送到指定机器上的指定端口上

OutputStream out=s.getOutputStream();  //使用对象s的“输出流”进行输出

out.write("hahahhahhah".getBytes());  //向输出流中写入一行String类型的数据转换成byte数组

s.close();     //关流操作

2、服务端创建的基本套路：
TCP服务器端的创建方式和UDP的创建方式不是太相同的，TCP使用的是ServerSocket创建服务，启动服务程序。TCP服务器端的创建方式：

 

（1）、创建“服务器端”的服务，启动该服务：ServerSocket ss=new ServerSocket(端口号);
解释：因为服务器的主机只有一台，客户端都是为了连接到这台服务器，这个服务器的端口号是事先定义的，客户端要自己连接到这台主机上的这个端口号上，所以这个主机服务器上的端口号是唯一的，客户端想要连接到这个服务器上，就要在创建客户端服务的时候写上这个服务器上的ip地址和端口号。
（2）、其次，对象ss调用accept()方法，接受数据，返回的是socket类型的对象，然后返回到socket类中寻找方法功能，也就是类的内功！如果自己需要接受客户端发过来的数据流，对象ss调用getInputStream()方法，返回的类型自己找api文档即可。
（3）、服务器端不能关闭，因为他是服务器，一shutdown，客户就完了。
示例代码：

ServerSocket ss=new ServerSocket(10000);
Socket s=ss.accept();
InputStream in=s.getInputStream();
byte[] buf=new byte[1024];
int len=in.read(buf);
System.out.println(new String(buf,0,len));

3、结束标记
在键盘录入的时候，自己一定要注意的一点就是”结束标记“因为结束标记是一个字符输入结束的标记，如果没有结束标记，那么控制台只能一直等待结束的信号，陷入死循环中，这是相当不好的一种结果。在BufferedWriter和BufferedReader中，这种书写结束标记的时候，可以使用类自身自带的newLine()方法，可以结束标记，当然也可以使用“\r\n”进行结束。
没有结束标记就是“狂等”，一直等待。socket客户端有shutdownInput和shutdownOutput方法，分别用来结束“输入流”和“输出流”。

注意：ServerSocket是没有结束标记的，因为它是服务端！只有Socket才有结束标记！！自己以前定义结束标记的时候，都是使用的自定义结束标记。这样比较不专业。在socket服务中，其实创建对象之后可以使用对象中的方法进行程序的结束，是有结束标记的。可以使用对象调用shutdownOutput和shuntdownInput来结束“流”的运行，就不用自己在自定义结束标记了，相当的方便快捷！

4、服务器端ServerSocket
ServerSocket ss=new ServerSocket(port,backlog);创建服务器端对象的时候，里面有个参数引起自己的注意，就是backlog，backlog就是允许最大连接的数量，也就是说允许连接的最大客户端的人数。

九、IP简介
1、概述：
ip地址协议处于“网络层“，如果本机没有进行任何ip地址的配置的话，默认情况下就是使用的是：127.0.0.1（本地回环地址）

2、注意：
如果使用的是“局域网”的话，我自己想要修改自己的ip地址的话，我想怎样修改怎样修改，可以吗？答案非常的肯定的，但是如果自己修改，并且想要跟别人通讯的话，那么自己必须需要确定的是，前面的三个字段的数字必须相同的，举个例子，如果自己起的ip地址是1.1.1.1，那么别人如果想要跟自己通讯的话，必须前面三个字段也是1.1.1，最后一位在0到255之间随意。

3、知识点：
（1）、普及一知识点，ipv6（ipv4的升级版）自己平常使用的都是ipv4版本的，也就是说里面ip地址只有数字，没有别的内容，但是ipv6里面可以有字母。
（2）、Socket套接字或者DatagramSocket套接字获取ip地址的方法：String ip=s.getInetAddress().getHostAddress();（其中s是TCP套接字Socket或者是UDP套接字DatagramSocket创建的对象）

十、TCP&UDP多线程编程
1、概述：
TCP和UDP编程往往是和多线程有关系的，所以自己这里需要自己复习一下以前的”线程“功课。

2、线程小复习：
（1）、使用多线程的时候，一般可以使用两种方式创建线程。（1）、extends Thread  继承Tread类（2）、implements Runnable 执行Runnable接口，一般使用的是后面的这种方法，避免继承带来的程序臃肿。

（2）、线程的使用也是有一定的先后顺序的，确定了是一个线程类之后，那么里面需要重新定义run方法了，也就是复写run方法。所有的线程类都定义好之后，在主函数中启动线程的方法就是使用start方法，进行启动线程的操作。（这是对自己以前的内容进行了复习一个小复习）

十一、TCP并发访问
1、概述：
如果一个客户访问百度，一次只能处理一个访问者，那就不叫百度了。所以为了让所有的访问者都可以在同一时间内访问百度网站，需要使用多线程（并发访问）的概念，下面自己详细阐述一下并发访问的思想。

2、并发访问的思想：
（1）、客户端：和平常的定义是一样的，因为客户端是单个的，不会和其他的客户端有任何的牵连，所以以前客户端是怎样定义的，这里还是怎样定义的。
（2）、服务端：服务端和平常就不一样了，因为服务端以前一次只能处理一个客户端，现在想要同时处理N多个客户端的请求，所以必须不一样。既然牵扯到多线程的并发访问事件，首先思想上要想到定义一个线程类，线程类的内容咱先不用管，先来看看服务端，服务端是用来接收客户端发送过来的数据包的，所以需要定义ServerSocket之后，使用accept方法进行数据的接收操作，因为是服务器端，要不停地接受N多个客户端的链接的，所以直接定义一个while死循环，将前面说的accept方法放到while循环中，线程的启动自己知道吧？直接调用start方法就可以啦，所以在这个while循环中需要定义new Thread(new 自己定义的线程类(对象)).start()进行线程的启动，将这些新创建的线程对象直接放在这个while循环中。

3、不用担心：
这里说前面自己定义的线程类，自己知道创建线程的是使用的implements Runnable实现Runnable接口的方法，方法里面还需要自己复写run方法，run方法中需要try...catch一下，这个不用自己担心，在使用eclipse编程的时候，系统会提示到。在run方法之前需要进行传值操作，因为上面自己定义的服务端是用一个while死循环创建线程的，也就是说可以创建无穷无尽的线程，可以接受N多个客户端的请求，所以这里线程类的先开始用构造方法将服务器端接收到的数据包返回的socket作为传值对象传入到构造方法中，然后run方法中自己想要的内容。

4、废话：
以上是自己总结的定义多线程并发访问的一个”基本规则“，所有的并发访问的操作都是基于这个类型进行的，所以不用担心，在开发的时候，自己记住这个规则就可以！！

5、小程序演示：

TCP客户端：

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

/*
 * 客户端在并发访问的时候是不用更改什么代码的！
 * */
class Client{
	public static void main(String[] args) throws UnknownHostException, IOException{
		Socket s=new Socket("192.168.1.104",10000);	//向指定的计算机指定的端口号发送信息
		FileInputStream fis=new FileInputStream("d:\\new.png");		//本程序读取的是一个d盘的jpg文件
		OutputStream out=s.getOutputStream();	//Socket创建的对象可以调用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();	//Socket对象s可以调用自身的getInputStream方法返回一个读取字节流
		byte[] bufIn=new byte[1024];
		int num=in.read(bufIn);		
		System.out.println(new String(bufIn,0,num));	//读取该字节流并且写到控制台中
		fis.close();
		s.close();
	}
}

TCP服务端：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;


class ServerThread implements Runnable{	//创建服务器的服务线程类ServerThread
	private Socket s;	
	ServerThread(Socket s){		//使用线程类的构造方法将服务端调用accept方法返回的客户端对象s传进来
		this.s=s;				//使用this关键字强调s就是Socket创建的对象s
	}
	public void run() {			//复写Runnable接口中的run方法
		// TODO Auto-generated method stub
		String ip=s.getInetAddress().getHostAddress();	//这都是可有可无的内容，不过用到了ip地址而已
		int num=1;
		try{
			System.out.println(ip+":connected");
			InputStream in=s.getInputStream();	//客户端对象s调用getInputStream返回一个接受字节流的对象in
			File file=new File(ip+"<"+(num)+">"+".jpg");
			while(file.exists()){
				file=new File(ip+"<"+(num++)+">"+".jpg");
			}
			FileOutputStream fos=new FileOutputStream(file);
			
			byte[] buf=new byte[1024];
			int len=0;
			while((len=in.read(buf))!=-1){	//读取字节流每读取一段数据就会在while循环中写入到特定目录中
				fos.write(buf,0,len);
			}
			OutputStream out=s.getOutputStream();	//定义一个输出字节流，用来给客户端发送一段话，这代码可有可无
			out.write("success".getBytes());
			fos.close();
			s.close();
		}
		catch(Exception e){
			throw new RuntimeException(ip+"error");
		}
	}
	
}
public class Server {
	public static void main(String[] args) throws IOException{
		ServerSocket ss=new ServerSocket(10000);	//服务端监听的是本机上的端口号10000
		while(true){		//建立一个while死循环不停地接受客户端线程
			Socket s=ss.accept();	//服务器通过while死循环不停地接受客户端的连接，返回的是一个客户端的对象s
			new Thread(new ServerThread(s)).start();	//不停地创建线程，并且每个线程都通过这个while死循环进行启动
		}
		
	}
}

十二、服务器工作原理
1、概述：
服务器的服务原理其实上很简单的，一个客户端访问服务器端，目的就是想访问服务器端的静态、动态网页、数据库的信息。所以服务器端的功能就是将这些数据进行遍历之后发送到客户端即可。

 

2、PrintWriter类
自己知道如果想要对文件进行读写操作的话，是需要使用对应的字节流或者是字符流就可以了，如果自己想要发送一个数据内容到对方的机器上的时候，并且在对方的控制台上显示出来，可以使用PrintWriter创建的对象调用println(内容)方法将内容直接发送到对方的控制台上，或者使用PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类，这是一个相当流弊的方法！

2、小示例：

ServerSocket ss = new ServerSocket(11000);
Socket s = ss.accept();
System.out.println(s.getInetAddress().getHostAddress());
PrintWriter out = new PrintWriter(s.getOutputStream(), true); //自动刷新
out.println("welcome to my please !<br><br> this is my homepage!");
s.close();
ss.close();

上面是自己手动编写的一段服务器代码段，首先创建服务器ServerSocket，服务端口号是11000，然后ServerSocket创建的对象引用ss调用方法accept接受客户端ip地址的请求，客户端其实就是在浏览器地址栏中输入服务器端的ip地址之后就可以访问服务器端，返回的是一个socket类型的s，然后服务器端监听到了客户端发送过来的请求，下面使用PrintWriter类发送一段字符流，自带自动刷新功能，输入一行文本内容，这里的文本内容可以不用写死，可以是一个遍历的内容，比方说遍历的html文本内容，然后客户端浏览器就会显示解析之后的html内容了，相当的简单明了吧？这就是tomcat服务器的工作原理，tomcat服务器使用纯java编写的。

3、总结：
这里不敢说是自己知道tomcat服务器的工作原理，但是肤浅的了解到tomcat是将html或者是其它的页面进行读取之后一行一行的输出到浏览器端，浏览器可以读取一行一行的代码，如果遇到html代码，就执行，进行相应的显示。所以只要安装了tomcat服务器就可以将自己事先编写好的网站进行部署即可。然后别的人就可以通过ip地址和端口号然后跟上主目录进行相应的访问。

4、http协议：
http协议目前只有两种，一个是1.0一个是1.1版本，tomcat支持最新的1.1版本，一般使用的都是1.1版本的，所以一般浏览器请求服务端的时候，请求的内容中可以使用java中的类创建的方法直接获取请求的内容。

十三、常用类InetAddress和InetSocketAddress区别
InetAddress里面只封装了ip地址，Socket的子类InetSocketAddress里面封装了ip地址和port端口号，所以使用InetAddress最多获取到ip地址，InetSocketAddress可以获取到ip地址和端口号。

十四、域名解析
1、浏览器工作原理：
首先明白一点，网络中每一个域名都是对应着一个ip地址的，有时候多个ip地址对应一个域名。如果客户想要访问一个网站，比方说“百度”，首先浏览器并不是去网络上查看的，它要到本机上地址为：C:\Windows\System32\Drivers\etc目录下的hosts文件中查看里面是不是记录了百度的ip地址，如果记录了得话，将会直接通过文件中记录的ip地址进行网站的访问。如果没有，查找离自己机器最近的DNS服务器，在上面查看域名和相应的ip地址对应的映射关系，找到百度的ip地址，因为浏览器是不认识域名的，只认识ip地址，所以只要到DNS服务器查找到对应的映射关系，就可以打开指定的网页。

2、DNS服务器：
DNS服务器就是将域名和ip地址进行一一映射的一个服务器，所有的客户端在访问自己想要访问的网站的时候，一般都回经过这个服务器，这个DNS服务器不是唯一的，一般客户端浏览器会选择离自己最近的DNS服务器进行查询，查到的话，将会将映射结果返回到客户端的浏览器上，浏览器通过返回的ip地址访问自己想要登陆的网站。但是、前提如果本机地址：C:\Windows\System32\Drivers\etc目录下的hosts文件中没有记录该网址的的映射关系的话，将会走DNS服务器，如果有记录的话，直接走的是ip地址，因为已经查询过了。

3、小智慧&小阴谋：
通过上面对DNS的描述，如果想要浏览器反应更加迅速的话，那么可以将对应的网站的ip地址和域名进行关联，这样就省去了查找DNS服务器的步骤，网页载入的速度就会加大一点，虽然自己可能感觉不到。
还有一个小阴谋，大家都知道本机的默认ip地址是127.0.0.1，后面对应的域名是localhost，如果自己不想让某人上指定网站的话，直接将该网址对应本地ip地址127.0.0.1，然后，别人就上不去了，因为浏览器会首先查阅这个文件，查到了ip地址和域名的对应关系，然后上网找网站，结果会出现“重定向异常”的错误，实际上像360杀毒这样的软件，监控到某个网站不正常的话，就会使用该方法，让用户不用担心不小心登陆该网站。

十五、URL类
1、小总结：
如果在以后和URL相关的开发中，自己一定要首先了解到的是，如果一个项目关联到的编程区域比较明显或者常用的话，一定要明白的一点是，java中应该已经为自己封装好了相应的类，只需要进行相应的对象的创建，然后调用相应的方法即可。

2、URL常用方法：
（1）、首先创建URL服务：URL url=new URL("http://www.baidu.com");
（2）、URL创建对象之后调用其中的OpenConnection或者是OpenStream都可以，但是调用前者的话，将会有更多的方法可以调用，所以根据自己的需要自己进行相关的调用即可。
（3）、调用方法之后一般返回的都是InputStream类型，所以将InputStream中的数据进行遍历即可，这就需要进入到InputStream类中进行相关内容的查看了，但是这里是总结的内容，所以直接写出来了：
 URLConnection conn=url.openConnection();
 InputStream in=conn.getInputStream();
 byte[] buf=new byte[1024];
 int len=in.read(buf);