Spring学习

置顶 | | | | |

SpringMVC基础

在这里插入图片描述

<1>数据响应

SpringMVC的数据响应主要有两种格式：

第一种就是进行页面跳转：

1.直接返回字符串：

首先创建一个success.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<%--
  Created by IntelliJ IDEA.
  User: g'g
  Date: 2020/10/9
  Time: 8:44
  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>
    <h1>Success成功~~~</h1>
</body>
</html>

在核心控制类中写入方法：

1
2
3
4
5
6
//数据响应：返回一个字符串类型的
@RequestMapping("/quick")//用来建立请求URL和处理请求方法的之间的联系
public String save(){
    System.out.println("UserController save running....");
    return "success";
}

但是要想通过这个字符串类型的数据进行跳转必须要先配置视图解析器

在SpringMVC的配置文件中写入

1
2
3
4
5
<!--配置视图解析器，将控制器方法返回的逻辑视图解析为物理视图-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/jsp/"/>
    <property name="suffix" value=".jsp"/>
</bean>

然后重新发布一下tomcat，看看是否成功：

5f98fd644d9b01f39cc12f72851523a

2.通过ModelAndView对象返回：

首先创建一个hello.jsp文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<%--
  Created by IntelliJ IDEA.
  User: g'g
  Date: 2020/10/11
  Time: 10:50
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>${msg}</title>
</head>
<body>
<h1>${msg}</h1>
</body>
</html>

在核心控制类中写入

1
2
3
4
5
6
7
8
9
10
11
//数据响应：返回一个ModelAndView类对象
   @RequestMapping("/quick2")
   public ModelAndView save2(){
       //创建ModeAndView对象，该对象包含返回视图名、模型名称以及模型对象
       ModelAndView view = new ModelAndView();
       //添加模型数据，可以是任何POJO对象
       view.addObject("msg","这是基于SpringMVC的程序~~~");
       //设置逻辑视图名，视图解析器会依据该名字解析到具体的视图页面
       view.setViewName("hello");
       return view;
   }

然后重新发布一下tomcat，看看是否成功：

98014169726d330c92020f0adc3596f

上述过程可以进行简化，让Spring为我们创建ModelAndView对象，我们之间用即可。

1
2
3
4
5
6
7
//数据响应：使用Spring注入的MOdelAndView对象,Spring也可注入其他对象
    @RequestMapping("/quick3")
    public ModelAndView save3(ModelAndView modelAndView){
        modelAndView.setViewName("hello");
        modelAndView.addObject("msg","基于Spring注入的ModelAndView对象~~~");
        return modelAndView;
    }

然后重新发布一下tomcat，看看是否成功：

fd465fd281a22787e1f62937b9e6881

第二种就是回写数据

1.直接返回字符串

将需要回写的字符串直接返回，但此时需要通过**@ResponseBody**注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回。

在核心控制类中写入：

1
2
3
4
5
6
7
//数据响应：直接回写一个字符串数据
    @RequestMapping("/hello1")
    //告知Spring我不页面跳转，直接输出字符串
    @ResponseBody
    public String save4() throws IOException {
        return "通过Spring注入HttpServletResponse对象回写了一个字符串";
    }

然后重新发布一下tomcat，看看是否成功：

8d2712258ad94e26bfe15dd9ebff57d

2.返回对象或集合

在核心配置类中进行写入：

1
2
3
4
5
6
7
8
9
10
//数据响应：回写数据：返回对象或者集合
    @RequestMapping("/hello2")
    @ResponseBody
    public String save5(User user) throws JsonProcessingException {
        user.setName("liuchang");
        user.setAge(21);
        ObjectMapper objectMapper=new ObjectMapper();
        String s = objectMapper.writeValueAsString(user);
        return s;
    }

cf1deb8a416b3751ce7b1fa8bcbf7f6

这里有一个问题：你会发现中文乱码了。怎么办呢？创建一个过滤器即可。

在webapp下的WEB-INF的web.xml文件中配置全局的filter:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--配置全局过滤的filter-->
    <!--为了解决中文乱码的问题-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

<2>请求数据

1.获得基本类型参数

在核心控制类中写入

1
2
3
4
5
6
7
//请求参数：Spring自动封装参数
@RequestMapping("/请求参数1")
@ResponseBody
public void save7(String username,int age){
    System.out.println(username);
    System.out.println(age);
}

访问地址应为：

e0b1b1fc0869cd59c89c94cfcc75908

查看一下结果：

59ba9dc872409c9577f7b5b9791edab

2.请求对象

首先创建一个User对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.liu.pojo;

public class User {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

然后在核心控制类中写入

1
2
3
4
5
6
//请求对象：Spring自动封装对象,对象的属性与请求参数的属性一致，对象就会自动映射匹配
   @RequestMapping("/请求对象")
   @ResponseBody
   public void save8(User user){
       System.out.println(user);
   }

重启tomcat查看结果：

039aecb1b71a5e281977fc8addc9220

fd233cc57e63e91eda0d044dbcd1d3b

3.请求数组

先在核心控制类中写入方法：

1
2
3
4
5
6
//请求数组：数组名称与请求参数的name一致，参数值就会自动映射匹配
    @RequestMapping("/请求数组")
    @ResponseBody
    public void save9(String[] strings){
        System.out.println(Arrays.asList(strings));
    }

运行tomcat，查看结果

e2dbaa0cb5403ddf17684c956fa8ed8

64b5e1cb96b539db44a1c71d1a105f8

4.请求集合

首先创建一个集合VO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.liu.pojo;

import java.util.List;

public class VO {
    private List<User> Users;

    @Override
    public String toString() {
        return "VO{" +
                "Users=" + Users +
                '}';
    }

    public List<User> getUsers() {
        return Users;
    }

    public void setUsers(List<User> users) {
        Users = users;
    }
}

然后在核心控制类中写入方法

1
2
3
4
5
6
//请求参数为一个集合：
    @RequestMapping("/请求集合")
    @ResponseBody
    public void save10(VO vo){
        System.out.println(vo);
    }

我们不能通过直接访问来请求一个集合，我们需要一个表单进行提交：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<%--
  Created by IntelliJ IDEA.
  User: g'g
  Date: 2020/10/11
  Time: 15:23
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>form表单提交数据</title>
</head>
<body>
    <form action="/SpringMVC_war/user/请求集合" method="post">
        <input type="text" name="users[0].name"><br/>
        <input type="text" name="users[0].age"><br/>
        <input type="text" name="users[1].name"><br/>
        <input type="text" name="users[1].age"><br/>
        <input type="text" name="users[2].name"><br/>
        <input type="text" name="users[2].age"><br/>
        <input type="text" name="users[3].name"><br/>
        <input type="text" name="users[4].age"><br/>
        <input type="submit" value="提交">
    </form>
</body>
</html>

重新发布tomcat来查看是否成功

访问fprm.jsp来填写表单，通过表单来获取一个集合对象

ba900ecc083f3114ae9c65344af652a

点击提交之后就进入了

35673640019d95975c319ebd0fc8379

在IDEA中可以看到已经得到了一个集合

6c286e694e3b6ac3c2e950abe244342

5.请求Servlet相关API

1
2
3
4
5
6
7
8
//获得Servlet相关API
    @RequestMapping("/api")
    @ResponseBody
    public void save14(HttpServletRequest request, HttpServletResponse response, HttpSession session){
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
    }

6.获得头信息

使用**@RequestHeader**可以获得请求头信息，相当于web阶段学习的request.getHeader(name)
@RequestHeader注解的属性如下：

  • value：请求头的名称
  • required：是否必须携带此请求头
1
2
3
4
5
6
//获得请求头信息
@RequestMapping("/header")
@ResponseBody
public void save15(@RequestHeader(value = "User-Agent",required = false)String user_agent){
    System.out.println(user_agent);
}

7.获得cookie

使用@CookieValue可以获得指定Cookie的值
@CookieValue注解的属性如下：

  • value：指定cookie的名称
  • required：是否必须携带此cookie
1
2
3
4
5
6
//获得cookie
   @RequestMapping("/cookie")
   @ResponseBody
   public void save16(@CookieValue(value = "JSESSIONID",required = false) String cookie){
       System.out.println(cookie);
   }

8.进行文件上传

首先引入相关包的坐标

1
2
3
4
5
6
7
8
9
10
<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.6</version>
</dependency>
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.4</version>
</dependency>

在SpringMVC核心配置文件中写入

1
2
3
4
5
<!--配置文件上传解析器-->
    <bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" id="multipartResolver">
        <property name="defaultEncoding" value="UTF-8"/>
        <property name="maxUploadSize" value="50000"/>
    </bean>

创建一个表单upload.jsp用于提交：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<%--
  Created by IntelliJ IDEA.
  User: liuchang
  Date: 2020/10/14
  Time: 上午8:32
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件上传</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/user/loading" method="post" enctype="multipart/form-data">
        名称：<input type="text" name="name"><br/>
        文件：<input type="file" name="file"><br/>
        <input type="submit" value="提交"><br/>
    </form>
</body>
</html>

在核心控制类中写入方法：

1
2
3
4
5
6
7
8
9
//文件上传
    @RequestMapping("/loading")
    @ResponseBody
    public void save16(String name, MultipartFile file) throws IOException {
        System.out.println(name);
        System.out.println(file);
        String filename = file.getOriginalFilename();
        file.transferTo(new File("/home/liuchang/IdeaProjects/Spring项目/SpringMVC"+filename));
    }

首先访问upload.jsp，提交后可以发现已经成功上传了。

相关文章
点击查看
-------------------本文结束 感谢您的阅读-------------------