厉害了，Spring中bean的12种定义方法！

傷城~ 2023-10-03 10:16 1阅读 0赞

###  ###

### 前言    ###

在庞大的java体系中，spring有着举足轻重的地位，它给每位开发者带来了极大的便利和惊喜。我们都知道spring是创建和管理bean的工厂，它提供了多种定义bean的方式，能够满足我们日常工作中的多种业务场景。

那么问题来了，你知道spring中有哪些方式可以定义bean？

我估计很多人会说出以下三种：

![43518f861f8afdebf974b96a6274b86f.png][]

没错，但我想说的是以上三种方式只是开胃小菜，实际上spring的功能远比你想象中更强大。

各位看官如果不信，请继续往下看。

### 1. xml文件配置bean ###

我们先从`xml配置bean`开始，它是spring最早支持的方式。后来，随着`springboot`越来越受欢迎，该方法目前已经用得很少了，但我建议我们还是有必要了解一下。

#### 1.1 构造器 ####

如果你之前有在bean.xml文件中配置过bean的经历，那么对如下的配置肯定不会陌生：

<bean id="personService" class="com.sue.cache.service.test7.PersonService">
    </bean>

这种方式是以前使用最多的方式，它默认使用了无参构造器创建bean。

当然我们还可以使用有参的构造器，通过`<constructor-arg>`标签来完成配置。

<bean id="personService" class="com.sue.cache.service.test7.PersonService">
       <constructor-arg index="0" value="susan"></constructor-arg>
       <constructor-arg index="1" ref="baseInfo"></constructor-arg>
    </bean>

其中：

*  `index`表示下标，从0开始。
 *  `value`表示常量值
 *  `ref`表示引用另一个bean

#### 1.2 setter方法 ####

除此之外，spring还提供了另外一种思路：通过setter方法设置bean所需参数，这种方式耦合性相对较低，比有参构造器使用更为广泛。

先定义Person实体：

@Data
    public class Person {
        private String name;
        private int age;
    }

它里面包含：成员变量name和age，getter/setter方法。

然后在bean.xml文件中配置bean时，加上`<property>`标签设置bean所需参数。

<bean id="person" class="com.sue.cache.service.test7.Person">
       <property name="name" value="susan"></constructor-arg>
       <property name="age" value="18"></constructor-arg>
    </bean>

#### 1.3 静态工厂 ####

这种方式的关键是需要定义一个工厂类，它里面包含一个创建bean的静态方法。例如：

public class SusanBeanFactory {
        public static Person createPerson(String name, int age) {
            return new Person(name, age);
        }
    }

接下来定义Person类如下：

@AllArgsConstructor
    @NoArgsConstructor
    @Data
    public class Person {
        private String name;
        private int age;
    }

它里面包含：成员变量name和age，getter/setter方法，无参构造器和全参构造器。

然后在bean.xml文件中配置bean时，通过`factory-method`参数指定静态工厂方法，同时通过`<constructor-arg>`设置相关参数。

<bean class="com.sue.cache.service.test7.SusanBeanFactory" factory-method="createPerson">
       <constructor-arg index="0" value="susan"></constructor-arg>
       <constructor-arg index="1" value="18"></constructor-arg>
    </bean>

#### 1.4 实例工厂方法 ####

这种方式也需要定义一个工厂类，但里面包含非静态的创建bean的方法。

public class SusanBeanFactory {
        public Person createPerson(String name, int age) {
            return new Person(name, age);
        }
    }

Person类跟上面一样，就不多说了。

然后bean.xml文件中配置bean时，需要先配置工厂bean。然后在配置实例bean时，通过`factory-bean`参数指定该工厂bean的引用。

<bean id="susanBeanFactory" class="com.sue.cache.service.test7.SusanBeanFactory">
    </bean>
    <bean factory-bean="susanBeanFactory" factory-method="createPerson">
       <constructor-arg index="0" value="susan"></constructor-arg>
       <constructor-arg index="1" value="18"></constructor-arg>
    </bean>

#### 1.5 FactoryBean ####

不知道大家有没有发现，上面的实例工厂方法每次都需要创建一个工厂类，不方面统一管理。

这时我们可以使用`FactoryBean`接口。

public class UserFactoryBean implements FactoryBean<User> {
        @Override
        public User getObject() throws Exception {
            return new User();
        }
    
        @Override
        public Class<?> getObjectType() {
            return User.class;
        }
    }

在它的`getObject`方法中可以实现我们自己的逻辑创建对象，并且在`getObjectType`方法中我们可以定义对象的类型。

然后在bean.xml文件中配置bean时，只需像普通的bean一样配置即可。

<bean id="userFactoryBean" class="com.sue.async.service.UserFactoryBean">
    </bean>

轻松搞定，so easy。

> 注意：getBean("userFactoryBean");获取的是getObject方法中返回的对象。而getBean("&userFactoryBean");获取的才是真正的UserFactoryBean对象。

我们通过上面五种方式，在bean.xml文件中把bean配置好之后，spring就会自动扫描和解析相应的标签，并且帮我们创建和实例化bean，然后放入spring容器中。

虽说基于xml文件的方式配置bean，简单而且非常灵活，比较适合一些小项目。但如果遇到比较复杂的项目，则需要配置大量的bean，而且bean之间的关系错综复杂，这样久而久之会导致xml文件迅速膨胀，非常不利于bean的管理。

### 2. Component注解 ###

为了解决bean太多时，xml文件过大，从而导致膨胀不好维护的问题。在spring2.5中开始支持：`@Component`、`@Repository`、`@Service`、`@Controller`等注解定义bean。

如果你有看过这些注解的源码的话，就会惊奇得发现：其实后三种注解也是`@Component`。

![4071ba1fa468dc4b4c855eaa7b6e93e3.png][]![5ce26715cb2ef022dc68173c7580a51e.png][]![c67dcf3c95a191baf5110cdce8922651.png][]

`@Component`系列注解的出现，给我们带来了极大的便利。我们不需要像以前那样在bean.xml文件中配置bean了，现在只用在类上加Component、Repository、Service、Controller，这四种注解中的任意一种，就能轻松完成bean的定义。

@Service
    public class PersonService {
        public String get() {
            return "data";
        }
    }

其实，这四种注解在功能上没有特别的区别，不过在业界有个不成文的约定：

*  Controller 一般用在控制层
 *  Service 一般用在业务层
 *  Repository 一般用在数据层
 *  Component 一般用在公共组件上

太棒了，简直一下子解放了我们的双手。

不过，需要特别注意的是，通过这种`@Component`扫描注解的方式定义bean的前提是：**需要先配置扫描路径**。

目前常用的配置扫描路径的方式如下：

1.  在applicationContext.xml文件中使用`<context:component-scan>`标签。例如：

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

1.  在springboot的启动类上加上`@ComponentScan`注解，例如：

@ComponentScan(basePackages = "com.sue.cache")
    @SpringBootApplication
    public class Application {
    
        public static void main(String[] args) {
            new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
        }
    }

1.  直接在`SpringBootApplication`注解上加，它支持ComponentScan功能：

@SpringBootApplication(scanBasePackages = "com.sue.cache")
    public class Application {
        
        public static void main(String[] args) {
            new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
        }
    }

当然，如果你需要扫描的类跟springboot的入口类，在同一级或者子级的包下面，无需指定`scanBasePackages`参数，spring默认会从入口类的同一级或者子级的包去找。

@SpringBootApplication
    public class Application {
        
        public static void main(String[] args) {
            new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
        }
    }

此外，除了上述四种`@Component`注解之外，springboot还增加了`@RestController`注解，它是一种特殊的`@Controller`注解，所以也是`@Component`注解。

`@RestController`还支持`@ResponseBody`注解的功能，即将接口响应数据的格式自动转换成json。

![421934e21cc242949f575f47334d052d.png][]

`@Component`系列注解已经让我们爱不释手了，它目前是我们日常工作中最多的定义bean的方式。

### 3. JavaConfig ###

`@Component`系列注解虽说使用起来非常方便，但是bean的创建过程完全交给spring容器来完成，我们没办法自己控制。

spring从3.0以后，开始支持JavaConfig的方式定义bean。它可以看做spring的配置文件，但并非真正的配置文件，我们需要通过编码java代码的方式创建bean。例如：

@Configuration
    public class MyConfiguration {
    
        @Bean
        public Person person() {
            return new Person();
        }
    }

在JavaConfig类上加`@Configuration`注解，相当于配置了`<beans>`标签。而在方法上加`@Bean`注解，相当于配置了`<bean>`标签。

此外，springboot还引入了一些列的`@Conditional`注解，用来控制bean的创建。

@Configuration
    public class MyConfiguration {
    
        @ConditionalOnClass(Country.class)
        @Bean
        public Person person() {
            return new Person();
        }
    }

`@ConditionalOnClass`注解的功能是当项目中存在Country类时，才实例化Person类。换句话说就是，如果项目中不存在Country类，就不实例化Person类。

这个功能非常有用，相当于一个开关控制着Person类，只有满足一定条件才能实例化。

spring中使用比较多的Conditional还有：

*  ConditionalOnBean
 *  ConditionalOnProperty
 *  ConditionalOnMissingClass
 *  ConditionalOnMissingBean
 *  ConditionalOnWebApplication

如果你对这些功能比较感兴趣，可以看看《[spring中那些让你爱不释手的代码技巧（续集）][spring]》，这是我之前写的一篇文章，里面做了更详细的介绍。

下面用一张图整体认识一下@Conditional家族:![bab5379608f75ea2983033d9cc2dc752.png][]

nice，有了这些功能，我们终于可以告别麻烦的xml时代了。

### 4. Import注解 ###

通过前面介绍的@Configuration和@Bean相结合的方式，我们可以通过代码定义bean。但这种方式有一定的局限性，它只能创建该类中定义的bean实例，不能创建其他类的bean实例，如果我们想创建其他类的bean实例该怎么办呢？

这时可以使用`@Import`注解导入。

#### 4.1 普通类 ####

spring4.2之后`@Import`注解可以实例化普通类的bean实例。例如：

先定义了Role类：

@Data
    public class Role {
        private Long id;
        private String name;
    }

接下来使用@Import注解导入Role类：

@Import(Role.class)
    @Configuration
    public class MyConfig {
    }

然后在调用的地方通过`@Autowired`注解注入所需的bean。

@RequestMapping("/")
    @RestController
    public class TestController {
    
        @Autowired
        private Role role;
    
        @GetMapping("/test")
        public String test() {
            System.out.println(role);
            return "test";
        }
    }

聪明的你可能会发现，我没有在任何地方定义过Role的bean，但spring却能自动创建该类的bean实例，这是为什么呢？

这也许正是`@Import`注解的强大之处。

此时，有些朋友可能会问：`@Import`注解能定义单个类的bean，但如果有多个类需要定义bean该怎么办呢？

恭喜你，这是个好问题，因为`@Import`注解也支持。

@Import({Role.class, User.class})
    @Configuration
    public class MyConfig {
    }

甚至，如果你想偷懒，不想写这种`MyConfig`类，springboot也欢迎。

@Import({Role.class, User.class})
    @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class,
            DataSourceTransactionManagerAutoConfiguration.class})
    public class Application {
    
        public static void main(String[] args) {
            new SpringApplicationBuilder(Application.class).web(WebApplicationType.SERVLET).run(args);
        }
    }

可以将@Import加到springboot的启动类上。

这样也能生效？

springboot的启动类一般都会加@SpringBootApplication注解，该注解上加了@SpringBootConfiguration注解。![916c185c8f6789deb2674378bda16de2.png][]

而@SpringBootConfiguration注解，上面又加了@Configuration注解![15eee7e665afe5e759878f00834efd35.png][]所以，springboot启动类本身带有@Configuration注解的功能。

意不意外？惊不惊喜？

#### 4.2 Configuration类 ####

上面介绍了@Import注解导入普通类的方法，它同时也支持导入Configuration类。

先定义一个Configuration类：

@Configuration
    public class MyConfig2 {
    
        @Bean
        public User user() {
            return  new User();
        }
    
        @Bean
        public Role role() {
            return new Role();
        }
    }

然后在另外一个Configuration类中引入前面的Configuration类：

@Import({MyConfig2.class})
    @Configuration
    public class MyConfig {
    }

这种方式，如果MyConfig2类已经在spring指定的扫描目录或者子目录下，则MyConfig类会显得有点多余。因为MyConfig2类本身就是一个配置类，它里面就能定义bean。

但如果MyConfig2类不在指定的spring扫描目录或者子目录下，则通过MyConfig类的导入功能，也能把MyConfig2类识别成配置类。这就有点厉害了喔。

**其实下面还有更高端的玩法**。

swagger作为一个优秀的文档生成框架，在spring项目中越来越受欢迎。接下来，我们以swagger2为例，介绍一下它是如何导入相关类的。

众所周知，我们引入swagger相关jar包之后，只需要在springboot的启动类上加上`@EnableSwagger2`注解，就能开启swagger的功能。

其中@EnableSwagger2注解中导入了Swagger2DocumentationConfiguration类。

![87c6ac79fad19e545e32de2f09d0757e.png][]该类是一个Configuration类，它又导入了另外两个类：

*  SpringfoxWebMvcConfiguration
 *  SwaggerCommonConfiguration

![af9169ba82dc8ddc689fb3ac63da0434.png][]SpringfoxWebMvcConfiguration类又会导入新的Configuration类，并且通过@ComponentScan注解扫描了一些其他的路径。![1222082e8f1809ac9bcfbc344b8076aa.png][]

SwaggerCommonConfiguration同样也通过@ComponentScan注解扫描了一些额外的路径。

![3b08caa6584fcf546b7d54c999fd2b58.png][]

如此一来，我们通过一个简单的`@EnableSwagger2`注解，就能轻松的导入swagger所需的一系列bean，并且拥有swagger的功能。

还有什么好说的，狂起点赞，简直完美。

#### 4.3 ImportSelector ####

上面提到的Configuration类，它的功能非常强大。但怎么说呢，它不太适合加复杂的判断条件，根据某些条件定义这些bean，根据另外的条件定义那些bean。

那么，这种需求该怎么实现呢？

这时就可以使用`ImportSelector`接口了。

首先定义一个类实现`ImportSelector`接口：

public class DataImportSelector implements ImportSelector {
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
            return new String[]{"com.sue.async.service.User", "com.sue.async.service.Role"};
        }
    }

重写`selectImports`方法，在该方法中指定需要定义bean的类名，注意要包含完整路径，而非相对路径。

然后在MyConfig类上@Import导入这个类即可：

@Import({DataImportSelector.class})
    @Configuration
    public class MyConfig {
    }

朋友们是不是又发现了一个新大陆？

不过，这个注解还有更牛逼的用途。

@EnableAutoConfiguration注解中导入了AutoConfigurationImportSelector类，并且里面包含系统参数名称：`spring.boot.enableautoconfiguration`。![7d9d25bdfb3d33b576d0744b349677de.png][]AutoConfigurationImportSelector类实现了`ImportSelector`接口。

![76984c4cde5fa63d547d7bc23d706eca.png][]并且重写了`selectImports`方法，该方法会根据某些注解去找所有需要创建bean的类名，然后返回这些类名。其中在查找这些类名之前，先调用isEnabled方法，判断是否需要继续查找。![50da864756f80bbd0048d4c8d5e9e657.png][]该方法会根据ENABLED\_OVERRIDE\_PROPERTY的值来作为判断条件。![efa0c685db3c16f092d3b8d0937693b6.png][]而这个值就是`spring.boot.enableautoconfiguration`。

换句话说，这里能根据系统参数控制bean是否需要被实例化，优秀。

我个人认为实现ImportSelector接口的好处主要有以下两点：

1.  把某个功能的相关类，可以放到一起，方面管理和维护。
2.  重写selectImports方法时，能够根据条件判断某些类是否需要被实例化，或者某个条件实例化这些bean，其他的条件实例化那些bean等。我们能够非常灵活的定制化bean的实例化。

#### 4.4 ImportBeanDefinitionRegistrar ####

我们通过上面的这种方式，确实能够非常灵活的自定义bean。

但它的自定义能力，还是有限的，它没法自定义bean的名称和作用域等属性。

有需求，就有解决方案。

接下来，我们一起看看`ImportBeanDefinitionRegistrar`接口的神奇之处。

先定义CustomImportSelector类实现ImportBeanDefinitionRegistrar接口：

public class CustomImportSelector implements ImportBeanDefinitionRegistrar {
    
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            RootBeanDefinition roleBeanDefinition = new RootBeanDefinition(Role.class);
            registry.registerBeanDefinition("role", roleBeanDefinition);
    
            RootBeanDefinition userBeanDefinition = new RootBeanDefinition(User.class);
            userBeanDefinition.setScope(ConfigurableBeanFactory.SCOPE_PROTOTYPE);
            registry.registerBeanDefinition("user", userBeanDefinition);
        }
    }

重写`registerBeanDefinitions`方法，在该方法中我们可以获取`BeanDefinitionRegistry`对象，通过它去注册bean。不过在注册bean之前，我们先要创建BeanDefinition对象，它里面可以自定义bean的名称、作用域等很多参数。

然后在MyConfig类上导入上面的类：

@Import({CustomImportSelector.class})
    @Configuration
    public class MyConfig {
    }

我们所熟悉的fegin功能，就是使用ImportBeanDefinitionRegistrar接口实现的：![fff01709356dbc2cf3ccf7a52d61b2c1.png][]具体细节就不多说了，有兴趣的朋友可以加我微信找我私聊。

### 5. PostProcessor ###

除此之外，spring还提供了专门注册bean的接口：`BeanDefinitionRegistryPostProcessor`。

该接口的方法postProcessBeanDefinitionRegistry上有这样一段描述：![3a5a4101735805c9dd2b33472dda2552.png][]修改应用程序上下文的内部bean定义注册表标准初始化。所有常规bean定义都将被加载，但是还没有bean被实例化。这允许进一步添加在下一个后处理阶段开始之前定义bean。

如果用这个接口来定义bean，我们要做的事情就变得非常简单了。只需定义一个类实现`BeanDefinitionRegistryPostProcessor`接口。

@Component
    public class MyRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            RootBeanDefinition roleBeanDefinition = new RootBeanDefinition(Role.class);
            registry.registerBeanDefinition("role", roleBeanDefinition);
    
            RootBeanDefinition userBeanDefinition = new RootBeanDefinition(User.class);
            userBeanDefinition.setScope(ConfigurableBeanFactory.SCOPE_PROTOTYPE);
            registry.registerBeanDefinition("user", userBeanDefinition);
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        }
    }

重写`postProcessBeanDefinitionRegistry`方法，在该方法中能够获取`BeanDefinitionRegistry`对象，它负责bean的注册工作。

不过细心的朋友可能会发现，里面还多了一个`postProcessBeanFactory`方法，没有做任何实现。

这个方法其实是它的父接口：`BeanFactoryPostProcessor`里的方法。

![c13b8988f65c3b8aedc2372b03ce1b60.png][]在应用程序上下文的标准bean工厂之后修改其内部bean工厂初始化。所有bean定义都已加载，但没有bean将被实例化。这允许重写或添加属性甚至可以初始化bean。

@Component
    public class MyPostProcessor implements BeanFactoryPostProcessor {
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            DefaultListableBeanFactory registry = (DefaultListableBeanFactory)beanFactory;
            RootBeanDefinition roleBeanDefinition = new RootBeanDefinition(Role.class);
            registry.registerBeanDefinition("role", roleBeanDefinition);
    
            RootBeanDefinition userBeanDefinition = new RootBeanDefinition(User.class);
            userBeanDefinition.setScope(ConfigurableBeanFactory.SCOPE_PROTOTYPE);
            registry.registerBeanDefinition("user", userBeanDefinition);
        }
    }

既然这两个接口都能注册bean，那么他们有什么区别？

*  BeanDefinitionRegistryPostProcessor 更侧重于bean的注册
 *  BeanFactoryPostProcessor 更侧重于对已经注册的bean的属性进行修改，虽然也可以注册bean。

此时，有些朋友可能会问：既然拿到BeanDefinitionRegistry对象就能注册bean，那通过BeanFactoryAware的方式是不是也能注册bean呢？

从下面这张图能够看出DefaultListableBeanFactory就实现了BeanDefinitionRegistry接口。![21dbe3f5c68de934be3bfd54c9eb9ff1.png][]

这样一来，我们如果能够获取DefaultListableBeanFactory对象的实例，然后调用它的注册方法，不就可以注册bean了？

说时迟那时快，定义一个类实现`BeanFactoryAware`接口：

@Component
    public class BeanFactoryRegistry implements BeanFactoryAware {
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            DefaultListableBeanFactory registry = (DefaultListableBeanFactory) beanFactory;
            RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(User.class);
            registry.registerBeanDefinition("user", rootBeanDefinition);
    
            RootBeanDefinition userBeanDefinition = new RootBeanDefinition(User.class);
            userBeanDefinition.setScope(ConfigurableBeanFactory.SCOPE_PROTOTYPE);
            registry.registerBeanDefinition("user", userBeanDefinition);
        }
    }

重写`setBeanFactory`方法，在该方法中能够获取BeanFactory对象，它能够强制转换成DefaultListableBeanFactory对象，然后通过该对象的实例注册bean。

当你满怀喜悦的运行项目时，发现竟然报错了：![5d0cff409c110ec91d92f30a1e67f32a.png][]

为什么会报错？

spring中bean的创建过程顺序大致如下：![0229ec1e6d015a506df55eee50e187e9.png][]`BeanFactoryAware`接口是在bean创建成功，并且完成依赖注入之后，在真正初始化之前才被调用的。在这个时候去注册bean意义不大，因为这个接口是给我们获取bean的，并不建议去注册bean，会引发很多问题。

> 此外，ApplicationContextRegistry和ApplicationListener接口也有类似的问题，我们可以用他们获取bean，但不建议用它们注册bean。

![61ffda9278e3f52702d3be1f98b9e3ee.gif][]

往期推荐

[![2cf734ea2de28c8b3a3c91231ddd7892.png][]][2cf734ea2de28c8b3a3c91231ddd7892.png 1]

[@Autowired报错的4种解决方案和原因分析！][2cf734ea2de28c8b3a3c91231ddd7892.png 1]

[![5210bd432d7e374c3d988975bacd1f48.png][]][5210bd432d7e374c3d988975bacd1f48.png 1]

[SpringBoot 中的 3 种条件装配！][5210bd432d7e374c3d988975bacd1f48.png 1]

[![8b6d8851c19ee27ec053ac85dc7ea282.png][]][8b6d8851c19ee27ec053ac85dc7ea282.png 1]

[SpringBoot 过滤器、拦截器、监听器对比及使用场景！][8b6d8851c19ee27ec053ac85dc7ea282.png 1]

--------------------

[43518f861f8afdebf974b96a6274b86f.png]: https://img-blog.csdnimg.cn/img_convert/43518f861f8afdebf974b96a6274b86f.png
[4071ba1fa468dc4b4c855eaa7b6e93e3.png]: https://img-blog.csdnimg.cn/img_convert/4071ba1fa468dc4b4c855eaa7b6e93e3.png
[5ce26715cb2ef022dc68173c7580a51e.png]: https://img-blog.csdnimg.cn/img_convert/5ce26715cb2ef022dc68173c7580a51e.png
[c67dcf3c95a191baf5110cdce8922651.png]: https://img-blog.csdnimg.cn/img_convert/c67dcf3c95a191baf5110cdce8922651.png
[421934e21cc242949f575f47334d052d.png]: https://img-blog.csdnimg.cn/img_convert/421934e21cc242949f575f47334d052d.png
[spring]: http://mp.weixin.qq.com/s?__biz=MzUxODkzNTQ3Nw%3D%3D&chksm=f9800cd6cef785c07022577cec282c3f990e35d80ee5cb07219681ed4db71cddabb9fcbeabd2&idx=1&mid=2247485964&scene=21&sn=6b228b315461498aa3e2ac241341f72a#wechat_redirect
[bab5379608f75ea2983033d9cc2dc752.png]: https://img-blog.csdnimg.cn/img_convert/bab5379608f75ea2983033d9cc2dc752.png
[916c185c8f6789deb2674378bda16de2.png]: https://img-blog.csdnimg.cn/img_convert/916c185c8f6789deb2674378bda16de2.png
[15eee7e665afe5e759878f00834efd35.png]: https://img-blog.csdnimg.cn/img_convert/15eee7e665afe5e759878f00834efd35.png
[87c6ac79fad19e545e32de2f09d0757e.png]: https://img-blog.csdnimg.cn/img_convert/87c6ac79fad19e545e32de2f09d0757e.png
[af9169ba82dc8ddc689fb3ac63da0434.png]: https://img-blog.csdnimg.cn/img_convert/af9169ba82dc8ddc689fb3ac63da0434.png
[1222082e8f1809ac9bcfbc344b8076aa.png]: https://img-blog.csdnimg.cn/img_convert/1222082e8f1809ac9bcfbc344b8076aa.png
[3b08caa6584fcf546b7d54c999fd2b58.png]: https://img-blog.csdnimg.cn/img_convert/3b08caa6584fcf546b7d54c999fd2b58.png
[7d9d25bdfb3d33b576d0744b349677de.png]: https://img-blog.csdnimg.cn/img_convert/7d9d25bdfb3d33b576d0744b349677de.png
[76984c4cde5fa63d547d7bc23d706eca.png]: https://img-blog.csdnimg.cn/img_convert/76984c4cde5fa63d547d7bc23d706eca.png
[50da864756f80bbd0048d4c8d5e9e657.png]: https://img-blog.csdnimg.cn/img_convert/50da864756f80bbd0048d4c8d5e9e657.png
[efa0c685db3c16f092d3b8d0937693b6.png]: https://img-blog.csdnimg.cn/img_convert/efa0c685db3c16f092d3b8d0937693b6.png
[fff01709356dbc2cf3ccf7a52d61b2c1.png]: https://img-blog.csdnimg.cn/img_convert/fff01709356dbc2cf3ccf7a52d61b2c1.png
[3a5a4101735805c9dd2b33472dda2552.png]: https://img-blog.csdnimg.cn/img_convert/3a5a4101735805c9dd2b33472dda2552.png
[c13b8988f65c3b8aedc2372b03ce1b60.png]: https://img-blog.csdnimg.cn/img_convert/c13b8988f65c3b8aedc2372b03ce1b60.png
[21dbe3f5c68de934be3bfd54c9eb9ff1.png]: https://img-blog.csdnimg.cn/img_convert/21dbe3f5c68de934be3bfd54c9eb9ff1.png
[5d0cff409c110ec91d92f30a1e67f32a.png]: https://img-blog.csdnimg.cn/img_convert/5d0cff409c110ec91d92f30a1e67f32a.png
[0229ec1e6d015a506df55eee50e187e9.png]: https://img-blog.csdnimg.cn/img_convert/0229ec1e6d015a506df55eee50e187e9.png
[61ffda9278e3f52702d3be1f98b9e3ee.gif]: https://img-blog.csdnimg.cn/img_convert/61ffda9278e3f52702d3be1f98b9e3ee.gif
[2cf734ea2de28c8b3a3c91231ddd7892.png]: https://img-blog.csdnimg.cn/img_convert/2cf734ea2de28c8b3a3c91231ddd7892.png
[2cf734ea2de28c8b3a3c91231ddd7892.png 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf9c66ccb815702d1838b7268dc722c614d3266520ee580e4a6db797a33c0739202f9ddfcb&idx=1&mid=2247496030&scene=21&sn=eccb6441a64457b6a090c8b63e9ad8c9#wechat_redirect
[5210bd432d7e374c3d988975bacd1f48.png]: https://img-blog.csdnimg.cn/img_convert/5210bd432d7e374c3d988975bacd1f48.png
[5210bd432d7e374c3d988975bacd1f48.png 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf9c02ccb8151480ae621ca2427d6281c4175a53248cbe001533debf3972b37997fb60b79c&idx=1&mid=2247495994&scene=21&sn=48107ea43691a1809baed0720d888547#wechat_redirect
[8b6d8851c19ee27ec053ac85dc7ea282.png]: https://img-blog.csdnimg.cn/img_convert/8b6d8851c19ee27ec053ac85dc7ea282.png
[8b6d8851c19ee27ec053ac85dc7ea282.png 1]: http://mp.weixin.qq.com/s?__biz=MzU1NTkwODE4Mw%3D%3D&chksm=fbcf9c26ccb81530a84d3d0af33ca899d520fb0f2cb30841b3312822165855e5006a8650fbe7&idx=1&mid=2247495966&scene=21&sn=ca302093434f1e7d5040114530bf335d#wechat_redirect