GWT+Spring+hibernate! Error 404 :(

package com.javacodegeeks.client;
 
import com.javacodegeeks.shared.dto.EmployeeDTO;
import com.javacodegeeks.shared.services.EmployeeServiceAsync;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.event.dom.client.KeyUpEvent;
import com.google.gwt.event.dom.client.KeyUpHandler;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.HTML;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.VerticalPanel;
 
 
public class Gwtspringtestnomaven
implements EntryPoint
{
    /**
     * The message displayed to the user when the server cannot be reached or
     * returns an error.
     */
    private static final String SERVER_ERROR = "An error occurred while "
      + "attempting to contact the server. Please check your network "
      + "connection and try again. The error is : ";
   
    /**
     * Create a remote service proxy to talk to the server-side Employee service.
     */
    private final EmployeeServiceAsync employeeService =EmployeeServiceAsync.Util.getInstance();
 
    /**
     * This is the entry point method.
     */
    public void onModuleLoad() {
     final Button saveOrUpdateButton = new Button("SaveOrUpdate");
     final Button retrieveButton = new Button("Retrieve");
     final TextBox employeeInfoField = new TextBox();
     employeeInfoField.setText("2 Employee Info jjjj");
     final TextBox employeeIdField = new TextBox();
     final Label errorLabel = new Label();
     
     // We can add style names to widgets
     saveOrUpdateButton.addStyleName("sendButton");
     retrieveButton.addStyleName("sendButton");
 
     // Add the nameField and sendButton to the RootPanel
     // Use RootPanel.get() to get the entire body element
     RootPanel.get("employeeInfoFieldContainer").add(employeeInfoField);
     RootPanel.get("updateEmployeeButtonContainer").add(saveOrUpdateButton);
     RootPanel.get("employeeIdFieldContainer").add(employeeIdField);
     RootPanel.get("retrieveEmployeeButtonContainer").add(retrieveButton);
     RootPanel.get("errorLabelContainer").add(errorLabel);
 
     // Focus the cursor on the name field when the app loads
     employeeInfoField.setFocus(true);
     employeeInfoField.selectAll();
 
     // Create the popup dialog box
     final DialogBox dialogBox = new DialogBox();
     dialogBox.setText("Remote Procedure Call");
     dialogBox.setAnimationEnabled(true);
     final Button closeButton = new Button("Close");
     // We can set the id of a widget by accessing its Element
     closeButton.getElement().setId("closeButton");
     final Label textToServerLabel = new Label();
     final HTML serverResponseLabel = new HTML();
     VerticalPanel dialogVPanel = new VerticalPanel();
     dialogVPanel.addStyleName("dialogVPanel");
     dialogVPanel.add(new HTML("<b>Sending request to the server:</b>"));
     dialogVPanel.add(textToServerLabel);
     dialogVPanel.add(new HTML("<b>Server replies:</b>"));
     dialogVPanel.add(serverResponseLabel);
     dialogVPanel.setHorizontalAlignment(VerticalPanel.ALIGN_RIGHT);
     dialogVPanel.add(closeButton);
     dialogBox.setWidget(dialogVPanel);
 
     // Add a handler to close the DialogBox
     closeButton.addClickHandler(new ClickHandler() {
      public void onClick(ClickEvent event) {
       dialogBox.hide();
       saveOrUpdateButton.setEnabled(true);
       saveOrUpdateButton.setFocus(true);
       retrieveButton.setEnabled(true);
      }
     });
 
     // Create a handler for the saveOrUpdateButton and employeeInfoField
     class SaveOrUpdateEmployeeHandler implements ClickHandler, KeyUpHandler {
      /**
       * Fired when the user clicks on the saveOrUpdateButton.
       */
      public void onClick(ClickEvent event) {
       sendEmployeeInfoToServer();
      }
 
      /**
       * Fired when the user types in the employeeInfoField.
       */
      public void onKeyUp(KeyUpEvent event) {
       if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
        sendEmployeeInfoToServer();
       }
      }
 
      /**
       * Send the employee info from the employeeInfoField to the server and wait for a response.
       */
      private void sendEmployeeInfoToServer() {
       // First, we validate the input.
       errorLabel.setText("");
       String textToServer = employeeInfoField.getText();
 
       // Then, we send the input to the server.
       saveOrUpdateButton.setEnabled(false);
       textToServerLabel.setText(textToServer);
       serverResponseLabel.setText("");
 
       String[] employeeInfo = textToServer.split(" ");
       
       long employeeId = Long.parseLong(employeeInfo[0]);
       String employeeName = employeeInfo[1];
       String employeeSurname = employeeInfo[2];
       String employeeJobTitle = employeeInfo[3];
       System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
       System.out.println("String[] = "+employeeInfo);
       System.out.println("employeeId = "+employeeId);
       System.out.println("employeeName = "+employeeName);
       System.out.println("employeeSurname = "+employeeSurname);
       System.out.println("employeeJobTitle = "+employeeJobTitle);
       
       employeeService.saveOrUpdateEmployee(employeeId, employeeName, employeeSurname, employeeJobTitle, 
         new AsyncCallback<Void>() {
          public void onFailure(Throwable caught) {
           // Show the RPC error message to the user
           dialogBox
             .setText("Remote Procedure Call - Failure");
           serverResponseLabel
             .addStyleName("serverResponseLabelError");
           serverResponseLabel.setHTML(SERVER_ERROR + caught.toString());
           dialogBox.center();
           closeButton.setFocus(true);
          }
 
          public void onSuccess(Void noAnswer) {
           dialogBox.setText("Remote Procedure Call");
           serverResponseLabel
             .removeStyleName("serverResponseLabelError");
           serverResponseLabel.setHTML("OK");
           dialogBox.center();
           closeButton.setFocus(true);
          }
         });
      }
     }
     
     // Create a handler for the retrieveButton and employeeIdField
     class RetrieveEmployeeHandler implements ClickHandler, KeyUpHandler {
      /**
       * Fired when the user clicks on the retrieveButton.
       */
      public void onClick(ClickEvent event) {
       sendEmployeeIdToServer();
      }
 
      /**
       * Fired when the user types in the employeeIdField.
       */
      public void onKeyUp(KeyUpEvent event) {
       if (event.getNativeKeyCode() == KeyCodes.KEY_ENTER) {
        sendEmployeeIdToServer();
       }
      }
 
      /**
       * Send the id from the employeeIdField to the server and wait for a response.
       */
      private void sendEmployeeIdToServer() {
       // First, we validate the input.
       errorLabel.setText("");
       String textToServer = employeeIdField.getText();
       System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
       System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!! sendEmployeeIdToServer = "+ textToServer);
       // Then, we send the input to the server.
       retrieveButton.setEnabled(false);
       textToServerLabel.setText(textToServer);
       serverResponseLabel.setText("");
 
       employeeService.findEmployee(Long.parseLong(textToServer),  
         new AsyncCallback<EmployeeDTO>() {
          public void onFailure(Throwable caught) {
           // Show the RPC error message to the user
           dialogBox
             .setText("Remote Procedure Call - Failure");
           serverResponseLabel
             .addStyleName("serverResponseLabelError");
           serverResponseLabel.setHTML(SERVER_ERROR + caught.toString());
           dialogBox.center();
           closeButton.setFocus(true);
          }
 
          public void onSuccess(EmployeeDTO employeeDTO) {
           dialogBox.setText("Remote Procedure Call");
           serverResponseLabel
             .removeStyleName("serverResponseLabelError");
           if(employeeDTO != null)
            serverResponseLabel.setHTML("Employee Information Id : " 
           + employeeDTO.getEmployeeId() + "Name : " + employeeDTO.getEmployeeName() 
           + "Surname : " + employeeDTO.getEmployeeSurname() 
           + " Job Title : " + employeeDTO.getJob());
           else
            serverResponseLabel.setHTML("No employee with the specified id found");
           dialogBox.center();
           closeButton.setFocus(true);
          }
         });
      }
     }
 
     // Add a handler to send the employee info to the server
     SaveOrUpdateEmployeeHandler saveOrUpdateEmployeehandler = new SaveOrUpdateEmployeeHandler();
     saveOrUpdateButton.addClickHandler(saveOrUpdateEmployeehandler);
     employeeInfoField.addKeyUpHandler(saveOrUpdateEmployeehandler);
     
     // Add a handler to send the employee id to the server
     RetrieveEmployeeHandler retrieveEmployeehandler = new RetrieveEmployeeHandler();
     retrieveButton.addClickHandler(retrieveEmployeehandler);
     employeeIdField.addKeyUpHandler(retrieveEmployeehandler);
    }

package com.javacodegeeks.shared.services;
 
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
 
import com.javacodegeeks.shared.dto.EmployeeDTO;
 
@RemoteServiceRelativePath("springGwtServices/employeeService")
public interface EmployeeService extends RemoteService {
 
 public EmployeeDTO findEmployee(long employeeId);
 public void saveEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;
 public void updateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;
 public void saveOrUpdateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception;
 public void deleteEmployee(long employeeId) throws Exception;
 
}

package com.javacodegeeks.shared.services;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
 
import com.google.gwt.user.client.rpc.ServiceDefTarget;
import com.javacodegeeks.shared.dto.EmployeeDTO;
 
public interface EmployeeServiceAsync {
 
 
    void deleteEmployee(long employeeId, AsyncCallback<Void> callback);
 
    void findEmployee(long employeeId, AsyncCallback<EmployeeDTO> callback);
 
    void saveEmployee(long employeeId, String name, String surname,
        String jobDescription, AsyncCallback<Void> callback);
 
    void saveOrUpdateEmployee(long employeeId, String name, String surname,
        String jobDescription, AsyncCallback<Void> callback);
 
    void updateEmployee(long employeeId, String name, String surname,
        String jobDescription, AsyncCallback<Void> callback);
 
    public static final class Util
    {
    private static EmployeeServiceAsync instance;
    public static final EmployeeServiceAsync getInstance()
    {
    if ( instance == null )
    {
    instance = (EmployeeServiceAsync) GWT.create( EmployeeService.class );
 
    ServiceDefTarget target = (ServiceDefTarget) instance;
    target.setServiceEntryPoint( GWT.getModuleBaseURL() + "springGwtServices/employeeService " );
 
    }
    return instance;
    }
    private Util()
    {
    // Utility class should not be instanciated
    }
    }
    
}

package com.javacodegeeks.server.services; 
 
import javax.annotation.PostConstruct; 
import javax.annotation.PreDestroy; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
import org.springframework.transaction.annotation.Propagation; 
import org.springframework.transaction.annotation.Transactional; 
 
import com.javacodegeeks.server.dao.EmployeeDAO;
import com.javacodegeeks.shared.dto.EmployeeDTO;
import com.javacodegeeks.shared.services.EmployeeService;
 
@Service("employeeService") 
public class EmployeeServiceImpl implements EmployeeService { 
  
    
 @Autowired 
 private EmployeeDAO employeeDAO; 
 
 @PostConstruct 
 public void init() throws Exception { 
 } 
  
 @PreDestroy 
 public void destroy() { 
 } 
 
 public EmployeeDTO findEmployee(long employeeId) { 
  
  return employeeDAO.findById(employeeId); 
   
 } 
  
 @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) 
 public void saveEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception { 
  EmployeeDTO employeeDTO = employeeDAO.findById(employeeId); 
   
  if(employeeDTO == null) { 
   employeeDTO = new EmployeeDTO(employeeId, name,surname, jobDescription); 
   employeeDAO.persist(employeeDTO); 
  } 
   
 } 
  
 @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) 
 public void updateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception { 
   
  EmployeeDTO employeeDTO = employeeDAO.findById(employeeId); 
   
  if(employeeDTO != null) { 
   employeeDTO.setEmployeeName(name); 
   employeeDTO.setEmployeeSurname(surname); 
   employeeDTO.setJob(jobDescription); 
  } 
 
 } 
  
 @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) 
 public void deleteEmployee(long employeeId) throws Exception { 
   
  EmployeeDTO employeeDTO = employeeDAO.findById(employeeId); 
   
  if(employeeDTO != null) 
   employeeDAO.remove(employeeDTO); 
 
 } 
  
 @Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class) 
 public void saveOrUpdateEmployee(long employeeId, String name, String surname, String jobDescription) throws Exception { 
   System.out.println("into SaveOrUpdate");
  EmployeeDTO employeeDTO = new EmployeeDTO(employeeId, name,surname, jobDescription); 
  System.out.println("SaveOrUpdate good");
  employeeDAO.merge(employeeDTO); 
  System.out.println(" SaveOrUpdate out"); 
 } 
 
}