仿写fegin

/**
 *  开启feign的使用， 在启动类上面定义扫描的包路径。
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import(FeignRegister.class)// 使用了自定义bean的注册器
public @interface EnableFeign {

    //扫描包的路径
    String[] basePackages() default {};
}


/**
 *  用来声明加入spring的ioc 容器里面 ， 在获取baseUrl 的值。
 *  baseurl  可以用类似 @value 注解的方式从配置文件读取。
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FeignClient {

    //根部的url,可以从配置文件读取 , 必传。
    String baseUrl();
}



/**
 * 作用在方法上面，表明请求的url 和方法。方法是一个枚举类型 
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FeignRequest {
    //请求url
    String url();

    //默认请求方式get
    RequestMethonEnum methon() default RequestMethonEnum.GET;
}

/**
 *  请求方式枚举类型
 */
public enum RequestMethonEnum {

    GET,POST,DELETE
}

// 注册类
public class FeignRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    Logger logger = LoggerFactory.getLogger(FeignRegister.class);


    private Environment environment;

    /**
     *  要将环境变量的配置加进去
     * @param environment
     */
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }


    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        Set<String> packages = getPackages(importingClassMetadata);
        CustomScanner customScanner = new CustomScanner(registry, environment);
        customScanner.scan(packages.toArray(new String[0]));
    }

    /**
     *  获取包名称，并且去重
     * @param metadata
     * @return
     */
    private Set<String> getPackages(AnnotationMetadata metadata) {
        AnnotationAttributes attributes =
                AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(EnableFeign.class.getName()));
        // 获取basePackages 的属性
        String[] basePackages = attributes.getStringArray("basePackages");
        return new LinkedHashSet<>(Arrays.asList(basePackages));
    }
}

// 扫描类 
public class CustomScanner extends ClassPathBeanDefinitionScanner {

    Logger logger = LoggerFactory.getLogger(CustomScanner.class);

    private Environment environment;

    /**
     *  构造器给register 注册用的
     * @param registry
     * @param environment
     */
    public CustomScanner(BeanDefinitionRegistry registry,Environment environment) {
            super(registry, false);
            this.environment = environment;
            registerFilter();
        }


    public void registerFilter () {
            // 表示要过滤出带有 feignClient 注解的类
            addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
        }

        //扫描包下待有`@feignClient` 注解的接口，调用 processBeanDefinitions() 实现接口代理类生成注册
        @Override
        protected Set<BeanDefinitionHolder> doScan (String...basePackages){
            Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
            if (beanDefinitions.isEmpty()) {
                logger.warn("No @feignClient interface was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");
            } else {
                // 执行以下bean的注册
                processBeanDefinitions(beanDefinitions);
            }
            return beanDefinitions;
        }

        /**
         * 重写候选判断逻辑，捞出带有注解的接口
         *
         * @param beanDefinition
         * @return
         */
        @Override
        protected boolean isCandidateComponent (AnnotatedBeanDefinition beanDefinition){
            //interface  接口会自动跳过, 这里要把接口加进去beanDefinition 里面
            boolean isCandidate = false;
            AnnotationMetadata metadata = beanDefinition.getMetadata();
            if (metadata.isIndependent()) {
                if ( !metadata.isAnnotation() && metadata.hasAnnotation(FeignClient.class.getName())) {
                    isCandidate = true;
                }
            }
            return isCandidate;
        }

    /**
     *  真正进行bean 的注册
     * @param beanDefinitions
     */
    private void processBeanDefinitions (Set < BeanDefinitionHolder > beanDefinitions) {
                GenericBeanDefinition definition;
            for (BeanDefinitionHolder holder : beanDefinitions) {
                definition = (GenericBeanDefinition) holder.getBeanDefinition();
                // definition.getConstructorArgumentValues()，BeanClass需要提供包含该属性的构造方法，否则会注入失败
                definition.getConstructorArgumentValues().addGenericArgumentValue(Objects.requireNonNull(definition.getBeanClassName()));
                // 获取注解的元注解对象
                AnnotationMetadata beanMetadata = ((AnnotatedBeanDefinition) definition).getMetadata();
                AnnotationAttributes attributes = AnnotationAttributes.fromMap(beanMetadata.getAnnotationAttributes(FeignClient.class.getName()));
                //解析interface上@FeignClientInfo注解信息，转换成FeignClientInfo对象
                FeignClientInfo feignClientInfo = new FeignClientInfo(attributes, environment);
                // 使用自己的factoryBean
                definition.setBeanClass(FeignFactoryBean.class);
                //FactoryBean属性
                definition.getPropertyValues().addPropertyValue("feignClientInfo", feignClientInfo);
            }
        }

}

public class FeignFactoryBean<T> implements FactoryBean<T> , ApplicationContextAware {

    Logger logger = LoggerFactory.getLogger(FeignFactoryBean.class);

    private Class<T> targetClass;

    private ApplicationContext applicationContext;

    private FeignClientInfo feignClientInfo;

    public FeignFactoryBean(Class<T> targetClass) {
        this.targetClass = targetClass;
    }



    @Override
    public boolean isSingleton() {
        return false;
    }

    @Override
        @SuppressWarnings("unchecked")
        public T getObject() throws Exception {
            return ProxyUtil.newProxyInstance(targetClass, new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    // 获取resttemplate
                    RestTemplate restTemplate = applicationContext.getBean(RestTemplate.class);
                    MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
                    // 参数绑定
                    for (int index = 0; index < args.length; index++) {
                        Parameter p = method.getParameters()[index];
                        params.add(p.getName(), args[index]);
                    }
                    String url = feignClientInfo.getBaseUrl();
                    FeignRequest annotation = method.getAnnotation(FeignRequest.class);
                    logger.info("FeignRequest注解上面的url是: "+url);
                    RequestMethonEnum methon = annotation.methon();
                    String response = null;
                    // 这里只写了post 
                    switch (methon){
                        case POST :
                            response   = restTemplate.postForObject(url+annotation.url(), params, String.class);
                            break;
                    }

                    // 判断返回类型是不是string
                    if (method.getReturnType() == String.class) {
                        return response;
                    }
                    return JSONObject.parseObject(response, method.getReturnType());
                }
            });
        }

    @Override
    public Class<?> getObjectType() {
        return targetClass;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

            this.applicationContext=applicationContext;
    }

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public FeignClientInfo getFeignClientInfo() {
        return feignClientInfo;
    }

    public void setFeignClientInfo(FeignClientInfo feignClientInfo) {
        this.feignClientInfo = feignClientInfo;
    }
}

@Configuration
public class RestTemplateConfig {

    /**
     *  生命restTemplate是一个bean 
     * @return
     */
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplateBuilder().build();
    }
}