SpringMVC框架的入门

Aimeiyyds

已于 2022-06-13 20:36:59 修改

阅读量186

点赞数

文章标签： mvc java 开发语言 spring

于 2022-06-08 09:22:51 首次发布

本文链接：https://blog.csdn.net/Aimeiyyds/article/details/125173539

版权

本文详细介绍了SpringMVC框架，包括MVC设计模式的基本概念，SpringMVC的工作流程，配置步骤，接收和处理请求参数的方法，以及如何返回JSON数据和处理异常。此外，还探讨了文件上传、全局异常处理和拦截器的使用，以及与前端如Element UI的交互。最后，列举了关键注解的作用，如@Controller、@RequestMapping等。

摘要由CSDN通过智能技术生成

1. 什么是MVC?

MVC 是 Model-View-Controller 的缩写。Model（模型） - View（视图） - Controller（控制器）是⼀个⽤于实现图形⽤户界⾯（GUI）程序
的软件架构模式。

2. MVC各层所执行的工作

其思想是把一个项目分成view（视图层），controller（控制层）和model（模型层）三层。三层分别负责不同的功能，view负责数据的展示和与用户的交互，controller负责对view层发来的数据进行封装和对model层发来的响应进行处理，model层接收controller层封装的数据后，对这些数据进行处理，从数据库获取数据，并反馈到controller层。

3. 什么是SpringMVC框架

springMVC它是spring框架的一个分支，该springMVC框架主要完成的功能是:接收浏览器的请求响应，对数据进行处理，然后返回页面进行显示，可以把它理解为和Servlet干的工作是一样的。

4. 为什么使用SpringMVC框架

让程序员只关心核心业务的开发，框架帮我们屏蔽原有技术跟业务开发无关的各类技术问题。

接收参数和转换为json数据时比较麻烦且重复代码多，SpringMVC框架可以帮你完成这些。

5. SpringMVC的工作流程

（1）用户发送请求至前端控制器DispatcherServlet。

（2）DispatcherServlet收到请求调用HandlerMapping处理器映射器。

（3）处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

（4）DispatcherServlet调用HandlerAdapter处理器适配器。

（5）HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

（6）Controller执行完成返回ModelAndView。

（7）HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

（8）DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

（9）ViewReslover解析后返回具体View。

（10）DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

（11）DispatcherServlet响应用户。

6. 如何使用SpringMVC

（1）创建一个maven-web工程，最好使用版本4.0的xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
</web-app>

（2）引入SpringMVC依赖，版本选后面带RELEASE的，版本稳定。

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.15.RELEASE</version>
    </dependency>
  </dependencies>

（3）注册DispatcherServlet到web.xml文件上

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <welcome-file-list>
        <welcome-file>add.jsp</welcome-file>
    </welcome-file-list>
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

（4）创建并配置SpringMVC配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--包扫描-->
    <context:component-scan base-package="com.zpb.controller"/>

</beans>

（5）创建Controller类

@Controller //该注解标记该类为处理层类---类似@WebServlet
public class HelloController {

    @RequestMapping(value = "hi") //把请求路径映射到该方法上。
    public String hi(){
        System.out.println("你好");

        return "success.jsp"; //响应一个页面
    }
}

7. 如何在controller接收请求的参数

之前通过request.getParamter("name")接参，该方法接参麻烦，类型都是String，如果数据是其他类型，需要手动转型且需要接参的数据很多时，麻烦且重复代码多。

7.1 接收少量的参数

只需要在方法里添加参数即可，但是要保证这个参数名要和请求的参数名一致。

@Controller
public class HelloServlet {
    @RequestMapping(value = "hi")
    public String hi(String says){
        System.out.println(says);
        return "success.jsp";   
    }
}

7.2 接收大量的参数

封装一个实体类来接收这些参数。

@Controller
public class UserController {

    @RequestMapping(value = "/add")
    public String add(User user){
        System.out.println(user);
        return "success.jsp";
    }
}

@Data
public class User {
    private String username;
    private String password;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
}

解决接收的参数值乱码只能添加过滤器。这里我们可以使用SpringMVC框架自带的编码过滤器CharacterEncodingFilter，也可以使用自己设计的编码过滤器。

使用SpringMVC框架自带的编码过滤器CharacterEncodingFilter：

在web.xml中设置：

    <filter>
        <filter-name>EncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param><!--参数设置，该过滤器中有个encoding参数是用来设置编码类型的-->
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>EncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

7.3 接收日期类型的参数

（1）在时间类型的属性上加上注解@DateTimeFormat(pattern = "yyyy-MM-dd"),如果包含时分秒则是pattern = "yyyy-MM-dd HH:mm:ss"。

@Data
public class User {
    private String username;
    private String password;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
}

（2）在SpringMVC配置文件中开启注解驱动

 <!--开启注解驱动-->
    <mvc:annotation-driven/>

注意：这里引用的是这个

xmlns:mvc="http://www.springframework.org/schema/mvc"

8. 处理静态资源

在SpringMVC配置文件中放行静态资源：

    <!--放行静态资源-->
    <mvc:default-servlet-handler/>

如果不放行，则无法加载图片，js，css。

原因：SpringMVC的前端控制器DispatcherServlet也把静态资源给拦截了。

9. 如何把controller层数据返回到网页并回显

有两种方法：

（1）通过request，session来保存并回显页面，缺点:与Tomcat容器绑定了。

    @RequestMapping(value = "list3")
    public String list3(HttpServletRequest request){
        User user = new User("刘六",new Date(),1,"北京");
        request.setAttribute("user3",user);
        return "success.jsp";
    }
    @RequestMapping(value = "list4")
    public String list4(HttpSession session){
        User user = new User("德华",new Date(),1,"香港");
        session.setAttribute("user4",user);
        return "success.jsp";
    }

（2）通过Model来保存，建议使用Model。

参数model,调用model.addAttribute()方法保存数据，默认保存的是request范围，可以使用注解更改为session范围。

@Controller
//model保存范围更改为session范围，value里写保存在session范围的key,可以设置多个"key"
@SessionAttributes(value = {"user2"})
public class HelloController {
    @RequestMapping(value = "list1")
    public String list1(Model model){
        User user = new User("张三",new Date(),1,"河南");
        model.addAttribute("user",user);
        return "success.jsp";
    }
    @RequestMapping(value = "list2")
    public String list2(Model model){
        User user2 = new User("李四",new Date(),0,"深圳");
        model.addAttribute("user2",user2);
        return "success.jsp";
    }

10. 如何使用重定向跳转

在方法的返回字符串的内容前加上redirect:

 @RequestMapping("list5")
    public String list5(){
        System.out.println("重定向跳转");
        //当springmvc看到你返回的字符串钟含有redirect:时 它认为你要进行重定向跳转
        return "redirect:list.jsp"; 
    }

11. springmvc返回json数据

（1）加入Jackson依赖

  <!--jackson依赖 可以把java对象转换为json对象-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.13.2.2</version>
    </dependency>

（2）在controller层，需要返回json数据的方法上加入注解@ResponseBody

    @RequestMapping(value = "json")
    @ResponseBody//把java对象转换为json对象
    public List<User> json(){
        List<User> list = new ArrayList<>();
        list.add(new User("王五",new Date(),1,"上海"));
        list.add(new User("张三",new Date(),1,"河南"));
        list.add(new User("李四",new Date(),0,"深圳"));
        return list;
    }

（3）值得注意的是：时间类型的json数据显示是毫秒，我们要在实体类加入注解@JsonFormat(pattern = "yyyy-MM-dd")使它显示正常格式

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String name;

    //设定接收的时间类型的数据
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    //设定转发的时间类型的json数据的格式
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
    private Integer sex;
    private String address;
}

12. springmvc的全局异常处理类

全局异常处理类的作用: 当controller发生异常，则有全局异常类来处理并执行相应的处理方法。

(1)如何使用全局异常处理类

a. 创建一个异常类,并使用@ControllerAdvice注解

@ControllerAdvice
public class MyExceptionHandler {
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Map error(){
        Map map = new HashMap();
        map.put("code","5000");
        map.put("msg","错误");
        return map;
    }
}

b.保证SpringMVC能够扫描到该类，需要在springmvc.xml中添加包扫描的包路径

<context:component-scan base-package="com.zpb.controller,com.zpb.handler"/>

13. SpringMVC拦截器

和过滤器类似，过滤器过滤掉某些资源，SpringMVC拦截器只会拦截controller层的资源路径

如何使用拦截器：

（1）创建一个类，并实现HandlerInterceptor接口,重写preHandle方法

public class MyInterceptor implements HandlerInterceptor {

    //拦截器的处理方法。
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("经过了该拦截器");

        return true;//true:表示拦截器放行 false：不放行
    }
}

（2）把该类注册到springmvc.xml文件中

<!--拦截器的配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--mapping:哪些路径需要经过拦截器
               /**: 表示n层路径
               /*:表示一层路径
                -->
            <mvc:mapping path="/**"/>
            <!--exclude-mapping:设置不经过该拦截的路径,记得要把静态资源放行-->
            <mvc:exclude-mapping path="/login"/>
            <mvc:exclude-mapping path="/css/**"/>
            <mvc:exclude-mapping path="/images/**"/>
            <mvc:exclude-mapping path="/js/**"/>
            <!--bean表示你自定义的拦截器类路径-->
            <bean class="com.zpb.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

14. 文件上传

14.1 文件上传到本地服务器

（1）引入文件上传的依赖

    <!--文件上传的依赖-->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.4</version>
    </dependency>

（2）创建一个页面

method: 提交方式文件上传必须为post提交。
enctype:默认application/x-www-form-urlencoded 表示提交表单数据
multipart/form-data:可以包含文件数据
input的类型必须为file类型，而且必须有name属性

<%--
  Created by IntelliJ IDEA.
  User: zpb1982379990
  Date: 2022/6/9
  Time: 19:02
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="upload01" method="post" enctype="multipart/form-data">
        <input type="file" name="myFile"/><br>
        <input type="submit" value="提交"/>
    </form>
</body>
</html>

（3）在springmvc中配置文件上传解析器

     <!--
     id的名称必须叫multipartResolver
     -->
     <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
          <!--这里的单位为字节10M*1024K*1024-->
          <property name="maxUploadSize" value="10485760"/>
     </bean>

（4）创建upload01接口方法

注意:MultipartFile 参数名必须和<input type="file" name="myfile"/>中name属性相同

@RequestMapping(value = "upload01")
    //注意:MultipartFile 参数名必须和<input type="file" name="myfile"/>中name属性相同
    public String upload01(MultipartFile myFile, HttpServletRequest request) throws Exception{
        //本地服务器的目录路径
        String path = request.getSession().getServletContext().getRealPath("upload");
        //如果本地服务器中没有这个文件夹则创建这个文件夹
        File file = new File(path);
        if (!file.exists()){
            file.mkdirs();
        }
        //把myfile保存到本地服务中某个文件夹下。
        String filename = UUID.randomUUID().toString().replace("-","")+myFile.getOriginalFilename();
        File target = new File(path+"/"+filename);
        //把myfile转移到目标目录下
        myFile.transferTo(target);
        return "";
    }

14.2 elementui+vue+axios上传文件到本地服务器

(1)页面的布局

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <!--引入element得css样式-->
    <link type="text/css" rel="stylesheet" href="css/index.css"/>
    <!--引入vue得js文件 这个必须在element之前引入-->
    <script type="text/javascript" src="js/vue.js"></script>
    <script type="text/javascript" src="js/qs.min.js"></script>
    <script type="text/javascript" src="js/axios.min.js"></script>
    <!--element得js文件-->
    <script type="text/javascript" src="js/index.js"></script>
</head>
<body>
    <div id="app">
        <%--action：文件上传的路径--%>
        <el-upload
                class="avatar-uploader"
                action="/upload02"
                :show-file-list="false"
                :on-success="handleAvatarSuccess"
                :before-upload="beforeAvatarUpload">
            <img v-if="imageUrl" :src="imageUrl" class="avatar">
            <i v-else class="el-icon-plus avatar-uploader-icon"></i>
        </el-upload>
    </div>
</body>
<script>
     var app=new Vue({
           el:"#app",
           data:{
               imageUrl:"",
           },
           methods:{
               //上传成功后触发的方法
               handleAvatarSuccess(res, file) {
                   this.imageUrl=res.data;
               },
               //上传前触发的方法
               beforeAvatarUpload(file) {
                   const isJPG = file.type === 'image/jpeg';
                   const isPNG = file.type === 'image/png';
                   const isLt2M = file.size / 1024 / 1024 < 2;
                   if (!isJPG) {
                       this.$message.error('上传头像图片只能是 JPG 格式!');
                   }
                   if (!isLt2M) {
                       this.$message.error('上传头像图片大小不能超过 2MB!');
                   }
                   return isJPG && isLt2M;
               }
           }
     })
</script>

<style>
    .avatar-uploader .el-upload {
        border: 1px dashed #d9d9d9;
        border-radius: 6px;
        cursor: pointer;
        position: relative;
        overflow: hidden;
    }
    .avatar-uploader .el-upload:hover {
        border-color: #409EFF;
    }
    .avatar-uploader-icon {
        font-size: 28px;
        color: #8c939d;
        width: 178px;
        height: 178px;
        line-height: 178px;
        text-align: center;
    }
    .avatar {
        width: 178px;
        height: 178px;
        display: block;
    }
</style>
</html>

(2)后台的接口

    @RequestMapping(value = "upload02")
    @ResponseBody
    public Map load02(MultipartFile file,HttpServletRequest request){
        try {
            String path = request.getSession().getServletContext().getRealPath("upload");
            File file1 = new File(path);
            if (!file1.exists()){
                file1.mkdirs();
            }
            String filename=UUID.randomUUID().toString().replace("-","")+file.getOriginalFilename();
            File target=new File(path+"/"+filename);
            file.transferTo(target);
            Map map = new HashMap();
            map.put("code",2000);
            map.put("msg","上传成功");
            //通过访问服务器地址来访问图片.
            map.put("data","http://localhost:8080/springweb_upload01/upload/"+filename);
            return map;
        } catch (IOException e) {
            e.printStackTrace();
        }
        Map map=new HashMap();
        map.put("code",5000);
        map.put("msg","上传失败");
        return map;
    }

上传到本地服务器的缺点: 如果搭建集群，导致文件无法在集群中共享。它的解决方法就是把文件专门上传到一个文件服务器上，这些tomcat服务器都操作同一个文件服务器。 oss阿里云的服务器可以作为我们的文件服务器。

14.3 普通文件上传到oss阿里云的服务器

（1）把文件上传里的copy过来并修改为自己的，我这里把它抽出来弄成了一个工具类。

// Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "oss-cn-hangzhou.aliyuncs.com";
        // 阿里云账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维，请登录RAM控制台创建RAM用户。
        String accessKeyId = "你的密钥ID";
        String accessKeySecret = "你的密钥";
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "aimeiyyds";
        // 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。这里调用自己封装的方法把文件放入生成的日期目录下
        String objectName = fileName(file);

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

        try {
            InputStream inputStream =file.getInputStream();
            // 创建PutObject请求。
            ossClient.putObject(bucketName, objectName, inputStream);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        //拼接url成oss服务器里文件的格式:  https://aimeiyyds.oss-cn-hangzhou.aliyuncs.com/2022/6/10/c4afd23698384d0f8963dbc7a50e1285QQ%E5%9B%BE%E7%89%8720200223174210.jpg
        String url = "https://"+bucketName+"."+endpoint+"/"+objectName;
        return url;
    }
    //获取上传到oss后的名字 你上传到oss后的名字 会根据日期帮你创建文件夹
    private static String fileName(MultipartFile file){
        Calendar calendar = Calendar.getInstance();
        String name = calendar.get(Calendar.YEAR)+"/"+(calendar.get(Calendar.MONDAY)+1)+"/"+calendar.get(Calendar.DATE)+"/"
                + UUID.randomUUID().toString().replace("-","")+file.getOriginalFilename();
        return name;
    }

（2）在controller层完成上传

    @RequestMapping("upload01")
    public String upload(MultipartFile file, HttpServletRequest request){
        String url = OssUtil.upload(file);
        request.setAttribute("url",url);
        return "success.jsp";
    }

14.4 elementui+vue+axios上传oss服务器

前端：

<%--
  Created by IntelliJ IDEA.
  User: zpb1982379990
  Date: 2022/6/10
  Time: 18:48
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <!--引入element得css样式-->
    <link type="text/css" rel="stylesheet" href="css/index.css"/>
    <!--引入vue得js文件 这个必须在element之前引入-->
    <script type="text/javascript" src="js/vue.js"></script>
    <script type="text/javascript" src="js/qs.min.js"></script>
    <script type="text/javascript" src="js/axios.min.js"></script>
    <!--element得js文件-->
    <script type="text/javascript" src="js/index.js"></script>
</head>
<body>
<div id="app">
    <el-form :label-position="labelPosition" label-width="70px" :model="userForm">
        <el-form-item label="用户名">
            <el-input v-model="userForm.username"></el-input>
        </el-form-item>
        <el-form-item label="密码">
            <el-input v-model="userForm.password"></el-input>
        </el-form-item>
        <el-form-item label="地址">
            <el-input v-model="userForm.address"></el-input>
        </el-form-item>
        <el-form-item label="头像:">
            <el-upload
                    class="avatar-uploader"
                    action="upload02"
                    :show-file-list="false"
                    :on-success="handleAvatarSuccess"
                    :before-upload="beforeAvatarUpload">
                <img v-if="imageUrl" :src="imageUrl" class="avatar">
                <i v-else class="el-icon-plus avatar-uploader-icon"></i>
            </el-upload>
        </el-form-item>
        <el-form-item>
            <el-button type="primary" @click="onSubmit" class="el-icon-circle-plus-outline">提交</el-button>
        </el-form-item>
    </el-form>

</div>
<script>
    var app = new Vue({
        el:"#app",
        data:{
            labelPosition: 'right',
            userForm: {},
            imageUrl:""
        },
        methods:{
            handleAvatarSuccess(result,file){
                this.imageUrl=result.data;
                this.userForm.avatarUrl=this.imageUrl;
            },
            //提交
            onSubmit(){
                axios.post("addUser",this.userForm).then(function(result){

                });
            },
            //上传前触发的方法
            beforeAvatarUpload(file) {
                const isJPG = file.type === 'image/jpeg';
                const isPNG = file.type === 'image/png';
                const isLt2M = file.size / 1024 / 1024 < 2;
                if (!isJPG) {
                    this.$message.error('上传头像图片只能是 JPG 格式!');
                }
                if (!isLt2M) {
                    this.$message.error('上传头像图片大小不能超过 2MB!');
                }
                return isJPG && isLt2M;
            }
        }
    })
</script>
<style>
    #app{
        width: 300px;
        height: 500px;
        border: 2px #000000 solid;
        position: absolute;
        left: 50%;
        top: 50%;
        transform: translate(-50%, -50%);
        padding: 10px 20px;
    }
    .avatar-uploader .el-upload {
        border: 1px dashed #d9d9d9;
        border-radius: 6px;
        cursor: pointer;
        position: relative;
        overflow: hidden;
    }
    .avatar-uploader .el-upload:hover {
        border-color: #409EFF;
    }
    .avatar-uploader-icon {
        font-size: 28px;
        color: #8c939d;
        width: 178px;
        height: 178px;
        line-height: 178px;
        text-align: center;
    }
    .avatar {
        width: 178px;
        height: 178px;
        display: block;
    }
</style>
</body>
</html>

后端：

这里可以封装一个工具类OssUtil

// Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "oss-cn-hangzhou.aliyuncs.com";
        // 阿里云账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维，请登录RAM控制台创建RAM用户。
        String accessKeyId = "你的密钥ID";
        String accessKeySecret = "你的密钥";
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "aimeiyyds";
        // 填写Object完整路径，完整路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。这里调用自己封装的方法把文件放入生成的日期目录下
        String objectName = fileName(file);

        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

        try {
            InputStream inputStream =file.getInputStream();
            // 创建PutObject请求。
            ossClient.putObject(bucketName, objectName, inputStream);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
        //拼接url成oss服务器里文件的格式:  https://aimeiyyds.oss-cn-hangzhou.aliyuncs.com/2022/6/10/c4afd23698384d0f8963dbc7a50e1285QQ%E5%9B%BE%E7%89%8720200223174210.jpg
        String url = "https://"+bucketName+"."+endpoint+"/"+objectName;
        return url;
    }
    //获取上传到oss后的名字 你上传到oss后的名字 会根据日期帮你创建文件夹
    private static String fileName(MultipartFile file){
        Calendar calendar = Calendar.getInstance();
        String name = calendar.get(Calendar.YEAR)+"/"+(calendar.get(Calendar.MONDAY)+1)+"/"+calendar.get(Calendar.DATE)+"/"
                + UUID.randomUUID().toString().replace("-","")+file.getOriginalFilename();
        return name;
    }

controller层：

@RequestMapping("upload02")
    @ResponseBody
    public CommonResult upload02(MultipartFile file){
        try {
            String url = OssUtil.upload(file);
            return new CommonResult(2000,"上传成功",url);
        }catch (Exception e){
            e.printStackTrace();
        }
        return new CommonResult(5000,"上传失败",null);
    }