Mad Deus disse SpringBoot Series é claro, fácil de entender, baseado na versão SpringBoot2.2.5, bem-vindo rosa atenção louco encaminhado para aprender.
número público micro-canal: Deus louca disse (de partida) bilibili: Deus louca disse Java (vídeo)
Sem a permissão do autor é proibida reimpressão
Princípio de funcionamento Inquiry
Antes de escrever HelloSpringBoot, no final é como executá-lo, o projeto Maven, geralmente a partir investiga arquivo pom.xml;
pom.xml
dependência pai
Onde é principalmente dependente de um projeto pai, principalmente de recursos filtros e plug-em projetos de gestão!
< Pai > < groupId > org.springframework.boot </ groupId > < artifactId > Primavera-boot-starter-parent </ artifactId > < versão > 2.2.5.RELEASE </ versão > < relativePath /> <! - pesquisa pai do repositório -> </ pai >
Ponto para ele, descobriu que existe um pai dependente
< Pai > < groupId > org.springframework.boot </ groupId > < artifactId > Primavera-boot-dependências </ artifactId > < versão > 2.2.5.RELEASE </ versão > < relativePath > ../../spring- boot-dependências </ relativePath > </ pai >
Aqui é a verdadeira gestão SpringBoot todas as aplicações que dependem da versão local, a versão do SpringBoot centro de controle;
Depois de importar dependência há necessidade de escrever a versão padrão, no entanto, se o pacote importado não é gerido de dependência sobre a necessidade de versão configure manualmente;
Iniciado primavera-boot-starter
< Dependência > < groupId > org.springframework.boot </ groupId > < artifactId > Primavera-boot-starter-web </ artifactId > </ dependência >
-a Bota-Starter-springboot xxx : é cenas springboot arranque
Starter - Bota-Spring web : introduzindo a montagem para nos ajudar módulo web está funcionando normalmente depende;
SpringBoot todas as características cenas são extraídos, fez uma série de arranque (arranque), só têm de introduzir estes arranque no projeto, vai depender de toda a importação correspondente em, usamos o recurso de importação é que tipo de cena de partida pode, nosso futuro também pode personalizar o seu próprio motor de arranque;
classe Master Boot
Análise pom.xml ao longo de olhar para a classe de inicialização
A classe de arranque principal padrão
// @SpringBootApplication para marcar uma classe principal // Descrição Esta é uma mola de arranque aplicação @SpringBootApplication pública classe SpringbootApplication { pública estáticos vazios principais (String [] args) { // pensei que era uma maneira de começar, eu não esperava para iniciar um serviço SpringApplication.run (. SpringbootApplication classe , args); } }
Mas a classe de inicialização simples não é fácil! Vamos analisar essas anotações ter feito o que
@SpringBootApplication
Papel: Marcação explicação sobre uma classe dessa classe é a configuração de classe principal de SpringBoot, SpringBoot deve executar o método principal desta classe de começar a aplicação SpringBoot;
Digite o seguinte comentário: você pode ver acima, existem muitas outras notas!
@SpringBootConfiguration @EnableAutoConfiguration @ComponentScan ( excludeFilters = {@filter ( tipo = FilterType.CUSTOM, aulas = {TypeExcludeFilter. Class } ), @filter ( tipo = FilterType.CUSTOM, aulas = {AutoConfigurationExcludeFilter. Class } )} ) público @ Interface SpringBootApplication { // ...... }
@ComponentScan
Este comentário é muito importante na Primavera, que correspondem a elementos na configuração XML.
Acção: verifica automaticamente e componentes de carga ou de feijão qualificado, definição de feijão serão carregados para dentro do vaso COI
@SpringBootConfiguration
Ação: SpringBoot classe de configuração, uma etiqueta classe diante, indica que esta é uma configuração de classe SpringBoot;
Continuamos a percorrer nesta Ver anotada
// ponto obtido na seguinte @Component @Configuration pública @ interface de SpringBootConfiguration {} @Component pública @ a interface de configuração {}
@Configuration aqui, esta é uma configuração descrita, a configuração, e é o ficheiro de configuração xml mola correspondente;
Isso explica por dentro @Component, comece a classe em si também é um componente na Primavera é responsável por iniciar a aplicação!
Continuamos a olhar para trás anotação SpringBootApplication.
@EnableAutoConfiguration
@EnableAutoConfiguration: ativação do recurso de configuração automática
Antes precisamos configurar suas próprias coisas, mas agora SpringBoot pode nos ajudar a automaticamente configure; @EnableAutoConfiguration tell SpringBoot ativação do recurso de configuração automática, a configuração automática para entrar em vigor;
Ver click-through notas seguir:
pacote de configuração automática: @AutoConfigurationPackage
@Import ({secretário. Class })
público @ interface de AutoConfigurationPackage {
}
@import : o @import mola anotação fundo, introduzida para um recipiente de montagem
acção Registrar.class: O pacote do programa inicial principal, onde o pacote de todas as seguintes classes e sub-pacotes para verificar todos os componentes dentro do recipiente de mola;
Esta análise é longo, retiro para a etapa anterior, continuar a olhar
@Import ({AutoConfigurationImportSelector.class}): introduzida no recipiente de montagem;
AutoConfigurationImportSelector: seletor de importação de configuração automática, então será selector quais componentes importá-lo? Clique esta classe nós fomos ver o código fonte:
1, esta classe tem um método tal
// obter o candidato configuração protegida List <String> getCandidateConfigurations (AnnotationMetadata Metadados, AnnotationAttributes os Atributos) { // getSpringFactoriesLoaderFactoryClass onde () método // troca é que vemos o início do arquivo de configuração de importação é iniciado classes anotadas automaticamente; EnableAutoConfiguration List < string> Configurações = SpringFactoriesLoader.loadFactoryNames ( a este .getSpringFactoriesLoaderFactoryClass (), o presente .getBeanClassLoader ()); Assert.notEmpty (Configurações, . aulas "nenhuma configuração Auto encontrada no META-INF / spring.factories o usando o Se você é um Embalagens personalizadas, arquivo está correto Claro que a marca ". ); retorno Configurações; }
2, por sua vez, chama a classe método estático SpringFactoriesLoader! Entramos loadFactoryNames classe SpringFactoriesLoader () Método
público static List <String> loadFactoryNames (<?> Class factoryClass, @Nullable ClassLoader Classloader) { Cadeia factoryClassName = factoryClass.getName (); // 这里它又调用了loadSpringFactories方法 retorno (Lista) loadSpringFactories (carregador de classe) .getOrDefault (factoryClassName, Collections.emptyList ()); }
3, continuamos a clique método loadSpringFactories
Privado estática as Map <String, List <string >> loadSpringFactories (@Nullable ClassLoader Classloader) { // obter Classloader, podemos ver um retorno para chegar até aqui é de classe EnableAutoConfiguration marcada si MultiValueMap <String, String> O resultado = (MultiValueMap) Cache .get (carregador de classe); IF (! Resultado = nulo ) { retornar o resultado; } else { try { // para adquirir um recurso "META-INF / spring.factories" Enumeration <o URL de> = Classloader urls =! nula carregador de classe?. getResources ( "META-INF / spring.factories "): ClassLoader.getSystemResources ( "META-INF / spring.fábricas"); LinkedMultiValueMap resultado = new new LinkedMultiValueMap (); // o recurso de passagem de leitura, um pacote de tornar as propriedades ao mesmo tempo (urls.hasMoreElements ()) { a URL URL = (URL) urls.nextElement (); um recurso UrlResource = new new um UrlResource (URL); as propriedades Propriedades = PropertiesLoaderUtils.loadProperties (recurso); o Iterator Var6 = properties.entrySet () Iterator ();. o tempo (var6.hasNext ()) { a entrada entrada = <,?> (a entrada) var6.next (); Cadeia factoryClassName = ((corda) entry.getKey ()) da guarnição ().; String [] var9 = StringUtils.commaDelimitedListToStringArray ((corda) entry.getValue ()); int var10 = var9.length; para ( int var11 = 0; var11 <var10; ++ var11) { Cadeia factoryName = var9 [var11]; result.add (factoryClassName, factoryName.trim ()); } } } Cache.put (Classloader, resultado); voltar resultado; } captura (IOException var13) { lançar novos IllegalArgumentException ( "Não é possível fábricas de carga do local [META-INF / spring.factories]" , var13); } } }
4, encontradas várias ocorrências de um arquivo: spring.factories , pesquisa global,
spring.factories
De acordo com nossos spring.factories de código aberto, vimos um monte de arquivos configurados automaticamente, ou seja configurar automaticamente a causa raiz!
WebMvcAutoConfiguration
Nós automaticamente configurada na classe acima apenas para encontrar um olhar aberto, por exemplo: WebMvcAutoConfiguration
Pode-se ver que estes são JavaConfig classe de configuração, e são injetados alguns Bean, você pode encontrar algum tipo de compreensão de sua própria, olhando para se familiarizar!
Por conseguinte, a busca é automaticamente configurada de caminho de classe real todas perfil META-INF / spring.factories, e em que o org.springframework.boot.autoconfigure correspondente. De acordo com o saco item de configuração, no exemplo correspondente marcado por reflexão JavaConfig @Configuration forma de configuração do recipiente classe COI, os quais são depois agregadas e ser carregado em um exemplo de recipiente COI.
conclusão:
-
SpringBoot EnableAutoConfiguration Obtém o valor especificado pela META-INF / spring.factories caminho de classe na inicialização
-
Esses valores são automaticamente configurados como uma classe em um navio, a classe terá efeito automaticamente configurado para a configuração automática para o trabalho para nos ajudar;
-
J2EE inteiras soluções globais e configuração automática são springboot-autoconfigure em um frasco;
-
Ele lhe dará um monte de contêiner importado classe de configuração automática (xxxAutoConfiguration), este cenário é importar todos os componentes necessários para o recipiente e configurar esses componentes;
-
Com classe de configuração automática, eliminando a necessidade de escrever manualmente a configuração que injetar componentes funcionais, tais trabalho;
Agora nós provavelmente deve compreender os princípios que operam sob, SpringBoot, vamos aprofundar novamente mais tarde!
SpringApplication
método simples
Inicialmente eu pensei que a execução de um método principal, mas não esperava para abrir um serviço;
@SpringBootApplication pública classe SpringbootApplication { pública estáticos vazios principais (String [] args) { SpringApplication.run (SpringbootApplication. Classe , args); } }
análise SpringApplication.run
O método de análise primária em duas partes, SpringApplication instanciado, o segundo é o método de execução;
SpringApplication
Esta classe é principalmente para fazer as seguintes quatro coisas:
1, inferir o tipo de aplicação é um projecto comum ou projeto Web
2, para encontrar e carregar todos initializer disponíveis, conjunto de atributos para os initializers
3, encontrar tudo o ouvinte aplicações, defina as propriedades para os ouvintes
4, a definição da classe de inferência e o método principal é fornecido, a operação para encontrar a classe principal
Ver construtor:
pública SpringApplication (ResourceLoader ResourceLoader, Classe ... fontes primárias) { // ...... este .webApplicationType = WebApplicationType.deduceFromClasspath (); esta .setInitializers ( esta .getSpringFactoriesInstances (); esta .setListeners ( esta .getSpringFactoriesInstances (ApplicationListener. classe )); esta .mainApplicationClass = este .deduceMainApplicationClass (); }
Método de análise de fluxo de execução
Esta foto junto com o código fonte e pode descobrir o!