Spring Boot微服务个人见解

以前开发一个项目，要花费不少时间在搭建项目，配置文件上，到现在Spring Boot开箱即用，需要技术栈导入pom就可以了，技术变更带来效率提示是巨大的。有时候我会疑惑，这一切如何得来的，Spring Boot怎么抛弃war部署，抛弃繁琐xml配置。

阅读本文章需要一定的Spring框架知识储备，最后能了解Spring如何进行Bean初始化的，至少知道BeanDefinition之类的知识点，才能更好阅读文章。下面代码基于Spring Boot 2.7.2 、 Spring Cloud 2021.0.3。

先从项目启动放入入口，每一个Spring Boot 项目都需要main入口都要调用SpringApplication.run开始

    public static ConfigurableApplicationContext run(Class primarySource, String... args) {
        return run(new Class[] { primarySource }, args);
    }

    public static ConfigurableApplicationContext run(Class[] primarySources, String[] args) {
        return new SpringApplication(primarySources).run(args);
    }
    public SpringApplication(Class... primarySources) {
        this(null, primarySources);
    }

    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
                //web 项目类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = new ArrayList<>(
                getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }

webApplicationType是一个枚举类，描述当前项目web类型
NONE： 当前项目不是一个web项目
SERVLET: 基于servlet api的传统web项目
REACTIVE： Spring webFlux 响应式web框架
deduceFromClasspath : 根据项目jar判断当前项目属于上面哪个一个类型,后面创建Spring 上下文对象需要用到
getSpringFactoriesInstances：从给定接口从文件META-INF/spring.factories 使用类名去加载全类名，并且返回接口所有实现类， 配置文件格式如下

org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

这个类似JVM的SPI机制，对于Spring为什么没有使用SPI来 引入扩展实例，我猜SPI不满足多构造参数的实现类初始化，这里暂时将这种机制称作：SpringFactoriesLoader加载。

BootstrapRegistryInitializer：用于初始化BootstrapRegistry的回调接口，在 使用BootstrapRegistry之前调用它。

ApplicationContextInitializer：在执行Spring工厂类调用AbstractApplicationContext.refresh（Spring 工厂核心方法bean初始化）之前初始化ConfigurableApplicationContext的回调接口。主要是做一个配置文件设置、属性设置。
ConfigurableApplicationContext 是一个SPI接口用于通过 配置方式初始化ApplicationContext 。Spring Boot作为Spring框架的集大成者上下文对象ApplicationContext往往根据不同环境有所区别的，这时很需要ApplicationContextInitializer这种接口，由不同组件根据自身情况去实现接口初始化上下文对象。

ApplicationContextInitializer接口

DelegatingApplicationContextInitializer： 通过环境变量 context.initializer.classes 类名，加载所有ConfigurdiableApplicationContext子类，实例化，排序执行ApplicationContextInitializer接口(接口参数)。
SharedMetadataReaderFactoryContextInitializer: 注册CachingMetadataReaderFactoryPostProcessor 用于向容器注册SharedMetadataReaderFactoryBean，用于缓存Spring加载资源
ContextIdApplicationContextInitializer: 初始化ContextId
ConfigurationWarningsApplicationContextInitializer：报告@ComponentScan配置错误信息输入告警日志
RSocketPortInfoApplicationContextInitializer: 创建一个监听事件，将server.ports赋值到 local.rsocket.server.port
ServerPortInfoApplicationContextInitializer： 创建web事件监听： 发布server namespace网络端口
ConditionEvaluationReportLoggingListener: 创建一个事件监听，spring初始化成功或失败，打印相关信息。

ApplicationListener列表

EnvironmentPostProcessorApplicationListener: 监听ApplicationEnvironmentPreparedEvent事件，执行EnvironmentPostProcessor 配置文件前置处理器，加载配置文件到ConfigurableEnvironment
AnsiOutputApplicationListener: 监听Spring刚启动事件，从配置文件加载ansi配置。
LoggingApplicationListener: 加载日志相关配置进行初始化设置。
BackgroundPreinitializer: 通过多线程方式初始化Formatter、Validation、HttpMessageConverter、jackson、UTF-8设置。
DelegatingApplicationListener:从配置文件 key：context.listener.classes加载监听器类名并实例化注册到容器中
ParentContextCloserApplicationListener: 监听父级容器关闭事件，并且将事件传递到子级逐级传递下取。
ClearCachesApplicationListener: 清除类加器缓存
FileEncodingApplicationListener: 检测当前系统环境的file.encoding和spring.mandatory-file-encoding设置的值是否一样，如果不一样的话，就会抛出一个IllegalStateException异常，程序启动立马停止

run方法

    public ConfigurableApplicationContext run(String... args) {
        long startTime = System.nanoTime();
                //调用BootstrapRegistryInitializer接口对上下文进行初始化
        DefaultBootstrapContext bootstrapContext = createBootstrapContext();
        ConfigurableApplicationContext context = null;
                // 设置 java.awt.headless  缺失显示设备需要CPU介入显示
        configureHeadlessProperty();
                //获取事件发布器实例，这里会将上面监听器实例装进发布器，监听器类似事件消费者
        SpringApplicationRunListeners listeners = getRunListeners(args);
                //发布starting 事件
        listeners.starting(bootstrapContext, this.mainApplicationClass);
        try {
             //获取所有启动参数
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //创建配置文件对象
            ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
             //从配置文件中忽视bean
            configureIgnoreBeanInfo(environment);
            //Banner  配置 打印
            Banner printedBanner = printBanner(environment);
             //使用ApplicationContextFactory 初始化ApplicationContentx Spring 工厂
            context = createApplicationContext();
            context.setApplicationStartup(this.applicationStartup);
            //配置文件对象配置
            //开始对applicationContext context 进行初始化
            prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            refreshContext(context); // 调用refresh
            //空方法
            afterRefresh(context, applicationArguments);
            Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
            }
            listeners.started(context, timeTakenToStartup);
             //调用所有 ApplicationRunner   CommandLineRunner
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, listeners);
            throw new IllegalStateException(ex);
        }
        try {
            Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
            listeners.ready(context, timeTakenToReady);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, null);
            throw new IllegalStateException(ex);
        }
        return context;
    }

run()Spring Boot框架启动流程

  1. 获取Java 命令行启动参数，从中提取Spring 配置参数，转换从对应变量
  2. 创建配置文件对象ConfigurableEnvironment ，命令行中会有profile设置，所以要根据profile加载配置文件，在执行配置文件事件
  3. 已经加载好文件了，从环境变量中检测是否存在配置spring.beaninfo.ignore，如果设置，写入到ConfigurableEnvironment中
  4. 开始打印banner,平常看到各种banner就是在这里执行
  5. 开始创建ConfigurableApplicationContext ，Spring 容器工厂上下文对象
  6. 对刚刚创建ConfigurableApplicationContext 调用ApplicationContextInitializer 进行属性设置
  7. 启动Spring 容器IOC、AOP
  8. 发布Spring启动完成事件
  9. 从容器中所有ApplicationRunner CommandLineRunner在调用方法
    在run方法里面就完成完成整个Spring容器启动流程了，包括Spring Cloud加载也是这里完成的。下面详细分析prepareEnvironment()，配置文件上下文如何初始化的

prepareEnvironment

    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
            DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
        // 根据webApplicationType 创建
        // SERVLET =>  ApplicationServletEnvironment
        //REACTIVE=> ApplicationReactiveWebEnvironment
        // NONE => ApplicationEnvironment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        // 命令行可能会有profile，可以选择那个profile，也会将命令行参数生成一个PropertySources
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        // 添加 configurationProperties  PropertySource到propertySourceList 队列最前面
        ConfigurationPropertySources.attach(environment);
        // 执行所有SpringApplicationRunListener
        listeners.environmentPrepared(bootstrapContext, environment);
        // 将defaultProperties sources 移致队尾
        DefaultPropertiesPropertySource.moveToEnd(environment);
        Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
                "Environment prefix cannot be set via properties.");
        // 从配置文件对应spring.main.* 属性注入
        bindToSpringApplication(environment);
        if (!this.isCustomEnvironment) {
           //将类型转换器设置到environment
            environment = convertEnvironment(environment);
        }
        // 因为EnvironmentPostProcessor  可能加载到配置文件里，这时需要configurationProperties 放入第一
        ConfigurationPropertySources.attach(environment);
        return environment;
    }

getOrCreateEnvironment() 如果当前environment如何为空，则会根据根据webApplicationType 类型选择对应类进行初始化。大家可能好奇environment怎么可能有值呢，接着玩下看，当我分析Spring Cloud时你就会返回environment不需要创建了。
ps: Environment 内部使用PropertySource区分不同配置文件，每一个源配置都有自己的名字，比如系统变量systemProperties、环境变量systemEnvironment等等。使用一个propertySourceList一个list将所有PropertySource保存起来，在队列前面永远最优先加载。
image.png

在上面写过一个监听器EnvironmentPostProcessorApplicationListener，它处理environmentPrepared事件，使用SpringFactoriesLoader加载所有EnvironmentPostProcessor 前置处理器，其中之一ConfigDataEnvironmentPostProcessor就是去做读取配置文件，里面还有很多逻辑处理，这里就不展开了，有兴趣的同学自行去分析代码。读取文件本身也是根据环境变量来的，这里有几个Spring内置配置

  • spring.config.location 设定加载文件路径，没有则是使用类路径./、config/
  • spring.config.additional-location: 加载外部文件路径，这个可以spring.config.location 共存，优先级最大

  • spring.config.name 设定文件名前置，默认 application
    上面这些变量都是从环境变量、系统变量中获取的，当然不会从配置文件读取到。通过设定文件路径、文件名这样方式确定加载文件,加载文件规则如下

    ${spring.config.location}/ ${spring.config.name}-${profile}.${extension}
  • extension：文件名后缀 内置支持4种，分别是： properties、yml、xml、yaml
    看下ConfigurableApplicationContext 如何被初始化的

prepareContext

    private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        // 初始化 ConfigurableEnvironment
        context.setEnvironment(environment);
        //初始化resourceLoader ConversionService
        postProcessApplicationContext(context);
        //执行上面从SpringFactoriesLoader加载 ApplicationContextInitializer  对ConfigurableApplicationContext 属性设置
        applyInitializers(context);
        // 调用SpringApplicationRunListener.contextPrepared 事件
        listeners.contextPrepared(context);
        // 执行BootstrapContextClosedEvent 事件
        bootstrapContext.close(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }
        //下面添加特定单例对象，为Spring初始化bean IOC 处理必要的bean
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        // 这里已经从配置文件加载 设置到自身属性上了，这时设置给上下文对象
        // allowCircularReferences 允许同名bean覆盖   lazyInitialization 对所有bean使用懒加载
        if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
            ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
            if (beanFactory instanceof DefaultListableBeanFactory) {
                ((DefaultListableBeanFactory) beanFactory)
                        .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
            }
        }
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
        // 这个前置处理器主要作用就是将配置defaultProperties 移到队尾
        context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
        // Load the sources 这里有启动类
        Set sources = getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        // 初始化 BeanDefinitionLoader   并将启动类注册成BeanDefinition
        load(context, sources.toArray(new Object[0]));
        // 所有监听器执行contextLoaded 事件
        listeners.contextLoaded(context);
    }
````
在这里完成了Spring 容器初始化，下一步就是启动了。

### bean初始化
其实我一直很好奇@Configuration这个注入如何实现配置类，还有还么多Class要被Spring进行初始化，如何变成BeanDefinition最后变成bean。我确定从`AbstractApplicationContext.refresh()`debug,终于被我发现Spring魔法，在`invokeBeanFactoryPostProcessors()`
在执行invokeBeanFactoryPostProcessors方法中回去获取`BeanDefinitionRegistryPostProcessor`类型内置对象，并且执行所有实现类。
- `BeanDefinitionRegistryPostProcessor`: 你可以理解成BeanDefinition注册前置处理器，主要就是生成BeanDefinition，再还给容器。在Spring还没有初始化bean时，这个接口运行实现类去初始化BeanDefinition再交还给Spring工厂对象,简白点就是这个对象会创建BeanDefinition，交给Spring，后续进行初始化bean。下面要讲解其中一个实现类`ConfigurationClassPostProcessor`
####  postProcessBeanFactory创建postProcessBeanFactory

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    int registryId = System.identityHashCode(registry);
    if (this.registriesPostProcessed.contains(registryId)) { //这个方法只能执行一次，通过记录上下文id标记执行
        throw new IllegalStateException(
                "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
    }
    if (this.factoriesPostProcessed.contains(registryId)) {
        throw new IllegalStateException(
                "postProcessBeanFactory already called on this post-processor against " + registry);
    }
    this.registriesPostProcessed.add(registryId);
    // 解析Class 生成BeanDefinition
    processConfigBeanDefinitions(registry);
}

/**
 * Build and validate a configuration model based on the registry of
 * {@link Configuration} classes.
 */
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List configCandidates = new ArrayList<>();
    String[] candidateNames = registry.getBeanDefinitionNames();
    //candidateNames 为前期使用BeanDefinitionRegistry 添加进去单例对象，除了拥有Spring 工厂对象外还有
    // SpringBoot main 启动类 这里能起到作用就是Spring Boot main 函数
    for (String beanName : candidateNames) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
            }
        }
        // 检查beanDef 是不是配置类，带有@Configuration都算
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    // 这里不存在没有配置类，只有配置@SpringBootApplication Class 就是一个配置类
    if (configCandidates.isEmpty()) {
        return;
    }

    // Sort by previously determined @Order value, if applicable
    configCandidates.sort((bd1, bd2) -> {
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
    });

    // Detect any custom bean name generation strategy supplied through the enclosing application context
    SingletonBeanRegistry sbr = null;
    if (registry instanceof SingletonBeanRegistry) {
        sbr = (SingletonBeanRegistry) registry;
        if (!this.localBeanNameGeneratorSet) {
            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
                    AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
            if (generator != null) {
                this.componentScanBeanNameGenerator = generator;
                this.importBeanNameGenerator = generator;
            }
        }
    }

    if (this.environment == null) {
        this.environment = new StandardEnvironment();
    }

    // Parse each @Configuration class
    // ConfigurationClassParser 看名字就知道，这是一个解析@Configuration 解析类
    // 将解析Class 工作专门委派给parse去做了，解析后的结果会变成 ConfigurationClass
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    Set candidates = new LinkedHashSet<>(configCandidates);
    Set alreadyParsed = new HashSet<>(configCandidates.size());
    do { //这里是一个循环
        StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
        parser.parse(candidates);
        parser.validate();
        //已经将所有配置类全部解析出来 变成ConfigurationClass
        Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed); // 删除已经解析过

        // Read the model and create bean definitions based on its content
        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                    registry, this.sourceExtractor, this.resourceLoader, this.environment,
                    this.importBeanNameGenerator, parser.getImportRegistry());
        }
        this.reader.loadBeanDefinitions(configClasses); //将所有ConfigurationClass 转化BeanDefinition ，并注册到容器中
        alreadyParsed.addAll(configClasses); //添加已经注册过的，上面删除对应
        processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

        candidates.clear();
        // 当ConfigurationClassParser  解析出ConfigurationClass 就会大于candidateNames
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames();
            Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
            Set alreadyParsedClasses = new HashSet<>();
            for (ConfigurationClass configurationClass : alreadyParsed) {
                alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
            }
            for (String candidateName : newCandidateNames) {
                if (!oldCandidateNames.contains(candidateName)) {
                    BeanDefinition bd = registry.getBeanDefinition(candidateName);
                    // bd 就是一个配置类
                    // bd 已经注册到容器中，但是不是在ConfigurationClassParser 解析出来的结果，则说明bd并没有通过解析生成
                    // 可能为第三方 BeanDefinitionRegistryPostProcessor 生成BeanDefinition，加入到candidates 再次进入循环中
                    //被ConfigurationClassParser 解析，可以生成更多BeanDefinition
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                            !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                        candidates.add(new BeanDefinitionHolder(bd, candidateName));
                    }
                }
            }
            candidateNames = newCandidateNames;
        }
    }
    while (!candidates.isEmpty()); // 当所有BeanDefinition 都已经被解析完了，循环就可以退出了
    //下面省略


}


看完上面的代码，ConfigurationClassPostProcessor就是Spring将带有@Configuration 标记Class经过一系列处理生成BeanDefinition的机制。在@SpringBootApplication 中有个一个@EnableAutoConfiguration带有@Import(AutoConfigurationImportSelector.class)，这个会被ConfigurationClassPostProcessor解析加载。其中AutoConfigurationImportSelector使用SpringFactoriesLoader加载，会将所有@EnableAutoConfiguration的配置类全部都加载ClassName，可以让Spring Boot 加载ScanPackage 基础包路径之外的配置类，再通过@ConditionalOnBean、@ConditionalOnProperty这类注解，根据Class、配置判断是否进行解析。
也就是说Spring Boot一开始就已经获取到所有配置类，只有当符合条件时才会进入解析、加载、实例化。

### Spring Cloud

上面说了Spring Boot自动化配置接下来就是Spring  Cloud方面，看了上面源码，发现没有代码有关Spring Cloud，现在还不知道配置中心的配置如何作用到已经开始运行Spring 容器中。在开始分析代码之前，先简单看一个例子
![image.png](https://upload-images.jianshu.io/upload_images/9213940-ebb638f2b745c88e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
可以看到applicatioinContext 有一个父级上下文，而这个就是Spring Cloud 上下文对象。看到这个是不是很惊奇，这个父级上下文在哪里初始化的呢，从代码角度去看了。
上面分析过ApplicationListener监听器中，在Spring Cloud lib jar中有一个实现类BootstrapApplicationListener，通过它来启动Spring Cloud。


public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
    ConfigurableEnvironment environment = event.getEnvironment();
    // 两个条件  environment 配置 spring.cloud.bootstrap.enabled 或者某个类是否存在，其实就是 spring-cloud-starter-bootstrap jar class
    // 配置 spring.config.use-legacy-processing  这个配置是用来兼容旧版本配置文件加载
    //我这里环境引入spring-cloud-starter-bootstrap  第一个条件返回true，第二条件不用判断
    if (!bootstrapEnabled(environment) && !useLegacyProcessing(environment)) {
        return;
    }
    // don't listen to events in a bootstrap context
    // 判断environment 是否已经存在bootstrap 文件，已经加载过不需要往下执行了
    //当父级初始化也会执行监听器事件，到时来到这里时，父级监听器不会往下执行了
    if (environment.getPropertySources().contains(BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
        return;
    }
    ConfigurableApplicationContext context = null;
    // 默认配置文件名，没有在环境变量配置默认就是bootstrap
    String configName = environment.resolvePlaceholders("${spring.cloud.bootstrap.name:bootstrap}");
    for (ApplicationContextInitializer initializer : event.getSpringApplication().getInitializers()) {
        if (initializer instanceof ParentContextApplicationContextInitializer) { //在已经存在ParentContextApplicationContextInitializer 中返回父级容器
            context = findBootstrapContext((ParentContextApplicationContextInitializer) initializer, configName);
        }
    }
    if (context == null) { //当上面ParentContextApplicationContextInitializer 没有执行就会走下面初始化父级容器方法
        // 这里会返回父级容器，也就是Spring Cloud 上下文对象
        context = bootstrapServiceContext(environment, event.getSpringApplication(), configName);
        event.getSpringApplication().addListeners(new CloseContextOnFailureApplicationListener(context));
    }
    //从父级容器中获取ApplicationContextInitializer 交给SpringApplication
    //父级生成ApplicationContextInitializer 用于增强子类
    apply(context, event.getSpringApplication(), environment);
}


这个监听器主要根据配置文件信息来启动Spring Cloud组件，如果没有相应的配置根据项目环境来，看下Spring Cloud上下文如何被初始化出来的。


private ConfigurableApplicationContext bootstrapServiceContext(ConfigurableEnvironment environment,
        final SpringApplication application, String configName) {
    ConfigurableEnvironment bootstrapEnvironment = new AbstractEnvironment() {
    };
    MutablePropertySources bootstrapProperties = bootstrapEnvironment.getPropertySources();
    String configLocation = environment.resolvePlaceholders("${spring.cloud.bootstrap.location:}");
    String configAdditionalLocation = environment
            .resolvePlaceholders("${spring.cloud.bootstrap.additional-location:}");
    Map bootstrapMap = new HashMap<>();
    // 使用代码生成一个Spring Cloud加载文件的配置信息，规则类似上面加载applicaton 配置
    bootstrapMap.put("spring.config.name", configName);
    bootstrapMap.put("spring.main.web-application-type", "none");
    if (StringUtils.hasText(configLocation)) {
        bootstrapMap.put("spring.config.location", configLocation);
    }
    if (StringUtils.hasText(configAdditionalLocation)) {
        bootstrapMap.put("spring.config.additional-location", configAdditionalLocation);
    }
            //将加载文件的配置信息放入配置文件上下文 environment
    bootstrapProperties.addFirst(new MapPropertySource(BOOTSTRAP_PROPERTY_SOURCE_NAME, bootstrapMap));
    for (PropertySource source : environment.getPropertySources()) {
        if (source instanceof StubPropertySource) {
            continue;
        }
        bootstrapProperties.addLast(source);
    }
    // TODO: is it possible or sensible to share a ResourceLoader?
    // SpringApplicationBuilder  为SpringApplication 包装类，重新生成SpringApplication来创建ApplicationContext 上下文
    SpringApplicationBuilder builder = new SpringApplicationBuilder().profiles(environment.getActiveProfiles())
            .bannerMode(Mode.OFF).environment(bootstrapEnvironment)
            // Don't use the default properties in this builder
            .registerShutdownHook(false).logStartupInfo(false).web(WebApplicationType.NONE);
    final SpringApplication builderApplication = builder.application();
    if (builderApplication.getMainApplicationClass() == null) {
        builder.main(application.getMainApplicationClass());
    }
    if (environment.getPropertySources().contains("refreshArgs")) {
        builderApplication.setListeners(filterListeners(builderApplication.getListeners()));
    }
    / BootstrapImportSelectorConfiguration
    builder.sources(BootstrapImportSelectorConfiguration.class);
    // 这里将调用SpringApplication.run 上面已经分析，
    final ConfigurableApplicationContext context = builder.run();
    context.setId("bootstrap");
    //这里添加AncestorInitializer 是一个ApplicationContextInitializer 实现类，目的就是让子applicationContext 和父级关联起来
    addAncestorInitializer(application, context);
    //当前environment 为子集配置对象，这里要删除掉父级加载文件信息
    bootstrapProperties.remove(BOOTSTRAP_PROPERTY_SOURCE_NAME);
    //将 springCloudDefaultProperties  配置文件信息copy到environment 中
    mergeDefaultProperties(environment.getPropertySources(), bootstrapProperties);
    return context;
}



现在所有代码都看完了，我们来理一理整一个流程就会清晰明了。
在BootstrapApplicationListener中会根据配置文件或者是项目环境jar来是否启动加载bootstrap配置文件。
先从生成加载Spring Cloud配置信息，使用SpringApplicationBuilder来构建SpringApplication对象，然
后执行SpringApplication.run 方法，这个代码我们已经分析过了，初始化Spring容器上下文对象，然后进入
核心refresh方法执行IOC。SpringApplicationBuilder构造SpringApplication 中没有像我们写启动类main
方法，会设置启动类Class。所以被ConfigurationClassPostProcessor解析BeanDefinition,并没有
@SpringApplication 这个注解，所以这个Spring Cloud 工厂没有获取到basepackae、
@EnableAutoConfiguration这些东西。根据上面代码知道Spring Cloud将
BootstrapImportSelectorConfiguration 作为BeanDefinition交给ConfigurationClassPostProcessor,
这样父级容器只有加载BootstrapConfiguration标记类，父级bean和子级bean相互隔离。这样父级容器就可以
去启动与Spring Cloud有关的bean。当Spring Cloud容器已经完成bean初始化后，再来执行SpringApplicaton.run
 启动Spring 容器创建。这样在子级启动之前已经将配置中心的配置对应的对象已经创建出来了。再通过
ApplicationContextInitializer接口将配置对象加载ConfigurableEnvironment中。

这里使用较短的篇幅来分析Spring Boot这个框架如何工作,站在自己的思维上，使用3个知识点来展示Spring
 Boot技术细节实现。第一个从SpringApplication.run了解Spring两大工厂对象
ConfigurableApplicationContext、ConfigurableEnvironment如何初始化处理出来的，配置文件如何被
加载的，加载规则，知识点SpringFactoriesLoader机制，如果要做Spring Boot组件必须要这个。了解了
Spring Boot ApplicationContextInitializer、ApplicationListener这些接口，还有
SpringApplicationRunListener为整个Spring Boot事件监听器，对应整个框架的不同阶段处理。第二
简单分析了Spring容器启动时如何生成BeanDefinition的机制实现类：
BeanDefinitionRegistryPostProcessor，了解了Spring Boot组件如何被加载、实例化，这个依赖启动类
的注解。最后Spring Cloud组件如何加载实例化，这个依赖于前面两个。
























你可能感兴趣的:(Spring Boot微服务个人见解)






    

  • 微服务下功能权限与数据权限的设计与实现
nbsaas-boot
微服务java架构

    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    

    • 

  • 腾讯云技术深度探索：构建高效云原生微服务架构
我的运维人生
云原生架构腾讯云运维开发技术共享

    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    

    • 

  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
文章永久免费只为良心
oracle数据库

    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    

    • 

  • spring如何整合druid连接池？
惜.己
springspringjunit数据库javaidea后端xml

    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    

    • 

  • SpringCloudAlibaba—Sentinel(限流)
菜鸟爪哇

    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    

    • 

  • springboot+vue项目实战一-创建SpringBoot简单项目
苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言

    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    

    • 

  • 06选课支付模块之基于消息队列发送支付通知消息
echo 云清
学成在线javarabbitmq消息队列支付通知学成在线

    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
    

    • 

  • Spring MVC 全面指南：从入门到精通的详细解析
一杯梅子酱
技术栈学习springmvcjava

    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    

    • 

  • Spring Boot中实现跨域请求
BABA8891
springboot后端java

    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    

    • 

  • 博客网站制作教程
2401_85194651
javamaven

    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    

    • 

  • RabbitMQ生产者重复机制与确认机制
java炒饭小能手
java-rabbitmqrabbitmqjava

    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    

    • 

  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
屿小夏
java开发语言

    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    

    • 

  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
瑞金彭于晏
springboot后端javaMVCspring数据库

    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    

    • 

  • spring mvc @RequestBody String类型参数
zoyation
spring-mvcspringmvc

    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    

    • 

  • Java -jar 如何在后台运行项目
vincent_hahaha

    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    

    • 

  • 网关gateway学习总结
猪猪365
学习总结学习总结

    一微服务概述:微服务网关就是一个系统!通过暴露该微服务的网关系统,方便我们进行相关的鉴权,安全控制,日志的统一处理,易于监控的相关功能!实现微服务网关技术都有哪些呢?1nginx:nginx是一个高性能的http和反向代理web的服务器,同事也提供了IMAP/POP3/SMTP服务.他可以支撑5万并发链接,并且cpu,内存等资源消耗非常的低,运行非常的稳定!2Zuul:Zuul是Netflix公司
    

    • 

  • spring security中几大组件的作用和执行顺序
阿信在这里
javaspring

    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    

    • 

  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
叶准鑫Natalie

    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    

    • 

  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
网顺技术团队
成品程序项目javavue.js汽车课程设计springboot

    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    

    • 

  • 分布式锁和spring事务管理
暴躁的鱼
锁及事务分布式springjava

    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    

    • 

  • 如何重启Linux服务器？
老男孩IT教育
gitlinux运维

    在Linux操作系统中，提供了多种方法用于重启服务器，那么Linux服务器如何重启?以下列举了常用的几种方法，希望对大家有所帮助，快来看看吧。重启Linux服务器有以下几种方法：1、使用命令行使用reboot命令reboot使用shutdown命令shutdown-rnow2、使用systemctl使用以下命令：systemctlreboot3、使用web界面大多数现代Linux发行版本都提供一个
    

    • 

  • Java面试笔记记录6
今天背八股了吗
java面试笔记

    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    

    • 

  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变
黑金IT
fastapi微服务fastapi架构

    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
    

    • 

  • 小米嵌入式面试题目RTOS面试题目 嵌入式面试题目
好家伙VCC
面试杂谈杂谈面试职场和发展

    第一章-非RTOSbootloader工作流程MCU启动流程通信协议，SPIIICMCU怎么选型，STM32F1和F4有什么区别外部RAM和内部RAM区别，怎么分配外部总线和内部总线区别MCU上的固件，数据是怎么分配的MCU启动流程IAP是怎么升级的，突然断电怎么办挑了麦轮项目（因为大疆RM也是麦轮，面试官看样子比较感兴趣）为什么用的CAN总线你说一下spi和i2c和UART的各自的工作方式优缺点
    

    • 

  • Sentinel
眼泪落在琴弦
springcloudjavajava

    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    

    • 

  • Spring @Async 深度解读：默认线程池执行器的配置与优化
小码快撩
springjava前端

    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    

    • 

  • Sentinel实时监控不展示问题
朱杰jjj
sentinelsentinel

    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    

    • 

  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
这孩子叫逆
Mybatis笔记mybatis数据库

    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    

    • 

  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java

    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    

    • 

  • 软件测试/测试开发/全日制 |利用Django REST framework构建微服务
霍格沃兹-慕漓
django微服务sqlite

    霍格沃兹测试开发学社推出了《Python全栈开发与自动化测试班》。本课程面向开发人员、测试人员与运维人员，课程内容涵盖Python编程语言、人工智能应用、数据分析、自动化办公、平台开发、UI自动化测试、接口测试、性能测试等方向。为大家提供更全面、更深入、更系统化的学习体验，课程还增加了名企私教服务内容，不仅有名企经理为你1v1辅导，还有行业专家进行技术指导，针对性地解决学习、工作中遇到的难题。让找
    

    • 

  • jquery实现的jsonp掉java后台
知了ing
javajsonpjquery

     什么是JSONP？
先说说JSONP是怎么产生的：
其实网上关于JSONP的讲解有很多，但却千篇一律，而且云里雾里，对于很多刚接触的人来讲理解起来有些困难，小可不才，试着用自己的方式来阐释一下这个问题，看看是否有帮助。
1、一个众所周知的问题，Ajax直接请求普通文件存在跨域无权限访问的问题，甭管你是静态页面、动态网页、web服务、WCF，只要是跨域请求，一律不准；
2、
    

    • 

  • Struts2学习笔记
caoyong
struts2

    SSH : Spring + Struts2 + Hibernate
三层架构(表示层,业务逻辑层,数据访问层) MVC模式 (Model View Controller)
分层原则:单向依赖，接口耦合
1、Struts2  =  Struts  + Webwork
2、搭建struts2开发环境
   a>、到www.apac
    

    • 

  • SpringMVC学习之后台往前台传值方法
满城风雨近重阳
springMVC

    springMVC控制器往前台传值的方法有以下几种：
1.ModelAndView
   通过往ModelAndView中存放viewName：目标地址和attribute参数来实现传参：
   
 ModelAndView mv=new ModelAndView();
 mv.setViewName="success
    

    • 

  • WebService存在的必要性？
一炮送你回车库
webservice

    做Java的经常在选择Webservice框架上徘徊很久，Axis  Xfire Axis2 CXF ，他们只有一个功能，发布HTTP服务然后用XML做数据传输。
是的，他们就做了两个功能，发布一个http服务让客户端或者浏览器连接，接收xml参数并发送xml结果。
当在不同的平台间传输数据时，就需要一个都能解析的数据格式。
但是为什么要使用xml呢？不能使json或者其他通用数据
    

    • 

  • js年份下拉框
3213213333332132
java web ee

    
<div id="divValue">test...</div>测试
//年份
<select id="year"></select>
<script type="text/javascript">
window.onload = 
    

    • 

  • 简单链式调用的实现技术
归来朝歌
方法调用链式反应编程思想

    在编程中，我们可以经常遇到这样一种场景：一个实例不断调用它自身的方法，像一条链条一样进行调用
这样的调用你可能在Ajax中，在页面中添加标签：
$("<p>").append($("<span>").text(list[i].name)).appendTo("#result");
 
也可能在HQ
    

    • 

  • JAVA调用.net 发布的webservice 接口
darkranger
webservice

     /**
* @Title: callInvoke
* @Description: TODO(调用接口公共方法)
* @param @param url 地址
* @param @param method 方法
* @param @param pama 参数
* @param @return
* @param @throws BusinessException 
    

    • 

  • Javascript模糊查找 | 第一章 循环不能不重视。
aijuans
Way

     最近受我的朋友委托用js+HTML做一个像手册一样的程序，里面要有可展开的大纲，模糊查找等功能。我这个人说实在的懒，本来是不愿意的，但想起了父亲以前教我要给朋友搞好关系，再加上这也可以巩固自己的js技术，于是就开始开发这个程序，没想到却出了点小问题，我做的查找只能绝对查找。具体的js代码如下：
function search(){
var arr=new Array("my
    

    • 

  • 狼和羊，该怎么抉择
atongyeye
工作

    狼和羊，该怎么抉择
在做一个链家的小项目，只有我和另外一个同事两个人负责，各负责一部分接口，我的接口写完，并全部测联调试通过。所以工作就剩下一下细枝末节的，工作就轻松很多。每天会帮另一个同事测试一些功能点，协助他完成一些业务型不强的工作。
今天早上到公司没多久，领导就在QQ上给我发信息，让我多协助同事测试，让我积极主动些，有点责任心等等，我听了这话，心里面立马凉半截，首先一个领导轻易说
    

    • 

  • 读取android系统的联系人拨号
百合不是茶
androidsqlite数据库内容提供者系统服务的使用

     
     联系人的姓名和号码是保存在不同的表中,不要一下子把号码查询来,我开始就是把姓名和电话同时查询出来的,导致系统非常的慢
 
关键代码:
 
 
1, 使用javabean操作存储读取到的数据
package com.example.bean;
/**
*
* @author Admini
    

    • 

  • ORACLE自定义异常
bijian1013
数据库自定义异常

    实例：
CREATE OR REPLACE PROCEDURE test_Exception
(
ParameterA IN varchar2,
ParameterB IN varchar2,
ErrorCode OUT varchar2 --返回值,错误编码
)
AS
/*以下是一些变量的定义*/
V1 NUMBER;
V2 nvarc
    

    • 

  • 查看端号使用情况
征客丶
windows

    一、查看端口
在windows命令行窗口下执行：
>netstat -aon|findstr "8080"
显示结果：
TCP     127.0.0.1:80         0.0.0.0:0    &
    

    • 

  • 【Spark二十】运行Spark Streaming的NetworkWordCount实例
bit1129
wordcount

    Spark Streaming简介
  NetworkWordCount代码
 
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with

    

    • 

  • Struts2 与 SpringMVC的比较
BlueSkator
struts2spring mvc

    1. 机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。 2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring
    

    • 

  • Hibernate在更新时，是可以不用session的update方法的(转帖）
BreakingBad
Hibernateupdate

    地址：http://blog.csdn.net/plpblue/article/details/9304459
public void synDevNameWithItil()
{Session session = null;Transaction tr = null;try{session = HibernateUtil.getSession();tr = session.beginTran
    

    • 

  • 读《研磨设计模式》-代码笔记-观察者模式
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
/**
* “观
    

    • 

  • 重置MySQL密码
chenhbc
mysql重置密码忘记密码

    如果你也像我这么健忘，把MySQL的密码搞忘记了，经过下面几个步骤就可以重置了（以Windows为例，Linux/Unix类似）：
1、关闭MySQL服务
2、打开CMD，进入MySQL安装目录的bin目录下，以跳过权限检查的方式启动MySQL
mysqld --skip-grant-tables
 3、新开一个CMD窗口，进入MySQL
mysql -uroot
 
    

    • 

  • 再谈系统论，控制论和信息论
comsci
设计模式生物能源企业应用领域模型

    
                           再谈系统论，控制论和信息论
    偶然看
    

    • 

  • oracle moving window size与 AWR retention period关系
daizj
oracle

    转自： http://tomszrp.itpub.net/post/11835/494147
晚上在做11gR1的一个awrrpt报告时,顺便想调整一下AWR snapshot的保留时间,结果遇到了ORA-13541这样的错误.下面是这个问题的发生和解决过程.
SQL> select * from v$version;
BANNER
-------------------
    

    • 

  • Python版B树
dieslrae
python

    话说以前的树都用java写的,最近发现python有点生疏了,于是用python写了个B树实现,B树在索引领域用得还是蛮多了,如果没记错mysql的默认索引好像就是B树...
首先是数据实体对象,很简单,只存放key,value
class Entity(object):
'''数据实体'''
def __init__(self,key,value)
    

    • 

  • C语言冒泡排序
dcj3sjt126com
算法

    代码示例：
# include <stdio.h>
//冒泡排序
void sort(int * a, int len)
{
int i, j, t;
for (i=0; i<len-1; i++)
{
for (j=0; j<len-1-i; j++)
{
if (a[j] > a[j+1]) // >表示升序 
    

    • 

  • 自定义导航栏样式
dcj3sjt126com
自定义

    -(void)setupAppAppearance
{
[[UILabel appearance] setFont:[UIFont fontWithName:@"FZLTHK—GBK1-0" size:20]];
[UIButton appearance].titleLabel.font =[UIFont fontWithName:@"FZLTH
    

    • 

  • 11.性能优化-优化-JVM参数总结
frank1234
jvm参数性能优化

    1.堆
-Xms --初始堆大小
-Xmx --最大堆大小
-Xmn --新生代大小
-Xss --线程栈大小
-XX:PermSize  --永久代初始大小
-XX:MaxPermSize  --永久代最大值
-XX:SurvivorRatio --新生代和suvivor比例,默认为8
-XX:TargetSurvivorRatio --survivor可使用
    

    • 

  • nginx日志分割 for linux
HarborChung
nginxlinux脚本

    nginx日志分割 for linux 默认情况下，nginx是不分割访问日志的，久而久之，网站的日志文件将会越来越大，占用空间不说，如果有问题要查看网站的日志的话，庞大的文件也将很难打开，于是便有了下面的脚本   使用方法，先将以下脚本保存为 cutlog.sh，放在/root 目录下，然后给予此脚本执行的权限
 
复制代码代码如下:
chmo
    

    • 

  • Spring4新特性——泛型限定式依赖注入
jinnianshilongnian
springspring4泛型式依赖注入

    Spring4新特性——泛型限定式依赖注入
Spring4新特性——核心容器的其他改进
Spring4新特性——Web开发的增强
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 
Spring4新特性——Groovy Bean定义DSL
Spring4新特性——更好的Java泛型操作API 
Spring4新
    

    • 

  • centOS安装GCC和G++
liuxihope
centosgcc

    Centos支持yum安装，安装软件一般格式为yum install .......，注意安装时要先成为root用户。
按照这个思路，我想安装过程如下：
安装gcc：yum install gcc
安装g++： yum install g++
实际操作过程发现，只能有gcc安装成功，而g++安装失败，提示g++ command not found。上网查了一下，正确安装应该
    

    • 

  • 第13章 Ajax进阶（上）
onestopweb
Ajax

    index.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    

    • 

  • How to determine BusinessObjects service pack and fix pack
blueoxygen
BO

    http://bukhantsov.org/2011/08/how-to-determine-businessobjects-service-pack-and-fix-pack/
 
The table below is helpful. Reference
  BOE XI 3.x
12.0.0.
y BOE XI 3.0 12.0.
x.
y BO
    

    • 

  • Oracle里的自增字段设置
tomcat_oracle
oracle

    　大家都知道吧，这很坑，尤其是用惯了mysql里的自增字段设置，结果oracle里面没有的。oh，no 　　我用的是12c版本的，它有一个新特性，可以这样设置自增序列，在创建表是，把id设置为自增序列
create table t
(
id 　　 　　 number generated by default as identity (start with 1 increment b
    

    • 

  • Spring Security（01）——初体验
yang_winnie
springSecurity

    Spring Security（01）——初体验
    博客分类： spring Security
Spring Security入门安全认证
       首先我们为Spring Security专门建立一个Spring的配置文件，该文件就专门用来作为Spring Security的配置
    

    •