Lambda表达式可以有多个参数、一个参数,Hibernate占位符警告

配置参数

  • 适用机型:通用
  • 品牌:唯卓
  • 类型:微电影器材

查看完整参数>>

 

y = 2

StringBuffer whereSql = new StringBuffer("");
List<Object> params = new ArrayList<Object>();
LinkedHashMap<String, String> orderBy = new LinkedHashMap<String, String>();

int paramPosition = 1;

if(!StrUtils.isBlank(userName)){
    whereSql.append(" and o.userName like ?").append(paramPosition++);
    params.add("%"+userName+"%");
}
if(!StrUtils.isBlank(loginName)){
    whereSql.append(" and o.loginName = ?").append(paramPosition++);
    params.add(loginName);
}

Func<string,int>strLength=delegate(stringstr){returnstr.Length;};//匿名委托

也要注意的是,当函数能接受许多必须的参数和可选的参数,那它只要定义一个过量的参数类型即可。

2

 

  1. (x, y) => x * y         //多参数,隐式类型=> 表达式  
  2. x => x * 5              //单参数, 隐式类型=>表达式  
  3. x => { return x * 5; }      //单参数,隐式类型=>语句块  
  4. (int x) => x * 5            //单参数,显式类型=>表达式  
  5. (int x) => { return x * 5; }      //单参数,显式类型=>语句块
     
  6. () => Console.WriteLine()   //无参数   注:无参数必须显式写()

传递参数集合

kwargs = {}

方法二:改成JPA占位符的方式(?号后面有带数字):

strLength=(stringstr)=>{returnstr.Length;};//(显式类型参数列表)=>
{语句},lambda表达式最冗长版本

python把参数收集到一个元组中,作为变量args。显式声明的参数之外如果没有位置参数,这个参数就作为一个空元组。

z = 3

以前我是这样写的,会提示警告,代码如下:

strLength=(stringstr)=>str.Length; //(显式类型参数列表)=> 表达式

注意:kwargs是一个正常的python字典类型,包含参数名和值。如果没有更多的关键字参数,kwargs就是一个空字典。

>>> dict2 = {‘x’: 2, ‘y’: 6}

 

例:

混合参数类型

5

意思就是说:?号占位参数在考虑作废,请使用命名参数或者Jpa样式的占位参数代替。

strLength=(str)=>str.Length;//(隐式类型参数列表)=> 表达式

def complex_function(a, b=None, *c, **d):

 

 

在参数名之前使用一个星号,就是让函数接受任意多的位置参数。

10

 

Lambda表达式:是一个匿名委托,是一种高效的类似于函数式编程的表达式,也是LINQ的基础。

除了函数能接受任意参数集合,python代码也可以调用带有任意多数量的函数,像前面说过的用星号。这种方式传递的参数由python扩展成为参数列表。以便被调用的函数
不需要为了这样调用而去使用过量参数。python中任何可调用的,都能用这种技法来调用。并且用相同的次序规则和标准参数一起使用。

… return x + y + z

strLength=str=>str.Length;//参数名 => 表达式

>>> def accept(**kwargs):
… for keyword, value in kwargs.items():
… print “%s => %r” % (keyword, value)

>>> accept(foo=’bar’, spam=’eggs’)
foo => ‘bar’
spam => ‘eggs’

>>> add_to_list()                   #
没有传递参数,使用默认值,竟出现两个 ‘END’

采用命名参数方式:

Lambda表达式可以有多个参数、一个参数,或者没有参数。其参数类型可以隐式或者显式。示例代码如下:

关键字参数

z = 3

/**
     * 设置参数
     * @param query Query
     * @param paramsMap Map<String, Object> paramsMap
     */
    protected static void setParameters(Query query, Map<String, Object> paramsMap) {
        if (null != query && null != paramsMap && paramsMap.size() > 0) {
            Set<String> set = paramsMap.keySet();
            for (String key : set) {
                query.setParameter(key, paramsMap.get(key));
            }
        }
    }

python在参数名之前使用2个星号来支持任意多的关键字参数。

1

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

1)必须的参数
2)可选的参数
3)过量的位置参数
4)过量的关键字参数

… return sum

  

csdn上的牛人就是多,加油

y = 2

/**
     * 设置参数
     * 
     * @param query
     * @param params
     */
    protected static void setParameters(Query query, Object[] params) {
        if (null != query && null != params && params.length > 0) {
            for (int i = 1; i <= params.length; i++) {
                //query.setParameter(name, params[i - 1]);
                query.setParameter(i, params[i - 1]);
            }
        }
    }

>>> def add(a, b, c):
… return a + b + c

>>> add(1, 2, 3)
6
>>> add(a=4, b=5, c=6)
15
>>> args = (2, 3)
>>> add(1, *args)
6
>>> kwargs={‘b’: 8, ‘c’: 9}
>>> add(a=7, **kwargs)
24
>>> add(a=7, *args)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: add() got multiple values for keyword argument ‘a’
>>> add(1, 2, a=7)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: add() got multiple values for keyword argument ‘a’

18

蕃薯耀 2016年8月19日 09:46:52 星期五

注意args和kwargs只是python的约定。任何函数参数,你可以自己喜欢的方式命名,但是最好和python标准的惯用法一致,以便你的代码,其他的程序员也能轻松读懂。

11

 

——————————————————————————

>>> b = (4, 5, 6)

StringBuffer whereSql = new StringBuffer("");
LinkedHashMap<String, String> orderBy = new LinkedHashMap<String, String>();
Map<String, Object> paramsMap = new HashMap<String, Object>();

if(!StrUtils.isBlank(userName)){
    whereSql.append(" and o.userName like :userName");
    paramsMap.put("userName", "%"+userName+"%");
}
if(!StrUtils.isBlank(loginName)){
    whereSql.append(" and o.loginName = :loginName");
    paramsMap.put("loginName", loginName);
}

位置参数

8

 

在运行时知道一个函数有什么参数,通常是不可能的。另一个情况是一个函数能操作很多对象。更有甚者,调用自身的函数变成一种api提供给可用的应用。

>>> def add_to_list(L=[]):

二、解决方案:

过量的参数

… return x + y + z

 

这个次序是必须的,因为*args和**kwargs只接受那些没有放进来的其他任何参数。没有这个次序,当你调用一个带有位置参数的函数,python就不知道哪个值是已声明参数想要的,也不知道哪个被作为过量参数对待。

5

方法一:改成命名参数的方式:

对于这些情况,python提供了两种特别的方法来定义函数的参数,允许函数接受过量的参数,不用显式声明参数。这些“额外”的参数下一步再解释。

numbers: (1, 2)

Query中设置参数的方法:

任意的位置参数和关键字参数可以和其他标准的参数声明一起使用。混合使用时要加些小心,因为python中他们的次序是重要的。参数归为4类,不是所有的类别都需要。他们必须按下面的次序定义,不用的可以跳过。

4

 

>>> def multiply(*args):
… total = 1
… for arg in args:
… total *= arg
… return total

>>> multiply(2, 3)
6
>>> multiply(2, 3, 4, 5, 6)
720

可变参数

 Positional parameter are considered deprecated;
 use named parameters or JPA-style positional parameters instead.

注意这个例子的最后几行,特别留意当传递一个元组作为过量的位置参数时,是否要显式的传递关键字参数。因为python使用次序规则来扩展过量的参数,那位置参数要放在前面。这个例子中,最后两个调用是相同的,python不能决定那个值是给a的。

   print ‘x =’, x

例子:

kwargs = {‘u’: 6, ‘v’: 7}

>>> func(*a, **b)

 

10

蕃薯耀 2016年8月19日 09:46:52 星期五

12

Hibernate占位符警告:use named parameters or JPA-style positional
parameters instead.

9

 

 其中”?”后面的”0″代表索引位置,在HQL语句中可重复出现,并不一定要从0开始,可以是任何数字,只是参数要与其对应上。

13

一、问题描述:

12

 

关键字参数

 

>>> def add(x, y, z):

2016-08-19 09:44:27 [org.hibernate.hql.internal.ast.HqlSqlWalker]-[WARN] [DEPRECATION] Encountered positional parameter near line 1, column 77 in HQL: [select o from com.lqy.spring.iwx.bean.User o  where 1=1 and o.userName like ? and o.deleteType = ?1  order by o.createTime desc].  Positional parameter are considered deprecated; use named parameters or JPA-style positional parameters instead.

…    sum += v

 

4

 

y = 2

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

默认参数要放在所有必选参数的后面。

只需要加多一个参数paramPosition,拼接sql时,也拼接在?号后面,就成了Jpa样式的占位参数,改动最小,比较省时省力。

10

 

kwargs = {‘u’: 6, ‘v’: 7}

 

Traceback (most recent call last):

使用hibernate进行查询时,由于需要接收页面传入的查询条件,使用了问号占位符(?),然后hibernate会在控制台输出一个警告信息,如下:

看看例子:

StringBuffer whereSql = new StringBuffer("");
List<Object> params = new ArrayList<Object>();
LinkedHashMap<String, String> orderBy = new LinkedHashMap<String, String>();

if(!StrUtils.isBlank(userName)){
    whereSql.append(" and o.userName like ?");
    params.add("%"+userName+"%");
}
if(!StrUtils.isBlank(loginName)){
    whereSql.append(" and o.loginName = ?");
    params.add(loginName);
}

3

 

5

为了去除警告,采用JPA样式占位符方式,因为这样修改起来比较简单,不需要修改[Query中设置参数的方法],代码如下:

2

//JPA占位符方式  
String hql = "select t from t_user t where t.name=?0";  
Query query = getSession().createQuery(hql);  
query.setParameter(0, "李四");  

>>> add(x=1)         # x=1 => kwargs={‘x’: 1}

 采用命名参数方式,主要变动的是参数类型改成了Map,后面需要改动的地方比较多,如:很多查询的方法传入的参数都不一样,这样就需要重构,多写一个方法。

>>> a = [1, 2]

//命名参数的方式  
String hql = "select t from t_usert where t.name=:name";  
Query query = getSession().createQuery(hql);  
query.setParameter("name", "李四");  

和可变参数类似,我们也可以使用 **kwargs 的形式来调用函数,比如:

x = 1

20

1

4

1

x = 1

10

x = 1

12

args = ()

…     print x + y + z

6

3

>>> func(1, 2)                     # 至少提供两个参数,因为 x,
y 是必选参数

2

>>> def add(x, y, z=1):     # x, y 是必选参数,z
是默认参数,默认值是 1

>>> def add(x, y=1, z):      # y
是默认参数,必须放在所有必选参数的后面

11

0

比如,下面对默认参数的使用是错误的:

>>> dict1 = {‘x’: 1}

>>> sum(**dict1)                     # 相当于 sum(x=1)

1

8

发表评论

电子邮件地址不会被公开。 必填项已用*标注