??總的來說，"需要"一個Bean，是指在運行時有其他代碼需要使用到這個Bean的實例，這個"需要"可能來源于其他Bean的依賴，也可能來源于框架的調(diào)用，或者你手動獲取。在這種需要出現(xiàn)時，如果對應的Bean還沒有被創(chuàng)建，那么Spring就會根據(jù)之前通過@ComponentScan等方式注冊的Bean定義，創(chuàng)建對應的Bean實例。

5.2 xml中啟用component-scan組件掃描

對應于 @ComponentScan 的 XML 配置是 <context:component-scan> 標簽

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.example" />

</beans>

??在這段 XML 配置中，<context:component-scan> 標簽指定了 Spring 需要掃描 com.example 包及其子包下的所有類，這與 @ComponentScan 注解的功能是一樣的。

??注意：在使用 <context:component-scan> 標簽時，需要在 XML 配置文件的頂部包含 context 命名空間和相應的 schema 位置（xsi:schemaLocation）。

5.3 不使用@ComponentScan的組件掃描

如果我們不寫@ComponentScan注解，那么這里可以把主程序改為如下：

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext("com.example");
        Library library = context.getBean(Library.class);
        System.out.println(library.getBook().getTitle());
        System.out.println(library.getBook().getAuthor());
    }
}

??AnnotationConfigApplicationContext 的構(gòu)造方法中有一個是填寫basePackages路徑的，可以接受一個或多個包的名字作為參數(shù)，然后掃描這些包及其子包。

運行結(jié)果如下：

??在這個例子中，Spring 將會掃描 com.example 包及其所有子包，查找并注冊所有的 Bean，達到和@ComponentScan注解一樣的效果。

??我們也可以手動創(chuàng)建一個配置類來注冊bean，那么想要運行得到一樣的效果，需要的代碼如下：

@Component
public class Book {
    
    private String title = "Java Programming";
    private String author = "Unknown";

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

@Component
public class Library {
    
    private Book book;

    public Book getBook() {
        return book;
    }

    public void setBook(Book book) {
        this.book = book;
    }
}

@Configuration
public class LibraryConfiguration {
    @Bean
    public Book book() {
        Book book = new Book();
        book.setTitle("Java Programming");
        book.setAuthor("Unknown");
        return book;
    }

    @Bean
    public Library library() {
        Library library = new Library();
        library.setBook(book());
        return library;
    }
}

主程序：

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(LibraryConfiguration.class);
        Library library = context.getBean(Library.class);
        System.out.println(library.getBook().getTitle());
        System.out.println(library.getBook().getAuthor());
    }
}

??我們創(chuàng)建了一個配置類LibraryConfiguration，用于定義Book和Library這兩個bean。然后以配置類LibraryConfiguration.class作為輸入的來創(chuàng)建Spring的IOC容器（Spring應用上下文就是Spring IOC容器）。

運行結(jié)果和前面一樣。

??注意，在這個例子里，如果你寫@ComponentScan，并且SpringApplication.run(Application.class, args);作為Spring上下文，那么這里運行配置類需要去掉Book和Library類的@Component注解，不然會報錯A bean with that name has already been defined。這是因為如果同時在 Book 和Library 類上使用了 @Component 注解，而且配置類LibraryConfiguration上使用了@Configuration注解，這都會被 @ComponentScan 掃描到，那么 Book 和 Library的實例將會被創(chuàng)建并注冊兩次。正確的做法是，要么在配置類中通過 @Bean 注解的方法創(chuàng)建Book 和 Library的實例，要么在 Book 和 Library 類上寫 @Component 注解。如果不是第三方庫，我們一般選擇后者。

為什么要有配置類出現(xiàn)？所有的Bean上面使用@Component，用@ComponentScan注解掃描不就能解決了嗎？

??我們在使用一些第三方庫時，需要對這些庫進行一些特定的配置。這些配置信息，我們可能無法直接通過注解或者XML來完成，或者通過這些方式完成起來非常麻煩。而配置類可以很好地解決這個問題。通過配置類，我們可以在Java代碼中完成任何復雜的配置邏輯。

??假設你正在使用 MyBatis，在這種情況下可能需要配置一個SqlSessionFactory，在大多數(shù)情況下，我們無法（也不應該）直接修改第三方庫的代碼，所以無法直接在SqlSessionFactory類或其他類上添加@Configuration、@Component等注解。為了能夠在Spring中使用和配置這些第三方庫，我們需要創(chuàng)建自己的配置類，并在其中定義@Bean方法來初始化和配置這些類的實例。這樣就可以靈活地控制這些類的實例化過程，并且可以利用Spring的依賴注入功能。

下面是一個使用@Configuration和@Bean來配置MyBatis的例子：

@Configuration
@MapperScan("com.example.demo.mapper")
public class MyBatisConfig {

    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        factoryBean.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath*:com/example/demo/mapper/*Mapper.xml")
        );
        return factoryBean.getObject();
    }
}

??sqlSessionFactory方法創(chuàng)建一個SqlSessionFactoryBean對象，并使用DataSource（Spring Boot默認為你配置的一個Bean）進行初始化。然后，它指定MyBatis mapper XML文件的位置，最后返回SqlSessionFactory對象。

??通過這種方式，你可以靈活地配置MyBatis，并將其整合到Spring應用中。這是一種比使用XML配置文件或僅僅依賴于自動配置更為靈活和強大的方式。

6. 組件注冊的其他注解

??@Controller, @Service, @Repository和@Component 一樣的效果，它們都會被 Spring IoC 容器識別，并將類實例化為 Bean。讓我們來看這些注解：

• @Controller：這個注解通常標注在表示表現(xiàn)層（比如 Web 層）的類上，如Spring MVC 中的控制器。它們處理用戶的 HTTP 請求并返回響應。雖然 @Controller 與 @Component 在功能上是類似的，但 @Controller 注解的使用表示了一種語義化的分層結(jié)構(gòu)，使得控制層代碼更加清晰。

• @Service：這個注解通常用于標注業(yè)務層的類，這些類負責處理業(yè)務邏輯。使用 @Service 注解表明該類是業(yè)務處理的核心類，使得代碼更具有語義化。

• @Repository：這個注解用于標記數(shù)據(jù)訪問層，也就是數(shù)據(jù)訪問對象或DAO層的組件。在數(shù)據(jù)庫操作的實現(xiàn)類上使用 @Repository 注解，這樣Spring將自動處理與數(shù)據(jù)庫相關(guān)的異常并將它們轉(zhuǎn)化為Spring的DataAccessExceptions。

??在實際開發(fā)中，幾乎很少看到@Repository，而是利用 MyBatis 的 @Mapper 或 @MapperScan 實現(xiàn)數(shù)據(jù)訪問，通常做法是，@MapperScan 注解用于掃描特定包及其子包下的接口，這些接口被稱為 Mapper 接口。Mapper 接口方法定義了 SQL 查詢語句的簽名，而具體的 SQL 查詢語句則通常在與接口同名的 XML 文件中定義。

??@MapperScan("com.example.**.mapper") 會掃描 com.example 包及其所有子包下的名為 mapper 的包，以及 mapper 包的子包。 ** 是一個通配符，代表任意深度的子包。

舉個例子，以下是一個 Mapper 接口的定義：

package com.example.demo.mapper;

public interface BookMapper {
    Book findBookById(int id);
}

對應的 XML 文件（通常位于 resources 目錄下，并且與接口在相同的包路徑中）

<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.BookMapper">
    <select id="findBookById" parameterType="int" resultType="com.example.demo.Book">
        SELECT title, author FROM book WHERE id = #{id}
    </select>
</mapper>

??注意：在 XML 文件中的 namespace 屬性值必須與 Mapper 接口的全限定類名相同，<select> 標簽的 id 屬性值必須與接口方法名相同。

然后，在 Spring Boot 的主類上，我們使用 @MapperScan 注解指定要掃描的包：

@SpringBootApplication
@MapperScan("com.example.**.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

??這樣，MyBatis 就會自動為 UserMapper 接口創(chuàng)建一個實現(xiàn)類（實際上是一個代理對象），并將其注冊到 Spring IOC 容器中，你就可以在你的服務類中直接注入 BookMapper 并使用它。

可能有小伙伴注意到了，這幾個注解中都有這么一段代碼

    @AliasFor(
        annotation = Component.class
    )
    String value() default "";

??@AliasFor 是 Spring 框架的注解，它允許你在一個注解屬性上聲明別名。在 Spring 的許多核心注解中，@AliasFor 用于聲明一個或多個別名屬性。

??舉個例子，在 @Controller, @Service, @Repository注解中，value() 方法上的 @AliasFor 聲明了一個別名屬性，它的目標注解是 @Component，具體的別名屬性是 value。也就是說，當我們在 @Controller, @Service, @Repository 注解上使用 value() 方法設置值時，實際上也就相當于在 @Component 注解上設置了 name 屬性的值。同時，這也表明了 @Controller, @Service, @Repository注解本身就是一個特殊的 @Component。

7. 將注解驅(qū)動的配置與XML驅(qū)動的配置結(jié)合使用

??有沒有這么一種可能，一個舊的Spring項目，里面有很多舊的XML配置，現(xiàn)在你接手了，想要全部用注解驅(qū)動，不想再寫XML配置了，那應該怎么兼容呢？

假設我們有一個舊的Spring XML配置文件 old-config.xml：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="oldBean" class="com.example.OldBean" />

</beans>

這個文件定義了一個名為 “oldBean” 的bean。

然后，我們編寫一個新的注解驅(qū)動的配置類：

package com.example;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

@Configuration
@ImportResource("classpath:old-config.xml")
public class NewConfig {

    @Bean
    public NewBean newBean() {
        return new NewBean();
    }
}

??在這個新的配置類中，我們使用 @ImportResource 注解來引入舊的XML配置文件，并定義了一個新的bean “newBean”。@ImportResource("classpath:old-config.xml")告訴Spring在初始化AppConfig配置類時，去類路徑下尋找old-config.xml文件，并加載其中的配置。

??當我們啟動應用程序時，Spring會創(chuàng)建一個 ApplicationContext，這個 ApplicationContext 會包含 old-config.xml 文件中定義的所有beans（例如 “oldBean”），以及 NewConfig 類中定義的所有beans（例如 “newBean”）。

package com.example;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(NewConfig.class);
        
        OldBean oldBean = context.getBean("oldBean", OldBean.class);
        NewBean newBean = context.getBean("newBean", NewBean.class);
        
        System.out.println(oldBean);
        System.out.println(newBean);
    }
}

??在以上的main方法中，我們通過使用AnnotationConfigApplicationContext并傳入NewConfig.class作為參數(shù)，初始化了一個Spring上下文。在這個上下文中，既包含了從old-config.xml導入的bean，也包含了在NewConfig配置類中使用@Bean注解定義的bean。

??所以，通過使用 @ImportResource，可以在新的注解配置中引入舊的XML配置，這樣就可以在不打斷舊的XML配置的基礎上逐步遷移至新的注解配置。

上面我們說到類路徑，什么是類路徑?

??resources目錄就是類路徑（classpath）的一部分。所以當我們說"類路徑下"的時候，實際上也包含了"resources"目錄。JVM在運行時，會把"src/main/resources"目錄下的所有文件和文件夾都添加到類路徑中。

??例如有一個XML文件位于"src/main/resources/config/some-context.xml"，那么可以用以下方式來引用它：

@Configuration
@ImportResource("classpath:config/some-context.xml")
public class AppConfig {
    //...
}

這里可以描述為在類路徑下的’config’目錄中查找’some-context.xml’文件。

為什么說JVM在運行時，會把"src/main/resources"目錄下的所有文件和文件夾都添加到類路徑中？

??當你編譯并運行一個Java項目時，JVM需要知道去哪里查找.class文件以及其他資源文件。這個查找的位置就是所謂的類路徑（Classpath）。類路徑可以包含文件系統(tǒng)上的目錄，也可以包含jar文件。簡單的說，類路徑就是JVM查找類和資源的地方。

??在一個標準的Maven項目結(jié)構(gòu)中，Java源代碼通常在src/main/java目錄下，而像是配置文件、圖片、靜態(tài)網(wǎng)頁等資源文件則放在src/main/resources目錄下。

??當你構(gòu)建項目時，Maven（或者其他的構(gòu)建工具，如Gradle）會把src/main/java目錄下的.java文件編譯成.class文件，并把它們和src/main/resources目錄下的資源文件一起復制到項目的輸出目錄（通常是target/classes目錄）。

??然后當你運行程序時，JVM會把target/classes目錄（即編譯后的src/main/java和src/main/resources）添加到類路徑中，這樣JVM就可以找到程序運行所需的類和資源了。

??如果有一個名為application.properties的文件在src/main/resources目錄下，就可以使用類路徑來訪問它，就像這樣：classpath:application.properties。在這里classpath:前綴告訴JVM這個路徑是相對于類路徑的，所以它會在類路徑中查找application.properties文件。因為src/main/resources在運行時被添加到了類路徑，所以JVM能找到這個文件。

8. 思考總結(jié)

8.1 為什么我們需要注冊組件，這與Bean注冊有什么區(qū)別？

??在Spring框架中，Bean對象是由Spring IoC容器創(chuàng)建和管理的。通常Bean對象是應用程序中的業(yè)務邏輯組件，如數(shù)據(jù)訪問對象（DAO）或其他服務類。

??組件注冊，或者說在Spring中通過@Component或者其派生注解（@Service, @Controller, @Repository等）標記的類，是告訴Spring框架這個類是一個組件，Spring需要創(chuàng)建它的實例并管理它的生命周期。這樣當使用到這個類的時候，Spring就可以自動地創(chuàng)建這個類的實例并注入到需要的地方。

??Bean注冊和組件注冊其實是非常類似的，都是為了讓Spring知道它需要管理哪些類的實例。區(qū)別在于Bean注冊通常發(fā)生在配置類中，使用@Bean注解來明確地定義每一個Bean，而組件注冊則是通過在類上使用@Component或者其派生注解來告訴Spring，這個類是一個組件，Spring應該自動地為其創(chuàng)建實例。

8.2 什么是組件掃描，為什么我們需要它，它是如何工作的？

??組件掃描是Spring的一種機制，用于自動發(fā)現(xiàn)應用程序中的Spring組件，并自動地為這些組件創(chuàng)建Bean定義，然后將它們注冊到Spring的應用上下文中，我們可以通過使用@ComponentScan注解來啟動組件掃描。

??我們需要組件掃描是因為它可以大大簡化配置過程，我們不再需要為應用程序中的每個類都顯式地創(chuàng)建Bean。而是通過簡單地在類上添加@Component或者其派生注解，并啟動組件掃描，就可以讓Spring自動地為我們的類創(chuàng)建Bean并管理它們。

??組件掃描的工作過程如下：使用@ComponentScan注解并指定一個或多個包路徑時，Spring會掃描這些包路徑及其子包中的所有類。對于標記了@Component或者其派生注解的類，Spring會在應用上下文啟動時為它們創(chuàng)建Bean，并將這些Bean定義注冊到Spring的應用上下文中。當需要使用這些類的實例時，Spring就可以自動注入這些實例。文章來源地址http://www.zghlxwxcb.cn/news/detail-460717.html

到了這里，關(guān)于Spring高手之路——深入理解注解驅(qū)動配置與XML配置的融合與區(qū)別的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！