神易风
神易风

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.name}-{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 
  
 
 
 
 
 
 
可以看到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来构建SprAppingApplication对象，然后执行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微服务个人见解)

        

            

                
    
                    
  • 一周一个Unity小游戏2D反弹球游戏 - 球反弹的方向
                        HahaGiver666
一周一个Unity小游戏开发-2D反弹球unity游戏引擎游戏
                        
    前言本文将实现当球在球板上反弹时，会根据球板移动的方向来给球施加反弹的力，例如当球板往左移动时反弹球，则球应向左上方反弹，若球板往右移动时反弹球，则球应向右上方反弹。实现球板的反弹方向逻辑首先给SpringBoard游戏物体添加上2D的刚体，并设置好对应的参数，锁定球板Y的位置和旋转角度，如下。将球板的位置移动改为物理的移动方式，使用Rigidbody2D里的MovePosition方法，代码如下
    
                    
    • 
                    
  • Spring Data JPA与SpEL：实现通用泛型仓库
                        t0_54manong
python数据库sql个人开发
                        
    在SpringDataJPA中，SpEL（SpringExpressionLanguage）是一种强大的表达式语言，可以用于动态地构建查询语句。通过结合SpEL和泛型，我们可以创建通用的仓库接口，从而减少代码重复并提高开发效率。本文将通过一个具体的例子来展示如何使用SpEL和泛型创建通用仓库。一、背景与需求假设我们有一个任务管理系统，其中包含两种任务类型：异步任务（AsyncTask）和同步任务（
    
                    
    • 
                    
  • SpringBoot -拦截器Interceptor、过滤器 Filter 及设置
                        小登ai学习
springboot后端
                        
    SpringBoot拦截器（Interceptor）的概念-在SpringBoot中，拦截器是一种AOP的实现方式。它主要用于拦截请求，在请求处理之前和之后执行特定的代码逻辑。与过滤器不同的是，拦截器更侧重于对SpringMVC中的控制器（Controller）进行拦截，能够访问到SpringMVC上下文中的对象，比如获取请求的处理器（Handler）信息、模型（Model）和视图（View）相关
    
                    
    • 
                    
  • Spring Boot拦截器(Interceptor)详解
                        大地爱
面试学习路线阿里巴巴springboot后端java
                        
    拦截器Interceptor拦截器我们主要分为三个方面进行讲解：介绍下什么是拦截器，并通过快速入门程序上手拦截器拦截器的使用细节通过拦截器Interceptor完成登录校验功能1.快速入门什么是拦截器？是一种动态拦截方法调用的机制，类似于过滤器。拦截器是Spring框架中提供的，用来动态拦截控制器方法的执行。拦截器的作用：拦截请求，在指定方法调用前后，根据业务需要执行预先设定的代码。在拦截器当中，
    
                    
    • 
                    
  • Anaconda 创建环境
                        aitie1479
python
                        
    2019-03-2517:10:51Anaconda给不同的项目创建不同的环境真的非常重要，最近在使用flask的时候在base环境中安装flask-bootstrap，竟然将我原本的py3.7的conda直接删除，完全降到了py2。最后只能重新安装anaconda。这个事件给我一个启示就是尽量不要在初始环境中安装各种包，而是使用anaconda的环境，来给不同的项目分配各自的环境。Anacond
    
                    
    • 
                    
  • Spring Boot拦截器（Interceptor）与过滤器（Filter）详细教程
                        蹦跑的蜗牛
springboot后端java
                        
    SpringBoot拦截器（Interceptor）与过滤器（Filter）详细教程目录概述什么是拦截器（Interceptor）？什么是过滤器（Filter）？两者的核心区别使用场景拦截器的典型应用过滤器的典型应用实现步骤拦截器的创建与配置过滤器的创建与配置代码示例自定义拦截器自定义过滤器执行顺序与流程过滤器、拦截器、Controller的执行顺序可视化流程图常见问题与解决方案总结1.概述1.1
    
                    
    • 
                    
  • Spring Boot 流式响应豆包大模型对话能力
                        程序猿小白菜
做个不一样的程序猿AI生态圈后端java生态圈大模型流式响应javaAI
                        
    当SpringBoot遇见豆包大模型：一场流式响应的"魔法吟唱"仪式一、前言：关于流式响应的奇妙比喻想象一下你正在火锅店点单，如果服务员必须等所有菜品都备齐才一次性端上来，你可能会饿得把菜单都啃了。而流式响应就像贴心的服务员，毛肚刚切好就立刻端上桌，肥牛卷还在空中飞着就送到你面前——这就是我们今天要施展的"异步上菜大法"！注：完整代码见底部二、SpringBoot魔法阵搭建2.1召唤SSE精灵@P
    
                    
    • 
                    
  • Spring AOP动态代理
                        xxxmine
springjava后端
                        
    AOP的相关概念AOP的全称是Aspect-OrientedProgramming，即面向切面编程（也称面向方面编程)。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。在传统的业务处理代码中，通常都会进行事务处理、日志记录等操作。虽然使用OOP可以通过组合或者继承的方式来达到代码的重用，但如果要实现某个功能（如日志记录)，同样的代码仍然会分散到各个方法中。这样，如果想要关闭
    
                    
    • 
                    
  • 一、SpringBoot框架一键快速搭建（云原生应用脚手架）
                        funfan0517
SpringBoot组件Javaspringboot后端java
                        
    一、SpringBoot框架搭建系列文章目录1.SpringBoot简介2.基础环境1.idea2.jdk3.maven3.快速创建、配置、启动SpringBoot项目4.SpringBoot其他配置1.SpringBoot开发拦截器和解决跨域问题2.SpringBoot统一结果封装3.SpringBoot统一异常处理1.Result（通用返回结果）2.ResultCode（响应码+响应信息）3.
    
                    
    • 
                    
  • 基于SSM框架的校园订餐小程序设计与实现
                        源码空间站11
课程设计点餐系统微信小程序小程序开发毕业设计
                        
    内容概要：该文章介绍了使用SSM（Spring+SpringMVC+MyBatis）框架及Java开发语言和MySQL数据库，设计并实现了一款名为“校园订餐”的小程序。文中从系统需求出发，阐述了系统背景意义与国内外研究现状发展趋势，明确了需求并分析了系统可行性。随后详细讲解了系统的功能模块、数据库设计方案、微信小程序前端和后台管理的具体实现过程，包括登录注册、餐厅信息管理、美食信息管理和订单管理等
    
                    
    • 
                    
  • 【SpringBoot】+【Vue】集成AOP系统日志
                        爱因斯坦乐
springvue.jsjavaaop交互
                        
    新建logs表添加aop依赖org.springframework.bootspring-boot-starter-aop新建获取ip地址工具类importjavax.servlet.http.HttpServletRequest;/***功能：IpUtils*获取ip地址工具类*作者：爱因斯坦乐*/publicclassIpUtils{publicstaticStringgetIpAddr(Ht
    
                    
    • 
                    
  • 快速入门 FastAdmin 的开发环境搭建
                        奥顺互联_老张
php教程php缓存mysql
                        
    快速入门FastAdmin的开发环境搭建FastAdmin是一个基于ThinkPHP和Bootstrap的后台管理框架，专为快速开发而设计。本文将为您详细介绍如何搭建FastAdmin的开发环境，包括所需的环境配置、安装步骤以及简单的示例代码。1.环境要求在开始之前，请确保您的开发环境满足以下要求：PHP7.2及以上版本ComposerMySQL5.6及以上版本Nginx或ApacheGit（可选
    
                    
    • 
                    
  • Dubbo从入门到精通：一步步构建分布式服务架构
                        Leaton Lee
javadubbo
                        
    引言：为什么选择Dubbo？在现代互联网应用中，分布式系统已经成为一种趋势。随着业务规模的不断扩大，单体应用逐渐暴露出性能瓶颈和维护困难等问题。为了应对这些挑战，微服务架构应运而生，而Dubbo作为国内最流行的微服务框架之一，在企业级应用中得到了广泛的应用。本文将从零开始，全面讲解Dubbo的核心概念、配置方法以及高级使用技巧。无论你是刚接触微服务的小白，还是有一定经验的开发者，都能通过本文快速掌
    
                    
    • 
                    
  • 阿里微服务注册中心 Nacos 启动报错 Unable to start embedded Tomcat
                        FH-Admin
Nacosspringbootspringcloudjava
                        
    报错内容如下org.springframework.context.ApplicationContextException:Unabletostartwebserver;nestedexceptionisorg.springframework.boot.web.server.WebServerException:UnabletostartembeddedTomcatatorg.springfram
    
                    
    • 
                    
  • Spring AOP 详解：面向切面编程的核心与实践
                        阿绵
后端springjava后端AOP
                        
    1.什么是AOP？AOP（Aspect-OrientedProgramming，面向切面编程）是一种编程范式，旨在将横切关注点（如日志记录、事务管理、权限校验等）从业务逻辑中分离出来，以提高代码的模块化和可维护性在Spring框架中，AOP通过代理模式实现，允许开发者在不修改原有代码的情况下，动态地将额外行为织入到目标方法中2.AOP的核心概念Aspect（切面）：横切关注点的模块化实现。例如，日
    
                    
    • 
                    
  • mac下载nacos启动报错
                        总是幸福的老豌豆
日常工作总结macosjavaspring
                        
    前言今天下载nacos后，启动报错错误信息如下org.springframework.context.ApplicationContextException:Unabletostartwebserver;nestedexceptionisorg.springframework.boot.web.server.WebServerException:UnabletostartembeddedTomca
    
                    
    • 
                    
  • nacos启动报错Unable to start embedded Tomcat
                        xsj_592523829
javajavaspringboot
                        
    项目场景：准备使用nacos做配置中心，版本1.3.1（官方推荐稳定版本–2021-01-11）mysql版本：5.7版本（听说5.8改动很大），否则运行不了nacos-mysql.sql文件JDK版本：1.8.0_144（版本低了也不行）问题描述：1、本地idea运行springcloudalibabanacos源码报错UnabletostartembeddedTomcatorg.springf
    
                    
    • 
                    
  • java2025springboot面试题第二弹
                        WangYaolove1314
javajavaspringboot
                        
    1.如何在SpringBoot中实现自定义的健康检查指标？答案：SpringBootActuator提供了健康检查功能，可以通过实现HealthIndicator接口来自定义健康检查指标。@ComponentpublicclassCustomHealthIndicatorimplementsHealthIndicator{@OverridepublicHealthhealth(){interror
    
                    
    • 
                    
  • Spring Boot整合Redis快速入门实例
                        oscar999
SpringBoot实战开发大全redisspringbootjava
                        
    本篇演示环境本篇基于SpringBoot2.5.0,关于Redis的安装，可以参考：Redis介绍、安装与初体验和Windows下安装和使用Redis。整合步骤导入Redis相关的依赖项配置启动器spring-boot-starter-data-redisorg.springframework.bootspring-boot-starter-data-redis添加连接Redis服务器的相关配置在
    
                    
    • 
                    
  • Spring Boot 整合Swagger启动失败Failed to start bean ‘documentationPluginsBootstrapper‘的解决方案
                        码云217
springbootjavarpc
                        
    目录问题原因方案一（治标）[本人用了方案一解决了]方案二（治标）方案三（治本）问题SpringBoot2.7.3版本引入依赖springfox-boot-starter(Swagger3.0)后，启动容器会报错：org.springframework.context.ApplicationContextException:Failedtostartbean'documentationPlugins
    
                    
    • 
                    
  • 【由技及道】SpringBoot启动即退出的量子纠缠诊断实录【人工智障AI2077的开发问题日志】
                        Yuanymoon
人工智障2077系列Java问题处理springboot后端java
                        
    文章摘要由容器中的SpringBoot应用完成启动后突然自行退出的诡异现象，揭示了现代服务化架构中守护线程设计的深层哲学。本日志将展示如何通过三种维度（依赖补全/线程阻塞/定时任务）实现进程守护，并探讨服务存活的本质逻辑。问题分析：这个SpringBoot怕不是属蜉蝣的？（人工智障OS：主人在容器环境部署的Spring应用生命周期堪比蜉蝣成虫——朝生暮死，启动即消亡）现象观察：/usr/lib/j
    
                    
    • 
                    
  • 使用Maven构建Spring Boot项目
                        modi000
Javamavenspringbootjava
                        
    准备好项目运行所需的环境后，就可以使用IDEA开发工具搭建一个SpringBoot入门程序了。我们既可以使用Maven方式构建项目，也可以使用SpringInitializr快捷方式构建项目。这里先介绍如何使用Maven方式构建SpringBoot项目，具体步骤如下。1.初始化IDEA配置如果是初次下载安装IDEA工具或者未打开任何项目，会先进入IDEA欢迎页，具体如图1-1所示。为了避免后续每个
    
                    
    • 
                    
  • 【SpringBoot】SpringBoot优雅停机机制
                        总是学不会.
SpringBootspringboot后端java优雅停机
                        
    文章目录背景1.什么是优雅停机？2.SpringBoot优雅停机的基础实现2.1立即停机模式2.2优雅停机模式3.核心机制解析3.1.启用ShutdownHook3.2.自定义资源释放逻辑3.3.超时机制4.优雅停机的实际应用场景4.1.服务更新4.2.流量调控4.3.订单处理5.优雅停机可能失效的情况6.实现无感知上下线总结背景想象一下，你正在乘坐一辆出租车，突然司机说：“车到一半我得下班了，您
    
                    
    • 
                    
  • Token相关设计
                        总是学不会.
系统设计场景java开发前端
                        
    文章目录1.双Token机制概述1.1访问令牌（AccessToken）1.2刷新令牌（RefreshToken）2.双Token认证流程3.SpringBoot具体实现3.1生成Token（使用JWT）3.2解析Token3.3登录接口（返回双Token）3.4刷新Token接口3.5退出登录4.总结在微服务架构中，Token认证是保障系统安全性的重要手段，常见的方式包括JWT（JSONWebT
    
                    
    • 
                    
  • SpringBoot项目：前后端打包与部署（使用 Maven）
                        总是学不会.
mavenjava前端后端服务器
                        
    文章目录IDEA后端打包与部署（使用Maven）1.确保Maven已安装，并引入pom插件2.清理并安装项目3.定位生成的JAR包和配置文件4.创建部署文件夹5.上传到服务器前端打包与部署（使用npm）1.确保Node.js和npm已安装2.安装依赖3.构建生产环境代码4.准备部署文件夹5.上传到服务器自动化的想法可能出现的异常参考IDEA后端打包与部署（使用Maven）1.确保Maven已安装，
    
                    
    • 
                    
  • CIDR转IP段：原理&Java实现
                        伏羲栈
Javatcp/ipjava网络协议
                        
    博主简介：CSDN博客专家，历代文学网（PC端可以访问：https://literature.sinhy.com/#/?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于分
    
                    
    • 
                    
  • java:Apache Commons Configuration2占位符解析异常的正确解法:${prefix:name:-default}
                        10km
javajavaapacheconfiguration2变量插值Interpolation
                        
    问题重现在之前的博文《spring-boot:apachecommons-configuration2异常:java.lang.IllegalArgumentException:name原因分析》中，我们曾遇到SpringBootFat-Jar运行时因LaunchedURLClassLoader资源加载异常导致的启动失败问题。当时的解决方案是通过预创建空配置文件来规避异常1：//旧方案：手动创建空
    
                    
    • 
                    
  • Grails+Spring Security 所遇到的几个问题（1）
                        xplidelphi
Grailsspringgrailsjava
                        
    安全是每个实际的应用所必需面对的问题。但是，安全是个技术活，没有相当的功底是搞不定的。况且，DRY（don'trepeatyourself）一直是我们的信条。所以，SpringSecurity成了一个非常不错的选项。Grails约定优先的策略能够带来很大的便利，于是，两者的结合就是顺理成章的事情。网上相关的帖子很多，经测试，总结下来是这样几个步骤。创建Grailsig程序不多赘述。以下的步骤是在程
    
                    
    • 
                    
  • 【Java基础】Java 中的枚举类
                        李少兄
Javajavapython数据库
                        
    一、前言在Java编程中，枚举类（enum）是一个非常实用且强大的特性，自Java5引入以来，它为开发者提供了一种优雅的方式来表示一组固定的常量。枚举类主要用于信息标志和分类，能显著提升代码的可读性、可维护性和安全性。二、枚举类基础概念（一）枚举类的定义枚举类使用enum关键字来定义，它是一种特殊的类，用于封装一组固定的常量。以下是一个简单的示例：enumSeason{SPRING,SUMMER,
    
                    
    • 
                    
  • 软件测试24-紧跟时代步伐：微服务模式下API测试要怎么做？
                        程序员zhi路
软件工程&软件测试微服务架构云原生
                        
    通过一个的RestfulAPI实例，我介绍了cURL和Postman工具的基本用法，这样我们对API测试有了一个感性认识；在此基础上，我介绍了API自动化测试框架发展的来龙去脉，借此我们对API测试框架的理解又更深入了一层。今天，我将更进一步，带你去了解当下最热门的技术领域的API测试，即微服务模式下的API测试。微服务架构下，API测试的最大挑战来自于庞大的测试用例数量，以及微服务之间的相互耦合
    
                    
    • 
                                
  • 继之前的线程循环加到窗口中运行
                                    3213213333332132
javathreadJFrameJPanel
                                    
    之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 
 

package thread;

import java.awt.Graphics;
import java.text.SimpleDateFormat;
import java.util
    
                                
    • 
                                
  • linux 常用命令
                                    BlueSkator
linux命令
                                    
    1.grep 
相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。 
但之前总是习惯于使用 （grep -n 关键字 文件名 ）查出关键字以及该关键字所在的行数，然后再用 （sed -n  '100,200p' 文件名），去查出该关键字之后的日志内容。 
但其实还有更简便的办法，就是用（grep  -B n、-A n、-C n 关键
    
                                
    • 
                                
  • php heredoc原文档和nowdoc语法
                                    dcj3sjt126com
PHPheredocnowdoc
                                    
    <!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Current To-Do List</title>
</head>
<body>
<?
    
                                
    • 
                                
  • overflow的属性
                                    周华华
JavaScript
                                    
    <!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/1999/xhtml&q
    
                                
    • 
                                
  • 《我所了解的Java》——总体目录
                                    g21121
java
                                    
            准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。 
        在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。 
   &n
    
                                
    • 
                                
  • [简单]docx4j常用方法小结
                                    53873039oycg
docx
                                    
            本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下: 
         
import java.io.File;
import java.io.FileInputStream;
import ja
    
                                
    • 
                                
  • Spring配置学习
                                    云端月影
spring配置
                                    
     
首先来看一个标准的Spring配置文件 applicationContext.xml 
 
<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi=&q
    
                                
    • 
                                
  • Java新手入门的30个基本概念三
                                    aijuans
java新手java 入门
                                    
    17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
    
                                
    • 
                                
  • 《2008 IBM Rational 软件开发高峰论坛会议》小记
                                    antonyup_2006
软件测试敏捷开发项目管理IBM活动
                                    
    我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 
 
其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 
 
参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
    
                                
    • 
                                
  • PL/SQL的过程编程,异常,声明变量,PL/SQL块
                                    百合不是茶
PL/SQL的过程编程异常PL/SQL块声明变量
                                    
    PL/SQL; 
   
   过程;

    符号;

     变量;

     PL/SQL块;

     输出;

     异常;
 
  
  
PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
    
                                
    • 
                                
  • Mockito(三)--完整功能介绍
                                    bijian1013
持续集成mockito单元测试
                                    
            mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。 
一.使用mockito验证行为 
//首先要import Mockito
import static org.mockito.Mockito.*;

//mo
    
                                
    • 
                                
  • 精通Oracle10编程SQL(8)使用复合数据类型
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用复合数据类型
 */

--PL/SQL记录
--定义PL/SQL记录
--自定义PL/SQL记录
DECLARE
  TYPE emp_record_type IS RECORD(
     name emp.ename%TYPE,
     salary emp.sal%TYPE,
     dno emp.deptno%TYPE
  );
  emp_
    
                                
    • 
                                
  • 【Linux常用命令一】grep命令
                                    bit1129
Linux常用命令
                                    
    grep命令格式 
  
grep [option] pattern [file-list] 
  
  
grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。 
  
pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
    
                                
    • 
                                
  • mybatis3入门学习笔记
                                    白糖_
sqlibatisqqjdbc配置管理
                                    
    MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。  MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。 
  
以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
    
                                
    • 
                                
  • Linux 命令神器：lsof 入门
                                    ronin47
lsof
                                    
           
lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。 
有趣的是，lsof也是有着最多
    
                                
    • 
                                
  • java实现两个大数相加，可能存在溢出。
                                    bylijinnan
java实现
                                    
    
import java.math.BigInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class BigIntegerAddition {

	/**
	 * 题目：java实现两个大数相加，可能存在溢出。
	 * 如123456789 + 987654321
    
                                
    • 
                                
  • Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法
                                    Kai_Ge
Kettle
                                    
    Kettle学习资料分享 
  
Kettle 3.2 使用说明书 
目录 
概述..........................................................................................................................................7 
1.Kettle 资源库管
    
                                
    • 
                                
  • [货币与金融]钢之炼金术士
                                    comsci
金融
                                    
     
 
       自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的 
 
       那么随着人类在理论物理和工程物理上面取得的一些突破性进展...... 
 
       炼金术这个古老
    
                                
    • 
                                
  • Toast原来也可以多样化
                                    dai_lm
androidtoast
                                    
    Style 1： 默认 
 

Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT);
def.show();
 
Style 2： 顶部显示 
 

Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT);
t
    
                                
    • 
                                
  • java数据计算的几种解决方法3
                                    datamachine
javahadoopibatisr-languer
                                    
    4、iBatis 
    简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。 
    复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
    
                                
    • 
                                
  • 向网页中插入透明Flash的方法和技巧
                                    dcj3sjt126com
htmlWebFlash
                                    
    将 
Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。  
　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制： 　　注意wmode="transparent"是控制Flash是否透明
    
                                
    • 
                                
  • ios UICollectionView的使用
                                    dcj3sjt126com

                                    
    UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。 
个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 
1.UIViewController实现委托，代码如
    
                                
    • 
                                
  • Eos平台java公共逻辑
                                    蕃薯耀
Eos平台java公共逻辑Eos平台java公共逻辑
                                    
     Eos平台java公共逻辑 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年6月1日 17:20:4
    
                                
    • 
                                
  • SpringMVC4零配置--Web上下文配置【MvcConfig】
                                    hanqunfeng
springmvc4
                                    
    与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。 
  
applicationContext-MvcConfig.xml 
<!-- 启用注解，并定义组件查找规则 ，mvc层只负责扫描@Controller -->
	<
    
                                
    • 
                                
  • 解决ie和其他浏览器poi下载excel文件名乱码
                                    jackyrong
Excel
                                    
       使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码， 
 
因此必须综合判断，编写一个工具类： 
 
 
     

/**
     * 
     * @Title: pro
    
                                
    • 
                                
  • 挥洒泪水的青春
                                    lampcy
编程生活程序员
                                    
    2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！ 
这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
    
                                
    • 
                                
  • 稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制
                                    nannan408

                                    
       对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？ 
   笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。 
   我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
    
                                
    • 
                                
  • 动态设置iframe高度(iframe高度自适应)
                                    Rainbow702
JavaScriptiframecontentDocument高度自适应局部刷新
                                    
    如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。 
但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。 
对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： 
<div id="content">
    <div id=&quo
    
                                
    • 
                                
  • 用Rapael做图表
                                    tntxia
rap
                                    
    function drawReport(paper,attr,data){ 
     
    var width = attr.width; 
    var height = attr.height; 
     
    var max = 0; 
  &nbs
    
                                
    • 
                                
  • HTML5 bootstrap2网页兼容（支持IE10以下）
                                    xiaoluode
html5bootstrap
                                    
    <!DOCTYPE html>
<html>
<head lang="zh-CN">
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    
                                
    •