Bird
Raised Fist0
Spring Bootframework~10 mins

Project structure walkthrough in Spring Boot - Interactive Code Practice

Choose your learning style10 modes available
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to define the main Spring Boot application class.

Spring Boot
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class [1] {
    public static void main(String[] args) {
        SpringApplication.run([1].class, args);
    }
}
Drag options to blanks, or click blank then click option'
ASpringBootApp
BMainApp
CApplication
DMyApp
Attempts:
3 left
💡 Hint
Common Mistakes
Using a class name that does not match in the run method.
Forgetting the @SpringBootApplication annotation.
2fill in blank
medium

Complete the code to declare a REST controller in Spring Boot.

Spring Boot
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.GetMapping;

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String [1]() {
        return "Hello, World!";
    }
}
Drag options to blanks, or click blank then click option'
AgetHello
Bhello
Cgreet
DsayHello
Attempts:
3 left
💡 Hint
Common Mistakes
Using method names that do not reflect the HTTP method.
Missing the @GetMapping annotation.
3fill in blank
hard

Fix the error in the Spring Boot application.properties file to set the server port.

Spring Boot
server.[1]=8081
Drag options to blanks, or click blank then click option'
Aport
Bhost
Caddress
Durl
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'server.host' instead of 'server.port'.
Setting properties in the wrong file.
4fill in blank
hard

Fill both blanks to create a simple service class and inject it into a controller.

Spring Boot
import org.springframework.stereotype.Service;

@Service
public class [1] {
    public String getMessage() {
        return "Service message";
    }
}

import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
public class MessageController {

    private final [2] service;

    @Autowired
    public MessageController([2] service) {
        this.service = service;
    }

    public String showMessage() {
        return service.getMessage();
    }
}
Drag options to blanks, or click blank then click option'
AMessageService
BMessageController
DHelloService
Attempts:
3 left
💡 Hint
Common Mistakes
Mismatching class names between service and controller.
Forgetting to annotate the service class with @Service.
5fill in blank
hard

Fill all three blanks to define a Spring Data JPA repository interface.

Spring Boot
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface [1] extends JpaRepository<[2], [3]> {
}
Drag options to blanks, or click blank then click option'
AUserRepository
BUser
CLong
DUserService
Attempts:
3 left
💡 Hint
Common Mistakes
Using service class names instead of repository names.
Incorrect generic types in JpaRepository.

Practice

(1/5)
1. In a typical Spring Boot project, where should you place your main application Java files?
easy
A. src/resources/java
B. src/main/resources
C. src/test/java
D. src/main/java

Solution

  1. Step 1: Understand Spring Boot folder roles

    The src/main/java folder is for main Java source code including the application entry point.
  2. Step 2: Identify correct folder for main Java files

    Main application files should not be in resources or test folders, so src/main/java is correct.
  3. Final Answer:

    src/main/java -> Option D
  4. Quick Check:

    Main Java code = src/main/java [OK]
Hint: Main Java code always goes under src/main/java [OK]
Common Mistakes:
  • Confusing resources folder with Java source folder
  • Placing main code in test folder
  • Using incorrect folder names like src/resources/java
2. Which file is commonly used to manage dependencies and build steps in a Spring Boot Maven project?
easy
A. pom.xml
B. application.properties
C. build.gradle
D. settings.xml

Solution

  1. Step 1: Identify build tool for Maven projects

    Maven uses pom.xml to manage dependencies and build configuration.
  2. Step 2: Differentiate from Gradle and config files

    build.gradle is for Gradle, application.properties is for app config, and settings.xml is not for dependencies.
  3. Final Answer:

    pom.xml -> Option A
  4. Quick Check:

    Maven build file = pom.xml [OK]
Hint: Maven uses pom.xml; Gradle uses build.gradle [OK]
Common Mistakes:
  • Confusing application.properties with build files
  • Mixing Gradle and Maven build files
  • Thinking settings.xml manages dependencies
3. Given this Spring Boot project structure snippet, where will the test Java files be located?
src/
  main/
    java/
    resources/
  test/
    java/
    resources/
medium
A. src/main/resources
B. src/test/java
C. src/main/java
D. src/test/resources

Solution

  1. Step 1: Understand test folder purpose

    The src/test/java folder is for Java test source files.
  2. Step 2: Identify test Java files location

    Test Java files go under src/test/java, not in main or resources folders.
  3. Final Answer:

    src/test/java -> Option B
  4. Quick Check:

    Test Java code = src/test/java [OK]
Hint: Test Java files go in src/test/java folder [OK]
Common Mistakes:
  • Putting test Java files in src/main/java
  • Confusing test resources with test Java code
  • Using src/main/resources for tests
4. You accidentally placed your application.properties file inside src/main/java. What problem will this cause?
medium
A. The application will fail to start due to missing config
B. The build will fail with a syntax error
C. The properties file will be ignored and default config used
D. The application.properties will be loaded correctly anyway

Solution

  1. Step 1: Know where Spring Boot loads config files

    Spring Boot loads application.properties from src/main/resources or classpath root.
  2. Step 2: Effect of wrong file location

    If placed in src/main/java, it won't be found and ignored, so defaults apply.
  3. Final Answer:

    The properties file will be ignored and default config used -> Option C
  4. Quick Check:

    Config files must be in resources, else ignored [OK]
Hint: Config files must be in resources folder to load [OK]
Common Mistakes:
  • Assuming app fails to start immediately
  • Thinking build fails due to config file location
  • Believing misplaced properties still load
5. You want to add a new configuration file for your Spring Boot app that should be packaged inside the jar and accessible at runtime. Where should you place this file?
hard
A. src/main/resources/config
B. src/main/java/config
C. src/test/resources/config
D. src/main/resources/static

Solution

  1. Step 1: Understand resource packaging in Spring Boot

    Files in src/main/resources are packaged inside the jar and available at runtime.
  2. Step 2: Choose correct folder for config files

    Config files should be under src/main/resources/config to be included and organized.
  3. Final Answer:

    src/main/resources/config -> Option A
  4. Quick Check:

    Runtime config files go in src/main/resources [OK]
Hint: Put runtime config files in src/main/resources folder [OK]
Common Mistakes:
  • Placing config files in src/main/java which is for code
  • Using test resources folder which is not packaged
  • Putting config in static folder meant for web assets
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard