springboot（入门后进阶）启动-事件-事件监控-系统参数

本是古典何须时尚 2022-11-21 09:58 110阅读 0赞

# Springboot进阶 #

# 启动springboot的三种方式 #

1.  使用SpringApplication的静态方法run
    
     *  特点：使用这种方式，配置属性使用外部application.properties属性文件进行配置
        
            SpringApplication.run(SpringbootAppliction.class,args)
2.  创建SpringApplication对象，调用其run方法
    
     *  特点：可以编程式配置属性
        
            SpringApplication spring=new SpringApplication(SpringbootApplication.class);
            spring.run(args);
3.  创建SpringApplicationBuilder对象，调用其run方法
    
     *  特点：可以指定容器之间的层级关系
        
            new SpringApplicationBuilder(SpringBootTestApplication.class).parent(Person.class).run(args);

# 层级关系SpringApplicationBuild #

*  理解：SpringBoot针对Spring中的层级关系做出了SpringApplicationBuild类，使用它可以指定容器之间的层级关系
    
        new SpringApplicationBuilder(SpringBootTestApplication.class).parent(Person.class)

# 流式写法对象.对象.对象 #

*  理解：就是调用其方法返回本体继续调用别的方法
    
        SpringApplication.run(args).getBean(UserDao.class).toString.subString()

# 事件核心 #

1.  事件对象（EventObject）
    
     *  理解：当触发事件时的事件源对象（源代码呈上）
        
            /** * The object on which the Event initially occurred. */
            protected transient Object  source;
2.  事件监听（EventListener）
    
     *  理解：对触发事件的监听。简单来说就是触发事件之后要干的事情
     *  源代码呈上！
     *  事件监听
        
            @Component
            public class ParentEvent implements ApplicationListener<EventTest> { 
                @Override
                public void onApplicationEvent(EventTest event) { 
                    Baby source = (Baby) event.getSource();
                    System.out.println("来，爸爸给你吃 nai nai ！！");
                }
            }
     *  被监听的事件
        
            @Component
            public class EventTest extends ApplicationEvent { 
                /** * Create a new {@code ApplicationEvent}. * * @param source the object on which the event initially occurred or with * which the event is associated (never {@code null}) */
                public EventTest(Object source) { 
                    super(source);
                }
            }
     *  被监听的对象
        
            @Component
            public class Baby implements ApplicationEventPublisherAware { 
                private String name;
                private int love;
            
                public String getName() { 
                    return name;
                }
            
                public void setName(String name) { 
                    this.name = name;
                }
            
                public int getLove() { 
                    return love;
                }
            
                public void setLove(int love) { 
                    this.love = love;
                }
            
                public void status(){ 
                    if (this.love<10){ 	
                        System.out.println("爸爸，我"+this.name+"饿了！");
                        this.applicationEventPublisher.publishEvent(new EventTest(this));//调用spring中的广播事件以通知所有监听事件
                    }
                }
                private ApplicationEventPublisher applicationEventPublisher;
            
                @Override
                public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) { 
                    this.applicationEventPublisher=applicationEventPublisher;
                }
            }
     *  具体使用（在main方法中）
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringBootTestApplication.class, args);
                    Baby bean = run.getBean(Baby.class);//获取到容器中的监听对象
                    bean.setName("王亚豪");//赋值
                    bean.setLove(5);
                    bean.status();//调用方法
     *  注意
        
         *  SpringBoot中一个监听对象，可以有多个监听事件
3.  Spring中的事件广播EventMulticaster
    
     *  作用
        
         *  管理事件监听
         *  广播事件

# springboot启动事件（官网1.7） #

1.  ApplicationStartingEvent
    
     *  环境准备好了，通知
    
    1.  ApplicationEnvironmentPreparedEvent
        
         *  环境已经创建好，但是容器还没有启动
    2.  ApplicationContextInitializedEvent
        
         *  在Bean还没有加载之前
    3.  ApplicationPreparedEvent
        
         *  bean已经定义完了的事件
    4.  ApplicationStartedEvent
        
         *  oc容器已经被刷新过了，到此时为止（Application基本运行完毕）
    5.  ApplicationReadyEvent
        
         *  Application Runner或者CommandLineRunner已经被调用的时候，springboot容器已经被启动完了发布的通知事件
    6.  AvailabilityChangeEvent
        
         *  监听应用程序的健康状态，
    7.  ApplicationFailedEvent
        
         *  启动失败事件

### Web Environment ###

*  决定springboot使用那种类型的ApplicationContext（ IOC容器 ）
    
     *  AnnotationConfigServletWebServerApplicationContext
        
         *  内嵌servlet容器
     *  AnnotationConfigReactiveWebServerApplicationContext
     *  AnnotationConfigApplicationContext
        
         *  默认ApplicationContext

### Accessing Application Arguments ###

*  介绍：获取启动参数
    
        @Bean
        public Person person(ApplicationArguments args) throws Exception { 
            String s = Arrays.toString(args.getSourceArgs());
            s=s.substring(s.indexOf("[")+1,s.indexOf("]"));
        
            if (!"admin".equals(s)){ 
                throw new Exception("食屎逝尸");
            }
            System.err.println("欢迎回家，我得"+s+"殿下");
            return new Person();
        }