1.基础知识：
- 网络编程：
在两台不同的计算机之间传递数据 - 客户端：手机app 浏览器 qq
服务器端：存储/处理数据的地方 - UPR：统一的资源定位
- http：//www.baidu.com/search？code=android&type=1
http/https:传输协议Tcp/Ip
www.baidu.com ：域名 表示一台网络中的电脑
ipv4 ipv6 地址：唯一标识一台网络中的计算机
32位 4个部分每个都是8个字节
172.20.10.15<->www.baidu.com
DNS服务器：域名解析
将www.baidu.com类型的域名解析位对应的ip地址
search对应的后台程序文件 php java jsp
？表示运行这个程序需要传递的参数
dode=android code是服务器端规定的手段
&如果有多个参数用这个符号链接 - ip地址：唯一标识某一台电脑
端口号：唯一标识电脑上的某一个进程（程序）80 - 数据传输：TCP/IP协议
TCP:面向链接的 不安全 打电话
UOP;面向无连接的 不安全 但是快 飞鸽传书 - 网络中的数据传输：Socket实现->套接字
Socket类：客户端
ServerSocket：服务器端 - 读取数据：服务器读取 客户端读取
BufferedReader->InputStreamReader->socket.getInputStream();
读取终端
BufferedReader->InputStream->System.in
输出： 客户端输出 服务器端输出
BufferedWriter->OutputStreamWriter->socket.getOutputStream();
PrintStream->socket.getOutputStream(); - Socket是什么呢？
Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。
image.png
10.
InputStreamReader()方法是字节流通向字符流的桥梁，它使用指定的 charset读取字节并将其解码为字符。
OutputStreamWriter 将字符流转换为字节流。是字符流通向字节流的桥梁
11. 输入流： getInputStream()
输出流：getOutputStream()
注意：输入输出是针对当前的来说
2.利用Socket实现客户端与服务端的固定通信
1.模拟客户端
class Client{
public static void main(String[]args) throws IOException {
//1.创建用于通信的socket
//指明和谁通信：ip地址 端口号
Socket socket=new Socket("10.129.16.206",18);
//接受服务器端的数据
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//socket.getInputStream();
String line=null;
while ((line=br.readLine()) !=null){
System.out.println(line);
}
//向服务端发送数据
PrintStream ps=new PrintStream(socket.getOutputStream());
ps.println("你好啊1111");
socket.shutdownOutput();
}
}
2.模拟服务器端
class Server{
public static void main(String[]args) throws IOException {
//1.创建服务器端的ServerSocket
ServerSocket ss=new ServerSocket(18);
//2.获取连接客户端的socket
Socket clientSocket=ss.accept();
//3.向客服端发送数据
// BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
PrintStream ps=new PrintStream(clientSocket.getOutputStream());
ps.println("登陆成功");
//输出完毕
clientSocket.shutdownOutput();
//4.接收发来的数据
BufferedReader br=new BufferedReader( new InputStreamReader(clientSocket.getInputStream()));
String line=null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
}
}
3.实现从终端输入到服务端再单向传递给客户端
1.客户端
class MyClient{
public static void main(String[]args){
//连接服务器端的socket
Socket socket=null;
try {
socket =new Socket("10.129.16.206",123);
//接收服务器端信息
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line=null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
//从键盘输入数据 发送给服务器端
} catch (IOException e) {
System.out.println("网络出错，请重新登录");
}finally {
//关闭连接
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.服务端
class MyServer{
public static void main(String[]args){
//创建ServerSocket
try(ServerSocket ss=new ServerSocket(123)){
//监听客户端
Socket socket=ss.accept();
//从终端接收数据
BufferedReader keyin= new BufferedReader(new InputStreamReader(System.in));
//获取向客户端输出数据的输出流
PrintStream ps=new PrintStream(socket.getOutputStream());
String line=null;
while ((line=keyin.readLine())!=null){
//发送给客户端
ps.println(line);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
}
}
}
4.实现将文件的内容通过客户端传给服务端 服务端再保存在自己文件里
1.提示：BufferedInputStream是带缓冲区的输入流，默认缓冲区大小是8M，能够减少访问磁盘的次数，提高文件读取性能；BufferedOutputStream是带缓冲区的输出流，能够提高文件的写入效率。
2.提示：FileInputStream从本地文件读取数据，FileOutputStream把数据写入本地文件。
3.客户端：
class Client1{
public static void main(String[] args) throws IOException {
//连接服务器 获取socket
Socket socket = new Socket("10.129.16.206",123);
//创建服务器端对应的输入流 用于接收服务器端发来的数据
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(br.readLine());
//向服务器端发送文件（图片)
//1.将文件写入到内存里
String path = "C:\\Users\\Day\\Desktop\\word\\3.jpg";
FileInputStream fis = new FileInputStream(path);
//2.创建字节流 outputStream
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
byte[] buf = new byte[1024];
int len = -1;
while ((len = fis.read(buf)) != -1){
bos.write(buf,0,len);
}
socket.shutdownOutput();
}
}
4.服务端
class Server1{
public static void main(String[] args) throws IOException {
//创建服务器端的ServerSoket
ServerSocket ss = new ServerSocket(123);
//监听客户端连接
//当有客户端来连接这个服务器 就可以得到对应的socket
//当没有客户端来连接 服务器一直在这里等待
Socket socket = ss.accept();
//创建客户端对应的输出流 用于向这个客户端发送数据
PrintStream ps = new PrintStream(socket.getOutputStream());
ps.println("连接成功 可以发数据了");
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
String path = "C:\\Users\\Day\\Desktop\\word\\4.jpg";
FileOutputStream fos = new FileOutputStream(path);
byte[] buf = new byte[1024];
int len = -1;
while((len = bis.read(buf)) != -1){
fos.write(buf,0,len);
}
}
}
5.通过多线程实现客户端与服务端之间的动态数据互通
1.提示：客户端：
主线程： 接受终端输入 将终端输入发送给服务器端
子线程： 接受服务器端发过来的数据
服务器端：
主线程： 接受终端输入 将终端输入发送给客户端
子线程：接受客户端发过来的数据
2.客户端主线程：
class Client{
public static void main(String[]args) throws IOException {
Socket socket=new Socket("10.129.16.206",8848);
//用一个子线程处理服务端数据
new Thread(new ClientThread(socket)).start();
//主线程处理终端输入发送给服务器端
BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
PrintStream ps=new PrintStream(socket.getOutputStream());
String line=null;
while ((line=keyin.readLine())!=null){
ps.println(line);
}
}
}
3.利用Runnable接口创建一个子线程处理客户端接受服务端的数据
class ClientThread implements Runnable{
private Socket socket;
//保存操作的socket对象
public ClientThread(Socket socket){
this.socket=socket;
}
@Override
public void run() {
BufferedReader br=null;
try {
br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line=null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("网络异常，请重新登录");
System.exit(-1);
}finally {
//关闭输入输出流
//关闭对应的socket连接
try {
if(br!=null) {
br.close();
}
if(socket!=null){
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.服务端主线程
class Server{
public static void main(String[]args) throws IOException {
ServerSocket ss=new ServerSocket(8848);
//获取客户端的socket
Socket socket =ss.accept();
//创建子线程 处理客户端输入信息
new ServerThread(socket).start();
//终端输入流对象
BufferedReader keyin=new BufferedReader( new InputStreamReader(System.in));
//向客户端的输出流对象
PrintStream ps=new PrintStream(socket.getOutputStream());
//读取终端的输入 将终端输出给客户端
String line=null;
while ((line=keyin.readLine())!=null){
ps.println(line);
}
}
}
5.通过继承Thread来创建一个子线程处理客户端给服务端的数据
class ServerThread extends Thread{
private Socket socket;
public ServerThread(Socket socket){
this.socket=socket;
}
@Override
public void run() {
BufferedReader br=null;
try {
br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line=null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("网络异常，请重新登录");
System.exit(-1);
}finally {
//关闭输入输出流
//关闭对应的socket连接
try {
if(br!=null) {
br.close();
}
if(socket!=null){
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
6.实现在通过服务端在客户端里面显示所有客户端输入的动态信息
1.服务端：
在服务器端维护一个数组Socket
class Server{
//保存每一个连接过来的socket对象
public static ArrayListsockets=new ArrayList<>();
public static void main(String[]args) throws IOException {
ServerSocket ss=new ServerSocket(6666);
//不停地等待客户端连接
while (true){
Socket socket=ss.accept();
//当有客户端连接过来了 就保存
sockets.add(socket);
//开启一个子线程处理每个客户端的输入
new ServerThread(socket).start();
}
}
}
2.创建服务端的子线程
class ServerThread extends Thread{
private Socket socket;
public ServerThread(Socket socket){
this.socket=socket;
}
@Override
public void run() {
BufferedReader br=null;
try {
br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line=null;
while ((line=br.readLine())!=null){
//群发消息
//遍历Server维护的数组
for(Socket s:Server.sockets){
//向socket对应的客户端 发送消息
PrintStream ps=new PrintStream(s.getOutputStream());
ps.println(line);
}
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("网络异常，请重新登录");
System.exit(-1);
}finally {
//关闭输入输出流
//关闭对应的socket连接
try {
if(br!=null) {
br.close();
}
if(socket!=null){
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.客户端
class Client{
public static void main(String[]args) throws IOException {
Socket socket=new Socket("10.129.16.206",6666);
//用一个子线程处理服务端数据
new Thread(new ClientThread(socket)).start();
//主线程处理终端输入发送给服务器端
BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
PrintStream ps=new PrintStream(socket.getOutputStream());
String line=null;
while ((line=keyin.readLine())!=null){
ps.println(line);
}
}
}
4.创建一个子线程处理客户端接受服务端的数据
class ClientThread implements Runnable{
private Socket socket;
//保存操作的socket对象
public ClientThread(Socket socket){
this.socket=socket;
}
@Override
public void run() {
BufferedReader br=null;
try {
br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line=null;
while ((line=br.readLine())!=null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("网络异常，请重新登录");
System.exit(-1);
}finally {
//关闭输入输出流
//关闭对应的socket连接
try {
if(br!=null) {
br.close();
}
if(socket!=null){
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
7.心得体会
今天的网络学习起初被那些 输入输出流等杂乱的知识搞懵逼了 后面下来查查理解得还可以，再回头看看今天上课写的这么多demo，感觉理解得还是 比较好，网络这一块的重要性也有一定的认知，所以还是得好好学学牢固，明后天继续加油