एक HttpServletResponse

Question

पर एक इनपुटस्ट्रीम लिखें मेरे पास एक इनपुटस्ट्रीम है जिसे मैं एक HttpServletResponse पर लिखना चाहता हूं। वहाँ बाइट के उपयोग के कारण इस दृष्टिकोण है, जो बहुत समय लगता है है []

InputStream is = getInputStream(); 
int contentLength = getContentLength(); 

byte[] data = new byte[contentLength]; 
is.read(data); 

//response here is the HttpServletResponse object 
response.setContentLength(contentLength); 
response.write(data); 

मैं सोच रहा था क्या संभवतः यह करने के लिए सबसे अच्छा तरीका हो सकता है की गति और दक्षता के मामले में,।

Answer 1

बस इसे पूरी तरह से जावा की स्मृति में कॉपी करने के बजाय ब्लॉक में लिखें। नीचे मूल उदाहरण इसे 10 केबी के ब्लॉक में लिखता है। इस तरह आप पूरी सामग्री लंबाई के बजाय केवल 10 केबी के लगातार स्मृति उपयोग के साथ समाप्त होते हैं। इसके अलावा एंडुसर सामग्री के कुछ हिस्सों को जल्द से जल्द शुरू कर देगा।

response.setContentLength(getContentLength()); 
byte[] buffer = new byte[10240]; 

try (
    InputStream input = getInputStream(); 
    OutputStream output = response.getOutputStream(); 
) { 
    for (int length = 0; (length = input.read(buffer)) > 0;) { 
     output.write(buffer, 0, length); 
    } 
} 

---

creme de la creme के रूप में प्रदर्शन के संबंध में, आप NIO Channels इस्तेमाल कर सकते हैं और एक सीधे ByteBuffer आवंटित। कुछ कस्टम उपयोगिता वर्ग में निम्न उपयोगिता/सहायक विधि बनाएं, उदा। Utils:

public static long stream(InputStream input, OutputStream output) throws IOException { 
    try (
     ReadableByteChannel inputChannel = Channels.newChannel(input); 
     WritableByteChannel outputChannel = Channels.newChannel(output); 
    ) { 
     ByteBuffer buffer = ByteBuffer.allocateDirect(10240); 
     long size = 0; 

     while (inputChannel.read(buffer) != -1) { 
      buffer.flip(); 
      size += outputChannel.write(buffer); 
      buffer.clear(); 
     } 

     return size; 
    } 
} 

जो तुम तो नीचे के रूप में उपयोग करें: मैं, बाइट [] के उपयोग से बचने के लिए वान

response.setContentLength(getContentLength()); 
Utils.stream(getInputStream(), response.getOutputStream()); 

Answer 2

BufferedInputStream in = null; 
BufferedOutputStream out = null; 
OutputStream os; 
os = new BufferedOutputStream(response.getOutputStream()); 
in = new BufferedInputStream(new FileInputStream(file)); 
out = new BufferedOutputStream(os); 
byte[] buffer = new byte[1024 * 8]; 
int j = -1; 
while ((j = in.read(buffer)) != -1) { 
    out.write(buffer, 0, j); 
} 

Answer 3

मुझे लगता है कि यह सबसे अच्छा तरीका है, लेकिन मैं निम्नलिखित परिवर्तन का सुझाव दूंगा। एक निश्चित आकार बफर का उपयोग करें (20K कहें) और फिर लूप में पढ़ने/लिखें। , आपका कार्यक्रम हमेशा उसी रूप में काम नहीं करेगा क्योंकि पढ़ने हमेशा पूरे सरणी आप इसे देने को भरने नहीं है:

पाश के लिए की तरह

Byte buffer[]=new byte[20*1024]; 
outputStream=response.getOutputStream(); 
while(true) { 
    int readSize=is.read(buffer); 
    if(readSize==-1) 
    break; 
    outputStream.write(buffer,0,readSize); 
} 

ps कुछ करना।