我的SpringMVC笔记

SpringMVC

使用

1.添加依赖junit、spring-webmvc、servlet-api、jsp-api、jstl

2.如果只是maven项目需要添加web支持

3.配置web.xml
<1>首先注册dispatcherServlet，在web.xml的servlet里springmvc初始化，设置初始化的启动文件springmvc-servlet.xml
设置启动级别
<2>匹配所有请求信息，这里我们设置servlet-mapping

4.springmvc-servlet.xml
<1>添加BeanNameUrlHandlerMapping、SimpleControllerHandlerAdapter两个bean(Mapping以及适配器)
<2>添加视图解析器–用于过滤/WEB-INF/…下的 后缀的jsp 文件

5.在对应的/WEB-INF/…放我们的hello.jsp页面

6.控制类：可以使用ModelAndView 对象传递数据，
addObject("","")//用于传递数据
setViewName(“hello”)//跳转到hello 页面，由于在springmvc-servlet.xml设置过地址，则会自动拼接成这里的地址

7.spring-servlet.xml里还可以设置Handler用于处理请求地址 /hello 我们请求hello就能访问了

可能出现错误：

1.由于我们创建的是普通的项目，可能缺少jar包，在IDEA项目发布中添加lib 依赖，重启Tomcat即可解决

总结：

1.使用SpringMVC我们可以不写Servlet，也不需要向以前写J2EE时候去写请求地址，全部交给Spring管理，我们基本上只需要改变controller

原理：

1.web.xml找springmvc-servlet.xml下/所有

2.当我们输入hello请求时，springmvc-servlet.xml去映射器找/hello 适配器找到HelloController类进入处理
【HandlerMapping里配置请求/hello-------用于处理我们的请求的，如下】

<bean id="/hello" class="com.example.controller.HelloController"/>
#controller是我们的控制类，HelloController是我们的具体方法

3.HelloController完成后通过视图解析器setViewName(“跳到xxxx.jsp页面”)

使用注解开发Springmvc

1.添加依赖junit、spring-webmvc、servlet-api、jsp-api、jstl 添加build

2.web.xml:注册servlet(绑定springmvc-servlet.xml)、拦截sprinmvc请求

3…springmvc-selvet.xml：
<1>配置自动扫描包(指定包下注解生效，由IOC统一管理)

<context:component-scan bease-package="com.example.controller"/>#扫描控制类

<2>让springmvc不处理静态资源

<mvc:default-servlet-handler/>

<3>让它支持注解驱动

<mvc:annotation-driven/>#配置后就不需要使用hander了，它会自动配置

<4>视图解析器–配置一下前缀后缀

4.在对应的/WEB-INF/…放我们的hello.jsp页面

5.控制类里使用@Controller 请求方法@RequestMapping
<1>@Controller—控制类返回页面的
@RequestMapping("/访问地址") return"xxx" xxx.jsp是已放在目标文件下的
@ResponseBody—返回字符串
<2>@RestController—返回字符串

Restful风格

不同请求方式实现不同效果，同一请求地址功能可以不同

@GetMapping用get方法提交
@PostMapping post方式提交
@PutMapping
@DeleteMapping
@PatchMapping

基本实现：

@RequstMapping("/add/{a}/{b}")
public String test(@PathVariable int a,@PathVariable int a){
    //使用@PathVariable就能得到上面的{}里的
}

提交方式不同：

方法一：手动添加

@RequstMapping(value="/add/{a}/{b}",method=RequestMethod.Get)
public String test(@PathVariable int a,@PathVariable int a){
    
}

方法二：使用注解

@PostMapping("/add/{a}/{b}")
public String test(@PathVariable int a,@PathVariable int a){  }

转发和重定向

如果不使用视图解析器
转发可以得到数据(转发功能更多些)，重定向不可以得到

@RequestMapping("/add/{a}/{b}")
public String test(Model model){
	model.addAttribute("msg","ModelTest");
    return "/WEB-INF/jsp/test.jsp";//需要自己拼接地址---默认转发
    return "forward/WEB-INF/jsp/test.jsp";//---转发
    
    
    return "redirect:/WEB-INF/jsp/test.jsp";//重定向
}

​ 有视图解析器

return "test.jsp";//转发

return "redirect:/test.jsp";//重定向
return "redirect:hello";//重定向到hello请求

接收请求参数

请求处理方法和请求参数不一致：
@RequestParam(“传入的”) String 我们需要的)—最好写时候都加上

如果传入对象：参数必须和对象里的一致

数据显示到前端

1.ModelAndView

//实现Controller接口
//使用ModelAndView对象，addObject传递信息，跳转页面setViewName
//返回类型ModelAndView
public class MyTest implements Controller{
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse) throws Exception{
        ModelAndView mx=new ModelAndView();
        mv.addObject("msg","..");//传递信息
        mv.setViewName("test");//跳转到test.jsp
        return mv;
    }
}

2.ModelMap–拿来即用

@RequestMapping("/hello")
public String hello(ModelMap model){
    model.addAttribute("","");//传递信息
    return "test";
}

3.Model–拿来即用–精简版

@RequestMapping("/hello")
public String hello(Model model){
    model.addAttribute("","");//传递信息
    return "test";
}

对比：
ModelAndView—存储数据同时，可以进行设置返回逻辑视图，进行控制展示层跳转【可以视图】
ModelMap—继承LinkedMap，【功能比较多】
Model—【精简版】

乱码

通常情况下：web.xml补充

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

极端情况下：

1.修改tomcat配置， tomcat/conf/service.xml 71行附近

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />

2.自定义过滤器(直接用)

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
* 解决get和post请求 全部乱码的过滤器
*/
public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
  }

   @Override
   public void doFilter(ServletRequest request, ServletResponseresponse, FilterChain chain) throws IOException, ServletException {
       //处理response的字符编码
       HttpServletResponse myResponse=(HttpServletResponse) response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 转型为与协议相关对象
       HttpServletRequest httpServletRequest = (HttpServletRequest)request;
       // 对request包装增强
       HttpServletRequest myrequest = newMyRequest(httpServletRequest);
       chain.doFilter(myrequest, response);
  }

   @Override
   public void init(FilterConfig filterConfig) throwsServletException {
  }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

   private HttpServletRequest request;
   //是否编码的标记
   private boolean hasEncode;
   //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
   public MyRequest(HttpServletRequest request) {
       super(request);// super必须写
       this.request = request;
  }

   // 对需要增强方法 进行覆盖
   @Override
   public Map getParameterMap() {
       // 先获得请求方式
       String method = request.getMethod();
       if (method.equalsIgnoreCase("post")) {
           // post请求
           try {
               // 处理post乱码
               request.setCharacterEncoding("utf-8");
               return request.getParameterMap();
          } catch (UnsupportedEncodingException e) {
               e.printStackTrace();
          }
      } else if (method.equalsIgnoreCase("get")) {
           // get请求
           Map<String, String[]> parameterMap =request.getParameterMap();
           if (!hasEncode) { // 确保get手动编码逻辑只运行一次
               for (String parameterName : parameterMap.keySet()) {
                   String[] values = parameterMap.get(parameterName);
                   if (values != null) {
                       for (int i = 0; i < values.length; i++) {
                           try {
                               // 处理get乱码
                               values[i] = new String(values[i]
                                      .getBytes("ISO-8859-1"), "utf-8");
                          } catch (UnsupportedEncodingException e) {
                               e.printStackTrace();
                          }
                      }
                  }
              }
               hasEncode = true;
          }
           return parameterMap;
      }
       return super.getParameterMap();
  }

   //取一个值
   @Override
   public String getParameter(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       if (values == null) {
           return null;
      }
       return values[0]; // 取回参数的第一个值
  }

   //取所有值
   @Override
   public String[] getParameterValues(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       return values;
  }
}

3.配置springmvc的乱码过滤

<filter>
	<filter-name>encofing</filter-name>
    <filter-class>com.xxx.xxx.xx.GenericEncodingFilter</filter-class>
</filter>
<filter-mapping>
	<filter-name>encoding</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

JSON

var user={name:"yang",age:1};
var json=JSON.stringify(user);//javaScript对象转化为json对象----JSON.stringify
var obj=JSON.parse(json);//json对象转化为javaScript对象----JSON.parse

JSON.stringify—对象转json
JSON.parse—json转对象

Jackson

使用Jackson:

1.依赖jackson-databind

2.配置web.xml、springmvc-servler.xml

3.将对象转化为字符串格式

ObjectMapper mapper=new ObjectMapper();//使用ObjectMapper
对象user
String str=mapper.writeValueAsString(user);

4.结果：对象转变成json格式
{“name”:“yang”,“age”:“456”}

出现乱码:

方法一:(不常用)

@RequestMapping(value="/xx",produces="application/json;charset=utf-8")
//在请求方法注释前加produces="application/json;charset=utf-8"

方法二:利用框架统一解决乱码问题
在 springmvcservlet.xml里

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

补充:用字符串格式显示时间

方法一:

方法二:

方法三:使用自定义工具----以后所有的json数据都可以用这个

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {
   
   public static String getJson(Object object) {
       return getJson(object,"yyyy-MM-dd HH:mm:ss");
  }

   public static String getJson(Object object,String dateFormat) {
       ObjectMapper mapper = new ObjectMapper();
       //不使用时间差的方式
       mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
       //自定义日期格式对象
       SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
       //指定日期格式
       mapper.setDateFormat(sdf);
       try {
           return mapper.writeValueAsString(object);
      } catch (JsonProcessingException e) {
           e.printStackTrace();
      }
       return null;
  }
}

Fastjson

阿里的用实现json与JavaBean转换

JSONObject–json对象
JSONArray–json对象数组
JSON–JSONObject和JSONArray的转化

使用:
1.依赖fastjson

2.需要的地方直接使用

字符串—>java对象

//Java对象 转 JSON字符串-----------
String str1 = JSON.toJSONString(list);
//JSON字符串 转 Java对象-----------
User jp_user1=JSON.parseObject(str2,User.class);

json对象—>java对象

//Java对象 转 JSON对象-----------
JSONObject jsonObject1 = (JSONObject)
JSON.toJSON(user2);
//JSON对象 转 Java对象-----------
User to_java_user =
JSON.toJavaObject(jsonObject1,User.class);

对象
JSONArray–json对象数组
JSON–JSONObject和JSONArray的转化

使用:
1.依赖fastjson

2.需要的地方直接使用

字符串—>java对象

//Java对象 转 JSON字符串-----------
String str1 = JSON.toJSONString(list);
//JSON字符串 转 Java对象-----------
User jp_user1=JSON.parseObject(str2,User.class);

json对象—>java对象

//Java对象 转 JSON对象-----------
JSONObject jsonObject1 = (JSONObject)
JSON.toJSON(user2);
//JSON对象 转 Java对象-----------
User to_java_user =
JSON.toJavaObject(jsonObject1,User.class);