黑马程序员——Java基础：网络编程

最新推荐文章于 2015-09-03 09:36:48 发布

幻化

最新推荐文章于 2015-09-03 09:36:48 发布

阅读量512

点赞数

分类专栏： Java学习笔记

本文链接：https://blog.csdn.net/u012770105/article/details/46698635

版权

Java学习笔记专栏收录该内容

17 篇文章 0 订阅

订阅专栏

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

一、网络编程

网络编程：在java.net包中。

网络通信：

      1.首先要找到对方的IP。

      2.数据要发送到对方指定的应用程序上，为了标识这些程序，所以给这些网络应用程序都用数字进行标识，为了方便称呼这个数字，我们叫做端口，逻辑端口（0~65535，其中0~1024被系统用了，或成为保留端口）。

      3.定义网络规则，这个网络规则称为协议。国际组织定义了通用协议TCP/IP。

即网络通信的三要素是：IP地址，端口号，传输协议。

注：可在dos中输入：ping 127.0.0.1或ping localhost(称为：本地回环地址)来测试网卡。

        在dos中输入：ipconfig可查看本机地址。

网络参考模型：

注：通常用户操作的是应用层，而编程人员需要做的是传输层和网际层，用户在应用层操作的数据，经过逐层封包，最后到物理层发送到另一个模型中，再进行逐层解包。

那么如何获取IP地址呢？

示例：获取IP
import java.net.*;
class TCPAddressDemo 
{
	public static void main(String[] args) throws UnknownHostException
	{
		//获取本机地址和名称
		InetAddress i=InetAddress.getLocalHost();
		String address=i.getHostAddress();
		String name=i.getHostName();
		//获取百度地址
		InetAddress ia=InetAddress.getByName("www.baidu.com");
		String str=ia.getHostAddress();
		System.out.println("address:"+address+"\tname:"+name);
		System.out.println("address："+str);
	}
}
常见的传输协议：

   1）UDP特点：

　　 1.面向无连接，即将数据及源和目的封装成数据包中，不建立链接的发送/面向无连接。

          2.每个数据包的大小限制在64K之内/数据会封包，限制在64K内。

          3.因无连接，是不可靠的协议/不可靠。

          4.不建立连接，速度快/速度快，易丢包。

    如：视频会议、聊天软件等。

   2）TCP特点：

         1.面向连接，在建立连接后，形成传输数据的通道/面向对象。

         2.在连接中进行大数据量的传输。

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

          4.必须建立连接，效率稍慢。

    如：打电话，下载等。

注：三次握手第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。

       如：找人时，A：在？ B：在。A：我知道了。

二、网络传输

1）UDP传输(DatagramSecket和DatagramPacket)的步骤：

1.创建发送器，接收器。

2.建立数据包。

3.调用socket的发送接收方法。

4.关闭socket。

注：发送端和接收端是两个独立运行的程序。

其中，socket：它被称之为插座，为网络服务提供的一种机制。相当于码头，想要通信先要有港口。通信的两端都要有socket。网络通信其实就是socket之间的通信。数据在两个socket之间通过IO传输。

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

/*需求：定义一个应用程序，用于接收UDP协议传输的数据并处理
思路：1.定义一个UDP的socket服务，通常会监听一个端口，就是给这个接收网络应用程序定一个数字标识，
方便明确哪些数据过来该应用程序可以进行处理
2.定义一个数据包，用来存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
3.通过socket服务的receive方法接收到的数据存入已定义好的数据包中
4.通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上
5.关闭资源*/
import java.net.*;
class UDPRece2308
{
	public static void main(String[] args)  throws Exception
	{
		 receUDP();
	}
	//接收数据
	public static void receUDP()throws Exception
	{
		DatagramSocket ds=new DatagramSocket(10000);//建立接收端
		byte[] buf=new byte[1024];
		DatagramPacket dp=new DatagramPacket(buf,buf.length);//创建包，用于存储数据
		ds.receive(dp);//调用socket服务的接收方法，将接收到的数据存到包中
		//获取包中的数据信息
		String ip=dp.getAddress().getHostAddress();
		String data=new String(dp.getData(),0,dp.getLength());
		int port=dp.getPort();
		System.out.println("ip="+ip+"data="+data+"port="+port);
		ds.close();//关闭资源
	}
}

先将程序打开，等待数据传过来

示例：通过UDP传输方式，将一段文字数据发送出去。

/*需求：通过UDP传输方式，将一段文字数据发送出去。
思路：1.建立UDP的socket服务
      2.提供数据，并将数据封装进包中
      3.通过socket服务的发送功能，将数据发送出去
      4.关闭资源
*/
import java.net.*;
class UDPSend2308
{
	public static void main(String[] args) throws Exception
	{
		 sendUDP();
	}
	//发送数据
	public static void sendUDP()throws Exception
	{
		DatagramSocket ds=new DatagramSocket();//建立发送端
		byte[] buf="Hello world".getBytes();
		//建立数据包
		DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.111"),10000);
		ds.send(dp);//调用socket服务的发送功能，将数据发送出去
		ds.close();//关闭资源
	}
}

传输数据：

UDPRece2308接收到的数据：

练习：编写一个聊天程序。如qq

/*编写一个聊天程序。如qq
有收数据部分，和发数据部分，这两部分同时执行，用到多线程

udp的发送端：
1：建立udp的socket服务，创建对象时如果没有明确端口，系统会自动分配一个未被使用的端口。
2：明确要发送的具体数据。
3：将数据封装成了数据包。
4：用socket服务的send方法将数据包发送出去。
5：关闭资源。

udp的接收端：
1：创建udp的socket服务，必须要明确一个端口，作用在于，只有发送到这个端口的数据才是这个接收端可以处理的数据。
2：定义数据包，用于存储接收到数据。
3：通过socket服务的接收方法将收到的数据存储到数据包中。
4：通过数据包的方法获取数据包中的具体数据内容，比如ip、端口、数据等等。
5：关闭资源。
*/
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)
			{
				if("886".equals(line))
					break;
				byte[] buf=line.getBytes(); // 2，明确要发送的具体数据。
				DatagramPacket dp=new DatagramPacket(buf // 3，将数据封装成了数据包。
					,buf.length,InetAddress.getByName("192.168.139.1"),10010);
				ds.send(dp);// 4，用socket服务的send方法将数据包发送出去。
			}
		}
		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];
				// 2，定义数据包，用于存储接收到数据。先定义字节数组，数据包会把数据存储到字节数组中。
				DatagramPacket dp=new DatagramPacket(buf,buf.length);
				// 3，通过socket服务的接收方法将收到的数据存储到数据包中。
				ds.receive(dp);
				// 4，通过数据包的方法获取数据包中的具体数据内容，比如ip，端口，数据等等。
				String ip=dp.getAddress().getHostAddress();
				int port = dp.getPort();
				String data=new String(dp.getData(),0,dp.getLength());
				System.out.println(ip+"::"+"::"+port+"::"+data);
			}
		}
		catch (Exception e)
		{
			throw new RuntimeException("接收失败");
		}	
	}
}

class UDPDemo
{
	public static void main(String[] args) throws Exception
	{
		// 1，建立udp的socket服务。
		DatagramSocket send=new DatagramSocket();//端口可以不指定，系统会随机分配。
		// 1，创建udp的socket服务。
		DatagramSocket rece=new DatagramSocket(10010);
		new Thread(new Send(send)).start();
		new Thread(new Rece(rece)).start();
	}
}

2）TCP传输(Socket和ServerSocket)的步骤：

1.创建客户端和服务器端

2.建立连接后，通过socket中的IO流进行数据的传输

3.关闭socket

注：同样客户端和服务器端是两个独立的应用程序。

服务端：

服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。

1）建立服务端的Socket服务，并监听一个端口。

2）获取连接过来的客户对象，通过ServerSocket的accept()方法，没有连接就会等待，所以此方法是阻塞式的。

3）客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。

4）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。

注：ServerSocket(int port,int packlog)：其中backlog表示队列的最大长度，即最多连入客户端的个数，即最大连接数。

示例：定义端点接收数据并打印在控制台上

import java.io.*;
import java.net.*;
class TCPServerDemo2309 
{
	public static void main(String[] args) throws IOException
	{
		//建立服务端的Socket服务，并监听一个端口
		ServerSocket ss=new ServerSocket(10001);
		//通过accept方法获取连接过来的客户端对象
		Socket s=ss.accept();
		String ip=s.getInetAddress().getHostAddress();
		//获取客户端发送过来的数据，通过客户端读取流的方式来读取数据
		InputStream in=s.getInputStream();
		byte[] buf=new byte[1024];
		int len=in.read(buf);
		String data=new String(buf,0,len);
		System.out.println("ip:"+ip+"\tdata:"+data);
		s.close();
		ss.close();
	}
}

打开服务端：

客户端：

通过查阅Socket对象的API文档，发现在该对象在建立时，就可去连接指定主机，因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。

1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取

2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Socket的输入流

3）通过输出流的write()方法将要发送的数据写入到流中

4）关闭Socket流资源

注：创建Socket对象，可以创建空参数的Socket对象。如Socket s=new Socket();通过connect(SocketAddress endPoint)方法来连接到服务器。其中，SocketAddress 的子类InetSocketAddress 封装了ip地址和端口。

示例：给服务器发送一个文本数据

/*需求：给服务端发送一个文本文件
思路：创建socket服务，并指定要连接的主机和端口
*/
import java.io.*;
import java.net.*;
class  TCPClientDemo2309
{
	public static void main(String[] args) throws IOException
	{
		//创建客户端socket对象，指定目的主机和端口，对象一建立，流就建立了
		Socket s=new Socket("192.168.1.111",10001);
		//获取socket流中的输出流
		OutputStream out=s.getOutputStream();
		out.write("Hello World".getBytes());
		s.close();
	}
}

客户端发送数据：

服务端接收到的数据：

练习1：建立一个文本转换服务器。客户端TCPClient2313,服务端TCPServer2313。客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端，而客户端可以不断的进行文本转换，可客户端输入over时，转换结束。

服务端：

分析：
服务端：
	源：socket读取流
	目的：socket输出流*/
import java.net.*;
import java.io.*;
import java.util.*;
class TCPServer2313 
{
	public static void main(String[] args) throws Exception
	{
		server(10000);
	}
	public static void server(int num)throws Exception
	{
		//接受客户端发送的信息2
		ServerSocket ss=new ServerSocket(num);
		Socket s=ss.accept();
		String ip=s.getInetAddress().getHostAddress();
		System.out.println("ip:"+ip+"-------connect");
		//socket读取流
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		//BufferedWriter bufOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		//可改为：
		PrintWriter bufOut=new PrintWriter(s.getOutputStream(),true);//true为自动刷新

		String line=null;
		while((line=bufIn.readLine())!=null)
		{
			System.out.println("客户端发过来的信息:"+line);
			//给客户端发送信息3
			//bufOut.write(line.toUpperCase());
			//bufOut.newLine();//因为客户端的readLine()是阻塞式的，判断结束的标记是回车符
			//bufOut.flush();//写入到的是缓冲区中，需刷新
			//可改为：
			bufOut.println("服务端返回的数据是："+line.toUpperCase());
		}
		ss.close();
	}
}

打开服务端：

客户端：

分析：
客户端：既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考
源：键盘录入
目的：设备网络，设备输出流
操作的是文本数据，可以选择字符流
步骤：1.建立服务
	  2.获取键盘录入
	  3.将数据发送给服务端
	  4.接收服务端返回的大写数据(3,4.....)
	  5.结束，关闭资源
都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲
*/
import java.net.*;
import java.io.*;
class TCPClient2313 
{
	public static void main(String[] args) throws Exception
	{
		client("192.168.1.111",10000);
	}
	public static void client(String str,int num) throws Exception
	{	
		Socket s=new Socket(str,num);
		//源：定义读取键盘数据的流对象。
		//读取：输进来的是字节流，要用的是字符流，所以要用InputStreamReader
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		//目的：将数据写入到socket输出流中，发送给服务端
		//输出：现在的是字符流，要发送出去的是字节流，所以要用OutputStreamWriter
		//BufferedWriter bufOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		//BufferedWriter:缓冲区具有newLine();可改为：
		PrintWriter bufOut=new PrintWriter(s.getOutputStream(),true);//true为自动刷新

		//定义一个socket读取流，读取服务端返回的大写信息;BufferedReader:缓冲区具有readLine();
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		String line=null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			//发送信息到服务器端1
			//bufOut.write(line);
			//bufOut.newLine();//因为客户端的readLine()是阻塞式的，判断结束的标记是回车符
			//bufOut.flush();//当写入一行，写入到的是缓冲区中
			//可改为：
			bufOut.println(line);

			//读取服务器端发送的数据4
			String value=bufIn.readLine();
			System.out.println(value);
		}
		bufr.close();
        //当socket关闭，其带有的读取流(getInputStream),关闭流(getOutputStream)也会随之关闭
		s.close();//当socket关闭后，readLine的结束标记为-1，所以服务端也会结束
	}
}
/*该例出现的问题
现象：客户端和服务端都在莫名的等待
原因是：客户端和服务端都有阻塞式方法，这些方法没有读到结束标记，就会一直等，
而导致两端都在等待*/

客户端运行，传输数据并且返还的数据：

服务端接收的数据：

练习2：网络间文件复制

客户端：

分析：1.建立socket
	  2.将本地文件发送到服务端
	  源：是纯文本，用Reader，硬盘，FileReader
	  目的：是纯文本，用Writer，硬盘，FileWriter*/
import java.net.*;
import java.io.*;
import java.util.*;
class TCPClient2314 
{
	public static void main(String[] args)  throws Exception
	{
		Socket s=new Socket("192.168.1.111",10001);
		BufferedReader bufr=new BufferedReader(new FileReader("TCPClient2313.java"));
		//BufferedWriter bufOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		//可转换成：
		PrintWriter bufOut=new PrintWriter(s.getOutputStream(),true);
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		//结束方式1：建立时间戳，来解决两边都等待的问题
		//long time=System.currentTimeMillis();
		//bufOut.println(time+"");
		//可改为：
		//DataOutputStream dos=new DataOutputStream(s.getOutputStream());
		//long time=System.currentTimeMillis();
		//dos.writeLong(time);
		
		String line=null;
		while((line=bufr.readLine())!=null)
		{
			/*bufOut.write(line);
			bufOut.newLine();
			bufOut.flush();*/
			bufOut.println(line);
		}
		//结束方式2：
		s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记-1
		System.out.println(bufIn.readLine());
		bufr.close();
		s.close();
	}
}

服务端：

分析：1.建立serversocket
	  2.接收客服端发送过来的文件，并保存在本机上*/
import java.net.*;
import java.io.*;
import java.util.*;
class TCPServer2314 
{
	public static void main(String[] args)  throws Exception
	{
		ServerSocket ss=new ServerSocket(10001);
		Socket s=ss.accept();
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		String ip=s.getInetAddress().getHostAddress();
		System.out.println("ip:"+ip+"-------connect");
		//BufferedWriter bufw=new BufferedWriter(new FileWriter("D:\\TCPClick2313.java"));
		//可转换成：
		PrintWriter bufw=new PrintWriter(new FileWriter("D:\\TCPClient2313.java"),true);

		//BufferedWriter bufOut=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		//可转换成：
		PrintWriter bufOut=new PrintWriter(s.getOutputStream(),true);
        /*//结束方式1：
		DataInputStream dis=new DataInputStream(s.getInputStream());
		long time=dis.readLong();//获取时间戳,然后，判断时间戳(结束标记)
		long currentTime=System.currentTimeMillis();
		System.out.println("curr:"+currentTime+"-time"+time);*/

		String line=null;
		while((line=bufIn.readLine())!=null)
		{
			//if(time!=currentTime)
				//break;
			/*bufw.write(line);
			bufw.newLine();
			bufw.flush();*/
			bufw.println(line);
		}
		bufOut.println("发送成功！");
		bufw.close();
		s.close();
		ss.close();
	}
}
/*结束方式：
    方法1:
	根据判断标记，可用判断时间戳
	//建立时间戳,因为时间是唯一的，来解决两边都等待的问题
	//long time=System.currentTimeMillis();
	//bufOut.println(time+"");
	//DataInputStream dis=new DataInputStream(s.getInputStream());
	//long time=dis.readLong();//获取时间戳,然后再去跟当前时间判断(结束标记)
	方法2:
	socket中的shutdownOutput()://关闭客户端的输出流，相当于给流中加入一个结束标记-1
	shutdownInput()
*/

练习3：上传图片，并发上传图片

客户端：

分析：
1.建立socket
2.源：不是纯文本，字节流，硬件，FileInputStream
  目的：传给服务端，不是纯文本，字节流，硬件，FileOutputStream*/
import java.net.*;
import java.io.*;
import java.util.*;
class TCPClient2401
{
	public static void main(String[] args)  throws Exception
	{
		//给主函数传值。cmd中：java TCPClick2401 d:\1.jpg
		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("请上传jpg格式的图片"+file.getName());
			return;
		}
		if(file.length()>1024*1024*8)
		{
			System.out.println("图片太大了......");
			return;
		}

		Socket s=new Socket("192.168.1.111",10002);
		FileInputStream fin=new FileInputStream (file);
        OutputStream out=s.getOutputStream();
		int len;
		byte[] buf=new byte[1024];
		while((len=fin.read(buf))!=-1)
		{
			out.write(buf,0,len);
		}
		s.shutdownOutput();
		InputStream in=s.getInputStream();
		byte[] bufIn=new byte[1024];
		int num=in.read(bufIn);
		System.out.println(new String(bufIn,0,num));		
		fin.close();
		s.close();
	}
}

服务端：

import java.net.*;
import java.io.*;
import java.util.*;
class TCPServer2401
{
	public static void main(String[] args)  throws Exception
	{
		ServerSocket ss=new ServerSocket(10002);
		while(true)
		{
			Socket s=ss.accept();
			new Thread(new PicThread(s)).start();
		}
		//ss.close();
	}
	public static void server() throws Exception
	{
		ServerSocket ss=new ServerSocket(10002);
		while (true)
		{
			Socket s=ss.accept();
			String ip=s.getInetAddress().getHostAddress();
			System.out.println("ip:"+ip+"------connect");

			InputStream in=s.getInputStream();
			FileOutputStream fos=new FileOutputStream("D:\\Mine_Huan\\11.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();
	}
}
/*这个服务端有一个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程。
这是B客户端连接，只有等待。因为服务器端还没有处理完A客户端的请求，还没有循环回来执行
accept方法。所以暂时获取不到B客户端对象；
那么为了让多个客户端同时并发访问服务端，服务端最好就是将每个客户端封装到一个单独的线程中，
这样，就可以处理多个客户端请求了
如何定义线程呢？
只要明确每一个客户端要在服务端执行的代码就可，将该代码存到run方法中
*/
//例如：客户端并发发送图片
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:"+ip+"------connect");
			InputStream in=s.getInputStream();
			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)
		{
			throw new RuntimeException(ip+"出错了");
		}	
	}
}

练习4：客户端通过键盘录入用户名，服务端对这个用户名进行校验。如果该用户存在，在服务端显示：xxx已登陆，并在客户端显示：xxx欢迎光临。如果该用户不存在，在服务端显示：xxx尝试登陆，并在客户端显示：xxx，该用户不存在。最多就登陆三次

客户端：

import java.net.*;
import java.io.*;
import java.util.*;
class  TCPClient2403
{
	public static void main(String[] args)  throws Exception
	{
		Socket s=new Socket("192.168.1.111",10003);
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		OutputStream out=s.getOutputStream();
		PrintWriter pw=new PrintWriter(out,true);
		InputStream in=s.getInputStream();
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(in));
		for(int i=0;i<3;i++)//最多就登陆三次
		{
			String line=bufr.readLine();
			if(line==null)
				break;
			pw.println(line);

			String info=bufIn.readLine();
			if(info.contains("欢迎"))
				break;
			System.out.println(info);
		}
		bufr.close();
		s.close();
	}
}

服务端：

分析：1.获取客户端发送过来的信息与本地的用户文件(user2403.txt)进行比较判断*/
import java.net.*;
import java.io.*;
import java.util.*;
class Server implements Runnable
{
	private Socket s;
	Server(Socket s)
	{
		this.s=s;
	}
	public void run()
	{
		int count=0;
		String ip=s.getInetAddress().getHostAddress();	
		System.out.println("ip:"+ip+"------connect");
		try
		{
			for(int i=0;i<3;i++)
			{			
				InputStream in=s.getInputStream();
				BufferedReader bufIn=new BufferedReader(new InputStreamReader(in));
				BufferedReader bufr=new BufferedReader(new FileReader("user2403.txt"));
				OutputStream out=s.getOutputStream();
				PrintWriter pw=new PrintWriter(out,true);
				String line=null;
				String user=bufIn.readLine();
				if(user==null)
					break;
				boolean flag=false;//标记
				while((line=bufr.readLine())!=null)
				{
					if(line.equals(user))
					{
						flag=true;
						break;
					}
				}
				if(flag)
				{
					System.out.println(user+"已登陆");
					pw.println(user+"欢迎光临");
					break;
				}
				else
				{
					System.out.println(user+"尝试登陆");
					pw.println(user+"该用户不存在");
				}
			}
			s.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException(ip+"登陆失败");
		}		
	}
}
class  TCPServer2403
{
	public static void main(String[] args)  throws Exception
	{
		ServerSocket ss=new ServerSocket(10003);
		while(true)
		{
			Socket s=ss.accept();
			new Thread(new Server(s)).start(); 
		}
		
	}
}

练习5：客户端：浏览器，服务端：自定义

客户端：

import java.net.*;
import java.io.*;
import java.util.*;
class  TCPClient2404
{
	public static void main(String[] args)  throws Exception
	{
		Socket s=new Socket("192.168.1.111",10004);
		OutputStream out=s.getOutputStream();
		PrintWriter pw=new PrintWriter(out,true);
		pw.println("GET /JavaExercise/myhtml HTTP/1.1");
		//pw.println("GET /Mine_Huan/MyFile/JavaExercise/myhtml HTTP/1.1");
		pw.println("Accept: */*");
		pw.println("Accept-Language: en-US");
		pw.println("Host: 192.168.139.1:10004");
		pw.println("Connection: closed");
		pw.println();
		pw.println();
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		String line=null;
		while((line=bufIn.readLine())!=null)
		{
			System.out.println(line);
		}
		s.close();
	}
}

服务端：

import java.net.*;
import java.io.*;
import java.util.*;
class  TCPServer2404
{
	public static void main(String[] args) throws Exception
	{
		ServerSocket ss=new ServerSocket(10004);
		Socket s=ss.accept();
		String ip=s.getInetAddress().getHostAddress();	
		System.out.println("ip:"+ip+"------connect");

		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();
		PrintWriter pw=new PrintWriter(out,true);
		pw.println("<font color='red' size='7'>Hello World!</font>");
		s.close();
		ss.close();
	}
}
//要先启动服务端(cmd),在浏览器中输入本机ip+访问端口即可访问服务端
//如：http://192.168.139.1:10004
//telnet：远程登陆命令，可以连接其它主机(相当于客户端)
//如：在cmd中：telnet 192.168.139.1 10004
//ip:192.168.139.1------connect

/**浏览器发送过来的信息:
GET /JavaExercise/myhtml HTTP/1.1
Accept: text/html, application/xhtml+xml, 
Accept-Language: en-US,en;q=0.5
User-Agent: Mozilla/5.0 (MSIE 9.0; Windows NT 6.3; WOW64; Trident/7.0; rv:11.0)
like Gecko
DontTrackMeHere: gzip, deflate
Host: 192.168.139.1:10004
DNT: 1
Connection: Keep-Alive

*/

注：浏览器发送给服务器的是：”HTTP的请求消息头“信息，第一行是请求行，最后一行空行的下面是：请求数据体；对应的还有”应答请求信息“。

三、URL对象和URLConnection对象：

URL：代表一个统一资源定位符，它是指向互联网“资源”的指针。即域名。

方法：

       1.String getProtocol()：获取协议名称

       2.String getHost()：获取主机名

       3.int getPort()：获取端口号

       4.String getFile()：获取URL文件名

       5.String getPath()：获取URL的路径部分

       6.String getQuery()：获取URL的查询部，客户端传输的特定信息

注：如果URL的路径出错，会报MalformedURLException异常。

       如当IP地址为192.168.1.254，当为254时，端口号为-1，默认其端口号为：80。

URLConnection类：是一个远程连接对象

如：URL url=new URL("http://write.blog.csdn.net/postedit/46698635");//创建URL对象

        URLConnection conn=url.openConnection();//连接指定主机，返回一个远程连接对象

        InputStream in=conn.getInputStream();

        byte[] buf=new byte[1024];

        int len=in.read(buf);

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

小知识：

    1.如果想将主机名翻译成IP地址，需要域名解析DNS(域名解析服务器)。

　　如：想登录www.sina.com.cn。需要先找DNS，通过DNS获取新浪IP地址，客户端再通过IP查找主机，但是它先要在本地主机上先查找再找DNS。

　 2.http://127.0.0.1:8080和http://localhost:8080：其实127和localhost的映射关系就在本地机子上，在”c:\windows\system32\drivers\ext\host“中，修改127和localhost的映射关系，可以有效的屏蔽恶意网站。

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

幻化

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——Java基础：网络编程

——-android培训、java培训、期待与您交流！ ———- 一、网络编程网络编程：在java.net包中。网络通信： 1.首先要找到对方的IP 2.数据要发送到对方指定的应用程序上，为了标识这些程序，所以给这些网络应用程序都用数字进行标识，为了方便称呼这个数字，我们叫做端口，逻辑端口（0~65535，其中0~1024被系统用了，或成为保留端口
复制链接

扫一扫