{"id":55734,"date":"2022-11-07T14:06:34","date_gmt":"2022-11-07T08:36:34","guid":{"rendered":"https:\/\/www.tothenew.com\/blog\/?p=55734"},"modified":"2022-11-25T09:58:15","modified_gmt":"2022-11-25T04:28:15","slug":"getting-started-with-spring-boot","status":"publish","type":"post","link":"https:\/\/www.tothenew.com\/blog\/getting-started-with-spring-boot\/","title":{"rendered":"Getting Started with Spring Boot"},"content":{"rendered":"

What is Spring Boot?<\/h2>\n

Spring Boot is now an open-source Java-Based framework to create standalone <\/span>microservices<\/strong>\u00a0with production-ready features. It is heavily maintained by the Pivotal team.\u00a0<\/span>Microservices<\/strong> is an architectural design that creates scalable, loosely coupled, and testable applications with a single function module with a well-defined interface.<\/span><\/p>\n

What is MicroService?<\/h2>\n

MicroService is an architecture that allows developers to develop and deploy services independently. Each service running has its own process, and this achieves the lightweight model to support business applications.<\/span><\/p>\n

Build tools \u2014 Maven and Gradle<\/strong><\/h2>\n

For building heavy projects, there is a need to sagreting code into components so that they can be reused again within the same project or by other projects.<\/p>\n

The components are stored in a location called a repository. These components can be referred to as artifacts when we talk about any build tool.<\/p>\n

    \n
  • Maven<\/strong> is the project management build tool developed by Apache Org, which adds the functionalities of Java libraries through\u00a0dependencies<\/strong>. Maven is a staged-driven build tool, and its lifecycle is divided into stages: validate, compile, test, package, verify, install and deploy. The core component of the Maven project is pom<\/strong>.xml<\/strong>.<\/li>\n
  • Gradle<\/strong> is an open-source build tool that adds functionalities of java libraries through plugins<\/strong>. The lifecycle of the Gradle build is divided into phases, such as initialization, configuration, and execution. The core component of the Gradle project is the build.gradle<\/strong>\u00a0file.<\/li>\n<\/ul>\n

    How does it work? @SpringBootApplication<\/h2>\n

    Spring Boot automatically configures your application based on the dependencies you have added to the project by using\u00a0@EnableAutoConfiguration<\/strong>\u00a0annotation.<\/p>\n

    For example,<\/h4>\n

    If MySQL database is on your classpath, but you have not configured any database connection, then Spring Boot auto-configures an in-memory database.<\/p>\n

    The entry point of the spring boot application is the class containing @SpringBootApplication<\/strong>\u00a0annotation and the main method.<\/p>\n

    Spring Boot automatically scans all the components included in the project by using\u00a0@ComponentScan<\/strong>\u00a0annotation.<\/p>\n

    @SpringBootApplication = @EnableAutoConfiguration + @ComponentScan + @SpringBootConfiguration<\/strong><\/p>\n

    Spring Boot starters<\/strong><\/h1>\n

    Spring Boot provides a number starter pack that can be used while developing an application. These starter packs, when loaded into the classpath, get into action.<\/p>\n

    The spring Boot framework follows the\u00a0spring-boot-starter-*<\/strong> pattern for all its starter packs, where “*” can be replaced with the utility provided.<\/p>\n

    Examples<\/h4>\n

    Look at the following Spring Boot starters explained below for a better understanding \u2212<\/p>\n

      \n
    • Spring Boot Starter Actuator dependency<\/strong>\u00a0is used to monitor and manage your application.<\/li>\n<\/ul>\n

      Its code is shown below \u2212<\/p>\n

           <dependency>\r\n            <groupId>org.springframework.boot<\/groupId>\r\n            <artifactId>spring-boot-starter-actuator<\/artifactId>\r\n     <\/dependency><\/span><\/pre>\n
        \n
      • Spring Boot Starter Security dependency<\/strong>\u00a0is used for Spring Security.<\/li>\n<\/ul>\n
        Its code is shown below \u2212<\/p>\n
             <dependency>\r\n            <groupId>org.springframework.boot<\/groupId>\r\n            <artifactId>spring-boot-starter-security<\/artifactId>\r\n     <\/dependency><\/span><\/pre>\n
          \n
        • Spring Boot Starter web dependency<\/strong> is used to write the Rest Endpoints.<\/li>\n<\/ul>\n
          Its code is shown below \u2212<\/p>\n
               <dependency>\r\n            <groupId>org.springframework.boot<\/groupId>\r\n            <artifactId>spring-boot-starter-web<\/artifactId>\r\n     <\/dependency><\/span><\/pre>\n
            \n
          • Spring Boot Starter Thyme Leaf dependency<\/strong>\u00a0is used to create a web application.<\/li>\n<\/ul>\n
            Its code is shown below \u2212<\/p>\n
                 <dependency>\r\n            <groupId>org.springframework.boot<\/groupId>\r\n            <artifactId>spring-boot-starter-thymeleaf<\/artifactId>\r\n     <\/dependency><\/span><\/pre>\n
              \n
            • Spring Boot Starter Test dependency<\/strong>\u00a0is used for writing Test cases.<\/li>\n<\/ul>\n
              Its code is shown below \u2212<\/p>\n
                   <dependency>\r\n            <groupId>org.springframework.boot<\/groupId>\r\n            <artifactId>spring-boot-starter-test<artifactId>\r\n     <\/dependency><\/span><\/pre>\n
              Auto Configuration<\/h1>\n
              Spring Boot Auto Configuration automatically configures your Spring application based on the JAR dependencies you added to the project. For example, if the MySQL database is on your classpath, but you have not configured any database connection, then Spring Boot auto-configures an in-memory database.<\/p>\n
              For this purpose,<\/h4>\n
              you need to add the @EnableAutoConfiguration annotation or @SpringBootApplication annotation to your main class file.<\/p>\n
              Then, your Spring Boot application will be automatically configured.<\/p>\n
              Observe the following code for a better understanding \u2212<\/p>\n
              import org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.EnableAutoConfiguration;\r\n\r\n@EnableAutoConfigurationpublic \r\nclass DemoApplication {\r\n          public static void main(String[] args) {\r\n                 SpringApplication.run(DemoApplication.class, args);\r\n               }\r\n}<\/span><\/pre>\n
              Spring Boot Application<\/h1>\n
              The entry point of the Spring Boot Application is the class containing @SpringBootApplication annotation. This class should have the main method to run the Spring Boot application. @SpringBootApplication annotation includes Auto- Configuration, Component Scan, and Spring Boot Configuration.<\/p>\n
              If you added the @SpringBootApplication annotation to the class, you do not need to add the @EnableAutoConfiguration, @ComponentScan, and @SpringBootConfiguration annotations. The @SpringBootApplication annotation includes all other annotations.<\/p>\n
              Observe the following code for a better understanding \u2212<\/p>\n
              import org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\n@SpringBootApplicationpublic \r\nclass DemoApplication {\r\npublic static void main(String[] args) {\r\nSpringApplication.run(DemoApplication.class, args);\r\n}\r\n}<\/span><\/pre>\n
              Core Spring framework annotations<\/strong><\/h1>\n
              Bean<\/h4>\n
              @Bean<\/strong> is an annotation that is used on the top of a method and can act as a replacement for the XML <\/bean> element. to declare a bean, simply annotate the method with\u00a0@Bean<\/strong>\u00a0annotation.<\/p>\n
              import org.springframework.boot.SpringApplication;\r\nimport org.springframework.context.annotation.Bean;\r\nimport org.springframework.context.annotation.Configuration;<\/span>@Configuration\r\nclass DemoApplication {\r\n@Bean\r\npublic static void main(String[] args) {\r\nSpringApplication.run(DemoApplication.class, args);\r\n}\r\n}<\/span>}\r\n}<\/span><\/pre>\n
              Autowired<\/h4>\n
              @autowired<\/strong>\u00a0is used to make a\u00a0constructor<\/strong>,\u00a0field<\/strong>, or\u00a0setter<\/strong>\u00a0method to get autowired by Spring DI.\u00a0Dependency Injection<\/strong> is a technique that removes the dependency of a component from the source code so that our code is loosely coupled with the component.<\/p>\n
              import org.springframework.boot.SpringApplication;\r\nimport org.springframework.context.annotation.ComponentScan;<\/span>@ComponentScanpublic \r\nclass DemoApplication {\r\npublic static void main(String[] args) {\r\nSpringApplication.run(DemoApplication.class, args);\r\n}\r\n}<\/span><\/pre>\n
              Component Scan<\/h1>\n
              Spring Boot application scans all the beans and package declarations when the application initializes. You need to add the\u00a0@ComponentScan<\/strong> annotation for your class file to scan the components added to your project.<\/p>\n
              Observe the following code for a better understanding \u2212<\/p>\n
              import org.springframework.boot.SpringApplication;\r\nimport org.springframework.context.annotation.ComponentScan;<\/span>@ComponentScanpublic \r\nclass DemoApplication {\r\npublic static void main(String[] args) {\r\nSpringApplication.run(DemoApplication.class, args);\r\n}\r\n}<\/span><\/pre>\n
              \n
              References<\/strong><\/h1>\n
              tutorialspoint, javatpoint, docs.spring.io, baeldung;<\/p>\n<\/div>\n
              <\/div>\n
              <\/div>","protected":false},"excerpt":{"rendered":"
              What is Spring Boot? Spring Boot is now an open-source Java-Based framework to create standalone microservices\u00a0with production-ready features. It is heavily maintained by the Pivotal team.\u00a0Microservices is an architectural design that creates scalable, loosely coupled, and testable applications with a single function module with a well-defined interface. What is MicroService? MicroService is an architecture that […]<\/p>\n","protected":false},"author":1507,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":5},"categories":[446],"tags":[5041],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/55734"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1507"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=55734"}],"version-history":[{"count":9,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/55734\/revisions"}],"predecessor-version":[{"id":55844,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/55734\/revisions\/55844"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=55734"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=55734"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=55734"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}