整理出来是 SpringMvc 笔记 方便以后查询 框架太多了 不经常使用 忘记的可能性很大 自己整理一套笔记 一看就明白了 1 对比
原始请求响应流程 1 发送请求 --> 2 控制层 --> 模型层进行处理 --> 视图 --> 渲染HTML
创建模型层 对象 Mvc模式 1 发送请求 --> 2 控制层 ---> 3 处理器映射器
<-- 返回结果 （寻找请求处理的类） ---> 4 处理器执行器
<-- 返回处理结果 ModelAndView（执行 映射器查询到的 处理类 执行对应处理方法） ---> 5 视图解析器
<-- 返回查询到的视图地址 （解析视图 （获取当前请求 对应的 视图页面）） ---> 6 渲染视图
7 返回响应 <-- <-- 渲染视图 （JSP） PS: 控制层 是前端执行器 具体执行类 是 后端控制器 配置文件模式
{ 1 配置SpringMvc 前端控制器 DispatcherServlet SpringMvc 是基于 servlet的 web.xml配置前端控制器：DispatcherServlet <!-- 配置springmvc核心分发器，对所有的url后缀为action的进行过滤 -->
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 改变springmvc配置文件的位置和名称 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping> 2 配置springmvc.xml <!-- 配置处理器映射器,springmvc默认的处理器映射器
BeanNameUrlHandlerMapping：根据bean(自定义Controler)的name属性的url去寻找hanler(Action:Controller)
-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean> <!-- 配置处理器适配器执行Controlelr ,springmvc默认的
SimpleControllerHandlerAdapter:执行Controller
-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean> <!-- 配置自定义Controler --> 也就是执行方法
<bean id="myController" name="/hello.do" class="cn.controller.MyController"></bean> public class MyController implements Controller{ public ModelAndView handleRequest(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
// 接受请求，接受参数，验证参数
//封装参数，调用业务方法
//返回视图
ModelAndView mv = new ModelAndView();
//设置页面回显数据
mv.addObject("hello", "欢迎学习springmvc！"); //指定跳转的视图
//返回物理视图
//mv.setViewName("/WEB-INF/jsps/index.jsp");
//返回逻辑视图
mv.setViewName("index"); return mv;
} } <!-- 配置sprigmvc视图解析器：解析逻辑试图
后台返回逻辑试图：index
视图解析器解析出真正物理视图：前缀+逻辑试图+后缀====/WEB-INF/jsps/index.jsp
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsps/"></property>
<property name="suffix" value=".jsp"></property>
</bean> 配置完上面的 就可以运行 Spring Mvc 了
} 处理器映射器
{ 1 简单处理器映射器 SimpleUrlHandlerMaping 多个 Url 地址 指向一个处理类 和 手动控制 Url映射地址 <!-- 简单处理器映射器：
把Url进行集中配置
-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="/abc.do">myController</prop>
<prop key="/ss.do">http</prop>
<prop key="/mine.do">http</prop>
</props>
</property> <!-- 配置自定义Controler -->
<bean id="myController" name="/hello.do" class="cn.lw.controller.MyController"></bean> <!-- 配置自定义HttpController -->
<bean id="http" class="cn.lw.controller.HttpController"></bean> 2 控制类名处理程序映射 ControllerClassNameHandlerMapping 根据类名（MyController）类名.do来访问,类名首字母小写 <!-- 定义通过: 类名.do 形式来访问controller -->
<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"></bean> <bean id="myController" name="/hello.do" class="cn.lw.controller.MyController"></bean> Url : myController.do 3 默认处理器映射器 BeanNameUrlHandlerMapping 根据url请求去匹配bean的name属性url，从而获取Controller 执行类
<bean name="/hello.do" class="cn.controller.MyController"></bean> PS： 多个处理器映射器是可以共存的 } 处理器适配器
{ 1 默认的处理器适配器 SimpleControllerHandlerAdapter 调用controller里面方法，返回modelAndView。 <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean> 该 处理器适配器 只处理 继承了 Controller 接口的 controller类 2 HttpRequestHandlerAdapter <!-- HttpRequestHandlerAdapter负责执行实现接口HttpRequestHandler的后端
控制器。
-->
<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"></bean> 该 处理器适配器 只处理 继承了 HttpRequestHandler 接口的 controller类 public class HttpController implements HttpRequestHandler{ public void handleRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//给Request设置值，在页面进行回显
request.setAttribute("hello", "这是HttpRequestHandler！");
//跳转页面
request.getRequestDispatcher("/WEB-INF/jsps/index.jsp").forward(request, response); } PS: 两个 处理器适配器 是可以共从的 }
} 命令控制器
{
用于接收页面参数
public class CommandController extends AbstractCommandController{ //指定参数绑定到那个javaBean
public CommandController(){
this.setCommandClass(User.class);
}
@Override
protected ModelAndView handle(HttpServletRequest request,
HttpServletResponse response, Object command, BindException errors)
throws Exception {
//把命令对象强转成User对象
User user = (User) command;
ModelAndView mv = new ModelAndView();
mv.addObject("user", user);
mv.setViewName("index");
return mv;
}
}
} 乱码问题
{ Get方式：
在Servers下面找 server.xml
<Connector URLEncoding="UTF-8" connectionTimeout="20000" port=.....> Post方式
使用 String编码过滤器：
在web.xml配置
<filter>
<filter-name>characterEncoding</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>characterEncoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping> } 时间类型转换问题
{ SpringMvc 会自动调用 一个initBinder 方法 @Override
protected void initBinder(HttpServletRequest request,
ServletRequestDataBinder binder) throws Exception {
String str = request.getParameter("birthday");
if(str.contains("/")){ binder.registerCustomEditor(Date.class,
new CustomDateEditor(new SimpleDateFormat("yyyy/MM/dd"), true));
}else{ binder.registerCustomEditor(Date.class,
new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
}
} } 配置文件开发实在是蛋疼 ------------------------------------------分割线------------------------------------------ 注解模式
{ 配置Web.xml
和配置文件中的一样 不需要更改什么 配置springmvc配置文件 <!-- 包自动扫描 -->
<context:component-scan base-package="cn.lw.controller"/>
<!-- 配置注解处理器映射器
功能：寻找执行类Controller
-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean> <!-- 配置注解处理器适配器
功能：调用controller方法，执行controller
-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean> <!-- 配置sprigmvc视图解析器：解析逻辑试图
后台返回逻辑试图：index
视图解析器解析出真正物理视图：前缀+逻辑试图+后缀====/WEB-INF/jsps/index.jsp
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsps/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
</beans> 自定义 Connector @Controller//<bean class="UserController"/>
@RequestMapping("/user")
public class UserController { @RequestMapping(value="/hello.do",method={RequestMethod.GET,RequestMethod.POST})
public String hello(){
return "index";
} //跳转到add页面
@RequestMapping("toAdd")
public String toAdd(){
return "add";
} //接受int类型参数
@RequestMapping("recieveInt")
public String recieveInt(Integer id){
System.out.println(id);
return "success";
} //接受字符类型参数
@RequestMapping("recieveStr")
public String recieveStr(String username)
{
System.out.println(username);
return "success";
} //接受数组类型参数
@RequestMapping("recieveArray")
public String recieveArray(Integer[] ids){
System.out.println(ids);
return "success";
}
HTML
{
ID：<input type="checkbox" name="ids" value="1" id="ids">
ID：<input type="checkbox" name="ids" value="2" id="ids">
ID：<input type="checkbox" name="ids" value="3" id="ids">
} //接受参数封装User对象
@RequestMapping("recieveUser")
public String recieveUser(User user){
System.out.println(user);
return "success";
}
HTML
{
姓名：<input type="text" name="user.username" id="username">
生日：<input type="text" name="user.birthday" id="birthday">
性别：<input type="text" name="user.sex" id="sex">
地址：<input type="text" name="user.address" id="address">
} //接受包装类型参数
@RequestMapping("recieveUserCustom")
public String recieveUserCustom(UserCustom userCustom){
System.out.println(userCustom);
return "success";
}
HTML
{
姓名：<input type="text" name="user.username" id="username">
生日：<input type="text" name="user.birthday" id="birthday">
性别：<input type="text" name="user.sex" id="sex">
地址：<input type="text" name="user.address" id="address">
} //接受集合类型参数
@RequestMapping("recieveList")
public String recieveList(UserCustom userCustom){
System.out.println(userCustom);
return "success";
}
HTML
{
姓名：<input type="text" name="userList[0].username" id="username">
地址：<input type="text" name="userList[0].address" id="address">
姓名：<input type="text" name="userList[1].username" id="username">
地址：<input type="text" name="userList[1].address" id="address">
} //接受集合类型参数
@RequestMapping("recieveMap")
public String recieveMap(UserCustom userCustom){
System.out.println(userCustom);
return "success";
}
HTML
{
姓名：<input type="text" name="maps['username']" id="username">
地址：<input type="text" name="maps['address']" id="address">
} //页面回显
@RequestMapping("list")
public String list(Model model){
//model 相当于application域对象
List<User> userList = new ArrayList<User>();
User user1 = new User();
user1.setId(1);
user1.setSex("男");
user1.setUsername("张三");
user1.setAddress("北京");
user1.setBirthday(new Date()); User user2 = new User();
user2.setId(2);
user2.setSex("男2");
user2.setUsername("张三222");
user2.setAddress("北京222");
user2.setBirthday(new Date()); User user3 = new User();
user3.setId(3);
user3.setSex("男3");
user3.setUsername("张三333");
user3.setAddress("北京333");
user3.setBirthday(new Date()); userList.add(user1);
userList.add(user2);
userList.add(user3); // springmvc使用 model 这个对象进行 数据传递
// model对象相当于 application 域 页面可以使用EL 进行处理
model.addAttribute("userList", userList);
return "list"; } //修改
@RequestMapping("updateByID/{id}")
public String updateByID(@PathVariable Integer id,Model model){
User user1 = new User();
user1.setId(id);
user1.setSex("男");
user1.setUsername("张三");
user1.setAddress("北京");
user1.setBirthday(new Date()); model.addAttribute("user", user1); return "edit";
} //测试转发
@RequestMapping("forward")
public String forward(){ return "forward:/items/list.do";
} //测试重定向
@RequestMapping("redirect")
public String redirect(){ return "redirect:/items/list.do";
}
} RequestMapping 注解 requestMapping(“hello”)
requestMapping(“/hello.do”)
requestMapping(value=”/hello.do”)
requestMapping(value=”/hello.do”,method=RequestMethod.GET) 浏览器直接访问,a标签都是get请求
表单提交(指定post)，ajax指定post提交，post提交。
requestMapping(value=”/hello.do”,method=RequestMethod.POST) requestMapping(value=”/hello.do”,method={RequestMethod.POST, RequestMethod.GET}) RequestMapping 根路径问题 如果出现方法名称相同 那就需要设置这个具体是哪个执行类的根路径 @RequestMapping("/a")
public class aController{ @RequestMapping("save")
public void save(){
}
}
Url 就是 /a/save.do @RequestMapping("/b")
public class bController{ @RequestMapping("save")
public void save(){
}
}
Url 就是 /b/save.do RequestParam 注解 defaultValue是默认值
value是别名 如 页面传递过来的是 id 就可以在方法中使用ids接收
required是 是否该参数必须传递 设置默认值后 改参数不起作用 如果没有传递 400错误 @RequestMapping("/home")
public String gohome(HttpServletRequest request,
@RequestParam(defaultValue="1",value="id",required=true)String ids){
System.out.println(request.getRequestURL());
return "index";
} } URL模版映射
{ 普通页面访问传参
Url :/执行类路径地址/updateid?id=1 @RequestMapping("updateid")
public String updateByID(Integer id,Model model){
User user1 = new User();
user1.setId(id);
user1.setSex("男");
user1.setUsername("张三");
user1.setAddress("北京");
user1.setBirthday(new Date());
model.addAttribute("user", user1);
return "edit";
}
Restfull风格设计 初始版本 Url:/执行类路径地址/updateid/1.do
//需要PathVariable这个注解
@RequestMapping("updateByID/{id}")
public String updateByID(@PathVariable Integer id,Model model){
User user1 = new User();
user1.setId(id);
user1.setSex("男");
user1.setUsername("张三");
user1.setAddress("北京");
user1.setBirthday(new Date()); model.addAttribute("user", user1); return "edit";
}
真正使用
配置Web 添加一个约定 <servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/rest/*</url-pattern>
</servlet-mapping> Url:/rest/执行类路径地址/updateid/1
} 转发和重定向
{ 转发 forward 本类进行转发
方式一：return ”forward：list.do“；
方式二：return ”forward：/user/list.do“； //测试转发
@RequestMapping("forward")
public String forward(){ return "forward:/user/list.do";
}
注意：user根路径前面必须有/ 跨类进行转发：
转发方式：return ”forward：/order/list.do“； 重定向 redirect 本类进行重定向
方式一：return ”redirect：list.do“；
方式二：return ”redirect：/user/list.do“； 跨类进行重定向：
转发方式：return ”redirect：/order/list.do“； } Mvc 注解模式 <mvc:annotation-driven/>
{
加入该标签 默认就创建了 配置注解处理器映射器 功能：寻找执行类Controller
RequestMappingHandlerMapping 配置注解处理器适配器 功能：调用controller方法，执行controller
RequestMappingHandlerAdapter 同时 默认提供了 json 格式的支持 springmvc 配置
{
<!-- 包自动扫描 -->
<context:component-scan base-package="cn.lw.controller"/>
<!-- Mvc 注解模式 -->
<mvc:annotation-driven/> <!-- 配置sprigmvc视图解析器：解析逻辑试图
后台返回逻辑试图：index
视图解析器解析出真正物理视图：前缀+逻辑试图+后缀====/WEB-INF/jsps/index.jsp
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsps/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
} } SpringMvc 对json 格式的支持
{ 加入Jar包 使用<mvc:annotation-driven/> 无法对其扩展 <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
</property> 由于 @RequestMapping("requestJson")
public @ResponseBody User requestJson(@RequestBody User user)
{
return user;
} 由于<mvc:annotation-driven/> 标签已经默认对Json支持了 所有 bean 就不用配置了 } SpringMvc 对多视图的支持
{
配置 springmvc配置文件
<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
<!-- 配置支持媒体类型 -->
<property name="contentNegotiationManager">
<bean
class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
<property name="mediaTypes">
<map>
<entry key="json" value="application/json"></entry>
<entry key="xml" value="application/xml"></entry>
</map>
</property>
</bean>
</property> <!-- 指定默认视图 -->
<property name="defaultViews">
<!-- 支持多个视图 -->
<list>
<!-- 对josn格式视图支持 -->
<bean
class="org.springframework.web.servlet.view.json.MappingJacksonJsonView"></bean> <!-- xml格式视图支持 -->
<bean class="org.springframework.web.servlet.view.xml.MarshallingView">
<constructor-arg>
<bean class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name="classesToBeBound">
<list>
<value>cn.lw.domain.User</value>
</list>
</property>
</bean>
</constructor-arg>
</bean>
</list>
</property>
</bean> @RequestMapping("userView")
public User userView(){
User u=new User();
return u;
} 访问很简单 通过后缀名 就自动转换成对应格式了 /rest/user/userView.json
/rest/user/userView.xml Ps： 配置 路径 } 文件上传
{ 在SpringMVC中配置文件上传解析器 <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="10240000"/>
</bean> 夸服务器上传 如果不写ID 可能会出错 解释一下 夸服务器上传 什么意思
就是单独的拿出一台服务器来保存图片，改服务器什么都不做 建立一个文件夹 修改一下允许 修改的 权限
最终结果就是 提供一个服务器路径 如 http://10.10.10.10:8080/imgs/1.img <script type="text/javascript">
function submitImgSize1Upload(){
var option={
type:'POST',
url:'${pageContext.request.contextPath }/upload/uploadPic.do',
dataType:'text',
data:{
fileName : 'imgSize1File'
},
success:function(data){
//把json格式的字符串转换成json对象
var jsonObj = $.parseJSON(data);
//返回服务器图片路径，把图片路径设置给img标签
$("#imgSize1ImgSrc").attr("src",jsonObj.fullPath);
//数据库保存相对路径
$("#imgSize1").val(jsonObj.relativePath);
}
};
$("#itemForm").ajaxSubmit(option);
}
</script> <form id="itemForm" action="${pageContext.request.contextPath }/items/saveOrUpdate.do" method="post">
<input type='file' id='imgSize1File' name='imgSize1File' class="file" onchange='submitImgSize1Upload()' />
</form> @RequestMapping("uploadPic")
public void uploadPic(HttpServletRequest request,String fileName,PrintWriter out){
//把Request强转成多部件请求对象
MultipartHttpServletRequest mh = (MultipartHttpServletRequest) request;
//根据文件名称获取文件对象
CommonsMultipartFile cm = (CommonsMultipartFile) mh.getFile(fileName);
//获取文件上传流
byte[] fbytes = cm.getBytes(); //文件名称在服务器有可能重复？
String newFileName="";
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
newFileName = sdf.format(new Date()); Random r = new Random(); for(int i =0 ;i<3;i++){
newFileName=newFileName+r.nextInt(10);
} //获取文件扩展名
String originalFilename = cm.getOriginalFilename();
String suffix = originalFilename.substring(originalFilename.lastIndexOf(".")); //创建jesy服务器，进行跨服务器上传
Client client = Client.create();
//把文件关联到远程服务器
WebResource resource = client.resource(Commons.PIC_HOST+"/upload/"+newFileName+suffix);
//上传
resource.put(String.class, fbytes); //ajax回调函数需要会写写什么东西？
//图片需要回显：需要图片完整路径
//数据库保存图片的相对路径.
String fullPath = Commons.PIC_HOST+"/upload/"+newFileName+suffix; String relativePath="/upload/"+newFileName+suffix;
//{"":"","":""}
String result="{\"fullPath\":\""+fullPath+"\",\"relativePath\":\""+relativePath+"\"}"; out.print(result);
} } springmvc 页面缓存 freemarker
{
配置xml
<!-- 配置freemarker模版文件前缀，模版文件编码 -->
<bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
<property name="templateLoaderPath" value="/WEB-INF/jsps/"></property>
<property name="defaultEncoding" value="UTF-8"></property>
</bean>
<!-- 配置freemarker视图解析后缀，页面显示视图编码 -->
<bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
<property name="suffix" value=".ftl"></property>
<property name="contentType" value="text/html;charset=utf-8"></property>
</bean> 意思是 .ftl 后缀的 请求 都走 freemarker视图 freemarker 有自己的 标签 和jsp 差不多 详细的请百度 } springMvc 拦截器
{
局部拦截器 针对单个处理器映射器，就叫局部拦截器。 全局拦截器 <!--拦截器 -->
<mvc:interceptors>
<!--多个拦截器,顺序执行 -->
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="cn.lw.interceptor.Interceptor1"></bean>
</mvc:interceptor>
<mvc:interceptor>
<mvc:mapping path="/**"/>
<bean class="cn.lw.interceptor.Interceptor2"></bean>
</mvc:interceptor>
</mvc:interceptors> public class Interceptor1 implements HandlerInterceptor{ //preHandle在处理器映射器之前进行执行
//return false:拦截 return true:放行
public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1,
Object arg2) throws Exception {
System.out.println("这是第一个拦截器Interceptor1。。。preHandle");
return true;
} //还没有调用Controller，还没返回modelAndView执行
public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
Object arg2, ModelAndView arg3) throws Exception {
System.out.println("这是第一个拦截器Interceptor1。。。postHandle"); } //返回modelAndView之后执行
public void afterCompletion(HttpServletRequest arg0,
HttpServletResponse arg1, Object arg2, Exception arg3)
throws Exception {
System.out.println("这是第一个拦截器Interceptor1。。。afterCompletion"); }
} Springmvc规定：凡是preHandle返回true，afterCompletion必须执行 第一个拦截器放行，第二个拦截器也放行： 这是第一个拦截器Interceptor1。。。preHandle
这是第二个拦截器Interceptor2。。。preHandle
这是第二个拦截器Interceptor2。。。postHandle
这是第一个拦截器Interceptor1。。。postHandle
这是第二个拦截器Interceptor2。。。afterCompletion
这是第一个拦截器Interceptor1。。。afterCompletion 第一个拦截器放行，第二个不放行： Springmvc规定：凡是preHandle返回true，afterCompletion必须执行。 这是第一个拦截器Interceptor1。。。preHandle
这是第二个拦截器Interceptor2。。。preHandle
这是第一个拦截器Interceptor1。。。afterCompletion }
一些问题
关于MVC REST 请求的问题
格式1
@RequestMapping(value = "{itemCatId}", method = RequestMethod.GET)
public ResponseEntity<TbItemParam> queryItemParamByItemCatid(
@PathVariable Long itemCatId)
{
}
格式2
@RequestMapping(value = "{itemCatId}", method = RequestMethod.GET)
@ResponseBody
public ResponseEntity<TbItemParam> queryItemParamByItemCatid(
@PathVariable("itemCatId") Long itemCatId)
{
}
格式3
@RequestMapping(value = "/destroy/{ConsumerID:^[0-9]*.*@[0-9]*}", method = RequestMethod.GET, produces = "application/json; charset=utf-8")
@ResponseBody
public String destroyMqConsumer(@PathVariable String ConsumerID)
{
}
返回值的问题
try
{
TbItemParam queryitemParam = new TbItemParam();
queryitemParam.setItemCatId(itemCatId);
return ResponseEntity.ok(queryitemParam); // 状态码是 200
return ResponseEntity.status(HttpStatus.CREATED).build(); // 状态码是 200 不返回 实体数据
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(queryitemParam); // 状态码是 200 返回 实体数据
}
catch (Exception e)
{
e.printStackTrace();
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null); // 状态码是 200 返回 实体数据 是null
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
// 状态码是 500
}
关于 请求过滤器 处理PUT 没有参数的问题
<!-- PUT 请求过滤器 处理PUT 没有参数的问题 -->
<filter>
<filter-name>HttpPutFormContentFilter</filter-name>
<filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>HttpPutFormContentFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
关于options 请求不处理的问题
<servlet>
<servlet-name>springdispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springMvc-viewresolver.xml</param-value>
</init-param>
<init-param>
<param-name>dispatchOptionsRequest</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
自己写的笔记，不管多久后 查看后也能非常快速的回顾起来。看别人写的始终是别人的