正文
JAVA自学笔记26
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
flowchart 箭头图标 勿删
JAVA自学笔记26
1、网络编程
1）用来实现网络互联的不同计算机上运行的程序可以进行数据交换
2）网络模型一般泛指
OSI：（Open System Interconnection）开放系统互联参考模型
TCP/IP参考模型
3）网络编程三要素
IP地址、端口、协议
①IP地址：在TCP/IP协议中网络通信中的计算机的唯一标识号
java提供类InetAddress供使用。
为了方便用4个十进制数表示
网络号段+主机号段
IP分类：
见书
ipconfig–查看本机IP地址
ping ip地址–测试本机与指定的ip地址间的通信是否有问题
特殊的Ip地址：
127.0.0.1–回环地址，表示本机
x.x.x.255–广播地址
x.x.x.0–网络地址
4）InetAddress
无构造方法：{
成员都是静态的
单例设计模式（Runtime)
类中有静态方法返回该类的对象
}
属上述情况中的最后一种
public static InetAddress getByName(String host):
根据主机名或者ip地址表示得到的IP地址对象
InetAdress address=InetAddress.getByName("cc");
String name=address.getHostName();//获取主机名
String ip=address.getHostName();//获取ip地址
5）端口号
每个网络程序都会至少有一个逻辑端口，用于标识进程的逻辑地址，不同 进程的标识
有效端口0~65535，其中0~1024系统使用或保留
6）协议
UDP：将数据源和目的封装成数据包中，不需要建立连接；每个数据包的大小限制在64k;因无连接，是不可靠的协议；不需要建立连接，速度快
TCP：建立连接，形成传输数据的通道：在连接进行大数据量的传输；通过3次握手完成连接，是可靠协议；必须建立连接，效率稍低。
7）socket通信原理
socket–网络套接字
网络上具有唯一标识的IP地址和端口组合在一起才能构成唯一能识别的标识符套接字。
原理机制：
通信的两端都有socket，网络通信其实是Socket之间的通信，数据在两个Socket之间通过IO传输
DatagramPacket (byte[] buf,int length,InetAddress address,int port)
构造包含数据，其长度，远程主机的Ip地址和远程主机的端口号
public void send(DatagramPacket p);
从此套接字发送数据报包。DatagramPacket含将要发送的数据，其长度，远程主机的Ip地址和远程主机的端口号
//UDP协议发送数据
--创建发送端Socket对象
--创建数据，并把数据打包
--调用Socket对象的放松方法发送数据包
--释放资源
//创建发送端Socket对象
DatagramSocket ds=new DatagramSocket();
//创建数据，并把数据打包
byte[] bys="good morning!你好";
int length=bys.length();
InetAddress address=InetAddress.getByName("222,241.111,1");
int port=10086;
DatagramPacket (bys,length,address,port)
//调用Socket对象的发送方法发送数据包
ds.send(dp);
//释放资源
ds.close();
DatagramSocket(int port);//创建数据报套接字并将其绑定到本地主机上的指定端口
public void receive(DatagramPacket p)从此套接字接收数据报包。
//UDP协议接收数据
--创建接受端Socket对象
--创建一个数据包（接收容器）
--调用Socket对象的接收方法接收数据
--解析数据包，并显示在控制台
--释放资源
//创建接受对象
DatagramSocket ds=new DatagramSocket(10086);
//创建一个数据包
byte[] bys=new byte[1024];
int length=bys.length;
DatagramPacket dp=new DatagramPacket(bys,length);
//调用Socket对象的接收方法接收数据
ds。receive(dp);
//解析数据包，并输出到控制台
//public byte[] getData():获取数据缓冲区
//public int getLength();//获取数据的实际长度
byte[] bys2=dp.getData();
int len=dp.getLength();
String s=new String(by2,0,len);
System.out.println(s);
ds.close();
//
图解：
//代码优化
public class ReceiveDemo{
public static void main(String args[]){
//创建接收端的Socket对象
DatagramSocket ds=new DatagramSocket(10086);
DatagramPacket dp=new DatagramPacket(bys,bys.length);
//接收数据
ds.receive(dp);
//解析数据，链式编程
String ip=dp.getAddress().getHostAddress();
String s=new String (dp.getData(),0,dp.getLength());
System.out.println(s);
ds.close();
}
}
public class SendDemo{
public static void main(String args[]){
byte[] bys="hello".getBytes();
DataPacket dp=new DatagramPacket(bys,bys.length.InetAddress.getByName("192.12.36.8"),10086);
ds.send(dp);
ds.close();
}
}多次启动接收端将提示该端口已被占用
//发送端的数据来自键盘录入
public class ReceiveDemo{
public static void main(String args[]){
//创建接收端的Socket对象
DatagramSocket ds=new DatagramSocket(10086);
while(true){
byte[] bys=new byte[1024];
DatagramPacket dp=new DatagramPacket(bys,bys.length);
//接收数据
ds.receive(dp);
//解析数据，链式编程
String ip=dp.getAddress().getHostAddress();
String s=new String (dp.getData(),0,dp.getLength());
System.out.println(s);
}
}
}
public class SendDemo{
public static void main(String args[]){
DatagramSocket ds=new DatagramSocket();
//封装键盘录入数据
BufferedReader ds=new DatagramSocket();
BUfferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null){
byte[] bys=line.getBytes();
DataPacket dp=new DatagramPacket(bys,bys.length.InetAddress.getByName("192.12.36.255"),10086);//广播地址
ds.send(dp);}
ds.close();
}
}//多线程实现聊天室
public class ChatRoom{
public static void main(String args[]){
DatagramSocket ds=new DatagramSocket();
DatagramSocket dsReceive=new DatagramSocket(12300);
SendThread st=new SendThread(dsSend);
ReceiveThread(dsReceive);
Thread t1=new Thread(st);
Thread t2=new Thread(rt);
t1.start();
t2.start();
}
}
public class SendThread implements Runnable{
private DatagramSocket ds;
public SendThread(DatagramSocket ds){
this.ds=ds;
}
public void run(){
BUfferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null){
byte[] bys=line.getBytes();
DataPacket dp=new DatagramPacket(bys,bys.length.InetAddress.getByName("192.12.36.255"),12300);//广播地址
ds.send(dp);}
ds.close();
}
}
public class ReceiveThread implements Runnable{
private DatagramSocket ds;
public ReceiveThread(DatagramSocket ds){
this.ds=ds;
}
public void run(){
while(true){
byte[] bys=new byte[1024];
DatagramPacket dp=new DatagramPacket(bys,bys.length);
//接收数据
ds.receive(dp);
//解析数据，链式编程
String ip=dp.getAddress().getHostAddress();
String s=new String (dp.getData(),0,dp.getLength());
System.out.println(s);
}
}
}2、TCP
//TCP发送数据
--创建发送端的Socket对象
--获取输出流写数据
--释放资源
public class ClientDemo{
public static void main(String args[]){
Socket s=new Socket(InetAddress.getByName("193.36.14.2"),6811);
//Socket s=new Socket("193.36.14.2",6811);也行
//获取输出流，写数据
public OutputStream getOutputStream()
OutputStream os=s.getOutputStream();
os,write("hell0!".getBytes());
s.close();
}
}//TCP协议接收数据
--创建接收端Socket对象
--监听客户端接收，返回一个对应的Socket对象
--获取输入流，读取数据显示在控制台
--释放资源
ServerSocket ss=new ServerSocket(6811);
//监听客户端连接，返回一个对应的Socket对象 Socket s=ss.accept();
//获取输入流显示在控制台
InputStream is=s.getInputStream();
byte[]bys=new byte[1024];
int len=is.read(bys);
String str=new String(bys,0,len);
String ip=s.getInetAddress().getHostAddress();
System.out,println(str);
//释放资源
s.close();
图解:
//有反馈的案例
public class ServerDemo{
public static void main(String[] aargs){
//创建服务器Socket对象
ServerSocket ss=new SeverSocket(9999);
//监听客户端的连接
Socket s=ss.accept();
//获取输入流
InputStream is=s.getInputStream();
byte[] bs=new byte[1024];
int len=is.read(bys);
String server=new String(bys,0,len);
System.out.println(server);
//获取输出值
OutputStream os=s.getOutpitStream();
os.write("数据已收取"。getByte());
//关闭
s.close();
}
}
public class ClientDemo{
public static void main(String[] args){
//创建客户端Socket对象
Socket s=new Socket("111.111.1.1",9999);
//获取输出流
OutputStream os=s.getOutputStream();
Os.write("今天天气还行".getBytes());
//获取输入流
InputStream is=s.getInputStream();
byte[] bys=new byte[1024];
int len=is.read(bys);
String client=new String(bys,0,len);
System.out.println(client);
//释放资源
s.close();
}
}//客户端键盘录入服务器控制台输出
public class ClientDemo{
public static void main(Stirng[] args){
Socket s=new Socket("192.168.2.92",22222);
//键盘录入数据
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String line=null;
while((line=br.readLine())!=null){
//把通道内的流包装一下
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));//字节流
String line=null;
while(if("886".equals(line)){
break;
}
(line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//释放资源
s.close();
}
}
}
//服务器
public class ServerDemo{
pubic static void main(String[] args){
//创建服务器Socket对象
ServerSocket ss=new ServerSocket(22222);
//监听客户端连接
Socket s=ss..accept();
//包装通道内的流
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
s.close();
}
}//客户端键盘录入服务器写到文本文件
public class ClientDemo{
pubic static void main(String args[]){
Socket s=new Socket("192.168.12.92",23456);
//封装键盘录入
Buffered br=new BufferedReader(new InputStreamReader(System.in));
//封装通道内的数据
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
String line=null;
While((line=br.readLine())!=null)
if("over".equals(line)){
break;
}
s.close();
}
}
public class ServerDemo{
public static void main(String[] args){
//创建服务器Socket对象
ServerSocket ss=new ServerSocket(23456);
//监听客户端连接
Socket s=ss.accept();
//封装通道内的数据
BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
//封装文本文件
BufferedWriter bw=new BufferedWriter(new FileWriter("a.txt"));
String line=null;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
bw,close();
s.close();
}
}//客户端读取文本文件服务器控制台输出
public static ClientDemo{
public static void main(String[] args){
//创建Socket对象
Socket s=new Socket("198.168.12.92",34567);
//封装文本文件
BufferedReader br=new BufferedReader(new FileReader("InetAddressDemo.java"));
//封装通道内的流
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line=null;
while((line=br.readLine())!=bull){
bw.write(line);
bw.newLine();
bw.flush();
}
br.close();
s.close();}
}
public class ServerDemo{
public static void main(String[] args){
//创建服务器Socket对象
ServerSocket ss=new ServerSocket(34567);
//监听客户端连接
Socket s=ss.accept();
//封装通道内的流
BufferedReader br=new BufferedReader(new InputStreamReader{s.getInputStream()));
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);
}
}
s.close();
}//客户端文本文件，服务器输出文本文件
public class UploadClient{
public static void main(String args[]){
//创建客户端Socket对象
Socket s=new Socket("192.188.12.92",11111);
//封装文本文件
BufferedReader br=new BufferedReader(new FileReader("InetAddressDemo.java"));
//封装通道内流
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
String line=null;
while((line=br.readLine())!=null){
br.close();
s.close();
}
}
public class Uploadserver{
public static void main(String args[]){
//创建服务器的Socket对象
ServerSocket ss=new ServerSocket(11111);
//监听客户端连接
Socket s=ss.accept();
//封装通道内的流
BufferedReader br=new BufferedReader(new InputStramReader(s.getInputStream()));
//封装文本文件
BufferedWriter bw=new BufferedWriter(new FileWriter("Copy.java"));
String line=null;
while((line=br.readLine())!=bull){
bw.write(line);
bw.newLine();
bw.flush();
bw.close();
s.close();
}
}//TCP上传文本文件并给出反馈
注意：读取文本文件是可以以null作为结束信息的，但是通道内是不能这样结束信息的。所以服务器根本就不知道结束了，而客户端还在等服务器给反馈，因此就相互等待了。
a.自定义结束标记
b.shutdownInput()--禁用此套接字的输出流，对于TCP套接字，任何以前写入的数据都将被发送，并且后跟TCP的正常终止序列。
以此为准
public class UploadClient {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket("192.168.12.92", 11111);
// 封装文本文件
BufferedReader br = new BufferedReader(new FileReader(
"InetAddressDemo.java"));
// 封装通道内流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
String line = null;
while ((line = br.readLine()) != null) { // 阻塞
bw.write(line);
bw.newLine();
bw.flush();
}
//自定义一个结束标记
// bw.write("over");
// bw.newLine();
// bw.flush();
//Socket提供了一个终止，它会通知服务器你别等了，我没有数据过来了
s.shutdownOutput();
// 接收反馈
BufferedReader brClient = new BufferedReader(new InputStreamReader(
s.getInputStream()));
String client = brClient.readLine(); // 阻塞
System.out.println(client);
// 释放资源
br.close();
s.close();
}
}
public class UploadServer {
public static void main(String[] args) throws IOException {
// 创建服务器端的Socket对象
ServerSocket ss = new ServerSocket(11111);
// 监听客户端连接
Socket s = ss.accept();// 阻塞
// 封装通道内的流
BufferedReader br = new BufferedReader(new InputStreamReader(
s.getInputStream()));
// 封装文本文件
BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
String line = null;
while ((line = br.readLine()) != null) { // 阻塞
// if("over".equals(line)){
// break;
// }
bw.write(line);
bw.newLine();
bw.flush();
}
// 给出反馈
BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(
s.getOutputStream()));
bwServer.write("文件上传成功");
bwServer.newLine();
bwServer.flush();
// 释放资源
bw.close();
s.close();
}
}
//TCP协议上传图片，使用字节流
public class UploadServer{
public static void main(String args){
//创建服务器Socket对象
ServerSocket ss=new ServerSocket(19191)；
//监听客户端连接
Socket s=ss.accept();
//封装通道内流
BufferedInputStream bis=new BufferedInputStream(s.getInputStream());
//封装图片文件
BufferedOutoutStream bos=new BufferedOutputStream{
new FileOutpuutStream("mn.jpg");
byte[] bys=new byte[1024];
int len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys,0,len);
}
//给一个反馈
OutputStream os=s.getOurStream();
os.write("success".getBytes());
bos.close();
s.close();
}
}
}
public class UploadClient{
public static void main(String args){
//创建客户端Socket对象
Socket s=new Socket("192.168.12.92"),19191);
//封装图片文件
BufferedInputStream bis=new BufferedInputStream(new FileInputStrean(a.jpg));
//封装通道内的流
BufferedOutputStream bos=new BufferedOutputStream(s.getOutputStream());
int len=0;
while((len=bis.read(bys))!=-1){
bos.write(bys,0,len);
bos.flush();//一定要刷新
}
s.shutdownOutput();
//读取反馈
InputStream is=s.getInputStream();
byte[] bys2=new byte[1024];
int len2=is.read(bys2);
String client=new String(by2,0,len2);
System.out.println(client);
//释放资源
bis.close();
s.close();
}
}
多个客户端上传至一个服务器
it.cast-15
