文档章节

SpringMVC

Romanceling
 Romanceling
发布于 2016/05/30 22:33
字数 1917
阅读 156
收藏 17

五大组件;运行原理;编程步骤;运行步骤;用注解的方式开发处理器;读取请求参数值;向页面传值;如何重定向
-------------------------------------------------------------------------------------------------------------------------

SpringMVC:是一个mvc框架,用来简化web应用程序的开发.


五大组件:
. DispatcherServlet(前端控制器)
. HandlerMapping(处理映射)
. Controller(处理器)
. ModelAndView(模型和视图)
. ViewResovler(视图解析器)

运行原理:

step1.请求先发送给DispatcherServlet,
DispatcherServlet会依据HandlerMapping
的配置调用相应的处理器(Controller)来处理。
step2.处理器将处理结果封装成ModelAndView
之后发送给DispatcherServlet。
step3.DispatcherServlet会调用ViewResovler来
将视图名解析成真正的视图对象(也就是说,
到底使用哪种技术来展现数据)。
step4.视图对象对数据进行处理,生成相应的页面

编程步骤:
step1. 导包(springmvc)相关的jar文件。
step2. 添加spring配置文件。
step3. 配置前端控制器(DispatcherServlet)。
注:web.xml文件当中去配置。
step4. 写Controller
注:业务处理写在Controller里面。
step5. 写JSP
step6. 修改spring配置文件,添加
HandleMapping与ViewResolver的配置信息。

运行步骤:

------------------------------------------------------------------------------------------------------------------------
最简单的一个案例示范:
1.导包:spring-webmvc,javaee-api-5,junit等.
2.spring配置文件:在resources下创建app.xml
3.配置前段控制器:web.xml里配置:
  <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>
          org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:app.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>*.do</url-pattern>
  </servlet-mapping>

4.编写Controller
/**
 * 处理器:用于处理业务逻辑
 * 要求:
 * 1.实现Controller接口
 * 2.在handlerRequest方法当中完成业务逻辑处理.该方法必须将处理结果封装成
 *      ModelAndView对象,然后返回.
 * @author Administrator
 *
 */

public class HelloController implements Controller {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("HelloController的handleRequest方法...");
        /*
         * ModelAndView有两个构造器:
         * 1.ModelAndView(String viewName)
         *   viewName:视图名称,视图名称会被ViewResolver解析成相应的视图对象(如jsp.)
         * 2.ModelAndView(String viewName,Map data)
         *   data:处理结果.
         */
        return new ModelAndView("hello");
    }    
}

5.写jsp:在WEB-INF下写hello.jsp
    <h1>Hello,SpringMVC!</h1>

6.修改spring配置:

<?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:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:jee="http://www.springframework.org/schema/jee" 
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">
    <!-- 
        配置HandleMapping负责指定请求路径与处理器(Controller)的对应关系.
     -->
    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="/hello.do">helloController</prop>
            </props>
        </property>
    </bean>
    
    <!-- 配置处理器 -->
    <bean id="helloController" class="controller.HelloController"/>
    
    <!-- 
        配置视图解析器:
        负责将视图名解析成真正的视图对象(比如jsp)
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>
------------------------------------------------------------------------------------------------------------------------
用注解的方式开发处理器:
步骤:
step1.导包
step2.配置文件
step3.配置DispatcherServlet
step4.写Controller
. 不用实现Controller接口。
. 可以添加多个处理方法。
. 处理方法写起来更灵活:方法名不做要求,返回值可以是ModelAndView,可以是String,也可以void。
. 使用到的注解:
@Controller : 要加在类前面。
@RequestMapping:可以加到类前面,也可以添加到处理方法前面。用来设置请求路径与
处理方法的对应关系。
step5.写jsp
step6.修改配置文件


**读取请求参数值

方式一:通过request。

方式二:处理方法的入参与请求参数名一致。

注:如果不一致,可以使用 @RequestParam(请求参数名)。

方式三:封装成javabean。

step1. 先写一个java类,该类要添加与请求参数名一致的属性,并且为这些
属性添加相应的get/set方法。
step2. 将这个类作为处理方法的入参。

**向页面传值

方式一:使用ModelAndView

step1. 将处理结果放到Map对象里面。
step2. 将Map对象添加到ModelAndView对象里面。
step3. 将ModelAndView作为处理方法的返回值。

方式二:使用request。

方式三:使用ModelMap对象作为处理方法的入参。

方式四:使用session。

如何重定向?

. 默认情况下,springmvc会使用转发机制。
. 如果要重定向,要看处理方法的返回值的类型。
情形一:返回值是String。
return “redirect:index.do”;
情形二: 返回值是ModelAndView。
step1. RedirectView rv = new RedirectView(“index.do”);
step2. return new ModelAndView(rv);


/**
 * 用注解的方式来开发处理器
 * 1.不用实现Controller接口(非侵入式)
 * 2.可以添加多个处理方法
 * 3.处理方法:
 *  a.方法名不做要求
 *  b.返回值可以是ModelAndView,可以是String,也可以是void.
 * 4.使用到的注解:
 *  @Controller :要加载类前面.
 *  @RequestMapping:可以加到类前面,也可以添加到处理方法前面,
 *  用来设置请求路径与处理方法的对应关系.
 * @author Administrator
 *
 */
@Controller
//@RequestMapping("/demo") http://ip:port/springcase-day04/demo/hello.do
public class HelloController {
    @RequestMapping("/hello.do")
    public ModelAndView toHello(){
        System.out.println("HelloController的toHello方法...");
        return new ModelAndView("hello");
    }
    
    @RequestMapping("/toLogin.do")
    /**
     * 处理方法的返回值可以是ModelAndView,也可以是String.区别:
     * 如果返回的既有数据也有视图名,可以使用ModelAndView,
     * 如果返回值只有视图名,可以直接返回String
     * @return  视图名
     */
    public String toLogin(){
        System.out.println("HelloController的toLogin方法...");
        return "login";
    }
    
    @RequestMapping("/login.do")
    //获得请求参数值的第一种方式:
    public String checkLogin(HttpServletRequest request) throws IOException{
        request.setCharacterEncoding("utf-8");
        String code = request.getParameter("code");
        String password = request.getParameter("pwd");
        System.out.println(code);
        System.out.println(password);
        //默认情况下,前端控制器会转发到某个jsp页面
        return "success";
    }
    
    @RequestMapping("/login2.do")
    /**
     * 获得请求参数值的第二种方式:
     * 处理方法的入参与请求参数名一致
     * 注:如果不一致,可以使用RequestParam(请求参数名)
     * @param code
     * @param pwd
     * @return
     */
    public String checkLogin2(String code,@RequestParam("pwd")String password){
        System.out.println("HelloController的checkLogin2方法...");
        System.out.println("code:"+code+","+"password:"+password);
        return "success";
    }
    
    @RequestMapping("/login3.do")
    /**
     * 读取请求参数的第三种方式:
     * step1.先写一个java类,该类要添加与请求参数名一致的属性,并且为这些属性添加get/set
     * step2.将这个类作为处理方法的入参
     * @return
     */
    public String checkLogin3(User user){
        System.out.println("HelloController的checkLogin3方法...");
        System.out.println("code:"+user.getCode()+"password:"+user.getPwd());
        return "success";
    }
    
    /**
     * 使用ModelAndView向页面传值
     * @return
     */
    @RequestMapping("/login4.do")
    public ModelAndView checkLogin4(User user){
        System.out.println("HelloController的checkLogin4方法...");
        System.out.println("code:"+user.getCode()+","+"password:"+user.getPwd());
        
        //要将处理结果封装成一个map
        Map<String,Object> data = new HashMap<String,Object>();
        //相当于执行了req.setAttribute
        data.put("code", user.getCode());
        ModelAndView mav = new ModelAndView("success",data);
        return mav;
    }
    
    /**
     * 使用request对象向页面传值
     * @return
     */
    @RequestMapping("/login5.do")
    public String checkLogin5(User user,HttpServletRequest request){
        System.out.println("HelloController的checkLogin5方法...");
        request.setAttribute("user", user);
        return "success";
    }
    
    /**
     * 使用ModelMap对象来向页面传值.
     * @return
     */
    @RequestMapping("/login6.do")
    public String checkLogin6(User user,ModelMap data){
        System.out.println("HelloController的checkLogin6方法...");
        //相当于req.setAttribute
        data.addAttribute("user", user);
        return "success";
    }
    
    @RequestMapping("/login7.do")
    /**
     * 使用session向页面传值
     * @return
     */
    public String checkLogin7(User user,HttpSession session){
        System.out.println("HelloController的checkLogin7方法...");
        session.setAttribute("user", user);
        return "success";
    }
    
    @RequestMapping("/login8.do")
    /**
     * 演示如何重定向
     * 如果处理方法的返回值是String,只需要将"redirect:"作为返回值的前缀.
     * @return
     */
    public String checkLogin8(){
        System.out.println("HelloController的checkLogin8方法...");
        return "redirect:toSuccess.do";
    }    
    @RequestMapping("/toSuccess.do")
    public String toSuccess(){
        return "success";
    }
    
    @RequestMapping("/login9.do")
    /**
     * 演示重定向
     * @return
     */
    public ModelAndView checkLogin9(){
        System.out.println("HelloController的checkLogin9方法...");
        RedirectView rv = new RedirectView("toSuccess.do");
        return new ModelAndView(rv);
    }
}

/**
 * 用来封装请求参数
 * @author Administrator
 *
 */
public class User {
    private String code;
    private String pwd;
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }    
}

© 著作权归作者所有

上一篇: Spring提高
下一篇: Spring基础
Romanceling
粉丝 14
博文 166
码字总数 91809
作品 0
无锡
程序员
私信 提问

暂无文章

Spring AOP-06-切入点类型

切入点是匹配连接点的拦截规则。之前使用的是注解@Pointcut,该注解是AspectJ中的。除了这个注解之外,Spring也提供了其他一些切入点类型: • 静态方法切入点StaticMethodMatcherPointcut •...

moon888
昨天
90
0
Class Loaders in Java

1. Introduction to Class Loaders Class loaders are responsible for loading Java classes during runtime dynamically to the JVM (Java Virtual Machine). Also, they are part of the ......

Ciet
昨天
68
0
以Lazada为例,看电商系统架构演进

什么是Lazada? Lazada 2012年成立于新加坡,是东南亚第一电商,2016年阿里投资10亿美金,2017年完成对lazada的收购。 业务模式上Lazada更偏重自营,类似于亚马逊,自建仓储和为商家提供服务...

春哥大魔王的博客
昨天
60
0
【自用】 Flutter Timer 简单用法

dart: void _startTime() async { _timer = Timer(Duration(seconds: sec), () { fun(xxx,yyy,zzz); }); } @override void dispose() { _timer.cancel()......

Tensor丨思悟
昨天
65
0
计算机实现原理专题--自动化(六)

目前实现的加减法器可以扩充到更高位宽的数值范围,不仅可以实现连续n个数的相加减,还可以实现其中几个数的相加减,并保存相应的结果。但是还不能应对某些场景,例如需要复用中间的临时结果...

FAT_mt
昨天
58
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部