作者： 清朝云

共计 156 个字符，预计需要花费 1 分钟才能阅读完成。

有时候想要下载别人随机图片，一个个保存非常麻烦，既然它是随机的图片，那么完全可以写个脚本进行保存，不过这种方式有可能存在相同文件。

for i in {1..200}
do
 wget https://www.dmoe.cc/random.php --no-check-certificate -O $i'.png'
done

结果如图：

提醒：本文发布于461天前，文中所关联的信息可能已发生改变，请知悉！

/>

共计 385 个字符，预计需要花费 1 分钟才能阅读完成。

有时候图床挂了，但是其他地方有备份站点时，可以通过如下方式进行修改图片地址。

例如，将 www.qcyqq.com/img 修改为 www.qcyqq.com。

// 更新图片链接
function replace_image_urls($content) {
    $pattern = '/<img([^>]*)data-original=["\']https?:\/\/img\.amjun\.com(.*?)["\'](.*?)>/i';
    $replacement = '<img$1data-original="https://www.qcyqq.com$2"$3>';
    $content = preg_replace($pattern, $replacement, $content);
    return $content;
}
add_filter('the_content', 'replace_image_urls');

提醒：本文发布于461天前，文中所关联的信息可能已发生改变，请知悉！

共计 468 个字符，预计需要花费 2 分钟才能阅读完成。

一、简介

EasyImage 是一款开源的图床，支持多文件上传，并且简单无数据库，返回图片 url 包括 markdown、bbscode、html 的格式。

它虽然名为简单图床，但是功能却很强。它能够支持 API，且支持压缩、去水印、转换格式，还支持鉴黄，设置黑名单和自定义代码等等。

二、安装

搭建代码如下：

docker run -d \
--name easyimage \
-p 80:80  \
ddsderek/easyimage

安装非常简单，部署好以后访问页面。进入如下页面，由于是 docker 安装，环境检测肯定是通过的，点击下一步即可。

/>

设置管理员账户和密码，并设置图片链接域名，这个链接域名就是返回的链接所包含的域名。

/>

三、配置和使用

1. 图床

下面的页面是后台设置页面，可以看见功能很多，具体相关设置就自行尝试了。

/>

批量上传图片效果如下：

/>

另外，统计界面如下，内容还是比较详细的。

/>

2. 文件床

虽然名为图床，但它可以关闭图床模式，也就可以上传任意文件，操作如下：

/>

并且还需要在上传设置中，配置允许的后缀名，清朝云这里设置为星号，也就是允许任意后缀。

/>

测试一下文件上传，效果如下：

提醒：本文发布于461天前，文中所关联的信息可能已发生改变，请知悉！

/>

共计 10577 个字符，预计需要花费 27 分钟才能阅读完成。

一、简介

spring 可以通过读取 xml 配置文件的方式，生成 bean 实例对象。

现有如下 beans.xml 配置文件和实体类与接口。

<?xml version="1.0" encoding="UTF-8"?>
<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="userService" class="com.amjun.spring.service.impl.UserServiceImpl">
    </bean>
</beans>

UserService.java

public interface UserService {

    void save();
}

UserServiceImpl.java

package com.amjun.spring.service.impl;

import com.amjun.spring.service.UserService;

public class UserServiceImpl implements UserService {

     @Override
    public void save() {

    }
}

可以通过 BeanFactory 创建容器。

public class BeanFactoryTest {

    public static void main(String[] args) {
        // 创建工程对象
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        // 创建xml文件读取器
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        // 读取配置文件给工厂
        reader.loadBeanDefinitions("beans.xml");
        // 去工厂获取实例
        UserService userService = (UserService)beanFactory.getBean("userService");
        System.out.println(userService);
    }
}

也可以通过 ApplicationContext 创建容器，但实际上 ApplicationContext 还是通过 BeanFactory 创建，并且他们创建实例的时机不通。

ApplicationContext 在加载配置文件时创建 bean 对象放入容器，BeanFactory 在获取 bean 对象时才创建，并放入容器。

public class BeanFactoryTest {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService)applicationContext.getBean("userService");
        System.out.println(userService);
    }
}

二、xml配置文件详解

Spring 开发中主要是对 Bean 的配置，Bean 的常用配置如下：

/>

1. 基础配置

这里的基础配置比较简单，这里只给出最终的 xml 文件和相关文件。

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <!-- 1. 可以配置 id 或者 别名，如果 id 和别名都不配置则可以通过全限定名进行获取对象
         2. 默认对象是单例模式 singleton，可设置为 prototype 多例模式(springmvc 情况下可以设置 request、session 域)
         3. lazy-init 配置懒加载，对于 beanfactory 无效，因为 beanfactory 是获取时才创建
         4. init-method 指定初始化方法，destroy-method 指定销毁方法 - 当容器显示关闭时执行
            除了指定 init-method，还可以通过实现 InitializingBean 接口的 afterPropertiesSet 方法实现初始化， 并在 init-method 之前执行
    -->
    <bean id="userService" name="alaisName,alaisName2" scope="singleton" lazy-init="false" init-method="init" destroy-method="destory"
          class="com.amjun.spring.service.impl.UserServiceImpl">
          <!--<constructor-arg name="name" value="abc"></constructor-arg>-->
        <property name="userMapper" ref="userMapper"></property>
    </bean>

    <bean id="userMapper" class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>
</beans>

UserService.java

public interface UserService {

    void save();
}

UserServiceImpl.java

public class UserServiceImpl implements UserService, InitializingBean {

    private String name;

    private UserMapper userMapper;

    public UserServiceImpl() {
        System.out.println("UserService实例化-无参构造");
    }

    public UserServiceImpl(String name) {
        System.out.println("UserService实例化-有参构造");
    }

    public void setUserMapper(UserMapper userMapper) {
        System.out.println("依赖注入userMapper");
        this.userMapper = userMapper;
    }

    public void init(){
        System.out.println("UserService初始化方法");
    }

    public void destory(){
        System.out.println("UserService销毁方法");
    }

    @Override
    public void save() {
        System.out.println("UserService 调用 userMapper 的 insert 方法");
        userMapper.insert();
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("执行afterPropertiesSet方法....");
    }
}

UserMapper.java

public interface UserMapper {

    void insert();
}

UserMapperImpl.java

public class UserMapperImpl implements UserMapper {

    public UserMapperImpl() {
        System.out.println("UserMapper实例化");
    }

    @Override
    public void insert() {
        System.out.println("用户信息入库");
    }
}

测试方法：

public class BeanFactoryTest {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService)applicationContext.getBean("userService");
        System.out.println(userService);
        userService.save();
        // 设置为多例模式每个对象都是新创建的
        UserService userService2 = (UserService)applicationContext.getBean("userService");
        System.out.println(userService2);
        applicationContext.close();
    }
}

2. 实例化bean的方式

2.1 构造方法实例化

默认就是使用无参构造方法进行实例化，如果需要有参构造方法实例化需要配置 constructor-arg 标签，且可以配置多个标签。

<bean id="userService" class="com.amjun.spring.service.impl.UserServiceImpl">
    <constructor-arg name="name" value="abc"></constructor-arg>
</bean>

2.2 工厂方式实例化

底层通过调用自定义的工厂方法对Bean进行实例化。

• 静态工厂实例化

public class MyBeanFactory1 {

    // 如果 userMapper 方法需要参数，同时配置 constructor-arg 即可
    public static UserMapper userMapper(){
        return new UserMapperImpl();
    }
}

xml 文件。

<bean id="userMapper1" class="com.amjun.spring.factory.MyBeanFactory1" factory-method="userMapper"></bean>

测试方法：

public class BeanFactoryTest {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserMapper userMapper1 = (UserMapper)applicationContext.getBean("userMapper1");
        System.out.println(userMapper1);
    }
}

静态工厂可以不创建工厂实例，通过静态方法创建对象。

/>

原理是 spring 解析配置文件时发现，需要生成的不是 MyBeanFactory1 对象，而是 userMapper 方法返回的对象。

好处：

1. bean 创建前后可以进行一些其他操作
2. 可以通过这种方式创建非自定义的 bean 交给 spring 进行管理（通过静态方法创建的bean）

• 实例工厂实例化

public class MyBeanFactory2 {

    // 如果 userMapper 方法需要参数，同时配置 constructor-arg 即可
    public UserMapper userMapper(){
        return new UserMapperImpl();
    }
}

xml 文件。

<bean id="myBeanFactory2" class="com.amjun.spring.factory.MyBeanFactory2"></bean>

<bean id="userMapper2" factory-bean="myBeanFactory2" factory-method="userMapper"></bean>

测试方法：

public class BeanFactoryTest {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserMapper userMapper2 = (UserMapper)applicationContext.getBean("userMapper2");
        System.out.println(userMapper2);
    }
}

可以看见先创建了工厂实例，再通过工厂方法创建实例。

/>

好处：

1. bean 创建前后可以进行一些其他操作
2. 可以通过这种方式创建非自定义的 bean 交给 spring 进行管理（通过实例对象创建的bean）

• 实现FactoryBean规范延迟实例化Bean

FactoryBean 是工厂 Bean， 注意和 BeanFactory 区分开。

FactoryBean 是一个接口。

public interface FactoryBean<T> {
    String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";

    @Nullable
    T getObject() throws Exception;

    @Nullable
    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

创建一个 MyBeanFactory3 实现 FactoryBean。

public class MyBeanFactory3 implements FactoryBean<UserMapper> {

    @Override
    public UserMapper getObject() throws Exception {
        return new UserMapperImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return UserMapper.class;
    }
}

xml 文件。

<bean id="userMapper3" class="com.amjun.spring.factory.MyBeanFactory3"></bean>

测试方法：

public class BeanFactoryTest {

    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        UserMapper userMapper3 = (UserMapper)applicationContext.getBean("userMapper3");
        System.out.println(userMapper3);
    }
}

为什么叫延迟实例化bean？

当加载配置文件时，可以看见并没有创建 UserMapper 实例，而是创建了工厂 Bean，并且此时 factoryBeanObjectCache 里面没有任何东西。

/>

当去容器里面获取实例时，FactoryBean 才调用 getObject 方法进行实例化 bean，并将实例放入 factoryBeanObjectCache 中。

/>

3. bean的依赖注入

3.1 手动装配

bean 的依赖注入有两种方式。

/>

依赖注入的数据类型有如下三种

• 普通数据类型，例如：String、int、boolean 等，通过 value 属性指定
• 引用数据类型，例如：UserDaolmpl、DataSource 等，通过 ref 属性指定
• 集合数据类型，例如：List、Map、Properties等

前面两种数据类型比较常见，这里说下 list 数据类型的注入，配置 set 将 list 标签替换为 set 即可。

现 UserServiceImpl.java 如下：

public class UserServiceImpl implements UserService {

    private List<String> stringList;

    private List<UserMapper> userMapperList;

    private Map<String, UserMapper> map;

    private Properties properties;

    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    public void setUserMapperList(List<UserMapper> userMapperList) {
        this.userMapperList = userMapperList;
    }

    public void setMap(Map<String, UserMapper> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

则 xml 配置如下：

<bean id="userService" class="com.amjun.spring.service.impl.UserServiceImpl">
    <property name="stringList">
        <list>
            <value>aaa</value>
            <value>bbb</value>
        </list>
    </property>
     <property name="userMapperList">
        <list>
            <!--  方式一 -->
            <!-- <bean class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>
            <bean class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>
            <bean class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>-->
            <!-- 方式二 -->
            <ref bean="userMapper1"></ref>
            <ref bean="userMapper2"></ref>
            <ref bean="userMapper3"></ref>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="d1" value-ref="userMapper1"></entry>
            <entry key="d2" value-ref="userMapper2"></entry>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="p1">ppp1</prop>
            <prop key="p2">ppp2</prop>
        </props>
    </property>
</bean>

<bean id="userMapper1" class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>
<bean id="userMapper2" class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>
<bean id="userMapper3" class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>

3.2 自动装配

如果被注入的属性类型是Bean引用的话，那么可以在<bean>标签中使用autowire属性去配置自动注入方式，属性值有两个：

• byName：通过属性名自动装配，即去匹配 setXxx 与 id=“xxx”（name=“xxx”）是否一致
• byType：通过 Bean 的类型从容器中匹配，匹配出多个相同 Bean 类型时，报错

<!-- 需要 UserServiceImpl 有 setUserMapper 方法， 有此方法时，自动去容器里面寻找 id 为 userMapper 的对象进行自动装配-->
<bean id="userService" class="com.amjun.spring.service.impl.UserServiceImpl" autowire="byName">
</bean>

<!-- 不管 UserMapperImpl 的 id 为任何值都可以自动装配，但是存在多个时报错-->
<bean id="userService2" class="com.amjun.spring.service.impl.UserServiceImpl" autowire="byType">
</bean>

<bean id="userMapper" class="com.amjun.spring.mapper.impl.UserMapperImpl"></bean>

4. spring的其他配置标签

Spring的xml标签大体上分为两类，一种是默认标签，一种是自定义标签

• 默认标签：就是不用额外导入其他命名空间约束的标签，例如 <bean>标签

• 自定义标签：就是需要额外引入其他命名空间约束，并通过前缀引用的标签，例如<context:property-placeholder/>标签

例如引入 context 命名空间，使用它里面的标签需要添加前缀。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder></context:property-placeholder>
</beans>

默认标签如下：

/>

需要注意的是，<beans>标签可以嵌套。

<?xml version="1.0" encoding="UTF-8"?>
<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="userService" class="com.amjun.spring.service.impl.UserServiceImpl"></bean>

    <!-- 开发环境 -->
    <beans profile="dev">
        <bean id="userService1" class="com.amjun.spring.service.impl.UserServiceImpl"></bean>
    </beans>

    <!-- 测试环境 -->
    <beans profile="test">
        <bean id="userService2" class="com.amjun.spring.service.impl.UserServiceImpl"></bean>
    </beans>
</beans>

可以使用以下两种方式指定被激活的环境：

• 使用命令行动态参数，虚拟机参数位置加载 -Dspring.profiles.active=test
• 使用代码的方式设置环境变量 System.setProperty(“spring.profiles.active”，”test”)·

当激活 test 环境时，可以在 environment 对象中看见。

/>

即使指定激活了 test 环境，还是可以获取到 id 为 userService 的实例，因为它是公共的。

当配置文件很多时，可以通过主配置文件引入其他配置文件。

<!-- 引入数据库配置文件-->
<importresource="classpath:dataSource.xml"></import>
<!-- 引入springmvc配置文件-->
<importresource="classpath:springMvc.xml"></import>

提醒：本文发布于424天前，文中所关联的信息可能已发生改变，请知悉！

共计 10181 个字符，预计需要花费 26 分钟才能阅读完成。

一、 实例化基本流程

基本流程图如下：

/>

Spring 容器在进行初始化时，会将 xml 配置的 <bean> 的信息封装成一个 BeanDefinition 对象，所有的 BeanDefinition 存储到一个名为 beanDefinitionMap 的 Map 集合中。

/>

Spring 框架再对该 beanDefinitionMap 进行遍历，使用反射创建 Bean 实例对象，创建好的 Bean 对象存储在一个名为 singletonObjects 的 Map 集合中。

/>

当调用 getBean 方法时则最终从该 singletonObjects 集合中取出 Bean 实例对象返回。

二、 spring后处理器

Spring 的后处理器是 Spring 对外开发的重要扩展点，允许许我们介入到 Bean 的整个实例化流程中来，以达到动态注册 BeanDefinition，动态修改 BeanDefinition，以及动态修改 Bean的作用。Spring 主要有两种后处理器：

• BeanFactoryPostProcessor：Bean工厂后处理器，在 BeanDefinitionMap 填充完毕，Bean 实例化之前执行
• BeanPostProcessor：Bean后处理器，一般在 Bean 实例化之后，填充到单例池 singletonObjects 之前执行。

1 BeanFactoryPostProcessor

1.1 基本使用

BeanFactoryPostProcessor 是一个接口规范，实现了该接口的类只要交由 Spring 容器管理的话，那么 Spring 就会回调该接口的方法，用于对 BeanDefinition 注册和修改的功能。

@FunctionalInterface
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

此时流程图如下：

/>

现有如下 BeanFactoryPostProcessor 实现类：

MyBeanFactoryPostProcessor.java

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor 的 postProcessBeanFactory 方法");
        // 修改 BeanDefinition
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
        beanDefinition.setBeanClassName("com.amjun.spring.mapper.impl.UserMapperImpl");

        // 最好实现 BeanDefinitionRegistryPostProcessor 接口来实现
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
        rootBeanDefinition.setBeanClassName("com.amjun.spring2.service.impl.PersonServiceImpl");
        // beanFactory 实际上是 DefaultListableBeanFactory， 是 ConfigurableListableBeanFactory 的子类
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) beanFactory;
        defaultListableBeanFactory.registerBeanDefinition("personService", rootBeanDefinition);
    }
}

MyBeanFactoryPostProcessor2.java

// 专门用于注册 BeanDefinition
public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {

    // 先执行该方法
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2 的 postProcessBeanDefinitionRegistry 方法");
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
        rootBeanDefinition.setBeanClassName("com.amjun.spring2.service.impl.PersonServiceImpl");
        beanDefinitionRegistry.registerBeanDefinition("personService2", rootBeanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2 的 postProcessBeanFactory 方法");
    }
}

xml 配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<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="userService" class="com.amjun.spring.service.impl.UserServiceImpl">

    </bean>

    <bean id="userMapper" class="com.amjun.spring.mapper.impl.UserMapperImpl">
    </bean>

    <bean id="myBeanFactoryPostProcessor" class="com.amjun.spring2.processor.MyBeanFactoryPostProcessor"></bean>

    <bean id="myBeanFactoryPostProcessor2" class="com.amjun.spring2.processor.MyBeanFactoryPostProcessor2"></bean>
</beans>

测试代码：

public class ApplicationContextTest {

    public static void main(String[] args) throws SQLException, IOException {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans2.xml");
        /*Object userService = applicationContext.getBean("userService");
        System.out.println(userService);*/

        /*Object personService = applicationContext.getBean("personService");
        System.out.println(personService);*/

        Object personService2 = applicationContext.getBean("personService2");
        System.out.println(personService2);
    }
}

1.2 案例-实现自动扫描

/>

注解类：MyComponent.java

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {

    String value();
}

待扫描的对象 OtherBean.java。

@MyComponent("otherBean")
public class OtherBean {
}

MyComponentBeanFactoryPostProcessor.java

public class MyComponentBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        // 通过扫描工具去扫描指定包及其子包下的所有类，收集使用@Mycomponent的注解的类
        Map<String, Class> stringClassMap = BaseClassScanUtils.scanMyComponentAnnotation("com.amjun.spring2");
        // 遍历 Map，组装BeanDefinition进行注册
        stringClassMap.forEach((beanName, clazz) -> {
            String beanClassName = clazz.getName(); // com.amjun.spring2.beans.OtherBean
            BeanDefinition beanDefinition = new RootBeanDefinition();
            beanDefinition.setBeanClassName(beanClassName);
            beanDefinitionRegistry.registerBeanDefinition(beanName, beanDefinition);
        });
    }
}

xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<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="myComponentBeanFactoryPostProcessor" class="com.amjun.spring2.processor.MyComponentBeanFactoryPostProcessor"></bean>
</beans>

测试方法：

public class ApplicationContextTest {

    public static void main(String[] args) throws SQLException, IOException {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans2.xml");

        Object otherBean = applicationContext.getBean("otherBean");
        System.out.println(otherBean);
    }
}

2 BeanPostProcessor

Bean 被实例化后，到最终缓存到名为 singletonObjects 单例池之前，中间会经过 Bean 的初始化过程，例如：属性的填充、初始方法 init 的执行等，其中有一个对外进行扩展的点 BeanPostProcessor，我们称为 Bean 后处理。跟上面的 Bean 工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的 BeanPostProcessor，会在流程节点上被 Spring 自动调用。

此时的流程图如下：

/>

2.1 基本使用

BeanPostProcessor 源码如下，实现该接口可以实现两个方法，但不是必须的。

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

2.2 相关方法执行顺序

现有如下对象 UserServiceImpl.java：

public class UserServiceImpl implements UserService, InitializingBean {

    private String name;

    private UserMapper userMapper;

    public UserServiceImpl() {
        System.out.println("UserService实例化-无参构造");
    }

    public UserServiceImpl(String name) {
        System.out.println("UserService实例化-有参构造");
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setUserMapper(UserMapper userMapper) {
        System.out.println("依赖注入userMapper");
        this.userMapper = userMapper;
    }

    public void init(){
        System.out.println("执行初始化 init 方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("属性设置之后执行初始化 afterPropertiesSet 方法");
    }

    @Override
    public void show() {
        System.out.println("show....");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

则执行方法的顺序如下：

/>

2.3 案例-实现日志增强

UserServiceImpl.java 同上，UserService.java 如下：

public interface UserService {

    void show();
}

必须定义一个接口，因为动态代理中生成的代理对象类型是根据目标对象实现的接口来确定的，不能直接强转为对象。

TimeLogBeanPostProcessor.java

public class TimeLogBeanPostProcessor implements BeanPostProcessor {

    @Nullable
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 使用动态代理对目标Bean进行增强，返回proxy对象
        Object beanProxy = Proxy.newProxyInstance(
                bean.getClass().getClassLoader(),
                bean.getClass().getInterfaces(),
                ((proxy, method, args) -> {
                    // 1. 输出开始时间
                    System.out.println("方法：" + method.getName() + "开始时间：" + new Date());
                    // 2. 执行目标方法
                    Object result = method.invoke(bean, args);
                    // 3. 输出结束时间
                    System.out.println("方法：" + method.getName() + "结束时间：" + new Date());
                    return result;
                })
        );
        return beanProxy;
    }
}

xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<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="userService" class="com.amjun.spring2.service.impl.UserServiceImpl" init-method="init">

    </bean>

    <bean id="userMapper" class="com.amjun.spring2.mapper.impl.UserMapperImpl">
    </bean>

    <!-- 测试 BeanPostProcessor -->
    <bean id="myBeanPostProcessor" class="com.amjun.spring2.processor.MyBeanPostProcessor"></bean>

    <bean id="timeLogBeanPostProcessor" class="com.amjun.spring2.processor.TimeLogBeanPostProcessor"></bean>
</beans>

测试：

public class ApplicationContextTest {

    public static void main(String[] args) throws SQLException, IOException {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans2.xml");

        UserService userService = (UserService)applicationContext.getBean("userService");
        userService.show();

    }
}

结果如下：

/>

三、完整流程图

/>

此流程图基于上诉流程图演变，且 bean 初始化阶段除了 Aware 接口方法回调基本都接触过。

这里简单了解一下 Aware 接口， 它允许 Bean 在被 Spring 容器创建时获取对容器或其他相关对象的引用，以便进行进一步的自定义操作或获取特定的资源。

以下是几个常见的Aware接口及其作用：

• ApplicationContextAware：实现该接口的Bean可以获取对ApplicationContext的引用，从而可以在运行时访问Spring容器的功能和资源。

• BeanFactoryAware：实现该接口的Bean可以获取对BeanFactory的引用，以便在需要时访问BeanFactory的功能。

• BeanNameAware：实现该接口的Bean可以获取其在Spring容器中注册的名称。

• EnvironmentAware：实现该接口的Bean可以获取对Environment的引用，以便在运行时获取配置属性和环境变量。

• ResourceLoaderAware：实现该接口的Bean可以获取对ResourceLoader的引用，以便在运行时加载外部资源。

举个例子。

public class UserServiceImpl implements UserService, ApplicationContextAware, BeanFactoryAware, BeanNameAware {

    private String name;
    private UserMapper userMapper;

    public UserServiceImpl() {
        //System.out.println("UserService实例化");
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setUserMapper(UserMapper userMapper) {
        //System.out.println("userService注入userMapper");
        this.userMapper = userMapper;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("创建userService的BeanFactory: " + beanFactory);
    }

    @Override
    public void setBeanName(String beanName) {
        System.out.println("userService的beanName: " + beanName);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("创建userService的ApplicationContext: " + applicationContext);
    }
}

ApplicationContextTest.java

public class ApplicationContextTest {

    public static void main(String[] args) throws SQLException, IOException {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans3.xml");
        UserServiceImpl userService = applicationContext.getBean("userService", UserServiceImpl.class);
        System.out.println(userService);
    }
}

结果如下：

/>

打印的这些内容都是创建对象之前无法获取的，因为 beanName 是在 xml 配置文件中指定的，ApplicationContext 获取到的 ClassPathXmlApplicationContext 也是在测试时创建的。

提醒：本文发布于423天前，文中所关联的信息可能已发生改变，请知悉！