{"id":3401,"date":"2024-09-19T10:52:12","date_gmt":"2024-09-19T08:52:12","guid":{"rendered":"https:\/\/nguenkam.com\/blog\/?p=3401"},"modified":"2024-09-20T15:15:02","modified_gmt":"2024-09-20T13:15:02","slug":"introduction-to-java-spring-boot-part-i","status":"publish","type":"post","link":"https:\/\/nguenkam.com\/blog\/index.php\/2024\/09\/19\/introduction-to-java-spring-boot-part-i\/","title":{"rendered":"Introduction to Java Spring Boot (Part I)"},"content":{"rendered":"\n

Spring Boot is a framework that simplifies the development of Java applications by providing a convention-over-configuration approach and reducing boilerplate code. It is particularly useful for creating microservices and RESTful web services. In this introduction, we will cover some important annotations and concepts in Spring Boot, while also drawing comparisons to Angular.<\/p>\n\n\n\n

Example Application<\/h4>\n\n\n\n

Here is a simple example of a Spring Boot application that implements a REST controller.<\/p>\n\n\n\n

import org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.web.bind.annotation.GetMapping;\nimport org.springframework.web.bind.annotation.RestController;\n\n@SpringBootApplication\npublic class DemoApplication {\n    public static void main(String[] args) {\n        SpringApplication.run(DemoApplication.class, args);\n    }\n}\n\n@RestController\nclass HelloController {\n    @GetMapping(\"\/hello\")\n    public String hello() {\n        return \"Hello, World!\";\n    }\n}<\/code><\/pre>\n\n\n\n
1. How Does the Spring Container Work?<\/h4>\n\n\n\n
The Spring Container manages the lifecycle of beans, which are created through Dependency Injection (DI). It is responsible for instantiating, configuring, and managing objects called beans. The container uses configuration metadata to determine how beans are created and wired together.<\/p>\n\n\n\n
2. What is ApplicationContext in Relation to the Spring Container?<\/h4>\n\n\n\n
ApplicationContext is an extension of the Spring Container that provides additional features such as event propagation, message source management, and support for internationalization. It serves as the central interface for the Spring IoC Container, allowing for the management of beans and their dependencies.<\/p>\n\n\n\n
import org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.CommandLineRunner;\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.stereotype.Component;\n\n@SpringBootApplication\npublic class MyApplication {\n    public static void main(String[] args) {\n        SpringApplication.run(MyApplication.class, args);\n    }\n}\n\n@Component\nclass MyCommandLineRunner implements CommandLineRunner {\n\n    @Autowired\n    private ApplicationContext applicationContext;\n\n    @Override\n    public void run(String... args) throws Exception {\n        \/\/ Fetching a bean from the application context\n        MyService myService = applicationContext.getBean(MyService.class);\n        myService.performAction();\n    }\n}\n\n@Component\nclass MyService {\n    public void performAction() {\n        System.out.println(\"Service action performed!\");\n    }\n}\n<\/code><\/pre>\n\n\n\n
Here\u2019s a code example demonstrating how to use the ApplicationContext<\/code> in a Spring Boot application:<\/p>\n\n\n\n
Example Code<\/h5>\n\n\n\n
import org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.CommandLineRunner;\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.context.ApplicationContext;\nimport org.springframework.stereotype.Component;\n\n@SpringBootApplication\npublic class MyApplication {\n    public static void main(String[] args) {\n        SpringApplication.run(MyApplication.class, args);\n    }\n}\n\n@Component\nclass MyCommandLineRunner implements CommandLineRunner {\n\n    @Autowired\n    private ApplicationContext applicationContext;\n\n    @Override\n    public void run(String... args) throws Exception {\n        \/\/ Fetching a bean from the application context\n        MyService myService = applicationContext.getBean(MyService.class);\n        myService.performAction();\n    }\n}\n\n@Component\nclass MyService {\n    public void performAction() {\n        System.out.println(\"Service action performed!\");\n    }\n}<\/code><\/pre>\n\n\n\n
Explanation of the Code<\/h5>\n\n\n\n
  1. @SpringBootApplication<\/code><\/strong>: This annotation marks the main class of the Spring Boot application, enabling auto-configuration and component scanning.<\/li>
  2. MyApplication<\/code><\/strong>: This is the main class that starts the Spring Boot application using SpringApplication.run()<\/code>.<\/li>
  3. @Component<\/code><\/strong>: The MyCommandLineRunner<\/code> class is annotated with @Component<\/code>, making it a Spring-managed bean. It will be automatically detected and registered in the application context.<\/li>
  4. CommandLineRunner<\/code><\/strong>: This interface allows you to run specific code after the Spring application context is loaded. The run<\/code> method is overridden to define what should happen at startup.<\/li>
  5. @Autowired<\/code><\/strong>: This annotation is used to inject the ApplicationContext<\/code> into the MyCommandLineRunner<\/code> bean. Spring will automatically provide the application context when this bean is created.<\/li>
  6. ApplicationContext<\/code><\/strong>: This is the central interface to the Spring IoC (Inversion of Control) container. It holds references to all the beans in the application. In this example, it is used to retrieve a specific bean (MyService<\/code>).<\/li>
  7. getBean(MyService.class)<\/code><\/strong>: This method is called on the ApplicationContext<\/code> to fetch an instance of MyService<\/code>. The class type is provided as an argument.<\/li>
  8. MyService<\/code><\/strong>: This is another Spring-managed bean that contains a method performAction()<\/code>. When called, it prints a message to the console.<\/li><\/ol>\n\n\n\n
    When we run this application, the MyCommandLineRunner<\/code> will execute at startup, fetching the MyService<\/code> bean from the application context and calling its performAction()<\/code> method. This demonstrates how to use the ApplicationContext<\/code> to manage and access beans in a Spring Boot application.<\/p>\n\n\n\n
    3. What is BeanPostProcessor in Spring Boot? Is There a Similar Mechanism in Angular?<\/h4>\n\n\n\n
    BeanPostProcessor<\/code> is an interface that allows for custom logic to be applied before and after the initialization of a bean. In Angular, there isn’t a direct equivalent, but similar concepts can be achieved through lifecycle hooks like ngOnInit<\/code>.<\/p>\n\n\n\n
    import org.springframework.beans.BeansException;\nimport org.springframework.beans.factory.config.BeanPostProcessor;\nimport org.springframework.boot.CommandLineRunner;\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.stereotype.Component;\n\n@SpringBootApplication\npublic class MyApplication {\n    public static void main(String[] args) {\n        SpringApplication.run(MyApplication.class, args);\n    }\n\n    @Bean\n    public MyService myService() {\n        return new MyService();\n    }\n\n    @Bean\n    public BeanPostProcessor myBeanPostProcessor() {\n        return new MyBeanPostProcessor();\n    }\n}\n\nclass MyService {\n    private String name;\n\n    public void setName(String name) {\n        this.name = name;\n    }\n\n    public String getName() {\n        return name;\n    }\n}\n\n@Component\nclass MyBeanPostProcessor implements BeanPostProcessor {\n\n    @Override\n    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {\n        if (bean instanceof MyService) {\n            ((MyService) bean).setName(\"Initialized Service\");\n            System.out.println(\"Before Initialization: Setting name for MyService\");\n        }\n        return bean;\n    }\n\n    @Override\n    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {\n        if (bean instanceof MyService) {\n            System.out.println(\"After Initialization: MyService is ready to use\");\n        }\n        return bean;\n    }\n}\n\n@Component\nclass MyCommandLineRunner implements CommandLineRunner {\n\n    private final MyService myService;\n\n    public MyCommandLineRunner(MyService myService) {\n        this.myService = myService;\n    }\n\n    @Override\n    public void run(String... args) throws Exception {\n        System.out.println(\"Running MyService with name: \" + myService.getName());\n    }\n}\n<\/code><\/pre>\n\n\n\n
    Explanation of the Code<\/h5>\n\n\n\n
    1. @SpringBootApplication<\/code><\/strong>: This annotation marks the main class of the Spring Boot application, enabling auto-configuration and component scanning.<\/li>
    2. MyApplication<\/code><\/strong>: The main class that starts the Spring Boot application using SpringApplication.run()<\/code>.<\/li>
    3. @Bean<\/code><\/strong>: The myService<\/code> method defines a bean of type MyService<\/code>. This bean will be managed by the Spring container.<\/li>
    4. MyService<\/code><\/strong>: A simple service class with a property name<\/code> and corresponding getter and setter methods.<\/li>
    5. MyBeanPostProcessor<\/code><\/strong>: This class implements the BeanPostProcessor<\/code> interface, which allows you to modify beans before and after their initialization.
      • postProcessBeforeInitialization<\/code><\/strong>: This method is called before a bean’s initialization callback (like @PostConstruct<\/code>). In this example, it checks if the bean is an instance of MyService<\/code> and sets its name to “Initialized Service”. It also prints a message indicating that the name is being set.<\/li>
      • postProcessAfterInitialization<\/code><\/strong>: This method is called after the bean’s initialization. It checks if the bean is an instance of MyService<\/code> and prints a message indicating that the service is ready to use.<\/li><\/ul><\/li>
      • MyCommandLineRunner<\/code><\/strong>: This component implements CommandLineRunner<\/code>, allowing it to run specific code after the Spring application context is loaded.
        • It receives the MyService<\/code> bean through constructor injection and prints its name when the application starts.<\/li><\/ul><\/li><\/ol>\n\n\n\n
          When you run this application, the MyBeanPostProcessor<\/code> will modify the MyService<\/code> bean during its lifecycle. The output will show the messages from both the postProcessBeforeInitialization<\/code> and postProcessAfterInitialization<\/code> methods, confirming that the name was set before initialization and that the service is ready to use afterward. This demonstrates how BeanPostProcessor<\/code> can be used to customize bean initialization in a Spring Boot application.<\/p>\n\n\n\n
          4. Field Injection<\/h4>\n\n\n\n
          Field Injection is a method of Dependency Injection where dependencies are directly injected into the fields of a class, typically using the @Autowired<\/code> annotation.<\/p>\n\n\n\n
          @Component\npublic class MyService {\n    @Autowired\n    private MyRepository myRepository;\n}\n<\/code><\/pre>\n\n\n\n
          5. Scope (singleton, prototype, session, request)<\/h4>\n\n\n\n
          • Singleton<\/strong>: A single instance per Spring Container (default).<\/li>
          • Prototype<\/strong>: A new instance for each request.<\/li>
          • Session<\/strong>: An instance per HTTP session.<\/li>
          • Request<\/strong>: An instance per HTTP request.<\/li><\/ul>\n\n\n\n
            6. CommandLineRunner<\/h4>\n\n\n\n
            CommandLineRunner<\/code> is an interface that provides a method to be executed on application startup.<\/p>\n\n\n\n
            import org.springframework.boot.CommandLineRunner;\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.stereotype.Component;\n\n@SpringBootApplication\npublic class MyApplication {\n    public static void main(String[] args) {\n        SpringApplication.run(MyApplication.class, args);\n    }\n}\n\n@Component\nclass MyCommandLineRunner implements CommandLineRunner {\n\n    @Override\n    public void run(String... args) throws Exception {\n        System.out.println(\"CommandLineRunner is executed on application startup\");\n        \/\/ Hier k\u00f6nnen Sie Initialisierungslogik hinzuf\u00fcgen\n    }\n}\n<\/code><\/pre>\n\n\n\n
            Explanation of the CommandLineRunner Code<\/h5>\n\n\n\n
            • CommandLineRunner<\/code><\/strong>: This interface provides a single method, run<\/code>, which is called after the application context is loaded and right before the application starts. You can use this method to execute logic that needs to run at startup, such as initializing data or performing setup tasks.<\/li>
            • @SpringBootApplication<\/code><\/strong>: This annotation marks the main class of a Spring Boot application. It combines several annotations, including @Configuration<\/code>, @EnableAutoConfiguration<\/code>, and @ComponentScan<\/code>, which collectively set up the Spring application context.<\/li>
            • @Component<\/code><\/strong>: This annotation indicates that the MyCommandLineRunner<\/code> class is a Spring-managed bean. By marking it as a component, Spring will automatically detect and register it during the component scanning process.<\/li>
            • run(String... args)<\/code><\/strong>: This method takes a variable number of string arguments (typically command-line arguments) and contains the logic that will be executed when the application starts. In this example, it simply prints a message to the console.<\/li><\/ul>\n\n\n\n
              When you run the application, the run<\/code> method of MyCommandLineRunner<\/code> is invoked, and you’ll see the message “CommandLineRunner is executed on application startup” printed in the console. This allows you to perform any necessary initialization or setup tasks right when your application starts.<\/p>\n\n\n\n
              7. HTTP Session in Java<\/h4>\n\n\n\n
              An HTTP session stores data across multiple HTTP requests for a specific user. In Java, this is commonly handled using HttpSessio<\/code>n<\/p>\n\n\n\n
              8. @ComponentScan<\/h4>\n\n\n\n
              @ComponentScan<\/code> instructs the Spring Container to look for beans in specified packages. It is often included in @SpringBootApplication<\/code>.<\/p>\n\n\n\n
              import org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\n\n@Configuration\n@ComponentScan(basePackages = \"com.example.package\")\npublic class AppConfig {\n}\n<\/code><\/pre>\n\n\n\n
              9. @SpringBootApplication<\/h4>\n\n\n\n
              This annotation combines several others, including @Configuration<\/code>, @EnableAutoConfiguration<\/code>, and @ComponentScan<\/code>. It serves as the entry point for a Spring Boot application.<\/p>\n\n\n\n
              import org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\n\n@SpringBootApplication\npublic class MyApplication {\n    public static void main(String[] args) {\n        SpringApplication.run(MyApplication.class, args);\n    }\n}\n<\/code><\/pre>\n\n\n\n
              10. @PostConstruct<\/h4>\n\n\n\n
              The @PostConstruct<\/code> annotation is used to mark a method that should be called after the bean’s construction. This is similar to ngOnInit<\/code> in Angular, where initializations are performed after the component is created.<\/p>\n\n\n\n
              Example:<\/h5>\n\n\n\n
              import javax.annotation.PostConstruct;\nimport org.springframework.stereotype.Component;\n\n@Component\npublic class MyBean {\n    \n    @PostConstruct\n    public void init() {\n        System.out.println(\"Bean is initialized\");\n    }\n}\n<\/code><\/pre>\n\n\n\n
              11. @Qualifier<\/h4>\n\n\n\n
              The @Qualifier<\/code> annotation is used to specify which bean to inject when multiple beans of the same type exist. This is useful for avoiding conflicts.<\/p>\n\n\n\n
              Example:<\/h5>\n\n\n\n
              import org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.beans.factory.annotation.Qualifier;\nimport org.springframework.stereotype.Component;\n\n@Component\npublic class MyService {\n    \n    @Autowired\n    @Qualifier(\"myRepository\")\n    private MyRepository myRepository;\n}\n<\/code><\/pre>\n\n\n\n
              12. @Configuration<\/h4>\n\n\n\n
              The @Configuration<\/code> annotation marks a class that contains bean definitions. These classes are processed by Spring when the application starts.<\/p>\n\n\n\n
              Example:<\/h5>\n\n\n\n
              @Configuration\npublic class AppConfig {\n    @Bean\n    public MyService myService() {\n        return new MyService();\n    }\n}<\/code><\/pre>\n\n\n\n
              The @Configuration<\/code> annotation is commonly used to indicate that a class declares one or more @Bean<\/code> methods. However, there are other annotations that can also be used for similar purposes:<\/p>\n\n\n\n
              • You can use @Component<\/code> to mark a class as a Spring-managed bean. While it doesn’t explicitly declare beans like @Configuration<\/code>, if the class contains @Bean<\/code> methods, Spring will treat it as a configuration class.<\/li>
              • @ComponentScan<\/code><\/strong>: This annotation is used in conjunction with @Configuration<\/code> or @SpringBootApplication<\/code> to specify the packages to scan for Spring components, including configuration classes.<\/li>
              • @EnableAutoConfiguration<\/code><\/strong> : Used in Spring Boot applications, this annotation automatically configures your application based on the dependencies present on the classpath. It can eliminate the need for many explicit @Configuration<\/code> classes.<\/li>
              • @Import<\/code><\/strong>:You can use this annotation to import other configuration classes into a configuration class. This allows you to modularize your configuration.<\/li><\/ul>\n\n\n\n
                @Configuration\n@Import(OtherConfig.class)\npublic class MyConfig {\n    \/\/ Bean definitions\n}\n<\/code><\/pre>\n\n\n\n
                13. @TestConfiguration<\/h4>\n\n\n\n
                The @TestConfiguration<\/code> annotation is used to define test-specific beans. These beans are only available in the test context.<\/p>\n\n\n\n
                Example:<\/h5>\n\n\n\n
                @TestConfiguration\npublic class TestConfig {\n    @Bean\n    public MyService myService() {\n        return Mockito.mock(MyService.class);\n    }\n}<\/code><\/pre>\n\n\n\n
                14. @Bean<\/h4>\n\n\n\n
                The @Bean<\/code> annotation is used to mark a method as a bean that should be managed by Spring.<\/p>\n\n\n\n
                Example:<\/h5>\n\n\n\n
                @Bean\npublic MyRepository myRepository() {\n    return new MyRepository();\n}<\/code><\/pre>\n\n\n\n
                15. @Profile<\/h4>\n\n\n\n
                The @Profile<\/code> annotation is used to activate beans only in specific profiles. This is useful for defining different configurations for development, testing, and production environments.<\/p>\n\n\n\n
                Example:<\/h5>\n\n\n\n
                @Profile(\"dev\")\n@Bean\npublic MyService devService() {\n    return new DevService();\n}\n\n@Profile(\"production\")\n@Bean\npublic MyService prodService() {\n    return new ProdService();\n}<\/code><\/pre>\n\n\n\n
                16. @ActiveProfiles<\/h4>\n\n\n\n
                The @ActiveProfiles<\/code> annotation is used to specify active profiles for tests. This helps control the configuration during testing.<\/p>\n\n\n\n
                Example:<\/h5>\n\n\n\n
                @ActiveProfiles(\"test\")\n@SpringBootTest\npublic class MyServiceTest {\n    \/\/ Test methods\n}<\/code><\/pre>\n\n\n\n
                17. @Primary<\/h4>\n\n\n\n
                The @Primary<\/code> annotation is used to designate a bean as the primary bean when multiple beans of the same type exist. This indicates which bean should be used by default.<\/p>\n\n\n\n
                Example:<\/h5>\n\n\n\n
                @Bean\n@Primary\npublic MyService primaryService() {\n    return new PrimaryService();\n}<\/code><\/pre>\n\n\n\n
                18. @SpringBootTest<\/h4>\n\n\n\n
                The @SpringBootTest<\/code> annotation is used for integration testing in a Spring Boot application. It loads the entire application context.<\/p>\n\n\n\n
                Example:<\/h5>\n\n\n\n
                @SpringBootTest\npublic class ApplicationTests {\n    @Test\n    public void contextLoads() {\n    }\n}<\/code><\/pre>\n\n\n\n
                19. Mockito<\/h4>\n\n\n\n
                Mockito is a popular framework for creating mock objects in tests. It allows you to test components in isolation.<\/p>\n\n\n\n
                Example:<\/h5>\n\n\n\n
                import static org.mockito.Mockito.*;\n\npublic class MyServiceTest {\n    @Test\n    public void testMyService() {\n        LogService mockLogService = Mockito.mock(LogService.class);\n        MyService myService = new MyService(mockLogService);\n\n        \/\/ Test logic\n    }\n}<\/code><\/pre>\n\n\n\n
                20. @ExtendWith<\/h4>\n\n\n\n
                @ExtendWith<\/code> is used in tests to register extensions that provide additional functionalities, such as Mockito or JUnit5-specific extensions.<\/p>\n\n\n\n
                import org.junit.jupiter.api.Test;\nimport org.junit.jupiter.api.extension.ExtendWith;\nimport org.mockito.junit.jupiter.MockitoExtension;\n\n@ExtendWith(MockitoExtension.class)\npublic class MyServiceTest {\n    \n    @Test\n    public void testWithMockito() {\n        \/\/ Test code using Mockito\n    }\n}\n<\/code><\/pre>\n\n\n\n
                <\/p>\n\n\n\n
                Conclusion<\/h5>\n\n\n\n
                In this introduction, we covered the basics of Java Spring Boot and explained some important annotations and concepts. These concepts are essential for developing robust and maintainable applications in Spring Boot and offer many advantages that make development more efficient.<\/p>\n","protected":false},"excerpt":{"rendered":"
                Spring Boot is a framework that simplifies the development of Java applications by providing a convention-over-configuration approach and reducing boilerplate code. It is particularly useful for creating microservices and RESTful web services. In this introduction, we will cover some important annotations and concepts in Spring Boot, while also drawing comparisons to Angular. Example Application Here […]<\/p>\n","protected":false},"author":1,"featured_media":3403,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[554,868],"tags":[876,872,874,879,878,870,881,883],"_links":{"self":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3401"}],"collection":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/comments?post=3401"}],"version-history":[{"count":5,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3401\/revisions"}],"predecessor-version":[{"id":3428,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/posts\/3401\/revisions\/3428"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/media\/3403"}],"wp:attachment":[{"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/media?parent=3401"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/categories?post=3401"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/nguenkam.com\/blog\/index.php\/wp-json\/wp\/v2\/tags?post=3401"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}