เร่งเวลาเริ่มต้น Spring Boot

ฉันมีแอปพลิเคชัน Spring Boot ฉันได้เพิ่มการอ้างอิงจำนวนมาก (น่าเสียดายที่ดูเหมือนว่าฉันต้องการสิ่งเหล่านี้ทั้งหมด) และเวลาเริ่มต้นก็เพิ่มขึ้นค่อนข้างมาก เพียงแค่ทำSpringApplication.run(source, args)ใช้เวลา 10 วินาที

แม้ว่าอาจจะไม่มากเมื่อเทียบกับสิ่งที่ "เคยชิน" แต่ฉันไม่พอใจที่ต้องใช้เวลามากขนาดนั้นส่วนใหญ่เป็นเพราะมันทำลายขั้นตอนการพัฒนา ในตอนนี้แอปพลิเคชันมีขนาดค่อนข้างเล็กดังนั้นฉันจึงถือว่าเวลาส่วนใหญ่เกี่ยวข้องกับการอ้างอิงที่เพิ่มเข้ามาไม่ใช่คลาสของแอปเอง

ฉันถือว่าปัญหาคือการสแกน classpath แต่ฉันไม่แน่ใจว่าจะทำอย่างไร:

• ยืนยันว่าเป็นปัญหา (เช่นวิธี "ดีบัก" Spring Boot)
• ถ้าเป็นสาเหตุจริงๆจะ จำกัด ยังไงให้มันเร็วขึ้น ตัวอย่างเช่นถ้าฉันรู้ว่าการอ้างอิงหรือแพ็คเกจบางอย่างไม่มีสิ่งที่ Spring ควรจะสแกนมีวิธี จำกัด หรือไม่

ฉันคิดว่าการปรับปรุง Spring ให้มีการเริ่มต้นถั่วแบบคู่ขนานระหว่างการเริ่มต้นจะทำให้สิ่งต่างๆเร็วขึ้น แต่คำขอการเพิ่มประสิทธิภาพนั้นเปิดให้บริการตั้งแต่ปี 2554 โดยไม่มีความคืบหน้าใด ๆ ฉันเห็นความพยายามอื่น ๆ ใน Spring Boot เองเช่นการปรับปรุงความเร็วในการสแกน Tomcat JarScanningแต่นั่นเป็นความเฉพาะของ Tomcat และถูกยกเลิกไปแล้ว

บทความนี้:

• http://www.nurkiewicz.com/2010/12/speeding-up-spring-integration-tests.html

แม้ว่าจะมุ่งเป้าไปที่การทดสอบการรวม แต่แนะนำให้ใช้lazy-init=trueอย่างไรก็ตามฉันไม่รู้ว่าจะใช้สิ่งนี้กับถั่วทั้งหมดใน Spring Boot โดยใช้การกำหนดค่า Java ได้อย่างไร - มีคำแนะนำที่นี่หรือไม่

ข้อเสนอแนะ (อื่น ๆ ) ยินดีต้อนรับ

Spring Boot ทำการกำหนดค่าอัตโนมัติจำนวนมากที่อาจไม่จำเป็น ดังนั้นคุณอาจต้องการ จำกัด เฉพาะการกำหนดค่าอัตโนมัติที่จำเป็นสำหรับแอปของคุณให้แคบลง หากต้องการดูรายการการกำหนดค่าอัตโนมัติทั้งหมดเพียงเรียกใช้การบันทึกorg.springframework.boot.autoconfigureในโหมด DEBUG ( logging.level.org.springframework.boot.autoconfigure=DEBUGในapplication.properties) อีกทางเลือกหนึ่งคือเรียกใช้แอปพลิเคชัน spring boot ด้วย--debugตัวเลือก:java -jar myproject-0.0.1-SNAPSHOT.jar --debug

จะมีบางอย่างเช่นนี้ในผลลัพธ์:

=========================
AUTO-CONFIGURATION REPORT
=========================

ตรวจสอบรายการนี้และรวมเฉพาะการกำหนดค่าอัตโนมัติที่คุณต้องการ:

@Configuration
@Import({
        DispatcherServletAutoConfiguration.class,
        EmbeddedServletContainerAutoConfiguration.class,
        ErrorMvcAutoConfiguration.class,
        HttpEncodingAutoConfiguration.class,
        HttpMessageConvertersAutoConfiguration.class,
        JacksonAutoConfiguration.class,
        ServerPropertiesAutoConfiguration.class,
        PropertyPlaceholderAutoConfiguration.class,
        ThymeleafAutoConfiguration.class,
        WebMvcAutoConfiguration.class,
        WebSocketAutoConfiguration.class,
})
public class SampleWebUiApplication {

คัดลอกโค้ดมาจากบล็อกโพสต์นี้

คำตอบที่ได้รับการโหวตมากที่สุดนั้นไม่ผิด แต่ก็ไม่ได้ลงลึกที่ฉันชอบดูและไม่มีหลักฐานทางวิทยาศาสตร์ ทีม Spring Boot ได้ทำแบบฝึกหัดเพื่อลดเวลาเริ่มต้นสำหรับ Boot 2.0 และตั๋ว11226มีข้อมูลที่เป็นประโยชน์มากมาย นอกจากนี้ยังมีตั๋ว7939 ที่เปิดให้เพิ่มข้อมูลเวลาในการประเมินเงื่อนไข แต่ดูเหมือนว่าจะไม่มี ETA ที่เฉพาะเจาะจง

Dave Syer เป็นแนวทางที่มีประโยชน์และเป็นระบบมากที่สุดสำหรับการดีบักเริ่มต้นระบบบูต https://github.com/dsyer/spring-boot-startup-bench

ฉันมีกรณีการใช้งานที่คล้ายกันเช่นกันดังนั้นฉันจึงใช้แนวทางของ Dave ในการเปรียบเทียบขนาดเล็กกับ JMH และวิ่งไปด้วย ผลที่ได้คือบูตมาตรฐานโครงการ ฉันออกแบบมาเพื่อให้สามารถใช้วัดเวลาเริ่มต้นสำหรับแอปพลิเคชัน Spring Boot ใด ๆ โดยใช้โถปฏิบัติการที่ผลิตโดยbootJar(ก่อนหน้านี้เรียกว่าbootRepackageใน Boot 1.5) งาน Gradle อย่าลังเลที่จะใช้มันและแสดงความคิดเห็น

การค้นพบของฉันมีดังนี้:

1. เรื่อง CPU มาก.
2. การเริ่ม JVM ด้วย-Xverify: noneช่วยได้มาก
3. การยกเว้นการกำหนดค่าอัตโนมัติที่ไม่จำเป็นจะช่วยได้
4. Dave แนะนำอาร์กิวเมนต์ JVM -XX: TieredStopAtLevel = 1แต่การทดสอบของฉันไม่ได้แสดงการปรับปรุงอย่างมีนัยสำคัญกับสิ่งนั้น นอกจากนี้-XX:TieredStopAtLevel=1อาจทำให้คำขอแรกของคุณช้าลง
5. มีรายงานเกี่ยวกับการแก้ปัญหาชื่อโฮสต์ช้า แต่ฉันไม่พบว่ามันเป็นปัญหาสำหรับแอพที่ฉันทดสอบ

Spring Boot 2.2.M1 ได้เพิ่มคุณสมบัติเพื่อรองรับ Lazy Initialization ใน Spring Boot

ตามค่าเริ่มต้นเมื่อบริบทของแอ็พพลิเคชันกำลังถูกรีเฟรชทุก bean ในบริบทจะถูกสร้างขึ้นและมีการแทรกการอ้างอิง ในทางตรงกันข้ามเมื่อนิยามของ bean ถูกกำหนดค่าให้เริ่มต้นอย่างเฉื่อยชามันจะไม่ถูกสร้างขึ้นและการอ้างอิงจะไม่ถูกฉีดเข้าไปจนกว่าจะจำเป็น

การเปิดใช้งาน Lazy การเตรียมชุดspring.main.lazy-initializationที่จะเป็นจริง

เมื่อใดที่จะเปิดใช้งาน Lazy Initialization

การเริ่มต้นขี้เกียจสามารถให้การปรับปรุงที่สำคัญในเวลาเริ่มต้น แต่ก็มีข้อเสียที่น่าสังเกตเช่นกันและสิ่งสำคัญคือต้องเปิดใช้งานด้วยความระมัดระวัง

สำหรับรายละเอียดเพิ่มเติมโปรดตรวจสอบเอกสาร

ตามที่อธิบายไว้ในคำถาม / คำตอบนี้ฉันคิดว่าแนวทางที่ดีที่สุดคือแทนที่จะเพิ่มเฉพาะสิ่งที่คุณคิดว่าคุณต้องการยกเว้นการอ้างอิงที่คุณรู้ว่าคุณไม่ต้องการ

ดู: ลดเวลาเริ่มต้น Spring Boot ให้น้อยที่สุด

สรุป:

คุณสามารถดูสิ่งที่เกิดขึ้นภายใต้ฝาครอบและเปิดใช้งานการบันทึกการดีบักง่ายๆเพียงระบุ --debug เมื่อเริ่มแอปพลิเคชันจากบรรทัดคำสั่ง คุณยังสามารถระบุ debug = true ใน application.properties ของคุณ

นอกจากนี้คุณสามารถตั้งค่าระดับการบันทึกใน application.properties ได้ง่ายๆดังนี้:

logging.level.org.springframework.web: DEBUG logging.level.org.hibernate: ERROR

หากคุณตรวจพบโมดูลที่กำหนดค่าอัตโนมัติที่คุณไม่ต้องการสามารถปิดใช้งานได้ สามารถดูเอกสารนี้ได้ที่นี่: http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#using-boot-disabling-specific-auto-configuration

ตัวอย่างจะมีลักษณะดังนี้:

@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}

มีรายการการกระทำที่เป็นไปได้ทั้งหมดอธิบายไว้ที่นี่: https://spring.io/blog/2018/12/12/how-fast-is-spring

ฉันจะใส่บันทึกที่สำคัญที่สุดจากด้าน Spring (ปรับเปลี่ยนเล็กน้อย):

• การยกเว้น Classpath จาก Spring Boot web starters:
  • ตัวตรวจสอบไฮเบอร์เนต
  • Jackson (แต่ตัวกระตุ้น Spring Boot ขึ้นอยู่กับมัน) ใช้ Gson หากคุณต้องการการเรนเดอร์ JSON (ใช้ได้กับ MVC นอกกรอบเท่านั้น)
  • Logback: ใช้ slf4j-jdk14 แทน
• ใช้ Spring-context-indexer มันจะไม่เพิ่มมาก แต่ทุกช่วยเล็กน้อย
• อย่าใช้ตัวกระตุ้นถ้าคุณไม่สามารถจ่ายได้
• ใช้ Spring Boot 2.1 และ Spring 5.1 เปลี่ยนเป็น 2.2 และ 5.2 เมื่อพร้อมใช้งาน
• แก้ไขตำแหน่งของไฟล์กำหนดค่า Spring Boot ด้วยspring.config.location(อาร์กิวเมนต์บรรทัดคำสั่งหรือคุณสมบัติของระบบเป็นต้น) ตัวอย่างสำหรับการทดสอบใน spring.config.location=file://./src/main/resources/application.propertiesIDE:
• ปิด JMX หากคุณไม่ต้องการใช้spring.jmx.enabled=false(นี่คือค่าเริ่มต้นใน Spring Boot 2.2)
• ทำให้คำจำกัดความ bean ขี้เกียจตามค่าเริ่มต้น มีแฟล็กใหม่spring.main.lazy-initialization=trueใน Spring Boot 2.2 (ใช้LazyInitBeanFactoryPostProcessorสำหรับ Spring รุ่นเก่า)
• แกะโถไขมันออกจากกล่องและเรียกใช้ด้วยคลาสพา ธ ที่ชัดเจน
• เรียกใช้ JVM ด้วย-noverify. พิจารณาด้วย-XX:TieredStopAtLevel=1(ซึ่งจะทำให้ JIT ช้าลงในภายหลังโดยเสียเวลาเริ่มต้นที่บันทึกไว้)

ที่กล่าวถึงLazyInitBeanFactoryPostProcessor(คุณสามารถใช้สำหรับ Spring 1.5 ได้หากคุณไม่สามารถใช้แฟล็กที่spring.main.lazy-initialization=trueมีให้จาก Spring 2.2)

public class LazyInitBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
      for (String beanName : beanFactory.getBeanDefinitionNames()) {
        BeanDefinition definition = beanFactory.getBeanDefinition(beanName);
        definition.setLazyInit(true);
      }
  }
}

คุณยังสามารถใช้ (หรือเขียนของคุณเอง - มันง่ายมาก) ในการวิเคราะห์เวลาเริ่มต้นของถั่ว: https://github.com/lwaddicor/spring-startup-analysis

หวังว่าจะช่วยได้!

ในกรณีของฉันมีจุดพักมากเกินไป เมื่อฉันคลิก "ปิดเสียงเบรกพอยต์" และรีสตาร์ทแอปพลิเคชันในโหมดดีบักแอปพลิเคชันจะเริ่มทำงานเร็วขึ้น 10 เท่า

ถ้าคุณกำลังพยายามที่จะพัฒนาเพิ่มประสิทธิภาพการเปิดรอบสำหรับการทดสอบด้วยตนเองผมขอแนะนำให้ใช้ของdevtools

แอปพลิเคชันที่ใช้ spring-boot-devtools จะรีสตาร์ทโดยอัตโนมัติเมื่อใดก็ตามที่ไฟล์บน classpath เปลี่ยนไป

เพียงคอมไพล์ใหม่ - และเซิร์ฟเวอร์จะรีสตาร์ทตัวเอง (สำหรับ Groovy คุณต้องอัปเดตไฟล์ต้นฉบับเท่านั้น) หากคุณใช้ IDE (เช่น 'vscode') มันอาจรวบรวมไฟล์ java ของคุณโดยอัตโนมัติดังนั้นเพียงแค่บันทึกไฟล์ java ก็สามารถเริ่มการรีสตาร์ทเซิร์ฟเวอร์ได้โดยทางอ้อม - และ Java ก็จะราบรื่นเช่นเดียวกับ Groovy ในเรื่องนี้

ความสวยงามของแนวทางนี้คือการลัดวงจรของการรีสตาร์ทแบบเพิ่มหน่วยจะลัดวงจรขั้นตอนการเริ่มต้นตั้งแต่เริ่มต้นดังนั้นบริการของคุณจะได้รับการสำรองข้อมูลและทำงานได้เร็วขึ้นมาก!

น่าเสียดายที่สิ่งนี้ไม่ช่วยเรื่องเวลาเริ่มต้นสำหรับการปรับใช้งานหรือการทดสอบหน่วยอัตโนมัติ

คำเตือน:หากคุณไม่ได้ใช้ Hibernate DDL สำหรับการสร้างสคีมา DB อัตโนมัติและคุณไม่ได้ใช้แคช L2 คำตอบนี้ไม่สามารถใช้ได้กับคุณ เลื่อนไปข้างหน้า

การค้นพบของฉันคือ Hibernate เพิ่มเวลาสำคัญในการเริ่มต้นแอปพลิเคชัน การปิดใช้งานแคช L2 และการเริ่มต้นฐานข้อมูลส่งผลให้การเริ่มต้นแอป Spring Boot เร็วขึ้น ปล่อยแคชไว้สำหรับการผลิตและปิดใช้งานสำหรับสภาพแวดล้อมการพัฒนาของคุณ

application.yml:

spring:
  jpa:
    generate-ddl: false
    hibernate:
      ddl-auto: none
    properties:
      hibernate:
        cache:
          use_second_level_cache: false
          use_query_cache: false

ผลการทดสอบ:

1. L2 cache เปิดอยู่และ ddl-auto: update

   INFO 5024 --- [restartedMain] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 23331 ms
   INFO 5024 --- [restartedMain] b.n.spring.Application : Started Application in 54.251 seconds (JVM running for 63.766)

2. แคช L2 ปิดอยู่และ ddl-auto: none

   INFO 10288 --- [restartedMain] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 9863 ms
   INFO 10288 --- [restartedMain] b.n.spring.Application : Started Application in 32.058 seconds (JVM running for 37.625)

ตอนนี้ฉันสงสัยว่าฉันจะทำอะไรกับเวลาว่างทั้งหมดนี้

ฉันคิดว่ามันแปลกที่ไม่มีใครแนะนำการเพิ่มประสิทธิภาพเหล่านี้มาก่อน คำแนะนำทั่วไปบางประการในการเพิ่มประสิทธิภาพการสร้างโครงการและการเริ่มต้นเมื่อพัฒนา:

• ไม่รวมไดเร็กทอรีการพัฒนาจากโปรแกรมสแกนไวรัส:
  • ไดเรกทอรีโครงการ
  • สร้างไดเรกทอรีผลลัพธ์ (ถ้าอยู่นอกไดเรกทอรีโครงการ)
  • ไดเร็กทอรีดัชนี IDE (เช่น ~ / .IntelliJIdea2018.3)
  • ไดเร็กทอรีการปรับใช้ (เว็บแอพใน Tomcat)
• อัพเกรดฮาร์ดแวร์ ใช้ CPU และ RAM ที่เร็วขึ้นการเชื่อมต่ออินเทอร์เน็ตที่ดีขึ้น (สำหรับการดาวน์โหลดการอ้างอิง) และการเชื่อมต่อฐานข้อมูลเปลี่ยนเป็น SSD การ์ดแสดงผลไม่สำคัญ

คำเตือน

1. ตัวเลือกแรกมาพร้อมกับราคาของการรักษาความปลอดภัยที่ลดลง
2. ตัวเลือกที่สองต้องเสียเงิน (เห็นได้ชัด)

สำหรับฉันดูเหมือนว่าคุณใช้การตั้งค่าที่ไม่ถูกต้อง เริ่มต้นด้วยการตรวจสอบ myContainer และข้อขัดแย้งที่อาจเกิดขึ้น ในการพิจารณาว่าใครใช้ทรัพยากรมากที่สุดคุณต้องตรวจสอบแผนที่หน่วยความจำ (ดูจำนวนข้อมูล!) สำหรับการพึ่งพาแต่ละครั้ง - และต้องใช้เวลามากเช่นกัน ... (และสิทธิ์ SUDO) โดยปกติแล้วคุณกำลังทดสอบโค้ดกับการอ้างอิงหรือไม่?