[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"global-header-tutorials-static":3,"article-types-of-dependency-injection-spring":4,"initial-similar-fetch":21},[],{"alias":5,"title":6,"description":6,"content":7,"thumbnail":8,"keywords":9,"categories":16,"tags":19,"createdAt":20},"types-of-dependency-injection-spring","Types of Dependency Injection in Spring Framework","{\"type\":\"doc\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"In this tutorial, we are going to learn different types of DI\"}]},{\"type\":\"bulletList\",\"content\":[{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Constructor Injection\"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Setter Injection\"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Field Injection\"}]}]}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"For more on IoC and DI, explore our other articles.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"marks\":[{\"type\":\"link\",\"attrs\":{\"href\":\"https:\u002F\u002Fcsbyte.com\u002Fblog\u002Fspring-framework-project-for-gradle-with-intellij-idea\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer nofollow\",\"class\":null,\"title\":null}}],\"text\":\"How to create a clean Spring Framework project for Gradle with IntelliJ IDEA\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"marks\":[{\"type\":\"link\",\"attrs\":{\"href\":\"https:\u002F\u002Fcsbyte.com\u002Fblog\u002Fspring-dependency-injection-and-inversion-control\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer nofollow\",\"class\":null,\"title\":null}}],\"text\":\"Dependency Injection (DI) and Inversion of Control (IoC) in Spring\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"marks\":[{\"type\":\"link\",\"attrs\":{\"href\":\"https:\u002F\u002Fcsbyte.com\u002Fblog\u002Fdependency-pull-lookup-spring\",\"target\":\"_blank\",\"rel\":\"noopener noreferrer nofollow\",\"class\":null,\"title\":null}}],\"text\":\"Dependency Pull and Contextualized Dependency Lookup in Spring Framework\"}]},{\"type\":\"heading\",\"attrs\":{\"textAlign\":null,\"level\":2},\"content\":[{\"type\":\"text\",\"text\":\"Constructor Injection\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"In constructor injection, the Spring IoC container injects dependencies via its constructor. The component declares one or more constructors with dependencies as arguments, and IoC injects those dependencies into the component class.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Let's look into the simple Notification System to demonstrate constructor injection. The modern Spring Framework, Spring 4.3+, the \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"@Autowire\"},{\"type\":\"text\",\"text\":\" annotation is optional if the class has a single constructor.\"}]},{\"type\":\"codeBlock\",\"attrs\":{\"language\":\"java\"},\"content\":[{\"type\":\"text\",\"text\":\"package org.csbyte.di;\\n\\n\\nimport org.springframework.context.ApplicationContext;\\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\\nimport org.springframework.context.annotation.ComponentScan;\\nimport org.springframework.context.annotation.Configuration;\\nimport org.springframework.stereotype.Component;\\nimport org.springframework.stereotype.Service;\\n\\npublic class ConstructorDemo {\\n    public static void main(String[] args) {\\n\\n        ApplicationContext container = new AnnotationConfigApplicationContext(NotificationAppConfig.class);\\n        NotificationService manager = container.getBean(NotificationService.class);\\n\\n        manager.sendAlert(\\n                \\\"john.doe@example.com\\\",\\n                \\\"Your package has shipped!\\\"\\n        );\\n    }\\n}\\n\\n@Configuration\\n@ComponentScan\\nclass NotificationAppConfig {\\n    \u002F\u002F Directs Spring to scan the current package for components to instantiate and wire\\n}\\n\\ninterface MessageSender {\\n    void sendNotification(String recipient, String message);\\n}\\n\\n@Component(\\\"emailService\\\")\\nclass EmailService implements MessageSender {\\n    @Override\\n    public void sendNotification(String recipient, String message) {\\n        System.out.println(\\\"Email Sent to \\\" + recipient + \\\": \\\" + message);\\n    }\\n}\\n\\n@Service\\nclass NotificationService {\\n\\n    private final MessageSender emailSender;\\n\\n    public NotificationService(MessageSender emailSender) {\\n        System.out.println(\\\"Executing Constructor Injection for EmailService\\\");\\n        this.emailSender = emailSender;\\n    }\\n\\n    public void sendAlert(String recipientEmail, String message) {\\n        emailSender.sendNotification(recipientEmail, message);\\n    }\\n}\\n\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Here, we are using a single file to use all the classes for simplicity of learning purposes; you can separate them out.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Here, we do have a config class \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"NotificationAppConfig\"},{\"type\":\"text\",\"text\":\"  email service, and a notification serverice class for accessing the email service as a dependency, \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"MessageSender\"},{\"type\":\"text\",\"text\":\"  for abstraction.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Now, let's look into the constructor injection code.\"}]},{\"type\":\"codeBlock\",\"attrs\":{\"language\":\"java\"},\"content\":[{\"type\":\"text\",\"text\":\"public NotificationService(MessageSender emailSender) {\\n        System.out.println(\\\"Executing Constructor Injection for EmailService\\\");\\n        this.emailSender = emailSender;\\n    }\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Here, we haven't used the \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"@Autowire\"},{\"type\":\"text\",\"text\":\" annotation to inject the dependency. \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"@Autowired\"},{\"type\":\"text\",\"text\":\" is optional here because it's the only constructor used inside \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"NotificationService\"},{\"type\":\"text\",\"text\":\" component.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"We can also use it with annotation, as\"}]},{\"type\":\"codeBlock\",\"attrs\":{\"language\":\"java\"},\"content\":[{\"type\":\"text\",\"text\":\"    @Autowired\\n    public NotificationService(@Qualifier(\\\"emailService\\\") MessageSender emailSender) {\\n        System.out.println(\\\"Executing Constructor Injection for EmailService\\\");\\n        this.emailSender = emailSender;\\n    }\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"@Qualifier(\\\"emailService\\\")\"},{\"type\":\"text\",\"text\":\" we  will define the \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"emailService\"},{\"type\":\"text\",\"text\":\" dependency must be injected. We will implement the other services to show how other injections work.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Let's look into why constructor injection is the best option for dependency injection.\"}]},{\"type\":\"bulletList\",\"content\":[{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"It guarantees immutability, i.e, the dependency injection via the constructor can't be changed or altered. If we look into the code, we define the \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"emailSender\"},{\"type\":\"text\",\"text\":\" dependency field as \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"final\"},{\"type\":\"text\",\"text\":\":\"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"private final MessageSender emailSender;\"},{\"type\":\"text\",\"text\":\" \"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Object can't be created without its dependency, which results in the dependency being non-null or it is mandatory. This will lead to no more \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"NullPointerException\"},{\"type\":\"text\",\"text\":\"  in runtime.\"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"As the fields are final, it's thread-safe ie the objects are safer in a concurrent environment. \"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Easity testing as we can simply pass mock dependencies directly into the constructor\"}]}]}]},{\"type\":\"heading\",\"attrs\":{\"textAlign\":null,\"level\":2},\"content\":[{\"type\":\"text\",\"text\":\"Setter Injection\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"In setter dependency injection, the IoC container injects component dependencies via a setter method\"}]},{\"type\":\"codeBlock\",\"attrs\":{\"language\":\"java\"},\"content\":[{\"type\":\"text\",\"text\":\"package org.csbyte.di;\\n\\nimport org.springframework.beans.factory.annotation.Autowired;\\nimport org.springframework.context.ApplicationContext;\\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\\nimport org.springframework.context.annotation.ComponentScan;\\nimport org.springframework.context.annotation.Configuration;\\nimport org.springframework.stereotype.Component;\\nimport org.springframework.stereotype.Service;\\n\\npublic class SetterInjectionDemo {\\n    public static void main(String[] args) {\\n        ApplicationContext container = new AnnotationConfigApplicationContext(NotificationAppConfig.class);\\n        NotificationService manager = container.getBean(NotificationService.class);\\n\\n        manager.sendAlert(\\\"+1-555-0199\\\", \\\"Your package has shipped!\\\");\\n    }\\n}\\n\\n@Configuration\\n@ComponentScan\\nclass NotificationAppConfig {\\n}\\n\\ninterface MessageSender {\\n    void sendNotification(String recipient, String message);\\n}\\n\\n@Component(\\\"smsService\\\")\\nclass SMSService implements MessageSender {\\n    @Override\\n    public void sendNotification(String recipient, String message) {\\n        System.out.println(\\\"SMS Sent to \\\" + recipient + \\\": \\\" + message);\\n    }\\n}\\n\\n@Service\\nclass NotificationService {\\n\\n    private MessageSender smsSender;\\n\\n    @Autowired\\n    public void setSmsSender(MessageSender smsSender) {\\n        System.out.println(\\\"Executing Setter Injection for SMSService\\\");\\n        this.smsSender = smsSender;\\n    }\\n\\n    public void sendAlert(String phoneNumber, String message) {\\n        System.out.println(\\\"\\\\n--- Initiating SMS Broadcast ---\\\");\\n        smsSender.sendNotification(phoneNumber, message);\\n    }\\n}\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"It can be flexible for optional dependencies that can be provided later by calling the setter method.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Another benefit of setter injection is that we can swap dependencies for a different implementation without creating a new instance of the parent component. Here is the example:\"}]},{\"type\":\"codeBlock\",\"attrs\":{\"language\":\"java\"},\"content\":[{\"type\":\"text\",\"text\":\"package org.csbyte.di;\\n\\nimport org.springframework.beans.factory.annotation.Autowired;\\nimport org.springframework.beans.factory.annotation.Qualifier;\\nimport org.springframework.context.ApplicationContext;\\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\\nimport org.springframework.context.annotation.ComponentScan;\\nimport org.springframework.context.annotation.Configuration;\\nimport org.springframework.stereotype.Component;\\nimport org.springframework.stereotype.Service;\\n\\npublic class SetterInjectionDemo {\\n    public static void main(String[] args) {\\n        ApplicationContext container = new AnnotationConfigApplicationContext(NotificationAppConfig.class);\\n        NotificationService manager = container.getBean(NotificationService.class);\\n\\n        \u002F\u002F Initial run using the production SMS service wired by Spring\\n        manager.sendAlert(\\\"+1-555-0199\\\", \\\"Your package has shipped!\\\");\\n\\n        \u002F\u002F Grab a different implementation from the container\\n        MessageSender mockSms = container.getBean(\\\"mockSmsService\\\", MessageSender.class);\\n\\n        \u002F\u002F Swap it on-the-fly without creating a new NotificationService instance!\\n        System.out.println(\\\"\\\\nSwapping implementation to Mock Service...\\\");\\n        manager.setSmsSender(mockSms);\\n\\n        \u002F\u002F Run it again—same parent object, completely different behavior\\n        manager.sendAlert(\\\"+1-555-0199\\\", \\\"Your package has shipped!\\\");\\n    }\\n}\\n\\n@Configuration\\n@ComponentScan\\nclass NotificationAppConfig {\\n}\\n\\ninterface MessageSender {\\n    void sendNotification(String recipient, String message);\\n}\\n\\n@Component(\\\"smsService\\\")\\nclass SMSService implements MessageSender {\\n    @Override\\n    public void sendNotification(String recipient, String message) {\\n        System.out.println(\\\"REAL SMS Sent to \\\" + recipient + \\\": \\\" + message);\\n    }\\n}\\n\\n@Component(\\\"mockSmsService\\\")\\nclass MockSMSService implements MessageSender {\\n    @Override\\n    public void sendNotification(String recipient, String message) {\\n        System.out.println(\\\"MOCK SMS (Simulated) to \\\" + recipient + \\\": \\\" + message);\\n    }\\n}\\n\\n@Service\\nclass NotificationService {\\n\\n    private MessageSender smsSender;\\n\\n    \u002F\u002F Acts as Spring's initial wire-up mechanism, AND our runtime gateway swap\\n    @Autowired\\n    public void setSmsSender(@Qualifier(\\\"smsService\\\") MessageSender smsSender) {\\n        this.smsSender = smsSender;\\n    }\\n\\n    public void sendAlert(String phoneNumber, String message) {\\n        smsSender.sendNotification(phoneNumber, message);\\n    }\\n}\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"This mechanism is useful for a circuit breaker or a failover. In the example, if the primary sms provider fails or goes down, the program can grab the backup service  from the context.\"}]},{\"type\":\"heading\",\"attrs\":{\"textAlign\":null,\"level\":2},\"content\":[{\"type\":\"text\",\"text\":\"Field Injection\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Field injection is a way to inject dependencies directly into our class as fields. We simply annotate the private field with the \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"@Autowired\"},{\"type\":\"text\",\"text\":\" annotation.\"}]},{\"type\":\"codeBlock\",\"attrs\":{\"language\":\"java\"},\"content\":[{\"type\":\"text\",\"text\":\"package org.csbyte.di;\\n\\nimport org.springframework.beans.factory.annotation.Autowired;\\nimport org.springframework.beans.factory.annotation.Qualifier;\\nimport org.springframework.context.ApplicationContext;\\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\\nimport org.springframework.context.annotation.ComponentScan;\\nimport org.springframework.context.annotation.Configuration;\\nimport org.springframework.stereotype.Component;\\nimport org.springframework.stereotype.Service;\\n\\nclass FieldInjectionDemo {\\n    public static void main(String[] args) {\\n        ApplicationContext container = new AnnotationConfigApplicationContext(NotificationAppConfig.class);\\n        NotificationService manager = container.getBean(NotificationService.class);\\n\\n        manager.sendAlert(\\\"device_token_xyz123\\\", \\\"Your package has shipped!\\\");\\n    }\\n}\\n\\n@Configuration\\n@ComponentScan\\nclass NotificationAppConfig {\\n}\\n\\ninterface MessageSender {\\n    void sendNotification(String recipient, String message);\\n}\\n\\n@Component(\\\"pushService\\\")\\nclass PushNotificationService implements MessageSender {\\n    @Override\\n    public void sendNotification(String recipient, String message) {\\n        System.out.println(\\\"Push Notification Sent to device \\\" + recipient + \\\": \\\" + message);\\n    }\\n}\\n\\n@Service\\nclass NotificationService {\\n\\n    \u002F\u002F FIELD INJECTION\\n    \u002F\u002F No constructor, no setter. Spring injects this directly into the\\n    \u002F\u002F private field via reflection after the class is instantiated.\\n    @Autowired\\n    @Qualifier(\\\"pushService\\\")\\n    private MessageSender pushSender;\\n\\n    public void sendAlert(String deviceId, String message) {\\n        System.out.println(\\\"\\\\n--- Initiating Push Notification Broadcast ---\\\");\\n        pushSender.sendNotification(deviceId, message);\\n    }\\n}\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"If you notice here, the dependency field is private. Even if it is private, how does the IoC container inject it? Actually, IoC will use reflection to populate the required dependencies.\"}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"In general, field injection is not recommended.\"}]},{\"type\":\"bulletList\",\"content\":[{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Single Responsibility Principle Violation:  Having more dependencies in a single class component means more responsibility. \"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Losing immutability: The field's injection occurs once the constructor instantiates the class or component; because of this, we can't make the field as \"},{\"type\":\"text\",\"marks\":[{\"type\":\"code\"}],\"text\":\"final\"},{\"type\":\"text\",\"text\":\" .\"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Difficult writing unit tests: The dependencies must be injected manually for the test class.\"}]}]},{\"type\":\"listItem\",\"content\":[{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"Violates Encapsulation: It requires Reflection to inject the values, making it tightly coupled to the Spring container.\"}]}]}]},{\"type\":\"paragraph\",\"attrs\":{\"textAlign\":null},\"content\":[{\"type\":\"text\",\"text\":\"In this tutorial, we learned the different types of DI, the importance of using them, and the disadvantages of each.\"}]}]}","\u002Fuploads\u002Fthumbnails\u002Fafb32399-6dda-41c4-b07c-7decb8257bbb_di_constructor_sette.jpeg",[10,11,12,13,14,15],"coding","spring-boot","ioc","programming","spring","di",[17,18],"Spring Framework","Spring Boot",[14,11],"2026-05-19T17:01:51.972Z",[22,29,35,41,47,53,59,65,71,77,83,89,95],{"alias":23,"title":24,"description":25,"thumbnail":26,"createdAt":27,"tutorialAlias":28,"lessonAlias":28},"springdoc-openapi-swagger-ui-in-spring","Implementing springdoc-openapi swagger ui in Spring Boot application","Adding springdoc-openapi swagger ui in a Spring Boot application","https:\u002F\u002Fapi.csbyte.com\u002Fuploads\u002Feditor\u002F3501ace5-c9b0-4819-8d35-d8714390c075_swagger_product_highlighted.png","2026-06-30T10:39:32.703Z",null,{"alias":30,"title":31,"description":32,"thumbnail":33,"createdAt":34,"tutorialAlias":28,"lessonAlias":28},"spring-boot-multi-stage-build-with-docker","Creating spring boot multi-stage build with docker","How to create a Spring Boot multi-stage build with Docker","\u002Fuploads\u002Fthumbnails\u002F8931e2f7-a669-4fbb-855b-5ebe396f462e_multi-stage-build-docke.jpeg","2026-06-20T06:34:41.356Z",{"alias":36,"title":37,"description":38,"thumbnail":39,"createdAt":40,"tutorialAlias":28,"lessonAlias":28},"configure-profile-in-spring-boot","Configure different spring profiles in spring boot application","Managing Spring Boot profiles for different environments along with Docker","\u002Fuploads\u002Fthumbnails\u002F59a52e59-4b56-469d-8902-41af5e0f13dd_Spring-profil.jpeg","2026-06-20T04:51:27.098Z",{"alias":42,"title":43,"description":44,"thumbnail":45,"createdAt":46,"tutorialAlias":28,"lessonAlias":28},"global-exception-handling-in-spring-boot","Implementing Robust Global Exception Handling in Spring Boot","How to Handle Errors in Spring Boot: An Architectural Guide","https:\u002F\u002Fapi.csbyte.com\u002Fuploads\u002Feditor\u002F554489e1-d142-4ea5-a393-994a13d7b113_exception-handling.png","2026-06-12T17:15:16.253Z",{"alias":48,"title":49,"description":50,"thumbnail":51,"createdAt":52,"tutorialAlias":28,"lessonAlias":28},"spring-boot-create-libraries-gradle","Building Reusable Spring Boot Libraries with Gradle","Architectural Guide: Building Reusable Spring Boot Libraries with Gradle","https:\u002F\u002Fapi.csbyte.com\u002Fuploads\u002Feditor\u002Ff4fb088d-1018-4d2b-ae6c-cdd5d0fd60ae_spring-Initializr.png","2026-06-12T15:55:20.994Z",{"alias":54,"title":55,"description":56,"thumbnail":57,"createdAt":58,"tutorialAlias":28,"lessonAlias":28},"multi-build-project-gradle-spring-boot","Setting up a multi-project build in Gradle for Spring Boot","How to set up a multi-project build in Gradle for Spring Boot","https:\u002F\u002Fapi.csbyte.com\u002Fuploads\u002Feditor\u002Fd43933e4-a7a3-404b-a300-8f02db98f549_multi-build-project.png","2026-06-12T04:15:23.045Z",{"alias":60,"title":61,"description":62,"thumbnail":63,"createdAt":64,"tutorialAlias":28,"lessonAlias":28},"java-version-mismatch-gradle","Java Version Mismatch for Gradle Build","How to Fix Gradle Error: Dependency requires at least JVM runtime version 17. This build uses a Java 8 JVM","\u002Fuploads\u002Fthumbnails\u002Fa4c6c910-5623-4db9-93f5-a515135adb99_gradle_version_mismatc.jpeg","2026-06-09T12:15:21.729Z",{"alias":66,"title":67,"description":68,"thumbnail":69,"createdAt":70,"tutorialAlias":28,"lessonAlias":28},"constructor-confusion-in-spring","Constructor Confusion in Spring Framework","Constructor Confusion and how to handle it in Spring Framework","\u002Fuploads\u002Fthumbnails\u002Fd0f09fc0-e1f9-49d1-bf9a-7d1c41050196_di_confusio.jpeg","2026-05-21T14:13:31.437Z",{"alias":72,"title":73,"description":74,"thumbnail":75,"createdAt":76,"tutorialAlias":28,"lessonAlias":28},"dependency-pull-lookup-spring","Dependency Pull and Contextualized Dependency Lookup in Spring Framework","Dependency Pull and Contextualized Dependency Lookup IoC Types in Spring Framework","\u002Fuploads\u002Fthumbnails\u002Fd1132443-313b-4dce-b713-55f356ef6051_depndency_pull.png","2026-05-20T15:26:06.494Z",{"alias":78,"title":79,"description":80,"thumbnail":81,"createdAt":82,"tutorialAlias":28,"lessonAlias":28},"spring-framework-project-for-gradle-with-intellij-idea","How to create a clean Spring Framework project for Gradle with IntelliJ IDEA","Create a clean Spring Framework project for Gradle with IntelliJ IDEA","https:\u002F\u002Fapi.csbyte.com\u002Fuploads\u002Feditor\u002F0e4abad5-17e2-4311-8cf0-7d8f67af975a_spring-framework.png","2026-05-19T10:28:20.866Z",{"alias":84,"title":85,"description":86,"thumbnail":87,"createdAt":88,"tutorialAlias":28,"lessonAlias":28},"spring-dependency-injection-and-inversion-control","Dependency Injection (DI) and Inversion of Control (IoC) in Spring","Mastering Dependency Injection (DI) and Inversion of Control (IoC) in Spring: A Practical Guide for Building a Notification System","\u002Fuploads\u002Fthumbnails\u002F53c64b94-f188-40b4-9ae9-ad97612d688b_spring_d.jpeg","2026-05-19T05:31:45.138Z",{"alias":90,"title":91,"description":92,"thumbnail":93,"createdAt":94,"tutorialAlias":28,"lessonAlias":28},"setting-nginx-ssl-for-spring-boot-application","Setup Nginx and SSL for Spring Boot Application","Setting Nginx as a reverse proxy in our Spring Boot application","\u002Fuploads\u002Fthumbnails\u002F5433c987-9e86-4d90-9cce-a831d1598ba4_spring-boot-nginx.png","2026-05-04T05:36:23.075Z",{"alias":96,"title":97,"description":98,"thumbnail":99,"createdAt":100,"tutorialAlias":28,"lessonAlias":28},"deploy-spring-boot-application-with-docker","Deploy Spring Boot Application with Docker on Ubuntu Server","The ultimate guide to deploying our Spring Boot application with Docker on an Ubuntu server","https:\u002F\u002Fapi.csbyte.com\u002Fuploads\u002Feditor\u002F55a11844-d1e9-4e83-80e5-c6bb6df7d58b_intellij-idea-build.png","2026-05-03T05:58:55.642Z"]