ಕ್ವಾರ್ಕಸ್ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮತ್ತು ಸ್ಪ್ರಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ

ಎಲ್ಲರಿಗೂ ನಮಸ್ಕಾರ, ಕ್ವಾರ್ಕಸ್ ಸರಣಿಯ ಮೂರನೇ ಪೋಸ್ಟ್ ಇಲ್ಲಿದೆ!

ಜಾವಾ ಮೈಕ್ರೋಸರ್ವಿಸ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ನಂಬಲಾಗಿದೆ ಎಕ್ಲಿಪ್ಸ್ ಮೈಕ್ರೊಪ್ರೊಫೈಲ್ и ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್ ಪ್ರತ್ಯೇಕ ಮತ್ತು ಸ್ವತಂತ್ರ APIಗಳಾಗಿವೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಅವರು ಈಗಾಗಲೇ ಬಳಸಿದ API ಗಳನ್ನು ಬಳಸುತ್ತಾರೆ, ಏಕೆಂದರೆ ಹೊಸ ಚೌಕಟ್ಟುಗಳು ಮತ್ತು ರನ್‌ಟೈಮ್ ಘಟಕಗಳನ್ನು ಕಲಿಯಲು ಸಾಕಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇಂದು ನಾವು ಕೆಲವು ಜನಪ್ರಿಯ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸರಳೀಕರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಮತ್ತು ಸ್ಪ್ರಿಂಗ್ API ಮತ್ತು ಹೊಸ ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ನಿಮಗೆ ತೋರಿಸುತ್ತದೆ ಕ್ವಾರ್ಕಸ್.

ಸ್ವಲ್ಪ ಹೆಚ್ಚು ವಿವರವಾಗಿ, ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ತಮ್ಮ ದಿನನಿತ್ಯದ ಕೆಲಸದಲ್ಲಿ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸಲು ಕ್ವಾರ್ಕಸ್ ಸ್ಪ್ರಿಂಗ್ API ಗಳನ್ನು ಹೇಗೆ ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂಬುದರ ವ್ಯಾಪ್ತಿ ಮತ್ತು ವಿವರಗಳನ್ನು ನಾವು ಮೊದಲು ನೋಡುತ್ತೇವೆ. ನಂತರ ನಾವು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಗಳನ್ನು ಕವರ್ ಮಾಡುತ್ತೇವೆ, ಇದು ಮೈಕ್ರೋಸರ್ವಿಸ್ ರಚಿಸುವಾಗ ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ.

ಕ್ವಾರ್ಕಸ್ ಏಕೆ? ಮೊದಲನೆಯದಾಗಿ, ಇದು ಲೈವ್ ಕೋಡಿಂಗ್ ಆಗಿದೆ, ಅಂದರೆ, ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API, ಸ್ಪ್ರಿಂಗ್ API ಮತ್ತು ಇತರ ಜಾವಾ API ಗಳಲ್ಲಿನ ಯಾವುದೇ ಬದಲಾವಣೆಗಳ ಸ್ವಯಂಚಾಲಿತ ಮರುಲೋಡ್ ಆಗಿದೆ, ಇದನ್ನು ಕೇವಲ ಒಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ: mvn quarkus:dev. ಎರಡನೆಯದಾಗಿ, ಚರ್ಚಿಸಲಾಗಿದೆ ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ವ್ಯಕ್ತಿ ಸೇವೆಯು (ಸ್ಪ್ರಿಂಗ್, ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮತ್ತು JPA API ಗಳಿಂದ ಸ್ಥಳೀಯ GraalVM ಇಮೇಜ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಬೈನರಿಯಾಗಿ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ) ಕೇವಲ 0.055 ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು RESTful ಅಪ್ಲಿಕೇಶನ್ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ನಲ್ಲಿ ಸುಮಾರು 90 MB RAM (RSS) ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದಲ್ಲದೆ, ಅದರ ಸಂಕಲನವನ್ನು ಕೇವಲ ಒಂದು ಆಜ್ಞೆಯೊಂದಿಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ: mvn ಪ್ಯಾಕೇಜ್ -Pnative.

ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಗಳೊಂದಿಗೆ ಸ್ಪ್ರಿಂಗ್ API ಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುವುದನ್ನು ಹೊರತುಪಡಿಸಿ ನಾವು MicroProfile ಕುರಿತು ವಿವರವಾಗಿ ಹೋಗುವುದಿಲ್ಲ.

ಕಂಟೈನರ್ ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್

ಈ ಲೇಖನವನ್ನು ಸರಳವಾಗಿಡಲು, ನಾವು ಇಲ್ಲಿ ಬೆಂಬಲದ ಉನ್ನತ ಮಟ್ಟದ ಅಂಶಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಳ್ಳುತ್ತೇವೆ. ಕುಬರ್ನೆಟ್ಸ್, ಏಕೆಂದರೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಕ್ವಾರ್ಕಸ್ ಅನ್ನು ಕುಬರ್ನೆಟ್ಸ್‌ಗಾಗಿ ಜಾವಾ ಸ್ಟಾಕ್‌ನಂತೆ ಇರಿಸಲಾಗಿದೆ, ಇದು ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಸೇವೆಗಳ ಪ್ರಾರಂಭದ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಮತ್ತು ಪರಿಣಾಮವಾಗಿ, ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಅವುಗಳ ಸಾಂದ್ರತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ ಮತ್ತು ಒಟ್ಟಾರೆ ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಕ್ವಾರ್ಕಸ್ ಕೂಡ ಸ್ವಯಂ ಉತ್ಪಾದನೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಕೊಡುಗೆಗಳು ನಾಯಕತ್ವ Kubernetes ಮತ್ತು Red Hat OpenShift ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ ನಿಯೋಜನೆಗಾಗಿ. ಜೊತೆಗೆ, ಕ್ವಾರ್ಕಸ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ Dockerfile.jvm (JVM ಪ್ಯಾಕೇಜಿಂಗ್) ಮತ್ತು Dockerfile.native (ಸ್ಥಳೀಯ ಬೈನರಿ ಪ್ಯಾಕೇಜಿಂಗ್) ಧಾರಕಗಳನ್ನು ರಚಿಸಲು ಅಗತ್ಯವಿರುವ ಫೈಲ್‌ಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಗುರಿಯ ನಿಯೋಜನೆ ಪರಿಸರವಾಗಿ ಕೇಂದ್ರೀಕರಿಸುವ ಮೂಲಕ, ಕ್ವಾರ್ಕಸ್ ಜಾವಾ ಚೌಕಟ್ಟುಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ, ಅಂತಹ ಕಾರ್ಯವನ್ನು ಕುಬರ್ನೆಟ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಮಟ್ಟದಲ್ಲಿಯೇ ಅಳವಡಿಸಲಾಗಿದೆ. ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಬಳಸುವ ಕುಬರ್ನೆಟ್ಸ್ ಮತ್ತು ವಿಶಿಷ್ಟವಾದ ಜಾವಾ ಚೌಕಟ್ಟುಗಳ ನಡುವಿನ ಕ್ರಿಯಾತ್ಮಕ ಪತ್ರವ್ಯವಹಾರದ ನಕ್ಷೆಯನ್ನು ಟೇಬಲ್ 1 ಒದಗಿಸುತ್ತದೆ.

ಕೋಷ್ಟಕ 1. ಜಾವಾ ಚೌಕಟ್ಟುಗಳು ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್ ನಡುವಿನ ಕ್ರಿಯಾತ್ಮಕ ಪತ್ರವ್ಯವಹಾರದ ನಕ್ಷೆ.

ಕ್ರಿಯಾತ್ಮಕ
ಸಾಂಪ್ರದಾಯಿಕ ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್
ಕುಬರ್ನೆಟ್ಸ್

ಸೇವೆಯ ಅನ್ವೇಷಣೆ
ಯುರೇಕಾ
ಡಿಎನ್ಎಸ್

ಸಂರಚನೆ
ಸ್ಪ್ರಿಂಗ್ ಮೇಘ ಸಂರಚನೆ
ನಕ್ಷೆಗಳು/ರಹಸ್ಯಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ

ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸಿಂಗ್
ರಿಬ್ಬನ್ (ಕ್ಲೈಂಟ್ ಸೈಡ್)
ಸೇವೆ, ಪ್ರತಿಕೃತಿ ನಿಯಂತ್ರಕ (ಸರ್ವರ್ ಸೈಡ್)

ಉದಾಹರಣೆಯಿಂದ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವುದು ಮತ್ತು ಚಾಲನೆ ಮಾಡುವುದು

ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ ಉದಾಹರಣೆ ಯೋಜನೆ, ಅಲ್ಲಿ ಸ್ಪ್ರಿಂಗ್ ಮತ್ತು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಗಳು ಮತ್ತು ಅದೇ ಜಾವಾ ವರ್ಗವನ್ನು ಒಟ್ಟಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಬಹುದು ಮತ್ತು ಆಜ್ಞಾ ಸಾಲಿನಿಂದ ರನ್ ಮಾಡಬಹುದು, ವಿವರಗಳಿಗಾಗಿ README.md ಫೈಲ್ ಅನ್ನು ನೋಡಿ.

ಸ್ಪ್ರಿಂಗ್ ಫ್ರೇಮ್ವರ್ಕ್ API ಗಳು

ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್

ಕ್ವಾರ್ಕಸ್ ವ್ಯಾಪ್ತಿಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಸಂದರ್ಭಗಳು ಮತ್ತು ಅವಲಂಬನೆ ಇಂಜೆಕ್ಷನ್ (CDI) APIಗಳು ಮತ್ತು ಸ್ಪ್ರಿಂಗ್ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ (ಸ್ಪ್ರಿಂಗ್ ಡಿಐ) APIಗಳು. ನೀವು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಜಾವಾ ಇಇ ಮತ್ತು ಜಕಾರ್ತ ಇಇ, ನಂತರ ನೀವು ಈಗಾಗಲೇ CDI ಯೊಂದಿಗೆ ಬಹಳ ಪರಿಚಿತರಾಗಿರುವಿರಿ. ಮತ್ತೊಂದೆಡೆ, ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಸ್ಪ್ರಿಂಗ್ ಡಿಐ ಜೊತೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ಸಾಧಿಸಲು ಸ್ಪ್ರಿಂಗ್ ಡಿಐ ಎಪಿಐಗಾಗಿ ಕ್ವಾರ್ಕಸ್ ವಿಸ್ತರಣೆಯನ್ನು ಬಳಸಬಹುದು. ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ DI API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳನ್ನು ಕೋಷ್ಟಕ 2 ರಲ್ಲಿ ನೀಡಲಾಗಿದೆ.

В ನಮ್ಮ ಉದಾಹರಣೆಯಿಂದ ಯೋಜನೆ CDI ಮತ್ತು ಸ್ಪ್ರಿಂಗ್ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಎರಡನ್ನೂ ಬಳಸುತ್ತದೆ. ಈ ವಿಷಯದ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಮತ್ತು ಉದಾಹರಣೆಗಳಿಗಾಗಿ, ಎಂಬ ಕ್ವಾರ್ಕಸ್ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ನೋಡಿ ಸ್ಪ್ರಿಂಗ್ ಡಿಐ ಮಾರ್ಗದರ್ಶಿ.

ಕೋಷ್ಟಕ 2. ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ DI API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳು.

ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ ಡಿಐ ವೈಶಿಷ್ಟ್ಯಗಳು
ಉದಾಹರಣೆಗಳು

ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಇಂಜೆಕ್ಷನ್

public PersonSpringController(
   PersonSpringRepository personRepository,  // injected      
   PersonSpringMPService personService) {    // injected
      this.personRepository = personRepository;
      this.personService = personService;
}

ಫೀಲ್ಡ್ ಇಂಜೆಕ್ಷನ್
ಆಟೋವೈರ್ಡ್
ಮೌಲ್ಯ

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

@Value("${fallbackSalutation}")
String fallbackSalutation;

ಹುರುಳಿ
@ ಕಾನ್ಫಿಗರೇಶನ್

@Configuration
public class AppConfiguration {
   @Bean(name = "capitalizeFunction")
   public StringFunction capitalizer() {
      return String::toUpperCase;
   }
}

ಕಾಂಪೊನೆಂಟ್

@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
   @Override
   public String apply(String s) {
      return s;
   }
}

ಸೇವೆ

@Service
public class MessageProducer {
   @Value("${greeting.message}")
   String message;

   public String getPrefix() {
      return message;
   }
}

ವೆಬ್ ಫ್ರೇಮ್ವರ್ಕ್

ಕ್ವಾರ್ಕಸ್ JAX-RS, ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್, JSON-P, ಮತ್ತು JSON-B ಅನ್ನು ಪ್ರಾಥಮಿಕ ವೆಬ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಯಾಗಿ ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂದು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಬಳಕೆದಾರರು ಇಷ್ಟಪಡುತ್ತಾರೆ. ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ API ಗಾಗಿ ಕ್ವಾರ್ಕಸ್‌ನ ಇತ್ತೀಚಿನ ಬೆಂಬಲದೊಂದಿಗೆ ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಸಂತೋಷಪಡುತ್ತಾರೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ REST ಇಂಟರ್‌ಫೇಸ್‌ಗಳು. ಸ್ಪ್ರಿಂಗ್ DI ಯಂತೆಯೇ, ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ API ಬೆಂಬಲದ ಮುಖ್ಯ ಗುರಿ ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಗಳ ಜೊತೆಯಲ್ಲಿ ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ API ಗಳನ್ನು ಬಳಸಲು ಸಕ್ರಿಯಗೊಳಿಸುವುದು. ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ API ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಉದಾಹರಣೆಗಳನ್ನು ಟೇಬಲ್ 3 ರಲ್ಲಿ ನೀಡಲಾಗಿದೆ ಮತ್ತು ಈ ವಿಷಯದ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಕ್ವಾರ್ಕಸ್ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ಕಾಣಬಹುದು ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ ಗೈಡ್.

ಕೋಷ್ಟಕ 3. ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳು.

ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ ವೈಶಿಷ್ಟ್ಯಗಳು
ಉದಾಹರಣೆಗಳು

@ರೆಸ್ಟ್ ಕಂಟ್ರೋಲರ್
@RequestMapping

@RestController
@RequestMapping("/person")
public class PersonSpringController {
   ...
   ...
   ...
}

@GetMapping
@ಪೋಸ್ಟ್ಮ್ಯಾಪಿಂಗ್
@ಪುಟ್‌ಮ್ಯಾಪಿಂಗ್
@ ಅಳಿಸಿ ಮ್ಯಾಪಿಂಗ್
@PatchMapping
@RequestParam
@RequestHeader
@ಮ್ಯಾಟ್ರಿಕ್ಸ್ ವೇರಿಯಬಲ್
@PathVariable
@ಕುಕಿ ಮೌಲ್ಯ
@RequestBody
@ResponseStatus
@ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲರ್
@RestControllerAdvice (ಭಾಗಶಃ)

@GetMapping(path = "/greet/{id}",
   produces = "text/plain")
   public String greetPerson(
   @PathVariable(name = "id") long id) {
   ...
   ...
   ...
}

ಸ್ಪ್ರಿಂಗ್ ಡೇಟಾ JPA

ಹೈಬರ್ನೇಟ್ ORM ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ವಾರ್ಕಸ್ JPA ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂದು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಬಳಕೆದಾರರು ಸಹ ಶ್ಲಾಘಿಸುತ್ತಾರೆ. ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಒಳ್ಳೆಯ ಸುದ್ದಿಯೂ ಇದೆ: ಕ್ವಾರ್ಕಸ್ ಸಾಮಾನ್ಯ ಸ್ಪ್ರಿಂಗ್ ಡೇಟಾ JPA ಟಿಪ್ಪಣಿಗಳು ಮತ್ತು ಪ್ರಕಾರಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ ಡೇಟಾ JPA API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳನ್ನು ಟೇಬಲ್ 4 ರಲ್ಲಿ ನೀಡಲಾಗಿದೆ.
В ನಮ್ಮ ಉದಾಹರಣೆಯಿಂದ ಯೋಜನೆ ಸ್ಪ್ರಿಂಗ್ ಡೇಟಾ JPA API ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಕ್ವಾರ್ಕಸ್ ಟ್ಯುಟೋರಿಯಲ್ ಎಂಬಲ್ಲಿ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಲಭ್ಯವಿದೆ ಸ್ಪ್ರಿಂಗ್ ಡೇಟಾ JPA ಮಾರ್ಗದರ್ಶಿ.

ಕೋಷ್ಟಕ 4. ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ ಡೇಟಾ JPA API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳು.

ಬೆಂಬಲಿತ ಸ್ಪ್ರಿಂಗ್ ಡೇಟಾ JPA ವೈಶಿಷ್ಟ್ಯಗಳು
ಉದಾಹರಣೆಗಳು

ಕ್ರೂಡ್ ರೆಪೊಸಿಟರಿ

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

ರೆಪೊಸಿಟರಿಯನ್ನು
JpaRepository
ಪೇಜಿಂಗ್ ಮತ್ತು ಸೋರ್ಟಿಂಗ್ ರೆಪೊಸಿಟರಿ

public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}

ರೆಪೊಸಿಟರಿ ತುಣುಕುಗಳು

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

ಪಡೆದ ಪ್ರಶ್ನೆ ವಿಧಾನಗಳು

public interface PersonRepository extends CrudRepository {

    List findByName(String name);
    
    Person findByNameBySsn(String ssn);
    
    Optional 
       findByNameBySsnIgnoreCase(String ssn);

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಪ್ರಶ್ನೆಗಳು

public interface MovieRepository
         extends CrudRepository {

    Movie findFirstByOrderByDurationDesc();

    @Query("select m from Movie m where m.rating = ?1")
    Iterator findByRating(String rating);

    @Query("from Movie where title = ?1")
    Movie findByTitle(String title);
}

ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಗಳು

ದೋಷಸಹಿಷ್ಣುತೆ

ಕ್ಯಾಸ್ಕೇಡಿಂಗ್ ವೈಫಲ್ಯಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಮೈಕ್ರೋ ಸರ್ವೀಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳನ್ನು ರಚಿಸಲು ದೋಷ ಸಹಿಷ್ಣುತೆಯ ರಚನೆಗಳು ಬಹಳ ಮುಖ್ಯ. ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಹಲವು ವರ್ಷಗಳಿಂದ ದೋಷ ಸಹಿಷ್ಣುತೆಗಾಗಿ ಸರ್ಕ್ಯೂಟ್ ಬ್ರೇಕರ್‌ಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದಾರೆ. ಹೈಸ್ಟ್ರಿಕ್ಸ್. ಆದಾಗ್ಯೂ, ಹೈಸ್ಟ್ರಿಕ್ಸ್ ಅನ್ನು ದೀರ್ಘಕಾಲದವರೆಗೆ ನವೀಕರಿಸಲಾಗಿಲ್ಲ, ಆದರೆ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ನ ತಪ್ಪು ಸಹಿಷ್ಣುತೆ ಈಗ ಸಕ್ರಿಯವಾಗಿ ಅಭಿವೃದ್ಧಿ ಹೊಂದುತ್ತಿದೆ ಮತ್ತು ಅದರ ಹಿಂದೆ ಹಲವಾರು ವರ್ಷಗಳ ಉತ್ಪಾದನಾ ಬಳಕೆಯನ್ನು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ, ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿನ ಸೇವೆಗಳ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಸುಧಾರಿಸಲು, ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಫಾಲ್ಟ್ ಟಾಲರೆನ್ಸ್ API ಗಳನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ, ಇವುಗಳ ಉದಾಹರಣೆಗಳನ್ನು ಟೇಬಲ್ 5 ರಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಇದರ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ಕ್ವಾರ್ಕಸ್ ಕೈಪಿಡಿಯನ್ನು ನೋಡಿ ತಪ್ಪು ಸಹಿಷ್ಣುತೆ ಮಾರ್ಗದರ್ಶಿ.

ಕೋಷ್ಟಕ 5. ಬೆಂಬಲಿತ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಫಾಲ್ಟ್ ಟಾಲರೆನ್ಸ್ API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳು.

ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಫಾಲ್ಟ್ ಟಾಲರೆನ್ಸ್ ವೈಶಿಷ್ಟ್ಯಗಳು
ವಿವರಣೆ
ಉದಾಹರಣೆಗಳು

@ಅಸಿಂಕ್ರೊನಸ್

ಪ್ರತ್ಯೇಕ ಥ್ರೆಡ್ನಲ್ಲಿ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

@Asynchronous
@Retry
public Future<String> getSalutation() {
   ...
   return future;
}

@ಬಲ್ಕ್‌ಹೆಡ್

ಏಕಕಾಲಿಕ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಿತಿಗೊಳಿಸಿ

@Bulkhead(5)
public void fiveConcurrent() {
   makeRemoteCall(); //...
}

@CircuitBreaker

ಸ್ಮಾರ್ಟ್ ವೈಫಲ್ಯ ನಿರ್ವಹಣೆ ಮತ್ತು ವೈಫಲ್ಯಗಳಿಂದ ಚೇತರಿಕೆ

@CircuitBreaker(delay=500   // milliseconds
   failureRatio = .75,
   requestVolumeThreshold = 20,
   successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

@ಫಾಲ್ಬ್ಯಾಕ್

ವೈಫಲ್ಯದ ಸಂದರ್ಭದಲ್ಲಿ ಪರ್ಯಾಯ ತರ್ಕವನ್ನು ಕರೆಯುವುದು

@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

public String fallback() {
   return "hello";
}

ಮರುಪ್ರಯತ್ನಿಸಿ

ವಿನಂತಿ ವಿಫಲವಾದಾಗ ಮರುಪ್ರಯತ್ನಿಸಿ

@Retry(maxRetries=3)
public String getSalutation() {
   makeRemoteCall(); //...
}

ಸಮಯ ಮೀರಿದೆ

ವೈಫಲ್ಯ ನಿಯಂತ್ರಣ ಸಮಯ ಮೀರಿದೆ

@Timeout(value = 500 )   // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

ತಪಾಸಣೆ ಸೇವೆಗಳು (ಸೇವಾ ಆರೋಗ್ಯ)

ವಿಶೇಷ ಸೇವೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕಂಟೈನರ್‌ಗಳ ಆರೋಗ್ಯವನ್ನು ಕುಬರ್ನೆಟ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತವೆ. ಸೇವೆಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಆಧಾರವಾಗಿರುವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಅನುಮತಿಸಲು, ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಕಸ್ಟಮ್ HealthIndicator ಮತ್ತು Spring Boot Actuator ಅನ್ನು ಬಳಸುತ್ತಾರೆ. ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿ, ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಹೆಲ್ತ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಬಹುದು, ಇದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಲೈವ್‌ನೆಸ್ ಚೆಕ್ ಅನ್ನು ಮಾಡುತ್ತದೆ, ಆದರೆ ಏಕಕಾಲದಲ್ಲಿ ಜೀವಂತಿಕೆ ಮತ್ತು ಸಿದ್ಧತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು. ಬೆಂಬಲಿತ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಹೆಲ್ತ್ API ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಉದಾಹರಣೆಗಳನ್ನು ಟೇಬಲ್ 6 ರಲ್ಲಿ ನೀಡಲಾಗಿದೆ ಮತ್ತು ಕ್ವಾರ್ಕಸ್ ಕೈಪಿಡಿಯಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಲಾಗಿದೆ ಆರೋಗ್ಯ ಮಾರ್ಗದರ್ಶಿ.

ಕೋಷ್ಟಕ 6: ಬೆಂಬಲಿತ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಹೆಲ್ತ್ API ಗಳ ಬಳಕೆಯ ಉದಾಹರಣೆಗಳು.

ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಆರೋಗ್ಯ ವೈಶಿಷ್ಟ್ಯಗಳು
ವಿವರಣೆ
ಉದಾಹರಣೆಗಳು

@ಲೈವ್ನೆಸ್

ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ವಿಫಲವಾದ ಕಂಟೈನರೈಸ್ ಮಾಡಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರೀಬೂಟ್ ಮಾಡುತ್ತದೆ
ಅಂತ್ಯಬಿಂದು:
ಹೋಸ್ಟ್:8080/ಹೆಲ್ತ್/ಲೈವ್

@Liveness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(ready ? true:false)
     .withData("mydata", data)
     .build();  
}

@ಸಿದ್ಧತೆ

ವೇದಿಕೆ ಸಿದ್ಧವಾಗಿಲ್ಲದಿದ್ದರೆ ಕಂಟೈನರೈಸ್ ಮಾಡಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಟ್ರಾಫಿಕ್ ಕಳುಹಿಸುವುದಿಲ್ಲ
ಅಂತ್ಯಬಿಂದು:
ಹೋಸ್ಟ್:8080/ಆರೋಗ್ಯ/ಸಿದ್ಧ

@Readiness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(live ? true:false)
     .withData("mydata", data)
     .build();  
}

ಮೆಟ್ರಿಕ್ಸ್

ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಕಾರ್ಯಾಚರಣೆಯ ಉದ್ದೇಶಗಳಿಗಾಗಿ (ಕಾರ್ಯಕ್ಷಮತೆ SLA ಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು) ಅಥವಾ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲದ ಉದ್ದೇಶಗಳಿಗಾಗಿ (ವ್ಯಾಪಾರ SLA ಗಳು) ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ. ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಸ್ಪ್ರಿಂಗ್ ಬೂಟ್ ಆಕ್ಟಿವೇಟರ್ ಮತ್ತು ಮೈಕ್ರೋಮೀಟರ್ ಬಳಸಿ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತಾರೆ. ಪ್ರತಿಯಾಗಿ, ಕ್ವಾರ್ಕಸ್ ಬೇಸ್‌ಲೈನ್ ಮೆಟ್ರಿಕ್ಸ್ (JVM ಮತ್ತು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್), ವೆಂಡರ್ ಮೆಟ್ರಿಕ್ಸ್ (ಕ್ವಾರ್ಕಸ್) ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಒದಗಿಸಲು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. MicroProfile ಮೆಟ್ರಿಕ್ಸ್‌ಗೆ ಅನುಷ್ಠಾನವು JSON ಮತ್ತು OpenMetrics (Prometheus) ಔಟ್‌ಪುಟ್ ಸ್ವರೂಪಗಳನ್ನು ಬೆಂಬಲಿಸುವ ಅಗತ್ಯವಿದೆ. ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮೆಟ್ರಿಕ್ಸ್ API ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳನ್ನು ಕೋಷ್ಟಕ 7 ರಲ್ಲಿ ನೀಡಲಾಗಿದೆ.

В ನಮ್ಮ ಉದಾಹರಣೆಯಿಂದ ಯೋಜನೆ ಅಪ್ಲಿಕೇಶನ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಒದಗಿಸಲು ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮೆಟ್ರಿಕ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ಕ್ವಾರ್ಕಸ್ ಕೈಪಿಡಿಯನ್ನು ನೋಡಿ ಮೆಟ್ರಿಕ್ಸ್ ಗೈಡ್.

ಕೋಷ್ಟಕ 7. ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮೆಟ್ರಿಕ್ಸ್ API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳು.

ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ಮೆಟ್ರಿಕ್ಸ್ ವೈಶಿಷ್ಟ್ಯಗಳು
ವಿವರಣೆ
ಉದಾಹರಣೆಗಳು

@ಎಣಿಸಲಾಗಿದೆ

ಟಿಪ್ಪಣಿ ಮಾಡಿದ ವಸ್ತುವನ್ನು ಎಷ್ಟು ಬಾರಿ ಕರೆಯಲಾಗಿದೆ ಎಂಬುದನ್ನು ಎಣಿಸುವ ಕೌಂಟರ್ ಕೌಂಟರ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ

@Counted(name = "fallbackCounter", 
  displayName = "Fallback Counter", 
  description = "Fallback Counter")
public String salutationFallback() {
   return fallbackSalutation;
}

@ConcurrentGauge

ಟಿಪ್ಪಣಿ ಮಾಡಿದ ವಸ್ತುವಿಗೆ ಏಕಕಾಲೀನ ಕರೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಗೇಜ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ

@ConcurrentGuage(
  name = "fallbackConcurrentGauge", 
  displayName="Fallback Concurrent", 
  description="Fallback Concurrent")
public String salutationFallback() {
   return fallbackSalutation;
}

@ಗೇಜ್

ಟಿಪ್ಪಣಿ ಮಾಡಲಾದ ವಸ್ತುವಿನ ಮೌಲ್ಯವನ್ನು ಅಳೆಯುವ ಗೇಜ್ ಸಂವೇದಕವನ್ನು ಸೂಚಿಸುತ್ತದೆ

@Metered(name = "FallbackGauge",
   displayName="Fallback Gauge",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

@ಮೀಟರ್ ಮಾಡಲಾಗಿದೆ

ಟಿಪ್ಪಣಿ ಮಾಡಲಾದ ವಸ್ತುವಿನ ಕರೆ ಆವರ್ತನವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಮೀಟರ್ ಸಂವೇದಕವನ್ನು ಸೂಚಿಸುತ್ತದೆ

@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

ಮೆಟ್ರಿಕ್

ಮೆಟ್ರಿಕ್ ಅನ್ನು ನಮೂದಿಸಲು ಅಥವಾ ಉತ್ಪಾದಿಸಲು ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ ಮೆಟಾಡೇಟಾದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿರುವ ಟಿಪ್ಪಣಿ

@Metric
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

ಸಮಯ ಮೀರಿದೆ

ಟಿಪ್ಪಣಿ ಮಾಡಿದ ವಸ್ತುವಿನ ಅವಧಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಟೈಮರ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ

@Timed(name = "TimedFallback",
   displayName="Timed Fallback",
   description="Fallback delay")
public String salutationFallback() {
   return fallbackSalutation;
}

ಮೆಟ್ರಿಕ್ಸ್ ಅಂತ್ಯಬಿಂದುಗಳು

ಅಪ್ಲಿಕೇಶನ್ ಮೆಟ್ರಿಕ್ಸ್ ಸ್ಥಳೀಯ ಹೋಸ್ಟ್:8080/ಮೆಟ್ರಿಕ್ಸ್/ಅಪ್ಲಿಕೇಶನ್
ಮೂಲ ಮಾಪನಗಳು ಸ್ಥಳೀಯ ಹೋಸ್ಟ್:8080/ಮೆಟ್ರಿಕ್ಸ್/ಬೇಸ್
ಮಾರಾಟಗಾರರ ಮೆಟ್ರಿಕ್ಸ್ ಸ್ಥಳೀಯ ಹೋಸ್ಟ್:8080/ಮೆಟ್ರಿಕ್ಸ್/ವೆಂಡರ್
ಎಲ್ಲಾ ಮೆಟ್ರಿಕ್‌ಗಳು ಸ್ಥಳೀಯ ಹೋಸ್ಟ್:8080/ಮೆಟ್ರಿಕ್ಸ್

ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್

ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ RESTful ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಅವುಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅನುಗುಣವಾದ ಕ್ಲೈಂಟ್ API ಗಳ ಅಗತ್ಯವಿರುತ್ತದೆ. RESTful ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಬಳಸಲು, ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ RestTemplate ಅನ್ನು ಬಳಸುತ್ತಾರೆ. ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಕ್ವಾರ್ಕಸ್ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್ API ಗಳನ್ನು ನೀಡುತ್ತದೆ, ಇವುಗಳ ಬಳಕೆಯ ಉದಾಹರಣೆಗಳನ್ನು ಟೇಬಲ್ 8 ರಲ್ಲಿ ನೀಡಲಾಗಿದೆ.

В ನಮ್ಮ ಉದಾಹರಣೆಯಿಂದ ಯೋಜನೆ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು RESTful ಎಂಡ್ ಪಾಯಿಂಟ್‌ಗಳ ಬಳಕೆಯನ್ನು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ವಿಷಯದ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಮತ್ತು ಉದಾಹರಣೆಗಳನ್ನು ಕ್ವಾರ್ಕಸ್ ಕೈಪಿಡಿಯಲ್ಲಿ ಕಾಣಬಹುದು ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್ ಗೈಡ್.

ಕೋಷ್ಟಕ 8. ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್ API ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳು.

ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್ ವೈಶಿಷ್ಟ್ಯಗಳು
ವಿವರಣೆ
ಉದಾಹರಣೆಗಳು

@RegisterRestClient

ಟೈಪ್ ಮಾಡಿದ ಜಾವಾ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು REST ಕ್ಲೈಂಟ್ ಆಗಿ ನೋಂದಾಯಿಸುತ್ತದೆ

@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}

@ರೆಸ್ಟ್ ಕ್ಲೈಂಟ್

ಟೈಪ್ ಮಾಡಿದ REST ಕ್ಲೈಂಟ್ ಇಂಟರ್ಫೇಸ್‌ನ ನಿದರ್ಶನದ ಅನುಷ್ಠಾನವನ್ನು ಗುರುತಿಸುತ್ತದೆ

@Autowired // or @Inject
@RestClient
MyRestClient restClient;

ಆಹ್ವಾನ

REST ಅಂತಿಮ ಬಿಂದುವನ್ನು ಕರೆಯುತ್ತದೆ

System.out.println(
   restClient.getSalutation());

mp-rest/url

REST ಅಂತಿಮ ಬಿಂದುವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ

application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

ಫಲಿತಾಂಶಗಳು

ಈ ಬ್ಲಾಗ್‌ನಲ್ಲಿ, ಪ್ರಾಥಮಿಕವಾಗಿ ಸ್ಪ್ರಿಂಗ್ ಡೆವಲಪರ್‌ಗಳನ್ನು ಗುರಿಯಾಗಿಟ್ಟುಕೊಂಡು, ಜಾವಾ ಮೈಕ್ರೊ ಸರ್ವೀಸ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಕ್ವಾರ್ಕಸ್‌ನಲ್ಲಿನ ಮೈಕ್ರೋಪ್ರೊಫೈಲ್ API ಗಳೊಂದಿಗೆ ಸ್ಪ್ರಿಂಗ್ API ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ನೂರಾರು ಮೆಗಾಬೈಟ್ RAM ಅನ್ನು ಉಳಿಸುವ ಸ್ಥಳೀಯ ಬೈನರಿ ಕೋಡ್‌ಗೆ ಕಂಪೈಲ್ ಮಾಡುವುದು ಮತ್ತು ಪ್ರಾರಂಭಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ನಾವು ತ್ವರಿತವಾಗಿ ನೋಡಿದ್ದೇವೆ. ಮಿಲಿಸೆಕೆಂಡುಗಳ ವಿಷಯ.

ನೀವು ಈಗಾಗಲೇ ಅರ್ಥಮಾಡಿಕೊಂಡಂತೆ, ಸ್ಪ್ರಿಂಗ್ ಮತ್ತು ಮೈಕ್ರೊಪ್ರೊಫೈಲ್ API ಗಳಿಗೆ ಬೆಂಬಲದ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿ, ಹಾಗೆಯೇ ಬಹಳಷ್ಟು ಇತರ ಉಪಯುಕ್ತ ಮಾಹಿತಿಗಳನ್ನು ಕಾಣಬಹುದು ಕ್ವಾರ್ಕಸ್ ಕೈಪಿಡಿಗಳು.

ಮೂಲ: www.habr.com