java基础 -网络编程笔记
666，InetAddress
package com.hspedu.api; import java.net.InetAddress;
import java.net.UnknownHostException; public class API {
public static void main(String[] args) throws UnknownHostException {
//1,获取本机 InetAddress 对象 getLocalHost
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);//小船儿的宇宙飞船/10.150.216.219 //2,根据指定主机名/域名获取 ip 地址对象 getByName
InetAddress host1 = InetAddress.getByName("小船儿的宇宙飞船");
System.out.println("host1= " + host1);//小船儿的宇宙飞船/10.150.216.219 //3,根据域名返回 InetAddress 对象，比如 www.baidu.com 对应
InetAddress host2 = InetAddress.getByName("www.baidu.com");
System.out.println("host2= " + host2);//www.baidu.com/220.181.38.149 //4,通过InetAddress 对象，获取对应的地址
String hostAddress = host2.getHostAddress();
System.out.println("host2 对应的ip= " + hostAddress);//220.181.38.149 //5,通过 InetAddress 对象，获取对应的主机名/或者域名
String hostName = host2.getHostName();
System.out.println("host2对应的主机名/域名= " + hostName);//www.baidu.com
}
}
668，TCP字节流编程1
思路：
客户端把数据从内存写出到数据通道上，然后服务端把数据通道上的数据读入到内存
代码：
服务端的代码：
package com.hspedu.socket; import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket; //服务端
public class SocketTCP01Server {
public static void main(String[] args) throws IOException {
//思路 //1. 在本机 的 9999 端口监听, 等待连接
// 细节: 要求在本机没有其它服务在监听 9999
// 细节： 这个 ServerSocket 可以通过 accept() 返回多个 Socket[多个客户端连接服务器的并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端，在9999端口监听，等待连接.."); //2. 当没有客户端连接 9999 端口时， 程序会 阻塞, 等待连接
// 如果有客户端连接， 则会返回 Socket 对象， 程序继续
Socket socket = serverSocket.accept();
System.out.println("socket = " + socket.getClass()); //3. 通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
InputStream inputStream = socket.getInputStream(); //4. IO 读取
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
} //5,关闭流和socket
inputStream.close();
socket.close();
serverSocket.close();//关闭
}
}
客户端的代码：
package com.hspedu.socket; import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException; //客户端， 发送 "hello, server" 给服务端
public class SocketTCP01Client {
public static void main(String[] args) throws IOException {
//思路 //1. 连接服务端 (ip , 端口）
//解读: 连接本机的 9999 端口, 如果连接成功， 返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket返回= " + socket.getClass()); //2. 连接上后， 生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream(); //3. 通过输出流， 写入数据到 数据通道
outputStream.write("hello, server".getBytes()); //4. 关闭流对象和 socket, 必须关闭
outputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
先运行 服务端的代码，再运行客户端的代码，两个代码的运行结果如下：
669，TCP字节流编程2
思路：
比上个案例多了一步： 服务端把 要发送的数据从内存写出到数据通道上
代码：
服务端的代码：
package com.hspedu.socket; import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket; public class SocketTCP02Server {
public static void main(String[] args) throws IOException {
//思路 //1. 在本机 的 9999 端口监听, 等待连接
// 细节: 要求在本机没有其它服务在监听 9999
// 细节： 这个 ServerSocket 可以通过 accept() 返回多个 Socket[多个客户端连接服务器的并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端，在9999端口监听，等待连接.."); //2. 当没有客户端连接 9999 端口时， 程序会 阻塞, 等待连接
// 如果有客户端连接， 则会返回 Socket 对象， 程序继续
Socket socket = serverSocket.accept();
System.out.println("socket = " + socket.getClass()); //3. 通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
InputStream inputStream = socket.getInputStream(); //4. IO 读取
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
} //5, 获取socket相关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello, client".getBytes());
//设置结束标记
socket.shutdownOutput(); //6,关闭流和socket
outputStream.close();
inputStream.close();
socket.close();
serverSocket.close();//关闭
}
}
客户端的代码：
package com.hspedu.socket; import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket; @SuppressWarnings({"all"})
public class SocketTCP02Client {
public static void main(String[] args) throws IOException {
//思路 //1. 连接服务端 (ip , 端口）
//解读: 连接本机的 9999 端口, 如果连接成功， 返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket返回= " + socket.getClass()); //2. 连接上后， 生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream(); //3. 通过输出流， 写入数据到 数据通道
outputStream.write("hello, server".getBytes());
//设置结束标记
socket.shutdownOutput(); //4. 获取和socket关联的输入流，读取数据（字节），并显示
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
} //5. 关闭流对象和 socket, 必须关闭
inputStream.close();
outputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
运行结果：
670，TCP字符流编程
思路：
代码：
服务端的代码：
package com.hspedu.socket; import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; public class SocketTCP03Server {
public static void main(String[] args) throws IOException {
//思路 //1. 在本机 的 9999 端口监听, 等待连接
// 细节: 要求在本机没有其它服务在监听 9999
// 细节： 这个 ServerSocket 可以通过 accept() 返回多个 Socket[多个客户端连接服务器的并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端，在9999端口监听，等待连接.."); //2. 当没有客户端连接 9999 端口时， 程序会 阻塞, 等待连接
// 如果有客户端连接， 则会返回 Socket 对象， 程序继续
Socket socket = serverSocket.accept();
System.out.println("socket = " + socket.getClass()); //3. 通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
InputStream inputStream = socket.getInputStream(); //4. IO读取，使用字符流，老师使用 InputStreamReader 将 inputStream 转成字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);//输出 //5, 获取socket相关联的输出流
OutputStream outputStream = socket.getOutputStream();
// 使用字符输出流的方式回复信息
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello client 字符流");
bufferedWriter.newLine();
bufferedWriter.flush();//注意需要手动的flush
//设置结束标记
socket.shutdownOutput(); //6,关闭流和socket
bufferedReader.close();
bufferedWriter.close();
socket.close();
serverSocket.close();//关闭
}
}
客户端的代码：
package com.hspedu.socket; import java.io.*;
import java.net.InetAddress;
import java.net.Socket; public class SocketTCP03Client {
public static void main(String[] args) throws IOException {
//思路 //1. 连接服务端 (ip , 端口）
//解读: 连接本机的 9999 端口, 如果连接成功， 返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket返回= " + socket.getClass()); //2. 连接上后， 生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream(); //3. 通过输出流，写入数据到 数据通道，使用字符流
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello, server 字符流");
bufferedWriter.newLine();// 插入一个换行符， 表示回复内容的结束，注意，要求对方使用readLine()
bufferedWriter.flush();//如果使用的是字符流，需要手动刷新，否则数据不会写入数据通道
//设置结束标记
socket.shutdownOutput(); //4. 获取和socket关联的输入流，读取数据（字符），并显示
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s); //5. 关闭流对象和 socket, 必须关闭
bufferedReader.close();//关闭外层流
outputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
运行结果：
671，网络上传文件
思路：
与前面的题不一样的是，客户端要先把图片读入到内存中，然后再把内存中的图片写出到数据通道上；服务端从数据通道上把图片的数据读入到自己电脑的内存中，再从内存中写出到存放的磁盘目录下；服务端把 收到图片的信息写出到数据通道上，客户端再读入。
代码：
StreamUtils 类
package com.hspedu.upload; import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader; /**
* 此类用于演示关于流的读写方法
*
*/
public class StreamUtils {
/**
* 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
* @param is
* @return
* @throws Exception
*/
public static byte[] streamToByteArray(InputStream is) throws Exception{
ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
byte[] b = new byte[1024];//字节数组
int len;
while((len=is.read(b))!=-1){//循环读取
bos.write(b, 0, len);//把读取到的数据，写入bos
}
byte[] array = bos.toByteArray();//然后将bos 转成字节数组
bos.close();
return array;
}
/**
* 功能：将InputStream转换成String
* @param is
* @return
* @throws Exception
*/ public static String streamToString(InputStream is) throws Exception{
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder builder= new StringBuilder();
String line;
while((line=reader.readLine())!=null){
builder.append(line+"\r\n");
}
return builder.toString(); } }
服务端的代码：
package com.hspedu.upload; import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; //文件上传的服务端
public class TCPFileUploadServer {
public static void main(String[] args) throws Exception {
//1. 服务端在本机监听8888端口
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务端在8888端口监听....");
//2. 等待连接
Socket socket = serverSocket.accept(); //3. 读取客户端发送的数据
// 通过Socket得到输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4. 将得到 bytes 数组，写入到指定的路径，就得到一个文件了
String destFilePath = "src\\1.jpg";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
bos.close(); // 向客户端回复 "收到图片"
// 通过socket 获取到输出流(字符)
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
writer.write("收到图片");
writer.flush();//把内容刷新到数据通道
socket.shutdownOutput();//设置写入结束标记 //关闭其他资源
writer.close();
bis.close();
socket.close();
serverSocket.close(); }
}
客户端的代码
package com.hspedu.upload; import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException; //文件上传的客户端
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//客户端连接服务端 8888，得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//创建读取磁盘文件的输入流
//String filePath = "e:\\qie.png";
String filePath = "d:\\1.jpg";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath)); //bytes 就是filePath对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis); //通过socket获取到输出流, 将bytes数据发送给服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
bis.close();
socket.shutdownOutput();//设置写入数据的结束标记 //=====接收从服务端回复的消息===== InputStream inputStream = socket.getInputStream();
//使用StreamUtils 的方法，直接将 inputStream 读取到的内容 转成字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s); //关闭相关的流
inputStream.close();
bos.close();
socket.close(); }
}
运行结果：
677，UDP网络编程1
思路：
代码：
接收端的代码：
package com.hspedu.udp; import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException; //UDP 接收端
public class UDPReceiverA {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象，准备在9999接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2. 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解UDP 协议时，老师说过一个数据包最大 64k
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
//3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
//老师提示: 当有数据包发送到 本机的9999端口时，就会接收到数据
// 如果没有数据包发送到 本机的9999端口, 就会阻塞等待.
System.out.println("接收端A 等待接收数据..");
socket.receive(packet); //4. 可以把packet 进行拆包，取出数据，并显示.
int length = packet.getLength();//实际接收到的数据字节长度
byte[] data = packet.getData();//接收到数据
String s = new String(data, 0, length);
System.out.println(s); //===回复信息给B端
//将需要发送的数据，封装到 DatagramPacket对象
data = "好的, 明天见".getBytes();
//说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
packet =
new DatagramPacket(data, data.length, InetAddress.getByName("192.168.191.221"), 9998); socket.send(packet);//发送 //5. 关闭资源
socket.close();
System.out.println("A端退出..."); }
}
发送端的代码：
package com.hspedu.udp; import java.io.IOException;
import java.net.*; //发送端 B ====> 也可以接收数据
public class UDPSenderB {
public static void main(String[] args) throws IOException {
//1.创建 DatagramSocket对象，准备在9998端口 接收数据
DatagramSocket socket = new DatagramSocket(9998); //2. 将需要发送的数据，封装到 DatagramPacket对象
byte[] data = "hello 明天吃火锅~".getBytes(); //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
DatagramPacket packet =
new DatagramPacket(data, data.length, InetAddress.getByName("192.168.191.221"), 9999); socket.send(packet); //3.=== 接收从A端回复的信息
//(1) 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解UDP 协议时，老师说过一个数据包最大 64k
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
//(2) 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
//老师提示: 当有数据包发送到 本机的9998端口时，就会接收到数据
// 如果没有数据包发送到 本机的9998端口, 就会阻塞等待.
socket.receive(packet); //(3) 可以把packet 进行拆包，取出数据，并显示.
int length = packet.getLength();//实际接收到的数据字节长度
data = packet.getData();//接收到数据
String s = new String(data, 0, length);
System.out.println(s); //关闭资源
socket.close();
System.out.println("B端退出");
}
}
运行结果：
679，网络编程作业1
代码：
把 670 节的代码拿来一改就行。
服务端的代码：
package com.hspedu.homework; import java.io.*;
import java.net.ServerSocket;
import java.net.Socket; @SuppressWarnings({"all"})
public class Homework01Server {
public static void main(String[] args) throws IOException {
//思路 //1. 在本机 的 9999 端口监听, 等待连接
// 细节: 要求在本机没有其它服务在监听 9999
// 细节： 这个 ServerSocket 可以通过 accept() 返回多个 Socket[多个客户端连接服务器的并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端，在9999端口监听，等待连接.."); //2. 当没有客户端连接 9999 端口时， 程序会 阻塞, 等待连接
// 如果有客户端连接， 则会返回 Socket 对象， 程序继续
Socket socket = serverSocket.accept(); //3. 通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
InputStream inputStream = socket.getInputStream();
//4. IO读取，使用字符流，老师使用 InputStreamReader 将 inputStream 转成字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
String answer = "";
if ("name".equals(s)) {
answer = "我是韩顺平";
} else if ("hobby".equals(s)) {
answer = "编写java程序";
} else {
answer = "你说的啥子";
} //5, 获取socket相关联的输出流
OutputStream outputStream = socket.getOutputStream();
// 使用字符输出流的方式回复信息
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write(answer);
bufferedWriter.newLine();
bufferedWriter.flush();//注意需要手动的flush
//设置结束标记
socket.shutdownOutput(); //6,关闭流和socket
bufferedReader.close();
bufferedWriter.close();
socket.close();
serverSocket.close();//关闭
}
}
客户端的代码：
package com.hspedu.homework; import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner; @SuppressWarnings({"all"})
public class Homework01Client {
public static void main(String[] args) throws IOException {
//思路 //1. 连接服务端 (ip , 端口）
//解读: 连接本机的 9999 端口, 如果连接成功， 返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket返回= " + socket.getClass()); //2. 连接上后， 生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream(); //3. 通过输出流，写入数据到 数据通道，使用字符流
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream)); //从键盘读取用户的问题
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题");
String question = scanner.next(); bufferedWriter.write(question);
bufferedWriter.newLine();// 插入一个换行符， 表示回复内容的结束，注意，要求对方使用readLine()
bufferedWriter.flush();//如果使用的是字符流，需要手动刷新，否则数据不会写入数据通道
//设置结束标记
socket.shutdownOutput(); //4. 获取和socket关联的输入流，读取数据（字符），并显示
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s); //5. 关闭流对象和 socket, 必须关闭
bufferedReader.close();//关闭外层流
outputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
运行结果：
680，网络编程作业2
代码：
把 677 节的代码拿来一改
接收端的代码：
package com.hspedu.homework; import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress; @SuppressWarnings({"all"})
//UDP 接收端
public class Homework02ReceiverA {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象，准备在8888接收数据
DatagramSocket socket = new DatagramSocket(8888);
//2. 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解UDP 协议时，老师说过一个数据包最大 64k
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
//3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
System.out.println("接收端 等待接收问题 ");
socket.receive(packet); //4. 可以把packet 进行拆包，取出数据，并显示.
int length = packet.getLength();//实际接收到的数据字节长度
byte[] data = packet.getData();//接收到数据
String s = new String(data, 0, length);
//判断接收到的信息是什么
String answer = "";
if ("四大名著是哪些".equals(s)) {
answer = "四大名著 《红楼梦》《三国演义》《西游记》《水浒传》";
} else {
answer = "what?";
} //===回复信息给B端
//将需要发送的数据，封装到 DatagramPacket对象
data = answer.getBytes();
//说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
packet =
new DatagramPacket(data, data.length, InetAddress.getByName("192.168.191.221"), 9998); socket.send(packet);//发送 //5. 关闭资源
socket.close();
System.out.println("A端退出..."); }
}
发送端的代码：
package com.hspedu.homework; import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner; @SuppressWarnings({"all"})
//发送端 B ====> 也可以接收数据
public class Homework02Sender {
public static void main(String[] args) throws IOException {
//1.创建 DatagramSocket对象，准备在9998端口 接收数据
DatagramSocket socket = new DatagramSocket(9998); //2. 将需要发送的数据，封装到 DatagramPacket对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题：");
String question = scanner.next();
byte[] data = question.getBytes(); //说明: 封装的 DatagramPacket对象 data 内容字节数组 , data.length , 主机(IP) , 端口
DatagramPacket packet =
new DatagramPacket(data, data.length, InetAddress.getByName("192.168.191.221"), 8888);
socket.send(packet); //3.=== 接收从A端回复的信息
//(1) 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解UDP 协议时，老师说过一个数据包最大 64k
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
//(2) 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
//老师提示: 当有数据包发送到 本机的9998端口时，就会接收到数据
// 如果没有数据包发送到 本机的9998端口, 就会阻塞等待.
socket.receive(packet); //(3) 可以把packet 进行拆包，取出数据，并显示.
int length = packet.getLength();//实际接收到的数据字节长度
data = packet.getData();//接收到数据
String s = new String(data, 0, length);
System.out.println(s); //关闭资源
socket.close();
System.out.println("B端退出");
}
}
运行结果：
java基础 -网络编程笔记的更多相关文章
- java基础-网络编程（Socket）技术选型入门之NIO技术
java基础-网络编程(Socket)技术选型入门之NIO技术 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.传统的网络编程 1>.编写socket通信的MyServer ...
- 二十三、Java基础--------网络编程
Java中另一个重要技术就是网络编程了,为了更好的学习web方向的知识,有必要对java之网络编程好好学习,本文将围绕网络编程技术进行分析. 常见的网络协议:UDP.TCP UDP 1. 将数据源和目 ...
- Java基础——网络编程（二）
一.套接字 Socket 网络驱动程序提供给应用程序编程的接口和一种机制,可以比喻成一个港口码头 应用程序只要把货放在这,就算完成了货物的运送.它在应用程序中创建,通过一种绑定机制与驱动程序建立关系, ...
- Java基础——网络编程（一）
本文主要记录网络编程的一些基础知识,学了前班部分,对专业术语有些蒙,但是,收货也是很多很多的.观察了自己计算机的进程,查找其他网络地址的IP,对互联网的层次关系有了更深一步的了解.下面多是概念的摘录, ...
- Java基础——网络编程
一.网络编程概述 概述: Java是 Internet 上的语言,它从语言级上提供了对网络应用程序的支持,程序员能够很容易开发常见的网络应用程序. Java提供的网络类库,可以实现无痛的网络连接,联网 ...
- java基础—网络编程
一.网络基础概念 首先理清一个概念:网络编程 != 网站编程,网络编程现在一般称为TCP/IP编程.
- JAVA基础——网络编程之网络链接
一.网络编程基本概念 1.OSI与TCP/IP体系模型 2.IP和端口 解决了文章最开始提到的定位的问题. IP在互联网中能唯一标识一台计算机,是每一台计算机的唯一标识(身份证):网络编程是和远程计算 ...
- Java之网络编程笔记
网络通讯要素: 1.IP地址 IP地址:用于标记一台计算机的身份证. IP地址由网络地址(确定网络)和主机地址(网络中的主机)组成. IP地址分为A类地址.B类地址.C类地址(常用).D类地址.E类地 ...
- Java基础——网络编程（三）
TCP 网络编程 -- tcp 分为客户端和服务端 -- 客户端对应的对象是 Socket -- 服务端对应的对象是 ServerSocket -- 如果客户端先启动,则出现 connection r ...
- 梦入IBM之java基础-网络编程
如今我们来谈谈最后的内容:网络编程: 1):TCP中是线程与线程进行通讯!内部的执行机制是这种:先有一个线程去监听某个port.然后假设有Socket连接上来了以后,server会生成一个Socket ...
随机推荐
- [oeasy]python0013_ASCII码表_英文字符编码_键盘字符
ASCII 码表 回忆上次内容 ord(c)和chr(i) 这是俩函数 这俩函数是一对,相反相成的⚖️ ord 通过 字符 找到对应的 数字 chr 通 ...
- 如何使用ventoy安装操作系统
使用ventoy安装操作系统 vrntoy简介 简单来说,Ventoy是一个制作可启动U盘的开源工具. 有了Ventoy你就无需反复地格式化U盘,你只需要把 ISO/WIM/IMG/VHD(x)/EF ...
- hadoop web界面
通过界面监控大数据平台运行状态 通过界面查看大数据平台状态 通过大数据平台 Hadoop 的用户界面可以查看平台的计算资源和存储资源.打开 http://master:8088/cluster/nod ...
- Netty的源码分析和业务场景
Netty 是一个高性能.异步事件驱动的网络应用框架,它基于 Java NIO 构建,广泛应用于互联网.大数据.游戏开发.通信行业等多个领域.以下是对 Netty 的源码分析.业务场景的详细介绍: 源 ...
- 【Vue】05 Webpack
Webpack是一个现代JS应用的静态模块打包的工具 学习Webpack需要我们安装NodeJS 配置CNPM & CRM 使用切换镜像的方式配置:[不建议] npm config set r ...
- python数据分析与可视化基础
一.数据分析介绍:1.数据分析含义:数据分析是指用适当的统计分析方法对收集来的大量数据进行分析,将它们加以汇总和理解并消化,以求最大化地开发数据的功能,发挥数据的作用.数据分析是为了提取有用信息和形成 ...
- 使用 Alba 对 AspnetCore项目进行测试
前言 在AspnetCore生态系统中,我们测试项目一般使用Microsoft.AspNetCore.TestHost的TestServer 到.NET6后提供的Microsoft.AspNetCor ...
- 预处理共轭梯度算法(Preconditioned Conjugate Gradients Method)
预处理共轭梯度算法(Preconditioned Conjugate Gradients Method) 给出百度百科上的解释: 预处理共轭梯度法 预处理共轭梯度法是.不必预先估计参数等特点. 共轭梯 ...
- 从hp的暗影精灵4来看移动cpu的实际性能表现与官方出厂性能数据之间的差距
手上有一款暗影精灵4的笔记本,CPU为i7-9750H,官方给出的睿频为4.5Ghz,但是自己使用过程中最高睿频只能达到3.9Ghz与4.1Ghz之间,根本就没有超过4.1Ghz的时候. (图的原网址 ...
- 新兴互联网银行搭档Apache SeaTunnel构建数据流通管道！
当新兴互联网银行乘着数字化改革的风潮搭档数据集成平台Apache SeaTunnel,成千万上亿的数据就有了快速流通的管道.6月26日14:00,Apache SeaTunnel社区将带上企业最佳实践 ...