Please enable JavaScript.

Coggle requires JavaScript to display documents.

Spring (Transaction (levels (when few transactions operate concurrently on…

- - - - transaction template ( has method execute which accepts instance of anonymous class havib=ng single method doInTransactionWithResult() )
      - Platform transaction manager
  - - - propagation - determines whether code should always or never run in a transaction, or if it should run in a new one.
      - isolation - determines how data within transaction are accessible to other users, processes and systems.
      - timeout
      - readOnly
      - noRollbackFor
      - rollbackFor - by default checked exceptions don't rollback transactions.
- - - - Component indicates that an annotated class is a “component”. Such classes are considered as candidates for auto-detection when using annotation-based configuration and classpath scanning.
      - Controller indicates that an annotated class is a “Controller” (e.g. a web controller).
      - Repository indicates that an annotated class is a “Repository”, originally defined by Domain-Driven Design (Evans, 2003) as “a mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects”.
      - Service indicates that an annotated class is a “Service”, originally defined by Domain-Driven Design (Evans, 2003) as “an operation offered as an interface that stands alone in the model, with no encapsulated state.” May also indicate that a class is a Business Service Facade (in the Core J2EE patterns sense) or something similar.
- - - - This method uses reflection to inject the dependencies, which is costlier than constructor-based or setter-based injection
      - It's really easy to keep adding multiple dependencies using this approach. If you were using constructor injection having multiple arguments would have made us think that the class does more than one thing which can violate the Single Responsibility Principle.
  - - - The behaviour of Autowired annotation is similar to the Inject annotation. The only difference is that the Autowired annotation is part of the Spring framework. This annotation has the same execution paths as the Inject
    - - This annotation has the following execution paths, listed by precedence: by name, by type, by qualifier
        
        Match by Name
        
        setter example
        private File defaultFile; @Resource(name="namedFile") protected void setDefaultFile(File defaultFile) { this.defaultFile = defaultFile; }
        
        Match by Type
        
        @Resource private File defaultFile;
        
        Match by Qualifier
        
        @Resource @Qualifier("defaultFile") private File dependency1; @Resource @Qualifier("namedFile") private File dependency2;
        
        setter based
        @Resource @Qualifier("namedFile") public void setArbDependency(File arbDependency) { this.arbDependency = arbDependency; }
      - @Resource(name="namedFile") private File defaultFile;
      - @Configuration public class ApplicationContextTestResourceNameType { @Bean(name="namedFile") public File namedFile() { File namedFile = new File("namedFile.txt"); return namedFile; } }
    - - This annotation has the following execution paths, listed by precedence: Match by Type, Match by Qualifier, Match by Name
- - - - [one,two] for list values; properties file doesn't support lists
      - key is string and value has its own type
      - Yaml ain't markup language
    - - @SpringBootApplication public class CustomApplication { public static void main(String[] args) { SpringApplication app = new SpringApplication(CustomApplication.class); app.setDefaultProperties(Collections .singletonMap("server.port", "8083")); app.run(args); } }
      - customizing the embedded server configuration
        
        @Component public class ServerPortCustomizer implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> { @Override public void customize(ConfigurableWebServerFactory factory) { factory.setPort(8086); } }
  - - - 3.1 Servlet Config init parameters
      - 3.2 ServletContext init parameters
      - 3.3 JNDI naming attributes
      - 3.4 System.getProperties
      - OS environment vars
- - - - Post-initialization call back methods
      - Pre-destruction call back methods
  - - - Spring will only use the marked auto-configuration bean if the class in the annotation's argument is present/absent
      - @Configuration @ConditionalOnClass(DataSource.class) class MySQLAutoconfiguration { //... }
    - - @Bean @ConditionalOnBean(name = "dataSource") LocalContainerEntityManagerFactoryBean entityManagerFactory() { // ... }
    - - @Bean @ConditionalOnProperty( name = "usemysql", havingValue = "local" ) DataSource dataSource() { // ... }
    - - @ConditionalOnResource(resources = "classpath:mysql.properties") Properties additionalProperties() { // ... }
    - - With these annotations, we can create conditions based on if the current application is or isn't a web application
      - @ConditionalOnWebApplication HealthCheckController healthCheckController() { // ... }
    - - @Bean @ConditionalOnExpression("${usemysql} && ${mysqlserver == 'local'}") DataSource dataSource() { // ... }
      - Spring will use the marked definition when the SpEL expression is evaluated to true:
    - - @Conditional(HibernateCondition.class) Properties additionalProperties() { //... }
      - For even more complex conditions, we can create a class evaluating the custom condition
- - - - A BeanFactory is essentially nothing more than the interface for an advanced factory capable of maintaining a registry of different beans and their dependencies
      - The BeanFactory enables us to read bean definitions and access them using the bean factory.
      - The default implementation instantiates beans lazily when getBean() is called.
      - Morep popular subinterfaces include : ApplicationContext
        WebApplicationContext and AutowireCapableBeanFactory. More popular implementations are AnnotationConfigWebApplicationContext, XmlWebApplicationContext, ClassPathXmlApplicationContext and FileSystemXmlApplicationContext
    - - The ApplicationContext container includes all functionality of the BeanFactory container, so it is generally recommended over the BeanFactory. BeanFactory can still be used for lightweight applications like mobile devices or applet based applications where data volume and speed is significant.
      - ApplicationContext is an interface representing a container holding all information, metadata, and beans in the application. It also extends the BeanFactory interface but the default implementation instantiates beans eagerly when the application starts.
      - In addition to the BeanFactory’s methods, ApplicationContext provides the ability to:
        
        Load file resources by extending the ResourcePatternResolver interface
        
        Publish events to registered listeners (via the ApplicationEventPublisher interface)
        
        Resolve messages supporting internationalization (with the MessageSource interface).
      - It’s read-only while the application is running
- - - - Aspekty: Aspekty zawierają logikę, która ma być wykonana przed, po, lub wokół metod w wybranych beanach. Aspekt jest specjalnym komponentem, który definiuje, gdzie i kiedy dana logika ma być zastosowana.
      - Aspect: a class that implements cross-cutting concerns, such as transaction management
    - - Porady (Advice): Konkretna logika, która ma być wykonana w określonym punkcie przecięcia. Istnieją różne rodzaje porad, takie jak Before, After, Around, AfterReturning, AfterThrowing.
    - - Punkt przecięcia to wyrażenie, które definiuje zbiór punktów przecięcia (Join Points), do których ma być zastosowana porada (Advice).
        Wyrażenia pointcut są definiowane za pomocą aspektów.