黑马程序员-----JAVA 网络编程

                ---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

网络编程：

网络模型：
OSI参考模型
TCP/IP参考模型

网络通讯要素：
IP地址:InetAddress，网络中设备的标识，不易记忆，可用主机名，本地回环地址：127.0.0.1 主机名：localhost。
端口：用于标识进程的逻辑地址，不同进程的标识，有效端口：0~65535，其中0~1024系统使用或保留端口。
传输协议:常见协议：TCP，UDP。

java 中ip对象：InetAddress.
import java.net.*;
class  IPDemo{
    public static voidmain(String[] args) throws UnknownHostException{
        //通过名称(ip字符串or主机名)来获取一个ip对象。
        InetAddress ip =InetAddress.getByName("www.baidu.com");//java.net.UnknownHostException
        System.out.println("addr:"+ip.getHostAddress());
        System.out.println("name:"+ip.getHostName());
    }
}

UDP与TCP区别:

UDP
将数据及源和目的封装成数据包中，不需要建立连接；
每个数据报的大小在限制在64k内；
因无连接，是不可靠协议；
不需要建立连接，速度快。

主要用于可靠性要求低,传输经济的应用如:视频聊天。

TCP
建立连接，形成传输数据的通道；
在连接中进行大数据量传输；
通过三次握手完成连接，是可靠协议；
必须建立连接，效率会稍低。

主要用于可靠性要求高的应用如:文件下载、文件传输。

Socket：套接字，通信的端点。

就是为网络服务提供的一种机制，通信的两端都有Socket，网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

udp的发送端：

1，建立udp的socket服务，创建对象时如果没有明确端口，系统会自动分配一个未被使用的端口。

2，明确要发送的具体数据。

3，将数据封装成了数据包。

4，用socket服务的send方法将数据包发送出去。

5，关闭资源。

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 UDPSendDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {

		System.out.println("发送端启动......");
		/*
		 * 创建UDP传输的发送端。
		 * 思路：
		 * 1，建立udp的socket服务。
		 * 2，将要发送的数据封装到数据包中。 
		 * 3，通过udp的socket服务将数据包发送出去。
		 * 4，关闭socket服务。
		 */
		//1,udpsocket服务。使用DatagramSocket对象。
		DatagramSocket ds = new DatagramSocket(8888);
		//2,将要发送的数据封装到数据包中。
		String str = "udp传输演示：哥们来了！";
			//使用DatagramPacket将数据封装到的该对象包中。
		byte[] buf = str.getBytes();		
		DatagramPacket dp = 
				new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.100"),10000);
		
		//3，通过udp的socket服务将数据包发送出去。使用send方法。
		ds.send(dp);		
		//4，关闭资源。
		ds.close();		
	}

}

udp的接收端：

1，创建udp的socket服务，必须要明确一个端口，作用在于，只有发送到这个端口的数据才是这个接收端可以处理的数据。

2，定义数据包，用于存储接收到数据。

3，通过socket服务的接收方法将收到的数据存储到数据包中。

4，通过数据包的方法获取数据包中的具体数据内容，比如ip、端口、数据等等。

5，关闭资源。

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class UDPReceDemo {
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		System.out.println("接收端启动......");
		/*
		 * 建立UDP接收端的思路。
		 * 1，建立udp socket服务,因为是要接收数据，必须要明确一个端口号。
		 * 2，创建数据包，用于存储接收到的数据。方便用数据包对象的方法解析这些数据.
		 * 3，使用socket服务的receive方法将接收的数据存储到数据包中。
		 * 4，通过数据包的方法解析数据包中的数据。
		 * 5，关闭资源 
		 */		
		//1,建立udp socket服务。
		DatagramSocket ds = new DatagramSocket(10000);		
		//2,创建数据包。
		byte[] buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf,buf.length);		
		//3,使用接收方法将数据存储到数据包中。
		ds.receive(dp);//阻塞式的。		
		//4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。
		String ip = dp.getAddress().getHostAddress();
		int port = dp.getPort();
		String text = new String(dp.getData(),0,dp.getLength());		
		System.out.println(ip+":"+port+":"+text);		
		//5,关闭资源。
		ds.close();				
	}	
}

TCP客户端：

1，建立tcp的socket服务，最好明确具体的地址和端口。这个对象在创建时，就已经可以对指定ip和端口进行连接(三次握手)。

2，如果连接成功，就意味着通道建立了，socket流就已经产生了。只要获取到socket流中的读取流和写入流即可，只要通过getInputStream和getOutputStream就可以获取两个流对象。

3，关闭资源。

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class ClientDemo {
	/**
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {
		//客户端发数据到服务端
		/*
		 * Tcp传输，客户端建立的过程。
		 * 1，创建tcp客户端socket服务。使用的是Socket对象。
		 * 		建议该对象一创建就明确目的地。要连接的主机。 
		 * 2，如果连接建立成功，说明数据传输通道已建立。
		 * 		该通道就是socket流 ,是底层建立好的。 既然是流，说明这里既有输入，又有输出。
		 * 		想要输入或者输出流对象，可以找Socket来获取。 
		 * 		可以通过getOutputStream(),和getInputStream()来获取两个字节流。
		 * 3，使用输出流，将数据写出。 
		 * 4，关闭资源。 
		 */				
		//创建客户端socket服务。
		Socket socket = new Socket("192.168.1.100",10002);		
		//获取socket流中的输出流。 
		OutputStream out = socket.getOutputStream();				
		//使用输出流将指定的数据写出去。
		out.write("tcp演示：哥们又来了!".getBytes());		
		//关闭资源。
		socket.close();				
	}
}

TCP服务端：

1，创建服务端socket服务，并监听一个端口。

2，服务端为了给客户端提供服务，获取客户端的内容，可以通过accept方法获取连接过来的客户端对象。

3，可以通过获取到的socket对象中的socket流和具体的客户端进行通讯。

4，如果通讯结束，关闭资源。注意：要先关客户端，再关服务端。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
//		服务端接收客户端发送过来的数据，并打印在控制台上。 
		/*
		 * 建立tcp服务端的思路：
		 * 1，创建服务端socket服务。通过ServerSocket对象。
		 * 2，服务端必须对外提供一个端口，否则客户端无法连接。
		 * 3，获取连接过来的客户端对象。
		 * 4，通过客户端对象获取socket流读取客户端发来的数据 
		 * 		并打印在控制台上。
		 * 5，关闭资源。关客户端，关服务端。 
		 */		
		//1创建服务端对象。
		ServerSocket ss = new ServerSocket(10002);		
		//2,获取连接过来的客户端对象。
		Socket s = ss.accept();//阻塞式.		
		String ip = s.getInetAddress().getHostAddress();		
		//3，通过socket对象获取输入流，要读取客户端发来的数据
		InputStream in = s.getInputStream();		
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		String text = new String(buf,0,len);
		System.out.println(ip+":"+text);						
		s.close();
		ss.close();		
	}
}

网络结构:
1.C/S  client/server	
	特点：
		该结构的软件，客户端和服务端都需要编写。
		可发成本较高，维护较为麻烦。		
	好处：
		客户端在本地可以分担一部分运算。
2.B/S  browser/server
	特点：
		该结构的软件，只开发服务器端，不开发客户端，因为客户端直接由浏览器取代。 
		开发成本相对低，维护更为简单。
	缺点：所有运算都要在服务端完成。

import java.net.URLDecoder ;
import java.net.URLEncoder ;
public class CodeDemo{
	public static void main(String args[]) throws Exception{
		String keyWord = "星星点灯" ;	 
		String encod = URLEncoder.encode(keyWord,"UTF-8");// 进行编码的操作
		System.out.println("编码之后的内容：" + encod);
		String decod = URLDecoder.decode(encod,"UTF-8");// 进行解码操作
		System.out.println("解码之后的内容：" + decod);
	}
}

/*
* 客户端输入字母数据，发送给服务端，
* 服务端收到后显示在控制台，并将该数据转成大写返回给客户端 
* 直到客户端输入over.转换结束. 
* 
* 创建一个英文大写转换服务器.
* 
* 分析:
* 有客户端和服务端,使用tcp传输
*/
//客户端：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class TransClient {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException, IOException {

		/*
		 * 思路：
		 * 客户端：
		 * 1，需要先有socket端点。
		 * 2，客户端的数据源：键盘。
		 * 3，客户端的目的：socket.
		 * 4，接收服务端的数据，源：socket。
		 * 5，将数据显示在打印出来：目的：控制台.
		 * 6，在这些流中操作的数据，都是文本数据。
		 * 转换客户端:
		 * 1,创建socket客户端对象。
		 * 2,获取键盘录入。
		 * 3，将录入的信息发送给socket输出流。
		 */		
		//1,创建socket客户端对象。
		Socket s = new Socket("192.168.1.100",10004);		
		//2，获取键盘录入。
		BufferedReader bufr  =
				new BufferedReader(new InputStreamReader(System.in));		
		//3,socket输出流。
//		new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);				
		//4,socket输入流，读取服务端返回的大写数据
		BufferedReader bufIn  = new BufferedReader(new InputStreamReader(s.getInputStream()));		
		String line = null;		
		while((line=bufr.readLine())!=null){			
			if("over".equals(line))
				break;			
//			out.print(line+"\r\n");
//			out.flush();
			out.println(line);			
			//读取服务端发回的一行大写数。
			String upperStr = bufIn.readLine();
			System.out.println(upperStr);
		}		
		s.close();		
	}
}
//服务端：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class TransServer {
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		/*
		 * 转换服务端。
		 * 分析：
		 * 1，serversocket服务。
		 * 2，获取socket对象。
		 * 3，源：socket，读取客户端发过来的需要转换的数据。
		 * 4，目的：显示在控制台上。
		 * 5，将数据转成大写发给客户端。 
		 */		
		//1.
		ServerSocket ss = new ServerSocket(10004);		
		//2.获取socket对象。
		Socket s = ss.accept();		
		//获取ip.
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"......connected");		
		//3,获取socket读取流，并装饰。 
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));		
		//4,获取socket的输出流，并装饰。
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);		
		String line = null;
		while((line=bufIn.readLine())!=null){			
			System.out.println(line);
			out.println(line.toUpperCase());
//			out.print(line.toUpperCase()+"\r\n");
//			out.flush();
		}		
		s.close();
		ss.close();		
	}
}

//URL与URLConnection
//URL:
import java.net.URL ;
import java.io.InputStream ;
import java.util.Scanner ;
public class URLDemo{
	public static void main(String args[]) throws Exception {	// 所有异常抛出
		URL url = new URL("http","bbs.itheima.con",80,"/forum-212-1.html") ;
		InputStream input = url.openStream() ;	// 打开输入流
		Scanner scan = new Scanner(input) ;		// 实例化Scanner类
		scan.useDelimiter("\n") ;	// 设置读取分隔符
		while(scan.hasNext()){
			System.out.println(scan.next()) ;
		}
	}
}
//URLConection
import java.net.URL ;
import java.net.URLConnection ;
import java.io.InputStream ;
import java.util.Scanner ;
public class URLConnectionDemo{
	public static void main(String args[]) throws Exception {	// 所有异常抛出
		URL url = new URL("http://bbs.itheima.com") ;
		URLConnection urlCon = url.openConnection() ;	// 建立连接
		System.out.println("内容大小：" + urlCon.getContentLength()) ;
		System.out.println("内容类型：" + urlCon.getContentType()) ;
	}
}

          ---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------