configuração compreensão e automática de SpringBoot micro serviços

O que é a Microservice

Em comparação com um todo aplicações, micro-serviços podem ser um pequeno módulo extraídas deste grande programa no passado, e eu extraído em forma de um módulo de usuário no projeto negócio da electricidade, o módulo de fim, por que fazê-lo, como uma aplicação já foi implantado em vários servidores, e se você mais tarde necessidade de modificar o programa, mas também para modificar a linha de chegada na re-operação em todos os servidores, tais resíduos de um dos recursos humanos e materiais, mas um programa pode ser dividido em vários módulos, um módulo, também conhecido como um micro-serviços, uma pluralidade de micro implantação do serviço dinâmico em vários servidores, se houver necessidade de modificar a função, basta especificar a plataforma micro serviços, outros serviços não são afetados micro; http interagem com o serviço entre micro ; pode corresponder a um conjunto de micro-serviços membros do desenvolvimento, os desenvolvedores podem escolher a sua própria linguagem de desenvolvimento e banco de dados, também dividido entre a equipe mais clara.

princípio configuração automática SpringBoot

Diretamente da anotação @ principal método de SpringBootApplication digite:

@SpringBootApplication
public class SpringbootConfigApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootConfigApplication.class, args);
    }
}

Ponto para ir ver @ EnableAutoConfiguration abrir anotação automaticamente configure:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

Digite @ EnableAutoConfiguration :

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

Veja @ Import ({ AutoConfigurationImportSelector.class }) em que abrir o seletor de configuração automática classe, em seguida, aponte para ver em AutoConfigurationImportSelector classe tem um selectImports () opções, e introduzindo a montagem que depende método getAutoConfigurationEntry () método, a sexta linha do bloco de código que se segue:

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

Em seguida, digite getAutoConfigurationEntry () Este método obter automaticamente entidades de configuração:

    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

Pode ser visto que a sexta linha tem um bloco de código getCandidateConfigurations () método de adquirir a configuração candidato, introduzir:

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

Este método tem um Assert notEmpty, onde parece realmente determinar se este recurso está vazio, olhar na parte de trás da palavra verde Nenhuma classe encontrada na configuração Auto META-INF / spring.factories e META-INF / spring.factories arquivo nenhuma classe de configuração automática, pode imaginar a ser seleccionado no ficheiro de recursos é carregado para dentro; entrar loadFactoryNames () método:

	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		String factoryTypeName = factoryType.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
	}

Aqui você pode ver uma loadSpringFactories () método de carregamento visto antes spring.factories termina arquivo Fábricas e insira o método:

	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryTypeName, factoryImplementationName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

ClassLoader.getResources pode ver na tentativa (FACTORIES_RESOURCE_LOCATION):
ClassLoader.getSystemResources (FACTORIES_RESOURCE_LOCATION)); código tal, as cargas carregador de classe de um recurso de FACTORIES_RESOURCE_LOCATION:

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

SpringFactoriesLoader classe tem uma posição que é definida na FACTORIES_RESOURCE_LOCATION recurso META-INF / spring.factories este documento, o documento é automaticamente disposta no frasco springboot:

cada classe de tais XXXAutoConfiguration são adicionados ao recipiente última mola, a configuração automática é Springboot acima.