精华内容
下载资源
问答
  • 参数解析
    千次阅读
    2019-01-16 00:38:57

    一、ThreadPoolExecutor的重要参数

    1)corePoolSize:核心线程数

    核心线程会一直存活,及时没有任务需要执行

    当线程数小于核心线程数时,即使有线程空闲,线程池也会优先创建新线程处理

    设置allowCoreThreadTimeout=true(默认false)时,核心线程会超时关闭

    2)queueCapacity:任务队列容量(阻塞队列)

    当核心线程数达到最大时,新任务会放在队列中排队等待执行

    3)maxPoolSize:最大线程数

    当线程数>=corePoolSize,且任务队列已满时。线程池会创建新线程来处理任务

    当线程数=maxPoolSize,且任务队列已满时,线程池会拒绝处理任务而抛出异常

    4)keepAliveTime:线程空闲时间

    当线程空闲时间达到keepAliveTime时,线程会退出,直到线程数量=corePoolSize

    如果allowCoreThreadTimeout=true,则会直到线程数量=0

    5)allowCoreThreadTimeout:允许核心线程超时

    6)rejectedExecutionHandler:任务拒绝处理器

    两种情况会拒绝处理任务:

    当线程数已经达到maxPoolSize,切队列已满,会拒绝新任务

    当线程池被调用shutdown()后,会等待线程池里的任务执行完毕,再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务,会拒绝新任务

    线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy,会抛出异常

    ThreadPoolExecutor类有几个内部实现类来处理这类情况:

    AbortPolicy 丢弃任务,抛运行时异常

    CallerRunsPolicy 执行任务

    DiscardPolicy 忽视,什么都不会发生

    DiscardOldestPolicy 从队列中踢出最先进入队列(最后一个执行)的任务

    实现RejectedExecutionHandler接口,可自定义处理器

    二、ThreadPoolExecutor执行顺序:

         线程池按以下行为执行任务:

    1. 当线程数小于核心线程数时,创建线程。
    2. 当线程数大于等于核心线程数,且任务队列未满时,将任务放入任务队列。
    3. 当线程数大于等于核心线程数,且任务队列已满,若线程数小于最大线程数,创建线程;若线程数等于最大线程数,抛出异常,拒绝任务

    三、如何设置参数

    1)默认值

    corePoolSize=1

    queueCapacity=Integer.MAX_VALUE

    maxPoolSize=Integer.MAX_VALUE

    keepAliveTime=60s

    allowCoreThreadTimeout=false

    rejectedExecutionHandler=AbortPolicy()

    2)如何来设置

    需要根据几个值来决定:

    tasks :每秒的任务数,假设为500~1000

    taskcost:每个任务花费时间,假设为0.1s

    responsetime:系统允许容忍的最大响应时间,假设为1s

    做几个计算:

    corePoolSize = 每秒需要多少个线程处理? 

    threadcount = tasks/(1/taskcost) =tasks*taskcout =  (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50

    根据8020原则,如果80%的每秒任务数小于800,那么corePoolSize设置为80即可

    queueCapacity = (coreSizePool/taskcost)*responsetime

    计算可得 queueCapacity = 80/0.1*1 = 80。意思是队列里的线程可以等待1s,超过了的需要新开线程来执行

    切记不能设置为Integer.MAX_VALUE,这样队列会很大,线程数只会保持在corePoolSize大小,当任务陡增时,不能新开线程来执行,响应时间会随之陡增。

    maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)

    计算可得 maxPoolSize = (1000-80)/10 = 92

    (最大任务数-队列容量)/每个线程每秒处理能力 = 最大线程数

    rejectedExecutionHandler:根据具体情况来决定,任务不重要可丢弃,任务重要则要利用一些缓冲机制来处理

    keepAliveTime和allowCoreThreadTimeout采用默认通常能满足

           以上都是理想值,实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了,则需要通过升级硬件和优化代码,降低taskcost来处理。

    更多相关内容
  • 精灵4RTK相机检校参数解析
  • 精灵4RTK相机检校参数解析
  • 解析厂家DUMP文件, 可以解析华为 爱立信 诺基亚 中兴厂家数据为EXCEL表格,数据解析时间较长,请耐心等待
  • 主要介绍了Spring boot中自定义Json参数解析器的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • argparse命令行参数与参数解析

    千次阅读 2022-04-20 22:10:49
    二、argparse命令行与参数解析工具 2.1 argparse使用步骤 2.2 argparse.ArgumentParser的常用参数解释 2.3 argparse.ArgumentParser.add_argument常用参数解释三、两种解析方式的区别 3.1 parse_args()解析方式...


    备注:t.py为所运行代码的文件名
       终端中的路径与t.py文件所在路径保持一致

        dest属性名称不要出现符号’-‘,例如:dest:‘best-model’,可用符号’_'也即,‘best_model’

    一、命令行与参数解析工具的作用?

      (1) 在Linux操作系统中,总离不开用命令行执行相关代码,因此使用命令行与参数解析工具封装相关参数是十分有必要的。
      (2) 可以十分便捷的生成帮助文档,以通俗的解释相关参数类型和运行方式。
      (3) 方便管理深度学习的相关参数,且较多与深度学习有关的源码均采用命令行与参数解析工具管理深度学习参数。
      (4) 较多与深度学习相关的开源代码,选择使用argparse来封装模型的超参数。

    二、argparse命令行与参数解析工具

     2.1 argparse使用步骤

      (1) 创建解析器对象
      (2) 添加参数
      (3) 解析参数
      具体示例如下所示:

    ## 示例一
    import argparse
    # 创建解析器对象
    parser = argparse.ArgumentParser(description='test argparse')
    # 向创建的解析器对象中添加参数
    parser.add_argument('-b', '--batch_size', dest='batch_size', type=int, default=16, help='the batch_size in training')
    parser.add_argument('-l', '--learning_rate', dest='lr', type=float, default=0.001, help='the learning rate in training')
    # 参数解析
    args = parser.parse_args()
    # 调用参数
    print(args.batch_size)
    print(args.lr)
    # 备注:dest表示参数的属性名称==>args.dest(batch_size)调用相应值
    #       default表示默认值
    #       dest属性名称不要出现符号'-',例如:dest:'best-model'
    # 运行步骤:
       # (1) 将上面的代码保存为t.py
       # (2) 在终端中打开输入指令:python t.py --batch_size 32 --learning_rate 0.0001
       #     或 python t.py -b 32 -l 0.0001
       # 备注:--batch_size为长参数, -b 为短参数
    
    
    ## 示例二
    import argparse
    # 创建解析器
    parser = argparse.ArgumentParser(description='Process some integers.')
    # 添加参数
    parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for the accumulator')
    parser.add_argument('--sum', dest='accumulate', action='store_const', const=sum, default=max, help='sum the integers')
    # 解析参数
    args = parser.parse_args()
    print(args.accumulate(args.integers))
    # 备注:nargs表示输入命令行参数的个数,'+'表示任意多个
    #       default表示默认值
    # 运行步骤:
       # (1) 将上面的代码保存为tt.py
       # (2) 在终端中打开输入指令:python t.py --sum 2 1
    

    先从命令行中选择参数,若无再从const中选择参数,若还没有则从选择默认参数

     2.2 argparse.ArgumentParser的常用参数解释

       (1) prog–程序的名称(默认-sys.argv[0], 即保存py文件的名称)==>无特殊情况不做修改

    import argparse
    # 创建解析器
    parser = argparse.ArgumentParser(prog='test.py', description='Process some integers.')
    # 添加参数
    parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for the accumulator')
    parser.add_argument('--sum', dest='accumulate', action='store_const', const=sum, default=max, help='sum the integers')
    # 解析参数
    args = parser.parse_args()
    print(args.accumulate(args.integers))
    # 在终端输入:python t.py -h,得到结果如下所示:
    # 更改前:usage: t.py [-h] [--sum] N [N ...]  
    # 更改后:usage: test.py [-h] [--sum] N [N ...]
    # 注意:t.py为py文件的文件名称
    

       (2) usage-描述程序用途的字符串,默认由添加到解析器的参数生成-使用默认值即可。
       (3) description-参数帮助之前显示的文档
       (4) epilog-参数帮助文档之后显示的文本

    import argparse
    # 创建解析器
    parser = argparse.ArgumentParser(prog='test.py', description='Process some integers.',  epilog='input Y(Yes)/N(No)?')
    # 添加参数
    parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for the accumulator')
    parser.add_argument('--sum', dest='accumulate', action='store_const', const=sum, default=max, help='sum the integers')
    # 解析参数
    args = parser.parse_args()
    print(args.accumulate(args.integers))
    # 在终端输入:python t.py -h,得到结果如下所示:
    # usage: test.py [-h] [--sum] N [N ...]
    # Process some integers.
    # positional arguments:
    #  N           an integer for the accumulator
    # optional arguments:
    #   -h, --help  show this help message and exit
    #   --sum       sum the integers
    # input Y(Yes)/N(No)?
    

       (5) parents - 一个 ArgumentParser 对象的列表,它们的参数也应包含在内

      (6) add_help - 为解析器添加一个 -h/–help 选项-默认值: True

    parents - 一个 ArgumentParser 对象的列表,它们的参数也应包含在内
    formatter_class - 用于自定义帮助文档输出格式的类
    prefix_chars - 可选参数的前缀字符集合(默认值:’-’)
    fromfile_prefix_chars - 当需要从文件中读取其他参数时,用于标识文件名的前缀字符集合> 默认值:None)
    argument_default - 参数的全局默认值(默认值: None)
    conflict_handler - 解决冲突选项的策略(通常是不必要的)
    add_help - 为解析器添加一个 -h/–help 选项(默认值: True)
    allow_abbrev - 如果缩写是无歧义的,则允许缩写长选项 (默认值:True)

     2.3 argparse.ArgumentParser.add_argument常用参数解释

      注意:(1) 每个参数都需要独立添加,若要添加两个参数则需要使用两个add_argument()
         (2) 所添加的参数分为两种:
           1) 位置参数 -positional arguments:按照参数设置的先后顺序读取读取命令行参数,不需要设置参数名,且传入的参数均为字符型。

    import argparse
    # 创建解析器
    parser = argparse.ArgumentParser(description='Process some integers.')
    # 添加参数
    parser.add_argument('integers', metavar='N', type=int, nargs='+',help='some integer')
    parser.add_argument('str', metavar='str', type=str, nargs='+',help='some str')
    # 解析参数
    args = parser.parse_args()
    # metavar='N'
    # nargs:表示输入命令行参数的个数,其中'+'表示任意个参数。
    # 在终端中输入:python t.py,可得到如下结果:
    # usage: test.py [-h] N [N ...] str [str ...]
    # positional arguments:
    #   N           some integer
    #   str         some str
    
    # optional arguments:
    #   -h, --help  show this help message and exit
    

           2) 可选参数 - 位置不固定按照参数名读取数据,具体如下所示:
             (a) -b/–batch_size, 长短参数
             (b) action指定参数:‘store_true’/‘store_false’ : 存储bool值True或False; ‘store_const’ :存储const指定的常数值。

    ## 示例一-存储命令行输入参数
    import argparse
    # 创建解析器
    parser = argparse.ArgumentParser(description='Process some integers.')
    # 添加参数
    parser.add_argument('-b', '--batch_size', dest='batch_size', type=int, default=16, help='the batch_size in training')
    parser.add_argument('-l', '--learning_rate', dest='lr', type=float, default=0.001, help='the learning rate in training')
    # 解析参数
    args = parser.parse_args()
    
    ## 示例二-指定参数(需要用到add_argument里的action属性)
    import argparse
    # 创建解析器
    parser = argparse.ArgumentParser(description='test the action attribute of add_argument')
    # 添加参数
    parser.add_argument('-b', '--bool_value', dest='bool_value', action='store_true', help='True')
    parser.add_argument('-l', '--learning_rate', dest='lr', type=float, default=0.001, help='the learning rate in training')
    # 解析参数
    args = parser.parse_args()
    if args.bool_value:
    	print('学习率%f'%args.lr)
    else:
    	print('--bool_value has not been given!')
    # 结果展示:
    #	(1)终端输入:python t.py -l 0.001 -b
    #          结果:学习率:0.001
    #          备注:输入 -b 后解析解析时会调用action里面指定的参数:store_true/store_false
    
    #	(2)终端输入:python t.py -l 0.001
    #          结果:--bool_value has not been given!
    
    ## 示例三-指定参数(需要用到add_argument里的action属性)
    import argparse
    # 创建解析器
    parser = argparse.ArgumentParser(description='Process some integers.')
    # 添加参数
    parser.add_argument('integers', metavar='N', type=int, nargs='+',help='an integer for the accumulator')
    parser.add_argument('--sum', dest='accumulate', action='store_const', const=sum, default=max, help='sum the integers')
    # 解析参数
    args = parser.parse_args()
    print(args.accumulate(args.integers))
    # 备注:nargs表示输入命令行参数的个数,'+'表示任意多个
    
    # 结果展示:
    #	(1)终端输入:python t.py --sum 3 2 1 4
    #          结果:10
    #          备注:输入参数名 -sum 后,解析解析时会调用const指定的参数:sum
    
    #	(2)终端输入:python t.py 3 2 1 4
    #          结果:4
    #          备注:在命令行没有输入-sum,则会调用默认参数
    

       (3) name/flags - 命令行参数的名称,如batch_size或 -b, --batch_size。
       (4) action - 当参数在命令行中出现时使用的动作基本类型:1) ‘store_true’/‘store_false’; 2) ‘store_const’。
       (5) nargs - 命令行参数的数量:1) args=‘*’ 表示参数可设置零个或多个;2) nargs=’ ‘+’ 表示参数可设置一个或多个;3) nargs='?'表示参数可设置零个或一个。
       (6) choices - 可用的参数的容器。

    import argparse
    # 创建解析器对象
    parser = argparse.ArgumentParser(description='test argparse')
    # 向创建的解析器对象中添加参数
    parser.add_argument('-b', '--batch_size', dest='batch_size', type=int, default=16, metavar='16', choices=[4, 16, 32], help='the batch_size in training')
    parser.add_argument('-l', '--learning_rate', dest='lr', type=float, default=0.001, metavar='0.01', help='the learning rate in training')
    # 参数解析
    args = parser.parse_known_args()
    
    # 在终端中输入:python t.py -b 5
    # 结果:
    # usage: t.py [-h] [-b 16] [-l 0.01]
    # t.py: error: argument -b/--batch_size: invalid choice: 5 (choose from 4, 16, 32)
    # 备注:因为5不在choices范围内,因此会报错。
    

       (7) metavar - 在help消息中显示使用的参数值示例。

    import argparse
    # 创建解析器对象
    parser = argparse.ArgumentParser(description='test argparse')
    # 向创建的解析器对象中添加参数
    parser.add_argument('-b', '--batch_size', dest='batch_size', type=int, default=16, metavar='16', choices=[4, 16, 32], help='the batch_size in training')
    parser.add_argument('-l', '--learning_rate', dest='lr', type=float, default=0.001, metavar='0.01', help='the learning rate in training')
    # 参数解析
    args = parser.parse_known_args()
    
    # 在终端中输入:python t.py -h
    # 结果:
    # usage: t.py [-h] [-b 16] [-l 0.01]
    # test argparse
    # optional arguments:
    #   -h, --help            show this help message and exit
    #   -b 16, --batch_size 16
    #                         the batch_size in training
    #   -l 0.01, --learning_rate 0.01
    #                         the learning rate in training
    

       (8) dest - 被添加到 parse_args() 所返回对象上的属性名。
       (9) default - 当参数未在命令行中出现时使用的值。
       (10) type - 命令行参数应当被转换成的类型。
       (11) required - 此命令行选项是否可省略 _仅选项可用。
       (12) help - 一个此选项作用的简单描述。

    三、两种解析方式的区别

     3.1 parse_args()解析方式

    import argparse
    # 创建解析器对象
    parser = argparse.ArgumentParser(description='test argparse')
    # 向创建的解析器对象中添加参数
    parser.add_argument('-b', '--batch_size', dest='batch_size', type=int, default=16, metavar='16',help='the batch_size in training')
    parser.add_argument('-l', '--learning_rate', dest='lr', type=float, default=0.001, help='the learning rate in training')
    # 参数解析
    args = parser.parse_args()
    print(args)
    # 终端输入命令:python t.py -b 32 -l 0.001
    #        结果:Namespace(batch_size=32, lr=0.001)
    
    # 输入的命令行参数不在已添加的参数范围内则会报错,如下所示:
    # 终端输入命令:python t.py -b 32 -l 0.001 -n 512
    #         结果: usage: t.py [-h] [--batch_size 16] [--learning_rate LR]
    #              t.py: error: unrecognized arguments: -n 512
    

      针对上述报错问题,可采用parse_known_args()解析方式。

     3.1 parse_known_args()解析方式

       使用parse_known_args()解析方式会返回一个元组分别用于存放已添加元素和未添加元素,如下所示:

    import argparse
    # 创建解析器对象
    parser = argparse.ArgumentParser(description='test argparse')
    # 向创建的解析器对象中添加参数
    parser.add_argument('-b', '--batch_size', dest='batch_size', type=int, default=16, metavar='16',help='the batch_size in training')
    parser.add_argument('-l', '--learning_rate', dest='lr', type=float, default=0.001, help='the learning rate in training')
    # 参数解析
    args = parser.parse_known_args()
    print(args)
    # print(args[0])
    # print(args[1])
    # 终端输入命令:python t.py -b 32 -l 0.001
    #        结果:(Namespace(batch_size=32, lr=0.001), [])
    
    # 输入的命令行参数不在已添加的参数范围内不会报错,如下所示:
    # 终端输入命令:python t.py -b 32 -l 0.001 -n 512
    #         结果: (Namespace(batch_size=16, lr=0.001), ['-n', '512'])
    #         备注:未添加元素以空格作为分隔符,且以字符串的形式被添加至列表中
    

    四、参考链接

      1、ArgumentParser相关属性介绍
      2、add_argument
      3、metavar参数的作用
      4、两种参数解析方式的比较
      5、python 命令行参数 argparse用法总结
      6、python argparese命令行参数

    展开全文
  • 这是一个用于解析传递给Java代码的命令行参数的库。
  • 主要介绍了AngularJS页面带参跳转及参数解析操作,结合具体实例形式分析了AngularJS使用URL传递参数及参数的接收、解析等相关操作技巧,需要的朋友可以参考下
  • Spring参数解析

    千次阅读 2021-09-17 21:49:53
    参数解析器 HandlerMethodArgumentResolver和AbstractNamedValueMethodArgumentResolver是解析策略的上层定义和抽象。 关于这两个类可以参考https://securitit.blog.csdn.net/article/details/110110872的解析。 ...


    请求映射处理适配器:RequestMappingHandlerAdapter

    在这里插入图片描述

    参数解析器:HandlerMethodArgumentResolver

    HandlerMethodArgumentResolver和AbstractNamedValueMethodArgumentResolver是解析策略的上层定义和抽象。

    关于这两个类可以参考https://securitit.blog.csdn.net/article/details/110110872的解析。

    HandlerMethodArgumentResolver是个接口,只有俩个方法

    public interface HandlerMethodArgumentResolver {
        boolean supportsParameter(MethodParameter var1);
    
        @Nullable
        Object resolveArgument(MethodParameter var1, @Nullable ModelAndViewContainer var2, NativeWebRequest var3, @Nullable WebDataBinderFactory var4) throws Exception;
    }
    
    • supportsParameter:用于判定是否需要处理该参数分解,返回true为需要,并会去调用下面的方法resolveArgument。
    • resolveArgument:真正用于处理参数分解的方法,返回的Object就是controller方法上的形参对象。

    获取默认参数解析器
    RequestMappingHandlerAdapter.getDefaultArgumentResolvers()

    	private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
    		List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();
    
    		// 基于注解的参数解析
    		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
    		resolvers.add(new RequestParamMapMethodArgumentResolver());
    		resolvers.add(new PathVariableMethodArgumentResolver());
    		resolvers.add(new PathVariableMapMethodArgumentResolver());
    		resolvers.add(new MatrixVariableMethodArgumentResolver());
    		resolvers.add(new MatrixVariableMapMethodArgumentResolver());
    		resolvers.add(new ServletModelAttributeMethodProcessor(false));
    		resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
    		resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
    		resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
    		resolvers.add(new RequestHeaderMapMethodArgumentResolver());
    		resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
    		resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
    		resolvers.add(new SessionAttributeMethodArgumentResolver());
    		resolvers.add(new RequestAttributeMethodArgumentResolver());
    
    		// 基于类型的参数解析
    		resolvers.add(new ServletRequestMethodArgumentResolver());
    		resolvers.add(new ServletResponseMethodArgumentResolver());
    		resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
    		resolvers.add(new RedirectAttributesMethodArgumentResolver());
    		resolvers.add(new ModelMethodProcessor());
    		resolvers.add(new MapMethodProcessor());
    		resolvers.add(new ErrorsMethodArgumentResolver());
    		resolvers.add(new SessionStatusMethodArgumentResolver());
    		resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
    
    		// 自定义参数解析
    		if (getCustomArgumentResolvers() != null) {
    			resolvers.addAll(getCustomArgumentResolvers());
    		}
    
    		// Catch-all
    		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
    		resolvers.add(new ServletModelAttributeMethodProcessor(true));
    
    		return resolvers;
    	}
    

    参数处理相关注解

    参数绑定常用注解:

    1. 处理request uri 部分(这里指uri template中variable,不含queryString部分)的注解: @PathVariable;

    2. 处理request header部分的注解: @RequestHeader, @CookieValue;

    3. 处理request body部分的注解:@RequestParam, @RequestBody;

    4. 处理attribute类型的注解: @SessionAttributes, @ModelAttribute;

    1.@PathVariable

    当使用@RequestMapping URI template 样式映射时, 即 someUrl/{paramId}, 这时的paramId可通过 @Pathvariable注解绑定它传过来的值到方法的参数上。

    @Controller  
    @RequestMapping(“/owners/{ownerId}”)  
    public class RelativePathUriTemplateController {  
    
      @RequestMapping(“/pets/{petId}”)  
      public void findPet(@PathVariable String ownerId, @PathVariable String petId, Model model) {      
      }  
    }  
    

    若方法参数名称和需要绑定的uri template中变量名称不一致,需要在@PathVariable(“name”)指定uri template中的名称。

    使用的参数解析器:

    1. PathVariableMapMethodArgumentResolver
      在某些条件成立的情况下才会使用此类进行解析:

      • 方法参数由@PathVariable注解注释。
      • 方法参数类型必须是Map类型。
      • 注释方法参数的@PathVariable的value属性不能有值。
    2. PathVariableMethodArgumentResolver
      在某些条件成立的情况下才会使用此类进行解析:

      • 方法参数由@PathVariable注解注释。
      • 当方法参数类型是Map时,要求其必须由@PathVariable注解注释,同时@PathVariable的value属性必须有值。

    2.@RequestHeader

    @RequestHeader 注解,可以把Request请求header部分的值绑定到方法的参数上。

    Host                    localhost:8080  
    Accept                  text/html,application/xhtml+xml,application/xml;q=0.9  
    Accept-Language         fr,en-gb;q=0.7,en;q=0.3  
    Accept-Encoding         gzip,deflate  
    Accept-Charset          ISO-8859-1,utf-8;q=0.7,*;q=0.7  
    Keep-Alive              300
    
    @RequestMapping(“/displayHeaderInfo.do”)  
    public void displayHeaderInfo(@RequestHeader(“Accept-Encoding”) String encoding,  
                                  @RequestHeader(“Keep-Alive”) long keepAlive)  {
                                  
    }  
    

    request header部分的 Accept-Encoding的值,绑定到参数encoding上了, Keep-Alive header的值绑定到参数keepAlive上。

    使用的参数解析器:

    1. RequestHeaderMapMethodArgumentResolver
      在某些条件成立的情况下才会使用此类进行解析:

      • 方法参数由@RequestHeader注解注释。
      • 方法参数类型必须是Map类型。
    2. RequestHeaderMethodArgumentResolver
      在某些条件成立的情况下才会使用此类进行解析:

      • 方法参数由@RequestHeader注解注释。
      • 方法参数类型不能为Map类型。

    @RequestHeader是用来处理Web请求头中的信息,随着网站的多样和多元化,@RequestHeader使用频率会越来越广泛。

    3.@CookieValue

    @CookieValue 可以把Request header中关于cookie的值绑定到方法的参数上。

    例如有如下Cookie值:

    JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84 
    
    @RequestMapping(“/displayHeaderInfo.do”)  
    public void displayHeaderInfo(@CookieValue(“JSESSIONID”) String cookie)  {  
    
    }  
    

    即把JSESSIONID的值绑定到参数cookie上。

    使用的参数解析器:

    1. ServletCookieValueMethodArgumentResolver
      ServletCookieValueMethodArgumentResolver实现了最主要的resolveName(…)方法,用于进行参数解析。
      • Cookie使用WebUtils.getCookie(…)从NativeWebRequest中解析。
      • 若方法参数是Cookie类型,那么直接返回Cookie类型。
      • 若方法参数非Cookie类型,那么urlPathHelper.decodeRequestString(…)解析得到String类型的值。

    @CookieValue注解在实际应用中,作用还是很大的,传统Web开发中,Cookie是不可绕过的一环,掌握如何快速的通过Spring框架取值,可以帮助我们更快更好的完成任务。

    4.@RequestParam

    • 常用来处理简单类型的绑定,通过Request.getParameter() 获取的String可直接转换为简单类型的情况( String–> 简单类型的转换操作由ConversionService配置的转换器来完成);因为使用request.getParameter()方式获取参数,所以可以处理get 方式中queryString的值,也可以处理post方式中 body data的值;

    • 用来处理Content-Type: 为 application/x-www-form-urlencoded编码的内容,提交方式GET、POST;

    • 该注解有两个属性: value、required; value用来指定要传入值的id名称,required用来指示参数是否必须绑定;

    使用的参数解析器:

    1. RequestParamMapMethodArgumentResolver

    2. RequestParamMethodArgumentResolve

    1)RequestParamMapMethodArgumentResolver

    实现了HandlerMethodArgumentResolver的supportsParameter(…)和resolveArgument(…)方法。
    使用条件:

    1. 方法参数由@RequestParam注解注释
    2. 方法参数类型必须是Map类型
      • 参数类型为MultiValueMap时,返回LinkedMultiValueMap实例,包含所有请求参数
      • 参数类型为Map时,返回LinkedHashMap实例,包含所有请求参数
    3. @RequestParam注解的name不能有值

    2)RequestParamMethodArgumentResolver

    RequestParamMethodArgumentResolver继承自抽象AbstractNamedValueMethodArgumentResolver

    除了能处理@RequestParam注解外,还可以处理@RequestPart注解。

    处理@RequestParam注解的条件:

    1. 方法参数由@RequestParam注解注释。
    2. 方法参数若是Map类型时,@RequestParam的name属性不能为空。
    3. 方法参数若不是Map类型时,都可以处理。

    处理@RequestPart注解的条件

    1. 方法参数不可由@RequestPart注解注释。
    2. 方法参数类型为org.springframework.web.multipart.MultipartFile、org.springframework.web.multipart.MultipartFile集合、org.springframework.web.multipart.MultipartFile数组、javax.servlet.http.Part、javax.servlet.http.Part集合或javax.servlet.http.Part数组。
    3. 一个简单类型的方法参数,包括:boolean、byte、char、short、int、long、float、double、Enum.class、CharSequence.class、Number.class、Date.class、URI.class、URL.class、Locale.class或Class.class。

    @RequestParam是用来处理Web请求头中的信息,随着网站的多样和多元化,@RequestParam使用频率会越来越广泛。

    5.@RequestPart

    @RequestPart用于将multipart/form-data类型数据映射到控制器处理方法的参数中。除了@RequestPart注解外,@RequestParam同样可以用于此类操作。

    @Controller
    @RequestMapping("/test")
    public class RequestPartController {
        /**
         * 跳转页面.
         */
        @GetMapping("test1")
        public ModelAndView requestPartHtml(HttpServletRequest req, HttpServletResponse res, ModelMap modelMap)
                throws Exception {
                
        }
        
        /**
         * RequestPart-MultipartFile接收参数.
         */
        @ResponseBody
        @PostMapping("test2")
        public String requestPartMultipartFile(@RequestPart("file") MultipartFile multipartFile) throws Exception {
    
        }
    
        /**
         * RequestPart-Part接收参数.
         */
        @ResponseBody
        @PostMapping("test3")
        public String requestPartPart(@RequestPart("file") Part part) throws Exception {
           
        }
        
        /**
         * RequestParam-MultipartFile接收参数.
         */
        @ResponseBody
        @PostMapping("test4")
        public String requestParamMultipartFile(@RequestParam("file") MultipartFile multipartFile) throws Exception {
    
        }
    
        /**
         * RequestParam-Part接收参数.
         */
        @ResponseBody
        @PostMapping("test5")
        public String requestParamPart(@RequestParam("file") Part part) throws Exception {
    
        }
    
        /**
         * Part接收参数.
         */
        @ResponseBody
        @PostMapping("test6")
        public String part(HttpServletRequest req) throws Exception {
            Part part = req.getPart("file");
    
        }
    
    }
    

    使用的参数解析器:

    1. RequestPartMethodArgumentResolver

    2. RequestHeaderMapMethodArgumentResolver
      在某些条件成立的情况下才会使用此类进行解析:

      • 方法参数由@RequestPart注解注释。
      • 方法参数不可由@RequestParam注解注释。
      • 方法参数类型为org.springframework.web.multipart.MultipartFile、org.springframework.web.multipart.MultipartFile集合、org.springframework.web.multipart.MultipartFile数组、javax.servlet.http.Part、javax.servlet.http.Part集合或javax.servlet.http.Part数组。
    3. RequestParamMethodArgumentResolver
      参考@RequestParam中的RequestParamMethodArgumentResolver用法

    @RequestPart和@RequestParam都可以处理multipart/form-data类型数据,本质上并没有区别,使用任何一个都能达到期望的效果。文件上传在实际应用中也是必不可少的。

    6.@RequestBody

    • 该注解常用来处理Content-Type: 不是application/x-www-form-urlencoded编码的内容,例如application/json, application/xml等;

    • 它是通过使用HandlerAdapter 配置的HttpMessageConverters来解析post data body,然后绑定到相应的bean上的。

    • 因为配置有FormHttpMessageConverter,所以也可以用来处理 application/x-www-form-urlencoded的内容,处理完的结果放在一个MultiValueMap<String, String>里,这种情况在某些特殊需求下使用

    Spring MVC中使用HandlerMethodArgumentResolver策略接口来定义处理器方法参数解析器,

    使用的参数解析器:

    1. RequestResponseBodyMethodProcessor

      RequestResponseBodyMethodProcessor实现相对比较负责,其功能涉及范围较广,参数绑定仅是其功能之一。RequestResponseBodyMethodProcessor实现了HandlerMethodArgumentResolver的supportsParameter(…)和resolveArgument(…)方法。

      使用此类进行解析的条件:

      1. 方法参数由@RequestBody注解注释。

      具体使用流程:
      通过resolveArgument(…)方法中readWithMessageConverters(…)用来进行请求正文的读取,方法具体内容:

      • 获取请求的Content-Type,用于后续消息转换。
      • 获取参数类型,用于参数实例化及初始化。
      • 遍历消息转换器,通过参数类型匹配可用的消息转换。
      • 调用参数转换器进行请求正文的转换。
      • 处理请求增强器:RequestBodyAdvice方法beforeBodyRead(…)、afterBodyRead(…)和handleEmptyBody(…)。

    7.@SessionAttributes

    该注解用来绑定HttpSession中的attribute对象的值,便于在方法中的参数里使用。

    该注解有value、types两个属性,可以通过名字和类型指定要使用的attribute 对象;

    @Controller  
    @RequestMapping(“/editPet.do”)  
    @SessionAttributes(“pet”)  
    public class EditPetForm {  
    
    }  
    

    使用的参数解析器:

    1. SessionAttributeMethodArgumentResolver

    8.@ModelAttribute

    该注解有两个用法,一个是用于方法上,一个是用于参数上;

    • 用于方法上时: 通常用来在处理@RequestMapping之前,为请求绑定需要从后台查询的model;

    • 用于参数上时: 用来通过名称对应,把相应名称的值绑定到注解的参数bean上;要绑定的值来源于:

      • @SessionAttributes 启用的attribute 对象上;
      • @ModelAttribute 用于方法上时指定的model对象;
      • 上述两种情况都没有时,new一个需要绑定的bean对象,然后把request中按名称对应的方式把值绑定到bean中。

    用到方法上:

    @ModelAttribute  
    
    public Account addAccount(@RequestParam String number) {  
    
        return accountManager.findAccount(number);  
    
    } 
    

    这种方式实际的效果就是在调用@RequestMapping的方法之前,为request对象的model里put(“account”, Account)。

    用在参数上:

    @RequestMapping(value=“/owners/{ownerId}/pets/{petId}/edit”, method = RequestMethod.POST)  
    public String processSubmit(@ModelAttribute Pet pet) {  
    
    } 
    

    首先查询 @SessionAttributes有无绑定的Pet对象,若没有则查询@ModelAttribute方法层面上是否绑定了Pet对象,若没有则将URI template中的值按对应的名称绑定到Pet对象的各属性上。

    其它注解

    @AliasFor

    参考文章:
    Spring 全面解析——Spring 注解面面通

    展开全文
  • Python命令行参数解析

    千次阅读 2022-04-20 19:18:28
    Python命令行传参数,sys.argv optparse模块

    Python命令行参数解析

    Python命令行解析是指读取终端传入的参数

    sys.argv属性

    这个是sys库立面的一个属性,其用于接收传入程序的命令行参数。它是一个列表。也就是差不多下面这种类型

    sqlmap.py -u http://www.baidu.com
    

    那么sys.argv的值就是如下

    ['sqlmap.py','-u','http://www.baidu.com']
    

    它的第一个参数是文件的路径。多个参数的话需要用空格隔开。一般sys.argv需要配合optparse模块使用。

    可以通过以下代码试试,sys.argv的输出

    import sys
    argsa = sys.argv
    print(argsa)
    

    注意需要在终端里面输入

    optparse模块

    optparse,是一个更够让程序设计人员轻松设计出简单明了、易于使用、符合标准的Unix命令例程式的Python模块。生成使用方法和帮助信息。简单来说它是一个用于处理sys.argv传进来的信息的模块。比如我们经常运行脚本时,会查看帮助信息就用用到--help,那么这个就是由此模块处理的。

    下面通过例子先来初步了解:

    from optparse import OptionParser #optparse里面最主要的类就是OptionParser了
    
    optParser = OptionParser() #创建一个对象
    
    optParser.add_option('-f','--file',action = 'store',type = "string" ,dest = 'filename')
    
    
    optParser.add_option("-v","--vison", action="store_false", dest="verbose",
                         default='hello',help="make lots of noise [default]")
    #上面的就是最主要的操作,差不多是定义参数的信息 -v是参数简写 --vsion是全写 两种名字都是同一个东西
    
    fakeArgs = ['-f','file.txt','-v','how are you', 'arg1', 'arg2']
    #这个fakeArgs是模拟sys.argv
    
    option , args = optParser.parse_args()
    #上面这里没有传入任何参数是为了更好的演示
    
    op , ar = optParser.parse_args(fakeArgs)
    #这里传入了fakeArgs,其操作和上面的是一样的
    #这里的op会返回一个类似字典的自定义类型option中的dest变量,而值则是我们自己传进去的
    
    print("option : ",option)
    print("args : ",args)
    print("op : ",op)
    print("ar : ",ar)
    

    最后程序输出的结果如下

    option :  {'filename': None, 'verbose': 'hello'}
    args :  []
    op :  {'filename': 'file.txt', 'verbose': False}
        #这里的verbose之所以是False于action参数有关
    ar :  ['how are you', 'arg1', 'arg2']
    

    add_option()函数里面参数的具体说明

    add_option()参数说明:
    action:存储方式,分为三种store、store_false、store_true
            type:类型
            dest:存储的变量
            default:默认值
            help:帮助信息
                       
    

    action不同值得说明:

       --store 上表示命令行参数的值保存在options对象中。例如上面一段代码,如果我们对optParser.parse_args()函数传入的参数列表中带有‘-f’,那么就会将列表中‘-f’的下一个元素作为其dest的实参filename的值,他们两个参数形成一个字典中的一个元素{filename:file_txt}。相反当我们的参数列表中没有‘-f’这个元素时,那么filename的值就会为空。
    
      --store_false fakeArgs 中存在'-v'verbose将会返回False,而不是‘how are you’,也就是说verbose的值与'-v'的后一位无关,只与‘-v’存在不存在有关。
    
      --store_ture  这与action="store_false"类似,只有其中有参数'-v'存在,则verbose的值为True,如果'-v'不存在,那么verbose的值为None。
    

    参考于CSDN

    默认的一个option -h

    除了自定义的,在命令行输入-h--help会自动整合所有选项的help及名称显示出来。如果添加一个usage的字符串也能把usage显示出来,例如:

    import sys
    from optparse import OptionParser
    
    if __name__ == '__main__':
        args = sys.argv[1:]
        #读取除文件地址外得参数
        
        usage = "This is test!" #使用方法字符串
        optParser = OptionParser(usage) #创建一个对象 并把usage传进去
       	
        optParser.add_option('-f','--file',type = "string",dest = 'filename',help="请输入文件路径")
        optParser.add_option("-u","--url", dest="url",default='http://www.baidu.com',help="请输入目标网址")
        optParser.add_option("-t","--test", dest="test",action="store_true",help="测试是否存在")
        #添加规则
        
        option , args = optParser.parse_args(args)
        #开始执行规则
        pass
    

    最后结果如图所示

    在这里插入图片描述

    完整的一个命令行传参示例

    import sys
    from optparse import OptionParser
    
    if __name__ == '__main__':
        args = sys.argv[1:]
        #读取除文件地址外得参数
        
        optParser = OptionParser() #创建一个对象
       	
        optParser.add_option('-f','--file',type = "string",dest = 'filename',help="请输入文件路径")
        optParser.add_option("-u","--url", dest="url",default='http://www.baidu.com',help="请输入目标网址")
        optParser.add_option("-t","--test", dest="test",action="store_true",help="测试是否存在",default='False')
        #添加规则
        
        option , args = optParser.parse_args(args)
        #开始执行规则
        
        print("-f传入了参数",option.filename) #注意option不是字典
        print("-u传入了参数",option.url)
        print("-t的状态为",option.test)
        print("args多余的东西有",args)
    
        pass
    

    测试的命令行

     python test.py -f "/flag" -t "hi" abcsdsd
    

    输出结果:

    -f传入了参数 /flag
    -u传入了参数 http://www.baidu.com
    -t的状态为 True
    args多余的东西有 ['hi', 'abcsdsd']
    
    展开全文
  • springmvc自定义属性编辑器和参数解析
  • 主要介绍了Python命令行参数解析模块getopt使用实例,本文讲解了使用语法格式、短选项参数实例、长选项参数实例等内容,需要的朋友可以参考下
  • SpringBoot请求参数解析全过程

    千次阅读 2021-07-17 20:32:09
    而请求参数解析主要是在第5、6步完成的。 前面几个步骤的过程可以参考这里,下面主要介绍请求参数是如何解析获得的。 2、DispatcherServlet整体调度 public class DispatcherServlet extends ...
  • 本文介绍了电压基准芯片的参数解析及应用技巧
  • URL参数解析

    千次阅读 2020-12-21 22:35:59
    URL(Uniform Resource Locator,统一资源定位器) protocol://host:port/path?... host (主机名):存放资源的服务器主机名或IP地址。...例如一个网页中有多个名词解释,可使用fragment直接定位到某一名词解释
  • C++ 命令行参数解析

    万次阅读 2018-11-06 15:32:23
    文章目录说明短参数之 getopt()长参数之 getopt_long()长参数之 getopt_long_only() 说明 ...博客三:使用 Qt 解析命令行参数 博客四:linux c/c++中getopt的使用 短参数之 getopt() 头文件:#i...
  • node.js-参数解析

    2021-02-05 14:42:59
    参数说明 同shell一样进行理解,当我们运行script.js的时候,会进行参数传入 node script.js --name=godme 它将全部的参数都存储在process.argv中,具体参数以空格进行分割。 const params = process.argv; console...
  • wmi_export 参数解析.md

    2020-04-02 21:38:12
    对wmi_export对自身电脑系统基本信息进行抓取,该资源将抓取的参数进行中文解释,以方便用户在查看wmi_export抓取信息进行对照。
  • CmdConfig旨在为Java程序提供轻量级的命令行参数解析,从单字符选项解析开始,并在将来添加更多高级功能。
  • smart参数解析.doc

    2021-09-29 19:06:54
    smart参数解析.doc
  • pytorch dataloader参数解析

    千次阅读 2021-07-08 14:08:52
    1. pin_memory参数解析 由于从 CPU 数据转移至 GPU 时,位于pinned(或叫做page-locked) memory上的 Tensor 会更快,因此DataLoader里设置了这一选项, 如果pin_memory=True, 则在提供数据时, 调用Tensor的.pinmemory()...
  • Qt命令行参数解析

    千次阅读 2020-06-20 12:53:35
    序言:实际工程中有时需要带命令行启动可执行程序(exe),如果使用Qt搭建的UI则可以使用命令行解析 一、命令行 (一)不带参数 单字符的命令通常以“-”开头:-h 多字符命令通常以“--”:--help 通常情况下 -...
  • main函数的参数解析

    千次阅读 2018-07-26 18:12:21
    第一个参数:argc是个整型的变量,表示命令行参数的个数(含第一个参数)。 第二个参数:argv是个字符指针的数组,每个元素是一个字符指针,指向一个字符串。这些字符串就是命令行中的每一个参数(字符串)。 第...
  • 华为LTE分析工具(参数解析工具)试用限制版
  • ffmpeg参数解释

    千次阅读 2022-05-07 15:31:17
    -re:以本地帧频读数据,主要用于模拟捕获设备 -i:指定要转换视频的源文件 -q:质量因子 -f:官网中的解释为,强制输入或输出文件格式。 通常会自动为输入文件检测格式,并从输出文件的文件扩展名中猜测该格式,...
  • 何为参数解析库 sys.argv getopt 内置的参数解析库 docopt 参数解析库 optparse 参数解析库 argparse 参数解析库 click 参数解析库 fire 参数解析库 typer 参数解析库 Commando 参数解析库 FLAGS 参数解析库 写在...
  • postgresql参数解析

    2014-09-28 16:43:26
    postgresql的参数的详细解析fdadsa dd ad s
  • protoc 参数解释

    万次阅读 2017-05-03 11:29:14
    protoc --proto_path=IMPORT_PATH --cpp_out=DST_DIR --java_out=DST_...使用c++语言,会生成针对每个message类型的一个类,对每一个类也提供了相应的处理方法,还提供了序列化到输出流和从输入流中解析的方法。
  • Java项目的命令行参数解析器 maven依赖配置 <dependency> <groupId>com.github.pcj</groupId> <artifactId>google-options</artifactId> <version>1.0.0</version>...
  • 摄像机镜头参数解析.doc

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,623,461
精华内容 1,049,384
关键字:

参数解析

友情链接: Convolutional-Code.rar