SSM框架之SpringMVC学习笔记

最新推荐文章于 2024-03-13 08:38:28 发布

北莽

最新推荐文章于 2024-03-13 08:38:28 发布

阅读量706

点赞数

分类专栏： JAVA学习笔记文章标签： java spring

本文链接：https://blog.youkuaiyun.com/weixin_45581692/article/details/123613542

版权

JAVA学习笔记专栏收录该内容

16 篇文章

订阅专栏

SpringMVC

1. 回顾内容
- 1.1 MVC架构
- 1.2 Servlet
2. 第一个SpringMVC程序
3. SpringMVC执行流程
4. 使用注解开发SpringMVC
5. RestFul风格
6. 结果跳转方式
- 6.1 ModelAndView
- 6.2 重定向和转发
7. 接收请求参数及数据回显
8. 乱码问题
9. JSON
- 9.1 什么是JSON
- 9.2 Controller返回JSON数据

1. 回顾内容

1.1 MVC架构

Model（模型）：数据层dao、服务层service
View（视图）：jsp、html
Controller（控制器）：servlet
在这里插入图片描述

用户发请求
Servlet接收请求数据，并调用对应的业务逻辑方法
Servlet转向到jsp，由jsp来渲染页面
servlet转向到jsp，由jsp来渲染页面
响应给前端更新后的页面

职则分析：
Controller控制器：取得表单数据；调用业务逻辑；转向指定的页面
Model模型：业务逻辑；保存数据的状态
View视图：显示页面

1.2 Servlet

1. 新建一个Maven工程当做父工程！pom依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

2. 建立一个Model：spring-01-servlet，添加 web app 的支持

3. 导入servlet和jsp的jar依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
</dependency>

4. HelloServlet

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if(method.equals("add")) {
            req.getSession().setAttribute("msg","add方法执行了");
        }
        if(method.equals("delete")) {
            req.getSession().setAttribute("msg","delete方法执行了");
        }
        req.getRequestDispatcher("/hello.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        this.doPost(req, resp);
    }
}

5. hello.jsp

<body>
    ${msg}
</body>

6. 在web.xml中注册Servlet

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern> <!--访问路径-->
</servlet-mapping>

<!--  默认为index.jsp  -->
<welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>

7. 配置Tomcat，并启动测试

2. 第一个SpringMVC程序

1. 新建一个Module，添加web的支持
2. 确定导入了SpringMVC的依赖
3. 配置web.xml，注册DispatcherServlet

<?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">

    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件：【servlet-name】-servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-->
        <load-on-startup>1</load-on-startup>
    </servlet>

<!--    / 匹配所有的请求：（不包括.jsp）-->
<!--    /* 匹配所有的请求：（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

4. 编写SpringMVC的配置文件！名称：springmvc-servlet.xml。说明：这里的名称要求是按照官方来的

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

5. 添加处理映射器

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

6. 添加处理器适配器

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

7. 添加视图解析器

<!--    视图解析器：DispatcherServlet给他的ModelAndView
    1. 获取了ModelAndView的数据
    2. 解析ModelAndView的视图名字
    3. 拼接视图名字，找到对应的视图 /WEB-INF/jsp/hello.jsp
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>

8. 编写我们要操作业务Controller，要么实现Controller接口，要么增加注解：需要返回一个ModelAndView，装数据，封视图；

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //： /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

9. 将自己的类交给SpringIOC容器，注册bean

<!--Handler-->
<bean id="/hello" class="com.kuang.controller.HelloController"/>
<!-- /hello也就是访问时，输入url最后的那一串-->

10. 写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面

<body>
    ${msg}
</body>

11. 配置tomcat启动测试

可能遇到的问题：访问出现404：

查看控制台输出，看一下是不是缺少了什么jar包
如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖。
重启Tomcat即可解决

3. SpringMVC执行流程

在这里插入图片描述

1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截。

假设请求的url为：http://localhost:8080/springmvc02/hello

这个url会被拆成三部分：

http://localhost:8080：服务器域名
springmvc02：部署在服务器上的web站点
hello：表示控制器

通过分析，如上url表示为：请求位于服务器localhost:8080上的springmvc02站点的hello控制器。

2. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping，HandlerMapping根据请求url查找Handler（上面案例中，Handler为“hello”，我们在springmvc-servlet.xml中注册了bean，id为“hello”）。

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

4. HandlerExecution将解析后的信息传递给DispatcherServlet，如解析控制器映射等。

5. HandlerAdapter表示处理器适配器，其按照待定的规则去执行Handler。

6. Handler让具体的Controller（上个案例中的HelloController类）执行。

7. Controller将具体的执行信息返回给HandlerAdapter，如ModelAndView。

8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet

9. DispatcherServlet调用视图解析器（ViewResolver）来解析HandlerAdapter传递的逻辑视图名。
视图解析器：DispatcherServlet给他的ModelAndView
1. 获取了ModelAndView的数据
2. 解析ModelAndView的视图名字
3. 拼接视图名字，找到对应的视图 /WEB-INF/jsp/hello.jsp
4. 将数据渲染到这个视图上

10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。

11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

12. 最终视图呈现给用户。

4. 使用注解开发SpringMVC

1. 新建一个module，添加web支持
2. 避免可能存在资源过滤问题。…
3. 在pom.xml文件引入相关的依赖
4. 配置web.xml。注意：版本要最新的4.0

<?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">

    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件：【servlet-name】-servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--    / 匹配所有的请求：（不包括.jsp）-->
    <!--    /* 匹配所有的请求：（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

5. 配置springmvc-servlet.xml。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描包，让指定包下的注解生效，由IOC容器统一管理 -->
    <context:component-scan base-package="com.kuang.controller"/>
    <!--让SpringMVC不处理静态资源-->
    <mvc:default-servlet-handler/>
    <!--支持mvc注解驱动-->
    <mvc:annotation-driven/>
	<!--
		之前需要注册HandlerMapping和HandlerAdapter两个实例，
		使用annotation-driver配置帮助我们自动完成两个实例的注入。
	-->

    <!--  视图解析器：DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

在这里插入图片描述

6. 创建对应的控制类，controller

@Controller //代表这个类会被Spring接管
//被这个注解的类，中的所有方法，如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析
@RequestMapping("/hello") //不需要在xml中注册bean了
public class HelloController {
    @RequestMapping("/h1") //访问路径：localhost:8080/hello/h1
    public String hello(Model model) {
        //封装数据
        model.addAttribute("msg","Hello,SpringMVC");
        return "hello"; //会被视图解析器解析：WEB-INF/jsp/hello.jsp
    }
}

7. 完善前端视图和controller之间的对应
创建jsp，完善内容。

使用SpringMVC必须配置的三大件：处理器映射器、处理器适配器、视图解析器。
通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置。

@Controller：代替了原来的Controller接口。表示这个类会被Spring接管，被这个注解的类，中的所有方法，如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析。
@RequestMapping：注解用于映射url到控制器类或一个特定的处理程序方法，可用于类或方法上（用于类上，表示的是父路径）。对比以前，我们不需要在xml中注册bean了

5. RestFul风格

概念：RestFul就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

看看原来是怎么访问的：

@RequestMapping("/add")
public String test1(int a, int b, Model model) {
    int result = a + b;
    model.addAttribute("msg","结果为：" + result);
    return "hello";
}

在这里插入图片描述
在方法中，参数名是什么，访问就要用什么。

使用@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

@RequestMapping("/add/{a}/{b}")
public String test1(@PathVariable int a, @PathVariable int b, Model model) {
    int result = a + b;
    model.addAttribute("msg", "结果为：" + result);
    return "hello";
}

在这里插入图片描述
请求类型
SpringMVC的@RequestMapping注解能够处理HTTP请求的方法，比如GET、PUT、POST、DELETE以及PATCH。
所有的地址栏请求默认都会是 HTTP GET 类型的。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
它所扮演的是 @RequestMapping(method=RequestMethod.GET) 的一个快捷方式

//@RequestMapping(value="/add/{a}/{b}",method=RequestMethod.GET)
@GetMapping("/add/{a}/{b}")
public String test2(@PathVariable int a, @PathVariable int b, Model model) {
    int result = a + b;
    model.addAttribute("msg","结果1为：" + result);
    return "hello";
}

@PostMapping("/add/{a}/{b}")
public String test3(@PathVariable int a, @PathVariable int b, Model model) {
    int result = a + b;
    model.addAttribute("msg","结果2为：" + result);
    return "hello";
}

地址栏相同，可以通过不同的提交方式，实现不同的效果（在前台设置提交方式，默认为get方式，提交方式对应不起来就会找不到）。

6. 结果跳转方式

6.1 ModelAndView

设置 ModelAndView 对象，根据view的名称，和视图解析器跳到指定的页面。

页面：{视图解析器前缀} + viewName + {视图解析器后缀}

<!--  视图解析器：DispatcherServlet给他的ModelAndView-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>

对应的controller类

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();
        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //： /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

6.2 重定向和转发

1. 用ServletAPI实现
通过 HttpServletResponse 实现重定向和转发。

@RequestMapping("/m1/t1")
public String test1(HttpServletRequest request, HttpServletResponse response) {
    HttpSession session = request.getSession();
    System.out.println(session.getId());
    return "test";
}

2. 通过SpringMVC来实现转发和重定向
如果没有视图解析器，转发中返回值需要写全路径，而重定向不用

@RequestMapping("/m1/t2")
public String test2(Model model) {
    model.addAttribute("msg","ModelTest1");
    //转发
    return "/WEB-INF/jsp/hello.jsp";
    //return "forward:/WEB-INF/jsp/hello.jsp"
}

@RequestMapping("/m1/t3")
public String test3() {
    //重定向
    return "redirect:/index.jsp";
}

重定向，不需要视图解析器，本质就是重新请求一个新地方。
注意：重定向不能访问WEB-INF下的资源

使用视图解析器

@RequestMapping("/m1/t2")
public String test2(Model model) {
    model.addAttribute("msg","ModelTest1");
    //转发
    return "hello";
}

7. 接收请求参数及数据回显

前面说过，传递参数时，需要保证方法参数名和传递的参数名一样，不然找不到。

@GetMapping("/t1")
public String test1(String name, Model model) {
    System.out.println("接收到前端的参数为：" + name);
    //将返回的结果传递给前端
    model.addAttribute("msg",name);
    return "hello";
}

在这里插入图片描述
我们可以在方法参数前加上一个注解@RequestParam，指定传递的参数名。

@GetMapping("/t1")
public String test1(@RequestParam("username") String name, Model model) {
    System.out.println("接收到前端的参数为：" + name);
    //将返回的结果传递给前端
    model.addAttribute("msg",name);
    return "hello";
}

在这里插入图片描述
如果方法参数是一个对象，那么前端传递的参数名，必须和对象中的变量名一致，不一致的参数结果为null。

@GetMapping("/t2")
public String test2(User user, Model model) {
    System.out.println("接收到前端的参数为：" + user);
    //将返回的结果传递给前端
    model.addAttribute("msg",user);
    return "hello";
}

在这里插入图片描述
数据回显
前面就说过的：ModelAndView、Model
还有一种：ModelMap

三者的区别：
Model：只有寥寥几个方法，只适合于存储数据，简化了新手对于Model对象的操作和理解；
ModelMap：继承了LinkedMap，除了实现了自身的一些方法，同样的继承LinkedMap的方法和特性；
ModelAndView：可以在存储数据的同时，可以进行设置返回的逻辑视图，进行控制显示层的跳转。

8. 乱码问题

在web.xml中配置SpringMVC的乱码过滤

<filter>
    <filter-name>encoding</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>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

有可能加上这段配置还是乱码，可能是各种环境问题。

9. JSON

9.1 什么是JSON

JSON( JavaScript Object Notation，JS对象标记 ) 是一种轻量级的数据交换格式，目前使用特别广泛。

采用完全独立于编程语言的文本格式来存储和表示数据。

简洁和清晰的层次结构使得JSON成为理想的数据交换语言。

易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率

JSON键值对是用来保存JavaScript对象的一种方式

JSON是JavaScript对象的字符串表示法，它使用文本表示一个JS对象的信息，本质是一个字符串。

var obj = {a:'Hello', b:'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a":"Hello", "b":"World"}'; //这是一个JSON字符串，本质是一个字符串

JSON和JavaScript对象转换
要实现从JSON字符串转换为JavaScript对象，使用 JSON.parse() 方法：

var obj = JSON.parse('{"a":"Hello", "b":"World"}');
//结果是 {a:'Hello', b:'World'}

要实现从JavaScript对象转换为JSON字符串，使用JSON.stringify()方法：

var json = JSON.stringify({a:'hello', b:'world'});
//结果是 '{"a":"hello", "b":"world"}'

9.2 Controller返回JSON数据

Jackson
加入依赖，然后创建实体类

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.10.0</version>
</dependency>

@RestController：不走视图解析器。 我们需要返回一个字符串。
@RestController = @Controller + @ResponseBody

@RestController //表示这个类不会走视图解析器，和@ResponseBody作用一样
public class UserController {
    @RequestMapping("/j1")
    //@ResponseBody  //它就不会走视图解析器，会直接返回一个字符串，配合@Controller使用
    public String json1() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();

        User user = new User("张三", 18, "男");
        String str = mapper.writeValueAsString(user);
        return str;
    }

在这里插入图片描述
返回一个集合

@RequestMapping("/j2")
public String json2() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();

    List<User> userList = new ArrayList<User>();

    User user1 = new User("张三", 20, "男");
    User user2 = new User("李四", 22, "男");
    User user3 = new User("王五", 23, "男");
    User user4 = new User("赵六", 24, "男");

    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    userList.add(user4);

    String str = mapper.writeValueAsString(userList);
    return str;
}

返回时间

@RequestMapping("/j3")
public String json3() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();

    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
    //自定义日期的格式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    mapper.setDateFormat(sdf);

    Date date = new Date();

    //ObjectMapper, 时间解析后的默认格式为：TimeStamp 时间戳
    return mapper.writeValueAsString(date);
}

必要时，我们可以对JSON相关的代码进行抽取。

乱码问题：替换原来的<mvc:annotation-driven/>

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

FastJson
fastjson.jar 是阿里开发的一款专门用于Java开发的包，可以方便的实现JSON对象与Javabean对象的转换，实现Javabean对象与JSON字符串的转换，实现JSON对象与JSON字符串的转换。

fastjson三个主要的类：
【JSONObject代表json对象】
【JSONArray代表json对象数组】
【JSON代表JSONObject和JSONArray的转化】

使用时，先加入依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

@RequestMapping("/j4")
public String json4() throws JsonProcessingException {
    List<User> userList = new ArrayList<User>();
    User user1 = new User("张三", 20, "男");
    User user2 = new User("李四", 22, "男");
    User user3 = new User("王五", 23, "男");
    User user4 = new User("赵六", 24, "男");
    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    userList.add(user4);

    String string = JSON.toJSONString(userList);
    return string;
}