BE Study 11th

Dependency Injection.

Dependency Injection is that, the Dependency is injected in the runtime, not the compile time.

For example,

class HelloFactory()
{
    private Helloer helloer = new HelloerImpl();
    public HelloFactory() { ... }
    public sayHello()
    {
        helloer.sayHello();
    }
}

The above looks descent(delegation pattern). However, the problem is that the class HelloFactory is depending on the class HelloerImpl() in the compile time. 

class HelloFactory()
{
    private final Helloer helloer;
    public HelloFactory(Helloer helloer)
    {
        this.helloer = helloer;
    }
    public sayHello()
    {
        helloer.sayHello();
    }

}
The above code is much better, because you can inject the dependency(of helloer) in the runtime like

helloFactory = HelloFactory(new HelloerImpl helloer).

Thus, it is great that you eliminated the compile-time dependency.


There are 3 different types of Dependency Injections. 
1. Constructor Injections

class HelloFactory()
{
    private final Helloer helloer;
    public HelloFactory(Helloer helloer)
    {
        this.helloer = helloer;
    }
    public sayHello()
    {
        helloer.sayHello();
    }

}
It looks like above. The key is literally that the Injection has occurred within the Constructor; public HelloFactory(Helloer helloer). It is most RECOMMENDED style of DI. One advantage of the style is that it can also set the attribute(the handler to be injected) as final.

You might think defining the constructor is a nuisance. For such people, there's an annotation @RequiredArgsConstructor. With the annotation, lombok creates an constructor that initializes all the final attributes.

2. Method Injection

class HelloFactory()
{
    private Helloer helloer;
    public HelloFactory()
    {
    }
    public void setHelloer(Helloer helloer)
    {
        this.helloer = helloer;
    }
    public sayHello()
    {
        helloer.sayHello();
    }

}
Method Injection literally means that the dependency is injected via 'method'. Usually, the method is setter. It isn't recommended these days because the handler is mutable, and also it can cause circular dependencies.

3. Field Injection

class HelloFactory()
{
    @Autowired
    private Helloer helloer;
    public HelloFactory()
    {
    }
    public sayHello()
    {
        helloer.sayHello();
    }

}
Field Injection is the the injection is occurred directly into the field. You might see that there's NO explicit way to inject the handler! Using Field Injection, the injection is occurred via the framework: the spring. This means that the code won't work without the framework, so SHOULD NOT be used.


댓글

댓글 쓰기

이 블로그의 인기 게시물

Interface of Java

 You can define(declare + initialize) variable like interface_name variable_name = new class_name() In such cases, the variable can only use method overriding the interfaces methods. Also, the language does not recognized it as the class; the language recognizes it as interface. Still, it does have member variables of the class and there are some libraries that enables the programmer to tell what class it is constructed(i.e. Reflection) Interface can be used as parameter of functions or return types of functions. When interface is a parameter, the class that implements the interface should be given to the function. When interface is a return type, it can be used for polymorphism. Also, variable of java(in case its not primitive type like int, float), it is rather closer to pointer of C++; it refers to the value, not contains value itself. The important point is that, when the class implements the interface, all of its public methods should be the interface's methods. If not, client...
자세한 내용 보기

Data Analytics Overview(OLTP vs OLAP)

You’ve likely heard about the lucrative careers of high-level Data Analysts, but have you ever wondered how they actually handle "Big Data"? Of course, they aren’t just using Microsoft Excel. To understand the technology behind it, we must first distinguish between the two primary ways we process information:  OLTP  and  OLAP . 1. OLTP OLTP (Online Transactional Processing)  is the DB used for company’s daily operations. Whenever you post on Reddit or place an order on Amazon, you are interacting with an OLTP database. It is triggered by the business's customer and handled by the backend server so that it can provide the business. Fast:  It handles millions of requests with millisecond response times. Small&Frequent:  It focuses on small, frequent transactions—usually just a few rows at a time. Write-intensive:  Its primary job is to record or update new data as it happens. 2. OLAP OLAP (Online Analytical Processing)  is the very technology we...
자세한 내용 보기

Leetcode

이미지
1. Two Sum: find a pair with specific sum   class Solution : def twoSum ( self , nums : List [ int ] , target : int ) - > List [ int ] : numMap = { } n = len ( nums ) # Build the hash table for i in range ( n ) : numMap [ nums [ i ] ] = i # Find the complement for i in range ( n ) : complement = target - nums [ i ] if complement in numMap and numMap [ complement ] != i : return [ i , numMap [ complement ] ] return [ ] # No solution found You might wonder how does the code deals with duplicates. As you can see, in the iteration of building the hash table, always the latter(with bigger index) will be saved in the hash table. In the latter iteration finding the complement, the former one(with smaller index) always goes through the iteration earlier, so the [i, numMap[complement]] can return two different indexes, carrying duplicate...
자세한 내용 보기