精华内容
参与话题
问答
  • Verilog中用parameter来定义常量,即用parameter来定义一个标识符来代表一个常量,称为符号常量,即标识符形式的常量,采用标识符代表一个常量可以提高程序的可读性和可维护性。另一个很有用的用途就是可以利用...

        Verilog中用parameter来定义常量,即用parameter来定义一个标识符来代表一个常量,称为符号常量,即标识符形式的常量,采用标识符代表一个常量可以提高程序的可读性和可维护性。另一个很有用的用途就是可以利用defparam或者在模块实例化的时候进行参数传递(即重写)

    一、parameter声明常量


        parameter定义常量,可以定义在模块内部或外部;常用于定义位宽或时间延迟(易变),此处以加一个常数的电路进行示例,如下:

    定义方式为: parameter 标识符 = (位宽)常数;// 位宽默认为32位,如果指定位宽则以指定值为准

    parameter在模块内部定义常量:

    
    module param_idef(
        input clk,
        input [2:0]din,
        output reg [3:0]sum
        );
    
    parameter ADD = 2'd1;
    always@(posedge clk)
    begin
        sum <= din+ADD;
    end
    endmodule
    

    parameter在模块外部定义常量:

    
    module param_odef
    #(parameter ADD2 = 2'd1)
    (
        input clk,
        input [2:0]din,
        output reg [3:0]sum
        );
    
    always@(posedge clk)
    begin
        sum <= din+ADD2;
    end
    endmodule
    

     测试文件如下:

    `timescale 1ns / 1ps
    //
    // Company: 
    // Engineer: CLL
    // 
    // Create Date: 2020/02/22 12:22:02
    // Design Name: 
    // Module Name: param_tsb
    // Project Name: 
    // Target Devices: 
    // Tool Versions: 
    // Description: 
    // 
    // Dependencies: 
    // 
    // Revision:
    // Revision 0.01 - File Created
    // Additional Comments:
    // 
    //
    
    
    module param_tsb(
    
        );
    //
    reg clk;
    reg [2:0]din;
    wire [3:0]sum1,sum2;
    //
    initial
    begin
        clk = 1'b1;
        forever #10 clk = ~clk;
    end
    //
    initial
    begin
        din = 3'd3;
        #80 din = 3'd1;
        #40 din = 3'd0;
    end
    
    param_idef inst1(
        .clk(clk),
        .din(din),
        .sum(sum1)
    );
    param_odef inst2(
        .clk(clk),
        .din(din),
        .sum(sum2)
    );
    endmodule
    

    输出为:

    简单验证了两种定义方式的正确性;

    二、parameter用于提高程序的可读性和可维护性

    可维护性:

    与软件编程类似,通过改变parameter定义的常量值,实现代码所有用到这一标识符部分的值,便于修改与维护;

    可读性:

    标识符按照常量实际意义取名,增强可读性;

    三、参数传递(重写)

    子模块利用parameter定义常量,被顶层调用时默认为子模块中参数

    模块调用修改参数:

    参数改变时,可在顶层模块调用子模块时进行参数修改;如:
        module Top(...);//这是一个顶层模块
            Decode #(4,0) U_D1(); //使得Width = 4, Polarity = 0;
            Decode #(5) U_D2(); //使得 Width = 5,Polarity 不变,即为1;
        endmodule

        module Decode(A,F);    //这是一个子模块
            parameter Width = 1, Polarity = 1;
            ......
        endmodule

    利用defparam修改参数:

    参数改变时,也可在利用defparam进行参数修改;如:
        module Top(...);//这是一个顶层模块

            defparam    U_D1.Width = 4;
            defparam    U_D1.Polarity = 0;
    //使得U_D1的Width = 4, Polarity = 0;

            defparam    U_D2.Width = 5;//使得U_D2的Width = 5,Polarity 不变,即为1;
            Decode U_D1();
            Decode U_D2();
        endmodule


        module Decode(A,F);    //这是一个子模块
            parameter Width = 1, Polarity = 1;
            ......
        endmodule

    四、仿真验证:

    设计一个位宽可变半加器,默认位宽为4bit,并且位宽可调;

    半加器设计如下:

    `timescale 1ns / 1ps
    //
    // Company: 
    // Engineer: CLL
    // 
    // Create Date: 2020/02/22 14:05:33
    // Design Name: 
    // Module Name: counter
    // Project Name: 
    // Target Devices: 
    // Tool Versions: 
    // Description: 
    // 
    // Dependencies: 
    // 
    // Revision:
    // Revision 0.01 - File Created
    // Additional Comments:
    // 
    //
    
    
    module counter
    #(parameter W = 3)
    (
        input [W:0]din1,
        input [W:0]din2,
        output [W:0]sum,
        output cout
        );
    assign {cout,sum} = din1+din2;
    endmodule
    

    修改参数仿真如下:

    例化1为默认参数,位宽应为4;

    例化2实例化时传递参数,传递位宽为6;(注意参数传递位置,在模块名称counter之后,实例名称istN之前)

    例化3利用defparam传递参数,传递位宽为6;(注意参数赋值与例化时端口赋值一样,可以位置赋值,也可以按照名称赋值;仿真采用名称赋值;也可部分参数赋值,未赋值参数保持默认)

    `timescale 1ns / 1ps
    //
    // Company: 
    // Engineer: CLL
    // 
    // Create Date: 2020/02/22 14:10:50
    // Design Name: 
    // Module Name: count_inst
    // Project Name: 
    // Target Devices: 
    // Tool Versions: 
    // Description: 
    // 
    // Dependencies: 
    // 
    // Revision:
    // Revision 0.01 - File Created
    // Additional Comments:
    // 
    //
    
    
    module count_inst(
        input [3:0]din1,
        input [3:0]din1_2,
        input [5:0]din2,
        input [5:0]din2_2,
        input [5:0]din3,
        input [5:0]din3_2,
        output [3:0]sum1,
        output cout1,
        output [5:0]sum2,
        output cout2,
        output [5:0]sum3,
        output cout3
        );
    // adder1 4bit,默认
        counter inst1(
            .din1(din1),
            .din2(din1_2),
            .sum(sum1),
            .cout(cout1)
        );
    // adder2 6bit,例化传递
        counter  #(.W(5)) inst2(
            .din1(din2),
            .din2(din2_2),
            .sum(sum2),
            .cout(cout2)
        );
    // adder3 6bit,defparam传递
    defparam inst3.W = 5;
        counter inst3(
            .din1(din3),
            .din2(din3_2),
            .sum(sum3),
            .cout(cout3)
        );
    
    endmodule
    

    对应RTL电路如下:

    通过例化结果的位宽,证明验证通过;

    五、参考文献:

    Verilog 参数Parameter篇

    Verilog中的parameter

    Verilog基础知识0(`define、parameter、localparam三者的区别及举例)

    【Verilog HDL】参数(Parameter)的作用案例

     

    展开全文
  • Verilog中的parameter

    万次阅读 多人点赞 2018-07-16 16:29:20
    1. 概述 在Verilog中我们常常会遇到要将一个常量(算法中的某个参数)赋给很多个变量的情况,如: x = 10; y = 10; z = 10; ...如果此时10要改为9,就需要在代码中修改3个地方,非常...parameter MAX = 10; x = MAX;...

    1. 概述

    在Verilog中我们常常会遇到要将一个常量(算法中的某个参数)赋给很多个变量的情况,如:

    x = 10;
    y = 10;
    z = 10;

    如果此时10要改为9,就需要在代码中修改3个地方,非常的不方便,并且这个10是没有任何意义的,我们不知道它代表什么,所以为了代码的易重用、易读性,我们应使常量参数化,如:

    parameter   MAX = 10;
    x = MAX;
    y = MAX;
    z = MAX;

    这样就只需要修改MAX就可以了,并且MAX是有意义的,增加代码的易读性。

    parameter是常量,不是变量,所以不允许在运行时修改它的值,即不能在组合逻辑或者时序逻辑中对其进行赋值。

    有两种类型的parameters:
    1)module parameters
    2)specify parameters,只能提供定时和延时的值,不可综合。
    

    2. module parameters

    module parameters有parameter和localparam两种,它们所代表的值都可在编译时进行修改(参数传递),parameter可直接修改,localparam只能间接修改。

    2.1 parameter

    parameter在模块中声明后,后续编译时还可以被重新声明的值所覆盖。

    parameter msb = 7;                  // defines msb as a constant value 7
    parameter e = 25, f = 9;            // defines two constant numbers
    parameter r = 5.7;                  // declares r as a real parameter
    parameter byte_size = 8,
              byte_mask = byte_size - 1;
    parameter average_delay = (r + f) / 2;
    parameter signed [3:0] mux_selector = 0;
    parameter real r1 = 3.5e17;
    parameter p1 = 13'h7e;
    parameter [31:0] dec_const = 1'b1;   // value converted to 32 bits
    parameter newconst = 3'h4;           // implied range of [2:0]
    parameter newconst = 4;              // implied range of at least [31:0]

    注:
    1)如果参数在声明时没有指定type和range,则默认为最后赋值给参数的type和range;
    2)如果参数有指定range,但没有type,则它的符号默认为unsigned,并且range和符号都不会被后面的声明所覆盖;
    3)如果参数有指定range,并且指定为有符号type,则它的range和符号都不会被后面的声明所覆盖;

    2.2 localparam

    localparam除了不能直接对其进行修改外,其他属性与parameter一样。可通过在声明时将parameter赋给localparam进行间接修改。状态机一般都使用localparam。

    parameter       X = 3;
    localparam      Y = X*2;

    这样修改X就间接修改了localparam Y的值。

    2.3 编译时parameter的参数传递

    对parameter的修改有两种方式:
    1)defparam声明
    2)模块实例声明
    

    注:如果defparam声明和模块实例声明冲突了,则使用defparam声明的值。

    2.3.1 defparam声明

    defparam使用层次化名称对模块中的参数重新赋值,如下面的代码所示,mod_a是一个实例化的模块,para_a和para_b是mod_a中的参数。

    defparam    mod_a.para_a = 2;
    defparam    mod_a.para_b = 3;
    mod_mod mod_a();

    注:如果有多个defparam声明一个parameter,则该parameter取文本(代码)中最后一个defparam声明的值。

    2.3.2 模块实例声明

    模块实例声明有两种实现方式:
    1)有序列表
    列表的顺序必须严格按照模块中参数声明的顺序,且不可跳过任何一个参数。如下面代码,mod_mod中有三个参数,a = 4,b = 5,c = 6.

    mod_mod #(1, 2, 3)        mod_a();      //三个参数都修改
    mod_mod #(4, 2, 3)        mod_a();      //只修改b和c,但是也要将a的值声明
    mod_mod #(1, 5, 3)        mod_a();      //只修改a和c,但是也要将b的值声明

    2)参数名
    声明时的参数名称需要和模块实例中的参数名称一致,不需要重新声明的参数可以缺省。

    mod_mod #(.a(2), .b(3))   mod_a();      //两个参数都重新声明
    mod_mod #(.b(3))          mod_b();      //只声明参数b

    注:针对一个实例的参数声明只能通过一种方式,不可混合,不同实例可以混合。如

    // 不合法
    mod_mod #(3, .b(4))       mod_a();      //同时使用两种方式,不合法
    // 合法
    mod_mod #(3, 4)           mod_a();      //只使用有序列表的方式
    mod_mod #(.a(3), .b(4))   mod_b();      //只使用参数名方式

    3. `define与parameter的区别

    `define作用于整个工程,而parameter只作用于本模块,一旦`define指令被编译,则在整个编译过程中都有效,所以仿真时使用`define相对于parameter重声明占用更少的内存。

    参考资料:
    1) IEEE Std 1364TM-2005: IEEE Standard for Verilog Hardware Description Language.
    2) Verilog Coding Styles for Improved Simulation Efficiency.
    3) https://blog.csdn.net/Times_poem/article/details/51371940

    展开全文
  • HttpServletRequest类既有getAttribute()方法,也由getParameter()方法,这两个方法有以下区别:    (1)HttpServletRequest类有setAttribute()方法,而没有setParameter()方法    (2)当两个Web组件...
    HttpServletRequest类既有getAttribute()方法,也由getParameter()方法,这两个方法有以下区别:  
       
      (1)HttpServletRequest类有setAttribute()方法,而没有setParameter()方法  
       
      (2)当两个Web组件之间为链接关系时,被链接的组件通过getParameter()方法来获得请求参数,例如假定welcome.jsp和authenticate.jsp之间为链接关系,welcome.jsp中有以下代码:  
       
      <a   href="authenticate.jsp?username=weiqin">authenticate.jsp   </a>  
       
      或者:  
       
      <form   name="form1"   method="post"   action="authenticate.jsp">  
          请输入用户姓名:<input   type="text"   name="username">  
          <input   type="submit"   name="Submit"   value="提交">  
      </form>  
       
      在authenticate.jsp中通过request.getParameter("username")方法来获得请求参数username:  
       
      <%   String   username=request.getParameter("username");   %>  
       
      (3)当两个Web组件之间为转发关系时,转发目标组件通过getAttribute()方法来和转发源组件共享request范围内的数据。假定authenticate.jsp和hello.jsp之间为转发关系。authenticate.jsp希望向hello.jsp传递当前的用户名字,如何传递这一数据呢?先在authenticate.jsp中调用setAttribute()方法:  
       
      <%  
      String   username=request.getParameter("username");  
      request.setAttribute("username",username);  
      %>  
       
      <jsp:forward   page="hello.jsp"   />  
       
      在hello.jsp中通过getAttribute()方法获得用户名字:  
       
      <%   String   username=(String)request.getAttribute("username");   %>  
      Hello:   <%=username   %>  
       
       
      (4)从更深的层次考虑,request.getParameter()方法传递的数据,会从Web客户端传到Web服务器端,代表HTTP请求数据。request.getParameter()方法返回String类型的数据。  
       
      request.setAttribute()和getAttribute()方法传递的数据只会存在于Web容器内部,在具有转发关系的Web组件之间共享。这两个方法能够设置Object类型的共享数据。  
       
      ——getParameter得到的都是String类型的。或者是http://a.jsp?id=123中的123,或者是某个表单提交过去的数据。  
      ——getAttribute则可以是对象。  
      ——getParameter()是获取POST/GET传递的参数值;  
      ——getAttribute()是获取对象容器中的数据值;  
      ——getParameter:用于客户端重定向时,即点击了链接或提交按扭时传值用,即用于在用表单或url重定向传值时接收数据用。  
      ——getAttribute:用于服务器端重定向时,即在sevlet中使用了forward函数,或struts中使用了mapping.findForward。getAttribute只能收到程序用setAttribute传过来的值。  
      另外,可以用setAttribute,getAttribute发送接收对象.而getParameter显然只能传字符串。  
      setAttribute是应用服务器把这个对象放在该页面所对应的一块内存中去,当你的页面服务器重定向到另一个页面时,应用服务器会把这块内存拷贝另一个页面所对应的内存中。这样getAttribute就能取得你所设下的值,当然这种方法可以传对象。session也一样,只是对象在内存中的生命周期不一样而已。  
      getParameter只是应用服务器在分析你送上来的request页面的文本时,取得你设在表单或url重定向时的值。
    展开全文
  • Java反射09 : 参数Parameter学习示例

    千次阅读 2018-03-04 14:52:23
    java.lang.reflect.Parameter类提供了用于获取和操作构造器的静态方法。 1.通过Parameter可以做什么 通过Parameter可以做以下事情: 如何通过Class对象获取其方法或构造器的参数Parameter对象? 如何通过...

    超级通道: Java泛型学习系列-绪论

    java.lang.reflect.Parameter类提供了用于获取和操作构造器的静态方法。

    1.通过Parameter可以做什么

    通过Parameter可以做以下事情:

    • 如何通过Class对象获取其方法或构造器的参数Parameter对象?
    • 如何通过Parameter获取相关信息:参数名、修饰符、参数类型、参数化类型、可变参数、注解

    2.代码实例

    实体类:

    /**
     * <p>用户表</p>
     *
     * @author hanchao 2018/2/14 22:30
     */
    public class User{
        public String username = "张三";
        private int password = 123456;
    
        /**
         * <p>测试:java反射-参数Parameter</p>
         *
         * @author hanchao 2018/3/4 14:24
         **/
        public void initUser(@MyAnnotationA @MyAnnotationB String username, @MyAnnotationB String password) {
        }
    }

    实例类:

    /**
     * Created by 韩超 on 2018/3/1.
     */
    public class ReflectParameterDemo {
        private final static Logger LOGGER = Logger.getLogger(ReflectParameterDemo.class);
    
        /**
         * <p>Title: java反射-参数Parameter</p>
         *
         * @author 韩超 2018/3/1 15:56
         */
        public static void main(String[] args) throws NoSuchMethodException {
            //===================================== 通过Class对象获取Parameter对象 =====================================
            LOGGER.info("===================================== 通过Class对象获取Parameter对象 =====================================");
            //首先获取Class对象
            Class userClass = User.class;
            LOGGER.info("首先获取Class对象:" + userClass);
            //然后获取Method(或者Constructor)对象
            Method method = userClass.getDeclaredMethod("initUser", String.class, String.class);
            LOGGER.info("然后获取Method或者Constructor对象:" + method);
            //然后获取Parameter对象数组
            Parameter[] parameters = method.getParameters();
            LOGGER.info("然后通过getParameters()获取Parameter对象数组");
            //然后获取Parameter对象
            Parameter parameter = parameters[0];
            LOGGER.info("最终获得参数Parameter对象" + parameter + "\n");
    
            //===================================== Parameter信息获取 =====================================
            LOGGER.info("===================================== Parameter信息获取 =====================================");
            LOGGER.info("通过parameter.getModifiers()获取参数修饰符:" + Modifier.toString(parameter.getModifiers()));
            LOGGER.info("通过parameter.getName()获取参数名:" + parameter.getName());
            LOGGER.info("通过parameter.getParameterizedType()获取参数化类型(泛型):" + parameter.getParameterizedType());
            LOGGER.info("通过parameter.toString()获取参数的字符串描述:" + parameter.toString());
            LOGGER.info("通过parameter.isSynthetic()判断参数是否是合成的:" + parameter.isSynthetic());
            LOGGER.info("通过parameter.isImplicit()判断参数是否是隐式的:" + parameter.isImplicit());
            LOGGER.info("通过parameter.isNamePresent()判断参数是否以类文件名命名:" + parameter.isNamePresent());
            LOGGER.info("通过parameter.isVarArgs()判断参数是否是可变的:" + parameter.isVarArgs() + "\n");
    
            //===================================== Parameter注解信息 =====================================
            LOGGER.info("===================================== Parameter注解信息 =====================================");
            //通过parameter.getAnnotatedType()获取注解的类型(组合类型)
            AnnotatedType annotatedType = parameter.getAnnotatedType();
            LOGGER.info("通过parameter.getAnnotatedType()获取注解的类型(组合类型)--参数类型:" + annotatedType.getType() + "\n");
    
            //通过parameter.getAnnotation()和parameter.getDeclaredAnnotation()获取参数的一个注解
            LOGGER.info("通过parameter.getAnnotation()获取参数的一个注解:" + parameter.getAnnotation(MyAnnotationB.class));
            LOGGER.info("通过parameter.getDeclaredAnnotation()获取参数的一个注解:" + parameter.getDeclaredAnnotation(MyAnnotationB.class) + "\n");
    
            //通过parameter.getAnnotationsByType(annotation.class)获取一类注解
            Annotation[] typeAnnotations = parameter.getAnnotationsByType(MyAnnotationB.class);
            for (Annotation annotation : typeAnnotations) {
                LOGGER.info("通过parameter.getAnnotationsByType(annotation.class)获取一类注解:" + annotation);
            }
            //通过parameter.getDeclaredAnnotationsByType(annotation.class)获取一类注解
            Annotation[] typeAnnotations1 = parameter.getDeclaredAnnotationsByType(MyAnnotationB.class);
            for (Annotation annotation : typeAnnotations1) {
                LOGGER.info("通过parameter.getDeclaredAnnotationsByType(annotation.class)获取一类注解:" + annotation);
            }
            System.out.println("");
    
            //通过parameter.getAnnotations()获取全部注解
            Annotation[] annotations = parameter.getAnnotations();
            for (Annotation annotation : annotations) {
                LOGGER.info("通过parameter.getAnnotations()获取全部注解:" + annotation);
            }
            //通过parameter.getDeclaredAnnotations()获取全部注解
            Annotation[] annotations1 = parameter.getDeclaredAnnotations();
            for (Annotation annotation : annotations1) {
                LOGGER.info("通过parameter.getDeclaredAnnotations()获取全部注解:" + annotation);
            }
        }
    }
    

    3.运行结果

    2018-03-04 14:46:45 INFO  ReflectParameterDemo:26 - ===================================== 通过Class对象获取Parameter对象 =====================================
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:29 - 首先获取Class对象:class pers.hanchao.reflect.common.User
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:32 - 然后获取Method或者Constructor对象:public void pers.hanchao.reflect.common.User.initUser(java.lang.String,java.lang.String)
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:35 - 然后通过getParameters()获取Parameter对象数组
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:38 - 最终获得参数Parameter对象java.lang.String arg0
    
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:41 - ===================================== Parameter信息获取 =====================================
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:42 - 通过parameter.getModifiers()获取参数修饰符:
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:43 - 通过parameter.getName()获取参数名:arg0
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:44 - 通过parameter.getParameterizedType()获取参数化类型(泛型):class java.lang.String
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:45 - 通过parameter.toString()获取参数的字符串描述:java.lang.String arg0
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:46 - 通过parameter.isSynthetic()判断参数是否是合成的:false
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:47 - 通过parameter.isImplicit()判断参数是否是隐式的:false
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:48 - 通过parameter.isNamePresent()判断参数是否以类文件名命名:false
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:49 - 通过parameter.isVarArgs()判断参数是否是可变的:false
    
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:52 - ===================================== Parameter注解信息 =====================================
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:55 - 通过parameter.getAnnotatedType()获取注解的类型(组合类型)--参数类型:class java.lang.String
    
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:58 - 通过parameter.getAnnotation()获取参数的一个注解:@pers.hanchao.reflect.common.MyAnnotationB()
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:59 - 通过parameter.getDeclaredAnnotation()获取参数的一个注解:@pers.hanchao.reflect.common.MyAnnotationB()
    
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:64 - 通过parameter.getAnnotationsByType(annotation.class)获取一类注解:@pers.hanchao.reflect.common.MyAnnotationB()
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:69 - 通过parameter.getDeclaredAnnotationsByType(annotation.class)获取一类注解:@pers.hanchao.reflect.common.MyAnnotationB()
    
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:76 - 通过parameter.getAnnotations()获取全部注解:@pers.hanchao.reflect.common.MyAnnotationA()
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:76 - 通过parameter.getAnnotations()获取全部注解:@pers.hanchao.reflect.common.MyAnnotationB()
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:81 - 通过parameter.getDeclaredAnnotations()获取全部注解:@pers.hanchao.reflect.common.MyAnnotationA()
    2018-03-04 14:46:45 INFO  ReflectParameterDemo:81 - 通过parameter.getDeclaredAnnotations()获取全部注解:@pers.hanchao.reflect.common.MyAnnotationB()

    4.总结

    根据代码实例和运行结果,总结如下:

    • 通过Class对象获取Parameter对象
      1. 首先获取Class对象
      2. 然后获取Method(或者Constructor)对象
      3. 然后通过getParameters()获取Parameter对象数组
      4. 最终获得参数Parameter对象
    • Parameter信息获取

      1. 通过parameter.getModifiers()获取参数修饰符
      2. 通过parameter.getName()获取参数名
      3. 通过parameter.getParameterizedType()获取参数化类型(泛型)
      4. 通过parameter.toString()获取参数的字符串描述
      5. 通过parameter.isSynthetic()判断参数是否是合成的
      6. 通过parameter.isImplicit()判断参数是否是隐式的
      7. 通过parameter.isNamePresent()判断参数是否以类文件名命名
      8. 通过parameter.isVarArgs()判断参数是否是可变的
      9. 通过parameter.getAnnotatedType()获取注解的类型(组合类型)
      10. 通过parameter.getAnnotation()和parameter.getDeclaredAnnotation()获取参数的一个注解
      11. 通过parameter.getAnnotationsByType(annotation.class)和parameter.getDeclaredAnnotationsByType(annotation.class)获取一类注解
      12. 通过parameter.getAnnotations()和parameter.getDeclaredAnnotations()获取全部注解
    • 有关获取Class对象的三种方式参见:Java反射02 : Class对象获取的三种方式和通过反射实例化对象的两种方式

    • 有关getXxxxgetDeclaredXxxx参见:Java反射 : Declared的作用 ( 例如 : getMethods和getDeclaredMethods )
    • 有关参数化类型(泛型)参见系列:Java泛型学习系列-绪论
    展开全文
  • mybatis中_parameter使用和常用sql

    千次阅读 2018-09-07 11:19:31
    简单数据类型,此时#{id,jdbcType=INTEGER}中id可以取任意名字如#{a,..._parameter != null"&gt;,此处一定使用_parameter != null而不是id != null &lt;select id="selectByPrimaryKey" resul...
  • torch.nn.Parameter()

    千次阅读 2019-07-31 21:30:00
    1.torch.nn.Parameter()官方解释 官方用法是: self.v = torch.nn.Parameter(torch.FloatTensor(hidden_size)) 含义是将一个固定不可训练的tensor转换成可以训练的类型parameter,并将这个parameter绑定到这个...
  • parameter setting

    2014-10-13 18:25:40
    SMT_parameter_setting_guide_v5_0
  • 如何修改request的parameter的几种方式

    千次阅读 2018-08-02 10:59:35
    这篇文章仅仅用来参考,本身不想写,request之所以不想让你修改parameter的值,就是因为这个东西一般不然改,有人问我为什么不让改,表面上说我只能说这属于篡改数据,因为这个使用户的请求数据,如果被篡改就相当于...
  • Verilog参数Parameter使用、参数化赋值

    千次阅读 2019-08-15 13:05:05
    1.参数化Parameter使用 方便后期重用,主要用于位宽、计数器大小、延时大小等的定义。 先说Parameters的三大分类分别是,Module Parameter, Local Parameter 以及Specify Parameter。 1.1Module Parameter: 模块...
  • 我在学习Verilog HDL的时候并没有系统的去学,只是大致的了解了下,然后就用一些常用的语法去...建议先看下上面提到的那篇博文,如果实在不想看,又想了解Parameter的作用,那就直接跳过下面的案例。 下面是顶层...
  • parameterType

    千次阅读 2018-05-23 22:00:44
    CRUD标签都有一个属性parameterType,statement通过它指定接收的参数类型。 接收参数的方式有两种: 1、 #{}预编译 2、${}非预编译(直接的sql拼接,不能防止sql注入) 参数类型有三种: 1、 基本数据类型 2...
  • 而今天的主题是parameterMap、parameterType、resultType、parameterMap,它们作用于ParameterHandler组件与ResultSetHandler 组件层。如果有人问你这类问题,其实是在考你的基本功(是否知道mybatis的架构或源码)....
  • mybatis中关于传入参数parameterType

    万次阅读 多人点赞 2013-12-11 22:04:47
    众所周知,mybatis的传入参数可以是各种Java的基本数据类型:包含int,String,Date等。基本数据类型作为传参,只能传入一个。通过#{参数名} 即可获取传入的值 ,复杂数据类型:包含JAVA实体类、Map。...
  • parameterType查询条件的输入类型分为简单类型和复杂类型,简单输入类型,如string ,int等,复杂类型如,pojo包装类,数组类型,集合类型, UserMapper.xml文件 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD ...
  • 严重: Servlet.service() for servlet [springmvc] in context with path [/superben] threw exception [Request processing failed; nested exception is org.mybatis.spring.MyBatisSystemException: nested ...
  • 【转载】mybatis parametertype 多个参数

    千次阅读 2019-02-10 11:23:33
    转自:https://blog.csdn.net/lixld/article/details/77980443  https://blog.csdn.net/mrqiang9001/article/details/79520436  https://blog.csdn.net/m_jack/article/details/79569015 一、单个...
  • parameterType的用法

    千次阅读 2018-11-28 13:52:15
    parameterType的用法-》 在mybatis映射接口的配置中,有select,insert,update,delete等元素都提到了 parameterType的用法,parameterType为输入参数,在配置的时候,配置相应的 输入参数类型即可。parameterType有...
  • parameterType 用法

    2020-08-26 14:20:59
    一个参数的这种其实没有必要写parameterType,而且还有就是多个参数的时候也没有必要写parameterType,也就是说,其实该参数的存在是不是特别必要的。其中@Param和parameterType 二者存其一即可。看名字就能知道...
  • resultType 与 parameterType 的基本使用的区别 : 1、使用 resultType : 主要针对于从数据库中提取相应的数据出来 2、使用parameterType : 主要针对于 将信息存入到数据库中 如: insert 增加数据到数据库zhong ...
  • parameterType和parameterMap的不同

    万次阅读 2018-10-12 14:50:57
    平常都是使用parameterType,今天写代码遇到parameterMap,突然,不知道怎么用。 关于ResultMap和ResultType、ParameterMap和ParameterType,它们都是存在于mybatis的应用中。一般在编写xml会用到。 1- 先说下...
  • 在MyBatis的select、insert、update、delete这些元素中都提到了parameterType这个属性。MyBatis现在可以使用的parameterType传入以下类型的参数,拼接sql语句。 基本类型:int,String,long,Date; 集合类型:数组...
  • 等标签中的parameter属性可以声明参数的类型,可以是基本数据类型,也可以是集合类型,还可以是pojo对象。例如: <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD ...
  • MyBatis传入参数与parameterType

    千次阅读 2016-06-13 20:57:37
    MyBatis传入参数与parameterType December 25, 2013DatabaseJavaopenwares Mybatis的Mapper文件中的select、insert、update、delete元素中有一个parameterType属性,用于对应的mapper接口方法接受的参数类型...
  • MyBatis的传入参数parameterType类型

    万次阅读 2016-11-14 10:51:41
    1. MyBatis的传入参数parameterType类型分两种  1. 1. 基本数据类型:int,string,long,Date;  1. 2. 复杂数据类型:类和Map 注:不同版本的MyBatis对基本类型传递过来的参数名称不能识别,要使用_parameter来...
  • parameterType、parameterMap与resultMap

    千次阅读 2019-02-21 10:43:47
    当实体类中的属性和数据库中的字段对应是,我们使用resultType和parameterType就可以完成CRUD; 当实体类中的属性和数据库中的字段不对应时,就要用resultMap和parameterMap了。 &nbsp; 下面的代码是一个Book...
  • 【问题】:springfox.documentation.service.Parameter类在怎么使用 【产生问题的原因】:在配置Swagger的时候发现这个类 ![图片说明](https://img-ask.csdn.net/upload/202004/02/1585838550_73079.png) ...
  • Mybatis的_parameter使用

    2019-05-22 16:44:20
    parameterType参数类型是实体类,而这个则采用的是一个具体类型的参数,这时在我们判断mappper.xml中判断参数时,由于parameterType参数类型不是实体类了,判断参数时,这时就需要用_parameter来代替参数判断,如果...
  • 错误为:There is no getter for property named 'name' in 'class java.lang.String'两种解决方式: 第一种:mybatis采用ognl解析参数,因此sql语句中 &... parameterType="String"&...
  • Mybatis的parameterType和resultType&amp;amp;resultMap应用 (尊重劳动成果,转载请注明出处:https://blog.csdn.net/qq_39778516/article/details/84111501 consistencely的博客) 1. parameterType(输入类型)...
  • MyBatis ParameterType配置参数的作用

    千次阅读 2019-04-06 16:10:16
    1.ParameterType的使用方式: SQL 语句传参的时候,使用标签的 parameterType 属性来设定。该属性的取值可以 是基本类型,引用类型(例如:String 类型),还可以是实体类类型(POJO 类),同时也可以使用实体类的包装...

空空如也

1 2 3 4 5 ... 20
收藏数 733,402
精华内容 293,360
关键字:

parameter