1.概述

Spring Boot简化了Spring应用的开发，不需要繁琐的XML配置就能开发。
那Spring Boot是怎么实现自动配置的呢？
这就要用到Spring Boot中提供的许多注解：

Spring提供XML配置、注解配置或Java配置来实现Bean的创建和注入
Spring IoC(ApplicationContext)容器负责进行扫描Bean，进行Bean的初始化、配置和依赖管理

本节介绍注解：

@Component
@Service
@Scope
@Repository
@Controller
@RestController
@RequestMapping
@PathVariable
@ResponseBody

2.声明Bean的注解

如何吸引Spring容器的注意而“有幸”成为Spring 容器管理的Bean呢？
在Spring Boot中就依靠注解，Spring提供了多个注解来声明Bean为Spring容器管理的Bean，注解不同代表的含义不同，但是对Spring容器来说都是Spring管理的Bean

声明Bean的注解有：

@Component 没有明确角色的组件
@Service 在业务逻辑层（Service层）使用
@Repositpry 在数据访问层（dao层）使用
@Controller 用于标注控制层组件
@RestController

3. @Component注解

@Component源码：

package org.springframework.stereotype;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @since 2.5
 * @see Repository
 * @see Service
 * @see Controller
 * @see org.springframework.context.annotation.ClassPathBeanDefinitionScanner // 扫描包中Bean，注册
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {

    // 如果有返回组件名称，否则返回空字符串
    String value() default "";

}

@Component作用在类上
@Component注解作用域默认为singleton
使用注解配置和类路径扫描时，被@Component注解标注的类会被Spring扫描并注册为Bean
@Component使用在不确定哪一个层的时候使用，可以作用在任何层次，把普通pojo实例化到spring容器
不推荐使用@Component注解，而应该使用它的扩展，如@Service、@Repository

3.1 @Component注解使用

package com.example.demo.annotation;

public interface IUser {
    public String get();
}

package com.example.demo.annotation.component;

@Component
public class UserComponentImpl implements IUser {
    private String name = "UserComponentImpl";

    @Override
    public String get() {
        return name;
    }
}

//@Component("componentBeanId")
@Component(value="componentBeanId")
public class UserComponentImplWithParam implements IUser {
    private String name = "UserComponentImplWithParam";

    @Override
    public String get() {
        return name;
    }
}

@Component注解测试：

package com.example.demo.annotation.component;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.example.demo.annotation.IUser;

@SpringBootApplication
public class ComponentApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ComponentApplication.class, args);

        IUser userComponentImpl1 = (UserComponentImpl)context.getBean("userComponentImpl");
        System.out.println(userComponentImpl1.get());

        IUser userComponentImpl2 = (UserComponentImplWithParam)context.getBean("componentBeanId");
        System.out.println(userComponentImpl2.get());
    }
}

@Component注解测试结果：
这里写图片描述

4. @Service注解

@Service注解源码：

package org.springframework.stereotype;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;

/**
 * @since 2.5
 * @see Component
 * @see Repository
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {

    @AliasFor(annotation = Component.class)
    String value() default "";

}

@Service是@Component注解的一个特例，作用在类上
@Service注解作用域默认为singleton
使用注解配置和类路径扫描时，被@Service注解标注的类会被Spring扫描并注册为Bean
@Service用于标注业务层组件,表示定义一个bean
@Service使用时没有传参数，Bean名称默认为当前类的类名，首字母小写
@Service(“serviceBeanId”)或@Service(value=”serviceBeanId”)使用时传参数，使用value作为Bean名字

4.1 @service注解使用

package com.example.demo.annotation;

public interface IUser {
    public String get();
}

package com.example.demo.annotation.service;

@Service
public class UserServiceImpl implements IUser {
    private final String name = "UserServiceImpl";

    public String get () {
        return name;
    }
}

//@Service("userService")
@Service(value="userService")
public class UserServiceImplWithParam implements IUser {
    private String name = "UserServiceImplWithParam";

    public String get() {
        return name;
    }
}

@Service注解测试：

package com.example.demo.annotation.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import com.example.demo.DemoApplication;
import com.example.demo.annotation.IUser;

@SpringBootApplication
public class ServiceApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);

        IUser serviceImpl1 = (UserServiceImpl) context.getBean("userServiceImpl");
        System.out.println(serviceImpl1.get());

        IUser serviceImpl2 = (UserServiceImplWithParam)context.getBean("userService");
        System.out.println(serviceImpl2.get());
    }
}

@Service注解测试结果：

说明：

扫描二维码关注公众号，回复： 3861460 查看本文章

@Service注解使用时不传参Bean名默认为当前类名，首字母小写
@Service注解使用时传参Bean名为参数value的值

这里写图片描述

4.2 @Scope注解

@Scope注解源码：

package org.springframework.context.annotation;

/**
 1. @since 2.5
 2. @see org.springframework.stereotype.Component
 3. @see org.springframework.context.annotation.Bean
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scope {

    @AliasFor("scopeName")
    String value() default "";

    @AliasFor("value")
    String scopeName() default "";

    ScopedProxyMode proxyMode() default ScopedProxyMode.DEFAULT;
}

@Scope有5中取值：
基本作用域：
org.springframework.beans.factory.config.ConfigurableBeanFactory.SCOPE_SINGLETON = "singleton"
org.springframework.beans.factory.config.ConfigurableBeanFactory.SCOPE_PROTOTYPE = "prototype"

Web作用域：
org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST = "request"
org.springframework.web.context.WebApplicationContext#SCOPE_SESSION = "session"
org.springframework.web.context.WebApplicationContext#SCOPE_APPLICATION = "application"

@Scope作用在类上和方法上
@Scope用来配置 spring bean 的作用域，它标识 bean 的作用域

4.2.1 singleton单例模式

Spring 容器中有且只有一个Bean实例，只要Spring容器不销毁或退出，该Bean实例就会一直存活

4.2.2 prototype原型模式

每次获取Bean的时候会有一个新的实例，Spring容器不能对返回Bean实例的整个生命周期负责

4.2.3 request模式

request只适用于Web程序，每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，当请求结束后，该对象的生命周期即告结束

4.2.4 session模式

session只适用于Web程序，session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效

4.2.5 application模式

application只适用于Web程序，全局作用域

4.3 @Service和@Scope注解一起使用

package com.example.demo.annotation.scope;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;

// 单例
@Service
@Scope("singleton")
public class SingletonScope {
    public SingletonScope() {

    }
}

//原型
@Service
@Scope("prototype")
public class PrototypeScope {
    public PrototypeScope() {

    }
}

@Service和@Scope注解测试：

package com.example.demo.annotation.scope;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class ScopeApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ScopeApplication.class, args);

        SingletonScope singletonScope1 = (SingletonScope) context.getBean("singletonScope");
        SingletonScope singletonScope2 = (SingletonScope) context.getBean("singletonScope");
        System.out.println("singleton单例模式：" + singletonScope1.equals(singletonScope2));

        PrototypeScope prototypeScope1 = (PrototypeScope) context.getBean("prototypeScope");
        PrototypeScope prototypeScope2 = (PrototypeScope) context.getBean("prototypeScope");
        System.out.println("prototype原型模式：" + prototypeScope1.equals(prototypeScope2));
    }
}

@Service和@Scope注解测试结果：

说明：

singleton模式得到的Bean是相同的，单例
prototype模式每次得到的Bean是不同的

这里写图片描述

5.@Repository注解

@Repository注解源码：

package org.springframework.stereotype;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;

/**
 * @since 2.0
 * @see Component
 * @see Service
 * @see org.springframework.dao.DataAccessException
 * @see org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {

    @AliasFor(annotation = Component.class)
    String value() default "";

}

@Repository注解作用在类上
@Repository注解作用域默认为singleton
使用注解配置和类路径扫描时，被@Reposito注解标注的类会被Spring扫描并注册为Bean
@Repository注解用于标注数据访问组件，即DAO组件
@Repository注解的作用不只是将类识别为Bean，同时它还能将所标注的类中抛出的数据访问异常封装为 Spring 的数据访问异常类型

5.1 @Repository注解使用

package com.example.demo.chapter1.annotation.repository;

import org.springframework.stereotype.Repository;

// @Repository注解默认作用域为singleton

@Repository
public class UserRepositoryImpl {
    public  UserRepositoryImpl () {

    }
}

@Repository注解测试：

package com.example.demo.chapter1.annotation.repository;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

// @Repository注解测试

@SpringBootApplication
public class RepopsitoryApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(RepopsitoryApplication.class, args);

        UserRepositoryImpl userRepositoryImpl1 = (UserRepositoryImpl) context.getBean("userRepositoryImpl");
        UserRepositoryImpl userRepositoryImpl2 = (UserRepositoryImpl) context.getBean("userRepositoryImpl");
        System.out.println("@Repository注解默认作用域为singleton，返回true： " + userRepositoryImpl1.equals(userRepositoryImpl2));
    }
}

@Repository注解测试结果：

说明：

@Repository注解默认作用域为singlton，单例
@Repository与@Scope注解一起使用可以修改Bean的作用域

这里写图片描述

6.@Controller注解

@Controller注解源码：

package org.springframework.stereotype;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;

/**
 * @since 2.5
 * @see Component
 * @see org.springframework.web.bind.annotation.RequestMapping
 * @see org.springframework.context.annotation.ClassPathBeanDefinitionScanner
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {

    @AliasFor(annotation = Component.class)
    String value() default "";

}

@Controller注解作用在类上
使用注解配置和类路径扫描时，被@Controller注解标注的类会被Spring扫描并注册为Bean
@Controller用于标注Web中控制层组件
被@Controller标注的类负责处理由DispatcherServlet分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model返回给对应的View进行展示
@Controller和@RequestMapping、@RequestParam等一些注解共同处理URL的映射

7.@RequestMapping注解

@RequestMapping注解源码：

package org.springframework.web.bind.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;

/**
 * @since 2.5
 * @see GetMapping
 * @see PostMapping
 * @see PutMapping
 * @see DeleteMapping
 * @see PatchMapping
 * @see RequestParam
 * @see RequestAttribute
 * @see PathVariable
 * @see ModelAttribute
 * @see SessionAttribute
 * @see SessionAttributes
 * @see InitBinder
 * @see org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
 * @see org.springframework.web.reactive.result.method.annotation.RequestMappingHandlerAdapter
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {

    String name() default "";

    @AliasFor("path")
    String[] value() default {};

    @AliasFor("value")
    String[] path() default {};

    RequestMethod[] method() default {};

    String[] params() default {};

    String[] headers() default {};

    String[] consumes() default {};

    String[] produces() default {};
}

@RequestMapping注解作用在类或方法上
@RequestMapping注解用来处理请求地址映射
@RequestMapping注解有7个属性

7.1 value和path参数

指定请求的实际地址，指定的地址可以是URI Template 模式

使用示例：

@RequestMapping("/test")
@RequestMapping(value="/test")
@RequestMapping(path="/test")
@RequestMapping(path="/test/*.do")

7.2 method参数

指定请求的method类型，请求类型：

package org.springframework.web.bind.annotation

public enum RequestMethod {
    GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
}

Spring Boot也提供了简化版后的@RequestMapping

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

使用示例：

@RequestMapping(value="/test", method=RequestMethod.GET)
@RequestMapping(value="/test", method=RequestMethod.POST)
@GetMapping("/test")
@PostMapping("/test")

7.3 consumes参数

指定处理允许的媒体类型，例如application/json, text/html

类型参考值见：org.springframework.http.MediaType

// 仅处理request Content-Type为“text/plain”类型的请求
@RequestMapping(value="/test", consumes="text/plain")
@RequestMapping(value="/test", consumes={"text/plain", "application/*"})

7.4 produces参数

指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回

// 仅处理request请求中Accept头中包含了"text/plain"的请求，同时暗示了返回的内容类型为text/plain
@RequestMapping(value="/test", products="text/plain")
@RequestMapping(value="/test", produces={"text/plain", "application/*"})

7.5 params参数

指定request中必须包含的请求参数，才会进入此方法

// 仅处理请求中包含了名为“action”，值为“query”的请求
@RequestMapping(value = "/test", params="action=query")

7.6 headers参数

指定请求中必须包含的请求头，才能进入此方法

// 仅处理request的header中包含了指定content-type=text/*的请求；
@RequestMapping(value = "/pets", headers = "content-type=text/*")

7.7 @RequestMapping注解使用

方法上的@RequestMapping会继承在类上的@RequestMapping
返回字符串，默认是视图名
Spring Boot视图默认路径：resources/templates

package com.example.demo.chapter1.annotation.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/test")
public class ControllerTest {

    /**
     * http://localhost:8080/test
     * 返回字符串, 默认是视图的名称
     * 1.Spring Boot的视图默认保存路径是：resources/templates
     * 2.视图后缀根据选用的视图模板决定，如ftl,html
     * 2.本方法返回的视图是：resources/templates/html/index.ftl
     * */
    public String getX() {
        return "/html/index";
    }

    /**
     * http://localhost:8080/test/get.do
     * 
     * 方法上的@RequestMapping会继承在类上的@RequestMapping
     * */
    @RequestMapping("/index.do")
    public String getY() {
        return "/html/index";
    }
}

7.8 @RequestMapping请求路径匹配

符号 * 匹配任一字符
符号 ** 匹配任意路径
符号？匹配单个字符
如果一个请求有多个@Requestmapping能够匹配，通过匹配更具体的方法处理此请求

@Controller
@RequestMapping("/test")
public class ControllerTest {

    /**
     * http://localhost:8080/test/welcome/index.do
     * http://localhost:8080/test/welcome/hello.do
     * 
     * 路径匹配
     * */
    @RequestMapping("/welcome/*.do")
    public String getZ() {
        return "/html/welcome";
    }
}

7.9 @RequestMapping方法参数

@RequestMapping注解标注的方法可以接受多种类型的参数：
详细参考书籍：Spring Boot精髓从构建小系统到架构分布式大系统

@PathVariable - 将URL中的值映射到方法参数中
Model - Spring MVC中通用的模型
ModelAndView - 包含了模型和视图路径的对象
JavaBean - 将HTTP参数映射到JavaBean对象
MultipartFile - 用于处理文件上传
@ModelAttribute - 用于将该注解的变量作为Model的一个属性

7.9.1 @PathVariable注解

@PathVariable注解从请求URL中获取参数并映射到方法的参数中

符号 {} 中的变量名与方法参数名一一对应
如果不想对应，如@RequestMapping中的变量名为id，方法参数名为index，可以使用@PathVariable(“id”) String index来对应

@Controller
@RequestMapping("/test/{id}")
public class PathVariableTest {

    @GetMapping("/{name}/index.do")
    public String get (@PathVariable Integer id, @PathVariable String name) {
        return id + "_" + name;
    }
}

7.9.2 Model做方法参数

MVC框架中存在一个类似Map结构的Model，可以向Mdel中添加视图需要的变量
Model对象用于方法参数的时候，Spring MVC在调用方法前自动创建Model

@Controller
@RequestMapping("/test/{id}")
public class PathVariableTest {

    @RequestMapping("/{name}/get.do")
    public String get (@PathVariable("id") Integer index, Model model) {
        model.addAttribute("id", index);
        return "/index";
    }
}

7.9.3 ModelAndView

ModelAndView类似于Model，但额外提供了一个视图名称
ModelAndView既可以通过自动创建，也可以在方法中自己创建

    @RequestMapping("/{name}/get.do")
    public ModelAndView get (@PathVariable("name") Integer index, ModelAndView view) {
        view.addObject("id", index);
        view.setViewName("/index.ftl");
        return view;
    }

    @RequestMapping("/{name}/get.do")
    public ModelAndView get (@PathVariable("name") Integer index) {
        ModelAndView view = new ModelAndView();
        view.addObject("id", index);
        view.setViewName("/index.ftl");
        return view;
    }

8.@ResponseBody注解

@ResponseBody注解支持将返回值放在response体内，而不是返回一个视图

@ResponseBody注解直接将返回的对象输出到客户端
如果返回字符串，直接返回
如果返回不是字符串，默认使用Jackson将对象序列化成JSON字符串后输出

package com.example.demo.chapter1.annotation.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/bi")
public class ResponseBodyTest {

    @RequestMapping("/login")
    @ResponseBody
    public String get () {
        return "Hello Spring Boot!";
    }
}

启动Spring Boot应用
在浏览器输入：http://localhost:8080/bi/login
返回结果：

9.@RestController注解

@RestController注解源码：

package org.springframework.web.bind.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.annotation.AliasFor;
import org.springframework.stereotype.Controller;

/**
 * @since 4.0
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {

    @AliasFor(annotation = Controller.class)
    String value() default "";

}

@RestController是一个组合注解
@RestController = @Controller + @ResponseBody
@RestController注解直接将返回的对象输出到客户端
如果返回字符串，直接返回
如果返回不是字符串，默认使用Jackson将对象序列化成JSON字符串后输出

@RestController注解测试：

package com.example.demo.chapter1.annotation.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RestControllerTest {

    @RequestMapping("/restControllerTest")
    public Map get () {
        HashMap<String, Object> map = new HashMap<>();
        map.put("姓名", "张三");
        map.put("年龄", 22);
        map.put("课程", new String[] {"数据结构", "Spring Boot", "Redis"});
        return map;
    }
}

启动Spring Boot应用
在浏览器输入：http://localhost:8080/restControllerTest
返回结果：

10.小结

其实，@Service、@Repository、@Component、@Controller、@RestController这5个注解的效果都是一样的，Spring会将被这5个注解标注的类加载到Spring上下文中

但是在项目中，却建议你严格按照除Componen的其余几个注解的含义使用在项目中。这对分层结构的web架构很有好处

Spring Boot常用注解（一） - 声明Bean的注解

1.概述

2.声明Bean的注解

3. @Component注解

3.1 @Component注解使用

4. @Service注解

4.1 @service注解使用

4.2 @Scope注解

4.2.1 singleton单例模式

4.2.2 prototype原型模式

4.2.3 request模式

4.2.4 session模式

4.2.5 application模式

4.3 @Service和@Scope注解一起使用

5.@Repository注解

5.1 @Repository注解使用

6.@Controller注解

7.@RequestMapping注解

7.1 value和path参数

7.2 method参数

7.3 consumes参数

7.4 produces参数

7.5 params参数

7.6 headers参数

7.7 @RequestMapping注解使用

7.8 @RequestMapping请求路径匹配

7.9 @RequestMapping方法参数

7.9.1 @PathVariable注解

7.9.2 Model做方法参数

7.9.3 ModelAndView

8.@ResponseBody注解

9.@RestController注解

10.小结

猜你喜欢