JAVA-day13-网络编程1-优快云博客

本文链接：https://blog.youkuaiyun.com/lc635408136/article/details/42103045

package com.qianfeng.net;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Demo1 {

	/**
	 * @param args
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException {
		//得到本地主机的IP地址对象
		//InetAddress  local = InetAddress.getLocalHost();
		
		//获取任意一台主机的IP地址对象
		InetAddress  local = InetAddress.getByName("www.baidu.com");
		
		//获取IP地址
		String ip  = local.getHostAddress();
		//获取主机名
		String name = local.getHostName();
		
		System.out.println(ip+":"+name);
		
		

	}

}

UDP

package com.qianfeng.udp1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceive1 {

	/**
	 * 创建udp协议的接收方
	 * 1:创建接收数据的Socket,同时要监听一个端口
	 * 2：创建一个空的数据报包，来接收发送端发送的数据报包，可以保证数据的原样性
	 * 3:使用Socket的接收功能接收数据
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		System.out.println("接收方启动......");
		//创建接收数据的Socket
		DatagramSocket  ds = new DatagramSocket(20000);
		
		//创建一个空的数据报包,来接收发送端发送的数据报包
		byte[] buf = new byte[1024];
		DatagramPacket  dp = new DatagramPacket(buf, buf.length);
		
		//使用Socket的接收功能接收数据
		ds.receive(dp);
		
		//解析数据报包中的数据
		//获取发送过来的数据
		byte[] arr = dp.getData();
		String data = new String(arr,0,dp.getLength());
		
		//得到发送方的ip地址
		String ip = dp.getAddress().getHostAddress();
		
		//得到发送方使用端口号
		int port = dp.getPort();
		
		System.out.println(ip+":"+port+":"+data);
		ds.close();
	}

}

package com.qianfeng.udp1;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UdpSend1 {

	public UdpSend1() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 创建基于udp协议的发送端
	 * 1:创建Socket端点
	 * 2:明确要发送的数据
	 * 3:把要发送的数据封装成数据报包
	 * 4:使用Socket的发送功能发送数据
	 * @throws IOException 
	 * 
	 */
	public static void main(String[] args) throws IOException {
		System.out.println("发送方启动......");
		//1:创建Socket端点
		DatagramSocket   ds = new DatagramSocket();
		
		//2:明确要发送的数据
		String  ss ="哥们儿，你好";
		byte[] arr = ss.getBytes();
		//把要发送的数据封装成数据报包:包含了要发生的数据，接收数据的主机，接收数据使用的端口
		DatagramPacket dp = new DatagramPacket(arr,arr.length,InetAddress.getByName("10.0.160.33"),20000);
		
		//使用Socket的发送功能发送数据
		ds.send(dp);
		
		
		//释放资源
		ds.close();

	}

}

package com.qianfeng.udp2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceive2 {

	/**
	 * 创建udp协议的接收方
	 * 1:创建接收数据的Socket,同时要监听一个端口
	 * 2：创建一个空的数据报包，来接收发送端发送的数据报包，可以保证数据的原样性
	 * 3:使用Socket的接收功能接收数据
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		System.out.println("接收方启动......");
		//创建接收数据的Socket
		DatagramSocket  ds = new DatagramSocket(20000);
		
		while(true)
		{
			//创建一个空的数据报包,来接收发送端发送的数据报包
			byte[] buf = new byte[1024];
			DatagramPacket  dp = new DatagramPacket(buf, buf.length);
			//使用Socket的接收功能接收数据
			ds.receive(dp);
			
			//解析数据报包中的数据
			//获取发送过来的数据
			String data = new String(dp.getData(),0,dp.getLength());
			String ip = dp.getAddress().getHostAddress();
			System.out.println(ip+":"+data);
		}
		
	}

}

package com.qianfeng.udp2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UdpSend2 {

	public UdpSend2() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 发送方可以接收键盘录入的数据一直发送
	 * 创建基于udp协议的发送端
	 * 1:创建Socket端点
	 * 2:明确要发送的数据
	 * 3:把要发送的数据封装成数据报包
	 * 4:使用Socket的发送功能发送数据
	 * @throws IOException 
	 * 
	 */
	public static void main(String[] args) throws IOException {
		//发送方可以接收键盘录入的数据一直发送
		System.out.println("发送方启动......");
		//1:创建Socket端点
		DatagramSocket   ds = new DatagramSocket();
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = null;
		
		while((line = br.readLine())!=null)
		{
			if("over".equals(line))
				break;
			byte[] arr = line.getBytes();
			//把要发送的数据封装成数据报包:包含了要发生的数据，接收数据的主机，接收数据使用的端口
			DatagramPacket dp = new DatagramPacket(arr,arr.length,InetAddress.getByName("10.0.160.255"),20000);
			
			//使用Socket的发送功能发送数据
			ds.send(dp);
		}
			
		
		//释放资源
		ds.close();

	}

}

package com.qianfeng.udp3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UdpChat {

	public UdpChat() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 实现一个群聊功能：在发送的同时还可以接收，就得使用多线程，一个线程负责发送，一个线程负责接收
	 * @throws SocketException 
	 */
	public static void main(String[] args) throws SocketException {
       DatagramSocket send = new DatagramSocket();
       DatagramSocket receive = new DatagramSocket(18888);
       
       new Thread(new Send(send)).start();
       new Thread(new Receive(receive)).start();
	}

}

// 定义发送任务
class Send implements Runnable {
	private DatagramSocket socket;

	public Send(DatagramSocket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = null;
		try {
			while ((line = br.readLine()) != null) {
				byte[] arr = line.getBytes();

				DatagramPacket packet = new DatagramPacket(arr, arr.length,
						InetAddress.getByName("10.0.160.255"), 18888);
				
				socket.send(packet);
				
				if("88".equals(line))
					break;

			}
			
		} catch (UnknownHostException e) {

			e.printStackTrace();
		} catch (IOException e) {

			e.printStackTrace();
		}

	}

}
// 定义接收任务
class Receive implements Runnable
{
	private DatagramSocket socket;
	
	public Receive(DatagramSocket socket)
	{
		this.socket = socket;
	}

	@Override
	public void run() {
		
		while(true)
		{
			byte[] arr = new byte[1024];
			DatagramPacket dp = new DatagramPacket(arr,arr.length);
			
			try {
				socket.receive(dp);
				String data = new String(dp.getData(),0,dp.getLength());
				String ip = dp.getAddress().getHostAddress();
				
				System.out.println(ip+":"+data);
				if("88".equals(data))
				{
					System.out.println(ip+"离开了聊天室");
				}
			} catch (IOException e) {
				
				e.printStackTrace();
			}
			
			
		}
		
	}
	
}

TCP

package com.qianfeng.tcp1;

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

public class TcpClient1 {

	/**
	 * 创建tcp的客户端
	 * 1:创建Socket端点,
	 * 2:从Socket流中获取输出流
	 * 3:向服务器端发送数据
	 * 4：关闭资源
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		//在创建断点的同时，需要指明连接的服务器的IP地址和服务器接收数据的地址
		//如果连接成功，就建立了一条通道，这条通道就是Socket流,这个流中既有输入流也有输出流
		Socket s = new Socket("10.0.160.33",19999);
		System.out.println(s);
		//向服务器端发送数据--使用Socket流中的输出流
		OutputStream  out = s.getOutputStream();
		
		//发送数据--其实就是向流中写入数据
	    out.write("哥们，你好".getBytes());
	    
	    //关闭资源
	    s.close();
	}

}

package com.qianfeng.tcp1;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer1 {

	/**
	 * 创建tcp服务器端
	 * 1:创建ServerSocket端点,监听一个端口
	 * 2:接收数据
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		System.out.println("tcp服务器端启动......");
		
		//创建ServerSocket端点
		ServerSocket ss = new ServerSocket(19999);
		
		//得到客户端对象--其实得到客户端对象就是得到客户端的Socket流
		Socket s = ss.accept();
		System.out.println(s.getInetAddress()+"连接到服务器......");
		
		//接收客户端发送的数据其实就是从Socket流中读取数据
		InputStream in = s.getInputStream();
		
		//读取客户端发送过来的数据
		byte[] arr = new byte[1024];
		int len = 0;
		len = in.read(arr);
		System.out.println(new String(arr,0,len));
		
		s.close();
		ss.close();
		
	}

}

package com.qianfeng.tcp2;

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

public class TcpServer2 {

	/**
	 * 创建tcp服务器端
	 * 1:创建ServerSocket端点,监听一个端口
	 * 2:接收数据
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		System.out.println("tcp服务器端启动......");
		
		//创建ServerSocket端点
		ServerSocket ss = new ServerSocket(19999);
		
		//得到客户端对象--其实得到客户端对象就是得到客户端的Socket流
		Socket s = ss.accept();
		System.out.println(s.getInetAddress()+"连接到服务器......");
		
		//接收客户端发送的数据其实就是从Socket流中读取数据
		InputStream in = s.getInputStream();
		
		//读取客户端发送过来的数据
		byte[] arr = new byte[1024];
		int len = 0;
		len = in.read(arr);
		System.out.println(new String(arr,0,len));
		
		//向客户端发送数据
		OutputStream out = s.getOutputStream();
		out.write("你好，我是服务器端".getBytes());
		
		
		
		s.close();
		ss.close();
		
	}

}

package com.qianfeng.tcp2;

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

public class TcpClient2 {

	/**
	 * 创建tcp的客户端
	 * 1:创建Socket端点,
	 * 2:从Socket流中获取输出流
	 * 3:向服务器端发送数据
	 * 4：关闭资源
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		//在创建断点的同时，需要指明连接的服务器的IP地址和服务器接收数据的地址
		//如果连接成功，就建立了一条通道，这条通道就是Socket流,这个流中既有输入流也有输出流
		Socket s = new Socket("10.0.160.33",19999);
		System.out.println(s);
		//向服务器端发送数据--使用Socket流中的输出流
		OutputStream  out = s.getOutputStream();
		
		//发送数据--其实就是向流中写入数据
	    out.write("哥们，你好".getBytes());
	    
	    //读取服务器端发送过来的数据
	    InputStream in = s.getInputStream();
	    byte[] arr = new byte[1024];
	    int len = 0;
	    len = in.read(arr);
	    System.out.println(new String(arr,0,len));
	    
	    //关闭资源
	    s.close();
	}

}

package com.qianfeng.tcp3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServer3 {

	/**
	 *实现一个大写转换服务器：
	 *       客户端接收键盘输入的小写字符串，发送给服务器端
	 *       服务器端把小写的字符串转成大写再发给客户端
	 *       直到输入over结束 
	 *服务器端的实现：
	 *1：创建ServerSocket对象，同时监听一个端口
	 *2:获取客户端对象
	 *3：读取小写的字符串
	 *4：发送大写的字符串
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//创建ServerSocket对象，同时监听一个端口
		ServerSocket ss = new ServerSocket(18889);
		
		//获取客户端对象
		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress()+"连接到服务器端.........");
		//创建读取客户端的小写字符串的字符读取流
		InputStream in = s.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(in));
		
		//创建向客户端发送数据的字符输出流
		OutputStream out = s.getOutputStream();
		PrintWriter  pw = new PrintWriter(out,true);
		
		String line = null;
		while((line = br.readLine())!=null)
		{
			pw.println(line.toUpperCase());
		}
		
		s.close();
		ss.close();

	}

}

package com.qianfeng.tcp3;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class TcpClient3 {

	public TcpClient3() {
		// TODO Auto-generated constructor stub
	}

	/**
	 *实现一个大写转换服务器：
	 *       客户端接收键盘输入的小写字符串，发送给服务器端
	 *       服务器端把小写的字符串转成大写再发给客户端
	 *       直到输入over结束 
	 * 客户端实现：
	 * 1：创建客户端的Socket对象
	 * 2:读取键盘输入的小写字符串
	 * 3：把小写的字符串发送给服务器端
	 * 4：读取服务器端发送回来的大写字符串
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		
		//创建客户端的Socket对象
		Socket s = new Socket("10.0.160.33",18889);
		
		//创建读取键盘输入的内容的字符读取流
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		//创建向服务器端发送数据的字符输出流
		OutputStream out = s.getOutputStream();
		PrintWriter pw = new PrintWriter(out,true);
		
		//创建读取服务器端发回 的数据的字符读取流
		InputStream in = s.getInputStream();
		BufferedReader  buf = new BufferedReader(new InputStreamReader(in));
		
		String line = null;
		while((line = br.readLine())!=null)
		{
			if("over".equals(line))
				break;
			pw.println(line);
			//读取服务器端发送的大写字符串
			String str = buf.readLine();
			System.out.println(str);
		}
		
		br.close();
		s.close();
		
	}

}

package com.qianfeng.tcp4;

import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TextUploadServer {

	/**
	 * 实现文件上传的服务器端：
	 * 1：创 建ServerSocket,并监听一个端口
	 * 2:获取客户端对象
	 * 3：循环读取客户端方式的数据
	 * 4：写入到本地的一个文件
	 * 5：向客户端发送“上传成功”
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		//创 建ServerSocket,并监听一个端口
		ServerSocket ss = new ServerSocket(19999);
		//获取客户端对象
		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress()+"连接到服务器端.........");
		
		//创建读取客户端的字符读取流
		BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		//创建写入文件的字符写入流
		PrintWriter pw = new PrintWriter(new FileWriter("tempfile\\copy2.java"),true);
		
		//创建向客户端写入数据的字符输出流
		PrintWriter  out = new PrintWriter(s.getOutputStream(),true);
		
		//读写
		String line = null;
		while((line =br.readLine())!=null)
		{
			//if("over".equals(line))
				//break;
			pw.println(line);
		}
		
		//发送“上传成功”
		out.println("上传成功");
		
		pw.close();
		s.close();
		ss.close();
		
		
		
		
		
	}

}

package com.qianfeng.tcp4;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class TextUploadClient {

	public TextUploadClient() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 实现文本文件的上传的客户端，服务器端向客户端发送“ 上传成功”
	 * 1:创建Socket端点，同时指定服务器的地址和端口
	 * 2:读取本地文本文件
	 * 3:写入到服务器端
	 * 4:读取服务器端向客户端发送 的 “ 上传成功”
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		//创建Socket端点，同时指定服务器的地址和端口
		Socket s = new Socket("10.0.160.33",19999);
		
		//创建读取文件的字符读取流
		BufferedReader br = new BufferedReader(new FileReader("tempfile\\TcpClient1.java"));
		
		//创建向服务器端写入数据的字符输出流
		OutputStream out = s.getOutputStream();
		PrintWriter pw = new PrintWriter(out,true);
		
		//创建读取服务器端的字符读取流
		InputStream in = s.getInputStream();
		BufferedReader buf = new BufferedReader(new InputStreamReader(in));
		
		//读写
		String line = null;
		while((line = br.readLine())!=null)
		{
			pw.println(line);
		}
		
		//向服务器端写入结束标记，告诉服务器端写入的数据已经写完
		s.shutdownOutput();
		
		
		//读取"上传成功"
		String str = buf.readLine();
		System.out.println(str);
		
		br.close();
		s.close();
		
		

	}

}

package com.qianfeng.tcp5;

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

public class PicUploadServer {

	public PicUploadServer() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 文件上传的服务器端
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//创建ServerSocket对象
		ServerSocket ss = new ServerSocket(20002);
		
		//获取客户端对象
		Socket s = ss.accept();
		
		//创建读取客户端的字节读取流
		InputStream in = s.getInputStream();
		
		//创建写入文件的字节输出流
		FileOutputStream fos = new FileOutputStream("tempfile\\ok_copy.jpg");
		
		//创建向客户端写入数据的字节输出流
		OutputStream out = s.getOutputStream();
		
		//读写
		byte[] arr = new byte[1024];
		int len =0;
		while((len = in.read(arr))!=-1)
		{
			fos.write(arr,0,len);
		}
		
		//写入"上传成功"
		out.write("上传成功".getBytes());
		
		fos.close();
		s.close();
		ss.close();
		

		
		
	}

}

package com.qianfeng.tcp5;

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

public class PicUploadClient {

	public PicUploadClient() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 上传图片的客户端
	 * 
	 * 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		
		//创建Socket对象
		Socket s = new Socket("10.0.160.33",20002);
		
        //创建读取文件的字节读取流
		FileInputStream fis = new FileInputStream("tempfile\\ok.jpg");
		
		//创建写入到服务器端的字节输出流
		OutputStream out = s.getOutputStream();
		
		//创建读取服务器端数据的字节输入流
		InputStream in = s.getInputStream();
		
		byte[] arr = new byte[1024];
		int len = 0;
		while((len = fis.read(arr))!=-1)
		{
			out.write(arr,0,len);
		}
		
		//向服务器端写入结束标记
		s.shutdownOutput();
		
		//读取“上传成功 ”
		byte[] b = new byte[1024];
		int num = in.read(b);
		System.out.println(new String(b,0,num));		
	}

}

package com.qianfeng.tcp6;

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

public class UploadPic implements Runnable {

	private Socket s;
	public UploadPic() {
		
	}
	public UploadPic(Socket s)
	{
		this.s = s;
	}

	@Override
	public void run() {
		
		String  ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"连接到服务器端.......");
		try {
			
			File dir = new File("e:\\picturess");
			if(!dir.exists())
				dir.mkdir();
			int count = 1;
			File file = new File(dir,ip+"("+count+")"+".jpg");
			while(file.exists())
			{
				file = new File(dir,ip+"("+(++count)+")"+".jpg");
			}
			
			InputStream in = s.getInputStream();
			FileOutputStream fos = new FileOutputStream(file);
			byte[] arr = new byte[1024];
			int len =0;
			while((len = in.read(arr))!=-1)
			{
				fos.write(arr,0,len);
			}
			
			fos.close();
			OutputStream out = s.getOutputStream();
			out.write("上传成功".getBytes());
			
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		
	}

}

package com.qianfeng.tcp6;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class PicUploadServer2 {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		ServerSocket ss = new ServerSocket(20003);
		
		while(true)
		{
			Socket s = ss.accept();
			new Thread(new UploadPic(s)).start();
		}
	}
}

package com.qianfeng.tcp6;

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

public class PicUploadClient2 {

	public PicUploadClient2() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * 上传图片的客户端
	 * 
	 * 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		
		//创建Socket对象
		Socket s = new Socket("10.0.160.33",20003);
		
        //创建读取文件的字节读取流
		FileInputStream fis = new FileInputStream("tempfile\\ok.jpg");
		
		//创建写入到服务器端的字节输出流
		OutputStream out = s.getOutputStream();
		
		//创建读取服务器端数据的字节输入流
		InputStream in = s.getInputStream();
		
		byte[] arr = new byte[1024];
		int len = 0;
		while((len = fis.read(arr))!=-1)
		{
			out.write(arr,0,len);
		}
		
		//向服务器端写入结束标记
		s.shutdownOutput();
		
		//读取“上传成功 ”
		byte[] b = new byte[1024];
		int num = in.read(b);
		System.out.println(new String(b,0,num));		
	}

}

package com.qianfeng.tcp7;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class Url {

	/**
	 * @throws IOException 
	 * 
	 */
	public static void main(String[] args) throws IOException {
		
        String path = "http://localhost:8080/myweb/index.html?name=lisi";
        
        URL url = new URL(path);
        
        System.out.println(url.getProtocol());
        System.out.println(url.getHost());
        System.out.println(url.getPort());
        System.out.println(url.getPath());
        System.out.println(url.getFile());
        
        //连接服务器端
        URLConnection con = url.openConnection();
        
        InputStream in = con.getInputStream();
        byte[] arr = new byte[1024];
        int len  =0;
        len = in.read(arr);
        System.out.println(new String(arr,0,len));
        
        
        
        
        
	}

}

package com.qianfeng.tcp7;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {

	/**
	 * 客户端是使用现成的浏览器
	 * 服务器端使用自定义的服务器
	 */
	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(20005);
		
		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress()+"连接到服务器.....");
		
		//读取浏览器向服务器端发送的数据
		InputStream in = s.getInputStream();
		byte[] arr = new byte[1024];
		int len =0;
		len = in.read(arr);
		System.out.println(new String(arr,0,len));
		
		
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		
		pw.println("欢迎访问!!!!");
		
		s.close();
		ss.close();

	}

}
/*请求的头信息
GET / HTTP/1.1
Host: localhost:20005
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,;q=0.8
User-Agent: Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36 SE 2.X MetaSr 1.0
Accept-Encoding: gzip,deflate,sdch
Accept-Language: zh-CN,zh;q=0.8
 */

package com.qianfeng.tcp7;

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

public class MyBrowser {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket s = new Socket("10.0.160.33",8080);
		
		OutputStream out = s.getOutputStream();
		
		PrintWriter pw = new PrintWriter(out,true);
		pw.println("GET /myweb/index.html HTTP/1.1");
		pw.println("Host: localhost:8080");
		pw.println("Connection: keep-alive");
		pw.println("Accept: */*");
		pw.println("Accept-Language: zh-CN,zh;q=0.8");
		pw.println();
		pw.println();
		
		InputStream in = s.getInputStream();
		byte[] arr = new byte[1024];
		int len = in.read(arr);
		System.out.println(new String(arr,0,len));
	}

}

/*响应头信息
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Accept-Ranges: bytes
ETag: W/"205-1409283202284"
Last-Modified: Fri, 29 Aug 2014 03:33:22 GMT
Content-Type: text/html
Content-Length: 205
Date: Fri, 12 Dec 2014 08:37:21 GMT
 */

/*
客户端通过键盘录入用户名。
服务端对这个用户名进行校验。

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

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

最多就登录三次。

*/
import java.io.*;
import java.net.*;
class Login 
{
	public static void main(String[] args)throws Exception 
	{
		Socket s = new Socket("192.168.102.101",9999);
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

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

		for(int i=1;i<=3;i++)
		{
		   String name = br.readLine();
		   if(name == null)
			   break;
		   pw.println(name);
           
		   String infor=in.readLine();
		   System.out.println(name+":"+infor);
		   if(infor.contains("欢迎"))
			   break;
		}
	}
}
class Check implements Runnable
{
   private Socket s;
   public Check(Socket s)
	{
        this.s = s;
    }
   public void run()
	{
        try
        {
			  for(int i=1;i<=3;i++)
			  {
			     BufferedReader  in = new BufferedReader(new InputStreamReader(s.getInputStream()));
				 String name= in.readLine();
				 if(name==null)
					 break;
				 BufferedReader br = new BufferedReader(new FileReader("user.txt"));

				 String line = null;
				 boolean flag = false;
				 while((line = br.readLine())!=null)
				  {
				          if(line.equals(name))
					      {
						      flag = true;
							  break;
						  }
				  }
				  PrintWriter pw = new PrintWriter(s.getOutputStream(),true);

				  if(flag)
				  {
				     System.out.println(name+"已登陆");
					 pw.println(name+"欢迎光临");
					 break;
				  }
				  else
				  {
				     System.out.println(name+"尝试登陆");
					 pw.println(name+"该用户不存在");
				  }
			  
			  
			  }
			  s.close();

        }
        catch (Exception e)
        {
			throw new RuntimeException("验证异常");
        }
   
    }


}

class UserLogin
{
	public static void main(String[] args)throws Exception
	{
		ServerSocket  ss = new ServerSocket(9999);

		while(true)
		{
		     Socket s = ss.accept();
			 new Thread(new Check(s)).start();
		}
	}
}