Java Play 2.2中的慢速块响应

在基于MyPlay框架的web应用程序中，用户可以下载csv或json格式的不同数据库表的所有行。表相对较大（100k+行），我正在尝试使用Play2.2中的分块来返回结果

然而问题是，尽管println语句显示行被写入Chunks.Out对象，但它们不会显示在客户端！如果我限制返回的行数，它将起作用，但在开始时也会有很大的延迟，如果我尝试返回所有行，则延迟会更大，并导致超时或服务器内存不足

我使用ebeanorm，表被索引，从psql查询不需要太多时间。有人知道可能是什么问题吗

我非常感谢你的帮助

以下是其中一个控制器的代码：

@SecureSocial.UserAwareAction
public static Result showEpex() {

    User user = getUser();
    if(user == null || user.getRole() == null)
        return ok(views.html.profile.render(user, Application.NOT_CONFIRMED_MSG));

    DynamicForm form = DynamicForm.form().bindFromRequest();
    final UserRequest req = UserRequest.getRequest(form);

    if(req.getFormat().equalsIgnoreCase("html")) {
        Page<EpexEntry> page = EpexEntry.page(req.getStart(), req.getFinish(), req.getPage());
        return ok(views.html.epex.render(page, req));
    }

    // otherwise chunk result and send back
    final ResultStreamer<EpexEntry> streamer = new ResultStreamer<EpexEntry>();
    Chunks<String> chunks = new StringChunks() {
            @Override
            public void onReady(play.mvc.Results.Chunks.Out<String> out) {

                Page<EpexEntry> page = EpexEntry.page(req.getStart(), req.getFinish(), 0);
                ResultStreamer<EpexEntry> streamer = new ResultStreamer<EpexEntry>();
                streamer.stream(out, page, req);
            }
    };
    return ok(chunks).as("text/plain");
}

@SecureSocial.userawa
公共静态结果showEpex（）{
User=getUser（）；
if（user==null | | user.getRole（）==null）
返回ok（views.html.profile.render（用户、应用程序、未确认消息））；
DynamicForm form=DynamicForm.form（）.bindFromRequest（）；
最终UserRequest req=UserRequest.getRequest（表单）；
if（req.getFormat（）.equalsIgnoreCase（“html”））{
Page Page=EpexEntry.Page（req.getStart（），req.getFinish（），req.getPage（））；
返回ok（views.html.epex.render（page，req））；
}
//否则，将结果分块并发送回
最终结果streamer拖缆=新结果streamer（）；
Chunks Chunks=新的StringChunks（）{
@凌驾
public void onReady（play.mvc.Results.Chunks.Out）{
Page Page=EpexEntry.Page（req.getStart（），req.getFinish（），0）；
ResultStreamer streamer=新的ResultStreamer（）；
拖缆流（输出，第页，要求）；
}
};
返回ok（块）.as（“文本/普通”）；
}

和拖缆：

public class ResultStreamer<T extends Entry> {

private static ALogger logger = Logger.of(ResultStreamer.class);

public void stream(Out<String> out, Page<T> page, UserRequest req) {

    if(req.getFormat().equalsIgnoreCase("json")) {
        JsonContext context = Ebean.createJsonContext();
        out.write("[\n");
        for(T e: page.getList())
            out.write(context.toJsonString(e) + ", ");
        while(page.hasNext()) {
            page = page.next();
            for(T e: page.getList())
                out.write(context.toJsonString(e) + ", ");
        }
        out.write("]\n");
        out.close();
    } else if(req.getFormat().equalsIgnoreCase("csv")) {
        for(T e: page.getList())
            out.write(e.toCsv(CSV_SEPARATOR) + "\n");
        while(page.hasNext()) {
            page = page.next();
            for(T e: page.getList())
                out.write(e.toCsv(CSV_SEPARATOR) + "\n");
        }
        out.close();
    }else {
        out.write("Invalid format! Only CSV, JSON and HTML can be generated!");
        out.close();
    }
}


public static final String CSV_SEPARATOR = ";";
} 

公共类ResultStreamer{
私有静态ALogger logger=logger.of（ResultStreamer.class）；
公共无效流（Out Out、Page Page、UserRequest req）{
if（req.getFormat（）.equalsIgnoreCase（“json”））{
JsonContext context=Ebean.createJsonContext（）；
输出。写入（“[\n”）；
对于（te:page.getList（））
out.write（context.toJsonString（e）+“，”）；
while（page.hasNext（））{
page=page.next（）；
对于（te:page.getList（））
out.write（context.toJsonString（e）+“，”）；
}
out.write（“]\n”）；
out.close（）；
}else if（req.getFormat（）.equalsIgnoreCase（“csv”））{
对于（te:page.getList（））
out.write（e.toCsv（CSV_分隔符）+“\n”）；
while（page.hasNext（））{
page=page.next（）；
对于（te:page.getList（））
out.write（e.toCsv（CSV_分隔符）+“\n”）；
}
out.close（）；
}否则{
write（“格式无效！只能生成CSV、JSON和HTML！”）；
out.close（）；
}
}
公共静态最终字符串CSV_分隔符=“；”；
} 

模型：

@Entity
@Table(name="epex")
public class EpexEntry extends Model implements Entry {

    @Id
    @Column(columnDefinition = "pg-uuid")
    private UUID id;
    private DateTime start;
    private DateTime finish;
    private String contract;
    private String market;
    private Double low;
    private Double high;
    private Double last;
    @Column(name="weight_avg")
    private Double weightAverage;
    private Double index;
    private Double buyVol;
    private Double sellVol;

    private static final String START_COL = "start";
    private static final String FINISH_COL = "finish";
    private static final String CONTRACT_COL = "contract";
    private static final String MARKET_COL = "market";
    private static final String ORDER_BY = MARKET_COL + "," + CONTRACT_COL + "," + START_COL;

    public static final int PAGE_SIZE = 100;

    public static final String HOURLY_CONTRACT = "hourly";
    public static final String MIN15_CONTRACT = "15min";

    public static final String FRANCE_MARKET = "france";
    public static final String GER_AUS_MARKET = "germany/austria";
    public static final String SWISS_MARKET = "switzerland";

    public static Finder<UUID, EpexEntry> find = 
            new Finder(UUID.class, EpexEntry.class);

    public EpexEntry() {
    }

    public EpexEntry(UUID id, DateTime start, DateTime finish, String contract,
            String market, Double low, Double high, Double last,
            Double weightAverage, Double index, Double buyVol, Double sellVol) {
        this.id = id;
        this.start = start;
        this.finish = finish;
        this.contract = contract;
        this.market = market;
        this.low = low;
        this.high = high;
        this.last = last;
        this.weightAverage = weightAverage;
        this.index = index;
        this.buyVol = buyVol;
        this.sellVol = sellVol;
    }

    public static Page<EpexEntry> page(DateTime from, DateTime to, int page) {

        if(from == null && to == null)
            return find.order(ORDER_BY).findPagingList(PAGE_SIZE).getPage(page);
        ExpressionList<EpexEntry> exp = find.where();
        if(from != null)
            exp = exp.ge(START_COL, from);
        if(to != null)
            exp = exp.le(FINISH_COL, to.plusHours(24));
        return exp.order(ORDER_BY).findPagingList(PAGE_SIZE).getPage(page);
    }

    @Override
    public String toCsv(String s) {
        return id + s + start + s + finish + s + contract + 
                s + market + s + low + s + high + s + 
                last + s + weightAverage + s + 
                index + s + buyVol + s + sellVol;   
    }

@实体
@表（name=“epex”）
公共类EpexEntry扩展模型实现入口{
@身份证
@列（columnDefinition=“pg uuid”）
私有UUID；
私有日期时间开始；
私人约会时间完成；
私人串合同；
私人市场；
私人双低；
私人双高；
私人双末；
@列（名称=“平均重量”）
私人双重平均；
私人双指数；
私人双重购买；
私人双重销售；
私有静态最终字符串START\u COL=“START”；
私有静态最终字符串FINISH\u COL=“FINISH”；
私有静态最终字符串合同\u COL=“合同”；
私有静态最终字符串市场\u COL=“市场”；
私有静态最终字符串订单\按=市场\列+”，“+合同\列+”，“+开始\列；
公共静态最终整版页面大小=100；
公共静态最终字符串HOURLY\u CONTRACT=“HOURLY”；
公共静态最终字符串MIN15_CONTRACT=“15min”；
公共静态最终字符串FRANCE_MARKET=“FRANCE”；
公共静态最终字符串geru AUS_MARKET=“德国/奥地利”；
公共静态最终字符串SWISS_MARKET=“swissand”；
公共静态查找器查找=
新查找程序（UUID.class、EpexEntry.class）；
公共电子出口{
}
公共EpexEntry（UUID id、DateTime start、DateTime finish、String contract、，
弦乐市场，双低，双高，双末，
双权重平均、双指数、双买入量、双卖出量）{
this.id=id；
this.start=start；
this.finish=完成；
本合同=合同；
这个市场=市场；
这个.低=低；
这个高=高；
this.last=last；
this.weightAverage=weightAverage；
这个指数=指数；
this.buyVol=buyVol；
this.sellVol=sellVol；
}
公共静态页面（DateTime-from、DateTime-to、int-Page）{
if（from==null&&to==null）
返回find.order（order_BY）.findPagingList（PAGE_SIZE）.getPage（PAGE）；
ExpressionList exp=find.where（）；
if（from！=null）
exp=exp.ge（起始列，起始）；
如果（到！=null）
exp=exp.le（饰面颜色，至plusHours（24））；
返回exp.order（order_BY）.findPagingList（PAGE_SIZE）.getPage（PAGE）；
}
@凌驾
公共字符串toCsv（字符串s）{
返回id+s+开始+s+结束+s+合同+
s+市场+s+低+s+高+s+
最后+s+权重平均值+s+
指数+s+buyVol+s+sellVol；
}

1.大多数浏览器在显示任何结果之前都会等待1-5 kb的数据。您可以使用命令

curl检查Play Framework是否确实发送数据http://localhost:9000

2.创建拖缆两次，首先删除

final ResultStreamer streamer=new ResultStreamer（）；
public static QueryIterator<EpexEntry> all() {
    return find.order(ORDER_BY).findIterate();
}

public void stream(Out<String> out, QueryIterator<T> iterator, UserRequest req) {

    if(req.getFormat().equalsIgnoreCase("json")) {
        JsonContext context = Ebean.createJsonContext();
        out.write("[\n");
        while (iterator.hasNext()) {
            out.write(context.toJsonString(iterator.next()) + ", ");
        }
        iterator.close(); // its important to close iterator
        out.write("]\n");
        out.close();
    } else // csv implementation here

            QueryIterator<EpexEntry> iterator = EpexEntry.all();
            ResultStreamer<EpexEntry> streamer = new ResultStreamer<EpexEntry>();
            streamer.stream(new BuffOut(out, 10000), iterator, req); // notice buffering here

public class Application extends Controller {
    public static Result showEpex() {
        Chunks<String> chunks = new StringChunks() {
            @Override
            public void onReady(play.mvc.Results.Chunks.Out<String> out) {
                new ResultStreamer().stream(out);
            }
        };
        return ok(chunks).as("text/plain");
    }
}

public class BuffOut {
    private StringBuilder sb;
    private Out<String> dst;

    public BuffOut(Out<String> dst, int bufSize) {
        this.dst = dst;
        this.sb = new StringBuilder(bufSize);
    }

    public void write(String data) {
        if ((sb.length() + data.length()) > sb.capacity()) {
            dst.write(sb.toString());
            sb.setLength(0);
        }
        sb.append(data);
    }

    public void close() {
        if (sb.length() > 0)
            dst.write(sb.toString());
        dst.close();
    }
}

public class ResultStreamer {
    public void stream(Out<String> out) {
    for (int i = 0; i < 10000; i++) {
            out.write("TEST" + i + "\n");
        }
        out.close();
    }
}

public class ResultStreamer {
    public void stream(Out<String> out) {
        BuffOut out2 = new BuffOut(out, 1000);
        for (int i = 0; i < 10000; i++) {
            out2.write("TEST" + i + "\n");
        }
        out2.close();
    }
}