6. Spring Configuration Metadata

 

- The Spring IoC (Inversion of Control) container is responsible for managing and controlling the lifecycle of Java objects, also known as beans. 

- Configuration metadata is essential for the Spring IoC container to understand how to create, configure, and manage these beans. 


There are three main ways to provide this configuration metadata:


1. XML-based Configuration:

   - In XML-based configuration, you use XML files to define the configuration metadata for your Spring application.

   - The configuration typically includes information about beans, their dependencies, and how they should be wired together.

   - An example of XML-based configuration:


     

     <!-- applicationContext.xml -->

     <beans xmlns="http://www.springframework.org/schema/beans"

            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

            xsi:schemaLocation="http://www.springframework.org/schema/beans

                                http://www.springframework.org/schema/beans/spring-beans.xsd">


         <bean id="userService" class="com.example.UserService">

             <property name="VariableName" ref="reftoAnotherBean"/>

         </bean>


         <bean id="reftoAnotherBean" class="com.example.UserRepository"/>

     </beans>



2. Annotation-based Configuration:

   - In annotation-based configuration, you use Java annotations to provide the configuration metadata.

   - Annotations like `@Component`, `@Service`, `@Repository`, and `@Autowired` are commonly used.

   - Spring scans the classpath for annotated classes and automatically registers them as beans in the context.

   - Example of annotation-based configuration:


     

     // UserService.java

     @Service

     public class UserService {

         @Autowired

         private UserRepository userRepository;

         // ...

     }


     // UserRepository.java

     @Repository

     public class UserRepository {

         // ...

     }



3. Java-based Configuration:

   - In Java-based configuration, you use Java classes and methods to provide configuration metadata.

   - Typically, a configuration class is annotated with `@Configuration`, and methods within the class annotated with `@Bean` define beans.

- Using @Configuration annotation indicates that Spring IoC container can use it as a source of Beans definitions. 

- Using the @Bean tells Spring that method will return an object which should be registered as a bean in Spring application context.

   - Example of Java-based configuration:



     // AppConfig.java

     @Configuration

     public class AppConfig {

         @Bean

         public UserService userService() {

             UserService userService = new UserService();

             userService.setUserRepository(userRepository());

             return userService;

         }


         @Bean

         public UserRepository userRepository() {

             return new UserRepository();

         }

     }

     



   - In this example, the `@Configuration` annotation indicates that the class contains Spring configuration. The `@Bean` annotation on methods indicates that the methods will return a bean managed by the Spring IoC container.



Comments

Post a Comment

Popular posts from this blog

11. Spring MVC @RequestMapping

  Spring MVC @RequestMapping In spring MVC @RequestMapping plays the role of mapping URL to the method of controller class. In Spring MVC application we generally use a URL which calls the Controller. In the Controller to map a given URL we use @RequestMapping annotation. RequestMapping can be used in many ways. 1. RequestMapping at Class Level 2. RequestMapping only at Method level 3. @RequestMapping annotations at class level as well as method levels 4. RequestMapping using HTTP methods 5. @RequestMapping with @RequestParam 6. @RequestMapping with @PathVariable 1. RequestMapping at Class Level @RequestMapping can be added at class Level. This way the URI provided will act as base URI for all other methods in the Controller class. @Controller @RequestMapping(value = "/employee") public class EmployeeController { // Methods.... } Now any requests with /employee as URL will hit this Controller class. 2. RequestMapping only at Method level @RequestMapping is optional for class ...
Read more

2. Spring Framework Module (Architecture)

Image
  Spring Framework Architecture The Spring Framework is a comprehensive framework for enterprise Java development. It provides a modular and organized way to build enterprise-level applications. The framework is divided into several modules, each addressing specific concerns.  Types  1. The Core Container: 2. Data Access / Integration 3. The Web   4. Miscellaneous (AOP)   1. Spring Core Container:    CORE: This module provides the fundamental parts of the framework,  its including the IoC (Inversion of Control) container and Dependency Injection features.   BEAN : It deals with the creation and management of Java objects (beans) and their dependencies.A sophisticated implementation of factory pattern called BeanFactory, is provided by, Bean module. CONTEXT : This module builds on the core and beans modules, providing a way to access application objects and services in a consistent manner. It has access rights for any objects that de...
Read more

10. Spring - MVC Framework

Image
  Introduction to Spring MVC Framework - Spring MVC is used to develop the web applications that uses MVC design pattern. By using Spring MVC we can build flexible and loosely coupled web applications. - The MVC design pattern helps in seperating the business logic, presentation logic and controller logic. - Models are responsible for encapsulating the application data.  - The Views render response to the user with the help of the model object .  - Controllers are responsible for receiving the request from the user and calling the back-end services. Spring MVC will make application development faster, cost effective and flexible. Advantage of Spring MVC Framework - Clear separation of responsibilities because it implements MVC design pattern. - Loose coupling among Model, View and Controller. - Inbuilt front controller. - Simplified Validation implementation. - Simplified Exception Handling. - Internationalization logic is simplified compared to other frameworks. - Spring...
Read more