精华内容
下载资源
问答
  • spring注入枚举类型作为参数

    万次阅读 2014-04-05 18:17:51
    //定义枚举类型 public enum ReportType { MONTH,WEEK,DAY } //使用枚举类型 public class ReportJob { private ReportType reportType; } //spring配置文件注入 注意: 枚举类型要想注入到...
    //定义枚举类型
    public enum ReportType {
        MONTH,WEEK,DAY
    }
    
    //使用枚举类型
    public class ReportJob {
        private ReportType reportType;
    }
    
    //spring配置文件注入
    <bean id="DAY" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">  
        	<property name="staticField" value="com.test.ReportType.DAY" />  
    	</bean>
    <bean id="dayReportJob" class="com.test.ReportJob">
    		<property name="reportType" ref="DAY" />
    	</bean>


    注意:

    枚举类型要想注入到类中,一定要先使用org.springframework.beans.factory.config.FieldRetrievingFactoryBean类将枚举类型进行转换,即

    <bean id="DAY" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">  
        	<property name="staticField" value="com.test.ReportType.DAY" />  
    	</bean>
    将ReportType.Day转换为DAY这个bean,然后在要注入的bean中使用<property name="reportType" ref="DAY" />引用即可。
    展开全文
  • JNI中枚举类型作为参数

    千次阅读 2017-09-22 17:48:07
    考虑本地函数参数中含有枚举类型的对象,在JNI部分要获取的是枚举对象,而非对象的一个函数。 package test; public class enumclass { public enum DATE { MONDAY, TUESDAY, WEDNESDAY, ...

    参考资料:使用JNI进行Java与C/C++语言混合编程(1)--在Java中调用C/C++本地库

         java native方法及JNI实例

    JNI是Java Native Interface的英文缩写,中文翻译为本地调用, 自从Java 1.1开始就成为了Java标准的一部分.

    C/C++是系统级的编程语言, 可以用来开发任何和系统相关的程序和类库, 但是Java本身编写底层的应用比较难实现, 使用JNI可以调用现有的本地库, 极大地灵活了Java的开发.

    C/C++的效率是目前最好的语言, 可以使用C/C++来实现一些实时性非常高的部分. C/C++和Java本身都是非常流行的编程语言, 一些大型软件中经常使用语言之间的混合编程.

    鉴于目前网络上JNI的文章不是特别多, 我将自己的一些总结写在这里. 如有错漏, 欢迎指正!

    Java调用C/C++大概有这样几个步骤

    1. 编写带有native方法的Java类, 使用javac工具编译Java类
    2. 使用javah来生成与native方法对应的头文件
    3. 实现相应的头文件, 并编译为动态链接库(windows下是.dll, linux下是.so)

    1.简单的JNI-HelloWorld

    首先我们看一下:Linux下JNI技术使用的一个简单实例

    首先,实现的是Java本地接口Hello.java,代码如下所示:

    复制代码
    class HelloWorld {
    
        public native void sayHello();
    
        static {
            System.loadLibrary("HelloWorld");
        }
    
        public static void main(String[] args) {
            (new HelloWorld()).sayHello();
        }
    }
    复制代码

     

    其中,方法声明为native,其实HelloWorld类就相当于一个接口,是为其他编程语言声明的接口。System.loadLibrary("HelloWorld");语句是一个static块,也就是在该HelloWorld类加载的时候进行执行。其中,该语句实现了加载本地的动态连接库(DLL),在Linux平台下,动态连接库文件是以.so作为扩展名的,也就是标准对象(Standard Object)。

    对该本地接口类进行编译:

    [root@localhost jni]# javac HelloWorld.java

     

    接着,通过编译的HelloWorld.class文件,生成C语言的头文件,执行命令:

    [root@localhost jni]# javah -jni HelloWorld

     

    可以看到,在当前目录下生成一个HelloWorld.h文件,该文件就是C的接口文件,为使用C实现Java接口中定义的方法,可以发现在HelloWorld.h中有一个方法声明:

    复制代码
    /* DO NOT EDIT THIS FILE - it is machine generated */
    
    #ifndef __HelloWorld__
    #define __HelloWorld__
    
    #include <jni.h>
    
    #ifdef __cplusplus
    extern "C"
    {
    #endif
    
    JNIEXPORT void JNICALL Java_HelloWorld_sayHello (JNIEnv *env, jobject);
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif /* __HelloWorld__ */
    复制代码

     


    然后,用C实现该方法,在HelloWorld.c文件中,代码如下:

    复制代码
    #include <jni.h>
    #include "HelloWorld.h"
    #include <stdio.h>
    
    JNIEXPORT void JNICALL Java_HelloWorld_sayHello (JNIEnv *env, jobject obj) {
        printf("Hello,the World!!!");
    }
    复制代码

     

    这里,方法签名为Java_HelloWorld_sayHello (JNIEnv *env, jobject obj),添加了形参obj,否则无法通过编译。

    接下来,生成动态连接库libHelloWorld.so,执行命令:

    [root@localhost jni]# gcc -fPIC -shared -o libHelloWorld.so HelloWorld.c

     

    (这里可能会遇到jni.h找不到的情况,再你配置的JAVA_HOME 文件夹目录下加上如下路径选项即可:

    -I $JAVA_HOME)/include -I $JAVA_HOME/include/linux


    可以在当前目录下看到libHelloWorld.so,动态连接库文件名称以lib开头。将该文件拷贝到usr/lib目录下面,就可以测试了。

    现在执行如下命令进行测试:

    [root@localhost jni]# java HelloWorld

     

    输出如下:

    Hello,the World!!!

    这只是一个非常简单的例子,主要是了解JNI在Linux下该如何用。在实际应用中,可能会非常复杂,并且要记住,一旦使用了JNI技术,系统的可移植性被破坏了。有些应用中,正是基于这种特性实现,比如限制软件的传播使用,保护开发商权益,等等。

    2.枚举型作为本地函数的参数

    主要参考了这篇文章:http://blog.csdn.net/hemowolf/article/details/6925243

    JAVA 的标准JNI中并没有enum类型,但是有jobject对象,那么类和枚举类型都可以通过jobject进行传递。

      

    2.1 创建枚举类型

    每个枚举对象都有一个对应的索引值,枚举类中有一个返回值函数。

    复制代码
    package test;
     
    public class enumclass {
     
        public enum envelopeType {
            NOT_SPECIFIED(-1), NONE(0), IMAGE(1), BITMAP(2);
     
            private int value;
     
            private envelopeType(int value) {
                this.value = value;
            }
     
            public int getValue() {
                return value;
            }
        }
     
    }
    复制代码

    2.2 JAVA  本地函数

    复制代码
    package test;
     
    import test.enumclass.envelopeType;
     
    public class enumtest {
     
        private envelopeType ent;
     
        public native static void printValue(envelopeType entype);
     
        public static void main(String[] args) {
     
            System.load("/home/sk/workspace/testenumjni2/jni/test.so");
     
            enumtest t1 = new enumtest();
            envelopeType e1 = null;
            int a = e1.IMAGE.getValue();
            System.out.println("------ the envelopeType value is :" + a);
            envelopeType e2 = envelopeType.NOT_SPECIFIED;
            // e2.IMAGE;
            printValue(e2);
     
        }
     
    }
    复制代码

    在命令行中(linux环境下)切换到工程的bin目录下执行如下命令:编译生成.h文件。

    javah  -jni test.enumtest

    2.3 JNI 接口部分

    根据上步的.h文件,编写对应的c/cpp文件。

    复制代码
    /* DO NOT EDIT THIS FILE - it is machine generated */
    #include <jni.h>
    /* Header for class test_enumtest */
     
    #ifndef _Included_test_enumtest
    #define _Included_test_enumtest
    #ifdef __cplusplus
    extern "C" {
    #endif
    /*
     * Class:     test_enumtest
     * Method:    printValue
     * Signature: (Ltest/enumclass/envelopeType;)V
     */
    JNIEXPORT void JNICALL Java_test_enumtest_printValue
    (JNIEnv *env, jobject obj1, jobject obj2) {
     
        jclass enumclass= env->GetObjectClass(obj2);
        if(enumclass == NULL) {
            printf(" get enumclass failed\r\n");
            return;
        }
     
        jmethodID getVal = env->GetMethodID(enumclass, "getValue", "()I");
        jint value = env->CallIntMethod(obj2, getVal);
            printf("------ the envelopeType value is :%d\r\n", value);
     
    }
     
    #ifdef __cplusplus
    }
    #endif
    #endif
    复制代码

    env->GetMethodID 有三个参数,第一个表示获取的类的名字,第二个参数是函数名,最后一个参数应该这样获得:

    这个参数应该是JAVA的类的方法的签名,它可以通过jdk的工具 javap 得到。如上面的 test.enumtest.envelopeType 类中的 getValue 方法,可以在命令行里执行:

    javap -s test.enumtest.envelopeType

     

    得到 test.enumtest.envelopeType  的所有方法的签名。

     

    2.4 下面是另一个没有索引值的枚举类型列子

    考虑本地函数参数中含有枚举类型的对象,在JNI部分要获取的是枚举对象,而非对象的一个函数。

    复制代码
    package test;
     
    public class enumclass {
     
        public enum DATE {
     
            MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATUDAY, SUNDAY;
        }
     
         
    }
    复制代码
    复制代码
    import test.enumclass.DATE;
     
    public class enumtest {
     
        private DATE date;
        public native static void callobj(DATE date);
         
        public static void main(String[] args){
             
            System.load("/home/sk/workspace/testenumjni3/jni/test.so");
            enumtest e1 = new enumtest();
            e1.date = DATE.SATUDAY;
            System.out.println(e1.date);
            //Now we call the native method
             
            DATE today = DATE.TUESDAY;
            callobj(today);
        }
         
    }
    复制代码
    复制代码
    /* DO NOT EDIT THIS FILE - it is machine generated */
    #include <jni.h>
    #include<string.h>
    /* Header for class test_enumtest */
     
    #ifndef _Included_test_enumtest
    #define _Included_test_enumtest
    #ifdef __cplusplus
    extern "C" {
    #endif
    /*
     * Class:     test_enumtest
     * Method:    callobj
     * Signature: (Ltest/enumclass/DATE;)V
     */
    JNIEXPORT void JNICALL Java_test_enumtest_callobj
      (JNIEnv *env, jobject obj1, jobject obj2){
     
        jclass enumclass= env->GetObjectClass(obj2);
            if(enumclass == NULL) {
                printf(" get enumclass failed\r\n");
                return;
            }
     
            jmethodID getVal = env->GetMethodID(enumclass, "name", "()Ljava/lang/String;");
            jstring value = (jstring)env->CallObjectMethod(obj2, getVal);
            const char * valueNative = env->GetStringUTFChars(value, 0);
     
            if (strcmp(valueNative, "MONDAY") == 0) {
            printf("TODAY IS MONDAY!");
            }
            else
                printf("TODAY IS  NOT MONDAY!");
     
     
     
    }
     
    #ifdef __cplusplus
    }
    #endif
    #endif
    复制代码

    jmethodID getVal = env->GetMethodID(enumclass, "name", "()Ljava/lang/String;");

    这里name()函数是enum类型自带的函数,()Ljava/lang/String;是对应的签名。具体的ENUM类型可以参考官方文档:

    http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Enum.html

    另外就是这里换成了(jstring)env->CallObjectMethod(obj2, getVal);方法。

     

    3.涉及C/C++与JAVA类型转换的问题

     下面的一个例子,是要在JNI中完成由C++写的代码函数的调用,函数的参数包括枚举类型的。需要在JNI中对原来C/C++定义的枚举型重新做一次映射(在数据量小的时候这样操作是可行的)。

    复制代码
    /* DO NOT EDIT THIS FILE - it is machine generated */
    #include <jni.h>
    #include<string.h>
    /*emun类型定义*/
    enum DATE {
       
            MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATUDAY, SUNDAY;
        }
     void returndate(DATE date);
     void returndate(DATE date){
        printf("%d/n","TODAY IS :");
        switch(date){
        case MONDAY:
         printf("%d/n","MONDAY");
        break;
        case TUESDAY:
             printf("%d/n","TUESDAY");
             break;
        case WEDNESDAY:
             printf("%d/n","WEDNESDAY");
             break;
        case THURSDAY:
             printf("%d/n","THURSDAY");
             break;
        case FRIDAY:
             printf("%d/n","FRIDAY");
             break;
        case SATUDAY:
             printf("%d/n","SATUDAY");
             break;
         case SUNDAY:
             printf("%d/n","SUNDAY");
    }
    }
    /* Header for class test_enumtest */
       
    #ifndef _Included_test_enumtest
    #define _Included_test_enumtest
    #ifdef __cplusplus
    extern "C" {
    #endif
    /*
     * Class:     test_enumtest
     * Method:    callobj
     * Signature: (Ltest/enumclass/DATE;)V
     */
    JNIEXPORT void JNICALL Java_test_enumtest_callobj
      (JNIEnv *env, jobject obj1, jobject obj2){
    jclass enumclass= env->GetObjectClass(obj2);
            if(enumclass == NULL) {
                printf(" get enumclass failed\r\n");
                return;
            }
       
            jmethodID getVal = env->GetMethodID(enumclass, "name", "()Ljava/lang/String;");
            jstring value = (jstring)env->CallObjectMethod(obj2, getVal);
            const char * valueNative = env->GetStringUTFChars(value, 0);
             DATE date;
            //这里完成一个转换
            if (strcmp(valueNative, "MONDAY") == 0) {
             date = MONDAY;
            }
            if.....(这里接着判断)
     returndate(date);
       
       
    }
       
    #ifdef __cplusplus
    }
    #endif
    #endif
    复制代码

    如果在JNI函数中调用C++的函数中带有枚举型参数,用jstring类型或者 char*类型的做参数都会报错,可以做的就是再做一次名字的映射,将上述类型映射成enmu类型,再当作参数去传递,就不会有问题了。

    展开全文
  • 也就是说只要不是成员运算符的重载不管返回值是什么类型,不管重载什么类型的运算符,必须有一个参数为类类型或者枚举类型(vs2019)

    在这里插入图片描述
    也就是说只要不是成员运算符的重载不管返回值是什么类型,不管重载什么类型的运算符,必须有一个参数为类类型或者枚举类型(vs2019)

    展开全文
  • Spring Cloud Feign绑定枚举类型参数

    千次阅读 2018-02-28 12:23:23
    在之前的文章《Spring Boot绑定枚举类型参数》中,我们讨论了Spring中的Converter和ConverterFactory,以及如何与Spring Boot整合以使得WebMVC能够接收枚举类型的参数。现在Spring Cloud已经逐渐流行了起来,其中最...

        在之前的文章《Spring Boot绑定枚举类型参数》中,我们讨论了Spring中的Converter和ConverterFactory,以及如何与Spring Boot整合以使得WebMVC能够接收枚举类型的参数。现在Spring Cloud已经逐渐流行了起来,其中最流行的要数Spring Cloud Netflix系列了。Netflix有个很重要的服务治理中间件Eureka,Feign由于其声名式的使用方式,使用@RequestMapping, @RequestParam, @PathVariable等传统的Spring Web MVC注解得以广泛使用。不过正如Spring Web MVC一样,在绑定参数的时候也会出现绑定自定义类型(例如枚举)的需求,在代码中手动进行转换当然能解决问题,但是这样终究不够优雅。经过稍加研究之后,分享给大家。

        我们都知道,Feign是Spring Cloud的众多实现之一,自然也可以使用Spring的功能进行配置。于是Spring的Converter又可以派上用场了(详见《Spring Boot绑定枚举类型参数》)。那么怎么才能将已经写好的Converter用到Feign当中呢?

        很显然,我们需要重新配置一下Feign。关于Feign的配置,可以点开@FeignClient注解,在这里发现这样一段代码:

        清单1 @FeignClient中的Configuration注解

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface FeignClient {
    	// ...
    
    	/**
    	 * A custom <code>@Configuration</code> for the feign client. Can contain override
    	 * <code>@Bean</code> definition for the pieces that make up the client, for instance
    	 * {@link feign.codec.Decoder}, {@link feign.codec.Encoder}, {@link feign.Contract}.
    	 *
    	 * @see FeignClientsConfiguration for the defaults
    	 */
    	Class<?>[] configuration() default {};
    
    	// ...
    }

        可以看到,只要写一个配置类,让@FeignClient的configuration字段指向这个配置类就可以解决这个问题,而且官方的源码中还给出了一个默认的配置类FeignClientsConfiguration。既然要写配置类,那毫无疑问要看看这个默认配置类FeignClientsConfiguration怎么写。

        清单2 官方的FeignClientsConfiguration实现

    @Configuration
    public class FeignClientsConfiguration {
    
    	@Autowired
    	private ObjectFactory<HttpMessageConverters> messageConverters;
    
    	@Autowired(required = false)
    	private List<AnnotatedParameterProcessor> parameterProcessors = new ArrayList<>();
    
    	@Autowired(required = false)
    	private List<FeignFormatterRegistrar> feignFormatterRegistrars = new ArrayList<>();
    
    	@Autowired(required = false)
    	private Logger logger;
    
    	@Bean
    	@ConditionalOnMissingBean
    	public Decoder feignDecoder() {
    		return new ResponseEntityDecoder(new SpringDecoder(this.messageConverters));
    	}
    
    	@Bean
    	@ConditionalOnMissingBean
    	public Encoder feignEncoder() {
    		return new SpringEncoder(this.messageConverters);
    	}
    
    	@Bean
    	@ConditionalOnMissingBean
    	public Contract feignContract(ConversionService feignConversionService) {
    		return new SpringMvcContract(this.parameterProcessors, feignConversionService);
    	}
    
    	@Bean
    	public FormattingConversionService feignConversionService() {
    		FormattingConversionService conversionService = new DefaultFormattingConversionService();
    		for (FeignFormatterRegistrar feignFormatterRegistrar : feignFormatterRegistrars) {
    			feignFormatterRegistrar.registerFormatters(conversionService);
    		}
    		return conversionService;
    	}
    
    	@Configuration
    	@ConditionalOnClass({ HystrixCommand.class, HystrixFeign.class })
    	protected static class HystrixFeignConfiguration {
    		@Bean
    		@Scope("prototype")
    		@ConditionalOnMissingBean
    		@ConditionalOnProperty(name = "feign.hystrix.enabled", matchIfMissing = false)
    		public Feign.Builder feignHystrixBuilder() {
    			return HystrixFeign.builder();
    		}
    	}
    
    	@Bean
    	@ConditionalOnMissingBean
    	public Retryer feignRetryer() {
    		return Retryer.NEVER_RETRY;
    	}
    
    	@Bean
    	@Scope("prototype")
    	@ConditionalOnMissingBean
    	public Feign.Builder feignBuilder(Retryer retryer) {
    		return Feign.builder().retryer(retryer);
    	}
    
    	@Bean
    	@ConditionalOnMissingBean(FeignLoggerFactory.class)
    	public FeignLoggerFactory feignLoggerFactory() {
    		return new DefaultFeignLoggerFactory(logger);
    	}
    
    }

    重点关注代码的28-41行。可以看到,Feign的ApplicationContxt中配置了一个FormattingConversionService,Feign就是通过这个FormattingConversionService来进行类型转换的。在这个FormattingConversionService的父类(已经差了两辈了)GenericConversionService中可以找到:

        清单3 GenericConversionService中配置Converter和ConverterFactory

    public class GenericConversionService implements ConfigurableConversionService {
    
    	// ...
    
    	@Override
    	public void addConverter(Converter<?, ?> converter) {
    		// ...
    	}
    
    	@Override
    	public <S, T> void addConverter(Class<S> sourceType, Class<T> targetType, Converter<? super S, ? extends T> converter) {
    		// ...
    	}
    
    	@Override
    	public void addConverter(GenericConverter converter) {
    		// ...
    	}
    
    	@Override
    	public void addConverterFactory(ConverterFactory<?, ?> factory) {
    		// ...
    	}
    
    	@Override
    	public void removeConvertible(Class<?> sourceType, Class<?> targetType) {
    		// ...
    	}
    
    	// ...
    }

        嘿嘿,你发现了什么?正是那熟悉的addConverter和addConverterFactory!有了这个,只要在新写好的Feign配置类中,在这个FormattingConversionService中调用这些方法就可以把写好的Converter和ConverterFactory注册进去。不过在清单2的feignContract()方法中的入参是ConversionService,并且还指定了@ConditionalOnMissingBean注解,而这个feignConversionService()方法则没有指定@ConditionalOnMissingBean注解,说明官方并不想让我们直接覆盖FormattingConversionService,而是通过调用feignContract()方法注册Converter和ConverterFactory。

        因此最后的思路就是,写一个Feign的配置类,里面要配置一个返回类型为Contract(就是官方FeignClientsConfiguration中的feignContract()返回类型)的Bean,在这个Bean中利用ConversionService注册Converter和ConverterFactory,写好之后再把这个配置类写到@FeignClient注解的configuration字段中,这样就能够实现自定义类型转换。这里面有一个小坑,就是这个配置类所在的包不能在@ComponentScan能够扫到的路径中。参考官方文档:

    The FooConfiguration has to be @configuration but take care that it is not in a @componentscan for the main application context, otherwise it will be used for every @feignclient. If you use @componentscan (or @springbootapplication) you need to take steps to avoid it being included (for instance put it in a separate, non-overlapping package, or specify the packages to scan explicitly in the @componentscan).

        好了,既然思路清晰了,就开始干活。

        首先,枚举和实现接口定义如下

        清单4 枚举的定义

        

    public enum Language implements NamedEnum {
    
        UNLIMITED("--"),
    
        // 英语
        ENGLISH("en"),
    
        // 简体中文
        CHINESE_SIMPLIFIED("zh-CN"),
    
        // 繁体中文
        CHINESE_TRADITIONAL("zh-TW");
    
        //语言的ISO_639-1缩写
        private String name;
    
        public String getName() {
            return name;
        }
    
        Language(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return name;
        }
    }

        清单5 接口NamedEnum的定义

    package org.fhp.springclouddemo.enums;
    
    import org.fhp.springclouddemo.exceptions.NoMatchedEnumException;
    
    import java.io.Serializable;
    import java.util.HashMap;
    import java.util.Map;
    
    public interface NamedEnum extends Serializable {
        String getName();
    
        Map<Class, Map> ENUM_MAP = new HashMap<>();
    
        static <E extends Enum & NamedEnum> E getByName(String name, Class<E> clazz) throws NoMatchedEnumException {
    //        Class<E> clazz = E.class;
            Map enumMap = ENUM_MAP.get(clazz);
    
            if(null == enumMap) {
                E[] enums = clazz.getEnumConstants();
    
                enumMap = new HashMap<String, E>();
    
                for(E current : enums) {
                    enumMap.put(current.getName(), current);
                }
            }
    
            E result =  (E) enumMap.get(name);
            if(result != null) {
                return result;
            } else {
                throw new NoMatchedEnumException("No element matches " + name);
            }
        }
    }

        其中,NoMatchEnumException为自定义异常,可自行实现。接下来我们实现Converter。这个无需实现ConverterFactory,只实现Converter即可。

        清单6 枚举转换Converter

    package org.fhp.springclouddemo.common;
    
    import org.fhp.springclouddemo.enums.NamedEnum;
    import org.springframework.core.convert.converter.Converter;
    
    public class UniversalReversedEnumConverter implements Converter<NamedEnum, String> {
    
        @Override
        public String convert(NamedEnum source) {
            return source.getName();
        }
    }

        现在Converter和枚举都有了,我们就可以上主菜了。

        清单7 Feign Client的配置

    package org.fhp.springclouddemo.service;
    
    import com.alibaba.fastjson.JSONObject;
    import org.fhp.springclouddemo.enums.Language;
    import org.fhp.springclouddemo.feignconfig.UDFeignClientsConfiguration;
    import org.springframework.cloud.netflix.feign.FeignClient;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;
    
    @FeignClient(value = "interpatch", configuration = MyFeignClientsConfiguration.class)
    public interface HelloFeignService {
    
        @RequestMapping(method = RequestMethod.GET, value = "/api/patch/search")
        JSONObject hello(@RequestParam(value="word") String word,
                         @RequestParam(value="from") Language from,
                         @RequestParam(value="to") Language to);
    }
        其中,MyFeignClientsConfiguration的配置如下:
        清单8 Feign配置文件的实现
    package org.fhp.springclouddemo.feignconfig;
    
    import feign.Contract;
    import org.fhp.springclouddemo.common.UniversalReversedEnumConverter;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.netflix.feign.AnnotatedParameterProcessor;
    import org.springframework.cloud.netflix.feign.support.SpringMvcContract;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.format.support.FormattingConversionService;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Configuration
    public class MyFeignClientsConfiguration {
    
        @Autowired(required = false)
        private List<AnnotatedParameterProcessor> parameterProcessors = new ArrayList<>();
    
        @Bean
        public Contract feignContract(FormattingConversionService feignConversionService) {
        	//在原配置类中是用ConversionService类型的参数,但ConversionService接口不支持addConverter操作,使用FormattingConversionService仍然可以实现feignContract配置。
            feignConversionService.addConverter(new UniversalReversedEnumConverter());
            return new SpringMvcContract(this.parameterProcessors, feignConversionService);
        }
    }
    
        大功告成!现在可以用Feign绑定枚举类型的参数了。



    展开全文
  • 客户端传递枚举类型参数

    千次阅读 2017-12-26 12:17:41
    概述,在利用Spring进行Web后台开发时,经常会遇到枚举类型的绑定问题。一般情况下,如果Spring接收到的参数值为枚举值对应的字符串,Spring会根据枚举的值与传入的字符串进行对应。 枚举类如下:  public enum ...
  • Spring Boot绑定枚举类型参数

    千次阅读 2018-11-20 18:13:42
    在利用Spring进行Web后台开发时,经常会遇到枚举类型的绑定问题。一般情况下,如果Spring接收到的参数值为字符串类型,Spring会根据枚举的值与传入的字符串进行对应。假设有如下枚举 清单1:枚举定义 public enum...
  • 使用反射设置枚举类型参数

    千次阅读 2016-12-07 15:19:23
    // 下面两种方法可以获取枚举值。看il代码,枚举就是一个整数 System.Object v = System.Enum.ToObject(test_enum,1); System.Object v2 = System.Enum.Parse(test_enum, "Test4"); method.Invoke(null, new ...
  • 深入理解Java枚举类型(enum)

    万次阅读 多人点赞 2017-05-13 18:27:14
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】 关联文章: 深入理解Java类型信息...深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
  • C语言使用枚举类型作为函数参数
  • 二 .Mybatis传递枚举类型参数,应该用自定义一个类实现 TypeHandler ,其中T为你指定的枚举类,然后在mapper.xml文件里面配置相应的type指定类型即可 (1)定义枚举类 public enum Status { VALID("系统下单", "1...
  • 在我们实际开发中,枚举类型应用十分广泛,可以避免在项目中定义大量的『魔法值』变量。但是,在 web 开发中,如何将枚举对象作为请求参数传进 Controller,做到类型自动转换?直接使用@RequestParam和@Reques...
  • 枚举类型 和 可变参数

    千次阅读 2017-02-26 11:08:17
    一定要放在所有参数的最后面, sum(不可变类型,可变类型int… nums),同时可变参数最多只能有一个 可以一个个参数传进去,也可以以数组的方式传进去。 格式 type … name// 这样定义意思是sum可以接收多个整型的...
  • C语言使用枚举类型作为函数参数

    万次阅读 2019-08-14 17:31:17
  • Date类中声明一个枚举变量 public:enum Month{jan=1,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec}; Date(int,Month,int); 主函数中声明一个Date类变量的时候 My_Code::Date b(2,jan,1992); 会报错,说jan是声明的...
  • java枚举类报错 1.问题详情图 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190811131450901.png?x-oss-process=image 请教大神帮帮忙了 看到的话
  • 使用Jmeter执行web系统的测试,在向服务器发送请求时,附在请求上面的参数类型有很多种。比如说数值型(包括整数、小数)、字串类型等等。如果说系统没有规定参数值的取值范围,那么作为测试人员,我们一般都会在...
  • Java 枚举类型

    千次阅读 2019-06-01 22:23:36
    Java 枚举类型介绍。反编译枚举类示例。
  • 1.枚举的遍历 枚举遍历,采用Enum#...项目中我们经常需要根据指定参数类型获取对象实例,因此在枚举类中我们需要自定方法,实例如下: import lombok.Getter; @Getter public enum NeitTaskTypeEnum { ZIP((shor...
  • 业务场景:前端提交了枚举的一个属性value,想由spring来完成参数类型自动转换成对应的枚举。 比方有一个枚举 @AllArgsConstructor(access = AccessLevel.PRIVATE) @Getter @JsonFormat(shape = JsonFormat....
  • 枚举类型与泛型

    2017-08-08 09:06:22
    JDK1.5中新增了枚举类型和泛型,枚举类型可以取代以往常量的定义方式,将常量封装在类或接口中,还提供了安全检查功能。枚举类型本质上还是以类的形式存在。泛型的出现不仅可以让程序员少写很多代码,主要的作用是...
  • 枚举类型成员的方法

    千次阅读 2019-06-26 14:54:02
    枚举类型较传统定义常量的方式,除了具有参数类型检测的优势之外,还具有其他方面的优势。 用户可以将一个枚举类型看作是枚举类型的一个实例,它继承于java.lang.Enum类,当定义一个枚举类型时,每一个枚举类型成员...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 248,905
精华内容 99,562
关键字:

枚举类型做参数