黑马程序员_网络编程

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

 

一，网络模型
OSI参考模型
TCP/IP参考模型
如图：

二，网络通讯要素
1，IP地址:InetAddress
网络中设备的标识
不易记忆，可用主机名
本地回环地址：127.0.0.1  主机名：localhost

2，端口号
用于标识进程的逻辑地址，不同进程的标识
有效端口：0~65535，其中0~1024系统使用或保留端口。

3，传输协议
通讯的规则
常见协议：TCP，UDP

三，InetAdderss类
类 InetAddress:表示互联网协议 (IP) 地址。
没有构造函数，方法由静态和非静态
通过static InetAddress getLocalHost() 返回本地主机对象。
如果找不到 host 的任何 IP 地址。系统会抛出UnknownHostException异常
类InetAddress中的常见方法：
public static InetAddress getByName(String host)：
在给定主机名的情况下确定主机的 IP 地址。主机名可以是机器名（如 "java.sun.com"），
也可以是其 IP 地址的文本表示形式。如果提供字面值 IP 地址，则仅检查地址格式的有效性。
如果主机为 null，则返回表示回送接口地址的 InetAddress。
public String getHostAddress()：返回 IP 地址字符串（以文本表现形式）。
public String getHostName()：获取此 IP 地址的主机名。

比如：获取本地主机名或网络中的主机名和IP地址

import java.net.*;
public class IPDemo {
 
 public static void main(String[] args)throws Exception {
//  //获取本地主机
//  InetAddress i= InetAddress.getLocalHost();
//  System.out.println(i.toString());
//  //获取IP地址的主机名
//  System.out.println("name:"+i.getHostName());
//  //获取IP地址
//  System.out.println("address:"+i.getHostAddress());
  //以主机名为主 因为IP地址需要被解析
  InetAddress ia =InetAddress.getByName("thinkpad-sl400");
  System.out.println("address:"+ia.getHostAddress());
  System.out.println("name:"+ia.getHostName()); 
 }
}

四，网络通信
1，通信步骤
a，找到对方IP
b，数据要发送到对方指定的应用程序上。为了标识这些应用程序，所以给这些网络应用程序
都用数字进行标识。为了方便称呼这个数字，叫做“端口”。逻辑端口
c，定义通信规则。这个通讯规则称为协议。
国际组织定义了通用协议TCP/IP。
用一个图来表示：

2，UDP传输
将数据及源和目的封装成数据包中，不需要建立连接
每个数据报的大小在限制在64k内
因无连接，是不可靠协议
不需要建立连接，速度快
DatagramSocket ：此类表示用来发送和接收数据报包的套接字。
DatagramPacket ：此类表示数据报包。
步骤：
建立发送端，接收端。
建立数据包，将数据封装到数据报包。
调用Socket的发送接收方法。
关闭Socket。
注意：发送端与接收端是两个独立的运行程序。

需求：通过udp传输方式，将一段文字数据发送出去。，
定义一个udp发送端。
思路：
1)，建立updsocket服务。
2)，提供数据，并将数据封装到数据包中。
3)，通过socket服务的发送功能，将数据包发出去。
4)，关闭资源。

代码：

	class  UdpSend
	{
		public static void main(String[] args) throws Exception
		{
			//1，创建udp服务。通过DatagramSocket对象。
			DatagramSocket ds = new DatagramSocket(8888);//创建数据报套接字 并绑定到本地端口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.100"),10000);

			//3，通过socket服务，将已有的数据包发送出去。通过send方法。
			ds.send(dp);

			//4，关闭资源。

			ds.close();

		}
	}

需求：
定义一个应用程序，用于接收udp协议传输的数据并处理的。

定义udp的接收端。
思路：
1)，定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。
 方便于明确哪些数据过来该应用程序可以处理。
2)，定义一个数据包，因为要存储接收到的字节数据。
因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3)，通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
4)，通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
5)，关闭资源。
代码：

class  UdpRece
{
	public static void main(String[] args) throws Exception
	{
		//1,创建udp socket，建立端点。(绑定到本地端口10000上)
		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();

	}
}

UDP聊天程序
需求：
编写一个聊天程序。有收数据的部分，和发数据的部分。
这两部分需要同时执行。那就需要用到多线程技术。
一个线程控制收，一个线程控制发。因为收和发动作是不一致的，所以要定义两个run方法。
而且这两个方法要封装到不同的类中。

代码：

import java.io.*;
import java.net.*;
//发送端
class Send implements Runnable
{
	//定义udp套接字作用于整个类
	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.100"),10002);

				ds.send(dp);
				//当输入886就结束聊天程序
				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);
				//通过服务的receive方法将收到数据存入数据包中。
				ds.receive(dp);

				//获取发送端的IP
				String ip = dp.getAddress().getHostAddress();
				//获取发送过来的数据
				String data = new String(dp.getData(),0,dp.getLength());
				//当输入886结束聊天程序
				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();

	}
}

3，TCP
定义：
建立连接，形成传输数据的通道。
在连接中进行大数据量传输
通过三次握手完成连接，是可靠协议
必须建立连接，效率会稍低

socket类
此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
Socket就是为网络服务提供的一种机制。通信的两端都有Socket。
网络通信其实就是Socket间的通信。数据在两个Socket间通过IO传输。

tcp分客户端和服务端。
客户端对应的对象是Socket。
服务端对应的对象是ServerSocket。
通信基本思路:
客户端：客户端需要明确服务器的ip地址以及端口，这样才可以去试着建立连接，如果连接失败，会出现异常。
因为tcp是面向连接的。所以在建立socket服务时，就要有服务端存在，并连接成功。
连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，
而Socket对象已经提供了输入流和输出流对象，通过getInputStream(),getOutputStream()获取即可。
与服务端通讯结束后，关闭Socket。

服务端：服务端需要明确它要处理的数据是从哪个端口进入的。
当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，
并通过该对象与客户端通过IO流进行数据传输。当该客户端访问结束，关闭该客户端。
代码：

/*
需求：给服务端发送给一个文本数据。

步骤：
1，创建Socket服务。并指定要连接的主机和端口。
2，获取socket的输出流发送数据
3，关闭发送端
*/
import java.io.*;
import java.net.*;
class  TcpClient
{
	public static void main(String[] args) throws Exception 
	{
		//创建客户端的socket服务。指定目的主机和端口
		Socket s = new Socket("192.168.1.102",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();
		//获取客户端的IP地址
		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();
	}
}

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

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
步骤
客户端：
1，建立socket服务。指定要连接主机和端口。
2，获取socket流中的输出流。将数据写到该流中。通过网络发送给服务端。
3，获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
4，关闭客户端资源。
服务端：
1，建立服务端的socket服务。ServerSocket();
 并监听一个端口。
2，获取连接过来的客户端对象。
 通过ServerSokcet的 accept方法。
3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。
 并打印在控制台。
4，获取客户端的输出流，通过该流将反馈给客户端的信息发送过去。
4，关闭客户端对象。关闭服务端。（可选）
代码：

import java.io.*;
import java.net.*;
class TcpClient2 
{
	public static void main(String[] args)throws Exception 
	{
		//建立socket服务，指定要连接的主机和端口
		Socket s = new Socket("192.168.1.254",10004);
		//获取socket流中的输出流
		OutputStream out = s.getOutputStream();
		//将数据写入输出流 并发送给我服务端
		out.write("服务端，你好".getBytes());

		//获取socket流中的输入流
		InputStream in = s.getInputStream();
		//用一个数组来接收服务端的反馈信息
		byte[] buf = new byte[1024];
		//将服务端反馈的信息写入数组
		int len = in.read(buf);

		System.out.println(new String(buf,0,len));
		//关闭客户端
		s.close();
	}
}


class TcpServer2
{
	public static void main(String[] args) throws Exception
	{
		//建立服务端服务 并绑定端口号10000到本地主机
		ServerSocket ss = new ServerSocket(10004);
		//获取客户端的套接字对象
		Socket s = ss.accept();
		//获取客户端IP
		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));

		//获取客户端的输出流
		OutputStream out = s.getOutputStream();


		Thread.sleep(10000);
		//将反馈给客户端的数据写入输出流中
		out.write("哥们收到,你也好".getBytes());
		//关闭客户端对象	
		s.close();
		//关闭服务端对象
		ss.close();
	}
}

需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。
而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。

分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据。可以选择字符流。

代码：

import java.io.*;
import java.net.*;
/*
客户端：
步骤
1，建立服务。
2，获取键盘录入。
3，将数据发给服务端。
4，获取服务端返回的大写数据。
5，结束，关资源。

都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
*/
class  TransClient
{
	public static void main(String[] args) throws Exception
	{
		Socket s = new Socket("192.168.1.254",10005);


		//定义读取键盘数据的流对象。
		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));


		//定义目的，将数据写入到socket输出流。发给服务端。
		//BufferedWriter bufOut = 
			//new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);



		//定义一个socket读取流，读取服务端返回的大写信息。
		BufferedReader bufIn = 
			new BufferedReader(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 void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10005);

		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");

		//读取socket读取流中的数据。
		BufferedReader bufIn =
			new BufferedReader(new InputStreamReader(s.getInputStream()));

		//目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。
		//BufferedWriter bufOut = 
			//new BufferedWriter(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();

	}
}

TCP通信的演示：
需求：客户端并发向服务端上传图片
客户端。
1，服务端点。
2，读取客户端已有的图片数据。
3，通过socket 输出流将数据发给服务端。
4，读取服务端反馈信息。
5，关闭。

服务端
这个服务端有个局限性。当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("请选择一个jpg格式的图片");
			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 ;
		}
		
		//创建客户端 指定服务端IP和端口号
		Socket s = new Socket("192.168.1.254",10007);

		FileInputStream fis = new FileInputStream(file);
		//为了发送数据，应该获取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();
		//为了接收数据 ，应该获取socket流中的输入流
		InputStream in = s.getInputStream();

		byte[] bufIn = new byte[1024];
		//接收服务端的反馈信息
		int num = in.read(bufIn);
		System.out.println(new String(bufIn,0,num));

		fis.close();
		s.close();
	}
}
class PicThread implements Runnable
{
	//封装客户端 来一个获取一个
	private Socket s;
	PicThread(Socket s)
	{
		this.s = s;
	}
	public void run()
	{
		//定义一个计数器
		int count = 1;//如果定义成成员变量则所有客户端共享这个数据
		String ip  = s.getInetAddress().getHostAddress();
		try
		{
			System.out.println(ip+"....connected");
			//获取socket中的输入流用于接收客户端发来的信息
			InputStream in = s.getInputStream();

			File dir =  new File("d:\\pic");
			
			File file = new File(dir,ip+"("+(count)+")"+".jpg");
			//判断该文件是否存在 存在就新建一个对象 
			while(file.exists())
				//当同一个IP发送已有的图片这时计数器加1 以免覆盖原有图片
				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+"上传失败");
		}
	}
}
class  PicServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10007);

		while(true)
		{
			Socket s = ss.accept();
			//来一个客户端 就建立一个线程	
			new Thread(new PicThread(s)).start();

		
		}

		//ss.close();
	}
}

客户端并发登陆服务端
客户端通过键盘录入用户名。
服务端对这个用户名进行校验。

如果该用户存在，在服务端显示xxx，已登陆。
并在客户端显示 xxx，欢迎光临。

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

最多就登录三次。
代码演示：

import java.io.*;
import java.net.*;


class  LoginClient
{
	public static void main(String[] args) throws Exception
	{
		//建立客户端服务 指定服务端IP和端口号
		Socket s = new Socket("192.168.1.254",10008);
		//获取键盘录入
		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));
		//将要发送给服务端的信息通过输出流发送给服务端
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		//建立一个输入流 获取服务端的反馈信息
		BufferedReader bufIn =
			new BufferedReader(new InputStreamReader(s.getInputStream()));

		//最多登陆三次
		for(int x=0; x<3; x++)
		{
			String line = bufr.readLine();
			if(line==null)
				break;
			out.println(line);

			String info = bufIn.readLine();
			System.out.println("info:"+info);
			if(info.contains("欢迎"))
				break;

		}
		//关闭资源
		bufr.close();
		s.close();
	}
}


class UserThread implements Runnable
{	//获取客户端对象
	private Socket s;
	UserThread(Socket s)
	{
		this.s = s;
	}
	public void run()
	{
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");
		try
		{ 
			//最多允许客户端登陆三次
			for(int x=0; x<3; x++)
			{	//获取客户端的信息
				BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));

				String name = bufIn.readLine();
				if(name==null)
					break;

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

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

				String line = null;
				//根据用户名进行判断
				boolean flag = 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)
		{
			throw new RuntimeException(ip+"校验失败");
		}
	}
}
class  LoginServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss = new ServerSocket(10008);
		//客户端并发访问
		while(true)
		{
			Socket s = ss.accept();

			new Thread(new UserThread(s)).start();
		}
	}
}

4，URL
类 URL 代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，
也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。
构造函数：
public URL(String protocol,String host,int port,String file)
根据指定 protocol、host、port 号和 file 创建 URL 对象。
常用方法：
 String getFile()
          获取此 URL 的文件名。
 String getHost()
          获取此 URL 的主机名（如果适用）。
 String getPath()
          获取此 URL 的路径部分。
 int getPort()
          获取此 URL 的端口号。
 String getProtocol()
          获取此 URL 的协议名称。
 String getQuery()
          获取此 URL 的查询部

代码演示：

import java.net.*;
class URLDemo 
{
	public static void main(String[] args) throws MalformedURLException
	{	//创建URL对象
		URL url = new URL("http://192.168.1.254/myweb/demo.html?name=haha&age=30");


		System.out.println("getProtocol() :"+url.getProtocol());//获取协议名称
		System.out.println("getHost() :"+url.getHost());//主机名
		System.out.println("getPort() :"+url.getPort());//端口号
		System.out.println("getPath() :"+url.getPath());//路径
		System.out.println("getFile() :"+url.getFile());//URL的文件名
		System.out.println("getQuery() :"+url.getQuery());//URL的查询部分
	}
}

5,类 URLConnection
抽象类 URLConnection 是所有类的超类，它代表应用程序和 URL 之间的通信链接。
此类的实例可用于读取和写入此 URL 引用的资源。
通常，创建一个到 URL 的连接需要几个步骤：
1,通过在 URL 上调用 openConnection 方法创建连接对象。
2,处理设置参数和一般请求属性。
3,使用 connect 方法建立到远程对象的实际连接。
4,远程对象变为可用。远程对象的头字段和内容变为可访问。

public URLConnection openConnection():
返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。
public InputStream getInputStream():
返回从此打开的连接读取的输入流。 在读取返回的输入流时，
如果在数据可供读取之前达到读入超时时间，则会抛出 SocketTimeoutException。

代码演示：

import java.net.*;
import java.io.*;
class  URLConnectionDemo
{
	public static void main(String[] args) throws Exception
	{
		URL url = new URL("http://192.168.1.254:8080/myweb/demo.html");

		URLConnection conn = url.openConnection();
		System.out.println(conn);
		
		InputStream in = conn.getInputStream();

		byte[] buf = new byte[1024];

		int len = in.read(buf);

		System.out.println(new String(buf,0,len));
	}
}

小知识点：
1，InetAddress 里面封装的是IP地址
   InetSocketAddress 封装的是IP地址加端口号

2，类 ServerSocket
构造函数public ServerSocket(int port,int backlog)：
利用指定的 backlog 创建服务器套接字并将其绑定到指定的本地端口号。
backlog表示队列的最大长度，也就是服务器能承受最大的连接个数。

3、在进行浏览器输入网址访问一台主机所做的操作：

如http://192.168.1.100:8080/myweb/myIE.html，
一般直接输入主机名：http://sina.com.cn等，那么如何通过主机名获取IP地址，
从而连接到这台主机的呢？这就需要将主机名翻译成IP地址，即域名解析：DNS
在进行访问的时候，会现在本地的hosts文件（C:\WINDOWS\system32\drivers\etc\hosts）
中找对应的映射，若有，则直接返回请求，若无，则到公网的映射列表即DNS中找对应的映射，
找到后，将主机名对应的IP地址返回给本机，本机通过这个IP地址找到对应的服务器。

 

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