Our products help customer solve difficult problems - revenue forecasting, pipeline management, service case management, and customer churn

SpringML

springml

How to Import CSV Data Into PostgreSQL Using Spring Boot Batch

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Hyerin Cho (조혜린), Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA;
(2) Ben S. Prather, CCS-2, Los Alamos National Laboratory, PO Box 1663, Los Alamos, NM 87545, USA;
(3) Ramesh Narayan, enter for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA;
(4) Priyamvada Natarajan, Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA, Department of Astronomy, Yale University, Kline Tower, 266 Whitney Avenue, New Haven, CT 06511, USA and Department of Physics, Yale University, P.O. Box 208121, New Haven, CT 06520, USA;
(5) Kung-Yi Su, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA;
(6) Angelo Ricarte, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA;
(7) Koushik Chatterjee, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA. Table of Links Abstract and Introduction Numerical Methods Hydrodynamic Bondi Accretion Magnetized Bondi Accretion Feedback Via Reconnection-Driven Convection Summary and Conclusions Acknowledgements Appendix A. GRMHD Primer and Definitions B. Numerical Set-up C. Resolution and Initial Condition Study References REFERENCES Angl´es-Alc´azar, D., Quataert, E., Hopkins, P. F., et al. 2021, ApJ, 917, 53, doi: 10.3847/1538-4357/ac09e8 Anile, A. M. 1989, Relativistic fluids and magneto-fluids: With applications in astrophysics and plasma physics Bisnovatyi-Kogan, G. S., & Ruzmaikin, A. A. 1974, Ap&SS, 28, 45, doi: 10.1007/BF00642237 Bondi, H. 1952, MNRAS, 112, 195, doi: 10.1093/mnras/112.2.195 Booth, C. M., & Schaye, J. 2009, MNRAS, 398, 53, doi: 10.1111/j.1365-2966.2009.15043.x Chatterjee, K., & Narayan, R. 2022, ApJ, 941, 30, doi: 10.3847/1538-4357/ac9d97 Chatterjee, K., Chael, A., Tiede, P., et al. 2023, Galaxies, 11, 38, doi: 10.3390/galaxies11020038 Dav´e, R., Angl´es-Alc´azar, D., Narayanan, D., et al. 2019, MNRAS, 486, 2827, doi: 10.1093/mnras/stz937 Event Horizon Telescope Collaboration, Akiyama, K., Algaba, J. C., et al. 2021, ApJL, 910, L13, doi: 10.3847/2041-8213/abe4de Ferrarese, L., & Merritt, D. 2000, ApJL, 539, L9, doi: 10.1086/312838 Ferri`ere, K. 2020, Plasma Physics and Controlled Fusion, 62, 014014, doi: 10.1088/13616587/ab49eb Fiacconi, D., Sijacki, D., & Pringle, J. E. 2018, MNRAS, 477, 3807, doi: 10.1093/mnras/sty893 Gammie, C. F., McKinney, J. C., & T´oth, G. 2003, ApJ, 589, 444, doi: 10.1086/374594 Gebhardt, K., Bender, R., Bower, G., et al. 2000, ApJL, 539, L13, doi: 10.1086/312840 Grete, P., Dolence, J. C., Miller, J. M., et al. 2023, 37, 465, doi: 10.1177/10943420221143775 Guerra, J. A., Lopez-Rodriguez, E., Chuss, D. T., Butterfield, N. O., & Schmelz, J. T. 2023, AJ, 166, 37, doi: 10.3847/1538-3881/acdacd Guo, M., Stone, J. M., Kim, C.-G., & Quataert, E. 2023, ApJ, 946, 26, doi: 10.3847/1538-4357/acb81e Hopkins, P. F., & Quataert, E. 2010, MNRAS, 407, 1529, doi: 10.1111/j.1365-2966.2010.17064.x Hopkins, P. F., Grudic, M. Y., Su, K.-Y., et al. 2023, arXiv e-prints, arXiv:2309.13115. https://arxiv.org/abs/2309.13115 Igumenshchev, I. V., & Narayan, R. 2002, ApJ, 566, 137, doi: 10.1086/338077 Igumenshchev, I. V., Narayan, R., & Abramowicz, M. A. 2003, ApJ, 592, 1042, doi: 10.1086/375769 Kaaz, N., Murguia-Berthier, A., Chatterjee, K., Liska, M. T. P., & Tchekhovskoy, A. 2023, ApJ, 950, 31, doi: 10.3847/1538-4357/acc7a1 Komissarov, S. S. 1999, MNRAS, 303, 343, doi: 10.1046/j.1365-8711.1999.02244.x Kormendy, J., & Ho, L. C. 2013, ARA&A, 51, 511, doi: 10.1146/annurev-astro-082708-101811 Lalakos, A., Gottlieb, O., Kaaz, N., et al. 2022, ApJL, 936, L5, doi: 10.3847/2041-8213/ac7bed Li, Y., & Bryan, G. L. 2014, ApJ, 789, 153, doi: 10.1088/0004-637X/789/2/153 Magorrian, J., Tremaine, S., Richstone, D., et al. 1998, AJ, 115, 2285, doi: 10.1086/300353 Meszaros, P. 1975, A&A, 44, 59 Michel, F. C. 1972, Ap&SS, 15, 153, doi: 10.1007/BF00649949 Narayan, R., Chael, A., Chatterjee, K., Ricarte, A., & Curd, B. 2022, MNRAS, 511, 3795, doi: 10.1093/mnras/stac285 Narayan, R., Igumenshchev, I. V., & Abramowicz, M. A. 2000, ApJ, 539, 798, doi: 10.1086/309268—. 2003, PASJ, 55, L69, doi: 10.1093/pasj/55.6.L69 Ni, Y., Di Matteo, T., Bird, S., et al. 2022, MNRAS, 513, 670, doi: 10.1093/mnras/stac351 Pen, U.-L., Matzner, C. D., & Wong, S. 2003, ApJL, 596, L207, doi: 10.1086/379339 Penna, R. F., Kulkarni, A., & Narayan, R. 2013, A&A, 559, A116, doi: 10.1051/0004-6361/201219666 Porth, O., Chatterjee, K., Narayan, R., et al. 2019, ApJS, 243, 26, doi: 10.3847/1538-4365/ab29fd Prather, B. S., Wong, G. N., Dhruv, V., et al. 2021, 6, 3336, doi: 10.21105/joss.03336 Quataert, E., & Gruzinov, A. 2000, ApJ, 539, 809, doi: 10.1086/309267 Ressler, S. M., Quataert, E., White, C. J., & Blaes, O. 2021, MNRAS, 504, 6076, doi: 10.1093/mnras/stab311 Ressler, S. M., White, C. J., Quataert, E., & Stone, J. M. 2020, ApJL, 896, L6, doi: 10.3847/2041-8213/ab9532 Ricarte, A., Tremmel, M., Natarajan, P., & Quinn, T. 2019, MNRAS, 489, 802, doi: 10.1093/mnras/stz2161 Ripperda, B., Liska, M., Chatterjee, K., et al. 2022, ApJL, 924, L32, doi: 10.3847/2041-8213/ac46a1 Rosas-Guevara, Y., Bower, R. G., Schaye, J., et al. 2016, MNRAS, 462, 190, doi: 10.1093/mnras/stw1679 Russell, H. R., Fabian, A. C., McNamara, B. R., & Broderick, A. E. 2015, MNRAS, 451, 588, doi: 10.1093/mnras/stv954 Shapiro, S. L., & Teukolsky, S. A. 1983, Black holes, white dwarfs, and neutron stars : the physics of compact objects Shvartsman, V. F. 1971, Soviet Ast., 15, 377 Sijacki, D., Vogelsberger, M., Genel, S., et al. 2015, MNRAS, 452, 575, doi: 10.1093/mnras/stv1340 Talbot, R. Y., Bourne, M. A., & Sijacki, D. 2021, MNRAS, 504, 3619, doi: 10.1093/mnras/stab804 Tchekhovskoy, A., McKinney, J. C., & Narayan, R. 2012, in Journal of Physics Conference Series, Vol. 372, Journal of Physics Conference Series, 012040, doi: 10.1088/1742-6596/372/1/012040 Tchekhovskoy, A., Narayan, R., & McKinney, J. C. 2011, MNRAS, 418, L79, doi: 10.1111/j.1745-3933.2011.01147.x Trott, C. R., Lebrun-Grandi, D., Arndt, D., et al. 2022, 33, 805, doi: 10.1109/TPDS.2021.3097283 Wang, Q. D., Nowak, M. A., Markoff, S. B., et al. 2013, Science, 341, 981, doi: 10.1126/science.1240755 Weinberger, R., Springel, V., Pakmor, R., et al. 2018, MNRAS, 479, 4056, doi: 10.1093/mnras/sty1733 Weinberger, R., Su, K.-Y., Ehlert, K., et al. 2023, MNRAS, 523, 1104, doi: 10.1093/mnras/stad1396 Wellons, S., Faucher-Gigu`ere, C.-A., Hopkins, P. F., et al. 2023, MNRAS, 520, 5394, doi: 10.1093/mnras/stad511 Wong, G. N., Du, Y., Prather, B. S., & Gammie, C. F. 2021, ApJ, 914, 55, doi: 10.3847/1538-4357/abf8b8 Yuan, F., Gan, Z., Narayan, R., et al. 2015, ApJ, 804, 101, doi: 10.1088/0004-637X/804/2/101 This paper is available on Arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. Authors: (1) Hyerin Cho (조혜린), Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (2) Ben S. Prather, CCS-2, Los Alamos National Laboratory, PO Box 1663, Los Alamos, NM 87545, USA; (3) Ramesh Narayan, enter for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (4) Priyamvada Natarajan, Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA, Department of Astronomy, Yale University, Kline Tower, 266 Whitney Avenue, New Haven, CT 06511, USA and Department of Physics, Yale University, P.O. Box 208121, New Haven, CT 06520, USA; (5) Kung-Yi Su, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (6) Angelo Ricarte, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (7) Koushik Chatterjee, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA. This paper is available on arxiv under CC 4.0 license. Authors : Authors (1) Hyerin Cho (조혜린), Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (2) Ben S. Prather, CCS-2, Los Alamos National Laboratory, PO Box 1663, Los Alamos, NM 87545, USA; (3) Ramesh Narayan, enter for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (4) Priyamvada Natarajan, Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA, Department of Astronomy, Yale University, Kline Tower, 266 Whitney Avenue, New Haven, CT 06511, USA and Department of Physics, Yale University, P.O. Box 208121, New Haven, CT 06520, USA; (5) Kung-Yi Su, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (6) Angelo Ricarte, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA; (7) Koushik Chatterjee, Center for Astrophysics | Harvard & Smithsonian, 60 Garden Street, Cambridge, MA 02138, USA and Black Hole Initiative at Harvard University, 20 Garden Street, Cambridge, MA 02138, USA. Table of Links Abstract and Introduction Abstract and Introduction Numerical Methods Numerical Methods Hydrodynamic Bondi Accretion Hydrodynamic Bondi Accretion Magnetized Bondi Accretion Magnetized Bondi Accretion Feedback Via Reconnection-Driven Convection Feedback Via Reconnection-Driven Convection Summary and Conclusions Summary and Conclusions Acknowledgements Acknowledgements Appendix Appendix A. GRMHD Primer and Definitions A. GRMHD Primer and Definitions B. Numerical Set-up B. Numerical Set-up C. Resolution and Initial Condition Study C. Resolution and Initial Condition Study References References REFERENCES Angl´es-Alc´azar, D., Quataert, E., Hopkins, P. F., et al. 2021, ApJ, 917, 53, doi: 10.3847/1538-4357/ac09e8 Anile, A. M. 1989, Relativistic fluids and magneto-fluids: With applications in astrophysics and plasma physics Bisnovatyi-Kogan, G. S., & Ruzmaikin, A. A. 1974, Ap&SS, 28, 45, doi: 10.1007/BF00642237 Bondi, H. 1952, MNRAS, 112, 195, doi: 10.1093/mnras/112.2.195 Booth, C. M., & Schaye, J. 2009, MNRAS, 398, 53, doi: 10.1111/j.1365-2966.2009.15043.x Chatterjee, K., & Narayan, R. 2022, ApJ, 941, 30, doi: 10.3847/1538-4357/ac9d97 Chatterjee, K., Chael, A., Tiede, P., et al. 2023, Galaxies, 11, 38, doi: 10.3390/galaxies11020038 Dav´e, R., Angl´es-Alc´azar, D., Narayanan, D., et al. 2019, MNRAS, 486, 2827, doi: 10.1093/mnras/stz937 Event Horizon Telescope Collaboration, Akiyama, K., Algaba, J. C., et al. 2021, ApJL, 910, L13, doi: 10.3847/2041-8213/abe4de Ferrarese, L., & Merritt, D. 2000, ApJL, 539, L9, doi: 10.1086/312838 Ferri`ere, K. 2020, Plasma Physics and Controlled Fusion, 62, 014014, doi: 10.1088/13616587/ab49eb Fiacconi, D., Sijacki, D., & Pringle, J. E. 2018, MNRAS, 477, 3807, doi: 10.1093/mnras/sty893 Gammie, C. F., McKinney, J. C., & T´oth, G. 2003, ApJ, 589, 444, doi: 10.1086/374594 Gebhardt, K., Bender, R., Bower, G., et al. 2000, ApJL, 539, L13, doi: 10.1086/312840 Grete, P., Dolence, J. C., Miller, J. M., et al. 2023, 37, 465, doi: 10.1177/10943420221143775 Guerra, J. A., Lopez-Rodriguez, E., Chuss, D. T., Butterfield, N. O., & Schmelz, J. T. 2023, AJ, 166, 37, doi: 10.3847/1538-3881/acdacd Guo, M., Stone, J. M., Kim, C.-G., & Quataert, E. 2023, ApJ, 946, 26, doi: 10.3847/1538-4357/acb81e Hopkins, P. F., & Quataert, E. 2010, MNRAS, 407, 1529, doi: 10.1111/j.1365-2966.2010.17064.x Hopkins, P. F., Grudic, M. Y., Su, K.-Y., et al. 2023, arXiv e-prints, arXiv:2309.13115. https://arxiv.org/abs/2309.13115 Igumenshchev, I. V., & Narayan, R. 2002, ApJ, 566, 137, doi: 10.1086/338077 Igumenshchev, I. V., Narayan, R., & Abramowicz, M. A. 2003, ApJ, 592, 1042, doi: 10.1086/375769 Kaaz, N., Murguia-Berthier, A., Chatterjee, K., Liska, M. T. P., & Tchekhovskoy, A. 2023, ApJ, 950, 31, doi: 10.3847/1538-4357/acc7a1 Komissarov, S. S. 1999, MNRAS, 303, 343, doi: 10.1046/j.1365-8711.1999.02244.x Kormendy, J., & Ho, L. C. 2013, ARA&A, 51, 511, doi: 10.1146/annurev-astro-082708-101811 Lalakos, A., Gottlieb, O., Kaaz, N., et al. 2022, ApJL, 936, L5, doi: 10.3847/2041-8213/ac7bed Li, Y., & Bryan, G. L. 2014, ApJ, 789, 153, doi: 10.1088/0004-637X/789/2/153 Magorrian, J., Tremaine, S., Richstone, D., et al. 1998, AJ, 115, 2285, doi: 10.1086/300353 Meszaros, P. 1975, A&A, 44, 59 Michel, F. C. 1972, Ap&SS, 15, 153, doi: 10.1007/BF00649949 Narayan, R., Chael, A., Chatterjee, K., Ricarte, A., & Curd, B. 2022, MNRAS, 511, 3795, doi: 10.1093/mnras/stac285 Narayan, R., Igumenshchev, I. V., & Abramowicz, M. A. 2000, ApJ, 539, 798, doi: 10.1086/309268—. 2003, PASJ, 55, L69, doi: 10.1093/pasj/55.6.L69 Ni, Y., Di Matteo, T., Bird, S., et al. 2022, MNRAS, 513, 670, doi: 10.1093/mnras/stac351 Pen, U.-L., Matzner, C. D., & Wong, S. 2003, ApJL, 596, L207, doi: 10.1086/379339 Penna, R. F., Kulkarni, A., & Narayan, R. 2013, A&A, 559, A116, doi: 10.1051/0004-6361/201219666 Porth, O., Chatterjee, K., Narayan, R., et al. 2019, ApJS, 243, 26, doi: 10.3847/1538-4365/ab29fd Prather, B. S., Wong, G. N., Dhruv, V., et al. 2021, 6, 3336, doi: 10.21105/joss.03336 Quataert, E., & Gruzinov, A. 2000, ApJ, 539, 809, doi: 10.1086/309267 Ressler, S. M., Quataert, E., White, C. J., & Blaes, O. 2021, MNRAS, 504, 6076, doi: 10.1093/mnras/stab311 Ressler, S. M., White, C. J., Quataert, E., & Stone, J. M. 2020, ApJL, 896, L6, doi: 10.3847/2041-8213/ab9532 Ricarte, A., Tremmel, M., Natarajan, P., & Quinn, T. 2019, MNRAS, 489, 802, doi: 10.1093/mnras/stz2161 Ripperda, B., Liska, M., Chatterjee, K., et al. 2022, ApJL, 924, L32, doi: 10.3847/2041-8213/ac46a1 Rosas-Guevara, Y., Bower, R. G., Schaye, J., et al. 2016, MNRAS, 462, 190, doi: 10.1093/mnras/stw1679 Russell, H. R., Fabian, A. C., McNamara, B. R., & Broderick, A. E. 2015, MNRAS, 451, 588, doi: 10.1093/mnras/stv954 Shapiro, S. L., & Teukolsky, S. A. 1983, Black holes, white dwarfs, and neutron stars : the physics of compact objects Shvartsman, V. F. 1971, Soviet Ast., 15, 377 Sijacki, D., Vogelsberger, M., Genel, S., et al. 2015, MNRAS, 452, 575, doi: 10.1093/mnras/stv1340 Talbot, R. Y., Bourne, M. A., & Sijacki, D. 2021, MNRAS, 504, 3619, doi: 10.1093/mnras/stab804 Tchekhovskoy, A., McKinney, J. C., & Narayan, R. 2012, in Journal of Physics Conference Series, Vol. 372, Journal of Physics Conference Series, 012040, doi: 10.1088/1742-6596/372/1/012040 Tchekhovskoy, A., Narayan, R., & McKinney, J. C. 2011, MNRAS, 418, L79, doi: 10.1111/j.1745-3933.2011.01147.x Trott, C. R., Lebrun-Grandi, D., Arndt, D., et al. 2022, 33, 805, doi: 10.1109/TPDS.2021.3097283 Wang, Q. D., Nowak, M. A., Markoff, S. B., et al. 2013, Science, 341, 981, doi: 10.1126/science.1240755 Weinberger, R., Springel, V., Pakmor, R., et al. 2018, MNRAS, 479, 4056, doi: 10.1093/mnras/sty1733 Weinberger, R., Su, K.-Y., Ehlert, K., et al. 2023, MNRAS, 523, 1104, doi: 10.1093/mnras/stad1396 Wellons, S., Faucher-Gigu`ere, C.-A., Hopkins, P. F., et al. 2023, MNRAS, 520, 5394, doi: 10.1093/mnras/stad511 Wong, G. N., Du, Y., Prather, B. S., & Gammie, C. F. 2021, ApJ, 914, 55, doi: 10.3847/1538-4357/abf8b8 Yuan, F., Gan, Z., Narayan, R., et al. 2015, ApJ, 804, 101, doi: 10.1088/0004-637X/804/2/101 This paper is available on Arxiv under CC 4.0 license. This paper is available on Arxiv under CC 4.0 license. Arxiv

All the References That We Used in Our Black Hole Study So You Can Continue to Learn

Adaptive Graph Neural Networks for Cosmological Data Generalization: Acknowledgements and Disclosure

Kuma Meshes Head-On - Everything You Need to Know

কুমা মেশেস হেড-অন - আপনার যা জানা দরকার

Kuma Meshes Frontal – Alles, was Sie wissen müssen

Kuma se enfrenta de frente: todo lo que necesitas saber

Kuma Meshes de front – Tout ce que vous devez savoir

कुमा मेशेस हेड-ऑन - वह सब कुछ जो आपको जानना चाहिए

クマが正面からメッシュ化 - 知っておくべきことすべて

Kuma Meshes 정면 대결 - 알아야 할 모든 것

Kuma Meshes Head-On - Tudo o que você precisa saber

Kuma Meses в лоб – все, что вам нужно знать

Kuma Kafa Başına Meshes - Bilmeniz Gereken Her Şey

Kuma Meshes Head-On - Mọi thứ bạn cần biết

Kuma Meshes 迎面而来——您需要了解的一切

Mission-critical applications require . The goal of high availability is to provide users with consistent access to services or resources, minimizing the chances of interruption. is a specific mechanism used to achieve high availability. It involves automatically detecting the failure of a system component (like a server, network, or database) and immediately switching operations to a standby component without human intervention. This increases resiliency. high availability Automatic failover MariaDB MaxScale is a database proxy that includes features for high availability. In this article, I'll show you how you can try it out with an application implemented in Java and Svelte. online store simulator Architecture The following diagram shows the architecture of the demo application: A web application developed with JavaScript and the Svelte framework makes HTTP requests to a Java backend. The backend answers with that the frontend uses to update the user interface on the browser. server-sent events The backend is implemented with and connects to a database cluster using (reactive). The backend logic is, in short, a simulation of reads and writes to an online store database. The simulation is parameterized, and the user can adjust: Spring Boot MariaDB R2DBC How many reads to the database per minute. Product visits per minute: How many writes to the database per minute. Orders per minute: Write amplification. Products per order: How many seconds until a request to the database is considered failed. Timeout in milliseconds: The database cluster is front-ended by a called MaxScale. This proxy makes the cluster look like a single logical database to the Java backend. MaxScale also performs read/write splitting (sending writes to the primary MariaDB server and reads to replicas), as well as load-balancing of reads among replica servers using a configurable algorithm. Data is automatically replicated from the primary to the replica database servers. database proxy Building the Docker images from source I have prepared custom Docker images for every component in the simulator. You can either build the images from the source (optional) or use the already built and published images from Docker Hub. If you decide to build the images yourself, you can find the source code on GitHub: Custom images for easy deployment of replicated MariaDB topologies with MaxScale. These images are suitable only for demo applications. Use the for production deployments. : MariaDB deployments DO NOT USE THESE IN PRODUCTION! official MariaDB Docker images The backend application that connects to the database cluster. : Backend application The frontend application that makes simulation configuration requests to the backend and receives events to show the simulation result. : Frontend application Each repository has Dockerfiles that you can use to build your own Docker images. For example, to build the backend application image, run: docker build --tag alejandrodu/online-store-simulator-java-backend . Running the simulation All the services can be started using the following Docker Compose file ( ): docker-compose.yml version: "3.9"
services:
  server-1:
    container_name: server-1
    image: alejandrodu/mariadb
    ports:
      - "3306:3306"
    environment:
      - MARIADB_CREATE_DATABASE=demo
      - MARIADB_CREATE_USER=user:Password123!
      - MARIADB_CREATE_REPLICATION_USER=replication_user:ReplicationPassword123!
      - MARIADB_CREATE_MAXSCALE_USER=maxscale_user:MaxScalePassword123!

  server-2:
    container_name: server-2
    image: alejandrodu/mariadb
    ports:
      - "3307:3306"
    environment:
      - MARIADB_REPLICATE_FROM=replication_user:ReplicationPassword123!@server-1:3306

  server-3:
    container_name: server-3
    image: alejandrodu/mariadb
    ports:
      - "3308:3306"
    environment:
      - MARIADB_REPLICATE_FROM=replication_user:ReplicationPassword123!@server-1:3306

  maxscale:
    container_name: maxscale
    image: alejandrodu/mariadb-maxscale
    command: --admin_host 0.0.0.0 --admin_secure_gui false
    ports:
      - "4000:4000"
      - "8989:8989"
      - "27017:27017"
    environment:
      - MAXSCALE_USER=maxscale_user:MaxScalePassword123!
      - MARIADB_HOST_1=server-1 3306
      - MARIADB_HOST_2=server-2 3306
      - MARIADB_HOST_3=server-3 3306
    healthcheck:
      test: ["CMD", "maxctrl", "list", "servers"]
      interval: 5s
      timeout: 10s
      retries: 5

  java-backend:
    container_name: java-backend
    image: alejandrodu/online-store-simulator-java-backend
    ports:
      - "8080:8080"
    environment:
    - spring.r2dbc.url=r2dbc:mariadb://maxscale:4000/demo
    - spring.r2dbc.username=user
    - spring.r2dbc.password=Password123!
    - spring.liquibase.url=jdbc:mariadb://maxscale:4000/demo
    - spring.liquibase.user=user
    - spring.liquibase.password=Password123!
    depends_on:
      maxscale:
        condition: service_healthy

  svelte-frontend:
    container_name: svelte-fronted
    image: alejandrodu/online-store-simulator-svelte-frontend
    ports:
      - "5173:80"
    environment:
      - BACKEND_URL=http://java-backend:8080 Move to the directory in which the Docker Compose file is, and start the services in detached mode as follows: docker compose up -d Configuring MaxScale Before you start the simulation, configure MaxScale for transaction replay. Also, timeouts should be adjusted to make the simulation more interesting. Navigate to and log into the UI using: http://localhost:8989/ Username: admin Password: mariadb You'll see a dashboard with the MariaDB cluster state. There's a primary server ( ), and two replicas ( and ). Replication is already configured from (primary) to and (replicas). All servers should be up and running. server-1 server-2 server-3 server-1 server-2 server-3 Click on and then on the icon to enable parameter editing. Set the following parameters: mdb_monitor pencil ( ): This enables automatic failover. When a MariaDB server is down, MaxScale selects a replica server and reconfigures it as the new primary so that writes can continue to happen. auto_failover true ( ): This enables the automatic rejoin of recovered servers. When a failed server is up again, MaxScale detects it and configures it as an available replica server. auto_rejoin true ( ): Sets the number of monitor (a component in MaxScale that checks server status) iterations required for a server to be down in order to activate the failover process. We set a value of to make sure the failover starts immediately after failure. failcount 1 1 ( ): Connection timeout for monitor connections. We set a low value (one second) to quickly activate failover for this demo. backend_connect_timeout 1000 ( ): Read timeout for monitor connections. backend_read_timeout 1000 ( ): Write timeout for monitor connections. backend_write_timeout 1000 ( ): Primary failure timeout. master_failure_timeout 1000 ( ): How often the servers are monitored. monitor_interval 1000 ⚠️ These values are appropriate for this demo but very likely not the best for production environments! WARNING: Once the parameters are set, click on and . Done Editing Confirm You also need to enable transaction replay, which automatically re-executes failed in-flight transactions on servers that went down just after a SQL statement was routed. This is a useful feature for software developers since it prevents the need for coding failure cases and transaction retry. On the main menu, click on and then on any of the links in the list of servers. Edit the parameters as follows: Dashboard query_router_service ( ): Activates automatic retry of failed transactions. transaction_replay true ( ): Same as the previous when a deadlock occurs. transaction_replay_retry_on_deadlock true ( ): Same as the previous when a checksum mismatch occurs. transaction_replay_retry_on_mismatch true Once the parameters are set, click on and . Done Editing Confirm Starting the simulation With everything configured, you can start the simulation. Navigate to and configure the following parameters (names are, I hope, self-explanatory): http://localhost:5173/ Product visits per minute: 6000 Orders per minute: 60 Timeout in milliseconds: 8000 But before you start the simulation, you need to create the products for the online store. Click on | . Leave the default values and click on . You should see the UI updating as products are created in the database. Data Create products... Create Now, you can finally click on and see the simulation in action. Start Simulating a server failure At this point, the primary server is handling writes (orders). What happens if you stop that server? In the command line run: docker stop server-1 Depending on multiple factors, you might get some "disappointed visitors" or even a few "missed opportunities" in the simulator. Or maybe you don't get any at all! Product visits (reads) and orders (writes) continue to happen, thanks to MaxScale. Without automatic failover, you have to reconfigure everything manually, which results in more offline time, many disappointed visitors, and missed opportunities! Start the failed server: docker start server-1 Go to the MaxScale ( ) and check that is now a functioning replica. Dashboard http://localhost:8989/ server-1 You can perform a manual to make the primary server again. Click on and then mouse hover over the section. Click on the icon and select . Click and check again in the that the new primary server is . switchover server-1 mdb_monitor MASTER pencil server-1 Swap Dashboard server-1 Conclusion Automatic failover is only one of the components in highly available systems. You can use a database proxy like MaxScale to set up automatic failover, as well as other components such as load-balancing, query routing, transaction retry, topology isolation, and more. Check out the documentation at . https://mariadb.com/kb/en/maxscale/ Also published . here

Achieving High Availability with MariaDB MaxScale

After this long digression

Illustration created with NightCafe As we’ve followed the fascinating twists and turns of numerous works of fiction, whose plots are in one way or another connected with robots, how many of us thought about the fact that we are already living in the very "robotic future" that is often presented in science fiction books, movies, and TV series? It's not as if someone drew a line and said: "By crossing this line, we are stepping into a new era." It's pretty obvious that even the fastest adoption of technology is still gradual. And that's fortunate, as it gives us the opportunity to adapt to the major socio-economic changes that are associated with technological advances. And there is no doubt that robotization entails these major changes. Let's take a look at the current level of robotics development and implementation. Statistics, as usual, will most accurately present the current state of affairs. And the most eloquent statistics of all are financial statistics. And it says that in 2022, the volume of the robotics market amounted to $34 billion. A rather modest, in our opinion, forecast says that by 2028, the market will grow to $45 billion a year. Interestingly, the service robot market is developing most actively. In 2022, it will account for 76% of total market share. This, of course, does not mean that industrial robots have ceased to be of interest. It's just that businesses realized their benefits and the opportunities they provide much earlier. In addition, the previous generation of robotics technology was simply unable to bring even marginally satisfactory models of service robots to market. Today, the state of affairs has changed. Several service and collaborative robots (cobots) have emerged from their diapers and begun to perform their duties in a wide variety of spheres. We are sure that among the readers of this text, there are those who, at home or in the office, use a robot vacuum cleaner and/or robotic carts to deliver various items. But these are by no means the most interesting examples of robotics technology. They are already being replaced by more advanced examples. An example of the next iteration is the Aeo service robot, which is capable of performing various actions using its manipulators. Another is Optimus, a series of humanoid robots from Tesla. It is expected that in the very near future - by 2025 - the market for cobots alone (i.e., robots that interact with people in the workspace) will exceed $12 billion. The current generation of service robots and cobots are already capable of taking over a number of routine, low-skill tasks. For example, they can perform the functions of nurses, security personnel, cleaners, porters, packers, waiters, pickers, "serve and fetch" assistants, and so on and so forth. As a rule, they are equipped with AI that is smart enough to execute voice commands that are given in any form. A separate topic is robotic transportation. According to forecasts, by 2030, 10% of all vehicles on the planet will be self-driving. And this figure is also rather modest in our opinion, and is not because of a lack of technical capability, but instead will result from a combination of price and psychological factors. As far as industrial robots are concerned, today, the creation of fully automated plants and factories is in full swing. In developed countries like South Korea, about 1,000 robots per 10,000 workers are being used in the manufacturing sector. This is a very approximate figure, but in this case, it is not the exact ratio of people to robots that matters. The salient issue is the complexity of these industrial robots. The idea of the factory of the future as an analog of traditional  "human-powered" production facilities in which human beings have been replaced by humanoid robots is fundamentally wrong. Anyone who has been to a robotized production facility knows that an ordinary industrial robot is, in fact, an automatic machine tool. Or an entire assembly line. You will agree that this kind of production unit cannot be considered simply as an improved (from the point of view of factory production) analog of a human being. Each such robot replaces entire teams and workshops. Illustration created with NightCafe The logical development of this concept is the creation of fully automated production facilities. In other words, plants, factories, and other production facilities will each, in fact, be a large and incredibly complex robot. By the way, there is a place for humanoid robots in these production environments, too. However, they should not be considered industrial robots; instead, they should be identified as a new level of service and collaborative robots designed to interact with other robots and maintain their workspaces. What will it look like? Note that we consider most predictions for robotics adoption and development that are statistically based to be too conservative. Of course, solid researchers simply must proceed with caution. But we will allow ourselves to draw on a history in which technological progress has often raced ahead of predictions based on statistical analysis. Think of the rapid evolution of cell phones into smartphones or the first personal computers into light, sleek laptops. So, let's try to imagine a robotic life ten years from now based on a similar rapidity in development. Industrial and factory production will be fully roboticized. Mass-produced goods will be produced by robotic factories. Service robots and cobots will maintain and repair these production facilities; self-directed transportation will deliver raw materials to them and export their finished products. Agriculture will also become extremely automated. This is particularly true with the development of technologies for growing meat products. Traditional livestock farms will mostly disappear, which, it should be noted, will have a positive impact on the environment. Service robots will take over most of the work in commerce and the service industry, which hasn’t transitioned into virtual reality. They will also take care of household chores, repairs, construction, cleaning, street beautification, and the like. Freight transportation and public transport will be completely taken over by self-driving trains, planes, airships, copters, buses, cabs, air cabs, and so on. The share of self-driven private transportation will gradually increase. This trend will be accelerated under the pressure of increasingly stringent safety requirements for drivers. All of the above, combined with the development of artificial intelligence and augmented reality, will rid people almost completely of the work being performed currently that is strenuous, boring, monotonous, or poses a risk to health (or is simply dangerous). In other words, people are not going to have to do most of the work that people have to do now. But what will mankind do? At least that part of it that will enjoy civilization’s benefits? This is the final chapter of our future fantasy. Robert McCall – Metropolis 2050 #4 The article was created in collaboration with Andriy Tkachenko Illustration created with NightCafe Illustration created with NightCafe Illustration created with NightCafe As we’ve followed the fascinating twists and turns of numerous works of fiction, whose plots are in one way or another connected with robots, how many of us thought about the fact that we are already living in the very "robotic future" that is often presented in science fiction books, movies, and TV series? It's not as if someone drew a line and said: "By crossing this line, we are stepping into a new era." It's pretty obvious that even the fastest adoption of technology is still gradual. And that's fortunate, as it gives us the opportunity to adapt to the major socio-economic changes that are associated with technological advances. And there is no doubt that robotization entails these major changes. Let's take a look at the current level of robotics development and implementation. Statistics, as usual, will most accurately present the current state of affairs. And the most eloquent statistics of all are financial statistics. And it says that in 2022, the volume of the robotics market amounted to $34 billion . A rather modest, in our opinion, forecast says that by 2028, the market will grow to $45 billion a year. $34 billion $34 billion Interestingly, the service robot market is developing most actively. In 2022, it will account for 76% of total market share . This, of course, does not mean that industrial robots have ceased to be of interest. It's just that businesses realized their benefits and the opportunities they provide much earlier. In addition, the previous generation of robotics technology was simply unable to bring even marginally satisfactory models of service robots to market. 76% of total market share 76% of total market share Today, the state of affairs has changed. Several service and collaborative robots (cobots) have emerged from their diapers and begun to perform their duties in a wide variety of spheres. We are sure that among the readers of this text, there are those who, at home or in the office, use a robot vacuum cleaner and/or robotic carts to deliver various items. But these are by no means the most interesting examples of robotics technology. They are already being replaced by more advanced examples. An example of the next iteration is the Aeo service robot, which is capable of performing various actions using its manipulators. Another is Optimus, a series of humanoid robots from Tesla . It is expected that in the very near future - by 2025 - the market for cobots alone (i.e., robots that interact with people in the workspace) will exceed $12 billion . Aeo Aeo Tesla Tesla $12 billion $12 billion The current generation of service robots and cobots are already capable of taking over a number of routine, low-skill tasks. For example, they can perform the functions of nurses, security personnel, cleaners, porters, packers, waiters, pickers, "serve and fetch" assistants, and so on and so forth. As a rule, they are equipped with AI that is smart enough to execute voice commands that are given in any form. A separate topic is robotic transportation. According to forecasts, by 2030, 10% of all vehicles on the planet will be self-driving. And this figure is also rather modest in our opinion, and is not because of a lack of technical capability, but instead will result from a combination of price and psychological factors. 10% of all vehicles 10% of all vehicles As far as industrial robots are concerned, today, the creation of fully automated plants and factories is in full swing. In developed countries like South Korea, about 1,000 robots per 10,000 workers are being used in the manufacturing sector. This is a very approximate figure, but in this case, it is not the exact ratio of people to robots that matters. The salient issue is the complexity of these industrial robots. The idea of the factory of the future as an analog of traditional  "human-powered" production facilities in which human beings have been replaced by humanoid robots is fundamentally wrong. Anyone who has been to a robotized production facility knows that an ordinary industrial robot is, in fact, an automatic machine tool. Or an entire assembly line. You will agree that this kind of production unit cannot be considered simply as an improved (from the point of view of factory production) analog of a human being. Each such robot replaces entire teams and workshops. about 1,000 robots per 10,000 workers about 1,000 robots per 10,000 workers Illustration created with NightCafe Illustration created with NightCafe The logical development of this concept is the creation of fully automated production facilities. In other words, plants, factories, and other production facilities will each, in fact, be a large and incredibly complex robot. By the way, there is a place for humanoid robots in these production environments, too. However, they should not be considered industrial robots; instead, they should be identified as a new level of service and collaborative robots designed to interact with other robots and maintain their workspaces. What will it look like? Note that we consider most predictions for robotics adoption and development that are statistically based to be too conservative. Of course, solid researchers simply must proceed with caution. But we will allow ourselves to draw on a history in which technological progress has often raced ahead of predictions based on statistical analysis. Think of the rapid evolution of cell phones into smartphones or the first personal computers into light, sleek laptops. So, let's try to imagine a robotic life ten years from now based on a similar rapidity in development. Industrial and factory production will be fully roboticized. Mass-produced goods will be produced by robotic factories. Service robots and cobots will maintain and repair these production facilities; self-directed transportation will deliver raw materials to them and export their finished products. Agriculture will also become extremely automated. This is particularly true with the development of technologies for growing meat products. Traditional livestock farms will mostly disappear, which, it should be noted, will have a positive impact on the environment. Service robots will take over most of the work in commerce and the service industry, which hasn’t transitioned into virtual reality. They will also take care of household chores, repairs, construction, cleaning, street beautification, and the like. Freight transportation and public transport will be completely taken over by self-driving trains, planes, airships, copters, buses, cabs, air cabs, and so on. The share of self-driven private transportation will gradually increase. This trend will be accelerated under the pressure of increasingly stringent safety requirements for drivers. All of the above, combined with the development of artificial intelligence and augmented reality, will rid people almost completely of the work being performed currently that is strenuous, boring, monotonous, or poses a risk to health (or is simply dangerous). In other words, people are not going to have to do most of the work that people have to do now. But what will mankind do? At least that part of it that will enjoy civilization’s benefits? This is the final chapter of our future fantasy. Robert McCall – Metropolis 2050 #4 Robert McCall – Metropolis 2050 #4 The article was created in collaboration with Andriy Tkachenko The article was created in collaboration with Andriy Tkachenko

What Will the Spring of Technology Bring? Part 3: Robotic Life

Writing Effective Integration Tests in Spring: Organized Testing Strategies for HTTP Request Mocking

Mastering Scheduling and Tax Execution in Spring Boot

What Will the Spring of Technology Bring? Part 2 — Virtual Human

Predictions, dreams, and fortune-telling about the day after tomorrow in IT and beyond. Winter is the traditional time to try to predict in which direction technology will move and develop during the coming year. But why limit ourselves to such a short period of time? Let's try to go into “futurology and short-range sci-fi mode” and attempt to decipher the signals that our present is sending to the future. We’ll focus on, let's say, the next five to ten years. Particularly since we, thanks to breakthroughs in the practical application of artificial intelligence, have once again entered a fascinating "Spring of Technology" period. People love mobile devices. The all-knowing statisticians say that by early 2023, the number of mobile users had reached 5.44 billion (68% of the world's population), demonstrating an increase of 168 million users over 12 months. In 2023, around 1.45 billion smartphones were sold, with that figure expected to reach 1.78 billion units in 2028. To put it simply, the day is not far off when every person on the planet will have their own mobile IT device. Even infants. It is not so difficult to imagine some gadget, like a bracelet, which will not only report an infant’s various physiological data but utilize AI to interpret the babble of a child who has not yet learned to speak “adult” language. We think that this simple prediction serves us well as a bridge to our next question, "What will mobile devices be like in the near future?” It is worth remembering that humans are nomadic hunter-gatherers by origin. And somewhere in our subconscious, we are still haunted by the idea of a universal personal assistant that is always with us. We are sure that many of our readers still remember the last spring of technology, during which button cellphones developed explosively. They were created to fulfill a single purpose - to provide mobile voice communication. However, with incredible speed, they then acquired additional functions. And, for the most part, these new functions had nothing to do with telephony. It is interesting that often, new innovations were not developed by mobile phone designers but by amateurs who rewrote existing cellphone software. Cellphone designers discovered that there was a demand for phones to do more than just make calls and store contact information. People wanted to use their mobile devices to listen to music, look at pictures, read news and books, play games, check email, and so on and so forth. Catching the wave, mobile manufacturers rushed to satisfy the market’s desires. How did it turn out? Everything possible was squeezed out of button cellphone technology, and after several years of stagnation the current reigning technology, the ubiquitous smartphone as we know it today was born. A computer with a touch screen interface that occupies almost the entire surface of the device’s front side. Interestingly, the appearance of something similar was predicted ten to fifteen years before the first iPhone. At the time, in the 1990s, many people thought that the realization of this prediction was far off in a very distant future. A crewed flight to Mars seemed to be a much less fantastic proposal. Today, we observe approximately the same cellphone environment as seen at the beginning of the century. For a long time, smartphone creators have not offered us anything fundamentally new, instead focusing on solving horizontal tasks, like a little better camera, a little more powerful processor, and a little more memory... At the same time, attempts to push the envelope have often looked like a return to the past. Yes, you guessed it, we're talking about foldable smartphones. As far as we can judge, the solution to the problem of vertical progress in mobile devices has nothing to do with the search for a new form factor. Why? Look at your hand. That is the main limitation of imaginative design. So, it is quite possible that current designers and developers are not so wrong, mostly focusing on improving the standard smartphone’s stuffing. This does not change the fact that this stuffing must, at some point, become fundamentally different. And this evolution will definitely occur. In order for this to happen, it is necessary to change our very idea of what a smartphone is. What is a modern mobile device from the point of view of most people - both users and IT specialists? That's right - a desktop’s younger sibling. Most websites and software products are first created for desktops and then adapted into a mobile version. As a rule, mobile versions are simplified and with trimmed functionality compared to their desktop counterparts. But, there is a feeling of change in the air, and the idea of focusing on smartphones is not as counterintuitive as it first seems. Have you noticed that the classic desktop, by and large, has lost its competition with the laptop, which is essentially a mobile device as well? Turning most users’ smartphones into their primary computers looks like a logical next step. What Will It Look Like? The smartphone itself will not change much in appearance. However, its functionality will increase dramatically, both through peripherals and, of course, through software. Smartphones will play the role of the main unit of the computer. Instead of a desktop, there will be a base for the smartphone on a table, to which a monitor and keyboard will be connected. In the future, all of this will be unnecessary - the screen and keyboard will both be projected as a holographic image. The next step will then be to abandon the base - the smartphone itself will be able to project a large holo screen and full-size keyboard. Surely, in time, the above-mentioned abilities will also be acquired by smartwatches. Admit it, haven't you dreamed of talking to a hologram of your interlocutor in the style of Star Wars? However, much more important than these technical improvements will be fundamentally new software. It will bring smartphones to a qualitatively different level, transforming the device into a universal personal assistant, which people have been dreaming about since the first cellphone appeared. You must have already guessed what we are going to say. Yes, you're right. This software will be based on artificial intelligence. In fact, it will be an AI assistant, or rather a team of AI assistants for all occasions, freely supporting voice and text dialog. Such smartphones will search the Internet, answer any question, perform simultaneous multilingual translation from any language, make regular payments, monitor health, plot routes, assist with driving (or driving independently), warn of dangers, and so on and so forth. Believe us - we are not making this prediction because of our professional connection to the topic of artificial intelligence. The fact that we have the honor of belonging to the Pitch Avatar team does not prevent us from seeing AI rapidly penetrating into all spheres of life. Of course, for a full-fledged real-time interaction between a smartphone and its user, you will need an additional device that simultaneously outputs audio and visual information and, at the same time, leaves your hands free. Something like glasses with earbuds. Of course, it won't be something bulky like current virtual reality helmets and goggles. Designers (and modelers, where would we be without them?) will strive to create something compact and sleek. Like regular glasses - sunglasses or for vision correction. And with the help of this hypothetical device, it will be possible to experience augmented reality and dive into virtual reality. But, for more about this, you will have to wait for the next chapter of our future fantasy. The article was created in collaboration with Andriy Tkachenko Predictions, dreams, and fortune-telling about the day after tomorrow in IT and beyond. Predictions, dreams, and fortune-telling about the day after tomorrow in IT and beyond. Predictions, dreams, and fortune-telling about the day after tomorrow in IT and beyond. Winter is the traditional time to try to predict in which direction technology will move and develop during the coming year. But why limit ourselves to such a short period of time? Let's try to go into “futurology and short-range sci-fi mode” and attempt to decipher the signals that our present is sending to the future. We’ll focus on, let's say, the next five to ten years. Particularly since we, thanks to breakthroughs in the practical application of artificial intelligence, have once again entered a fascinating "Spring of Technology" period. People love mobile devices. The all-knowing statisticians say that by early 2023, the number of mobile users had reached 5.44 billion (68% of the world's population), demonstrating an increase of 168 million users over 12 months. In 2023, around 1.45 billion smartphones were sold, with that figure expected to reach 1.78 billion units in 2028. 5.44 billion 5.44 billion 1.45 billion smartphones 1.45 billion smartphones 1.78 billion 1.78 billion To put it simply, the day is not far off when every person on the planet will have their own mobile IT device. Even infants. It is not so difficult to imagine some gadget, like a bracelet, which will not only report an infant’s various physiological data but utilize AI to interpret the babble of a child who has not yet learned to speak “adult” language. We think that this simple prediction serves us well as a bridge to our next question, "What will mobile devices be like in the near future?” It is worth remembering that humans are nomadic hunter-gatherers by origin. And somewhere in our subconscious, we are still haunted by the idea of a universal personal assistant that is always with us. We are sure that many of our readers still remember the last spring of technology, during which button cellphones developed explosively. They were created to fulfill a single purpose - to provide mobile voice communication. However, with incredible speed, they then acquired additional functions. And, for the most part, these new functions had nothing to do with telephony. It is interesting that often, new innovations were not developed by mobile phone designers but by amateurs who rewrote existing cellphone software. Cellphone designers discovered that there was a demand for phones to do more than just make calls and store contact information. People wanted to use their mobile devices to listen to music, look at pictures, read news and books, play games, check email, and so on and so forth. Catching the wave, mobile manufacturers rushed to satisfy the market’s desires. How did it turn out? Everything possible was squeezed out of button cellphone technology, and after several years of stagnation the current reigning technology, the ubiquitous smartphone as we know it today was born. A computer with a touch screen interface that occupies almost the entire surface of the device’s front side. Interestingly, the appearance of something similar was predicted ten to fifteen years before the first iPhone. At the time, in the 1990s, many people thought that the realization of this prediction was far off in a very distant future. A crewed flight to Mars seemed to be a much less fantastic proposal. Today, we observe approximately the same cellphone environment as seen at the beginning of the century. For a long time, smartphone creators have not offered us anything fundamentally new, instead focusing on solving horizontal tasks, like a little better camera, a little more powerful processor, and a little more memory... At the same time, attempts to push the envelope have often looked like a return to the past. Yes, you guessed it, we're talking about foldable smartphones. As far as we can judge, the solution to the problem of vertical progress in mobile devices has nothing to do with the search for a new form factor. Why? Look at your hand. That is the main limitation of imaginative design. So, it is quite possible that current designers and developers are not so wrong, mostly focusing on improving the standard smartphone’s stuffing. This does not change the fact that this stuffing must, at some point, become fundamentally different. And this evolution will definitely occur. In order for this to happen, it is necessary to change our very idea of what a smartphone is. What is a modern mobile device from the point of view of most people - both users and IT specialists? That's right - a desktop’s younger sibling. Most websites and software products are first created for desktops and then adapted into a mobile version. As a rule, mobile versions are simplified and with trimmed functionality compared to their desktop counterparts. But, there is a feeling of change in the air, and the idea of focusing on smartphones is not as counterintuitive as it first seems. Have you noticed that the classic desktop, by and large, has lost its competition with the laptop, which is essentially a mobile device as well? Turning most users’ smartphones into their primary computers looks like a logical next step. What Will It Look Like? The smartphone itself will not change much in appearance. However, its functionality will increase dramatically, both through peripherals and, of course, through software. Smartphones will play the role of the main unit of the computer. Instead of a desktop, there will be a base for the smartphone on a table, to which a monitor and keyboard will be connected. In the future, all of this will be unnecessary - the screen and keyboard will both be projected as a holographic image. The next step will then be to abandon the base - the smartphone itself will be able to project a large holo screen and full-size keyboard. Surely, in time, the above-mentioned abilities will also be acquired by smartwatches. Admit it, haven't you dreamed of talking to a hologram of your interlocutor in the style of Star Wars? However, much more important than these technical improvements will be fundamentally new software. It will bring smartphones to a qualitatively different level, transforming the device into a universal personal assistant, which people have been dreaming about since the first cellphone appeared. You must have already guessed what we are going to say. Yes, you're right. This software will be based on artificial intelligence. In fact, it will be an AI assistant, or rather a team of AI assistants for all occasions, freely supporting voice and text dialog. Such smartphones will search the Internet, answer any question, perform simultaneous multilingual translation from any language, make regular payments, monitor health, plot routes, assist with driving (or driving independently), warn of dangers, and so on and so forth. Believe us - we are not making this prediction because of our professional connection to the topic of artificial intelligence. The fact that we have the honor of belonging to the Pitch Avatar team does not prevent us from seeing AI rapidly penetrating into all spheres of life. Pitch Avatar Pitch Avatar Of course, for a full-fledged real-time interaction between a smartphone and its user, you will need an additional device that simultaneously outputs audio and visual information and, at the same time, leaves your hands free. Something like glasses with earbuds. Of course, it won't be something bulky like current virtual reality helmets and goggles. Designers (and modelers, where would we be without them?) will strive to create something compact and sleek. Like regular glasses - sunglasses or for vision correction. And with the help of this hypothetical device, it will be possible to experience augmented reality and dive into virtual reality. But, for more about this, you will have to wait for the next chapter of our future fantasy. The article was created in collaboration with Andriy Tkachenko The article was created in collaboration with Andriy Tkachenko

What Will the Spring of Technology Bring? Part 1. Mobile Man

What is Authentication? 🔐 Authentication is the process of verifying the identity of users, ensuring they are who they claim to be before granting access to a system or application. In the context of web applications, this is crucial for protecting sensitive information and resources. Authentication involves: User Credentials:🔑 Users provide credentials, such as usernames and passwords. Verification Process:✔️ The system verifies the provided credentials against stored data. Successful verification grants access; otherwise, access is denied Spring Security🍃 For developers building Spring-based applications, Spring Security serves as the de-facto standard for securing their creations. This comprehensive framework provides robust authentication and authorization mechanisms, ensuring your application’s data and functionality remain safe from unauthorized access. Java JWT (JSON Web Token)Authentication: A Secure and Scalable 🔐📈 Approach JWT stands for JSON Web Token, a self-contained token that contains information about the user and is signed by the server for verification. It has become a popular choice for authorization due to its numerous advantages. Use Cases: JWTs are widely used in various scenarios: Public APIs: Securely access public APIs without requiring frequent logins. Mobile Applications: Store user information and authorization details within the token for offline use. Single Sign-On (SSO): This allows users to seamlessly access multiple applications with a single login. Practical application of JWT by implementing it in a Spring Boot application to secure our API endpoints⛏👷 Now, we will configure the in-memory user and JWT. We will create an API endpoint and secure it using Spring Boot security. Create a Spring Boot Project Use Spring Initializr to create a new Spring Boot project with the following dependencies: For Web: <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency> For Security <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency> Lombok: <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency> For JWT: <dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId> 
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency> Let’s start with creating an endpoint to be secured: @RestController
@RequestMapping("/home")
public class Controller {
  @Autowired
    private UserService userService;
  @GetMapping("/users")
    public List<User> getUsers(){
      System.out.println("getting users");
      return userService.getUsers();
  }
} Create a user: @Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User {
    private String userId;
    private String name;
    private String email;
} Create a service class: @Service
public class UserService {
    private List<User> store=new ArrayList<>();
    public UserService() {
        store.add(new User(UUID.randomUUID().toString(), "Bhushan", "bhushan@gmail.com"));
        store.add(new User(UUID.randomUUID().toString(), "Ramesh", "ramesh@gmail.com"));
        store.add(new User(UUID.randomUUID().toString(), "Suresh", "suresh@gmail.com"));
        store.add(new User(UUID.randomUUID().toString(), "Paresh", "paresh@gmail.com"));
    }
    public List<User> getUsers(){
        return this.store;
    }
} Create an in-memory user with UserDetailService bean: @Configuration
public class AppConfig {
    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails userDetails = User.builder().
                username("Bhushan")
                .password(passwordEncoder().encode("Nemade")).roles("ADMIN").
                build();
        return new InMemoryUserDetailsManager(userDetails);
    }
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration builder) throws Exception {
        return builder.getAuthenticationManager();
    }
} Start with creating the class JWTAthenticationEntryPoint that will be implementing : Used to handle authentication-related exceptions. Specifically, it is responsible for returning an unauthorized (401) response to clients who attempt to access protected resources without proper authentication. AuthenticationEntryPoint @Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException)
            throws IOException, ServletException {
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        PrintWriter writer = response.getWriter();
        writer.println("Access Denied !! " + authException.getMessage());
    }
} The helper class is often created to encapsulate the logic related to the generation, parsing, validation, and manipulation of JWTs in a more modular and maintainable way. It provides a set of methods and utilities to interact with JWTs. Create a JWT helper class: @Component
public class JwtHelper {
    public static final long JWT_TOKEN_VALIDITY = 5 * 60 * 60;
    private String secret = "afafasfafafasfasfasfafacasdasfasxASFACASDFACASDFASFASFDAFASFASDAADSCSDFADCVSGCFVADXCcadwavfsfarvf";
    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }
    public Date getExpirationDateFromToken(String token) {
        return getClaimFromToken(token, Claims::getExpiration);
    }
    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }
    private Claims getAllClaimsFromToken(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }
    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        return doGenerateToken(claims, userDetails.getUsername());
    }
    private String doGenerateToken(Map<String, Object> claims, String subject) {

        return Jwts.builder().setClaims(claims).setSubject(subject).setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + JWT_TOKEN_VALIDITY * 1000))
                .signWith(SignatureAlgorithm.HS512, secret).compact();
    }
    public Boolean validateToken(String token, UserDetails userDetails) {
        final String username = getUsernameFromToken(token);
        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
    }
} Extending the class for a JWT authentication filter in Spring Security is a common approach to ensure that the filter is only executed once per request. This helps prevent unnecessary duplicate processing and ensures that the filter logic is applied consistently. Create a JwtAuthenticationFilter class which will extend OncePerRequestFilter: OncePerRequestFilter @Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {
   private Logger logger = LoggerFactory.getLogger(OncePerRequestFilter.class);
    @Autowired
    private JwtHelper jwtHelper;
    @Autowired
    private UserDetailsService userDetailsService;
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String requestHeader = request.getHeader("Authorization");
        logger.info(" Header :  {}", requestHeader);
        String username = null;
        String token = null;
        if (requestHeader != null && requestHeader.startsWith("Bearer")) {
            token = requestHeader.substring(7);
            try {
                username = this.jwtHelper.getUsernameFromToken(token);
            } catch (IllegalArgumentException e) {
                logger.info("Illegal Argument while fetching the username !!");
                e.printStackTrace();
            } catch (ExpiredJwtException e) {
                logger.info("Given jwt token is expired !!");
                e.printStackTrace();
            } catch (MalformedJwtException e) {
                logger.info("Some changed has done in token !! Invalid Token");
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            logger.info("Invalid Header Value !! ");
        }
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            Boolean validateToken = this.jwtHelper.validateToken(token, userDetails);
            if (validateToken) {     
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            } else {
                logger.info("Validation fails !!");
            }
        }
        filterChain.doFilter(request, response);
    }
} Create a SecurityConfig class as spring security in the configuration file: @Configuration
public class SecurityConfig {
    @Autowired
    private JwtAuthenticationEntryPoint point;
    @Autowired
    private JwtAuthenticationFilter filter;
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.csrf(csrf -> csrf.disable())
                .authorizeRequests().
                requestMatchers("/test").authenticated().requestMatchers("/auth/login").permitAll()
                .anyRequest()
                .authenticated()
                .and().exceptionHandling(ex -> ex.authenticationEntryPoint(point))
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS));
        http.addFilterBefore(filter, UsernamePasswordAuthenticationFilter.class);
        return http.build();
    }
} Create a login API to accept the username and password: @RestController
@RequestMapping("/auth")
public class AuthController {
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private AuthenticationManager manager;
    @Autowired
    private JwtHelper helper;
    private Logger logger = LoggerFactory.getLogger(AuthController.class);
    @PostMapping("/login")
    public ResponseEntity<JwtResponse> login(@RequestBody JwtRequest request) {
        this.doAuthenticate(request.getEmail(), request.getPassword());
        UserDetails userDetails = userDetailsService.loadUserByUsername(request.getEmail());
        String token = this.helper.generateToken(userDetails);

        JwtResponse response = JwtResponse.builder()
                .jwtToken(token)
                .username(userDetails.getUsername()).build();
        return new ResponseEntity<>(response, HttpStatus.OK);
    }
    private void doAuthenticate(String email, String password) {
        UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(email, password);
        try {
            manager.authenticate(authentication);
        } catch (BadCredentialsException e) {
            throw new BadCredentialsException(" Invalid Username or Password  !!");
        }
    }
    @ExceptionHandler(BadCredentialsException.class)
    public String exceptionHandler() {
        return "Credentials Invalid !!";
    }
} : Creating a JWT request and response involves defining structures for sending and receiving JWTs during the authentication process. Typically, a JWT request is used to send user credentials (e.g., username and password) to the server for authentication, and a JWT response is used to deliver a token upon successful authentication. Create a JWT Request and JWT Response to receive data and send login details @Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString
public class JwtRequest {
    private  String email;
    private String password;
} @Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@ToString
public class JwtResponse {
    private String jwtToken;
    private String username;
} Test the API using Postman to generate a JWT token, then use that token as a header in subsequent requests to access the protected API and verify successful authentication. Dive Deeper : youtube.com/watch?v=q2l91Ffc_8U&t=3299s https://springframework.guru/jwt-authentication-in-spring-microservices-jwt-token/ Thank you for reading😊 Also published here.

Mastering JWT Authentication & Authorization in Spring Boot 3.1

I have often been asked to develop advanced search services. By advanced search, I mean searches in which it’s possible to apply multiple filters on all (or almost all) fields such as: like, between, in, greater than, etc. So imagine having to build a service, based on one or more entities, capable of offering an endpoint that can be called like this (start keeping an eye out for special suffixes ): <propertyName>< > _suffix curl - request GET \
 - url 'http://www.myexampledomain.com/persons?
firstName=Biagio
&lastName_startsWith=Toz
&birthDate_gte=19910101
&country_in=IT,FR,DE
&company.name_in=Microsoft,Apple
&company.employees_between=500,5000' or curl --request GET \
--url 'http://www.myexampledomain.com/persons?
firstName_endsWith=gio
&lastName_in=Tozzi,Totti
&birthDate_lt=19980101
&_offset=0
&_limit=100
&birthDate_sort=ASC' If you are using in a Spring Boot project, you can now develop this search service with just a few lines of code thanks to ! Let me explain what it is. JPA JPA Search Helper JPA Search Helper First step: @Searchable annotation Start by applying the annotation to the fields in your DTO, or your JPA entity, that you want to make available for search. @Searchable @Data
public class Person {

    @Searchable
    private String firstName;

    @Searchable
    private String lastName;

    @Searchable(entityFieldKey = "dateOfBirth")
    private Date birthDate;

    @Searchable
    private String country;
    
    private Company company;

    @Data
    public static class Company {
        
        @Searchable(entityFieldKey=companyEntity.name)
        private String name;
              
        @Searchable(entityFieldKey=companyEntity.employeesCount)
        private int employees;

    }

} The annotation allows you to specify: Core properties: : the name of the field defined on the entity bean (not to be specified if using the annotation on the entity bean). If not specified the key will be the field name. entityFieldKey : the managed object type by entity. If not specified the librariy tries to obtain it based on field type (es. field without target type definition will be INTEGER). If there is no type compatible with those managed, it will be managed as a string. Managed types: STRING, INTEGER, DOUBLE, FLOAT, LONG, BIGDECIMAL, BOOLEAN, DATE, LOCALDATE, LOCALDATETIME, LOCALTIME, OFFSETDATETIME, OFFSETTIME. targetType Integer Validation properties: : only for DATE target type. Defines the date pattern to use. datePattern , : maximum/minimum length of the value maxSize minSize , : only for numeric types. Maximum/minimum number of digits. maxDigits minDigits : regex pattern. regexPattern : only for decimal numeric types. Default #.## decimalFormat Continuing the example, our entity classes: @Entity
@Data
public class PersonEntity {

    @Id
    private Long id;

    @Column(name = "FIRST_NAME")
    private String firstName;

    @Column(name = "LAST_NAME")
    private String lastName;

    @Column(name = "BIRTH_DATE")
    private Date dateOfBirth;

    @Column(name = "COUNTRY")
    private String country;
        
    @OneToOne
    private CompanyEntity companyEntity;

}

@Entity
@Data
public class CompanyEntity {

    @Id
    private Long id;

    @Column(name = "NAME")
    private String name;

    @Column(name = "COUNT")
    private Integer employeesCount;

} Second and last step: JPASearchRepository<?> Your Spring JPA repository must extend : JPASearchRepository<?> @Repository
public interface PersonRepository extends JpaRepository<PersonEntity, Long>, JPASearchRepository<PersonEntity> {

} Well, let’s build the filters and feed them to the repository: // ...

Map<String, String> filters = new HashMap<>();
filters.put("firstName_eq", "Biagio");
filters.put("lastName_startsWith", "Toz");
filters.put("birthDate_gte", "19910101"); 
filters.put("country_in", "IT,FR,DE");
filters.put("company.name_in", "Microsoft,Apple");
filters.put("company.employees_between", "500,5000");

// Without pagination
List<PersonEntity> fullSearch = personRepository.findAll(filters, Person.class);

filters.put("birthDate_sort" : "ASC");
filters.put("_limit", "10");
filters.put("_offset", "0");

// With pagination
Page<PersonEntity> sortedAndPaginatedSearch = personRepository.findAllWithPaginationAndSorting(filters, Person.class);

// ... You just need to define a map whose key is made up of and search value. The complete list of suffixes, i.e. available filters, is . <fieldName>< > _suffix here : if no suffix is ​​specified the search is done in equal (_eq) Note 1 : In the example I applied the @Searchable annotation on the DTO fields. Alternatively, it’s possible to apply them directly on the entity. Note 2 A pseudo-real implementation in a Spring Boot project Service/Manager bean: @Service 
public class PersonManager { 	
    	
    @Autowired 		
    private PersonRepository personRepository;
    		 		
    public List<Person> find(Map<String, String> filters) {
      return personRepository.findAllWithPaginationAndSorting(filters, Person.class).stream().map(this::toDTO).toList(); 
    } 

    private static Person toDTO(PersonEntity personEntity) {
        // ...
    }

} Controller: @RestController
public class MyController {
    
    @Autowired 		
    private PersonManager personManager;
         
    @GetMapping(path="/persons", produces = MediaType.APPLICATION_JSON_VALUE)  
    public List<Person> findPersons(@RequestParam Map<String, String> requestParams) {  
        return personManager.find(requestParams);  
    }
} ..et voilà les jeux sont faits Extra The library allows you to force join fetch. A join allows associations or collections of values to be initialized along with their parent objects using a single select. “fetch” That’s how: // ...

Map<String, JoinFetch> fetches = Map.of("companyEntity", JoinFetch.LEFT);
personRepository.findAll(filters, Person.class, fetches);

// ... That’s all.. for now! Also published . here

Unlocking Advanced Search in Spring Boot with JPA Search Helper

Starting a new project is always a mix of excitement and tough decisions, especially when you're stitching together familiar tools like Google Docs with powerhouses like GitHub Pages. This is the story of building , a tool that I hoped would make life easier for many. I'll be diving into why I chose Java 21 and Spring Boot 3.x, ditched GraalVM after some trial and error, and why a simple VPS with won out over more complex options. I also went with Postgres and JPA but steered clear of migration tools like Flyway. It's a no-frills, honest recount of the choices, changes, and the occasional 'aha' moments of an engineer trying to make something useful and efficient. gdocweb Docker Compose Introducing gdocweb Before we dive into the technical intricacies and the decision-making labyrinth of building , let's set the stage by understanding what is and the problem it solves. In simple terms, connects Google Docs to GitHub Pages. It's a simple web builder that generates free sites with all the raw power of GitHub behind it and all the usability of Google Docs. gdocweb gdocweb gdocweb I decided to build to eliminate the complexities typically associated with website building and documentation. It's for users who seek a hassle-free way to publish and maintain their content, but also for savvy users who enjoy the power of GitHub but don't want to deal with markdown nuances. gdocweb Here's a short video explaining for the general public: gdocweb https://www.youtube.com/watch?v=aaDBFVx6qC8&embedable=true Java 21 and Spring Boot 3.x: Innovation and Maturity When you're spearheading a project on your own, like I was with , you have the liberty to make technology choices that might be more challenging in a team or corporate environment. This freedom led me to choose Java 21 and Spring Boot 3.x for this project. The decision to go with the current Long-Term Support (LTS) version of Java was a no-brainer. It's always tempting to use the latest and greatest, but with , it wasn't just about using something new; it was about leveraging a platform that has stood the test of time and has evolved to meet modern development needs. Virtual threads were a major part of the decision to go with Java 21. Cost is a huge factor in such projects, and squeezing the maximum throughput from a server is crucial in these situations. gdocweb Java 21 Java, being a mature technology, offered a sense of reliability even in its latest iteration. Similarly, Spring Boot 3.x, despite being a newer version, comes from a lineage of robust and well-tested frameworks. It's a conservative choice in the sense of its long-standing reputation but innovative in its features and capabilities. However, this decision wasn't without its hiccups. During the process of integrating Google API access, I had to go through a security CASA tier 2 review. Here's where the choice of Java 21 threw a curveball. The review tool was tailored for JDK 11, and although it worked with JDK 21, it still added a bit of stress to the process. It was a reminder that when you're working with cutting-edge versions of technologies, there can be unexpected bumps along the road, even if they are as mature as Java. The transition to Spring Boot 3.x had its own set of challenges, particularly with the changes in security configurations. These modifications rendered most online samples and guides obsolete, breaking a lot of what I had initially set up. It was a learning curve, adjusting to these changes and figuring out a new way of doing things. However, most other aspects were relatively simple, and the best compliment I can give to Spring Boot 3.x is that it's very similar to Spring Boot 2.x. GraalVM Native Image for Efficiency My interest in GraalVM native image for was primarily driven by its promise of reduced memory usage and faster startup times. The idea was that with lower memory requirements, I could run more server instances, leading to better scalability and resilience. Faster startup times also meant quicker recovery from failures, a crucial aspect of maintaining a reliable service. gdocweb Implementing GraalVM Getting GraalVM to work was nontrivial but not too hard. After some trial and error, I managed to set up a process that built the GraalVM project and uploaded it to Docker. This was particularly necessary because I'm using an M2 Mac, while my server runs on Intel architecture. This setup meant I had to deal with an 18-minute wait time for each update – a significant delay for any development cycle. Continuous Integration (CI) Facing the Production Challenges Things started getting rocky when I started to test the project production and staging environments. It became a 'whack-a-mole' scenario with missing library code from the native image. Each issue fixed seemed to only lead to another, and the 18-minute cycle for each update added to the frustration. The final straw was realizing the incompatibility issues with Google API libraries. Solving these issues would require extensive testing on a GraalVM build, which was already burdened by slow build times. For a small project like mine, this became a bottleneck too cumbersome to justify the benefits. The Decision to Move On While GraalVM seemed ideal on paper for saving resources, the reality was different. It consumed my limited GitHub Actions minutes and required extensive testing, which was impractical for a project of this scale. Ultimately, I decided to abandon the GraalVM route. If you do choose to use GraalVM, then this was the GitHub Actions script I used. I hope it can help you with your journey: name: Java CI with Maven

on:
  push:
    branches: [ "master" ]
  pull_request:
    branches: [ "master" ]

jobs:
  build:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:latest
        env:
          POSTGRES_PASSWORD: yourpassword
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
    - uses: actions/checkout@v3
    - uses: graalvm/setup-graalvm@v1
      with:
        java-version: '21'
        version: '22.3.2' 
        distribution: 'graalvm'
        cache: 'maven'
        components: 'native-image'
        native-image-job-reports: 'true'
        github-token: ${{ secrets.GITHUB_TOKEN }}
    - name: Wait for PostgreSQL
      run: sleep 10
    - name: Build with Maven
      run: mvn -Pnative native:compile

    - name: Build Docker Image
      run: docker build -t autosite:latest .

    - name: Log in to Docker Hub
      uses: docker/login-action@v1
      with:
        username: ${{ secrets.DOCKERHUB_USERNAME }}
        password: ${{ secrets.DOCKERHUB_TOKEN }}

    - name: Push Docker Image
      run: |
        docker tag autosite:latest mydockeruser/autosite:latest
        docker push mydockeruser/autosite:latest This configuration was a crucial part of my attempt to leverage GraalVM's benefits, but as the project evolved, so did my understanding of the trade-offs between idealism in technology choice and practicality in deployment and maintenance. Deployment: VPS and Docker Compose When it came to deploying , I had a few paths to consider. Each option came with its pros and cons, but after careful evaluation, I settled on using a Virtual Private Server (VPS) with Docker Compose. Here’s a breakdown of my thought process and why this choice made the most sense for my needs. gdocweb Avoiding Raw VPS Deployment I immediately ruled out the straightforward approach of installing the application directly on a VPS. This method fell short in terms of migration ease, testing, and flexibility. Containers offer a more streamlined and efficient approach. They provide a level of abstraction and consistency across different environments, which is invaluable. Steering Clear of Managed Containers & Orchestration Managed containers and orchestration (e.g., k8s) were another option, and while they offer scalability and ease of management, they introduce complexity in other areas. For instance, when using a managed service it would often mean relying on cloud storage for databases, which can get expensive quickly. My philosophy was to focus on cost before horizontal scale, especially in the early stages of a project. Kubernetes If we don't optimize and stabilize when we're small, the problems will only get worse as we grow. Scaling should ideally start with vertical scaling before moving to horizontal, vertical scaling means more CPU/RAM while horizontal adds additional machines. Vertical scaling is not only more cost-effective but also crucial from a technical standpoint. It makes it easier to identify performance bottlenecks using simple profiling tools. In contrast, horizontal scaling can often mask these issues by adding more instances, which could lead to higher costs and hidden performance problems. The Choice of Docker Compose Docker Compose emerged as the clear winner for several reasons. It allowed me to seamlessly integrate the database and the application container. Their communication is contained within a closed network, adding an extra layer of security with no externally open ports. Moreover, the cost is fixed and predictable, with no surprises based on usage. This setup offered me the flexibility and ease of containerization without the overhead and complexity of more extensive container orchestration systems. It was the perfect middle ground, providing the necessary features without overcomplicating the deployment process. By using Docker Compose, I maintained control over the environment and kept the deployment process straightforward and manageable. This decision aligned perfectly with the overall ethos of – simplicity, efficiency, and practicality. gdocweb Front-End: Thymeleaf Over Modern Alternatives The front-end development of presented a bit of a challenge for me. In an era where React and similar frameworks are dominating the scene, opting for Thymeleaf might seem like a step back. However, this decision was based on practical considerations and a clear understanding of the project's requirements and my strengths as a developer. gdocweb React: Modern but Not a One-Size-Fits-All Solution React is undeniably modern and powerful, but it comes with its own set of complexities. My experience with React is akin to many developers dabbling outside their comfort zone - functional but not exactly proficient. I've seen the kind of perplexed expressions from seasoned React developers when they look at my code, much like the ones I have when I'm reading complex Java code written by others. React’s learning curve, coupled with its slower performance in certain scenarios and the risk of not achieving an aesthetically pleasing result without deep expertise, made me reconsider its suitability for . gdocweb The Appeal of Thymeleaf Thymeleaf, on the other hand, offered a more straightforward approach, aligning well with the project's ethos of simplicity and efficiency. Its HTML-based interfaces, while perhaps seen as antiquated next to frameworks like React, come with substantial advantages: : Thymeleaf provides an easy-to-understand and easy-to-debug flow, making it a practical choice for a project like this. Simplicity in Page Flow : It’s known for its fast performance, which is a significant factor in providing a good user experience. Performance and Speed : Thymeleaf eliminates the need for additional package management, reducing complexity and potential vulnerabilities. No Need for NPM : The server-side nature of Thymeleaf inherently reduces the risk of client-side issues. Lower Risk of Client-Side Vulnerabilities Considering HTMX for Dynamic Functionality The idea of incorporating HTMX for some dynamic behavior in the front-end did cross my mind. HTMX has been on my radar for a while, promising to add dynamic functionalities easily. However, I had to ask myself if it was truly necessary for a tool like , which is essentially a straightforward wizard. My conclusion was that opting for HTMX might be more of Resume Driven Design (RDD) on my part rather than a technical necessity. gdocweb In summary, the choice of Thymeleaf was a blend of practicality, familiarity, and efficiency. It allowed me to build a fast, simple, and effective front-end without the overhead and complexity of more modern frameworks, which, while powerful, weren't necessary for the scope of this project. Final Word The key takeaway in this post is the importance of practicality in technology choices. When we're building our own projects, it's much easier to experiment with newer technologies, but this is a slippery slope. We need to keep our feet grounded in familiar territories while experimenting. My experience with GraalVM highlights the importance of aligning technology choices with project needs and being flexible in adapting to challenges. It’s a reminder that in technology, sometimes the simpler, tried-and-tested paths can be the most effective. Also published . here

Introducing gdocweb: Web Building with Java 21, Spring Boot 3.x, and More

A lot of people ask me why I have not bothered myself with NextJS, Svelte, and a million other cool frameworks out there. I have been building websites for decades, and I have built websites that have been used by millions of users for a long period of time. Some of my websites are 15+ years old. My oldest website is running PHP and uses the Codeigniter framework. All others are in Java and primarily Spring Boot. Why I Prefer Spring Boot There is something called the Lindy effect. Java is as Lindy as things can get in tech. Java has been around for a long time and has solved a lot of problems that many other techs might not even have encountered. Java has been used by large enterprises, small enterprises, startups, and military tech. The thing with Java and Spring Boot is that it is slightly harder to learn them; once you have learned and spent some time with these techs, it is a breeze to develop and change them. The problem with many other technologies is the opposite. They are a breeze to start with, then come some version changes, and suddenly things, break. Angular 1 and Angular 2 are very different. React has undergone similar version changes that have been breaking for many. NextJs recently . This was a major change that became controversial. moved from a “pages” based router to an “app” based router Java, on the other hand, is extremely robust. You can still write code like it is 2016, and it does not matter. You can still use fairly old versions, and it does not really harm you much. Resources Java is arguably the least resource-intensive way to develop applications these days. Rust and Go are supposedly better but are considered exotic. I can scale Java apps for dozens of cloud nodes, and it works just perfectly; sometimes handling 1000s of requests per second. Java’s inbuilt multi-threading system allows you to properly utilize your IO to db, which is very hard to achieve in say, PHP. Java and Spring Boot Are Not Silver Bullets Having said this, I am not saying other frameworks are worthless. It is just the case for the kind of sites I built. I had to scale with a shoestring budget and nonexistent resources to manage resources. I wanted something robust, and Spring Boot was that. But there are perfectly valid reasons to use PHP, Django, Rails, and NextJs. For example, I have found PHP 7+ and Larval to be absolutely brilliant web frameworks. Rails works fantastic for enterprise applications where you have to launch something very very quickly. When Not to Use Spring Boot Do not bother using Spring Boot if you are building something that is unlikely to be turned into a bigger project. For example, your personal website can be hosted using PHP or NextJs. If you want to just serve static content or very minimal server interactions, please consider Laravel or NextJs.

Should You Use Spring Boot for Full-Stack Development?

Microservices (or microservices architecture) is an architectural style for developing applications. When a microservices-based application responds to a user workflow or request, it may call on multiple external microservices (exposed over the internet), which may call on too few internal microservices (not exposed over the internet). Each has a specific concern, which allows an extensive application to be separated into smaller pieces. microservice Authentication and Authorization in Microservices When moving to microservices, securing the microservices needs to be undertaken differently than a monolithic application. A monolith application has a single-user session context shared by all internal components. An architecture based on microservices does not share user context across them, so sharing it requires explicit communication between microservices. A combination of Authentication (AuthN) and Authorization (AutZ) is commonly used to secure applications. – verifies that you are who you claim to be. AuthN – whether the user can access information or execute the operation. AuthZ Recently, I was developing an authorization workflow for a set of microservices, and the challenge was: - 1.	How to enable role-based authorization per API? 2.	How to propagate roles received from external microservice to internal microservice? In this article, we will see how I solved these two problems by developing: - 1.	Custom annotation using AspectJ 2.	Custom request filter and client interceptor using Spring framework Let’s get started! What is our Problem? I created a data flow diagram (Figure 1) to explain the problem. There is one UI application, making calls to external microservices and these calls may also be served by other internal microservices. The session manager’s service responsibility is to log in to the user, store the session, and call the AuthZ service. AuthZ service calls the user subscription service to get logged-in user roles. AuthZ service returns the role to the session manager service, and these roles are passed (in the header as JSON array) to all backend external microservices per API call. Session manager service attaches one request HTTP header “ ” to all API requests. X-Application-Roles Example : X-Application-Roles  : ["GLOBAL_ADMIN", “TENANT_ADMIN”, “APPLICATION_USER”] When an API request has this header with given values, it says that the logged-in user ID has these roles assigned per application subscription. What is our solution? Coming next to original problem statements:- How do we enable role-based authorization per API? I tried the following approaches to solve this problem: - Create a separate microservice to check whether roles coming in the X-Application-Roles header have the role needed to make this API call and use this microservice call in each API request. Create a custom roles annotation and use this annotation in all backend APIs I decided to proceed with the second approach as I needed to resolve roles for 30+ backend APIs and the first approach was introducing another hop with each API request. How do we propagate roles received from external microservice to internal microservice? The solution to the first problem is well suited for external microservices as they were directly receiving the X-Application-Roles header from requests coming from UI, but the challenge was to propagate this header further to internal microservices and use the same custom role annotation. I tried the following approaches to solve this problem: - Use spring library to propagate custom headers, e.g., spring cloud sleuth Use request and client filter interceptor I decided to proceed with the second approach as I don’t want to introduce another library dependency and extra configuration. Custom roles annotation to annotate backend APIs : Create and enumeration to hold roles and header name: - Step 1 public enum ApplicationRoles { 
  GLOBAL_ADMIN,
  TENANT_ADMIN,
  APPLICATION_USER;
  
  public static final String X_APPLICATION_ROLES_HEADER = "X-Application-Roles";
} : Create an interface that we’ll use as a method-level annotation on Spring boot’s controller’s APIs: - Step 2 @Target(ElementType.METHOD) 
@Retention(RetentionPolicy.RUNTIME) 
public @interface RolesAllowed { 
  ApplicationRoles[] value();
} : Create a custom aspect using the AspectJ library to check whether roles coming in the X-Application-Roles header have the role needed to make this API call. This annotation will serve the API request when roles present in the request header have role applied over API (will show in next step) else it will throw a FORBIDDEN exception. Step 3 @Aspect
public class RolesCheckAspect {
    
    // User your package name where RolesAllowed interface exists
    @Before("@annotation(com.adp.security.auth.RolesAllowed)")
    public void before(JoinPoint joinPoint) throws JsonProcessingException {
        
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        // Get expected Roles from annotation
        Set<ApplicationRoles> expectedRoles = Arrays.stream(methodSignature.getMethod().getAnnotation(RolesAllowed.class).value()).collect(Collectors.toSet());
        // Get all annotations defined in method signature
        Annotation[][] parameterAnnotations = methodSignature.getMethod().getParameterAnnotations();
        // Get actual arguments from the method
        Object[] methodArguments = joinPoint.getArgs();
        // Get actual roles from request
        Set<ApplicationRoles> actualRoles = getActualRoles(parameterAnnotations, methodArguments);
        // Check whether actual roles have expected API role
        if (expectedRoles.stream().noneMatch(actualRoles::contains))
            throw new ForbiddenException(String.format("Required roles are missing in '%s' header", ApplicationRoles.X_APPLICATION_ROLES_HEADER));
    }

    private static Set<ApplicationRoles> getActualRoles(Annotation[][] parameterAnnotations, Object[] methodArguments) throws JsonProcessingException {
        // Get roles header index in annotations
        int rolesHeaderIndex = getRolesHeaderIndex(parameterAnnotations);

        ObjectMapper objectMapper = JsonMapper.builder()
                .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS)
                .build();
        return objectMapper.readValue(String.valueOf(methodArguments[rolesHeaderIndex]), new TypeReference<>() {});
    }

    private static int getRolesHeaderIndex(Annotation[][] parameterAnnotations) {
        record HeaderWithIndex(int index, Optional<RequestHeader> requestHeader){}

        HeaderWithIndex rolesHeader = IntStream.range(0, parameterAnnotations.length)
                .mapToObj(argIndex -> {
                    Optional<RequestHeader> optionalRequestHeader = Arrays.stream(parameterAnnotations[argIndex])
                            .filter(RequestHeader.class::isInstance)
                            .map(RequestHeader.class::cast)
                            .filter(requestHeader -> requestHeader.value().equalsIgnoreCase(ApplicationRoles.X_APPLICATION_ROLES_HEADER))
                            .findFirst();
                    return new HeaderWithIndex(argIndex, optionalRequestHeader);
                })
                .filter(headerWithIndex -> headerWithIndex.requestHeader().isPresent())
                .findFirst()
                .orElseThrow(() -> new BadRequestException(String.format("Required header '%s' is not present", ApplicationRoles.X_APPLICATION_ROLES_HEADER)));

        return rolesHeader.index();
    }
} : Configure RolesCheckAspect bean. This step is necessary when your roles aspect class exists in different library projects. Step 4 @Configuration
public class RestTemplateConfig {
    @Bean
    public RolesCheckAspect rolesCheckAspect() {
           return new RolesCheckAspect();
    }
} :  Use roles annotation over the API Step 5 @GetMapping("/api/v1/hierarchy")
@RolesAllowed(value={ApplicationRoles.APPLICATION_USER})
public ResponseEntity<String> getHierarchy(
                     @RequestHeader(TENANT) String tenant,
                     @RequestHeader(ApplicationRoles.X_APPLICATION_ROLES_HEADER) String roles
) { 
       return ResponseEntity.ok(hierarchyService.getHierarchy(tenant));
} Roles header propagation Roles header propagation from external microservice APIs to internal microservice APIs Now, we have authorization enabled for external microservice; the remaining problem is propagating the X-Application-Roles header to the internal microservice. : Create a class to store roles from incoming API requests. This class will be configured as . Step 1 request scoped bean public class RolesInfo { 
  private String roles;
  
  public String getRoles() {
    return roles;
  }

  public void setRoles(String roles) {
    this.roles = roles;
  }
} : Create a custom request filter to store roles from the header to the RolesInfo object. Step 2 public class RolesFilter implements Filter {
    
    private final RolesInfo rolesInfo;
    
    public RolesFilter(RolesInfo rolesInfo) {
        this.rolesInfo = rolesInfo;
    }
    
    @Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest;
    String roles = httpServletRequest.getHeader(ApplicationRoles.X_APPLICATION_ROLES_HEADER);
    // Setting roles in request scoped bean object
    rolesInfo.setRoles(roles);
    filterChain.doFilter(servletRequest, servletResponse);
  }
} : Create a client interceptor to fetch roles from the request scoped bean and propagate to internal microservice API requests. Step 3 public class RolesInterceptor implements ClientHttpRequestInterceptor { 
  
  private final RolesInfo rolesInfo;
  
  public RolesInterceptor(RolesInfo rolesInfo) {
      this.rolesInfo = rolesInfo;
  }

  @Override
public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
    // Header propagation : Get roles from request scoped bean object and add with header
    String roles = rolesInfo.getRoles();
    request.getHeaders().add(ApplicationRoles.X_APPLICATION_ROLES_HEADER, roles);
    return execution.execute(request, body);
  }
} : Configure request scoped bean and add client interceptor to . Step 4 RestTemplate @Configuration 
public class RestTemplateConfig { 

  @Bean
  public RestTemplate restTemplate() {
      RestTemplate restTemplate = new RestTemplate();
      List<ClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
      if (CollectionUtils.isEmpty(interceptors)) {
          interceptors = new ArrayList<>();
      }
      interceptors.add(new RolesInterceptor(rolesInfo()));
      restTemplate.setInterceptors(interceptors);
      return restTemplate;
  }

  @Bean
  @Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
  public RolesInfo rolesInfo () {
      return new RolesInfo();
  }
} It's better to create a separate library project with roles aspect, request filter, and client interceptor and use it in different microservice code repositories to avoid repeating the same steps and code duplication. Hope you enjoyed reading this article!

Custom Annotation-Based Authorization and Headers Propagation in Spring Boot microservices

In the world of software development, there are many scenarios where it is necessary to model and work with data that does not have its own identity and is not an entity in the strict sense. This data is information that characterizes an aspect of an object or event, and can be used in different contexts. What is a Value Object? Value Object is one of the key design patterns that allows you to model and work with this kind of data. Value Objects are objects whose identity is determined by their values, not by an identifier. They are immutable and do not have their own life cycle, unlike entities that have a unique identifier and can change over time. Why use Value Objects in Spring and Hibernate? In the context of developing applications built on Spring and Hibernate, using Value Objects has many advantages. They make the code more understandable, make maintenance easier, and help improve performance. For example, Value Objects can be used to represent date and time, addresses, geographic coordinates, currency, and other attributes that can be generalized as data that does not have its own identity. The purpose of this article The purpose of this article is to consider the application of the Value Object pattern in the context of applications built using Spring and Hibernate. We'll start by explaining how to create Value Objects in Java, and then look at how they can be integrated into Hibernate for storage in a database. We will also look at methods for transferring and using Value Objects in Spring applications and provide examples and tips on how to use them effectively. Let's start by learning how to model Value Objects in Java and why it's important for your application. Value Object pattern in Java Value Object is an immutable class that wraps a simple value (int, string, bool...) or other Value Objects, while validating input values. You cannot create an instance of Value Object with an invalid input value. A classic example of a Value Object is a phone number. var phoneNumberRaw = "+78005553535";
var phoneNumber = new PhoneNumber("+78005553535"); In the first case, we store the phone number as a String. In the second case, we have a PhoneNumber class, which has some kind of validation. @Value
public class PhoneNumber {
    private static final PhoneNumberUtil PHONE_NUMBER_UTIL = PhoneNumberUtil.getInstance();

    String value;

    public PhoneNumber(String value) {
        this.value = validateAndNormalizePhoneNumber(value);
    }

    private static String validateAndNormalizePhoneNumber(String value) {
        try {
            if (Long.parseLong(value) <= 0) {
                throw new PhoneNumberParsingException("The phone number cannot be negative: " + value);
            }
            final var phoneNumber = PHONE_NUMBER_UTIL.parse(value, "RU");
            final String formattedPhoneNumber = PHONE_NUMBER_UTIL.format(phoneNumber, E164);
            // return the phone in the format 78005553535
            return formattedPhoneNumber.substring(1);
        } catch (NumberParseException | NumberFormatException e) {
            throw new PhoneNumberParsingException("The phone number isn't valid: " + value, e);
        }
    }
} Advantages of using Value Object: Normalization of the value of the Value Object Not all Value Objects normalize values, in our example, all three phone numbers are the same phone number in terms of value: var set = new HashSet<PhoneNumber>();

set.add(new PhoneNumber("+78005553535"));
set.add(new PhoneNumber("78005553535"));
set.add(new PhoneNumber("88005553535"));

assertEquals(1, set.size()); That is, when saving a Value Object, its value is normalized and subsequently compared with other Value Object objects by value. A more secure API. public static User newUser(String phoneNumber,
                           String passportNumber) { … } In this example, you can pass obviously incorrect data to the user creation function and subsequently get a lot of problems. If Value Object is used as parameters, then guaranteed validated data is transmitted. public static User newUser(PhoneNumber phoneNumber,
                           PassportNumber passportNumber) { … } How to implement in Hibernate @Entity
public class User {
    @Id
    private UUID id;

    @Column(name = "phone_number")
    @Convert(converter = PhoneNumberConverter.class)
    private PhoneNumber phoneNumber;
} @Converter
public class PhoneNumberConverter implements AttributeConverter<PhoneNumber, String>{
    public String convertToDatabaseColumn(PhoneNumber attribute) {
        return attribute.getValue();
    }

    public PhoneNumber convertToEntityAttribute(String dbData) {
        return new PhoneNumber(dbData);
    }
} Problems: The problem with the Like request For example, we validate the order name according to the following rules: No more than 70 characters Only English letters and a space Automatic trim() Multiple spaces are converted to one: "Red        chair" -> "Red chair" The Entity code will look like this: @Value
public class OrderName {
  String value;

  public OrderName(String value) {
    this.value = validateOrderName(value);
  }

  private static String validateOrderName(String value) {
    …
  }
} @Entity
public class Order {
     …
    @Convert(converter = OrderNameConverter.class)
    private OrderName name;
} Repository Code: public interface OrderRepository extends JpaRepository<Order, UUID>{
    List<Order> findByNameLike(String name);
} As a result, we get an error: Unexpected exception thrown: org.springframework.dao.InvalidDataAccessApiUsageException: Argument [name%] of type [java.lang.String] did not match parameter type [com.example.domain.OrderName (n/a)] The problem is that for Order.name you can't search by %. The problem is solved using native query: @Query(
    value = "SELECT * FROM order WHERE name LIKE :name",
    nativeQuery = true
)
List<Order> findByNameLike(String name); If the validation/normalization rules have changed, then we cannot subtract the data. The problem can be solved by updating the database of old data, but This is not always acceptable Updates can be non-trivial The solution is apply Value Object only when inserting/changing data. The advantages of this approach: New validation/normalization rules will not break compatibility with existing data The rules are still encapsulated in one place, they are easy to change If we pass a Value Object somewhere, we are sure of the validity of the values based on the compiled requirements Like-the request is working as expected public interface OrderRepository extends JpaRepository<Order, UUID> {
    List<Order> findByNameLike(String name);
} Conclusions Value Object allows you to make the code more secure and easier to maintain Keep in mind that validation changes, but the data remains Apply validation only to the data that you own Value Object can only be used on data that is being added/modified, but not necessarily on readable data.

Value Object Design Pattern in Hibernate/Spring

In our , we looked at running a Spring Boot application on Choreo. We used an in-memory H2 database, which isn't robust enough for a real-world application. For instance, if the application restarts, all the added employee data disappears. In this article, we’ll address how to configure a persistent database, moving our app one step closer to being production-ready. previous article To create the database, I’m using the newly introduced feature in Choreo, which allows you to create MySQL or PostgreSQL databases on any cloud provider of your choice. DB as a Service Creating a Database Navigate to the Choreo Console and go to your Organization’s Home page. Make sure you're in the view that lists all projects in your organization. Select -> from the left menu (this option only appears in the organization’s view). Dependencies Databases It will bring up the following screen. Click ' ' and select a database type. I’ll be using MySQL. Give a name like and click ' '. Create employee-db Next You’ll be prompted to select a cloud provider and a plan. I’ll go with as the Provider and as the plan. Since my application runs in the US region, I’ll choose the for the Database location. Click . Digital Ocean Hobbyist United States Next Your database will now start provisioning, which will take a few minutes. While the database is provisioning, we can make some changes to our Spring Boot application. If you want to follow along, you can get the base version - where we stopped from the previous article. Or you can use if you prefer to skip ahead and go straight to deployment. from here this branch Changing the Spring Boot App Clone the repository and check out the code: git clone git@github.com:jaadds/employee.git

cd employee Since we’re transitioning from an in-memory H2 database, we need to replace the H2 dependency with the MySQL driver in the . pom.xml Replace: <dependency>
	<groupId>com.h2database</groupId>
	<artifactId>h2</artifactId>
	<version>2.2.222</version>
</dependency> with <dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.27</version>
</dependency> Then, you need to add the following properties specifying connection details for your database. Add these to . src/main/resources/application.properties spring.datasource.url=jdbc:mysql://<HOST>:<PORT>/<DEFAULT DATABASE>
spring.datasource.username=<DEFAULT USER>
spring.datasource.password=<PASSWORD>
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver If the database has finished provisioning, you can start the application and verify its connectivity: ./mvnw spring-boot:run Since the database is empty, the GET operation won’t return any results. Instead, try adding an employee with a POST request: curl -H "Content-Type: application/json" -X POST http://localhost:8080/api/employees -d '{"firstName":"Frodo","lastName":"Baggins","email":"frodo@bagend.me"}' If you’re getting a response without errors, then you’ve configured the database correctly. But don’t hastily commit the code just yet. There are a few more changes to be made. Using Environment Variables for Connection Parameters In practice, we don’t commit sensitive details like database connection parameters in plain text. Since they’re in a repository, anyone with access to the repo could then change the database. Instead, we use environment variables as placeholders. We can set these variables in our local environment to get the values resolved properly. Let’s change the application.properties file to use environment variables. In Spring Boot, when you specify a name in the format, the value is read from the environment. Replace our connection details with the following: ${VAR_NAME} spring.datasource.url=jdbc:mysql://${DB_HOST}:${DB_PORT}/${DB_NAME}
spring.datasource.username=${DB_USER}
spring.datasource.password=${DB_PASSWORD} Set the values for these variables in your environment like this: export DB_PORT=<PORT>
export DB_HOST=<HOST>
export DB_NAME=<DEFAULT DATABASE>
export DB_PASSWORD=<PASSWORD>
export DB_USER=<DEFAULT USER> Restart the Spring Boot application and make sure it starts without errors: ./mvnw spring-boot:run Call the GET operation and verify that the application can access the database and return results: curl http://localhost:8080/api/employees Now, you’re ready to commit the changes and push them to your repository. Deploying Changes to Choreo If you’re using a single branch to keep your changes, you can proceed directly to the . In my case, I've used a different branch named to maintain the changes discussed here. So, I need to inform Choreo about this new branch. deployment section database Pointing the new branch (Optional) Go to your component's overview page on Choreo. Select the ' ' dropdown in the top-left corner and click ' '. Deployment Track Create New Choose the branch and enter for the API version, then click ' '. We're effectively creating a new deployment track by pointing to our new branch. This feature allows you to run two versions of the same app simultaneously. Changes in the 'main' branch are exposed as API version 1.0, and changes in the 'database' branch will be under v1.1. You can learn more about this feature . v1.1 Create here Now, if you go to the ' ' page, you'll see changes from the 'Database' branch ready for deployment. Deploy Deploying the App In this section, we’ll continue with deploying the app and look at how to securely set the connection details using the environment variables we defined earlier. Go to the Deploy page and make sure the Build Area shows your latest commit. Click the ' button to start the wizard. The first step is to set environment variables. Configure & Deploy’ Click the ' ' button and input the following environment variables: Add - The database host URL DB_HOST - The database port DB_PORT - The database name DB_NAME - The default username DB_USER - The database password (mark this as a secret) DB_PASSWORD After specifying all the values, click ' ' to proceed through the remaining steps, which we won't need to modify. Finally, click ' ' to initiate the deployment. Next Deploy This will trigger the build and deployment, which will take a couple of minutes to complete. So, while the deployment is in progress, let’s recap what we’ve done. By setting the environment variables, we've specified the connection details for that particular environment. When deploying an app through Choreo, underneath, they get deployed to a Kubernetes cluster. The environment variables we specified, are set in a config map. Since the app and the config map are in the same namespace, these values are available only to that specific app. What about the password? Since we marked it as a secret, Choreo stores it as a Kubernetes secret, and its value is kept in an . Because the app, secret, and ConfigMap are all deployed in the same namespace, only the intended app gets to read the values. Different apps from different organizations cannot read the values just by guessing their names. Azure KeyVault If the deployment is done by now, we can test the app. Testing the App Open the Swagger console and test the API by invoking the operation. Check whether the details you added locally are correctly retrieved. GET /employees !! You've configured the database successfully. Well done In this post, our goal was to add persistence to our application. We connected a DB to our application running on the Development environment. However, when dealing with micro-services, it's common practice to use separate databases for different environments. As an exercise, you can create another database and use it while promoting your app to Production. Let me know how it goes.

Stories, News & Mentions about SPRINGML

Springml’s Stories on HackerNoon