JAVA自学笔记26

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