banxitan

Java字符串操作小记

posted @ 2009-06-27 12:08 MikyTan 阅读(164) | 评论 (0) | 编辑 收藏

tomcat 配置 小记

posted @ 2009-05-27 11:16 MikyTan 阅读(248) | 评论 (0) | 编辑 收藏

Struts2中 用OGNL表达式定义字符串常量 与单个字符常量需要注意的一个小细节

具体记录如下：

<s:set name="fieldType" value="'condition'"></s:set>
<s:set name="countryID" value="'CHN'"></s:set>
<s:set name="corpCenter" value="#session.opType.corpCenter"></s:set>
<s:set name="corpID" value="#session.opType.corpID"></s:set>
<s:set name="corpType" value="#session.opType.corpType"></s:set>
<s:set name="agentID" value=""></s:set>
<s:set name="city" value=""></s:set>
<s:set name="agentType" value='"A"'></s:set>
注意上面红色部分的标识。当定义的变量为单个字符是，必须外面是单引号，字符用双引号引起。

<s:action name="ReportBeanListAction" id="reportBeanSkyechoAgentListAction">
                      <s:param name="agentID"><s:property value="agentID" /></s:param>
         <s:param name="city"><s:property value="city" /></s:param>
         <s:param name="corpID"><s:property value="corpID" /></s:param>
         <s:param name="corpCenter"><s:property value="corpCenter" /></s:param>
         <s:param name="agentType"><s:property value="agentType" /></s:param>
                        </s:action>

附：转载OGNL表达式相关的知识点：

OGNL的全称是Object Graph Navigation Language(对象图导航语言)，它是一种强大的表达式语言，让你通过简单一致的表达式语法来读取和设置Java对象的属性值，调用对象的方法，遍历整个对象的结构图，实现字段类型转换等功能。

为什么使用OGNL
相对于其它的表达式语言，OGNL的功能更为强大，它提供了很多高级而必需的特性，例如强大的类型转换功能、静态或实例方法的执行、跨集合投影，以及动态lambda表达式定义等。
OGNL基础
OGNL表达式的计算都是围绕OGNL上下文来进行的，OGNL上下文实际上就是一个Map对象，由ognl.OgnlContext类(实现了 java.util.Map接口)来表示。OGNL上下文可以包含一个或多个JavaBean对象，在这些对象中有一个是特殊的，这个对象就是上下文的根 (root)对象。如果在写表达式的时候，没有指定使用上下文中的哪一个对象，那么根对象将被假定为表达式所依据的对象。
在OGNL上下文中，只能有一个根对象，如果你访问根对象，那么在写表达式的时候，直接写对象的属性就可以了；否则，你需要使用“#key”前缀，例如表达式#namager.name。
OGNL表达式
OGNL表达式的基础单元就是导航链，通常简称为链(chain)。最简单的链由下列部分组成：
１、属性名：如name和manager.name；
２、方法调用：如manager.hashCode()，返回manager对象的散列码；
３、数组索引：如emals[0]，返回当前对象的邮件列表中的第一个邮件地址。
所有OGNL表达式的计算都是在当前对象的上下文中，一个链简单地使用链中先前链接的结果作为下一步计算的当前对象。我们看如下所示的链：
name.toCharArray()[0].numericValue.toString()
这个表达式按照下列的步骤进行计算：
１、获取根对象的name属性；
２、在String结果上调用toCharArray()方法；
３、从char数组中提取第一个字符；
４、从提取的字符对象上行到numericValue属性(这个字符被表示为Character对象，Character类有一个getNumericValue()方法)；
５、在Integer对象结果上调用toString()方法。
这个表达式最终结果是最后返回的toString()方法调用返回的字符串。
常量
OGNL支持的所有常量类型：
１、字符串常量：
以单引号或双引号括起来的字符串。如”hello”，’hello’。
不过要注意的是，如果是单个字符的字符串常量，必须使用双引号。
２、字符常量：
以单引号括起来的字符。如’a'。
３、数值常量：
除了Java中的int、long、float和double外，OGNL还让你使用“b”或“B”后缀指定BigDecimal常量，用“h”“H”后缀指定BigInteger常量。
４、布尔常量：
true和false。
５、null常量。
操作符
OGNL除了支持所有的Java操作符外，还支持以下几种：
１、逗号,
与C语言中的逗号操作符类似。
２、花括号{}
用于创建列表，元素之间用逗号分隔。
３、in和not in
用于判断一个值是否在集合中。
访问JavaBean的属性
假如有一个employee对象作为OGNL上下文的根对象，那对于下面的表达式：
１、name
对应的java代码是employee.getName();
２、address.country
对应的java代码是employee.getAddress().getCountry();
访问静态方法和静态字段
@class@method(args)　　　　　//调用静态方法
@class@field　　　　　　　　   //调用静态字段
其中class必须给出完整的类名(包括包名),如果省略class，那么默认使用的类是java.util.Math，如：
@@min(5,3)
@@max(5,3)
@@PI
索引访问
OGNL支持多种索引方式的访问。
１、数组和列表索引
在OGNL中，数组和列表可以大致看成是一样的。
如：array[0]、list[0]。表达式：{’zhangsan’,'lisi’,'wangwu’}[1]等。
２、JavaBean的索引属性
要使用索引属性，需要提供两对setter和getter方法，一对用于数组，一对用于数组中的元素。
如：有一个索引属性interest，它的getter和setter如下
public String[] interest;
public String[] getInterest(){ return interest;}
public void setInterest(String[] interest){ this.interest=interest;}
public String getInterest(int i){ return interest[i]}
public void setInterest(int i, String newInterest){ interest[i]=newInterest;}
对于表达式interest[2]，OGNL可以正确解释这个表达式，调用getInterest(2)方法。如果是设置的情况下，会调用setInterest(2,value)方法。
３、OGNL对象的索引属性
JavaBean的索引属性只能使用整型作为索引，OGNL扩展了索引属性的概念，可以使用任意的对象来作为索引。
对集合进行操作
１、创建集合：
创建列表
使用花括号将元素包含起来，元素之间使用逗号分隔。如{’zhangsan’,'lisi’,'wangwu’}
创建数组
OGNL中创建数组与Java语言中创建数组类似。
创建Map
Map使用特殊的语法来创建     #{”key”:value, ……}
如果想指定创建的Map类型，可以在左花括号前指定Map实现类的类名。如：
#@java.util.LinkedHashMap@{”key”:”value”,….}
Map通过key来访问，如map["key"]或map.key。
２、投影
OGNL提供了一种简单的方式在一个集合中对每一个元素闻调用相同的方法，或者抽取相同的属性，并将结果保存为一个新的集合，称之为投影。
假如employees是一个包含了employee对象的列表，那么
#employees.{name}将返回所有雇员的名字的列表。
在投影期间，使用#this变量来引用迭代中的当前元素。
如：objects.{#this instanceof String? #this: #this.toString()}
３、选择
OGNL提供了一种简单的方式来使用表达式从集合中选择某些元素，并将结果保存到新的集合中，称为选择。
如#employees.{?#this.salary>3000}
将返回薪水大于3000的所有雇员的列表。
#employees.{^#this.salary>3000}
将返回第一个薪水大于3000的雇员的列表。
#employees.{$#this.salary>3000}
将返回最后一个薪水大于3000的雇员的列表。
lambda表达式
lambda表达式的语法是：　　　:[...]。OGNL中的lambda表达式只能使用一个参数，这个参数通过#this引用。
如：
#fact= :[ #this<=1 ? 1 : #this* #fact ( #this-1) ], #fact(30)
#fib= :[#this==0 ? 0 : #this==1 ? 1 : #fib(#this-2)+#fib(#this-1)], #fib(11)

OGNL的全称是Object Graph Navigation Language(对象图导航语言)，它是一种强大的表达式语言，让你通过简单一致的表达式语法来读取和设置Java对象的属性值，调用对象的方法，遍历整个对象的结构图，实现字段类型转换等功能。

为什么使用OGNL
相对于其它的表达式语言，OGNL的功能更为强大，它提供了很多高级而必需的特性，例如强大的类型转换功能、静态或实例方法的执行、跨集合投影，以及动态lambda表达式定义等。
OGNL基础
OGNL表达式的计算都是围绕OGNL上下文来进行的，OGNL上下文实际上就是一个Map对象，由ognl.OgnlContext类(实现了 java.util.Map接口)来表示。OGNL上下文可以包含一个或多个JavaBean对象，在这些对象中有一个是特殊的，这个对象就是上下文的根 (root)对象。如果在写表达式的时候，没有指定使用上下文中的哪一个对象，那么根对象将被假定为表达式所依据的对象。
在OGNL上下文中，只能有一个根对象，如果你访问根对象，那么在写表达式的时候，直接写对象的属性就可以了；否则，你需要使用“#key”前缀，例如表达式#namager.name。
OGNL表达式
OGNL表达式的基础单元就是导航链，通常简称为链(chain)。最简单的链由下列部分组成：
１、属性名：如name和manager.name；
２、方法调用：如manager.hashCode()，返回manager对象的散列码；
３、数组索引：如emals[0]，返回当前对象的邮件列表中的第一个邮件地址。
所有OGNL表达式的计算都是在当前对象的上下文中，一个链简单地使用链中先前链接的结果作为下一步计算的当前对象。我们看如下所示的链：
name.toCharArray()[0].numericValue.toString()
这个表达式按照下列的步骤进行计算：
１、获取根对象的name属性；
２、在String结果上调用toCharArray()方法；
３、从char数组中提取第一个字符；
４、从提取的字符对象上行到numericValue属性(这个字符被表示为Character对象，Character类有一个getNumericValue()方法)；
５、在Integer对象结果上调用toString()方法。
这个表达式最终结果是最后返回的toString()方法调用返回的字符串。
常量
OGNL支持的所有常量类型：
１、字符串常量：
以单引号或双引号括起来的字符串。如”hello”，’hello’。
不过要注意的是，如果是单个字符的字符串常量，必须使用双引号。
２、字符常量：
以单引号括起来的字符。如’a'。
３、数值常量：
除了Java中的int、long、float和double外，OGNL还让你使用“b”或“B”后缀指定BigDecimal常量，用“h”“H”后缀指定BigInteger常量。
４、布尔常量：
true和false。
５、null常量。
操作符
OGNL除了支持所有的Java操作符外，还支持以下几种：
１、逗号,
与C语言中的逗号操作符类似。
２、花括号{}
用于创建列表，元素之间用逗号分隔。
３、in和not in
用于判断一个值是否在集合中。
访问JavaBean的属性
假如有一个employee对象作为OGNL上下文的根对象，那对于下面的表达式：
１、name
对应的java代码是employee.getName();
２、address.country
对应的java代码是employee.getAddress().getCountry();
访问静态方法和静态字段
@class@method(args)　　　　　//调用静态方法
@class@field　　　　　　　　   //调用静态字段
其中class必须给出完整的类名(包括包名),如果省略class，那么默认使用的类是java.util.Math，如：
@@min(5,3)
@@max(5,3)
@@PI
索引访问
OGNL支持多种索引方式的访问。
１、数组和列表索引
在OGNL中，数组和列表可以大致看成是一样的。
如：array[0]、list[0]。表达式：{’zhangsan’,'lisi’,'wangwu’}[1]等。
２、JavaBean的索引属性
要使用索引属性，需要提供两对setter和getter方法，一对用于数组，一对用于数组中的元素。
如：有一个索引属性interest，它的getter和setter如下
public String[] interest;
public String[] getInterest(){ return interest;}
public void setInterest(String[] interest){ this.interest=interest;}
public String getInterest(int i){ return interest[i]}
public void setInterest(int i, String newInterest){ interest[i]=newInterest;}
对于表达式interest[2]，OGNL可以正确解释这个表达式，调用getInterest(2)方法。如果是设置的情况下，会调用setInterest(2,value)方法。
３、OGNL对象的索引属性
JavaBean的索引属性只能使用整型作为索引，OGNL扩展了索引属性的概念，可以使用任意的对象来作为索引。
对集合进行操作
１、创建集合：
创建列表
使用花括号将元素包含起来，元素之间使用逗号分隔。如{’zhangsan’,'lisi’,'wangwu’}
创建数组
OGNL中创建数组与Java语言中创建数组类似。
创建Map
Map使用特殊的语法来创建     #{”key”:value, ……}
如果想指定创建的Map类型，可以在左花括号前指定Map实现类的类名。如：
#@java.util.LinkedHashMap@{”key”:”value”,….}
Map通过key来访问，如map["key"]或map.key。
２、投影
OGNL提供了一种简单的方式在一个集合中对每一个元素闻调用相同的方法，或者抽取相同的属性，并将结果保存为一个新的集合，称之为投影。
假如employees是一个包含了employee对象的列表，那么
#employees.{name}将返回所有雇员的名字的列表。
在投影期间，使用#this变量来引用迭代中的当前元素。
如：objects.{#this instanceof String? #this: #this.toString()}
３、选择
OGNL提供了一种简单的方式来使用表达式从集合中选择某些元素，并将结果保存到新的集合中，称为选择。
如#employees.{?#this.salary>3000}
将返回薪水大于3000的所有雇员的列表。
#employees.{^#this.salary>3000}
将返回第一个薪水大于3000的雇员的列表。
#employees.{$#this.salary>3000}
将返回最后一个薪水大于3000的雇员的列表。
lambda表达式
lambda表达式的语法是：　　　:[...]。OGNL中的lambda表达式只能使用一个参数，这个参数通过#this引用。
如：
#fact= :[ #this<=1 ? 1 : #this* #fact ( #this-1) ], #fact(30)
#fib= :[#this==0 ? 0 : #this==1 ? 1 : #fib(#this-2)+#fib(#this-1)], #fib(11)

posted @ 2009-05-09 12:30 MikyTan 阅读(4879) | 评论 (0) | 编辑 收藏

Struts2 字符串截取

posted @ 2009-05-05 22:55 MikyTan 阅读(380) | 评论 (0) | 编辑 收藏

JSP 中使用Struts2的值 (Strust2 中调用JAVA的公共类方法)

<%@ page import="com.opensymphony.xwork2.util.ValueStack" %>

……

<%= ((ValueStack)request.getAttribute("struts.valueStack")).findString("str") %>

<s:set name="str" value="%{str}" />

<%=request.getAttribute("str") %>

posted @ 2009-05-05 20:42 MikyTan 阅读(2665) | 评论 (1) | 编辑 收藏

产品时间段(StartDate,EndDate)SQL查询

create table T([id] int,[开始时间] datetime,[结束时间] datetime,[价格] numeric(4,1))
insert into T
select 1,'2008-01-01','2008-09-10',220.0 union all
select 2,'2008-09-11','2008-09-30',280.0 union all
select 3,'2008-10-01','2008-10-10',320.0 union all
select 3,'2008-10-13','2008-12-31',350.0

select * from T
go
--Code
create procedure GetTimePrice(@begintime datetime,@endtime datetime)
as
declare @tmptime datetime
declare @tmp table (dt datetime,price numeric(4,1))--结果表
begin
set @tmptime=@begintime
while @tmptime<=@endtime
begin

insert into @tmp
select @tmptime,价格  from t where @tmptime between 开始时间 and 结束时间
set @tmptime=DATEADD(dd,1,@tmptime)
end
select * from @tmp
end
go

exec GetTimePrice '2008-09-09','2008-09-14'--执行
--Drop
drop table T
drop procedure GetTimePrice

set nocount on
create table T([id] int,[开始时间] datetime,[结束时间] datetime,[价格] numeric(4,1))
insert into T
select 1,'2008-01-01','2008-09-10',220.0 union all
select 2,'2008-09-11','2008-09-30',280.0 union all
select 3,'2008-10-01','2008-10-10',320.0 union all
select 3,'2008-10-11','2008-12-31',350.0

declare @bgnTime datetime set @bgnTime = '2008-09-09'
declare @endTime datetime set @endTime = '2008-09-13'
select id
    ,case when [开始时间]<@bgnTime then @bgnTime else [开始时间] end as [开始时间] -- 让输出结果更贴近参数表现出来
    ,case when [结束时间]>@endTime then @endTime else [结束时间] end as [结束时间] -- 让输出结果更贴近参数表现出来
    ,[价格]
from T
where [开始时间]<@endTime
and [结束时间]>@bgnTime
-- id,开始时间,结束时间
-- 1,2008-09-09 00:00:00.000,2008-09-10 00:00:00.000
-- 2,2008-09-11 00:00:00.000,2008-09-13 00:00:00.000

drop table T

id          开始时间                                                   结束时间                                                   价格     
----------- ------------------------------------------------------ ------------------------------------------------------ ------ 
1           2008-09-09 00:00:00.000                                2008-09-10 00:00:00.000                                220.0
2           2008-09-11 00:00:00.000                                2008-09-13 00:00:00.000                                280.0

posted @ 2009-04-23 20:50 MikyTan 阅读(795) | 评论 (0) | 编辑 收藏

jQuery实现input文本框内灰色提示文本效果 和 input标签获取焦点是文本框内提示信息清空

posted @ 2009-04-23 11:50 MikyTan 阅读(13374) | 评论 (3) | 编辑 收藏

酒店价格间夜显示(JavaScript 实现)

posted @ 2009-04-21 13:31 MikyTan 阅读(402) | 评论 (0) | 编辑 收藏

JavaScript 取Table表格中的值

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE> New Document </TITLE>
<META NAME="Generator" CONTENT="EditPlus">
<META NAME="Author" CONTENT="">
<META NAME="Keywords" CONTENT="">
<META NAME="Description" CONTENT="">
</HEAD>

<BODY onload="getTableValue()">
<script language="javascript">
    function getTableValue(){
    alert(document.getElementById('table1').rows[0].cells[0].innerHTML);
         //or
    alert(document.getElementById('table1').rows.item(0).cells.item(0).innerHTML);
    }
</script>
<table id="table1">
     <tr>
         <td>1</td>
         <td>2</td>
      </tr>
     <tr>
         <td>3</td>
         <td>2</td>
      </tr>
</table>
</BODY>
</HTML>

posted @ 2009-04-15 11:38 MikyTan 阅读(1300) | 评论 (0) | 编辑 收藏

xmlbeans dom level 3 not implemented

今天在用XmlBeans解析XML DOC时，遇到“xmlbeans dom level 3 not implemented”的解决办法！

问题产生的原因：
    1、由于在生成的XML结构中插入了一些未在XSD中定义的节点，那么这些节点无法用XMLBeans所采用的对象的方法获取，只能采用DOM的方式来处理，但在处理的过程中报“xmlbeans dom level 3 not implemented”

//实例化一个文档构建器工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
//通过文档构建器工厂获取一个文档构建器
DocumentBuilder builder = factory.newDocumentBuilder();
//通过文档通过文档构建器构建一个文档实例
AssertionDocument assertionDoc = AssertionDocument.Factory.parse(new File(”xml/assertion.xml”), loadOptions);

Document doc = builder.parse(new InputSource(new StringReader(assertionDoc.toString())));
doc.getDocumentElement().setIdAttribute(”AssertionID”, true);

posted @ 2009-04-14 10:11 MikyTan 阅读(778) | 评论 (0) | 编辑 收藏