javase(13)_网络编程
一、概述
1、网络编程的核心是IP、端口(表示应用程序)、协议三大元素
2、网络编程的本质是进程间通信
3、网络编程的2个主要问题:1是定位主机,2是数据传输
二、网络通信的概念
1、网络通信协议
计算机网络中实现通信必须有一些约定即通信协议,对速率、 传输代码、代码结构、传输控制步骤、出错控制等制定标志.
2、网络通信接口
为了使两个结点之间能进行对话,必须在它们之间建立通信工具(即接口),使彼此之间能进行信息交换,接口包含两部分:
硬件部分:实现结点之间的信息传送
软件部分:规定双方使用哪种通信协议
3、通信协议的分层思想
由于结点之间联系很复杂,在制定协议时,把复杂的成份分解为一些简单的成份,再将它们复合起来,即同层间可以互相通信、上一层可以调用下一层,而与再下一层不发现关系,各层互不影响,利于系统的开发和扩展.TCP/IP的四层参考模型包括:应用层、 传输层、网络层、物理+数据链路层.
4、数据的封装和拆分
数据由上层网下层传输时,会再原数据上加上每一层的控制信息,最后转变为二进制代码通过物理层传输,然后挨个拆分控制信息把数据传输到指定的应用程序.也称为数据的封包和拆包.
三、IP协议
IP和端口能唯一定位到需要通信的进程.这里的IP表示地址,区别于IP协议.在OSI体系还是TCP/IP体系中,IP协议位于网际层,来封装IP地址到报文中.
四、TCP和UDP协议
TCP是Tranfer Control Protocol的简称,是一种面向连接的保证可靠传输的协议.通过TCP协议传输,得到的是一个顺序的无差错的数据流.发送方和接收方的成对的两个socket之间必须建立连接,以便在TCP协议的基础上进行通信,当一个socket(通常都是server socket)等待建立连接时,另一个socket可以要求进行连接,一旦这两个socket连接起来,它们就可以进行双向数据传输,双方都可以进行发送或接收操作.
UDP是User Datagram Protocol的简称,是一种无连接的协议,每个数据报都是一个独立的信息,包括完整的源地址或目的地址,它在网络上以任何可能的路径传往目的地,因此能否到达目的地,到达目的地的时间以及内容的正确性都是不能被保证的.
比较:
UDP:
- 每个数据报中都给出了完整的地址信息,因此无需要建立发送方和接收方的连接.
- UDP传输数据时是有大小限制的,每个被传输的数据报必须限定在64KB之内.
- UDP是一个不可靠的协议,发送方所发送的数据报并不一定以相同的次序到达接收方
- 速度快
TCP:
- 面向连接的协议,在socket之间进行数据传输之前必然要建立连接,所以在TCP中需要连接时间.
- TCP传输数据大小限制,一旦连接建立起来,双方的socket就可以按统一的格式传输大的数据.
- TCP是一个可靠的协议,它确保接收方完全正确地获取发送方所发送的全部数据.
- 速度慢
五、Socket
Socket是网络驱动层提供给应用程序编程接口和一种机制.我们可以把 Socket 比喻成是一个港口码头.应用程序只要把货物放到港口码头上,就算完成了货物的运送.对于接收方应用程序也要创建一个港口码头,只需要等待货物到达码头后将货物取走.
Socket 是在应用程序中创建的,它是通过一种绑定机制与驱动程序建立关系,告诉自己所对应的 IP 和 Port.在网络上传输的每一个数据帧,必须包含发送者的 IP 地址和端口号.创建完 Socket 以后,应用程序写入到 Socket 的数据,由 Socket 交给驱动程序向网络上发送数据,计算机从网络上收到与某个 Socket 绑定的 IP 和 Port 相关的数据后,由驱动程序再交给 Socket ,应用程序就可以从这个 Socket 中读取接收到的数据.网络应用程序就是这样通过 Socket 发送和接收的.
六、UDP用法
例1:需求:通过udp传输方式,将一段文字数据发送出去.
/*
定义发送端
1,建立updsocket服务.
2,提供数据,并将数据封装到数据包中.
3,通过socket服务的发送功能,将数据包发出去.
4,关闭资源.
*/
class UdpSend{
public static void main(String[] args) throws Exception{
//1,创建udp服务,通过DatagramSocket对象.
DatagramSocket ds = new DatagramSocket();
//2,确定数据,并封装成数据包.DatagramPacket(byte[] buf,int length,InetAddress address,int port)
byte[] buf = "udp ge men lai le ".getBytes();
DatagramPacket dp =
new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),);
//3,通过socket服务,将已有的数据包发送出去.通过send方法.
ds.send(dp);
//4,关闭资源.
ds.close();
}
} /*
定义udp的接收端.
1,定义udpsocket服务.通常会监听一个端口.用于明确哪些数据过来该应用程序可以处理.
2,定义一个数据包,因为要存储接收到的字节数据.因为数据包对象中有更多功能可以提取字节数据中的不同数据信息.
3,通过socket服务的receive方法将收到的数据存入已定义好的数据包中.
4,通过数据包对象的特有功能.将这些不同的数据取出.打印在控制台上.
5,关闭资源.
*/
class UdpRece{
public static void main(String[] args) throws Exception{
//1,创建udp socket,建立端点.
DatagramSocket ds = new DatagramSocket();
while(true){
//2,定义数据包.用于存储数据.·
byte[] buf = new byte[];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
//3,通过服务的receive方法将收到数据存入数据包中.
ds.receive(dp);//阻塞式方法.
//4,通过数据包的方法获取其中的数据.
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(),,dp.getLength());
int port = dp.getPort();
System.out.println(ip+"::"+data+"::"+port);
}
//5,关闭资源
//ds.close();
}
}
例2:编写一个聊天程序
/*有收数据的部分,和发数据的部分,这两部分需要同时执行,那就需要用到多线程技术,一个线程控制收,一个线程控制发.*/
import java.io.*;
import java.net.*;
class Send implements Runnable{
private DatagramSocket ds;
public Send(DatagramSocket ds){
this.ds = ds;
}
public void run(){
try{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
byte[] buf=null;
while((line=bufr.readLine())!=null){
buf = line.getBytes();
DatagramPacket dp = new DatagramPacket(
buf,buf.length,InetAddress.getByName("192.168.1.255"),);//255广播地址
ds.send(dp);
if("".equals(line))
break;
}
}
catch (Exception e){
throw new RuntimeException("发送端失败");
}
}
} class Rece implements Runnable{
private DatagramSocket ds;
public Rece(DatagramSocket ds){
this.ds = ds;
}
public void run(){
try{
byte[] buf=null;
DatagramPacket dp=null;
while(true){
buf = new byte[];
dp = new DatagramPacket(buf,buf.length);
ds.receive(dp);
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(),,dp.getLength());
if("".equals(data)){
System.out.println(ip+"....离开聊天室");
break;
}
System.out.println(ip+":"+data);
}
}
catch (Exception e){
throw new RuntimeException("接收端失败");
}
}
}
七、TCP用法
例1:需求:给服务端发送给一个文本数据.
/*
TCP分客户端和服务端,客户端对应的对象是Socket,服务端对应的对象是ServerSocket.
客户端
该对象建立时,就可以去连接指定主机.
因为tcp是面向连接的.所以在建立socket服务时,
就要有服务端存在,并连接成功.形成通路后,在该通道进行数据的传输.
*/
import java.io.*;
import java.net.*;
class TcpClient{
public static void main(String[] args) throws Exception {
//创建客户端的socket服务.指定目的主机和端口
Socket s = new Socket("192.168.1.254",);
//为了发送数据,应该获取socket流中的输出流.
OutputStream out = s.getOutputStream();
out.write("tcp ge men lai le ".getBytes());
s.close();
}
} class TcpServer{
public static void main(String[] args) throws Exception{
//建立服务端socket服务.并监听一个端口.
ServerSocket ss = new ServerSocket();
while(true){
//通过accept方法获取连接过来的客户端对象.
Socket s = ss.accept(); //阻塞式方法
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+".....connected");
//获取客户端发送过来的数据,那么要使用客户端对象的读取流来读取数据.
InputStream in = s.getInputStream();
byte[] buf = new byte[];
int len = in.read(buf);
System.out.println(new String(buf,,len));
s.close();//关闭客户端.
}
//ss.close(); 可选,服务器端一般不关闭
}
}
例2:TCP传输客户端和服务端的互访,客户端给服务端发送数据,服务端收到后,给客户端反馈信息
class TcpClient2 {
public static void main(String[] args)throws Exception {
Socket s = new Socket("192.168.1.254",);
OutputStream out = s.getOutputStream();
out.write("服务端,你好".getBytes());
InputStream in = s.getInputStream();
byte[] buf = new byte[];
int len = in.read(buf);
System.out.println(new String(buf,,len));
s.close();
}
}
class TcpServer2{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket();
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
InputStream in = s.getInputStream();
byte[] buf = new byte[];
int len = in.read(buf);
System.out.println(new String(buf,,len));
OutputStream out = s.getOutputStream();
Thread.sleep();
out.write("哥们收到,你也好".getBytes());
s.close();
ss.close();
}
}
例3:建立一个文本转换服务器
/*
客户端给服务端发送文本,服务单会将文本转成大写在返回给客户端.
而且客户度可以不断的进行文本转换.当客户端输入over时,转换结束.
都是文本数据,可以使用字符流进行操作,同时提高效率,加入缓冲.*/
import java.io.*;
import java.net.*; class TransClient{
public static void main(String[] args) throws Exception{
Socket s = new Socket("192.168.1.254",);
//定义读取键盘数据的流对象.
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//定义目的,将数据写入到socket输出流.发给服务端.
//BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);//带自动刷新,用来代替BufferedWriter
//定义一个socket读取流,读取服务端返回的大写信息.
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
while((line=bufr.readLine())!=null){ //readLine读到回车符才会返回数据
if("over".equals(line))
break;
out.println(line); //换行
// bufOut.write(line);
// bufOut.newLine();
// bufOut.flush();
String str =bufIn.readLine();
System.out.println("server:"+str);
}
bufr.close();
s.close();
}
}
class TransServer{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket();
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
//读取socket读取流中的数据.
BufferedReader bufIn =new BufferedReader(new InputStreamReader(s.getInputStream()));
//目的.socket输出流.将大写数据写入到socket输出流,并发送给客户端.
//BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufIn.readLine())!=null){
System.out.println(line);
out.println(line.toUpperCase());
// bufOut.write(line.toUpperCase());
// bufOut.newLine();
// bufOut.flush();
}
s.close();
ss.close();
}
}
运行结果:
现象:客户端和服务端都在莫名的等待.因为客户端和服务端都有阻塞式readLine方法.这些方法么没有读到结束标记.那么就一直等而导致两端,都在等待.
例4:客户端上传一个文件到服务器端
class TextClient{
public static void main(String[] args) throws Exception{
Socket s = new Socket("192.168.1.254",);
BufferedReader bufr = new BufferedReader(new FileReader("IPDemo.java"));
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufr.readLine())!=null){ //能结束,键盘录入的话不能结束,需要在下面判断
out.println(line);
}
s.shutdownOutput();//关闭客户端的输出流.相当于给流中加入一个结束标记-1.否则服务器端会一直一直等待
String str = bufIn.readLine();
bufr.close();
s.close(); //socket关闭,它中的流也随着关闭
}
}
class TextServer{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket();
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
PrintWriter out = new PrintWriter(new FileWriter("server.txt"),true);
PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufIn.readLine())!=null){
//if("over".equals(line)) break; //这种方式如果文件中存在over字符会出错
out.println(line);
}
pw.println("上传成功");
out.close();
s.close();
ss.close();
}
}
例5:上传一个图片到服务器端(单线程)
public class UploadImgClient {
public static void main(String[] args) throws UnknownHostException, IOException {
Socket socket = new Socket("10.0.247.209",9100);
FileInputStream fis = new FileInputStream(new File("C:/Users/145019/Desktop/bbb.png"));
OutputStream os = socket.getOutputStream();
InputStream is = socket.getInputStream();
byte[] b = new byte[1024];
int l=0;
while((l=fis.read(b))!=-1){//写到b缓存区里
os.write(b, 0, l);
}
socket.shutdownOutput();
int ll=is.read(b);
String str = new String(b,0,ll);
System.out.println(str);
fis.close();
socket.close();
}
}
public class TestTCPServer {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(9100);
while(true){//这种用法只能一个个从队列中取client提供服务
Socket s=ss.accept();
System.out.println(s.getInetAddress());
InputStream is = s.getInputStream();
FileOutputStream fos= new FileOutputStream(new File("D:/server.gif"));
OutputStream os = s.getOutputStream();
byte[] b = new byte[1024];
int l=0;
while((l=is.read(b))!=-1){
fos.write(b, 0, l);
}
os.write("bao cun cheng gong!".getBytes());
fos.close();
}
}
}
例6:客户端并发上传图片到服务器
public class UploadImgClient {
public static void main(String[] args) throws UnknownHostException, IOException {
if(args.length!=1){
System.out.println("请选择一个jpg格式的图片");
return ;
}
File file = new File(args[0]);
if(!(file.exists() && file.isFile())){
System.out.println("该文件有问题,要么不存在,要么不是文件");
return ;
}
if(!file.getName().endsWith(".jpg")){
System.out.println("图片格式错误,请重新选择");
return ;
}
if(file.length()>1024*1024*5){
System.out.println("文件过大,没安好心");
return ;
}
Socket socket = new Socket("10.0.247.209",9100);
FileInputStream fis = new FileInputStream(file);
OutputStream os = socket.getOutputStream();
InputStream is = socket.getInputStream();
byte[] b = new byte[1024];
int l=0;
while((l=fis.read(b))!=-1){//写到b缓存区里
os.write(b, 0, l);
}
socket.shutdownOutput();
int ll=is.read(b);
String str = new String(b,0,ll);
System.out.println(str);
fis.close();
socket.close();
}
}
/*
服务端
上例中服务端有个局限性.当A客户端连接上以后.被服务端获取到.服务端执行具体流程.
这时B客户端连接,只有等待.因为服务端还没有处理完A客户端的请求,还有循环回来执行下次accept方法.所以暂时获取不到B客户端对象.
为了可以让多个客户端同时并发访问服务端.服务端最好就是将每个客户端封装到一个单独的线程中,这样,就可以同时处理多个客户端请求.
*/
class Handle implements Runnable{
private Socket s;
public Handle(Socket s) {
this.s=s;
}
public void run(){
InetAddress ip = s.getInetAddress();
InputStream is=null;
FileOutputStream fos=null;
OutputStream os=null;
try{
int count=1;
System.out.println(ip+"连接成功!");
is = s.getInputStream();
File dir = new File("d:\\pic");
File file = new File(dir,ip+"("+(count)+")"+".jpg");
while(file.exists())
file = new File(dir,ip+"("+(count++)+")"+".jpg");
fos= new FileOutputStream(file);
os = s.getOutputStream();
byte[] b = new byte[1024];
int l=0;
while((l=is.read(b))!=-1){
fos.write(b, 0, l);
}
os.write("bao cun cheng gong!".getBytes());
}catch(Exception e){
throw new RuntimeException(ip+"上传失败！");
}finally{
try {
fos.close();
s.close();
} catch (IOException e) {}
}
}
}
public class TestTCPServer {
public static void main(String[] args) throws IOException {
ServerSocket ss = new ServerSocket(9100);
ExecutorService es = Executors.newFixedThreadPool(10);/此处其实和在ServerSocket中直接指定效果一样
while(true){
Socket s=ss.accept();
es.execute(new Handle(s));
}
}
}
例7:客户端通过键盘录入用户名,服务端对这个用户名进行校验,最多登录3次
/*
如果该用户存在,在服务端显示xxx,已登陆,并在客户端显示 xxx,欢迎光临.
如果该用户存在,在服务端显示xxx,尝试登陆,并在客户端显示 xxx,该用户不存在.*/
class LoginClient{
public static void main(String[] args) throws Exception{
Socket s = new Socket("192.168.1.254",10008);
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
BufferedReader bufIn =new BufferedReader(new InputStreamReader(s.getInputStream())); for(int x=0; x<3; x++){
String line = bufr.readLine();
if(line==null)
break;
out.println(line);
String info = bufIn.readLine();
System.out.println("info:"+info);
if(info.contains("欢迎"))
break;
}
bufr.close();
s.close();
}
} class UserThread implements Runnable{
private Socket s;
UserThread(Socket s){
this.s = s;
}
public void run(){
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
try{
for(int x=0; x<3; x++){
BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
String name = bufIn.readLine();
if(name==null)
break;
BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String line = null;
boolean flag = false;
while((line=bufr.readLine())!=null){
if(line.equals(name)){
flag = true;
break;
}
}
if(flag){
System.out.println(name+",已登录");
out.println(name+",欢迎光临");
break;
}
else{
System.out.println(name+",尝试登录");
out.println(name+",用户名不存在");
}
}
s.close();
}
catch (Exception e){
throw new RuntimeException(ip+"校验失败");
}
}
}
class LoginServer{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(10008);
while(true){
Socket s = ss.accept();
new Thread(new UserThread(s)).start();
}
}
}
例8、自定义浏览器客户端和Tomcat服务器端
public class MyTomcat {
public static void main(String[] args) throws IOException {
ServerSocket ss=new ServerSocket(9000);
Socket s = ss.accept();
InputStream is = s.getInputStream();
byte []b = new byte[1024];
int l=is.read(b);
System.out.println(new String(b,0,l));
}
}
如上是简易服务器,通过浏览器地址栏输入localhost:9000,可看到控制台输出如下信息,也就是浏览器发送给tomcat的数据
GET / HTTP/1.1 //此处显示要请求的资源路径
Host: 10.0.247.209:9000 //请求主机IP和端口
Connection: keep-alive //功能使客户端到服务器端的连接持续有效,当出现对服务器的后继请求时,避免了重新建立连接
Cache-Control: max-age=0 //缓存时间为0,也就是不缓存,下次从新向服务器发送请求
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8//客户端可接收数据类型
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko)
Accept-Encoding: gzip, deflate, sdch //可以接收经过压缩的数据,以减少网络带宽
Accept-Language: zh-CN,zh;q=0.8 //接收的数据语言
如下是按照浏览器发送的内容自定义客户端去访问apachetomcat服务器,可在控制台看到如下信息
public class MyIE {
public static void main(String[] args)throws Exception {
Socket s = new Socket("10.0.16.114",8070);
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
out.println("GET /index.html HTTP/1.1");
out.println("Host: 10.0.247.209:9000");
out.println("Connection: keep-alive");
out.println("Cache-Control: max-age=0");
out.println("Accept: text/html,application/xhtml+xml,application/xml;*/*;q=0.8");
out.println("User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36");
out.println("Accept-Encoding: gzip, deflate, sdch");
out.println("Accept-Language: zh-CN,zh;q=0.8");
out.println();
BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));
String line = null;
while((line=bufr.readLine())!=null){
System.out.println(line);
}
s.close();
}
}
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Accept-Ranges: bytes
ETag: W/"512-1422437486000"
Last-Modified: Wed, 28 Jan 2015 09:31:26 GMT
Content-Type: text/html;charset=utf-8
Content-Length: 512
Date: Fri, 18 Sep 2015 07:15:51 GMT <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<link href="styles/bootstrap.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div class="jumbotron">
<h1>F2C</h1>
<p></p>
<p>
<a href="admin/welcome.wss" class="btn btn-primary btn-lg">asdfa</a>
<a href="seller/welcome.wss" class="btn btn-primary btn-lg">asdfasf</a>
</p>
</div>
</body>
</html>
八、URL和URLConnection
socket是传输层编程,URL是应用层编程,经过封包拆包的过程,在打印内容中看不到http请求头和服务器返回头.
public class TestUrl {
public static void main(String[] args) throws URISyntaxException, IOException {
URL url = new URL("http://10.0.16.114:8070/index.html");
/*URLConnection con = url.openConnection();
InputStream is = con.getInputStream();*/
InputStream is = url.openStream(); //上面兩句的簡寫
byte[]b=new byte[1024];
int l = is.read(b);
System.out.println(new String(b,0,l));
}
}
九、网页爬虫
/*网页爬虫(蜘蛛)*/
import java.util.regex.*;
import java.net.*;
public class WebCrawler{
public static void main(String[] args) throws Exception{
getMails();
}
public static void getMails()throws Exception{
URL url = new URL("http://www.cnblogs.com/wangweiNB/category/729579.html");
URLConnection conn = url.openConnection();
BufferedReader bufIn = new BufferedReader(new InputStreamReader(conn.getInputStream()));
String line = null;
String mailreg = "java";
Pattern p = Pattern.compile(mailreg);
while((line=bufIn.readLine())!=null){
Matcher m = p.matcher(line);
while(m.find()){
System.out.println(m.group());
}
}
} //获取指定文档中的邮件地址,使用获取功能.Pattern Matcher
public static void getMails1()throws Exception{
BufferedReader bufr = new BufferedReader(new FileReader("mail.txt"));
String line = null;
String mailreg = "\\w+@\\w+(\\.\\w+)+";
Pattern p = Pattern.compile(mailreg);
while((line=bufr.readLine())!=null){
Matcher m = p.matcher(line);
while(m.find()){
System.out.println(m.group());
}
}
}
}
十、域名解析的过程,首先查host文件,如果查到就直接返回,如果没有查到就会查找DNS服务器,可通过host文件来屏蔽网站.
javase(13)_网络编程的更多相关文章
- JavaSE学习总结第26天_网络编程
26.01 网络编程概述 网络编程:就是用来实现网络互连的不同计算机上运行的程序间可以进行数据交换. 26.02 网络模型概述和图解 计算机网络之间以何种规则进行通信,就是网络模型研究问题. ...
- 黑马程序员：Java编程_网络编程
=========== ASP.Net+Android+IOS开发..Net培训.期待与您交流!=========== 网络编程就是两个(或多个)设备(例如计算机)之间的数据传输,更具体的说,网络编程 ...
- JavaSE——UDP协议网络编程（二）
在 UDP 网络编程中,发送方与接收方没有建立联系,没有明显的服务器端和客户端的区别. 类 DatagramSocket: 此类表示用来发送和接收数据报包的套接字. 主要的构造方法: Datagram ...
- Java之旅_高级教程_网络编程
摘自:http://www.runoob.com/java/java-networking.html JAVA网络编程 网络编程是指编写运行在多个设备(计算机)的程序,这些设备都通过网络连接起来. j ...
- JavaSE——TCP协议网络编程（二）
1.Java网络编程与多线程的综合应用: 类Socket提供了方法getInputStream ()和getOutStream()来得到对应的输入/输出流以进行读/写操作,这两个方法分别返回Input ...
- JavaSE——TCP协议网络编程（一）
实现客户端与服务端的连接: 创建TCP服务端的 ServerSocket ServerSocket :此类实现服务器套接字.服务器套接字请求通过网络传入,基于该请求执行某些操作,然后可能向请求者返回结 ...
- Java精选笔记_网络编程
网络编程 概述 现在的网络编程基本上都是基于请求/响应方式的,也就是一个设备发送请求数据给另外一个,然后接收另一个设备的反馈. 在网络编程中,发起连接程序,也就是发送第一次请求的程序,被称作客户端(C ...
- day7_直播_网络编程篇(元昊老师著)
网络编程篇计算机网络: 多台独立的计算机用网络通信设备连接起来的网络.实现资源共享和数据传递. 比如,我们之前的学过的知识可以将D盘的一个文件传到C盘,但如果你想从你的电脑传一个文件到我的电脑上目前是 ...
- python进阶九_网络编程
Python网络编程一 一．一些基本概念 在Python网络编程这一节中会涉及到非常多网络相关的术语.对于一些最主要的概念,如TCP/IP,Socket等等不再赘述,不明确的能够自己去查一查,对于一些 ...
随机推荐
- 用EnumMap代替序数索引
用EnumMap代替序数索引 有时候,会见到利用ordinal方法来索引数组的代码.例如下面这个简化的类,表示一种烹饪用的香草: public class Herb { public enum T ...
- Python 实现简单的登录注册界面
Python 实现简单的登录注册界面 注意:编写代码之前需要导入很重要的包 import tkinter as tk import pickle from tkinter import message ...
- 自然语言处理（二）——PTB数据集的预处理
参考书 <TensorFlow:实战Google深度学习框架>(第2版) 首先按照词频顺序为每个词汇分配一个编号,然后将词汇表保存到一个独立的vocab文件中. #!/usr/bin/en ...
- Validation（3）--全局参数异常校验捕获及返回XML解决
@RestControllerAdvice原创直接上代码,后面再说怎么用1.这个是一个Form,用来接收参数的,一个简单的NotEmpty注解校验,merchantName这个参数是必传的: pack ...
- 「今日 GitHub 趋势」让全世界程序员体会中国的 12306 抢票狂潮
[2018年1月7日 GitHub 趋势] No.1:yyx990803 / build-your-own-mint 单日 714 星 使用 Plaid,Google 表格和 CircleCI 构建您 ...
- beanutils包下载
- 2017"百度之星"程序设计大赛 - 初赛（A）今夕何夕
Problem Description 今天是2017年8月6日,农历闰六月十五. 小度独自凭栏,望着一轮圆月,发出了“今夕何夕,见此良人”的寂寞感慨. 为了排遣郁结,它决定思考一个数学问题:接下来最 ...
- python+selenium+requests爬取qq空间相册时遇到的问题及解决思路
最近研究了下用python爬取qq空间相册的问题,遇到的问题及解决思路如下: 1.qq空间相册的访问需要qq登录并且需是好友,requests模块模拟qq登录略显麻烦,所以采用selenium的dri ...
- Java的Cloneable接口还有深浅复制
我的小记录 首先语法上,搞清除,Java有个Cloneable接口,但这个接口是没有定义方法的. 那实现了这个接口有什么用呢? 再看Object类中,有个clone()方法,这个方法提供一个浅复制的功 ...
- ZOJ Seven-Segment Display 暴力dfs + 剪枝
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3954 0 = on 1 = off A seven segment ...