instead, it had turned into a catastrophe ... whyyyy

by create a document

```java import org.springframework.core.env.Environment; public class MyApplication {

public static void main(String[] args) {
       ApplicationContext ctx = new AnnotationConfigApplicationContext(someConfigClass);
       Environment env = ctx.getEnvironment(); // (1)
       String databaseUrl = env.getProperty("database.url"); // (2)
       boolean containsPassword = env.containsProperty("database.password");
       // etc
}

} ```

instead of specificlt get resources (or config) from each file ... Spring can do it with single line

So that they can inject other logic defined in other annoation

```java import javax.sql.DataSource; import org.springframework.stereotype.Component; import org.springframework.beans.factory.annotation.Autowired;

@Component public class UserDao {

@Autowired
private DataSource dataSource;

} ```

```java @Component public class UserDao {

private DataSource dataSource;

public UserDao(DataSource dataSource) {
    this.dataSource = dataSource;
}

} ```

```java import javax.sql.DataSource; import org.springframework.stereotype.Component; import org.springframework.beans.factory.annotation.Autowired;

@Component public class UserDao {

private DataSource dataSource;

public UserDao(@Autowired DataSource dataSource) {
    this.dataSource = dataSource;
}

} ```

```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration;

@Configuration @ComponentScan // (1) public class MyApplicationContextConfiguration {

@Bean
public DataSource dataSource() {
    MysqlDataSource dataSource = new MysqlDataSource();
    dataSource.setUser("root");
    dataSource.setPassword("s3cr3t");
    dataSource.setURL("jdbc:mysql://localhost:3306/myDatabase");
    return dataSource;
}

// (2)

// no more UserDao @Bean method!

} ```

• Singleton: All DAOs share the same DataSource.
• Prototype: All DAOs get their own DataSource.
• Session: new DataSource per HttpRequest or HttpSession or WebSocket

the getBean method from

java ApplicationContext ctx = new AnnotationConfigApplicationContext(MyApplicationContextConfiguration.class); UserDao userDao = ctx.getBean(UserDao.class);

Again, we introduce another problems. The application class need to know the logic of how UserDao and DataSource working

We called it tight-coupled. It hard to modify and make it more general.

And when we have duplicated code for such operation (database connection) this will introduce new problems ... too many database connection

We will have duplicated code

He create DataSource instance here in findById method, which will introduce more problem later on

The idea of dependency is when we want to use other class feature that's it

from the example class UserDao is just a DAO class (data access object) and it needs feature of the DataSource class to prepare SQL statement. So, it needs to do something to get that object which is declare new DataSource()

```java public class UserDao {

public User findById(Integer id) throws SQLException {
    try (Connection connection = dataSource.getConnection()) { // (1)
           PreparedStatement selectStatement = connection.prepareStatement("select * from users where id =  ?");
           // use the connection etc.
    }
}

} ```

Constructor

```java

private DependencyA dependencyA; private DependencyB dependencyB; private DependencyC dependencyC;

@Autowired public DI(DependencyA dependencyA, DependencyB dependencyB, DependencyC dependencyC) { this.dependencyA = dependencyA; this.dependencyB = dependencyB; this.dependencyC = dependencyC; } ```

Setter

```java

private DependencyA dependencyA; private DependencyB dependencyB; private DependencyC dependencyC;

@Autowired public void setDependencyA(DependencyA dependencyA) { this.dependencyA = dependencyA; }

@Autowired public void setDependencyB(DependencyB dependencyB) { this.dependencyB = dependencyB; }

@Autowired public void setDependencyC(DependencyC dependencyC) { this.dependencyC = dependencyC; } ```

Field injection

```java

@Autowired private DependencyA dependencyA;

@Autowired private DependencyB dependencyB;

@Autowired private DependencyC dependencyC; ```

use @babel/eslint-parser instead

don't forget to yarn add -D @babel/eslint-parser

dark and gloomy ~ คลุมเครือ

collect result

trigger run all jobs

start 3 workers

what's the differences?

It's more like your test focus on how code are implement, but actually you need to focus on how you application should interact with user

because code coverage doesn't mean your software doesn't have bug

instead feature coverage, can guarantee that :D

yes, no test on button click event

🤣

I'm begin to test when we already have testing-library, so I didn't have that experience :D