Spring Boot Complete Tutorial

Post Updated on | By hanucodes@gmail.com | No comments

Download [PDF | Excel | Images | Spring Boot Project]

Part 1: Spring Boot Introduction – Deployment, Embedded Server, Dependencies, Maven, STS, Run from IDE

ActionHow to do?DetailsImages
Spring vs Spring Boot1. Spring Boot uses Spring internally.
2. Spring Boot makes it easier for users to use Spring
3. Spring Boot is easy to start as reduces configurations
Spring Initializr1. Spring Initializr Project – https://start.spring.io/
2. To create a quick startup project for Spring Boot
3. Uses Maven / Gradle
4. Download the project and import it into IDE
Embeded Server1. Provides and embeded server like Tomcat inside the JAR file
2. JAR File generated will have the – application code + Tomcat		JAR – myapp.jar
  –> myapp code
  –> embedded tomcat
Running Spring Boot Apps1. App JAR can be run in standalone mode like
2. App can also be run from IDE		java – jar myapp.jar
Deployment1. Can be deployed as WAR file in external servers – like Tomcat, Apache etc.
2. In this case the WAR will not have the embeded server since it si not required		TOMCAT external server
  1. WAR – myapp.war –> only myapp code
Dependency JARs1. You can manually download all the dependent JAR files in your Spring boot project
2. However, this will take a lot of manual effort
Maven 1. You can tell Maven the dependencies that you need in your Spring Boot project
2. Maven will automatically download all the dependent JAR files to your project at compile time
STS 4 IDE1. Install JDK 17 or higher
2. Install STS 4 for Eclipse
Spring Boot ProjectFile > New > Spring Starter Project
1. Service URL https://start.spring.io/
2. Project – Maven
3. Language – Java
4. Spring Boot Version – stable version
5. Group / Package (com.helpercodes.demo1)
6. Artifact / Name (myapp)
7. Packaging – JAR
8. Java Version – 17
9. Dependencies – Spring WEB		spring-starter-projecct.png

spring-starter-dependency.png
Spring Boot StartersA collection of Maven dependencies with correct versions that are grouped together.
Project Files1. src/main/java – com.helpercodes.MyappApplication.java
2. pom.xml

Run from IDERun As > Spring Boot App
Application will be started		ide-run-blank-project.png
Access App from BrowserOpen Browser
Hit the app URL – http://localhost:8080/
Likely to see Error since there is no REST controller defined		access-blank-app.png

Part 2: Maven – How Maven works, pom.xml, Spring Dependencies, Project Structure

ActionHow to do?DetailsImages
Maven Use Case1. Project Management tool
2. used for dependency management
3. Maven will automatically download and add the dependent JAR files to the project during compile/run time
4. Manual effort not required
Maven Works?1. Reads your project config file (pom.xml)
2. Checks if the dependent JARs are available locally on your computer in Maven Local Repository
3. If not available, get the dependency JARs from Maven Central Repository Online
4. Saves the dependencies in the Maven Local Repository
5. Makes the dependecies avaialble for compilation and Runs		Maven
1. pom.xml
2. Maven Local Repo
3. Maven Central Repo
4. Build / Run
Secondary Dependencies1. If the dependcies mentioned in you config file pom.xml also need more dependencies
2. Then Maven will also download and pull the secondary dependencies
Class PathsMaven will add JARs automatically to your class path for compile and run
Project Structuremyapp
1. pom.xml  ——————- project config file
2. src/main/java  ————- app java files
3. src/main/resources  ——– app prop / config files
4. src/main/webapp ———— app web files – css,js…
5. src/test/java  ————- unit test code
6. src/test/resources
7. target  ——————– compiled code / artifacts
8. mvnw.cmd 		project structure is standard and portable between IDEs
Project Object Modelpom.xml
1. project meta data
2. dependencies
3. plugins		<project>

  <groupId>…</groupId>
  <artifactId>…</artifactId>
  <version>…</version>

  <dependencies>
    …
    <dependency>
      <groupId>…</groupId>
      <artifactId>…</artifactId>
    </dependency>
    …
  </dependency>

</project>		pom-structure.png
Project IdentificationEvery Project can be uniquely identified by GAV
1. groupId   ————– reverse domain name
2. artifactId  ———— project name
3. version  ————— version number		Example:
groupId – com.helpercodes
artifactId – myapp
version – 1.0
Dependency IdentificationVisit the Maven Central Repository –
https://central.sonatype.com/
All projects with GAV will be listed here and can be used as a depencency		spring-web-dependecy-repo.png
Maven Wrappermvnw.cmd or mvnw.sh File in Project
Automatically downloads latest maven version if not found on system
> mvnw clean compile test

If Maven is already installed, then these files can be ignored
> mvn clean compile test

Part 3: Spring Boot Application – application.properties, Value Injection, Spring Application Run

ActionAnnotationMeaningImages
Spring Boot App@SpringBootApplication
public class MyappApplication {

  public static void main(String[] args) {
    SpringApplication.run(MyappApplication.class, args);
  }

}		@SpringBootApplication – Defines a Spring Boot Application

SpringApplication.run – Runs the Spring Application		spring-app-basic.png
Application Properties FileLocation:
src/main/resources/application.properties

By default created by Initialzr
Loaded by Spring Boot during runtime

1. Can add Spring Boot properties
2. Can add custom properties		Example
1. server.port=8181
2. company.name=Helper Codes
application-properties.png
Value InjectionTo get property value from application.properties file into Class Variable

@Value(“${company.name}”)
private String companyName;		@Value – Pulls a property value from application.properties

company.name=Helper Codes
value-injection.png


value-injection-output.png

Part 4: Spring Boot Basics – Spring Container, Inversion of Control, Dependency Injection, Autowiring

ActionAnnotationMeaningImages
Spring Container Basics1. Spring Container – will work as Object Factory
2. Application code will ask Spring Container to give a Shop Object
3. Spring Container will use some configuration to decide which type of Shop Object to provide – Food Shop | Game Shop | Dress Shop
Spring Container Functions1. Inversion of Control
— create and manager objects

2. Dependency Injection
— provide objects where required
Spring Container ConfigurationAny below config required so that Spring Container can inject correct objects –

1. XML configuration (not used – legacy)
2. Java Annotations
3. Java source Code
Injection Types1. Constructor Injection
— use when you have manadatory dependencies

2. Setter Injection
— use when you haev optional dependencies		@Autowired annotation on constructor is constructor injection

@Autowired annotation on setter is setter injection
AutowiringAutowiring is used for Injecting Objects

1. Spring will try to match the expected object by class / interface
2. The Class must be annotated by @Component
3. Object of this class will be created and injected to the code

Part 5: Spring REST Basics – Rest Controller, Request Mapping, Method Mapping

ActionAnnotationMeaningImages
Rest Controller@RestController
@RequestMapping(“/myapp”)
public class MyRestController {

  @GetMapping(“/”)
  public String sayHello() {
    return “Hello”;
  }

}		@RestController – Defines Class that provides REST Web Service APIs

@RequestMapping – Defines Class level Path for the REST Controller

localhost:8080/myapp/ –> Hello
Rest Controller Endpoints@RestController
@RequestMapping(“/myapp”)
public class MyRestController {

  @GetMapping(“/info”)
  public String sayHello() {
    return “Hello There”;
  }

}		@GetMapping – Defines Method and Path for endpoint GET request

localhost:8080/myapp/info –> Hello		basic-rest-controller.png

basic-rest-output.png

Part 6: Spring Component Annotations – Component, Scanning, Constructor Injection, Setter Injection, Value Injection

ActionAnnotationMeaningImages
Component Scanning@SpringBootApplication – enables the component scanning

Component Scanning will be done in
— same package
— all sub-packages

To enable Component Scan for other package outside,
@SpringBootApplication({“com.thirdpartycode”,”com.test”})		@SpringBootApplication composed of
1. @EnableAutoConfiguration
— spring boot auto config support

2. @ComponentScan
— component scan on current and sub packages

3. @Configuration
— register extra beans with @Bean annotation
— import other config classes
Component Interfacepublic interface Shop {
  public String getShopName();
}		shop-interface.png
Component Implementation 1@Component
public class FoodShop implements Shop {
  
  @Override
  public String getShopName() {
    return “Welcome to Food Shop!”;
  }

}		@Component – Marks the Class as a Spring Bean.
Component class can be injected as a dependency		food-shop-component.png
Rest Controller

Constructor Injection		@RestController
@RequestMapping(“/shop”)
public class ShopRestController {
        
  private Shop myShop;
        
  @Autowired
  public ShopRestController(Shop wiredShop) {
    myShop = wiredShop;
  }
        
  @GetMapping(“/name”)
  public String sayHello() {
    return myShop.getShopName();
  }

}		@AutoWired – Tells Spring Boot to inject the dependency.

Since there is only one implementation of the Component Interface Spring will automatically figure out which Component Type to inject.

What Spring does internally for autowiring?

Shop wiredShop = new FoodShop();

ShopRestController controller = new ShopRestController(wiredShop)

shop-rest-controller.png

food-app-output.png
Rest Controller

Setter Injection		@RestController
@RequestMapping(“/shop”)
public class ShopRestController {
        
  private Shop myShop;

  @Autowired
  public void setShop(Shop wiredShop) {
    this.myShop = wiredShop;
  }
        
  @GetMapping(“/name”)
  public String sayHello() {
    return myShop.getShopName();
  }

}		— Any method name can be used for injecting components

What Spring does internally for autowiring?

Shop wiredShop = new FoodShop();

ShopRestController controller = new ShopRestController();

controller.setShop(wiredShop);
shop-rest-controller-setter-inj.png

food-app-output.png
Rest Controller

Field Injection		@RestController
@RequestMapping(“/shop”)
public class ShopRestController {
        
  @Autowired
  private Shop myShop;
        
  @GetMapping(“/name”)
  public String sayHello() {
    return myShop.getShopName();
  }

}		— Not recommended. Makes code harder to unit test

— Any attribute can be used with @Autowired to inject it as a dependency		shop-rest-controller-field-injection.png

Part 7: Spring Multiple Components – Qualifier, Primary, Lazy Initialization, Global Lazy

ActionAnnotationMeaningImages
Component Implementation 2@Component
public class ElectronicShop implements Shop {

  @Override
  public String getShopName() {
    return “Welcome to Electronic Shop!”;
  }

}
— Multiple Interface implementation

–Spring will throw error

Field myShop in com.helpercodes.shopapp.ShopRestController required a single bean, but 2 were found:
electronic-shop-component.png
Rest Controller

Qualifier based Injection		@RestController
@RequestMapping(“/shop”)
public class ShopRestController {
        
  private Shop myShop;

  @Autowired
  public ShopRestController(
    @Qualifier(“electronicShop”)
    Shop wiredShop) {
      myShop = wiredShop;
  }
        
  @GetMapping(“/name”)
  public String sayHello() {
    return myShop.getShopName();
  }

}		@Qualifier(beanId) – tells Spring which bean to inject as the dependency

beanId is the class name of the Component in camelCase

@Qualifier can be used for both constructor and setter injection		food-app-electronic-output.png

shop-rest-controller-qualifier.png
Component Implementation

Primary		@Component
@Primary
public class FoodShop implements Shop {

  public FoodShop() {
    System.out.println(“Contructing Food Shop”);
  }

  @Override
  public String getShopName() {
    return “Welcome to Food Shop!”;
  }

}		@Primary – tells Spring which is the Primary Component in case of multiple Component implementation

Only one Component from the multiple implementations can be Primary

In this case if Qualifier is not present in the dependency injection, then the primary component will be injected

If Qualifier is present in injection, then Qualifier has higher priority and Qualifier Component will be injected		food-shop-primary.png
Component Implementation

Lazy Initialization		@Component
@Lazy
public class ElectronicShop implements Shop {
        
  public ElectronicShop() {
    System.out.println(“Contructing Electronic Shop”);
  }

  @Override
  public String getShopName() {
    return “Welcome to Electronic Shop!”;
  }

}
Normally, all Components and Beans are initialized suring startup.

@Lazy – tell Spring to initialze the Bean only if it is needed by dependency injection or it is explicitly requested

Since Food Shop is Primary Bean, Electronic Shop will not be initialized auotmatically.		food-shop-lazy.png
Global Lazy Initapplication.properties

spring.main.lazy-initialization=true


1. All Beans will be Lazy initialized.

2. This includes Components and Controllers

3. When the REST endpoint is accessed, then the initialization will happen

4. First Component will be initialized for injection. Then Controller will be initialized and injected

Pro: Helps in fast startup for high number of components

Con: Controller will not be initialized until requested by web page.

Can throw issues like not enough memory in later stage when initialization is required		global-lazy-init.png

Part 8: Spring Beans – Bean Scope, Scope Types

ActionAnnotationMeaningImages
Bean ScopeScope defines lifecycle of the bean

1. Number of instances of the bean created.

2. Time for which the Bean exists

3. Sharing of the Bean
Scope Types1. Singleton
— Only one instance of the Bean is created.
— The instance is saved in memory.
— Same instance is shared and injected for all dependency injections

2. Prototype
— New instance is created for each container request / injection

3. Request
— New instance is created for each HTTP request

4. Session
— New instance is created for each HTTP Session

5. Global Session
— New instance is created for each HTTP Global Session		Default Scope in Spring is Singleton
Rest Controller

Scope Check		@RestController
@RequestMapping(“/shop”)
public class ShopRestController {
        
  private Shop myShop1;
  private Shop myShop2;
        
  @Autowired
  public ShopRestController(
    @Qualifier(“foodShop”) Shop wiredShop1,
    @Qualifier(“foodShop”) Shop wiredShop2) {
                
        System.out.println(“Contructing Shop Rest Controller”);
        myShop1 = wiredShop1;
        myShop2 = wiredShop2;
  }
        
  @GetMapping(“/check”)
  public String cehckScope() {
    if(myShop1==myShop2) {
      return “Singleton Scope”;
    } else {
      return “Prototype Scope”;
    }
  }

}
shop-controller-scope-check.png

singleton-scope-output.png
Scope Prototype@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class FoodShop implements Shop {

  @Override
  public String getShopName() {
    return “Welcome to Food Shop!”;
  }

}		@Scope – defines an explicit scope for the Bean / Component

Prototype beans are lazy by default.

Custom Destroy Method is not called by Spring for Prototype Scope Beans		food-shop-prototype-scope.png

prototype-scope-output.png

Part 9: Spring Beans – Bean LifeCycle, Post Construct, Pre Destroy

ActionAnnotationMeaningImages
Bean Lifecycle1. Spring Container start
2. Bean Instantiation
3. Dependency Injection
4. Internal Spring Processing
5. Custom Init Method
…
6. Container Shutdown
7. Custom Destroy Method
Use CasesCustom Init Method can:
1. call custom business logic for init
2. init resource connections to DB, files etc.

Custom Destroy Method can:
1. call custom business logic for destruction
2. cleanup resource connections to DB, files etc.
Custom Init

Custom Destroy		@Component
public class FoodShop implements Shop {
        
  public FoodShop() {
    System.out.println(“Contructing Food Shop”);
  }
        
  @PostConstruct
  public void initFoodShop() {
    System.out.println(“Initializing Food Shop”);
  }
        
  @PreDestroy
  public void destroyFoodShop() {
    System.out.println(“Destroying Food Shop”);
  }
        
  @Override
  public String getShopName() {
    System.out.println(“Welcome to Food Shop!”);
    return “Welcome to Food Shop!”;
  }

}		@PostConstruct – defines a custom method to call during Bean Initialization

@PreDestroy – defines a custom method to call during Bean Destruction

For prototype scoped beans, Spring does not call the destroy method.		food-shop-custom-init-destroy.png

Part 10: Spring Bean – Bean Implementation, Configuration, Bean Injection

ActionAnnotationMeaningImages
Bean Implementationpublic class CarShop implements Shop {
        
  public CarShop() {
    System.out.println(“Contructing Car Shop”);
  }

  @Override
  public String getShopName() {
    return “Welcome to Car Shop!”;
  }

}		Component Annotation is not used herecar-shop-implementation.png
Bean Configuration@Configuration
public class ShopConfig {
        
  @Bean
  public Shop carShop() {
    return new CarShop();
  }

}		@Configuration – defines Config class to define beans

@Bean – defines the Beaan Implementation class as a Bean

Bean manually constructs the class and returns instance for it.

Bean ID is the method Name by default.
@Bean(“myCustomBean”) => will set bean id as myCustomBean that needs to be used with @Qualifier during dependency injection
shop-configuration.png
Bean Injection@RestController
@RequestMapping(“/shop”)
public class ShopRestController {
  private Shop myShop1;
        
  @Autowired
  public ShopRestController(
    @Qualifier(“carShop”) Shop wiredShop1
  ) {
    System.out.println(“Constructing Shop Rest Controller”);
    myShop1 = wiredShop1;
  }
        
  @GetMapping(“/name”)
  public String sayHello() {
    return myShop1.getShopName();
  }

}
@Qualifier – needs to provide the bean id to be injected
shop-rest-controller-bean-injection.png

car-shop-bean-output.png
Bean Use Case1. To make existing third party class available to Spring
2. No Access to the Source code to mark it as Component
3. But still want to use the class as a Spring Bean
4. This Bean can now be injected in code

Part 11: Spring JPA – Hibernate, Dependencies, Data Source Properties, Command Line Runner

ActionAnnotationMeaningImages
JPAJPA is specification (interface) of API that implements ORM

1. ORM Framework – Object to Relational Mapping
2. Map the Java Object Attributes to Database Columns
Hibernate1. Implementation of JPA specification
2. Vendor implementation in Spring to implement JPA
3. Save / Retrieve Java objects to Database

Spring App –> JPA Spec –> Hibernate Impl –> JDBC –> Database
Dependencies<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
  <groupId>com.h2database</groupId>
  <artifactId>h2</artifactId>
  <scope>runtime</scope>
</dependency>
add the dependencies in pom.xml for data-jpa and the type of database you want to connect.

we will use a H2 database in this case.		pom-db-dependency.png
Datasource Connection Propertiesapplication.properties

spring.datasource.url=jdbc:h2:file:/data/empapp
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
Database connection propertiesapp-properties-db.png
Command Line Application@SpringBootApplication
public class MyappApplication {

  public static void main(String[] args) {
    SpringApplication.run(MyappApplication.class, args);
  }

  @Bean
  public CommandLineRunner commandLineRunner(String[] args) {
    return runner -> {
      System.out.println(“In Command Line Runner”);
    };
  }

}		the command line runner code will run in command line and show output in the command line console

runs code after spring is loaded		cmd-line-app.png

cmd-line-output.png

Part 12: Spring DAO – Object to Relational Mapping ORM, ID GeneratedValue Strategy, Data Access Object DAO, Repository, EntityManager, Transactional

ActionAnnotationMeaningImages
Java Object to Database Mapping
ORM		@Entity
@Table(name=”employee”)
public class Employee {

  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  @Column(name=”id”)
  private int id;

  @Column(name=”display_name”)
  private String displayName;

  @Column(name=”email”)
  private String email;

  public Employee() {}

  //all-arg constructor
  //getters
  //setters
  //to string

}		@Entity – defines the class has a mapping with a Database Table

No Arg constructor is required

@Table – defines the name of the Database Table to which the Java Class maps

@Column – defines the name of the database column to which the Class attribute maps to

@Id – defines the Primary Key / Identity Column  of the Database Table

db-employee.png
ID Generation@GeneratedValue(strategy=GenerationType.AUTO)

@GeneratedValue(strategy=GenerationType.IDENTITY)

@GeneratedValue(strategy=GenerationType.SEQUENCE)

@GeneratedValue(strategy=GenerationType.TABLE)

@GeneratedValue(strategy=GenerationType.UUID)
@GeneratedValue – defines how the ID column values will be generated

IDENTITY – means ID column values are generated by an identity column in the database. They are auto-incremented.

SEQUENCE – means ID column values are generated by a database sequence

TABLE – means ID column values come from a separate database table column defined

UUID – means ID column values will be generated by JPA in UUID format
DAO Basic ArchitectureApp –> DAO –> Entity Manager –> Data Source –> Database
DAO is the Database Access Object Class.

This will use the EntityManager API and interact with Database for CRUD operation
DAO Interface Createpublic interface EmployeeDAO {
        
  void create (Employee employee);

}
emp-dao-create.png
DAO Implementation Create@Repository
public class EmployeeDAOImpl implements EmployeeDAO {

  private EntityManager entityManager;

  @Autowired
  public EmployeeDAOImpl(EntityManager entityManager) {
    this.entityManager = entityManager;
  }

  @Override
  @Transactional
  public void create(Employee employee) {
    entityManager.persist(employee);
  }

}
@Repository – defines class component which is the DAO

@Transactional – defines the method should execute in a atomic transaction.

Autowiring can inject the EntityManager Component in the Repository Constructor		emp-dao-impl-create.png
Runner App Create@Bean
@Autowired
public CommandLineRunner commandLineRunner
    (EmployeeDAO employeeDAO) {

  return runner -> {
    System.out.println(“In Command Line Runner”);
    createEmployee(employeeDAO,
    “Jake Peralta”, “jake.peralta@comedy.com”);
  };
}

private void createEmployee(EmployeeDAO employeeDAO,
    String name, String email) {

  System.out.println(“Create Employee Start”);
  Employee employee = new Employee(name, email);
  employeeDAO.create(employee);
  System.out.println(“Employee Created:”+employee.toString());
}		Autowiring can inject the EmployeeDAO Component in the Command Line Runner Beanemp-create-runner.png

emp-create-output.png
Category: Spring | Tag: , ,

Leave a Reply

Your email address will not be published. Required fields are marked *