Please enable JavaScript.

Coggle requires JavaScript to display documents.

Spring Fundamentals - Coggle Diagram

- - - - Bean
        public Store store() {
        Store store = new Store();
        store.setItem(item1());
        return store;
        }
      - optional dependencies
      - Autowired
        public void setFooService(FooService fooService) {
        this.fooService = fooService;
        }
    - - Disavantages
        
        It's really easy to keep adding multiple dependencies using this approach then violating SRP
        
        uses reflection to inject the dependencies, which is costlier than constructor-based or setter-based injection
      - Autowired
        private FooService fooService;
    - - Bean
        public Store store() {
        return new Store(item1());
        }
      - mandatory dependencies
  - - - loads bean definitions and wires them together
      - What is?
      - Fully responsible for the creation of and wiring of the objects that make up the application
- - - - Java Objects initializaed bu the Spring IOC container
    - - Singleton
        
        a single object instance is instantiated once per Spring IoC container.
      - Prototype
        
        A new instance is generated per request
      - Request
      - Session
      - Websocket
      - The default scope is Singleton
      - Application
    - - Ordinary Beans
      - Factory Beans
    - - proxyBeanMethods
    - - is a alias for a bean
      - Component
        Qualifier("cold")
        public class IceCream implements Dessert { ... }
        
        Autowired
        Qualifier("cold")
        public void setDessert(Dessert dessert) {
        this.dessert = dessert;
        }
      - Bean
        Qualifier("cold")
        public Dessert iceCream() {
        return new IceCream();
        }
      - Used when u have multiple implementations of the same interface
    - - Lazy initialization
        
        Set lazy for all beans
        
        [application.yml] spring: main: lazy-initialization: true
        
        [application.properties] spring.main.lazy-initialization=true
        
        Set lazy for all method with Bean within the configuration class
        
        Lazy
        Configuration
        public class AppConfig {}
        
        Only a specific bean
        
        Bean
        Lazy(true)
        public Region getRegion(){
        return new Region();
        }
        
        Advantages
        
        improve the startup time of the application
        
        Disavantages
        
        could mask issues, getting them in run time instead of startup time (memory errors, misconfigurations, or class-definition-found errors)
        
        increase the latency of HTTP requests (will affect only the first request)
      - By default all the defined beans, and their dependencies, are created when the application context is created.
    - - specifying bean dependencies
      - @Bean @DependsOn({"fileReader","fileWriter"}) public FileProcessor fileProcessor(){ return new FileProcessor();}
      - Component
        DependsOn({"filereader", "fileWriter"})
        public class FileProcessor {}