Please enable JavaScript.

Coggle requires JavaScript to display documents.

Spring Framework (Anotations (Java Persistence API(JPA) (@Temporal (used…

- - - - Bean must be populated at configuration time
    - - applied on fields, setter methods, and constructors.
      - @Qualifier
        
        When you need more control of the dependency injection process
      - Injects object dependency implicitly
      - allows to skip configurations elsewhere of what to inject and just does it for you
    - - configuration by itself and will have methods to instantiate and configure the dependencies
      - @ComponentScan
        
        allow Spring to know the packages to scan for annotated components
      - @Bean
        
        works as bean ID and it creates and returns the actual bean
        
        Used at method level
      - used on classes
    - - used on component classes
    - - used at the field, constructor parameter, and method parameter level
      - indicates a default value expression for the field or parameter to initialize the property with
  - - - used on classes to indicate a Spring component
      - @Service
        
        marks a Java class that performs some service, such as execute business logic, perform calculations and call external APIs
      - marks the Java class as a bean or say component
    - - used to identify controllers for Spring MVC or Spring WebFlux
    - - used on Java classes which directly access the database.
  - - - usually placed on the main application class
      - implicitly defines a base “search package”
      - tells Spring Boot to start adding beans based on classpath settings, other beans, and various property settings
    - - used on the application class while setting up a Spring Boot project
      - must be kept in the base package
      - it only does is a component scan
      - it will scan only its sub-packages
      - Equivalent to
        
        @ComponentScan
        
        @EnableAutoConfiguration
        
        @Configuration
  - - - used on Java classes that play the role of controller in your application
      - allows autodetection of component classes in the classpath and auto-registering bean definitions
  - - - used to mark the class as a persistent Java class
    - - used to provide the details of the table that this entity will be mapped to
    - - used to define the primary key
    - - used to define the primary key generation strategy
    - - used to validate that the annotated field is not null or empty
    - - used to define the properties of the column that will be mapped to the annotated field
    - - used with java.util.Calendar
      - used with java.util.Date
      - converts the date and time values from Java Object to compatible database type and vice versa
    - - automatically populate the field when it is created or updated
    - - tells Spring to bootstrap the repository during the component scan
  - - - sets the values to ignore the values given by the clients
    - - used to indicate external property name
      - name used in data format
  - - - @PostMapping
      - @DeleteMapping
      - @GetMapping
      - @PutMapping
      - @PatchMapping
      - Combination of @Controller and @ResponseBody annotations
- - - - Programming Paradigm
      - Derived from Structured Programming
      - based upon the concept of the procedure call
  - - - Removing dependencies from code
      - Dependencies are injected/supplied to "objects"
      - Advantages
        
        Objects can be added and tested independently of other objects using mock objects
        
        Not having own dependency on other object
        
        Allows a client the flexibility of being configurable. Only client's behavior is fixed.
        
        Allows concurrent or independent development
        
        Increased system maintainability
      - Doesn't depend on anything other than you pass them
      - Principle: a dependency should never be made upon a concretion; only upon an abstraction
      - Depend upon abstractions, not upon concretions.
        
        Depends on interface and abstract classes
        
        https://goo.gl/NtZVcS
      - Analogy
        
        Your CD Player stereo is useless without a CD with music on it... (It's dependent on the CD). If they built CD Players with the CD already in it, it would get boring very quickly...
        So they build them so you can "inject" the CD, (on which it is dependent) into the player. That way you can inject a different one each time, and get "different" behavior (music) dependent on which one you inject.
        The only requirement is that the CD must be compatible with the interface defined by the player. (You can't play a blue-ray disk in a 1992 CD player.)
        ref:https://stackoverflow.com/questions/424457/does-anyone-have-a-good-analogy-for-dependency-injection
        
        Electrical appliances are useless when there is no socket, and if the appliance's wire is just directly connected to one socket and you want to move to another place, the appliance is hard to use it on your new location, because you have to remove the wire between the appliance and the socket. All you have to do is connect the wire to the pin plug and the socket to the pin plug, so you can easily move it around.
      - Constructor Injection
        
        public class BraveKnight implements Knight { private Quest quest; public BraveKnight(Quest quest) { this.quest = quest; } public void embarkQuest() { quest.embark(); } }
      - Made up of two or more classes that collaborate with each other to perform some business logic
    - - Class Dependency
        
        public byte[] readFileContents(String fileName) { // this method takes a String as parameter. Therefore it depends on the String class }
      - Interface Dependency
        
        public byte[] readFileContents(CharSequence fileName) { // 'CharSequence' instances of any of classes can be used as parameter to the method }
      - Method/Field Dependency
        
        public byte[] readFileContents(Object fileNameContainer) { Method method = fileNameContainer .getClass() .getMethod("getFileName", null); String fileName = method.invoke(fileNameContainer, null); // dependencies on concrete methods or fields of an object }
  - - - Code is tightly coupled. One change causes a cascade of subsequent changes in dependent modules.
    - - software that tends to break in many places every time it is changed, even in areas that are conceptually unrelated
    - - inability to reuse software from other parts of the system
- - - - ApplicationPreparedEvent
        
        is sent just before the refresh is started, but after bean definitions have been loaded.
        
        ApplicationReadyEvent
        
        is sent after the refresh and any related callbacks have been processed to indicate the application is ready to service requests.
        
        ApplicationFailedEvent
        
        is sent if there is an exception on startup.