黑马程序员--网络编程（23天）

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

1.网络通讯要素：ip地址， 端口号， 传输协议

2.通信原理：（1）.找到对方的ip
    （2）.数据要发送到对方指定的应用程序上，为了标识这些应用程序，
   所以给这些网络应用程序都用数字进行标识，为了方便称呼这个
数字，我们称之为端口，即逻辑端口。

3.osi网络分层：
（1）应用层
（2）表示层
（3）会话层
（4）传输层
（5）网络层
（6）数据链路层
（7）物理层

4.TCP/IP参考模型：
（1）应用层
（2）传输层
（3）网际层
（4）主机至网络层

5.scoket（插座）就是为网络服务提供的一种机制，通信两端都有scoket,同时数据在两个Scoket见通过IO传输

6.获取本机的IP地址的代码示例：
package earth;

import java.io.IOException;

import java.net.*;

public class Net01 {

public static void main(String[] args) throws IOException{

//获取本机的Ip地址和计算机名，记得要抛出异常
InetAddress ia = InetAddress.getLocalHost();
System.out.println(ia);
//将获取的数据 输出

}

}

7.getHostAddress;获取本机的IP地址

8.getHostname:获取本机的名称

9.获取针对某个IP地址的计算机名：
package earth;

import java.io.IOException;

import java.net.*;

public class Net02 {

public static void main(String[] args) throws IOException{
InetAddress ia = InetAddress.getByName("192.168.1.240");

//获取目标数据
System.out.println("address:" + ia.getHostAddress());
System.out.println("name:" + ia.getHostName());

}

}

10.端口号：用于表示进程的逻辑地址，不同进程的标识

11.端口号：有效端口：0-65535，其中0-1024系统使用或保留端口

12.UDP特点:
（1）将数据及源和目的封装成数据包中，不需要建立连接
（2）每个数据包的大小在限制在64K
（3）因无连接，是不可靠协议
（4）不需要链接，速度快

13.TCP：
（1）建立连接，形成传输数据的通道
（2）在链接中进行大数据量传输
（3）通过三次握手完成链接，是可靠协议
（4）必须建立链接，效率会稍低

14.DatagramSocket:此类表示用来发送和接收数据包的套接字

15.DatagramPacket:此类表示数据包。

16.InetAddress.getByName():在给定主机名的情况下确定主机的IP地址

17.示例代码：
package earth;

import java.io.IOException;

import java.net.*;

public class Net03 {

public static void main(String[] args) throws IOException{

//首先创建一个DatagramScoket对象和UPD服务
DatagramSocket ds = new DatagramSocket();

//写数据并将数据并打包
byte[] by = "this is first ".getBytes();
//创建数据（写一个数据）

//打包
//DatagramPacket(byte[] buf(数组名), int length（长度）, InetAddress address（传输目标的名）, int port（端口号）)
DatagramPacket dp = new DatagramPacket(by, by.length, InetAddress.getByName("192.168.1.240"), 8888);

//将已有的数据通过Send发送出去
ds.send(dp);

//关闭资源
ds.close();

}

}

class reo{
public static void main(String[] args)
throws IOException{

//1.创建一个DatagramSocket的接收对象
DatagramSocket ds = new DatagramSocket();

//2.定义数据包并进行存储
byte[] by = new byte[1024];

//接收数据DatagramPacket(byte[] buf, int length) 
DatagramPacket dp = new DatagramPacket(by, by.length);

//4.用Receive的方法接收数据
ds.receive(dp);

//通过数据包获取其中的 数据
String st = dp.getAddress().getHostAddress();

String st0 = new String(dp.getData(), 0, by.length);
//对数据进行有效的截取，并将数据强制转化成String类型

int port = dp.getPort();
//获取端口

System.out.println("地址" + st + "数据" + st0 + "端口" + port);

ds.close();
}

}

18.示例代码：

（1）

package earth;

import java.net.*;

import java.io.*;

public class Net04 {

public static void main(String[] args) throws Exception{

//首先建立Socket服务
DatagramSocket ds = new DatagramSocket();

//从键盘获取数据
BufferedReader br = new Buf
4000
feredReader(new InputStreamReader(System.in));

//依次获取键盘输入的数据，并将其打包进行发送
String st = null;

//依次获取数据，但遇到某个关键字时则程序自行结束
while((st = br.readLine()) != null){

//如果输入这个关键字则程序关闭
if("over".equals(st)){
break;

}

//如果不是，则进行数据数据的打包
byte[] by = st.getBytes();

//使用DatagramPacket进行数据的发送
DatagramPacket dp = new DatagramPacket(by, by.length, InetAddress.getByName("192.168.1.240"),10001);

ds.send(dp);
}
ds.close();

}

}

（2）

package earth;

import java.net.*;

public class Net05 {

public static void main(String[] args) throws Exception{

//此程序是为了实现数据的接收功能,同时监听，某个接口
DatagramSocket ds = new DatagramSocket(10001);

//同过使用while循环来进行数据的依次接收
while(true){

//创建数据的存储空间来实现对接收的数据先进行存储
byte[] by = new byte[1024];

//使用DatagramPacket（byte[] buf, int length）来接收长度length的数据包
DatagramPacket dp = new DatagramPacket(by, by.length);

//用receive来接收数据
ds.receive(dp);

//对接收的数据进行解析
String ip = dp.getAddress().getHostAddress();
//获取主机的IP的地址
String pc = new String(dp.getData(), 0, dp.getLength());
//截取有效的数据，并将强制转换成String类型的数据

//将数据输出
System.out.println("ip:" + ip);
System.out.println("pc" + pc);

}

}

}

19.Runable;使用实现接口Runable的对象创建按一个线程时，启动该线程将导致在独立执行的线程中
调用对象的Run的无参方法。

20.示例代码：

package earth;

import java.net.*;

import java.io.*;

public class Net06 {

public static void main(String[] args) throws Exception{
DatagramSocket senSocket = new DatagramSocket();
DatagramSocket receSocket = new DatagramSocket(10002);

//建立线程
new Thread(new Send01(senSocket)).start();
new Thread(new Rece(receSocket)).start();

}

}

//发送端

//创建一个发送的端口

class Send01 implements Runnable{

//创建一个变量
private DatagramSocket ds;

public Send01(DatagramSocket ds){
this.ds = ds;

}

public void run(){

//需要对程序进行抛出异常
try{

//监听键盘输入
BufferedReader br =  new BufferedReader(new InputStreamReader(System.in));

String st = null;
while((st = br.readLine()) != null){

//设置某个关键字来完成程序的关闭
if("over".equals(st)){
break;

}

//如果为出现关键字则数据发送继续
byte[] by = st.getBytes();
//使用DatagramPacket来进行数据的发送
DatagramPacket dp = new DatagramPacket(by, by.length, InetAddress.getByName("192.168.1.240"),10002);

ds.send(dp);
}
}catch(Exception e){
throw new RuntimeException("数据端发送失败");
}
}

}

//接收端

class Rece implements Runnable{
private DatagramSocket ds;

public Rece(DatagramSocket ds){
this.ds = ds;

}

//run方法
public void run(){

//抛出异常
try{

while(true){
byte[] by = new byte[1024];
DatagramPacket dp = new DatagramPacket(by, by.length);

//用Receive接收
ds.receive(dp);

String ip = dp.getAddress().getHostAddress();
String pc = new String(dp.getData(), 0, dp.getLength());
System.out.println("ip:" + ip);
System.out.println("pc:" + pc);
}
}catch(Exception e){
throw new RuntimeException("接收端失败");
}
}

}

Tcp传输：

21：Socket:此类实现客户端套接字

22.ServerSocket：此类实现服务器套接字，服务器套接字等待请求通过网络传入，它基于该请求某些
操作，然后可能向请求者返回结果。

23.服务端：
（1）建立服务端的Socket服务，ServerSocket（）并监听一个端口
（2）获取链接过来的客户端对象，通过ServerSocket的accept方法，并没有链接就会等，所以
这个方法阻塞式的。
（3）客户端如果发过来的数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象
的读取流来读取发过来的数据，并打印在控制台上。

24.示例代码：

package earth;

import java.net.*;

import java.io.*;

public class Tcp_basic_01 {

public static void main(String[] args) throws Exception{

//创建Socket服务的客户端，并制定目的地和端口
Socket sk = new Socket("192.168.1.240", 10001);

//为了发送数据，应该获取Socket流输出的流
OutputStream os = sk.getOutputStream();

os.write("你真贱，哈哈".getBytes());

sk.close();

}

}

class Tcp_basic_02{

public static void main(String[] args) throws Exception{

//建立服务端Socket，并监听一个端口
ServerSocket sk = new ServerSocket(10001);

//通过accept获取链接过来的客户端对象
Socket s = sk.accept();

String ip = s.getInetAddress().getHostAddress();
System.out.println(ip);

//获取客户端发送的数据，要使用客户端读取流来读取数据
InputStream is = s.getInputStream();
byte[] by = new byte[1024];
int len = is.read(by);

System.out.println(new String(by, 0, len));

s.close();
sk.close();

}

}

25.客户端：
（1）建立Socket服务，指定要链接主机和端口。
（2）获取Socket流中的输出流，将数据写到该流中，通过网络发送给服务端。
（3）获取Socket流中的输出流，将服务端反馈的数据获取到，并打印。
（4）关闭客户端。

26.实现客户端与服务端的数据交互（代码示例）：

package earth;

import java.net.*;

import java.io.*;

//客户端

public class Tcp_basic_03 {

public static void main(String[] args) throws Exception{

/**实现数据接收端与服务器之间的数据之间的相互交流*/

//创建一个Socket服务，并定制目的地和端口
Socket sk = new Socket("192.168.1.240", 10002);
//为了 发送数据，应该使用socket流
OutputStream os = sk.getOutputStream();
//写一个数据
os.write("this is ben,who are you".getBytes());

//实现数据的接收
InputStream is = sk.getInputStream();

//创建一个字节数组
byte[] by = new byte[1024];
int len = is.read(by);
System.out.println(new String(by, 0, len));

sk.close();
//关闭服务

}

}

//服务端

class Tcp_basic_04{

public static void main(String[] args) throws Exception{
//监听某个端口
ServerSocket ss = new ServerSocket(10002);
//接收数据
Socket s = ss.accept();

//获取发送端的信息
String ip = s.getInetAddress().getHostAddress();
System.out.println(ip);
//将获取的信息打印出来

//接收数据流
InputStream is = s.getInputStream();
byte[] by = new byte[1024];
int len = is.read(by);
System.out.println(new String(by, 0, len));

//进行数据反馈
OutputStream os = s.getOutputStream();
os.write("my name is hihi".getBytes());
//发布字节流数据

s.close();
ss.close();

}

}

27.将输入的字母转化成大写（示例代码）：

package earth;

import java.net.*;

import java.io.*;

//客户端

public class Tcp_basic_05 {

public static void main(String[] args) throws Exception{

//创建socket服务
Socket sk = new Socket("192.168.1.240", 10002);
//是指目标和端口号

//定义读取键盘流对象
BufferedReader brin = new BufferedReader(new InputStreamReader(System.in));

//将数据写到socket输出流中，发给服务端
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(sk.getOutputStream()));

//定义一个socket读取流，接收服务端返回的信息
BufferedReader brout = new BufferedReader(new InputStreamReader(sk.getInputStream()));

//实现对键盘输入数据的不端读取
String st = null;
while((st = brin.readLine()) != null){

//出现某个关键字后对程序进行关闭
if("over".equals(st)){
break;

}
bw.write(st);
bw.newLine();
//出现回车时则进行数据的传输
bw.flush();
//刷新缓存中的数据，并将数据输出

String st1 = brout.readLine();
//对返回的数据进行读取
System.out.println(st1);
}
brin.close();
//关闭键盘录入程序
sk.close();
//关闭socket服务程序

}

}

//服务端

class Tcp_basic_06{
public static void main(String[] args)
throws Exception{

//对某一端口进行监听
ServerSocket ss = new ServerSocket(10002);

//对数据端进行原始数据的接收
Socket s = ss.accept();
//对数据来源的机器信息进行解析
String ip= ss.getInetAddress().getHostAddress();
System.out.println(ip);  
//对解析后的信息进行显示

//读取socket流中的数据
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));

//将转化的好的大写数据通过是socket服务，转发到客户端
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

//对获取的数据进行不断读取并将数据进行加工
String st = null;
while((st = br.readLine()) != null){

//对获取的数据进行加工
bw.write(st.toUpperCase());
bw.newLine();
bw.flush();

}
s.close();
ss.close();

}

}

28.printWriter:向文本输出流打印对象的格式化显示形式。

29.System .currentTimeMillis():数据类型是long,作用为返回以毫秒为单位的当前时间。

30.文件信息的传输（示例代码）：

package earth;

import java.io.*;

import java.net.*;

//客户端

class Tusclen {

public static void main(String[] args) throws Exception{

//建立socket服务，定义目标和端口号
Socket sk = new Socket("192.168.1.240", 10001);

//读取数据
BufferedReader br = new BufferedReader(new FileReader("ok04.txt"));

//使用printWriter来实现文件的传输，并通过socket来实现文件的传输
PrintWriter pw = new PrintWriter(sk.getOutputStream(), true);

//开始对文件数据进行读取来进行发送
String st = null;
while((st = br.readLine()) != null){

//获取数据后发送数据给服务端
pw.write(st);
}

sk.shutdownOutput();
//文件在传输完成后关闭数据

//获取从服务端的信息反馈
BufferedReader brd = new BufferedReader(new InputStreamReader(sk.getInputStream()));

String str = brd.readLine();
//对犯规信息进行读取
System.out.println(str);
//将获取的反馈信息进行输出

br.close();
sk.close();

}

}

//服务端

class Server_side{

public static void main(String[] args) throws Exception{

//对端口进行监听
ServerSocket ss = new ServerSocket(10001);

Socket sk = ss.accept();
//解析来自客户端的信息
String ip = sk.getInetAddress().getHostAddress();
System.out.println("ip" + ip);

//从字符输出流读取文本
BufferedReader bur = new BufferedReader(new InputStreamReader(sk.getInputStream()));
PrintWriter pr = new PrintWriter(new FileWriter("ok05.txt"), true);
//将获取的数据写入一个文件中

//开始向文件中写入数据
String st = null;
while((st = bur.readLine()) != null){

pr.print(st);

}

//完成数据的读写后给客户端反馈信息
PrintWriter pw = new PrintWriter(sk.getOutputStream(), true);
pw.print("传输成功");

sk.close();
ss.close();

}
}

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------