SpringMVC汇总

  • Controller 控制器
  • RequestMapping 作为一个映射的访问的路径
  • 视图解析器
1
2
3
4
5
6
7
8
<bean id="jspViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--
prefix 前缀 用于指定jsp页面的存放位置,只有存放在这个路径下的jsp才能被使用
suffix 后缀 用于指定视图文件的文件格式,后缀名
-->
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
  • 设置请求方式
1
2
3
4
@RequestMapping(value={"/testMethod","/testMethod2"},method=RequestMethod.POST)
public String testMethod(){
return "myJsp";
}
  • RequestParam注解
1
2
3
4
5
6
7
8
9
@RequestMapping("/testParam")
public String testParam(@RequestParam(value="id",required=false,defaultValue="1") Integer id,
@RequestParam(value="name") String name){

System.out.println(id);
System.out.println(name);

return "myJsp";
}
  • 实体类接收参数
1
2
3
4
5
6
7
@RequestMapping("/testParamByModel")
public String testParamByModel(StuModel stuModel){

System.out.println(stuModel);

return "myJsp";
}

-请求的编码

1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- 设置请求时的编码方式 -->
<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>

-ant风格访问路径映射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/**
* Ant风格的访问路径映射
* 通配符方式
* 用法:
* 1.一个星号 *
* 星号可以匹配任意长度的任意字符,但是只能向下匹配一级的路径
* /testAnt/123/
* /testAnt/12323asdacadad/
*/
@RequestMapping("/testAnt/*")
public String testAnt(){
System.out.println("执行了testAnt");
return "";
}

/**
* 用法:
* 2.两个星号 **
* 两个星号可以匹配无限级别,输入任意字符,都可以访问到
*/
@RequestMapping("/testAnt1/**")
public String testAnt1(){
System.out.println("执行了testAnt1");
return "";
}

/**
* 用法:
* 3.问号 ?
* 占位符 一个占位符 只能替换成一个字符
*/
@RequestMapping("/testAnt2/a?b?c??")
public String testAnt2(){
System.out.println("执行了testAnt2");
return "";
}
  • ModelAttribute 注解
    (类似于静态代码块)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    * @ModelAttribute注解
    * 作用:
    * 1.将方法的返回值存入request
    * 场景:
    * 查询公共数据,每个处理器都要查询这部分数据
    * 可以将查询数据的代码,提取到一个带有@ModelAttribute注解的方法中
    * 用法:
    * 1.将注解写在方法的定义处
    * 过程:
    * 如果访问了控制器中的某一个处理器
    * 首先检测该控制器中有没有注解了@ModelAttribute的方法
    * 如果有,先执行带有@ModelAttribute的方法(有几个执行几个)

    @ModelAttribute("stu")
    public StuModel stuModelReq(){
    System.out.println("执行了model方法");
    StuModel stuModel = new StuModel();
    stuModel.setAge(1);
    stuModel.setStuName("张三");
    return stuModel;
    }
  • 转发和重定向

1
2
3
4
5
6
7
8
9
@RequestMapping("/forward")
public String forward(){
return "forward:/testModel";
}

@RequestMapping("/redirect")
public String redirect(){
return "redirect:/testModel";
}
  • PathVariable注解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
* @PathVariable注解
* 模板类型的URL
* 场景:
* http://blog.youkuaiyun.com/dev_csdn/article/details/78839218
* http://blog.youkuaiyun.com/dev_csdn/article/details/78839392
* 作用:
* 接收请求参数,接收的是访问路径中的请求参数
* 1.可以将参数隐藏到访问路径中
* 2.实现Rest风格
* 用法:
* /testPath/张三/25
* 1.value属性的值 要和 大括号中的字符对应,那么就可以接收到对应为值的参数值
* 注意:
* 只能接受在访问路径中的参数,不能接收问号传参,form表单提交
* 解释:
* 模板类型的URL在传递的参数没有参数名,大括号所在的位置,在访问时直接替换为参数值
* {}大括号,代表了这是一个参数
*/
@RequestMapping("/testPath/{name}/{age}")
public String testPath(@PathVariable(value="name") String name,@PathVariable(value="age")
Integer age){

System.out.println(name);

System.out.println(age);

return "my";
}
  • 请求转化:请求转换将请求方法进行转换:put,post,get,delete–>表单的必须有一个隐藏域里面有一个name=”_method”,请求的方法必须是POST,因为POST的方法可能是最原生的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
1.在web.xml文件中配置 请求转换过滤器
<!-- 请求转换过滤器 (选配)-->
<filter>
<filter-name>httpMethodFilter</filter-name>
<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>httpMethodFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

2.编写form表单
表单的请求方式必须是post
表单中必须有一个参数,参数名必须为_method 参数值 是想要转换的请求方式
<form action="/SpringMvc_02/testMethod" method="post">

<input type="hidden" name="_method" value="put" />

<input type="submit" value="提交" />
</form>


/**
* 将Post请求转换为请他类型请求
* 作用:
* 1.类型转换
* 2.结合模板类型的URL,实现REST风格
* 用法:
* 1.请求方式必须是POST(GET不能转换)
* 2.需要配置请求转换的过滤器(web.xml)
* 3.表单中要有一个参数,参数名字必须叫 _method
*/
@RequestMapping(value="/testMethod",method=RequestMethod.PUT)
public String testMethod(){
System.out.println("执行了testMethod");
return "my";
}
  • 利用这种方法:我们可以设计其他风格
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/**
* Rest风格
* 1.通过访问路径能够表达出,要做的是什么事
* 2.请求参数放在访问路径中
* 3.每种请求方式,对应了不同的操作
* GET -- 获取资源
* POST -- 新增资源
* PUT -- 更新资源
* DELETE -- 删除资源
* 场景:
* 学生的增删改查
* 编写4个处理器,处理器的访问路径都是一样的,请求方式不一样,每种请求方式对应了一种操作
*/
@RequestMapping(value="/stu",method=RequestMethod.GET)
public String getStu(){
System.out.println("查询学生");
return "";
}


@RequestMapping(value="/stu",method=RequestMethod.POST)
public String addStu(StuModel stuModel){
System.out.println("新增学生");
return "";
}


@RequestMapping(value="/stu",method=RequestMethod.PUT)
public String updateStu(StuModel stuModel){
System.out.println("修改学生");
return "";
}


@RequestMapping(value="/stu/{id}",method=RequestMethod.DELETE)
public String delStu(@PathVariable(value="id") Integer id){
System.out.println("删除学生");
return "";
}


<!-- 新增 -->
<hr/>
<form action="/SpringMvc_02/stu" method="post">
<input type="submit" value="提交" />
</form>

<!-- 修改 -->
<hr/>
<form action="/SpringMvc_02/stu" method="post">
<input type="hidden" name="_method" value="put" />
<input type="submit" value="提交" />
</form>

<!-- 删除 -->
<hr/>
<form action="/SpringMvc_02/stu/3" method="post">
<input type="hidden" name="_method" value="delete" />
<input type="submit" value="提交" />
</form>
  • ModelAndView —>这个对象确实比较牛逼,集合视图有关系和model有关系
  • map集合放入到modelandview调用addobject的结果。。。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
* ModelAndView
* 作用:
* 既能返回页面,又能向页面传递数据
* 用法:
* 将ModelAndView作为方法的返回值
* 1.setViewName 如果想返回jsp,调用ModelAndView对象的setViewName方法,与之前String规则一致
* 2.setView 可以返回一个自定义视图(实现了View接口的类)
* 3.addAllObjects 传递进来一个Map集合,会将map集合中的所有键值对 存入request
* 4.addObject (一个参数)将一个对象存入request,key 是 根据对象类型的 类名,将首字母小写
* 5.addObject (两个参数)跟request.setAttribute一样
*/
@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView(){
ModelAndView modelAndView = new ModelAndView();
// 可以返回一个自定义视图(实现了View接口的类)
// modelAndView.setView(view);
modelAndView.setViewName("my");

//传递进来一个Map集合,会将map集合中的所有键值对 存入request
Map<String,Object> map = new HashMap<String,Object>();
map.put("name", "张三");
map.put("age", 25);
modelAndView.addAllObjects(map);
//将一个对象存入request,key 是 根据对象类型的 类名,将首字母小写
StuModel stuModel = new StuModel();
stuModel.setStuName("李四");
modelAndView.addObject(stuModel);
//跟request.setAttribute一样
modelAndView.addObject("str", "abc");
return modelAndView;
}

<h1>ModelAndView</h1>
<h1>${name}</h1>
<h1>${age}</h1>
<h1>${stuModel.stuName}</h1>
<h1>${str}</h1>
  • ModelMap,Map,Model三大模型(向页面传递数据的数据模型)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
在SpringMvc中 有6种方式可以向request中存放数据
1.原生HttpServletRequest (会出现覆盖情况)
2.ModelAndView
3.ModelAttribute
4.ModelMap
5.Map
6.Model

/**
* Map集合 -- java中的Map集合
* 作用:
* 将数据存入request
* 用法:
* 在处理器的入参处,声明Map集合
*/
@RequestMapping("/testMap")
public String testMap(Map<String,Object> map,StuModel stuModel){
map.put("map", "我是map中的数据");
StuModel model = new StuModel();
model.setAge(99999);
map.put("stuModel", model);
return "my";
}

/**
* Model
*/
@RequestMapping("/testModel1")
public String testModel1(Model model){
model.addAttribute("model", "我是model中的数据");
return "my";
}

<h1>modelMap</h1>
<h1>${modelMap}</h1>
<h1>${stuModel.age}</h1>

<h1>map集合</h1>
<h1>${map}</h1>
<h1>${stuModel.age}</h1>
  • @SessionAttributes注解
  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    在SpringMvc中有2种方式向Session中保存数据
    1.原生HttpSessoin
    2.SessionAttributes注解

    @SessionAttributes(value={"name"},types={Integer.class})
    @Controller
    public class MyController {
    }

    /**
    * SessionAttributes注解
    * 作用:
    * 1.向sessoin中保存数据
    * 将ModelMap中的数据 复制到session一份
    * ModelAndView,ModelAttribute,Map集合,ModelMap,Model 这五种东西里数据,都是在ModelMap中
    * 2.每次请求,会将SessionAttributes中的数据,复制到处理器的ModelMap中
    * 用法:
    * 该注解要写在类定义处
    * 过程:
    * @SessionAttributes(value={"name"},types={Integer.class})
    * 作用于整个类
    * 当访问这个类的任意一个处理器的时候,该注解都会开始工作
    * 1.用value属性中的值,去根该处理器的ModelMap中的key进行匹配,如果匹配到了
    * 那么将这个键值对,复制到session中
    * 2.用types属性中的值,去跟该处理器的ModelMap中的value进行匹配,如果发现类型一致,
    * 那么将这个键值对,复制到session中
    */
    @RequestMapping("/testSession")
    public String testSession(ModelMap modelMap){
    modelMap.addAttribute("name", "张三");
    modelMap.addAttribute("age", 99);
    return "my";
    }
  • 自定义视图

主要通过 接口实现视图的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
1.编写自定义视图类
/**
* 自定义视图
* 用法:
* 1.需要实现View接口
* 2.实现两个方法
*
* @author muty
*
*/
public class MyView implements View{

/**
* 设置视图类型
*/
@Override
public String getContentType() {
return "text/html";
}

/**
* 视图内容
*/
@Override
public void render(Map<String, ?> arg0, HttpServletRequest request,
HttpServletResponse response) throws Exception {

//设置编码方式
response.setHeader("Content-type", "text/html;charset=UTF-8");
response.setCharacterEncoding("UTF-8");

response.getWriter().print("<h1>这是一个自定义视图</h1>");

}

}
2.在springmvc配置文件中配置自定义视图类

<!-- 配置自定义视图 class属性为 自定义视图的完全限定名 -->
<bean id="myView" class="com.view.MyView" />
3.配置自定义视图解析器
<!-- 配置自定义视图解析器 -->
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver">
<!--
视图解析器的顺序,order的值越小越优先被使用
那么如果没有手动配置该属性的话,那么默认是Integer的最大值,Integer.MAX_VALUE
-->
<property name="order" value="1"></property>
</bean>


/**
* 使用字符串返回自定义视图
* 用法:
* 返回值写的是,配置文件中自定义视图类对应的bean标签的id值
* 需要将自定义视图类
* 和自定义视图解析器配置在SpringMvc配置文件中
* @return
*/
@RequestMapping("/myView")
public String myView(){
return "myView";
}

/**
* 使用ModelAndView返回自定义视图
* 用法:
* 调用setView方法,将自定义视图类进行实例化
* 如果说使用ModelAndView,那么无需做任何配置,因为直接传递给了它一个View对象,
* 在底层,SpringMvc就不需要解析,直接拿来使用
*/
@RequestMapping("/myView1")
public ModelAndView myView1(){
ModelAndView modelAndView = new ModelAndView();
modelAndView.setView(new MyView());
return modelAndView;
}

如果使用ModelAndView的setView方法,那么不需要进行任何配置
  • 国际化配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
20.国际化资源配置(了解)
方式1.通过浏览器的语言实现国际化的切换

1.在src下新建两个资源文件,一个中文,一个英文
i18n_zh_CN.properties i18n_en_US.properties
两个资源中,key要保持一致,value了 为对应语言的内容

2.在springMvc配置文件中 配置国际化资源管理器
<!-- 配置国际化资源管理器 -->
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basename" value="i18n"></property>
</bean>

3.编写一个处理器,跳转到一个jsp页面
/**
* 通过处理器跳转到页面,实现国际化
* @return
*/
@RequestMapping("/login")
public String login(){
return "login";
}


4.在jsp页面中,首先导入标签库
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

<body>

<fmt:message key="username"></fmt:message>
<fmt:message key="password"></fmt:message>

</body>

方式2,通过在页面上点击链接,传递相关的语言参数,实现国际化
1.创建资源文件,跟方式1一致
2.在springmvc配置文件中 配置4个东西

国际化资源管理器
<!-- 配置国际化资源管理器 -->
<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basename" value="i18n"></property>
</bean>
国际化资源解析器
<!-- 国际化资源解析器 id不能变-->
<bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver"></bean>
国际化拦截器
<!-- 配置国际化拦截器 -->
<bean id="localeChangeInterceptor"
class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor"></bean>

拦截器的拦截路径
<!-- 配置拦截器的拦截路径,拦截哪些请求 -->
<mvc:interceptors>
<mvc:interceptor>
<!-- 拦截所有请求 -->
<mvc:mapping path="/**"/>
<ref bean="localeChangeInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>

3.在jsp中通过传递参数的方式实现国际化
<a href="/SpringMvc_03/login?locale=zh_CN">中文</a>
<a href="/SpringMvc_03/login?locale=en_US">英文</a>
  • 文件上传
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/**
* 文件上传
* 步骤:
* 1.导入两个jar包,commons-fileupload.jar commons-io.jar
* 2.在springmvc配置文件中,配置文件上传解析器
* 3.form表单请求方式要为post,enctype="multipart/form-data"
* 4.要为表单中的file控件 指定name属性,就把它当成一个普通参数即可,获取时也是根据name来获取
* 5.使用@RequestParma来获取参数,value的值,与file控件的name值一致,使用MultipartFile来接收
* 6.获取文件名
* 7.获取上传文件的绝对路径
* 8.实例化File对象
* 9.调用transferTo方法,写入文件
* 10.如果需要显示,那么拼接显示的路径
* 注意:
* 1.multipartFile对象永远都不为null
* 如果要判断是否选择了文件,那么要根据文件名来判断,如果获取到的文件名是空字符串,那么证明没有选择文件
* 2.如何接收多个文件
* 2.1表单中的多个file控件name都是一样的
* 获取方式是 @RequestParam(value="file") List<MultipartFile> multipartFiles
* 2.2表单中有多个file控件,但是name都不一样
* 获取方式是 分开获取 @RequestParam(value="file") @RequestParam(value="file1")
* 3.如何使用实体类来接收文件参数
* 实体类中使用 private MultipartFile file;
* 属性的类型为MultipartFile 属性名字和file控件的name属性对应 即可
* @throws IOException
* @throws IllegalStateException
*/
@RequestMapping("/uploadFile")
public String uploadFile(@RequestParam(value="file") MultipartFile multipartFile,
HttpServletRequest request) throws IllegalStateException, IOException{
//1.获取文件名字
String fileName = multipartFile.getOriginalFilename();
//2.获取upload文件夹的绝对路径(获取到的,是该项目在tomcat下的路径,而不是工作空间中的路径)
String realPath = request.getServletContext().getRealPath("/upload");
System.out.println(realPath);
//3.创建File对象
File file = new File(realPath+File.separator+fileName);
//4.写入文件
multipartFile.transferTo(file);


//5.拿到用于显示图片的路径
String showPath = request.getContextPath() + "/upload/" + fileName;

request.setAttribute("showPath", showPath);

return "my";
}
  • @ResponseBody注解
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
	/**
* @ResponseBody注解
* 场景:
* 1.为手机端提供json数据(前后端代码分离)
* 2.为PC前端页面 提供json数据(前后端代码分离)
* 3.配合JQ中的ajax来使用(所有代码都自己写)
* 用法:
* 1.如果导入3个jar包(jackson)
* 2.注解要写在方法定义处
* 作用:
* 1.将处理器方法的返回值 格式化为json返回(需要将哪个类型格式化为json,就将哪个类型作为方法返回值)
* 注意:
* 1.如果处理器被注解了@ResponseBody,那么将不在能返回视图,任何方式都不能返回视图
* 2.如果处理器被注解了@ResponseBody,那么使用request.setAttribute是无用的
* 3.如果使用ajax向处理器发送了请求,那么处理器一定要注解@ResponseBody,不然ajax拿不到返回值
*/
将一个字符串输出到浏览器
@RequestMapping(value="/jsonStr",produces="application/json;charset=utf8")
@ResponseBody
public String jsonStr(){
return "我是一个字符串";
}

将一个实体类格式化为json返回
/**
* 将一个实体类格式化为json
* @return
*/
@ResponseBody
@RequestMapping("/jsonModel")
public StuModel jsonModel(){
StuModel stuModel = new StuModel();
stuModel.setAddress("北京");
stuModel.setAge(88);
stuModel.setStuName("张三");
return stuModel;
}

将一个集合格式化为json返回
@ResponseBody
@RequestMapping("/jsonList")
public List<StuModel> jsonList(@RequestParam(value="id") Integer id,
StuModel model){
List<StuModel> list = new ArrayList<StuModel>();
StuModel stuModel = new StuModel();
stuModel.setAddress("北京");
stuModel.setAge(88);
stuModel.setStuName("张三");
list.add(stuModel);

StuModel stuModel1 = new StuModel();
stuModel1.setAddress("上海");
stuModel1.setAge(99);
stuModel1.setStuName("李四");
list.add(stuModel1);
return list;
}


使用ajax向处理器发起请求
<button type="button" onclick="ajaxModel()">ajax操作json实体类</button>

function ajaxModel(){
//使用ajax 向处理器发起请求
$.ajax({
url:"/SpringMvc_04/jsonModel",//请求路径
data:"",//请求参数,没有参数,不需要传递参数时,该属性可以省略
//返回值类型 text,json,如果处理器返回值为String,那么使用text,处理器返回值为实体类,或者集合,那么使用json
//该属性可以省略
dataType:"json",
type:"post",//请求方式 get post
async:true,//同步和异步,true 异步 false 同步, 默认true
success:function(data){
//执行成功时的回调函数,200
//回调函数中的变量,可以接收到处理器所返回的json数据
//操作json的方式 与实体类基本一致 (与el表达式取值基本一致,只不过没有了)
alert(data.stuName);
// alert(data.address);
},error:function(){
//执行时发生错误,500
}
})

}


操作json数组
function ajaxList(){
$.ajax({
url:"/SpringMvc_04/jsonList?id=1",
data:"",
success:function(data){
//1.for循环
for(var i=0;i<data.length;i++){
alert(data[i].stuName);
alert(data[i].age);
}
//2.each循环
//第一个参数,用来计数使用,当前循环时第几次
//第二个参数,是每次循环时数组中的真正元素
$.each(data,function(key,i){
alert(i.stuName);
alert(i.age);
})
}
})
}

使用ajax实现新增学生的流程
1.新建form表单
<!-- 虽然有一个form表单,但是不使用表单进行提交,
使用form表单,是为了获取表单中的所有参数
使用ajax进行提交,然后将表单中的所有参数,传递到处理器,
在处理器中使用实体类接收请求参数
-->
<form id="editForm">
<input type="text" name="stuName" />
<input type="text" name="age" />
<button type="button" onclick="addStu()">新增学生</button>
</form>

2.编写js方法
function addStu(){
$.ajax({
url:"/SpringMvc_04/addStu",
//格式化表单中的所有参数
//将表单中所有带有name属性的元素当做参数,传递
data:$("#editForm").serialize(),
success:function(data){
if(data == 'success'){
alert("新增成功");
//跳转
window.location = "/SpringMvc_04/xxxx";
}else{
alert("新增失败");
}
}
})
}

3.编写Handler进行对应的处理
/**
* 接收ajax传递过来的表单中请求参数
* 1.form表单指定id属性,不需要action 和 method
* 2.要传递的元素,还是要写name属性
* 3.在ajax的data属性 根据id获取表单,调用serialize();
* $("#editForm").serialize()
* 4.在处理器中,可以使用@RequestParam注解分别接收,也可以使用实体类接收
*/
@ResponseBody
@RequestMapping("/addStu")
public String addStu(StuModel stuModel){
System.out.println(stuModel);
//1.插入
//2.如果插入方法返回true,那么我向ajax返回一个成功的 字符串 success
//如果插入方法返回false,那么我向ajax返回一个失败的字符串 failed
return "success";
}
  • 拦截器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/**
* 如何实现一个自定义的拦截器
* 需要实现HandlerInterceptor接口
* 过程:
* 1.preHandele,会在处理器之前执行
* 1.1 如果preHandel返回true那么将会执行处理器
* 1.2 如果放回false,不会执行处理器,本次请求结束
* 2.postHandle,会在处理器执行完毕之后 执行
* 3.afterCompletion,会在渲染视图之后,返回页面之前,执行,在这个方法中可以做一些释放资源的操作
* @author muty
*
*/


一个拦截器的执行顺序
1.在处理器执行之前,会执行拦截器的preHandle方法
2.如果preHandle方法返回true,那么会执行处理器,然后执行postHandle和afterCompletion方法
3.如果preHandle方法返回false,请求结束,不会执拦截器的后续两个方法

多个拦截器的执行顺序
1.执行处理器之前,会按照配置文件的顺序,执行每个拦截器的preHandle方法,如果所有preHandle方法返回都是true,那么将执行处理器,然后倒序执行所有拦截器的postHandle,倒序执行所有拦截器的afterCompletion

2.按照顺序执行所有拦截器的preHandle,如果其中一个拦截器的preHandle方法返回了false,那么将倒序执行除了自己以外的其他拦截器的afterCompletion


使用拦截器实现简单的登录过滤
场景:
有些功能需要登录后使用,那么如果直接访问该功能,需要让用户跳转到登录页面,先进行登录

1.编写拦截器,实现preHandle方法
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object arg2) throws Exception {

String abc = (String) request.getSession().getAttribute("user");
if(abc == null){
//跳转到登录页面
response.sendRedirect("login.jsp");
return false;
}
return true;
}

<!-- 所有拦截器 都要配置在这个标签中 -->
<mvc:interceptors>
<!-- 登录拦截器配置 -->
<mvc:interceptor>
<!-- 配置需要让拦截器,拦截哪些请求 /** 代表拦截所有请求 -->
<mvc:mapping path="/**"/>
<!--
不拦截哪些请求 优先级会高于拦截的请求
注意:一定要让所使用的静态资源不被拦截
-->
<mvc:exclude-mapping path="/js/**"/>
<mvc:exclude-mapping path="/dologin"/>
<!-- 指定拦截器是哪一个类,类的完全限定名字,包名+类名 -->
<bean class="com.interceptor.LoginInterceptor" />
</mvc:interceptor>
</mvc:interceptors>
  • 参数类型转换器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
	1.创建参数类型转换器
/**
* 自定义的参数类型转换器
* 场景:
* 在页面的一个文本框中 输入 张三-99-北京
* 在处理器中直接使用实体类进行接收,将相关的值 绑定到实体类对应的属性上
* 用法:
* 需要实现Converter接口
* S source 源目标的类型(原参数的类型)
* T target 目标类型(目标参数类型)
* @author muty
*
*/
public class StuConvert implements Converter<String, StuModel>{

/**
* 转换的方法
* 返回值,就是转换后的类型
* 方法的参数,是源参数的值
* str的值 就是 张三-99-北京
*/
@Override
public StuModel convert(String str) {
StuModel stuModel = new StuModel();
String infos[] = str.split("-");
stuModel.setStuName(infos[0]);
stuModel.setAge(Integer.parseInt(infos[1]));
stuModel.setAddress(infos[2]);
return stuModel;
}

}

2.在springMvc配置文件中进行配置
<!-- 需要配置转换器工厂 -->
<bean id="convertService"
class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<list>
<!-- 配置自定义参数转换器 写的是转换器的完全限定名,包名+类型 -->
<bean class="com.convert.StuConvert" />
</list>
</property>
</bean>

<mvc:annotation-driven conversion-service="convertService"/>


3.编写处理器
/**
* 将字符串转换为实体类
* 在处理器中,直接使用转换后的类型,来接收参数
* 使用@RequestParam注解,将传递过来的字符串参数接收到,因为使用了转换器,所以直接使用实体类来接收参数值
* @return
*/
@RequestMapping("/strToModel")
public String strToModel(@RequestParam(value="info") StuModel stuModel){
System.out.println(stuModel);
return "";
}

http://localhost:8080/SpringMvc_04/strToModel?info=张三-88-北京
  • RequestBody()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/**
* @RequestBody注解(接收请求参数)
* 作用:
* 将请求的时的json类型参数,转换为java对象
* 用法:
* 1.请求时要使用ajax(只要能发送json类型的参数即可)
* 2.请求方式要为post
* 3.请求参数必须是一个json格式的字符串
* 3.1 必须使用到引号将json数据引用起来,将它变为一个json格式的字符串
* 3.2 调用js中的方法,将json数据格式化为json字符串 JSON.stringify
* 4.请求时要设置contentType属性为application/json
* 5.会将json参数 格式化为java对象(实体类),所以在处理器中使用实体类 来接收传递过来的参数,
* 将@RequestBody注解 写在实体类前面
* 6.要导入3个jackson的jar包
*/
@RequestMapping("/requestBody")
public String requestBody(@RequestBody StuModel stuModel){
System.out.println(stuModel);
return "";
}

@RequestMapping("/requestBodyList")
public String requestBodyList(@RequestBody List<StuModel> stuModels){
System.out.println(stuModels);
return "";
}

JSP页面测试
<button type="button" onclick="requestBody()">传递json参数</button>
<button type="button" onclick="requestBodyList()">传递json数组</button>


function requestBody(){
$.ajax({
url:"/SpringMvc_05/requestBody",
type:"post",
data:'{"stuName":"张三","age":25,"address":"北京"}',
// data:JSON.stringify({"stuName":"张三","age":25,"address":"北京"}),
contentType:"application/json",
success:function(data){

}
})
}


function requestBodyList(){

//创建一个数组
var arr = new Array();
//创建一个json对象
var stu1 = {"stuName":"张三","age":25,"address":"北京"};
var stu2 = {"stuName":"李四","age":88,"address":"上海"};
//将对象存入数组
arr.push(stu1);
arr.push(stu2);

$.ajax({
url:"/SpringMvc_05/requestBodyList",
type:"post",
data:JSON.stringify(arr),
contentType:"application/json",
success:function(data){

}
})
}
  • springMVC 运行原理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
request 请求 我要做的一件事
Handler 处理器(方法) 工具,要做这件事的工具
HandlerAdapter 干活的人

九大组件
1.HandlerMapping 根据request找到相应的处理器和拦截器
2.HandlerAdapter 调用处理器方法(执行处理器方法)
3.HandlerExceptionResolver 异常解析器
4.ViewResolver 视图解析器
5.LocaleResolver 国际化资源解析器
6.ThemeResolver 主题解析器(切换css,图片)
7.MultipartResolver 文件上传解析器
8.FlashMapManager 用于redirect传递参数
9.ViewNameTranslator 用于设置默认视图名字(没有视图的时候启用)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值