首页 > 代码库 > 【FunnyBear的Java之旅 - Spring篇】7步初探 Spring MVC
【FunnyBear的Java之旅 - Spring篇】7步初探 Spring MVC
本文将介绍如何搭建一个简单的Spring MVC项目，其中包含依赖注入，视图控制，数据库连接，等关键功能。
在开始阅读前，你需要：MySQL Server, Eclipse EE，Maven Eclipse插件，Spring Eclipse插件，基本的Java Core和Servlet知识。
最终的项目结构如下图所示
1. 新建工程。
这里总的思路是，新建一个普通的Dynamic Web Project，然后把它转换成Maven工程，最后添加对Spring Framework的引用。
1.1 "Dynamic web module version"选择2.5，因为这样我们会默认得到一个web.xml的配置文件，它会是我们进行Spring MVC配置的起点。
1.2 右键新建的工程，把它转换成Maven工程
1.3 然后把生成的pom.xml文件内容进行如下替换。其中我们添加了对于Spring，MySQL driver和jstl的依赖。Maven插件会读取这个文件，下载相应jar包。
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.funnybear.spring</groupId> <artifactId>springmvc</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>war</packaging> <build> <sourceDirectory>src</sourceDirectory> <plugins> <plugin> <artifactId>maven-war-plugin</artifactId> <version>2.6</version> <configuration> <warSourceDirectory>WebContent</warSourceDirectory> <failOnMissingWebXml>false</failOnMissingWebXml> </configuration> </plugin> <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.5.1</version> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> </plugins> </build> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.3.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.3.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>4.3.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>4.3.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.3.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.3.0.RELEASE</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>6.0.4</version> </dependency> <dependency> <groupId>jstl</groupId> <artifactId>jstl</artifactId> <version>1.0</version> </dependency> <dependency> <groupId>taglibs</groupId> <artifactId>standard</artifactId> <version>1.1.0</version> </dependency> </dependencies></project>
下载完成的jar包应如下图
2. 添加DispatcherServlet
Spring提供了默认的请求中转类，指定路径下的http请求会先进入Dispatcher对象，Dispatcher对象会从指定的beans配置里获取Controller对象。每个Controller对象需要指定自己想处理的请求路径，当路径与Controller相匹配时，Controller的处理方法将会被执行。
2.1 在web.xml中添加DispatcherServlet。
我们给DispatcherServlet起名为users，所以这个类在启动时，会扫描WEB-INF文件夹，看其中是否有users-servlet.xml这样一个beans配置文件。
DispatcherServlet被配置为处理根路径"\"，即对我们这个Web App的所有请求都会经过DispatcherServlet中转。
<servlet> <description></description> <display-name>users</display-name> <servlet-name>users</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup></servlet><servlet-mapping> <servlet-name>users</servlet-name> <url-pattern>/</url-pattern></servlet-mapping>
2.2 在WEB-INF下添加名为users-servlet.xml的配置。
其中包含了三个重要的信息：以扫描标注(Annotation)的方式导入依赖，从哪个package导入依赖，注册视图解析器(ViewResolver)。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"> <mvc:annotation-driven></mvc:annotation-driven> <context:component-scan base-package="com.funnybear.springmvc.controllers"> </context:component-scan> <bean id="jspViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/jsps/"></property> <property name="suffix" value=".jsp"></property> </bean></beans>
3. 添加Controller
在Jave Resources文件夹下，添加UsersController
3.1 @Controller，让这个类能被导出供DispatcherServlet使用。
3.2 @RequestMapping，指定处理方法对应的请求路径。如注释所示，处理方法可以返回多种数据类型，返回结果将交由在users-servlet.xml配置的视图解析器处理(ViewResolver)。
3.3 @Autowired，这是依赖注入的标识，请求一个Service类被注入进来，供Controller使用，这主要是为了实现业务逻辑和Controller的解耦。我们将在之后创建Service类。
package com.funnybear.springmvc.controllers;import java.util.List;import java.util.Map;import javax.servlet.http.HttpSession;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.servlet.ModelAndView;import com.funnybear.springmvc.dao.User;import com.funnybear.springmvc.service.UsersService;@Controllerpublic class UsersController { private UsersService usersService; @Autowired public void setUsersService(UsersService usersService) { this.usersService = usersService; } @RequestMapping("/users") public String showHome(Model model) { List<User> users = usersService.getUsers(); //This object is in request scope model.addAttribute("users", users); return "users"; } /* @RequestMapping("/") public String showHome(HttpSession session) { session.setAttribute("name", "Bob"); return "home"; } @RequestMapping("/") public ModelAndView showHome() { //This object is in request scope ModelAndView mv = new ModelAndView("home"); Map<String, Object> model = mv.getModel(); model.put("name", "Cliff"); return mv; } */ }
4. 添加数据源
4.1 在Tomcat的context.xml中添加数据源，其中需要提供MySQL数据库服务器的地址，用户名，密码和数据库名
<Context> <WatchedResource>WEB-INF/web.xml</WatchedResource> <WatchedResource>${catalina.base}/conf/web.xml</WatchedResource> <Resource name="jdbc/webshop" auth="Container" type="javax.sql.DataSource" maxTotal="100" maxIdle="30" maxWaitMillis="10000" username="tan" password="admin" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/webshop" /></Context>
4.2 在web.xml中引用数据源
<description>Funny Bear MySQL</description><resource-ref> <description>DB Connection</description> <res-ref-name>jdbc/webshop</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth></resource-ref>
5. 添加DAO
有了数据源，我们就可以新建DAO对象去使用它了。我们使用Spring的依赖注入机制来实现数据源的绑定。
5.1 在Java Resources文件夹下，新建UsersDAO类。它把自己作为bean导出，同时请求注入DataSource对象。
package com.funnybear.springmvc.dao;import java.sql.ResultSet;import java.sql.SQLException;import java.util.List;import javax.sql.DataSource;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.RowMapper;import org.springframework.stereotype.Component;@Component("usersDAO")public class UsersDAO { private JdbcTemplate jdbc; @Autowired public void setDataSource(DataSource dataSource) { this.jdbc = new JdbcTemplate(dataSource); } public List<User> getUsers() { return jdbc.query("select * from users", new RowMapper<User>() { public User mapRow(ResultSet rs, int rowNum) throws SQLException { User user = new User(rs.getString("name"), rs.getString("email")); return user; } }); }}
5.2 在Java Resources文件夹下，创建Spring Beans配置文件daoContext.xml，专门放置DAO相关的bean。其中我们声明了DAO bean和DataSource bean，这样，就建立起了他们之间的依赖。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee" xsi:schemaLocation="http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.3.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> <context:annotation-config></context:annotation-config> <context:component-scan base-package="com.funnybear.springmvc.dao"> </context:component-scan> <jee:jndi-lookup jndi-name="jdbc/webshop" id="dataSource" expected-type="javax.sql.DataSource"> </jee:jndi-lookup></beans>
5.3 在web.xml中添加对daoContext.xml的引用。Spring web context在初始化的时候，会扫描添加进去的配置文件，这样Contoller就能取得相应的依赖。
<listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param> <param-name>contextConfigLocation</param-name> <param-value> classpath:com/funnybear/springmvc/config/daoContext.xml classpath:com/funnybear/springmvc/config/serviceContext.xml </param-value></context-param>
6. 添加服务层
DAO创建完成后，我们可以在Controller里直接注入DAO对象，从而操作数据。但为了实现业务逻辑的解耦，我们添加服务层。最终会是，Controller引用服务层，服务层引用DAO。
6.1 在Java Resources文件夹下，新建UsersServece类。它把自己作为bean导出，同时请求注入DAO对象。
package com.funnybear.springmvc.service;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import com.funnybear.springmvc.dao.User;import com.funnybear.springmvc.dao.UsersDAO;@Service("usersService")public class UsersService { private UsersDAO usersDAO; @Autowired public void setUsersDAO(UsersDAO usersDAO) { this.usersDAO = usersDAO; } public List<User> getUsers(){ return usersDAO.getUsers(); }}
6.2 在Java Resources文件夹下，创建Spring Beans配置文件serviceContext.xml，专门放置DAO相关的bean。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd"> <context:annotation-config></context:annotation-config> <context:component-scan base-package="com.funnybear.springmvc.service"> </context:component-scan></beans>
6.3 在web.xml中添加对serviceContext.xml的引用(已经被包含在5.3的示例代码中)。
7. 添加视图
视图的文件名应与Controller返回的名字相对应，视图的后缀和位置应与视图解释器的配置相对应(在users-servlet.xml中)
7.1 在WEB-INF/jsps文件夹下，新建users.jsp与UsersController相对应
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%><%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%><%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><title>Show All Users</title></head><body> <c:forEach var="user" items="${users}"> Name: ${user.name}<br /> </c:forEach></body></html>
7.2 在jsp文件中，我们使用jstl来帮助读取和显示数据。
总结
至此，我们的Spring MVC示例工程就完成了，user表中的数据被顺利导出。另外两个Controller和视图的实现步骤与UserContoller是一样的，核心都是Controller, DAO, Service, JSP一一对应，Spring beans配置文件和依赖注入，是它们之间的粘合剂。在学习过程中，我也遇到很头疼的问题，总结如下。
问题1：Controller无法被加载：
org.springframework.web.servlet.PageNotFound noHandlerFound
No mapping found for HTTP request with URI [/springmvc/] in DispatcherServlet with name ‘offers‘
猜想是因为Controller编译成的class文件没有被拷贝到Tomcat的工程目录下，或者旧的工程文件在Tomcat目录下没有被删除。
解决思路：每次改动java文件后，都清空workspace，重新build
a) 清空workspace
b) 清空Tomcat缓存
c) 再次运行即可
【FunnyBear的Java之旅 - Spring篇】7步初探 Spring MVC