转载自：https://www.cnblogs.com/fengrui-/p/6074381.html

一、简介

在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse 等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获取到。为了先对Controller 有一个初步的印象，以下先定义一个简单的Controller ：
@Controller
public class MyController {

    @RequestMapping ( "/showView" )
    public ModelAndView showView() {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
       return modelAndView;
    }

}

在上面的示例中，@Controller 是标记在类MyController 上面的，所以类MyController 就是一个SpringMVC Controller 对象了，然后使用@RequestMapping(“/showView”) 标记在Controller 方法上，表示当请求/showView.do 的时候访问的是MyController 的showView 方法，该方法返回了一个包括Model 和View 的ModelAndView 对象。

二、使用 @Controller 定义一个 Controller 控制器

@Controller 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。@Controller 只是定义了一个控制器类，而使用@RequestMapping 注解的方法才是真正处理请求的处理器，这个接下来就会讲到。
单单使用@Controller 标记在一个类上还不能真正意义上的说它就是SpringMVC 的一个控制器类，因为这个时候Spring 还不认识它。那么要如何做Spring 才能认识它呢？这个时候就需要我们把这个控制器类交给Spring 来管理。拿MyController 来举一个例子
@Controller
public class MyController {
    @RequestMapping ( "/showView" )
    public ModelAndView showView() {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
       return modelAndView;
    }

}

这个时候有两种方式可以把MyController 交给Spring 管理，好让它能够识别我们标记的@Controller 。
第一种方式是在SpringMVC 的配置文件中定义MyController 的bean 对象。
<bean class="com.host.app.web.controller.MyController"/>

第二种方式是在SpringMVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。
 < context:component-scan base-package = "com.host.app.web.controller" >
       < context:exclude-filter type = "annotation"
           expression = "org.springframework.stereotype.Service" />
    </ context:component-scan > 

注：上面 context:exclude-filter 标注的是不扫描 @Service 标注的类
三、使用 @RequestMapping 来映射 Request 请求与处理器

可以使用@RequestMapping 来映射URL 到控制器类，或者是到Controller 控制器的处理方法上。当@RequestMapping 标记在Controller 类上的时候，里面使用@RequestMapping 标记的方法的请求地址都是相对于类上的@RequestMapping 而言的；当Controller 类上没有标记@RequestMapping 注解时，方法上的@RequestMapping 都是绝对路径。这种绝对路径和相对路径所组合成的最终路径都是相对于根路径“/ ”而言的。
@Controller
public class MyController {
    @RequestMapping ( "/showView" )
    public ModelAndView showView() {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
       return modelAndView;
    }

}

在这个控制器中，因为MyController 没有被@RequestMapping 标记，所以当需要访问到里面使用了@RequestMapping 标记的showView 方法时，就是使用的绝对路径/showView.do 请求就可以了。
@Controller
@RequestMapping ( "/test" )
public class MyController {
    @RequestMapping ( "/showView" )
    public ModelAndView showView() {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
       return modelAndView;
    }

}

这种情况是在控制器上加了@RequestMapping 注解，所以当需要访问到里面使用了@RequestMapping 标记的方法showView() 的时候就需要使用showView 方法上@RequestMapping 相对于控制器MyController上@RequestMapping 的地址，即/test/showView.do 。
（一）使用 URI 模板

URI 模板就是在URI 中给定一个变量，然后在映射的时候动态的给该变量赋值。如URI 模板http://localhost/app/{variable1}/index.html ，这个模板里面包含一个变量variable1 ，那么当我们请求http://localhost/app/hello/index.html 的时候，该URL 就跟模板相匹配，只是把模板中的variable1 用hello 来取代。在SpringMVC 中，这种取代模板中定义的变量的值也可以给处理器方法使用，这样我们就可以非常方便的实现URL 的RestFul 风格。这个变量在SpringMVC 中是使用@PathVariable 来标记的。
在SpringMVC 中，我们可以使用@PathVariable 来标记一个Controller 的处理方法参数，表示该参数的值将使用URI 模板中对应的变量的值来赋值。
@Controller
@RequestMapping ( "/test/{variable1}" )
public class MyController {

    @RequestMapping ( "/showView/{variable2}" )
    public ModelAndView showView( @PathVariable String variable1, @PathVariable ( "variable2" ) int variable2) {
       ModelAndView modelAndView = new ModelAndView();
       modelAndView.setViewName( "viewName" );
       modelAndView.addObject( " 需要放到 model 中的属性名称 " , " 对应的属性值，它是一个对象 " );
       return modelAndView;
    }
}

在上面的代码中我们定义了两个URI 变量，一个是控制器类上的variable1 ，一个是showView 方法上的variable2，然后在showView 方法的参数里面使用@PathVariable 标记使用了这两个变量。所以当我们使用/test/hello/showView/2.do 来请求的时候就可以访问到MyController 的showView 方法，这个时候variable1 就被赋予值hello ，variable2 就被赋予值2 ，然后我们在showView 方法参数里面标注了参数variable1 和variable2 是来自访问路径的path 变量，这样方法参数variable1 和variable2 就被分别赋予hello 和2 。方法参数variable1 是定义为String 类型，variable2 是定义为int 类型，像这种简单类型在进行赋值的时候Spring 是会帮我们自动转换的
在上面的代码中我们可以看到在标记variable1 为path 变量的时候我们使用的是@PathVariable ，而在标记variable2 的时候使用的是@PathVariable(“variable2”) 。这两者有什么区别呢？第一种情况就默认去URI 模板中找跟参数名相同的变量，但是这种情况只有在使用debug 模式进行编译的时候才可以，而第二种情况是明确规定使用的就是URI 模板中的variable2 变量。当不是使用debug 模式进行编译，或者是所需要使用的变量名跟参数名不相同的时候，就要使用第二种方式明确指出使用的是URI 模板中的哪个变量。
除了在请求路径中使用URI 模板，定义变量之外，@RequestMapping 中还支持通配符“* ”。如下面的代码我就可以使用/myTest/whatever/wildcard.do 访问到Controller 的testWildcard 方法。
@Controller
@RequestMapping ( "/myTest" )
public class MyController {
    @RequestMapping ( "*/wildcard" )
    public String testWildcard() {
       System. out .println( "wildcard------------" );
       return "wildcard" ;
    }  
}

（二）使用 @RequestParam 绑定 HttpServletRequest 请求参数到控制器方法参数
@RequestMapping ( "requestParam" )
   public String testRequestParam( @RequestParam(required=false) String name, @RequestParam ( "age" ) int age) {
       return "requestParam" ;
   } 

在上面代码中利用@RequestParam 从HttpServletRequest 中绑定了参数name 到控制器方法参数name ，绑定了参数age 到控制器方法参数age 。值得注意的是和@PathVariable 一样，当你没有明确指定从request 中取哪个参数时，Spring 在代码是debug 编译的情况下会默认取更方法参数同名的参数，如果不是debug 编译的就会报错。此外，当需要从request 中绑定的参数和方法的参数名不相同的时候，也需要在@RequestParam 中明确指出是要绑定哪个参数。在上面的代码中如果我访问/requestParam.do?name=hello&age=1 则Spring 将会把request请求参数name 的值hello 赋给对应的处理方法参数name ，把参数age 的值1 赋给对应的处理方法参数age 。
在@RequestParam 中除了指定绑定哪个参数的属性value 之外，还有一个属性required ，它表示所指定的参数是否必须在request 属性中存在，默认是true ，表示必须存在，当不存在时就会报错。在上面代码中我们指定了参数name 的required 的属性为false ，而没有指定age 的required 属性，这时候如果我们访问/requestParam.do而没有传递参数的时候，系统就会抛出异常，因为age 参数是必须存在的，而我们没有指定。而如果我们访问/requestParam.do?age=1 的时候就可以正常访问，因为我们传递了必须的参数age ，而参数name 是非必须的，不传递也可以。

接上篇文章，HelloWorld程序中我们已经创建了一个HellController，里面包含了响应JSON的方法，本文针对Controller再做一下讲解。
回顾上篇文章，我们在Controller中使用 @RestController 注解，该注解是Spring 4.0引入的。查看源码可知其包含了 @Controller 和 @ResponseBody 注解。我们可以理解为 @Controller的增强版。专门为响应内容式的 Controller 而设计的，可以直接响应对象为JSON。

而 @Controller 用来响应页面，spring-boot 支持多种模版引擎包括：

1，FreeMarker

2，Groovy

3，Thymeleaf （Spring 官网使用这个）

4，Velocity

5，JSP （貌似Spring Boot官方不推荐，STS创建的项目会在src/main/resources 下有个templates 目录，这里就是让我们放模版文件的，然后并没有生成诸如 SpringMVC 中的webapp目录）

不过本文还是选择大家都熟悉的JSP来举例，因为使用JSP与默认支持的模版需要特殊处理，所以拿来举例更好。
关于Controller 方法可以接收参数使用@RequestBody、@RequestParam、@ModelAttribute、JSONObject、HttpEntity 等方式，皆与Spring的使用一样，这里不做赘述。
下面我们来说一下如何使用 @Controller 实现响应JSP页面（与SpringMVC也是一样使用）。

创建PageController，编码如下：
package org.springboot.sample.controller;

import java.util.Date;
import java.util.Map;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class PageController {
	
	// 从 application.properties 中读取配置，如取不到默认值为Hello Shanhy
	@Value("${application.hell:Hello Shanhy}")
	private String hello = "Hello Shanhy";

	/**
	 * 默认页<br/>
	 * @RequestMapping("/") 和 @RequestMapping 是有区别的
	 * 如果不写参数，则为全局默认页，加入输入404页面，也会自动访问到这个页面。
	 * 如果加了参数“/”，则只认为是根页面。
	 *
	 * @return
	 * @author SHANHY
	 * @create  2016年1月5日
	 */
	@RequestMapping(value = {"/","/index"})
	public String index(Map<String, Object> model){
		// 直接返回字符串，框架默认会去 spring.view.prefix 目录下的 （index拼接spring.view.suffix）页面
		// 本例为 /WEB-INF/jsp/index.jsp
		model.put("time", new Date());
		model.put("message", this.hello);
		return "index";
	}
	
	/**
	 * 响应到JSP页面page1
	 *
	 * @return
	 * @author SHANHY
	 * @create  2016年1月5日
	 */
	@RequestMapping("/page1")
	public ModelAndView page1(){
		// 页面位置 /WEB-INF/jsp/page/page1.jsp
		ModelAndView mav = new ModelAndView("page/page1");
		mav.addObject("content", hello);
		return mav;
	}
	
	/**
	 * 响应到JSP页面page1（可以直接使用Model封装内容，直接返回页面字符串）
	 *
	 * @return
	 * @author SHANHY
	 * @create  2016年1月5日
	 */
	@RequestMapping("/page2")
	public String page2(Model model){
		// 页面位置 /WEB-INF/jsp/page/page1.jsp
		model.addAttribute("content", hello + "（第二种）");
		return "page/page1";
	}
}

pom.xml添加依赖：
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
		</dependency>

上面说了spring-boot 不推荐JSP，想使用JSP需要配置application.properties。

添加src/main/resources/application.properties内容：
# 页面默认前缀目录
spring.mvc.view.prefix=/WEB-INF/jsp/
# 响应页面默认后缀
spring.mvc.view.suffix=.jsp
# 自定义属性，可以在Controller中读取
application.hello=Hello Shanhy

在 src/main 下面创建 webapp/WEB-INF/jsp 目录用来存放我们的jsp页面。

index.jsp
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Spring Boot Sample</title>
</head>

<body>
	Time: ${time}
	<br>
	Message: ${message}
</body>
</html>

page1.jsp
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Spring Boot Sample</title>
</head>

<body>
	<h1>${content }</h1>
</body>
</html>

要想让spring-boot支持JSP，需要将项目打成war包。

我们做最后一点修改，修改pom.xml文件，将 jar 中的 jar 修改为 war
然后启动spring-boot服务。

访问页面查看结果：
http://localhost:8080
http://localhost:8080/page1
http://localhost:8080/page2
最后附上工程结构：

如果需要使用 FreeMarker 的同学，请按下面的方法说明修改：

1、去掉 application.properties 中的 spring.mvc.view.prefix 和 spring.mvc.view.suffix 配置。

2、将 .ftl 模版页面放到 resources/templates 中（如上面工程截图所示）

其中 error.ftl 是系统默认的错误页，内容自定。

3、修改 pom.xml ，如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.springboot.sample</groupId>
	<artifactId>spring-boot-sample</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
<!-- 	<packaging>war</packaging> -->

	<name>spring-boot-sample</name>
	<description>Spring Boot Sample Web Application</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.3.1.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		
<!-- 		<dependency> -->
<!-- 			<groupId>org.springframework.boot</groupId> -->
<!-- 			<artifactId>spring-boot-starter-web</artifactId> -->
<!-- 		</dependency> -->
<!-- 		<dependency> -->
<!-- 			<groupId>org.springframework.boot</groupId> -->
<!-- 			<artifactId>spring-boot-starter-tomcat</artifactId> -->
<!-- 		</dependency> -->
<!-- 		<dependency> -->
<!-- 			<groupId>org.apache.tomcat.embed</groupId> -->
<!-- 			<artifactId>tomcat-embed-jasper</artifactId> -->
<!-- 			<scope>provided</scope> -->
<!-- 		</dependency> -->
<!-- 		<dependency> -->
<!-- 			<groupId>javax.servlet</groupId> -->
<!-- 			<artifactId>jstl</artifactId> -->
<!-- 		</dependency> -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-freemarker</artifactId>
		</dependency>
	</dependencies>
	
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
	

</project>

1. @Controller控制层
2. @Service()
3. @Repository持久层


@Autowired依赖注入源码分析
1. @Controller控制层

@Controller用于标记在一个类上，使用它标记的类就是一个SpringMvc Controller对象，分发处理器会扫描使用该注解的类的方法，并检测该方法是否使用了@RequestMapping注解。
@Controller只是定义了一个控制器类，而使用@RequestMapping注解的方法才是处理请求的处理器。

@Controller标记在一个类上还不能真正意义上说它就是SpringMvc的控制器，应为这个时候Spring还不认识它，这个时候需要把这个控制器交给Spring来管理。有两种方式可以管理：

<!--基于注解的装配-->
<!--方式一-->
<bean class="com.HelloWorld"/>
<!--方式二-->
<!--路径写到controller的上一层-->
<context:component-scan base-package="com"/>

Action层:
package com;
@Controller
public class HelloWorld{
	
	@RequestMapping(value="/showRegUser")
	public String printHello() {
		return "hello";
	}

    @Autowried
    private IocSerevce service;
    public void add(){
        service.add();
    }
}


component-scan默认扫描的注解类型是@Component,不过，在@Component的语义基础之上细化为@Reposity，@Service,@Controller.

有一个use-defaultbao'i-filters属性，属性默认是true,表示会扫描抱下所有的标有@Component的类，并注册为bean，也就是@Component的子注解@Service,@reposity等

如果只想扫描包下的@Controller或其他内容，则设置use-default-filters属性为false，表示不再按照scan指定的包进行扫描，而是按照指定包进行扫描

<context:component-scan base-package="com" user-default-filters="false">
    <context:include-filter type="regex" expression="com.tan.*"/>
</context:component-scan>

当没有设置use-default-filters属性或属性为true时，表示基于base-package包下指定扫描的具体路径。
2. @Service()


此注注解属于业务逻辑层，service或者manager层

默认按照名称进行装配，如果名称可以通过name属性指定，如果没有name属性，注解写在字段上时，默认去字段名进行查找，如果注解写在setter方法上，默认按照方法属性名称进行装配。当找不到匹配的bean时，才按照类型进行装配，如果name名称一旦指定就会按照名称进行装配

Service层：
@Service()
public class IocService{

    @Resource
    private IIocDao iiocDao;
    public void add(){
        iiocDao.add();
    }
}

3. @Repository持久层
此注解式持久层组件，用于标注数据访问组件，即DAO组件

DAO层

先定义一个接口
public interface IIocDao{
    public void add();
}

然后实现类
//Dao层中定义了一些接口
//表示将Dao类声明为bean
@Repository
public class IocDao implements IIocDao{
    public void add(){
        System.out.println("调用了Dao");
    }
}


另外一种解释：
@Repository对应数据访问层Bean

@Repository(value="userDao")
public class UserDaoImpl extends BeansDaoImpl<User>{
    ......
}

@Repository(value=“userDao”)注解告诉Spring ,让Spring创建一个名字叫做"userDao"的UserDapImpl实例。

当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使用@Resource(name=“userDao”)注解告诉Spring,Spring把创建好的userDao注入给Service即可。
 //注入userDao，从数据库中根据用户Id取出指定用户时需要用到
 @Resource(name = "userDao")
 private BaseDao<User> userDao;

参考文章:https://www.cnblogs.com/xdp-gacl/p/3495887.html

  
1.不带参数跳转


1.1 
同一个controller内部跳转



return "redirect:/toList";   //可以省略一层路径
等价于    
return new ModelAndView("redirect:/toList");

1.2 
不同controller内部跳转



return return "redirect:/MESBcElectric/list"; //两层路径必须齐全


  
2.拼接参数跳转


2.1 自己拼接参数 

RedirectAttributes attr



return "redirect:/MESBcElectric/list?name="+name+"&password="+password;
//自己在路径后拼接需要传递到另一个controller中的参数

缺点：自己拼接的参数，若是中文，会出现乱码 

2.2 利用类拼接参数

RedirectAttributes attr； 

attr.addAttribute(“name”, value);



public String findlist(MESBcElectric mESBcElectric,RedirectAttributes attr){

        //自动拼接参数
        attr.addAttribute("process", mESBcElectric.getProcess());

        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM");
        Date date1 = mESBcElectric.getDate();
        String date=sdf.format(date1);  
        attr.addAttribute("date",date);//将date由日期类型转化为字符串类型再进行拼接

        return "redirect:/MESBcElectric/list";
        跳转后链接地址为：
return "redirect:/MESBcElectric/list?process="+mESBcElectric.getProcess()+"&date="+date;

利用类拼接的参数，不会出现中文乱码


  
3.带参数不拼接url页面


RedirectAttributes attr； 

attr.addFlashAttribute(“name”, form.getName()); 

页面取值，直接用el表达式就能获得到，这里的原理是放到session中，session在跳到页面后马上移除对象。所以你刷新一下后这个值就会丢掉。 

    @RequestMapping("/save")  
    public String save(@ModelAttribute("form") Bean form,RedirectAttributes attr)  
                   throws Exception {  

        String code =  service.save(form);  

        attr.addFlashAttribute("name", form.getName());//暂时存在session中    
        attr.addFlashAttribute("success", "添加成功!");  
        return "redirect:/index"; 
       } 


@RequestMapping("/index")  


    public String save(@ModelAttribute("form") Bean form,RedirectAttributes attr)  
                   throws Exception {  
            return "redirect:/main/list";  
    }  


注意 

attr.addAttribute(“a”, “a”); 和 attr.addFlashAttribute(“b”, “b”);的区别

1.使用RedirectAttributes的addAttribute方法传递参数会跟随在URL后面 ，如上代码即为http:/index.action?a=a  。

2.使用addFlashAttribute不会跟随在URL后面，会把该参数值暂时保存于session，待重定向url获取该参数后从session中移除，这里的redirect必须是方法映射路径，jsp无效。你会发现redirect后的jsp页面中b只会出现一次，刷新后b再也不会出现了，这验证了上面说的，b被访问后就会从session中移除。对于重复提交可以使用此来完成.


  
重要知识


通过Controller跳转controller所带的参数会自动封装在下一个Controller的实体类对象中，无需再进行request获取