configuración entendimiento y automática de servicios de micro SpringBoot

¿Qué es lo microService

En comparación con todo un aplicaciones, micro-servicios pueden ser un pequeño módulo extraído de este gran programa en el pasado, y extrae la forma de un módulo de usuario en el proyecto de negocio eléctrico, el módulo de orden, ¿por qué hacerlo, tales como una aplicación se ha desplegado en varios servidores, y si más tarde resulta necesario modificar el programa, sino también para modificar la línea de meta en la cirugía de revisión en todos los servidores, un desperdicio de los recursos humanos y materiales, pero un programa puede ser dividida en múltiples módulos, un módulo, también conocido como un micro-servicios, una pluralidad de despliegue de servicios dinámicos micro en varios servidores, si hay necesidad de modificar la función, simplemente especifican el estante servicios de micro, otros servicios no se ven afectados micro; http interactúan con servicio entre micro ; puede corresponder a un conjunto de miembros de micro-servicios de elaboración, los desarrolladores pueden elegir su propio lenguaje de desarrollo y base de datos, también dividida entre el equipo más clara.

principio configuración automática SpringBoot

Directamente desde la anotación @ método principal de SpringBootApplication introduzca:

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

Punto para ir a ver @ EnableAutoConfiguration abrir anotación automática de configuración:

@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}
)}
)

Introduzca @ 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 {};
}

Ver @ importación ({ AutoConfigurationImportSelector.class }) en el que abrir el automático selector de configuración de clase, entonces el punto de ver en AutoConfigurationImportSelector clase tiene un selectImports () opciones, y la introducción del conjunto que depende método getAutoConfigurationEntry () método, la sexta línea en el siguiente bloque de código:

    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());
        }
    }

A continuación, introduzca getAutoConfigurationEntry () Este método obtener automáticamente entidades de configuración:

    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);
        }
    }

Puede ser visto que la sexta línea tiene un bloque de código getCandidateConfigurations método de adquirir la configuración candidata (), entre:

    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 tiene una aserción notEmpty, donde parece realmente determinar si este recurso está vacía, vistazo a la parte posterior de la palabra verde No hay clases encontraron en la configuración automática META-INF / spring.factories y META-INF / spring.factories archivo no clase de configuración automática, se puede adivinar a ser seleccionado en el archivo de recursos está dentro cargado; 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());
	}

Aquí se puede ver una loadSpringFactories () método de carga visto antes spring.factories extremos de archivos fábricas, y luego entrar en el 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 pueden ver en el intento (FACTORIES_RESOURCE_LOCATION):
ClassLoader.getSystemResources (FACTORIES_RESOURCE_LOCATION)); un código de ejemplo, el cargador de clase de un recurso desde FACTORIES_RESOURCE_LOCATION:

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

SpringFactoriesLoader clase tiene una posición que se define en la FACTORIES_RESOURCE_LOCATION recurso META-INF / spring.factories este documento, el documento está dispuesto de forma automática en el frasco springboot:

cada uno de tales XXXAutoConfiguration clase se añaden al recipiente de la primavera pasada, la configuración automática Springboot es anteriormente.