Study & DevО программировании и не только

HashMap f = (HashMap) request.getAttribute("f$");

if (f != null){

  out.println ("Получены в качестве параметров несколько файлов ... анализирую...");

  final Iterator set = f.keySet().iterator();

  while (set.hasNext()){

    String varName = (String) set.next();

    Object value = f.get(varName);

    if (value instanceof ArrayList){

       out.println("Переменная содержит список файлов");

       ArrayList alistValues = (ArrayList) value;

       for (Object alistValue : alistValues) {

          HashMap paramFile = (HashMap) alistValue;

          out.println ("-------------");

          out.println ("orig_name: "+ paramFile.get("orig_name"));

          out.println ("tmp_name: "+ paramFile.get("tmp_name"));

          out.println ("size: "+ paramFile.get("size"));

          out.println ("content-type: "+ paramFile.get("content-type"));

          out.println ("-------------");

        }

     }

     else{

        out.println("Переменная содержит только один файл");

        HashMap paramFile = (HashMap) value;

        out.println ("-------------");

        out.println ("orig_name: "+ paramFile.get("orig_name"));

        out.println ("tmp_name: "+ paramFile.get("tmp_name"));

        out.println ("size: "+ paramFile.get("size"));

        out.println ("content-type: "+ paramFile.get("content-type"));

        out.println ("-------------");

     }

  }

}

else{

   out.println ("Файлов нет  ... не анализирую...");

}

HashMap<String, ArrayList<HashMap<String, String>>> f = 

        (HashMap<String, ArrayList<HashMap<String, String>>>)    request.getAttribute("f$");

if (f != null) {

   out.println("Получены в качестве параметров несколько файлов ... анализирую...");

   final Iterator set = f.keySet().iterator();

   while (set.hasNext()) {

      String varName = (String) set.next();

      Object value = f.get(varName);

      out.println("Переменная содержит список файлов");

      ArrayList alistValues = (ArrayList) value;

      for (Object alistValue : alistValues) {

         HashMap paramFile = (HashMap) alistValue;

         out.println("-------------");

         out.println("orig_name: " + paramFile.get("orig_name"));

         out.println("tmp_name: " + paramFile.get("tmp_name"));

         out.println("size: " + paramFile.get("size"));

         out.println("content-type: " + paramFile.get("content-type"));

         out.println("-------------");

      }

   }// while

} else {

    out.println("Файлов нет  ... не анализирую...");

 }

package helpers;

import org.apache.commons.fileupload.FileItem;

import org.apache.commons.fileupload.FileItemFactory;

import org.apache.commons.fileupload.disk.DiskFileItemFactory;

import org.apache.commons.fileupload.servlet.ServletFileUpload;

import org.apache.commons.io.FilenameUtils;

import javax.servlet.*;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;

import java.io.File;

import java.io.IOException;

import java.util.*;

public class SmartFileUploads implements Filter {

    private class UTf8MakerReqiestWrapper extends HttpServletRequestWrapper {

        HashMap<String, String[]> params = new HashMap<String, String[]>();

        public String getParameter(String s) {

            if (params.get(s) == null) return null;

            return params.get(s).length != 0 ? params.get(s)[0] : null;

        }

        public Map getParameterMap() {

            return params;

        }

        public Enumeration getParameterNames() {

            return Collections.enumeration(params.keySet());

        }

        public String[] getParameterValues(String s) {

            return params.get(s);

        }

        private HashMap parseFile(FileItem item) throws Exception {

            String name = item.getName();

            long filelen = item.getSize();

            HashMap<String, String> nextfile = new HashMap<String, String>();

            if (name != null && (name.length() > 0)) {// если файл был загружен

                name = FilenameUtils.getName(name);

                final File tempFile = File.createTempFile("zedzed", "zedzed");

                // здесь файл не клонируется а в случае возмоности переименовывается

                item.write(tempFile);

                nextfile.put(PARAM_ORIG_NAME, name);

                nextfile.put(PARAM_SIZE_NAME, "" + filelen);

                nextfile.put(PARAM_TMP_NAME, tempFile.getAbsolutePath());

                nextfile.put(PARAM_CONTENTTYPE_NAME, item.getContentType());

                // после парсинга файл необходимо зарегистрировать в специальном 

                // списке файлов подлежащих удалению после завершения работы фильтра

                origNames.add(tempFile.getAbsolutePath());

            } else {

                nextfile.put(PARAM_ORIG_NAME, null);

                nextfile.put(PARAM_SIZE_NAME, "-1");

                nextfile.put(PARAM_TMP_NAME, null);

                nextfile.put(PARAM_CONTENTTYPE_NAME, null);

            }

            return nextfile;

        }

        private ArrayList<String> origNames = new ArrayList<String>();

        private UTf8MakerReqiestWrapper(HttpServletRequest hreq) throws Exception {

            super(hreq);

            final String usedCharset = hreq.getCharacterEncoding();

            final HashMap<String, Object> f = new HashMap<String, Object>();

            hreq.setAttribute("f$", f);

            ServletFileUpload upload = new ServletFileUpload(factory);

            List items = upload.parseRequest(hreq);

            Iterator iter = items.iterator();

            while (iter.hasNext()) {

                FileItem item = (FileItem) iter.next();

                String fld_name = item.getFieldName();

                Boolean is_multifield = false;

                if (fld_name.endsWith("[]")) {

                    fld_name = fld_name.substring(0, fld_name.length() - 2);

                    is_multifield = true;

                }

                if (item.isFormField()) {

                    final String fValue = item.getString(usedCharset);

                    // если поле содержит массив строк

                    if (is_multifield) {

                        if (params.containsKey(fld_name)) {

                            String[] strings = params.get(fld_name);

                            String[] strings2 = new String[1 + strings.length];

                            System.arraycopy(strings, 0, strings2, 0, strings.length);

                            strings2[strings.length] = fValue;

                            strings = null;

                            params.put(fld_name, strings2);

                        } else {

                            params.put(fld_name, new String[]{fValue});

                        }

                    }//if multi values

                    else {

                        //if single value (skip old values)

                        params.put(fld_name, new String[]{fValue});

                    }

                    // теперь обработаем файлы

                } else {

                    // если у выполняется загрузка массива файлов

                    if (is_multifield) {

                        if (f.containsKey(fld_name)) {

                            ((ArrayList<HashMap<String, String>>)f.get(fld_name)).add(parseFile(item));

                        }//if has item by this name

                        else {

                            final ArrayList<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>();

                            list.add(parseFile(item));

                            f.put(fld_name, list);

                        }

                    } else {

                        // если файл загружается в единственном экземпляре, то необходимо 

                        // проигнорировать все остальные значения

                        // однако следует учитывать стиль формирования результата

                        if (forceUnifiedResultSetStyle){

                            final ArrayList<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>();

                            list.add(parseFile(item));

                            f.put(fld_name, list);

                        }

                        else

                            f.put(fld_name, parseFile(item));

                    }

                }//else if fileupload, not regular fieldname

                // но это еще не все возможно что поле попало в раздел файлов и теперь необходимо сделать так

                // чтобы удалились все эти вредные файлы

                try {

                    item.delete();

                } catch (Exception e) {

                    log("--UTF8Maker::cannot delete tmp file (parse stage)--: " + hreq.getRequestURI());

                }

            }// while

        }// constructor

        private void cleanup() {

            // необходимо удалить все файлы которые были созданы на стадии парсинга запроса,

            // но все еще не были удалены после его окончания

            // файл должен быть либо удален либо перенесен в другое место

            for (String origName : origNames) {

                try {

                    File ftmp = new File(origName);

                    if (ftmp.exists())

                        ftmp.delete();

                } catch (Exception e) {

                    log("--UTF8Maker::cannot delete tmp file (cleanup stage)--: " + origName);

                }

            }

        }

    }// end of CLASS

    // сведения об загруженных файлах хранятся в виде HashMap <string, String> 

    // в качестве ключей этой "карты" возможны следующие значения:

    // 1. Оригинальное имя файла (естественно, без каталогов)

    private static final String PARAM_ORIG_NAME = "orig_name";

    // 2. Имя временного файла в котором хранится информация

    private static final String PARAM_TMP_NAME = "tmp_name";

    // 3. Размер загруженного файла (необходимо выполнить парсинг строки)

    private static final String PARAM_SIZE_NAME = "size";

    // 4. Тип загруженного документа

    private static final String PARAM_CONTENTTYPE_NAME = "content-type";

    // имя параметра под которым в кофигурационном файле хранятся сведения об том,

    // в какую кодировку необходимо установить параметры входящего запроса

    private static final String FORCE_SET_ENCODING_URLENCODED_INIT_PARAM_NAME = "force-set-encoding-urlencoded";

    private static final String FORCE_SET_ENCODING_MULTIPART_INIT_PARAM_NAME = "force-set-encoding-multipart";

    private static final String FORCE_UNIFIED_RESULT_STYLE_INIT_PARAM_NAME = "force-unified-result-style";

    private FileItemFactory factory = null;

    private String forceSetEncodingMultpart = null;

    private String forceSetEncodingURLEncoded = null;

    private Boolean forceUnifiedResultSetStyle = false;

    private FilterConfig config = null;

    private File tempDir;

    private Integer MAX_SIZE_IN_MEMORY = 2000;

    // завершение жизненного цикла сервлета - не выполняется никаких действий

    public void destroy() {

        config.getServletContext().log("--UTF8Maker::destroy--");

    }

    // выполнение фильтрации запроса

    public void doFilter(ServletRequest req, ServletResponse resp,

                         FilterChain chain) throws ServletException, IOException {

        // если входящий запрос не Http, то мы не умеем его обрабатывать и пропускаем без изменений

        if (!(req instanceof HttpServletRequest)) {

            chain.doFilter(req, resp);

            return;

        }

        HttpServletRequest hreq = (HttpServletRequest) req;

        // теперь следует узнать то, следует ли нам выполнять обработку такого запроса

        boolean isMultipart = ServletFileUpload.isMultipartContent(hreq);

        if (isMultipart) {

            // устанавливаем значение кодировки

            if (forceSetEncodingMultpart != null)

                req.setCharacterEncoding(forceSetEncodingMultpart);

            else

                req.setCharacterEncoding("ISO8859-1");

            log("--UTF8Maker::process--: " + hreq.getRequestURI());

            // нужно создать обертку над объектом входящего HttpServletRequest, 

            // в котором переопределить выполняемый парсинг входных данных

            UTf8MakerReqiestWrapper req2 = null;

            try {

                req2 = new UTf8MakerReqiestWrapper((HttpServletRequest) req);

                // выполняем обработку запроса как будто ничего не случилось

                chain.doFilter(req2, resp);

                // теперь нужно подчистить за собой - удалить временные файлы

                req2.cleanup();

            } catch (Exception e) {

                log("--UTF8Maker::exception--: " + e.getMessage());

                throw new ServletException(e);

            }

        } else {

            // если обработка не нужна то пропускаем запрос без изменений

            if (forceSetEncodingURLEncoded != null)

                req.setCharacterEncoding(forceSetEncodingURLEncoded);

            log("--UTF8Maker::skip--: " + hreq.getRequestURI());

            chain.doFilter(req, resp);

        }

    }//end of  --doFilter--

    // инициализация, здесь выполняется создание фабрики парсинга входящих запросов DiskFileItemFactory.

    // затем выполняется чтение конфигурационного файла web.xml и установка значений 

    // для переменных управляющих работой фильтра преобразований

    public void init(FilterConfig config) throws ServletException {

        this.config = config;

        try {

            final File tempFile = File.createTempFile("zedzed", "zedzed");

            tempDir = tempFile.getParentFile();

            tempFile.delete();

            factory = new DiskFileItemFactory(MAX_SIZE_IN_MEMORY, tempDir);

        } catch (IOException e) {

            log("--UTF8Maker::fail init--" + e.getMessage());

            throw new ServletException(e);

        }

        log("--UTF8Maker::init--");

        forceSetEncodingMultpart = config.getInitParameter(FORCE_SET_ENCODING_MULTIPART_INIT_PARAM_NAME);

        forceSetEncodingURLEncoded = config.getInitParameter(FORCE_SET_ENCODING_URLENCODED_INIT_PARAM_NAME);

        forceUnifiedResultSetStyle = Boolean.parseBoolean(config.getInitParameter(FORCE_UNIFIED_RESULT_STYLE_INIT_PARAM_NAME));

        log("param (forceSetEncoding) = " + forceSetEncodingMultpart + " / " + 

                 forceSetEncodingURLEncoded + " / "+forceUnifiedResultSetStyle);

    }

    private void log(String s) {

        config.getServletContext().log(s);

    }

}