Spring MVC 实践

混魔MJM 混魔MJM 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 500+累计阅读 503平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
转载 最新推荐文章于 2026-08-07 12:30:18 发布 503 阅读 AI 写同款· GEO 优化 ›
MVC 模式深度解析与 Spring 框架实践研究 MVC 模式通过分离模型、视图、控制器，有效解决了复杂应用的组件耦合问题，提升了开发效率和系统可维护性；Spring MVC 作为 MVC 模式的经典实现，通过中央调度器、处理器映射器、适配器等组件的协作，实现了灵活可扩展的 Web 开发架构；源码级分析显示，Spring MVC 大量运用了策略模式、模板方法模式等设计模式，其扩展点设计为开发者提供了高度的定制能力；在现代开发中，MVC 模式与 RESTful 架构、前端 MVVM 框架结合，持续发挥着核心架构模式的作用。 阅读详情

Spring Web MVC

Spring-Web-MVC是一种基于请求驱动的轻量级Web-MVC设计模式框架, Spring MVC使用MVC架构思想, 对Web层进行职责解耦,使用请求-响应模型将数据、业务与视图进行分离, 简化开发.

MVC

MVC(模型-视图-控制器)是一个以设计界面应用程序为基础的架构模式,通过分离模型-视图-控制器在应用中的角色将业务逻辑从界面中解耦:

  • 模型负责封装应用数据和业务逻辑;
  • 视图仅负责展示数据;
  • 控制器负责接收用户请求,并调用模型(Service/Manger/DAO)来处理业务逻辑.模型可能会返回一些数据需要在视图层展示,控制器就需要整理模型数据并调用视图展示.

MVC模式的核心思想就是将业务逻辑从界面中分离出来,允许它们单独改变而不会相互影响.

Spring MVC

Spring MVC框架是基于Java语言的MVC架构具体实现.他的设计围绕DispatcherServlet展开,DispatcherServlet负责将请求分派给指定的Controller(Handler),通过可配置的HandlerMapping、HandlAdapter、Controller、ViewResolver来处理请求拿到数据并填充对应的视图View:

组件 名称 描述
DispatcherServlet 调度器/前端控制器 DispatcherServlet是前端控制器模式的具体实现(详细可参考Front Controller),他提供了整个Web应用的集中访问点,截获请求并将其分派给指定的Controller,相当于MVC中的C. 他的存在降低了组件之间的耦合性.
HandlerMapping 处理器映射器 HandlerMapping负责根据用户请求URI找到对应的Controller与Interceptor,并将它们封装在HandlerExecutionChain中返回给DispatcherServlet.
HandlAdapter 处理器适配器 Spring MVC通过HandlerAdapter执行Controller,这是适配器模式的应用,通过扩展适配器可以执行更多类型的Controller.
Controller 处理器 Controller(又称Handler)是继DispatcherServlet前端控制器之后的后端控制器,在DispatcherServlet的控制下Controller对具体的用户请求进行处理.
ViewResolver 视图解析器 负责将Model数据填充到View, 组合生成视图展示:他首先将逻辑视图名解析成物理视图名,生成View视图对象,最后对View进行渲染(填充数据). Spring默认提供了针对JSP/Velocity/PFD等视图的ViewResolver实现.

初识Spring MVC

需求: 用户列表查询.

  • 创建Maven Web项目
mvn archetype:generate  -DgroupId=com.fq.mvc 
                        -DartifactId=MVC 
                        -DarchetypeArtifactId=maven-archetype-webapp 
                        -DinteractiveMode=false
                        -DarchetypeCatalog=internal

  • 依赖管理
    在pom.xml中添加Spring、Spring MVC、 Sevlet及Velocity依赖:
<!-- Spring -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring.version}</version>
</dependency>
 
<!-- WEB -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>${servlet.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
</dependency>
 
<!-- Velocity -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity</artifactId>
    <version>${velocity.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-tools</artifactId>
    <version>${velocity.tools.version}</version>
</dependency>

  • 配置DispatcherServlet(web.xml)
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
 
    <display-name>MVC</display-name>
 
    <!-- 配置SpringMVC -->
    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!-- contextConfigLocation: 指定MVC配置文件位置 -->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/mvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <!-- 拦截所有以.do结尾的URL -->
        <servlet-name>mvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

  • 配置HandlerMapping/HandlerAdapter(mvc-servlet.xml)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 
http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <!-- 处理器映射器 -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
 
    <!-- 处理器适配器 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
</beans>

  • Controller
/**
 * @author jifang
 * @since 16/3/15 下午4:40.
 */
public class UserController implements Controller {
 
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        List<User> users = new ArrayList<>();
        users.add(new User(1, "翡青", new Date(), 1, "浙江-杭州"));
        users.add(new User(2, "小芳", new Date(), 2, "山东-青岛"));

        ModelAndView result = new ModelAndView();
        result.addObject("users", users);
        result.setViewName("users");
        return result;
    }
}

<!-- 装配 Controller -->
<bean name="/mvc/users.do" class="com.fq.mvc.controller.UserController"/>

  • 配置ViewResolver(mvc-servlet.xml)
    由于我们视图选用的是Velocity,因此配置VelocityViewResolver:
<!-- 配置视图解析器 -->
<bean id="viewResolver"
      class="org.springframework.web.servlet.view.velocity.VelocityViewResolver">
    <property name="suffix" value=".vm"/>
    <property name="contentType" value="text/html;charset=UTF-8"/>
    <property name="dateToolAttribute" value="dateTool"/>
    <property name="numberToolAttribute" value="numberTool"/>
    <property name="exposeRequestAttributes" value="false"/>
    <property name="exposeSessionAttributes" value="true"/>
</bean>
 
<!-- 配置Velocity -->
<bean id="velocityConfigurer"
      class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
    <!-- 设置VM模板放置位置-->
    <property name="resourceLoaderPath" value="views"/>
    <!-- 防止乱码 -->
    <property name="velocityProperties">
        <props>
            <prop key="input.encoding">UTF-8</prop>
            <prop key="output.encoding">UTF-8</prop>
        </props>
    </property>
</bean>

  • View(/views/users.vm)
<html>
<head>
    <title>用户列表</title>
    <link rel="stylesheet" href="/css/main.css">
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
</head>
<body>
<div id="global">
    <fieldset>
        <legend>用户列表:</legend>
 
        <table width="100%" border=0>
            <tr>
                <td>ID</td>
                <td>username</td>
                <td>birthday</td>
                <td>sex</td>
                <td>address</td>
            </tr>
 
            #foreach($user in $users)
                <tr>
                    <td>${user.id}</td>
                    <td>${user.name}</td>
                    <td>${user.birthday}</td>
                    #if(${user.sex} == 1)
                        <td>男</td>
                    #else
                        <td>女</td>
                    #end
                    <td>${user.address}</td>
                </tr>
            #end
        </table>
    </fieldset>
</div>
</body>
</html>
参考: main.css地址: OSChina


小结

  • 前端控制器
    Spring MVC DispatcherServlet的url-pattern有两种配置方式:

    • *.do: 拦截所有以.do结尾的URI.
    • / : 拦截 所有 URI.
  • 处理器映射器
    BeanNameUrlHandlerMapping指定将Bean的Name作为URI映射; Spring还提供了SimpleUrlHandlerMapping将URI和Controller的id统一映射配置.
  • 处理器适配器
    SimpleControllerHandlerAdapter对所有实现了Controller接口的JavaBean适配.Spring还提供HttpRequestHandlerAdapter对所有实现了HttpRequestHandler接口的JavaBean适配.
  • 视图解析器
    前面使用Velocity作为视图展示,如果使用的是JSP的话, 需要配置另一种视图解析器InternalResourceViewResolver:
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- "JstlView"表示可以在JSP页面JSTL标签库,所以需要在项目中添加JSTL依赖 -->
    <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
    <property name="prefix" value="/views"/>
    <property name="suffix" value=".jsp"/>
</bean>

注解初步

从2.5版本开始, Spring引入了注解开发:

  • 注解驱动(mvc-servlet.xml)
    • 从3.1版本开始,Spring MVC使用RequestMappingHandlerMapping 注解式处理器映射器 对标有@ResquestMapping的方法进行映射.
    • 从3.1版本开始,Spring MVC使用RequestMappingHandlerAdapter 注解式处理器适配器 对标记有@ResquestMapping的方法进行适配.
    • Spring MVC使用<mvc:annotation-driven/> 注解驱动自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter及其他相关配置. 因此在mvc-servlet.xml最简单有效的配置方式是使用<mvc:annotation-driven/>替代注解处理器和适配器:
<mvc:annotation-driven/>

尽管<mvc:annotation-driven/>很小, 但他具有足够的威力, 它注册了很多的特性, 包括对JSR-303校验、信息转换以及对域格式化的支持.

  • 组件扫描(mvc-servlet.xml):
    使用Spring的组件扫描来省去为每个Controller注册的麻烦:
<context:component-scan base-package="com.fq.mvc.controller"/>

  • 注解Controller
@Controller
@RequestMapping("/mvc")
public class UserController {
 
    @RequestMapping("/users.do")
    public ModelAndView users() {
        List<User> users = new ArrayList<>();
        users.add(new User(1, "翡青", new Date(), 1, "浙江-杭州"));
        users.add(new User(2, "小芳", new Date(), 2, "山东-青岛"));
 
        ModelAndView result = new ModelAndView();
        result.addObject("users", users);
        result.setViewName("users");
        return result;
    }
}

使用基于注解的`Controller`有以下优点: - 基于注解的`Controller`请求映射关系不存储在配置文件中,使用`@RequestMappeing`便可以对一个方法进行映射. - 一个`Controller`内可以有多个处理方法,可以响应多个动作,这样就允许将同一模块的多个操作写在同一个`Controller`里面,便于模块划分,且减少类的数量.

集成MyBatis

  • 通过Spring将各层整合:
    • 持久层DAO(MyBatis的Mapper)注册到Spring容器中.
    • 业务层Service/Manager从Spring容器中拿到DAO接口, 并注册Service服务.
    • 表现层Controller从Spring容器中拿到Service接口, 通过Spring MVC进行数据展示.

需求: 展示所有用户数据(由于数据模型较简单, 因此从DAO到Controller只使用一个DO对象-User).

  • 依赖管理
<!-- Spring -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>${spring.version}</version>
</dependency>
 
<!-- AOP -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>${spring.version}</version>
</dependency>
 
<!-- WEB -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>${servlet.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
</dependency>
 
<!-- Velocity -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity</artifactId>
    <version>${velocity.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-tools</artifactId>
    <version>${velocity.tools.version}</version>
</dependency>
 
<!-- DB -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.3.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql.version}</version>
</dependency>
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>${hikaricp.version}</version>
</dependency>
 
<!-- Spring DB支持 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>${mybatis.spring.version}</version>
</dependency>
 
<!-- log -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>${logback.version}</version>
</dependency>

集成MyBatis

  • mybatis-configuration.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <mappers>
        <mapper resource="mybatis/mapper/UserDAO.xml"/>
    </mappers>
</configuration>

  • domain: User
/**
 * @author jifang.
 * @since 2016/5/26 11:16.
 */
public class User {
 
    private int id;
 
    private String name;
 
    private Date birthday;
 
    private int sex;
 
    private String address;
 
    public User() {
    }
 
    public User(int id, String name, Date birthday, int sex, String address) {
        this.id = id;
        this.name = name;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Date getBirthday() {
        return birthday;
    }
 
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
 
    public int getSex() {
        return sex;
    }
 
    public void setSex(int sex) {
        this.sex = sex;
    }
 
    public String getAddress() {
        return address;
    }
 
    public void setAddress(String address) {
        this.address = address;
    }
}

  • UserDAO
/**
 * @author jifang
 * @since 16/3/20 下午5:47.
 */
public interface UserDAO {
 
    List<User> selectAllUsers();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fq.mvc.dao.UserDAO">
 
    <select id="selectAllUsers" resultType="com.fq.mvc.domain.User">
        SELECT *
        FROM user;
    </select>
 
</mapper>

  • applicationContext-datasource.xml(配置数据源)
<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.xsd">
 
    <context:property-placeholder location="classpath:db.properties"/>
 
    <!-- 配置数据源 -->
    <bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig">
        <property name="driverClassName" value="${mysql.driver.class}"/>
        <property name="jdbcUrl" value="${mysql.url}"/>
        <property name="username" value="${mysql.user}"/>
        <property name="password" value="${mysql.password}"/>
        <property name="maximumPoolSize" value="5"/>
        <property name="maxLifetime" value="700000"/>
        <property name="idleTimeout" value="600000"/>
        <property name="connectionTimeout" value="10000"/>
        <property name="dataSourceProperties">
            <props>
                <prop key="dataSourceClassName">com.mysql.jdbc.jdbc2.optional.MysqlDataSource</prop>
                <prop key="cachePrepStmts">true</prop>
                <prop key="prepStmtCacheSize">250</prop>
                <prop key="prepStmtCacheSqlLimit">2048</prop>
            </props>
        </property>
    </bean>
 
    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
        <constructor-arg ref="hikariConfig"/>
    </bean>
 
    <!-- 配置SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis/mybatis-configuration.xml"/>
    </bean>
 
    <!-- 基于包扫描的mapper配置 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.fq.mvc.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
 
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
 
</beans>

  • db.properties
## Data Source
mysql.driver.class=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://host:port/db?characterEncoding=utf-8
mysql.user=user
mysql.password=password

集成Service

public interface UserService {
 
    List<User> getAllUsers();
}

@Service
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserDAO dao;
 
    @Override
    public List<User> getAllUsers() {
        return dao.selectAllUsers();
    }
}

  • applicationContext.xml(配置组件扫描与事务控制)
<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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.xsd
 
 
http://www.springframework.org/schema/tx
 
 
http://www.springframework.org/schema/tx/spring-tx.xsd
 
 
http://www.springframework.org/schema/aop
 
 
http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <import resource="applicationContext-datasource.xml"/>
 
    <context:component-scan base-package="com.fq.mvc.service"/>
 
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
 
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="select*" timeout="-1" propagation="REQUIRED" read-only="true"/>
        </tx:attributes>
    </tx:advice>
 
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.fq.mvc.service.impl.UserServiceImpl.*(..))"/>
    </aop:config>
 
</beans>

集成MVC

  • Controller
@Controller
@RequestMapping("/mvc")
public class UserController {
 
    @Autowired
    private UserService service;
 
    @RequestMapping(value = "/user.do")
    public ModelAndView users() {
        List<User> users = service.getAllUsers();
        return new ModelAndView("users", "users", users);
    }
}

  • mvc-servlet.xml
<?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/beans
 
http://www.springframework.org/schema/beans/spring-beans.xsd
 
 
http://www.springframework.org/schema/mvc
 
 
http://www.springframework.org/schema/mvc/spring-mvc.xsd
 
 
http://www.springframework.org/schema/context
 
 
http://www.springframework.org/schema/context/spring-context.xsd">
 
    <mvc:annotation-driven/>
 
    <context:component-scan base-package="com.fq.mvc.controller"/>
 
    <!-- 配置视图解析器 -->
    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.velocity.VelocityViewResolver">
        <property name="suffix" value=".vm"/>
        <property name="contentType" value="text/html;charset=UTF-8"/>
        <property name="dateToolAttribute" value="dateTool"/>
        <property name="numberToolAttribute" value="numberTool"/>
        <property name="exposeRequestAttributes" value="false"/>
        <property name="exposeSessionAttributes" value="true"/>
    </bean>
 
    <!-- 配置Velocity -->
    <bean id="velocityConfigurer"
          class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
        <!-- 设置VM模板放置位置-->
        <property name="resourceLoaderPath" value="views"/>
        <!-- 防止乱码 -->
        <property name="velocityProperties">
            <props>
                <prop key="input.encoding">UTF-8</prop>
                <prop key="output.encoding">UTF-8</prop>
            </props>
        </property>
    </bean>
</beans>

  • web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
 
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
 
    <display-name>MVC</display-name>
 
    <!-- 加载Spring -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/applicationContext.xml</param-value>
    </context-param>
 
    <!-- 加载SpringMVC -->
    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/mvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

  • View视图同前

集成log

为了能够看到Spring MVC的运行时信息, 最好在应用中集成一种Log实现, 在此选用LogBack:

  • logback.xml
<configuration>
 
    <property name="log_root_dir" value="/data/logs/mvc/"/>
    <property name="log_pattern" value="%d{HH:mm:ss.SSS} [%thread] %-5level %logger{0} - %msg%n"/>
 
    <appender name="STD_OUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${log_pattern}</pattern>
        </encoder>
    </appender>
    <appender name="FILE_OUT" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log_root_dir}/mvc-server.%d{YY-MM-dd}.log</fileNamePattern>
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log_pattern}</pattern>
        </encoder>
    </appender>
 
    <root level="DEBUG">
        <appender-ref ref="STD_OUT"/>
        <appender-ref ref="FILE_OUT"/>
    </root>
 
</configuration>

注解开发

需求: 实现User添加.

  • add_user.vm
<html>
<head>
    <title>用户添加</title>
    <link rel="stylesheet" href="/css/main.css">
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
</head>
<body>
<div id="global">
    <fieldset>
        <legend>Add a User</legend>
        <form action="/mvc/add_user.do" method="post">
            <p>
                <label for="name">username: </label>
                <input type="text" name="name" tabindex="1">
            </p>
 
            <p>
                <label for="birthday">birthday: </label>
                <input type="text" name="birthday" tabindex="2"/>
            </p>
 
            <p>
                <label for="sex">sex: </label>
                <select name="sex" tabindex="3">
                    <option value="1">男</option>
                    <option value="2">女</option>
                </select>
            </p>
            <p>
                <label form="address">address: </label>
                <input type="text" name="address" tabindex="4">
            </p>
            <p id="buttons">
                <input type="reset" tabindex="5">
                <input type="submit" tabindex="6" value="Add User">
            </p>
        </form>
    </fieldset>
</div>
</body>
</html>

  • Controller
@RequestMapping("/add_user.do")
public String addUser(User user){
    service.addUser(user);
    return "redirect: users.do";
}
  • Service/DAO实现简单,不再赘述.

请求参数解析

在传统的Servlet编程中, 可以使用HttpServletRequest的getParameter()方法来获取请求参数值, 而在Spring MVC中, 它会调用请求参数解析组件将客户端传过来的String字符串解析为指定的Java对象并传递给Controller, 这个过程称为请求参数解析.

Spring MVC默认提供了很多参数解析组件, 因此Controller的请求处理方法默认就可以接收很多不同类型:

JavaEE JavaSE Spring
ServletRequest /HttpServletRequest InputStream / Reader WebRequest / NativeWebRequest
ServletResponse /HttpServletResponse OutputStream / Writer Model / ModelMap
HttpSession 命令或表单对象 (如String / Integer /User) RedirectAttributes
HttpEntity<?> Array / List / Map Errors / BindingResult
  带@PathVariable / @MatrixVariable注解的对象 @RequestParam / @RequestHeader / @RequestBody /@RequestPart
  Principal / Locale SessionStatus
    UriComponentsBuilder

注:
1. 如果Controller形参名与URI中name不一致, 可使用@RequestParam注解对其进行修饰.
2. Spring MVC还支持路径变量映射(路径变量类似于请求参数, 但没有key部分, 只是一个值, 详细可参考博客Spring MVC URL 路径映射).

ModelAttribute

Spring MVC会在每次调用请求处理方法时都创建一个Model对象, 若打算使用该实例, 则可以在方法的形参添加一个Model形参. 其实还可以使用@ModelAttribute注解来访问Model实例: 使用@ModelAttribute注解标注参数或方法,该方法会将其输入的或创建的参数对象添加到Model对象中:

  • @ModelAttribute标注形参
@RequestMapping("/check_id.do")
public String checkId(@ModelAttribute("id") String id, Model model){
    return "check_id";
}

String实例将以id做key添加到Model对象中(如果key未命名,则默认使用类型的名称(如string)做key).

  • @ModelAttribute标注方法
    @ModelAttribute的第二个用途是标注一个非请求处理方法: 被@ModelAttribute标注的方法会在每次调用Controller的请求处理方法时调用.该方法可以返回对象或void:

如果返回对象, 该对象会自动添加到Model中:

@ModelAttribute
private List<User> addUser() {
    return service.getAllUsers();
}

若返回 void , 则必须添加一个 Model 类型参数, 自行将实例添加到 Model 中: 

@ModelAttribute
private void addUser(Model model) {
    model.addAttribute("users", service.getAllUsers());
}

重定向与Flash属性

使用重定向的一个重要场景是避免用户重新加载页面再次调用相同动作. 比如add_user.do: 当用户提交表单时会将用户信息插入数据库. 但如果在提交表单后重新加载页面, add_user.do会被再次调用, 相同的用户可能会被再次添加.为了避免这种情况, 最好的办法是在提交表单后将用户重定向到一个不同的页面,这个页面任意重新加载都没有副作用.

但使用重定向的一个不便之处在于: 无法轻松的给目标页面传值. 如果采用转发, 可属性添加到Model, 使得目标视图可以轻松访问. 但用户重定向需要经过客户端, 所以Model的一切内容都会在重定向中丢失. 幸运的是, 在Spring 3.1之后,可以通过Flash属性提供重定向传值的方法:

要使用Flash属性, 必须要有<annotation-driven/>注解驱动支持, 然后在方法上添加一个新的参数类型RedirectAttributes:

@RequestMapping("/add_user.do")
public String addUser(User user, RedirectAttributes attributes){
    service.addUser(user);
    attributes.addAttribute("message", "new user has been saved to DB.");
    return "redirect: /views/message.vm";
}

Controller返回值

应用了@Controller与@RequestMapping注解之后,Controller不再需要implements特定的接口, 因此Controller的返回值也变得多种多样:

返回值 描述
ModelAndView 包含视图名与Model数据
Model  
Map 包含模型的属性
View  
String 代表逻辑视图名
void 可以在参数中传入request/response完成对参数的解析, 对客户端的响应
HttpEntity/ResponseEntity 提供对Servlet的访问, 以响应HTTP头部和内容
Callable  
DeferredResult  
其他任意类型 常与响应JSON/XML结合

原文链接：http://www.importnew.com/20774.html

收录于
Java

当前文章被收录于：

Java
80 篇文章 2 人学习
订阅专栏 查看详情
Java 网络编程

当前文章被收录于：

Java 网络编程
7 篇文章 0 人学习
订阅专栏 查看详情
标签
#spring #mvc #spring mvc #web应用 #设计模式
Spring MVC 的设计模式最佳实践 虽然 Spring MVC 框架本身实现了 MVC 和前端控制器 (Front Controller) 等模式，但在实际应用开发中，如何在其提供的基础上，结合其他设计模式和最佳实践来组织代码，构建出可维护、可测试、可扩展的应用，是至关重要的。本指南将深入探讨 Spring MVC 开发中的一些核心设计模式和最佳实践。理解并应用这些模式，能够帮助您构建出职责清晰、高度解耦、易于测试、易于维护和可扩展的 Spring MVC 应用，从而更好地应对现代 Web 应用开发特别是微服务架构带来的挑战。 阅读详情

相关推荐

Spring MVC与JSP集成项目实践指南.zip

Spring MVC是Spring框架中用于Web应用程序开发的一部分，它遵循MVC（Model-View-Controller）设计模式。这种设计模式将应用程序分为三个核心组件，有助于分离关注点，提高系统的可维护性和扩展性。Spring Web MVC 4.2.5.RELEASE，作为Spring Framework中的MVC组件的一个版本，为开发者提供了丰富的特性，以此来简化Web应用的开发。该版本主要特性包括：响应式编程支持：对响应式编程模型的增强，允许开发者构建异步、非阻塞的应用程序。

weixin_42351520的博客 1065

Spring MVC 实践 - Base

Spring MVC 实践 标签 ： Java与Web Spring Web MVC Spring-Web-MVC是一种基于请求驱动的轻量级Web-MVC设计模式框架, Spring MVC使用MVC架构思想, 对Web层进行职责解耦,使用请求-响应模型将数据、业务与视图进行分离, 简化开发. MVC MVC(模型-视图-控制器)是一个以设计界面应用程序为基础的架构模式,...

dawuafang 225

SLF4J、Logback、Spring MVC、Maven集成实践案例

SLF4J，即简单日志门面（Simple Logging Facade for Java），是一个抽象层，允许最终用户在后台实现不同的日志框架。它本身不提供日志记录的功能，而是提供了一组统一的日志接口，使得开发者可以在运行时将这些接口绑定到具体的日志系统上。如果Logback提供的标准组件不足以满足特定需求，开发者可以创建自定义的Appender、Layout或者过滤器等组件。通过继承类，LayoutBase类，或者实现Filter接口，开发者可以实现自己的日志组件。

weixin_33480380的博客 1161

springmvc详解

原文 目录 P1、前言 1、回顾MVC 1.1、什么是MVC 1.2、Model1时代 1.3、Model2时代 1.4、回顾Servlet 2、什么是SpringMVC 2.1、概述 2.2、中心控制器 2.3、SpringMVC执行原理 P2、第一个MVC程序 1、 配置版 2、 注解版 3、小结 P3、RestFul和控制器 1、控制器Controller 2、实现Controller接口 3、使用注解@Controller 4、RequestMapping 5、

ss810540895的博客 2万+

Spring MVC与Hibernate综合开发实践

本文还有配套的精品资源，点击获取 简介：Spring MVC和Hibernate是Java开发中广泛使用的两个框架，本压缩包包含Spring MVC的jar包及Hibernate 3.6.8版本的相关资料，旨在为开发者提供完整的Web应用开发解决方案。通过理解Spring MVC的MVC架构及其组件，学习注解驱动开发和AOP集成，同时掌握Hibernate的ORM映射、数据...

weixin_35752233的博客 1433

basemvc:基础MVC

basemvc Base MVC Web应用是资源密集型的，最好只使用必要的代码而丢掉其他多余部分 简介： 使用过 JavaScript框架（如 AngularJS, Backbone 或者Ember ）的人都很熟悉在UI（用户界面，前端）中mvc的工作机理。这些框架实现了MVC，使得在一个单页面中实现根据需要变化视图时更加轻松，而模型-视图-控制器（mvc）的核心概念就是：处理传入请求的控制器、显示信息的视图、表示业务规则和数据访问的模型 概念： 　　应用中的代码利用urls中的“#”实现MVC模式的导航。应用以一个缺省的url开始，基于哈希值的代码加载应用视图并且将对象-模型应用于视图模板。 　　url格式像下面这样： 　　 Name/index.html#/Route Name 　　视图内容必须以{{Property-Name}}的方式绑定对象模型的值和属性。代码会查找这个专门的模板

【框架篇】Spring MVC 介绍及使用（详细教程）

Spring MVC是Spring框架提供的基于MVC架构并继承了Servlet API的Web开发框架。它遵循MVC模式的原则，提供了一套完整的开发流程和特性。通过Spring框架的支持，它能够实现灵活性、可配置性和可扩展性，帮助开发者构建高性能的Web应用程序。

小杨的博客 6万+

深入排查127.0.0.1拒绝连接：从端口占用到Tomcat服务启动的完整解决方案

本文针对开发者访问127.0.0.1时遭遇“拒绝连接”的常见问题，提供了一套完整的排查与解决方案。文章从端口占用检查入手，详细讲解了使用netstat命令识别进程，并深入分析了服务监听地址、IPv6配置、防火墙以及Tomcat服务安装与启动等核心环节。通过实战演练，指导读者系统性地解决从网络层到应用层的各类连接问题，最终确保本地服务成功运行并可通过本地回环地址正常访问。

weixin_29279047的博客 3186

SpringMVC(看这一篇就够了)

MVC全称Model View Controller，是一种设计创建Web应用程序的模式。这三个单词分别代表Web应用程序的三个部分：Model（模型）：指数据模型。用于存储数据以及处理用户请求的业务逻辑。在Web应用中，JavaBean对象，业务模型等都属于Model。View（视图）：用于展示模型中的数据的，一般为jsp或html文件。Controller（控制器）：是应用程序中处理用户交互的部分。接受视图提出的请求，将数据交给模型处理，并将处理后的结果交给视图显示。 SpringMVC是一个基于MVC

m0_74436895的博客 3万+

VisualStudio2022配置CGAL

vs2022和vs2017安装配置boost没什么区别，只需要注意boost的msvc得是14.3的，这玩意跟visualstudio版本挂钩的。压缩包解压，得到下面这两文件，然后把auxiliary这个文件挪到CGAL-5.6里面就行了。我用cgal读取一个stl模型，并输出相关信息（想可视化的话需要安装Qt，不想装Qt也可以装VTK）然后下载下面这两个压缩包。照着下面的截图填就完事了。

weixin_43850909的博客 1171

小米万兆路由器里的Docker安装可道云(Kodexplorer)私有网盘

小米2022年12月份发布了万兆路由器，里面可以使用Docker。 今天尝试在小米的万兆路由器里安装[可道云](http://kodcloud.com/)(Kodexplorer)私有网盘。

engchina的专栏 1万+

[Spring]MVC基本介绍与实践

JavaEE开发框架-SpringMVC 文章目录JavaEE开发框架-SpringMVC概述应用导包配置中央控制器创建配置文件参数控制器SpringMVC基于注解开发参数接收返回数据给视图Ajax调用SpringMVC的方法重定向 概述 srpingmvc功能 Controller为中心完成对系统流程的控制管理 从请求中搜集数据 对传入的参数进行验证 将结果返回给视图 针对不...

JunsIr的技术栈 830

Android 10.0 任务栏音乐播放器后台播放杀进程功能实现

在10.0的系统rom定制化开发过程中，在某些情况下在安装第三方播放器以后，播放音乐的时候，在最近任务栏recents列表中，点击全部清除，发现音乐播放器还在播放音乐，导致出现bug，完整的 解决方法，肯定是需要点击全部清除以后，音乐播放器也被杀掉进程,接下来看下这个问题怎么解决

安卓兼职framework和app工程师的博客 652

Spring MVC 的的核心原理与实践指南

通过其清晰的架构和丰富的功能集，开发者可以快速构建从简单到复杂的企业级应用。Spring MVC 是 Spring 框架中的一个重要模块，用于构建基于 Java 的 Web 应用程序。它遵循模型-视图-控制器（MVC）设计模式，提供了一种结构化的方式来开发灵活、松耦合的 Web 应用。随着 Spring Boot 的普及，Spring MVC 的开发变得更加简单高效，但底层原理仍然不变。无论是传统的 Web 应用还是现代的 RESTful 服务，Spring MVC 都是一个值得信赖的选择。

2301_81564787的博客 1062

3dmax文件格式转换——.max 转换为 .flt（解决转换后.flt没有纹理贴图的问题）

本文主要介绍如何在3dmax中将.max格式文件转换为.flt格式文件，并解决转换后的文件没有纹理贴图的问题。 在3dmax中，将.max文件转换为.flt格式，只需导出选择.flt格式即可，但是导出的文件在osgEarth中加载后，缺少纹理和贴图。 下面是解决方案： 1、选中加载的模型，然后点击 渲染-> 渲染到纹理 2、将 渲染到纹理 子窗口往下拉，点击 添加 按钮，添加 ...

cchangcs 6168

rk3568 Android12 增加 USB HOST 模式开关(二)

将原有 USB-C 改为 USB-A，并在设置中增加USB工作模式开关可以让用户选择USB端口的功能模式，例如充电、文件传输、或MIDI设备。用户能够灵活管理设备的连接方式，优化数据传输和设备兼容性。

weixin_35723192的博客 734

Spring MVC开发实践教程

在当今快速发展的Web应用开发领域，Spring MVC作为Spring框架的核心模块，已经成为Java企业级开发的事实标准。它以其清晰的架构设计、强大的功能和灵活的扩展性，帮助开发者构建高效、可维护的Web应用程序。log.info("请求开始: {} {}", request.getMethod(), request.getRequestURI());记住，优秀的代码不仅仅是能运行的代码，更是可维护、可扩展、高效的代码。Spring MVC为你提供了实现这一目标的强大工具，剩下的就是你的实践和创造了。

wnhnkj_121的博客 241

各大厂薪资对比爬虫：Python采集OfferShow爆料数据

print(f"⚠️ API返回错误码: {data.get('code')}, msg: {data.get('msg')}")ax.set_title('各大厂薪资对比 (基于OfferShow爆料数据)', fontsize=16, fontweight='bold')stats.columns = ['人数', '平均年薪', '年薪中位数', '年薪标准差', '平均月薪', '平均月数']print(analyzer.get_position_stats('字节跳动').head(10))

2201_76125261的博客 603

深入解析 Spring MVC：架构、组件与最佳实践

Spring MVC 是 Spring 框架的一部分，专门用于构建 Web 应用程序。它遵循模型-视图-控制器（MVC）设计模式，使得开发 Java Web 应用更加简单和高效。Spring MVC 不仅提供了丰富的功能，还能够很好地与其他 Spring 模块集成，使其成为企业级应用开发的首选框架之一。

2301_77163982的博客 2819

FISCO BCOS 系列（一）—— 搭建第一个区块链网络&配置控制台指南

本文详细介绍了FISCO BCOS区块链网络的搭建与配置过程，包括环境准备、单机四节点网络搭建、控制台配置使用等核心内容。从系统要求、依赖安装开始，逐步指导如何通过脚本快速搭建区块链网络，配置控制台连接，并演示了账户管理、合约部署调用等基础操作。同时提供了多节点网络配置、常见问题解决方案以及生产环境安全建议，为开发者提供了从入门到进阶的完整指南。

分享AI、区块链技术及应用，未来已来 809

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的，已经排好版了，而且还是完整的，适合小白

Spring MVC开发实践

作为Java EE体系中最经典的Web框架之一，Spring MVC以其优雅的设计哲学和强大的功能特性，成为众多企业级应用的首选解决方案。本文将深入探讨Spring MVC的核心架构、开发实践中的关键技巧，以及如何通过最佳实践构建高效、可维护的Web应用。随着Spring Boot的兴起，Spring MVC的配置变得更加简单，但背后的设计哲学和最佳实践依然值得我们深入研究和实践。同时，结合Spring的验证框架，我们可以轻松实现请求参数的自动验证，确保数据的完整性和安全性。

cjppbt_425的博客 219

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能：商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传，基本资料下载，开钱箱、小票打印、收款结算，支持多币种付款方式（现金、储值卡、礼券、微信等）,支持多种促销。运行环境：.net 4.0登陆信息用户名:1001 密码:123456内置商品信息，商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

Spring MVC：深入理解与应用实践

Spring MVC是Spring框架提供的一个用于构建Web应用程序的Model-View-Controller（MVC）实现。它通过分离业务逻辑、数据、显示来组织代码，使得Web应用程序的开发变得更加简洁和高效。本文将从概述、功能点、背景、业务点、底层原理等多个方面深入剖析Spring MVC，并通过多个Java示例展示其应用实践，同时指出对应实践的优缺点。Spring MVC是Spring框架提供的一个基于Servlet的Web框架，它实现了MVC设计模式。

喜欢猪猪 1853

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章，有部分习题没有答案，全英文复分析阿尔福斯(Ahlfors) 第三版答案

Spring Web MVC入门指南：从Servlet到SpringBoot实践

Tomcat作为Servlet容器，为Java Web应用提供运行时环境。其webapps目录存放部署项目，每个请求会由对应Servlet处理。实际体验中发现，其智能代码补全对注解参数提示特别友好，适合新手快速掌握@RequestParam等复杂属性的使用场景。@RestController：组合@Controller+@ResponseBody。文件上传：@RequestPart处理multipart数据。返回结果自动序列化（@ResponseBody）destroy()释放资源。

ThunderstormDragon65的博客 381
上一篇： 用Java编写CGI小结
下一篇： Swing程序最佳架构设计—以业务对象为中心的MVC模式
点赞 0
评论 0
书签 书签 0
混魔MJM
混魔MJM
博客等级 码龄9年 57粉丝 0原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值