SpringMvc学习笔记(二)通过实例学习注解式控制器

合集下载

springmvc第一天课堂笔记

springmvc 第一天springmvc的基础知识课程安排：第一天：springmvc的基础知识什么是springmvc？springmvc框架原理（掌握）前端控制器、处理器映射器、处理器适配器、视图解析器springmvc入门程序目的：对前端控制器、处理器映射器、处理器适配器、视图解析器学习非注解的处理器映射器、处理器适配器注解的处理器映射器、处理器适配器（掌握）springmvc和mybatis整合（掌握）springmvc注解开发：（掌握）常用的注解学习参数绑定（简单类型、pojo、集合类型（明天讲））自定义参数绑定（掌握）springmvc和struts2区别第二天：springmvc的高级应用参数绑定（集合类型）数据回显上传图片json数据交互RESTful支持拦截器1springmvc框架1.1什么是springmvcspringmvc是spring框架的一个模块，springmvc和spring无需通过中间整合层进行整合。

（struts2与Spring整合的时候需要借助单独的jar包）springmvc是一个基于mvc的web框架。

1.2 mvc 在b/s 系统下的应用mvc 是一个设计模式，mvc 在b/s 系统下的应用：C 控制器比如struts2中的filter controller 接口用户请求，响应request 请求M 模型(model) pojo action service dao请求模型进行处理处理结果返回V 视图 view视图渲染将模型数据填充到request 域response 响应b/s 系统下模型无法将数据填充到视图1.3 springmvc 框架第一步：发起请求到前端控制器(DispatcherServlet)第二步：前端控制器请求HandlerMapping 查找 Handler 可以根据xml 配置、注解进行查找第三步：处理器映射器HandlerMapping 向前端控制器返回Handler 第四步：前端控制器调用处理器适配器去执行Handler 第五步：处理器适配器去执行Handler第六步：Handler执行完成给适配器返回ModelAndView第七步：处理器适配器向前端控制器返回ModelAndViewModelAndView是springmvc框架的一个底层对象，包括Model和view第八步：前端控制器请求视图解析器去进行视图解析根据逻辑视图名解析成真正的视图(jsp)第九步：视图解析器向前端控制器返回View第十步：前端控制器进行视图渲染视图渲染将模型数据(在ModelAndView对象中)填充到request域第十一步：前端控制器向用户响应结果组件：1、前端控制器DispatcherServlet（不需要程序员开发）作用接收请求，响应结果，相当于转发器，中央处理器。

最全最经典spring_mvc教程

spring mvc学习教程(一)-入门实例引言1.MVC：Model-View-Control框架性质的C层要完成的主要工作：封装web请求为一个数据对象、调用业务逻辑层来处理数据对象、返回处理数据结果及相应的视图给用户。

2.简要概述springmvcSpring C 层框架的核心是DispatcherServlet，它的作用是将请求分发给不同的后端处理器，也即使用了一种被称为Front Controller 的模式（后面对此模式有简要说明）。

Spring 的C 层框架使用了后端控制器来、映射处理器和视图解析器来共同完成C 层框架的主要工作。

并且spring 的C 层框架还真正地把业务层处理的数据结果和相应的视图拼成一个对象，即我们后面会经常用到的ModelAndView 对象。

一、入门实例1. 搭建环境在spring的官方API文档中，给出所有包的作用概述，现列举常用的包及相关作用：org.springframework.aop-3.0.5.RELEASE.jar：与Aop编程相关的包org.springframework.beans-3.0.5.RELEASE.jar：提供了简捷操作bean的接口org.springframework.context-3.0.5.RELEASE.jar：构建在beans包基础上，用来处理资源文件及国际化。

org.springframework.core-3.0.5.RELEASE.jar：spring核心包org.springframework.web-3.0.5.RELEASE.jar：web核心包，提供了web层接口org.springframework.web.servlet-3.0.5.RELEASE.jar：web 层的一个具体实包，DispatcherServlet也位于此包中。

后文全部在spring3.0 版本中进行，为了方便，建议在搭建环境中导入spring3.0 的所有jar 包（所有jar 包位于dist 目录下）。

springmvc的知识点总结

springmvc的知识点总结一、控制器1. 控制器是Spring MVC框架中的核心组件，它负责接收请求并处理用户的输入。

在Spring MVC中，控制器通常以注解@Controller标记，并通过@RequestMapping注解来指定处理请求的URL。

2. 一个简单的控制器可以像下面这样定义：```java@Controllerpublic class HomeController {@RequestMapping("/")public String home() {return "index";}}```在这个例子中，HomeController类使用@Controller标记为一个控制器，并使用@RequestMapping("/")注解来指定处理根路径("/")的请求。

该方法返回一个String类型的视图名称，Spring MVC将根据这个名称来查找对应的视图。

3. 控制器方法还可以接收请求参数以及路径变量。

例如：```java@RequestMapping("/user/{id}")public String getUser(@PathVariable("id") long userId, Model model) {User user = userService.getUserById(userId);model.addAttribute("user", user);return "user";}```在这个例子中，@PathVariable注解用于绑定路径变量到方法的参数中。

二、视图解析1. Spring MVC使用视图解析器来将控制器返回的视图名称解析成实际的视图。

在Spring MVC的配置文件中，可以配置多个视图解析器，并按顺序来尝试解析视图名称。

springmvc第二天课堂笔记

springmvc第二天高级知识复习：springmvc框架：DispatcherServlet前端控制器：接收request，进行responseHandlerMapping处理器映射器：根据url查找Handler。

（可以通过xml配置方式，注解方式）HandlerAdapter处理器适配器：根据特定规则去执行Handler，编写Handler时需要按照HandlerAdapter的要求去编写。

Handler处理器（后端控制器）：需要程序员去编写，常用注解开发方式。

Handler处理器执行后结果是ModelAndView，具体开发时Handler返回方法值类型包括：ModelAndView、String（逻辑视图名）、void（通过在Handler形参中添加request和response，类似原始servlet开发方式，注意：可以通过指定response响应的结果类型实现json数据输出）View resolver视图解析器：根据逻辑视图名生成真正的视图（在springmvc中使用View对象表示）View视图:jsp页面，仅是数据展示，没有业务逻辑。

注解开发：使用注解方式的处理器映射器和适配器：<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandl erMapping"/><bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandl erAdapter"/>在实际开发，使用<mvc:annotation-driven>代替上边处理器映射器和适配器配置。

Spring MVC3注解学习之简单入门范例

Spring MVC3注解学习之简单入门范例文章均为原创，转载请注明出处。

本文地址：/post/430.html之前做Web应用都是在用Struts2，觉得功能强大，效率也能提升很多，所以一直都很喜欢Struts。

虽然也曾经在接手前人遗留的项目时遭遇过Spring MVC，不过不知道是前人用的不好，还是自己水平差，亦或者是Spring MVC（那个时候还是2）本身的问题，让Spring MVC给自己留下了很不好的印象：配置文件繁琐、功能一般甚至简陋、不能够在开发效率上与Struts2媲美等等问题，致使自己一直以来都是带着偏见看待Spring MVC的，也因此一直都没有再去尝试过。

最近是一次偶然的机会，再次正面遭遇Spring MVC，不过这次它改头换面，由2升级到3了，看到别人基于Spring MVC注解方式写出来的简洁流畅的代码后，惊叹于Spring MVC3的注解驱动能力之强大，代码之简洁，觉得自己以前的偏见简直就是愚昧至极，不由地暗自对Spring MVC有了好感，打算实实在在尝试一把。

不过自己之前对Spring MVC确实不熟，加之这次升级的内容有点多，所以我找来了一份很好的入门文档《Spring3_MVC注解教程》作为自己的领路人。

这份PPT做的很好，本文也是在此基础上有感而发的，在此感谢作者陈雄华先生的辛勤劳动和无私奉献！本文所示代码均基于最新版SpringFrameword3.2.3，请知悉。

Spring MVC框架简介∙支持REST风格的URL∙添加更多注解，可完全注解驱动∙引入HTTP输入输出转换器（HttpMessageConverter）∙和数据转换、格式化、验证框架无缝集成∙对静态资源处理提供特殊支持∙更加灵活的控制器方法签名，可完全独立于Servlet API Spring MVC框架结构框架的实现者如何在应用中使用Spring-MVC？1.在应用中添加Spring框架支持；2.在web.xml中配置Spring-MVC的请求转发器(前端控制器)3.编写Spring-MVC的配置文件4.将任意JavaBean通过注解配置成Controller(控制器)并注解其中的方法5.完成步骤简单明了，接下来我们一步一步详细说明：在应用中加入Spring支持：因为Spring-MVC是属于SpringFramework的一部分，因此要在应用中使用Spring-MVC，就必须以引入Spring基础框架为前提，另外还包括beans、context、aop、web组件，将上述组件的jar及其依赖添加到buildpath下，就算完成了为应用添加Spring框架支持的工作，然后在web.xml中配置Spring的监听器，代码如下：另外，因为是在web应用中使用Spring，因此建议配置一个名为org.springframework.web.util.IntrospectorCleanupListener的监听器来处理资源回收的工作：再配置一个编码过滤器在web.xml中配置Spring-MVC的请求转发器(前端控制器)在应用中使用Spring-MVC比较简单，除了需要引入相关依赖库外，还需要在web.xml配置Spring-MVC的请求转发器，代码如下：编写Spring-MVC的配置文件在上述代码中，我们告知Spring-MVC的请求转发器我们的mvc配置在classpath:mvc-config.xml中，因此我们需要在该文件中正确描述我们的mvc配置信息，配置代码如下：将任意JavaBean通过注解配置成Controller(控制器)并注解其中的方法本文主要示范如何使用注解为应用添加Spring-MVC支持，因此本文中的所有MVC映射配置都采用注解方式，范例Controller如下所示：为了是上面的Controller能够正常使用，我们还需要在WebRoot下创建Controller 中使用的逻辑视图对应的视图文件，以上例中create为例，我们在WEB-INF/jsp/目录下新建jsp文件，内容如下：完成上述四个步骤后，将工程部署到任意web容器(本文采用tomcat6.0)，然后启动，即可在浏览器中浏览映射出来的地址，如果需要在记录详细的Spring调试信息，则可以通过配置log4j来实现（这里多说一句，Spring的调试信息真的很详细很丰富，通过分析日志，将有助于我们快速理解和掌握Spring-MVC的工作原理）。

SpringMVC常用注解@Controller,@Service,@repository。。。

SpringMVC常⽤注解@Controller,@Service,@repository。

SpringMVC常⽤注解@Controller,@Service,@repository,@Componentcontroller层使⽤@controller注解@Controller ⽤于标记在⼀个类上，使⽤它标记的类就是⼀个SpringMVC Controller 对象。

分发处理器将会扫描使⽤了该注解的类的⽅法。

通俗来说，被Controller标记的类就是⼀个控制器，这个类中的⽅法，就是相应的动作。

@RequestMapping是⼀个⽤来处理请求地址映射的注解，可⽤于类或⽅法上。

⽤于类上，表⽰类中的所有响应请求的⽅法都是以该地址作为⽗路径。

⽐如图⼀中，跳转到登录页⾯的路径就是localhost:8080/xxx-war/user/toLoginservice采⽤@service注解例：@Service("userService")注解是告诉，当Spring要创建UserServiceImpl的的实例时，bean的名字必须叫做"userService"，这样当Action需要使⽤UserServiceImpl的的实例时,就可以由Spring创建好的"userService"，然后注⼊给Action。

dao层使⽤@repository注解@Repository(value="userDao")注解是告诉Spring，让Spring创建⼀个名字叫“userDao”的UserDaoImpl实例。

当Service需要使⽤Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使⽤@Resource(name = "userDao")注解告诉Spring，Spring把创建好的userDao注⼊给Service即可。

聊聊springmvc中controller的方法的参数注解方式

聊聊springmvc中controller的⽅法的参数注解⽅式绪论相信接触过springmvc的同学都知道，在springmvc的控制层中，我们在⽅法的参数中可以使⽤注解标识。

⽐如下⾯例⼦：public Map<String, Object> login(@PathVariable("loginParams") String loginParams)@PathVariable注解就标识了这个参数是作为⼀个请求地址模板变量的（不清楚的同学可以先学习⼀下restful设计风格）。

这些注解都是spring内置注解，那么我们可不可以⾃定义注解来实现⾃⼰的业务逻辑处理呢？答案是可以的，spring团队的⼀⼤设计哲学思想就是让⾃⼰的系统有⽆限可能性的拓展。

spring框架底层⼜是如何解析这些参数的注解的呢？那么在学习⾃定义参数注解之前，我们先了解⼀下spring底层是怎么来解析这些注解参数的。

实际上，这些处理过程是要涉及到配置⽂件的加载和解析以及⼀堆的各种处理，⼩弟功⼒尚浅，就分析不到那么多了，只是简单过⼀下。

内置参数注解的解析下⾯，我们从源码⾓度来分析：⾸先，sping定义了⼀个统⼀的⽅法参数注解解析接⼝HandlerMethodArgumentResolver，所有⽅法参数解析类都需要实现这个接⼝，接⼝很简单，定义了两个⽅法：public interface HandlerMethodArgumentResolver {/*** 判断⽅法参数是否包含指定的参数注解* 含有返回true，不含有返回false*/boolean supportsParameter(MethodParameter parameter);/*** 在给定的具体的请求中，把⽅法的参数解析到参数值⾥⾯，返回解析到的参数值，没有返回null* 只有在supportsParameter返回true的时候，resolveArgument⽅法才会执⾏*/Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;}现在，带着⼤家看看@PathVariable参数注解的解析具体过程，源代码如下：public class PathVariableMethodArgumentResolver extends AbstractNamedValueMethodArgumentResolverimplements UriComponentsContributor {/** 这⾥省略其它⽅法*/@Overridepublic boolean supportsParameter(MethodParameter parameter) {// 不含有PathVariable注解，返回falseif (!parameter.hasParameterAnnotation(PathVariable.class)) {return false;}// PathVariable注解的参数类型是Map类型if (Map.class.isAssignableFrom(parameter.getParameterType())) {String paramName = parameter.getParameterAnnotation(PathVariable.class).value();return StringUtils.hasText(paramName);}return true;}// PathVariableMethodArgumentResolver没有重写resolveArgument，直接使⽤AbstractNamedValueMethodArgumentResolver默认⾏为/** 如果supportsParameter返回true，在这⾥真正处理参数**/protected void handleResolvedValue(Object arg, String name, MethodParameter parameter,ModelAndViewContainer mavContainer, NativeWebRequest request) {String key = View.PATH_VARIABLES;int scope = RequestAttributes.SCOPE_REQUEST;Map<String, Object> pathVars = (Map<String, Object>) request.getAttribute(key, scope);if (pathVars == null) {pathVars = new HashMap<String, Object>();request.setAttribute(key, pathVars, scope);}// 把参数的key-value放进请求域，也就是把值赋给了⽅法参数，⽐如请求路径是： api/v1/task/{id}，⽅法参数@PathVariable("id") String taskId，那么此时name=taskId, org=id的值// 当然，怎么把请求地址中对应的值获取出来，不在这篇博客的讨论范畴。

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实现，也只需修改这里的配置就行了。

基于SpringMVC拦截器和注解实现controller中访问权限控制

基于SpringMVC拦截器和注解实现controller中访问权限控制SpringMVC的拦截器HandlerInterceptorAdapter对应提供了三个preHandle，postHandle，afterCompletion⽅法。

1. preHandle在业务处理器处理请求之前被调⽤；2. postHandle在业务处理器处理请求执⾏完成后,⽣成视图之前执⾏；3. afterCompletion在DispatcherServlet完全处理完请求后被调⽤,可⽤于清理资源等；所以要想实现⾃⼰的权限管理逻辑，需要继承HandlerInterceptorAdapter并重写其三个⽅法。

⼀、⾃定义拦截器配置⽅法1. 在sping的xml配置中可以⽤<mvc:interceptors>和<mvc:interceptor>来配置拦截器类（实现HandlerInterceptorAdapter）2. 在javaConfig中配置通过WebMvcConfiguration的实现类配置拦截器类（实现HandlerInterceptorAdapter）⼆、⽰例2.1、javaconfig中配置SpringMVC⽰例1、新建⼀个springboot项⽬auth-demo22、权限校验相关的注解package com.dxz.authdemo2.web.auth;import ng.annotation.ElementType;import ng.annotation.Retention;import ng.annotation.RetentionPolicy;import ng.annotation.Target;@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)public @interface Permission {/** 检查项枚举 */PermissionEnum[] permissionTypes() default {};/** 检查项关系 */RelationEnum relation() default RelationEnum.OR;}package com.dxz.authdemo2.web.auth;import java.io.PrintWriter;import ng.annotation.Annotation;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;import org.springframework.beans.factory.annotation.Autowired;import ponent;import org.springframework.web.method.HandlerMethod;import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;/*** 权限检查拦截器*/@Componentpublic class PermissionCheckInterceptor extends HandlerInterceptorAdapter {/** 权限检查服务 */@Autowiredprivate PermissionCheckProcessor permissionCheckProcessor;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//Class<?> clazz = handler.getClass();Class<?> clazz = ((HandlerMethod)handler).getBeanType();System.out.println("PermissionCheckInterceptor.preHandle()" + clazz);for(Annotation a : clazz.getAnnotations()){System.out.println(a);}if (clazz.isAnnotationPresent(Permission.class)) {Permission permission = (Permission) clazz.getAnnotation(Permission.class);return permissionCheckProcessor.process(permission, request, response);}return true;}public boolean preHandle2(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("SecurityInterceptor:"+request.getContextPath()+","+request.getRequestURI()+","+request.getMethod()); HttpSession session = request.getSession();if (session.getAttribute("uid") == null) {System.out.println("AuthorizationException:未登录！"+request.getMethod());if("POST".equalsIgnoreCase(request.getMethod())){response.setContentType("text/html; charset=utf-8");PrintWriter out = response.getWriter();out.write("未登录！");out.flush();out.close();}else{response.sendRedirect(request.getContextPath()+"/login");}return false;} else {return true;}}}package com.dxz.authdemo2.web.auth;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import ponent;@Componentpublic class PermissionCheckProcessor {public boolean process(Permission permission, HttpServletRequest request, HttpServletResponse response) {PermissionEnum[] permissionTypes = permission.permissionTypes();try {String uid = request.getParameter("uid");if ("duanxz".equals(uid)) {System.out.println("认证成功");return true;} else {System.out.println("认证失败");return false;}} catch (Exception e) {return false;}}}package com.dxz.authdemo2.web.auth;public enum PermissionEnum {DEVELOPER_VALID, DEVELOPER_FREEZE;}package com.dxz.authdemo2.web.auth;public enum RelationEnum {OR, AND;}3、SpringMVC拦截器配置package com.dxz.authdemo2.web.auth;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.InterceptorRegistry;import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;@Configurationpublic class WebMvcConfiguration extends WebMvcConfigurerAdapter {@AutowiredPermissionCheckInterceptor permissionCheckInterceptor;@Overridepublic void addInterceptors(InterceptorRegistry registry) {// addPathPatterns ⽤于添加拦截规则// excludePathPatterns ⽤户排除拦截// 映射为 user 的控制器下的所有映射registry.addInterceptor(permissionCheckInterceptor).addPathPatterns("/admin/*").excludePathPatterns("/index", "/");super.addInterceptors(registry);}}4、测试controllerpackage com.dxz.authdemo2.web;import javax.servlet.http.HttpServletRequest;import org.springframework.stereotype.Controller;import org.springframework.ui.ModelMap;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import com.dxz.authdemo2.web.auth.Permission;import com.dxz.authdemo2.web.auth.PermissionEnum;@Controller@RequestMapping("/admin")@Permission(permissionTypes = { PermissionEnum.DEVELOPER_VALID })public class AppDetailController {@RequestMapping(value="/appDetail", method = RequestMethod.GET)public String doGet(ModelMap modelMap, HttpServletRequest httpServletRequest) { //1. 业务操作，此处省略System.out.println("appDetail.htm 处理中...");return "appDetail";}}package com.dxz.authdemo2.web;import javax.servlet.http.HttpServletRequest;import org.springframework.stereotype.Controller;import org.springframework.ui.ModelMap;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import com.dxz.authdemo2.web.auth.Permission;import com.dxz.authdemo2.web.auth.PermissionEnum;@Controller@RequestMapping("index")public class IndexController {@RequestMapping(method = RequestMethod.GET)public void doGet(ModelMap modelMap, HttpServletRequest httpServletRequest) {System.out.println("index");}}cotroller中的jsp⽂件appDetail.jsp<html><h1>appDetail</h1></html>启动类：package com.dxz.authdemo2;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.EnableAutoConfiguration;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.context.annotation.Bean;import org.springframework.web.servlet.ViewResolver;import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer; import org.springframework.web.servlet.config.annotation.EnableWebMvc;import org.springframework.web.servlet.view.InternalResourceViewResolver;@EnableWebMvc@EnableAutoConfiguration@SpringBootApplicationpublic class AuthDemo2Application {public static void main(String[] args) {SpringApplication.run(AuthDemo2Application.class, args);}// 配置JSP视图解析器@Beanpublic ViewResolver viewResolver() {InternalResourceViewResolver resolver = new InternalResourceViewResolver();resolver.setPrefix("/WEB-INF/views/");resolver.setSuffix(".jsp");return resolver;}}结果：访问：访问：2.2、xml中配置SpringMVC⽰例⾸先在springmvc.xml中加⼊⾃⼰定义的拦截器我的实现逻辑PermissionCheckInterceptor，如下：<mvc:interceptors><mvc:interceptor><mvc:mapping path="/" /><mvc:mapping path="/user/**" /><mvc:mapping path="/test/**" /><bean class="com.dxz.authdemo2.web.auth.PermissionCheckInterceptor"></bean></mvc:interceptor> </mvc:interceptors>。

springmvc学习笔记。

springmvc学习笔记1、springmvc都做了什么？1.1、Controller为中心完成对系统流程的控制管理；1.2、从请求中收集数据；1.3、对传入的参数进行验证；1.4、将结果返回给视图；1.5、针对不同的视图提供不同的解决方案；1.6、针对JSP视图技术提供标签库；1.7、拦截器；1.8、上传文件。

2、springmvc结构：2.1、Dispatcherservlet：中央控制器，把请求转发到具体的控制类；2.2、Controller:具体处理请求的控制器（配置文件方式需要配置，注解方式不用配置）；2.3、HandlerMapping：映射处理器，负责映射中央处理器转发给Controller时的映射策略；2.4、ModelAndView：服务层返回的数据和视图层的封装类（无论是配置文件还是注解都不需要配置）2.5、ViewResolver & View：视图解析器，解析具体的视图。

2.6、Interceptors：拦截器，负责拦截我们定义的请求然后做处理工作（无论是配置文件方式还是注解方式都需要先创建再配置）红色加粗的是需要自己创建，黑色的需要配置。

3、配置文件形式创建第一个springmvc的例子步骤：1、创建一个web工程；2、导包；3、在web.xml中配置springmvc的中央控制器DispatcherServlet；request.getScheme();//可以返回当前页面使用的协议，就是“http”request.getServerName();//可以返回当前页面所在的服务器的名字，其实就是一般的localhost，如果是真的部署在服务器上那就是服务器的地址request.getServerPort;//返回的是当前页面所在的服务器使用的端口，一般情况下是8080端口，（自己的机器测试的话就是8080）request.getContextPath;//返回当前页面所在的应用程序的路径，这四个拼装起来，就是当前应用的跟路径了http://localhost:80804、创建controller；需要写.java程序；4.1、写一个类继承AbstractController，自动重写里面方法（与servlet很像）；4.2、在springmvc-servlet.xml中配置controller和视图解析器ViewResolver；4.3、Controller中的bean name="/hello.do"，这个”/hello.do”将来要作为访问地址的http://localhost:8080/springmvc-1/hello.do5、制作jsp页面。

20150322springmvc课堂笔记(企业重点)

springmvc第二天注解开发高级知识1复习springmvc框架：用户请求url到DispatcherServlet前端控制器，相当于中央调度器，降低系统各组件之间耦合度DispatcherServlet前端控制器通过HandlerMapping根据url找到Handler。

DispatcherServlet前端控制器通过HandlerAdapter处理器适配器执行Handler。

DispatcherServlet前端控制器拿着Handler返回的ModelAndView通过视图解析器ViewResolver去进行视图解析。

视图解析：将程序中写的逻辑视图名，转成真正的视图（springmvc通过view表示各各不同类型的视图）。

DispatcherServlet前端控制器调用View的渲染方法进行视图渲染（将ModelAndView中的Model放到request域）。

要掌握springmvc的注解开发，企业中常用springmvc注解开发。

使用专门注解处理器映射器（RequestMappingHandlerMapping）和处理器适配器（RequestMappingHandlerAdapter）。

<mvc:annotation-driven/>可以代替上边的处理器映射器和适配器的配置。

在Handler(Controller)中定义很多的方法，一个方法通过RequestMapping和url进行映射。

方法返回值：ModelAndView、string(jsp的逻辑视图名)、void（通过response将数据输出成json）方法输入参数（形参）：springmvc需要将请求的key/value(串，id=001&type=t002)、解析、绑定到Handler(Controller)中方法的形参上。

springmvc默认支持多类型的参数绑定。

默认支持哪些类型：HttpServletRequest、response、session、Model(用于将数据填充到request域)@requestParam注解：用于绑定单个请求参数，常用于简单类型参数（Integer、String 、Float。

SpringMVC中常用的注解

SpringMVC 中常用的注解 spring 从2.5版本开始在编程中引入注解，用户可以使用@RequestMapping ，@RequestParam ， @ModelAttribute 等等这样类似的注解。

到目前为止，Spring 的版本虽然发生了很大的变化，但注解的特性却是一直延续下来，并不断扩展，让广大的开发人员的双手变的更轻松起来，这都离不开Annotation 的强大作用，今天我们就一起来看看Spring MVC 4中常用的那些注解吧。

1. @ControllerController 控制器是通过服务接口定义的提供访问应用程序的一种行为，它解释用户的输入，将其转换成一个模型然后将试图呈献给用户。

Spring MVC 使用 @Controller 定义控制器，它还允许自动检测定义在类路径下的组件并自动注册。

如想自动检测生效，需在XML 头文件下引入 spring-context:1 2 3 4 5 678910 11 12 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.spr /schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:context="/schema/context " xsi:schemaLocation=" /schema/beans /schema/beans/spring-b eans.xsd /schema/context /schema/context/spring -context.xsd"><context:component-scan base-package="org.springframework.s13 amples.petclinic.web"/></beans>2. @RequestMapping我们可以 @RequestMapping 注解将类似 “/favsoft ”这样的URL 映射到整个类或特定的处理方法上。

SpringMVC学习笔记

SpringMVC学习笔记作者：胡晟源。

QQ：1312837781配置spring提示：1 Spring Tool Suit (STS)2 Hibernate Tools对于JUNO版本的Eclipse 可以在help->Eclipse Marketplace 输入插件的名字在列表中选择插件安装就可以了。

SpringMvc原理图解：导入jar包一：springmvc工作流程。

①.servlet容器初始化一个request请求②.DispatcherServlet分发器负责发送请求到映射器.③.despatcherServlet把请求交给处理器映射Mapping，mapping来寻找需要执行的control④.处理器映射把请求分发给控制器Controler。

⑤.Controler执行完毕后返回ModelAndView(视图解析器)⑥.把ModelAndView返回给dispatcherServlet核心分发器⑦.由于DespatcherServlet不参与具体的处理，所以把modelAndView交给视图解析器。

⑧.视图解析器解析成一个真正的视图，再发给view然后response。

ParameterizableViewController(参数控制器)①.在springmvc-servlet.xml里面加上配置②.通过参数控制器访问页面流程解析：也可以直接在参数控制器里定义name属性，直接通过name属性地址来访问。

如下：但要注意的是：配置文件里必须有BeanNameUrlHandlerMapping情况下，默认映射将会被覆盖；以name属性；来访问将会失败。

命令控制器③.在springmvc里面有如下配置。

④.使用简单url进行访问，参数被封装进javabean。

http://localhost:8080/mysm/comm.do?id=1&userName=zhangsan&password=123&age=13 命令控制器①.首先：springMVC有三个映射器，如果不定义映射Mapping，那么就会使默认：●<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>也就是说：上面这个定义和不定义都是一样的。

详解springMVC—三种控制器controller

详解springMVC—三种控制器controller在springmvc中提供了三种controller的配置，1.针对不需要controller代码的，也就是只起到跳转页⾯的作⽤。

2.可以接受实体类型的controller。

3.可以接受表单数据的controller，它只允许POST提交，在配置⽂件中需要指定提交FORM，请求成功的FORM。

1.直接转发到页⾯，不需要添加controller代码。

<bean id="toLogin" name="/toLogin.do" class="org.springframework.web.servlet.mvc.ParameterizableViewController"><propertynamepropertyname="viewName" value="login"></property></bean>2.命令控制器，需要指定实体对象类型,在controller中直接接受指定改实体类。

配置⽂件<bean name="/comm.do" id="comm"class="mController"><propertynamepropertyname="commandClass"value="com.roy.model.Person"></property></bean>controller代码package com.roy.controller;import java.util.Date;import java.text.SimpleDateFormat;import javax.servlet.http.HttpServletRequest;import javax.xml.crypto.Data;import org.springframework.beans.propertyeditors.CustomDateEditor;import org.springframework.web.bind.ServletRequestDataBinder;import org.springframework.web.servlet.mvc.SimpleFormController;import com.roy.model.Person;public class FormController extends SimpleFormController {@Overrideprotected void doSubmitAction(Object command) throws Exception {Person p=(Person) command;System.out.println(p.toString());super.doSubmitAction(command);}}3.表单控制器，在配置⽂件中指定了接受的对象，接受的表单页⾯，以及处理请求成功后的的页⾯。

springMVC详解以及注解说明

springMVC详解以及注解说明基于注释（Annotation）的配置有越来越流行的趋势，Spring 2.5 顺应这种趋势，提供了完全基于注释配置Bean、装配Bean 的功能，您可以使用基于注释的Spring IoC 替换原来基于XML 的配置。

本文通过实例详细讲述了Spring 2.5 基于注释IoC 功能的使用。

概述注释配置相对于XML 配置具有很多的优势：∙ 它可以充分利用Java 的反射机制获取类结构信息，这些信息可以有效减少配置的工作。

如使用JPA 注释配置ORM 映射时，我们就不需要指定PO 的属性名、类型等信息，如果关系表字段和PO 属性名、类型都一致，您甚至无需编写任务属性映射信息——因为这些信息都可以通过Java 反射机制获取。

∙ 注释和Java 代码位于一个文件中，而XML 配置采用独立的配置文件，大多数配置信息在程序开发完成后都不会调整，如果配置信息和Java 代码放在一起，有助于增强程序的内聚性。

而采用独立的XML 配置文件，程序员在编写一个功能时，往往需要在程序文件和配置文件中不停切换，这种思维上的不连贯会降低开发效率。

因此在很多情况下，注释配置比XML 配置更受欢迎，注释配置有进一步流行的趋势。

Spring 2.5 的一大增强就是引入了很多注释类，现在您已经可以使用注释配置完成大部分XML 配置的功能。

在这篇文章里，我们将向您讲述使用注释进行Bean 定义和依赖注入的内容。

Spring2.5的注释Spring 2.5 提供了AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 和RequiredAnnotationBeanPostProcessor这四个主要的关于Annotation 的BeanPostProcessor。

springmvc框架常用注解详解

springmvc框架常⽤注解详解使⽤注解来构造IoC容器通过@controller标注即可将class定义为⼀个controller类。

为使spring能找到定义为controller的bean,需要在applicationContext.xml配置⽂件中注册<context:component-scan base-package="com.maya"/>。

在base-package指明⼀个包。

如果某个类的头上带有特定的注解【@Component/@Repository/@Service/@Controller】，就会将这个对象作为Bean注册进Spring容器。

<context:component-scan base-package="com.om.*"/>1:@Component@Component是所有受Spring 管理组件的通⽤形式，@Component注解可以放在类的头上，@Component不推荐使⽤。

2:@Controller@Controller对应表现层的Bean，也就是Action。

注：实际上，使⽤@component，也可以起到@Controller同样的作⽤。

使⽤@Controller注解标识UserController之后，就表⽰要把UserController交给Spring容器管理，在Spring容器中会存在⼀个名字为"UserController"的action，这个名字是根据UserController类名来取的。

注意：如果@Controller不指定其value【@Controller】，则默认的bean名字为这个类的类名⾸字母⼩写，如果指定value【@Controller(value="UserController")】或者【@Controller("UserController")】，则使⽤value作为bean的名字。

springMVC学习（注解实现依赖注入）

springMVC学习（注解实现依赖注⼊）上⼀篇博客，学习了，即利⽤容器来为类中的属性赋值，分为两种赋值⽅法，利⽤set和利⽤构造⽅法，我们都知道，如果我需要为某⼀个属性赋值的话，必须为该属性写上set⽅法，那么⼤家有没有想过⼀个问题，如果我们⼀个类中有很多个属性，我们会⽣成⼤量的set⽅法，如果⽤构造⽅法来赋值，即<constructor-arg index="" type="" ref="" value=""></constructor-arg>，这样也会存在很多个这样的标签，因为⼀个<constructor-arg index="" type="" ref="" value=""></constructor-arg>只能为⼀个属性赋值，为了解决这些难题，我们可以利⽤注解来为属性进⾏赋值。

同样，我们新建两个类ClassInfo.和Teacher.java[html]1. package com.test.spring.di;2.3. public class ClassInfo {4.5. public void printClassInfo() {6. System.out.println("this is classInfo....");7. }8. }[html]1. package com.test.spring.di;2.3. import javax.annotation.Resource;4.5. public class Teacher {6.7. private String teacherName;8. @Resource9. private ClassInfo classInfo;10.11. public void printClassInfo() {12. this.classInfo.printClassInfo();13. }14.15. }注意，这⾥我们给需要被赋值的属性上添加了@Resource的注解。

springmvc_day02_课堂笔记

springmvc第二天课程回顾：1、springmvc的介绍和框架原理●介绍●框架原理：dispatcherservlet、HandlerMapping、HandlerAdapter、ViewResolver1、用户发送请求（url），dispatcherservlet将url 交给HandlerMapping处理，处理完成后返回：HandlerExecutionChain对象（Controller、Interceptor）2、dispatcherservlet将controller交给HandlerAdapter处理，调用Handle方法，返回ModelAndView。

3、dispatcherservlet将MV交给ViewResolver处理，将MV对象拆分成了model和view，并且将model渲染到view视图。

4、dispatcherservlet将view响应给用户。

2、入门程序●编写Controller ---- @Controller注解。

●指定访问的url --- @RequestMapping●编写springmvc核心配置文件：配置了三个基本点、扫描controller●编写web.xml：加载springmvc的配置文件、配置访问拦截的url、配置dispatcherservlet3、ssm整合(springMVC—spring--mybatis)●思路：整合包●环境搭建1、创建web工程2、导入所有的jar包3、mybatis全局配置文件4、将mybatis交给spring管理的配置文件5、管理所有service的配置文件6、管理事务的配置文件7、编写springmvc框架启动时需要的核心配置文件（加载了所有的配置文件）8、编写web.xml9、资源文件（日志、连接数据库）●dao层开发●service开发●controller开发4、springmvc的参数绑定●概念●默认支持参数绑定：requst、response、session、modle、modelmap●与基本类型的参数绑定：要求：请求key的名称与形参名称保持一致。

springMVC基于注解的控制器

springMVC基于注解的控制器springMVC基于注解的控制器的优点有两个：1、控制器可以处理多个动作，这就允许将相关操作写在⼀个类中。

2、控制器的请求映射不需要存储在配置⽂件中。

使⽤requestMapping注释类型，可以对⼀个⽅法进⾏请求处理。

接下来介绍两个最重要的注释类型：⼀、controller注释类型这种注释类型⽤于指⽰Spring类的实例是⼀个实例；import org.springframework.stereotype;public class CustemerController{//methods}Spring 使⽤扫描机制来找到应⽤程序中所有基于注解的控制器类；1、配置spring-context<beans...xmlns:context="/schema/context"...>2、配置<component-scan/>假设所有的控制器类都在com.example.controller及其⼦包中<context:component-scan base-package="com.example.controller"/>⼆、RequestMapping注解类型1、为每个动作开发相应的处理⽅法。

使⽤org.springframework.web.bind.annotation.RequestMapping注解类型映射URI和⽅法；RequestMapping映射了⼀个请求和⼀种⽅法。

可以使⽤@RequestMapping注解⼀种⽅法或类。

看下⾯例⼦：@Controllerpublic class CustemerController{@RequestMapping(value = "/customer_input")public String inputCustemer(){//do somethingreturn "CustemerForm";}}value 属性就是将URI映射到⽅法。

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

Springmvc学习笔记(二)
通过实例学习注解式控制器
一、注解式控制器简介
Spring2.5之前，我们都是通过实现Controller接口或其实现来定义我们的处理器类。

Spring2.5之后引入注解式处理器支持，通过@Controller 和@RequestMapping注解定义我们的处理器类。

通过笔记（一）的例子，我们已经初步认识了基于注解的控制器实现方式。

下面我们来详细介绍一下注解式控制器运行流程与使用方法。

@Controller：用于标识是处理器类；
@RequestMapping：请求到处理器功能方法的映射规则；
@RequestParam：请求参数到处理器功能处理方法的方法参数上的绑定；
@ModelAttribute：请求参数到命令对象的绑定；
@SessionAttributes：用于声明session级别存储的属性，放置在处理器类上，通常列出模型属性（如@ModelAttribute）对应的名称，则这些属性会透明的保存到session中；
@CookieValue：cookie数据到处理器功能处理方法的方法参数上的绑定；
@RequestHeader：请求头（header）数据到处理器功能处理方法的方法参数上的绑定；
@RequestBody：请求的body体的绑定（通过HttpMessageConverter进行类型转换）；
@ResponseBody：处理器功能处理方法的返回值作为响应体（通过HttpMessageConverter进行类型转换）；
@ResponseStatus：定义处理器功能处理方法/异常处理器返回的状态码和原因；
@ExceptionHandler：注解式声明异常处理器；
@PathVariable：请求URI中的模板变量部分到处理器功能处理方法的方法参数上的绑定，从而支持RESTful架构风格的URI；
二、用户管理系统实例（Springmvc+hibernate+Spring）
（一）环境搭建
1. 创建User实体类
2. 进行Dao层，Service层的搭建，这里不再赘述。

3. 创建Spring的配置文件，配置基于注解的IOC配置。

4. 创建hibernate配置文件，配置数据库方言，注册User。

5. 创建pringmvc配置文件，开启基于注解的控制器配置
6. 修改web.xml。

这里只是简略的说明一下环境搭建的步骤，具体的配置见源码。

（二）功能的实现
1. UserController：
也就是说，我要访问这个控制器里的方法，url必须为”user/…”
2. 查询User列表
list.jsp页面：
3. 添加User：
list.jsp页面：
add.jsp
4. 修改User
list.jsp中：
update.jsp:
5. 登录LoginController：
login.jsp
6. 注销
list.jsp中：
（三）系统实现
1. 启动tomcat，访问localhost:8080/springmvc_hibernate_spring/login/
跳转到了http://localhost:8080/springmvc_hibernate_spring/user/list
添加用户：
修改用户：。