Java基础---网络编程
2015-12-09 10:10
716 查看
网络参考模型
OSI(Open System Interconnection开放系统互联)参考模型
TCP/IP 参考模型
七层描述
1、物理层:主要定义物流设备标准,如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流(就是由1、0转换为电流强弱来进行传输,到达目的地后再转换为1、0,也就是我们常说的数模转换)。这一层数据叫做比特。
2、数据链路层:主要将从物流层接收的数据进行MAC地址(网卡的地址)的封装与解封装。常把这一层的数据叫做帧。这一层工作的设备是交换机,数据通过交换机传输。
3、网络层:主要将下层接收的数据进行IP地址(例,192.168.0.1)的封装与解封装。在这一层工作的设备是路由器,常把这一层数据叫做数据包。
4、传输层:定义了一些传输数据的协议和端口号(www端口号80等),如:TCP(传输控制协议,传输效率低,可靠性强,用于传输可靠性要求高,数据量大的数据),UDP(用户数据协议,与TCP特性恰恰相反,用于传输可靠性要求不高,数据量小的数据,如QQ聊天数据就是通过这种方式传输的)。主要是将从下层接收的数据进行分段和传输,到达目的地址后再进行重组。常常把这一层叫做段。
5、会话层:通过传输层(端口号:传输端口与接收端口)建立传输的通路。主要在你的系统之间发起会话或者接收会话请求(设备之间需要相互认识可以是IP也可以是MAC或者是主机名)。
6、表示层:主要是进行对接接收的数据进行解释,加密与解密、压缩与解压缩等(也就是把计算机能够识别的东西转换成人能够识别的东西 如图片、声音等)。
7、应用层:主要是一些终端的应用,比如说FTP(各种文件下载)、WEB(IE浏览)、QQ之类的(可以把它理解成我们在电脑屏幕上可以看到的东西,就是终端应用)。
P.S.
1、每个网卡的MAC地址都是全球唯一的。
2、路由器实现将数据包发送指定的地点。
3、应用软件之间通信的过程就是层与层之间封包、解封包的过程。
4、OSI参考模型虽然设计精细,但过于麻烦,效率不高,因此产生了简化版的TCP/IP参考模型。
网络通信要素
1、IP地址:InetAddress
网络中设备的标识。
不易记忆,可用主机名。
本地回环地址:127.0.0.1 主机名:localhost。
2、端口号
用于标识进程(应用程序)的逻辑地址,不同进程的标识。
有效端口:0~65535,其中0~1024系统使用或保留端口。
P.S.
当一台计算机A向另一台B发送QQ信息时,首先路由器通过数据包中的IP地址定位该信息发送到哪一台机器。然后计算机B接收到数据包后,通过此数据包中的端口号定位到发送给本机的QQ应用程序。
3、传输协议
通讯的规则。
常见协议:UDP、TCP。
UDP
将数据及源和目的封装成数据包中,不需要建立链接。
每个数据包的大小在限制在64k内。
因无链接,是不可靠协议。
不需要建立链接,数度快。
应用案例:QQ、FeiQ聊天、在线视频用的都是UDP传输协议。
TCP
建立链接,形成传输数据通信。
在链接中进行大数据量传输。
通过三次握手完成连接,是可靠协议。
必须建立连接,效率会稍低。
应用案例:FTP,File Transfer Protocol(文件传输协议)。
InetAddress示例:
域名解析
在浏览器中输入新浪的域名,DNS解析域名成IP,然后计算机再通过获取到的IP访问新浪服务器。
域名解析,最先走是本地hosts(C:\Windows\System32\drivers\etc)文件,解析失败了,才去访问DNS服务器解析、获取IP地址。
在hosts文件中添加 127.0.0.1 www.baidu.com 则访问 "www.baidu.com" 实则访问 "127.0.0.1"
这个本地换回地址,从而达到屏蔽网站的效果。
UDP协议-发送端&接收端
Socket
Socket就是为网络服务提供的一种机制。
通信的两端都有Socket。
网络通信其实就是Socket间的通信。
数据在两个Socket间通过IO传输。
UDP传输
DatagramSocket(用来发送和接收数据报包的套接字)与DatagramPacket(数据报包)。
建立发送端,接收端。
建立数据包。
调用Socket。
关闭Socket.
发送端与接收端是两个独立的运行程序。
UDP发送端
P.S.
由于UDP协议传输数据,只管发送数据,而不管接收端是否能接收数据。因此,应该首先启动接收端程序,在启动发送端程序。
聊天程序(双窗口模式)
UDP发送端
聊天程序(单窗口模式-群聊)
UDP发送端
TCP协议-客户端&服务端
客户端(Client)首先与服务端(Server)建立连接,形成通道(其实就是IO流),然后,数据就可以在通道之间进行传输,并且单个Server端可以同时与多个Client端建立连接。
Socket和ServerSocket,建立客户端和服务端。
建立连接后,通过Socket中的IO流进行数据的传输。
关闭socket.
同样,客户端与服务器端是两个独立的应用程序。
TCP客户端
客户端需要明确服务器的ip地址及端口,这样才可以去试着建立连接,如果连接失败,会出现异常。
连接成功,说明客户端与服务端建立通道,那么通过IO流就可以进行数据的传输,而Socket对象已经提供了输入流和输出流对象,通过getInputStream().getOutputStream()获取即可。
与服务端通讯结束后,关闭Socket。
TCP服务端
服务端需要明确它要处理的数据是从哪个端口进入的。
当有客户端访问时,要明确哪个客户端,可以通过accept()获取已连接的客户端对象,并通过该对象与客户端通过IO流进行数据传输。
当该客户端访问结束,关闭该客户端。
示例:
TCP客户端
P.S.
TCP协议传输数据必须先开服务端,再打开客户端。否则,客户端根本就连接不上服务端。
TCP客户端
文本转换TCP客户端和服务端
TCP客户端
2、上面练习中的客户端和服务端的PrintWriter对象out获取到数据后,一定要刷新,否则对方(服务端或客户端)就获取不到数据,程序便无法正常执行。刷新操作可以通过PrintWriter类的println()方法实现,也可以通过PrintWriter类的flush()方法实现。但是,由于获取数据的方法是BufferedReader对象bufIn的readLine()方法(阻塞式方法),此方法只有遇到“\r\n”标记时,才认为数据读取完毕,赋值给String对象line。所以,使用BufferedWriter类的flush()方法刷新数据时一定要记得追加“\r\n”!
java Socket通信使用BufferedReader和BufferedWriter的注意事项
注意事项:readLine()要求有换行标识,write()要输出换行标识,要调用flush()刷新缓冲区。
注意readLine()方法,通过查看JDK中关于此方法的注释可知,它是读取一行数据,这行数据的末尾必须有换行符标识符说明到此为止是一行。不然readLine()方法无法顺利读取。
所以在服务器端或客户端进行输出的时候必须输出换行标识(\n),让对方可以顺利读取一行。因此可以这样写writer.write("hello world\n")。为了更好地使用java的跨平台特性,BufferedWriter提供了一个newLine()方法,该方法就是专门输出一个换行符。所以也可以这样写writer.write("hello world");writer.newLine();
另外既然是BufferedWriter,自然用到了缓冲,当你输出的字符长度不超过缓冲区时,可能不会被输出,这时候程序也无法正常运行。所以要用writer.flush();刷新缓冲区。也就是说writer.write("我接收到你的数据:"+input);writer.newLine();writer.flush();必须一起使用,它们总是同时出现,因此你可以自定义一个方法,包含这三个方法。
TCP服务端
了解客户端和服务端的原理
最常见的客户端:浏览器
最常见的服务端:服务器
1、自定义服务器
使用已有客户端浏览器,了解一下客户端向服务端发了什么请求
2、模拟一个浏览器获取信息
URL&URLConnection
URI:统一资源标识符。
URL:统一资源定位符,也就是说根据URL能定位到网络上的某个资源,它是指向互联网“资源”的指针
每个URL都是URI,但不一定每个URI都是URL。这是因为URI还包括一个子类,即统一资源名称(URN),它命名资源但不指定如何定位资源。
执行结果
getProtocol:http
getHost:127.0.0.1
getPort:9090
getFile:/myweb/1.html?name=lisi
getPath:/myweb/1.html
getQuery:name=lisi
获取相应头信息
1.C/S client/server
特点:该结构的软件,客户端和服务端都需要编写。开发成本较高,维护较为麻烦。
好处:客户端在本地可以分担一部分任务。例如,杀毒软件直接对本机文件进行杀毒。
2.B/S browser/server
特点:该结构软件,只开发服务端,不可发客户端,因为客户端直接由浏览器替代。开发成本相对低,维护更为简单。
缺点:所有的运算都要在服务端完成。
练习:TCP协议上传图片客户端和服务端
TCP服务
TCP协议服务端多线程技术
UploadTask.java
OSI(Open System Interconnection开放系统互联)参考模型
TCP/IP 参考模型
七层描述
1、物理层:主要定义物流设备标准,如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流(就是由1、0转换为电流强弱来进行传输,到达目的地后再转换为1、0,也就是我们常说的数模转换)。这一层数据叫做比特。
2、数据链路层:主要将从物流层接收的数据进行MAC地址(网卡的地址)的封装与解封装。常把这一层的数据叫做帧。这一层工作的设备是交换机,数据通过交换机传输。
3、网络层:主要将下层接收的数据进行IP地址(例,192.168.0.1)的封装与解封装。在这一层工作的设备是路由器,常把这一层数据叫做数据包。
4、传输层:定义了一些传输数据的协议和端口号(www端口号80等),如:TCP(传输控制协议,传输效率低,可靠性强,用于传输可靠性要求高,数据量大的数据),UDP(用户数据协议,与TCP特性恰恰相反,用于传输可靠性要求不高,数据量小的数据,如QQ聊天数据就是通过这种方式传输的)。主要是将从下层接收的数据进行分段和传输,到达目的地址后再进行重组。常常把这一层叫做段。
5、会话层:通过传输层(端口号:传输端口与接收端口)建立传输的通路。主要在你的系统之间发起会话或者接收会话请求(设备之间需要相互认识可以是IP也可以是MAC或者是主机名)。
6、表示层:主要是进行对接接收的数据进行解释,加密与解密、压缩与解压缩等(也就是把计算机能够识别的东西转换成人能够识别的东西 如图片、声音等)。
7、应用层:主要是一些终端的应用,比如说FTP(各种文件下载)、WEB(IE浏览)、QQ之类的(可以把它理解成我们在电脑屏幕上可以看到的东西,就是终端应用)。
P.S.
1、每个网卡的MAC地址都是全球唯一的。
2、路由器实现将数据包发送指定的地点。
3、应用软件之间通信的过程就是层与层之间封包、解封包的过程。
4、OSI参考模型虽然设计精细,但过于麻烦,效率不高,因此产生了简化版的TCP/IP参考模型。
网络通信要素
1、IP地址:InetAddress
网络中设备的标识。
不易记忆,可用主机名。
本地回环地址:127.0.0.1 主机名:localhost。
2、端口号
用于标识进程(应用程序)的逻辑地址,不同进程的标识。
有效端口:0~65535,其中0~1024系统使用或保留端口。
P.S.
当一台计算机A向另一台B发送QQ信息时,首先路由器通过数据包中的IP地址定位该信息发送到哪一台机器。然后计算机B接收到数据包后,通过此数据包中的端口号定位到发送给本机的QQ应用程序。
3、传输协议
通讯的规则。
常见协议:UDP、TCP。
UDP
将数据及源和目的封装成数据包中,不需要建立链接。
每个数据包的大小在限制在64k内。
因无链接,是不可靠协议。
不需要建立链接,数度快。
应用案例:QQ、FeiQ聊天、在线视频用的都是UDP传输协议。
TCP
建立链接,形成传输数据通信。
在链接中进行大数据量传输。
通过三次握手完成连接,是可靠协议。
必须建立连接,效率会稍低。
应用案例:FTP,File Transfer Protocol(文件传输协议)。
InetAddress示例:
import java.net.InetAddress; import java.net.UnknownHostException; public class IPDemo { public static void main(String[] args) throws UnknownHostException { InetAddress ip = InetAddress.getLocalHost(); System.out.println(ip.getHostAddress()); System.out.println(ip.getHostName()); System.out.println("-----------"); // 获取其它主机的ip地址对象 ip = InetAddress.getByName("www.baidu.com"); System.out.println(ip.getHostAddress()); System.out.println(ip.getHostName()); } }
域名解析
在浏览器中输入新浪的域名,DNS解析域名成IP,然后计算机再通过获取到的IP访问新浪服务器。
域名解析,最先走是本地hosts(C:\Windows\System32\drivers\etc)文件,解析失败了,才去访问DNS服务器解析、获取IP地址。
在hosts文件中添加 127.0.0.1 www.baidu.com 则访问 "www.baidu.com" 实则访问 "127.0.0.1"
这个本地换回地址,从而达到屏蔽网站的效果。
UDP协议-发送端&接收端
Socket
Socket就是为网络服务提供的一种机制。
通信的两端都有Socket。
网络通信其实就是Socket间的通信。
数据在两个Socket间通过IO传输。
UDP传输
DatagramSocket(用来发送和接收数据报包的套接字)与DatagramPacket(数据报包)。
建立发送端,接收端。
建立数据包。
调用Socket。
关闭Socket.
发送端与接收端是两个独立的运行程序。
UDP发送端
import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class UDPSendDemo { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub System.out.println("发送端启动...."); /* 创建UDP传输的发送端。 思路: 1.建立udp的socket服务 2.将要发送的数据封装到数据包中。 3.通过udp的socket服务将数据包发送出去。 4.关闭socket服务 */ //1.udp socket服务。使用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.110"),10000); //3.通过udp的socket服务将数据发送出去,使用send方法。 ds.send(dp); //4.关闭资源 ds.close(); } }UDP接收端
import java.net.DatagramPacket; import java.net.DatagramSocket; public class UDPReceDemo { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub System.out.println("接收端启动"); /* * 建立UDP接收端的思路 * 思路: * 1.建立udp的socket服务,因为是要接收数据,必须要明确一个端口号。 * 2.创建数据包,用于存储接收到的数据,方便用数据包对象的方法解析这些数据。 * 3.使用socket服务的receive方法将接收的数据存储到数据包中。 * 4.通过数据包的方法解析数据包中的数据。 * 关闭资源。 * */ //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(); } }
P.S.
由于UDP协议传输数据,只管发送数据,而不管接收端是否能接收数据。因此,应该首先启动接收端程序,在启动发送端程序。
聊天程序(双窗口模式)
UDP发送端
import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class UDPSendDemo { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub System.out.println("发送端启动...."); DatagramSocket ds = new DatagramSocket(8888); BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); String line = null; while((line=bufr.readLine())!=null) { byte[] buf = line.getBytes(); DatagramPacket dp = new DatagramPacket(buf, buf.length,InetAddress.getByName("192.168.1.110"),10000); ds.send(dp); if("886".equals(line)) break; } ds.close(); } }UDP接收端
import java.net.DatagramPacket; import java.net.DatagramSocket; public class UDPReceDemo { public static void main(String[] args) throws Exception { System.out.println("接收端启动"); DatagramSocket ds = new DatagramSocket(10000); while(true) { byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf,buf.length); ds.receive(dp);//阻塞式的。 String ip = dp.getAddress().getHostAddress(); int port = dp.getPort(); String text = new String(dp.getData(),0,dp.getLength()); System.out.println(ip+":"+port+":"+text); } } }
聊天程序(单窗口模式-群聊)
UDP发送端
import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class Send implements Runnable { private DatagramSocket ds; public Send(DatagramSocket ds) { this.ds = ds; } @Override public void run() { try { BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); String line = null; while((line=bufr.readLine())!=null) { byte[] buf = line.getBytes(); DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),1001); ds.send(dp); if("886".equals(line)) break; } ds.close(); } catch (Exception e) { e.printStackTrace(); } } }UDP接受端
import java.net.DatagramPacket; import java.net.DatagramSocket; public class Rece implements Runnable { private DatagramSocket ds; public Rece(DatagramSocket ds) { this.ds = ds; } @Override public void run() { try { while(true) { byte[] buf = new byte[1024]; DatagramPacket dp = new DatagramPacket(buf,buf.length); ds.receive(dp); String ip = dp.getAddress().getHostAddress(); int port = dp.getPort(); String text = new String(dp.getData(),0,dp.getLength()); System.out.println(ip+":"+port+":"+text); if("886".equals(text)) { System.out.println(ip+"退出聊天室"); } } } catch (Exception e) { e.printStackTrace(); } } }启动发送端、接受端线程程序
import java.io.IOException; import java.net.DatagramSocket; public class ChatDemo { public static void main(String[] args) throws Exception { // TODO Auto-generated method stub DatagramSocket send = new DatagramSocket(); DatagramSocket rece = new DatagramSocket(1001); Send s = new Send(send); Rece r = new Rece(rece); new Thread(s).start(); new Thread(r).start(); } }
TCP协议-客户端&服务端
客户端(Client)首先与服务端(Server)建立连接,形成通道(其实就是IO流),然后,数据就可以在通道之间进行传输,并且单个Server端可以同时与多个Client端建立连接。
Socket和ServerSocket,建立客户端和服务端。
建立连接后,通过Socket中的IO流进行数据的传输。
关闭socket.
同样,客户端与服务器端是两个独立的应用程序。
TCP客户端
客户端需要明确服务器的ip地址及端口,这样才可以去试着建立连接,如果连接失败,会出现异常。
连接成功,说明客户端与服务端建立通道,那么通过IO流就可以进行数据的传输,而Socket对象已经提供了输入流和输出流对象,通过getInputStream().getOutputStream()获取即可。
与服务端通讯结束后,关闭Socket。
TCP服务端
服务端需要明确它要处理的数据是从哪个端口进入的。
当有客户端访问时,要明确哪个客户端,可以通过accept()获取已连接的客户端对象,并通过该对象与客户端通过IO流进行数据传输。
当该客户端访问结束,关闭该客户端。
示例:
TCP客户端
import java.io.IOException; import java.io.OutputStream; import java.net.Socket; import java.net.UnknownHostException; public class ClientDemo { public static void main(String[] args) throws UnknownHostException, IOException { //客户端发数据到服务端 /* *TCP传输,客户端建立的过程。 *1.创建TCP客户端Socket服务,使用的是Socket对象。 * 建议改对象一创建就明确目的地,要连接的主机。 *2.如果连接建立成功,说明数据传输通道已建立。 * 该通道就是Socket流,是底层建立好的。既然是流,说明这里既有输入,又有输出。 * 想要输入或者输出流对象,可以找Socket来获取。 *3.使用输出流,将数据写出。 *4.关闭资源。 * */ //创建客户端socket服务。 Socket socket = new Socket("127.0.0.1",10002); //获取socket流中的输出流 OutputStream out = socket.getOutputStream(); //使用输出流将指定的数据写出去。 out.write("tcp演示:哥们又来了!".getBytes()); //断口连接,关闭资源,socket获取的输出流也被关闭,没有必要再写代码关闭。 socket.close(); } }TCP服务端
import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { 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(); } }
P.S.
TCP协议传输数据必须先开服务端,再打开客户端。否则,客户端根本就连接不上服务端。
TCP客户端
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.net.UnknownHostException; public class ClientDemo { public static void main(String[] args) throws UnknownHostException, IOException { Socket socket = new Socket("127.0.0.1",10002); OutputStream out = socket.getOutputStream(); out.write("tcp演示:哥们又来了".getBytes()); //读取各户端返回的数据,使用Socket读取流。 InputStream in = socket.getInputStream(); byte[] buf = new byte[1024]; int len = in.read(buf); String text = new String(buf,0,len); System.out.println(text); socket.close(); } }TCP服务端
import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { public static void main(String[] args) throws IOException { ServerSocket ss = new ServerSocket(10002); Socket s = ss.accept(); String ip = s.getInetAddress().getHostAddress(); 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); //使用客户端socket对象的输出流输出流给客户端返回数据 OutputStream out = s.getOutputStream(); out.write("收到".getBytes()); s.close(); ss.close(); } }
文本转换TCP客户端和服务端
TCP客户端
import java.io.BufferedReader; //import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; //import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.net.Socket; import java.net.UnknownHostException; public class TransClient { public static void main(String[] args) throws UnknownHostException, IOException { //1.创建socket客户端对象。 Socket s= new Socket("127.0.0.1",10004); //2.获取键盘录入 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); //3.socket输出流 //BufferedWriter out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); PrintWriter out = new PrintWriter(s.getOutputStream(),true); //4.socket输入流,读取服务端返回的大数据 BufferedReader bufln = new BufferedReader(new InputStreamReader(s.getInputStream())); String line = null; while((line = bufr.readLine())!=null) { if("over".equals(line)) break; out.println(line); //获取服务端发回的一行大写数据 String upperStr = bufln.readLine(); System.out.println(upperStr); } s.close(); } }TCP服务端
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 { public static void main(String[] args) throws IOException { //1.创建ServerSocket 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 bufln = new BufferedReader(new InputStreamReader(s.getInputStream())); //4.获取socket输出流,并装饰。 PrintWriter out = new PrintWriter(s.getOutputStream(),true); System.out.println("ooo"); String line = null; while((line=bufln.readLine())!=null) { System.out.println(line); out.println(line.toUpperCase()); } s.close(); ss.close(); } }
<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">常见问题:</span>1、上面练习中之所以客户端结束后,服务端也随之结束的原因在于:客户端的socket关闭后,服务端获取的客户端socket读取流也关闭了,因此读取不到数据,line = bufIn.readLine()为null,循环结束,ServerSocket的close方法也就执行关闭了。
2、上面练习中的客户端和服务端的PrintWriter对象out获取到数据后,一定要刷新,否则对方(服务端或客户端)就获取不到数据,程序便无法正常执行。刷新操作可以通过PrintWriter类的println()方法实现,也可以通过PrintWriter类的flush()方法实现。但是,由于获取数据的方法是BufferedReader对象bufIn的readLine()方法(阻塞式方法),此方法只有遇到“\r\n”标记时,才认为数据读取完毕,赋值给String对象line。所以,使用BufferedWriter类的flush()方法刷新数据时一定要记得追加“\r\n”!
java Socket通信使用BufferedReader和BufferedWriter的注意事项
注意事项:readLine()要求有换行标识,write()要输出换行标识,要调用flush()刷新缓冲区。
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); String input = null; while(!"bye".equalsIgnoreCase(input=reader.readLine())){ System.out.println("客户端传来数据:"+input); writer.write("我接收到你的数据:"+input); writer.newLine(); writer.flush(); }上面的java Socket通信用到了BufferedReader的readLine()方法和BufferedWriter的write()方法。
注意readLine()方法,通过查看JDK中关于此方法的注释可知,它是读取一行数据,这行数据的末尾必须有换行符标识符说明到此为止是一行。不然readLine()方法无法顺利读取。
所以在服务器端或客户端进行输出的时候必须输出换行标识(\n),让对方可以顺利读取一行。因此可以这样写writer.write("hello world\n")。为了更好地使用java的跨平台特性,BufferedWriter提供了一个newLine()方法,该方法就是专门输出一个换行符。所以也可以这样写writer.write("hello world");writer.newLine();
另外既然是BufferedWriter,自然用到了缓冲,当你输出的字符长度不超过缓冲区时,可能不会被输出,这时候程序也无法正常运行。所以要用writer.flush();刷新缓冲区。也就是说writer.write("我接收到你的数据:"+input);writer.newLine();writer.flush();必须一起使用,它们总是同时出现,因此你可以自定义一个方法,包含这三个方法。
public void writeLine(String msg){ writer.write(msg); writer.newLine(); writer.flush(); }TCP协议上传文本文件
TCP服务端
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileWriter; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; public class UploadServer { public static void main(String[] args) throws Exception { ServerSocket ss = new ServerSocket(10005); Socket s = ss.accept(); System.out.println(s.getInetAddress().getHostAddress()+"....connected"); BufferedReader bufln = new BufferedReader(new InputStreamReader(s.getInputStream())); BufferedWriter bufw = new BufferedWriter(new FileWriter("d:\\javaExc\\server.txt")); String line = null; while((line=bufln.readLine())!=null) { if("over".equals(line)) break; bufw.write(line); bufw.newLine();bufw.<span style="font-family: Arial, Helvetica, sans-serif;">flush();</span> } PrintWriter out = new PrintWriter(s.getOutputStream(),true); out.println("上传成功"); bufw.close(); s.close(); ss.close(); } }TCP客户端
import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.Socket; import java.net.UnknownHostException; public class UploadClient { public static void main(String[] args) throws UnknownHostException, IOException { Socket s = new Socket("127.0.0.1",10005); BufferedReader bufr = new BufferedReader(new FileReader("d:\\javaExc\\client.txt")); PrintWriter out = new PrintWriter(s.getOutputStream(),true); String line = null; while((line=bufr.readLine())!=null) { out.println(line); } //告诉服务器,客户端写完了。 s.shutdownOutput(); BufferedReader bufln = new BufferedReader(new InputStreamReader(s.getInputStream())); String str = bufln.readLine(); System.out.println(str); bufr.close(); s.close(); } }
了解客户端和服务端的原理
最常见的客户端:浏览器
最常见的服务端:服务器
1、自定义服务器
使用已有客户端浏览器,了解一下客户端向服务端发了什么请求
import java.io.IOException; import java.io.InputStream; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; public class MyTomcat { public static void main(String[] args) throws IOException { ServerSocket ss = new ServerSocket(9090); Socket s = ss.accept(); System.out.println(s.getInetAddress().getHostAddress()+"....connected"); InputStream in = s.getInputStream(); byte[] buf = new byte[1024]; int len = in.read(buf); String text = new String(buf,0,len); System.out.println(text); //给客户端一个反馈信息。 PrintWriter out = new PrintWriter(s.getOutputStream(),true); out.println("<font color='red' size='7'>欢迎光临</font>"); s.close(); ss.close(); } }
2、模拟一个浏览器获取信息
import java.io.IOException; import java.io.InputStream; import java.io.PrintWriter; import java.net.Socket; import java.net.UnknownHostException; public class MyBrowser { public static void main(String[] args) throws UnknownHostException, IOException { Socket s = new Socket("127.0.0.1",9090); //模拟浏览器,向tomcat服务端发送符合http协议的请求消息。 PrintWriter out = new PrintWriter(s.getOutputStream(),true); out.println("GET /myweb/1.html HTTP/1.1"); out.println("Accept:*/*"); out.println("Host:"+s.getInetAddress().getHostAddress()+":"+s.getPort()); out.println("Connection:close"); out.println(); 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(); } }
URL&URLConnection
URI:统一资源标识符。
URL:统一资源定位符,也就是说根据URL能定位到网络上的某个资源,它是指向互联网“资源”的指针
每个URL都是URI,但不一定每个URI都是URL。这是因为URI还包括一个子类,即统一资源名称(URN),它命名资源但不指定如何定位资源。
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.MalformedURLException; import java.net.URL; public class URLDemo { public static void main(String[] args) throws IOException { String str_url = "http://127.0.0.1:9090/myweb/1.html?name=lisi"; URL url = new URL(str_url); System.out.println("getProtocol:"+url.getProtocol()); System.out.println("getHost:"+url.getHost()); System.out.println("getPort:"+url.getPort()); System.out.println("getFile:"+url.getFile()); System.out.println("getPath:"+url.getPath()); System.out.println("getQuery:"+url.getQuery()); /*InputStream in = url.openStream();//相当于url.openConnection().getInjputStream(); byte[] buf = new byte[1024]; int len = in.read(buf); String text = new String(buf,0,len); System.out.println(text); in.close();*/ BufferedReader bfrd = new BufferedReader(new InputStreamReader(url.openStream())); String line = null; while((line=bfrd.readLine())!=null) { System.out.println(line); } bfrd.close(); } }
执行结果
getProtocol:http
getHost:127.0.0.1
getPort:9090
getFile:/myweb/1.html?name=lisi
getPath:/myweb/1.html
getQuery:name=lisi
获取相应头信息
import java.io.IOException; import java.net.MalformedURLException; import java.net.URL; import java.net.URLConnection; public class URLDemo { public static void main(String[] args) throws IOException { String str_url="http://127.0.0.1:9090/myweb/1.html?name=lisi"; URL url=new URL(str_url); //获取url对象的Url连接器对象。将连接封装成了对象:java中内置的可以解析的具体协议对象+socket. URLConnection conn = url.openConnection(); System.out.println(conn); //由于URLConnection对象已经把响应头解析了,所以,可以通过URLConnection对象获取响应头某属性名对应的属性值。 String value = conn.getHeaderField("Content-Type"); System.out.println(value); } }常见网络构造
1.C/S client/server
特点:该结构的软件,客户端和服务端都需要编写。开发成本较高,维护较为麻烦。
好处:客户端在本地可以分担一部分任务。例如,杀毒软件直接对本机文件进行杀毒。
2.B/S browser/server
特点:该结构软件,只开发服务端,不可发客户端,因为客户端直接由浏览器替代。开发成本相对低,维护更为简单。
缺点:所有的运算都要在服务端完成。
练习:TCP协议上传图片客户端和服务端
TCP服务
import java.io.File; 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 UploadPicServer { public static void main(String[] args) throws IOException { // TODO Auto-generated method stub //创建tcp的socket服务端 ServerSocket ss= new ServerSocket(10006); //获取客户端 Socket s = ss.accept(); String ip = s.getInetAddress().getHostAddress(); System.out.println(ip+".......Connected"); //读取客户端发来的数据 InputStream in = s.getInputStream(); //将读取的数据存储到一个文件中。 File dir = new File("c:\\pic"); if(!dir.exists()) dir.mkdirs(); File file = new File(dir,ip+".bmp"); FileOutputStream fos = new FileOutputStream(file); byte[] buf = new byte[1024]; int len = 0; while((len=in.read(buf))!=-1) { fos.write(buf, 0, len); } //获取socket输出流,将上传成功字样发送给客户端 OutputStream out = s.getOutputStream(); out.write("上传成功".getBytes()); fos.close(); s.close(); ss.close(); } }TCP客户端
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 UploadPicClient { public static void main(String[] args) throws UnknownHostException, IOException { // TODO Auto-generated method stub //1.创建客户端socket. Socket s = new Socket("127.0.0.1",10006); //2.读取客户端要上传的图片文件。 FileInputStream fis = new FileInputStream("C:\\Users\\49921_000\\Desktop\\11.jpg"); //3.获取socket输出流,将读到图片数据发送给服务端。 OutputStream out = s.getOutputStream(); 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(); } }
TCP协议服务端多线程技术
UploadTask.java
import java.io.File; import java.io.FileOutputStream; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; public class UploadTask implements Runnable { 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); 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"); } FileOutputStream fos = new FileOutputStream(file); byte[] buf = new byte[1024]; int len = 0; while((len=in.read(buf))!=-1) { fos.write(buf, 0, len); } OutputStream out = s.getOutputStream(); out.write("上传成功".getBytes()); fos.close(); s.close(); } catch (Exception e) { e.printStackTrace(); } } }UploadServer.java
import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class UploadServer { public static void main(String[] args) throws IOException { // TODO Auto-generated method stub ServerSocket ss = new ServerSocket(10006); while(true) { Socket s= ss.accept(); new Thread(new UploadTask(s)).start(); } } }服务器处理客户端的请求,并且返回响应的信息
相关文章推荐
- HTTP 1.1的常用请求报头
- 深入安卓大图片处理机制,本地及网络图片不加载到内存预压缩
- http请求响应头信息
- HttpURLConnnection
- 网络营销包含哪些方面的知识听太原郭文军细讲
- 【高可用HA】Apache (3) —— Mac下配置Apache Httpd负载均衡(Load Balancer)之mod_proxy
- Java读取网络图片
- http 使用curl发起https请求
- 校园网的无线网络建设经验谈
- Python Cookie HTTP获取cookie并处理
- HTTP缓存是如何实现
- Java锁--synchronized(转载zi http://zhh9106.iteye.com/blog/2151791)
- [网络管理]全双工与半双工的区别
- 对TCP/IP网络协议的深入浅出归纳
- Struts2的Action中获取HttpServletRequest对象
- 【计算机网络】:填空题复习等详细解答
- 第二十六天-文件系统选型及nfs网络文件进阶
- Installing .NET Core on Ubuntu-摘自网络
- Android | Android Studio无法使用HttpClient的解决办法
- HttpURLConnection 传参数 避免乱码