Analisis kod sumber Spring Cloud: Bahagian 1

Jangan ketawakan rakan yang membaca kod sumber Pada masa kini, temu bual hanya tentang esei lapan bahagian dan tidak boleh dipercayai. Saya tidak mempunyai pilihan selain membuat roda, jika tidak ia akan menjadi sangat memenatkan dan membosankan!

Secara peribadi, saya rasa prasyarat untuk membaca kod sumber adalah untuk dapat menggunakannya, anda boleh meneka bagaimana orang lain melaksanakannya. Jika ada dokumen rasmi yang berkaitan, kemudian baca dokumen rasmi.

Namun, sayangnya banyak dokumen rasmi yang ditulis dengan buruk sehingga membuatkan anda keliru selepas membacanya seketika.

Baru-baru ini saya sedang belajar 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">openfeign kod sumber Pada masa itu, saya menemui anotasi utama dalam kod sumber: @Import . openfeign源码的时候，发现在源码中有个关键注解：@Import。

项目启动类：

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月07日 16:47
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
@EnableFeignClients(basePackages = {"com.tian.feign"})
@SpringBootApplication()
public class    MqApplication {
    public static void main(String[] args) {
        SpringApplication.run(MqApplication.class, args);
    }
}

然后，就是我们的feignclient接口：

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月07日 16:47
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
@FeignClient(contextId = "userFeignClient", value = "charge-user-service")
public interface UserFeignClient {

    /**
     * 邀请成功增加收益
     *
     * @param invitedDto 邀请增加收益
     * @return 邀请成功
     */
    @PostMapping("/user/invited/register")
    CommonResult<Boolean> invitedRegister(@RequestBody InvitedDto invitedDto);
}

使用案例：

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月07日 16:47
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    UserFeignClient userFeignClient;

    @PostMapping("/invited")
    public CommonResult invitedRegister(){
        //省略不想搞的代码
        return userFeignClient.invitedRegister(invitedDto);
    }

}

从上面的代码中，我们可以看出openfeign关键代码有：

@EnableFeignClients(basePackages = {"com.tian.feign"})

@FeignClient(contextId = "userFeignClient", value = "charge-user-service")

userFeignClient.invitedRegister(invitedDto);

Kelas permulaan projek: 🎜

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月07日 16:47
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients { 
 String[] value() default {}; 
 String[] basePackages() default {}; 
 Class<?>[] basePackageClasses() default {}; 
 Class<?>[] defaultConfiguration() default {}; 
 Class<?>[] clients() default {};
}

🎜Kemudian, inilah feignclientAntaramuka: 🎜

@Import(FeignClientsRegistrar.class)

🎜Kes penggunaan: 🎜

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月07日 16:47
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
                                    BeanDefinitionRegistry registry) {
    registerDefaultConfiguration(metadata, registry);
    registerFeignClients(metadata, registry);
}

🎜Daripada kod di atas, kita dapat melihat bahawaopenfeignKod utama ialah: 🎜

@EnableFeignClients( basePackages = {"com.tian.feign"})🎜

@FeignClient(contextId = "userFeignClient", value = " charge-user-service")🎜

userFeignClient.invitedRegister(invitedDto);🎜

@EnableFeignClients

@EnableFeignClients这个注解在启动类上，我们肯定要重点关注。

小技巧：凡是以@Enable开头的各种注解基本上都是开启xxxx。比如：@EnableFeignClients表示开启feign客户端。

我们进入@EnableFeignClients中

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月07日 16:47
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients { 
 String[] value() default {}; 
 String[] basePackages() default {}; 
 Class<?>[] basePackageClasses() default {}; 
 Class<?>[] defaultConfiguration() default {}; 
 Class<?>[] clients() default {};
}

我们通常只需要关心属性basePackages，表示我们需要扫描的包目录。

如果既没有指定basePackages，也没有指定basePackageClasses，则采用启动类所在的目录作为包扫描路径。默认是这种情况。

本文重点来了，在这个注解@EnableFeignClients上有个注解@Import(FeignClientsRegistrar.class)，这里到底是有什么作用？

@Import()@Import()

@Import()注解是在spring 3.0版本中引入的，字面意义就是导入.

@Import注解的全类名是org.springframework.context.annotation.Import。其只有一个默认的value属性，该属性类型为Class<?>[]，表示可以传入一个或多个Class对象。

通过注释可以看出，该注解有如下作用：

可以导入一个或多个组件类（通常是@Configuration配置类）该注解的功能与Spring XML中的<import/>元素相同。可以导入@Configuration配置类、ImportSelect和ImportBeanDefinitionRegistrar的实现类。

从spring 4.2版本开始，还可以引用常规组件类（普通类），该功能类似于AnnotationConfigApplicationContext.register()方法。

该注解可以在类中声明，也可以在元注解中声明。如果需要导入XML或其他非@Configuration定义的资源，可以使用@ImportResource

@Import() anotasi telah diperkenalkan pada musim bunga versi 3.0 dan makna literalnya ialah import.

🎜Nama kelas penuh anotasi @Import ialah org.springframework.context.annotation.Import. Ia hanya mempunyai satu atribut nilai lalai, iaitu jenis Class&lt ;?>[], menunjukkan bahawa satu atau lebih objek Kelas boleh dihantar masuk. 🎜🎜Seperti yang dapat dilihat daripada anotasi, anotasi mempunyai fungsi berikut: 🎜🎜Anda boleh mengimport satu atau lebih kelas komponen (biasanya kelas konfigurasi @Configuration Fungsi anotasi ini adalah sama dengan <import/> elemen adalah sama . Boleh mengimport@ConfigurationKelas konfigurasi, ImportSelect dan ImportBeanDefinitionRegistrar kelas pelaksanaan. 🎜🎜Bermula dari musim bunga 4.2, anda juga boleh merujuk kelas komponen biasa (kelas biasa) Fungsi ini serupa dengan Kaedah AnnotationConfigApplicationContext.register(). 🎜🎜Anotasi ini boleh diisytiharkan dalam kelas atau dalam anotasi meta. Jika anda perlu mengimport XML atau lain-lain bukan- , 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96 );">@Configuration Untuk sumber yang ditentukan, anda boleh menggunakan @ImportResource anotasi . 🎜🎜Biasanya ada tiga cara untuk menggunakannya: 🎜

• @Import一个普通类 spring会将该类加载到spring容器中
• @Import一个类，该类实现了ImportBeanDefinitionRegistrar接口，在重写的registerBeanDefinitions方法里面，能拿到BeanDefinitionRegistry的注册器，能手工往beanDefinitionMap中注册 beanDefinition
• @Import一个类 该类实现了ImportSelector 重写selectImports方法该方法返回了String[]数组的对象，数组里面的类都会注入到spring容器当中。

下面我们来聊聊@Import在openfeign的这里是起到什么作用。

openfeign中作用

回答上面的代码里

@Import(FeignClientsRegistrar.class)

这里导入的是FeignClientsRegistrar类，我们再来看看他的类关系图：

从类关系图来看，FeignClientsRegistrar实现了ImportBeanDefinitionRegistrar接口。再结合@Import的三种使用方式中的第二种方式，能手工往beanDefinitionMap中注册 beanDefinition。

/**
 * @author tianwc  公众号：java后端技术全栈、面试专栏
 * @version 1.0.0
 * @date 2023年07月07日 16:47
 * 在线刷题 1200+题和1000+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
 */
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
                                    BeanDefinitionRegistry registry) {
    registerDefaultConfiguration(metadata, registry);
    registerFeignClients(metadata, registry);
}

这个方法registerBeanDefinitions()是feign的核心入口方法，其中会做两件事：

注册默认的配置和注册所有的FeignClient。

registerDefaultConfiguration(metadata, registry)

这个方法是负责注册OpenFeign的默认配置 ，逻辑相对简单：

private void registerDefaultConfiguration(AnnotationMetadata metadata,
                                          BeanDefinitionRegistry registry) {
    //获取@EnableFeignClients的全部属性
    //@EnableFeignClients(basePackages = {"com.tian.feign"}) 
    //这里的basePackages就是我们指定的熟悉
    Map<String, Object> defaultAttrs = metadata
        .getAnnotationAttributes(EnableFeignClients.class.getName(), true);

    if (defaultAttrs != null && defaultAttrs.containsKey("defaultConfiguration")) {
        String name;
        if (metadata.hasEnclosingClass()) {
            name = "default." + metadata.getEnclosingClassName();
        }
        else {
            name = "default." + metadata.getClassName();
        }
        registerClientConfiguration(registry, name,
                                    defaultAttrs.get("defaultConfiguration"));
    }
}

defaultAttrs中内容如下：

但是这里我们只关注defaultConfiguration，我们并有对其进行设置，所以我们可以忽略他。重点是下面这个方法。

registerFeignClients(metadata, registry)

这里就是项目启动时和openfeign相关的核心代码，这也是@EnableFeignClients和@FeignClient两个注解关联起来的地方。

我们进入源码中：

public void registerFeignClients(AnnotationMetadata metadata,
                                 BeanDefinitionRegistry registry) {
    
    ClassPathScanningCandidateComponentProvider scanner = getScanner();
    scanner.setResourceLoader(this.resourceLoader);

    Set<String> basePackages;

    Map<String, Object> attrs = metadata
        .getAnnotationAttributes(EnableFeignClients.class.getName());
    AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(
        FeignClient.class);
    final Class<?>[] clients = attrs == null ? null
        : (Class<?>[]) attrs.get("clients");
    if (clients == null || clients.length == 0) {
        scanner.addIncludeFilter(annotationTypeFilter);
        basePackages = getBasePackages(metadata);
    }
    else {
        final Set<String> clientClasses = new HashSet<>();
        basePackages = new HashSet<>();
        for (Class<?> clazz : clients) {
            basePackages.add(ClassUtils.getPackageName(clazz));
            clientClasses.add(clazz.getCanonicalName());
        }
        AbstractClassTestingTypeFilter filter = new AbstractClassTestingTypeFilter() {
            @Override
            protected boolean match(ClassMetadata metadata) {
                String cleaned = metadata.getClassName().replaceAll("\\$", ".");
                return clientClasses.contains(cleaned);
            }
        };
        scanner.addIncludeFilter(
            new AllTypeFilter(Arrays.asList(filter, annotationTypeFilter)));
    }

    for (String basePackage : basePackages) {
        Set<BeanDefinition> candidateComponents = scanner
            .findCandidateComponents(basePackage);
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                // verify annotated class is an interface
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(),
                              "@FeignClient can only be specified on an interface");

                Map<String, Object> attributes = annotationMetadata
                    .getAnnotationAttributes(
                    FeignClient.class.getCanonicalName());

                String name = getClientName(attributes);
                registerClientConfiguration(registry, name,
                                            attributes.get("configuration"));

                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
}

代码一行一行看是不是觉得很累，我给你总结好了。

上面的方法分为以下七个步骤：

• Mula-mula dapatkan @EnableFeignClients beranotasi Semua atribut, terutamanya untuk mendapatkan laluan pakej imbasan (basePackages); <code style='font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);'>@EnableFeignClients注解的所有属性，主要为了拿到扫描包路径（basePackages）；
• 因为一般不会在@EnableFeignClients注解中配置clients属性，所以会进入到clients属性为空时的逻辑；
• 然后通过getScanner()方法获取扫描器：ClassPathScanningCandidateComponentProvider，并将上下文AnnotationConfigServletWebServerApplicationContext作为扫描器的ResourceLoader；
• 接着给扫描器ClassPathScanningCandidateComponentProvider添加一个注解过滤器（AnnotationTypeFilter），只过滤出包含@FeignClient注解的BeanDefinition；
• 再通过getBasePackages(metadata)方法获取@EnableFeingClients
🎜 kerana ia biasanya tidak digunakan dalam @EnableFeignClients konfigurasikan atribut klien dalam anotasi, jadi ia akan memasuki logik apabila atribut klien kosong; 🎜🎜🎜🎜 Kemudian hantar getScanner() kaedah mendapat pengimbas: ClassPathScanningCandidateComponentProvider dan konteks AnnotationConfigServletWebServerApplicationContextSebagai pengimbasResourceLoader;🎜🎜🎜🎜Kemudian berikan pengimbasClassPathScanningCandidateComponentProviderTambah penapis anotasi (AnnotationTypeFilter) untuk hanya menapis fail yang mengandungi @FeignClient anotasiBeanDefinition; 🎜🎜🎜🎜 dan kemudian lulus getBasePackages(metadata) kaedah memperolehLaluan imbasan pakej atau kelas imbasan yang dinyatakan dalam anotasi @EnableFeingClients; jika tidak diperolehi, laluan pakej di mana kelas permulaan terletak akan diimbas secara lalai; 🎜🎜
• Kemudian masukkan logik teras: pas scanner.findCandidateComponents( basePackage) kaedah mengimbas semua anotasi daripada laluan pakej @FeignClientAntara muka beranotasi dan layak untuk pemasangan;
scanner.findCandidateComponents(basePackage)方法从包路径下扫描出所有标注了@FeignClient注解并符合条件装配的接口；

最后将FeignClientConfiguration 在BeanDefinitionRegistry中注册一下，再对FeignClient做真正的注册操作。

总结

在openfeign源码中的@Import注解在这里的作用就是将扫描到带有FeignClient

Akhir sekali, FeignClientConfiguration dalam Daftarkannya dalam BeanDefinitionRegistry, dan kemudian FeignClient melakukan operasi pendaftaran sebenar.

Ringkasan

DalamopenfeignAnotasi @Import dalam kod sumber digunakan di sini untuk mengimbas fail dengan FeignClientSemua kelas antara muka yang diberi anotasi didaftarkan dalam bentuk kacang dalam bekas IOC spring.

🎜 Mari kita tekankan sekali lagi cara menggunakan anotasi @Import: 🎜

• @ImportSpring kelas biasa Kelas ini akan dimuatkan ke dalam bekas spring@Import一个普通类 spring会将该类加载到spring容器中
• @Import一个类，该类实现了ImportBeanDefinitionRegistrar接口，在重写的registerBeanDefinitions方法里面，能拿到BeanDefinitionRegistry的注册器，能手工往beanDefinitionMap中注册 beanDefinition
• @Import一个类 该类实现了ImportSelector 重写selectImports

@ImportKelas yang melaksanakan ImportBeanDefinitionRegistrar kod> antara muka, dalam <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba (27, 31) , 35, 0.05);font-family: " operator mono consolas monaco menlo monospace break-all rgb>registerBeanDefinitionsIn kaedahnya, anda boleh mendapatkan <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27 , 31, 35, 0.05);font-family: " operator mono consolas monaco menlo monospace break-all rgb>BeanDefinitionRegistryregister, anda boleh menetapkan secara manual beanDefinitionMap DaftarbeanDefinition

@ImportSebuah kelas yang melaksanakan ImportSelector Tulis SemulaselectImports kaedah Kaedah ini mengembalikan objek tatasusunan String[], dan kelas dalam tatasusunan akan Inject ke dalam bekas spring .

Baiklah, itu sahaja perkongsian hari ini. Terdapat banyak perkara menarik dalam openfeign ini, kami akan kongsikan pada masa akan datang! 🎜🎜🎜🎜🎜🎜🎜

Atas ialah kandungan terperinci Analisis kod sumber Spring Cloud: Bahagian 1. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!