spring项目初始化时需要做些事

最新推荐文章于 2023-06-20 11:45:00 发布
最新推荐文章于 2023-06-20 11:45:00 发布
阅读量248 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/2528990/blog/1835624
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

当你在使用spring框架时，需要在项目启动时就做些事情时，你可能需要使用到这些东西

// 实现了InitializingBean接口的类，在spring初始化Bean的时候就会执行该方法（afterPropertiesSet）
// 实现了DisposableBean接口的类，在spring销毁bean时，spring容器会执行destory方法，比如释放资源
// 实现了ApplicationContextAware 接口的类 ，当spring容器被初始化的时候，会自动将ApplicationContext注入进来，使用setApplicationContext方法
// 实现了ApplicationListener接口的bean，ApplicationEvent事件监听器，spring容器启动后会发一个事件通知
// 实现了BeanNameAware接口的类，能获得本身bean的id属性

这里是摘抄于Dubbo源码

/*
 * Copyright 1999-2011 Alibaba Group.
 *  
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *  
 *      http://www.apache.org/licenses/LICENSE-2.0
 *  
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.dubbo.config.spring;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.support.AbstractApplicationContext;

import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ModuleConfig;
import com.alibaba.dubbo.config.MonitorConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.ProviderConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.ServiceConfig;
import com.alibaba.dubbo.config.annotation.Service;
import com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory;

/**
 * ServiceFactoryBean
 * 
 * @author william.liangf
 * @export
 */

// 实现了InitializingBean接口的类，在spring初始化Bean的时候就会执行该方法（afterPropertiesSet）
// 实现了DisposableBean接口的类，在spring销毁bean时，spring容器会执行destory方法，比如释放资源
// 实现了ApplicationContextAware 接口的类 ，当spring容器被初始化的时候，会自动将ApplicationContext注入进来，使用setApplicationContext方法
// 实现了ApplicationListener接口的bean，ApplicationEvent事件监听器，spring容器启动后会发一个事件通知
// 实现了BeanNameAware接口的类，能获得本身bean的id属性
public class ServiceBean<T> extends ServiceConfig<T> implements InitializingBean, DisposableBean, ApplicationContextAware, ApplicationListener, BeanNameAware {

	private static final long serialVersionUID = 213195494150089726L;

    private static transient ApplicationContext SPRING_CONTEXT;
    
	private transient ApplicationContext applicationContext;

    private transient String beanName;

    private transient boolean supportedApplicationListener;
    
	public ServiceBean() {
        super();
    }

    public ServiceBean(Service service) {
        super(service);
    }

    public static ApplicationContext getSpringContext() {
	    return SPRING_CONTEXT;
	}

	public void setApplicationContext(ApplicationContext applicationContext) {
		this.applicationContext = applicationContext;
		SpringExtensionFactory.addApplicationContext(applicationContext);
		if (applicationContext != null) {
		    SPRING_CONTEXT = applicationContext;
		    try {
	            Method method = applicationContext.getClass().getMethod("addApplicationListener", new Class<?>[]{ApplicationListener.class}); // 兼容Spring2.0.1
	            method.invoke(applicationContext, new Object[] {this});
	            supportedApplicationListener = true;
	        } catch (Throwable t) {
                if (applicationContext instanceof AbstractApplicationContext) {
    	            try {
    	                Method method = AbstractApplicationContext.class.getDeclaredMethod("addListener", new Class<?>[]{ApplicationListener.class}); // 兼容Spring2.0.1
                        if (! method.isAccessible()) {
                            method.setAccessible(true);
                        }
    	                method.invoke(applicationContext, new Object[] {this});
                        supportedApplicationListener = true;
    	            } catch (Throwable t2) {
    	            }
	            }
	        }
		}
	}

    public void setBeanName(String name) {
        this.beanName = name;
    }

    public void onApplicationEvent(ApplicationEvent event) {
        if (ContextRefreshedEvent.class.getName().equals(event.getClass().getName())) {
        	if (isDelay() && ! isExported() && ! isUnexported()) {
                if (logger.isInfoEnabled()) {
                    logger.info("The service ready on spring started. service: " + getInterface());
                }
                export();
            }
        }
    }
    
    private boolean isDelay() {
        Integer delay = getDelay();
        ProviderConfig provider = getProvider();
        if (delay == null && provider != null) {
            delay = provider.getDelay();
        }
        return supportedApplicationListener && (delay == null || delay.intValue() == -1);
    }

    // spring初始化时，就会执行该方法
    @SuppressWarnings({ "unchecked", "deprecation" })
	public void afterPropertiesSet() throws Exception {
        if (getProvider() == null) {
            Map<String, ProviderConfig> providerConfigMap = applicationContext == null ? null  : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ProviderConfig.class, false, false);
            if (providerConfigMap != null && providerConfigMap.size() > 0) {
                Map<String, ProtocolConfig> protocolConfigMap = applicationContext == null ? null  : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ProtocolConfig.class, false, false);
                if ((protocolConfigMap == null || protocolConfigMap.size() == 0)
                        && providerConfigMap.size() > 1) { // 兼容旧版本
                    List<ProviderConfig> providerConfigs = new ArrayList<ProviderConfig>();
                    for (ProviderConfig config : providerConfigMap.values()) {
                        if (config.isDefault() != null && config.isDefault().booleanValue()) {
                            providerConfigs.add(config);
                        }
                    }
                    if (providerConfigs.size() > 0) {
                        setProviders(providerConfigs);
                    }
                } else {
                    ProviderConfig providerConfig = null;
                    for (ProviderConfig config : providerConfigMap.values()) {
                        if (config.isDefault() == null || config.isDefault().booleanValue()) {
                            if (providerConfig != null) {
                                throw new IllegalStateException("Duplicate provider configs: " + providerConfig + " and " + config);
                            }
                            providerConfig = config;
                        }
                    }
                    if (providerConfig != null) {
                        setProvider(providerConfig);
                    }
                }
            }
        }
        if (getApplication() == null
                && (getProvider() == null || getProvider().getApplication() == null)) {
            Map<String, ApplicationConfig> applicationConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ApplicationConfig.class, false, false);
            if (applicationConfigMap != null && applicationConfigMap.size() > 0) {
                ApplicationConfig applicationConfig = null;
                for (ApplicationConfig config : applicationConfigMap.values()) {
                    if (config.isDefault() == null || config.isDefault().booleanValue()) {
                        if (applicationConfig != null) {
                            throw new IllegalStateException("Duplicate application configs: " + applicationConfig + " and " + config);
                        }
                        applicationConfig = config;
                    }
                }
                if (applicationConfig != null) {
                    setApplication(applicationConfig);
                }
            }
        }
        if (getModule() == null
                && (getProvider() == null || getProvider().getModule() == null)) {
            Map<String, ModuleConfig> moduleConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ModuleConfig.class, false, false);
            if (moduleConfigMap != null && moduleConfigMap.size() > 0) {
                ModuleConfig moduleConfig = null;
                for (ModuleConfig config : moduleConfigMap.values()) {
                    if (config.isDefault() == null || config.isDefault().booleanValue()) {
                        if (moduleConfig != null) {
                            throw new IllegalStateException("Duplicate module configs: " + moduleConfig + " and " + config);
                        }
                        moduleConfig = config;
                    }
                }
                if (moduleConfig != null) {
                    setModule(moduleConfig);
                }
            }
        }
        if ((getRegistries() == null || getRegistries().size() == 0)
                && (getProvider() == null || getProvider().getRegistries() == null || getProvider().getRegistries().size() == 0)
                && (getApplication() == null || getApplication().getRegistries() == null || getApplication().getRegistries().size() == 0)) {
            Map<String, RegistryConfig> registryConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, RegistryConfig.class, false, false);
            if (registryConfigMap != null && registryConfigMap.size() > 0) {
                List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();
                for (RegistryConfig config : registryConfigMap.values()) {
                    if (config.isDefault() == null || config.isDefault().booleanValue()) {
                        registryConfigs.add(config);
                    }
                }
                if (registryConfigs != null && registryConfigs.size() > 0) {
                    super.setRegistries(registryConfigs);
                }
            }
        }
        if (getMonitor() == null
                && (getProvider() == null || getProvider().getMonitor() == null)
                && (getApplication() == null || getApplication().getMonitor() == null)) {
            Map<String, MonitorConfig> monitorConfigMap = applicationContext == null ? null : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, MonitorConfig.class, false, false);
            if (monitorConfigMap != null && monitorConfigMap.size() > 0) {
                MonitorConfig monitorConfig = null;
                for (MonitorConfig config : monitorConfigMap.values()) {
                    if (config.isDefault() == null || config.isDefault().booleanValue()) {
                        if (monitorConfig != null) {
                            throw new IllegalStateException("Duplicate monitor configs: " + monitorConfig + " and " + config);
                        }
                        monitorConfig = config;
                    }
                }
                if (monitorConfig != null) {
                    setMonitor(monitorConfig);
                }
            }
        }
        if ((getProtocols() == null || getProtocols().size() == 0)
                && (getProvider() == null || getProvider().getProtocols() == null || getProvider().getProtocols().size() == 0)) {
            Map<String, ProtocolConfig> protocolConfigMap = applicationContext == null ? null  : BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ProtocolConfig.class, false, false);
            if (protocolConfigMap != null && protocolConfigMap.size() > 0) {
                List<ProtocolConfig> protocolConfigs = new ArrayList<ProtocolConfig>();
                for (ProtocolConfig config : protocolConfigMap.values()) {
                    if (config.isDefault() == null || config.isDefault().booleanValue()) {
                        protocolConfigs.add(config);
                    }
                }
                if (protocolConfigs != null && protocolConfigs.size() > 0) {
                    super.setProtocols(protocolConfigs);
                }
            }
        }
        if (getPath() == null || getPath().length() == 0) {
            if (beanName != null && beanName.length() > 0 
                    && getInterface() != null && getInterface().length() > 0
                    && beanName.startsWith(getInterface())) {
                setPath(beanName);
            }
        }
        if (! isDelay()) {
            export();
        }
    }

    public void destroy() throws Exception {
        unexport();
    }

}

 

转载于:https://my.oschina.net/u/2528990/blog/1835624

weixin_34418883
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
初始化springboot项目
qq_54516125的博客
03-14 3547
spring boot的初始化搭建
Spring Boot解决项目启动时初始化资源的方法
08-27
在实际工作中，我们总会遇到这样需求，在项目启动的时候需要做一些初始化的操作，比如初始化线程池，提前加载好加密证书等。今天我们将介绍一个 Spring Boot 神器，专门帮助大家解决项目启动初始化资源操作。 这个...
【Spring面试全家桶】Spring之初始化前、初始化、初始化后详解
Java程序员廖志伟
06-20 832
在Java Spring框架中，Bean定义读取器（BeanDefinitionReader）是用于读取配置文件或注解信息的组件，它将配置文件或注解信息解析成Bean定义（BeanDefinition），并将这些Bean定义存储在Bean定义注册表（BeanDefinitionRegistry）中。解析后的Bean定义被保存在Bean定义注册表中，并在需要时被使用。在第二步中，IoC容器会通过Bean工厂来实例化这些Bean定义，并将它们转化为实际的Bean对象，然后将这些对象存储在IoC容器中。
Spring容器初始化过程都做了哪些事儿
杨安康的博客
04-01 8033
1.ClassPathXmlApplicationContext为入口构造方法中有个refresh()方法用来初始化Spring refresh运行的大致流程： ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();—-2 invokeBeanFactoryPostProcessor
面试常见问题丨深入解析Spring中Bean的整个初始化过程
威哥爱编程，一个坚持研究技术的80后老鸟，擅长后端、AI 大模型、鸿蒙等技术体系，愿与你在技术路上一起成长！
07-01 957
原创 千锋侯哥一. 前言在面试过程中，经常有小伙伴会被问到Spring中Bean的生命周期，如果对Spring不了解可能对此类问题难以下手，就算通过百度查询到答案，也可能因为不理解而难以记忆，过段时间又忘记了，那么今天千锋侯哥就带小伙伴深入的解析下Spring中Bean的整个初始化过程。二. IOC容器的初始化过程我们都知道，IOC容器初始化时会进行各种Bean的初始化（单例非懒加载），因此在了解Bean的生命周期之前，我们先来看一下IOC容器的整个初始化过程。我们先整体看下流程图，做到心中有数，理解无误。
Spring Bean的初始化过程
ysmdelog的博客
04-15 1240
1.创建容器。 2.反射调用构造器创建实体(此时该实体还不是bean)。 3.Spring会识别被配置成bean的信息，扫描注解的包。把实体对应的类信息封闭成一个BeanDefinition对象，会把这些BeanDefinition对象放入到一个Map中。会根据配置判断是否是单例，如果是单例，会放到单例池。再进行验证，最后进入依赖注入。 4.set方法。 5.(如果实现了BeanNameAware接口)，就会调用setBeanName方法。 6.(如果实现了BeanFactoryAware接口)，就会调用s
spring初始化bean时执行某些方法完成特定的初始化操作
weixin_30794499的博客
06-11 258
在项目中经常会在容器启动时，完成特定的初始化操作，如资源文件的加载等。 一 实现的方式有三种： 1.使用@PostConstruct注解，该注解作用于void方法上 2.在配置文件中配置init-method方法 <bean id="student" class="com.demo.spring.entity.Student" init-method="init2"> ...
SpringBoot项目启动时如何读取配置以及初始化资源
08-18
在这个例子中，`testInit`方法会在Spring容器初始化时调用，生成一个Bean并将其添加到容器中。 2. **实现CommandLineRunner接口** `CommandLineRunner`接口提供了在Spring应用启动后，所有Bean初始化完成之前...
Java 后端万用项目初始化模板
06-03
Spring Boot 调试工具和项目处理器 Spring AOP 切面编程 Spring Scheduler 定时任务 Spring 事务注解 业务特性： 业务代码生成器（支持自动生成 Service、Controller、数据模型代码） Spring Session Redis 分布式...
spring boot源码-自定义初始化器的三种方式
12-21
在Spring Boot应用中，自定义初始化器是一种扩展和定制应用程序启动过程的方式。下面将详细介绍三种在Spring Boot中创建自定义初始化器的方法。 ### 第一种：通过`spring.factories`文件 1. **创建配置文件**：在`...
SpringBoot项目启动时实现调用一次初始化方法.docx
12-10
在Spring Boot应用中，我们经常需要在项目启动时执行一次初始化操作，比如加载配置、预设数据等。这里我们将详细探讨如何实现这个需求，主要涉及`@PostConstruct`注解、`CommandLineRunner`接口以及在启动类中直接...
六种方式实现 springboot 项目 启动预加载
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
08-30 3294
目录前言1、监听容器刷新完成扩展点`ApplicationListener`高级玩法2、`SpringBoot`的`CommandLineRunner`接口源码分析3、`SpringBoot`的`ApplicationRunner`接口源码分析4、`@PostConstruct`注解5、@Bean注解中指定初始化方法6、 `InitializingBean`接口总结总结 前言 在实际工作中总是需要在项目启动时做一些初始化的操作，比如初始化线程池、提前加载好加密证书… 那么经典问题来了，这也是面试官经常会问到
Spring bean初始化过程
zhengkun51的博客
10-26 2488
1：实例化一个ApplicationContext的对象； 2：调用bean工厂后置处理器完成扫描； 3：循环解析扫描出来的类信息； 4：实例化一个BeanDefinition对象来存储解析出来的信息； 5：把实例化好的beanDefinition对象put到beanDefinitionMap当中缓存起来，以便后面实例化bean； 6：再次调用bean工厂后置处理器； 7：当然spring还会干很多事情，比如国际化，比如注册BeanPostProcessor等等，如果我们只关心如何实例化一个bean的话那么
最全Spring初始化Bean的方法
just_for_that_moment的博客
11-14 4015
最全Spring初始化Bean的方法
Spring源码学习(一)：Spring容器创建和初始化工作准备
liangsheng_g的专栏
11-09 339
文章目录前言一、Spring是什么？二、探究1. Spring容器启动1.1 容器类型（contextClass）的判断1.2 容器的实例化2. 容器的创建及实例化过程2.1 构造方法读下去2.1.1 scanner的作用2.1.2 reader的作用总结 前言 基于学习遗忘曲线收敛太快，决定将Spring源码的解读记录下来。今天是第一篇，容器的启动 那就开始吧~ 一、Spring是什么？ 用java的应该都清楚Spring框架是什么，目前市面上的主流java框架也都会做和Spring的结合。Sprin
Spring容器初始化过程
weixin_33937778的博客
06-07 2221
一、Spring 容器高层视图 Spring 启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化Bean，装配号Bean之间的依赖关系，为上层应用提供准备就绪的运行环境。 二、内部工作机制 该图描述了Spring容器从加载配置文件到创建出一个完整Bean的作业流程： １、ResourceLoader从存储介质中...
Spring中初始化bean和销毁bean的时候执行某个方法的详解
热门推荐
NextX工作室的博客
04-27 1万+
版权声明：本文为博主原创文章，未经博主允许不得转载。 关于在spring  容器初始化 bean 和销毁前所做的操作定义方式有三种： 第一种：通过注解@PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作 [java] view plain copy print?
spring初始化后，做一些事情
tianjinsong的专栏
09-02 3866
http://blog.csdn.net/liuyifeng1920/article/details/49800537 我的目的是想在项目加载完毕之后,需要进行一些初始化的动作,比如从数据库查询数据,缓存起来. 找到了三种方式: 第一种方式  写一个类，实现BeanPostProcessor，这个接口有两个方法  （1）postProcessBeforeInitializa
Spring 实现初始化和销毁bean之前进行的操作的方法
乐于学习、乐于分享、乐于总结
05-05 1635
第一种：  通过@PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作 第二种： 通过 在xml中定义init-method 和  destory-method方法 第三种： 通过bean实现InitializingBean和 DisposableBean接口
spring boot 项目初始化
最新发布
06-10
Spring Boot是一个流行的开源框架，它简化了构建生产级Spring应用的过程。当你创建一个新的Spring Boot项目时，项目初始化主要包括以下几个关键步骤： 1. **启动依赖**：Spring Boot通过`main`方法（通常在`Application`类中）自动配置和启动，不需要显式地配置XML或大量的`@Configuration`类。 2. **自动配置**：Spring Boot的核心是自动配置机制，它基于Maven或Gradle的`pom.xml`或`build.gradle`文件查找特定的依赖，并根据这些依赖来自动设置应用的环境，如数据源、Web服务器等。 3. **starter模块**：Spring Boot提供了很多starter模块，比如web、data-jpa等，通过添加这些starter到你的项目，你只需声明你需要的功能，Spring Boot会自动配置相应的组件。 4. **嵌入式服务器**：Spring Boot内置了Tomcat、Jetty或Undertow等服务器，无需额外部署，使得本地开发更方便。 5. **初始目录结构**：典型的Spring Boot项目会有`src/main/java`（Java代码）、`src/main/resources`（配置文件和静态资源）和`src/test`（测试代码）等目录。 6. **YAML或properties文件**：配置信息通常存储在`application.properties`或`application.yml`文件中，这些文件用于设置Spring应用的各种属性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值