Compressing data through URLConnection

Question

I was looking into to the URLConnection and try to get a way to configure the connection(set my own sockets so that I can compress data going back and forth) similar to the way RMI handles this issue by providing clientSocketFactory, and serversocketFactory to UnicastRemoteObject. It seems there is no way to do that. I know I can specify URLStreamHandlerFactory but that does not seem to do what I am looking for.
I am looking for a way to control the underlying communication mechanism in which the connection I get from URL.openConnection() uses. That is possible if the API would provide a way to pass <mechanism>Factories to the URL. if any one has a solution to this please email it to me.
I will give you some code to see what I am talking about.
//Servlet
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class DataCruncherServlet extends HttpServlet {
public void init(ServletConfig config) throws ServletException {
super.init(config);
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
doPost(req, res);
public void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
ServletInputStream in = req.getInputStream();
InputStreamReader inr = new InputStreamReader(in);
StringBuffer sb = new StringBuffer();
char data[] = new char[1024];
while( inr.read(data) != -1 ) {
sb.append(new String(data));
OutputStream out = res.getOutputStream();
out.write(sb.toString().getBytes());
in.close();
inr.close();
out.close();
//For The client
import java.net.*;
import java.io.*;
public class DataCruncherClient {
public static void main(String[] args) {
URL fileURL = null;
URLConnection con = null;
StringBuffer buffer = null;
OutputStream out = null;
BufferedReader br = null;
InputStreamReader in = null;
try {
fileURL = new URL("http://localhost:8000/myContext/DataCruncherServlet");
//There is no way to control the underlying communication mechanism(sockets rmi, ...)
//connection we get uses.
con = fileURL.openConnection();
con.setDoOutput(true);
con.setDoInput(true);
out = con.getOutputStream();
br = new BufferedReader(new FileReader("test.txt"));
StringBuffer sb = new StringBuffer();
String line = null;
while( (line = br.readLine()) != null){
sb.append(line);
out.write(sb.toString().getBytes());
in = new InputStreamReader(con.getInputStream());
char data[] = new char[1024];
buffer = new StringBuffer();
while( in.read(data) != -1 ) {
buffer.append(new String(data));
catch(MalformedURLException me) {
System.out.println("MalFormed URLException: "+me.getMessage());
catch(FileNotFoundException fe) {
System.out.println("File Not Found: "+fe.getMessage());
catch(IOException ioex){
System.out.println("IOEXception: "+ioex.getMessage());
finally{
try {
out.close();
br.close();
in.close();
catch(IOException ioex) {
System.out.println("can not close stream: "+ioex.getMessage());
System.out.println("Returned from Servlet is: ");
System.out.println(buffer.toString());
email me :[email protected]

Answer 1

s.append(char[]) and s.append(char[], int, int) are
similar each one is converted into string throught
String.valueOf(char[]) and String.valueOf(char[], int,
int) respectively then it is appended to the
s(stringBuffer) so I do not see why one is more
efficient Than the other, please explain.from the implementation of StringBuffer:
    public synchronized StringBuffer append(char str[], int offset, int len) {
        int newcount = count + len;
     if (newcount > value.length)
         expandCapacity(newcount);
     System.arraycopy(str, offset, value, count, len);
     count = newcount;
     return this;
    }where do you see conversion to String? typically you do multiple appends and then one StringBuffer.toString(). this is different from creating a String on every append.
Using Zip streams can fix the particular problem I
outlined but I was thinking about a way to control
the underlying communication mechanizim in which the
connection(URLConnection) depend on.so you wanted to hide the compression inside of URL.openStream()?
robert