Spring筆記(2) - 生命週期/屬性賦值/自動裝配

一.生命週期

@Bean自定義初始化和銷燬方法

//====xml方式： init-method和destroy-method====
    <bean id="person" class="com.hrh.bean.Person" scope="singleton" init-method="" destroy-method="">
        <property name="name" value="張三"></property>
        <property name="age" value="20"></property>
    </bean>
//====@Bean方式====
/**
 *單實例：只調用initMethod一次，容器關閉時會調用destroyMethod
 *多實例: 每次調用Bean都調用initMethod，容器關閉不會調用destroyMethod，需要手動調用
 **/
    @Bean(initMethod = "",destroyMethod = "")
    public Person person() {
        System.out.println("注入容器。。。。。");
        return new Person("張三", 20);
    }
//====實現接口方式====
/**
 * InitializingBean：定義初始化邏輯，實現afterPropertiesSet()
 * DisposableBean：定義銷燬邏輯，實現destroy()
 */
@Component
public class Person implements InitializingBean, DisposableBean {
    public Person(){
        System.out.println("Person 。。。 constructor");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Person 。。。afterPropertiesSet");
    }

    @Override
    public void destroy() throws DestroyFailedException {
        System.out.println("Person 。。。destroy");
    }
}
@Configurable
@ComponentScan(value = "com.hrh")
public class BeanConfig {}

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
context.close();

@PostConstruct和@PreDestroy

/**
 * JSR250:
 *  @PostConstruct: 在bean創建完成並且屬性賦值完成後，來執行初始化方法
 *  @PreDestroy ：在容器銷燬bean之前通知進行清理工作
 */
@Component
public class Color {
    public Color() {
        System.out.println("Color 。。。 constructor");
    }

    @PostConstruct//對象創建並賦值之後調用
    public void init() throws Exception {
        System.out.println("Color 。。。init");
    }

    @PreDestroy//容器移除對象之前
    public void destroy() {
        System.out.println("Color 。。。destroy");
    }
}

BeanPostProcessor：bean後置處理器，對bean初始化之前和之後的處理，上文的@PostConstruct和@PreDestroy就是使用了該類實現的

    @Component
    public class MyBeanPostProcessor implements BeanPostProcessor {
        /**
         *
         * @param bean 容器創建的實例
         * @param beanName 容器創建實例的名字
         * @return 創建的實例或進行包裝後的實例
         * @throws BeansException
         */
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("postProcessBeforeInitialization====>【"+bean+"】："+beanName);
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("postProcessAfterInitialization====>【"+bean+"】："+beanName);
            return bean;
        }
    }
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
    }

原理：從doCreateBean可以看到，在對bean進行屬性賦值後，調用initializeBean初始化bean，在initializeBean中會在調用初始化方法前後會遍歷所有的BeanPostProcessor實現的方法

    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        ....
        refresh();//刷新容器
    }
    public void refresh() throws BeansException, IllegalStateException {
        ...
        //初始化剩下所有的(非懶加載的）單實例對象
        finishBeanFactoryInitialization(beanFactory);
    }
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        ...
        //初始化剩下所有的(非懶加載的）單實例對象
        beanFactory.preInstantiateSingletons();
    }
    public void preInstantiateSingletons() throws BeansException {
        ...
        getBean(beanName);
        ...
    }
    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }
    protected <T> T doGetBean(
                final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
                throws BeansException {
        ...
        //getSingleton獲取實例
        sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                try {
                    return createBean(beanName, mbd, args);//創建實例
                }
                ...
            }
        });
        ...
        return (T) bean;
    }

    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        ...
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);//創建實例
        ...
        return beanInstance;
    }
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        ...
        Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);//對屬性賦值
            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);//初始化對象，相當後置處理器的調用
            }
        }
        ...
        return exposedObject;
    }
    //從下面可以看到，在執行初始化方法之前，執行applyBeanPostProcessorsBeforeInitialization，執行完初始化方法之後，執行applyBeanPostProcessorsAfterInitialization
    protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        ...
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        ...
        invokeInitMethods(beanName, wrappedBean, mbd);//執行初始化方法
        ...
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        return wrappedBean;
    }
    @Override
    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {
        Object result = existingBean;
        //遍歷執行BeanPostProcessor
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }

InitDestroyAnnotationBeanPostProcessor：處理@PostConstruct和@PreDestroy

    /**
     *  處理javax.annotation.PostConstruct註解
     */
    public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
        this.initAnnotationType = initAnnotationType;
    }
    /**
     *  處理javax.annotation.PreDestroy註解
     */
    public void setDestroyAnnotationType(Class<? extends Annotation> destroyAnnotationType) {
        this.destroyAnnotationType = destroyAnnotationType;
    }
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //找到了使用@PostConstruct和@PreDestroy的類的生命週期註解
        LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
        try {
            //對每個註解上的方法進行反射執行
            metadata.invokeInitMethods(bean, beanName);
        }
        catch (InvocationTargetException ex) {
            throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
        }
        return bean;
    }
    public void invokeInitMethods(Object target, String beanName) throws Throwable {
        Collection<LifecycleElement> checkedInitMethods = this.checkedInitMethods;
        Collection<LifecycleElement> initMethodsToIterate =
                (checkedInitMethods != null ? checkedInitMethods : this.initMethods);
        if (!initMethodsToIterate.isEmpty()) {
            for (LifecycleElement element : initMethodsToIterate) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Invoking init method on bean '" + beanName + "': " + element.getMethod());
                }
                //element包含註解和註解上的方法 
                element.invoke(target);//執行每個註解上的方法
            }
        }
    }

二.屬性賦值

@Value

public class Person {
    /**
     * @Value :基本數值，SpEL表達式 #{}, ${}獲取配置文件的值
     */
    @Value("張三")
    private String name;
    @Value("#{20-1}")
    private Integer age;
}

@PropertySource：讀取外部配置文件中k/v的數據

public class Person{
    /**
     * @Value :基本數值，SpEL表達式 #{}, ${}獲取配置文件的值
     */
    @Value("張三")
    private String name;
    @Value("#{20-1}")
    private Integer age;
    @Value("${sex}")
    private String sex;
}
@PropertySource(value = "classpath:/global.properties")
@Configurable
public class BeanConfig {}

global.properties
sex=男

三.自動裝配

@Autowired&@Qualifier&@Primary：Spring定義

@Service
public class UserService {
    /**
     * @Autowired :自動注入
     * 1）默認優先按照類型去容器中對應的組件：context.getBean(UserDao.class);
     * 2）如果有多少相同類型的組件，需要將屬性的名稱作爲id去容器查找：(UserDao) context.getBean("userDao1")
     * 3）@Qualifier("userDao1")：指定需要裝配的組件id，而不是使用默認屬性;優先級比@Primary高
     * 4）如果UserDao沒有注入容器(@Repository和 @Bean)：啓用@Autowired會報空指針異常，需要required = false，表示從容器中找到就自動裝配，找不到就設爲null
     * 5)@Primary表示Spring自動裝配時，默認使用首選的bean
     */
    @Qualifier("userDao")
    @Autowired
    private UserDao userDao;

    public void printf() {
        System.out.println(userDao);
    }
}
@Repository
public class UserDao {
    private String id ="1";

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "UserDao{" +
                "id='" + id + '\'' +
                '}';
    }
}
@Configurable
@ComponentScan(value = "com.hrh")
public class BeanConfig {
    @Primary
    @Bean("userDao1")
    public UserDao userDao() {
        UserDao userDao = new UserDao();
        userDao.setId("2");
        return userDao;
    }
}
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanConfig.class);
UserService person = context.getBean(UserService.class);
person.printf();
//UserDao userDao = context.getBean(UserDao.class);
UserDao userDao =(UserDao) context.getBean("userDao1");
System.out.println(userDao);

@Resource&@Inject：Java規範
1. @Resource：只按照屬性名稱進行裝配，可以使用@Resource(name = "")裝配指定id；不支持@Primary的使用，即使用該註解是無效的；
2. @Inject：支持自動裝配，和@Autowired功能一樣，支持@Primary的使用；沒有required = false屬性；

Aware注入Spring底層組件&原理

自定義組件使用Spring容器底層的一些組件(ApplicationContext、BeanFactory...），實現xxxAware

public class Color  implements ApplicationContextAware {
    private ApplicationContext applicationContext;
    //獲取容器並賦值給當前類
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

xxxAware使用對應的xxxAwareProcessor進行處理：利用後置處理器在類初始化時注入組件

    //bean：獲得實現了ApplicationContextAware接口的類，即Color
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //類型判斷
        if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
            return bean;
        }

        AccessControlContext acc = null;

        if (System.getSecurityManager() != null) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            //權限檢查
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareInterfaces(bean);
                return null;
            }, acc);
        }
        else {
            invokeAwareInterfaces(bean);//轉換並注入組件
        }

        return bean;
    }

    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
        }
        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }
        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
        }
        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
        }
        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
        }
        if (bean instanceof ApplicationContextAware) {
            //給當前類注入ApplicationContext
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }

@Profile：指定組件在哪個環境的情況下才能被註冊到容器中

加了環境標識的bean，只有在指定環境才能被註冊到容器中，默認是default環境
寫在配置類上，只有是指定環境整個配置類裏面的所有配置才能生效

沒有環境標識的bean在任何環境下都會被註冊到容器中

@PropertySource("classpaht:/db.properties")
@Configuration
public class BeanProfileConfig {
    @Value("${db.user}")
    private String user;
    @Value("${db.driverClass}")
    private String driverClass;

    @Profile("test")
    @Bean
    public DataSource TestDateSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Profile("dev")
    @Bean
    public DataSource DevDateSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/dev");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Profile("pro")
    @Bean
    public DataSource ProDateSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/pro");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }
}
/**
 * 1.使用命令行動態參數：在虛擬機參數位置加載 -Dspring.profiles.active=test
 * 2.代碼方式：創建無參容器，設置激活環境
 */
//創建容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//設置需要激活的環境
context.getEnvironment().setActiveProfiles("test");
//註冊主配置類
context.register(BeanProfileConfig.class);
//啓動刷新容器
context.refresh();

Spring筆記(2) - 生命週期/屬性賦值/自動裝配

一.生命週期

@Bean自定義初始化和銷燬方法

@PostConstruct和@PreDestroy

BeanPostProcessor：bean後置處理器，對bean初始化之前和之後的處理，上文的@PostConstruct和@PreDestroy就是使用了該類實現的

原理：從doCreateBean可以看到，在對bean進行屬性賦值後，調用initializeBean初始化bean，在initializeBean中會在調用初始化方法前後會遍歷所有的BeanPostProcessor實現的方法

InitDestroyAnnotationBeanPostProcessor：處理@PostConstruct和@PreDestroy

二.屬性賦值

@Value

@PropertySource：讀取外部配置文件中k/v的數據

三.自動裝配

@Autowired&@Qualifier&@Primary：Spring定義

@Resource&@Inject：Java規範

@Resource：只按照屬性名稱進行裝配，可以使用@Resource(name = "")裝配指定id；不支持@Primary的使用，即使用該註解是無效的；

@Inject：支持自動裝配，和@Autowired功能一樣，支持@Primary的使用；沒有required = false屬性；

Aware注入Spring底層組件&原理

自定義組件使用Spring容器底層的一些組件(ApplicationContext、BeanFactory...），實現xxxAware

xxxAware使用對應的xxxAwareProcessor進行處理：利用後置處理器在類初始化時注入組件

@Profile：指定組件在哪個環境的情況下才能被註冊到容器中

.Net 8.0 下的新RPC，IceRPC之試試的新玩法"打洞"

關於遊戲付費的一點想法

我通過CKA和CKS啦！

《最新出爐》系列入門篇-Python+Playwright自動化測試-42-強大的可視化追蹤利器Trace Viewer

大數據怎麼學？對大數據開發領域及崗位的詳細解讀，完整理解大數據開發領域技術體系

nacos適配SqlServer、Oracle nacos適配達夢、瀚高、人大金倉數據庫及部分源碼探究

nacos適配達夢、瀚高、人大金倉數據庫及部分源碼探究

Feign踩坑源碼分析--@FeignClient注入容器

Feign踩坑源碼分析 -- 請求參數分號變逗號

Quartz動態設置併發數量

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結