`中增加了属性`xmlns:context`、`xmlns:mvc`，对应的在`xsi:schemaLocation`增加了:
74 | ```plain
75 | http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
76 | http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
77 | ```
78 |
79 | 关于`
85 |
86 | contextConfigLocation
87 | /WEB-INF/applicationContext.xml
88 |
89 |
90 | org.springframework.web.context.ContextLoaderListener
91 |
92 |
93 | dispatcher
94 | org.springframework.web.servlet.DispatcherServlet
95 | 2
96 |
97 |
98 | dispatcher
99 | /
100 |
101 |
102 |
103 | 30
104 |
105 |
106 |
107 | redirect.jsp
108 |
109 |
110 | ```
111 |
112 | ### 模板文件
113 |
114 | **index.jsp：**
115 | ```html
116 | <%@page contentType="text/html" pageEncoding="UTF-8"%>
117 |
119 |
120 |
121 |
122 | Welcome to Spring Web MVC project
124 |
125 |
126 |
127 | Hello! This is the default welcome page for a Spring Web MVC project.
128 | To display a different welcome page for this project, modify
129 | index.jsp , or create your own welcome page then change
130 | the redirection in redirect.jsp to point to the new
131 | welcome page and also update the welcome-file setting in
132 | web.xml .
133 |
134 |
135 | ```
136 |
137 | **hello/method01.jsp：**
138 | ```html
139 | <%@page contentType="text/html" pageEncoding="UTF-8"%>
140 |
141 |
142 |
143 | JSP Page
145 |
146 |
147 | Hello Method01
148 |
149 |
150 | ```
151 |
152 | **hello/method04.jsp：**
153 | ```plain
154 | <%@page contentType="text/plain" pageEncoding="UTF-8"%>
155 |
156 | name: ${name}
157 | ```
158 |
159 | ### HelloController.java
160 | ```java
161 | package me.letiantian.controller;
162 |
163 | import java.io.PrintWriter;
164 | import javax.servlet.http.HttpServletRequest;
165 | import javax.servlet.http.HttpServletResponse;
166 | import org.springframework.stereotype.Controller;
167 | import org.springframework.ui.Model;
168 | import org.springframework.web.bind.annotation.PathVariable;
169 | import org.springframework.web.bind.annotation.RequestMapping;
170 | import org.springframework.web.bind.annotation.RequestMethod;
171 |
172 | @Controller
173 | @RequestMapping("/hello")
174 | public class HelloController{
175 |
176 | @RequestMapping(value = "")
177 | public String index() {
178 | return "index";
179 | }
180 |
181 | @RequestMapping(value = "/method01")
182 | public String method01() {
183 | return "hello/method01";
184 | }
185 |
186 | // 仅支持HTTP POST方法
187 | @RequestMapping(value = "/method02", method = {RequestMethod.POST})
188 | public String method02() {
189 | return "hello/method01";
190 | }
191 |
192 | @RequestMapping(value = "/method03")
193 | public void method03(HttpServletRequest request, HttpServletResponse response) {
194 | response.setContentType("text/plain;charset=UTF-8");
195 | try (PrintWriter out = response.getWriter()) {
196 | out.println("contextPath: " + request.getContextPath());
197 | out.println("name: " + request.getParameter("name"));
198 | } catch (Exception ex) {
199 | System.out.println(""+ex.getMessage());
200 | }
201 | }
202 |
203 | @RequestMapping(value = "/method04/{name}")
204 | public String method04(@PathVariable String name, Model model) {
205 | model.addAttribute("name", name);
206 | return "hello/method04";
207 | }
208 |
209 | @RequestMapping(value = "/method05/{id}")
210 | public String method05(@PathVariable int id, Model model) {
211 | model.addAttribute("name", id);
212 | return "hello/method04";
213 | }
214 | }
215 | ```
216 |
217 | ## 测试
218 |
219 | 
220 | 
221 | 
222 | 
223 | 
224 | 
225 | 
226 | 
227 |
228 | ## 其他
229 |
230 | **如何让一个方法映射多个URL？**
231 | 很简单，例如`@RequestMapping(value = {"/hello", "/hi"})`。可参考[Spring MVC: Mapping Multiple URLs to Same Controller](http://stackoverflow.com/questions/3898442/spring-mvc-mapping-multiple-urls-to-same-controller)。
232 |
233 | **如何自定义错误页面？**
234 | [Spring MVC : How To Return Custom 404 Error Pages](http://www.javabeat.net/spring-mvc-404-error-page/)
235 | [Spring MVC Exception Handling Example](http://www.mkyong.com/spring-mvc/spring-mvc-exception-handling-example/)
236 | [Exception Handling in Spring MVC](https://spring.io/blog/2013/11/01/exception-handling-in-spring-mvc)
237 |
238 | **@PathVariable是绑定数据的其中一种方法，还有绑定Cookie中数据，将表单数据绑定到对象中等方法：**
239 | [Spring MVC Cookie example](http://viralpatel.net/blogs/spring-mvc-cookie-example/)
240 | [Injecting and Binding Objects to Spring MVC Controllers](http://www.cnblogs.com/davidwang456/p/4019595.html)
241 |
--------------------------------------------------------------------------------
/00-07.md:
--------------------------------------------------------------------------------
1 | 00-07、使用数据库连接池
2 | ---
3 |
4 | 目前比较常见的连接池实现有DBCP、C3P0,Tomcat_JDBC等。
5 |
6 | 本文使用的连接池是DBCP。
7 |
8 | 进入[http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi](http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi)下载`Apache Commons DBCP for JDBC `，[http://commons.apache.org/proper/commons-pool/download_pool.cgi](http://commons.apache.org/proper/commons-pool/download_pool.cgi)中下载`Apache Commons Pool`，[http://dev.mysql.com/downloads/connector/j/](http://dev.mysql.com/downloads/connector/j/)下载MySQL的JDBC驱动。
9 |
10 | 若下载出现问题，可以到一些Maven仓库中下载。例如[http://mvnrepository.com/](http://mvnrepository.com/)、[http://maven.oschina.net](http://maven.oschina.net)。
11 |
12 |
13 | ## 数据库准备
14 | MySQL 5.6。
15 |
16 | ```sql
17 | --创建数据库
18 | CREATE DATABASE IF NOT EXISTS `test` DEFAULT CHARSET utf8 COLLATE utf8_general_ci;
19 | USE `test`;
20 | --创建table
21 | CREATE TABLE IF NOT EXISTS user
22 | (
23 | `id` int AUTO_INCREMENT,
24 | `name` varchar(255),
25 | `email` varchar(255),
26 | `age` varchar(255),
27 | `passwd` varchar(255),
28 | PRIMARY KEY (`id`),
29 | UNIQUE KEY (`name`),
30 | UNIQUE KEY (`email`)
31 | ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
32 | ---插入若干数据
33 | INSERT INTO user (`name`, `email`, `age`, `passwd`)
34 | VALUES ('user01', 'user01@163.com', 20, password('123'));
35 |
36 | INSERT INTO user (`name`, `email`, `age`, `passwd`)
37 | VALUES ('user02', 'user02@163.com', 20, password('456'));
38 | ```
39 |
40 | ## 示例1
41 |
42 | 目录结构如下：
43 | 
44 |
45 | **web.xml源码：**
46 | ```xml
47 |
48 |
49 |
50 |
51 | default
52 | *.jpg
53 |
54 |
55 |
56 | default
57 | *.png
58 |
59 |
60 |
61 | default
62 | *.js
63 |
64 |
65 |
66 | default
67 | *.css
68 |
69 |
70 |
71 |
72 | 30
73 |
74 |
75 |
76 |
77 | ```
78 |
79 | **dbcp.properties源码：**
80 | ```plain
81 | driverClassName=com.mysql.jdbc.Driver
82 | url=jdbc:mysql://localhost:3306/test
83 | username=root
84 | password=123456
85 | initialSize=2
86 | maxActive=15
87 | maxIdle=2
88 | minIdle=1
89 | maxWait=30000
90 | ```
91 | 这些配置的解释请见[BasicDataSource Configuration Parameters](http://commons.apache.org/proper/commons-dbcp/configuration.html)。
92 |
93 | **HelloServlet.java源码：**
94 | ```java
95 | package me.letiantian.servlet;
96 |
97 | import java.io.IOException;
98 | import java.io.PrintWriter;
99 | import java.sql.Connection;
100 | import java.sql.PreparedStatement;
101 | import java.sql.ResultSet;
102 | import java.util.Properties;
103 | import javax.servlet.annotation.WebServlet;
104 | import javax.servlet.http.HttpServlet;
105 | import javax.servlet.http.HttpServletRequest;
106 | import javax.servlet.http.HttpServletResponse;
107 | import javax.sql.DataSource;
108 |
109 | import org.apache.commons.dbcp.BasicDataSourceFactory;
110 |
111 |
112 | @WebServlet(name = "HelloServlet", urlPatterns = {"/hello"})
113 | public class HelloServlet extends HttpServlet {
114 |
115 | protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws IOException {
116 | response.setContentType("text/html;charset=UTF-8");
117 | PrintWriter out = response.getWriter();
118 | try{
119 | Properties properties=new Properties();
120 | properties.load(getServletContext().getResourceAsStream("/WEB-INF/dbcp.properties"));
121 | DataSource dataSource = BasicDataSourceFactory.createDataSource(properties);
122 | Connection conn = dataSource.getConnection();
123 | String sql = "select 1+1 as result;";
124 | PreparedStatement pstmt = conn.prepareStatement(sql);
125 | ResultSet rs = pstmt.executeQuery();
126 |
127 | if (rs.next()) {
128 | int result = rs.getInt("result");
129 | out.println("result: " + result);
130 | }
131 |
132 | rs.close();
133 | pstmt.close();
134 | conn.close();
135 |
136 | } catch (Exception ex) {
137 | out.println(ex.getMessage());
138 | }
139 | }
140 |
141 | @Override
142 | protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
143 | processRequest(request, response);
144 | }
145 |
146 |
147 | @Override
148 | protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
149 | processRequest(request, response);
150 | }
151 |
152 | }
153 | ```
154 |
155 | 运行项目，浏览器访问`http://localhost:8084/Project_0007_DBCP/hello`：
156 | 
157 |
158 |
159 | ## 改进：将初始化的连接池放到Servlet上下文中
160 | 上面代码中是再servlet中初始化连接池，更好的方法是再Listener中初始化，并将连接池作为属性放入servlet上下文中。
161 |
162 | 源文件以及代码有所变化，项目结构如下：
163 | 
164 |
165 | DBCPListener.java内容如下：
166 | ```java
167 | package me.letiantian.listener;
168 |
169 | import java.util.Properties;
170 | import javax.servlet.ServletContext;
171 | import javax.servlet.ServletContextEvent;
172 | import javax.servlet.ServletContextListener;
173 | import javax.servlet.annotation.WebListener;
174 | import javax.sql.DataSource;
175 | import org.apache.commons.dbcp.BasicDataSourceFactory;
176 |
177 | @WebListener
178 | public class DBCPListener implements ServletContextListener{
179 |
180 | // 应用启动时，该方法被调用
181 | @Override
182 | public void contextInitialized(ServletContextEvent sce) {
183 | try {
184 | System.out.println("设置数据库连接池");
185 | ServletContext application = sce.getServletContext();
186 | Properties properties=new Properties();
187 | properties.load(application.getResourceAsStream("/WEB-INF/dbcp.properties"));
188 | DataSource dataSource = BasicDataSourceFactory.createDataSource(properties);
189 | application.setAttribute("dataSource", dataSource);
190 | }
191 | catch(Exception ex) {
192 | System.err.println("数据库连接池设置出现异常：" + ex.getMessage());
193 | }
194 | }
195 |
196 | // 应用关闭时，该方法被调用
197 | @Override
198 | public void contextDestroyed(ServletContextEvent sce) {
199 |
200 | }
201 |
202 | }
203 | ```
204 |
205 | HelloServlet.java内容如下：
206 | ```java
207 | package me.letiantian.servlet;
208 |
209 | import java.io.IOException;
210 | import java.io.PrintWriter;
211 | import java.sql.Connection;
212 | import java.sql.PreparedStatement;
213 | import java.sql.ResultSet;
214 | import javax.servlet.annotation.WebServlet;
215 | import javax.servlet.http.HttpServlet;
216 | import javax.servlet.http.HttpServletRequest;
217 | import javax.servlet.http.HttpServletResponse;
218 | import javax.sql.DataSource;
219 |
220 | @WebServlet(name = "HelloServlet", urlPatterns = {"/hello"})
221 | public class HelloServlet extends HttpServlet {
222 |
223 | protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws IOException {
224 | response.setContentType("text/html;charset=UTF-8");
225 | PrintWriter out = response.getWriter();
226 | try {
227 | DataSource dataSource = (DataSource) getServletContext().getAttribute("dataSource");
228 | Connection conn = dataSource.getConnection();
229 | String sql = "select name from user;";
230 | PreparedStatement pstmt = conn.prepareStatement(sql);
231 | ResultSet rs = pstmt.executeQuery();
232 |
233 | while (rs.next()) {
234 | String name = rs.getString("name");
235 | out.println("result: " + name + "");
236 | }
237 |
238 | rs.close();
239 | pstmt.close();
240 | conn.close();
241 |
242 | } catch (Exception ex) {
243 | out.println(ex.getMessage());
244 | }
245 | }
246 |
247 | @Override
248 | protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
249 | processRequest(request, response);
250 | }
251 |
252 |
253 | @Override
254 | protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
255 | processRequest(request, response);
256 | }
257 |
258 | }
259 | ```
260 |
261 | 启动项目，可以看到Tomcat输出：
262 | ```plain
263 | 设置数据库连接池
264 | ```
265 |
266 | 浏览器输出：
267 | 
268 |
269 | 查看一下mysql的连接：
270 | ```plain
271 | mysql> show processlist;
272 | +----+------+-----------------+------+---------+------+-------+------------------+
273 | | Id | User | Host | db | Command | Time | State | Info |
274 | +----+------+-----------------+------+---------+------+-------+------------------+
275 | | 45 | root | localhost | test | Query | 0 | init | show processlist |
276 | | 77 | root | localhost:41770 | test | Sleep | 300 | | NULL |
277 | | 78 | root | localhost:41771 | test | Sleep | 300 | | NULL |
278 | | 83 | root | localhost:41790 | test | Sleep | 274 | | NULL |
279 | | 84 | root | localhost:41791 | test | Sleep | 69 | | NULL |
280 | +----+------+-----------------+------+---------+------+-------+------------------+
281 | 5 rows in set (0.00 sec)
282 | ```
283 |
284 | 关闭Tomcat，查看数据库连接：
285 | ```plain
286 | mysql> show processlist;
287 | +----+------+-----------+------+---------+------+-------+------------------+
288 | | Id | User | Host | db | Command | Time | State | Info |
289 | +----+------+-----------+------+---------+------+-------+------------------+
290 | | 45 | root | localhost | test | Query | 0 | init | show processlist |
291 | +----+------+-----------+------+---------+------+-------+------------------+
292 | 1 row in set (0.00 sec)
293 | ```
294 |
295 | ## DBUtils
296 | 使用DBUtils可以更加方便的操作数据库，可以参考[DBUtils简明教程](http://www.letiantian.me/2015-03-09-apache-dbutils/)。
297 |
298 |
299 | ## 资料
300 | 官网
301 | [DBCP,C3P0,Tomcat_JDBC 性能及稳定性测试](http://www.open-open.com/lib/view/open1329182303124.html)
302 | [数据连接池DBCP参数介绍](http://my.oschina.net/robinsonlu/blog/77759)
303 | [DBCP数据库连接池的使用](http://my.oschina.net/donghongyu/blog/190494)
304 |
--------------------------------------------------------------------------------
/01-03.md:
--------------------------------------------------------------------------------
1 | 01-03、JdbcTemplate
2 | ---
3 |
4 | JdbcTemplate是Spring MVC内置的对JDBC的一个封装。
5 |
6 | ## 数据库准备
7 | MySQL 5.6。
8 |
9 | ```sql
10 | --创建数据库
11 | CREATE DATABASE IF NOT EXISTS `test` DEFAULT CHARSET utf8 COLLATE utf8_general_ci;
12 | USE `test`;
13 | --创建table
14 | CREATE TABLE IF NOT EXISTS user
15 | (
16 | `id` int AUTO_INCREMENT,
17 | `name` varchar(255),
18 | `email` varchar(255),
19 | `age` varchar(255),
20 | `passwd` varchar(255),
21 | PRIMARY KEY (`id`),
22 | UNIQUE KEY (`name`),
23 | UNIQUE KEY (`email`)
24 | ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
25 | ---插入若干数据
26 | INSERT INTO user (`name`, `email`, `age`, `passwd`)
27 | VALUES ('user01', 'user01@163.com', 20, password('123'));
28 |
29 | INSERT INTO user (`name`, `email`, `age`, `passwd`)
30 | VALUES ('user02', 'user02@163.com', 20, password('456'));
31 |
32 | INSERT INTO user (`name`, `email`, `age`, `passwd`)
33 | VALUES ('用户03', 'user03@163.com', 20, password('456'));
34 | ```
35 |
36 | ## 示例1
37 | 继续使用的上一节[01-02、使用Spring MVC构建Hello World](./01-02.md)中创建的项目。
38 |
39 | 项目结构如下：
40 | 
41 |
42 | 图中红线下的文件是新增或者修改的文件。
43 |
44 | MySQL的JDBC封装`mysql-connector-java-**.jar`别忘了放到Libraries里。
45 |
46 | ### 源码
47 |
48 | **SelectController.java源码：**
49 | ```java
50 | package me.letiantian.controller;
51 |
52 | import java.util.List;
53 | import java.util.Map;
54 | import javax.servlet.http.HttpServletRequest;
55 | import javax.servlet.http.HttpServletResponse;
56 | import org.springframework.beans.factory.annotation.Autowired;
57 | import org.springframework.web.servlet.ModelAndView;
58 | import org.springframework.web.servlet.mvc.Controller;
59 | import org.springframework.jdbc.core.JdbcTemplate;
60 |
61 | import me.letiantian.service.UserService;
62 |
63 | public class SelectController implements Controller{
64 |
65 | @Autowired
66 | private UserService userDao;
67 |
68 | @Autowired
69 | private JdbcTemplate jdbcTemplate;
70 |
71 | @Override
72 | public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
73 | response.setContentType("text/html;charset=UTF-8");
74 | ModelAndView mv = new ModelAndView();
75 |
76 | List users = jdbcTemplate.queryForList("SELECT * FROM user");
77 | mv.addObject("users", users);
78 |
79 | Map user1 = userDao.getUserById(1);
80 | mv.addObject("user1", user1);
81 |
82 | Map user2 = jdbcTemplate.queryForMap("SELECT * FROM user WHERE id=2");
83 | mv.addObject("user2", user2);
84 |
85 | mv.addObject("message", "无错误信息");
86 | mv.setViewName("select");
87 | return mv;
88 | }
89 |
90 | }
91 | ```
92 |
93 | **UserService.java源码： **
94 | ```java
95 | package me.letiantian.service;
96 |
97 | import java.util.Map;
98 | import org.springframework.beans.factory.annotation.Autowired;
99 | import org.springframework.jdbc.core.JdbcTemplate;
100 | import org.springframework.stereotype.Service;
101 |
102 | @Service
103 | public class UserService {
104 |
105 | @Autowired
106 | private JdbcTemplate jdbcTemplate;
107 |
108 | public Map getUserById(int id) {
109 |
110 | Map user = jdbcTemplate.queryForMap("SELECT * FROM user WHERE id=?", new Object[] {id});
111 | return user;
112 |
113 | }
114 |
115 | }
116 | ```
117 |
118 | **select.jsp源码： **
119 | ```html
120 | <%@page contentType="text/html" pageEncoding="UTF-8"%>
121 | <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
122 |
123 |
124 |
125 | JSP Page
127 |
128 |
129 | Hello World!
130 |
131 |
132 |
133 |
134 |
135 |
138 |
139 |
140 |
141 |
142 |
143 |
146 |
147 |
148 |
149 |
152 |
153 |
154 |
155 |
156 |
159 |
160 |
161 |
162 |
165 |
166 |
167 |
168 | ${message}
169 |
170 |
171 | ```
172 |
173 | **dispatcher-servlet.xml源码：**
174 | ```xml
175 |
176 |
177 |
187 |
188 |
193 |
194 |
195 | indexController
196 | helloController
197 | selectController
198 |
199 |
200 |
201 |
202 |
220 | ```
221 |
222 | 该文件中新增加了`selectController`，以及`
237 |
238 |
249 |
251 |
252 |
253 | ```
254 | `dataSource`设置程MySQL，并注入到`jdbcTemplate`。
255 |
256 | **运行项目，浏览器访问：**
257 | 
258 |
259 |
260 | ## 资料
261 | **JdbcTemplate中的有多种查询方法，可以参考：**
262 | [JdbcTemplate 查询](http://www.cnblogs.com/shitianzeng/articles/2318995.html)
263 | [Spring JdbcTemplate方法详解](http://blog.csdn.net/dyllove98/article/details/7772463)
264 |
265 | **上面的JSP中用到了JSTL，以下几篇文件可以看一下：**
266 | [在JSTL EL中处理java.util.Map，及嵌套List的情况](http://my.oschina.net/letiantian/blog/511920)
267 | [JSP 标准标签库（JSTL）](http://www.runoob.com/jsp/jsp-jstl.html)
268 |
269 | **JdbcTemplate也可以使用事务，有声明式和编程式两种方法：**
270 | [Spring Declarative Transactions](http://www.simplespringtutorial.com/springDeclarativeTransactions.html)
271 | [Spring Programmatic Transactions](http://www.simplespringtutorial.com/springProgrammaticTransactions.html)
272 | [Spring Programmatic Transaction Management](http://www.tutorialspoint.com/spring/programmatic_management.htm)
273 | [Spring JdbcTemplate 与 事务管理](http://blog.sina.com.cn/s/blog_63f08ebf0100orev.html)
274 | [Transactions with JdbcTemplate](http://www.javacreed.com/transactions-with-jdbctemplate/)
275 |
276 |
277 | **如何使用连接池？**
278 | [JDBC Database connection pool in Spring FrameWork - How to SetUp Example](http://javarevisited.blogspot.jp/2012/06/jdbc-database-connection-pool-in-spring.html)
279 | [Setup Connection Pooling in Spring MVC](http://stackoverflow.com/questions/3552831/setup-connection-pooling-in-spring-mvc)
280 |
281 | **其他：**
282 | [Spring MVC with JdbcTemplate Example](http://www.codejava.net/frameworks/spring/spring-mvc-with-jdbctemplate-example)
283 | [Spring MVC and List Example](http://www.mkyong.com/spring-mvc/spring-mvc-and-list-example/)
284 |
--------------------------------------------------------------------------------
/00-04.md:
--------------------------------------------------------------------------------
1 | 00-04、理解Servlet
2 | ---
3 |
4 | 本文依然使用[00-03、从JSP开始](./00-03.md)中创建的项目HelloJSP。
5 |
6 | 本文主要有以下内容：
7 |
8 | * 如何使用Servlet编写Hello Servlet
9 | * 如何将Servlet与URL对应起来
10 | * Servlet如何调用JSP
11 | * Servlet如何返回JSON数据
12 | * 如何编写一个Dispatcher
13 |
14 |
15 | ## Hello Servlet
16 | 项目结构如下：
17 |
18 | 
19 |
20 | `HelloServlet.java`内容如下：
21 | ```java
22 | package me.letiantian.servlet;
23 |
24 | import java.io.IOException;
25 | import java.io.PrintWriter;
26 | import javax.servlet.ServletException;
27 | import javax.servlet.http.HttpServlet;
28 | import javax.servlet.http.HttpServletRequest;
29 | import javax.servlet.http.HttpServletResponse;
30 |
31 | public class HelloServlet extends HttpServlet {
32 |
33 | protected void processRequest(HttpServletRequest request, HttpServletResponse response)
34 | throws ServletException, IOException {
35 | response.setContentType("text/html;charset=UTF-8");
36 | try (PrintWriter out = response.getWriter()) {
37 | out.println("");
38 | out.println("");
39 | out.println("");
40 | out.println("Servlet HelloServlet ");
41 | out.println("");
42 | out.println("");
43 | out.println("Servlet HelloServlet at " + request.getContextPath() + " ");
44 | out.println("");
45 | out.println("");
46 | }
47 | }
48 |
49 | @Override
50 | protected void doGet(HttpServletRequest request, HttpServletResponse response)
51 | throws ServletException, IOException {
52 | processRequest(request, response);
53 | }
54 |
55 | @Override
56 | protected void doPost(HttpServletRequest request, HttpServletResponse response)
57 | throws ServletException, IOException {
58 | processRequest(request, response);
59 | }
60 |
61 | }
62 |
63 | ```
64 | HTTP最常见的方法是GET和POST，在一个Servlet中对应的处理方法分别是doGet()和doPost()。
65 | `response.setContentType("text/html;charset=UTF-8");` 用来设置HTTP响应头中的Content-Type。
66 | PrintWriter对象out的输出内容则是响应正文。
67 |
68 |
69 | `web.xml`内容如下：
70 | ```xml
71 |
72 |
73 |
74 | HelloServlet
75 | me.letiantian.servlet.HelloServlet
76 |
77 |
78 | HelloServlet
79 | /HelloServlet
80 |
81 |
82 |
83 | 30
84 |
85 |
86 |
87 | ```
88 | 在这个配置中，`me.letiantian.servlet.HelloServlet`与URL`/HelloServlet`对应。
89 | `session-timeout`设置了session的有效时间，单位是分钟（不过目前的程序里还没用过session）。
90 |
91 | 浏览器访问`http://127.0.0.1:8084/HelloJSP`会显示404；访问`http://127.0.0.1:8084/HelloJSP/HelloServlet`会显示`Servlet HelloServlet at /HelloJSP`，这也正是`me.letiantian.servlet.HelloServlet`输出的HTML的渲染结果。
92 |
93 |
94 | ### 也可以使用注解将Servlet和URL对应起来
95 |
96 | 首先清空web.xml中关于URL的配置，web.xml最终内容如下：
97 | ```xml
98 |
99 |
100 |
101 |
102 |
103 | 30
104 |
105 |
106 |
107 |
108 |
109 | ```
110 | 然后对`me.letiantian.servlet.HelloServlet`类略做修改：
111 | ```java
112 | package me.letiantian.servlet;
113 |
114 | import java.io.IOException;
115 | import java.io.PrintWriter;
116 | import javax.servlet.ServletException;
117 | import javax.servlet.http.HttpServlet;
118 | import javax.servlet.http.HttpServletRequest;
119 | import javax.servlet.http.HttpServletResponse;
120 |
121 | import javax.servlet.annotation.WebServlet;
122 |
123 | @WebServlet("/HelloServlet")
124 | public class HelloServlet extends HttpServlet {
125 | // ......
126 | }
127 | ```
128 |
129 | 重新启动项目，浏览器访问效果和之前是相同的。
130 |
131 |
132 | ## Servlet调用JSP
133 | 改写me.letiantian.servlet.HelloServlet类，内容如下：
134 |
135 | ```java
136 | package me.letiantian.servlet;
137 |
138 | import java.io.IOException;
139 | import java.io.PrintWriter;
140 | import javax.servlet.RequestDispatcher;
141 | import javax.servlet.ServletException;
142 | import javax.servlet.http.HttpServlet;
143 | import javax.servlet.http.HttpServletRequest;
144 | import javax.servlet.http.HttpServletResponse;
145 |
146 | import javax.servlet.annotation.WebServlet;
147 |
148 | @WebServlet("/HelloServlet")
149 | public class HelloServlet extends HttpServlet {
150 |
151 | protected void processRequest(HttpServletRequest request, HttpServletResponse response)
152 | throws ServletException, IOException {
153 | response.setContentType("text/html;charset=UTF-8");
154 | request.setAttribute("title", "Hello Servlet");
155 | request.setAttribute("content", "你好");
156 | RequestDispatcher rd = request.getRequestDispatcher("/WEB-INF/jsp/hello.jsp");
157 | rd.forward(request, response);
158 | }
159 |
160 | @Override
161 | protected void doGet(HttpServletRequest request, HttpServletResponse response)
162 | throws ServletException, IOException {
163 | processRequest(request, response);
164 | }
165 |
166 | @Override
167 | protected void doPost(HttpServletRequest request, HttpServletResponse response)
168 | throws ServletException, IOException {
169 | processRequest(request, response);
170 | }
171 |
172 | }
173 | ```
174 |
175 | 在`WEB-INF/`下创建目录`jsp`，然后在`jsp`目录下新建`hello.jsp`，内容如下：
176 | ```html
177 |
178 |
179 |
180 | ${title}
182 |
183 |
184 | ${content}
185 |
186 |
187 | ```
188 |
189 | 重启该项目，访问`http://127.0.0.1:8084/HelloJSP/HelloServlet`：
190 | ```plain
191 | $ curl -i http://127.0.0.1:8084/HelloJSP/HelloServlet
192 | HTTP/1.1 200 OK
193 | Server: Apache-Coyote/1.1
194 | Set-Cookie: JSESSIONID=7CCCFD5467F8330066F827623802FB23; Path=/HelloJSP/; HttpOnly
195 | Content-Type: text/html;charset=UTF-8
196 | Content-Length: 215
197 | Date: Fri, 18 Sep 2015 08:09:58 GMT
198 |
199 |
200 |
201 |
202 |
203 | Hello Servlet
205 |
206 |
207 | 你好
208 |
209 |
210 | ```
211 |
212 | ## CSS等静态文件放在什么地方
213 | 在项目下建立static目录，再这个目录下添加`test.js`，内容如下：
214 | ```
215 | console.log("hello world");
216 | ```
217 | 在`web.xml`添加以下内容：
218 | ```xml
219 |
220 | default
221 | *.jpg
222 |
223 |
224 |
225 | default
226 | *.png
227 |
228 |
229 |
230 | default
231 | *.js
232 |
233 |
234 |
235 | default
236 | *.css
237 |
238 | ```
239 | 此时，项目结构如下：
240 | 
241 |
242 | 启动项目，访问
243 | ```plain
244 | $ curl -i http://localhost:8084/HelloJSP/static/test.js
245 | HTTP/1.1 200 OK
246 | Server: Apache-Coyote/1.1
247 | Accept-Ranges: bytes
248 | ETag: W/"27-1442566151000"
249 | Last-Modified: Fri, 18 Sep 2015 08:49:11 GMT
250 | Content-Type: application/javascript
251 | Content-Length: 27
252 | Date: Fri, 18 Sep 2015 08:58:00 GMT
253 |
254 | console.log("hello world");
255 | ```
256 |
257 | ```plain
258 | $ curl -i http://localhost:8084/HelloJSP/static/test.js?time=123
259 | HTTP/1.1 200 OK
260 | Server: Apache-Coyote/1.1
261 | Accept-Ranges: bytes
262 | ETag: W/"27-1442566151000"
263 | Last-Modified: Fri, 18 Sep 2015 08:49:11 GMT
264 | Content-Type: application/javascript
265 | Content-Length: 27
266 | Date: Fri, 18 Sep 2015 08:58:09 GMT
267 |
268 | console.log("hello world");
269 | ```
270 |
271 | ## Servlet如何返回JSON数据
272 |
273 | 将
274 | ```
275 | response.setContentType("text/html;charset=UTF-8");
276 | ```
277 | 修改为
278 | ```
279 | response.setContentType("application/json;charset=UTF-8");
280 | ```
281 | 。
282 |
283 | `out.println`输出JSON格式的字符串即可。
284 |
285 |
286 | ## 编写Dispatcher
287 | 基于以上的学习，已经可以编写一个分发器了。
288 | 将HelloServlet.java修改为DispatcherServlet.java，内容修改为：
289 | ```java
290 | package me.letiantian.servlet;
291 |
292 | import java.io.IOException;
293 | import java.io.PrintWriter;
294 | import javax.servlet.ServletException;
295 | import javax.servlet.http.HttpServlet;
296 | import javax.servlet.http.HttpServletRequest;
297 | import javax.servlet.http.HttpServletResponse;
298 |
299 | import javax.servlet.annotation.WebServlet;
300 |
301 | @WebServlet("/")
302 | public class HelloServlet extends HttpServlet {
303 |
304 | protected void processRequest(HttpServletRequest request, HttpServletResponse response)
305 | throws ServletException, IOException {
306 | response.setContentType("text/plain;charset=UTF-8");
307 | try (PrintWriter out = response.getWriter()) {
308 | out.println("context: " + request.getContextPath());
309 | out.println("request uri: " + request.getRequestURI());
310 | out.println("params: " + request.getParameterMap());
311 | }
312 | }
313 |
314 | @Override
315 | protected void doGet(HttpServletRequest request, HttpServletResponse response)
316 | throws ServletException, IOException {
317 | processRequest(request, response);
318 | }
319 |
320 | @Override
321 | protected void doPost(HttpServletRequest request, HttpServletResponse response)
322 | throws ServletException, IOException {
323 | processRequest(request, response);
324 | }
325 |
326 | }
327 | ```
328 | 运行项目，访问结果如下：
329 | ```
330 | $ curl http://localhost:8084/HelloJSP/user
331 | context: /HelloJSP
332 | request uri: /HelloJSP/user
333 | params: {}
334 | ```
335 | ```
336 | $ curl http://localhost:8084/HelloJSP/user?name=letian
337 | context: /HelloJSP
338 | request uri: /HelloJSP/user
339 | params: {name=[Ljava.lang.String;@49ea47b4}
340 | ```
341 | ```
342 | $ curl http://localhost:8084/HelloJSP/static/test.js
343 | console.log("hello world");
344 | ```
345 | （这个代码并没什么用～）
346 |
347 | 从这段代码中可以看到，我们可以通过request对象得到HTTP请求信息，特别是request URI。在这个程序的基础上，我们
348 | 可以继续扩充它，使得其遇到某个URI，就调用指定的处理函数。慢慢地补充，一个框架就出来了。
349 |
350 |
351 | ## 资料
352 |
353 | 本节中，JSP使用了表达式语言，可以参考：
354 | [JSTL 入门: 表达式语言](http://www.ibm.com/developerworks/cn/java/j-jstl0211/index.html)
355 | [JSP 表达式语言](http://www.runoob.com/jsp/jsp-expression-language.html)
356 |
--------------------------------------------------------------------------------
/01-06.md:
--------------------------------------------------------------------------------
1 | 01-06、校验器
2 | ---
3 |
4 | 校验器，Validator。
5 |
6 | 在处理带有表单数据的HTTP请求时，通常这样做：
7 |
8 | ```plain
9 | if (表单数据符合要求) {
10 | 处理数据，返回结果；
11 | } else {
12 | 返回结果，提示用户重新输入数据；
13 | }
14 | ```
15 |
16 | 判断表单数据是否符合要求这就是校验器该做的事情。我们可以自己编写校验类，也可以使用Spring MVC自带的相关类。
17 |
18 | ## 将表单数据绑定到对象中
19 | 项目结构如下：
20 | 
21 |
22 | ### 源码
23 | **web.xml**
24 | ```xml
25 |
26 |
27 |
28 | contextConfigLocation
29 | /WEB-INF/applicationContext.xml
30 |
31 |
32 | org.springframework.web.context.ContextLoaderListener
33 |
34 |
35 | dispatcher
36 | org.springframework.web.servlet.DispatcherServlet
37 | 2
38 |
39 |
40 | dispatcher
41 | /
42 |
43 |
44 |
45 | 30
46 |
47 |
48 |
49 | redirect.jsp
50 |
51 |
52 | ```
53 |
54 | **applicationContext.xml**
55 | ```xml
56 |
57 |
65 |
66 |
67 | ```
68 |
69 | **dispatcher-servlet.xml**
70 | ```xml
71 |
72 |
84 |
85 |
91 |
92 |
93 | indexController
94 |
95 |
96 |
97 |
98 |
108 | ```
109 |
110 | **hello/input.jsp**
111 | ```html
112 | <%@page contentType="text/html" pageEncoding="UTF-8"%>
113 |
114 |
115 |
116 | JSP Page
118 |
119 |
120 |
126 |
127 |
128 | ```
129 |
130 | **hello/output.jsp**
131 | ```plain
132 | <%@page contentType="text/plain" pageEncoding="UTF-8"%>
133 | first name: ${person.firstName}
134 | second name: ${person.secondName}
135 | ```
136 |
137 | **Person.java**
138 | ```java
139 | package me.letiantian.form;
140 |
141 | public class Person {
142 |
143 | private String firstName;
144 | private String secondName;
145 |
146 | public String getFirstName() {
147 | return firstName;
148 | }
149 |
150 | public void setFirstName(String firstName) {
151 | this.firstName = firstName;
152 | }
153 |
154 | public String getSecondName() {
155 | return secondName;
156 | }
157 |
158 | public void setSecondName(String secondName) {
159 | this.secondName = secondName;
160 | }
161 |
162 | }
163 | ```
164 |
165 | **HelloController.java**
166 | ```java
167 | package me.letiantian.controller;
168 |
169 | import java.io.PrintWriter;
170 | import javax.servlet.http.HttpServletRequest;
171 | import javax.servlet.http.HttpServletResponse;
172 | import org.springframework.stereotype.Controller;
173 | import org.springframework.ui.Model;
174 | import org.springframework.web.bind.annotation.PathVariable;
175 | import org.springframework.web.bind.annotation.RequestMapping;
176 | import org.springframework.web.bind.annotation.RequestMethod;
177 |
178 | import me.letiantian.form.Person;
179 | import org.springframework.web.bind.annotation.ModelAttribute;
180 |
181 | @Controller
182 | @RequestMapping("/hello")
183 | public class HelloController{
184 |
185 | @RequestMapping(value = "")
186 | public String index() {
187 | return "index";
188 | }
189 |
190 | @RequestMapping(value = "/input")
191 | public String input() {
192 | return "hello/input";
193 | }
194 |
195 | @RequestMapping(value = "/output")
196 | public String output(Person person, Model model) {
197 | model.addAttribute("person", person);
198 | return "hello/output";
199 | }
200 |
201 | // @RequestMapping(value = "/output")
202 | // public String output(@ModelAttribute(value="person") Person person, Model model) {
203 | // return "hello/output";
204 | // }
205 |
206 | }
207 | ```
208 |
209 | 注意，
210 | ```java
211 | @RequestMapping(value = "/output")
212 | public String output(Person person, Model model) {
213 | model.addAttribute("person", person);
214 | return "hello/output";
215 | }
216 | ```
217 | 和
218 | ```java
219 | @RequestMapping(value = "/output")
220 | public String output(@ModelAttribute(value="person") Person person, Model model) {
221 | return "hello/output";
222 | }
223 | ```
224 |
225 | 是一样的。
226 |
227 | ### 浏览器访问
228 |
229 | 表单填入信息：
230 | 
231 | 提交表单后：
232 | 
233 |
234 |
235 | ## 校验数据
236 |
237 | ### hello/input.jsp修改如下
238 | ```html
239 | <%@page contentType="text/html" pageEncoding="UTF-8"%>
240 | <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
241 | <%@taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
242 |
243 |
244 |
245 | JSP Page
247 |
250 |
251 |
252 |
253 |
254 | firstName:
258 |
259 |
260 |
261 | ```
262 |
263 | 注意` type) {
325 | return Person.class.isAssignableFrom(type);
326 | }
327 |
328 | @Override
329 | public void validate(Object o, Errors errors) {
330 | Person person = (Person) o;
331 | ValidationUtils.rejectIfEmptyOrWhitespace(errors, "firstName", null, "firstName不能为空");
332 | ValidationUtils.rejectIfEmptyOrWhitespace(errors, "secondName", null, "secondName不能为空");
333 | if (person.getFirstName().length() < 2) {
334 | errors.rejectValue("firstName", null, "firstName太短");
335 | }
336 | }
337 | }
338 | ```
339 |
340 | ### 测试
341 | **第1组：**
342 |
343 | 
344 | 
345 |
346 | **第2组：**
347 |
348 | 
349 | 
350 |
351 | **第3组：**
352 |
353 | 
354 | 
355 |
--------------------------------------------------------------------------------
/01-02.md:
--------------------------------------------------------------------------------
1 | 01-02、使用Spring MVC构建Hello World
2 | ---
3 |
4 | 本文演示如何使用Spring MVC做出最简单的Hello World应用。
5 |
6 | ## 示例1
7 | 项目创建和之前一样，不过在最后一步要选择Spring Web MVC：
8 | 
9 |
10 | 项目结构如下：
11 | 
12 |
13 | ### web.xml源码：
14 | ```xml
15 |
16 |
17 |
18 | contextConfigLocation
19 | /WEB-INF/applicationContext.xml
20 |
21 |
22 |
23 | org.springframework.web.context.ContextLoaderListener
24 |
25 |
26 |
27 | dispatcher
28 | org.springframework.web.servlet.DispatcherServlet
29 | 2
30 |
31 |
32 |
33 | dispatcher
34 | *.htm
35 |
36 |
37 |
38 |
39 | 30
40 |
41 |
42 |
43 | redirect.jsp
44 |
45 |
46 | ```
47 | 如果遇到匹配*.htm的URL，会使用`org.springframework.web.servlet.DispatcherServlet`来处理。
48 |
49 | ### applicationContext.xml源码：
50 | ```xml
51 |
52 |
53 |
61 |
62 |
72 |
73 |
74 |
75 |
76 | ```
77 | applicationContext.xml是Spring的配置文件。
78 |
79 | ### dispatcher-servlet.xml源码：
80 | ```xml
81 |
82 |
83 |
91 |
92 |
100 |
101 |
102 | indexController
103 |
104 |
105 |
106 |
107 |
120 | ```
121 |
122 | 在`Welcome to Spring Web MVC project
143 |
144 |
145 |
146 | Hello! This is the default welcome page for a Spring Web MVC project.
147 | To display a different welcome page for this project, modify
148 | index.jsp , or create your own welcome page then change
149 | the redirection in redirect.jsp to point to the new
150 | welcome page and also update the welcome-file setting in
151 | web.xml .
152 |
153 |
154 | ```
155 |
156 | 运行项目，打开浏览器访问`http://localhost:8084/Project_0102/`，会自动跳转到
157 | `http://localhost:8084/Project_0102/index.htm`，并显示`index.jsp`的内容。
158 |
159 | ### Hello World
160 | 修改dispatcher-servlet.xml，将`
163 |
164 |
165 | indexController
166 | helloController
167 |
168 |
169 |
170 | ```
171 |
172 | 并添加：
173 | ```xml
174 | Hello world
205 |
206 |
207 | ${message}
208 |
209 |
210 | ```
211 |
212 | 创建static目录，在static目录下创建test.js，内容如下：
213 | ```js
214 | console.log("hello world");
215 | ```
216 |
217 | 在`web.xml`中添加：
218 | ```xml
219 |
220 | default
221 | *.jpg
222 |
223 |
224 |
225 | default
226 | *.png
227 |
228 |
229 |
230 | default
231 | *.js
232 |
233 |
234 |
235 | default
236 | *.css
237 |
238 | ```
239 |
240 | 好了，现在的项目结构如下：
241 | 
242 |
243 | 浏览器访问结果：
244 | 
245 | 
246 |
247 | 乱码了~囧~
248 |
249 | **解决方法：**
250 | 在`HelloController.java`加入`response.setContentType("text/html;charset=UTF-8");`：
251 | ```java
252 | package me.letiantian.controller;
253 |
254 | import javax.servlet.http.HttpServletRequest;
255 | import javax.servlet.http.HttpServletResponse;
256 | import org.springframework.web.servlet.ModelAndView;
257 | import org.springframework.web.servlet.mvc.Controller;
258 |
259 | public class HelloController implements Controller{
260 |
261 | @Override
262 | public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
263 | response.setContentType("text/html;charset=UTF-8"); // 新加入的内容
264 | ModelAndView mv = new ModelAndView();
265 | mv.addObject("message", "Hello World!你好");
266 | mv.setViewName("hello");
267 | return mv;
268 | }
269 |
270 | }
271 | ```
272 |
273 |
274 | ## 示例2
275 |
276 | ### 换种方法配置静态资源
277 |
278 | 删掉在`web.xml`中的：
279 | ```xml
280 |
281 | default
282 | *.jpg
283 |
284 |
285 |
286 | default
287 | *.png
288 |
289 |
290 |
291 | default
292 | *.js
293 |
294 |
295 |
296 | default
297 | *.css
298 |
299 | ```
300 | 在`dispatcher-servlet.xml`中增加以下内容：
301 | ```xml
302 |
303 |
304 |
314 |
315 |
316 |
319 | ```
320 |
321 | 注意，在beans的属性中增加了`xmlns:mvc="http://www.springframework.org/schema/mvc"`，属性`xsi:schemaLocation`中增加了`http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd`。
322 |
323 |
324 | ### 不再使用任何后缀（例如.html，.jsp）
325 |
326 | 将`redirect.jsp`修改为：
327 | ```jsp
328 | <%@page contentType="text/html" pageEncoding="UTF-8"%>
329 | <% response.sendRedirect("index"); %>
330 | ```
331 |
332 | 将web.xml中的：
333 | ```xml
334 |
335 | dispatcher
336 | *.htm
337 |
338 | ```
339 |
340 | 修改为：
341 | ```xml
342 |
343 | dispatcher
344 | /
345 |
346 | ```
347 |
348 | 将`dispatcher-servlet.xml`中的：
349 | ```xml
350 |
351 |
352 |
353 | indexController
354 | helloController
355 |
356 |
357 |
358 | ```
359 |
360 | 修改为：
361 | ```xml
362 |
363 |
364 |
365 | indexController
366 | helloController
367 |
368 |
369 |
370 | ```
371 |
372 | 然后，浏览器访问`http://localhost:8084/Project_0102/hello`。
373 |
374 |
375 | ## 示例3
376 |
377 | 这个示例展示如何获取URL中的数据。
378 |
379 | 修改`HelloController.java`:
380 | ```java
381 | package me.letiantian.controller;
382 |
383 | import javax.servlet.http.HttpServletRequest;
384 | import javax.servlet.http.HttpServletResponse;
385 | import org.springframework.web.servlet.ModelAndView;
386 | import org.springframework.web.servlet.mvc.Controller;
387 |
388 | public class HelloController implements Controller{
389 |
390 | @Override
391 | public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
392 | response.setContentType("text/html;charset=UTF-8");
393 | ModelAndView mv = new ModelAndView();
394 | mv.addObject("name", request.getParameter("name"));
395 | mv.setViewName("hello");
396 | return mv;
397 | }
398 |
399 | }
400 | ```
401 |
402 | 修改`hello.jsp`：
403 | ```html
404 | <%@page contentType="text/html" pageEncoding="UTF-8"%>
405 |
406 |
407 | Hello world
408 |
409 |
410 | ${pageContext.request.contextPath}
411 |
412 |
416 |
417 | 提交的数据： ${name}
418 |
419 |
420 |
421 | ```
422 | `${pageContext.request.contextPath}`的输出是`/Project_0102`。
423 | 浏览器访问：
424 | 
425 |
426 | 再编辑JSP文件时候遇到了这样的问题：
427 |
428 | > The header.jspf contains characters which will probably be damaged during
429 | conversion to the ISO-8859-1 character set.
430 | Do you want to save the file using this character set?
431 |
432 | 解决办法见[http://stackoverflow.com/questions/15499182/netbeans-forces-me-to-save-in-specific-encoding](http://stackoverflow.com/questions/15499182/netbeans-forces-me-to-save-in-specific-encoding)。
433 |
434 | ## 资料
435 | - [Chapter 13. Web MVC framework](http://docs.spring.io/spring/docs/2.5.x/reference/mvc.html)
436 | - [Spring MVC – How to include JS or CSS files in a JSP page](http://www.mkyong.com/spring-mvc/spring-mvc-how-to-include-js-or-css-files-in-a-jsp-page/)
437 |
438 | - [dispatcher-servlet.xml and application-context.xml的区别](http://stackoverflow.com/questions/4549034/dispatcher-servlet-xml-and-application-context-xml)
439 |
440 | - [Spring MVC SimpleUrlHandlerMapping example](http://www.mkyong.com/spring-mvc/spring-mvc-simpleurlhandlermapping-example/)
441 | - [springMVC中文乱码问题](http://blog.csdn.net/xuechongyang/article/details/8283924)
442 | - [SpringMVC 基于注解的Controller @RequestMapping @RequestParam.. ](http://blog.csdn.net/lufeng20/article/details/7598801)
443 |
444 | - urlMapping也可以通过注解来定义，例如[Spring 4 MVC Hello World Tutorial – Full Example](http://javahash.com/spring-4-mvc-hello-world-tutorial-full-example/)。
445 |
--------------------------------------------------------------------------------