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

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

}

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) 再次运行即可

时间： 2024-10-11 19:02:09

【FunnyBear的Java之旅 - Spring篇】7步初探 Spring MVC的相关文章

【FunnyBear的Java之旅 - Spring篇】7步连接MySQL

准备工作: a) 启动MySQL服务器, 使用MySQL Workbench新建数据库 b) 下载Eclipse EE, 并安装Maven和Spring Framework插件 c) 由于默认的Maven服务器可能被墙,所以需要为Maven配置mirror server,此处不展开解释 最终的项目结构将如图所示,具体每个文件的作用将在下文中逐步介绍 第一步:在Eclipse中新建Maven project. 主要是为了方便jar的导入和项目结构的管理 第二步:导入相关jar包.修改Maven p

【FunnyBear的Java之旅 - Spring篇】Spring表单验证

尝试对Spring提供的表单进行了验证 1. 创建表单 在jsp页面中添加如下表单.其中action对应我们准备的Controller,commandName用于指定在pageContext中表单所对应的对象.Spring会自动把表单数据填充到对象中.sf:input和sf:error的path对应对象的属性. <%@ taglib prefix="sf" uri="http://www.springframework.org/tags/form"%>

【FunnyBear的Java之旅 - Spring篇】Spring 静态资源

在Spring MVC框架下配置静态资源: 1. 创建静态资源文件夹,如下图中的main.css 2. 在DispatcherServlet对应的beans配置文件中,添加mvc命名空间和如下配置 xmlns:mvc="http://www.springframework.org/schema/mvc" <mvc:resources location="/resources/" mapping="/static/**" /> loca

Java之旅--定时任务(Timer、Quartz、Spring、LinuxCron)

在Java中,实现定时任务有多种方式.本文介绍4种.Timer和TimerTask.Spring.QuartZ.Linux Cron. 以上4种实现定时任务的方式.Timer是最简单的.不须要不论什么框架,只JDK就能够.缺点是不过个时间间隔的定时器,调度简单.Spring和QuartZ都支持cron,功能都非常强大,Spring的长处是略微简单一点,QuartZ的长处是没有Spring也可使用:Linux Cron是个操作系统级别的定时任务.适用于全部操作系统支持的语言,缺点是精度只能到达分钟

Java之旅——起航篇

大一时,学校开过一年java,但效果不理想,后来从最基础的VB开始入门学习,现在重新开始对Java的认识.突然有一些感受,以HelloWorld开头,写篇碎碎念. 大四上半年开始,好多同学都去一些培训班学习了,其中有几个就在学习java. 在大一下学期,系里就开了Java语言程序设计这门课,而且本来要上一个学期的课程,硬生生给我们上了两个学期,一年后大家的学习成果怎么样呢 ?班里有大量同学连HelloWorld都敲不出来(包括我)--严肃点!请不要把这个事实当成一个笑话!(我猜这种现象不仅仅发生

从.Net到Java学习第四篇——spring boot+redis

从.Net到Java学习第一篇——开篇 从.Net到Java学习第二篇——IDEA and start spring boot 从.Net到Java学习第三篇——spring boot+mybatis+mysql 接上一篇,本篇使用到的框架redis.FastJSON. 环境准备 安装redis,下图是我本机的redis绿色版,你可以网上自行下载安装,如果不知道如何怎么操作,可以移步到我的另一篇文章:ASP.NET Redis 开发 以管理员身份打开CMD窗口: C:\Users\zouqj>e

Java面试题--Spring篇

Spring 概述 1. 什么是spring? Spring 是个java企业级应用的开源开发框架.Spring主要用来开发Java应用,但是有些扩展是针对构建J2EE平台的web应用.Spring 框架目标是简化Java企业级应用开发,并通过POJO为基础的编程模型促进良好的编程习惯. 2. 使用Spring框架的好处是什么? 轻量:Spring 是轻量的,基本的版本大约2MB. 控制反转:Spring通过控制反转实现了松散耦合,对象们给出它们的依赖,而不是创建或查找依赖的对象们. 面向切面的

spring之旅第一篇-初识spring

一.概述 只要用框架开发java,一定躲不过spring,Spring是一个轻量级的Java开源框架,存在的目的是用于构建轻量级的J2EE应用.Spring的核心是控制反转(IOC)和面向切面编程(AOP).spring有如下特点: 轻量级:应用大小和应用开支,包括应用方式 DI/IoC:提供松耦合的一种实现技术 AOP:切面编程将业务逻辑从应用服务中分离 容器:包含并管理应用对象的生命周期和配置 框架:使用组件配置组合成复杂的应用,并提供很多基础功能 由于spring是一个容器型的框架,所以它

JAVA之旅（三十四）——自定义服务端，URLConnection，正则表达式特点，匹配，切割，替换，获取，网页爬虫

JAVA之旅(三十四)--自定义服务端,URLConnection,正则表达式特点,匹配,切割,替换,获取,网页爬虫 我们接着来说网络编程,TCP 一.自定义服务端 我们直接写一个服务端,让本机去连接,可以看到什么样的效果 package com.lgl.socket; import java.io.IOException; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; publ