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

本文链接：https://blog.csdn.net/yueye12/article/details/42737827

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

网络通讯三要素：IP地址，端口号，传输协议udp,tcp

ip地址：对象：InetAddress getByAddress()//获取ip地址对象，包括主机名和地址值； getAllByName():给定主机名，返回ip地址组成的数组

练习：通过udp传输方式，将一段文字数据发送出去

步骤：1.建立udpsocket服务

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

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

4.关闭资源

import java.net.*;
class UdpSend
{
	public static void main(String[] args)throws Exception
	{
		//创建udp服务，通过DatagramSocket对象
		DatagramSocket ds=new DatagramSocket();
		
		//确定数据，并封装成数据包
		byte[] buf="udp shuju bao".getBytes();	//将数据转换成字节存入字节数组中

		//创建包，包中包括要发送数据的长度，接收数据的ip地址名（地址值），端口
		DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.28"),10000);

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

		//关闭资源
		ds.close();
	}
}

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

步骤：1.定义udpsocket服务，通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识，便于知道接收哪些数据该做出处理
2.定义一个数据包，存储接收的数据。数据包对象中有更多功能可以提取字节数据中的不同数据信息

3.通过socket服务的接收功能，接收数据包中的数据并存入到已定义好的数据包中

4.根据数据包具有的特有功能，将这些不同数据取出，打印在控制台上。

5.关闭资源

import java.net.*;
class UdpReceive
{
	public static void main(String[] args) throws Exception
	{
		//创建udp socket，建立端点
		DatagramSocket ds=new DatagramSocket(10000);

		//定义数据包，用于存储数据
		byte[] buf=new byte[1024];
		DatagramPacket dp=new DatagramPacket(buf,buf.length);

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

		ds.receive(dp);

		//通过数据包的方法获取包中数据
		String ip=dp.getAddress().getHostAddress();	//获取地址
		String data=new String(dp.getData(),0,dp.getLength());	//获取数据，并将数组中的有效数据转换为字符串

		int port =dp.getPort();		//获取端口信息

		System.out.println(ip+"::"+data+"::"+port);
		
		//关闭资源
		ds.close();
	}
}

接收端先开等待接收数据：

发送端发送数据：

练习：获取键盘录入，然后发送端将录入数据发送，接收端接收

发送端录入：

接收端显示：

编写一个聊天程序：收发数据都可以同时操作，就需要引用多线程

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

class Send implements Runnable	//创建发送线程
{
	private DatagramSocket ds;	//引用udp socket变量，因为有收发两个，所以可以引用成员变量，可以在后面初始化
	public Send(DatagramSocket ds)
	{
		this.ds=ds;	//将ds运用到整个类中
	}

	public void run()
	{
		try
		{		
			BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));	//获取键盘录入，存入缓冲区
			
			String line=null;
			
			while((line=bufr.readLine())!=null)	//开始读取流中录入的数据
			{
				if("886".equals(line))
					break;
				byte[] buf=line.getBytes();	//将数据转入字节数组中
				
				DatagramPacket dp=		//创建包，将数据存入包中
					new DatagramPacket(buf,0,buf.length,InetAddress.getByName("192.168.1.255"),10002);	//用255段表示将数据以广播的形式发送出去
				ds.send(dp);	
			}
		}
		catch(Exception e)
		{
			throw new RuntimeException("发送失败");
		}
	}
}

class Rece implements Runnable	//创建接收线程
{
	private DatagramSocket ds;	//引用udp socket变量，因为有收发两个，所以可以引用成员变量，可以在后面初始化
	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();	//获取接收数据的ip地址
				String data=new String(dp.getData(),0,dp.getLength());	//获取接收到的数据

				System.out.println(ip+"::"+data);
			}
		}
		catch(Exception e)
		{
			throw new RuntimeException("接收失败");
		}
	}
}


class ChatDemo
{
	public static void main(String[] args) throws Exception
	{
		//创建udpSocket服务
		DatagramSocket sendSocket=new DatagramSocket();
		DatagramSocket receSocket=new DatagramSocket(10002);

		//开始线程运行
		new Thread(new Send(sendSocket)).start();
		new Thread(new Rece(receSocket)).start();
		
	}
}

Tcp传输:tcp分为客户端和服务端，客户端服务soket，服务端服务：serverSoket

演示Tcp传输

因为Tcp是面向连接的，所以在建立socket服务时，就要有服务端存在，并连接成功，形成通路后，在该通道进行数据的传输

建立客户端服务，发送数据

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

class TcpClient
{
	public static void main(String[] args) throws Exception
	{
		//创建socket服务，指定目的主机和端口
		Socket=s=new Socket("192.168.1.28",10005);

		//获取socket流中的输出流，发送数据
		OutputStream out=s.getOutputStream();

		out.write("tcp ，我来了".getBytes());

		s.close();
	}
}

服务端：接收数据，打印在控制台上

步骤：1.建立服务端的socket服务，并监听一个端口

2.获取连接过来的客户端对象，通过ServerSocket的accept方法，没有连接就会等待，所以这个方法是阻塞式的

3.客户端如果发送过来数据，服务器端要使用对应的客户端对象，并获取到该对象的读取流读取发送过来的数据，打印控制台上

4.关闭服务端（可以不关）

练习：演示tcp的客户端和服务端的互访

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

客户端步骤：1.建立socket服务，指定要连接的主机和端口

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

3.获取socket流中的输入流，将服务器返回的数据获取到并打印

import java.io.*;
import java.net.*;
class TcpClient2
{
	public static void main(String[] args) throws Exception
	{
		//创建socket服务
		Socket s=new Socket("192.168.1.28",10004);
		//获取输出流，方便写入数据
		OutputStream out=s.getOutputStream();
		//写入数据
		out.write("服务端，你好".getBytes());

		//获取输入流，读取服务端返回的信息
		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
	{
	ServerSocket ss=new ServerSocket(10004);	//使用ServerSocket服务
	Socket s=ss.accept();		//接收客户端发送的数据
	String ip=s.getInetAddress().getHostAddress();	//获取客户端的ip地址

	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();	//获取输出流，便于写反馈信息给客户端
	out.write("收到了，你也好".getBytes());

	s.close();
	ss.close();
	}
}

练习：建立一个文本转换服务器，客户端给服务端发送文本，服务端会将文本转成大写再返回客户端。而且客户端可以不断的发送，直到发送“over”结束

分析：客户端：源：键盘录入；目的：网络设备，网络输出流

import java.io.*;
import java.net.*;
class TcpClie
{
	public static void main(String[] args)throws Exception
     {
	//创建客户端Socket服务
	Socket s=new Socket("192.168.1.28",10006);

	//获取键盘录入
	BufferedReader bufw=new BufferedReader(new InputStreamReader(System.in));
	
	//定义目的，将数据写入socket流中，发给服务器
	BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
	//PrintWriter pw=new PrintWriter(s.getOutputStream(),true);  

	//定义一个socket读取流，读取服务端返回的数据
	BufferedReader bufin=new BufferedReader(new InputStreamReader(s.getInputStream()));
	String line=null;
	while((line=bufw.readLine())!=null)
	{
		if("over".equals(line))
			break;
		//pw.println(line);

		bufout.write(line);	//如果输入的不是over,则将读取的数据写入流中
		bufout.newLine();		//换行标志，表示已经读完了
		bufout.flush();		//刷新缓冲区的数据，确保发送出去
		String str=bufin.readLine();	//获取服务端返回的数据
		System.out.println(str);
	}
	bufw.close();
	s.close();
     }
}

class TcpServ
{
	public static void main(String[] args)throws Exception
	{
		//创建ServerSocket服务
		ServerSocket ss=new ServerSocket(10006);

		Socket s=ss.accept();	//服务端接收客户端连接对象

		String ip=s.getInetAddress().getHostAddress();	//获取客户端地址
		System.out.println(ip);
		//读取流中的数据
		BufferedReader bufin=new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		//目的,将大写数据写入socket输出流，返回给客户端
		BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		//PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
		String line=null;
		while((line=bufin.readLine())!=null)
		{
			//pw.println(line);
			System.out.println(line);
			bufout.write(line.toUpperCase());	//将数据转成大写
			bufout.newLine();		//换行标志，表示已经读完了
			bufout.flush();		//刷新缓冲区，将数据发送出去
		}
		s.close();
		ss.close();
	}
}

服务端：

客户端：

tcp文件复制

import java.io.*;
import java.net.*;
class TextClient
{
	public static void main(String[] args) throws Exception 
	{
		Socket s=new Socket("192.168.1.28",11000);	//使用Socket服务
		
		BufferedReader bufr=new BufferedReader(new FileReader("IPDemo.java"));	//源：.java文件
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);		//目的：socket服务的输出流


		String line=null;
		while((line=bufr.readLine())!=null)
		{
			pw.println(line);
		}

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

			//接收服务器返回的数据
		BufferedReader bufin=new BufferedReader(new InputStreamReader(s.getInputStream()));
		String str=bufin.readLine();
		System.out.println(str);

		bufr.close();
		s.close();
	}
}

class TextServer
{
   public static void main(String[] args) throws Exception 
   {
	ServerSocket ss=new ServerSocket(11000);	//获取ServerSocket服务
	Socket s=ss.accept();		//接收客户端传来的连接对象

	String ip=s.getInetAddress().getHostAddress();	//接收客户端ip地址
	System.out.println(ip);


	BufferedReader bufr=new BufferedReader(new InputStreamReader(s.getInputStream()));	//服务器端的源：接受到socket源中的数据

	PrintWriter pw=new PrintWriter(new FileWriter("serve.txt"),true);	//目的，存入.txt文件中
	String line=null;
	while((line=bufr.readLine())!=null)
	{

		pw.println(line);
	}

	
	PrintWriter p=new PrintWriter(s.getOutputStream(),true);	//返回客户端数据
	p.println("上传成功");

	pw.close();
	s.close();
	ss.close();
    }
}

客户端上传，并收到反馈

服务端接收

练习：上传图片

import java.io.*;
import java.net.*;
class PicClient
{
	public static void main(String[] arga) throws Exception
	{
		Socket s=new Socket("192.168.1.28",10007);	//使用socket服务

		FileInputStream fis=new FileInputStream("c:\\p1.jpg");	//读取图片文件

		OutputStream out=s.getOutputStream();		//获取socket服务的输出流，方便数据上传

		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服务的输入流，便于接收服务端反馈信息
		byte[] bufin=new byte[1024];
		
		int num=in.read(bufin);		//读取反馈信息
		System.out.println(new String(bufin,0,num));

		fis.close();
		s.close();
	}
}

class PicServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss=new ServerSocket(10007);	//获取ServerSocket服务

		Socket s=ss.accept();		//接收客户端传来的连接对象

		String ip=s.getInetAddress().getHostAddress();	//获取客户端ip地址
		System.out.println(ip);

		InputStream in=s.getInputStream();	//获取ServerSocket服务的输入流，方便读取数据

		FileOutputStream fos=new FileOutputStream("serve.jpg");	//创建存储接收数据的文件

		int len=0;
		byte[] buf=new byte[1024];
		while((len=in.read(buf))!=-1)	//读取输入流中的数据存入数组中
		{
			fos.write(buf,0,len);	//将数组中的数据写入文件中
		}
		
		OutputStream out=s.getOutputStream();	//获取服务中的输出流，能够返回客户端信息

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

		fos.close();
		s.close();
		ss.close();
	}
}

客户端上传，并获取反馈信息

服务端接收数据

练习：多个客户端可以同时连接到服务端，并上传数据

服务端将每个客户端封装到一个单独的线程中，就可以同时处理多个客户的请求了

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

class PicThread implements Runnable
{
	private Socket s;
	PicThread(Socket s)
	{
		this.s=s;
	}	
	public void run()
	{
		int count=1;
  		String ip=s.getInetAddress().getHostAddress();	//获取客户端ip地址
		System.out.println(ip);
	   try
	   {
		

		InputStream in=s.getInputStream();	//获取ServerSocket服务的输入流，方便读取数据

		File file=new File(ip+"("+count+")"+".jpg");		//多次接收，避免覆盖	


		while(file.exists())
			file=new File(ip+"("+(count++)+")"+".jpg");	//存在就创建一个新的

		FileOutputStream fos=new FileOutputStream(file);	//创建存储接收数据的文件

		int len=0;
		byte[] buf=new byte[1024];
		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)
		{
			System.out.println(ip+"上传失败");
		}
	}
}


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;
		}
		Socket s=new Socket("192.168.1.198",10011);	//使用socket服务

		FileInputStream fis=new FileInputStream(file);	//读取图片文件

		OutputStream out=s.getOutputStream();		//获取socket服务的输出流，方便数据上传

		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服务的输入流，便于接收服务端反馈信息
		byte[] bufin=new byte[1024];
		
		int num=in.read(bufin);		//读取反馈信息
		System.out.println(new String(bufin,0,num));

		fis.close();
		s.close();
	}
}

class PicServer
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss=new ServerSocket(10011);	//获取ServerSocket服务

		while(true)
		{
			Socket s=ss.accept();
			new Thread(new PicThread(s)).start();	//创建上传数据的线程
		}

		//ss.close();
	}
}

练习：自定义一个服务器，客户端是浏览器

import java.net.*;
import java.io.*;
class ServerDemo
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss=new ServerSocket(13000);	//引用ServerSocket服务，

		Socket s=ss.accept();		//连接到客户端
		System.out.println(s.getInetAddress().getHostAddress());		//获取客户端地址
		
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);	//返回客户端数据
		
		pw.println("服务器你好");
		
		s.close();
		ss.close();
	}
}

客户端是服务器，服务端是TomCat服务器：启动Tomcat服务器，在Tomcat文件夹的Webapps中新建MyWeb文件夹，里面自己创建一个网页，打开主机网页，端口是8080

自定义一个客户端，服务端还是TomCat服务器

打开Tomcat服务器，运行MyIE

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

class MyIE
{
	public static void main(String[] args)	throws Exception
	{
		Socket s=new Socket("192.168.1.198",8080);
		
		PrintWriter out=new PrintWriter(s.getOutputStream(),true);

		//模拟浏览器发送的返回信息
		out.println("GET /MyWeb/MyWeb.html  HTTP/1.1");
		out.println("Accept:*/*");
		out.println("Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3");
		out.println("Host: 192.168.1.198:13000");
		out.println("Connection: closed");

		//用空行将头部信息和请求体分隔开
		out.println();
		out.println();

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

		String line=null;
		while((line=bufr.readLine())!=null)
		{
			System.out.println(line);
		}
			
		s.close();
	}
}

/*
D:\java0217\day24>java ServerDemo
192.168.1.198
GET / HTTP/1.1
Host: 192.168.1.198:13000
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:35.0) Geck
35.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Connection: keep-alive
Cache-Control: max-age=0

*/

在命令行显示出了网页内容

下面利用图形化界面来实现显示自定义网页内容

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
class MyIEGUI
{
	private Frame f;
	private TextField tf;
	private Button but;
	private TextArea ta;
	private Dialog d;	//引用一个对话框成员变量
	private Label lab;	//引用一个标签
	private Button okbu;	//引用按钮变量，应用于对话框中
	MyIEGUI()
	{
		init();
	}
	public void init()
	{
		f=new Frame("my window");	//创建一个窗体
		f.setBounds(300,100,600,500);	//设置窗体的位置，宽高
		
		f.setLayout(new FlowLayout());	//设置成流布局

		tf=new TextField(60);	//新建文本框，设置列数是30
		
		but=new Button("转到");	//新建按钮
		ta=new TextArea(25,70);	//新建文本编辑区域，15行40列

		d=new Dialog(f,"提示信息-self",true);	//新建一个对话框,true值表示当前窗口不处理就无法处理后置窗口
		d.setBounds(400,200,240,150);		//设置对话框的位置和宽高
		d.setLayout(new BorderLayout());		//设置对话框布局为流式布局

		lab=new Label();			//创建标签
		okbu=new Button("确定");		//创建对话框中的按钮

		d.add(lab);
		d.add(okbu);

		f.add(tf);
		f.add(but);
		f.add(ta);

		myEvent();	
		f.setVisible(true);	//设置窗口可视
	}
	private void myEvent()
	{
		okbu.addActionListener(new ActionListener()	//操作时调用
			{
				public void actionPerformed(ActionEvent e)
				{
					d.setVisible(false);	//点击对话框的确认按钮事件就会不显示对话框了
				}
			});
		d.addWindowListener(new WindowAdapter()	//添加窗体关闭方法，复写关闭方法
			{
				public void windowClosing(WindowEvent e)
				{
					d.setVisible(false);	//点击对话框关闭按钮的时候就不显示对话框了
				}
			});
		tf.addKeyListener(new KeyAdapter()
		{
			public void keyPressed(KeyEvent e)
			{
				
					try
					{
					if(e.getKeyCode()==KeyEvent.VK_ENTER)
						showDir();		//在操作时调用目录转入文本区功能函数
					}
					catch(Exception ex)
					{
						throw new RuntimeException();
					}
			}
		});
					
		but.addActionListener(new ActionListener()	//添加窗体监听器
			{
				public void actionPerformed(ActionEvent e)	//操作时调用
				{
					try
					{
						showDir();		//在操作时调用目录转入文本区功能函数
					}
					catch(Exception ex)
					{
						throw new RuntimeException();
					}
				}
			});
		f.addWindowListener(new WindowAdapter()		//添加窗体关闭方法，复写关闭方法
			{
				public void windowClosing(WindowEvent ex)
				{
					System.exit(0);		//退出窗体
				}
			});

	}

	private void showDir()	throws Exception     //输入目录后转入文本区的功能封装成一个方法
	{
		ta.setText("");
		String url=tf.getText();	//获取网页地址

		int index1=url.indexOf("//")+2;	//获取地址角标
		int index2=url.indexOf("/",index1);	//获取目录角标

		String str=url.substring(index1,index2);	//获取到ip地址和端口号
		String[] arr=str.split(":");
		String host=arr[0];	//得到主机地址
		int port =Integer.parseInt(arr[1]);	//得到端口号
		String Path=url.substring(index2);	//得到目录列表

		
		//ta.setText(str+"---"+Path);

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

		//模拟浏览器发送的返回信息
		out.println("GET "+Path+"  HTTP/1.1");
		out.println("Accept:*/*");
		out.println("Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3");
		out.println("Host: 192.168.1.198:13000");
		out.println("Connection: closed");

		//用空行将头部信息和请求体分隔开
		out.println();
		out.println();

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

		String line=null;
		while((line=bufr.readLine())!=null)
		{
			ta.append(line+"\r\n");
		}
			
		s.close();
	}

	public static void main(String[] args)
	{
		new MyIEGUI();
	}
}

运用url对象，解析头字段

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
class MyIEGUI2
{
	private Frame f;
	private TextField tf;
	private Button but;
	private TextArea ta;
	private Dialog d;	//引用一个对话框成员变量
	private Label lab;	//引用一个标签
	private Button okbu;	//引用按钮变量，应用于对话框中
	MyIEGUI2()
	{
		init();
	}
	public void init()
	{
		f=new Frame("my window");	//创建一个窗体
		f.setBounds(300,100,600,500);	//设置窗体的位置，宽高
		
		f.setLayout(new FlowLayout());	//设置成流布局

		tf=new TextField(60);	//新建文本框，设置列数是30
		
		but=new Button("转到");	//新建按钮
		ta=new TextArea(25,70);	//新建文本编辑区域，15行40列

		d=new Dialog(f,"提示信息-self",true);	//新建一个对话框,true值表示当前窗口不处理就无法处理后置窗口
		d.setBounds(400,200,240,150);		//设置对话框的位置和宽高
		d.setLayout(new BorderLayout());		//设置对话框布局为流式布局

		lab=new Label();			//创建标签
		okbu=new Button("确定");		//创建对话框中的按钮

		d.add(lab);
		d.add(okbu);

		f.add(tf);
		f.add(but);
		f.add(ta);

		myEvent();	
		f.setVisible(true);	//设置窗口可视
	}
	private void myEvent()
	{
		okbu.addActionListener(new ActionListener()	//操作时调用
			{
				public void actionPerformed(ActionEvent e)
				{
					d.setVisible(false);	//点击对话框的确认按钮事件就会不显示对话框了
				}
			});
		d.addWindowListener(new WindowAdapter()	//添加窗体关闭方法，复写关闭方法
			{
				public void windowClosing(WindowEvent e)
				{
					d.setVisible(false);	//点击对话框关闭按钮的时候就不显示对话框了
				}
			});
		tf.addKeyListener(new KeyAdapter()
		{
			public void keyPressed(KeyEvent e)
			{
				
					try
					{
					if(e.getKeyCode()==KeyEvent.VK_ENTER)
						showDir();		//在操作时调用目录转入文本区功能函数
					}
					catch(Exception ex)
					{
						throw new RuntimeException();
					}
			}
		});
					
		but.addActionListener(new ActionListener()	//添加窗体监听器
			{
				public void actionPerformed(ActionEvent e)	//操作时调用
				{
					try
					{
						showDir();		//在操作时调用目录转入文本区功能函数
					}
					catch(Exception ex)
					{
						throw new RuntimeException();
					}
				}
			});
		f.addWindowListener(new WindowAdapter()		//添加窗体关闭方法，复写关闭方法
			{
				public void windowClosing(WindowEvent ex)
				{
					System.exit(0);		//退出窗体
				}
			});

	}

	private void showDir()	throws Exception     //输入目录后转入文本区的功能封装成一个方法
	{
		ta.setText("");

		String urlpath=tf.getText();	//获取网页地址
		
		URL url=new URL(urlpath);	//将网页地址传入资源定位符中
		URLConnection conn=url.openConnection();	//返回url连接到的远程对象
		
		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 MyIEGUI2();
	}
}