重学java基础----网络编程

企业开发 2023-04-06 23:36:30 阅读次数: 0

参考于韩顺平老师JAVA基础课程以及笔记

网络相关概念

  • 网络通信
    在这里插入图片描述

  • 网络
    在这里插入图片描述

  • ip地址
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述

  • 域名
    在这里插入图片描述
    在这里插入图片描述

  • 网络通信协议
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

InetAddress类

  • 介绍
    在这里插入图片描述
    在这里插入图片描述
  • 示例代码
package com.file.network;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-14:22
 */
public class ineraddress_ {
    
    
    public static void main(String[] args) throws UnknownHostException {
    
    
        //获取本机InetAddress对象 getLocalHost
        InetAddress localhost=InetAddress.getLocalHost();
        System.out.println(localhost);

        //根据指定主机名/域名获取ip地址对象 getByName
        InetAddress host2=InetAddress.getByName("DESKTOP-TKLC0PE");
        System.out.println(host2);
        InetAddress host3 = InetAddress.getByName("www.baidu.com");
        System.out.println(host3);

        //获取InetAddress对象的主机名 gethostname
        String hostName = host3.getHostName();
        System.out.println(hostName);

        获取InetAddress对象的地址 getHostAddress
        String hostAddress = host2.getHostAddress();
        System.out.println(hostAddress);


        //

    }
}

在这里插入图片描述

Socket

  • 介绍
    在这里插入图片描述
    在这里插入图片描述

  • 网络通信编程
    在这里插入图片描述
    在这里插入图片描述

  • 应用案例1----使用字节流
    在这里插入图片描述

在这里插入图片描述

扫描二维码关注公众号，回复： 14613876 查看本文章 
 package com.file.socket;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-15:01
 * 服务端代码
 *
 */
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.file.network;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-15:03
 * 客户端代码
 */
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("客户端退出。。。。");

    }
}

在这里插入图片描述

  • 应用案例2----使用字节流
    在这里插入图片描述
    在这里插入图片描述

注意：加结束标记，否则客户端和服务器都处于停止状态

package com.file.socket;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-15:01
 *服务端代码
 */
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相关的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());
        //设置结束标记，否则一直处于监听状态
        socket.shutdownOutput();

        //5.关闭流和 socket
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();//关闭
    }
}

package com.file.network;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-15:03
 * 客户端代码
 */
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());
        //设置结束标记
        socket.shutdownOutput();

        //4.获取和socket相关的输入流，读取字节，显示
        InputStream inputStream = socket.getInputStream();
        int readLen=0;
        byte[]buf=new byte[1024];
        while ((readLen=inputStream.read(buf))!=-1){
    
    
            System.out.println(new String(buf,0,readLen));
        }
        //5. 关闭流对象和 socket, 必须关闭
        outputStream.close();
        inputStream.close();
        socket.close();
        System.out.println("客户端退出。。。。");

    }
}
  • 应用案例----使用字符流
    在这里插入图片描述

注意： bufferedWriter.newLine();//插入一个换行符，表示写入内容结束，注意：要求对方必须使用readline(),与结束标记相同
bufferedWriter.flush(); //注意需要手动的flush，否则程序会停止，且数据不会写入到数据通道

package com.file.socket;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-15:01
 * 服务端
 *
 */
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 读取
        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,cliect");
        bufferedWriter.newLine(); //插入一个换行符，表示回复内容的结束
        bufferedWriter.flush(); //注意需要手动的flush

        //5.关闭流和 socket
        bufferedWriter.close();
        bufferedReader.close();
        outputStream.close();
        inputStream.close();
        socket.close();
        serverSocket.close();//关闭
    }
}

package com.file.network;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.BrokenBarrierException;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-15:03
 */
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.//3. 通过输出流，写入数据到 数据通道,使用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server");
        bufferedWriter.newLine();//插入一个换行符，表示写入内容结束，注意：要求对方必须使用readline(),与结束标记相同
        bufferedWriter.flush();



        //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();
        bufferedWriter.close();
        socket.close();
        System.out.println("客户端退出。。。。");

    }
}
  • 应用案例4----上传文件
    在这里插入图片描述
    在这里插入图片描述
package com.file.upload;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-16:19
 */
public class StreamUtils {
    
    
    /**
     * 功能：将输入流转换成 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);
        }
        byte[] array = bos.toByteArray();
        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){
    
     //当读取到 null 时，就表示结束
            builder.append(line+"\r\n");
        }
        return builder.toString();
    }
}

package com.file.upload;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-16:04
 *
 * 文件上传的服务器
 */
public class TcpUploadFileServer {
    
    
    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 destPath="src\\app.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destPath));

        bos.write(bytes);
        bos.close();

        //向客户端回复"收到图片"
        //通过soket获取字符输出流
        BufferedWriter w = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        w.write("收到图片");
        w.flush();//将内容刷新到数据通道
        socket.shutdownOutput();//设置写入结束标记



        //关闭流
        w.close();
        bis.close();
        socket.close();
        serverSocket.close();


    }
}

package com.file.upload;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.text.Bidi;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-16:05
 */
public class TcpUploadFileClient {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //客户端连接服务器对象8888，获取socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);

        //创建读取磁盘文件的输入流
        String filePath="D:\\111.jpg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));

        //获取filepath对应的字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //通过socket获取输出流，将bytes数据发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件对应的字节数组内容，写入到数据通道

        bos.flush(); //刷新内容，真正写入到磁盘
        bis.close();//关闭字节输入流
        socket.shutdownOutput();//设置结束标志

        //接受服务端回复的信息,创建socket相关的输入流
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils方法，将inputstream读取的内容转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);


        //关闭流
        inputStream.close();
        bos.close();
        socket.close();



    }
}

netstat命令

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

UDP网络编程

  • 介绍
    在这里插入图片描述
    在这里插入图片描述
  • 案例
    在这里插入图片描述
    在这里插入图片描述
package com.file.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-17:10
 * 接收端
 */
public class udpReciverA {
    
    
    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端口时，就会接受到数据
        //否则，就会一直阻塞等待
        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端=====
        //5.将需要发送的数据，封装到DatagramPacket对象
        byte[] bufdata ="你好，B端".getBytes();
        DatagramPacket packet1 = new DatagramPacket(bufdata, bufdata.length, InetAddress.getByName("192.168.0.125"), 9998);
        socket.send(packet1);

        //关闭资源
        socket.close();
        System.out.println("A端退出。。。");

    }
}

package com.file.udp;

import java.io.IOException;
import java.net.*;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-17:10
 * 发送端
 */
public class udpSendB {
    
    
    public static void main(String[] args) throws IOException {
    
    
        //1.创建一个 DatagramSocket对象，准备在9998接受数据
        DatagramSocket socket =new DatagramSocket(9998);

        //2. 将需要发送的数据，封装到 DatagramPacket 对象
        byte[]data="你好，A端".getBytes();

        //3. 封装的 DatagramPacket 对象 data 内容字节数组 , data.length , 主机(IP) , 端口
        DatagramPacket packet=new DatagramPacket(data,data.length, InetAddress.getByName("192.168.0.125"),9999);

        //4.发送数据
        socket.send(packet);

        //5.=====接受A端的数据=======
        //1.创建一个DatagramPacket对象，准备接受数据
        // udp协议数据包最大为64k
        byte[] buf =new byte[1024];
        packet = new DatagramPacket(buf,buf.length);

        //2.调用 接受方法，将通过网络传输的DatagramPacket 对象
        // 填充的packet对象

        //当有数据包发送到本机的9999端口时，就会接受到数据
        //否则，就会一直阻塞等待
        socket.receive(packet);

        //3.可以把packet进行拆包，取出数据，并显示
        int length = packet.getLength();//实际接收到的数据字节长度
        data = packet.getData();//接收到的数据
        String s=new String(data,0,length);
        System.out.println(s);


        //5.关闭资源
        socket.close();
        System.out.println("B端退出。。。。");


    }
}

作业

在这里插入图片描述

package com.file.upload;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-17:56
 */
public class homeworkclient {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //1.接受用户输入，指定下载文件
        Scanner scanner =new Scanner(System.in);
        System.out.println("请输入下载文件名");
        String downLoadFileName = scanner.next();

        //2.客户端连接服务器，准备发送数据
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);

        //3.获取socket关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(downLoadFileName.getBytes());
        socket.shutdownOutput();//结束标志

        //4.读取服务器返回的字节数据
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //5.使用工具类
        byte[] bytes = StreamUtils.streamToByteArray(bis);

        //6.得到输出流，写入磁盘
        String fileName="D:\\"+downLoadFileName+".jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileName));
        bos.write(bytes);

        //7.关闭资源
        bos.close();
        bis.close();
        outputStream.close();
        socket.close();

        System.out.println("客户端退出。。。。");

    }
}

package com.file.upload;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-17:56
 */
public class homeworkserver {
    
    
    public static void main(String[] args) throws Exception {
    
    
        //1.监听9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端在9999端口监听，等待用户下载数据。。。。");
        //2.等待客户端连接
        Socket socket= serverSocket.accept();
        //3.读取客户端下载的文件名
        InputStream inputStream = socket.getInputStream();
        String s = StreamUtils.streamToString(inputStream);
        System.out.println("客户端要下载的文件名为:"+s);

        //4.服务器上有app.jpg和a.jpg，客户端下载a.jpg，否则，一律返回app.jpg

        String resFileName="";
        if("b".equals(s)){
    
    
            resFileName="src\\app.jpg";
        }else {
    
    
            resFileName="src\\a.jpg";
        }
        //4.创建一个输入流，读取文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(resFileName));
        //5.使用工具类，获取字节数组
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //6.获取socket关联的字节输出流
        OutputStream outputStream = socket.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(outputStream);
        //7.写入数据，返回给客户端
        bos.write(bytes);
        bos.flush();
        //结束标记
        socket.shutdownOutput();

        //8.关闭资源
        bis.close();
        inputStream.close();
        bos.close();
        socket.close();
        serverSocket.close();
        System.out.println("服务端退出");


    }
}

package com.file.upload;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * @Description
 * @autor wzl
 * @date 2022/8/18-16:19
 */
public class StreamUtils {
    
    
    /**
     * 功能：将输入流转换成 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);
        }
        byte[] array = bos.toByteArray();
        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){
    
     //当读取到 null 时，就表示结束
            builder.append(line+"\r\n");
        }
        return builder.toString();
    }
}

猜你喜欢

转载自blog.csdn.net/qq_38716929/article/details/126401659
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022