目錄
- 註解開發簡介
- 常用註解
- 啟用註解功能
- bean 定義：@Component、@Controller、@Service、@Repository
- bean 的引用型別屬性注入：@Autowired、@Qualifier
- bean 的引用型別屬性注入：@Inject、@Named、@Resource
- bean 的引用型別屬性注入：@Primary
- bean 的非引用型別屬性注入：@Value
- bean 的作用域：@Scope
- bean 的生命週期：@PostConstruct、@PreDestroy
- 載入第三方資源：@Bean
- 載入 properties 檔案：@PropertySource
- 純註解開發：@Configuration、@ComponentScan
- 匯入第三方配置：@Import
- 綜合案例
- 整合第三方技術
- IoC 底層核心原理
註解開發簡介
註解開發的好處：使用註解的形式替代 xml 配置，將繁雜的 Spring 配置檔案從工程中徹底消除掉，簡化書寫。
註解驅動的弊端：
-
為了達成註解驅動的目的，可能會將原先很簡單的書寫，變得更加複雜。
-
XML 中配置第三方開發的資源是很方便的，但使用註解驅動無法在第三方開發的資源中進行編輯，因此會增大開發工作量。
常用註解
Spring 原始註解：主要是替代 <Bean> 的配置。
| 註解 | 說明 |
|---|---|
| @Component | 使用在類上用於例項化 Bean |
| @Controller | 使用在 web 層類上用於例項化 Bean |
| @Service | 使用在 service 層類上用於例項化 Bean |
| @Repository | 使用在 dao 層類上用於例項化 Bean |
| @Autowired | 使用在欄位上用於根據型別依賴注入 |
| @Qualifier | 結合 @Autowired 一起使用，用於根據名稱進行依賴注入引用型別 |
| @Resource | 相當於 @Autowired + @Qualifier，按照名稱進行注入引用型別 |
| @Value | 注入普通型別的屬性 |
| @Scope | 標註 Bean 的作用範圍 |
| @PostConstruct | 使用在方法上標註該方法是 Bean 的初始化方法 |
| @PreDestroy | 使用在方法上標註該方法是 Bean 的銷燬方法 |
Spring 新註解：
使用上面的註解還不能全部替代 xml 配置檔案，還需要使用註解替代的配置如下：
- 非自定義的Bean的配置：<bean>
- 載入properties檔案的配置：<context:property-placeholder>
- 元件掃描的配置：<context:component-scan>
- 引入其他檔案：<import>
| 註解 | 說明 |
|---|---|
| @Configuration | 用於指定當前類是一個 Spring 配置類，當建立容器時會從該類上載入註解。用於指定 Spring 在初始化容器時要掃描的包。 |
| @ComponentScan | 作用和在 Spring 的 xml 配置檔案中的 <context:component-scan base-package="com.itheima"/> 一樣。 |
| @Bean | 使用在方法上，標註將該方法的返回值儲存到 Spring 容器中。 |
| @PropertySource | 用於載入 .properties 檔案中的配置。 |
| @Import | 用於匯入其他配置類。 |
啟用註解功能
- 啟動註解掃描，載入類中配置的註解項：
<context:component-scan base-package="packageName"/>
-
說明：
-
在進行包所掃描時，會對配置的包及其子包中所有檔案進行掃描。
-
掃描過程是以資料夾遞迴迭代的形式進行的。
-
掃描過程僅讀取合法的 java 檔案。
-
掃描時僅讀取 spring 可識別的註解。
-
掃描結束後會將可識別的有效註解轉化為 spring 對應的資源加入 IoC 容器。
-
-
注意：
-
無論是註解格式還是 XML 配置格式，最終都是將資源載入到 IoC 容器中，差別僅僅是資料讀取方式不同。
-
從載入效率上來說，註解優於 XML 配置檔案。
-
bean 定義：@Component、@Controller、@Service、@Repository
-
型別：類註解
-
位置：類定義上方。
-
作用：設定該類為 spring 管理的 bean 。
-
示例：
@Component
public class ClassName{}
-
說明：@Controller、@Service 、@Repository 是 @Component 的衍生註解，功能同 @Component 。
-
相關屬性：
- value(預設) ：定義 bean 的訪問 id 。
bean 的引用型別屬性注入：@Autowired、@Qualifier
-
型別：屬性註解、方法註解
-
位置：屬性定義上方，方法定義上方。
-
作用：設定對應屬性的物件或對方法進行引用型別傳參。
-
說明：@Autowired 預設按型別裝配，指定 @Qualifier 後則可以指定裝配的 bean 的 id 。
-
相關屬性：
- required：定義該屬性是否允許為 null 。
bean 的引用型別屬性注入：@Inject、@Named、@Resource
-
說明：
- @Inject 與 @Named 是 JSR330 規範中的註解，功能與 @Autowired 和 @Qualifier 完全相同，適用於不同架構場景。
- @Resource 是 JSR250 規範中的註解，可以簡化書寫格式。
-
@Resource 相關屬性：
-
name：設定注入的 bean 的 id 。
-
type：設定注入的 bean 的型別，接收的引數為 Class 型別。
-
bean 的引用型別屬性注入：@Primary
-
型別：類註解
-
位置：類定義上方。
-
作用：設定類對應的bean按型別裝配時優先裝配。
-
說明：@Autowired 預設按型別裝配，當出現相同型別的 bean，使用 @Primary 會提高按型別自動裝配的優先順序，但多個 @Primary 會導致優先順序設定無效。
bean 的非引用型別屬性注入：@Value
-
型別：屬性註解、方法註解
-
位置：屬性定義上方，方法定義上方。
-
作用：設定對應屬性的值或對方法進行傳參。
-
說明：
-
value 值僅支援非引用型別資料，賦值時對方法的所有引數全部賦值。
-
value 值支援讀取 properties 檔案中的屬性值，通過類屬性將 properties 中資料傳入類中。
-
value 值支援 SpEL 。
-
@value 註解如果新增在屬性上方，可以省略 set 方法（set 方法的目的是為屬性賦值）。
-
bean 的作用域：@Scope
-
型別：類註解
-
位置：類定義上方。
-
作用：設定該類作為 bean 對應的 scope 屬性。
-
相關屬性
- value(預設)：定義 bean 的作用域，預設為 singleton 。
bean 的生命週期：@PostConstruct、@PreDestroy
-
型別：方法註解
-
位置：方法定義上方。
-
作用：設定該類作為 bean 對應的生命週期方法。
載入第三方資源：@Bean
-
型別：方法註解
-
位置：方法定義上方。
-
作用：設定該方法的返回值作為 spring 管理的 bean 。
-
範例：
@Bean("dataSource")
public DruidDataSource createDataSource() { return ……; }
-
說明：
-
因為第三方 bean 無法在其原始碼上進行修改，因此可以使用 @Bean 解決第三方 bean 的引入問題。
-
該註解用於替代 XML 配置中的靜態工廠與例項工廠建立 bean，不區分方法是否為靜態或非靜態。
-
@Bean 所在的類必須被 spring 掃描載入，否則該註解無法生效。
-
-
相關屬性
- value(預設)：定義 bean 的訪問 id 。
載入 properties 檔案：@PropertySource
-
型別：類註解
-
位置：類定義上方。
-
作用：載入 properties 檔案中的屬性值。
-
範例：
@PropertySource(value="classpath:jdbc.properties")
public class ClassName {
@Value("${propertiesAttributeName}")
private String attributeName;
}
-
說明：不支援*通配格式，一旦載入，所有 spring 控制的 bean 中均可使用對應屬性值
-
相關屬性
-
value(預設)：設定載入的 properties 檔名。
-
ignoreResourceNotFound：如果資源未找到，是否忽略，預設為 false 。
-
純註解開發：@Configuration、@ComponentScan
-
型別：類註解
-
位置：類定義上方。
-
作用：設定當前類為 spring 核心配置載入類（不再需要 spring 配置檔案）。
-
範例：
@Configuration
@ComponentScan("scanPackageName")
public class SpringConfigClassName{
}
- 說明：
- 核心配合類用於替換 spring 核心配置檔案，此類可以設定空的，不設定變數與屬性。
- bean 掃描工作使用註解 @ComponentScan 替代。
- 載入純註解格式上下文物件，需要使用 AnnotationConfigApplicationContext：
```java
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
匯入第三方配置：@Import
-
型別：類註解
-
位置：類定義上方。
-
作用：匯入第三方 bean 作為 spring 控制的資源。
-
範例：
@Configuration
@Import(OtherClassName.class)
public class ClassName {
}
-
說明：
-
@Import 註解在同一個類上，僅允許新增一次，如果需要匯入多個，使用陣列的形式進行設定。
-
在被匯入的類中可以繼續使用 @Import 匯入其他資源（瞭解）。
-
@Bean 所在的類可以使用匯入的形式進入 spring 容器，無需宣告為 bean 。
-
綜合案例
maven 依賴：
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
</dependencies>
spring 配置類
DataSourceConfig.java：
package com.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
// 資料來源配置類
// 相當於 <context:property-placeholder location="classpath:jdbc.properties"/>，且不能用萬用字元*
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfig {
@Value("${jdbc.driver}")
private static String driver;
@Value("${jdbc.url}")
private static String url;
@Value("${jdbc.username}")
private static String username;
@Value("${jdbc.password}")
private static String password;
@Bean("dataSource") // 將方法的返回值放置Spring容器中
public static DruidDataSource getDataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
}
SpringConfig.java：
package com.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
// Spring核心配置類
@Configuration
@ComponentScan("com") // 相當於 <context:component-scan base-package="com"/>
@Import({DataSourceConfig.class}) // 相當於 <import resource=""/>
public class SpringConfig {
}
dao 層
UserDaoImpl.java：
package com.dao.impl;
import com.dao.UserDao;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
// 相當於 <bean id="UserDao" ref="com.dao.impl.UserDaoImpl"/>
// @Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {
@Override
public void save() {
System.out.println("UserDao save...");
}
}
service 層
UserServiceImpl.java：
package com.service.impl;
import com.dao.UserDao;
import com.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import javax.sql.DataSource;
// 相當於 <bean id="UserService" ref="com.service.impl.UserServiceImpl"/>
// @Component("userService")
@Service("userService")
public class UserServiceImpl implements UserService {
// <property name="userDao" ref="userDao"></property>
// @Autowired // 可單獨使用，按照資料型別從spring容器中進行匹配的（有多個相同資料型別的bean時則會有匹配問題）
// @Qualifier("userDao") // 指定bean的id從spring容器中匹配，且要結合@Autowired一起用
@Resource(name="userDao") // 相當於 @Autowired+@Autowired
UserDao userDao;
@Resource(name="dataSource")
DataSource dataSource;
@Value("${jdbc.driver}") // 讀取配置檔案中的值
private String driver;
/* 使用註解開發可以省略set方法，使用配置檔案則不能省略
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
*/
@Override
public void save() {
System.out.println("driver: "+driver);
System.out.println("dataSource: "+dataSource);
userDao.save();
}
@PostConstruct
public void init() {
System.out.println("service物件的初始化方法");
}
@PreDestroy
public void destroy() {
System.out.println("service物件的銷燬方法");
}
}
controller 層
App.java：
package com.controller;
import com.config.SpringConfig;
import com.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class App {
public static void main(String[] args) {
// ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = (UserService)context.getBean("userService");
userService.save();
context.close();
}
}
執行結果：
service物件的初始化方法
dataSource: {
CreateTime:"2021-12-03 01:05:00",
ActiveCount:0,
PoolingCount:0,
CreateCount:0,
DestroyCount:0,
CloseCount:0,
ConnectCount:0,
Connections:[
]
}
UserDao save...
service物件的銷燬方法
整合第三方技術
註解整合 Mybatis
註解整合 MyBatis 的開發步驟：
- 修改 mybatis 外部配置檔案格式為註解格式；
- 業務類使用 @Component 宣告 bean，使用 @Autowired 注入物件；
- 建立配置檔案 JDBCConfig 與 MyBatisConfig 類，並將其匯入到核心配置類 SpringConfig；
- 開啟註解掃描；
- 使用 AnnotationConfigApplicationContext 物件載入配置項。
核心內容如下：
- Maven 依賴：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.11</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.8.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.3</version>
</dependency>
- MybatisConfig.java（Mybatis 配置類）：
package com.config;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class MybatisConfig {
/*
<!-- spring整合mybatis後，建立連線用的物件 -->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="typeAliasesPackage" value="com.domain"/>
</bean>
<!-- 掃描mybatis對映配置，將其作為spring的bean進行管理 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.dao"/>
</bean>
*/
// 以下註解代替以上配置檔案內容：返回值會作為Spring容器的bean
@Bean
public SqlSessionFactoryBean getSqlSessionFactoryBean(@Autowired DataSource dataSource) {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
sqlSessionFactoryBean.setTypeAliasesPackage("com.domain");
return sqlSessionFactoryBean;
}
@Bean
public MapperScannerConfigurer getMapperScannerConfigurer() {
MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
mapperScannerConfigurer.setBasePackage("com.dao");
return mapperScannerConfigurer;
}
}
- SpringConfig.java（Spring 核心配置類）：
package com.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@ComponentScan("com") // 相當於 <context:component-scan base-package="com"/>
@Import({DataSourceConfig.class, MybatisConfig.class}) // 相當於 <import resource=""/>
public class SpringConfig {
}
註解整合 Junit
註解整合 Junit 的開發步驟：
- Spring 接管 Junit 的執行權，使用 Spring 專用的 Junit 類載入器；
2.為 Junit 測試用例設定對應的 Spring 容器：
-
從 Spring 5.0 以後，要求 Junit 的版本必須是 4.12 或以上。
-
Junit 僅用於單元測試，不能將 Junit 的測試類配置成 Spring 的 bean，否則該配置將會被打包進入工程中。
示例：整合 Junit5
- Maven 依賴：
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
- 測試類：
package com.service;
import com.config.SpringConfig;
import com.domain.User;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import java.util.List;
// 設定spring專用的類載入器
@ExtendWith(SpringExtension.class)
// 設定載入的spring上下文對應的配置
@ContextConfiguration(classes=SpringConfig.class)
public class UserServiceTest {
@Autowired
UserService userService;
@Test
public void testFindById() {
User user = userService.findById(1);
// System.out.println(user);
Assertions.assertEquals("Mick", user.getName());
}
@Test
public void testFindAll() {
List<User> users = userService.findAll();
Assertions.assertEquals(3, users.size());
}
}
IoC 底層核心原理
IoC 核心介面
元件掃描器：@ComponentScan
元件掃描器：開發過程中，需要根據需求載入必要的 bean 或排除指定 bean。
應用場景：
- 資料層介面測試
- 業務層介面測試
- 各種執行環境設定
配置掃描器
-
名稱：@ComponentScan
-
型別：類註解
-
位置：類定義上方
-
作用：設定 spring 配置載入類掃描規則
-
範例：
@Configuration
@ComponentScan(
value="com", // 設定基礎掃描路徑
excludeFilters = // 設定過濾規則，當前為排除過濾
@ComponentScan.Filter( // 設定過濾器
type= FilterType.ANNOTATION, // 設定過濾方式為按照註解進行過濾
classes=Repository.class) // 設定具體的過濾項。如不載入所有@Repository修飾的bean
)
public class SpringConfig {
}
-
includeFilters：設定包含性過濾器
-
excludeFilters：設定排除性過濾器
-
type：設定過濾器型別（過濾策略）
- ANNOTATION
- ASSIGNABLE_TYPE
- ASPECTJ
- REGEX
- CUSTOM
自定義掃描器
-
名稱：TypeFilter
-
型別：介面
-
作用：自定義型別過濾器
示例:
- 自定義掃描器
public class MyTypeFilter implements TypeFilter {
public boolean match(MetadataReader mr, MetadataReaderFactory mrf) throws IOException {
ClassMetadata cm = metadataReader.getClassMetadata();
tring className = cm.getClassName();
if(className.equals("com.itheima.dao.impl.BookDaoImpl")){
return true; // 進行過濾（攔截）
}
return false; // 不過濾（放行）
}
}
- 配置類：
@Configuration
@ComponentScan(
value = "com",
excludeFilters = @ComponentScan.Filter(
type= FilterType.CUSTOM,
classes = MyTypeFilter.class
)
)
public class SpringConfig {
}
自定義匯入器：ImportSelector
bean 只有通過配置才可以進入 spring 容器，被 spring 載入並控制。配置 bean 的方式如下：
-
XML 檔案中使用 <bean/> 標籤配置
-
使用 @Component 及衍生註解配置
企業開發過程中，通常需要配置大量的 bean，因此需要一種快速高效配置大量 bean 的方式。
ImportSelector 註解：
-
型別：介面
-
作用：自定義 bean 匯入器（匯入未加 @Component 註解的 bean）
示例：
- 自定義匯入器：
public class MyImportSelector implements ImportSelector {
public String[] selectImports(AnnotationMetadata icm) {
// 返回需要匯入的bean陣列。該bean即使沒加@Component註解也能被掃描識別
return new String[]{"com.dao.impl.AccountDaoImpl"};
}
}
- 配置類：
@Configuration
@ComponentScan("com")
@Import(MyImportSelector.class) // 匯入自定義匯入器
public class SpringConfig {
}
自定義匯入器的封裝工具類：
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AspectJTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import java.io.IOException;
import java.util.HashSet;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class CustomerImportSelector implements ImportSelector {
private String expression;
public CustomerImportSelector(){
try {
//初始化時指定載入的properties檔名
Properties loadAllProperties = PropertiesLoaderUtils.loadAllProperties("import.properties");
//設定載入的屬性名
expression = loadAllProperties.getProperty("path");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
//1.定義掃描包的名稱
String[] basePackages = null;
//2.判斷有@Import註解的類上是否有@ComponentScan註解
if (importingClassMetadata.hasAnnotation(ComponentScan.class.getName())) {
//3.取出@ComponentScan註解的屬性
Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(ComponentScan.class.getName());
//4.取出屬性名稱為basePackages屬性的值
basePackages = (String[]) annotationAttributes.get("basePackages");
}
//5.判斷是否有此屬性（如果沒有ComponentScan註解則屬性值為null，如果有ComponentScan註解，則basePackages預設為空陣列）
if (basePackages == null || basePackages.length == 0) {
String basePackage = null;
try {
//6.取出包含@Import註解類的包名
basePackage = Class.forName(importingClassMetadata.getClassName()).getPackage().getName();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//7.存入陣列中
basePackages = new String[] {basePackage};
}
//8.建立類路徑掃描器
ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
//9.建立型別過濾器(此處使用切入點表示式型別過濾器)
TypeFilter typeFilter = new AspectJTypeFilter(expression,this.getClass().getClassLoader());
//10.給掃描器加入型別過濾器
scanner.addIncludeFilter(typeFilter);
//11.建立存放全限定類名的集合
Set<String> classes = new HashSet<>();
//12.填充集合資料
for (String basePackage : basePackages) {
scanner.findCandidateComponents(basePackage).forEach(beanDefinition -> classes.add(beanDefinition.getBeanClassName()));
}
//13.按照規則返回
return classes.toArray(new String[classes.size()]);
}
}
自定義註冊器：ImportBeanDefinitionRegistrar
-
型別：介面
-
作用：自定義 bean 定義註冊器（識別標記了 @Component 的 bean）
示例：
- 自定義註冊器：
// 表示com目錄下的bean全部註冊
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
public void registerBeanDefinitions(AnnotationMetadata icm, BeanDefinitionRegistry r) {
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(r, false);
TypeFilter tf = new TypeFilter() {
public boolean match(MetadataReader mr, MetadataReaderFactory mrf) throws IOException {
return true;
}
};
scanner.addIncludeFilter(tf); // 包含
// scanner.addExcludeFilter(tf); // 排除
scanner.scan("com");
}
}
- 配置類：
@Configuration
@Import(MyImportBeanDefinitionRegistrar.class) // 作用等同於 @ComponentScan("com")
public class SpringConfig {
}
封裝工具類：
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.filter.AspectJTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;
public class CustomeImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
private String expression;
public CustomeImportBeanDefinitionRegistrar(){
try {
//初始化時指定載入的properties檔名
Properties loadAllProperties = PropertiesLoaderUtils.loadAllProperties("import.properties");
//設定載入的屬性名
expression = loadAllProperties.getProperty("path");
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//1.定義掃描包的名稱
String[] basePackages = null;
//2.判斷有@Import註解的類上是否有@ComponentScan註解
if (importingClassMetadata.hasAnnotation(ComponentScan.class.getName())) {
//3.取出@ComponentScan註解的屬性
Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(ComponentScan.class.getName());
//4.取出屬性名稱為basePackages屬性的值
basePackages = (String[]) annotationAttributes.get("basePackages");
}
//5.判斷是否有此屬性（如果沒有ComponentScan註解則屬性值為null，如果有ComponentScan註解，則basePackages預設為空陣列）
if (basePackages == null || basePackages.length == 0) {
String basePackage = null;
try {
//6.取出包含@Import註解類的包名
basePackage = Class.forName(importingClassMetadata.getClassName()).getPackage().getName();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//7.存入陣列中
basePackages = new String[] {basePackage};
}
//8.建立類路徑掃描器
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, false);
//9.建立型別過濾器(此處使用切入點表示式型別過濾器)
TypeFilter typeFilter = new AspectJTypeFilter(expression,this.getClass().getClassLoader());
//10.給掃描器加入型別過濾器
scanner.addIncludeFilter(typeFilter);
//11.掃描指定包
scanner.scan(basePackages);
}
}
bean 初始化過程解析
bean 統一初始化
-
BeanFactoryPostProcessor
-
作用：定義了在 bean 工廠物件建立後，bean 物件建立前執行的動作，用於對工廠進行建立後業務處理。
-
執行時機：當前操作用於對工廠進行處理，僅執行一次。
-
-
BeanPostProcessor
-
作用：定義了所有 bean 初始化前後進行的統一動作，用於對 bean 進行建立前業務處理與建立後業務處理。
-
執行時機：當前操作伴隨著每個 bean 的建立過程，每次建立 bean 均執行該操作。
-
-
InitializingBean
-
作用：定義了每個 bean 的初始化前進行的動作，屬於非統一性動作，用於對 bean 進行建立前業務處理。
-
執行時機：當前操作伴隨著任意一個 bean 的建立過程，保障其個性化業務處理。
-
-
注意：上述操作均需要被 spring 容器載入方可執行。
示例：
- BeanFactoryPostProcessor：
package com.post;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
public class MyBeanFactory implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
System.out.println("Bean工廠製作好了");
}
}
- BeanPostProcessor：
package com.post;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBean implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean之前巴拉巴拉");
System.out.println(beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean之後巴拉巴拉");
return bean;
}
}
- InitializingBean：
package com.service.impl;
import com.dao.UserDao;
import com.domain.User;
import com.service.UserService;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
@Service("userService")
public class UserServiceImpl implements InitializingBean {
// 定義當前bean初始化操作，功效等同於init-method屬性配置
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("UserServiceImpl......bean ...init......");
}
}
- 執行結果：
Bean工廠製作好了
bean之前巴拉巴拉
springConfig
bean之後巴拉巴拉
bean之前巴拉巴拉
com.config.DataSourceConfig
bean之後巴拉巴拉
bean之前巴拉巴拉
dataSource
bean之後巴拉巴拉
bean之前巴拉巴拉
getSqlSessionFactoryBean
bean之後巴拉巴拉
bean之後巴拉巴拉
bean之前巴拉巴拉
userDao
bean之後巴拉巴拉
bean之後巴拉巴拉
bean之前巴拉巴拉
userService
UserServiceImpl......bean ...init......
bean之後巴拉巴拉
bean之前巴拉巴拉
com.service.UserServiceTest.ORIGINAL
bean之後巴拉巴拉
單個 bean 初始化
- FactoryBean：對單一的 bean 的初始化過程進行封裝，達到簡化配置的目的。
FactoryBean 與 BeanFactory 區別：
-
FactoryBean：封裝單個 bean 的建立過程。通常是為了建立另一個 bean 而做的準備工作。
-
BeanFactory：Spring 容器頂層介面，統一定義了 bean 相關的獲取操作。
示例：
import org.springframework.beans.factory.FactoryBean;
public class UserServiceImplFactoryBean implements FactoryBean {
// 重點：返回資料
@Override
public Object getObject() throws Exception {
return new UserServiceImpl();
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}