网络模型：OSI ( Open System Interconnection)       TCP/IP{


物理层：物理设备标准 主机至网络层

数据链路层：MAC地址封装解封装

网络层：IP地址封装解封装 网际层

传输层：协议，端口号 传输层

会话层：建立数据传输通道

表示层：对数据解析 应用层

应用层：终端应用

}


DNS解析：配置文件，存储的是网址与IP地址。输入网址后查询该文件，找到IP地址，然后进行连接。


本地有该文件，则先获取本地，在获取互联网上。

UDP协议{

特点：

1.将数据及源和目的封装到数据包，不需要建立连接，每个数据包限制在64k

2.因为不需要实时连接，所以是不可靠的协议，速度快

用到的类：DatagramSocket：用来传输接收数据包

练习：

发送端，接收端的运行顺序不需要限定

/**
	 * 建立一个发送数据的端口
	 * 
	 *思路：
	 *	1.有一个发送数据包的发送端
	 *	2.有将数据进行打包的对象，并且制定发送的目的
	 *	3.通过发送端将数据包发送出去
	 *
	 *步骤：
	 *	1.建立发送端对象
	 *	2.创建发送的缓冲区，从键盘上读取数据
	 *	3.建立一个循环，读取键盘内容，并发送
	 *	3.建立数据包对象，指定接收端的地址，端口号，以及发送的数据
	 *	4.定义一个循环结束的标记，读到该标记就结束循环
	 *	5.关闭资源 
	 * @param args
	 * @throws IOException 
	 */

	public static void main(String[] args) throws IOException {
		
		DatagramSocket sender = new DatagramSocket();		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = null;
		
		while((line=br.readLine()) != null){
			while(line.equals("over"))
				break;
			DatagramPacket data = new DatagramPacket(line.getBytes(), 0, line.length(),InetAddress.getLocalHost(), 8090);
			sender.send(data);			
		}
		sender.close();
	} 
  
/**
	 * 建立一个接受数据的端口
	 * 
	 *思路：
	 *	1.有一个接受数据包的接收端
	 *	2.有接收数据包的对象，并将数据进行解析
	 *	3.将接收到的数据打印
	 *
	 *步骤：
	 *	1.建立接收端对象，指定端口号
	 *	2.创建接收对象的对象，用于解析数据
	 *	3.建立一个循环，
	 *	3.接收发送端的内容，
	 *	5.关闭资源 
	 * @param args
	 * @throws IOException 
	 * @throws IOException 
	 */

	public static void main(String[] args) throws IOException {
		DatagramSocket receiver = new DatagramSocket(8090);
		byte[] buf = new byte[1024];
		DatagramPacket dataRe = new DatagramPacket(buf, buf.length);
		
		while(true){
			receiver.receive(dataRe);
			System.out.println(new String(dataRe.getData(),0,dataRe.getLength()));			
		}
	}

}


TCP协议{

特点;

1.建立连接，形成传输数据的通道，能进行大数据量传输

2.实时连接（三次握手完成），可靠的协议，效率较低

用到的类：Socket：客户端 ServerSocket：服务端

练习：

必须先运行服务端，再运行客户端

/**
	 * 建立一个服务端，与客户端联系
	 * 
	 *	思路：
	 *	1.需要一个服务端对象，指定端口号，用于被客户端连接
	 *	2.利用方法连接客户端
	 *	3.获取客户端的流对象，以及发送的数据
	 *	4.再次获取客户端的流对象，发送数据
	 *	步骤：
	 *	1.创建一个服务端对象，指定端口号，
	 *	2.连接客户端
	 *	3.获取客户端输入流对象，读取数据
	 *	4.将数据打印，
	 *	5.获取客户端输出流对象，写出数据
	 *	6.关闭资源
	 * 
	 * @param args
	 * @throws IOException 
	 */

	public static void main(String[] args) throws IOException {
		
		ServerSocket server = new ServerSocket(9090);
		Socket so =	server.accept();
		InputStream is = so.getInputStream();
		byte[] buf = new byte[1024];
		int len = is.read(buf);
		System.out.println(new String(buf, 0, len));
		
		OutputStream os = so.getOutputStream();
		os.write("收到".getBytes());
		
		server.close();	
		so.close();
	} 
  
/**
	 * 有一个客户端，用来与服务端进行通信
	 *
	 *	思路:
	 *	1.创建一客户端，指定服务端地址，端口，与其进行通信
	 *	2.利用输出流往外写数据
	 *	3.利用输入流读取服务端发送过来的数据
	 *
	 *	步骤:
	 *	1.创建一个客户端，指定地址，端口号
	 *	2.获取输出流
	 *	3.写出数据
	 *	4.获取输入流
	 *	5.读取数据
	 * 
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket client = new Socket(InetAddress.getLocalHost(), 9090);
		OutputStream os = client.getOutputStream();
		os.write("客户端连接成功".getBytes());
		os.flush();
		
		InputStream is = client.getInputStream();
		byte[] buf = new byte[1024];
		int len = is.read(buf);
		System.out.println(new String(buf, 0, len));
		client.close();
	}


客户端发送小写，接收大写

/**
	 * 要求： 有一个服务端，接收客户端传过来的字符串并将其转为大写返回给客户端
	 * 
	 * 思路:
	 * 1.有一个服务端对象，接收客户端数据之后将其转为大写
	 * 2.利用客户端的流把大写字符传到客户端
	 * 3.需要将从客户端获取的字节流转为操作字符串的流
	 * 
	 * 步骤：
	 * 	1.创建一个服务端对象，指定端口号
	 * 	2.与客户端进行通信，并获得客户端对象
	 * 	3.使用客户端的输入流，封装成字符流。读取数据
	 * 	4.可以使用字符串的静态转换方法。将数据转为大写，再利用客户端输出流，传到客户端
	 * 	5.指定一个循环，并指定结束标记，在循环内部执行第3.4两步骤
	 * 	6.关闭资源
	 * 
	 * @param args
	 * @throws IOException 
	 */

	public static void main(String[] args) throws IOException {
		ServerSocket transSer = new ServerSocket(9010);
		Socket client = transSer.accept();
		BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
		String line = null;
		
		while((line=br.readLine()) != null){
			if(line.equals("over"))
				break;
			String upperLine = line.toUpperCase();
			BufferedWriter bos = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
			bos.write(upperLine);
			bos.newLine();
			bos.flush();
		}
		transSer.close();

	} 
  
/**
	 * 要求：有一个客户端，与某个服务端连接之后，往服务端传输数据，并接受服务端的数据
	 * 
	 * 思路：
	 * 1.有一个客户端，指定通信服务端的ip地址以及端口号
	 * 2.利用自身的输出流对象，往服务端传送数据
	 * 3.利用自身的输入流对象，接受服务端传过来的数据
	 * 4.可以将字节流对象封装成操作字符串的对象
	 * 
	 * 步骤：
	 * 1.创建一个客户端，与服务端通信
	 * 2.从键盘上读取数据，
	 * 3.将输出流对象封装成缓冲字符流，并将读取到的数据写到服务端
	 * 4.利用输入流对象，读取从服务端传送过来的数据。
	 * 5.穿件循环，指定结束标记，执行步骤2.3.4
	 * 
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket client = new Socket(InetAddress.getLocalHost(), 9010);
		String line = null;
		while(true){
			BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
			line = is.readLine();
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
			bw.write(line);
			bw.newLine();
			bw.flush();
			if(line.equals("over"))
				break;
			BufferedReader readServer = new BufferedReader(new InputStreamReader(client.getInputStream()));
			line = readServer.readLine();
			System.out.println(line);			
		}
	} 
  

 }