title: How to handle an Excel formula in a JAVA / JEE spreadsheet?
body: <p>I have a little project to do in JEE courses. The aim is to create a little spreadsheet in JEE. My level in Java is really bad but I try to do my best to succeed in this project anyway...</p>
  
  <p>I have some trouble to display the result of a formula on my web page.</p>
  
  <p>I use an Excel file in order to save all my cells instead of using a database.
  My program works this way:</p>
  
  <ul>
  <li><p>My servlet allows me to insert a value to a cell . For example : cell : A1 => value : =12*2</p></li>
  <li><p>Then the value is stored in the A1 cell of my excel file. But I have to evaluate the cell before (click on the cell and press enter by myself) in order to have the result of the formula (24 in this case).</p></li>
  <li><p>Then my web page displays the table with the good cells at the good place but the problem is that it displays only the formula without the result. It doesn't calculate...
  For example : A1 is displayed like that 12*2 (without the "=")</p></li>
  </ul>
  
  <p>Here is the code of the GridManager class :</p>
  
  <pre><code>    package managers;
  
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.poi.hssf.util.CellReference;
  import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
  import org.apache.poi.ss.usermodel.Cell;
  import org.apache.poi.ss.usermodel.CellValue;
  import org.apache.poi.ss.usermodel.CreationHelper;
  import org.apache.poi.ss.usermodel.DataFormatter;
  import org.apache.poi.ss.usermodel.FormulaEvaluator;
  import org.apache.poi.ss.usermodel.Row;
  import org.apache.poi.ss.usermodel.Sheet;
  import org.apache.poi.ss.usermodel.Workbook;
  import org.apache.poi.ss.usermodel.WorkbookFactory;
  
  import interfaces.Config;
  import interfaces.Grid;
  import interfaces.cell;
  import interfaces.cell.CellType;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  
  public class GridManager implements Grid {
  
      private Workbook wb;
      private FormulaEvaluator evaluator;
  
      public GridManager() {
          super();
      }
  
      /**
       * Implémentation de la fonction de récupération d'une valeur de cellule
       */
      public String getCell(String address) {
  
          String valCell = null;
  
          // Ouvrir le fichier excel
          if (openExcelFile()) {
  
              // Récupération de la feuille
              Sheet sheet1 = wb.getSheetAt(0);
  
              // Récupération de la cellule
              CellReference cellReference = new CellReference(address);
              Row row = sheet1.getRow(cellReference.getRow());
              Cell cell = row.getCell(cellReference.getCol());
              if (cell != null) {
  
                  // Récupération de la valeur
                  DataFormatter formatter = new DataFormatter();
                  valCell = formatter.formatCellValue(cell);
              }
  
          } else {
              System.err.println("Impossible d'accéder au fichier");
          }
  
          return valCell;
      }
  
      /**
       * Implémentation de la fonction d'attribution d'une valeur à  une cellule
       */
      public String setCell(String address, cell cell) {
  
          // Ouvrir le fichier excel
          openExcelFile();
  
          // Récupération de la feuille de style
          Sheet sheet = wb.getSheetAt(0);
  
          // Création de cellule
          CellReference cr = new CellReference(address);
          int r = cr.getRow();
          int c = cr.getCol();
  
          // Remplissage de cellule
          Row row = sheet.getRow(r);
          if (row == null)
              row = sheet.createRow(r);
  
          // Si type est formule on calcule et on stocke le resultat
          if (cell.getType() == CellType.FORMULA){
  
  
              CreationHelper createHelper = wb.getCreationHelper();
              FormulaEvaluator evaluator = wb.getCreationHelper().createFormulaEvaluator();
  
              row.createCell(c).setCellValue(createHelper.createRichTextString(cell.getRawValue()));
  
  
          }else{
              CreationHelper createHelper = wb.getCreationHelper();
              row.createCell(c).setCellValue(createHelper.createRichTextString(cell.getRawValue()));
          }
  
  
          // Ecriture dans la feuille
          FileOutputStream fileOut;
          try {
              fileOut = new FileOutputStream(Config.cheminTableur);
              wb.write(fileOut);
              fileOut.close();
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          } catch (IOException e) {
              e.printStackTrace();
          }
  
          return cell.getComputedValue();
      }
  
      /**
       * Implémentation de la fonction qui retourne la liste de toutes les
       * cellules ayant une valeur
       */
      public HashMap&lt;Integer,List&lt;cell&gt;&gt; getAllCells() {
  
          HashMap&lt;Integer, List&lt;cell&gt;&gt; tableCells  = new HashMap&lt;Integer, List&lt;cell&gt;&gt;();
  
          List&lt;cell&gt; cells;
  
          // Ouvrir le fichier excel
          openExcelFile();
  
          // Récupération de la feuille
          Sheet sheet1 = wb.getSheetAt(0);
  
          // Récupération des valeurs
          final DataFormatter formatter = new DataFormatter();
  
          // Ligne Debut / Fin
          int rowStart = Math.min(15, sheet1.getFirstRowNum());
          int rowEnd = Math.max(1400, sheet1.getLastRowNum());
  
          for (int rowNum = rowStart; rowNum &lt; rowEnd; rowNum++) {
  
              cells =  new ArrayList&lt;cell&gt;();
  
              Row r = sheet1.getRow(rowNum);
  
              if (r == null) {
                  // Si ligne vide
                  continue;
              }
  
              int lastColumn = Math.max(r.getLastCellNum(), 0);
  
              for (int cn = 0; cn &lt; lastColumn; cn++) {
  
                  final Cell cellule = r.getCell(cn, Row.RETURN_BLANK_AS_NULL);
  
                  if (cellule == null) {
                      cell c = new cell() {
                          public cell.CellType getType() {
  
                              return cell.CellType.STRING;
                          }
  
                          public String getRawValue() {
                              return formatter.formatCellValue(cellule);
                          }
  
                          public String getComputedValue() {
                                  return " ";                         
                          }
                      };
  
                      cells.add(c);
                  } else {
                      cell c = new cell() {
                          public cell.CellType getType() {
  
                              // Récupération du type de la cellule
                              cell.CellType type = null;
                              switch (cellule.getCellType()) {
                              case Cell.CELL_TYPE_STRING:
                                  type = cell.CellType.STRING;
                                  break;
                              case Cell.CELL_TYPE_NUMERIC:
                                  type = cell.CellType.NUMBER;
                                  break;
                              case Cell.CELL_TYPE_FORMULA:
                                  type = cell.CellType.FORMULA;
  
                                  break;
                              }
  
                              return type;
                          }
  
                          public String getRawValue() {
                              return formatter.formatCellValue(cellule);
                          }
  
                          public String getComputedValue() {
                              // Si la valeur de la cellule est le résultat d'une
                              // formule on retourne le résultat sinon on retourne la
                              // valeur de cellule
  
                                  return formatter.formatCellValue(cellule);
  
                          }
                      };
  
                      cells.add(c);
                  }
  
                  tableCells.put(rowNum,cells);           
              }
          }
  
          return tableCells;
      }
  
      /**
       * Fonction d'ouverture du tableur Excel
       */
      public boolean openExcelFile() {
  
          try {
              wb = WorkbookFactory.create(new FileInputStream(Config.cheminTableur));
              return true;
          } catch (InvalidFormatException e) {
              System.err.println("Format du fichier est invalide");
          } catch (FileNotFoundException e) {
              System.err.println("Le chemin vers fichier est incorrecte");
          } catch (IOException e) {
              e.printStackTrace();
          }
  
          return false;
      }
  
  }
  </code></pre>
  
  <p>Here is the servlet code :</p>
  
  <pre><code>    package web;
  
  import java.io.IOException;
  import java.util.List;
  import java.util.Map;
  
  import javax.servlet.ServletException;
  import javax.servlet.annotation.WebServlet;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import interfaces.cell;
  import interfaces.cell.CellType;
  import managers.GridManager;
  
  /**
   * Servlet d'implementation 
   */
  @WebServlet("/tableurServlet")
  public class TableurServlet extends HttpServlet {
      private static final long serialVersionUID = 1L;
  
      private GridManager gridManager = new GridManager();
  
      public TableurServlet() {
          super();
      }
  
      /**
       * Récupération de toutes les valeurs ou une seule valeur ou Set d'une valeur depuis url    
       */
      protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  
          // Set d'une valeur de cellule
          if(request.getParameter("address") != null &amp;&amp; request.getParameter("value") != null){
  
              // Renvoie vers la méthode doPut pour attribuer la valeur à la cellule
              doPut(request, response);
          }
          // Récupération d'une valeur d'une cellule
          else if(request.getParameter("address") != null){
  
              // Stockage de la valeur
              String cellValue = gridManager.getCell(request.getParameter("address"));
  
              // Passer le paramétre à la vue index.jsp
              request.setAttribute("cellValue", cellValue);
  
              // Redirection vers la vue index.jsp
              request.getRequestDispatcher("index.jsp").forward(request, response);
  
          }
          // Récupération des valeurs des cellules remplies
          else {
  
              // Stockage des valeurs récuperés dans une liste
              Map&lt;Integer,List&lt;cell&gt;&gt; cells  = gridManager.getAllCells();
  
              // Passer le paramétre à la vue index.jsp
              request.setAttribute("cells", cells);
  
              // Redirection vers la vue index.jsp
              request.getRequestDispatcher("index.jsp").forward(request, response);
          }
  
      }
  
      /**
       *  Set d'une valeur d'une cellule depuis formulaire
       */
      protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  
          // Renvoie vers la methode doPut() pour attribuer la valeur à la cellule
          doPut(request, response);
      }
  
      /**
       *  Set D'une valeur d'une cellule
       */
      @Override
      protected void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  
          if (request.getParameter("address") != null  &amp;&amp; request.getParameter("value") != null){
  
              // Récupération des valeurs passés
              String address = request.getParameter("address");
              final String value = request.getParameter("value");
  
              final CellType cellType;
              Integer intValue;
              try {
                  intValue = Integer.parseInt(value);
              }
              catch(NumberFormatException e) {
                  intValue=null;
              }
              if ( intValue!=null &amp;&amp; !value.startsWith("'")) {
                  cellType=CellType.NUMBER;
              }
              else if ( value.startsWith("=") ) {
                  cellType=CellType.FORMULA;
  
  
  
              }
              else {
                  cellType=CellType.STRING;
              }
  
  
  
              // Remplissage de cellule
              gridManager.setCell(address, new cell() {
  
                  public CellType getType() {
  
  
  
                      return cellType;
                  }
  
                  public String getRawValue() {
                      return value;
                  }
  
                  public String getComputedValue() {
                      return value;
                  }
              });
          }
      }
  
  }   
  </code></pre>
  
  <p>I can't see where is the problem. How can I display the result of my Formula directly on my web page ? Please, can you help me ? Sorry for the french comments btw.</p>