Форум программистов [Powered by Invision Power Board]

Код


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

Код


HttpServlet

Код


public class LibraryServiceImpl extends RemoteServiceServlet implements LibraryService {.....}

Код


 public final void doPost(HttpServletRequest request, HttpServletResponse response) {

Код



package com.google.gwt.user.server.rpc;

import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
import com.google.gwt.user.client.rpc.SerializationException;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class RemoteServiceS extends HttpServlet implements
    SerializationPolicyProvider {

  private final ThreadLocal<HttpServletRequest> perThreadRequest = new ThreadLocal<HttpServletRequest>();

  private final ThreadLocal<HttpServletResponse> perThreadResponse = new ThreadLocal<HttpServletResponse>();

  private final Map<String, SerializationPolicy> serializationPolicyCache = new HashMap<String, SerializationPolicy>();

  public RemoteServiceS() {
  }

  @Override
  public final void doPost(HttpServletRequest request,
      HttpServletResponse response) {
    try {
      // Store the request & response objects in thread-local storage.
      //
      perThreadRequest.set(request);
      perThreadResponse.set(response);

      // Read the request fully.
      //
      String requestPayload = readContent(request);

      // Let subclasses see the serialized request.
      //
      onBeforeRequestDeserialized(requestPayload);

      // Invoke the core dispatching logic, which returns the serialized
      // result.
      //
      String responsePayload = processCall(requestPayload);

      // Let subclasses see the serialized response.
      //
      onAfterResponseSerialized(responsePayload);

      // Write the response.
      //
      writeResponse(request, response, responsePayload);
      return;
    } catch (Throwable e) {
      // Give a subclass a chance to either handle the exception or rethrow it
      //
      doUnexpectedFailure(e);
    } finally {
      // null the thread-locals to avoid holding request/response
      //
      perThreadRequest.set(null);
      perThreadResponse.set(null);
    }
  }

  public final SerializationPolicy getSerializationPolicy(String moduleBaseURL,
      String strongName) {

    SerializationPolicy serializationPolicy = getCachedSerializationPolicy(
        moduleBaseURL, strongName);
    if (serializationPolicy != null) {
      return serializationPolicy;
    }

    serializationPolicy = doGetSerializationPolicy(getThreadLocalRequest(),
        moduleBaseURL, strongName);

    if (serializationPolicy == null) {
      // Failed to get the requested serialization policy; use the default
      log(
          "WARNING: Failed to get the SerializationPolicy '"
              + strongName
              + "' for module '"
              + moduleBaseURL
              + "'; a legacy, 1.3.3 compatible, serialization policy will be used.  You may experience SerializationExceptions as a result.",
          null);
      serializationPolicy = RPC.getDefaultSerializationPolicy();
    }

    // This could cache null or an actual instance. Either way we will not
    // attempt to lookup the policy again.
    putCachedSerializationPolicy(moduleBaseURL, strongName, serializationPolicy);

    return serializationPolicy;
  }

  public String processCall(String payload) throws SerializationException {
    try {
      RPCRequest rpcRequest = RPC.decodeRequest(payload, this.getClass(), this);
      onAfterRequestDeserialized(rpcRequest);
      return RPC.invokeAndEncodeResponse(this, rpcRequest.getMethod(),
          rpcRequest.getParameters(), rpcRequest.getSerializationPolicy());
    } catch (IncompatibleRemoteServiceException ex) {
      log(
          "An IncompatibleRemoteServiceException was thrown while processing this call.",
          ex);
      return RPC.encodeResponseForFailure(null, ex);
    }
  }

  protected SerializationPolicy doGetSerializationPolicy(
      HttpServletRequest request, String moduleBaseURL, String strongName) {
    // The request can tell you the path of the web app relative to the
    // container root.
    String contextPath = request.getContextPath();

    String modulePath = null;
    if (moduleBaseURL != null) {
      try {
        modulePath = new URL(moduleBaseURL).getPath();
      } catch (MalformedURLException ex) {
        // log the information, we will default
        log("Malformed moduleBaseURL: " + moduleBaseURL, ex);
      }
    }

    SerializationPolicy serializationPolicy = null;

    /*
     * Check that the module path must be in the same web app as the servlet
     * itself. If you need to implement a scheme different than this, override
     * this method.
     */
    if (modulePath == null || !modulePath.startsWith(contextPath)) {
      String message = "ERROR: The module path requested, "
          + modulePath
          + ", is not in the same web application as this servlet, "
          + contextPath
          + ".  Your module may not be properly configured or your client and server code maybe out of date.";
      log(message, null);
    } else {
      // Strip off the context path from the module base URL. It should be a
      // strict prefix.
      String contextRelativePath = modulePath.substring(contextPath.length());

      String serializationPolicyFilePath = SerializationPolicyLoader.getSerializationPolicyFileName(contextRelativePath
          + strongName);

      // Open the RPC resource file read its contents.
      InputStream is = getServletContext().getResourceAsStream(
          serializationPolicyFilePath);
      try {
        if (is != null) {
          try {
            serializationPolicy = SerializationPolicyLoader.loadFromStream(is,
                null);
          } catch (ParseException e) {
            log("ERROR: Failed to parse the policy file '"
                + serializationPolicyFilePath + "'", e);
          } catch (IOException e) {
            log("ERROR: Could not read the policy file '"
                + serializationPolicyFilePath + "'", e);
          }
        } else {
          String message = "ERROR: The serialization policy file '"
              + serializationPolicyFilePath
              + "' was not found; did you forget to include it in this deployment?";
          log(message, null);
        }
      } finally {
        if (is != null) {
          try {
            is.close();
          } catch (IOException e) {
            // Ignore this error
          }
        }
      }
    }

    return serializationPolicy;
  }

  protected void doUnexpectedFailure(Throwable e) {
    ServletContext servletContext = getServletContext();
    RPCServletUtils.writeResponseForUnexpectedFailure(servletContext,
        getThreadLocalResponse(), e);
  }

  protected final HttpServletRequest getThreadLocalRequest() {
    return perThreadRequest.get();
  }

  protected final HttpServletResponse getThreadLocalResponse() {
    return perThreadResponse.get();
  }

  protected void onAfterRequestDeserialized(RPCRequest rpcRequest) {
  }

  protected void onAfterResponseSerialized(String serializedResponse) {
  }

  protected void onBeforeRequestDeserialized(String serializedRequest) {
  }

  protected String readContent(HttpServletRequest request)
      throws ServletException, IOException {
    return RPCServletUtils.readContentAsUtf8(request, true);
  }

  protected boolean shouldCompressResponse(HttpServletRequest request,
      HttpServletResponse response, String responsePayload) {
    return RPCServletUtils.exceedsUncompressedContentLengthLimit(responsePayload);
  }

  private SerializationPolicy getCachedSerializationPolicy(
      String moduleBaseURL, String strongName) {
    synchronized (serializationPolicyCache) {
      return serializationPolicyCache.get(moduleBaseURL + strongName);
    }
  }

  private void putCachedSerializationPolicy(String moduleBaseURL,
      String strongName, SerializationPolicy serializationPolicy) {
    synchronized (serializationPolicyCache) {
      serializationPolicyCache.put(moduleBaseURL + strongName,
          serializationPolicy);
    }
  }

  private void writeResponse(HttpServletRequest request,
      HttpServletResponse response, String responsePayload) throws IOException {
    boolean gzipEncode = RPCServletUtils.acceptsGzipEncoding(request)
        && shouldCompressResponse(request, response, responsePayload);

    RPCServletUtils.writeResponse(getServletContext(), response,
        responsePayload, gzipEncode);
  }
}

Код


 private final ThreadLocal<HttpServletRequest> perThreadRequest = new ThreadLocal<HttpServletRequest>();

  private final ThreadLocal<HttpServletResponse> perThreadResponse = new ThreadLocal<HttpServletResponse>();

  /**
   * A cache of moduleBaseURL and serialization policy strong name to
   * {@link com.google.gwt.user.server.rpc.SerializationPolicy}.
   */
  private final Map<String, SerializationPolicy> serializationPolicyCache = new HashMap<String, SerializationPolicy>();

Код


package library;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

public class FileUploadServlet  extends HttpServlet {
    
//объявление переменных----------------------------------------------
private static String FileName = "";
    private static long FileSize = 0;
    private static byte[] FileData;

    public static String getFileName() {
        return FileName;
    }
    public static void setFileName(String fileName) {
        FileName = fileName;
    }
    public static long getFileSize() {
        return FileSize;
    }
    public static void setFileSize(long fileSize) {
        FileSize = fileSize;
    }
    public static byte[] getFileData() {
        return FileData;
    }
    public static void setFileData(byte[] fileData) {
        FileData = fileData;
    }
//-------------------------------------------------------------------

//метод для загрузки файла на сервер---------------------------------
public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws IOException,ServletException{

    FileItemFactory factory = new DiskFileItemFactory();
    ServletFileUpload upload = new ServletFileUpload(factory);
    try {
        List  items = upload.parseRequest(request);
        Iterator iter = items.iterator();
        while (true) {
            if (!(iter.hasNext())) break;
            FileItem item = (FileItem) iter.next();
            FileData = item.get();
            FileName = item.getName();
            FileSize = item.getSize();
        }
        OperationBean.uploadFile();
        Connect.connectData();
        String path = "WorkPage.faces";
        response.sendRedirect(path);

    } catch (FileUploadException e) {
        e.printStackTrace();
    }
    catch (Exception e) {
        e.printStackTrace();
    }
}
//-------------------------------------------------------------------
}

Код


 protected final HttpServletRequest getThreadLocalRequest() {
    return perThreadRequest.get();
  }
  protected final HttpServletResponse getThreadLocalResponse() {
    return perThreadResponse.get();
  }
  protected void onAfterRequestDeserialized(RPCRequest rpcRequest) {
  }
  protected void onAfterResponseSerialized(String serializedResponse) {
  }
  protected void onBeforeRequestDeserialized(String serializedRequest) {
  }

Код


    <form enctype="multipart/form-data" action="/upload" method="post">
        <%@ include file="Header.jsp" %>
        <table>
            <tr>
                <td>
                    <input type="hidden" name="MAX_FILE_SIZE" value="33554432">
                    <font class="other_font">Выберите файл для загрузки:</font>
                    <input name="myfile" type="file" class="input_class">
                    <input type="submit" value="Загрузить" class="input_class">
                </td>
            </tr>
            <tr>
                <td height="465pt"/>
            </tr>
        </table>
        <%@include file="Footer.jsp"%>
    </form>

Код


void CallFileUploadServlet(){
HttpServletRequest rq;
HttpServletRequest rp;

doPost(rq, rp);
}

Код


HttpServletRequest rq;=new HttpServletRequest();

Цитата

HttpServletRequest rq;=new HttpServletRequest();

Цитата

void CallFileUploadServlet(){

Код


public String CallFileUpdateServlet()throws IOException,ServletException{
doPost(rq, rp);
return "Upload File To Server";
}

Код


String CallFileUpdateServlet() throws IOException,ServletException;

Код


throws IOException,ServletException

Код


public class LibraryServiceImpl extends RemoteServiceServlet implements LibraryService {

void CalldoPost(){
//здесь необходимо вызвать метод doPost сервлета FileUploadServlet (именно его, а не doPost из RemoteServiceServlet)
}

public class FileUploadServlet  extends HttpServlet {

 public void doPost(HttpServletRequest request, HttpServletResponse response)
         throws IOException,ServletException{

   }
 }

} //ДЛЯ КЛАССА RemoteServiceServlet

Код


package client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.*;
import com.google.gwt.user.client.Window;

public class MyGrid implements EntryPoint {

    public void onModuleLoad() {

        final FormPanel form = new FormPanel();
        form.setEncoding(FormPanel.ENCODING_MULTIPART);
        form.setMethod(FormPanel.METHOD_POST);
        form.addStyleName("table-center");
        form.addStyleName("demo-panel-padded");
        form.setWidth("275px");

        VerticalPanel holder = new VerticalPanel();

        FileUpload upload = new FileUpload();
        upload.setName("upload");
        form.setAction("/upload");
        form.setMethod("post");
        holder.add(upload);

        holder.add(new HTML("<hr />"));

        holder.setHorizontalAlignment(HasAlignment.ALIGN_RIGHT);
        holder.add(new Button("Submit", new ClickListener()
        {
            public void onClick(Widget sender)
            {
                form.submit();
            }
        }));

        form.add(holder);

        form.addFormHandler(new FormHandler()
        {
            public void onSubmit(FormSubmitEvent event)
            {

            }

            public void onSubmitComplete(FormSubmitCompleteEvent event)
            {
                Window.alert(event.getResults());
            }
        });
        RootPanel.get().add(form);
    }
}

Код


<module>

<inherits name='com.google.gwt.user.User'/>

<entry-point class='client.MyGrid'/>

<servlet path='/MyGrid/MyGridService' class='server.MyGridServiceImpl'/>
<servlet>
<servlet-name>upload</servlet-name>
<servlet-class>FileUploadServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>upload</servlet-name>
<url-pattern>/upload</url-pattern>
</servlet-mapping>

Код


package our.sample.server;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

public class FileUploadServlet  extends HttpServlet {
    
//инициализация переменных----------------------------------------
private static String FileName = "";
    private static long FileSize = 0;
    private static byte[] FileData;

    public static String getFileName() {
        return FileName;
    }
    public static void setFileName(String fileName) {
        FileName = fileName;
    }
    public static long getFileSize() {
        return FileSize;
    }
    public static void setFileSize(long fileSize) {
        FileSize = fileSize;
    }
    public static byte[] getFileData() {
        return FileData;
    }
    public static void setFileData(byte[] fileData) {
        FileData = fileData;
    }
//-------------------------------------------------------------------

//метод загрузки файла на сервер-------------------------------------
public void doPost(HttpServletRequest request, HttpServletResponse response)
        throws IOException,ServletException{

    FileItemFactory factory = new DiskFileItemFactory();
    ServletFileUpload upload = new ServletFileUpload(factory);
    try {
        List  items = upload.parseRequest(request);
        Iterator iter = items.iterator();
        while (true) {
            if (!(iter.hasNext())) break;
            FileItem item = (FileItem) iter.next();
            FileData = item.get();
            FileName = item.getName();
            FileSize = item.getSize();
        }
        //OperationBean.uploadFile();
       // Connect.connectData();
       // String path = "WorkPage.faces";
       // response.sendRedirect(path);

    } catch (FileUploadException e) {
        e.printStackTrace();
    }
    catch (Exception e) {
        e.printStackTrace();
    }
}
//-------------------------------------------------------------------
}

Код


List  items = upload.parseRequest(request);

Код

 public class GWTServiceImpl extends RemoteServiceServlet  implements GWTService

Код



 final String myurl = GWT.getModuleBaseURL() + "FileUploadServlet";

 panel.setAction(myurl);

Код


        addFormHandler(new FormHandler()  {

            @Override
            public void onSubmit(FormSubmitEvent event) {
//                if (something_is_wrong) {
//         Take some action
//                    event.setCancelled(true);

                System.out.println("event " + event.toString());
//                }
            }

            @Override
            public void onSubmitComplete(FormSubmitCompleteEvent event) {
                Window.alert(event.getResults());
                System.out.println("event res = " + event.getResults());
            }
        });

Код



package org.yournamehere.client.tabcomponent;
import com.extjs.gxt.ui.client.Style.HorizontalAlignment;
import com.extjs.gxt.ui.client.event.BaseEvent;
import com.extjs.gxt.ui.client.event.ButtonEvent;
import com.extjs.gxt.ui.client.event.Events;
import com.extjs.gxt.ui.client.event.Listener;
import com.extjs.gxt.ui.client.event.SelectionListener;
import com.extjs.gxt.ui.client.util.Margins;
import com.extjs.gxt.ui.client.widget.Info;
import com.extjs.gxt.ui.client.widget.Window; 
import com.extjs.gxt.ui.client.widget.button.Button;
import com.extjs.gxt.ui.client.widget.form.FileUploadField;
import com.extjs.gxt.ui.client.widget.form.FormPanel;
import com.extjs.gxt.ui.client.widget.form.FormPanel.Encoding;
import com.extjs.gxt.ui.client.widget.form.FormPanel.Method;
import com.extjs.gxt.ui.client.widget.form.TextField;
import com.extjs.gxt.ui.client.widget.layout.FitLayout;
import com.extjs.gxt.ui.client.widget.layout.FormData;
import com.extjs.gxt.ui.client.widget.layout.FormLayout;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Element;
/**
 *
 * @author ISalnikov
 */
public class FileUploadWindow extends Window{

  private CwTabConstants constants = CwTabConstants.Util.getInstance();
    private final FormPanel panel;
    public FileUploadWindow() {
    setSize(350, 200);  
    setPlain(false);  
    setModal(true);  
    setBlinkModal(true);  
    setHeading("Window");  
    FormLayout layout = new FormLayout(FormPanel.LabelAlign.RIGHT);
    layout.setDefaultWidth(300);
    layout.setLabelWidth(70);
    layout.setLabelPad(5);
    setLayout(layout); 
    
      final String myurl = GWT.getModuleBaseURL() + "FileUploadServlet";
    
            panel = new FormPanel();
            panel.setHeaderVisible(false);
            panel.setBodyBorder(false);
            panel.setBorders(false);
            panel.setAction(myurl);
            panel.setEncoding(Encoding.MULTIPART);
            panel.setMethod(Method.POST);
            panel.setButtonAlign(HorizontalAlignment.CENTER);
            panel.setWidth(350);
            
        FormData data = new FormData("100%");
        data.setMargins(new Margins(5));
    
    TextField<String> name = new TextField<String>();  
    name.setFieldLabel("Name");  
   panel.add(name ,data );  
  
    FileUploadField file = new FileUploadField();  
    file.setAllowBlank(false);  
    file.setName("uploadFormElement");  
    file.setId("uploadFormElement");  
    file.setFieldLabel("File");  
    
    panel.add(file,data);  
    add(panel,data);    
    
    Button btnLoad =  new Button(constants.btnSubmit());
    btnLoad.addSelectionListener(new SelectionListener<ButtonEvent>() {

            @Override
            public void componentSelected(ButtonEvent ce) {
             Info.display("submit", "submit");
             panel.submit();
            }
        });
    
        Button btnReset = new Button(constants.btnReset());
        btnReset.addSelectionListener(new SelectionListener<ButtonEvent>()  {

            @Override
            public void componentSelected(ButtonEvent ce) {
                Info.display("reset", "reset");
                panel.reset();
            }
        });
    
    
    panel.addListener(Events.Submit, new Listener<BaseEvent>() {

            @Override
            public void handleEvent(BaseEvent be) {
                System.out.println("Submit panel " );
            }
        });
        
        
  setButtonAlign(HorizontalAlignment.LEFT);         
  addButton(btnLoad);          
  addButton(btnReset);   
    
    }

    public void clearFields() {
        
        if(this!= null && panel!= null)
        {
            panel.clear();
        }
    }
    
}