SpringMVC_summary

最新推荐文章于 2022-12-10 18:57:58 发布

春哥的技术还不行

最新推荐文章于 2022-12-10 18:57:58 发布

阅读量534

点赞数 1

文章标签： SpringMVC 环境配置 SpringMVC的应用

本文链接：https://blog.csdn.net/qq_39817135/article/details/98737119

版权

Spring-MVC:

spring Model and Viewer Controller 轻量级的Web Framework

springMVC主要有以下的内容：
1. springMVC的环境配置及入门；
2. springMVC的核心；response & request
3. springMVC的内容补充：文件上传，拦截器，异常解析；
4. 包含上述内容的项目;
知识点：
ApplicationContex获取方式

在Web项目中，可以使用ServletContextListener监听Web应用的启动，在Web应用启动时，就加载Spring的配置文件，创建ApplicationContext，并将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得ApplicationContext对象了。

（在Spring中，ApplicationContext是通过new ClasspathXmlApplicationContext(spring中的配置文件) 方式获取的）；

其配置文件见附件2

附：在使用了SpringMVC框架的Web项目中，也可以再获取ApplicationContext的对象：只不过需要使用web项目中的API： WebApplicationContextUtils. 及其方法：getWebApplicationContext(servletContext);

ApplicationContext applicationContext =    
 WebApplicationContextUtils.getWebApplicationContext(servletContext);
    Object obj = applicationContext.getBean("id");

快速入门，即执行流程：

[外链图片转存失败(img-PGf2DGh3-1565150727471)(C:\Users\19433\AppData\Local\Temp\1564840372050.png)]

[外链图片转存失败(img-KOYXmkX1-1565150727472)(C:\Users\19433\AppData\Local\Temp\1564840421120.png)]

1. request

页面跳转，返回字符串
- （这里是在 spring-mvc.xml 文件中配置了视图解析器,用来添加返回页面的前缀和后缀）
```
'<bean id="ViewResolver" class=" ..............InternalResourceViewResolver">
	<properpty name="prefix" value="/jsp/">
	<properpty name="suffix" value="/.jsp">
</bean>'
```
ViewResolver的工作原理：

[外链图片转存失败(img-tKLiHmSO-1565150727472)(C:\Users\19433\AppData\Local\Temp\1564962153615.png)]
页面跳转，返回标准的ModeAndView 类；

2.1 在Controller中方法返回ModelAndView对象，并且设置视图名称

@RequestMapping(value="/quick2")
    public ModelAndView save2(){
        /*  Model:模型 作用封装数据
            View：视图 作用展示数据    */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username","itcast");
        //设置视图名称
        modelAndView.setViewName("success");
        return modelAndView;
    }

// 2.2 可以直接传递ModeAndView对象，不用new对象

public ModelAndView save3(ModelAndView modelAndView){

// 2.3 可以只传递Mode对象或者View对象

public String save4(Model model){

3 在Controller方法的形参上可以直接使用原生的HttpServeltRequest对象，只需声明即可：

//这里使用“huhu”存储在request域中之后，可以在success页面中取出，这样与ModeAndView 对象的作用相同:
@RequestMapping("/ma3")
    public String ModelAndView(HttpServletRequest request) {
        request.setAttribute("huhu", "呼彩娥呼彩娥春春红唇");
        return "success";
    }

<--!这里是跳转的页面，取的过程-->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>success</title>
</head>
<body>
<h1>success!!!! 呼呼</h1>
<h3>${huhu}</h3>
</body>
</html>

@ResponseBody <<=>> response.getWriter().print(“hello world”) 回写数据：
1. 通过SpringMVC框架注入的response对象，使用response.getWriter().print(“hello world”) 回写数据，此时不需要视图跳转，业务方法返回值为void；
  
  将需要回写的字符串直接返回，但此时需要通过**@ResponseBody**注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回

@ResponseBody 其返回一个json字符串

@RequestMapping("/ma6")
    @ResponseBody
    public String ModelAndView3() throws Exception {
        System.out.println("Controller save running....ma6");
        User user = new User();
        user.setUsername("huhu");
        user.setAge(25);
        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(user);
        return json;		    }

这里一定记住实体类转json字符串的方法：

String value = new ObjectMapper().writeValueAsString("实体类");

@ResponseBody 直接返回一个实体类（相当于转换为json字符串了，在浏览器还是以键值对的形式出现）

@RequestMapping("/ma7")
@ResponseBody    //表示永远返回的是字符串
public User ModelAndView7() {
    System.out.println("Controller save running....ma7");
    User user = new User();
    user.setUsername("春哥");
    user.setAge(26);
    return user;
}

关于出入的参数，里面需要的参数完全可以由地址栏获取：

@RequestMapping("/ma9")
@ResponseBody    //表示永远返回的是字符串
public String ModelAndView9(String username, int age) {
    System.out.println("Controller save running..../ma9");
    System.out.println(username);
    System.out.println(age);
    return username+"...."+age;
}

浏览器视图：

[外链图片转存失败(img-zJwSvO29-1565150727473)(C:\Users\19433\AppData\Local\Temp\1565075009873.png)]

本来直接返回json字符串是有问题的，需要配置：

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>

注意：在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。

使用<mvc:annotation-driven />自动加载 RequestMappingHandlerMapping（处理映射器）和RequestMappingHandlerAdapter（处理适配器），可用在Spring-xml.xml配置文件中使用<mvc:annotation-driven />替代注解处理器和适配器的配置。

同时使用<mvc:annotation-driven />默认底层就会集成jackson进行对象或集合的json格式字符串的转换。

数据响应总结：

1） 页面跳转：直接返回字符串通过ModelAndView对象返回

2） 回写数据：直接返回字符串 HttpServletResponse 对象直接写回数据，HttpServletRequest对象带回数据，Model对象带回数据或者@ResponseBody将字符串数据写回返回对象或集合 @ResponseBody+<mvc:annotation-driven/>

可以从地址栏获取数据，只要函数需要传递参数，就需要在数据，就需要数据地址栏中根据要求，进行拼接；

关于POJO

POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。
使用POJO名称是为了避免和EJB混淆起来, 而且简称比较直接. 其中有一些属性及其getter setter方法的类,没有业务逻辑，有时可以作为VO(value -object)或dto(Data Transform Object)来使用.当然,如果你有一个简单的运算属性也是可以的,但不允许有业务方法,也不能携带有connection之类的方法。

总结：严格按照封装的类的属性名称进行数据传递传输，可以自动被服务器解析到

2.request 数据响应：返回参数

[外链图片转存失败(img-ULTgGsHf-1565150727473)(C:\Users\19433\AppData\Local\Temp\1564629401310.png)]

数组：

@RequestMapping("/ma11")
@ResponseBody    //表示永远返回的是字符串
public String ModelAndView11(String[] argus) {
    System.out.println("Controller save running..../ma11");
    System.out.println(Arrays.asList(argus));
    return Arrays.asList(argus).toString();
}

[外链图片转存失败(img-8JFnlkr5-1565150727473)(C:\Users\19433\AppData\Local\Temp\1565092174861.png)]

封装集合时需要注意，新建一个以集合为唯一属性的类：

（注意这里的Student 不能传递泛型，他的泛型是List的，不能跨到下一级）

这种集合的形式，一般都是提交表单的时候需要使用的。
```
public class Student {
    private List<User> userList;
```

利用异步请求中，data参数传递数据：data中可以是Json字符串，而json字符串是可以封装集合的

{}表示对象
[]表示集合
不管如何都是会呈现json字符串的形式（键值对的形式）

ajax传递的代码：

<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
    <script>
        <%--这里是定义数组，并且在数组中赋元素--%>
        var userList=new Array();
        userList.push({username:"zhangsan",age:18});
        userList.push({username:"lisi",age:67});

        $.ajax({
            type:"POST",
            url:"${pageContext.request.contextPath}/user/ma13",
            data:JSON.stringify(userList),
            contentType:"application/json;charter=utf-8"
        });
    </script>
</head>

这里有 data:JSON.stringify(userList) 就是将上面的 Javascript 的 List对象转换为json字符串；

/**
  * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
  * @param value A JavaScript value, usually an object or array, to be converted.
  * @param replacer A function that transforms the results.
  * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
  */
stringify(value: any, replacer?: (key: string, value: any) => any, space?: string | number): string;

controller端代码：

@RequestBody可以直接接收集合数据而无需使用POJO进行包装（也就是不使用第一种方法，使用实体类中的属性间接传递集合，这里是利用了json字符串可以传递集合的方式。）

//使用AJAX的test类//一定注意
    @RequestMapping("/ma13")
    @ResponseBody    //表示永远返回的是字符串
    public User ModelAndView13(@RequestBody List <User> list,User user1) {
        System.out.println("Controller save running..../ma13");
        System.out.println(list);
        for (User user : list) {
            System.out.println(user);
        }
        System.out.println(user1);
//        new ObjectMapper(list.get(0))
        return user1;
    }

这里补充一下 Asynchronize Javascript and Xml

JQeury实现方式
1. $. a j a x () * * 语法：$ .ajax({键值对});//使用$.ajax()发送异步请求

$.ajax({
		url:"ajaxServlet1111" , 		// 请求路径

		type:"POST" , 					//请求方式

		//data: "username=jack&age=23",		//请求参数(拼接字符串)
		data:{"username":"jack","age":23},	//json 字符串

		success:function (data) {
			alert(data);
		},						//响应成功后的回调函数
		
		error:function () {
			alert("出错啦...") //表示请求响应出现错误，会执行的回调函数
		}

		dataType:"text"	//设置接受到的响应数据的格式
	});

关于get与post方式的简化版：

	关于使用JQeury的AJAX使用
		2. $.get()：发送get请求
			* 语法：$.get(url, [data], [callback], [type])
				* 参数：
					* url：请求路径
					* data：请求参数
					* callback：回调函数
					* type：响应结果的类型
	**3. $.post()：发送post请求
		** 语法：$.post(url, [data], [callback], [type])
			** 参数：	****	url：请求路径
						** 		data：请求参数
						** 		callback：回调函数
						** 		type：响应结果的类型  // 默认是text

关于json注意：

数据由逗号分隔：多个键值对由逗号分隔;
花括号保存对象：使用{}定义json 格式;
方括号保存数组：[];
可以{}中嵌套[]；也可以[]中嵌套{};
java
1. java 对象转为json字符串并序列化到本地储存： new ObjectMapper().getValue(new File(“C://A.txt”), 对象名称)
2. 普通的都是使用： getValueAsStream( 对象名称)
静态资源开放在spring-mvc.xml配置文件中指定放行的资源：

<mvc:resources mapping="/js/**"location="/js/"/>

<mvc:default-servlet-handler/>
全局请求参数的字符编码统一：filter过滤：

<!--配置全局过滤的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>

通过@RequestParam注解显示的绑定，设置参数传递的默认值，传则有，不传则默认

/使用RequestParam的test类
@RequestMapping(value = "/ma14",produces = "text/application;charset=utf-8")
@ResponseBody    //表示永远返回的是字符串
public String ModelAndView14(@RequestParam(value = "a", required = false, defaultValue = "默认的值 default Value !!") String s) {
    System.out.println("Controller save running..../ma14");
    System.out.println(s);
    return s;
}

使用@PathVariable注解进行占位符的匹配获取

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。基本与@RequestParam的方式相同，但是其功能比起强大，也没有设置占位符，可以传递获取的方法类型；

获取Servlet的API

//API的test类
@RequestMapping("/ma17")
@ResponseBody    //表示永远返回的是字符串
public void ModelAndView17(HttpServletResponse response, HttpServletRequest request, HttpSession session) {
    System.out.println("Controller save running..../ma17");
    System.out.println(response);
    System.out.println(request);
    System.out.println(session);
}

//RequesterHeader  test
@RequestMapping("/ma18")
@ResponseBody    //表示永远返回的是字符串
// @RequestHeader(value = "User-Agent",required = false)
public void ModelAndView18(@RequestHeader(value = "Cookie", required = false) String uu) {
    System.out.println("Controller save running..../ma18");
    //User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.90 Safari/537.36
    //Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
    //Cookie: JSESSIONID=108AF92133332B1BFF3115E058408359
    System.out.println(uu);
}

//RequesterHeader  test
@RequestMapping("/ma19")
@ResponseBody    //表示永远返回的是字符串
// @RequestHeader(value = "User-Agent",required = false)
public void ModelAndView19(@CookieValue(value = "JSESSIONID", required = false) String uu) {
    System.out.println("Controller save running..../ma19");
    //JSESSIONID: 108AF92133332B1BFF3115E058408359
    //相对于@request value="Cookie"更进了一层；
    System.out.println(uu);
}

Spring-mvc第三天

附件：

附件1 SSM Framework need the Liberary:

spring-context (spring框架的坐标)
spring-web （在Web项目中，可以使用ServletContextListener监听Web应用的启动）
spring-webmvc
javax.servlet ( Servlet坐标)
aspectj
spring-jdbc
c3p0
mysql-connector-java
spring-tx 4与8 同在（声明式事务）
spring-test
junit
commons-io
commons-upload
jackson-sore
jackson-annotation
jackson-databind
mybatis
jstl (jstl语句的)

附件2. web.xml 下的配置详情：

<!--【1】全局初始化参数,that is refered to the configuration!-->
<!--这里就需要引入	2. spring-contextsaaaaaaaaaaaaaaaaaaaaaaa  进pom文件 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

<!--【2】Config spring listener Listen the start-up of web-->
<!--这里就需要引入  2. spring-web  进pom文件 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!--【3】springMVC 前端控制器   core configuration 这里是用来配置-->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--【3.1】springMVC 前端控制器  需要引入单独控制前端的  spring-mvc文件：区别于上面所引入的context-param文件，这里引入的是 init-param 文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring_mvc.xml</param-value>
        </init-param>
        <!--【3.2】这里是配置的加载优先级 -->
        <load-on-startup>1</load-on-startup>
    </servlet>
		<!--【3.3】关于Servlet的配置，主要由<servlet>和<servlet-mapping>  -->
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
         <!--【3.4】这里的路径是缺省的   -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

附件3. spring-mvc.xml configuration

<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 
    http://www.springframework.org/schema/beans/spring-beans.xsd 
    http://www.springframework.org/schema/mvc   
    http://www.springframework.org/schema/mvc/spring-mvc.xsd  
    http://www.springframework.org/schema/context   
    http://www.springframework.org/schema/context/spring-context.xsd">
    
    <!--【1】 MVC的注解驱动-->
    <mvc:annotation-driven/>
    
    <!--【2】配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--【3】静态资源权限开放-->
    <mvc:default-servlet-handler/>

    <!--【4】配置controller层的扫描-->
    <context:component-scan base-package="com.itcast"></context:component-scan>

pringframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<!--【1】 MVC的注解驱动-->
<mvc:annotation-driven/>

<!--【2】配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/pages/"/>
    <property name="suffix" value=".jsp"/>
</bean>
<!--【3】静态资源权限开放-->
<mvc:default-servlet-handler/>

<!--【4】配置controller层的扫描-->
<context:component-scan base-package="com.itcast"></context:component-scan>

春哥的技术还不行

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
SpringMVC_summary

Spring-MVC:spring Model and Viewer Controller 轻量级的Web FrameworkspringMVC主要有四天的内容：springMVC的环境配置及入门；springMVC的核心；response & requestspringMVC的内容补充：文件上传，拦截器，异常解析；包含上述内容的项目;知识点：...
复制链接

扫一扫