基于Java的HTTP图像传输

Question

希望在堆栈溢出方面的Java专家能够提供一些启示：

我们通过序列化映像(在将其转换为Java类型之后)成功地发送图像，但是序列化的IO似乎很昂贵( readObject()，writeObject())，因为我们一直在碰到servlet容器中的"java.lang.OutOfMemoryError: Java堆空间“错误。

是否有更好的方法在Java中通过HTTP传输图像文件？

该应用程序使用Java机器人类通过servlet不断地向多个客户端发送桌面映像(以方便HTTP传输)。听起来已经是很好的建议了，让我发布一些代码，为我的项目提供一个想法。我必须使用Java (在使用servlet的web上)，我的工作依赖于这个...please帮助.

添加来自组件___________的关键代码摘录的__

I. ClientApplet (捕获桌面图像(通过套接字向中央ImageBroker发送序列化)

-> II. ImageBroker (通过套接字从ClientApplet读取序列化的图像，并将其发送到servlet，使其可供使用)

-> III. ViewerServlet通过ViewerServlet将图像转发给applets

-> IV.Applet读取序列化图像

// I. Client Applet
// (sends serialized desktop images to ImageBroker server over TCP sockets )

class ScreenShoot extends Thread {

Socket socket = null;
Robot robot = null; // Used to capture screen
Rectangle rectangle = null; //Used to represent screen dimensions
boolean continueLoop = true; //Used to exit the program

public ScreenShoot(Socket socket, Robot robot, Rectangle rect) {
    this.socket = socket;
    this.robot = robot;
    rectangle = rect;
    start();
}

public void run() {
    ObjectOutputStream oos = null; //Used to write an object to the streem
    try {
        //Prepare ObjectOutputStream
        oos = new ObjectOutputStream(socket.getOutputStream());
    } catch (IOException ex) {
        ex.printStackTrace();
    }

    String Userid = "test";
    String ConfId = "ONE";

    MyClass sendHeader = new MyClass(Userid,ConfId, 300, 300, 20, 30);
    System.out.println("sendHeader: " + sendHeader);

// Send the header (username, ConferenceID) first before sending the images
    try {
        oos.writeObject(sendHeader);
        System.out.println("sent HEADER object1: ");
    } catch (IOException ex) {
        ex.printStackTrace();
    }

    int countRec = 1;
    while (continueLoop) {
        //Capture screen
        BufferedImage image = robot.createScreenCapture(rectangle);
        /* I have to wrap BufferedImage with ImageIcon because BufferedImage class
         * does not implement Serializable interface
         */
        ImageIcon imageIcon = new ImageIcon(image);

        //Send captured screen to the server

        try {
            System.out.println("ScreenSpyer:before sending image-writeObject");
        //     oos.writeObject(imageIcon);
            oos.writeUnshared(imageIcon);
            countRec++;
            if (countRec > 20 ) {
             oos.reset(); //Clear ObjectOutputStream cache
             countRec = 1;
            }
            System.out.println("ScreenSpyer: New screenshot sent");
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        //wait for 1000ms to redu/ e network traffic
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

II.Central ImageBroker Server Broker通过TCP套接字处理来自不同发送方的图像，并将它们传输到右查看器(通过servlet)，-Receives图像来自客户端屏幕小程序-将序列化的图像转发给ViewerServlet。

// Section READING the incoming images ( this is over simple TCP Sockets)
class HandleSenders extends Thread {
  private Socket socket = null;
  private WinTest mainprog;
  private MessageBin source;
  private InputStream fromServer = null; 

  public HandleSenders(WinTest mainprog, Socket socket, MessageBin source) {
    super("HandleSenders");
    this.socket = socket;
    this.mainprog = mainprog;
this.source = source;

  }

 // getNextMessage() returns the next new message.
 // It blocks until there is one.

 public String getNextMessage() {
  // Create a message sink to wait for a new message from the
  // message source.
  return new MessageHold().getNextMessage(source);
 }

public void run() {
    // Reading Images from SnreenSender client 
    ObjectInputStream in = null;

byte[] buffer = new byte[256];
int fromServer_val, backup_val =0 ;

    try {
        // in = new ObjectInputStream(socket.getInputStream());
        fromServer = socket.getInputStream();    
    in = new  ObjectInputStream(fromServer);
    boolean forever = true;
        int cntr = 1;
        boolean contin = true;
        int counter = 1;

        boolean Found = false;
    String theMessage = "";
    while (contin) {
            // if (cntr++ > 5) break;
            // fromServer_val = fromServer.read(buffer);
            // dealing with null values which crashes the system,
            // if for some problem in transmission you get a null, we just put the 
            // previous valid data
            // into the null one.


     ImageIcon imageIcon = (ImageIcon)in.readObject();

     Found = mainprog.FindViewersAndSend(senderHeader.confid, imageIcon);



    // Blocks first time and only if the structure has no 
            // clients for this sender

            if (!Found)
            theMessage = getNextMessage(); //blocks

处理将映像发送到servlet的部分

 public boolean FindViewersAndSend(String confid, ImageIcon imageIcon) {
Iterator it = socketMap.entrySet().iterator();
ObjectOutputStream viewerOut = null;
byte[] buffer = new byte[256];
Socket viewerClient = null;
OutputStream toClient = null;
boolean Found = false;
int recordCount = 1;
try {
   while (it.hasNext()) {
       // Iterating through structures of Viewer servlet socket connections 
       Map.Entry pairs = (Map.Entry)it.next();
   socketUserStruct = getSocketDetails((String)pairs.getKey());
   if ( socketUserStruct != null && !socketUserStruct.equals ("")) {
    StructConfId = (String)socketUserStruct.getConfId();
    StructUserId = (String)pairs.getKey();
       }
   if (StructConfId.equals(confid)) {
          Found = true;
          viewerOut = (ObjectOutputStream)socketUserStruct.getObjectOutputStream();
          // write the serialized data to the servlet....
          // which in turn sends it to the applet over http
          // viewerOut.writeObject(imageIcon);

          viewerOut.writeUnshared(imageIcon);

          recordCount++;   
          if (recordCount > 10) {
                 viewerOut.flush();
                 recordCount = 0;
          }
   }    
    }
} 
catch (IOException e) 
{      /// clean up
        removeSocketClient(StructUserId);

 }
return Found;

}

III. ViewerServlet -从images获取图像并将序列化的映像发送给Applets (通过http)

public void doGet(HttpServletRequest req,
                  HttpServletResponse res) throws ServletException,

    Socket echoSocket = null;
    PrintWriter out = null;
    InputStream fromServer = null;
    byte[] buffer = new byte[256];
    int fromServer_val, backup_val = 0;

    // OutputStream toClient = res.getOutputStream();
    try {
        echoSocket = new Socket("localhost", RES_PORT);
        out = new PrintWriter(echoSocket.getOutputStream(), true);

        String screensize = "300";
        String viewerHeader = userid+","+confid+","+screensize;  
        out.println(viewerHeader);

        out.println("bye");
        out.flush();
      InputStream is = echoSocket.getInputStream();
      ObjectInputStream in = new ObjectInputStream(is);
      ObjectOutputStream oos = new ObjectOutputStream(res.getOutputStream());


        try {
           int recordCount = 1;
            while (true) {

              ImageIcon imageIcon = (ImageIcon)in.readObject();
              oos.writeObject(imageIcon); 
                if (recordCount++ > 5) {
                    recordCount = 1;
                    oos.flush();
                }
                // oos.flush();


            }
        } catch (ClassNotFoundException e) {
                   .......                   
        } catch (IOException ex) {
            ex.printStackTrace();


        }




    } catch (IOException e) { // show("plainViewAdapter-doGet:4");
        fromServer.close();
    }

}

查看器小程序(连接到Viewer Servlet以接收图像)

public void start() {
    try {

        String url_string =
            "http://" + winsellahost + ":" + winsellaport + "/BrowserShare  
             /viewerproxyservlet" +
            "?userid=viewer1&confid=ONE";
        URL url = new URL(url_string);
        InputStream is = url.openConnection().getInputStream();
        ObjectInputStream in = new ObjectInputStream(is);
        boolean firstTime = true;

        while (continueLoop) {

          show("5");
            //Recve client screenshot and resize it to the current panel size

            ImageIcon imageIcon = (ImageIcon)in.readObject();
            // in.reset();
            Image image = imageIcon.getImage();
            image =
                    image.getScaledInstance(cPanel.getWidth(), cPanel.getHeight(),
                                            Image.SCALE_FAST);
            //Draw the received screenshot


        }
        in.close();
        is.close();

    } catch (IOException ex) {
        ex.printStackTrace();

    } catch (ClassNotFoundException ex) {
        ex.printStackTrace();
    }


}

Answer 1

不要序列化到对象。

序列化PNG映像OutputStream中的Bufferedimage，并从InputStream读取它的另一侧。

使用ImageIO.write序列化它，使用ImageIO.read反序列化它。

http://docs.oracle.com/javase/6/docs/api/javax/imageio/ImageIO.html

安东尼