网络编程 网络结构模型TCP协议相关对象常见客户端和服务端

网络结构模型：
 OSI七层模型->物理层（接口设备，比特流传输）-数据链路层（MAC，交换机）-网络层（IP，路由）-传输层（协议端口）-会话层（建立数据传输通路）-表示层（数据解析）-应用层（终端的应用软件）
 TCP/IP四层模型->应用层-传输层-网际层-网络层//详见计算机网络

网络通讯要素：
 IP地址->本机IP：127.0.0.1 本机名：localhost
 端口号->用于标识进程的逻辑地址//有效端口065535，01024为系统使用或保留端口
 传输协议->通讯的规则，常见协议TCP,UDP
  UDP:将数据及源和目的封装成数据包，数据报限制在64k内，无需建立连接，速度快，为不可靠协议
  TCP:建立连接形成通道，连接中进行大数据量传输，通过三次握手完成连接，效率稍低，是可靠协议

网络编程涉及的包：java.net包
IP对象：InetAddress(ipv4:Inet4Address-ipv6:Inet6Address)

InetAdress ip = InetAddress.getLocalHost();//获取本地主机ip地址对象
ip.getHostAddress();//获取对象ip地址
ip.getHostName();//获取对象主机名
ip = InetAddress.getByName("192.168.1.100");//通过ip地址或主机名获取其他主机的ip地址对象--getAllByName返回ip对象数组（服务器）

域名解析：域名-本地host-dns服务器-ip地址-相应的主机/服务器

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

UDP协议相关对象：
DatagramPacket：数据报包//数据报包
DatagramSocket：数据报报的发送和接受点

/*UDP传输的发送端*/
DatagramSocket ds = new DatagramSocket();//建立udp的socket服务,有SocketException异常
String str = "udp传输内容";
byte[] buf = str.getBytes();
DatagramPacket dp = 
	new DatagramPacket(buf,buf.length,InetAddress.getName("192.168.1.1"),10000);//将要发送的数据封装到数据包中，10000为端口号
ds.send(dp);//通过upd的socket服务将数据包发送出去
ds.close();//关闭socket服务

/*接收端，无连接*/
DatagramSocket dg = new DatagramSocket(10000);//接受数据需要明确端口号
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);//创建数据包，用于存储接受到的数据。可以通过数据包的方法解析
dg.receive(dp);//使用接受方法存储到数据包中，阻塞式
Stirng ip = dp.getAddress().getHostAddress();//获取ip地址
int port = dp.getPort();//获取发送端的端口，发送端的Socket对象没有指定端口，所以是随机的
String text = new String(dp.getData(),0,dp.getLength());//更多方法详见DatagramPacket对象API
dg.close();
//实现同时的发送和接收则可以结合多线程技术，255为广播地址即1-244地址的用户都接收的到数据包

TCP协议相关对象：
Socket：实现客户端的端点
ServerSocket：服务端的端点，可以连接多个客户端
socket流：底层建立，只要连接建立成功并建立了数据传输通道就存在，说明存在输入和输出，可以通过Socket对象来获取（getOutputStream(),getInputStream()）//通过流技术可以对数据文件进行更多的操作

/*客户端*/
Socket socket = new Socket("192.168.1.100",10002);//创建tcp客户端socket服务，明确要连接的主机
OutputStream out = socket.getOutputStream();获取socket流中的输出流
out.write("tcp演示".getBytes());//在流中写入指定数据

InputStream in = socket.getInputStream();//读取服务端返回的数据
byte[] buf = new byte[1024];
int len = in.read();
String text = new String(buf,0,len);
System.out.println()

socket.close();//关闭资源

/*服务端*/
ServerSocket ss = new ServerSocket(10002);//服务端提供连接端口
Socket s = ss.accept();//获取连接过来的客户端对象
String ip = s.getInetAddress().getHostAddress();//获取客户端ip地址
InputStream in = s.getInputStream();//通过客户端对象获取socket流的输入流读取客户端发来的数据（用的是客户端的流）
bytes[] buf = new bytes[1024];
int len = in.read(buf);
String text = new String(buf,0,len);
System.out.println(ip+":"+text);

OutputStream out = s.getOutputStream();//给客户端返回数据
out.write("收到"。getBytes());

s.close();
ss.close();

上传文本文件实例：

/*客户端用流读取本地文本文件，并通过socket流传给服务端，服务端通过socket流获取数据后写入本地文本文件时
 *要定义结束标记，不然客户端循环读取结束后，服务端循环写入并未停止，会造成阻塞
 *第二种方法：告诉服务端，客户端写完了->shutdownOutput()方法-shutdownInput()//设置结束标记或将流置于末尾
*/
//客户端
Socket s = new Socket("192.168.1.100",10005);
BuffereReader bufr = new BufereReader(new FileReader("client.txt"));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufr.redLine())!=null){
	out.println(line);
}
//out.println("over");//结束标记
s.shutdownOutput();//告诉服务端，客户端的此输出流结束了
BuffereReader bufIn = new BuffereReader(new InputStreamReader(s.getInputStream()));
String str = bufr.readLine();
System.out.println(str);//上传成功
bufr.close();
s.close();
//服务端
ServerSocket ss = new ServerSocket(10005);
Socket s= ss.accept();
BuffereReaderReader bufIn = new BuffereReader(new InputStreamReader(s.getInputStream()));
BuffereWriter bufw = new BuffereWriter(new FileWriter("server.txt"));
String line = null;
while((line=bufIn.readLine())!=null){
	//if("over".equals(line))
	//	break;
	bufw.write(line);
	bufw.newLine();
	bufw.flush();
}
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
out.println("上传成功");
bufw.close();
s.close();
ss.close();
//客户端
Socket s = new Socket("192.168.1.100",10006);
FileInputStream fis = new FileInputStream("c:\\0.bmp");
OutputStream out = s.getOuputStream();
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1){
	out.write(buf,0,len);
}
s.shutdownOutput();
InputStream in = s.getInputStream();
byte[] bufIn = new byte[1024];
int lenIn = in.read(buf);
String text = new String(buf,0,lenIn);
System.out.println(text);
fis.close();
s.close();
//服务端
ServerSocket ss = new ServerSocket(10006);

while(true){
	Socket s= ss.accept();
	new Thread(new UploadTask(s).start());//每有一个客户端连接到服务端则创建一个线程
}

class UploadTask{
	private Socket s;
	public UploadTask(Socket s){
		this.s = s;
	}
	public void run(){
		int count = 0;
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"...connected")
		try{
		InputStream in = s.getInputStream();
		File dir = new File("c:\\pic");
		if(!dir.exists()){
			dir.mkdirs();
		}
		File file = new File(dir,ip+".bmp");
		while(file.exists()){//如果文件已经存在于服务端
			file = new File(dir,ip+"("+(++count)+").bmp")
		}
		//上传文件可以通过File获取上传文件的文件名知道其文件类型或运用某些工具类
		FileOutputStream fos = new FileOutStream(file);
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=in.read(buf))!=-1){
			fos.writer(buf,0,len);
		}
		OutputStream out = s.getOutputStream();
		out.write("上传成功“.getBytes());
		fos.close();
		s.close();
		}catch(){}
	}
}

常见客户端和服务端：
 客户端->浏览器
 服务器->Tomcat
//可以自定义服务端，用浏览器通过指定的端口访问http://192.168.1.100:9090, 浏览器会自动解析流中的数据（字符文本/html等超文本标记）
浏览器发给服务端的信息:
1

//模拟浏览器发送给Tomcat服务端的消息并获取信息
class MyBrowser{
	public static void main(String[] args){
		Socket s = new Socket("192.168.199.100",8080);
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		out.println("GET /myweb/1.html HTTP/1.1");
		out.println("Accept: */*");
		out.println("Host: 192.168.1.100:8080");
		out.println("Connection: close");
		out.println("");
		
		InputStream in = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		String str = new String(buf,0,len);
		System.out.println(str);
		s.close();
	}
}

上面模拟浏览器的例子效果：
2
由图可知，没有解析应答消息头和应答体（html）的内容

URL和URLConnection类：

String str_url = "http://192.168.1.100:8080/myweb/1.html?name=lisi";//需要解析
URL url = new URL(str_url);
url.getProtocol();//http
url.getHost();//192.168.1.100
url.getPort();//8080
url.getFile();// /myweb/1.html?name=lisi
url.getPath();// /myweb/1.html
url.getQuery();//name=lisi
InputStream in = url.openStream();//输出流中的数据时，只显示应答体，应答消息头被解析了
//↑打开此URL的连接并返回一个用于从该连接连续读入的InputStream流
URLConnection conn = url.openConnection();//获取url对象的URL连接器对象，将连接封装成了对象
//↑java中内置的可以解析具体协议的对象，就是解析了应答消息头
conn.getHeaderField("Content-Type");// text/html->可以通过此对象获取应答消息头的信息
conn.getInputStream();//也可以获取Socket的输入输出流，openStream方法就是对此功能进行了封装

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