introdução

Spring Boot é uma estrutura altamente personalizável projetada para ajudar os desenvolvedores a criar, configurar e gerenciar rapidamente seus aplicativos

descrição do ponto de extensão

O ponto de extensão do Spring Boot é principalmente permitir que os desenvolvedores personalizem e estendam suas funções. 自动配置类Por exemplo, você pode substituir ou adicionar uma nova configuração automática criando uma personalizada ; ou adicionar lógica de aplicativo personalizada por meio de 实现ApplicationContextAware ou CommandLineRunner do Spring Boot ; além disso, você também pode encapsular e fornecer dependências específicas criando Gather. Abaixo apresentarei as ideias básicas de implementação ou casos desses três tipos de extensões personalizadas等接口自定义的starter

Classe de configuração automática para extensões sofisticadas

Crie uma classe de configuração e adicione anotações à classe @Configuration.
Crie o bean que precisa ser registrado na classe de configuração e use @Beana anotação para marcar o método.
Se precisar configurar propriedades, você poderá criar uma classe de propriedade de configuração e adicionar anotações à classe @ConfigurationProperties. O atributo desta anotação prefixespecifica um prefixo para propriedades de configuração.
Use anotações na classe de configuração @EnableConfigurationPropertiespara ativar a classe de propriedade de configuração.
Se precisar registrar beans condicionalmente, você poderá usar @Conditionalanotações para especificar uma condição.
Se precisar especificar que um bean será registrado somente quando um perfil específico for ativado, você poderá adicionar anotações ao método de definição do bean @Profilee especificar o perfil que precisa ser ativado.
Se precisar conectar automaticamente as dependências do Bean, você pode adicionar @Autowiredanotações nas propriedades ou métodos setter.
Se precisar injetar um bean com um nome especificado, você pode adicionar anotações à propriedade @Resourcee especificar o nome do bean que precisa ser injetado.

Interface de implementação de extensão sofisticada

Método para realizar

ApplicationContextInitializer: Usado para personalizar o processo de inicialização do contexto do aplicativo.
SpringBootApplicationProcessor: usado para personalizar a configuração de aplicativos Spring Boot. Ao implementar esta interface e usar lógica customizada, você pode modificar as classes de configuração de seu aplicativo Spring Boot.
EnvironmentPostProcessor: Usado para customizar o processo de inicialização e configuração do ambiente Spring. Ao implementar esta interface, você pode definir uma classe que será chamada antes ou durante a criação do ambiente Spring, permitindo personalizar ou modificar a configuração de variáveis de ambiente, carregamento de arquivos de configuração, etc.
ResourceLoaderAware: Fornece uma referência ao ResourceLoader para que Bean possa acessar o carregador de recursos
ApplicationContextAware: Fornece uma referência ao ApplicationContext, para que Bean possa acessar o contexto da aplicação.
ApplicationArguments: argumentos de linha de comando usados para obter o aplicativo
BeanNameGenerator: Estratégia de geração de nome de Bean customizado.
BeanDefinitionRegistryPostProcessor: Permite realizar algum processamento customizado antes de registrar todos os beans no BeanDefinitionRegistry.
BeanPostProcessor: permite algum processamento personalizado durante o ciclo de vida do Bean, como autowiring e pós-processamento.
BeanFactoryPostProcessor: Permite que algum processamento customizado seja executado antes do BeanFactory ser inicializado, como alterar a definição do Bean ou substituir outros Beans.
EnvironmentAware: Fornece uma referência ao SpringEnvironment, permitindo que Bean acesse as informações do ambiente da aplicação.
Inicializador: Usado para realizar algumas operações customizadas no início do ciclo de vida do Bean.
ApplicationListener: escuta o lançamento de ApplicationEvent para responder a eventos em nível de aplicativo.
MessageSourceAware: Fornece uma referência a MessageSource para que Bean possa acessar mensagens internacionalizadas.
BeanFactoryAware: Fornece uma referência ao BeanFactory, para que o Bean possa acessar a fábrica do Bean.
ApplicationContextAware: Fornece uma referência ao ApplicationContext, para que o Bean possa acessar o contexto da aplicação.
ServletContextAware: Fornece uma referência ao ServletContext, permitindo que Bean acesse o contexto da aplicação Web.
BeanDestroyedHandler: Execute algumas ações customizadas no final do ciclo de vida do Bean.
Ciclo de vida: define a interface do ciclo de vida do Bean, permitindo aos desenvolvedores realizar algumas operações personalizadas nos principais métodos do ciclo de vida (como inicialização, destruição, etc.).
CustomEditorConfigurer: Permite definir um editor de propriedades customizado para converter tipos de propriedades em editores adequados.
ResourcePatternResolver: usado para resolver o caminho do recurso para encontrar o recurso especificado.
BeanDefinitionReader: Usado para ler informações de definição de Bean, incluindo classes de configuração XML e Java, etc.
BeanDefinitionRegistry: Usado para gerenciar o registro e resolução de definições de Bean.
BeanDefinitionDecoder: Usado para decodificar informações de definição de Bean e convertê-las em objetos Bean operáveis.
BeanDefinitionDocumentReader: utilizado para ler as informações de definição do Bean no arquivo de configuração XML.
BeanDefinitionParser: usado para analisar tipos específicos de arquivos de configuração (como classes XML ou Java).
BeanDefinitionHolder: Contém definições de Bean e seus nomes relacionados, aliases e outras informações.
BeanDefinitionVisitor: Usado para acessar e manipular informações de definição de Bean.
BeanDefinitionReaderListener: ouve o evento de leitura da definição do Bean, usado para realizar algumas operações customizadas durante o processo de leitura.
BeanDefinitionRegistryListener: Ouça eventos de registro de definição de Bean para executar algumas operações personalizadas durante o processo de registro.
BeanDefinitionParserDelegate: Fornece alguns métodos auxiliares para ajudar a analisar e verificar as informações de definição do Bean.
BeanDefinitionValidationVisitor: Usado para verificar a validade da definição do Bean.
BeanNameGeneratorHolder: Contém um BeanNameGenerator e um BeanNameGeneratorDelegate.
BeanFactoryInitializerAdapter: Permite que a funcionalidade da interface BeanFactoryInitializr seja implementada através do BeanFactory.
LifeCycleProcessor: Usado para realizar operações customizadas no ciclo de vida do Bean, como executar lógica específica quando ocorre um evento de ciclo de vida do Bean.
CommandLineRunner: usado para executar lógica de linha de comando personalizada após o início do aplicativo. Ao implementar esta interface, você pode definir uma classe e escrever uma lógica customizada no método run desta classe para executar ações específicas após o início do aplicativo.
ApplicationRunner: semelhante ao CommandLineRunner, usado para executar lógica personalizada após o início do aplicativo. Ao contrário do CommandLineRunner, o ApplicationRunner é mais adequado para processamento complexo de parâmetros de linha de comando e processamento de saída.
WebMvcConfigurer: Usado para customizar a configuração do Spring MVC. Ao implementar esta interface e reescrever o método addConventions, você pode personalizar as convenções do Spring MVC, como personalizar caminhos do controlador, tratamento de exceções, etc.
AsyncConfigurer: Usado para customizar a configuração de métodos assíncronos. Ao implementar essa interface e reescrever o método getAsyncExecutor, é possível customizar a configuração do conjunto de encadeamentos para execução assíncrona, como tamanho e tipo do conjunto de encadeamentos.

amostra

@SpringBootApplication
@Slf4j
public class J4nJspApplication implements ApplicationContextAware , BeanNameGenerator , BeanDefinitionRegistryPostProcessor, BeanPostProcessor, BeanFactoryPostProcessor
, EnvironmentAware, CommandLineRunner {
    public static void main(String[] args) {
        SpringApplication.run(J4nJspApplication.class, args);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("获取上下文进行操作");
    }

    @Override
    public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
        log.info("我可以改变bean的名称");
        return null;
    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        log.info("我可以获取容器并修改bean或添加bean");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        log.info("提供了bean definition的解析和注册功能，可以解析配置文件中定义的Bean只是我的功能之一而已");
    }

    @Override
    public void setEnvironment(Environment environment) {
        log.info("环境变量{}", JSONUtil.toJsonStr(environment));
    }

    @Override
    public void run(String... args) throws Exception {
        log.info("我可以在项目启动后执行一些操作");
    }
}

Starter personalizado para extensões sofisticadas

Método de importação

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import( AutoConfigurationxxxx.class)
public @interface EnableAutoConfiguration{}
AutoConfigurationxxxximplementosBeanFactoryAware, EnvironmentAware, Ordered ...
tag de classe de inicialização@EnableAutoConfiguration

A abordagem das Fábricas de Primavera

crie um novo arquivoresources/META-INFO/spring.factories
Configuração de arquivo org.springframework.boot.autoconfigure.EnableAutoConfiguration=你的配置类包路径.配置类,xxx,xxx,xxx, múltiplas classes de configuração separadas por vírgulas

Resumir

Configuração automática: a função de configuração automática do Spring pode ajudar os desenvolvedores a construir rapidamente uma estrutura de aplicativo, mas às vezes a configuração padrão pode não atender às necessidades reais. Por meio de extensões personalizadas, os desenvolvedores podem fornecer seu próprio código de configuração automática para substituir a configuração padrão para atender às necessidades específicas do aplicativo.
Implementar interfaces: Spring fornece muitas interfaces e classes abstratas, e os desenvolvedores podem implementar essas interfaces para personalizar funções estendidas. Ao implementar a interface, os desenvolvedores podem personalizar sua própria lógica de negócios, aprimorar as funções do Spring e melhorar a flexibilidade e a capacidade de manutenção do aplicativo.
starters: os starters do Spring Boot são uma forma de iniciar rapidamente projetos fornecidos pelo Spring.Ele fornece algumas bibliotecas de dependências comumente usadas, para que os desenvolvedores não precisem adicionar manualmente essas dependências ao iniciar o projeto. Por meio de extensões personalizadas, os desenvolvedores podem adicionar seus próprios iniciadores para fornecer mais funções e suporte de biblioteca, facilitando o uso de seus próprios projetos por outros desenvolvedores.

obrigado

Muito obrigado por ler este artigo do início ao fim, espero que o conteúdo dele possa inspirar e ajudar você. Se você tiver outras dúvidas ou precisar de mais esclarecimentos, fique à vontade para acompanhar minha dinâmica e deixar uma mensagem
Por fim, você pode seguir o autor e dar um like, obrigado!
Se você acha que vale a pena colecionar, você pode coletá-lo

Em extensões sofisticadas do Spring ou Spring Boot

Diretório de artigos