UDP和TCP

/**
 * java.net.InetAddress:此类表示互联网协议(IP)地址.
 * 把电脑的ip地址封装一个类,通过这个类可以操作地址了
 * 静态的成员方法：
 * 		static InetAddress getLocalHost() 返回本地(自己的电脑)主机
 * 		static InetAddress getByName(String host) 在给定机名的情况下确定主机的ip地址
 * 非静态成员方法：
 * 		InetAddress getLocalHost() 返回ip地址字符串
 * 		InetAddress getByName() 获取此地址的主机名
 */
public class DemoInetAddress {
	public static void main(String[] args) throws UnknownHostException {
		InetAddress host = InetAddress.getLocalHost();
		System.out.println("地址：" + host);
		InetAddress name = InetAddress.getByName("www.baidu.com");
		System.out.println(name);
	}
}

/**
 * UDP通信：面向无连接通信,不管是否有接收端,都可以发送数据
 * UDP通信的发送端：把数据和接收端的IP地址端口进行封装
 * 和UDP通信的相关类：
 * 		java.net.DatagramPacket：此类表示数据报包.（集装箱）
 * 		java.net.DatagramSocket:此类表示用来发送和接收数据包的套接字（码头）
 * 		套接字：封装了IP地址和端口号的网络软件
 * 构造方法：
 * 		DatagramPacket(byte[] buf,int length,InetAddress address,int port);
 * 		构造数据包,用来将长度为length的包发送到指定主机上的指定端口
 * 		参数说明：byte[] buf:要封装的数据;int length：发送的数据长度
 * 			   InetAddress address：接收端的IP地址对象;int port：端口
 * 		DatagramSocket() 创建DatagramSocket对象,系统随机分配端口号
 * 		DatagramSocket(int port) 创建数据报套接字并将其绑定到本地主机上的指定端口
 * 		DatagramSocket成员方法：void send(DatagramPacket p)
 */
public class UDPDemo {
	public static void main(String[] args) throws IOException {
		//1.创建DatagramPacket对象,封装数据,数据长度,接收端的IP地址和端口;进行打包
		//准备数据
		byte[] bytes = new byte[1024];
		DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
		//2.创建DatagramSocket对象,和系统要指定的端口号
		DatagramSocket socket = new DatagramSocket(8888);
		//3.使用DatagramSocket对象中的方法receive,接收接收发送端的数据报包
		socket.receive(packet);		
		InetAddress address = packet.getAddress();
		int length = packet.getLength();
		int port = packet.getPort();
		String msg = new String(bytes, 0, length);
		System.out.println(msg +"-->ip"+address.getHostAddress()+",端口号："+port);
		socket.close();
	}
}

public class UDPDemoSend {
	public static void main(String[] args) throws IOException {
		byte[] bytes = "你好".getBytes();
		//准备接收端的IP地址对象
		InetAddress address = InetAddress.getByName("127.0.0.1");		
		DatagramPacket packet = new DatagramPacket(bytes, bytes.length,address,8888);
		DatagramSocket socket = new DatagramSocket();
		socket.send(packet);
		socket.close();
	}
}

/*
 * 创建文件上传案例的客户端
 * 	
 * 数据源:本地文件 c:\\1.jpg
 * 目的地:服务器
 * 
 * 实现步骤:
 * 	1.创建本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
 * 	2.创建客户端Socket对象,封装服务器的IP地址和端口号
 * 	3.使用Socket对象中的方法getOutputStream,获取网络输出流对象OutputStream
 * 	4.使用本地字节输入流FileInputStream中的方法read,读取要上传的文件
 * 	5.使用网络输出流对象OutputStream中方法write,把读取到的文件上传到服务器
 * 	6.使用Socket对象中的方法getInputStream,获取网络输入流对象InputStream
 * 	7.使用网络输入流对象InputStream中的方法read读取服务器回写的数据
 * 	8.释放资源(FileInputStream,Socket)
 */
public class TCPClient {
	public static void main(String[] args) throws IOException {
		//1.创建本地字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
		FileInputStream fis = new FileInputStream("c:\\1.jpg");
		//2.创建客户端Socket对象,封装服务器的IP地址和端口号
		Socket socket = new Socket("127.0.0.1", 9999);
		//3.使用Socket对象中的方法getOutputStream,获取网络输出流对象OutputStream
		OutputStream os = socket.getOutputStream();
		//4.使用本地字节输入流FileInputStream中的方法read,读取要上传的文件
		int len = 0;
		while((len = fis.read())!=-1){
			//5.使用网络输出流对象OutputStream中方法write,把读取到的文件上传到服务器
			os.write(len);
		}
		
		/*
		 * 给服务器写一个终止符号
		 * 使用Socket中的方法
		 * void shutdownOutput()  禁用此套接字的输出流。 
		 */
		socket.shutdownOutput();
		
		//6.使用Socket对象中的方法getInputStream,获取网络输入流对象InputStream
		InputStream is = socket.getInputStream();
		//7.使用网络输入流对象InputStream中的方法read读取服务器回写的数据
		byte[] bytes = new byte[1024];
		len = 0;
		while((len = is.read(bytes))!=-1){
			System.out.println(new String(bytes,0,len));
		}
		
		//8.释放资源(FileInputStream,Socket)
		fis.close();
		socket.close();
	}
}

/*
 * 创建多线程文件上传的服务器端
 * 
 * 服务器要一直监听,是否有客户端请求
 * 有一个客户端请求服务器,就开启一个线程,实现文件上传
 */
public class TCPServer {
	public static void main(String[] args) throws IOException {
		//1.创建服务器对象ServerSocket,和系统要指定的端口号
		ServerSocket server = new ServerSocket(9999);
		
		//服务器要一直监听,是否有客户端请求
		while(true){
			Socket socket = server.accept();
			//有一个客户端请求服务器,就开启一个线程,实现文件上传
			new Thread(new RunnableImpl(socket)).start();
		}
	}
}

/*
 * 创建线程类
 */
public class RunnableImpl implements Runnable{
	//定义一个客户端对象
	private Socket socket;	
	public RunnableImpl(Socket socket) {
		super();
		this.socket = socket;
	}
	@Override
	public void run() {
		//获取文件上传的客户端对象,实现文件上传
		try {
			File file = new File("d:\\upload");
			if(!file.exists()){
				file.mkdirs();
			}
			InputStream is = socket.getInputStream();
			
			/*
			 * 自定义一个文件名称,防止重复
			 * 域名+毫秒值+随机数
			 */
			String fileName = "itcast"+System.currentTimeMillis()+new Random().nextInt(666666)+".jpg";
			
			//5.创建本地字节输出流对象FileOutputStreamm,构造中绑定要写数据的目的地
			FileOutputStream fos = new FileOutputStream(file+file.separator+fileName);
			//6.使用网络输入流对象InputStream中的方法read,读取客户端上传的文件
			byte[] bytes = new byte[1024];
			int len = 0;
			System.out.println("22222222222222222222222222");
			while((len = is.read(bytes))!=-1){
				//7.使用本地字节输出流对象FileOutputStreamm,把读取到的文件,写入到服务器硬盘上
				fos.write(bytes,0,len);
			}			
			System.out.println("read阻塞了,执行不到!!!!");
			
			//8.使用Socket对象中的方法getOutputStream,获取网络输出流对象OutputStream
			//9.使用网络输出流对象OutputStream中方法write给客户端回写数据
			socket.getOutputStream().write("上传成功!".getBytes());
			//10.释放资源(fos,Socket,ServerSocket)
			fos.close();
			socket.close();
		} catch (Exception e) {
			System.out.println(e);
		}
	}
}