UserService userService = new UserService();

@Service  // 告訴Spring：這是一個(gè)Bean，請幫我管理。@Service是@Component的衍生注解
public class UserService {
    // ...
}

public class UserService {
    private UserDao userDao;  // UserService依賴UserDao
    public User getUser(Long id) {
        return userDao.findById(id);  // 需要用到UserDao
    }
}

public class UserService {
    private UserDao userDao;
    public UserService() {
        this.userDao = new UserDaoImpl();  // 自己創(chuàng)建依賴
    }
}

@Service
public class UserService {
    @Autowired  // 告訴Spring：請把UserDao注入給我
    private UserDao userDao;
}

public class UserService {
    private UserDao userDao;
    public UserService() {
        // 你決定創(chuàng)建什么對象
        this.userDao = new UserDaoImpl();
    }
}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // Spring決定注入什么對象
}

// Spring容器啟動(dòng)時(shí)
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
// 從容器獲取Bean
UserService userService = context.getBean(UserService.class);
// 這個(gè)userService已經(jīng)注入好了所有依賴，可以直接使用
User user = userService.getUser(1L);

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    @Autowired
    private EmailService emailService;
}

@Service
//@RequiredArgsConstructor      
//Lombok注解，寫了這個(gè)就不用寫構(gòu)造器了，但是要加入Lombok依賴。（依賴在博主之前的關(guān)于Lombok的文章中有提到過）
public class UserService {
    private final UserDao userDao;
    private final EmailService emailService;
    // Spring 4.3+ 單構(gòu)造器可省略@Autowired
    public UserService(UserDao userDao, EmailService emailService) {
        this.userDao = userDao;
        this.emailService = emailService;
    }
}

@Service
public class UserService {
    private UserDao userDao;
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

<bean id="userDao" class="com.example.dao.UserDaoImpl"/>
<bean id="userService" class="com.example.service.UserService">
    <property name="userDao" ref="userDao"/>  <!-- 手動(dòng)指定依賴 -->
</bean>

@Service
public class UserService {
    @Autowired  // 自動(dòng)裝配，Spring自動(dòng)找到UserDao并注入
    private UserDao userDao;
}

<!-- 按類型自動(dòng)裝配 -->
<bean id="userService" class="com.example.service.UserService" 
      autowire="byType"/>
<!-- 按名稱自動(dòng)裝配 -->
<bean id="userService" class="com.example.service.UserService" 
      autowire="byName"/>

@Service
public class UserService {
    @Autowired  // 注解方式，更簡潔
    private UserDao userDao;
}

@Configuration
public class AppConfig {
    @Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }
    @Bean
    public UserService userService() {
        return new UserService();  // 自動(dòng)裝配
    }
}

@SpringBootApplication  // 自動(dòng)掃描，自動(dòng)裝配
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

1. Spring容器啟動(dòng)，掃描所有Bean定義
   ↓
2. 創(chuàng)建Bean實(shí)例（調(diào)用構(gòu)造函數(shù)）
   ↓
3. AutowiredAnnotationBeanPostProcessor介入
   ↓
4. 掃描Bean中的@Autowired注解
   ↓
5. 解析依賴類型
   ↓
6. 在容器中查找匹配的Bean
   ├─ 按類型查找（byType）- 默認(rèn)策略
   ├─ 如果有多個(gè)，按@Primary篩選
   ├─ 如果還有多個(gè)，按@Qualifier篩選
   └─ 如果還有多個(gè)，按字段名稱匹配
   ↓
7. 通過反射注入依賴
   ↓
8. Bean初始化完成

@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 查找UserDao類型的Bean
}

@Repository
@Primary  // 標(biāo)記為首選
public class UserDaoMysqlImpl implements UserDao { }
@Repository
public class UserDaoMongoImpl implements UserDao { }
@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 自動(dòng)選擇@Primary標(biāo)記的Bean
}

@Service
public class UserService {
    @Autowired
    @Qualifier("userDaoMongoImpl")  // 明確指定使用哪個(gè)Bean
    private UserDao userDao;
}

@Service
public class UserService {
    @Autowired
    private UserDao userDaoMysqlImpl;  // 字段名與Bean名稱一致
}

@Service
public class UserService {
    // 注入所有UserDao類型的Bean
    @Autowired
    private List<UserDao> userDaoList;
    
    // 注入所有UserDao類型的Bean到Map，key為Bean名稱
    @Autowired
    private Map<String, UserDao> userDaoMap;
}

@Qualifier（最高優(yōu)先級）
    ↓
@Primary
    ↓
字段名稱匹配
    ↓
類型匹配（默認(rèn)）

// 有兩個(gè)UserDao的實(shí)現(xiàn)
@Repository
public class UserDaoMysqlImpl implements UserDao { }

@Repository
public class UserDaoMongoImpl implements UserDao { }

// 注入時(shí)會(huì)報(bào)錯(cuò)
@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 錯(cuò)誤：找到2個(gè)候選Bean
}

@Service
public class UserService {
    @Autowired(required = false)  // 找不到Bean不報(bào)錯(cuò)，注入null
    private CacheService cacheService;
    public User getUser(Long id) {
        if (cacheService != null) {
            User cached = cacheService.get(id);
            if (cached != null) return cached;
        }
        return userDao.findById(id);
    }
}

@Service
public class UserService {
    @Autowired
    private Optional<CacheService> cacheService;
    public User getUser(Long id) {
        return cacheService
            .map(cache -> cache.get(id))
            .orElseGet(() -> userDao.findById(id));
    }
}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    public UserService() {
        // 錯(cuò)誤：此時(shí)userDao還未注入，為null
        // userDao.findAll();
    }
    @PostConstruct
    public void init() {
        // 正確：此時(shí)userDao已經(jīng)注入
        userDao.findAll();
    }
}

// 不推薦：循環(huán)依賴
@Service
public class UserService {
    @Autowired
    private OrderService orderService;
}
@Service
public class OrderService {
    @Autowired
    private UserService userService;
}
// 推薦：重新設(shè)計(jì)，單向依賴
@Service
public class OrderService {
    @Autowired
    private UserService userService;  // 單向依賴
}

SpringBoot自動(dòng)配置 → 創(chuàng)建Bean
         ↓
Spring自動(dòng)裝配 → 注入Bean

// SpringBoot自動(dòng)配置：自動(dòng)創(chuàng)建DataSource Bean
@Configuration
@ConditionalOnClass(DataSource.class)
public class DataSourceAutoConfiguration {
    @Bean
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}
// 自動(dòng)裝配：自動(dòng)注入DataSource依賴
@Service
public class UserService {
    @Autowired  // 自動(dòng)裝配
    private DataSource dataSource;  // 這個(gè)Bean是自動(dòng)配置創(chuàng)建的
}

@Service
public class UserService {
    @Resource  // 默認(rèn)按名稱裝配
    private UserDao userDao;
    @Resource(name = "userDaoMysqlImpl")  // 指定Bean名稱
    private UserDao userDao2;
}

@Service
public class UserService {
    @Inject  // 功能類似@Autowired
    private UserDao userDao;
}

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

@Service
public class UserService {
    @Value("${app.name}")  // 從配置文件讀取
    private String appName;
    @Value("${app.max-users:100}")  // 指定默認(rèn)值100
    private int maxUsers;
    @Value("#{systemProperties['user.home']}")  // SpEL表達(dá)式
    private String userHome;
}

app.name=我的應(yīng)用
app.max-users=500

@Service
public class UserService {
    @Autowired
    private OrderService orderService;  // UserService依賴OrderService
}
@Service
public class OrderService {
    @Autowired
    private UserService userService;  // OrderService依賴UserService
}

@Service
public class UserService {
    private final OrderService orderService;
    public UserService(OrderService orderService) {
        this.orderService = orderService;
    }
}
@Service
public class OrderService {
    private final UserService userService;
    public OrderService(UserService userService) {
        this.userService = userService;  // 報(bào)錯(cuò)！無法解決
    }
}

@Service
public class UserService {
    private final OrderService orderService;
    public UserService(@Lazy OrderService orderService) {
        this.orderService = orderService;  // 注入代理對象，延遲初始化
    }
}

// 錯(cuò)誤：忘記加@Service注解
public class UserService {
    @Autowired
    private UserDao userDao;  // 注入失敗，為null
}
// 正確：添加@Service注解
@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 正常注入
}

@SpringBootApplication
@ComponentScan("com.example.service")  // 只掃描service包
public class Application {
    // UserDao在com.example.dao包下，掃描不到
}
// 正確：掃描父包
@SpringBootApplication
@ComponentScan("com.example")  // 掃描整個(gè)com.example包
public class Application { }

// 錯(cuò)誤：直接new的對象，Spring無法注入依賴
UserService service = new UserService();
service.getUser(1L);  // userDao為null，報(bào)NPE
// 正確：從Spring容器獲取
@RestController
public class UserController {
    @Autowired
    private UserService userService;  // 從容器獲取，依賴已注入
    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);  // 正常使用
    }
}

// 錯(cuò)誤：無法注入靜態(tài)字段
@Service
public class UserService {
    @Autowired
    private static UserDao userDao;  // 無法注入
}
// 正確：使用非靜態(tài)字段
@Service
public class UserService {
    @Autowired
    private UserDao userDao;  // 正常注入
}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    private List<User> cache;
    // 錯(cuò)誤：構(gòu)造函數(shù)執(zhí)行時(shí)，userDao還未注入
    public UserService() {
        this.cache = userDao.findAll();  // NPE！
    }
}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    private List<User> cache;
    @PostConstruct  // 在依賴注入完成后執(zhí)行
    public void init() {
        this.cache = userDao.findAll();  // 正確
    }
}

1. 實(shí)例化（執(zhí)行構(gòu)造函數(shù)）
   ↓
2. 依賴注入（@Autowired生效）
   ↓
3. 初始化前（@PostConstruct執(zhí)行）
   ↓
4. 初始化（InitializingBean.afterPropertiesSet()）
   ↓
5. Bean可用
   ↓
6. 銷毀前（@PreDestroy執(zhí)行）
   ↓
7. 銷毀（DisposableBean.destroy()）

// 推薦
@Service
public class UserService {
    private final UserDao userDao;  // final保證線程安全
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}
//或者可以這樣寫，一個(gè)意思
@Service
@@RequiredArgsConstructor 
public class UserService {
    private final UserDao userDao;
}

@Service
public class UserService {
    private final UserDao userDao;  // final保證線程安全
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

@Service
public class UserService {
    private final UserDao userDao;
    public UserService(@Qualifier("userDaoMysqlImpl") UserDao userDao) {
        this.userDao = userDao;
    }
}

@Service
public class UserService {
    @Autowired
    private Optional<CacheService> cacheService;
}

@SpringBootApplication  // 包含@ComponentScan，自動(dòng)掃描當(dāng)前包及子包
//目標(biāo)類標(biāo)注 @Component 或其衍生注解，且類處于啟動(dòng)類所在包/子包下，SpringBoot 就會(huì)自動(dòng)掃描并將其注冊為 Bean 實(shí)例。
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Service
public class UserService {
    @Autowired
    private JdbcTemplate jdbcTemplate;  // SpringBoot自動(dòng)配置，直接注入
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
@Service
public class UserService {
    @Autowired
    private EntityManager entityManager;  // 自動(dòng)配置，直接注入
}

Spring依賴注入（本文）
    ↓
SpringBoot自動(dòng)配置原理
    ↓
自定義Starter開發(fā)
    ↓
Spring AOP原理
    ↓
Spring事務(wù)管理