【FunnyBear的Java之旅 - Spring篇】7步初探 Spring MVC

时间：2016-10-04 16:21:51 阅读：291 评论：0 收藏：0 [点我收藏+]

标签：

本文将介绍如何搭建一个简单的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>

View Code

下载完成的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>

View Code

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>

View Code

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;

@Controller
public 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;
    }
    */
    
}

View Code

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>

View Code

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>

View Code

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;
            }
        });
    }

}

View Code

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>

View Code

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>

View Code

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();
    }
}

View Code

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>

View Code

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>

View Code

7.2 在jsp文件中，我们使用jstl来帮助读取和显示数据。

总结

至此，我们的Spring MVC示例工程就完成了，user表中的数据被顺利导出。另外两个Controller和视图的实现步骤与UserContoller是一样的，核心都是Controller, DAO, Service, JSP一一对应，Spring beans配置文件和依赖注入，是它们之间的粘合剂。在学习过程中，我也遇到很头疼的问题，总结如下。

技术分享