java的文件操作

news2024/11/7 10:34:08

Path、Paths 和 Files 是 Java NIO（New I/O）文件处理系统中的核心组件，它们提供了比传统 java.io.File 更加灵活和高效的文件操作方式。

  1. 概述
    随着 Java 7 引入 NIO.2（即 Java New I/O 2），文件处理得到了显著改进。Path、Paths 和 Files 是 NIO.2 中用于文件和目录操作的三个关键组件：

Path：表示文件系统中的路径，类似于传统的 java.io.File，但更加灵活和功能丰富。
Paths：一个工具类，提供静态方法用于创建 Path 实例。
Files：一个实用工具类，提供了大量静态方法用于执行文件和目录的各种操作，如创建、删除、复制、移动、读取和写入等。
相比传统的 File 类，NIO.2 提供了更好的错误处理、更丰富的功能以及对不同文件系统的支持。

  1. Path 接口
    概述
    Path 是一个接口，位于 java.nio.file 包中，用于表示文件系统中的路径。它提供了一种平台无关的方式来表示文件和目录的路径，并支持丰富的路径操作。

主要功能和方法
以下是 Path 接口的一些关键方法和功能：

路径创建与解析
Path resolve(String other)：将给定的路径字符串解析为当前路径的子路径。
Path resolve(Path other)：将给定的 Path 解析为当前路径的子路径。
Path relativize(Path other)：计算从当前路径到给定路径的相对路径。
路径信息
String getFileName()：返回路径中的文件名部分。
Path getParent()：返回路径的父路径。
Path getRoot()：返回路径的根组件。
int getNameCount()：返回路径中的名称元素数。
Path getName(int index)：返回指定索引的名称元素。
路径转换
Path toAbsolutePath()：将相对路径转换为绝对路径。
Path normalize()：规范化路径，去除冗余的名称元素，如 “.” 和 “…”。
路径比较
boolean startsWith(String other)：判断路径是否以给定的路径字符串开头。
boolean endsWith(String other)：判断路径是否以给定的路径字符串结尾。
boolean equals(Object other)：判断两个路径是否相等。
其他方法
Iterator iterator()：返回一个迭代器，用于遍历路径中的名称元素。
String toString()：返回路径的字符串表示。
String toAbsolutePath().toString()：返回绝对路径的字符串表示。
示例代码
import java.nio.file.Path;
import java.nio.file.Paths;

public class PathExample {
public static void main(String[] args) {
// 创建 Path 实例
Path path = Paths.get(“src”, “main”, “java”, “Example.java”);

    // 获取文件名
    System.out.println("文件名: " + path.getFileName());
    
    // 获取父路径
    System.out.println("父路径: " + path.getParent());
    
    // 获取根路径
    System.out.println("根路径: " + path.getRoot());
    
    // 规范化路径
    Path normalizedPath = path.normalize();
    System.out.println("规范化路径: " + normalizedPath);
    
    // 转换为绝对路径
    Path absolutePath = path.toAbsolutePath();
    System.out.println("绝对路径: " + absolutePath);
    
    // 解析子路径
    Path resolvedPath = path.resolve("subdir/File.txt");
    System.out.println("解析后的路径: " + resolvedPath);
    
    // 计算相对路径
    Path basePath = Paths.get("src/main");
    Path relativePath = basePath.relativize(path);
    System.out.println("相对路径: " + relativePath);
    
    // 遍历路径中的元素
    System.out.println("路径元素:");
    for (Path element : path) {
        System.out.println(element);
    }
}

}
输出示例：

文件名: Example.java
父路径: src/main/java
根路径: null
规范化路径: src/main/java/Example.java
绝对路径: /Users/username/project/src/main/java/Example.java
解析后的路径: src/main/java/Example.java/subdir/File.txt
相对路径: java/Example.java
路径元素:
src
main
java
Example.java
3. Paths 类
概述
Paths 是一个最终类，位于 java.nio.file 包中，提供了静态方法用于创建 Path 实例。它简化了 Path 对象的创建过程，使代码更加简洁和易读。

创建 Path 实例
import java.nio.file.Path;
import java.nio.file.Paths;
import java.net.URI;

public class PathsExample {
public static void main(String[] args) {
// 使用多个字符串片段创建路径
Path path1 = Paths.get(“C:”, “Users”, “Public”, “Documents”);
System.out.println("路径1: " + path1);

    // 使用单个字符串创建路径
    Path path2 = Paths.get("/home/user/docs");
    System.out.println("路径2: " + path2);
    
    // 使用相对路径创建路径
    Path path3 = Paths.get("src/main/java/Example.java");
    System.out.println("路径3: " + path3);
      
    // 组合路径片段
    Path basePath = Paths.get("/home/user");
    Path combinedPath = basePath.resolve("downloads/music");
    System.out.println("组合后的路径: " + combinedPath);
}

}
输出示例：

路径1: C:\Users\Public\Documents
路径2: /home/user/docs
路径3: src/main/java/Example.java
组合后的路径: /home/user/downloads/music
注意事项
Paths.get(…) 方法会根据操作系统自动处理路径分隔符，无需手动指定。例如，在 Windows 上会使用 \，在 Unix/Linux 上会使用 /。
4. Files 类
概述
Files 是一个最终类，位于 java.nio.file 包中，提供了大量的静态方法用于执行文件和目录的各种操作。它与 Path 接口紧密集成，提供了比 java.io.File 更加丰富和高效的功能。

主要功能和方法
Files 类的方法可以大致分为以下几类：

文件和目录的创建
文件和目录的删除
文件和目录的复制与移动
文件内容的读取与写入
文件属性的获取与修改
目录的遍历和查找

  1. 文件和目录的创建
    static Path createFile(Path path, FileAttribute<?>... attrs)：创建一个新文件。 static Path createDirectory(Path dir, FileAttribute<?>… attrs)：创建一个新目录。
    static Path createDirectories(Path dir, FileAttribute<?>… attrs)：递归地创建目录，包括不存在的父目录。
  2. 文件和目录的删除
    static void delete(Path path)：删除指定的文件或目录。如果路径是目录，则目录必须为空。
    static boolean deleteIfExists(Path path)：删除指定的文件或目录，如果存在的话。
  3. 文件和目录的复制与移动
    static Path copy(Path source, Path target, CopyOption… options)：复制文件或目录。
    static Path move(Path source, Path target, CopyOption… options)：移动或重命名文件或目录。
  4. 文件内容的读取与写入
    static byte[] readAllBytes(Path path)：读取文件的所有字节。
    static List readAllLines(Path path, Charset cs)：按行读取文件内容。
    static Path write(Path path, byte[] bytes, OpenOption… options)：将字节数组写入文件。
    static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption… options)：将行写入文件。
  5. 文件属性的获取与修改
    static boolean exists(Path path, LinkOption… options)：检查路径是否存在。
    static boolean isDirectory(Path path, LinkOption… options)：判断路径是否是目录。
    static boolean isRegularFile(Path path, LinkOption… options)：判断路径是否是常规文件。
    static long size(Path path)：获取文件的大小（以字节为单位）。
    static FileTime getLastModifiedTime(Path path, LinkOption… options)：获取文件的最后修改时间。
    static Path setLastModifiedTime(Path path, FileTime time)：设置文件的最后修改时间。
  6. 目录的遍历和查找
    static DirectoryStream newDirectoryStream(Path dir, DirectoryStream.Filter<? super Path> filter)：打开一个目录流，遍历目录中的文件和子目录。
    static Stream walk(Path start, FileVisitOption… options)：递归地遍历目录树。
    static Stream list(Path dir)：列出目录中的内容，不进行递归。
    示例代码
    以下是一些常见的 Files 类方法的示例：

创建文件和目录
import java.nio.file.*;
import java.io.IOException;

public class FilesCreateExample {
public static void main(String[] args) {
Path directory = Paths.get(“exampleDir”);
Path file = directory.resolve(“exampleFile.txt”);

    try {
        // 创建目录
        if (!Files.exists(directory)) {
            Files.createDirectory(directory);
            System.out.println("目录已创建: " + directory);
        }
        
        // 创建文件
        if (!Files.exists(file)) {
            Files.createFile(file);
            System.out.println("文件已创建: " + file);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
写入和读取文件内容
import java.nio.file.*;
import java.io.IOException;
import java.util.List;

public class FilesReadWriteExample {
public static void main(String[] args) {
Path file = Paths.get(“exampleDir/exampleFile.txt”);

    // 写入字节数组到文件
    String content = "Hello, Java NIO!";
    try {
        Files.write(file, content.getBytes(), StandardOpenOption.WRITE);
        System.out.println("数据已写入文件");
    } catch (IOException e) {
        e.printStackTrace();
    }
    
    // 读取所有字节
    try {
        byte[] data = Files.readAllBytes(file);
        System.out.println("文件内容 (字节): " + new String(data));
    } catch (IOException e) {
        e.printStackTrace();
    }
    
    // 按行读取文件内容
    try {
        List<String> lines = Files.readAllLines(file, StandardOpenOption.READ);
        System.out.println("文件内容 (按行):");
        for (String line : lines) {
            System.out.println(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
复制和移动文件
import java.nio.file.*;
import java.io.IOException;

public class FilesCopyMoveExample {
public static void main(String[] args) {
Path source = Paths.get(“exampleDir/exampleFile.txt”);
Path targetCopy = Paths.get(“exampleDir/copyOfExampleFile.txt”);
Path targetMove = Paths.get(“exampleDir/movedExampleFile.txt”);

    try {
        // 复制文件
        Files.copy(source, targetCopy, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("文件已复制到: " + targetCopy);
        
        // 移动文件
        Files.move(source, targetMove, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("文件已移动到: " + targetMove);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
删除文件和目录
import java.nio.file.*;
import java.io.IOException;

public class FilesDeleteExample {
public static void main(String[] args) {
Path file = Paths.get(“exampleDir/movedExampleFile.txt”);
Path directory = Paths.get(“exampleDir”);

    try {
        // 删除文件
        if (Files.deleteIfExists(file)) {
            System.out.println("文件已删除: " + file);
        }
        
        // 删除目录（目录必须为空）
        if (Files.deleteIfExists(directory)) {
            System.out.println("目录已删除: " + directory);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
遍历目录内容
import java.nio.file.*;
import java.io.IOException;

public class FilesListDirectoryExample {
public static void main(String[] args) {
Path directory = Paths.get(“exampleDir”);

    try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory)) {
        System.out.println("目录中的文件:");
        for (Path entry : stream) {
            System.out.println(entry.getFileName());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
获取和设置文件属性
import java.nio.file.*;
import java.nio.file.attribute.FileTime;
import java.io.IOException;

public class FilesAttributesExample {
public static void main(String[] args) {
Path file = Paths.get(“exampleDir/exampleFile.txt”);

    try {
        // 获取文件大小
        long size = Files.size(file);
        System.out.println("文件大小: " + size + " 字节");
        
        // 获取最后修改时间
        FileTime lastModifiedTime = Files.getLastModifiedTime(file);
        System.out.println("最后修改时间: " + lastModifiedTime);
        
        // 设置最后修改时间为当前时间
        FileTime newTime = FileTime.fromMillis(System.currentTimeMillis());
        Files.setLastModifiedTime(file, newTime);
        System.out.println("最后修改时间已更新");
        
        // 检查文件是否存在
        boolean exists = Files.exists(file);
        System.out.println("文件存在: " + exists);
        
        // 检查是否为目录
        boolean isDirectory = Files.isDirectory(file);
        System.out.println("是目录: " + isDirectory);
        
        // 检查是否为常规文件
        boolean isRegularFile = Files.isRegularFile(file);
        System.out.println("是常规文件: " + isRegularFile);
        
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
注意事项
异常处理：大多数 Files 类的方法都会抛出 IOException，因此在使用这些方法时需要适当的异常处理。
原子操作：某些方法（如 Files.move）可以进行原子操作，确保文件操作的完整性。
性能考虑：对于大文件或大量文件操作，考虑使用流式处理方法（如 Files.newBufferedReader 和 Files.newBufferedWriter）以提高性能和减少内存消耗。
5. Path、Paths 和 Files 的协同使用
这三个组件通常一起使用，以实现对文件和目录的全面操作。以下是一个综合示例，展示了如何使用 Path、Paths 和 Files 完成常见的文件操作任务。

综合示例
import java.nio.file.*;
import java.io.IOException;
import java.util.List;
import java.nio.charset.StandardCharsets;

public class ComprehensiveFileOperations {
public static void main(String[] args) {
Path directory = Paths.get(“comprehensiveExampleDir”);
Path file = directory.resolve(“exampleFile.txt”);
Path copyFile = directory.resolve(“copyOfExampleFile.txt”);
Path movedFile = directory.resolve(“movedExampleFile.txt”);

    try {
        // 1. 创建目录
        if (!Files.exists(directory)) {
            Files.createDirectory(directory);
            System.out.println("目录已创建: " + directory);
        }
        
        // 2. 创建文件
        if (!Files.exists(file)) {
            Files.createFile(file);
            System.out.println("文件已创建: " + file);
        }
        
        // 3. 写入数据到文件
        String content = "Hello, Comprehensive Java NIO!";
        Files.write(file, content.getBytes(StandardCharsets.UTF_8), StandardOpenOption.WRITE);
        System.out.println("数据已写入文件: " + file);
        
        // 4. 读取文件内容
        List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);
        System.out.println("文件内容:");
        for (String line : lines) {
            System.out.println(line);
        }
        
        // 5. 复制文件
        Files.copy(file, copyFile, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("文件已复制到: " + copyFile);
        
        // 6. 移动文件
        Files.move(file, movedFile, StandardCopyOption.REPLACE_EXISTING);
        System.out.println("文件已移动到: " + movedFile);
        
        // 7. 获取文件属性
        long size = Files.size(movedFile);
        FileTime lastModifiedTime = Files.getLastModifiedTime(movedFile);
        System.out.println("文件大小: " + size + " 字节");
        System.out.println("最后修改时间: " + lastModifiedTime);
        
        // 8. 遍历目录中的文件
        System.out.println("目录中的文件:");
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory)) {
            for (Path entry : stream) {
                System.out.println(entry.getFileName());
            }
        }
        
        // 9. 删除文件和目录
        Files.deleteIfExists(copyFile);
        System.out.println("复制的文件已删除: " + copyFile);
        
        Files.deleteIfExists(movedFile);
        System.out.println("移动的文件已删除: " + movedFile);
        
        Files.deleteIfExists(directory);
        System.out.println("目录已删除: " + directory);
        
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
运行结果示例：

目录已创建: comprehensiveExampleDir
文件已创建: comprehensiveExampleDir/exampleFile.txt
数据已写入文件: comprehensiveExampleDir/exampleFile.txt
文件内容:
Hello, Comprehensive Java NIO!
文件已复制到: comprehensiveExampleDir/copyOfExampleFile.txt
文件已移动到: comprehensiveExampleDir/movedExampleFile.txt
文件大小: 31 字节
最后修改时间: 2024-04-27T10:15:30Z
目录中的文件:
copyOfExampleFile.txt
movedExampleFile.txt
复制的文件已删除: comprehensiveExampleDir/copyOfExampleFile.txt
移动的文件已删除: comprehensiveExampleDir/movedExampleFile.txt
目录已删除: comprehensiveExampleDir
解释
创建目录和文件：使用 Files.createDirectory 和 Files.createFile 方法创建目录和文件。
写入和读取文件：使用 Files.write 将字符串写入文件，使用 Files.readAllLines 读取文件内容。
复制和移动文件：使用 Files.copy 复制文件，使用 Files.move 移动文件。
获取文件属性：使用 Files.size 和 Files.getLastModifiedTime 获取文件的大小和最后修改时间。
遍历目录：使用 Files.newDirectoryStream 遍历目录中的文件。
删除文件和目录：使用 Files.deleteIfExists 删除文件和目录。
6. 高级功能和最佳实践

  1. 使用文件过滤器
    Files.newDirectoryStream 方法支持使用过滤器来筛选目录中的文件。例如，仅列出 .txt 文件：

import java.nio.file.*;
import java.io.IOException;

public class FilesFilterExample {
public static void main(String[] args) {
Path directory = Paths.get(“exampleDir”);

    try (DirectoryStream<Path> stream = Files.newDirectoryStream(directory, "*.txt")) {
        System.out.println("目录中的 .txt 文件:");
        for (Path entry : stream) {
            System.out.println(entry.getFileName());
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
2. 使用文件遍历器
对于复杂的目录遍历，可以使用 Files.walkFileTree 方法结合 FileVisitor 接口，实现自定义的遍历逻辑。例如，查找目录中所有的 .java 文件：

import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;

public class FilesWalkFileTreeExample {
public static void main(String[] args) {
Path startPath = Paths.get(“src”);

    try {
        Files.walkFileTree(startPath, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                if (file.toString().endsWith(".java")) {
                    System.out.println("找到 Java 文件: " + file);
                }
                return FileVisitResult.CONTINUE;
            }
        });
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
3. 异步文件操作
虽然 Files 类主要提供同步方法，但结合 Java NIO 的异步通道（如 AsynchronousFileChannel），可以实现异步文件操作，提高性能。

import java.nio.file.;
import java.nio.channels.;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.util.concurrent.Future;

public class AsynchronousFileExample {
public static void main(String[] args) {
Path file = Paths.get(“asyncExample.txt”);

    try (AsynchronousFileChannel asyncChannel = AsynchronousFileChannel.open(file, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
        String content = "Asynchronous File Writing in Java NIO.";
        ByteBuffer buffer = ByteBuffer.wrap(content.getBytes());
        
        Future<Integer> operation = asyncChannel.write(buffer, 0);
        
        while (!operation.isDone()) {
            System.out.println("正在写入文件...");
            Thread.sleep(100);
        }
        
        System.out.println("写入完成，写入字节数: " + operation.get());
    } catch (IOException | InterruptedException e) {
        e.printStackTrace();
    }
}

}
4. 处理文件系统差异
NIO.2 支持不同类型的文件系统（如本地文件系统、ZIP 文件系统等）。可以使用 FileSystem 类和相关方法来处理不同的文件系统。

import java.nio.file.*;
import java.io.IOException;

public class ZipFileSystemExample {
public static void main(String[] args) {
Path zipPath = Paths.get(“example.zip”);
try (FileSystem zipFs = FileSystems.newFileSystem(zipPath, null)) {
Path internalPath = zipFs.getPath(“/newFile.txt”);
Files.write(internalPath, “内容写入 ZIP 文件”.getBytes(), StandardOpenOption.CREATE);
System.out.println(“文件已写入 ZIP 文件”);
} catch (IOException e) {
e.printStackTrace();
}
}
}
5. 错误处理和资源管理
异常处理：尽量使用具体的异常类型，如 NoSuchFileException、DirectoryNotEmptyException 等，以便更精确地处理错误。
资源管理：使用 try-with-resources 语句自动关闭流和目录流，避免资源泄漏。
import java.nio.file.*;
import java.io.IOException;

public class ResourceManagementExample {
public static void main(String[] args) {
Path file = Paths.get(“exampleDir/exampleFile.txt”);

    // 使用 try-with-resources 读取文件内容
    try (BufferedReader reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) {
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}
6. 性能优化
批量操作：尽量批量读取或写入数据，减少 I/O 操作的次数。
缓冲流：使用缓冲流（如 BufferedReader 和 BufferedWriter）提高读写性能。
并行处理：对于大规模文件操作，可以考虑并行处理，如使用多线程或并行流。
7. 总结
Path、Paths 和 Files 是 Java NIO.2 中处理文件和目录操作的核心组件，提供了比传统 java.io.File 更加现代化、灵活和高效的功能。以下是它们的主要特点和最佳使用场景：

Path：

表示文件系统中的路径，提供丰富的路径操作方法。
不同于 String，提供平台无关的路径处理。
Paths：

提供静态方法 get，简化 Path 对象的创建过程。
使代码更加简洁和易读。
Files：

提供大量静态方法用于执行文件和目录的各种操作，如创建、删除、复制、移动、读取、写入等。
与 Path 紧密集成，支持高级文件操作和属性管理。
最佳实践
优先使用 NIO.2 的类：在新的项目中，优先使用 Path、Paths 和 Files，而非 java.io.File，以获得更好的性能和更多功能。
使用 try-with-resources：确保所有的流和资源在使用后被正确关闭，避免资源泄漏。
处理具体异常：尽量捕获和处理具体的异常类型，以便更好地应对不同的错误情况。
优化性能：对于大量或大规模的文件操作，考虑使用缓冲流、批量操作或并行处理来提高性能。
利用文件过滤和遍历器：使用 DirectoryStream 和 FileVisitor 实现高效的文件过滤和目录遍历。
保持路径的不可变性：Path 对象是不可变的，这有助于线程安全和代码的健壮性。
通过充分理解和运用 Path、Paths 和 Files，可以高效地处理 Java 应用中的各种文件和目录操作任务，提升代码的可维护性和性能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2234952.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

qt QItemSelectionModel详解

qt QItemSelectionModel详解

1、概述 QItemSelectionModel是Qt框架中提供的一个功能强大且灵活的项选择模型类。它主要用于在用户界面中管理和操作用户选定的项&#xff0c;是实现交互式和响应式应用程序的重要组件。QItemSelectionModel能够帮助开发者创建用户友好和高效的多选列表、表格数据选择等应用场…
阅读更多...
SAP ABAP开发学习——WDA 七 使用文本与消息

SAP ABAP开发学习——WDA 七 使用文本与消息

目录 从数据字典读取文本 使用OTR文本 从程序中调用OTR文本 消息分类 定义消息显示位置 text类消息的使用 T100 消息的使用 OTR消息实例 消息内容修改 从数据字典读取文本 使用OTR文本 可以自己创建OTR文本 从程序中调用OTR文本 消息分类 定义消息显示位置 text类消息的…
阅读更多...
实习作假：阿里健康实习做了RABC中台，还优化了短信发送流程

实习作假：阿里健康实习做了RABC中台，还优化了短信发送流程

最近有二本同学说&#xff1a;“大拿老师&#xff0c;能帮忙看下简历吗&#xff1f;” 如果是从面试官的角度来看&#xff0c;这个同学的实习简历是很虚假的。 但是我们一直强调的是&#xff1a;校招的实习简历是不能出现明显的虚假。 首先&#xff0c;你去公司做事情&#…
阅读更多...
mqtt 传递和推送 温湿度计消息 js

mqtt 传递和推送 温湿度计消息 js

mqtt 传递和推送 温湿度计消息 做了一个mqtt的小网站 包括设备管理&#xff0c;订阅管理&#xff0c;连接认证订阅授权 这里我新增了一个设备 订阅组温湿度里面有两个订阅 设备详情授权给设备使用 设备连接 和之前的wifi连接一样 温湿度也和之前的使用一样 require(u…
阅读更多...
基于Jeecgboot3.6.3vue3的flowable流程增加online表单的审批支持（一）整体思路

基于Jeecgboot3.6.3vue3的flowable流程增加online表单的审批支持（一）整体思路

更多技术支持与服务请加入我的知识星球或加我微信，名称:亿事达nbcio技术交流社区https://t.zsxq.com/iPi8F 今天讲一下流程审批支持online表单，我们知道，之前的VForm3表单不支持数据库存储，自定义业务表单要求又比较高，需要自己写一些前后端的代码，那online就不需要，可以…
阅读更多...
Git超详细笔记包含IDEA整合操作

Git超详细笔记包含IDEA整合操作

git超详细笔记 文章目录 git超详细笔记第1章Git概述1.1、何为版本控制1.2、为什么需要版本控制1.3、版本控制工具1.4 、Git简史1.5、Git工作机制1.6 、Git和代码托管中心 第2章Git安装第3章Git常用命令3.1、设置用户签名3.2、初始化本地库本地库&#xff08;Local Repository&a…
阅读更多...
HTML 基础标签——多媒体标签＜img＞、＜object＞ 与 ＜embed＞

HTML 基础标签——多媒体标签＜img＞、＜object＞ 与 ＜embed＞

文章目录 1. `<img>` 标签主要属性示例注意事项2. `<object>` 标签概述主要属性示例注意事项3. `<embed>` 标签概述主要属性示例注意事项小结在现代网页设计中，多媒体内容的使用变得越来越重要，因为它能够有效增强用户体验、吸引注意力并传达信息。HTML 提…
阅读更多...
flutter 项目初建碰到的控制台报错无法启动问题

flutter 项目初建碰到的控制台报错无法启动问题

在第一次运行flutter时&#xff0c;会碰见一直卡在Runing Gradle task assembleDebug的问题。其实出现这个问题的原因有两个。 一&#xff1a;如果你flutter -doctor 检测都很ok&#xff0c;而且环境配置都很正确&#xff0c;那么大概率就是需要多等一会&#xff0c;少则几十分…
阅读更多...
使用ssh-key免密登录服务器或免密连接git代码仓库网站

使用ssh-key免密登录服务器或免密连接git代码仓库网站

ssh登录服务器场景 假设有两台机器&#xff0c;分别是&#xff1a; 源机器&#xff1a;主机A&#xff08;hostA&#xff09;&#xff0c;ip&#xff1a;198.168.0.1 目标机器&#xff1a;主机B&#xff08;hostB&#xff09;&#xff0c;ip&#xff1a;192.168.0.2 ssh-key免…
阅读更多...
初识Electron 进程通信

初识Electron 进程通信

概述 Electron chromium nodejs native API&#xff0c;也就是将node环境和浏览器环境整合到了一起&#xff0c;这样就构成了桌面端&#xff08;chromium负责渲染、node负责操作系统API等&#xff09; 流程模型 预加载脚本&#xff1a;运行在浏览器环境下&#xff0c;但是…
阅读更多...
小菜家教平台（三）：基于SpringBoot+Vue打造一站式学习管理系统

小菜家教平台（三）：基于SpringBoot+Vue打造一站式学习管理系统

目录 前言 今日进度 详细过程 相关知识点 前言 昨天重构了数据库并实现了登录功能&#xff0c;今天继续进行开发&#xff0c;创作不易&#xff0c;请多多支持~ 今日进度 添加过滤器、实现登出功能、实现用户授权功能校验 详细过程 一、添加过滤器 自定义过滤器作用&…
阅读更多...
小新学习k8s第六天之pod详解

小新学习k8s第六天之pod详解

一、资源限制 Pod是k8s中的最小的资源管理组件&#xff0c;pod也是最小化运行容器化应用的资源对象。一个Pod代表着集群中运行的一个进程。k8s中其他大多数组件都是围绕着Pod来进行支撑和扩展Pod功能的&#xff0c;例如&#xff0c;用于管理Pod运行的StatefulSet和Deployment等…
阅读更多...
戴尔电脑 Bios 如何进入？Dell Bios 进入 Bios 快捷键是什么？

戴尔电脑 Bios 如何进入？Dell Bios 进入 Bios 快捷键是什么？

BIOS&#xff08;基本输入输出系统&#xff09;是计算机启动时运行的第一个程序&#xff0c;它负责初始化硬件并加载操作系统。对于戴尔电脑用户来说&#xff0c;有时可能需要进入 BIOS 进行一些特定的设置调整&#xff0c;比如更改启动顺序、调整性能选项或解决硬件兼容性问题…
阅读更多...
【UE5】一种老派的假反射做法，可以用于移动端，或对反射的速度、清晰度有需求的地方

【UE5】一种老派的假反射做法，可以用于移动端，或对反射的速度、清晰度有需求的地方

没想到大家这篇文章呼声还挺高 这篇文章是对它的详细实现&#xff0c;建议在阅读本篇之前&#xff0c;先浏览一下前面的文章&#xff0c;以便更好地理解和掌握内容。 这种老派的假反射技术&#xff0c;适合用于移动端或对反射效果的速度和清晰度有较高要求的场合。该技术通过一…
阅读更多...
MongoDB笔记02-MongoDB基本常用命令

MongoDB笔记02-MongoDB基本常用命令

文章目录 一、前言二、数据库操作2.1 选择和创建数据库2.2 数据库的删除 3 集合操作3.1 集合的显式创建3.2 集合的隐式创建3.3 集合的删除 四、文档基本CRUD4.1 文档的插入4.1.1 单个文档插入4.1.2 批量插入 4.2 文档的基本查询4.2.1 查询所有4.2.2 投影查询&#xff08;Projec…
阅读更多...
【启程Golang之旅】深入理解 Protocol Buffers 及其应用

【启程Golang之旅】深入理解 Protocol Buffers 及其应用

如果你是 Go 语言的开发者&#xff0c;理解如何在 Go 中使用 Protobuf&#xff0c;将帮助你大幅提升数据传输的效率&#xff0c;并实现更高性能的系统设计。 本篇文章将深入探讨 Go 语言中使用 Protobuf 的基础知识、常见应用以及最佳实践&#xff0c;带你一步步了解如何在项目…
阅读更多...
最新发布：数智人才成长引擎

最新发布：数智人才成长引擎

数字经济时代 数智人才缺口不断增大 根据公开发布的信息显示&#xff0c;中国&#xff0c;作为全球最大的数字经济体之一&#xff0c;当前数智人才&#xff08;涵盖了数智人才、数据分析师、AI专家、云计算工程师等关键岗位&#xff09;的总体缺口已攀升至惊人的2500万至3000…
阅读更多...
ServletContext介绍

ServletContext介绍

文章目录 1、ServletContext对象介绍1_方法介绍2_用例分析 2、ServletContainerInitializer1_整体结构2_工作原理3_使用案例 3、Spring案例源码分析1_注册DispatcherServlet2_注册配置类3_SpringServletContainerInitializer 4_总结 ServletContext 表示上下文对象&#xff0c;…
阅读更多...
Linux的硬盘管理

Linux的硬盘管理

硬盘有价&#xff0c;数据无价 1. 硬盘的概念 硬盘是一种计算机的存储设备&#xff0c;通常是由一个或者多个磁性盘片组成。硬盘即可以安装在计算机的内部&#xff0c;也可以外接计算机。 保存数据 数据&#xff1a;操作系统&#xff0c;应用程序&#xff0c;文档多媒体文件…
阅读更多...
云渲染与汽车CGI图像技术优势和劣势

云渲染与汽车CGI图像技术优势和劣势

在数字时代&#xff0c;云渲染技术以其独特的优势在汽车CGI图像制作中占据了重要地位。云渲染通过利用云计算的分布式处理能力&#xff0c;将渲染任务分配给云端的服务器集群进行计算&#xff0c;从而实现高效、高质量的渲染效果。 这种技术的优势主要体现在以下几个方面&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023