ನೀವು ಈಗಾಗಲೇ ನಿಮ್ಮ ಸಾಫ್ಟ್ವೇರ್ ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ, ಆದರೆ ಪ್ಲ್ಯಾಟ್ಫಾರ್ಮ್ ಅನ್ನು ವಿಸ್ತರಿಸಲು ನಿಮ್ಮ ತಾಂತ್ರಿಕ ಬಳಕೆದಾರರನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ನಿಮಗೆ ಇನ್ನೂ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ವಿಧಾನದ ಅಗತ್ಯವಿದೆ.
OSGi ಹೆಚ್ಚಿನ ಜಾವಾ ಡೆವಲಪರ್ಗಳಿಗೆ ಚಿರಪರಿಚಿತವಾಗಿದ್ದರೂ, ಅದನ್ನು ನಿಮ್ಮ ಉತ್ಪನ್ನಕ್ಕೆ ಸಂಯೋಜಿಸುವುದು ಬೆದರಿಸುವ ಕೆಲಸದಂತೆ ತೋರುತ್ತದೆ. OSGi ಯ ನಿಖರವಾದ ಕಾರ್ಯನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ಸ್ಪಷ್ಟತೆಯ ಕೊರತೆಯು ಮುಂದಿನ ಹಾದಿಯನ್ನು ಮತ್ತಷ್ಟು ಅಸ್ತವ್ಯಸ್ತಗೊಳಿಸುತ್ತದೆ.
ಅವರು ಪ್ರಯೋಗಿಸಲು ಬಯಸುವ ಯಾವುದಕ್ಕೂ ವ್ಯತಿರಿಕ್ತವಾಗಿ, OSGi ಅನೇಕ ಜಾವಾ ಡೆವಲಪರ್ಗಳಿಗೆ ವಿಶಾಲ ಸಮುದ್ರವನ್ನು ನೌಕಾಯಾನ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಂತೆ ಭಾಸವಾಗುತ್ತದೆ.
ಈ ಲೇಖನವು ನೇರವಾದ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬಳಸಿಕೊಂಡು OSGi ಫೆಲಿಕ್ಸ್ ಸ್ಪ್ರಿಂಗ್ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ನಿಮಗೆ ಪರಿಚಯಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಅನುಕೂಲಗಳು ಮತ್ತು ಇತರ ಪ್ರಮುಖ ವಿವರಗಳ ಮೂಲಕ ಹೋಗುತ್ತದೆ.
ಹಾಗಾದರೆ OSGi ಎಂದರೇನು?
ಮಾಡ್ಯೂಲ್ಗಳು ಮತ್ತು ಘಟಕಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ವಿತರಿಸುವುದು OSGi (ಓಪನ್ ಸರ್ವಿಸ್ ಗೇಟ್ವೇ ಇನಿಶಿಯೇಟಿವ್) ಎಂದು ಕರೆಯಲ್ಪಡುವ ಜಾವಾ ಫ್ರೇಮ್ವರ್ಕ್ನಿಂದ ಸಾಧ್ಯವಾಗಿದೆ.
ಇದು ಫಂಕ್ಷನ್ ಎನ್ಕ್ಯಾಪ್ಸುಲೇಶನ್ ಮತ್ತು ಲೂಸ್ ಕಪ್ಲಿಂಗ್ ಅನ್ನು ಒತ್ತಿಹೇಳುತ್ತದೆ, ಇದು ಡೆವಲಪರ್ಗಳಿಗೆ ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ, ಮೂಲ ಕೋಡ್ಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಗಳ ನಡುವೆ ಸುಲಭವಾಗಿ ವರ್ಗಾಯಿಸಬಹುದಾದ ಮಾಡ್ಯುಲರ್ ಕಾರ್ಯವನ್ನು ಒಳಗೊಂಡಂತೆ ಅಂತ್ಯವಿಲ್ಲದ ಅವಲಂಬನೆಗಳ ಅಗತ್ಯವಿಲ್ಲ.
OSGi ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?
ಜಾವಾಗೆ ಡೈನಾಮಿಕ್ ಕಾಂಪೊನೆಂಟ್ ಸಿಸ್ಟಮ್ ಅನ್ನು OSGi ಎಂದು ಕರೆಯಲಾಗುವ ವಿಶೇಷಣಗಳ ಗುಂಪಿನಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಈ ಸ್ಪೆಕ್ಸ್ ಅಭಿವೃದ್ಧಿ ವಿಧಾನವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹಲವಾರು ಭಾಗಗಳಿಂದ ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಕಟ್ಟುಗಳಾಗಿ ಪ್ಯಾಕ್ ಮಾಡಲಾಗುತ್ತದೆ.
ಸ್ಥಳೀಯ ಮತ್ತು ನೆಟ್ವರ್ಕ್ ಆಧಾರಿತ ಸೇವೆಗಳನ್ನು ಈ ಘಟಕಗಳು ಸಂವಹನ ಮಾಡಲು ಬಳಸುತ್ತವೆ. ಕಾರ್ಯಕ್ರಮದ ಕೋರ್ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಸಾಧ್ಯವಾಗುವಂತೆ ಕಾಂಪ್ಯಾಕ್ಟ್ ಮಾಡುವುದು ಗುರಿಯಾಗಿದೆ. ಈ ಕೋಡ್ ಮತ್ತು ಹಲವಾರು ಘಟಕಗಳ ನಡುವೆ ಹೆಚ್ಚಿನ ಜೋಡಣೆ ಸಾಧ್ಯ.
ಅಪ್ಲಿಕೇಶನ್ನ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕಟ್ಟಡದ ಅಂಶಗಳನ್ನು ಘಟಕಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ನಿಮ್ಮ ಇ-ಕಾಮರ್ಸ್ ವೆಬ್ಸೈಟ್ಗಾಗಿ ಶಾಪಿಂಗ್ ಕಾರ್ಟ್ ಅಥವಾ ನಿಮ್ಮ ಸಿಬ್ಬಂದಿ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಗಾಗಿ ವೇತನದಾರರ ಅಪ್ಲಿಕೇಶನ್ನಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳ ಬಗ್ಗೆ ಯೋಚಿಸಿ.
ಘಟಕಗಳು ತಮ್ಮ ಅಳವಡಿಕೆಗಳನ್ನು ಇತರ ಘಟಕಗಳಿಂದ ಮರೆಮಾಡಲು OSGi ಅನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಸೇವೆಗಳ ಮೂಲಕ ಅವರಿಗೆ ಅಗತ್ಯವಾದ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಒದಗಿಸಬಹುದು.
ಇದು ಘಟಕಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರದ ಡೇಟಾವನ್ನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಬದಲಾಯಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ ಮತ್ತು ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
OSGi ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿನ ಘಟಕಗಳ ನಡುವಿನ ಎಲ್ಲಾ ಸಂಪರ್ಕಗಳನ್ನು ಆದರ್ಶ ಜಗತ್ತಿನಲ್ಲಿ ಸೇವೆಗಳ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ. ಸೇವೆಗಳಿಗಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ API ಅನ್ನು ಜಾವಾ ಪ್ಯಾಕೇಜ್ ಒಳಗೊಂಡಿದೆ.
ಸೇವಾ ಪೂರೈಕೆದಾರರು ಮತ್ತು ಗ್ರಾಹಕರ ನಡುವಿನ ಸಹಯೋಗಕ್ಕೆ API ಅನ್ನು ರೂಪಿಸುವ ತರಗತಿಗಳು ಮತ್ತು/ಅಥವಾ ಇಂಟರ್ಫೇಸ್ಗಳ ಬಳಕೆಯ ಅಗತ್ಯವಿದೆ.
ಎಲ್ಲಾ OSGi ಘಟಕಗಳನ್ನು ಬಂಡಲ್ಗಳಲ್ಲಿ ಒಟ್ಟಿಗೆ ಪ್ಯಾಕ್ ಮಾಡಲಾಗುತ್ತದೆ, ಪ್ರತಿಯೊಂದೂ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಬಂಡಲ್ಗಳು ಪರಿಸರದಿಂದ ಏನು ಬೇಕು ಮತ್ತು ಅವುಗಳು ಏನು ಸಮರ್ಥವಾಗಿವೆ ಎಂಬುದರ ಕುರಿತು ಸಾಕಷ್ಟು ಸ್ಪಷ್ಟವಾಗಿವೆ.
ಪ್ರಯೋಜನಗಳು
- OSGi ಅಪ್ಲಿಕೇಶನ್ಗಳು ಬಾಹ್ಯ ಬಂಡಲ್ ರೆಪೊಸಿಟರಿಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿವೆ.
- ಫ್ರೇಮ್ವರ್ಕ್ ಮಾಡ್ಯೂಲ್ ಮಟ್ಟದಲ್ಲಿ ಸೇವಾ-ಆಧಾರಿತ ವಿನ್ಯಾಸವನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
- ಥರ್ಡ್-ಪಾರ್ಟಿ ಲೈಬ್ರರಿಗಳನ್ನು ಸ್ಟ್ಯಾಂಡರ್ಡೈಸ್ ಮಾಡುವುದರ ಜೊತೆಗೆ ಮತ್ತು ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸುವ ಜೊತೆಗೆ ಅಪ್ಲಿಕೇಶನ್ ಬಂಡಲ್ಗಳ ಆವೃತ್ತಿಗಳು ಮತ್ತು ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇದು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.
- ಅಪ್ಲಿಕೇಶನ್ಗಳು ಬದಲಾಗುತ್ತಿರುವ ಬೇಡಿಕೆಗಳಿಗೆ ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳಬಲ್ಲವು, ಹೆಚ್ಚು ಪೋರ್ಟಬಲ್ ಮತ್ತು ಮರುಇಂಜಿನಿಯರ್ಗೆ ತ್ವರಿತವಾಗಿರುತ್ತವೆ.
- A ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ Java EE ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾದರಿಯೊಂದಿಗೆ ಫ್ರೇಮ್ವರ್ಕ್ನ ಏಕೀಕರಣಕ್ಕೆ ಧನ್ಯವಾದಗಳು ಡೈನಾಮಿಕ್ ಜೀವಿತಾವಧಿಯೊಂದಿಗೆ ಆವೃತ್ತಿಯ OSGi ಬಂಡಲ್ಗಳ ಗುಂಪಿನಂತೆ ನಿಯೋಜಿಸಬಹುದು.
- ಅಪ್ಲಿಕೇಶನ್ನ ಭಾಗವಾಗಿ ಥರ್ಡ್-ಪಾರ್ಟಿ ಲೈಬ್ರರಿಯಾಗಿ ಸ್ಥಾಪಿಸುವ ಬದಲು, ಫ್ರೇಮ್ವರ್ಕ್ ಸ್ಪ್ರಿಂಗ್ ಫ್ರೇಮ್ವರ್ಕ್ನ ಘೋಷಣಾ ಜೋಡಣೆ ಮತ್ತು ಸುವ್ಯವಸ್ಥಿತ ಘಟಕ ಪರೀಕ್ಷೆಯನ್ನು ಪ್ರಮಾಣೀಕೃತ ರೂಪದಲ್ಲಿ ಒದಗಿಸುತ್ತದೆ, ಇದನ್ನು ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ ರನ್ಟೈಮ್ನ ಭಾಗವಾಗಿ ಒದಗಿಸಲಾಗಿದೆ.
- ಡೈನಾಮಿಕ್ ಜೀವನಚಕ್ರಗಳೊಂದಿಗೆ ಹಲವಾರು ಆವೃತ್ತಿಯ ಬಂಡಲ್ಗಳಿಂದ ಮಾಡಲ್ಪಟ್ಟ ಕಾರ್ಪೊರೇಟ್ ಅಪ್ಲಿಕೇಶನ್ಗಳಿಗಾಗಿ, ಫ್ರೇಮ್ವರ್ಕ್ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ನೀಡುತ್ತದೆ.
- ಇದು ಸಂಯೋಜಿತ ಬಂಡಲ್ ರೆಪೊಸಿಟರಿಯನ್ನು ಹೊಂದಿದ್ದು, ಹಲವಾರು ಅಪ್ಲಿಕೇಶನ್ಗಳು ಬಳಸುವ ಹಂಚಿದ ಸಾಮಾನ್ಯ ಮತ್ತು ಆವೃತ್ತಿಯ ಬಂಡಲ್ಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು, ಪ್ರತಿ ಹಂಚಿದ ಲೈಬ್ರರಿಯ ಪ್ರತ್ಯೇಕ ನಕಲನ್ನು ನಿಯೋಜಿಸದಂತೆ ಪ್ರತಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ತಡೆಯುತ್ತದೆ.
OSGi ಫೆಲಿಕ್ಸ್ ವಸಂತದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವುದು
ಸಂಪನ್ಮೂಲಗಳನ್ನು ಪಡೆಯುವುದು
ಅಪಾಚೆ ಕರಾಫ್ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡುವ ಮೂಲಕ ಈ ಸೈಟ್, ನಾವು ನಮ್ಮ OSGi ಸಾಹಸವನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು.
ಅಪಾಚೆ ಫೆಲಿಕ್ಸ್ ಅನ್ನು ಆಧರಿಸಿ, OSGi ವಿವರಣೆಯ ಅಪಾಚೆ ಅನುಷ್ಠಾನ, ಅಪಾಚೆ ಕರಾಫ್ OSGi-ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್ಗಳಿಗೆ ವೇದಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಕರಾಫ್ ಫೆಲಿಕ್ಸ್ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ವಿವಿಧ ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅದು OSGi ಯೊಂದಿಗೆ ನಮ್ಮನ್ನು ಪರಿಚಿತಗೊಳಿಸಲು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ಫೇಸ್ ಅದು ಪ್ಲಾಟ್ಫಾರ್ಮ್ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ನಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಬಂಡಲ್ಗಳಿಗೆ ಪ್ರವೇಶ ಬಿಂದು
OSGi ಪರಿಸರದಲ್ಲಿ ರನ್ ಮಾಡುವ ಮೊದಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು OSGi ಬಂಡಲ್ನಂತೆ ಪ್ಯಾಕ್ ಮಾಡಬೇಕು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅಪ್ಲಿಕೇಶನ್ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು; ಇದು ಪ್ರಮಾಣಿತ ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಶೂನ್ಯ ಮುಖ್ಯ (ಸ್ಟ್ರಿಂಗ್[] ಆರ್ಗ್ಸ್) ಕಾರ್ಯವಲ್ಲ.
ಆದ್ದರಿಂದ "" ರಚಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸೋಣಹಲೋ ವರ್ಲ್ಡ್OSGi ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್.
ಮೂಲ OSGi API ಅವಲಂಬನೆಯನ್ನು ಸ್ಥಾಪಿಸುವ ಮೂಲಕ ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:
OSGi ರನ್ಟೈಮ್ ಅವಲಂಬನೆಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಬಂಡಲ್ ಅದನ್ನು ಒಳಗೊಂಡಿರುವ ಅಗತ್ಯವಿಲ್ಲ. ಆದ್ದರಿಂದ, ಅದನ್ನು ಸರಬರಾಜು ಮಾಡಲಾಗಿದೆ ಎಂದು ಗುರುತಿಸಲಾಗಿದೆ.
ಈಗ ನಾವು ನೇರವಾದ HelloWorld ವರ್ಗವನ್ನು ರಚಿಸೋಣ:
ಬಂಡಲ್ಗಳಿಗೆ ಪ್ರವೇಶ ಬಿಂದುಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ತರಗತಿಗಳು OSGi-ಒದಗಿಸಿದ BundleActivator ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು.
ಈ ವರ್ಗವನ್ನು ಹೊಂದಿರುವ ಬಂಡಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, OSGi ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಪ್ರಾರಂಭ() ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ. ಇನ್ನೊಂದು ಬದಿಯಲ್ಲಿ, ಬಂಡಲ್ ಅನ್ನು ನಿಲ್ಲಿಸುವ ಸ್ವಲ್ಪ ಮೊದಲು, ಸ್ಟಾಪ್ () ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ.
ಪ್ರತಿಯೊಂದು ಬಂಡಲ್ ಒಂದು ಬಂಡಲ್ ಆಕ್ಟಿವೇಟರ್ ಅನ್ನು ಮಾತ್ರ ಹೊಂದಿರಬಹುದು ಎಂಬುದನ್ನು ನಾವು ಮರೆಯಬಾರದು. ನೀಡಲಾದ ಬಂಡಲ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಎರಡೂ ಮಾರ್ಗಗಳು OSGi ರನ್ಟೈಮ್ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಬಹುದು.
ಬಂಡಲ್ ರಚಿಸಲಾಗುತ್ತಿದೆ
ಅಗತ್ಯ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವ ಮೂಲಕ pom.xml ಅನ್ನು ನಿಜವಾದ OSGi ಬಂಡಲ್ ಆಗಿ ಮಾಡಿ.
ಬಂಡಲ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವುದು ನಮ್ಮ ಗುರಿ ಎಂದು ನಾವು ಮೊದಲು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಕ್ತಪಡಿಸಬೇಕು.
ನಂತರ, ನಾವು HelloWorld ವರ್ಗವನ್ನು OSGi ಬಂಡಲ್ ಆಗಿ ಪ್ಯಾಕೇಜ್ ಮಾಡಲು ಮಾವೆನ್-ಬಂಡಲ್-ಪ್ಲಗಿನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಅಪಾಚೆ ಫೆಲಿಕ್ಸ್ ಸಮುದಾಯದ ಸೌಜನ್ಯ:
ಬಂಡಲ್ನ ಮ್ಯಾನಿಫೆಸ್ಟ್ ಫೈಲ್ನಲ್ಲಿ ನಾವು ಸೇರಿಸಲು ಬಯಸುವ OSGi ಹೆಡರ್ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಸೂಚನೆಗಳ ವಿಭಾಗದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ.
ಬಂಡಲ್-ಆಕ್ಟಿವೇಟರ್ ಎಂಬುದು ಬಂಡಲ್ ಆಕ್ಟಿವೇಟರ್ ಪರಿಹಾರದ ಸರಿಯಾದ ಅರ್ಹತೆಯ ಹೆಸರು, ಇದನ್ನು ಬಂಡಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಮತ್ತು ನಿಲ್ಲಿಸಲು ಬಳಸಲಾಗುವುದು. ಇದು ಈಗಷ್ಟೇ ರಚಿಸಿದ ವರ್ಗಕ್ಕೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ.
ಇದು OSGi ಹೆಡರ್ ಅಲ್ಲದಿದ್ದರೂ, ಖಾಸಗಿ-ಪ್ಯಾಕೇಜ್ ಹೆಡರ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಂಡಲ್ಗೆ ಸೇರಿಸಲು ಪ್ಲಗಿನ್ಗೆ ಸೂಚನೆ ನೀಡುತ್ತದೆ ಆದರೆ ಅದನ್ನು ಇತರ ಪ್ಲಗಿನ್ಗಳಿಗೆ ಪ್ರವೇಶಿಸುವಂತೆ ಮಾಡುವುದಿಲ್ಲ. ಬಂಡಲ್ ಅನ್ನು ರಚಿಸಲು mvn ಅನುಸ್ಥಾಪನಾ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬೇಕು.
ಬಂಡಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ಚಾಲನೆ ಮಾಡುವುದು
ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ಕರಾಫ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ:
ಅಲ್ಲಿ "KARAF HOME" ಕರಾಫ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ಫೋಲ್ಡರ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. Karaf ಕನ್ಸೋಲ್ ಪ್ರಾಂಪ್ಟ್ ಕಾಣಿಸಿಕೊಂಡಾಗ ಬಂಡಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ನಾವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು:
ಸ್ಥಳೀಯ ಮಾವೆನ್ ರೆಪೊಸಿಟರಿಯನ್ನು ಬಳಸುವುದು ಹೇಗೆ ಕರಾಫ್ಗೆ ಬಂಡಲ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಹೇಳಲಾಗುತ್ತದೆ.
ಬಂಡಲ್ನ ಸಂಖ್ಯಾತ್ಮಕ ಐಡಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತಾ, ಕರಾಫ್ ಅದನ್ನು ಬರೆಯುತ್ತಾನೆ. ಹಿಂದೆ ಎಷ್ಟು ಬಂಡಲ್ಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ಈ ಐಡಿ ಭಿನ್ನವಾಗಿರಬಹುದು. ಬಂಡಲ್ ಅನ್ನು ಈಗ ಯಶಸ್ವಿಯಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ, ಮತ್ತು ಅದನ್ನು ಪ್ರಾರಂಭಿಸುವ ಆಜ್ಞೆಯು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ:
ನೀವು ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ ಕ್ಷಣ, "ಹಲೋ ವರ್ಲ್ಡ್ ಬೈ ಜೇ" ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ನಾವು ಈಗ ಇದನ್ನು ಬಳಸಿಕೊಂಡು ಬಂಡಲ್ ಅನ್ನು ನಿಲ್ಲಿಸಬಹುದು ಮತ್ತು ತೆಗೆದುಹಾಕಬಹುದು:
ಕನ್ಸೋಲ್ "ಜೇ ಬೈ ವರ್ಲ್ಡ್" ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
ತೀರ್ಮಾನ
ಡೆವಲಪರ್ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗೆ ಹೊಸ ಕಾರ್ಯವನ್ನು ಸುಲಭವಾಗಿ ಸೇರಿಸಬಹುದು ಮತ್ತು OSGi ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂನ ಇತರ ಘಟಕಗಳಿಂದ ಅದನ್ನು ಸುರಕ್ಷಿತವಾಗಿರಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ಪ್ರತ್ಯೇಕಿಸಬಹುದು.
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ ನಾವು OSGi ಬಗ್ಗೆ ಕಲಿತಿದ್ದೇವೆ, ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಅದರ ಅನುಕೂಲಗಳು ಮತ್ತು ನೇರವಾದ ಪ್ರೋಗ್ರಾಂ ಸೇರಿದಂತೆ. ನಿಮ್ಮ ಸ್ವಂತ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ OSGi ಅನ್ನು ಸಂಯೋಜಿಸುವುದು ಕಷ್ಟವೇನಲ್ಲ.
ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್!
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ