java中对反射的应用

爱被打了一巴掌 2022-06-02 11:27 218阅读 0赞

\--需要用的工具类，java工具类标签里面有

package com.yanshu.utils;

import java.sql.CallableStatement;  
import java.sql.Connection;  
import java.sql.ResultSet;  
import java.sql.ResultSetMetaData;  
import java.sql.SQLException;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
import java.util.Timer;  
import java.util.TimerTask;  
import java.util.concurrent.SynchronousQueue;  
  
  
import org.springframework.data.crossstore.HashMapChangeSet;  
  
  
import com.alibaba.fastjson.JSON;  
import com.yanshu.pojo.Shop\_Inde;  
import com.yanshu.pojo.Shop\_IndePc;  
import com.yanshu.pojo.Shop\_IndeWifi;  
import com.yanshu.tools.MapPojo;  
/\*import com.yanshu.pojo.Shop\_Indexes;  
import com.yanshu.test.MapPojo;  
import com.yanshu.test.MapTrunPojo;  
import com.yanshu.test.Student;\*/  
import com.yanshu.utils.ConnSql;  
import com.yanshu.utils.JdbcUtil;  
/\*\*  
 \* 完整  
 \* @author Administrator  
 \*  
 \*/  
public class ProcJsonUtil \{  
  
  
public static   Map<String, Object> findProcs(String storageName, String\[\] args) \{  
CallableStatement cs = null;  
ResultSet rs = null;  
Map<String, Object> map = new HashMap<String, Object>();  
Connection conn = JdbcUtil.getConn();  
try \{  
String newStorageName = ConnSql.storageNameHandle(storageName, args.length);  
cs = conn.prepareCall("\{call " + newStorageName + "\}");  
for (int i = 0; i < args.length; i++) \{  
cs.setString(i + 1, args\[i\]);  
\}  
rs = cs.executeQuery();  
ResultSetMetaData rsmd = rs.getMetaData();  
  
/\*\*  
\* 遍历循环出表的列名  
\*/  
List list = new ArrayList<>();  
for (int i = 0; i < rsmd.getColumnCount(); i++) \{  
String columnLabel = rsmd.getColumnLabel(i + 1);  
list.add(columnLabel);  
\}  
list = (List) JSON.toJSON(list);  
/\*\*  
\* 遍历循环出列向对应的字段  
\*/  
List listtwo = new ArrayList<>();  
int listii = 0;  
int ii = rsmd.getColumnCount();  
while (rs.next()) \{  
List listtre = new ArrayList<>();  
  
  
for (int i = 1; i <= ii; i++) \{  
Object columnValue = rs.getObject(i);  
if(columnValue==null)  
\{  
Object object="0";  
columnValue=object;  
\}  
listtre.add(columnValue);  
  
  
\}  
listtwo.add(listtre);  
listii = listtwo.size();  
\}  
Map<String, ArrayList<?>> map1 = new HashMap<String, ArrayList<?>>();  
Map<String, Object> mapTwo = new HashMap<String, Object>();  
  
  
mapTwo.put("rows", listtwo);  
mapTwo.put("columns", list);  
//map.put("count", listii);  
map.put("data", mapTwo);  
  
  
\} catch (SQLException e) \{  
e.printStackTrace();  
\}finally  
\{  
//释放资源  
JdbcUtil.closeConn(rs, cs, null, null, conn);  
\}  
return map;  
  
  
\}  
public static String getIndicators(String storageName, String\[\] args)  
\{  
  
Connection conn = null;  
CallableStatement cs=null;  
ResultSet rs=null;  
try \{  
conn = JdbcUtil.getConn();  
String newStorageName = ConnSql.storageNameHandle(storageName, args.length);  
cs = conn.prepareCall("\{call " + newStorageName + "\}");  
//遍历循环参数  
for (int i = 0; i < args.length; i++) \{  
cs.setString(i + 1, args\[i\]);  
\}  
rs = cs.executeQuery();  
ResultSetMetaData rsmdThree = rs.getMetaData();  
int columnCount = rsmdThree.getColumnCount();  
  
/\*\*  
\* 遍历循环出表的列名  
\*/  
List list = new ArrayList<>();  
  
for (int i = 0; i <columnCount; i++) \{  
String columnLabel = rsmdThree.getColumnLabel(i + 1);  
list.add(columnLabel);  
\}  
list = (List) JSON.toJSON(list);  
System.out.println(list);//-----  
/\*\*  
\* 遍历循环出列向对应的字段  
\*/  
List listtwo = new ArrayList<>();  
List listIndicators=new ArrayList<>();  
int listii = 0;  
while (rs.next()) \{  
List listtre = new ArrayList<>();  
for (int i = 1; i <=columnCount; i++) \{  
Object columnValue = rs.getObject(i);  
if(columnValue==null)  
\{  
Object object="0";  
columnValue=object;  
\}  
listtre.add(columnValue);  
  
  
  
\}  
listtwo.add(listtre);  
//格式 \[\{\},\{\}\]  
Map<String, Object> dataMap = new HashMap<String, Object>(0);  
for (int i = 1; i <= rsmdThree.getColumnCount(); i++) \{  
dataMap.put(rsmdThree.getColumnName(i), rs.getObject(i));  
\}  
listIndicators.add(dataMap);  
\}  
Map map=new HashMap<>();  
map.put("coluem",list);  
map.put("rows", listtwo);  
System.out.println("222-->>>"+JSON.toJSON(map));  
System.out.println("111--->>"+JSON.toJSON(listtwo));//-----  
System.out.println("222--->>"+JSON.toJSONString(listIndicators));//----  
  
\} catch (SQLException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
\}  
  
return "111";  
\}  
  
  
  
  
public static String getIndicatorse(String storageName, String\[\] args)  
\{  
  
Connection conn = null;  
CallableStatement cs=null;  
ResultSet rs=null;  
String zhengh=null;  
List listliulian=null;  
List listfangke=null;  
List listxiadan=null;  
List listzhifu=null;  
List listwanjei =null;  
List listIndicators=new ArrayList<>();  
try \{  
conn = JdbcUtil.getConn();  
String newStorageName = ConnSql.storageNameHandle(storageName, args.length);  
cs = conn.prepareCall("\{call " + newStorageName + "\}");  
//遍历循环参数  
for (int i = 0; i < args.length; i++) \{  
cs.setString(i + 1, args\[i\]);  
\}  
rs = cs.executeQuery();  
ResultSetMetaData rsmdThree = rs.getMetaData();  
int columnCount = rsmdThree.getColumnCount();  
  
  
/\*\*  
\* 遍历循环出列向对应的字段  
\*/  
List listtwo = new ArrayList<>();  
  
int listii = 0;  
while (rs.next()) \{  
  
//格式 \[\{\},\{\}\]  
Map<String, Object> dataMap = new HashMap<String, Object>(0);  
for (int i = 1; i <= rsmdThree.getColumnCount(); i++) \{  
dataMap.put(rsmdThree.getColumnName(i), rs.getObject(i));  
  
\}  
  
/\*  listliulian.add(liu);  
listfangke.add(fangke);  
listxiadan.add(xiadan);  
listzhifu.add(zhifu);  
listwanjei.add(wanjei);\*/  
Object key=null;  
  Object value=null;  
//System.out.println(dataMap);  
for (Object map : dataMap.entrySet())\{    
key = ((Map.Entry)map).getKey();  
   value = ((Map.Entry)map).getValue();  
   if(key=="无线访客占比"||key.equals("无线访客占比"))  
   \{  
    Object mapTurnPojo = MapPojo.mapTurnPojo(dataMap, Shop\_IndeWifi.class);  
System.out.println(mapTurnPojo);  
listliulian = Shop\_IndeWifi.listliulian;  
listfangke = Shop\_IndeWifi.listfangke;  
listxiadan = Shop\_IndeWifi.listxiadan;  
listzhifu = Shop\_IndeWifi.listzhifu;  
listwanjei = Shop\_IndeWifi.listwanjei;  
   \}  
   else   if(key=="全平台访客占比"||key.equals("全平台访客占比"))  
   \{  
    Object mapTurnPojo = MapPojo.mapTurnPojo(dataMap, Shop\_Inde.class);  
System.out.println(mapTurnPojo);  
listliulian = Shop\_Inde.listliulian;  
listfangke = Shop\_Inde.listfangke;  
listxiadan = Shop\_Inde.listxiadan;  
listzhifu = Shop\_Inde.listzhifu;  
listwanjei = Shop\_Inde.listwanjei;  
   \}  
     
   else    if(key=="PC访客占比"||key.equals("PC访客占比"))  
   \{  
    Object mapTurnPojo = MapPojo.mapTurnPojo(dataMap, Shop\_IndePc.class);  
System.out.println(mapTurnPojo);  
listliulian = Shop\_IndePc.listliulian;  
listfangke = Shop\_IndePc.listfangke;  
listxiadan = Shop\_IndePc.listxiadan;  
listzhifu = Shop\_IndePc.listzhifu;  
listwanjei = Shop\_IndePc.listwanjei;  
   \}  
     
\}  
  
\}  
  
  
String listliulians="\{\\"流量特征 \\":"+listliulian+"\}";  
String listfangkes="\{\\"访客特征 \\":"+listfangke+"\}";  
String listxiadans="\{\\"下单特征 \\":"+listxiadan+"\}";  
String listzhifus="\{\\"支付特征 \\":"+listzhifu+"\}";  
String listwanjeis="\{\\"完结特征 \\":"+listwanjei+"\}";  
zhengh="\["+listliulians+","+listfangkes+","+listxiadans+","+listzhifus+","+listwanjeis+"\]";  
Shop\_Inde.listliulian.clear();  
Shop\_Inde.listfangke.clear();  
Shop\_Inde.listxiadan.clear();  
Shop\_Inde.listzhifu.clear();  
Shop\_Inde.listwanjei.clear();  
Shop\_IndeWifi.listliulian.clear();  
Shop\_IndeWifi.listfangke.clear();  
Shop\_IndeWifi.listxiadan.clear();  
Shop\_IndeWifi.listzhifu.clear();  
Shop\_IndeWifi.listwanjei.clear();  
Shop\_IndePc.listliulian.clear();  
Shop\_IndePc.listfangke.clear();  
Shop\_IndePc.listxiadan.clear();  
Shop\_IndePc.listzhifu.clear();  
Shop\_IndePc.listwanjei.clear();  
   
   
   
// System.out.println(zhengh);  
\} catch (SQLException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
\}finally  
\{  
//释放资源  
JdbcUtil.closeConn(rs, cs, null, null, conn);  
\}  
  
  
  
return zhengh;  
\}  
  
public static void main(String\[\] args) throws Exception \{  
  
  
//String\[\] par = new String\[\] \{"1783198133", "36155392729","2","20170801","20170820"\};  
//Map<String, Object> map1 = findProcs("SP\_Find\_Auctiontargetes", par);  
//exec  SP\_FindTarget\_news @Sellerid=601879343  ,  @Starttime= 20170801 , @ETime=20170825 , @platfrom=2  
//String\[\] par = new String\[\] \{"601879343", "20170801","20170825","2"\};  
//Map<String, Object> map1 = getIndicators("SP\_FindTarget\_news", par);  
//System.out.println(getIndicators("SP\_FindTarget\_news", par));  
//Description  Resource Path  Location Type  
//F:/java/.m2/repository/com/datastax/cassandra/cassandra-driver-core/3.1.4/cassandra-driver-core-3.1.4.jar' in project 'ysss' cannot be read or is not a valid ZIP file ysss Build path Build Path Problem  
  
  
Long start=0L;  
Long end=0L;  
start=System.currentTimeMillis();  
String\[\] par = new String\[\] \{"601879343", "20170801","20170807","1"\};  
//Map<String, Object> map1 = getIndicators("SP\_FindTarget\_news", par);  
String indicatorse2 = getIndicatorse("SP\_FindTarget\_news", par);  
System.out.println(indicatorse2);  
//System.out.println(JSON.toJSONString(indicatorse2));  
  
  
  
end=System.currentTimeMillis();  
System.out.println("使用StringBuffer的时间是:" + (end - start) + "毫秒!");  
  
  
  
  
\}

\-----反射的应用

package com.yanshu.tools;  
  
  
import java.lang.reflect.Field;  
import java.lang.reflect.Modifier;  
import java.util.Map;  
//1.利用反射完成Map转成实体对象功能是实现的方法2.编写了指标的表格的接口3.优化了17个宝贝的接口和宝贝折线图，树状图的接口  
public class MapPojo \{  
/\*\*  
     \* Map转成实体对象  
     \* @param map map实体对象包含属性  
     \* @param clazz 实体对象类型  
     \* @return  
     \*/  
    public static Object mapTurnPojo(Map<String, Object> map,Class<?> clazz)  
    \{  
    if(map==null)  
    \{  
    return null;  
    \}  
    Object object=null;  
    try \{  
    //创建一个新的实例  
object=clazz.newInstance();  
  
  
//获取和操作类的一组私有的属性  
Field\[\] fields=object.getClass().getDeclaredFields();  
for (Field field : fields) \{  
int modifiers = field.getModifiers();  
//对类和成员访问修饰符进行解码  
if(Modifier.isStatic(modifiers)||Modifier.isFinal(modifiers))  
\{  
continue;  
\}  
field.setAccessible(true);  
            field.set(object, map.get(field.getName()));  
             
\}  
  
  
\} catch (Exception e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
\}   
return object;  
    \}  
  
  
\}

\----实体的调用 ，其他2个类似省略。。。

package com.yanshu.pojo;  
  
  
import java.math.BigDecimal;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
  
public class Shop\_Inde \{  
private Long 日期;  
private Long 访客数;  
private Long 新访客数;  
private Long 回头客数;  
private BigDecimal 新访客占比;  
private BigDecimal 全平台访客占比;  
private BigDecimal PC访客占比;  
private BigDecimal 无线访客占比;  
private BigDecimal 一次留存率;  
private BigDecimal 平均访问深度;  
private BigDecimal 详情页到达率;  
private BigDecimal 详情页收藏率;  
private BigDecimal 详情页加购率;  
private Long 店铺拍下笔数;  
private BigDecimal 店铺拍下金额;  
private BigDecimal 店铺下单率;  
private BigDecimal 下单客单件;  
private BigDecimal 下单客单价;  
private BigDecimal 店铺成交金额;  
private BigDecimal 下单支付率;  
private BigDecimal 订单支付率;  
private BigDecimal 支付客单件;  
private BigDecimal 支付客单价;  
private BigDecimal 已收货金额;  
private Long 交易成功笔数;  
private Long 已收货商品数;  
private BigDecimal 退款成功金额;  
private BigDecimal 七天订单完结率;  
  
  
public Long get日期() \{  
return 日期;  
\}  
public void set日期(Long 日期) \{  
this.日期 = 日期;  
\}  
public Long get访客数() \{  
return 访客数;  
\}  
public void set访客数(Long 访客数) \{  
this.访客数 = 访客数;  
\}  
public Long get新访客数() \{  
return 新访客数;  
\}  
public void set新访客数(Long 新访客数) \{  
this.新访客数 = 新访客数;  
\}  
public Long get回头客数() \{  
return 回头客数;  
\}  
public void set回头客数(Long 回头客数) \{  
this.回头客数 = 回头客数;  
\}  
  
  
  
  
public BigDecimal get新访客占比() \{  
return 新访客占比;  
\}  
public void set新访客占比(BigDecimal 新访客占比) \{  
this.新访客占比 = 新访客占比;  
\}  
  
  
  
public BigDecimal get全平台访客占比() \{  
return 全平台访客占比;  
\}  
public void set全平台访客占比(BigDecimal 全平台访客占比) \{  
this.全平台访客占比 = 全平台访客占比;  
\}  
public BigDecimal get一次留存率() \{  
return 一次留存率;  
\}  
public void set一次留存率(BigDecimal 一次留存率) \{  
this.一次留存率 = 一次留存率;  
\}  
public BigDecimal get平均访问深度() \{  
return 平均访问深度;  
\}  
public void set平均访问深度(BigDecimal 平均访问深度) \{  
this.平均访问深度 = 平均访问深度;  
\}  
public BigDecimal get详情页到达率() \{  
return 详情页到达率;  
\}  
public void set详情页到达率(BigDecimal 详情页到达率) \{  
this.详情页到达率 = 详情页到达率;  
\}  
public BigDecimal get详情页收藏率() \{  
return 详情页收藏率;  
\}  
public void set详情页收藏率(BigDecimal 详情页收藏率) \{  
this.详情页收藏率 = 详情页收藏率;  
\}  
public BigDecimal get详情页加购率() \{  
return 详情页加购率;  
\}  
public void set详情页加购率(BigDecimal 详情页加购率) \{  
this.详情页加购率 = 详情页加购率;  
\}  
public Long get店铺拍下笔数() \{  
return 店铺拍下笔数;  
\}  
public void set店铺拍下笔数(Long 店铺拍下笔数) \{  
this.店铺拍下笔数 = 店铺拍下笔数;  
\}  
public BigDecimal get店铺拍下金额() \{  
return 店铺拍下金额;  
\}  
public void set店铺拍下金额(BigDecimal 店铺拍下金额) \{  
this.店铺拍下金额 = 店铺拍下金额;  
\}  
public BigDecimal get店铺下单率() \{  
return 店铺下单率;  
\}  
public void set店铺下单率(BigDecimal 店铺下单率) \{  
this.店铺下单率 = 店铺下单率;  
\}  
public BigDecimal get下单客单件() \{  
return 下单客单件;  
\}  
public void set下单客单件(BigDecimal 下单客单件) \{  
this.下单客单件 = 下单客单件;  
\}  
public BigDecimal get下单客单价() \{  
return 下单客单价;  
\}  
public void set下单客单价(BigDecimal 下单客单价) \{  
this.下单客单价 = 下单客单价;  
\}  
public BigDecimal get店铺成交金额() \{  
return 店铺成交金额;  
\}  
public void set店铺成交金额(BigDecimal 店铺成交金额) \{  
this.店铺成交金额 = 店铺成交金额;  
\}  
public BigDecimal get下单支付率() \{  
return 下单支付率;  
\}  
public void set下单支付率(BigDecimal 下单支付率) \{  
this.下单支付率 = 下单支付率;  
\}  
public BigDecimal get订单支付率() \{  
return 订单支付率;  
\}  
public void set订单支付率(BigDecimal 订单支付率) \{  
this.订单支付率 = 订单支付率;  
\}  
public BigDecimal get支付客单件() \{  
return 支付客单件;  
\}  
public void set支付客单件(BigDecimal 支付客单件) \{  
this.支付客单件 = 支付客单件;  
\}  
public BigDecimal get支付客单价() \{  
return 支付客单价;  
\}  
public void set支付客单价(BigDecimal 支付客单价) \{  
this.支付客单价 = 支付客单价;  
\}  
public BigDecimal get已收货金额() \{  
return 已收货金额;  
\}  
public void set已收货金额(BigDecimal 已收货金额) \{  
this.已收货金额 = 已收货金额;  
\}  
public Long get交易成功笔数() \{  
return 交易成功笔数;  
\}  
public void set交易成功笔数(Long 交易成功笔数) \{  
this.交易成功笔数 = 交易成功笔数;  
\}  
public Long get已收货商品数() \{  
return 已收货商品数;  
\}  
public void set已收货商品数(Long 已收货商品数) \{  
this.已收货商品数 = 已收货商品数;  
\}  
public BigDecimal get退款成功金额() \{  
return 退款成功金额;  
\}  
public void set退款成功金额(BigDecimal 退款成功金额) \{  
this.退款成功金额 = 退款成功金额;  
\}  
public BigDecimal get七天订单完结率() \{  
return 七天订单完结率;  
\}  
public void set七天订单完结率(BigDecimal 七天订单完结率) \{  
this.七天订单完结率 = 七天订单完结率;  
\}  
public BigDecimal getPC访客占比() \{  
return PC访客占比;  
\}  
public void setPC访客占比(BigDecimal pC访客占比) \{  
PC访客占比 = pC访客占比;  
\}  
public BigDecimal get无线访客占比() \{  
return 无线访客占比;  
\}  
public void set无线访客占比(BigDecimal 无线访客占比) \{  
this.无线访客占比 = 无线访客占比;  
\}  
  
//return "\{\\"type\\":\\"error\\"\}";  
//\[\{" 流量特征 :"\[\{"访客数:"3781", 新访客数:" 3357 ", 回头客数: " 424 \}\]\}\]  
 public static   int count ;  
 public static List listliulian=new ArrayList<>();  
 public static List listfangke=new ArrayList<>();  
 public static List listxiadan=new ArrayList<>();  
 public static List listzhifu=new ArrayList<>();  
 public static List listwanjei=new ArrayList<>();  
  
  
  
@Override  
public String toString() \{  
// Integer count=0;  
Long start=0l;  
String liu="";  
String fangke="";  
String xiadan="";  
String zhifu="";  
String wanjei="";  
  
  
  
  
liu="\{\\"访客数\\":"+ 访客数+",\\"新访客数\\":"+ 新访客数 +" ,\\" 回头客数\\": "+ 回头客数 + ",\\" 新访客占比\\": "+ 新访客占比 + ",\\" 全平台访客占比\\": "+ 全平台访客占比 + " \}";  
  
fangke="\{\\"一次留存率\\":"+ 一次留存率+",\\"详情页到达率\\":"+ 详情页到达率 +" ,\\" 平均访问深度\\": "+ 平均访问深度 + " ,\\" 页面收藏率\\": "+ 详情页收藏率 + ",\\" 页面加购率\\": "+ 详情页加购率 + "\}";  
  
xiadan="\{\\"店铺拍下笔数\\":"+ 店铺拍下笔数+",\\"店铺拍下金额\\":"+ 店铺拍下金额 +" ,\\" 店铺下单率\\": "+ 店铺下单率 + ",\\" 下单客单件\\": "+ 下单客单件 + ",\\" 下单客单价\\": "+ 下单客单价 + " \}";  
  
zhifu="\{\\"店铺成交金额\\":"+ 店铺成交金额+",\\"下单支付率\\":"+ 下单支付率 +" ,\\" 订单支付率\\": "+ 订单支付率 + ",\\" 支付客单件\\": "+ 支付客单件 + ",\\" 支付客单价\\": "+ 支付客单价 + " \}";  
   
wanjei="\{\\"已收款金额\\":"+ 已收货金额+",\\"交易成功笔数\\":"+ 交易成功笔数 +" ,\\" 已收货商品数\\": "+ 已收货商品数 + ",\\" 退款成功金额\\": "+ 退款成功金额 + ",\\" 七天订单完结率\\": "+ 七天订单完结率 + " \}";  
//System.out.println("liu--->>"+liu);  
//start=System.currentTimeMillis();  
// System.out.println(start);  
int num = Shop\_Inde.count++;  
// System.out.println("num--->>>"+num);  
   
int size = listliulian.size();  
String zhengh=null;  
String listliulians=null;  
//for(int i=0;i<num;i++)  
// \{  
   
   
listliulian.add(liu);  
listfangke.add(fangke);  
listxiadan.add(xiadan);  
listzhifu.add(zhifu);  
listwanjei.add(wanjei);   
  
  
  
  
/\* listliulians="\{\\"流量特征 \\":"+listliulian+"\}";  
String listfangkes="\{\\"访客特征 \\":"+listfangke+"\}";  
String listxiadans="\{\\"下单特征 \\":"+listxiadan+"\}";  
String listzhifus="\{\\"支付特征 \\":"+listzhifu+"\}";  
String listwanjeis="\{\\"完结特征 \\":"+listwanjei+"\}";  
zhengh="\["+listliulians+","+listfangkes+","+listxiadans+","+listzhifus+","+listwanjeis+"\]";\*/  
  
//System.out.println("zhengh--->>"+zhengh);  
  
 //  
  
String string="";  
return string;  
\}  
  
  
  
/\*public String toString() \{  
return "\[\{\\" 流量特征\\": \{访客数:" + 访客数 + ", 新访客数=" + 新访客数 + ", 回头客数=" + 回头客数 + " ,新访客占比=" +新访客占比 + "\}\},"  
\+ "\{访客特征= \{一次留存率=" + 一次留存率 + ", 新访客数=" + 新访客数 +  ", 平均访问深度=" + 平均访问深度 + " ,新访客占比=" +新访客占比 + "\}\},"  
\+ "\{下单特征= \{访客数=" + 访客数 + ", 新访客数=" + 新访客数 + ", 回头客数=" + 回头客数 + "\}\},"  
\+ "\{支付特征= \{访客数=" + 访客数 + ", 新访客数=" + 新访客数 + ", 回头客数=" + 回头客数 + "\}\},"  
\+ "\{完结特征= \{访客数=" + 访客数 + ", 新访客数=" + 新访客数 + ", 回头客数=" + 回头客数 + "\}\}\]"  
;  
\}\*/  
  
  
  
  
  
  
  
  
\}