手把手教你云相册项目简易开发 day2 Springboot+SpringCloud+Nacos+Fegin+SpringCloudGateway+S3存储-minio/华为云OBS相关配置和简单使用

心已赠人 2024-03-17 18:01 12阅读 0赞

## 书接上回 ##

首先我们先改一下上一次创建好的子项目里的application文件，其中分别改一下对应的application的名字，以便后面介绍SpringCloud的时候Nacos注册名字方便寻找到子项目，还需要修改端口，其中端口修改分别如下：

api：9009 users：9008 image：9007 gateway：88 audit：9001（gateway和audit后面会介绍到，可以先按照之前的先创建好）

## ![31a879257bfd4d82b4b77ed39b69eae7.png][] ##

## ![590acfc1232048fb8af14e9eab45a626.png][] ##

##  ##

## 测试接口 ##

先介绍一下各个注解：

@Controller：返回给前端的内容是视图

@ResponseBody：将方法或者接口返回的数据渲染成JSON

@RestController：相当于@Controller+@ResponseBody，一般在类上注释了@RestController则就直接说明返回给前端的内容是JSON形式的，而如果只是单独需要某个方法返回JSON则可以接口注释@Controller而具体某个方法上注释@ResponseBody

@RequestParam：表示接受对应的请求里需要带有单个参数

@RequestBody：表示接受对应的请求里需要带有请求体

接下来在在cloud-photo-users项目里的UserController进行接口测试

1.先创建一个common包导入下面代码，作用是把返回的数据封装一下

BaseErrorInfo

package com.cloud.photo.users.common;
    
    /**
     * 自定义描述错误接口
     * @author linzsh
     */
    public interface BaseErrorInfo {
        /**
         * 错误码
         * @return 错误码
         */
        Integer getResultCode();
    
        /**
         * 错误描述
         * @return 错误描述
         */
        String getResultMsg();
    }

CommonEnum：封装常用的自定义错误枚举类

package com.cloud.photo.users.common;
    
    /**
     * 自定义错误枚举类
     * @author linzsh
     */
    public enum CommonEnum implements BaseErrorInfo {
    
        //success
        SUCCESS(200, "成功！"),
    
        //error
        INTERNAL_SERVER_ERROR(90500, "服务器内部错误!"),
    
        SAVE_ERROR(90401, "插入失败!"),
        LOGIN_INFO_IS_NULL(90400, "登录信息为空!"),
        USERNAME_PASSWORD_ERROR(90400, "请检查账密是否正确!"),
        PHONE_IS_NULL(90400, "手机号不能为空!"),
        PHONE_IS_NOT_VALID(90400, "手机号不合法!"),
        FILE_LIST_IS_NULL(90400, "上传的文件列表未空!"),
        TRANS_IS_NULL(90404, "传输列表为空!"),
        LOGIN_FAIL(90400, "登录失败!"),
        USER_INFO_NOT_INPUT(90401, "你是第一次登录, 请补全用户信息!"),
        NO_LOGIN(90402, "您未登录!"),
        USER_IS_NULL(90404, "用户信息不存在!"),
        UNAUTHORIZED_CODE(90402,"登录Token过期，请重新登陆！"),
        NO_PERMISSION_CODE(90406, "没有权限进行此操作！"),
        FILE_NOT_UPLOADED(90407, "文件未上传！"),
        FILE_UPLOADED_ERROR(90408, "文件上传出错！"),
        NO_UPLOAD_FILE(90409, "没有获取到传输列表！"),
        ;
    
        //数据操作错误定义
        /** 错误码 */
        private final Integer resultCode;
    
        /** 错误描述 */
        private final String resultMsg;
    
        CommonEnum(Integer resultCode, String resultMsg) {
            this.resultCode = resultCode;
            this.resultMsg = resultMsg;
        }
    
        @Override
        public Integer getResultCode() {
            return this.resultCode;
        }
    
        @Override
        public String getResultMsg() {
            return this.resultMsg;
        }
    }

ResultBody：封装数据体

package com.cloud.photo.users.common;
    
    import com.alibaba.fastjson.JSONObject;
    import lombok.Data;
    
    /**
     * 业务响应体
     *
     * @author linzsh
     */
    @Data
    public class ResultBody {
        /**
         * 响应业务代码
         */
        private Integer code;
    
        /**
         * 响应消息
         */
        private String message;
    
        /**
         * 响应结果
         */
        private Object data;
    
        /**
         * 请求ID
         */
        private String requestId;
    
        public ResultBody() {
        }
    
        public ResultBody(BaseErrorInfo errorInfo) {
            this.code = errorInfo.getResultCode();
            this.message = errorInfo.getResultMsg();
        }
    
        /**
         * 返回默认成功
         *
         * @return ResultBody
         */
        public static ResultBody success() {
            return success(null, CommonEnum.SUCCESS);
        }
    
        /**
         * 成功
         *
         * @param data 数据响应体
         * @return ResultBody
         */
        public static ResultBody success(Object data,String requestId) {
            ResultBody rb = new ResultBody();
            rb.setCode(CommonEnum.SUCCESS.getResultCode());
            rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
            rb.setData(data);
            rb.setRequestId(requestId);
            return rb;
        }
    
        /**
         * 成功
         *
         * @param data 数据响应体
         * @return ResultBody
         */
        public static ResultBody success(Object data) {
            ResultBody rb = new ResultBody();
            rb.setCode(CommonEnum.SUCCESS.getResultCode());
            rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
            rb.setData(data);
            return rb;
        }
    
        /**
         * 成功
         *
         * @param data 数据体
         * @param errorInfo 一个业务状态枚举
         * @return ResultBody
         */
        public static ResultBody success(Object data, BaseErrorInfo errorInfo) {
            ResultBody rb = new ResultBody();
            if (errorInfo == null) {
                rb.setCode(CommonEnum.SUCCESS.getResultCode());
                rb.setMessage(CommonEnum.SUCCESS.getResultMsg());
            } else {
                rb.setCode(errorInfo.getResultCode());
                rb.setMessage(errorInfo.getResultMsg());
            }
            rb.setData(data);
            return rb;
        }
    
        /**
         * 失败
         * @param errorInfo 状态信息
         * @return ResultBody
         */
        public static ResultBody error(BaseErrorInfo errorInfo) {
            ResultBody rb = new ResultBody();
            rb.setCode(errorInfo.getResultCode());
            rb.setMessage(errorInfo.getResultMsg());
            rb.setData(null);
            return rb;
        }
    
        /**
         * 失败
         * @param code 状态码
         * @param message 状态描述
         * @return ResultBody
         */
        public static ResultBody error(Integer code, String message,String requestId) {
            ResultBody rb = new ResultBody();
            rb.setCode(code);
            rb.setMessage(message);
            rb.setData(null);
            rb.setRequestId(requestId);
            return rb;
        }
    
    
        /**
         * 失败
         * @param message 状态描述
         * @return ResultBody
         */
        public static ResultBody error(String message) {
            ResultBody rb = new ResultBody();
            rb.setCode(CommonEnum.INTERNAL_SERVER_ERROR.getResultCode());
            rb.setMessage(message);
            rb.setData(null);
            return rb;
        }
    
        /**
         * 失败
         * @param code 状态码
         * @param message 状态描述
         * @return ResultBody
         */
        public static ResultBody error(Integer code, String message) {
            ResultBody rb = new ResultBody();
            rb.setCode(code);
            rb.setMessage(message);
            rb.setData(null);
            return rb;
        }
    
        @Override
        public String toString() {
            return JSONObject.toJSONString(this);
        }
    
    }

2.写一个getUserInfo方法用来返回用户的手机信息

package com.cloud.photo.users.controller;
    
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.cloud.photo.users.common.CommonEnum;
    import com.cloud.photo.users.common.ResultBody;
    import com.cloud.photo.users.entity.User;
    import com.cloud.photo.users.service.UserService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    import org.springframework.stereotype.Controller;
    
    /**
     * <p>
     *  前端控制器
     * </p>
     *
     * @author ltao
     * @since 2023-07-09
     */
    @RestController
    @RequestMapping("/users")
    @Slf4j
    public class UserController {
        @Autowired
        private UserService userService;
    
        /**
         * 获得用户信息，根据用户手机获取用户信息
         * @param phone
         * @return resultBody
         */
        @GetMapping("/getUserInfo")
        public ResultBody getUserInfo(@RequestParam(value = "phone") String phone){
            log.info("getUserInfo-phone"+ phone + ",start!");
    
            User user = userService.getOne(new QueryWrapper<User>().eq("phone",phone));
    
            log.info("getUserInfo()-phone=" + phone + ",user=" + user);
    
            ResultBody resultBody = (user == null ) ? ResultBody.error(CommonEnum.USER_IS_NULL) : ResultBody.success(user);
    
            log.info("getUserInfo()-phone=" + phone + ",resultBody=" + resultBody);
    
            return resultBody;
    
        }
    
        /**
         * 添加用户
         * @param user 需要一个请求体,发送请求的时候可以根据User来构造一个
         * @return
         */
        @PostMapping("/addUser")
        public ResultBody addUser(@RequestBody User user){
            boolean result = userService.save(user);
            return result ? ResultBody.success() : ResultBody.error(CommonEnum.SAVE_ERROR);
        }
    }

3.用postman或者自己选用其他方法进行测试接口

3.1先根据User的数据类型插入一条信息，根据User结果编写json的请求体

![77180d8477374f50a19fa99724e071f7.png][]

可以看到插入成功

![2c8ffe8b7cbd4ad0be02300116349301.png][]

**注意：**中途我出现了 mybatis-plus出现Invalid bound statement (not found) com.atguigu.admin.service.UserService.getBaseMappe的报错

**解决：**这里的MapperScan要详细，不能是.\*这样泛

![c54251068feb41568b29d9cba9a41559.png][]

3.2 接下来测试查询方法

![e16035980dd146d5b98765971feef348.png][]

成功发送后可以看到

![52f82ca4b4ee4b1cbe53caac2825c398.png][]

## Nacos ##

Nacos在微服务中的作用是

*  将子服务或者子项目在上面进行一个注册，相当于一个通讯录，方便其他服务需要调用相关信息的时候找到对应服务

官网地址：[Nacos 快速开始][Nacos]

下载地址：[Releases · alibaba/nacos (github.com)][Releases _ alibaba_nacos _github.com]

找到自己想要的版本 （官方推荐2.1.1，但具体看当时的官方文档推荐）

![8e3bf9af622143c48a8d568ce94d16d1.png][]

![5d15ea955bae45319e37e55b682f9ff7.png][]

![226c3d90bcaf4b778428963cfefe467d.png][]

1. 解压nacos

![77afdf869de24ffb831be55b47c692a0.png][]

2. 修改配置

进入/conf目录，用文本编辑器打开application.properties文件

\#启用登录校验

nacos.core.auth.enabled=true

\#设置账号密码

nacos.core.auth.server.identity.key=nacos
    nacos.core.auth.server.identity.value=nacos

\#修改secretKey（这个不做强制要求，看你具体情况）

nacos.core.auth.plugin.nacos.token.secret.key=CloudPhoto0123456789012345678901234567890123 45678901234567890123456789

![97adc68b633347aab2f1a579fc5d5578.png][]

3. 进入/bin目录，执行命令启动nacos，standalone表示单机启动

startup.cmd -m standalone

![67b6bf2371014e338eb60af2d99b5c29.png][]

修改集群变成单机

在`bin`文件夹下，修改`startup.cmd`里面的内容 ，找到**`set MODE="cluster"`**,替换为**`set MODE="standalone"`**，原来默认的是集群，现在修改为单机模式

![d77a8d924a864b4fbeeafa846435ec54.png][]

4.复制 给出的网页然后复制粘贴到浏览器去访问，成功则会出现下面界面

![4cbf810911074eb7a35ddf637408bf84.png][]

5.在IDEA里集成nacos

导入依赖

<dependency>
                <groupId>com.alibaba.nacos</groupId>
                <artifactId>nacos-client</artifactId>
                <version>2.1.1</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            </dependency>

yml配置 ，addr要根据启动后的nacos再来修改

nacos:
          discovery:
            username: nacos
            password: nacos
            server-addr: 127.0.0.1:8848

![7409f6d266124bcf864ebb476f9092c1.png][]

要记得也要去启动类的上面配置**@EnableDiscoveryClient**注解

![97e92e8aa4774921bbfa04328ad10ee0.png][]

启动过程这里会有一个红色的报错可以不用去理会他，因为服务一启动就会去nacos读配置，但如果没有数据的话回去微服务里的yml中寻找配置信息。

![aca378f768de455ba26cc06b9918ff18.png][] 如果启动的过程遇到了以下的报错可以在application name下面配置下面信息，意思是把web-application-type这个不启动，因为现在是发生了冲突

![f37efa12a728493da0c2262fc5b7e6bd.png][]

![53d691d0579d4f8f92565128cd822d29.png][]

项目启动成功后去nacos查看相关微服务已经被我们注册上来了

![03254a6504924027bc0a3ca582fa4c2f.png][]

接下来把其他服务也启动然后注册进来

![a4682882cb4a4c09aac3d4ea880ea8cf.png][]

![fbdf862422c447e4891207fdbc03b6fb.png][]

6.关闭（Windows下），意思就是直接关闭cmd窗口也可以

cmd shutdown.cmd

## Fegin ##

是一种负载均衡的HTTP客户端, **使用Feign调用API就像调用本地方法一样**，从避免了 调用目标微服务时，需要不断的解析/封装json 数据的繁琐

1.pom添加依赖

![b2f85ec5b05d4fe4ad0d4e53543f194f.png][]

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
                <version>2.1.3.RELEASE</version>
            </dependency>

2.在启动类上加入注解，表示feign接口扫描，

@EnableFeignClients(basePackages = {"com.cloud.photo.api.feign"})

3.测试

接下来在api项目中调用user服务中查询客户信息的测试。

大致流程思路：

3.1.在api子项目中创建一个接口类Api2UserFeginService,并在类上注释**@FeignClient("cloud-photo-user")，**表示这个调用了这个接口类的方法后就要去该**cloud-photo-user**项目下去寻找对应的方法具体实现，就像调用本地方法一样

![a9bc90ccddc34b199643d2cf58e4921c.png][]

![dfa4076a6f634af487cf17f8b3194bf3.png][]

3.2然后再编写一个Api2UserController，这是一个专属于Controller的方法，通过专属的api然后在里面调用 Api2UserFegin，Api2UserFegin再去寻找user子项目中具体的方法

![f163fbbe8e7a4dc2a946b9e14028bc5a.png][]

3.3同时在api项目的application.yml文件里配置上，Feign的负载均衡底层用的就是Ribbon，所以这里的请求超时配置其实就是配置Ribbon

# feign 超时配置
    feign:
      client:
        config:
          default:
            # 超时设置 30 秒超时
            connectTimeout: 30000 #请求连接超时时间
            readTimeout: 30000 #请求处理的超时时间

3.4启动nacos，和启动其他服务，将服务注册到nacos上，再打开redis。这里我只启动了users和api服务，然后发送请求

![9d8538a3f9474e0f86d281f6e8a9c907.png][]

发送成功后结果如下：

![e9fd2e45381642fdbeeff7b22c163a34.png][]

![a2cea9068d88427b8c2c4aaa581684ee.png][]

**总体思路**：在一个服务如api想调用另一个服务如users时候要通过nacos先把服务注册到一个类似通讯录的地方然后通过fegin进行转发。如在api中写一个api/getUserInfo的Controller，再写一个fegin接口，里面调用user的接口进行转发，然后请求发到api上的时候再通过fegin把请求丢给user去处理

**注意!!!!!：**

1.报错：No qualifying bean of type ‘org.springframework.boot.autoconfigure.http.HttpMessageConverters‘ available

[No qualifying bean of type ‘org.springframework.boot.autoconfigure.http.HttpMessageConverters‘ avail\_kkoneone11的博客-CSDN博客][No qualifying bean of type _org.springframework.boot.autoconfigure.http.HttpMessageConverters_ avail_kkoneone11_-CSDN]

2.报错：Could not autowire. No beans of ‘Api2UserFegin‘ type found

[使用feign调用的时候出现Could not autowire. No beans of ‘Api2UserFegin‘ type found报错\_kkoneone11的博客-CSDN博客][feign_Could not autowire. No beans of _Api2UserFegin_ type found_kkoneone11_-CSDN]

Api2UserFegin

package com.cloud.photo.api.feign;
    
    import com.cloud.photo.api.common.ResultBody;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    
    /**
     * @Author：kkoneone11
     * @name：Api2UserFeginService
     * @Date：2023/7/12 10:53
     */
    
    
    /**
     * @FeignClient 表明要去寻找的项目的名字
     */
    
    @FeignClient("cloud-photo-users")
    @RequestMapping("/users")
    public interface Api2UserFegin {
    
        /**
         * 调用use服务下的接口，注意接口调用要对应到具体的方法
         * @param phone
         * @return
         */
        @GetMapping("/getUserInfo")
        ResultBody getUserInfo(@RequestParam(value = "phone") String phone);
    }

Api2UserController

package com.cloud.photo.api.controller;
    
    import com.cloud.photo.api.common.ResultBody;
    import com.cloud.photo.api.feign.Api2UserFegin;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @Author：kkoneone11
     * @name：Api2UserController
     * @Date：2023/7/12 10:53
     */
    
    /**
     * 通过"/api/getUserInfo"路径去访问Api2UserController
     */
    @RestController
    @Slf4j
    @RequestMapping("/api")
    public class Api2UserController {
        @Autowired
        private Api2UserFegin api2UserFegin;
    
    
        @GetMapping("/getUserInfo")
        public ResultBody getUserInfo(@RequestParam(value = "phone") String phone){
            log.info("getUserInfo() - phone =" + phone + ",start!");
            //使用fegin调用
            ResultBody resultBody = api2UserFegin.getUserInfo(phone);
            log.info("getUserInfo() - phone" + phone + ",resultBody" + resultBody);
            return resultBody;
        }
    }

## SpringCloudGateway ##

通过gateway将请求

1.相关配置

1.1导入依赖

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>

1.2SpringCloudGateway的yml配置

解析一下gateway中第一段id的含义：

*  id:指明这次路由的名字
 *  uri: lb意思是负载均衡，如果nacos里找到5个则会负载到其中的一个，而cloud-photo-api是最终要去的服务。从注册中心获取
 *  predicates:断言，就是发送的请求带有Path=/api/\*这种前缀的就要去到上面的loud-photo-api
 *  filters:过滤器：这里是重写路径，通过正则表达式修改。这里的意思是把/api/前面的路径都删除只保留后面的，如localhost:88/api/getUserInfo --> localhost:9009/getUserInfo
 *  order，用于多个 Route 之间的排序，数值越小排序越靠前，匹配优先级越高。

这里执行顺序是：当发送一个请求过来的时候断言拦截到，然后交给filter处理完再丢回给uri

spring:
      cloud:
        #  网关配置
        gateway:
          routes:
            #   高优先级路由放前面
            - id: api_route
              uri: lb://cloud-photo-api
              predicates:
                - Path=/api/**
              #  localhost:88/api/** --> localhost:10000/**
              filters:
              # - RewritePath=/api/(?<segment>/?.*), /$\{segement}
            - id: audit_route
              uri: lb://cloud-photo-audit
              predicates:
                - Path=/audit/**
              #   localhost:88/audit/** --> localhost:10000/**
              filters:
                - RewritePath=/audit/(?<segment>/?.*), /$\{segement}
        # nacos config
        nacos:
          discovery:
            username: nacos
            password: nacos
            server-addr: 192.168.252.1:8848
      redis:
        host: 127.0.0.1
        port: 6379
    
      application:
        name: cloud-photo-gateway
      main:
        web-application-type: reactive
      datasource:
        url: jdbc:mysql://localhost:3306/photo?useSSL=false&characterEncoding=UTF-8&allowPublicKeyRetrieval=true
        username: root
        password: 1234
        driver-class-name: com.mysql.jdbc.Driver
    
      kafka:
        bootstrap-servers: 127.0.0.1:9092
        producer: # producer 生产者
          retries: 0 # 重试次数
          acks: 1 # 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
          batch-size: 16384 # 批量大小
          buffer-memory: 33554432 # 生产端缓冲区大小
          key-serializer: org.apache.kafka.common.serialization.StringSerializer
          value-serializer: org.apache.kafka.common.serialization.StringSerializer
        consumer: # consumer消费者
          group-id: javagroup # 默认的消费组ID
          enable-auto-commit: true # 是否自动提交offset
          auto-commit-interval: 100  # 提交offset延时(接收到消息后多久提交offset)
    
          # earliest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
          # latest:当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
          # none:topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
          auto-offset-reset: latest
          key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
          value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    #服务端口
    server:
      port: 88

1.3.MyCorsConfiguration跨域类

![5f34f7e5f81e4ebaaeb9d831e9291dd4.png][]

package com.photo.gateway.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.cors.CorsConfiguration;
    import org.springframework.web.cors.reactive.CorsWebFilter;
    import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
    
    /**
     * 跨域配置
     * @author linzsh
     */
    @Configuration
    public class MyCorsConfiguration {
    
        @Bean
        public CorsWebFilter corsWebFilter() {
            UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
            CorsConfiguration corsConfiguration = new CorsConfiguration();
    
            //1、配置跨域
    
            //允许哪些请求头头进行跨域
            corsConfiguration.addAllowedHeader("*");
            //允许哪些请求方式进行跨域
            corsConfiguration.addAllowedMethod("*");
            //允许哪些请求来源进行跨域
            corsConfiguration.addAllowedOrigin("*");
            //允许携带cookies
            corsConfiguration.setAllowCredentials(true);
    
            source.registerCorsConfiguration("/**", corsConfiguration);
    
            return new CorsWebFilter(source);
        }
    }

![d5785a313ba848a6bd7ab372b971c3b4.png][]

2.测试

2.1启动gateway主类确保都在nacos注册了

![9041ef8fcb674c15acce0dbd9c2683b6.png][]

2.2往网关里发一条请求，使请求远程调用user中的getUserInfo。这里是发送了一条[http://localhost:88/api/getUserInfo?phone=123456][http_localhost_88_api_getUserInfo_phone_123456]

请求 http://localhost:88/api/getUserInfo?phone=123456，进入网关后在断言处判断，然后通过filter变成localhost:9009/getUserInfo再丢给了api服务中去处理，而Api2UserController接受到之后又调用了fegin进行请求转发到user中去调用对应Controller处理

![c876e9996a244edf8f69956e0ad08367.png][]

## S3存储-minio ##

介绍：

S3 Simple Storage Service 简单存储服务，对象存储在存储段（bucket） 中，S3对象存储是亚马逊AWS提供的一种云存储服务，它可以帮助用户存储 和检索任意数量的数据，而且具有高可用性、高可靠性和高扩展性等优点。 在S3对象存储中，数据以对象的形式存储，每个对象都有一个唯一的键( key) 和一个值（ value )，并且可以通过HTTP或HTTPS协议进行访问

*  **高可用性/多副本**:如果某个物理位置发生故障，S3对象存储会自动将数据 切换到其他可用的位置，从而保证数据的连续性和可用性。 
 *  **可扩展性:**S3对象存储可以存储任意数量的数据，而且可以根据需要自动扩 展存储容量。 
 *  **多方式访问:**包括REST AP1、AWS SDK、命令行工具等，以满足不同的应 用场景和需求。 
 *  bucket/endPoint/AK/SK

1.配置

1.1hutool工具类导入依赖，如果用的阿里云的话version可能不用这么高，不然导入不成功

<dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.7.4</version>
    </dependency>

<dependency>
                <groupId>com.amazonaws</groupId>
                <artifactId>aws-java-sdk-core</artifactId>
                <version>1.12.487</version>
            </dependency>
    
    
            <dependency>
                <groupId>com.amazonaws</groupId>
                <artifactId>aws-java-sdk-s3</artifactId>
                <version>1.12.487</version>
            </dependency>

1.2导入S3Util工具类

![b06df7e688b849e894aa9e9a826f14e8.png][]

按照自己的实际情况修改

*  accessKey：登录账号
 *  secretKey：登录密码
 *  bucketName：要操作的桶名
 *  serviceEndpoint：minio或者华为云obs地址

package com.cloud.photo.api.utils;
    
    import cn.hutool.core.codec.Base64;
    import com.alibaba.fastjson.JSONObject;
    import com.amazonaws.HttpMethod;
    import com.amazonaws.auth.AWSCredentials;
    import com.amazonaws.auth.AWSStaticCredentialsProvider;
    import com.amazonaws.auth.BasicAWSCredentials;
    import com.amazonaws.auth.profile.ProfileCredentialsProvider;
    import com.amazonaws.client.builder.AwsClientBuilder;
    import com.amazonaws.services.s3.AmazonS3;
    import com.amazonaws.services.s3.AmazonS3ClientBuilder;
    import com.amazonaws.services.s3.model.*;
    import org.apache.commons.lang.StringUtils;
    import org.apache.tomcat.util.buf.HexUtils;
    
    import java.io.*;
    import java.net.URL;
    import java.net.URLEncoder;
    import java.util.*;
    
    import static org.bouncycastle.asn1.x500.style.RFC4519Style.cn;
    
    public class S3Util {
    
    
    
    
        //本地minio或者华为云的账号密码
        private static String accessKey = "minioadmin";
        private static String secretKey = "minioadmin";
        private static String bucketName = "cloud-photo";
        //本地minio或者华为云的连接
        private static String serviceEndpoint = "http://127.0.0.1:9000";
    
    
        private static String containerId = "10001";
    
        /**
         * 获取上传地址
         * @param suffixName
         * @param fileMd5
         * @return
         */
        public static String getPutUploadUrl(String suffixName,String fileMd5) {
    
            //链接过期时间
            Date expiration = new Date();
            long expTimeMillis = expiration.getTime();
            expTimeMillis += 1000 * 60 * 10;
            expiration.setTime(expTimeMillis);
            String objectId = UUID.randomUUID().toString().replaceAll("-","");
            String base64Md5 = "";
            if(StringUtils.isNotBlank(suffixName)){
                objectId = objectId +"." + suffixName;
            }
            //建立S3客户端，获取上传地址
            AmazonS3 s3Client = getAmazonS3Client();
            GeneratePresignedUrlRequest generatePresignedUrlRequest =
                    new GeneratePresignedUrlRequest(bucketName, objectId)
                            .withMethod(HttpMethod.PUT)
                            .withExpiration(expiration);
            if(StringUtils.isNotBlank(fileMd5)){
                base64Md5= Base64.encode(HexUtils.fromHexString(fileMd5));
                generatePresignedUrlRequest = generatePresignedUrlRequest.withContentMd5(base64Md5);
            }
            URL url = s3Client.generatePresignedUrl(generatePresignedUrlRequest);
    
            JSONObject jsonObject =new JSONObject();
            jsonObject.put("objectId",objectId);
            jsonObject.put("url",url);
            jsonObject.put("containerId",containerId);
            jsonObject.put("base64Md5",base64Md5);
            return jsonObject.toJSONString();
        }
    
        /**
         * 获取文件资源池信息
         * @param objectId
         * @return
         */
        public static S3ObjectSummary getObjectInfo(String objectId){
            AmazonS3 s3Client = getAmazonS3Client();
    
            ListObjectsV2Request listObjectsRequest = new ListObjectsV2Request()
                    .withBucketName(bucketName)
                    .withPrefix(objectId);
    
            ListObjectsV2Result listing = s3Client.listObjectsV2(listObjectsRequest);
            List<S3ObjectSummary> s3ObjectSummarieList = listing.getObjectSummaries();
    
            if(s3ObjectSummarieList!=null && s3ObjectSummarieList.size()>0){
                return s3ObjectSummarieList.get(0);
            }
            return null;
        }
    
        public static String getDownloadUrl(String containerId, String objectId){
            return getDownloadUrl(containerId, objectId,null);
        }
    
        public static String getDownloadUrl(String containerId, String objectId,String filename) {
            AmazonS3 s3Client = getAmazonS3Client();
            GeneratePresignedUrlRequest httpRequest = new GeneratePresignedUrlRequest(bucketName, objectId);
            //设置过期时间
            Date expiration = new Date();
            long expTimeMillis = expiration.getTime();
            expTimeMillis += 1000 * 60 * 10;
            expiration.setTime(expTimeMillis);
            httpRequest.setExpiration(expiration);
    
            if(StringUtils.isNotBlank(filename)){
                String responseContentDisposition = null;
                try {
                    responseContentDisposition = "attachment;filename=" + URLEncoder.encode(filename, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                httpRequest.addRequestParameter("response-content-disposition", responseContentDisposition);
            }
            return s3Client.generatePresignedUrl(httpRequest).toString();
    
        }
    
        private static AmazonS3 getAmazonS3Client(){
            AwsClientBuilder.EndpointConfiguration endpointConfiguration =new AwsClientBuilder.EndpointConfiguration(serviceEndpoint,"");
            AWSCredentials awsCredentials = new BasicAWSCredentials(accessKey, secretKey);
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withCredentials(new AWSStaticCredentialsProvider(awsCredentials))
                    .withEndpointConfiguration(endpointConfiguration)
                    .build();
            return s3Client;
        }
    
        /**
         * 查询桶列表
         */
        public static void getBuckets() {
            AmazonS3 s3Client = getAmazonS3Client();
            List<Bucket> bucketList = s3Client.listBuckets();
            for (int i = 0; i < bucketList.size(); i++) {
                System.out.println(bucketList.get(i).getName());
            }
        }
    
    
    
        /**
         * 查询桶的文件
         */
    
        public static void listObjects() {
            AmazonS3 s3Client = getAmazonS3Client();
            ListObjectsRequest listObjectRequest = new ListObjectsRequest();
            ObjectListing objectListing = null;
            listObjectRequest.setBucketName(bucketName);
            // listObjectRequest.setPrefix("DATALAKE/LF02/");
    
            int j=0;
            int num =0;
            do {
                objectListing = s3Client.listObjects(listObjectRequest);
                List<S3ObjectSummary> s3ObjectSummaries = objectListing.getObjectSummaries();
                if (s3ObjectSummaries != null && s3ObjectSummaries.size() > 0) {
                    for (int i = 0; i < s3ObjectSummaries.size(); i++) {
                        num =j*1000+i;
                        System.out.println(num+"|"+j+"|"+i + "|" + s3ObjectSummaries.get(i).getKey() + "|" + s3ObjectSummaries.get(i).getETag());
                    }
                }
                j++;
                listObjectRequest.setMarker(objectListing.getNextMarker());
            } while (objectListing.isTruncated());
        }
    
        /**
         * 生成下载地址
         */
    
        public static void  genDownloadUrl  (){
            AmazonS3 s3Client = getAmazonS3Client();
            //华为obs存储文件路径
            String key = "123.jpg";
            //一小时后
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.HOUR,1);
            Date expiration = calendar.getTime();
            //生成下载地址
            URL url = s3Client.generatePresignedUrl(bucketName,key,expiration);
            String downloadUrl = url.getProtocol()+"://"+url.getHost()+":9000"+url.getFile();
    
            System.out.println(downloadUrl);
        }
    
        /**
         * 一次上传
         */
    
        public static void putObjectTest(){
            AmazonS3 s3Client = getAmazonS3Client();
            String key = "12345789.jpg";
            File file = new File("D:/peixun/img/123.jpg");
            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName,key,file);
            s3Client.putObject(putObjectRequest);
            System.out.println("putObjectTest success + src="+file.getName()+",obs dest ="+key);
        }
    
        /**
         * 分片上传
         */
    
        public static void multiPut()  {
            AmazonS3 s3Client = getAmazonS3Client();
            //初始化上传
            String key = "33333";
            InitiateMultipartUploadRequest initiateMultipartUploadRequest = new InitiateMultipartUploadRequest(bucketName,key);
            InitiateMultipartUploadResult initiateMultipartUploadResult = s3Client.initiateMultipartUpload(initiateMultipartUploadRequest);
            if(initiateMultipartUploadResult!=null){
                String uploadId = initiateMultipartUploadResult.getUploadId();
                //上传文件
                UploadPartRequest uploadPartRequest = new UploadPartRequest().withUploadId(uploadId);
                uploadPartRequest.setUploadId(uploadId);
                uploadPartRequest.setBucketName(bucketName);
                uploadPartRequest.setKey(key);
                List<PartETag> partETags = new ArrayList<>();
                byte[] content = new byte[5*1024*1024];
                String filePath = "d:\\SQLyog-13.1.8-0.x64Trial.exe";
                File file = new File(filePath);
                try{
                    FileInputStream fis = new FileInputStream(file);
                    BufferedInputStream bis = new BufferedInputStream(fis);
                    int readSize = 0;
                    int partNum =1;
                    while ((readSize = bis.read(content)) > 0) {
                        uploadPartRequest.setPartSize(readSize);
                        uploadPartRequest.setPartNumber(partNum);
                        uploadPartRequest.setInputStream(new ByteArrayInputStream(content));
                        partNum++;
                        UploadPartResult  uploadPartResult= s3Client.uploadPart(uploadPartRequest);
                        partETags.add(uploadPartResult.getPartETag());
                        System.out.println("uploadPartResult:"+uploadPartResult.getPartNumber()+"|"+uploadPartResult.getETag()+"|"+uploadPartResult.getServerSideEncryption()+"|"+uploadPartResult.getPartETag());
                    }
    
    
                }catch (Exception e){
                    e.printStackTrace();
                }
    
    
                //合并提交
                CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest(bucketName, key, uploadId, partETags);
                s3Client.completeMultipartUpload(compRequest);
            }
        }
    
        /**
         * 刪除文件
         */
    
        public static void delObject(){
            AmazonS3 s3Client = getAmazonS3Client();
    
            String key = "123.jpg";
            s3Client.deleteObject(bucketName,key);
    
        }
    
    
    
    
    
    
        public static void main(String[] args) {
    
    
          //getBuckets();
    
            listObjects();
    
           //putObject();
    
           // multiPut();
    
    
    
    
          // genDownloadUrlTest();
           // delObject();
    
           //  System.out.println("uuuuu======"+url);
    
    
    
        }
    }

2.测试

最下方有主方法可以直接进行每个方法的测试

2.1查看桶 getBucketsTest();

![e07c158d6c0d4f1482947652e92c091b.png][]

2.2分片上传 multiPutTest(); 记得修改上传文件的路径

![ec6b2071a1b64967ad63bf7b139fe655.png][]

2.3genDownloadUrlTest()获取上传路径

![db0fa3384e924a4795997e2f69058852.png][]

注意！！：遇到NoClassDefFoundError: org/joda/time/DateTimeZone报错可以在pom里添加一个

<dependency>
                <groupId>joda-time</groupId>
                <artifactId>joda-time</artifactId>
                <version>2.10</version>
            </dependency>

本机下创建一个文件夹，里面创建四个文件相当于四个节点

![40705730d188495ca879beef2d6e682f.png][]

![f85fb62bc24f4bd2b7444691f34ebb30.png][]

打开cmd窗口，输入已下命令启动minio的服务。如果是四台虚拟机，则文件路径换成虚拟机的http访问路径即可

minio.exe server D:\software\minio\minio_data\data1 D:\software\minio\minio_data\data2 D:\software\minio\minio_data\data3 D:\software\minio\minio_data\data4

![348af15f30f344f6913f7a99867d11e4.png][]

![6099de3f95054fc5950db54a8db39051.png][]

![ee0b622b50f54400b698207d68f6bc82.png][]

创建一个testbucket桶![61457f17f4c5470193d0915a217e7884.png][]

随便查看一个节点可以看到已经有创建好的testbucket

![83bb1315292047ffb4cca01ea9c1fb4c.png][]

上传文件

![57ca2bd3dd114cfcaae880b1b4569ca8.png][]

## S3存储-华为云OBS ##

## ![ccaabb64f90444f08bcd3cb81fd8cb14.png][] ##

[31a879257bfd4d82b4b77ed39b69eae7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/8e09d6efa080407694364f10d2ac352a.png
[590acfc1232048fb8af14e9eab45a626.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1a2f64b3a59e498094c6c3d85eaf64eb.png
[77180d8477374f50a19fa99724e071f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/d5f2babd23104c6f89b180739a82ee6d.png
[2c8ffe8b7cbd4ad0be02300116349301.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/673875398fc1408db7f8889fde85441f.png
[c54251068feb41568b29d9cba9a41559.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/79bf78158d6e46b1a65e7a02559f388f.png
[e16035980dd146d5b98765971feef348.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/b39a4be0951b470897b66a0a8487f1ad.png
[52f82ca4b4ee4b1cbe53caac2825c398.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/668671394e824fbc98f1187e7a7d5732.png
[Nacos]: https://nacos.io/zh-cn/docs/v2/quickstart/quick-start.html
[Releases _ alibaba_nacos _github.com]: https://github.com/alibaba/nacos/releases
[8e3bf9af622143c48a8d568ce94d16d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/7ec9bf7922b24ac2b05104d1ab9db0c2.png
[5d15ea955bae45319e37e55b682f9ff7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/3ad628b6390d41b9a0c1d648c96d6fbd.png
[226c3d90bcaf4b778428963cfefe467d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/7777ffeb180c4fb980bf401c2a775bff.png
[77afdf869de24ffb831be55b47c692a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/5c53617eff964e509ac4695d247837c8.png
[97adc68b633347aab2f1a579fc5d5578.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/4e5e97e2e8b049daa4d18cb91857395d.png
[67b6bf2371014e338eb60af2d99b5c29.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/dfbc1ffbd6984ae8a76f2933fd02404b.png
[d77a8d924a864b4fbeeafa846435ec54.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/979ac0e3d00b418d867e8130c80ee353.png
[4cbf810911074eb7a35ddf637408bf84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/484729c046544b889ec9411d39df8bc0.png
[7409f6d266124bcf864ebb476f9092c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/cd8f142907a04d638dbb164625948f1e.png
[97e92e8aa4774921bbfa04328ad10ee0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a31fa21c42c843f9a7cfe78bd1a6b649.png
[aca378f768de455ba26cc06b9918ff18.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/60275d55c28b48e3af37b62dfecc18c4.png
[f37efa12a728493da0c2262fc5b7e6bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/af98cb018bb44fb0af3d5248c631535d.png
[53d691d0579d4f8f92565128cd822d29.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/ed3657c143f94476ae3d140712e0ed68.png
[03254a6504924027bc0a3ca582fa4c2f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/9fa0b31e5a634fbb8b62888559c18659.png
[a4682882cb4a4c09aac3d4ea880ea8cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/27e3d6c06a0146c4906f996635f7b035.png
[fbdf862422c447e4891207fdbc03b6fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/23078628d1924215a5f2f75904454abe.png
[b2f85ec5b05d4fe4ad0d4e53543f194f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a920ec6ec608488eb34aa1f048235e1a.png
[a9bc90ccddc34b199643d2cf58e4921c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/90a133cdd9794279b0743540ccc24060.png
[dfa4076a6f634af487cf17f8b3194bf3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/e3e4c1472e574bc7ab5180ef474d8f73.png
[f163fbbe8e7a4dc2a946b9e14028bc5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/8503513aff7840c394b9528cfa1be472.png
[9d8538a3f9474e0f86d281f6e8a9c907.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/75693d4d63274aa79443098c07707490.png
[e9fd2e45381642fdbeeff7b22c163a34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/5e055abd7a1c4da985af488be77b905c.png
[a2cea9068d88427b8c2c4aaa581684ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/552125300b534881a02e13242131c37e.png
[No qualifying bean of type _org.springframework.boot.autoconfigure.http.HttpMessageConverters_ avail_kkoneone11_-CSDN]: https://blog.csdn.net/m0_62314761/article/details/131680802
[feign_Could not autowire. No beans of _Api2UserFegin_ type found_kkoneone11_-CSDN]: https://blog.csdn.net/m0_62314761/article/details/131680256
[5f34f7e5f81e4ebaaeb9d831e9291dd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/13e725f9e2fb4ae4bdec2e4212a6df4c.png
[d5785a313ba848a6bd7ab372b971c3b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/0f948b57b2864fc3a444661e182c9ccd.png
[9041ef8fcb674c15acce0dbd9c2683b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/34f190736f124489babb60456f455b41.png
[http_localhost_88_api_getUserInfo_phone_123456]: http://localhost:88/api/getUserInfo?phone=123456
[c876e9996a244edf8f69956e0ad08367.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/518cbd5cfcaf4a0bb573d5ca4a2b622c.png
[b06df7e688b849e894aa9e9a826f14e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a31e62fb271d44a2bad7b03c6d801167.png
[e07c158d6c0d4f1482947652e92c091b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/52c3740ec3cd4587a35dbc4092e117da.png
[ec6b2071a1b64967ad63bf7b139fe655.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/6ba5dc89ae55423c90b326ec77cb2d2e.png
[db0fa3384e924a4795997e2f69058852.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/6a4880ecd3eb4fadb55415958d4b4f33.png
[40705730d188495ca879beef2d6e682f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/53893bbb98944fc3b7f7e579c46b5d34.png
[f85fb62bc24f4bd2b7444691f34ebb30.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/fd66e17b2f3347f891a77c78a7529825.png
[348af15f30f344f6913f7a99867d11e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1c44b642830b4a1c90f01ee8332fd668.png
[6099de3f95054fc5950db54a8db39051.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/5adbf3deb8454d90925b95ac31d71dd4.png
[ee0b622b50f54400b698207d68f6bc82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/d019d24d662a4c618144f139296c2545.png
[61457f17f4c5470193d0915a217e7884.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/dc4cfbfafb4140ed90da0ca531800b3b.png
[83bb1315292047ffb4cca01ea9c1fb4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/715037277a5a473d814c6b4fd2d66869.png
[57ca2bd3dd114cfcaae880b1b4569ca8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/adc5a5d471a0452eb9a52ab90cd648b2.png
[ccaabb64f90444f08bcd3cb81fd8cb14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/d292ab3b986143a7b107bd4c156dac5d.png