• Springboot2 注解

    一.底层注解

    1、@Configuration

    Full模式：配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

    Lite模式：配置 类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断

    1. #############################Configuration使用示例######################################################
    2. /**
    3.  * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
    4.  * 2、配置类本身也是组件
    5.  * 3、proxyBeanMethods：代理bean的方法
    6.  *      Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
    7.  *      Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
    8.  *      组件依赖必须使用Full模式默认。其他默认是否Lite模式
    9.  *
    10.  *
    11.  *
    12.  */
    13. @Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
    14. public class MyConfig {
    15.  
    16.     /**
    17.      * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
    18.      * @return
    19.      */
    20.     @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    21.     public User user01(){
    22.         User zhangsan = new User("zhangsan", 18);
    23.         //user组件依赖了Pet组件
    24.         zhangsan.setPet(tomcatPet());
    25.         return zhangsan;
    26.     }
    27.  
    28.     @Bean("tom")
    29.     public Pet tomcatPet(){
    30.         return new Pet("tomcat");
    31.     }
    32. }
    33.  
    34.  
    35. ################################@Configuration测试代码如下########################################
    36. @SpringBootConfiguration
    37. @EnableAutoConfiguration
    38. @ComponentScan("com.atguigu.boot")
    39. public class MainApplication {
    40.  
    41.     public static void main(String[] args) {
    42.         //1、返回我们IOC容器
    43.         ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
    44.  
    45.         //2、查看容器里面的组件
    46.         String[] names = run.getBeanDefinitionNames();
    47.         for (String name : names) {
    48.             System.out.println(name);
    49.         }
    50.  
    51.         //3、从容器中获取组件
    52.  
    53.         Pet tom01 = run.getBean("tom", Pet.class);
    54.  
    55.         Pet tom02 = run.getBean("tom", Pet.class);
    56.  
    57.         System.out.println("组件："+(tom01 == tom02));
    58.  
    59.  
    60.         //4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
    61.         MyConfig bean = run.getBean(MyConfig.class);
    62.         System.out.println(bean);
    63.  
    64.         //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
    65.         //保持组件单实例
    66.         User user = bean.user01();
    67.         User user1 = bean.user01();
    68.         System.out.println(user == user1);
    69.  
    70.  
    71.         User user01 = run.getBean("user01", User.class);
    72.         Pet tom = run.getBean("tom", Pet.class);
    73.  
    74.         System.out.println("用户的宠物："+(user01.getPet() == tom));
    75.  
    76.  
    77.  
    78.     }
    79. }

    2、@Bean、@Component、@Controller、@Service、@Repository

    spring 中的老注解

    3、@ComponentScan、@Import

    1.  * 4、@Import({User.class, DBHelper.class})
    2.  *      给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
    3.  *
    4.  *
    5.  *
    6.  */
    7.  
    8. @Import({User.class, DBHelper.class})
    9. @Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
    10. public class MyConfig {
    11. }

    4、@Conditional

    条件装配：满足Conditional指定的条件，则进行组件注入

    1. =====================测试条件装配==========================
    2. @Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
    3. //@ConditionalOnBean(name = "tom")
    4. @ConditionalOnMissingBean(name = "tom")
    5. public class MyConfig {
    6.  
    7.  
    8.     /**
    9.      * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
    10.      * @return
    11.      */
    12.  
    13.     @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    14.     public User user01(){
    15.         User zhangsan = new User("zhangsan", 18);
    16.         //user组件依赖了Pet组件
    17.         zhangsan.setPet(tomcatPet());
    18.         return zhangsan;
    19.     }
    20.  
    21.     @Bean("tom22")
    22.     public Pet tomcatPet(){
    23.         return new Pet("tomcat");
    24.     }
    25. }
    26.  
    27. public static void main(String[] args) {
    28.         //1、返回我们IOC容器
    29.         ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
    30.  
    31.         //2、查看容器里面的组件
    32.         String[] names = run.getBeanDefinitionNames();
    33.         for (String name : names) {
    34.             System.out.println(name);
    35.         }
    36.  
    37.         boolean tom = run.containsBean("tom");
    38.         System.out.println("容器中Tom组件："+tom);
    39.  
    40.         boolean user01 = run.containsBean("user01");
    41.         System.out.println("容器中user01组件："+user01);
    42.  
    43.         boolean tom22 = run.containsBean("tom22");
    44.         System.out.println("容器中tom22组件："+tom22);
    45.  
    46.  
    47.     }

    5、@ImportResource

    原生配置文件引入，导入Spring的配置文件（xml）

    1. ======================beans.xml=========================
    3. <beans xmlns="http://www.springframework.org/schema/beans"
    4.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    5.        xmlns:context="http://www.springframework.org/schema/context"
    6.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    7.  
    8.     <bean id="haha" class="com.atguigu.boot.bean.User">
    9.         <property name="name" value="zhangsan">property>
    10.         <property name="age" value="18">property>
    11.     bean>
    12.  
    13.     <bean id="hehe" class="com.atguigu.boot.bean.Pet">
    14.         <property name="name" value="tomcat">property>
    15.     bean>
    16. beans>
    1. @ImportResource("classpath:beans.xml")
    2. public class MyConfig {}
    3.  
    4. ======================测试=================
    5.         boolean haha = run.containsBean("haha");
    6.         boolean hehe = run.containsBean("hehe");
    7.         System.out.println("haha："+haha);//true
    8.         System.out.println("hehe："+hehe);//true

    6、配置绑定

    6.1 @Component + @ConfigurationProperties

    在Bean上标注

    1. /**
    2.  * 只有在容器中的组件，才会拥有SpringBoot提供的强大功能
    3.  */
    4. @Component
    5. @ConfigurationProperties(prefix = "mycar")
    6. public class Car {
    7.  
    8.     private String brand;
    9.     private Integer price;
    10.  
    11.     public String getBrand() {
    12.         return brand;
    13.     }
    14.  
    15.     public void setBrand(String brand) {
    16.         this.brand = brand;
    17.     }
    18.  
    19.     public Integer getPrice() {
    20.         return price;
    21.     }
    22.  
    23.     public void setPrice(Integer price) {
    24.         this.price = price;
    25.     }
    26.  
    27.     @Override
    28.     public String toString() {
    29.         return "Car{" +
    30.                 "brand='" + brand + '\'' +
    31.                 ", price=" + price +
    32.                 '}';
    33.     }
    34. }

    6.2 @EnableConfigurationProperties + @ConfigurationProperties

    在Bean上标注@ConfigurationProperties，在Bean Configure上标注@EnableConfigurationProperties

    1. @EnableConfigurationProperties(Car.class)
    2. //1、开启Car配置绑定功能
    3. //2、把这个Car这个组件自动注册到容器中
    4. public class MyConfig {
    5. }

    二.自动配置

    • SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
    • 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
    • 生效的配置类就会给容器中装配很多组件
    • 只要容器中有这些组件，相当于这些功能就有了
    • 定制化配置（用户直接自己@Bean替换底层的组件，用户去看这个组件是获取的配置文件什么值就去修改。）

    xxxxxAutoConfiguration ---> 组件 ---> xxxxProperties里面拿值 ----> application.properties

    7、@SpringBootApplicaiton  引导加载自动配置类

    相当于以下3个注解，是一个合成注解

    1. @SpringBootConfiguration
    2. @EnableAutoConfiguration
    3. @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    4. 		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    5. public @interface SpringBootApplication{}

    7.1 @SpringBootConfiguration

    @Configuration。代表当前是一个配置类

    7.2 @ComponentScan

    指定扫描哪些，Spring注解；

    7.3 @EnableAutoConfiguration

    相当于以下2个注解，是一个合成注解

    1. @AutoConfigurationPackage
    2. @Import(AutoConfigurationImportSelector.class)
    3. public @interface EnableAutoConfiguration {}

    7.3.1 @AutoConfigurationPackage

    自动配置包？指定了默认的包规则

    1. @Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
    2. public @interface AutoConfigurationPackage {}
    3.  
    4. //利用Registrar给容器中导入一系列组件
    5. //将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

    7.3.2 @Import(AutoConfigurationImportSelector.class)

    1. 1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
    2. 2、调用List configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
    3. 3、利用工厂加载 Map> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
    4. 4、从META-INF/spring.factories位置来加载一个文件。
    5. 	默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
    6.     spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

    8、@Conditional  按需开启自动配置项，修改默认配置

    1. 虽然我们127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration
    2. 按照条件装配规则（@Conditional），最终会按需配置。
    1.         @Bean
    2. 		@ConditionalOnBean(MultipartResolver.class)  //容器中有这个类型组件
    3. 		@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
    4. 		public MultipartResolver multipartResolver(MultipartResolver resolver) {
    5.             //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
    6.             //SpringMVC multipartResolver。防止有些用户配置的文件上传解析器不符合规范
    7. 			// Detect if the user has created a MultipartResolver but named it incorrectly
    8. 			return resolver;
    9. 		}
    10. 给容器中加入了文件上传解析器；
    1. @Bean
    2. 	@ConditionalOnMissingBean
    3. 	public CharacterEncodingFilter characterEncodingFilter() {
    4.         //SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先
    5.  
    6.     }

    三.SpringMVC请求处理

    9、注解

    @PathVariable、@RequestHeader、@ModelAttribute、@RequestParam、@MatrixVariable、@CookieValue、@RequestBody

    1. @RestController
    2. public class ParameterTestController {
    3.  
    4.  
    5.     //  car/2/owner/zhangsan
    6.     @GetMapping("/car/{id}/owner/{username}")
    7.     public Map getCar(@PathVariable("id") Integer id,
    8.                                      @PathVariable("username") String name,
    9.                                      @PathVariable Map pv,
    10.                                      @RequestHeader("User-Agent") String userAgent,
    11.                                      @RequestHeader Map header,
    12.                                      @RequestParam("age") Integer age,
    13.                                      @RequestParam("inters") List inters,
    14.                                      @RequestParam Map params,
    15.                                      @CookieValue("_ga") String _ga,
    16.                                      @CookieValue("_ga") Cookie cookie){
    17.  
    18.  
    19.         Map map = new HashMap<>();
    20.  
    21. //        map.put("id",id);
    22. //        map.put("name",name);
    23. //        map.put("pv",pv);
    24. //        map.put("userAgent",userAgent);
    25. //        map.put("headers",header);
    26.         map.put("age",age);
    27.         map.put("inters",inters);
    28.         map.put("params",params);
    29.         map.put("_ga",_ga);
    30.         System.out.println(cookie.getName()+"===>"+cookie.getValue());
    31.         return map;
    32.     }
    33.  
    34.  
    35.     @PostMapping("/save")
    36.     public Map postMethod(@RequestBody String content){
    37.         Map map = new HashMap<>();
    38.         map.put("content",content);
    39.         return map;
    40.     }
    41.  
    42.  
    43.     //1、语法： 请求路径：/cars/sell;low=34;brand=byd,audi,yd
    44.     //2、SpringBoot默认是禁用了矩阵变量的功能
    45.     //      手动开启：原理。对于路径的处理。UrlPathHelper进行解析。
    46.     //              removeSemicolonContent（移除分号内容）支持矩阵变量的
    47.     //3、矩阵变量必须有url路径变量才能被解析
    48.     @GetMapping("/cars/{path}")
    49.     public Map carsSell(@MatrixVariable("low") Integer low,
    50.                         @MatrixVariable("brand") List brand,
    51.                         @PathVariable("path") String path){
    52.         Map map = new HashMap<>();
    53.  
    54.         map.put("low",low);
    55.         map.put("brand",brand);
    56.         map.put("path",path);
    57.         return map;
    58.     }
    59.  
    60.     // /boss/1;age=20/2;age=10
    61.  
    62.     @GetMapping("/boss/{bossId}/{empId}")
    63.     public Map boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer bossAge,
    64.                     @MatrixVariable(value = "age",pathVar = "empId") Integer empAge){
    65.         Map map = new HashMap<>();
    66.  
    67.         map.put("bossAge",bossAge);
    68.         map.put("empAge",empAge);
    69.         return map;
    70.  
    71.     }
    72.  
    73. }

    10、Servlet API

    WebRequest、ServletRequest、MultipartRequest、 HttpSession、javax.servlet.http.PushBuilder、Principal、InputStream、Reader、HttpMethod、Locale、TimeZone、ZoneId

    1. @Override
    2. 	public boolean supportsParameter(MethodParameter parameter) {
    3. 		Class paramType = parameter.getParameterType();
    4. 		return (WebRequest.class.isAssignableFrom(paramType) ||
    5. 				ServletRequest.class.isAssignableFrom(paramType) ||
    6. 				MultipartRequest.class.isAssignableFrom(paramType) ||
    7. 				HttpSession.class.isAssignableFrom(paramType) ||
    8. 				(pushBuilder != null && pushBuilder.isAssignableFrom(paramType)) ||
    9. 				Principal.class.isAssignableFrom(paramType) ||
    10. 				InputStream.class.isAssignableFrom(paramType) ||
    11. 				Reader.class.isAssignableFrom(paramType) ||
    12. 				HttpMethod.class == paramType ||
    13. 				Locale.class == paramType ||
    14. 				TimeZone.class == paramType ||
    15. 				ZoneId.class == paramType);
    16. 	}

    11、复杂参数

    Map、Model（map、model里面的数据会被放在request的请求域 request.setAttribute）、Errors/BindingResult、RedirectAttributes（ 重定向携带数据）、ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder

    Map map,  Model model, HttpServletRequest request 都是可以给request域中放数据，request.getAttribute();

    Map、Model类型的参数，会返回 mavContainer.getModel（）；---> BindingAwareModelMap 是Model 也是Map，mavContainer.getModel(); 获取到值的

    12、自定义对象参数

    可以自动类型转换与格式化，可以级联封装。

    1. /**
    2.  *     姓名： <input name="userName"/> 
    3.  *     年龄： <input name="age"/> 
    4.  *     生日： <input name="birth"/> 
    5.  *     宠物姓名：<input name="pet.name"/>
    6.  *     宠物年龄：<input name="pet.age"/>
    7.  */
    8. @Data
    9. public class Person {
    10.     
    11.     private String userName;
    12.     private Integer age;
    13.     private Date birth;
    14.     private Pet pet;
    15.     
    16. }
    17.  
    18. @Data
    19. public class Pet {
    20.  
    21.     private String name;
    22.     private String age;
    23.  
    24. }
    25.  
    26. result

    四.其他

    13. Lombok

    @NoArgsConstructor

    生成无参构造器
    @AllArgsConstructor

    生成有参构造器
    @Data

    自动生成 get set 方法
    @ToString

    重写toString方法
    @EqualsAndHashCode

    重写hash方法

    @Slf4j

    日志

    14. Servlet API

    web原生组件注入：

    @ServletComponentScan(basePackages = "com.atguigu.admin") :指定原生Servlet组件都放在那里

    @WebServlet(urlPatterns = "/my")：效果：直接响应，没有经过Spring的拦截器？

    @WebFilter(urlPatterns={"/css/*","/images/*"})

    @WebListener

    15. Mybatis

    @Mapper

    @MapperScan

    @TableName

    MybatisPlus 中将表和Mapper映射

  • 相关阅读:
    设计模式学习笔记——抽象工厂模式
    数据结构——红黑树（详解性质+C++模拟）
    百度智能云千帆推出大模型普惠计划，0成本切换
    50天50个前端小项目（纯html+css+js）第十八天（背景轮播图）
    ant Design vue中a-row 内容不会垂直居中
    文献 | “科研狗”不配拥有健康的心理？
    SHAP解释模型（二）
    C语言打印九九乘法表
    2、JSP——配置Tomcat服务器
    Linux 内核开发 - NetFilter
  • 原文地址：https://blog.csdn.net/xd592319702/article/details/126073093