SpringMVC - xiaoWang3486

关于springMVC：
Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。轻量级，简单易学
高效 , 基于请求响应的MVC框架
与Spring兼容性好，无缝结合
约定优于配置
功能强大：RESTful、数据验证、格式化、本地化、主题等
简洁灵活
springMVC的实现原理图

发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者

实现流程：
HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler让具体的Controller执行。
Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户。

4.springMVC的使用：

1.创建父工程，在公共pom文件中配置依赖

\<dependencies\>  
 \<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\</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\>  
 \<dependency\>  
 \<groupId\>javax.servlet\</groupId\>  
 \<artifactId\>jstl\</artifactId\>  
 \<version\>1.2\</version\>  
 \</dependency\>  
\</dependencies\>

在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\>  
 \<!--启动级别-1--\>  
 \<load-on-startup\>1\</load-on-startup\>  
 \</servlet\>  
 \<!--  
 在SpringMVC中， / /\*  
 / : 只匹配所有的请求，不会去匹配jsp页面  
 /\* : 匹配所有的请求，包括jsp页面  
 --\>  
 \<servlet-mapping\>  
 \<servlet-name\>springmvc\</servlet-name\>  
 \<url-pattern\>/\</url-pattern\>  
 \</servlet-mapping\>  
\</web-app\>

在resouces目录里添加springmvc-servlet.xml配置文件

添加处理器映射器 (HandlerMapping)

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

添加处理器适配器 (HandlerAdapter)

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

添加视图解析器 (ViewResolver)

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>

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

<bean id="/hello" class="com.kuang.controller.HelloController"/>

使用注解方式使用springmvc

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

<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

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

<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

在resouces目录里添加springmvc-servlet.xml配置文件

<context:component-scan base-package="spring.study.controller"/>

<mvc:default-servlet-handler />

<mvc:annotation-driven />

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
id="InternalResourceViewResolver">

<property name="prefix" value="/WEB-INF/jsp/"/>

<property name="suffix" value=".jsp" />
</bean>

</beans>

3.创建controller（添加注解）

@Controller
public class FirstController {
@RequestMapping("/hell")
public String hello(Model model){
model.addAttribute("nam","hello annotation Springmvc!!");
return "hello";
}
}

RestFul风格

使用路径变量的好处

简洁、高效、安全

使路径变得更加简洁；

获得参数更加方便，框架会自动进行类型转换。

通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。

安全，不会暴露变量名

概念

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

功能

资源：互联网所有的事物都可以被抽象为资源

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。

分别对应添加、删除、修改、查询。

传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

使用RestFul操作资源 ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询,GET
http://127.0.0.1/item 新增,POST
http://127.0.0.1/item 更新,PUT
http://127.0.0.1/item/1 删除,DELETE

返回值处理

处理提交数据

1.提交的域名称和处理方法参数名一致

提交数据 : http://localhost:8080/hello?name=kuangshen

处理方法 :

1.  @RequestMapping("/hello")
2.  public String hello(String name){
3.  System.out.println(name);
4.  return "hello";
5.  }

后台输出 : kuangshen

2、提交的域名称和处理方法参数名不一致

提交数据 : [@RequestParam](http://localhost:8080/hello?username=kuangshen处理方法(使用<a href=)()注解"">http://localhost:8080/hello?username=kuangshen处理方法(使用@RequestParam()注解括号内存入提交的域名称) :

1.  //@RequestParam("username") : username提交的域的名称 .
2.  @RequestMapping("/hello")
3.  public String hello(@RequestParam("username") String name){
4.  System.out.println(name);
5.  return "hello";
6.  }

后台输出 : kuangshen

3、提交的是一个对象

要求提交的表单域和对象的属性名一致 , 参数使用对象即可

实体类：

1.  public class User {
2.  private int id;
3.  private String name;
4.  private int age;
5.  //构造
6.  //get/set
7.  //tostring()
8.  }

提交数据 : http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15

处理方法 :

1.  @RequestMapping("/user")
2.  public String user(User user){
3.  System.out.println(user);
4.  return "hello";
5.  }

后台输出 : User { id=1, name=’kuangshen’, age=15 }

说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

解决乱码问题

配置SpringMVC的乱码过滤

给web.xml文件添加过滤器

1.  \<filter\>
2.  \<filter-name\>encoding\</filter-name\>
3.  \<filter-class\>org.springframework.web.filter.CharacterEncodingFilter\</filter-class\>
4.  \<init-param\>
5.  \<param-name\>encoding\</param-name\>
6.  \<param-value\>utf-8\</param-value\>
7.  \</init-param\>
8.  \</filter\>
9.  \<filter-mapping\>
10.  \<filter-name\>encoding\</filter-name\>
11.  \<url-pattern\>/\*\</url-pattern\>
12.  \</filter-mapping\>

其他方法

修改tomcat配置文件service.xml ：设置编码！

1.  \<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
2.  connectionTimeout="20000"
3.  redirectPort="8443" /\>

JSON

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

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

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

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

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都能通过 JSON来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

对象表示为键值对，数据由逗号分隔

花括号保存对象

方括号保存数组

JSON键值对是保存 JavaScript对象的一种方式,和 JavaScript 对象的写法大同小异，键/值对组合中的键名写在前并用双引号“”包裹，用冒号:分隔，然后紧接着值：

JSON 和 JavaScript 对象的关系：

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

//将js对象转换为JSON对象

var json = JSON.stringify(user);

//将JSON对象转换为JavaScript对象

var obj = JSON.parse(json);

乱码统一解决

可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！

1.  \<!--JSON乱码问题配置--\>
2.  \<mvc:annotation-driven\>
3.  \<mvc:message-converters register-defaults="true"\>
4.  \<bean class="org.springframework.http.converter.StringHttpMessageConverter"\>
5.  \<constructor-arg value="UTF-8"/\>
6.  \</bean\>
7.  \<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"\>
8.  \<property name="objectMapper"\>
9.  \<bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"\>
10.  \<property name="failOnEmptyBeans" value="false"/\>
11.  \</bean\>
12.  \</property\>
13.  \</bean\>
14.  \</mvc:message-converters\>
15.  \</mvc:annotation-driven\>

使用Jackson

使用Jackson解析工具，需要导入它的jar包；

1.  \<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core --\>
2.  \<dependency\>
3.  \<groupId\>com.fasterxml.jackson.core\</groupId\>
4.  \<artifactId\>jackson-databind\</artifactId\>
5.  \<version\>2.9.8\</version\>
6.  \</dependency\>

其余配置不变，修改UserController代码，使用ObjectMapper

@RestController 返回字符串

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！ :

1.  @RestController
2.  public class UserController {
3.  
4.  @RequestMapping("/j1")
5.  //@ResponseBody //添加@ResponseBody就不会走视图解析器，会直接返回一个字符串
6.  public String json1() throws JsonProcessingException {
7.  //jackson, ObjectMapper
8.  ObjectMapper mapper = new ObjectMapper();
9.  //创建一个对象
10.  User user = new User("张三一号",18,"女");
11.  
12.  String str = mapper.writeValueAsString(user);
13.  
14.  return str;
15.  }
16.  
17.  }

开发一个书籍项目：

项目准备

1.设计数据库

2.构建maven项目模块

3.在pom文件中引入依赖

<!-- 保证各级目录资源被打包>

\<build\>  
 \<resources\>  
 \<resource\>  
 \<directory\>src/main/java\</directory\>  
 \<includes\>  
 \<include\>\*\*/\*.properties\</include\>  
 \<include\>\*\*/\*.xml\</include\>  
 \</includes\>  
 \<filtering\>false\</filtering\>  
 \</resource\>  
 \<resource\>  
 \<directory\>src/main/resources\</directory\>  
 \<includes\>  
 \<include\>\*\*/\*.properties\</include\>  
 \<include\>\*\*/\*.xml\</include\>  
 \</includes\>  
 \<filtering\>false\</filtering\>  
 \</resource\>  
 \</resources\>  
\</build\>

编写Model层

4.在java目录下创建pojo，dao，service包

5.编写与数据库表类型匹配的pojo类

编写三层架构(dao持久层,service业务层,view调用控制层)

编写dao层

6.编写对应的dao层方法

7.编写dao层的mapper.xml文件

\<?xml version="1.0" encoding="UTF-8" ?\>  
\<!DOCTYPE mapper  
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd"\>  
\<mapper namespace="dao层对应接口的全限定类名"\>\</mapper\>

8.创建mybatis核心配置文件,配置起别名,配置mapper映射

\<?xml version="1.0" encoding="UTF-8" ?\>  
\<!DOCTYPE configuration  
 PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
 "http://mybatis.org/dtd/mybatis-3-config.dtd"\>  
\<configuration\>  
 \<typeAliases\>  
 \<package name="spring.study.pojo"/\>  
 \</typeAliases\>  
 \<mappers\>  
 \<mapper class="spring.study.dao.BooksMapper"/\>  
 \</mappers\>  
\</configuration\>

9.编写jdbc.properties配置文件

10.配置spring-dao.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 http://www.springframework.org/schema/beans/spring-beans.xsd"\>  
\<!-- 引入外部资源--\>  
\<!-- 配置数据源--\>  
\<!-- 配置SqlSessionFactoryBean--\>  
\<!-- 配置核心配置文件位置--\>  
\<!-- 添加进行操作的数据圆对象--\>  
\<!-- 配置mapper扫描器,添加代理类--\>  
\<!-- 配置SqlSessionFactoryBeanNAme--\>  
\<!-- 配置basePackage需要代理类接口的dao包--\>  
\</beans\>

编写service层

11.编写service接口方法

12.编写service的实现类,定义并私有化dao层对象,并创建set构造注入

13.配置spring-service.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 http://www.springframework.org/schema/beans/spring-beans.xsd"\>  
 \<!-- 添加包的扫描--\>  
 \<!-- 添加serviceImpl的bean对象--\>  
 \<!-- 通过set注入把dao层mapper代理类bean注入--\>  
 \<!-- 添加service层事务配置DataSourceTransactionMAnager--\>  
 \<!-- 注入进行管理的数据源对象--\>  
\</beans\>

编写controller层

14.给模块添加Web框架

15.配置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"\>  
 \<!-- 注册DispatcherServlet--\>  
 \<!-- 配置springmvc层配置文件路径初始化参数--\>  
 \<!-- 加载优先级--\>

\<!-- 添加filter乱码过滤器CharacterEncodingFilter\>  
\</web-app\>

16.配置spring-mvc.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 http://www.springframework.org/schema/beans/spring-beans.xsd"\>  
 <!-- 添加包的组件扫描\>
<!-- 添加annotation-diven配置，引入HandlerMapping,HandlerAdapter\>
<!-- 配置静态资源处理\>
<!-- 配置视图处理器InternalResourceViewResolver\>
<!-- 配置前缀和后缀  
</beans\>

16.编写添加了@Controller注解的controller的类处理用户发送的请求

posted on 2023-09-25 14:32 xiaoWang3486 阅读(14) 评论(0) 收藏举报

刷新页面返回顶部

xiaoWang3486

公告

1.创建父工程，在公共pom文件中配置依赖

在web.xml文件中配置注册DispatcherServlet

在resouces目录里添加springmvc-servlet.xml配置文件

使用注解方式使用springmvc

在web.xml文件中配置注册DispatcherServlet

在resouces目录里添加springmvc-servlet.xml配置文件

RestFul风格

处理提交数据

1.提交的域名称和处理方法参数名一致

2、提交的域名称和处理方法参数名不一致

3、提交的是一个对象

配置SpringMVC的乱码过滤

给web.xml文件 添加过滤器

其他方法

JSON

乱码统一解决

使用Jackson

@RestController 返回字符串

项目准备

编写Model层

编写三层架构(dao持久层,service业务层,view调用控制层)

给web.xml文件添加过滤器