Java 使用google app engine时显示迭代错误

我遇到了以下问题： 我试图抓取距离用户手机x[英里/公里]以内的用户 电话。我正在使用谷歌应用程序引擎的数据存储api，我搞不懂 问题是什么。问题是当我使用 itiration–出现一个错误，告诉我无法在中使用不同的属性 组合过滤器

    package com.linkedlive.business;

    import java.io.IOException;
    import java.util.Iterator;

    import javax.servlet.http.*;

    import org.json.JSONArray;
    import org.json.JSONObject;

    import com.biomedica.server.geolocation.GeoLocation;
    import com.biomedica.server.searchtools.SearchForGeolocEntitiy;
    import com.google.appengine.api.datastore.DatastoreService;
    import com.google.appengine.api.datastore.DatastoreServiceFactory;
    import com.google.appengine.api.datastore.Entity;
    import com.google.appengine.api.datastore.KeyFactory;

    @SuppressWarnings("serial")
    public class Venue extends HttpServlet {

    public void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws IOException {
        this.doPost(req, resp);

    }

    public void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws IOException {

        DatastoreService datastore =
      DatastoreServiceFactory.getDatastoreService();


        String cmd=req.getParameter("cmd");
        if(cmd.equals("venuenearby"))
        {
            GeoLocation geo=new GeoLocation();
            SearchForGeolocEntitiy search=new
    SearchForGeolocEntitiy("accounts");// this is a class that i created to set the
    query filters see bellow
            // get request parameters
            float lat=Float.valueOf(req.getParameter("lat"));
            float lng=Float.valueOf(req.getParameter("lng"));
            float rad=Float.valueOf(req.getParameter("rad"));
            // calculate the distance


            Iterable<Entity>
    ent=search.GetJSONForEntitiyNearByUsingBounds(lat,
    lng,geo.getGeoLocationBounds(lat, lng, rad) );
            Iterator<Entity> i=ent.iterator();
            JSONObject json=new JSONObject();
            JSONArray injson=new JSONArray();
            json.put("result", "venuenearby");

            while(i.hasNext())
            {
                try {
                    JSONObject j=new JSONObject();
                    Entity t=i.next();
                    j.put("key",
    KeyFactory.keyToString(t.getKey()));
                    j.put("userid",
    t.getProperty("userid"));
                    j.put("filepath",
    t.getProperty("filepath"));
                    injson.put(j);
                } catch (NullPointerException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
            json.put("body",injson);
            resp.getWriter().write(json.toString());
        }


    }
    }





///////////////////////////////////////////////////////////////////////////////
////////////////////
//////////////////////////  SearchForGeolocEntitiy      
////////////////////////////////////


    package com.biomedica.server.searchtools;

    import java.lang.reflect.Array;
    import java.util.Arrays;

    import com.biomedica.server.geolocation.GeoLocation;
    import com.google.appengine.api.datastore.DatastoreService;
    import com.google.appengine.api.datastore.DatastoreServiceFactory;
    import com.google.appengine.api.datastore.Entity;
    import com.google.appengine.api.datastore.PreparedQuery;
    import com.google.appengine.api.datastore.Query;
    import com.google.appengine.api.datastore.Query.CompositeFilterOperator;
    import com.google.appengine.api.datastore.Query.Filter;
    import com.google.appengine.api.datastore.Query.FilterOperator;
    import com.google.appengine.api.datastore.Query.FilterPredicate;
    import com.google.appengine.api.datastore.Query.CompositeFilter;

     public class SearchForGeolocEntitiy {
     private String EntitiyName;
     private Query q;

     public SearchForGeolocEntitiy(String name)
    {
        EntitiyName=name;
        q=new Query(name);

    }
    public Iterable<Entity> GetJSONForEntitiyNearBy(double lang,double
    lat,double rad,int max_result)
    {
        DatastoreService datastore =
    DatastoreServiceFactory.getDatastoreService();
        // decleeraing filter object




                Filter filter_min_lngt=new
    FilterPredicate("lng", FilterOperator.GREATER_THAN, lang-rad);
                Filter filter_max_lngt=new
    FilterPredicate("lng", FilterOperator.LESS_THAN, lang+rad);
                Filter filter_min_lat=new
    FilterPredicate("lat", FilterOperator.GREATER_THAN, lat-rad);
                Filter filter_max_lat=new
    FilterPredicate("lat", FilterOperator.LESS_THAN, lat+rad);

                Filter filter_lng=new
    CompositeFilter(CompositeFilterOperator.AND,Arrays.asList(filter_min_lngt,filte
    r_max_lngt));
                Filter filter_lat=new
    CompositeFilter(CompositeFilterOperator.AND,Arrays.asList(filter_min_lat,filter
    _max_lat));


                Filter filter=new
    CompositeFilter(CompositeFilterOperator.AND,Arrays.asList(filter_lng,filter_lat
     ));

                q.setFilter(filter);
                PreparedQuery pq = datastore.prepare(q);


                return pq.asIterable();

    }
    public Iterable<Entity> GetJSONForEntitiyNearByUsingSSID(String
    EntityName,String entityID,String SSID)
    {
        DatastoreService datastore =
    DatastoreServiceFactory.getDatastoreService();
        // decleeraing filter object


            Filter filter_entityID=new FilterPredicate(EntityName,
    FilterOperator.EQUAL, entityID);

                Filter filter_min_lngt=new
    FilterPredicate("lng", FilterOperator.EQUAL, SSID);

                Filter filter=new
    CompositeFilter(CompositeFilterOperator.AND,Arrays.asList(filter_entityID,filte
    r_min_lngt));

                q.setFilter(filter);

                PreparedQuery pq = datastore.prepare(q);
                return pq.asIterable();


    }
    public Iterable<Entity> GetJSONForEntitiyNearByUsingBounds(float
    lng,float lat,GeoLocation.GeoLocationBoundry bound)
    {
        DatastoreService datastore =
    DatastoreServiceFactory.getDatastoreService();

        Filter filter_min_lngt=new FilterPredicate("lng",
    FilterOperator.LESS_THAN, bound.lng1);
        Filter filter_max_lngt=new FilterPredicate("lng",
    FilterOperator.LESS_THAN, bound.lng2);
        Filter filter_min_lat=new FilterPredicate("lat",
    FilterOperator.GREATER_THAN, bound.lat1);
        Filter filter_max_lat=new FilterPredicate("lat",
    FilterOperator.LESS_THAN, bound.lat2);

        Filter filter_lng=new
    CompositeFilter(CompositeFilterOperator.AND,Arrays.asList(filter_min_lngt,filte
    r_max_lngt));
        Filter filter_lat=new
    CompositeFilter(CompositeFilterOperator.AND,Arrays.asList(filter_min_lat,filter
    _max_lat));


        Filter filter=new
    CompositeFilter(CompositeFilterOperator.AND,Arrays.asList(filter_lng,filter_lat
    ));

        q.setFilter(filter);

        PreparedQuery pq = datastore.prepare(q);


        return pq.asIterable();
    }
    }

package com.linkedlive.business；
导入java.io.IOException；
导入java.util.Iterator；
导入javax.servlet.http.*；
导入org.json.JSONArray；
导入org.json.JSONObject；
导入com.biomedica.server.geolocation.geolocation；
导入com.biomedica.server.searchtools.searchForgeOlocentiy；
导入com.google.appengine.api.datastore.DatastoreService；
导入com.google.appengine.api.datastore.DatastoreServiceFactory；
导入com.google.appengine.api.datastore.Entity；
导入com.google.appengine.api.datastore.KeyFactory；
@抑制警告（“串行”）
公共类场馆扩展HttpServlet{
公共无效数据集（HttpServletRequest请求、HttpServletResponse响应）
抛出IOException{
这是doPost（请求、响应）；
}
public void doPost（HttpServletRequest-req、HttpServletResponse-resp）
抛出IOException{
数据存储服务数据存储=
DatastoreServiceFactory.getDatastoreService（）；
字符串cmd=req.getParameter（“cmd”）；
如果（cmd.equals（“Venunearby”））
{
地理位置=新地理位置（）；
searchForgeOlocentiy搜索=新建
SearchForGeolocEntitiy（“accounts”）；//这是我创建的一个类，用于设置
查询过滤器见下文
//获取请求参数
float lat=float.valueOf（要求获取参数（“lat”））；
浮动lng=浮动数值（要求获取参数（“lng”））；
float rad=float.valueOf（请求获取参数（“rad”））；
//计算距离
可迭代的
ent=search.getJSONForentiyNearByUsingBounds（lat，
液化天然气，地理位置getGeoLocationBounds（纬度、液化天然气、弧度）；
迭代器i=ent.Iterator（）；
JSONObject json=新的JSONObject（）；
JSONArray injson=新的JSONArray（）；
put（“result”、“venuenearby”）；
while（i.hasNext（））
{
试一试{
JSONObject j=新的JSONObject（）；
实体t=i.next（）；
j、 放置（“键”，
keyToString（t.getKey（））；
j、 put（“用户ID”，
t、 getProperty（“userid”）；
j、 放置（“文件路径”，
t、 getProperty（“文件路径”）；
injson.put（j）；
}捕获（NullPointerException e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
}
json.put（“body”，injson）；
resp.getWriter（）.write（json.toString（））；
}
}
}
///////////////////////////////////////////////////////////////////////////////
////////////////////
//////////////////////////色差
////////////////////////////////////
包com.biomedica.server.searchtools；
导入java.lang.reflect.Array；
导入java.util.array；
导入com.biomedica.server.geolocation.geolocation；
导入com.google.appengine.api.datastore.DatastoreService；
导入com.google.appengine.api.datastore.DatastoreServiceFactory；
导入com.google.appengine.api.datastore.Entity；
导入com.google.appengine.api.datastore.PreparedQuery；
导入com.google.appengine.api.datastore.Query；
导入com.google.appengine.api.datastore.Query.CompositeFilterOperator；
导入com.google.appengine.api.datastore.Query.Filter；
导入com.google.appengine.api.datastore.Query.FilterOperator；
导入com.google.appengine.api.datastore.Query.FilterPredicate；
导入com.google.appengine.api.datastore.Query.CompositeFilter；
公共类搜索{
私有字符串实体名称；
私有查询q；
public SearchForGeolocEntitiy（字符串名称）
{
EntitiyName=名称；
q=新查询（名称）；
}
公共Iterable GetJSonForentiyNearby（双朗，双
横向、双弧度、整数最大值（结果）
{
数据存储服务数据存储=
DatastoreServiceFactory.getDatastoreService（）；
//去斜滤器对象
过滤器过滤器\u最小\u lngt=新
过滤器预测（“lng”，过滤器操作员大于，朗拉德）；
过滤器过滤器\u max\u lngt=新
过滤器预测（“lng”，过滤器操作器小于，lang+rad）；
过滤器过滤器\u min\u lat=新
过滤器预测（“lat”，过滤器操作员大于，lat rad）；
过滤器过滤器\u max\u lat=新
过滤器预测（“lat”，过滤器操作员小于，lat+rad）；
过滤器=新的
CompositeFilter（CompositeFilterOperator.AND，Arrays.asList（filter\u min\u lngt，filte
r_max_lngt）；
过滤器过滤器=新的
CompositeFilter（CompositeFilterOperator.AND，Arrays.asList（filter\u min\u lat，filter
_马克斯·拉特）；
过滤器=新的
CompositeFilter（CompositeFilterOperator.AND，Arrays.asList（filter\u lng，filter\u lat
));
q、 设置过滤器（过滤器）；
PreparedQuery pq=数据存储。prepare（q）；
返回pq.asIterable（）；
}
公共Iterable GetJSonForentiyNearByUsingSSID（字符串
EntityName、字符串entityID、字符串SSID）
{
数据存储服务数据存储=
DatastoreServiceFactory.getDatastoreService（）；
//去斜滤器对象
Filter Filter\u entityID=新的FilterPredicate（EntityName，
FilterOperator.EQUAL，entityID）；
过滤器过滤器\u最小\u lngt=新
过滤器预测（“lng”，过滤器操作员，同等，SSID）；
过滤器=新的
CompositeFilter（CompositeFilterOperator.AND，Arrays.asList（filter\u entityID，filte
r_min_lngt）；
q、 硒