【Spring进阶系列丨第七篇】Spring框架新注解分类及详解

叁歲伎倆 2024-05-09 16:20 80阅读 0赞

#### 文章目录 ####

*  一、Spring新注解
 *   *  1.1、Configuration注解
     *   *  1.1.1、定义一个类
         *  1.1.2、使用Configuration注解修饰类
         *  1.1.3、作用
     *  1.2、Bean注解
     *   *  1.2.1、定义bean
         *  1.2.2、在主配置类中注册bean
         *  1.2.3、测试容器中是否有该bean
         *  1.2.4、注册bean的同时可以指定bean名称
         *  1.2.5、补充内容
         *   *  1.2.5.1、案例1【方法有参数】
             *  1.2.5.2、案例2
     *  1.3、ComponentScan注解
     *   *  1.3.1、案例1
         *  1.3.2、案例2
         *  1.3.3、案例3
     *  1.4、Scope注解
     *   *  1.4.1、定义Bean
         *  1.4.2、注册Bean并定义作用域
         *  1.4.3、测试
         *  1.4.4、将Bean的作用域改为多例
         *  1.4.5、测试1
         *  1.4.6、测试2
     *  1.5、Lazy注解
     *   *  1.5.1、注册Bean
         *  1.5.2、测试
         *  1.5.3、总结
     *  1.6、Conditional注解【了解】
     *   *  1.6.1、定义两个Bean
         *  1.6.2、定义两个类实现Condition接口
         *  1.6.3、注册Bean
         *  1.6.4、测试1
         *  1.6.5、测试2
         *  1.6.6、总结
     *  1.7、Import注解
     *   *  1.7.1、用法一
         *   *  1.7.1.1、定义Bean
             *  1.7.1.2、注册Bean
             *  1.7.1.3、测试容器中是否有该Bean
             *  1.7.1.4、注意
         *  1.7.2、用法二
         *   *  1.7.2.1、定义Bean
             *  1.7.2.2、新建配置类并注册Bean
             *  1.7.2.3、Import导入配置类
             *  1.7.2.4、测试容器有哪些Bean
             *  1.7.2.5、总结
     *  1.8、PropertySource注解
     *   *  1.8.1、定义Pig.properties文件
         *  1.8.2、主配置类
         *  1.8.3、测试
 *  好书推荐

![在这里插入图片描述][15dfca57a7a3459f9465c713c7f0dfc2.png_pic_center]

## 一、Spring新注解 ##

### 1.1、Configuration注解 ###

#### 1.1.1、定义一个类 ####

public class SpringMainConfig {
        
    
    }

#### 1.1.2、使用Configuration注解修饰类 ####

@Configuration
    public class SpringMainConfig {
        
        
    }

#### 1.1.3、作用 ####

使用Configuration注解修饰的类表示的是：当前类是一个配置类。该类的作用和beans.xml是一样的，换句话说，该注解所修饰的类就是用来代替beans.xml文件的。

### 1.2、Bean注解 ###

#### 1.2.1、定义bean ####

public class User {
        
        
        private Integer id;
        
        private String name;
    
        public User(Integer id, String name) {
        
            this.id = id;
            this.name = name;
        }
    }

#### 1.2.2、在主配置类中注册bean ####

在以前，使用xml去注册bean的时候，使用的是bean标签，形如：

现在改为使用注解，使用的是@Bean注解。

@Configuration
    public class SpringMainConfig {
        
        
        // 给容器中注册一个bean;类型为方法返回值的类型，默认方法名作为id，即bean的名字默认是方法名
        @Bean
        public User user(){
        
            return new User(1,"段康家");
        }
    }

#### 1.2.3、测试容器中是否有该bean ####

@Test
    public void testUser() throws Exception{
        
    
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
        User user = (User) ac.getBean("user");
        System.out.println(user);	// User{id=1, name='段康家'}
    }

#### 1.2.4、注册bean的同时可以指定bean名称 ####

@Configuration
    public class SpringMainConfig {
        
    
        // 给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
      	// 可以再注册Bean的同时，不用方法名作为id,可以指定bean的名称。
        @Bean("user01")
        public User user(){
        
            return new User(1,"段康家");
        }
    }

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

#### 1.2.5、补充内容 ####

##### 1.2.5.1、案例1【方法有参数】 #####

// 定义UserDao接口
    public interface UserDao {
        
    
    }

// 定义UserDao接口的实现类
    public class UserDaoImpl01 implements UserDao{
        
    
    }

// 定义UserService
    public class UserServiceImpl {
        
    
        private UserDao userDao;
    	
      	// 构造方法接收UserDao类型的对象
        public UserServiceImpl(UserDao userDao){
        
            this.userDao = userDao;
        }
    }

重点看主配置类：

@Configuration
    public class SpringMainConfig {
        
    
        // 给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
        @Bean
        public UserServiceImpl userService(UserDao userDao){
        
            return new UserServiceImpl(userDao);
        }
    
        @Bean
        public UserDao userDao01(){
        
            return new UserDaoImpl01();
        }
    }

@Test
    public void testUser() throws Exception{
        
    
      	ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
        UserServiceImpl userService = (UserServiceImpl) ac.getBean("userService");
        System.out.println(userService);
    }

说明：测试后发现程序能够正常运行，说明UserDao能够正常的以构造函数参数的形式注入到UserServiceImpl类中。

总结：当我们使用Bean注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象。查找的方式和Autowired注解的作用是一样的。即：**Spring会从容器中根据类型注入**

##### 1.2.5.2、案例2 #####

当然还有一种情况是：容器中注册了多个相同类型的Bean，那么Spring又是如何注入的呢？在8.2.5.1案例基础之上再添加一个UserDaoImpl02。

public class UserDaoImpl02 implements UserDao{
        
    
    }

在再主配置类中注册该UserDaoImpl02的Bean.

![在这里插入图片描述][d967687b16084bf19769e30752691aaf.png]

通过看图可以知道，有问题，不能够实现自动注入，该怎么办呢？两种方式：

**a、修改方法的参数**

![在这里插入图片描述][eb389a3053c142f88d77d6dc462fa272.png]

**b、指定Bean的名称**

![在这里插入图片描述][743f6eb025ec4f51941882d44c9e2207.png]

总结：本质上来说，解决方案1和解决方案2是一样的。

c、使用Qualifier注解。

实际上在7.3.2章节中，已经讲到了关于Qualifier注解的使用，通过该注解实现的功能是：当系统中存在多个相同类型的bean的时候，Spring就会注入失败，这个时候就需要再根据名称实现注入，而使用Qualifier注解可以达到根据给定名称的bean实现注入 。在以前讲解的过程中，我们是把该注解应用到了对类的成员变量上 ，但是需要注意的细节是：该注解应用到成员变量上时，注入时不能单独使用，需要搭配Autowired注解 。 但是，这里有一个例外，那么就是该注解也可以应用在方法参数上。

![在这里插入图片描述][ea9708d2851e4d5d92b50bf9d0e2781f.png]

**特别注意：当把Qualifier注解应用在方法参数上时，可以单独使用**

### 1.3、ComponentScan注解 ###

==作用：==指定spring在创建容器时要扫描的包。作用就如同在配置文件中这样的定义：

#### 1.3.1、案例1 ####

第一步：定义三个Bean，分别是CatController、CatService、CatMapper，并分别用@Controller、@Service、@Repository修饰。

package cn.bdqn.controller;
    
    @Controller
    public class CatController {
        
        
    }

package cn.bdqn.service;
    
    @Service
    public class CatServiceImpl {
        
    
    }

package cn.bdqn.mapper;
    
    @Repository
    public class CatMapper {
        
        
    }

第二步：要想真正的注册到容器中，就必须要让容器扫描到此注解所修饰的类所在的包。

@Configuration
    @ComponentScan(value = {
        "cn.bdqn"})
    public class SpringMainConfig {
        
    }

第三步：测试容器中是否注册了该bean。

@Test
    public void testComponentScan() throws Exception{
        
    
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
    
        // 获取Spring容器中已经注册好的bean,把所有bean的名字获取出来
        String[] names = ac.getBeanDefinitionNames();
        for (String name:names) {
        
            System.out.println(name);
        }
    }
    /**
    	结果：
    		catController
            catMapper
            catServiceImpl
    */

总结：默认情况下，Spring会扫描cn.bdqn包以及子包下面所有的使用@Controller、@Service、@Repository、@Component所修饰的bean注册到容器中

#### 1.3.2、案例2 ####

\*\*需求：\*\*我现在不想扫描被@Controller所修饰的类注册到容器中，即让Spring扫描不到即可。言外之意就是：把所有被@Controller所修饰的类给排除掉。

**说明：定义的CatController、CatServiceImpl、CatMapper不变，使用的是案例1。唯一要修改的配置是主配置文件类。为@ComponentScan注解添加excludeFilters**属性即可。

\*\*含义：\*\*excludeFilters的作用指定扫描的时候按照什么规则排除那些组件。

\*\*做法：\*\*修改主配置类，即

@Configuration
    @ComponentScan(
      value = {
        "cn.bdqn"},
      excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,
                                              value = {
        Controller.class})
                       }
    )
    public class SpringMainConfig {
        
      
    }

\*\*测试：\*\*测试代码同案例1

/**
    	catMapper
    	catServiceImpl
    **/

#### 1.3.3、案例3 ####

\*\*需求：\*\*我现在只想扫描被@Controller所修饰的类注册到容器中，被其他修饰的注解不扫描。

**说明：定义的CatController、CatServiceImpl、CatMapper不变，使用的是案例1。唯一要修改的配置是主配置文件类。为@ComponentScan注解添加includeFilters**属性即可。

\*\*含义：\*\*includeFilters的作用指定扫描的时候只需要包含哪些组件。

\*\*做法：\*\*修改主配置类，即

@Configuration
    @ComponentScan(value = {
        "cn.bdqn"},
                   includeFilters = {
        
                        @ComponentScan.Filter(type = FilterType.ANNOTATION,
                                              value = {
        Controller.class, Service.class})}
    )
    public class SpringMainConfig {
        
    }

\*\*测试：\*\*测试代码同案例1

/**
    	catController
        catMapper
        catServiceImpl
        测试，发现，不仅仅Controller被扫描进来了，包括Service，Mapper也都扫描进来了，好像不起作用，没有生效，原因是在于在使用includeFilters做只包含的时候，还需要关闭默认的过滤规则【在默认情况下，Spring是扫描指定包及子包下的被@Component、@Controller、@Service等bean的。】
    */

**主配置文件类修改如下：**

@Configuration
    @ComponentScan(value = {
        "cn.bdqn"},
                   includeFilters = {
        
                        @ComponentScan.Filter(type = FilterType.ANNOTATION,
                                              value = {
        Controller.class, Service.class})},
                   useDefaultFilters = false
    )
    public class SpringMainConfig {
        
    }

**测试：**

/**
    	catController
    	测试发现：结果正常，符合预期结果，只扫描到了Controller注解。
    */

### 1.4、Scope注解 ###

作用：可以改变bean的作用域。在Spring中，Bean的默认作用域是单例的。

#### 1.4.1、定义Bean ####

public class User {
        
    
        private Integer id;
    
        private String name;
    
        public User(Integer id, String name) {
        
            this.id = id;
            this.name = name;
        }
    }

#### 1.4.2、注册Bean并定义作用域 ####

@Configuration
    public class SpringMainConfig {
        
    
        @Bean
        @Scope
        public User user(){
        
          	System.out.println("对象创建啦");
            return new User(1,"HelloWorld");
        }
    }

#### 1.4.3、测试 ####

@Test
    public void testComponentScan() throws Exception{
        
    
      	ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
    }
    /**
    	对象创建啦
    */

结果：注册的Bean默认是单实例的，Spring容器将会在启动的时候调用方法创建对象后放入容器中，以后每次需要拿对象了就直接从容器中拿，而且每次拿的还是同一个。

#### 1.4.4、将Bean的作用域改为多例 ####

@Configuration
    public class SpringMainConfig {
        
    
        @Bean
        @Scope("prototype")
        public User user(){
        
            System.out.println("对象创建啦");
            return new User(1,"HelloWorld");
        }
    }

#### 1.4.5、测试1 ####

@Test
    public void testPrototype() throws Exception{
        
    
      	ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
    }
    /**
    	测试后发现容器启动的时候，多例对象并不会创建。
    */

#### 1.4.6、测试2 ####

@Test
    public void testPrototype() throws Exception{
        
    
      ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
    
      User user01 = (User) ac.getBean("user");
      User user02 = (User) ac.getBean("user");
    }
    /**
    	对象创建啦
    	对象创建啦
    */

总结：对于多实例来说，Spring容器在启动的时候并不会去调用方法创建对象并放在容器中，而是每次获取的时候才会调用方法创建对象，并且每次获取到的对象还不一样。

### 1.5、Lazy注解 ###

作用：用此注解修饰的Bean表示的该Bean需要被懒加载，即不会随着Spring容器的启动而去创建。

#### 1.5.1、注册Bean ####

@Configuration
    public class SpringMainConfig {
        
    
        @Bean
        @Lazy(value = true)	// 开启懒加载
        public User user(){
        
            System.out.println("对象创建啦");
            return new User(1,"HelloWorld");
        }
    }

#### 1.5.2、测试 ####

@Test
    public void testSingleton() throws Exception{
        
    
       ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
    }
    /**
    	控制台什么都没有输出，因为我们的Bean被Layz注解修饰了，即使Spring容器启动了，我们的Bean也不会去创建，只有等到了真正要用到该bean了才去创建。
    */

#### 1.5.3、总结 ####

*  这个Lazy注解是针对单实例Bean才有效，因为也只有单实例Bean才会默认在容器启动的时候创建对象。
 *  懒加载：容器启动不创建对象，只有在第一次使用(获取)Bean的时候采取创建对象，并初始化。
 *  该注解的作用等价于。

### 1.6、Conditional注解【了解】 ###

作用： 根据一定的条件进行判断，当满足这个条件时给容器注入Bean。

==位置：==既可以修饰类也可以修饰方法。

==需求：==当前操作系统如果是window，则注入WindoBean，如果是linux系统，则注入LinuxBean。

首先查看下@Conditional注解的源代码，即：

public @interface Conditional {
        
      	// 该注解的属性值是一个Class类型的数组，数组的Class元素类型必须继承Condition接口，即元素的类型必
      	// 须是Condition类型。
    	Class<? extends Condition>[] value();	
    }

继续Condition接口的源代码：

public interface Condition {
        
    	
      	// 提供一个返回boolean值的方法，返回true则注入bean，false则不注入
    	boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
    }

#### 1.6.1、定义两个Bean ####

// Window的bean
    public class WindowBean {
        
        private String name;
    
        public WindowBean(String name) {
        
            this.name = name;
        }
    }

// Linux的Bean
    public class LinuxBean {
        
        private String name;
    
        public LinuxBean(String name) {
        
            this.name = name;
        }
    }

#### 1.6.2、定义两个类实现Condition接口 ####

// Window环境的条件
    public class WindowCondition implements Condition {
        
    
        // context：上下文环境
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        
    
            String osName = context.getEnvironment().getProperty("os.name");
            if (osName.contains("Windows")){
        
                return true;
            }
            return false;
        }
    }

// Linux环境条件
    public class LinuxCondition implements Condition {
        
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        
            String osName = context.getEnvironment().getProperty("os.name");
            if (osName.contains("linux")){
        
                return true;
            }
            return false;
        }
    }

#### 1.6.3、注册Bean ####

@Configuration
    public class SpringMainConfig {
        
    
        // 如果当前环境是Winows环境则注入WindowBean
        @Bean
        @Conditional(value = {
        WindowCondition.class})
        public WindowBean windowBean(){
        
            return new WindowBean("这个是window操作系统");
        }
    
        // 如果当前环境是Linux环境则注入LinuxBean
        @Bean
        @Conditional(value = {
        LinuxCondition.class})
        public LinuxBean linuxBean(){
        
            return new LinuxBean("这个是Linux操作系统");
        }
    }

#### 1.6.4、测试1 ####

@Test
    public void testBean() throws Exception{
        
    
       ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
       // 查看Spring容器中所有注册的Bean
       String[] names = ac.getBeanDefinitionNames();
       for (String name:names) {
        
            System.out.println(name);	
        }
    }
    /**
    	windowBean
    	由于现在是在window操作系统上测试，故仅仅注册了WindowBean。
    */

#### 1.6.5、测试2 ####

测试下如果程序运行在linux下，是否能够注入LinuxBean？测试过程，即：运行程序的时候手动的指定运行时参数信息，步骤如下：

![在这里插入图片描述][45a7998991a64728842bf3faf8da79c6.png]

![在这里插入图片描述][f2e4f799be74497992042ef34a284d2d.png]

测试后，发现，打印的结果是：LinuxBean。

#### 1.6.6、总结 ####

*  使用Conditional注解修饰在方法上，只有当条件满足的时候，即返回true，才会将所修饰的方法调用并且会创建Bean对象添加到容器中。
 *  使用Conditional也可以修饰类，比如修饰主配置类，那么假如这个主配置类中定义了很多的Bean，如果该注解修饰了一个类，则只有条件满足的时候，即返回true，那么主配置类中所定义的Bean才会注册到容器中。即：@Conditional标注在类上就决定了该类中的一批bean是否能够注入。

### 1.7、Import注解 ###

![在这里插入图片描述][3116f190a0514d1ebc369433be2cfb5d.png]

#### 1.7.1、用法一 ####

简单来说，Import注解可以去修饰常规组件类，意思是：所谓的常规组件类就是一个普通的Java类， 而如果这个普通的Java类被@Import注解修饰，那么也可以将这个Java类注册到Spring容器中，成为Bean。

##### 1.7.1.1、定义Bean #####

public class Dog {
        
        
    }

##### 1.7.1.2、注册Bean #####

@Configuration
    @Import(value = {
        Dog.class})
    public class SpringMainConfig {
        
    }

##### 1.7.1.3、测试容器中是否有该Bean #####

@Test
    public void testDogBean() throws Exception{
        
    
      	ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
      	// 查看Spring容器中所有注册的Bean
      	String[] names = ac.getBeanDefinitionNames();
      	for (String name:names) {
        
           System.out.println(name);
      	}
    }
    /**
    	cn.bdqn.Dog
    */

##### 1.7.1.4、注意 #####

使用Import注解导入一个常规组件的时候，这个Bean的名称是类的全路径

#### 1.7.2、用法二 ####

即Import可以导入被@Configuration注解所修饰的类，换句话说，Import注解可以去导入其他的配置类，存在的一个细节是：假如这个配置类里面也注册了多个Bean，那么同样也会将这些个Bean一并注册到Spring容器中。

##### 1.7.2.1、定义Bean #####

// 奥迪
    public class AuDi {
        
        
    }

// 宝马
    public class BMW {
        
    
    }

##### 1.7.2.2、新建配置类并注册Bean #####

// 针对系统中存在的车的一个配置类
    @Configuration
    public class Car {
        
    
        @Bean
        public AuDi auDi(){
        
            return new AuDi();
        }
    
        @Bean
        public BMW bmw(){
        
            return new BMW();
        }
    }

##### 1.7.2.3、Import导入配置类 #####

@Configuration
    @Import(value = {
        Car.class})
    public class SpringMainConfig {
        
    }

##### 1.7.2.4、测试容器有哪些Bean #####

测试代码如同8.7.1.3，结果如下：

/**
    	cn.bdqn.Car	---> 配置类
    	auDi		---> 配置类中的奥迪Bean
    	bmw			---> 配置类中的宝马Bean
    */

##### 1.7.2.5、总结 #####

*  测试后发现，如果Import导入的是一个配置类，那么Spring会将这个配置类、以及配置类中定义的Bean都会注册到容器中。
 *  同时，有Import注解修饰的那个配置类是主配置类，被Import注解导入的配置类也叫子配置类。例如用法二，SpringMainConfig这个配置类就是主配置类，Car这个配置类称之为子配置类。
 *  这样做的好处：可以将不同功能、不同业务的Bean单独分开配置，而不是统一的都配置到一个配置类中，单独配置，结构清晰，功能划分的也很清楚。

### 1.8、PropertySource注解 ###

==作用：可以设置properties文件的位置，这样的话，就可以通过Value注解读取配置文件的内容。==该注解的作用等同于：

<context:property-placeholder location="classpath:db.properties"/>

位置：该注解通常和@Configuration注解一起使用。

#### 1.8.1、定义Pig.properties文件 ####

id=1
    name=丁春秋

#### 1.8.2、主配置类 ####

@Configuration	// 主配置类
    @ComponentScan("cn.bdqn")	// 扫描包，目的是能够扫描到Pig类
    @PropertySource(value = {
        "pig.properties"})	//加载配置文件
    public class SpringMainConfig {
        
        
    }

#### 1.8.3、测试 ####

@Test
    public void testPig() throws Exception{
        
    
       	ApplicationContext ac = new AnnotationConfigApplicationContext(SpringMainConfig.class);
    
       	Pig pig = (Pig) ac.getBean("pig");
    
       	System.out.println(pig);	// 1,name
    }

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

## 好书推荐 ##

![在这里插入图片描述][ad5d1e1497e94171a10b6dafefff95e4.png]

**《Java官方入门教程（第9版·Java 17）》**

本书针对Java SE 17做了全面细致的更新，将引导你轻松学习最新的核心Java编程技能。开篇讲述基础知识，内容涉及如何创建、编译和运行Java程序。此后浓墨重彩地描述构成Java语言核心的关键字、语法和结构。本书还涵盖Java的一些更高级特性，如多线程编程、泛型、lambda表达式、模块、记录、密封类和Swing。另外，还介绍了Java的交互式编程工具JShell。本书通俗易懂、简明扼要、详略得当，成为全球数百万读者的选择。

**作者简介**

> **\[美\]赫伯特·希尔特(Herbert Schildt)**  
> Herbert是Java语言领域的权威专家，拥有伊利诺伊大学的学士和硕士学位。被International Developer杂志评为“全球最著名的编程书籍创作者之一”“。他撰写的编程书籍在全球范围内销售了数百万册，已被翻译 成所有主要的非英语语言。他撰写了大量Java方面的书籍，包括Java: The Complete Reference、Herb Schildt’s Java Programming Cookbook、Introducing JavaFX 8 Programming和 Swing: A Beginner’s Guide。还撰写了许多关于C、C++和C\#的图书。Ed Burns在Secrets of the Rock Star Programmers: Riding the IT Crest一书中将Herbert列为明星程序员。尽管对计算机的所有方面都感兴趣，但Herbert主要关注计算机语言。

**购书链接：[点此进入][Link 1]**

![在这里插入图片描述][5d81e68aa5684e8a93996df87b33140a.png_pic_center]

[15dfca57a7a3459f9465c713c7f0dfc2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/56852e8d40e6417eb294a045542ec34c.png
[d967687b16084bf19769e30752691aaf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/1583e44abf7443f18ffc209ff1cadd2c.png
[eb389a3053c142f88d77d6dc462fa272.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/aa34661b23d847b994c086770eeab0c7.png
[743f6eb025ec4f51941882d44c9e2207.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/c4ecbd31d23f43c78a37af324dca7214.png
[ea9708d2851e4d5d92b50bf9d0e2781f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/7a4d385ff6cb473faac73aef375122e2.png
[45a7998991a64728842bf3faf8da79c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/fe6e1e640e64451685ab804a6a74f995.png
[f2e4f799be74497992042ef34a284d2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/a27b864ed74d4de49819c0ba7d370176.png
[3116f190a0514d1ebc369433be2cfb5d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/28c19c92da684c55b47b083c3c482f7c.png
[ad5d1e1497e94171a10b6dafefff95e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/5515c200690848df9995d8a7e9e49d94.png
[Link 1]: https://union-click.jd.com/jdc?e=618%7Cpc%7C&p=JF8BAQkJK1olXwMGVlZcAUgfCl8IGVIXXwAHVG4ZVxNJXF9RXh5UHw0cSgYYXBcIWDoXSQVJQwYAXVxfDk4XHDZNRwYlD1oGXB0JSx50dC8LEhprFnl0DFcYaEcbM244GFoWWA4CUFtVDnsnA2g4STXN67Da8e9B3OGY1uefK1olXQACV1xUAE8QAW4MHWsSXQ8yDwszfClMei9_fAByFHVcZG5tC3sQA2YcHSlUDxIEJm5tCHsUM28JG1ISXQABVV5VFEsQA2kIHkcVWwYBVldVDE8eC20AK1kUXAILZG5tDk8XAwhVYF5XJFhDHCkubyl3AS1USzlqMwRFBzs8VUsWei1jcF0RVAZEMW5t
[5d81e68aa5684e8a93996df87b33140a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/09/cc7c75eeded447a184f0318447fc4796.png