Docker 搭建 Minio 容器

news2024/12/23 8:58:08

Docker 搭建 Minio 容器 (完整详细版)
简介：

Minio 是一个基于Apache License
v2.0开源协议的对象存储服务，虽然轻量，却拥有着不错的性能。它兼容亚马逊S3云存储服务接口，非常适合于存储大容量非结构化的数据。

例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等，而一个对象文件可以是任意大小，从几 kb 到最大 5T 不等。

最重要的是免费

说明：

Docker如果想安装软件 , 必须先到Docker镜像仓库下载镜像。

Docker官方镜像

1、寻找Minio镜像
在这里插入图片描述
在这里插入图片描述
2、下载Minio镜像

# 下载镜像
docker pull minio/minio

#查看镜像
docker images

在这里插入图片描述
在这里插入图片描述
3、创建目录
一个用来存放配置，一个用来存储上传文件的目录

启动前需要先创建Minio外部挂载的配置文件（ /opt/minio/config）,和存储上传文件的目录（ /opt/minio/data）

mkdir -p /opt/minio/config

mkdir -p /opt/minio/data

4、创建Minio容器并运行

docker run \
-p 19000:9000 \
-p 9090:9090 \
--net=host \
--name minio \
-d --restart=always \
-e "MINIO_ACCESS_KEY=minioadmin" \
-e "MINIO_SECRET_KEY=minioadmin" \
-v /opt/minio/data:/data \
-v /opt/minio/config:/root/.minio \
 minio/minio server \
/data --console-address ":9090" -address ":19000"

在这里插入图片描述
4.1、访问操作
访问：http://47.117.160.102:9090/login 用户名：密码 minioadmin：minioadmin
在这里插入图片描述
4.2、创建用户
在这里插入图片描述
在这里插入图片描述
4.3、创建组
在这里插入图片描述
在这里插入图片描述
4.4、创建Buckets
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
4.6、文件上传
在这里插入图片描述
4.6、浏览器访问上传文件

在这里插入图片描述

4.6.1、输入ip:19000/Buckets名/文件名，如果不行，看看端口是否开放

5、Springboot简单使用
5.1、添加MinIO依赖Pom

<dependencies>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- MinIO 客户端 -->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.5.7</version>
        </dependency>
    
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.11</version>
        </dependency>
    
</dependencies>

5.2、配置MinIO的yaml

server:
  port: 3333

spring:
  servlet:
    multipart:
      max-request-size: 200MB
      max-file-size: 200MB

minio:
  url: http://127.0.0.1:19000 #换成自己的minio服务端地址
  accessKey: minioadmin # 用户名
  secretKey: minioadmin # 密码
  bucketName: demo  # bucketName指的就是之前创建的MinIO桶Bucket

5.3、配置类Config

@Data
@Configuration
public class MinioConfig {

    /**
     * 访问地址
     */
    @Value("${minio.url}")
    private String endpoint;

    /**
     * accessKey类似于用户ID，用于唯一标识你的账户
     */
    @Value("${minio.accessKey}")
    private String accessKey;

    /**
     * secretKey是你账户的密码
     */
    @Value("${minio.secretKey}")
    private String secretKey;

    /**
     * 默认存储桶
     */
    @Value("${minio.bucketName}")
    private String bucketName;

    @Bean
    public MinioClient minioClient() {
        MinioClient minioClient = MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
        return minioClient;
    }
}

5.4、创建MinIO工具类

/**
 * MinIO工具类
 *
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class MinioUtils {

    private final MinioClient minioClient;

    /******************************  Operate Bucket Start  ******************************/

    /**
     * 启动SpringBoot容器的时候初始化Bucket
     * 如果没有Bucket则创建
     *
     * @param bucketName
     */
    @SneakyThrows(Exception.class)
    private void createBucket(String bucketName) {
        if (!bucketExists(bucketName)) {
            minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
        }
    }

    /**
     * 判断Bucket是否存在，true：存在，false：不存在
     *
     * @param bucketName
     * @return
     */
    @SneakyThrows(Exception.class)
    public boolean bucketExists(String bucketName) {
        return minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
    }

    /**
     * 获得Bucket的策略
     *
     * @param bucketName
     * @return
     */
    @SneakyThrows(Exception.class)
    public String getBucketPolicy(String bucketName) {
        return minioClient.getBucketPolicy(GetBucketPolicyArgs
                .builder()
                .bucket(bucketName)
                .build());
    }

    /**
     * 获得所有Bucket列表
     *
     * @return
     */
    @SneakyThrows(Exception.class)
    public List<Bucket> getAllBuckets() {
        return minioClient.listBuckets();
    }

    /**
     * 根据bucketName获取其相关信息
     *
     * @param bucketName
     * @return
     */
    @SneakyThrows(Exception.class)
    public Optional<Bucket> getBucket(String bucketName) {
        return getAllBuckets().stream().filter(b -> b.name().equals(bucketName)).findFirst();
    }

    /**
     * 根据bucketName删除Bucket，true：删除成功； false：删除失败，文件或已不存在
     *
     * @param bucketName
     * @throws Exception
     */
    @SneakyThrows(Exception.class)
    public void removeBucket(String bucketName) {
        minioClient.removeBucket(RemoveBucketArgs.builder().bucket(bucketName).build());
    }

    /******************************  Operate Bucket End  ******************************/


    /******************************  Operate Files Start  ******************************/

    /**
     * 判断文件是否存在
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public boolean isObjectExist(String bucketName, String objectName) {
        boolean exist = true;
        try {
            minioClient.statObject(StatObjectArgs.builder().bucket(bucketName).object(objectName).build());
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> 判断文件是否存在, 异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 判断文件夹是否存在
     *
     * @param bucketName
     * @param objectName
     * @return
     */
    public boolean isFolderExist(String bucketName, String objectName) {
        boolean exist = false;
        try {
            Iterable<Result<Item>> results = minioClient.listObjects(
                    ListObjectsArgs.builder().bucket(bucketName).prefix(objectName).recursive(false).build());
            for (Result<Item> result : results) {
                Item item = result.get();
                if (item.isDir() && objectName.equals(item.objectName())) {
                    exist = true;
                }
            }
        } catch (Exception e) {
            log.error("[Minio工具类]>>>> 判断文件夹是否存在，异常：", e);
            exist = false;
        }
        return exist;
    }

    /**
     * 根据文件前置查询文件
     *
     * @param bucketName 存储桶
     * @param prefix     前缀
     * @param recursive  是否使用递归查询
     * @return MinioItem 列表
     */
    @SneakyThrows(Exception.class)
    public List<Item> getAllObjectsByPrefix(String bucketName,
                                            String prefix,
                                            boolean recursive) {
        List<Item> list = new ArrayList<>();
        Iterable<Result<Item>> objectsIterator = minioClient.listObjects(
                ListObjectsArgs.builder().bucket(bucketName).prefix(prefix).recursive(recursive).build());
        if (objectsIterator != null) {
            for (Result<Item> o : objectsIterator) {
                Item item = o.get();
                list.add(item);
            }
        }
        return list;
    }

    /**
     * 获取文件流
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @return 二进制流
     */
    @SneakyThrows(Exception.class)
    public InputStream getObject(String bucketName, String objectName) {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 断点下载
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @param offset     起始字节的位置
     * @param length     要读取的长度
     * @return 二进制流
     */
    @SneakyThrows(Exception.class)
    public InputStream getObject(String bucketName, String objectName, long offset, long length) {
        return minioClient.getObject(
                GetObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .offset(offset)
                        .length(length)
                        .build());
    }

    /**
     * 获取路径下文件列表
     *
     * @param bucketName 存储桶
     * @param prefix     文件名称
     * @param recursive  是否递归查找，false：模拟文件夹结构查找
     * @return 二进制流
     */
    public Iterable<Result<Item>> listObjects(String bucketName, String prefix, boolean recursive) {
        return minioClient.listObjects(
                ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .prefix(prefix)
                        .recursive(recursive)
                        .build());
    }

    /**
     * 使用MultipartFile进行文件上传
     *
     * @param bucketName  存储桶
     * @param file        文件名
     * @param objectName  对象名
     * @param contentType 类型
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, MultipartFile file, String objectName, String contentType) {
        InputStream inputStream = file.getInputStream();
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .contentType(contentType)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 图片上传
     * @param bucketName
     * @param imageBase64
     * @param imageName
     * @return
     */
    public ObjectWriteResponse uploadImage(String bucketName, String imageBase64, String imageName) {
        if (!StringUtils.isEmpty(imageBase64)) {
            InputStream in = base64ToInputStream(imageBase64);
            String newName = System.currentTimeMillis() + "_" + imageName + ".jpg";
            String year = String.valueOf(new Date().getYear());
            String month = String.valueOf(new Date().getMonth());
            return uploadFile(bucketName, year + "/" + month + "/" + newName, in);

        }
        return null;
    }
// BASE64Decoder在jdk8以上的版本移除了，报错最简单解决换成jdk8就行了
    public static InputStream base64ToInputStream(String base64) {
        ByteArrayInputStream stream = null;
        try {
            byte[] bytes = new BASE64Decoder().decodeBuffer(base64.trim());
            stream = new ByteArrayInputStream(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return stream;
    }


    /**
     * 上传本地文件
     *
     * @param bucketName 存储桶
     * @param objectName 对象名称
     * @param fileName   本地文件路径
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, String fileName) {
        return minioClient.uploadObject(
                UploadObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .filename(fileName)
                        .build());
    }

    /**
     * 通过流上传文件
     *
     * @param bucketName  存储桶
     * @param objectName  文件对象
     * @param inputStream 文件流
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse uploadFile(String bucketName, String objectName, InputStream inputStream) {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(inputStream, inputStream.available(), -1)
                        .build());
    }

    /**
     * 创建文件夹或目录
     *
     * @param bucketName 存储桶
     * @param objectName 目录路径
     * @return
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse createDir(String bucketName, String objectName) {
        return minioClient.putObject(
                PutObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .stream(new ByteArrayInputStream(new byte[]{}), 0, -1)
                        .build());
    }

    /**
     * 获取文件信息, 如果抛出异常则说明文件不存在
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     * @return
     */
    @SneakyThrows(Exception.class)
    public String getFileStatusInfo(String bucketName, String objectName) {
        return minioClient.statObject(
                StatObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build()).toString();
    }

    /**
     * 拷贝文件
     *
     * @param bucketName    存储桶
     * @param objectName    文件名
     * @param srcBucketName 目标存储桶
     * @param srcObjectName 目标文件名
     */
    @SneakyThrows(Exception.class)
    public ObjectWriteResponse copyFile(String bucketName, String objectName, String srcBucketName, String srcObjectName) {
        return minioClient.copyObject(
                CopyObjectArgs.builder()
                        .source(CopySource.builder().bucket(bucketName).object(objectName).build())
                        .bucket(srcBucketName)
                        .object(srcObjectName)
                        .build());
    }

    /**
     * 删除文件
     *
     * @param bucketName 存储桶
     * @param objectName 文件名称
     */
    @SneakyThrows(Exception.class)
    public void removeFile(String bucketName, String objectName) {
        minioClient.removeObject(
                RemoveObjectArgs.builder()
                        .bucket(bucketName)
                        .object(objectName)
                        .build());
    }

    /**
     * 批量删除文件
     *
     * @param bucketName 存储桶
     * @param keys       需要删除的文件列表
     * @return
     */
    public void removeFiles(String bucketName, List<String> keys) {
        List<DeleteObject> objects = new LinkedList<>();
        keys.forEach(s -> {
            objects.add(new DeleteObject(s));
            try {
                removeFile(bucketName, s);
            } catch (Exception e) {
                log.error("[Minio工具类]>>>> 批量删除文件，异常：", e);
            }
        });
    }

    /**
     * 获取文件外链
     *
     * @param bucketName 存储桶
     * @param objectName 文件名
     * @param expires    过期时间 <=7 秒 （外链有效时间（单位：秒））
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getPresignedObjectUrl(String bucketName, String objectName, Integer expires) {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder().expiry(expires).bucket(bucketName).object(objectName).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 获得文件外链
     *
     * @param bucketName
     * @param objectName
     * @return url
     */
    @SneakyThrows(Exception.class)
    public String getPresignedObjectUrl(String bucketName, String objectName) {
        GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                .bucket(bucketName)
                .object(objectName)
                .method(Method.GET).build();
        return minioClient.getPresignedObjectUrl(args);
    }

    /**
     * 将URLDecoder编码转成UTF8
     *
     * @param str
     * @return
     * @throws UnsupportedEncodingException
     */
    public String getUtf8ByURLDecoder(String str) throws UnsupportedEncodingException {
        String url = str.replaceAll("%(?![0-9a-fA-F]{2})", "%25");
        return URLDecoder.decode(url, "UTF-8");
    }
}

5.5、创建Controller

@Slf4j
@RestController
@RequestMapping("/oss")
public class OSSController {

    @Autowired
    private MinioUtils minioUtils;

    @Autowired
    private MinioConfig minioConfig;

    /**
     * 文件上传
     *
     * @param file
     */
    @PostMapping("/upload")
    public String upload(@RequestParam("file") MultipartFile file) {
        try {
            //文件名
            String fileName = file.getOriginalFilename();
            String newFileName = System.currentTimeMillis() + "." + StringUtils.substringAfterLast(fileName, ".");
            //类型
            String contentType = file.getContentType();
            minioUtils.uploadFile(minioConfig.getBucketName(), file, newFileName, contentType);
            return "上传成功";
        } catch (Exception e) {
            log.error("上传失败");
            return "上传失败";
        }
    }

    /**
     * 删除
     *
     * @param fileName
     */
    @DeleteMapping("/")
    public void delete(@RequestParam("fileName") String fileName) {
        minioUtils.removeFile(minioConfig.getBucketName(), fileName);
    }

    /**
     * 获取文件信息
     *
     * @param fileName
     * @return
     */
    @GetMapping("/info")
    public String getFileStatusInfo(@RequestParam("fileName") String fileName) {
        return minioUtils.getFileStatusInfo(minioConfig.getBucketName(), fileName);
    }

    /**
     * 获取文件外链
     *
     * @param fileName
     * @return
     */
    @GetMapping("/url")
    public String getPresignedObjectUrl(@RequestParam("fileName") String fileName) {
        return minioUtils.getPresignedObjectUrl(minioConfig.getBucketName(), fileName);
    }

    /**
     * 文件下载
     *
     * @param fileName
     * @param response
     */
    @GetMapping("/download")
    public void download(@RequestParam("fileName") String fileName, HttpServletResponse response) {
        try {
            InputStream fileInputStream = minioUtils.getObject(minioConfig.getBucketName(), fileName);
            response.setHeader("Content-Disposition", "attachment;filename=" + fileName);
            response.setContentType("application/force-download");
            response.setCharacterEncoding("UTF-8");
            IOUtils.copy(fileInputStream, response.getOutputStream());
        } catch (Exception e) {
            log.error("下载失败");
        }
    }

}

6、测试验证
6.1、文件上传
使用Postman调用http://localhost:3333/oss/upload 接口，选择某个文件测试上传功能，如下图所示：
在这里插入图片描述
6.2、文件下载
在浏览器中，调用http://localhost:3333/oss/download?fileName=1701436432918.gif 接口，验证文件下载接口，如下图所示：

在这里插入图片描述

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

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

相关文章

CentOS通过rsync实现文件同步（daemon方式）

CentOS通过rsync实现文件同步（daemon方式）

rsync介绍 rsync是Liunx下的远程数据同步工具&#xff0c;可快速同步多台服务器间的文件和目录&#xff0c;并可实现增量同步以减少数据的传输。 rsync有两种常用的认证方式&#xff0c;一种是rsync-daemon方式&#xff0c;另外一种是ssh方式。 daemon 方式与 ssh 方式相比有…
阅读更多...
Nginx代理路径被吃

Nginx代理路径被吃

Nginx代理路径被吃的情况 日常工作中经常使用nginx反向代理一些资源&#xff0c;有时正常代理&#xff0c;发现代理不过去。 验证被吃调location情况 通过浏览器访问&#xff1a; https://zhao138969.com/LinuxPackage/Python/SelectDocker location /LinuxPackage { proxy…
阅读更多...
深度学习Day-27：生成对抗网络（GAN）入门

深度学习Day-27：生成对抗网络（GAN）入门

&#x1f368; 本文为&#xff1a;[&#x1f517;365天深度学习训练营] 中的学习记录博客 &#x1f356; 原作者&#xff1a;[K同学啊 | 接辅导、项目定制] 要求&#xff1a; 了解什么是生成对抗网络生成对抗网络结构是怎么样的学习本文代码&#xff0c;并跑通代码调用训练好…
阅读更多...
【MeterSphere】3.X备份与还原

【MeterSphere】3.X备份与还原

目录 一、手动备份数据库 二、备份 minio 目录 三、自动备份 3.1 设置备份服务器 3.2 创建文件夹 msdb_bak 3.3 设置备份脚本 3.4 创建用于定时任务脚本文件 3.5 为msdb_bak赋权 3.6 执行 install_ms_backup.sh 3.7 查看定时任务是否成功 四、还原数据 4.1 还原 s…
阅读更多...
LinkedHashSet底层原理

LinkedHashSet底层原理

LinkedHashSet 的特点 去重&#xff1a;不允许重复的元素&#xff0c;类似于 HashSet。有序&#xff1a;能够记住元素的插入顺序&#xff0c;类似于 LinkedList。性能&#xff1a;具有较好的平均时间复杂度&#xff0c;如添加、删除和查找操作通常都是 O(1)。 内部实现 数据…
阅读更多...
Java全栈课程之Linux——进程管理

Java全栈课程之Linux——进程管理

一、什么是进程 1、在Linux中,每一个程序都是有自己的一个进程,每一个进程都有一个id号! 2、每一个进程呢,都会有一个父进程! 3、进程可以有两种存在方式:前台!后台运行! 4、一般的话服务都是后台运行的,基本的程序都是前台运行的! 二、命令 ps 查看当前系统中正在执行的…
阅读更多...
航空客运订票系统（数据结构与算法课设）（C语言版）

航空客运订票系统（数据结构与算法课设）（C语言版）

本文为数据结构与算法课设《航空客运订票系统》的分享与实践，采用了顺序表和链表两种数据结构。贴近生活采用了系统选择来区别用户和管理员。 目录 1.设计内容与要求 2.功能实现和程序调试 功能实现 函数原型清单 程序调试 3.代码实现 (1)结构体定义 (2)管理员菜单…
阅读更多...
若依开发平台数据权限设计与实现深度剖析

若依开发平台数据权限设计与实现深度剖析

概述 在之前的博客《数据权限的设计与思考》中&#xff0c;我们对软件系统的数据权限进行了全面的梳理。接下来&#xff0c;本文深度剖析主流开源的若依开发平台数据权限是怎么设计与实现的。 平台展示 在角色管理菜单中&#xff0c;在角色列表中选择一个具体角色&#xff…
阅读更多...
【C++】实验十二

【C++】实验十二

题目&#xff1a; 1、事先编好程序&#xff0c;上机调试和运行程序&#xff0c;分析结果。 将教材第11章例11.1的程序片段补充和改写成一个完整、正确的程序&#xff0c;用公用继承方式。在程序中包括输入数据的函数&#xff0c;在程序运行时输入num&#xff0c;name&#xf…
阅读更多...
人工智能与机器学习原理精解【11】

人工智能与机器学习原理精解【11】

文章目录 广义线性模型基础理论泊松分布的基本公式一、基本公式二、泊松分布的特点三、泊松分布的应用场景四、泊松分布与二项分布的关系五、总结 泊松回归例子1例子背景模型设定数据收集模型拟合结果解释预测应用场景 泊松回归例子2背景数据准备模型设定模型拟合结果解释预测 …
阅读更多...
红外视觉简介：近红外图像与中远红外图像

红外视觉简介：近红外图像与中远红外图像

在本教程中，您将学习红外成像的基础知识，包括： 什么是红外图像：近红外与中远红外红外摄像机的类型它们有什么用处什么是红外图像？近红外图像 在开始处理这种奇怪的图像之前，我们应该了解它们的来源。 我们都熟悉常见的数字彩色可见图片（图 1，左），因为我们每年都会用…
阅读更多...
“华数杯”全国大学生数学建模竞赛含金量如何？

“华数杯”全国大学生数学建模竞赛含金量如何？

“华数杯”全国大学生数学建模竞赛是由华中师范大学主办的一项全国性的大学生数学建模竞赛。该竞赛旨在提高大学生的数学建模能力和实践能力，增强大学生的创新意识和团队协作精神。 搜集一些评价，有人说该竞赛的含金量较高，但是也有一些人认为其认可度不高，报名费用较贵。…
阅读更多...
【漏洞复现】华天动力OA downloadWpsFile.jsp 任意文件读取漏洞

【漏洞复现】华天动力OA downloadWpsFile.jsp 任意文件读取漏洞

0x01 产品简介 华天动力OA是一款将先进的管理思想、 管理模式和软件技术、网络技术相结合&#xff0c;为用户提供了低成本、 高效能的协同办公和管理平台。 0x02 漏洞概述 华天动力OA downloadWpsFile.jsp 接口处存在任意文件读取漏洞&#xff0c;未经身份认证的攻击者可利用…
阅读更多...
springboot民办高校科研项目管理系统-计算机毕业设计源码54009

springboot民办高校科研项目管理系统-计算机毕业设计源码54009

摘 要 21世纪的今天&#xff0c;随着社会的不断发展与进步&#xff0c;人们对于信息科学化的认识&#xff0c;已由低层次向高层次发展&#xff0c;由原来的感性认识向理性认识提高&#xff0c;管理工作的重要性已逐渐被人们所认识&#xff0c;科学化的管理&#xff0c;使信息存…
阅读更多...
Chat2DB新推Chat2Excel,让数据对话跃然纸上

Chat2DB新推Chat2Excel,让数据对话跃然纸上

Excel 智能问答 Chat2Excel 1. 创建新聊天 点击左侧AI对话&#xff0c;进入对话界面。点击加号""按钮以开始一个新的对话。 新建对话选择表格类型, 选择上传excel文档。 双击对话名称可以修改对话名称。现在我们就可以开始针对于Excel进行智能问答了。 2. 智能…
阅读更多...
小程序开发_02项目构成

小程序开发_02项目构成

一、项目的基本结构 二、小程序的页面组成部分 三、json配置文件 ① project.config.json文件 作用&#xff1a;项目的配置文件&#xff0c;用来记录对小程序开发工具所作的个性化配置 ② sitemap.json 作用&#xff1a;是否允许被微信引擎搜索,不希望被搜索dis ③ app.jso…
阅读更多...
Pycharm打开 .xlsx文件 使用系统自带的软件

Pycharm打开 .xlsx文件 使用系统自带的软件

问题由来 最初默认是使用自带的软件打开 同事电脑默认打开方式是pycharm&#xff0c;有点不好弄&#xff0c;希望打开方式是默认系统默认&#xff1b; 自己尝试修改了一下自己的.xlsx打开方式&#xff0c;无法解决同事问题&#xff0c;后删除默认&#xff0c;自己电脑就出现乱码…
阅读更多...
软考网络工程师 VS 华为认证HCIP，中级认证里哪个更香？

软考网络工程师 VS 华为认证HCIP，中级认证里哪个更香？

在网络工程师的专业发展道路上&#xff0c;技能的提升可以说是升职加薪的第一要点。 如果有想要考证的网工朋友&#xff0c;想来软考和华为认证&#xff0c;基本都是绕不开的。 很多朋友都会在软考中级的网络工程师认证和华为HCIP之间感到犯难&#xff0c;一样都是中级认证&…
阅读更多...
GIT版本管理与分支控制

GIT版本管理与分支控制

目录 1、了解Git功能 2、第一次使用Git&#xff08;首次配置好&#xff0c;后续不用再操作&#xff09; 打开git后端 设置用户签名 结果 3、初始项目架构 创建本地新仓库并初始化 文件添加到本地仓库 a.文件添加缓存区 b.缓存区内容提交到本地仓库 c.改写提交的注释 …
阅读更多...
Miniconda快速安装conda

Miniconda快速安装conda

关注B站可以观看更多实战教学视频&#xff1a;hallo128的个人空间 安装官方网址&#xff1a;https://docs.anaconda.com/miniconda/#quick-command-line-install 1. Miniconda for Windows curl https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe -o …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023