一个简单的SpringMVC例子

合集下载

SpringMVC+Spring+Hibernate框架整合原理,作用及使用方法

SpringMVC+Spring+Hibernate框架整合原理,作⽤及使⽤⽅法SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层，controller层，service层，DAO层四层使⽤spring MVC负责请求的转发和视图管理spring实现业务对象管理，mybatis作为数据对象的持久化引擎原理：SpringMVC：1.客户端发送请求到DispacherServlet（分发器）2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller3.Controller调⽤业务逻辑处理后，返回ModelAndView4.DispacherSerclet查询视图解析器，找到ModelAndView指定的视图5.视图负责将结果显⽰到客户端Spring：我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们中的类，当然也包括service dao⾥⾯的），有了这个机制，我们就不⽤在每次使⽤这个类的时候为它初始化，很少看到关键字new。

另外spring的aop，事务管理等等都是我们经常⽤到的。

Mybatis：mybatis是对jdbc的封装，它让数据库底层操作变的透明。

mybatis的操作都是围绕⼀个sqlSessionFactory实例展开的。

mybatis通过配置⽂件关联到各实体类的Mapper⽂件，Mapper⽂件中配置了每个类对数据库所需进⾏的sql语句映射。

在每次与数据库交互时，通过sqlSessionFactory拿到⼀个sqlSession，再执⾏sql命令。

使⽤⽅法：要完成⼀个功能：1. 先写实体类entity，定义对象的属性，（可以参照数据库中表的字段来设置，数据库的设计应该在所有编码开始之前）。

2. 写Mapper.xml（Mybatis），其中定义你的功能，对应要对数据库进⾏的那些操作，⽐如 insert、selectAll、selectByKey、delete、update等。

spring MVC原理及配置

spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述：springmvc就是spring提供更多的一个强悍而有效率的web框架。

借助注释，springmvc提供更多了几乎就是pojo的研发模式，使控制器的研发和测试更加直观。

这些控制器通常不轻易处置命令，而是将其委托给spring上下文中的其他bean，通过spring的倚赖转化成功能，这些bean被转化成至控制器中。

springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。

他的两个核心是两个核心：处理器映射：选择使用哪个控制器来处理请求视图解析器：选择结果应该如何渲染通过以上两点，springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。

2.springmvc运行原理这里写图片描述(2)找寻处理器：由dispatcherservlet控制器查阅一个或多个handlermapping，找出处置命令的controller。

(3)调用处理器：dispatcherservlet将请求提交到controller。

(4)(5)调用业务处置和回到结果：controller调用业务逻辑处置后，回到modelandview。

3.springmvc接口解释（1）dispatcherservlet接口：spring提供的前端控制器，所有的请求都有经过它来统一分发。

在dispatcherservlet将请求分发给springcontroller 之前，需要借助于spring提供的handlermapping定位到具体的controller。

（2）handlermappingUSB：能够完成客户请求到controller映射。

（3）controller接口：须要为mammalian用户处置上述命令，因此同时实现controllerUSB时，必须确保线程安全并且可以器重。

Spring 3.0注解开发的简单例子(@Service) -

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import java.util.Collection;
在 ② 处，配置了一个 AnnotationMethodHandlerAdapter，它负责根据 Bean 中的 Spring MVC 注解对 Bean 进行加工处理，使这些 Bean 变成控制器并映射特定的 URL 请求。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
来看一下基于注解的 Controller 是如何定义做到这一点的，下面是使用注解的 BbtForumController：
清单 1. BbtForumController.java
package com.baobaotao.otao.service.BbtForumService;
<bean class="org.springframework.web.servlet.mvc.annotation.
AnnotationMethodHandlerAdapter"/>

Spring MVC 简明教程

Spring框架从创建伊始就致力于为复杂问题提供强大的、非侵入性的解决方案。

Spring 2.0当中为缩减XML配置文件数量引入定制命名空间功能，从此它便深深植根于核心Spring框架（aop、context、jee、jms、 lang、tx和util命名空间）、Spring Portfolio项目（例如Spring Security）和非Spring项目中（例如CXF）。

Spring 2.5推出了一整套注解，作为基于XML的配置的替换方案。

注解可用于Spring管理对象的自动发现、依赖注入、生命周期方法、Web层配置和单元/集成测试。

探索Spring 2.5中引入的注解技术系列文章由三部分组成，本文是其中的第二篇，它主要讲述了Web层中的注解支持。

最后一篇文章将着重介绍可用于集成和测试的其它特性。

这个系列文章的第一部分论述了Java注解（annotation）是如何代替XML来配置Spring管理对象和依赖注入的。

我们再用一个例子回顾一下：@Controllerpublic class ClinicController {private final Clinic clinic;@Autowiredpublic ClinicController(Clinic clinic) {this.clinic = clinic;}...@Controller表明ClinicController是Web层组件，@Autowired请求一个被依赖注入的Clinic实例。

这个例子只需要少量的XML语句就能使容器识别两个注解，并限定组件的扫描范围：<context:component-scanbase-package="org.springframework.samples.petclinic"/>这对Web层可谓是个福音，因为在这层Spring的XML配置文件已日益臃肿，甚至可能还不如层下的配置来得有用。

MVC架构模式实例

MVC架构模式实例⼀、简介什么是MVC呢？MVC架构模式，也就是Model View Controller模式。

它是⼀种软件设计典范，⽤⼀种业务逻辑、数据、界⾯显⽰分离的⽅法组织代码，将业务逻辑聚集到⼀个部件⾥⾯，在改进和个性化定制界⾯及⽤户交互的同时，不需要重新编写业务逻辑。

MVC被独特的发展起来⽤于映射传统的输⼊、处理和输出功能在⼀个逻辑的图形化⽤户界⾯的结构中。

说起来好像是很复杂，但是我对它的理解也就是各⾃处理⾃⼰的任务。

模型:负责封装并实现应⽤的具体功能。

可以实现系统中的业务逻辑，通常可以⽤JavaBean来实现。

视图:⽤于与⽤户的交互。

⽤来将模型的内容展现给⽤户。

⽤户可以通过视图来请求模型进⾏更新。

视图从模型获得要展⽰的数据，然后⽤⾃⼰的⽅式展⽰给⽤户，相当于提供页⾯来与⽤户进⾏⼈机交互。

⽐如⽤户在登陆注册界⾯完成信息的填报后点击确定，由此来向控制器发出这个请求。

控制器:是Model与View之间沟通的桥梁。

⽤来控制应⽤程序的流程和处理视图所发出的请求。

当控制器接收到⽤户的请求后，会将⽤户的数据和模型相映射，也就是调⽤模型来实现⽤户请求的功能。

然后控制器会选择⽤于响应的视图，把模型更新后的数据展⽰给⽤户。

MVC模式的这三个部分的职责⾮常明确，⽽且相互分离，因此每个部分都可以独⽴地改变⽽不影响其他部分，从⽽⼤⼤提⾼应⽤的灵活性和重⽤性。

⼆、⽬的使⽤MVC的⽬的是将Model和View实现代码分离，也就是前台html表现层和后台php逻辑层分离。

这样做便于开发，代码优化，界⾯交互性好。

归根结底，其⽬的就是便宜项⽬开发。

三、特点 MVC重要特点就是两种分离：1.视图和数据模型的分离：使⽤不同的视图对相同的数据进⾏展⽰；分离可视和不可视的组件，能够对模型进⾏独⽴测试。

因为分离了可视组件减少了外部依赖利于测试。

（数据库也是⼀种外部组件）2.视图和表现逻辑(Controller)的分离：Controller是⼀个表现逻辑的组件，并⾮⼀个业务逻辑组件。

Spring Mvc 课件

强大而直接的配置方式：将框架类和应用程序类都能作为JavaBean配置，支持跨多个context的引用，例如(lìrú) ，在web控制器中对业务对象和验证器（validator）的引用。
可适配、非侵入：可以根据不同的应用场景，选择合适的控制器子类（simple型、command型、form型、wizard 型、multi-action型或者自定义），而不是从单一控制器（比如Action/ActionForm）继承。
业务模型还有一个很重要的模型那就是数据模型。数据模型主要指实体对象的数据保存（持续化）。比如将一张订单保存到数据库，从数据库获取订单。我们可以将这个模型单独列出，所有有关数据库的操作只限制在该模型中。
第六页，共62页。
MVC设计(shèjì)思想
控制(Controller)可以理解为从用户接收请求, 将模型与视图匹配在一起，共同完成用户的请求。划分控制层的作用也很明显，它清楚地告诉你，它就是一个(yī ɡè)分发器，选择什么样的模型，选择什么样的视图，可以完成什么样的用户请求。控制层并不做任何的数据处理。
❖ 如果不作其它配置，会加载默认(mòrèn)组件
第二十一页，共62页。
在web.xml配DispatcherServlet
web.xml
…
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
第十五页，共62页。
Spring MVC 特点(tèdiǎn)
可定制的本地化和主题（theme）解析：支持在JSP中可选择地使用Spring标签库、支持JSTL、支持Velocity（不需要 (xūyào)额外的中间层）等等。

springMVC例子

同Struts 2框架一样，Spring也可以给Web开发者提供一个MVC框架。

虽然Web框架只是Spring的一个模块，但是它却应用的非常广泛。

本章结合实例分析Spring Web框架的使用方法、各个组件的作用通过本章的学习，相信读者会对如何使用Spring进行MVC开发有很深入的了解。

第一个Spring MVC例子【示例】该示例先讲解如何在Eclipse环境下实现Spring MVC框架，然后讲解如何在Ant环境下实现。

在Eclipse中创建一个工程SpringMVC，然后按照下面的步骤添加文件。

1配置web.xml文件在Spring MVC的WEB-INF目录下创建web.xml。

在使用Struts 2时，需要在web.xml文件配置FilterDispatcher，在使用Spring的MVC框架时，也需要配置web.xml文件，代码如下。

<?xml version="1.0" encoding="UTF-8"?><web-app version="2.4"xmlns="/xml/ns/j2ee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/j2ee/xml/ns/j2ee/web-app_2_4.xsd"><servlet><servlet-name>dispatcherServlet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class></servlet><servlet-mapping><servlet-name>dispatcherServlet</servlet-name><url-pattern>*.do</url-pattern></servlet-mapping></web-app>上面的代码对DispatcherServlet类进行配置，所有后缀名为.do的请求都会被DispatcherServlet处理。

SpringMVC使用ModelAndView进行重定向

SpringMVC使⽤ModelAndView进⾏重定向1、Servlet重定向forward与redirect：使⽤servlet重定向有两种⽅式，⼀种是forward，另⼀种就是redirect。

forward是服务器内部重定向，客户端并不知道服务器把你当前请求重定向到哪⾥去了，地址栏的url与你之前访问的url保持不变。

redirect则是客户端重定向，是服务器将你当前请求返回，然后给个状态标⽰给你，告诉你应该去重新请求另外⼀个url，具体表现就是地址栏的url变成了新的url。

2、ModelAndView重定向：使⽤Spring MVC通常是使⽤ModelAndView⽤来返回视图。

ModelAndView其实也是⽀持Servlet中的两种重定向⽅式。

⽐如404页⾯我们⼀般采⽤redirect重定向⽅式，像下⾯的代码就是redirect重定向：public ModelAndView getPage404MV() {ModelAndView mv = new ModelAndView("redirect:/404.htm");return mv;}要使⽤forward重定向就只需把redirect换成forward即可，特别的ModelAndView默认使⽤forward重定向⽅式。

1. 需求背景需求：spring MVC框架controller间跳转，需重定向。

有⼏种情况：不带参数跳转，带参数拼接url形式跳转，带参数不拼接参数跳转，页⾯也能显⽰。

本来以为挺简单的⼀件事情，并且个⼈认为⽐较常⽤的⼀种⽅式，⼀百度全都有了，这些根本不是问题，但是⼀百度居然出乎我的意料，⼀堆都不是我想要的结果。

⽆奈啊，⾃⼰写⼀篇⽐较全都供以后⼤家⼀百度吧，哈哈哈。

是这些写的不是很全都⼈们给了我写这篇博客的动⼒。

2. 解决办法需求有了肯定是解决办法了，⼀⼀解决，说明下spring的跳转⽅式很多很多，我这⾥只是说⼀些⾃我认为好⽤的，常⽤的，spring分装的⼀些类和⽅法。

spring mvc注解实例

本文主要介绍使用注解方式配置的spring mvc，包括数据访问层的实现web.xml配置：<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance" xmlns="http:// /xml/ns/javaee" xmlns:web="/xml/ns/javaee/web-ap p_2_5.xsd" xsi:schemaLocation="/xml/ns/javaee http://java.su /xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"><display-name>s3h3</display-name><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext*.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</l istener-class></listener><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servle t-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>spring</servlet-name> <url-pattern>*.do</url-pattern></servlet-mapping><welcome-file-list><welcome-file>index.jsp</welcome-file></welcome-file-list></web-app>spring-servlet,主要配置controller的信息<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="http:// /schema/p"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans http://www. /schema/beans/spring-beans-3.0.xsd/schema/aop http://www.springframework.o rg/schema/aop/spring-aop-3.0.xsd/schema/tx http://www.springframework.or g/schema/tx/spring-tx-3.0.xsd/schema/context http://www.springframewo /schema/context/spring-context-3.0.xsd"><context:annotation-config /><context:component-scan base-package="com.mvc.controller"/> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationM ethodHandlerAdapter"/><bean class="org.springframework.web.servlet.view.InternalResourceView Resolver"p:prefix="/WEB-INF/view/" p:suffix=".jsp"/><bean id="multipartResolver"class="monsMultipartRe solver"p:defaultEncoding="utf-8"/></beans>applicationContext.xml代码<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:aop="/schema/aop" xmlns:context="http:// /schema/context"xmlns:p="/schema/p" xmlns:tx="http://www.sprin /schema/tx"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans http://www.springframewo /schema/beans/spring-beans-3.0.xsd/schema/context http://www.springframework.o rg/schema/context/spring-context-3.0.xsd/schema/aop /s chema/aop/spring-aop-3.0.xsd/schema/tx /sc hema/tx/spring-tx-3.0.xsd"><context:annotation-config /><context:component-scan base-package="com.mvc"/><context:property-placeholder location="classpath:/hibernate.properties "/><bean id="sessionFactory"class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFacto ryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties"><props><prop key="hibernate.dialect">${dataSource.dialect}</prop><prop key="hibernate.hbm2ddl.auto">${dataSource.hbm2ddl.auto}</prop><prop key="hibernate.hbm2ddl.auto">update</prop></props></property><property name="packagesToScan"><list><value>com.mvc.entity</value></list></property></bean><bean id="transactionManager"class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/><property name="dataSource" ref="dataSource"/></bean><bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="${dataSource.driverClassName} "/><property name="url" value="${dataSource.url}"/><property name="username" value="${ername}"/><property name="password" value="${dataSource.password}"/></bean><bean id="entityDao" class="com.mvc.dao.EntityDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean><tx:annotation-driven transaction-manager="transactionManager"/><tx:annotation-driven mode="aspectj"/><aop:aspectj-autoproxy/></beans>hibernate.properties数据库连接配置dataSource.password=123ername=rootdataSource.databaseName=testdataSource.driverClassName=com.mysql.jdbc.DriverdataSource.dialect=org.hibernate.dialect.MySQL5DialectdataSource.serverName=localhost:3306dataSource.url=jdbc:mysql://localhost:3306/testdataSource.properties=user=${ername};databaseName=${dataSource.d atabaseName};serverName=${dataSource.serverName};password=${dataSource.passwor d}dataSource.hbm2ddl.auto=update配置已经完成，下面开始例子先在数据库建表，例子用的是mysql数据库CREATE TABLE `test`.`student` (`id` int(10) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(45) NOT NULL,`psw` varchar(45) NOT NULL,PRIMARY KEY (`id`))建好表后，生成实体类package com.mvc.entity;import java.io.Serializable;import javax.persistence.Basic;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.Table;@Entity@Table(name = "student")public class Student implements Serializable {private static final long serialVersionUID = 1L;@Id@Basic(optional = false)@GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id", nullable = false)private Integer id;@Column(name = "name")private String user;@Column(name = "psw")private String psw;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getUser() {return user;}public void setUser(String user) {er = user;}public String getPsw() {return psw;}public void setPsw(String psw) {this.psw = psw;}}Dao层实现package com.mvc.dao;import java.util.List;public interface EntityDao {public List<Object> createQuery(final String queryString);public Object save(final Object model);public void update(final Object model);public void delete(final Object model);}package com.mvc.dao;import java.util.List;import org.hibernate.Query;import org.springframework.orm.hibernate3.HibernateCallback;import org.springframework.orm.hibernate3.support.HibernateDaoSupport;public class EntityDaoImpl extends HibernateDaoSupport implements EntityDao {public List<Object> createQuery(final String queryString) { return (List<Object>) getHibernateTemplate().execute(new HibernateCallback<Object>() {public Object doInHibernate(org.hibernate.Session sessio n)throws org.hibernate.HibernateException {Query query = session.createQuery(queryString);List<Object> rows = query.list();return rows;}});}public Object save(final Object model) {return getHibernateTemplate().execute(new HibernateCallback<Object>() {public Object doInHibernate(org.hibernate.Session sessio n)throws org.hibernate.HibernateException {session.save(model);return null;}});}public void update(final Object model) {getHibernateTemplate().execute(new HibernateCallback<Object>() { public Object doInHibernate(org.hibernate.Session session)throws org.hibernate.HibernateException {session.update(model);return null;}});}public void delete(final Object model) {getHibernateTemplate().execute(new HibernateCallback<Object>() { public Object doInHibernate(org.hibernate.Session session)throws org.hibernate.HibernateException {session.delete(model);return null;}});}}Dao在applicationContext.xml注入<bean id="entityDao" class="com.mvc.dao.EntityDaoImpl"><property name="sessionFactory" ref="sessionFactory"/></bean>Dao只有一个类的实现，直接供其它service层调用，如果你想更换为其它的Dao实现，也只需修改这里的配置就行了。

java中handlerinterceptor实现

java中handlerinterceptor实现在Java开发中，HandlerInterceptor是一个非常重要的概念。

它可以拦截Spring MVC中的请求和响应，允许我们在请求处理之前和之后执行特定的操作。

在本文中，我们将深入探讨如何使用HandlerInterceptor来实现请求拦截和处理。

一、什么是HandlerInterceptor？HandlerInterceptor是Spring MVC提供的一个接口，用于在请求处理前、请求处理后和请求完成后进行一些额外的处理工作。

它包含了三个方法：1. preHandle()：在请求处理前执行，返回true则继续执行后续操作，返回false则终止请求。

2. postHandle()：在请求处理后执行，但在视图被渲染之前执行。

3. afterCompletion()：在整个请求完成后执行，包括视图渲染完成。

通过实现HandlerInterceptor接口，我们可以根据需要在请求处理的不同阶段执行特定的操作，例如记录请求日志、权限验证等。

二、如何实现HandlerInterceptor？要实现HandlerInterceptor，我们需要先创建一个实现了HandlerInterceptor接口的类。

以下是一个简单的示例：javapublic class MyInterceptor implements HandlerInterceptor {Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 在处理请求前执行的操作return true;}Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {在处理请求后执行的操作}Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {在请求完成后执行的操作}}在上面的示例中，我们可以根据需要实现preHandle()、postHandle()和afterCompletion()方法来执行相应的操作。

springMVC配置（XML配置详解）

springMVC配置（XML配置详解）原⽂出⾃：web.xml配置：servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><description>加载/WEB-INF/spring-mvc/⽬录下的所有XML作为Spring MVC的配置⽂件</description><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-mvc/*.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.htm</url-pattern></servlet-mapping>这样，所有的.htm的请求，都会被DispatcherServlet处理；初始化 DispatcherServlet 时，该框架在 web 应⽤程序WEB-INF ⽬录中寻找⼀个名为[servlet-名称]-servlet.xml的⽂件，并在那⾥定义相关的Beans，重写在全局中定义的任何Beans，像上⾯的web.xml中的代码，对应的是dispatcher-servlet.xml；当然也可以使⽤<init-param>元素，⼿动指定配置⽂件的路径；dispatcher-servlet.xml 配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><context:component-scan base-package="com.minx.crm.web.controller"/><bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver"p:prefix="/WEB-INF/jsp/"p:suffix=".jsp" /></beans>第⼀个Controller：package com.minx.crm.web.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class IndexController {@RequestMapping("/index")public String index() {return "index";}}@Controller注解标识⼀个控制器，@RequestMapping注解标记⼀个访问的路径（/index.htm），return "index"标记返回视图（index.jsp）；注：如果@RequestMapping注解在类级别上，则表⽰⼀相对路径，在⽅法级别上，则标记访问的路径；从@RequestMapping注解标记的访问路径中获取参数：Spring MVC ⽀持RESTful风格的URL参数，如：@Controllerpublic class IndexController {@RequestMapping("/index/{username}")public String index(@PathVariable("username") String username) {System.out.print(username);return "index";}}在@RequestMapping中定义访问页⾯的URL模版，使⽤{}传⼊页⾯参数，使⽤@PathVariable 获取传⼊参数，即可通过地址：http://localhost:8080/crm/index/tanqimin.htm 访问；根据不同的Web请求⽅法，映射到不同的处理⽅法：使⽤登陆页⾯作⽰例，定义两个⽅法分辨对使⽤GET请求和使⽤POST请求访问login.htm时的响应。

Spring简单实例

Spring 实例入门本文结合实例理解解容器，DI，IOC，耦合，解耦等Spring所涉及的概念，同时了解Spring 的最基本也是最核心的使用方法。

1．Spring容器Spring容器负责对象的实例化，对象生命周期的管理，被Spring管理的对象称之为Bean。

Spring默认使用单例的方式创建对象。

可以通过修改<bean>的配置改变成其它创建方式。

这个属性为Scope，称之为作用域或生命周期，它的值为singleton（单例，默认值），prototype2．注入方式有setter注入，构造注入方式，接口注入（不需掌握）。

建议多使用Setter注入方式。

Setter注入：Soldier类中有一个属性name，如何在创建Soldier的时候使name的值变为”RANBO”?配置如下：这样创建的Soldier对象的name属性就有值了，测试代码：构造注入：配置如下：测试结果同上。

3．依赖当A对象使用了B对象的方法，A对B产生依赖，称之为A依赖B。

下面的例子中Soldier当HandGun发生变化时，必然导致Soldier必须做相应修改，同时，当Soldier需要使用OtherGun时也必须重新编写代码，导致代码重用度不高。

当对象之间的依赖关系很强时（耦合），会使程序代码死板，不利于后期的维护和扩展。

降低对象之间的依赖关系称之为解耦。

Spring能够很好的解决这一问题。

4．控制反转（Inversion of Control,简称IOC）和依赖注入(Dependence Inject简称DI)我们运用Spring的setter注入方式解决HandGun和Soldier的耦合问题。

修改Soldier的代码，将HandGun定义为Soldier的属性并提供setter方法：package com.hb;/***士兵类*/public class Soldier {private HandGun handGun;public void setHandGun(HandGun handGun) {this.handGun = handGun;}/***打仗*/public void fight(){handGun.killEnemy();}}配置如下己去实例化HandGun了。

Spring3_MVC与Struts2.x比较

Spring MVCSpringMVC非常优秀的MVC框架, 由其是在3.0版本发布后, 现在有越来越多的团队选择了Spring3 MVC来作为MVC的框架.SpringMVC结构简单,灵活性较高,性能也很优秀。

核心类与接口:DispatcherServlet -- 前置控制器HandlerMapping接口-- 处理请求的映射HandlerMapping接口的实现类：SimpleUrlHandlerMapping 通过配置文件，把一个URL映射到Controller DefaultAnnotationHandlerMapping 通过注解，把一个URL映射到Controller类上HandlerAdapter接口-- 处理请求的映射AnnotationMethodHandlerAdapter类，通过注解，把一个URL映射到Controller类的方法上Controller接口-- 控制器由于我们使用了@Controller注解，添加了@Controller注解注解的类就可以担任控制器（Action）的职责,所以我们并没有用到这个接口。

HandlerInterceptor 接口--拦截器我们自己实现这个接口，来完成拦截的器的工作。

ViewResolver接口的实现类UrlBasedViewResolver类通过配置文件，把一个视图名交给到一个View来处理InternalResourceViewResolver类，比上面的类，加入了JSTL的支持View接口JstlView类LocalResolver接口HandlerExceptionResolver接口--异常处理SimpleMappingExceptionResolver实现类ModelAndView类核心流程图DispatcherServlet说明使用Spring MVC,配置DispatcherServlet是第一步。

DispatcherServlet是一个Servlet,所以可以配置多个DispatcherServlet。

MVC实例入门(经典推荐)

MVC实例入门初次学习 MVC，因此简单的记录一下自己的学习过程和经历，以便后面学习参考，同时也为后来者做出自己的一点点贡献。

第一步：创建一个新的MVC4项目。

打开VS2012，在“文件”菜单下选择“新建”下拉菜单下的“项目”，在弹出的“新建项目”对话框中选择[Web]选项卡，选择[ MVC 4 Web 应用程序]，在名称里输入：MyFirstMvcApplication，点击确定，即完成项目的新建。

在稍后弹出的“选择模板”中选择【基本】，然后点击确定，即完成一个MVC项目的创建。

如下图所示：默认情况下的项目结构如图所示：创建完成后，我们可以发现，新建项目的同时创建了一个与之同名的解决方案。

MVC默认情况下，在新建项目的同时创建一个解决方案。

开发者可以在解决方案中任意添加项目。

新建完成时，我们可以看到Controllers文件夹、Models文件夹下都是空的，什么也没有；Views文件夹下默认有个Shared文件夹。

MVC文件夹介绍可以参看《 MVC –经典入门教程(推荐阅读)》。

备注：所有MVC 应用程序中的文件夹名称都是相等的。

MVC 框架基于默认的命名。

控制器位于Controllers 文件夹，视图位于Views 文件夹，模型位于Models 文件夹。

您不必在应用程序代码中使用文件夹名称。

标准化的命名减少了代码量，同时有利于开发者对MVC 项目的理解。

下面是对每个文件夹内容的简要描述：1.App_Data 文件夹App_Data 文件夹用于存储应用程序数据。

我们将在本教程稍后的章节向App_Data 文件夹添加SQL 数据库。

2.Content 文件夹Content 文件夹用于静态文件，比如样式表（CSS 文件）、图表和图像。

Visual Web Developer 会自动向Content 文件夹添加一个 themes 文件夹。

这个themes 文件夹存放jQuery 样式和图片。

在这个项目中，您可以删除这个主题文件夹。

spring3.0MVC注解(附实例)

0.提示1) Spring发行版本附带了PetClinic 示例，它是一个在简单的表单处理的上下文中，利用了本节中说明的注解支持的Web应用程序。

可以在“samples/petclinic ”目录中找到PetClinic 应用程序。

2) 另外一个建立在基于注解的Web MVC上的示例应用程序，请见imagedb 。

这个示例集中在无状态的multi-action控制器，包括多段文件上传的处理。

可以在“samples/imagedb ”目录找到imagedb 应用程序。

1.建立dispatcher实现注解支持只有对应的HandlerMapping（为了实现类型级别的注解）和/ 或HandlerAdapter（为了实现方法级别的注解）出现在 dispatcher中时， @RequestMapping 才会被处理。

这在DispatcherServlet 和DispatcherPortlet 中都是缺省的行为。

然而，如果是在定义自己的HandlerMappings或HandlerAdapters，就需要确保一个对应的自定义的DefaultAnnotation HandlerMapping和 /或AnnotationMethod HandlerAdapter同样被定义——假设想要使用@RequestMapping 。

例1:雁联zfpt-servlet.xml例2：web.xml2.1 webAppRootKey2.3 log4jConfigLocation2.4 contextConfigLocation2.5 springSecurityFilterChain2.6 Log4jConfigListener2.7 ContextLoaderListener2.8 DispatcherServlet2.9 exception.java例3：雁联web.xml如果你想要自定义映射策略，显式的定义一个DefaultAnnotationHandlerMapping和 /或AnnotationMethodHandlerAdapter也有实际意义。

Springmvc拦截器实现原理解析

Springmvc拦截器实现原理解析概述SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,⽤于对处理器进⾏预处理和后处理。

开发者可以⾃⼰定义⼀些拦截器来实现特定的功能。

过滤器与拦截器的区别：拦截器是AOP思想的具体应⽤。

过滤器servlet规范中的⼀部分，任何java web⼯程都可以使⽤在url-pattern中配置了/*之后，可以对所有要访问的资源进⾏拦截拦截器拦截器是SpringMVC框架⾃⼰的，只有使⽤了SpringMVC框架的⼯程才能使⽤拦截器只会拦截访问的控制器⽅法，如果访问的是jsp/html/css/image/js是不会进⾏拦截的⾃定义拦截器那如何实现拦截器呢？想要⾃定义拦截器，必须实现 HandlerInterceptor 接⼝。

新建⼀个Moudule ，添加web⽀持配置web.xml 和 springmvc-servlet.xml ⽂件编写⼀个拦截器package com.xiaohua.interceptor;import org.springframework.web.servlet.HandlerInterceptor;import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class MyInterceptor implements HandlerInterceptor {//在请求处理的⽅法之前执⾏//如果返回true执⾏下⼀个拦截器//如果返回false就不执⾏下⼀个拦截器public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {System.out.println("------------处理前------------");return true;}//在请求处理⽅法执⾏之后执⾏public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception { System.out.println("------------处理后------------");}//在dispatcherServlet处理后执⾏,做清理⼯作.public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {System.out.println("------------清理------------");}}在springmvc的配置⽂件中配置拦截器<mvc:interceptors><mvc:interceptor><mvc:mapping path="/**"/><bean class="com.xiaohua.interceptor.MyInterceptor"/></mvc:interceptor></mvc:interceptors>编写⼀个Controller，接收请求package com.xiaohua.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;//测试拦截器的控制器@Controllerpublic class InterceptorController {@RequestMapping("/interceptor")@ResponseBodypublic String testFunction() {System.out.println("控制器中的⽅法执⾏了");return "hello";}}前端 index.jsp<a href="${pageContext.request.contextPath}/interceptor" rel="external nofollow" >拦截器测试</a>启动tomcat 测试⼀下！验证⽤户是否登陆（认证⽤户）实现思路有⼀个登陆页⾯，需要写⼀个controller访问页⾯。

SpringMVC单文件上传与多文件上传实例

SpringMVC单⽂件上传与多⽂件上传实例⼀、简述⼀个javaWeb项⽬中，⽂件上传功能⼏乎是必不可少的，本⼈在项⽬开发中也时常会遇到，以前也没怎么去理它，今天有空学习了⼀下这⽅⾯的知识，于是便将本⼈学到的SpringMVC中单⽂件与多⽂件上传这部分知识做下笔记。

⼆、单⽂件上传1、页⾯这⾥以⼀个简单的表单提交为例⼦，⽂件上传需要将表单的提交⽅法设置为post，将enctype的值设置为"multipart/form-data"。

<form action="${pageContext.request.contextPath}/test/upload.do" method="post" enctype="multipart/form-data"><input type="file" name="img"><br /><input type="submit" name="提交"></form>2、控制器在Controller的处理⽅法中，使⽤MultipartFile对象作为参数接收前端上传过来的⽂件，具体说明请看代码注释。

@Controller@RequestMapping("/test")public class MyController {@RequestMapping(value = "/upload.do", method = RequestMethod.POST)// 这⾥的MultipartFile对象变量名跟表单中的file类型的input标签的name相同，所以框架会⾃动⽤MultipartFile对象来接收上传过来的⽂件，当然也可以使⽤@RequestParam("img")指定其对应的参数名称 public String upload(MultipartFile img, HttpSession session)throws Exception {// 如果没有⽂件上传，MultipartFile也不会为null，可以通过调⽤getSize()⽅法获取⽂件的⼤⼩来判断是否有上传⽂件if (img.getSize() > 0) {// 得到项⽬在服务器的真实根路径，如：/home/tomcat/webapp/项⽬名/imagesString path = session.getServletContext().getRealPath("images");// 得到⽂件的原始名称，如：美⼥.pngString fileName = img.getOriginalFilename();// 通过⽂件的原始名称，可以对上传⽂件类型做限制，如：只能上传jpg和png的图⽚⽂件if (fileName.endsWith("jpg") || fileName.endsWith("png")) {File file = new File(path, fileName);img.transferTo(file);return "/success.jsp";}}return "/error.jsp";}}3、springmvc.xml配置使⽤MultipartFile对象接收前端上传过来的⽂件，还需要在springmvc的配置⽂件中进⾏如下配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:mvc="/schema/mvc" xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop" xmlns:tx="/schema/tx"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/tx/schema/tx/spring-tx.xsd/schema/mvc/schema/mvc/spring-mvc.xsd/schema/aop/schema/aop/spring-aop.xsd/schema/context/schema/context/spring-context.xsd">...<bean id="multipartResolver" class="monsMultipartResolver"><property name="defaultEncoding" value="utf-8"/><property name="maxUploadSize" value="1048576"/><property name="maxUploadSizePerFile" value="1048576"/></bean><bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver"><property name="defaultErrorView" value="/error.jsp"/></bean></beans>上⾯配置⽂件中的CommonsMultipartResolver下的属性值配置不是必须的，你也可以全部不写。

面向Web 2.0的Spring MVC构架

面向Web 2.0的Spring MVC构架概要——在构建具有丰富用户体验的web应用时,目前有很多的web应用程序架构可用,但是很难决定选择哪一个。

Web 2.0应用允许个人在网络上直接来管理他们的在线内容,并可以与其他用户和设备分享。

不过这种共享需要运行访问控制。

虽然现在存在访问控制解决方案,然而,不尽人意的是他们不能支持开放和用户主导Web环境的功能。

相较于这些web 开发框架，MVC构架最受欢迎。

模型-视图-控制器(MVC)是一种软件架构,目前被认为是一种运用于体系结构模式中使用的软件工程。

这种构架将“域逻辑”(用户的应用逻辑)从用户界面(输入和显示)分离出来,支持独立开发、测试和单独维护(分离要点)。

模型-视图-控制器(MVC)模式通过从应用的各种单独的不同方面(输入逻辑、业务逻辑和UI逻辑)来创建,同时提供这些元素之间的松散耦合。

关键字——Spring MVC，体系, XStudio,SOA, 控制器。

1、介绍关于具体什么定义了一个网站是“web2.0”?有许多不同的意见,很难确定一个确切的定义。

但它会弄清楚当我们将经历所有可用的web开发框架。

各种web开发架构如下·Ntier体系在软件工程领域中,多层架构(通常称为n层架构)是一个在性能、应用进程和数据管理上逻辑独立的客户机-服务器一体的结构。

例如,一个应用程序,该应用程序使用中间件服务用户和数据库之间的数据请求。

最广泛使用的多层架构是三层体系结构。

N-tier体系应用程序体系结构为开发人员提供了一个模型来创建一个灵活的和可重用的应用程序。

通过将一个应用程序分解成层,开发人员只需要修改或添加一个特定的层,而不是重写整个应用程序。

应该有性能、业务或数据访问层和数据层。

层与层的概念往往交替使用。

∙面向服务的体系结构在软件工程中,面向服务的体系结构(SOA)是一组运用协议和手段来设计和开发软件的形式。

这些服务是构建软件组件(离散块的代码和/或数据结构),可以重用于不同目的的业务功能,。

spring mvc原理

第一次发帖，谨作为以后的回顾以及参考，有问题的地方，希望高手指正！1.Spring MVC工作原理①当用户在浏览器中点击一个链接或者提交一个表单时，那么就会产生一个请求（request）。

当请求离开浏览器时，它会携带用户请求的信息（比如说请求的URL信息，用户名，密码什么的）。

②请求的第一站到达的是Spring的DispatcherServlet，它是一个前端控制器，工作是将用户的请求委托给其他的组件（这里是交给Spring MVC的控制器）去处理。

这里DispatcherServlet要决定将请求传给哪一个控制器（Controller）去处理，那么这时就需要处理器映射（Handler Mapping）了。

处理器映射会看请求的URL信息，然后决定将请求交给哪一个控制器去处理。

比如说有两个控制器ControllerA和ControllerB，分别处理后缀名为.html和.jsp送来的请求，那么当请求者的后缀名为.html时，那么DispatcherServlet就将请求交给ControllerA进行处理。

③当选择了一个合适的控制器后，DispatcherServlet就会将请求交给这个控制器去处理。

在这个控制器上，用户的请求将会将用户提交的一些信息交由控制器处理并等待。

然而设计的比较好的控制器本身对信息做很少的处理或者根本不做处理，而是将业务逻辑交给一个或多个服务器对象（Model）去处理。

④当控制器对用户请求所携带的信息进行处理（或交给模型层处理）后，经常会产生一些其他的需要返回给浏览器进行显示的数据。

这些原始数据直接显示出来显然是不友好的，那么就需要视图（View）来对这些数据进行显示了。

控制器的最后一件事就是将模型数据打包，并且指定产生输出的视图的特定名称，然后它将模型、视图名称以及request请求一起发送给DispatcherServlet。

所以控制器并没有与视图进行耦合，因为传递给DispatcherServlet的视图名称并不是某一个指定的特殊的文件名称（如后缀名一定是JSP或其他什么名称），它只要是一个可以产生输出和展示结果的逻辑名称就可以了。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

—通知（Ａｄvｉce）：在特定的连接点,ＡOP框架执行的动作。各种类型的通知包括“arｏunｄ”、“bｅｆoｒe”和“ｔhrows”通知。通知类型将在下面讨论。许多ＡＯP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。
— 切入点（Pointcut）:指定一个通知将被引发的一系列连接点的集合。ＡOP框架必须允许开发者指定切入点,例如，使用正则表达式。
— Ａfｔer reｔurnｉｎg通知：在连接点正常完成后执行的通知，例如，一个方法正常返回，没有抛出异常。
Ａround通知是最通用的通知类型。大部分基于拦截的ＡOＰ框架(如Nanning和Ｊboss4)只提供Around通知。
如同ＡspectＪ，Ｓpｒing提供所有类型的通知,我们推荐你使用最为合适的通知类型来实现需要的行为。例如,如果只是需要用一个方法的返回值来更新缓存，你最好实现一个ａｆｔｅr rｅｔｕrning通知,而不是arｏunｄ通知,虽然aｒounｄ通知也能完成同样的事情。使用最合适的通知类型使编程模型变得简单,并能减少潜在错误。例如，你不需要调用在arouｎｄ通知中所需使用的ＭeｔｈodInvocaｔion的pｒoceed(）方法，因此就调用失败。
实现类
Javａ代码
8<span stylｅ="font－sｉｚｅ:ｍedium;">ｐackａgｅcｏm.ｔest.TestSpring3;
9
10publｉｃｃlassUsｅｒServiｃeImpｉmｐleｍｅntｓUｓerServicｅ／／实现UserＳervice接口
11.．.{
12ｐublicvoidｐrintＵｓer(Sｔring user) ...{
ＡOP将应用系统分为两部分，核心业务逻辑（Ｃoｒeｂusiｎessｃonceｒns)及横向的通用逻辑,也就是所谓的方面Crosscｕtｔing enterpｒiｓe concerns，例如,所有大中型应用都要涉及到的持久化管理(Persisｔｅnt）、事务管理(Trａnsacｔiｏn Maｎagement）、安全管理（Ｓecｕritｙ)、日志管理(Lｏｇging）和调试管理(Debｕgｇｉng)等。
接口类
Javａ代码
1<spanstyle="foｎｔ－ｓizｅ: meｄium;">packagecｏm.ｔest.TcｉｎterfａｃeUserSｅrvｉce／/被拦截的接口
4...{
5ｐublｉcvｏidprintUｓｅr(Striｎgｕser);
6}
7<／span>
13Sysｔｅｍ.out.prｉntln(＂printUser user:＂+ user);/／显示uｓer
14}
15｝
16
17</span＞
AOP拦截器
Java代码
18<spanｓｔyｌe=＂font－size: meｄｉｕｍ;"＞ｐackageｃom.ｔesｔ．TesｔSpｒｉng3;
切入点的概念是AOP的关键，它使AOＰ区别于其他使用拦截的技术。切入点使通知独立于OO的层次选定目标。例如,提供声明式事务管理的around通知可以被应用到跨越多个对象的一组方法上。因此切入点构成了AOP的结构要素。
拦截器（也称拦截机)
拦截机(Iｎtｅrｃeptｏr),是AOP（Ａspect-OrｉentedPｒogrammｉng)的另一种叫法。AOＰ本身是一门语言,只不过我们使用的是基于ＪＡVA的集成到Ｓpring中的SｐｒinｇＡOP。同样,我们将通过我们的例子来理解陌生的概念。
ＡOＰ概念
让我们从定义一些重要的AＯP概念开始。
—方面(Aｓpｅct）：一个关注点的模块化,这个关注点实现可能另外横切多个对象。事务管理是Ｊ2EE应用中一个很好的横切关注点例子。方面用Ｓpring的Aｄvｉsor或拦截器实现。
—连接点（Joiｎｐoｉnｔ):程序执行过程中明确的点，如方法的调用或特定的异常被抛出。
—Beｆore通知:在一个连接点之前执行的通知,但这个通知不能阻止连接点前的执行(除非它抛出一个异常）。
—Ｔｈrows通知:在方法抛出异常时执行的通知。Spring提供强制类型的Ｔhｒｏws通知，因此你可以书写代码捕获感兴趣的异常(和它的子类），不需要从Tｈrowable或Ｅxceptiｏn强制类型转换。
AＯP正在成为软件开发的下一个光环。使用ＡＯP,你可以将处理ａspect的代码注入主程序，通常主程序的主要目的并不在于处理这些aspecｔ。AOP可以防止代码混乱。
Spｒｉｎgframeｗｏrk是很有前途的ＡOP技术。作为一种非侵略性的、轻型的AOP frameｗorｋ，你无需使用预编译器或其他的元标签,便可以在Ｊava程序中使用它。这意味着开发团队里只需一人要对付AOＰfraｍeｗork,其他人还是像往常一样编程。
一个简单的Sprinｇ-ＭVC例子
———————————————————————————————— 作者：
———————————————————————————————— 日期：
AOP(Aｓｐect OrienteｄPrｏgramming),也就是面向方面编程的技术。AOP基于IoC基础，是对OOP的有益补充。
—引入（Ｉntｒｏductiｏn)：添加方法或字段到被通知的类。Ｓｐrinｇ允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现IｓModified接口，来简化缓存。
—目标对象(TaｒgetＯbjecｔ）:包含连接点的对象，也被称作被通知或被代理对象。
—AOＰ代理（AOP Prｏxｙ):AOＰ框架创建的对象，包含通知。在Spｒinｇ中，AOP代理可以是JDＫ动态代理或CGLIB代理。
—编织(Ｗeaviｎg)：组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspeｃtJ编译器），也可以在运行时完成。Ｓpring和其他纯Jａva AOP框架一样，在运行时完成织入。
各种通知类型包括：
—Arounｄ通知:包围一个连接点的通知，如方法调用。这是最强大的通知。Aｒoｕd通知在方法调用前后完成自定义的行为，它们负责选择继续执行连接点或通过返回它们自己的返回值或抛出异常来短路执行。