Please enable JavaScript.

Coggle requires JavaScript to display documents.

Spring (Testing (@ExtendWith(SpringExtension.class), @ContextConfiguration…

- - - - allows dirty read (a tx can see change made from another uncommited tx)
    - - NOT allow dirty read (can only see committed updates)
      - default for most DB
    - - NOT allow dirty read
      - read is idempotent
      - may result in locking, depending on DBMS used
    - - NOT allow non-idempotent read or dirty read
      - NOT allow phantom reads
  - - - default, execute within current tx, create one if none exists
    - - create a new tx, suspending the current tx if exists
    - - create a new nested tx
- - - - a point of execution of a program, like method call or exception thrown
    - - an expression that selects multiple join points
    - - code to execute at each selected join point
    - - a module that encapsulates pointcuts and advice
    - - the way combining aspects with main code
  - - - @AfterReturning(value="execution...",
        returning="someType")
        
        access JoinPoint, returned value from target method
      - @AfterThrowing(value=..., throwing="exceptionType")
        
        access JoinPoint and Exception thrown from target
        
        only invoke on matching exception type
        
        do NOT stop exception propagation, use @Around advice to stop it
      - @After("execution...")
        
        advice called regardless exception thrown or not by target
      - @Around
        
        access ProceedingJoinPoint
        
        ProceedingJoinPoint inherits JoinPoint and adds proceed(), which calls the target method
      - @Before("execution(void set())")
        
        if a exception thrown out from advice, the target won't be called.
  - - - Externalise and centralise Pointcuts into a separate class file
      - Break complicated expressions into smaller part
        
        e.g. @Before("serverStartMethod(server, input)"), serverStartMethod is the pointcut ID which represent a method using it as its name and annotated Pointcu("excution()")t
      - allow point cut to be reusable
    - - e.g. @Before("execution... && target(server) && args(input) && @annotation(txn)")
        server and input are argument names in the method annotated
      - target(...) selects the target
        this(...) selects the proxy
      - @annotation(txn) -> @transactional
- - - - Spring use the last one it sees defined
      - Order (control which Bean method to run and this is the class level annotation)
    - - prototype (created new isntance when referenced)
      - singleton (default)
        
        To multi-thread issues(same bean at same time):
        1.stateless or immutable beans;
        
        sychronized;
        
        different scope.
      - session (web env only)
      - request (web env only)
      - websocket
      - refresh
      - thread (defined but not registered)
      - customer (Create and registered new factory )
    - - Profile("profileName") can be on class level (configuration class)or method level (@Bean method), can control which PropertySource to be imported
      - Ways to active profile:
        
        command-line -> -Dspring.profile.active = dev,jpa;
        
        System property setting -> System.setProperty("spring.profile.active", "dev, jpa");
        
        ActiveProfiles annotation
  - - - to separate config into multiple files(Best practice is to separate "application" bean from "infrastructure" bean)
      - to bring a config file into scope
    - - Spring find the bean based on type
  - - - introduce properties from external world:
      - Environment obtain values from this
    - - handy way to fetch env var from placeholders like "${db.driver}"
      - BUT need a static bean for PropertySourcesPlaceholderConfigurer()
        
        automactically defined in spring boot projects
- - - - persist(Object o)
      - remove(Object o)
      - find(Class entity, Object primaryKey)
      - JPA Quering
        
        Query createQuery(String jpqlString, [returnclass])
        .setParameter(paramName/index, value)
        .getResultList()/getSingleResult()
        
        select required, cannot user *
      - flush()
- - - - load from
        
        Component from ComponentScan
        
        XML files
        
        Configuration classes
      - Process -> invoke BeanFactoryPostProcessor
        
        modify any bean definition in the factory before any objects created
        
        example
        
        Value -> use PropertySourcesPlaceholderConfigurer(this bean defined with static to make sure it is created before create other bean) to evaluate them
      - load to (BeanFactory)
    - - BPP(BeanPostProcessor)
        
        create Proxy for bean
        
        CGLib Proxy - extends the bean it proxies
        
        prefer JDK Proxy a.k.a. dynamic proxies which proxy all interfaces by implement them
        
        add behaviour to bean transparently
        
        e.g: call methods with PostConstruct ; Resource :
        
        two entry point: BeforeInit and AfterInit
      - find and injecte Dependencies (bean instantiated here unless bean is annotated with lazy )
- - - - hides/decouple implementation details
      - more specific sub-exception types rather than a single general type
      - consistent across all supported data access tech
      - unchecked
  - - - key
        
        can use object field as key, key="#author.name"
        
        can use custom key generator, key="T(example.KeyGen).hash(#author)"
      - condition
        
        only cache if condition is true, condition="#person.age < 20"
    - - (value="cachestore name", beforeInvocation=true) clear cache before method invoked
    - - SimpleCacheManager
        
        creates a ConcurrentHashMap for each cache name
        
        NO cache control options like overflow or eviction, just for testing
      - 3rd-party ( :question: when to use which? )
        
        Google's Caffeine
        
        HazelCast
        
        Redis
        
        ...
        
        Gemfire
        
        distributed, replicated across multiple nodes
        
        consistent updates on all copies in parallel
        
        No data loss if node fails
        
        auto recovery and rebalancing
  - - - lamba expression is from java 8 and it can be encapsulated in a class implementing 3 interfaces for resultSet
      - query(someSQL, [(RowCallbackHandler/ResultSetExtractor<T>)](ResultSet rs, [int row]) -> expression to deal with one row in rs)
    - - single row - queryForMap(...)
      - multi rows - queryForList(...)
    - - T mapRow(ResultSet rs, int rowNum) throws SQLException
    - - processRow(ResultSet rs) throws SQLException
    - - T extractData(ResultSet rs) throws SQLException, DataAccessException
      - processing entire result set at once
    - - update(sql, params, ...)
- - - - NOT called for prototype beans
      - invoked by ConfigurableApplicationContext.close()
      - SpringApplication.run(...) registers context.close() to JVM shutdown hooks
- - - - MVC controller
    - - DAO class, Data access logic
    - - Business service logic
    - - retention = RUNTIME
        Target = TYPE
        Service
        Transactional
    - - java configuration
- - - - @RequestMapping("/path")
        
        class/method annotation
        
        usually use on class, and use additional mappings to narrow down specific requests
        
        @RequestParam("paramName")
        
        @RequestHeader
        
        @PathVariable("varName")
      - @Controller
    - - coordinate all request handling
      - delegates to web infrastructure beans
      - auto-created by Spring Boot, given full access to WebApplicationContext