使用docker创建minio镜像并上传文件，提供demo

news2025/1/22 21:00:09

使用docker创建minio镜像并上传文件，提供demo

  • 1. 整体描述
  • 2. 环境搭建
    • 2.1 windows环境搭建
    • 2.2 docker部署
  • 3. spring集成
    • 3.1 添加依赖
    • 3.2 配置文件
    • 3.3 创建config类
    • 3.4 创建minio操作类
    • 3.5 创建启动类
    • 3.6 测试controller
  • 4. 测试操作
    • 4.1 demo运行
    • 4.2 页面查看
    • 4.3 上传文件
    • 4.4 预览/下载文件
  • 5. demo下载
  • 6. 总结

1. 整体描述

MinIO是一个对象存储解决方案，它提供了一个Amazon Web Services S3兼容的API，并支持所有S3的核心特性。MinIO可以部署在任何地方——公共云或私有云、裸机基础设施、编排环境和边缘基础设施。

本文档介绍MinIO最新稳定版本RELEASE.2023-09-04T19-57-37Z在Windows平台上部署MinIO的操作、管理和开发。

上面是官网介绍，用有道翻译的，官网地址: 链接。

2. 环境搭建

使用docker搭建minio环境，可以直接用官网下载minio镜像，我们先用windows环境搭建一下。

2.1 windows环境搭建

在官网下载页面，选择windows，下载的是一个minion.exe文件。我放在了d:/minio目录下，在此再创建一个data文件夹，用来储存minio上传的文件。
然后在命令行执行如下指令启动minio：

setx MINIO_ROOT_USER minioadmin
setx MINIO_ROOT_PASSWORD minioadmin
D:\minio\minio.exe server D:\minio\data\ --console-address ":9001"

看到如下就说明启动成功了：
windowsminio启动
然后通过浏览器访问：
http://localhost:9001/
进入如下登录页面：
默认用户名和密码都是minioadmin
minio登录页面

2.2 docker部署

使用docker部署就更简单了，首先拉取官方镜像：

docker pull minio/minio

拉取成功之后，执行创建和启动容器：

docker run -p 9000:9000 -p 9001:9001 minio/minio server /data --console-address ":9001"

看到如下就说明启动成功：
docker启动minio
同样通过浏览器访问：
http://localhost:9001/
进入如下登录页面：
默认用户名和密码都是minioadmin

3. spring集成

通过springboot框架集成minio，实现上传文件的目的。

3.1 添加依赖

首先创建一个springboot工程，添加如下依赖：

<!-- lombok 自动生成方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <!--io常用工具类 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.5</version>
        </dependency>
        <!--常用工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!-- minio-->
        <dependency>
            <groupId>io.minio</groupId>
            <artifactId>minio</artifactId>
            <version>8.4.6</version>
        </dependency>

3.2 配置文件

在springboot的yml配置文件中添加minio环境的配置：

#minio相关配置
minio:
  endpoint: http://127.0.0.1:9000
  accessKey: minioadmin
  secretKey: minioadmin

3.3 创建config类

package com.thcb.miniodemo.config;

import io.minio.MinioClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * MinioUtil
 *
 * @author thcb
 * @date 2023-09-05
 */
@Component
public class MinioClientConfig {
    @Value("${minio.endpoint}")
    private String endpoint;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;

    /**
     * 注入minio 客户端
     *
     * @return
     */
    @Bean
    public MinioClient minioClient() {

        return MinioClient.builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
    }

}

3.4 创建minio操作类

minio操作类，用来写minio基础方法

package com.thcb.miniodemo.minio;

import com.thcb.miniodemo.utils.*;
import io.minio.*;
import io.minio.http.Method;
import io.minio.messages.Bucket;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.List;

/**
 * MinioUtil
 *
 * @author thcb
 * @date 2023-09-05
 */
@Component
@Slf4j
@RequiredArgsConstructor
public class MinioUtil {

    private final MinioClient minioClient;
    /**
     * 两票数据桶
     */
    public static String TEST_BUCKET = "test";

    private static String POLICY = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:GetBucketLocation\",\"s3:ListBucket\",\"s3:ListBucketMultipartUploads\"],\"Resource\":[\"arn:aws:s3:::%s\"]},{\"Effect\":\"Allow\",\"Principal\":{\"AWS\":[\"*\"]},\"Action\":[\"s3:DeleteObject\",\"s3:GetObject\",\"s3:ListMultipartUploadParts\",\"s3:PutObject\",\"s3:AbortMultipartUpload\"],\"Resource\":[\"arn:aws:s3:::%s/*\"]}]}";

    public void initMinIo() {
        log.warn("start initMinIo.");

        if (!bucketExists(TEST_BUCKET)) {
            log.warn("start makeBucket {}.", TEST_BUCKET);
            makeBucket(TEST_BUCKET);
            log.warn("finish makeBucket {}.", TEST_BUCKET);
        }
        try {
            log.warn("start setBucketPolicy {}.", TEST_BUCKET);
            minioClient.setBucketPolicy(SetBucketPolicyArgs.builder().bucket(TEST_BUCKET).config(String.format(POLICY, TEST_BUCKET, TEST_BUCKET)).build());
            log.warn("finish setBucketPolicy {}.", TEST_BUCKET);
        } catch (Exception e) {
            log.error("setBucketPolicy from minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
        }
    }

    /**
     * 查看存储bucket是否存在
     *
     * @return boolean
     */
    public Boolean bucketExists(String bucketName) {
        Boolean found;
        try {
            found = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
        } catch (Exception e) {
            log.error("bucketExists from minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
            return false;
        }
        return found;
    }

    /**
     * 创建存储bucket
     *
     * @return Boolean
     */
    public synchronized Boolean makeBucket(String bucketName) {
        try {
            minioClient.makeBucket(MakeBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            log.error("makeBucket from minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
            return false;
        }
        return true;
    }

    /**
     * 删除存储bucket
     *
     * @return Boolean
     */
    public synchronized Boolean removeBucket(String bucketName) {
        try {
            minioClient.removeBucket(RemoveBucketArgs.builder()
                    .bucket(bucketName)
                    .build());
        } catch (Exception e) {
            log.error("removeBucket from minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
            return false;
        }
        return true;
    }

    /**
     * 获取全部bucket
     */
    public List<Bucket> getAllBuckets() {
        try {
            List<Bucket> buckets = minioClient.listBuckets();
            return buckets;
        } catch (Exception e) {
            log.error("getAllBuckets from minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
        }
        return null;
    }

    /**
     * 文件上传
     *
     * @param file       文件
     * @param bucketName 桶名称
     * @return Boolean
     */
    public synchronized String upload2Bucket(MultipartFile file, String bucketName) {
        return String.format("/%s/%s", bucketName, upload(file, bucketName));
    }

    /**
     * 文件上传
     *
     * @param file       文件
     * @param bucketName 桶名称
     * @return Boolean
     */
    public synchronized String upload(MultipartFile file, String bucketName) {
        String originalFilename = file.getOriginalFilename();
        if (StringUtils.isBlank(originalFilename)) {
            throw new CustomException("文件格式错误");
        }
        String fileName = UUIDUtil.UUID() + originalFilename.substring(originalFilename.lastIndexOf("."));
        String objectName = DateUtils.dateTimeNow(DateUtils.YYYYMMDD) + "/" + fileName;
        try {
            PutObjectArgs objectArgs = PutObjectArgs.builder().bucket(bucketName).object(objectName)
                    .stream(file.getInputStream(), file.getSize(), -1).contentType(file.getContentType()).build();
            //文件名称相同会覆盖
            minioClient.putObject(objectArgs);
        } catch (Exception e) {
            log.error("upload file to minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
            return null;
        }
        return objectName;
    }

    /**
     * 文件上传
     *
     * @param file 文件
     * @return Boolean
     */
    public synchronized String upload(MultipartFile file) {
        return upload(file, TEST_BUCKET);
    }

    /**
     * 预览
     *
     * @param fileName
     * @return
     */
    public String preview(String fileName) {
        return preview(fileName, TEST_BUCKET);
    }

    /**
     * 预览
     *
     * @param fileName
     * @param bucketName 桶名称
     * @return
     */
    public String preview(String fileName, String bucketName) {
        // 查看文件地址
        GetPresignedObjectUrlArgs build = GetPresignedObjectUrlArgs.builder().bucket(bucketName).object(fileName).method(Method.GET).build();
        try {
            String url = minioClient.getPresignedObjectUrl(build);
            return url;
        } catch (Exception e) {
            log.error("preview file to minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
        }
        return null;
    }

    /**
     * 文件下载
     *
     * @param fileName         文件名称
     * @param originalFileName 原文件名称
     * @param res              response
     * @return Boolean
     */
    public void download(String fileName, String originalFileName, HttpServletRequest req, HttpServletResponse res) {
        download(fileName, TEST_BUCKET, req, res);
    }

    /**
     * 文件下载
     *
     * @param fileName         文件名称
     * @param bucketName       桶名称
     * @param originalFileName 原文件名称
     * @param res              response
     * @return Boolean
     */
    public void download(String fileName, String bucketName, String originalFileName, HttpServletRequest req, HttpServletResponse res) {
        GetObjectArgs objectArgs = GetObjectArgs.builder().bucket(bucketName)
                .object(fileName).build();
        try (GetObjectResponse response = minioClient.getObject(objectArgs)) {
            byte[] buf = new byte[1024];
            int len;
            try (FastByteArrayOutputStream os = new FastByteArrayOutputStream()) {
                while ((len = response.read(buf)) != -1) {
                    os.write(buf, 0, len);
                }
                os.flush();
                byte[] bytes = os.toByteArray();
                res.setCharacterEncoding("utf-8");

                String type = req.getHeader("User-Agent").toLowerCase();
                String firefox = "firefox", chrome = "chrome";
                String encodedFileName;
                if (type.indexOf(firefox) > 0 || type.indexOf(chrome) > 0) {
                    encodedFileName = new String(originalFileName.getBytes(StandardCharsets.UTF_8), "iso8859-1");
                } else {
                    encodedFileName = URLEncoder.encode(originalFileName, StandardCharsets.UTF_8.name());
                }

                // 设置强制下载不打开
                // res.setContentType("application/force-download");
                // res.setContentType("application/octet-stream");
                res.setContentType(FileDownloadUtils.getFileContentType(fileName));
                res.addHeader("Content-Disposition", "attachment;fileName=" + encodedFileName + ";filename*=utf-8''" + encodedFileName);
                res.addHeader("Content-Length", bytes.length + "");
                try (ServletOutputStream stream = res.getOutputStream()) {
                    stream.write(bytes);
                    stream.flush();
                }
            }
            res.flushBuffer();
        } catch (Exception e) {
            log.error("download file from minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
        }
    }

    /**
     * 删除
     *
     * @param fileName
     * @return
     * @throws Exception
     */
    public boolean remove(String fileName) {
        return remove(fileName, TEST_BUCKET);
    }

    /**
     * 删除
     *
     * @param fileName
     * @return
     * @throws Exception
     */
    public synchronized boolean remove(String fileName, String bucketName) {
        try {
            minioClient.removeObject(RemoveObjectArgs.builder().bucket(bucketName).object(fileName).build());
        } catch (Exception e) {
            log.error("remove file from minio occur exception. e={}", ExceptionUtil.getExceptionMessage(e));
            return false;
        }
        return true;
    }

}

3.5 创建启动类

在springboot启动成功后连接minio

package com.thcb.miniodemo.listener;

import com.thcb.miniodemo.minio.MinioUtil;
import com.thcb.miniodemo.utils.ExceptionUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * ApplicationReadyListener
 *
 * @author thcb
 * @date 2023-09-05
 */
@Component
public class ApplicationReadyListener implements ApplicationListener<ApplicationReadyEvent> {
    private static final Logger log = LoggerFactory.getLogger(ApplicationReadyListener.class);

    @Autowired
    private MinioUtil minioUtil;

    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        try {
            doPostConstruct();
        } catch (Exception e) {
            log.error("e={}", ExceptionUtil.getExceptionMessage(e));
        }
    }

    private void doPostConstruct() {
        log.info("initMinIo");
        initMinIo();
    }

    /**
     * 初始化minio桶文件
     */
    private void initMinIo() {
        minioUtil.initMinIo();
    }
}

3.6 测试controller

写一个测试的controller，测试minio相关功能

package com.thcb.miniodemo.controller;

import com.thcb.miniodemo.minio.MinioUtil;
import com.thcb.miniodemo.utils.AjaxResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

/**
 * TestController
 *
 * @author thcb
 * @date 2023-09-05
 */
@RestController
@RequestMapping("/TestController")
public class TestController {

    private static final Logger log = LoggerFactory.getLogger(TestController.class);

    @Autowired
    private MinioUtil minioUtil;

    @RequestMapping("/test")
    @ResponseBody
    public String test() {
        return "test success";
    }

    @PostMapping("/uploadFile")
    public AjaxResult uploadFile(MultipartFile file) throws Exception {
        try {
            String pathUrl = minioUtil.upload2Bucket(file, MinioUtil.TEST_BUCKET);
            return AjaxResult.success(pathUrl);
        } catch (Exception e) {
            return AjaxResult.error(e.toString());
        }
    }
}

4. 测试操作

4.1 demo运行

运行工程，如下log说明连接成功：
miniodemo运行

4.2 页面查看

运行完成，在页面应该能看到我们创建的桶：
桶

4.3 上传文件

使用postman调用我们写的测试接口，上传一个文件到minio
postman调用
上传成功，在页面上也可以看到这个文件：
文件查看

4.4 预览/下载文件

如果上传的是图片，通过返回的url，浏览器可以直接访问预览，如果是其他类型的文件，是可以通过这个返回的url进行下载的：
http://localhost:9000/test/20230908/2b31664c4a004a5cb4b2934ebf5300cd.jpg

5. demo下载

minio的demo已经上传到csdn，需要的可以自行下载，在本文基本也把主要的核心代码都贴出来了，这个demo使用的是springboot框架，加了一些工具类，可以直接拿来用，或者新工程改个名字就能用了。demo结构截图：
demo结构
demo工程地址：demo下载地址，传到了gitcode上，应该是csdn弄的一个代码仓库，和git差不多。

6. 总结

minio还是很方便的，从部署到使用，都可以非常快速的搭建，而且比较稳定。

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

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

相关文章

GoogLeNet 08

GoogLeNet 08

一、发展 1989年&#xff0c;Yann LeCun提出了一种用反向传导进行更新的卷积神经网络&#xff0c;称为LeNet。 1998年&#xff0c;Yann LeCun提出了一种用反向传导进行更新的卷积神经网络&#xff0c;称为LeNet-5 AlexNet是2012年ISLVRC 2012&#xff08;ImageNet Large Sca…
阅读更多...
[docker]笔记-存储管理

[docker]笔记-存储管理

1、docker数据存储分为非永久性存储和永久性存储。 非永久性存储&#xff1a;容器创建会默认创建非永久性存储&#xff0c;该存储从属于容器&#xff0c;生命周期与容器相同&#xff0c;会随着容器的关闭而消失&#xff08;可理解为内存中数据&#xff0c;会随关机而消失&…
阅读更多...
【jmeter】连接mysql无法使用executeQuery()

【jmeter】连接mysql无法使用executeQuery()

Can not issue data manipulation statements with executeQuery(). 翻译为&#xff1a; 在这里插入图片描述 看一下JDBC Request里的Query Type 改为Prepared Updata Statement&#xff0c;改完再试一下
阅读更多...
CMake+CLion+Qt配置

CMake+CLion+Qt配置

在这里我下载MSVC的工具包&#xff0c;并没有下载Visual Studio。 配置编译环境 下载Visual Studio&#xff0c;其中有MSVC编译工具&#xff0c;下载MSVC工具包&#xff0c; 工具包下载链接&#xff1a;https://visualstudio.microsoft.com/zh-hans/visual-cpp-build-tools/ …
阅读更多...
结构方程模型SEM、路径分析房价和犯罪率数据、预测智力影响因素可视化2案例...

结构方程模型SEM、路径分析房价和犯罪率数据、预测智力影响因素可视化2案例...

原文链接&#xff1a;http://tecdat.cn/?p25044 在本文&#xff0c;我们将考虑观察/显示所有变量的模型&#xff0c;以及具有潜在变量的模型&#xff08;点击文末“阅读原文”获取完整代码数据&#xff09;。 1 简介 第一种有时称为“路径分析”&#xff0c;而后者有时称为“测…
阅读更多...
2023国赛数学建模C题思路代码 - 蔬菜类商品的自动定价与补货决策

2023国赛数学建模C题思路代码 - 蔬菜类商品的自动定价与补货决策

# 1 赛题 在生鲜商超中&#xff0c;一般蔬菜类商品的保鲜期都比较短&#xff0c;且品相随销售时间的增加而变差&#xff0c; 大部分品种如当日未售出&#xff0c;隔日就无法再售。因此&#xff0c; 商超通常会根据各商品的历史销售和需 求情况每天进行补货。 由于商超销售的蔬菜…
阅读更多...
【Linux】工具Gdb调试轻度使用(C++)

【Linux】工具Gdb调试轻度使用(C++)

目录 一、Gdb背景 二、Gdb基本命令 【2.1】list | l 【2.2】break | b 【2.5】delete | d 【2.6】disable 【2.7】enable 【2.3】info 【2.4】info locals 【2.6】run | r 【2.7】next | n 【2.8】step | s 【2.9】 continue | c 【2.10】bt 【2.11】finish 三…
阅读更多...
idea报错“Static methods in interface require -target:jvm-1.8”

idea报错“Static methods in interface require -target:jvm-1.8”

如题&#xff0c;在 idea 中跑 java 、scala 混编代码时&#xff0c;出现上面的错误。 问题的原因很明显是 idea 中的 jdk 版本设置有问题&#xff0c;针对性作如下排查&#xff1a; 检查项目的 java 版本 在File-> Project Settings中&#xff0c;检查检查idea的 java 版本…
阅读更多...
SQL Server 跨库/服务器查询

SQL Server 跨库/服务器查询

这里写目录标题 1 SQL Server 跨库/服务器查询1.1 跨库查询1.2 跨服务器查询1.2.1 创建链接服务器1.2.2 跨库查询 1.3 拓展&#xff1a;SQL Server 中所有权和用户与架构的分离 1 SQL Server 跨库/服务器查询 1.1 跨库查询 在同一服务器下的跨库查询较为简单&#xff0c;示例…
阅读更多...
QT Creator更改主题和编辑器风格（附几款黑色主题）

QT Creator更改主题和编辑器风格（附几款黑色主题）

适用于qtcreator 一、使用自带主题与编辑器风格 打开Qt选择"工具"->"选项"&#xff1b; 2. 选择"环境"->"Theme"切换不同的主题风格 这里切换的是外边框的风格&#xff0c;如果编辑器中有同名的风格&#xff0c;编辑器的风格也…
阅读更多...
【计算机基础知识9】前端设计模式与常见类型

【计算机基础知识9】前端设计模式与常见类型

目录 一、前言 二、设计模式的基本概念和原则 三、创建型设计模式 四、结构型设计模式 五、行为型设计模式 六、MVC和MVVM框架中的设计模式 七、实际应用案例分析 一、前言 在软件开发领域&#xff0c;设计模式是一种解决常见问题的最佳实践&#xff0c;它可以帮助开发…
阅读更多...
手敲Cocos简易地图编辑器：人生地图是一本不断修改的书,每一次编辑都是为了克服新的阻挡

手敲Cocos简易地图编辑器：人生地图是一本不断修改的书,每一次编辑都是为了克服新的阻挡

引言 本系列是《8年主程手把手打造Cocos独立游戏开发框架》&#xff0c;欢迎大家关注分享收藏订阅。 在上一篇文章&#xff0c;笔者给大家讲解了在Cocos独立游戏开发框架中&#xff0c;如何自定义实现Tile地图管理器&#xff0c;成功地在游戏中优化加载一张特大的地图。接下来…
阅读更多...
持久层框架之Mybatis

持久层框架之Mybatis

概述 MyBatis是apache的一个开源项目iBatis,2010年改名为MyBatis,2013年11月迁移到GithubMyBatis是一款优秀的持久层框架,它对jdbc的操作数据库的过程进行封装,使开发者只需要关注SQL本身而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结…
阅读更多...
软件设计模式系列之二——抽象工厂模式

软件设计模式系列之二——抽象工厂模式

1 抽象工厂模式的定义 抽象工厂模式是一种创建型设计模式&#xff0c;它提供了一种创建一组相关或相互依赖对象的方式&#xff0c;而无需指定它们的具体类。该模式以一组抽象接口为核心&#xff0c;包括抽象工厂接口和一组抽象产品接口&#xff0c;每个具体工厂类负责创建特定…
阅读更多...
More Effective C++学习笔记（5）

More Effective C++学习笔记（5）

目录 条款25&#xff1a;将构造函数和非成员函数虚化条款26&#xff1a;限制某个类所能产生的对象数量条款27&#xff1a;要求&#xff08;或禁止&#xff09;对象产生于heap&#xff08;堆&#xff09;之中条款28&#xff1a;智能指针条款29&#xff1a;引用计数条款30&#x…
阅读更多...
uview indexList 按字母跳转不了

uview indexList 按字母跳转不了

点击字母跳转不到位的问题&#xff1a;在<u-index-list>添加方法select“clickSelect“ 锚点要加id&#xff0c;用对应的字母做为id值&#xff0c; <u-index-anchor :id"key" :index"key"/> <template><view><view class&qu…
阅读更多...
法国新法案强迫 Firefox 等浏览器审查网站

法国新法案强迫 Firefox 等浏览器审查网站

导读Mozilla 基金会已发起了一份请愿书&#xff0c;旨在阻止法国政府强迫 Mozilla Firefox 等浏览器审查网站。 据悉&#xff0c;法国政府正在制定一项旨在打击网络欺诈的 SREN 法案 (“Projet de loi Visant scuriser et reguler lespace numrique”)&#xff0c;包含大约 2…
阅读更多...
将本地jar包手动添加到Maven仓库依赖处理

将本地jar包手动添加到Maven仓库依赖处理

一、起因 在日常开发中&#xff0c;经常会遇到一些情况&#xff0c;就是在更新Maven时&#xff0c;从网上下载jar包的时候网络不稳定或者其他原因导致jar包数据缺失而导致的依赖无法正常引入的情况. 还有一些其他情况如个人jar包一类的。 二、解决 以前以上这些情况&#x…
阅读更多...
三维模型3DTile格式轻量化压缩处理效率提高的技术方浅析

三维模型3DTile格式轻量化压缩处理效率提高的技术方浅析

三维模型3DTile格式轻量化压缩处理效率提高的技术方浅析 随着三维模型在各个领域的广泛应用&#xff0c;对于其格式的轻量化压缩处理和效率提高的需求也越发迫切。本文将介绍一些技术方法&#xff0c;帮助实现三维模型3DTile格式的轻量化压缩处理并提高处理效率。 首先&#x…
阅读更多...
手写Spring：第14章-自动扫描Bean对象注册

手写Spring：第14章-自动扫描Bean对象注册

文章目录 一、目标&#xff1a;自动扫描Bean对象注册二、设计&#xff1a;自动扫描Bean对象注册三、实现&#xff1a;自动扫描Bean对象注册3.0 引入依赖3.1 工程结构3.2 Bean生命周期中自动加载包扫描注册Bean对象和设置占位符属性类图3.3 主力占位符配置3.4 定义拦截注解3.4.1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023