찾다
Javajava지도 시간SpringBoot 시작 프로세스 SpringApplication 소스 코드 분석

    SpringBoot启动流程源码分析一、入口参数研究和创建对象

    准备阶段分析

    以下先看下SpringApplication的run()方法

    package org.springframework.boot;
    public ConfigurableApplicationContext run(String... args) {
       //1.计时器
       StopWatch stopWatch = new StopWatch();
       stopWatch.start();
       ConfigurableApplicationContext context = null;
       Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
       //2.headless配置
       configureHeadlessProperty();
       //3、获取监听
       SpringApplicationRunListeners listeners = getRunListeners(args);
       listeners.starting();
       try {
       //应用程序启动的参数  
          ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
          //4、准备环境
          ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
          //环境创建成功后,配置bean信息,决定是否跳过 BeanInfo 类的扫描,如果设置为 true,则跳过
          configureIgnoreBeanInfo(environment);
          //打印banner信息
          Banner printedBanner = printBanner(environment);
          context = createApplicationContext();
          exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
          prepareContext(context, environment, listeners, applicationArguments, printedBanner);
          refreshContext(context);
          afterRefresh(context, applicationArguments);
          //停止计时
          stopWatch.stop();
          //控制是否打印日志的,这里为true,即打印日志
          if (this.logStartupInfo) {
             new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
          }
          listeners.started(context);
          callRunners(context, applicationArguments);
       }
       catch (Throwable ex) {
          handleRunFailure(context, ex, exceptionReporters, listeners);
          throw new IllegalStateException(ex);
       }
       try {
          listeners.running(context);
       }
       catch (Throwable ex) {
          handleRunFailure(context, ex, exceptionReporters, null);
          throw new IllegalStateException(ex);
       }
       return context;
    }

    我将会根据执行过程逐行进行分析

    1、StopWatch计时器

    此类实则为计时器,如下对具体使用进行分析

    StopWatch stopWatch = new StopWatch();
    //开始计时
    stopWatch.start();
    //停止计时
    stopWatch.stop();

    对于具体打印的上面写的为

    //将当前类传入StartupInfoLogger创建了一个对象
    //然后调用logStarted打印日志
    new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    //创建一个Log类
    protected Log getApplicationLog() {
       if (this.mainApplicationClass == null) {
          return logger;
       }
       return LogFactory.getLog(this.mainApplicationClass);
    }
    //调用log类的log.info()方法来打印日志
    public void logStarted(Log log, StopWatch stopWatch) {
        if (log.isInfoEnabled()) {
                log.info(getStartedMessage(stopWatch));
        }
    }
    //打印详细的日志
    private StringBuilder getStartedMessage(StopWatch stopWatch) {
       StringBuilder message = new StringBuilder();
       message.append("Started ");
       message.append(getApplicationName());
       message.append(" in ");
       message.append(stopWatch.getTotalTimeSeconds());
       try {
          double uptime = ManagementFactory.getRuntimeMXBean().getUptime() / 1000.0;
          message.append(" seconds (JVM running for " + uptime + ")");
       }
       catch (Throwable ex) {
          // No JVM time available
       }
       return message;
    }

    这里可以看到stopWatch.getTotalTimeSeconds()方法就是来获取实际的计时时间的。再者,通过这几行代码,我们也可以考虑下平常在写代码的时候,有几种日志打印方式?SpringBoot是怎么集成日志框架的?

    2、configureHeadlessProperty()

    private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";
    private void configureHeadlessProperty() {
       System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
             System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
    }

    这一部分代码这样理解吧,首先java.awt包提供了用于创建用户界面和绘制图形图像的所有分类,那么 属性SYSTEM_PROPERTY_JAVA_AWT_HEADLESS就一定会和用户界面相关了。 这里将SYSTEM_PROPERTY_JAVA_AWT_HEADLESS设置为true,其实就是表示在缺少显示屏、键盘或者鼠标中的系统配置,如果将其设置为true,那么headless工具包就会被使用。

    3、getRunListeners(args) 获取监听

    总体上可以分这三步

    • 获取一个默认的加载器

    • 根据类型获取spring.factories中符合的类名

    • 创建类实例,返回

    如下将跟下代码

    //获取所有监听
    SpringApplicationRunListeners listeners = getRunListeners(args);
    //启动监听
    listeners.starting();

    跳转进入getRunListeners方法

    private SpringApplicationRunListeners getRunListeners(String[] args) {
       Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
       return new SpringApplicationRunListeners(logger,
             getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
    }
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
      //3.1获取类加载器
       ClassLoader classLoader = getClassLoader();
       // Use names and ensure unique to protect against duplicates
       //3.2 根据类型获取spring.factories中符合的类名
       Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
       //3.3 创建类实例
       List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
       //对实例进行排序
       AnnotationAwareOrderComparator.sort(instances);
       return instances;
    }
    SpringApplicationRunListeners类解读

    先看下SpringApplicationRunListeners类

    /**
     * A collection of {@link SpringApplicationRunListener}.
     *
     * @author Phillip Webb
     */
    class SpringApplicationRunListeners {
       private final Log log;
       private final List<SpringApplicationRunListener> listeners;
       SpringApplicationRunListeners(Log log, Collection<? extends SpringApplicationRunListener> listeners) {
          this.log = log;
          this.listeners = new ArrayList<>(listeners);
       }

    SpringApplicationRunListeners类内部关联了SpringApplicationRunListener的集合,说白了就是用List集合存储了SpringApplicationRunListeners类,那么,我们就需要了解一下这个类是干嘛的

    老规矩,先把源码抬上来

    /**
     *//可以理解为Spring Boot应用的运行时监听器
     * Listener for the {@link SpringApplication} {@code run} method.
     *//SpringApplicationRunListener的构造器参数必须依次为SpringApplication和String[]类型
     * {@link SpringApplicationRunListener}s are loaded via the {@link SpringFactoriesLoader}
     * and should declare a public constructor that accepts a {@link SpringApplication}
     * instance and a {@code String[]} of arguments.
     *//每次运行的时候将会创建一个 SpringApplicationRunListener
      A new
     * {@link SpringApplicationRunListener} instance will be created for each run.
     *
     */
    public interface SpringApplicationRunListener {
       /**
        * Called immediately when the run method has first started. Can be used for very
        * early initialization.
        */
        //Spring应用刚启动
       void starting();
       /**
        * Called once the environment has been prepared, but before the
        * {@link ApplicationContext} has been created.
        * @param environment the environment
        */
        //ConfigurableEnvironment准备妥当,允许将其调整
       void environmentPrepared(ConfigurableEnvironment environment);
       /**
        * Called once the {@link ApplicationContext} has been created and prepared, but
        * before sources have been loaded.
        * @param context the application context
        */
        //ConfigurableApplicationContext准备妥当,允许将其调整
       void contextPrepared(ConfigurableApplicationContext context);
       /**
        * Called once the application context has been loaded but before it has been
        * refreshed.
        * @param context the application context
        */
        //ConfigurableApplicationContext已装载,但是任未启动
       void contextLoaded(ConfigurableApplicationContext context);
       /**
        * The context has been refreshed and the application has started but
        * {@link CommandLineRunner CommandLineRunners} and {@link ApplicationRunner
        * ApplicationRunners} have not been called.
        * @param context the application context.
        * @since 2.0.0
        */
        //ConfigurableApplicationContext已启动,此时Spring Bean已初始化完成
       void started(ConfigurableApplicationContext context);
       /**
        * Called immediately before the run method finishes, when the application context has
        * been refreshed and all {@link CommandLineRunner CommandLineRunners} and
        * {@link ApplicationRunner ApplicationRunners} have been called.
        * @param context the application context.
        * @since 2.0.0
        */
        //Spring应用正在运行
       void running(ConfigurableApplicationContext context);
       /**
        * Called when a failure occurs when running the application.
        * @param context the application context or {@code null} if a failure occurred before
        * the context was created
        * @param exception the failure
        * @since 2.0.0
        */
        //Spring应用运行失败
       void failed(ConfigurableApplicationContext context, Throwable exception);
    }

    单纯的看源码,是一个简单的接口,这时候我们可以看下作者给的注释。理解部分就直接加到上面源码中了。

    再看下他的实现类EventPublishingRunListener

    public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
       private final SpringApplication application;
       private final String[] args;
       private final SimpleApplicationEventMulticaster initialMulticaster;
       public EventPublishingRunListener(SpringApplication application, String[] args) {
          this.application = application;
          this.args = args;
          this.initialMulticaster = new SimpleApplicationEventMulticaster();
          for (ApplicationListener<?> listener : application.getListeners()) {
             this.initialMulticaster.addApplicationListener(listener);
          }
       }

    这里我们看到两点:

    • 构造器参数和他实现的接口(上面刚分析了)注释中规定的一致

    • 将SpringApplication中的ApplicationListener实例列表全部添加到了SimpleApplicationEventMulticaster对象中

    SimpleApplicationEventMulticaster是Spring框架的一个监听类,用于发布Spring应用事件。因此EventPublishingRunListener实际充当了Spring Boot事件发布者的角色。

    这里我再跟进源码的时候发现,针对SpringBoot的事件/监听机制内容还是挺多的,我们在充分理解的时候需要先了解Spring的事件/监听机制,后面将两个结合后单独进行对比分析。

    3.1获取类加载器getClassLoader()
    ClassLoader classLoader = getClassLoader();
    public ClassLoader getClassLoader() {
      if (this.resourceLoader != null) {
         return this.resourceLoader.getClassLoader();
      }
      return ClassUtils.getDefaultClassLoader();
    }

    这里的类加载器获取首先是获取resourceLoader的类加载器,获取不到则获取默认的类加载器。 resourceLoader是资源加载器类,有具体的实现类。

    3.2 根据类型获取spring.factories中符合的类名
    SpringFactoriesLoader.loadFactoryNames(type, classLoader)
    public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    //获取类型名称:org.springframework.context.ApplicationContextInitializer
       String factoryClassName = factoryClass.getName();
       return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

    我们继续对loadSpringFactories追下去

    private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        //从缓存里面获取
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
            //执行classLoader.getResources("META-INF/spring.factories"),表示通过加载器获取META-INF/spring.factories下的资源
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();
                while(urls.hasMoreElements()) {
                   //文件地址
                    URL url = (URL)urls.nextElement();
                    //从指定位置加载UrlResource
                    UrlResource resource = new UrlResource(url);
                    //加载里面的属性,属性见下图
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();
                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        //获取key值
                        String factoryClassName = ((String)entry.getKey()).trim();
                        //获取value值
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;
    //这里是将查询出来的key作为result的key,value转换成字符数组存放到result的value中
                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryName = var9[var11];
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }
                //将结果集存入缓存中
                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

    SpringBoot 시작 프로세스 SpringApplication 소스 코드 분석

    default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
    }

    这个的意思是如果没有,则获取一个空的list

    3.3创建实例createSpringFactoriesInstances()

    这一步其实就是将上一步从META-INF/spring.factories加载进来的资源进行实例化。

    private <T> List<T> createSpringFactoriesInstances()(Class<T> type, Class<?>[] parameterTypes,
          ClassLoader classLoader, Object[] args, Set<String> names) {
       List<T> instances = new ArrayList<>(names.size());
       for (String name : names) {
          try {
          //根据类加载器获取指定类
             Class<?> instanceClass = ClassUtils.forName(name, classLoader);
             Assert.isAssignable(type, instanceClass);
             //根据参数获取构造器
             Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
             //根据传入的构造器对象以及构造器所需的参数创建一个实例
             T instance = (T) BeanUtils.instantiateClass(constructor, args);
             //添加实例到集合中
             instances.add(instance);
          }
          catch (Throwable ex) {
             throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
          }
       }
       return instances;
    }

    4、环境准备prepareEnvironment

    prepareEnvironment(listeners, applicationArguments)
    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
          ApplicationArguments applicationArguments) {
       // Create and configure the environment
       //4.1 创建一个环境
       ConfigurableEnvironment environment = getOrCreateEnvironment();
       //4.2 配置环境
       configureEnvironment(environment, applicationArguments.getSourceArgs());
       //4.3 ConfigurationPropertySourcesPropertySource对象存入到第一位
       ConfigurationPropertySources.attach(environment);
       //listeners环境准备(就是广播ApplicationEnvironmentPreparedEvent事件)
       listeners.environmentPrepared(environment);
       // 将环境绑定到SpringApplication
       bindToSpringApplication(environment);
         // 如果是非web环境,将环境转换成StandardEnvironment
       if (!this.isCustomEnvironment) {
          environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
                deduceEnvironmentClass());
       }
        // 配置PropertySources对它自己的递归依赖
       ConfigurationPropertySources.attach(environment);
       return environment;
    }
    4.1创建一个环境getOrCreateEnvironment
    private ConfigurableEnvironment getOrCreateEnvironment() {
    //有的话,直接返回
      if (this.environment != null) {
         return this.environment;
      }
      //这里我们在上面见到过,通过WebApplicationType.deduceFromClasspath()方法获取的
      switch (this.webApplicationType) {
      case SERVLET:
         return new StandardServletEnvironment();
      case REACTIVE:
         return new StandardReactiveWebEnvironment();
      default:
         return new StandardEnvironment();
      }
    }

    这里创建了一个StandardServletEnvironment实例的环境 systemProperties用来封装了JDK相关的信息 如下图

    SpringBoot 시작 프로세스 SpringApplication 소스 코드 분석

    systemEnvironment用来封转环境相关的信息

    SpringBoot 시작 프로세스 SpringApplication 소스 코드 분석

    封装的还是挺详细的哈。

    4.2 配置环境
    protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
       if (this.addConversionService) {
          ConversionService conversionService = ApplicationConversionService.getSharedInstance();
          environment.setConversionService((ConfigurableConversionService) conversionService);
       }
       configurePropertySources(environment, args);
       configureProfiles(environment, args);
    }

    setConversionService(ConfigurableConversionService conversionService)方法继承于ConfigurablePropertyResolver接口, 该接口是PropertyResolver类型都将实现的配置接口。提供用于访问和自定义将属性值从一种类型转换为另一种类型时使用的ConversionService的工具。PropertyResolver是用于针对任何底层源解析属性的接口。

    configurePropertySources(environment, args);当前方法主要是将启动命令中的参数和run 方法中的参数封装为PropertySource。

    protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
    //获取所有的属性源,就是获取4.1的ConfigurableEnvironment上获取到的属性
      MutablePropertySources sources = environment.getPropertySources();
      if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
         sources.addLast(new MapPropertySource("defaultProperties", this.defaultProperties));
      }
      //是否添加命令启动参数,addCommandLineProperties为true,表示需要添加,但是前提是你得配置了参数
      if (this.addCommandLineProperties && args.length > 0) {
         String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
         if (sources.contains(name)) {
            PropertySource<?> source = sources.get(name);
            CompositePropertySource composite = new CompositePropertySource(name);
            composite.addPropertySource(
                  new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
            composite.addPropertySource(source);
            sources.replace(name, composite);
         }
         else {
            sources.addFirst(new SimpleCommandLinePropertySource(args));
         }
      }
    }

    configureProfiles(environment, args);环境配置

    protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
    //获取激活的环境
      environment.getActiveProfiles(); // ensure they are initialized
      // But these ones should go first (last wins in a property key clash)
      Set<String> profiles = new LinkedHashSet<>(this.additionalProfiles);
      profiles.addAll(Arrays.asList(environment.getActiveProfiles()));
      //设置当前的环境
      environment.setActiveProfiles(StringUtils.toStringArray(profiles));
    }
    4.3 ConfigurationPropertySourcesPropertySource对象存入
    public static void attach(Environment environment) {
       Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
       //获取所有的属性源,就是获取4.1的ConfigurableEnvironment上获取到的属性
       MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
       //判断是否有 属性 configurationProperties
       PropertySource<?> attached = sources.get(ATTACHED_PROPERTY_SOURCE_NAME);
       if (attached != null && attached.getSource() != sources) {
          sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
          attached = null;
       }
       if (attached == null) {
       // 将sources封装成ConfigurationPropertySourcesPropertySource对象,并把这个对象放到sources的第一位置
          sources.addFirst(new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,
                new SpringConfigurationPropertySources(sources)));
       }
    }

    위 내용은 SpringBoot 시작 프로세스 SpringApplication 소스 코드 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

    성명
    이 기사는 亿速云에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제
    Java가 크로스 플랫폼 데스크톱 응용 프로그램을 개발하기 위해 인기있는 선택 인 이유는 무엇입니까?Java가 크로스 플랫폼 데스크톱 응용 프로그램을 개발하기 위해 인기있는 선택 인 이유는 무엇입니까?Apr 25, 2025 am 12:23 AM

    javaispopularforcross-platformdesktopapplicationsduetoits "writeonce, runanywhere"철학

    Java의 플랫폼 별 코드 작성 상황에 대해 토론하십시오.Java의 플랫폼 별 코드 작성 상황에 대해 토론하십시오.Apr 25, 2025 am 12:22 AM

    Java에서 플랫폼 별 코드를 작성하는 이유에는 특정 운영 체제 기능에 대한 액세스, 특정 하드웨어와 상호 작용하고 성능 최적화가 포함됩니다. 1) JNA 또는 JNI를 사용하여 Windows 레지스트리에 액세스하십시오. 2) JNI를 통한 Linux 특이 적 하드웨어 드라이버와 상호 작용; 3) 금속을 사용하여 JNI를 통해 MacOS의 게임 성능을 최적화하십시오. 그럼에도 불구하고 플랫폼 별 코드를 작성하면 코드의 이식성에 영향을 미치고 복잡성을 높이며 잠재적으로 성능 오버 헤드 및 보안 위험을 초래할 수 있습니다.

    플랫폼 독립성과 관련된 Java 개발의 미래 트렌드는 무엇입니까?플랫폼 독립성과 관련된 Java 개발의 미래 트렌드는 무엇입니까?Apr 25, 2025 am 12:12 AM

    Java는 Cloud-Native Applications, Multi-Platform 배포 및 교차 운용성을 통해 플랫폼 독립성을 더욱 향상시킬 것입니다. 1) Cloud Native Applications는 Graalvm 및 Quarkus를 사용하여 시작 속도를 높입니다. 2) Java는 임베디드 장치, 모바일 장치 및 양자 컴퓨터로 확장됩니다. 3) Graalvm을 통해 Java는 Python 및 JavaScript와 같은 언어와 완벽하게 통합되어 언어 교차 수용 가능성을 향상시킵니다.

    Java의 강력한 타이핑은 플랫폼 독립성에 어떻게 기여합니까?Java의 강력한 타이핑은 플랫폼 독립성에 어떻게 기여합니까?Apr 25, 2025 am 12:11 AM

    Java의 강력한 유형 시스템은 유형 안전, 통합 유형 변환 및 다형성을 통해 플랫폼 독립성을 보장합니다. 1) 유형 안전성 런타임 오류를 피하기 위해 컴파일 시간에 유형 검사를 수행합니다. 2) 통합 유형 변환 규칙은 모든 플랫폼에서 일관성이 있습니다. 3) 다형성 및 인터페이스 메커니즘은 코드가 다른 플랫폼에서 일관되게 행동하게 만듭니다.

    JNI (Java Native Interface)가 플랫폼 독립성을 손상시킬 수있는 방법을 설명하십시오.JNI (Java Native Interface)가 플랫폼 독립성을 손상시킬 수있는 방법을 설명하십시오.Apr 25, 2025 am 12:07 AM

    JNI는 Java의 플랫폼 독립성을 파괴 할 것입니다. 1) JNI는 특정 플랫폼에 대한 로컬 라이브러리를 요구합니다. 2) 대상 플랫폼에서 로컬 코드를 컴파일하고 연결해야합니다. 3) 운영 체제 또는 JVM의 다른 버전은 다른 로컬 라이브러리 버전을 필요로 할 수 있습니다.

    Java의 플랫폼 독립성을 위협하거나 향상시키는 새로운 기술이 있습니까?Java의 플랫폼 독립성을 위협하거나 향상시키는 새로운 기술이 있습니까?Apr 24, 2025 am 12:11 AM

    신흥 기술은 위협을 일으키고 Java의 플랫폼 독립성을 향상시킵니다. 1) Docker와 같은 클라우드 컴퓨팅 및 컨테이너화 기술은 Java의 플랫폼 독립성을 향상 시키지만 다양한 클라우드 환경에 적응하도록 최적화되어야합니다. 2) WebAssembly는 Graalvm을 통해 Java 코드를 컴파일하여 플랫폼 독립성을 확장하지만 성능을 위해 다른 언어와 경쟁해야합니다.

    JVM의 다른 구현은 무엇이며, 모두 같은 수준의 플랫폼 독립성을 제공합니까?JVM의 다른 구현은 무엇이며, 모두 같은 수준의 플랫폼 독립성을 제공합니까?Apr 24, 2025 am 12:10 AM

    다른 JVM 구현은 플랫폼 독립성을 제공 할 수 있지만 성능은 약간 다릅니다. 1. OracleHotspot 및 OpenJDKJVM 플랫폼 독립성에서 유사하게 수행되지만 OpenJDK에는 추가 구성이 필요할 수 있습니다. 2. IBMJ9JVM은 특정 운영 체제에서 최적화를 수행합니다. 3. Graalvm은 여러 언어를 지원하며 추가 구성이 필요합니다. 4. AzulzingJVM에는 특정 플랫폼 조정이 필요합니다.

    플랫폼 독립성은 개발 비용과 시간을 어떻게 줄입니까?플랫폼 독립성은 개발 비용과 시간을 어떻게 줄입니까?Apr 24, 2025 am 12:08 AM

    플랫폼 독립성은 여러 운영 체제에서 동일한 코드 세트를 실행하여 개발 비용을 줄이고 개발 시간을 단축시킵니다. 구체적으로, 그것은 다음과 같이 나타납니다. 1. 개발 시간을 줄이면 하나의 코드 세트 만 필요합니다. 2. 유지 보수 비용을 줄이고 테스트 프로세스를 통합합니다. 3. 배포 프로세스를 단순화하기위한 빠른 반복 및 팀 협업.

    See all articles

    핫 AI 도구

    Undresser.AI Undress

    Undresser.AI Undress

    사실적인 누드 사진을 만들기 위한 AI 기반 앱

    AI Clothes Remover

    AI Clothes Remover

    사진에서 옷을 제거하는 온라인 AI 도구입니다.

    Undress AI Tool

    Undress AI Tool

    무료로 이미지를 벗다

    Clothoff.io

    Clothoff.io

    AI 옷 제거제

    Video Face Swap

    Video Face Swap

    완전히 무료인 AI 얼굴 교환 도구를 사용하여 모든 비디오의 얼굴을 쉽게 바꾸세요!

    뜨거운 도구

    안전한 시험 브라우저

    안전한 시험 브라우저

    안전한 시험 브라우저는 온라인 시험을 안전하게 치르기 위한 보안 브라우저 환경입니다. 이 소프트웨어는 모든 컴퓨터를 안전한 워크스테이션으로 바꿔줍니다. 이는 모든 유틸리티에 대한 액세스를 제어하고 학생들이 승인되지 않은 리소스를 사용하는 것을 방지합니다.

    PhpStorm 맥 버전

    PhpStorm 맥 버전

    최신(2018.2.1) 전문 PHP 통합 개발 도구

    MinGW - Windows용 미니멀리스트 GNU

    MinGW - Windows용 미니멀리스트 GNU

    이 프로젝트는 osdn.net/projects/mingw로 마이그레이션되는 중입니다. 계속해서 그곳에서 우리를 팔로우할 수 있습니다. MinGW: GCC(GNU Compiler Collection)의 기본 Windows 포트로, 기본 Windows 애플리케이션을 구축하기 위한 무료 배포 가능 가져오기 라이브러리 및 헤더 파일로 C99 기능을 지원하는 MSVC 런타임에 대한 확장이 포함되어 있습니다. 모든 MinGW 소프트웨어는 64비트 Windows 플랫폼에서 실행될 수 있습니다.

    맨티스BT

    맨티스BT

    Mantis는 제품 결함 추적을 돕기 위해 설계된 배포하기 쉬운 웹 기반 결함 추적 도구입니다. PHP, MySQL 및 웹 서버가 필요합니다. 데모 및 호스팅 서비스를 확인해 보세요.

    VSCode Windows 64비트 다운로드

    VSCode Windows 64비트 다운로드

    Microsoft에서 출시한 강력한 무료 IDE 편집기