@Bizlet("数据对象扩展运算逻辑")
public class DataObjectExt {
private DataObjectExt(){
//工具类不能实例化
}
/**
*
将变长的源数组内容添加到目标Xpath数组
* @param targetXpath 目标数组的xpath
* @param
sourceXpath 变长的源数组Xpath
*/
@Bizlet(
value="将变长的源数组内容添加到目标Xpath数组",
params =
{
@BizletParam(index = 0, type =
ParamType.CONSTANT,paramAlias="targetXpath"),
@BizletParam(index=1,type=ParamType.CONSTANT,paramAlias="strings")
}
)
public
static void appendObject(String
targetXpath,String...sourceXpath){
for(String
xpath:sourceXpath){
appendObject(targetXpath,xpath);
}
}
/**
* 将源数组添加到目标Xpath数组
* @param targetXpath 目标数组的xpath名称
*
@param dataObjects 源对象数组
*/
private static void appendObject(String
targetXpath,String sourceXpath){
IDataContext
context=DataContextManager.current().getDefaultContext();
Object[]
sourceObjects=convertObjectArray(context.get(sourceXpath));
if(sourceObjects==null||sourceObjects.length==0)
return
;
Object[]
targetObjects=convertObjectArray(context.get(targetXpath));
if(targetObjects==null||targetObjects.length==0){
targetObjects=new
DataObject[sourceObjects.length];
System.arraycopy(sourceObjects, 0,
targetObjects, 0,
sourceObjects.length);
}else{
//临时交换变量
Object[] temp=new
Object[targetObjects.length];
System.arraycopy(targetObjects, 0,
temp, 0, targetObjects.length);
targetObjects=new
Object[targetObjects.length+sourceObjects.length];
System.arraycopy(temp,
0, targetObjects, 0, temp.length);
System.arraycopy(sourceObjects,
0, targetObjects, temp.length,
sourceObjects.length);
}
context.set(targetXpath,
targetObjects);
}
private static Object[] convertObjectArray(Object
object){
Object[] target=null;
if(object instanceof
Collection){
Collection<?>
collection=(Collection)object;
target=(Object[])collection.toArray(new
Object[collection.size()]);
}else if(object instanceof
Object[]){
target=(Object[])object;
}
return
target;
}
/**
* 获取指定不重复属性值的数组
* @param xpath 目标数组的xpath
* @param
propertyName 指定不重复的属性值
* @return
返回不重复属性值的对象数组
*/
@Bizlet(
value="获取指定不重复属性值的数组",
params =
{
@BizletParam(index = 0, type =
ParamType.CONSTANT,paramAlias="xpath"),
@BizletParam(index = 1, type
= ParamType.CONSTANT,paramAlias="propertyName")
}
)
@SuppressWarnings("unchecked")
public static void
getUniqueObjects(String xpath,final String
propertyName){
IDataContext
context=DataContextManager.current().getDefaultContext();
Object[]
target=convertObjectArray(context.get(xpath));
if( target!=null && target.length>0) {
List
targetList=Arrays.asList(target);
java.util.Collections.sort(targetList,
new Comparator() {
public int compare(final Object o1, final Object
o2){
final DataObject m1 = (DataObject)o1;
final
DataObject m2 =
(DataObject)o2;
if(m1.get(propertyName)!=null&&m2.get(propertyName)!=null){
final
String order1=m1.get(propertyName).toString();
final String
order2=m2.get(propertyName).toString();
return
order1.compareTo(order2);
}
return 0;
}
});
Object value=null;
List<DataObject> result=new
ArrayList<DataObject>();
for(Iterator it =
targetList.iterator(); it.hasNext();) {
DataObject
obj=(DataObject)it.next();
if(obj.get(propertyName)!=null&&obj.get(propertyName).equals(value)){
//it.remove()不能使用,从Arrays.asList的数组是不可修改的!!!
}else{
result.add(obj);
value=obj.get(propertyName);
}
}
context.set(xpath, (Object[])result.toArray(new
Object[result.size()]));
}
}
/**
* 向当前DataContext中的数组对象或者list对象添加DataObject对象<BR>
*
如果对应的PropertyName已经存在,则不添加;如果propertyName为null则不检查对象的属性是否重复
* @param
xpath DataObject数组或者list所在xpath。
* @param dataObject
需要添加的DataObject对象。
* @param propertyName
检查DataObject对象实体名的属性值是否已经存在数组中。
*/
@SuppressWarnings("unchecked")
@Bizlet(
value="添加不重复的数据对象到目标Xpath数组",
params
= {
@BizletParam(index = 0, type =
ParamType.CONSTANT,paramAlias="xpath"),
@BizletParam(index=1,type=ParamType.VARIABLE,paramAlias="dataObject"),
@BizletParam(index
= 2, type = ParamType.CONSTANT,paramAlias="propertyName")
}
)
public static void appendObject(String xpath, DataObject
dataObject,String propertyName) {
if (null == dataObject)
return ;
IDataContext ctx=DataContextManager.current().getDefaultContext();
DataObject[] target=null;
DataObject[] dataObjects=(DataObject[])ctx.get(xpath);
if(propertyName!=null&&isDuplicateProperty(dataObjects,dataObject,propertyName)){
return
;
}
int length = (dataObjects == null) ? 0 : Array.getLength(dataObjects);
target = new DataObject[length + 1];
for (int i = 0; i
<length; i++)
target[i] = (DataObject) Array.get(dataObjects,
i);
target[length] = dataObject;
ctx.set(xpath, target);
}
/**
* 判断目标数组中的对象是否存在与源对象中相同的属性值
* @param targets 目标数组
*
@param source 源对象
* @param propertyName 属性名
* @return
存在返回true,不存在返回false
*/
private static boolean
isDuplicateProperty(DataObject[] targets,DataObject source,String
propertyName){
if(source==null||source.get(propertyName)==null)
return
false;
if(targets!=null&&targets.length>0){
for(int
i=0;i<targets.length;i++){
if(source.get(propertyName).equals(targets[i].get(propertyName))){
return
true;
}
}
}
return false;
}
/**
*
不设置数据对象指定的属性值
* @param dataobject DataObject数据对象
* @param properties
属性名称动态数组
*/
@Bizlet(
value="不设置数据对象指定的属性",
params =
{
@BizletParam(index = 0, type =
ParamType.VARIABLE,paramAlias="dataObject"),
@BizletParam(index=1,type=ParamType.VARIABLE,paramAlias="properties")
}
)
public
static void unSetProperties(DataObject dataobject, String...
properties){
for(String
propertyName:properties){
dataobject.unset(propertyName);
}
}
/**
* 不设置数据对象指定的属性,如果当前xpath的对象为集合或对象数组,则有相同属性的全部不设置属性值
* @param xpath
数据对象的xpath
* @param properties
属性名称动态数组
*/
@Bizlet(
value="不设置数据对象指定的属性",
params =
{
@BizletParam(index = 0, type =
ParamType.CONSTANT,paramAlias="xpath"),
@BizletParam(index=1,type=ParamType.VARIABLE,paramAlias="properties")
}
)
public
static void unSetProperties(String xpath,String...
properties){
IDataContext
context=DataContextManager.current().getDefaultContext();
Object
obj=context.get(xpath);
if(obj instanceof
java.util.Collection){
java.util.Collection<?>
collection=(java.util.Collection)obj;
context.set(xpath,
unSetProperties((DataObject[])collection.toArray(new
DataObject[collection.size()]),properties));
}
else if(obj
instanceof DataObject[]){
DataObject[]
dataObjects=(DataObject[])obj;
context.set(xpath,
unSetProperties(dataObjects,properties));
}else if(obj instanceof
DataObject){
DataObject dataObject=(DataObject)obj;
for(String
propertyName:properties)
dataObject.unset(propertyName);
context.set(xpath,
obj);
}
}
/**
* 清除数据对象的所有属性值
* @param
dataObject
DataObject对象
*/
@Bizlet(
value="清除数据对象的所有属性值",
params =
{
@BizletParam(index = 0, type =
ParamType.VARIABLE,paramAlias="dataObject"),
}
)
public
static void cleanProperties(DataObject dataObject){
Iterator
properties=dataObject.getType().getProperties().iterator();
while(properties.hasNext()){
Property
property=(Property)properties.next();
dataObject.unset(property);
}
}
private static DataObject[]
unSetProperties(DataObject[] obj,String... properties){
DataObject[]
dataObjects=(DataObject[])obj;
List<DataObject> result=new
ArrayList<DataObject>();
for(DataObject
array:dataObjects){
for(String
propertyName:properties){
array.unset(propertyName);
}
result.add(array);
}
return
(DataObject[])result.toArray(new
DataObject[result.size()]);
}
}