Problème Gxt et Spring

Bonjour, j'ai un probléme au niveau d'appel d'une méthode via RPC.
j'ai des méthodes déclaré dans la couche service et lors de leurs appels je me trouve dans OnFailure () . j'ai tésté mes services et ils fonctionnes sur la console . Quand j'ai implémenté une simple méthode dans le serveur le résultat était juste coté clilent. je n'arrive même pas à identifier le niveau de mon probléme.
voilà mes classes:

classe EmployeeDto

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package com.javacodegeeks.gwtspring.client.shared.dto;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
 
@Entity
@Table(name = "EMPLOYEE")
public class EmployeeDTO implements java.io.Serializable {
 
	private static final long serialVersionUID = 7440297955003302414L;
 
	@Id
	@Column(name="employee_id")
	private long employeeId;
 
	@Column(name="employee_name", nullable = false, length=30)
	private String employeeName;
 
	@Column(name="employee_surname", nullable = false, length=30)
	private String employeeSurname;
 
	@Column(name="job", length=50)
	private String job;
 
	@Column(name="login", length=50)
    private String login;
 
	@Column(name="password", length=50)
    private String password;
 
 
	public String getLogin() {
		return login;
	}
 
	public void setLogin(String login) {
		this.login = login;
	}
 
	public String getPassword() {
		return password;
	}
 
	public void setPassword(String password) {
		this.password = password;
	}
 
	public EmployeeDTO() {
	}
 
	public EmployeeDTO(int employeeId) {
		this.employeeId = employeeId;		
	}
 
	public EmployeeDTO(long employeeId, String employeeName, String employeeSurname,
			String job) {
		this.employeeId = employeeId;
		this.employeeName = employeeName;
		this.employeeSurname = employeeSurname;
		this.job = job;
	}
 
	public EmployeeDTO(String login,String password)
	{
		this.login=login;
		this.password=password;	
 
	}
 
	public long getEmployeeId() {
		return employeeId;
	}
 
	public void setEmployeeId(long employeeId) {
		this.employeeId = employeeId;
	}
 
	public String getEmployeeName() {
		return employeeName;
	}
 
	public void setEmployeeName(String employeeName) {
		this.employeeName = employeeName;
	}
 
	public String getEmployeeSurname() {
		return employeeSurname;
	}
 
	public void setEmployeeSurname(String employeeSurname) {
		this.employeeSurname = employeeSurname;
	}
 
	public String getJob() {
		return job;
	}
 
	public void setJob(String job) {
		this.job = job;
	}
}

classe JPA

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
package com.javacodegeeks.gwtspring.client.server.dao;
 
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import javax.persistence.Query;
 
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.orm.jpa.support.JpaDaoSupport;
 
import com.javacodegeeks.gwtspring.client.shared.dto.EmployeeDTO;
 
public abstract class JpaDAO<K, E> extends JpaDaoSupport {
	protected Class<E> entityClass;
 
	@SuppressWarnings("unchecked")
	public JpaDAO() {
		ParameterizedType genericSuperclass = (ParameterizedType) getClass()
				.getGenericSuperclass();
		this.entityClass = (Class<E>) genericSuperclass
				.getActualTypeArguments()[1];
	}
 
	public void persist(E entity) {
		getJpaTemplate().persist(entity);
	}
 
	public void remove(E entity) {
		getJpaTemplate().remove(entity);
	}
 
	public E merge(E entity) {
		return getJpaTemplate().merge(entity);
	}
 
	public void refresh(E entity) {
		getJpaTemplate().refresh(entity);
	}
 
	public E findById(long id) {
		return getJpaTemplate().find(entityClass, id);
	}
 
	public E flush(E entity) {
		getJpaTemplate().flush();
		return entity;
	}
 
	@SuppressWarnings("unchecked")
	public List<E> findAll() {
		Object res = getJpaTemplate().execute(new JpaCallback<Object>() {
 
			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query q = em.createQuery("SELECT h FROM " +
						entityClass.getName() + " h");
				return q.getResultList();
			}
 
		});
 
		return (List<E>) res;
	}
 
	public Integer removeAll() {
		return (Integer) getJpaTemplate().execute(new JpaCallback<Object>() {
 
			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query q = em.createQuery("DELETE FROM " +
						entityClass.getName() + " h");
				return q.executeUpdate();
			}
 
		});
	}
	@SuppressWarnings("unchecked")
	public ArrayList<EmployeeDTO> pass(final String log, final String passe){
		Object res = getJpaTemplate().execute(new JpaCallback<Object>() {
 
		public Object doInJpa(EntityManager em) throws PersistenceException {
			Query q = em.createQuery("SELECT h FROM " +
					entityClass.getName() + " h where h.login like :log and h.password like :passe").setParameter("log",log).setParameter("passe", passe);
			return q.getResultList();
		}
 
	});
		return (ArrayList<EmployeeDTO> )res;
 
 
 
	}
	public String test (final String cle){
		String hj = null;
		Object res = getJpaTemplate().execute(new JpaCallback<Object>() {
			public Object doInJpa(EntityManager em) throws PersistenceException {
		Query q = em.createQuery("SELECT h FROM "+ entityClass.getName() + " h where h.login like :cle ").setParameter("cle",cle);
		return q.getResultList();		
		}	
		});
		ArrayList<EmployeeDTO>ary=(ArrayList<EmployeeDTO> )res;	
		for
		(Iterator i = ary.iterator();i.hasNext();){
			EmployeeDTO o= (EmployeeDTO) i.next();
            hj= o.getEmployeeName();
		}
		return hj;
 
	}
}

classe EmployeeDao

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.javacodegeeks.gwtspring.client.server.dao;
 
import javax.annotation.PostConstruct;
import javax.persistence.EntityManagerFactory;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
 
import com.javacodegeeks.gwtspring.client.shared.dto.EmployeeDTO;
 
 
@SuppressWarnings("restriction")
@Repository("employeeDAO")
public class EmployeeDAO extends JpaDAO<Long, EmployeeDTO> {
 
	@Autowired
	EntityManagerFactory entityManagerFactory;
 
	@PostConstruct
	public void init() {
		super.setEntityManagerFactory(entityManagerFactory);
	}
 
}

classe d'implementation des services

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
package com.javacodegeeks.gwtspring.client.server;
 
import java.util.ArrayList;
import java.util.Iterator;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import javax.persistence.Query;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.javacodegeeks.gwtspring.client.client.kal;
import com.javacodegeeks.gwtspring.client.server.dao.EmployeeDAO;
import com.javacodegeeks.gwtspring.client.shared.dto.EmployeeDTO;
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
 
 
 
@Service("employeeService1")
public class kalImpl extends RemoteServiceServlet implements kal{
 
	/**
         * 
         */
	private static final long serialVersionUID = 965686776688745392L;
	@Autowired
	private EmployeeDAO employeeDAO;
 
 
	@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 {
 
		EmployeeDTO employeeDTO = new EmployeeDTO(employeeId, name,surname, jobDescription);
 
		employeeDAO.merge(employeeDTO);
 
	}
	public ArrayList<EmployeeDTO> authen(String login , String password)throws Exception{
	return	employeeDAO.pass(login, password);
 
	}
	public String test(String cle)throws Exception{
		String s = employeeDAO.test(cle);
		return s;
 
//		return employeeDAO.test(cle);
	} 
	public String test2 (String dre)throws Exception{
		return dre;
 
	}
 
 
	}

interface des services

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.javacodegeeks.gwtspring.client.client;
 
import java.util.ArrayList;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
import com.javacodegeeks.gwtspring.client.shared.dto.EmployeeDTO;
 
@RemoteServiceRelativePath("kal")
public interface kal 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;
	public ArrayList<EmployeeDTO> authen(String login,String password)throws Exception;
     public String test ( String cle) throws Exception;
     public String test2 ( String dre) throws Exception;
 
}

interfaces Async des services

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.javacodegeeks.gwtspring.client.client;
 
import java.util.ArrayList;
 
import com.google.gwt.user.client.rpc.AsyncCallback;
 
public interface kalAsync {
	 void findEmployee( long employeeId, AsyncCallback<com.javacodegeeks.gwtspring.client.shared.dto.EmployeeDTO> callback );
 
		void  authen(java.lang.String login,java.lang.String password,AsyncCallback<ArrayList<com.javacodegeeks.gwtspring.client.shared.dto.EmployeeDTO>> callback);
 
	    /**
             * GWT-RPC service  asynchronous (client-side) interface
             * @see com.javacodegeeks.gwtspring.client.client.EmployeeService
             */
	    void saveEmployee( long employeeId, java.lang.String name, java.lang.String surname, java.lang.String jobDescription, AsyncCallback<Void> callback );
 
 
	    /**
             * GWT-RPC service  asynchronous (client-side) interface
             * @see com.javacodegeeks.gwtspring.client.client.EmployeeService
             */
	    void updateEmployee( long employeeId, java.lang.String name, java.lang.String surname, java.lang.String jobDescription, AsyncCallback<Void> callback );
 
 
	    /**
             * GWT-RPC service  asynchronous (client-side) interface
             * @see com.javacodegeeks.gwtspring.client.client.EmployeeService
             */
	    void saveOrUpdateEmployee( long employeeId, java.lang.String name, java.lang.String surname, java.lang.String jobDescription, AsyncCallback<Void> callback );
 
 
	    /**
             * GWT-RPC service  asynchronous (client-side) interface
             * @see com.javacodegeeks.gwtspring.client.client.EmployeeService
             */
	    void deleteEmployee( long employeeId, AsyncCallback<Void> callback );
 
		void test(String cle, AsyncCallback<String> callback);
 
		void test2(String dre, AsyncCallback<String> callback);
}

la classe cliente de Gxt

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
package com.javacodegeeks.gwtspring.client.client;
 
import java.util.ArrayList;
 
 
/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class Application1 implements EntryPoint
{
 
	/**
         * The message displayed to the user when the server cannot be reached or
         * returns an error.
         */
	@SuppressWarnings("unused")
	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();
	public kalAsync instance = (kalAsync) GWT.create( kal.class );
	/**
         * This is the entry point method.
         */
	public void onModuleLoad() {
		final Label errorLabel = new Label();
		final TextField<String> login = new TextField<String>();
		final TextField<String> pwd = new TextField<String>();
		final Button auth = new Button("auth");
 
		// Add the nameField and sendButton to the RootPanel
		// Use RootPanel.get() to get the entire body element
		//final RootPanel rootPanel = RootPanel.get("employeeInfoFieldContainer");
		RootPanel.get("errorLabelContainer").add(errorLabel);
		RootPanel.get("employeeLoginContainer").add(login);
		RootPanel.get("employeePwdContainer").add(pwd, 10, 0);
		RootPanel.get("connectEmployeeContainer").add(auth, 96, 23);
		auth.setSize("97px", "36px");
 
		// Create the popup dialog box
		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("<br><b>Server replies:</b>"));
		dialogVPanel.add(serverResponseLabel);
		dialogVPanel.setHorizontalAlign(HorizontalAlignment.RIGHT);
		dialogVPanel.add(closeButton);
 
		// Add a handler to close the DialogBox
 
 
		// Create a handler for the saveOrUpdateButton and employeeInfoField
 
 
		// Create a handler for the retrieveButton and employeeIdField
 
		auth.addSelectionListener(new SelectionListener<ButtonEvent>() {
 
			@Override
			public void componentSelected(ButtonEvent ce) {
				//Info.display("ok", "ok");
				errorLabel.setText("");
				String loginToServer = login.getValue();
				String passToServer = pwd.getValue();
 
				// Then, we send the input to the server.
				auth.setEnabled(false);
				textToServerLabel.setText(loginToServer+passToServer);
				serverResponseLabel.setText("");
 
				//String[] employeeInfo = textToServer.split(" ");
 
				//long employeeId = Long.parseLong(employeeInfo[0]);
				//String employeeName = employeeInfo[1];
				//String employeeSurname = employeeInfo[2];
				//String employeeJobTitle = employeeInfo[3];
 
				/*employeeService.authen(loginToServer,passToServer, new AsyncCallback<ArrayList<EmployeeDTO>>() {
 
 
					public void onSuccess(EmployeeDTO employeeDTO) {
								dialogBox.setText("Remote Procedure Call");
								serverResponseLabel
										.removeStyleName("serverResponseLabelError");
								if(employeeDTO != null)
									serverResponseLabel.setHTML("Employee Information <br>Id : " + employeeDTO.getEmployeeId() + "<br>Name : " + employeeDTO.getEmployeeName() + "<br>Surname : " + employeeDTO.getEmployeeSurname() + "<br>Job Title : " + employeeDTO.getJob());
								else
									serverResponseLabel.setHTML("Mauvaise Connexion");
								dialogBox.center();
								closeButton.setFocus(true);								
							}
 
					public void onSuccess(ArrayList<EmployeeDTO> emp) {
						serverResponseLabel
						.removeStyleName("serverResponseLabelError");
						if(emp !=null){
							for (@SuppressWarnings("rawtypes")
									Iterator i = emp.iterator();i.hasNext();){
								EmployeeDTO eto= (EmployeeDTO) i.next();
 
								//serverResponseLabel.setHTML("Employee Information <br>Id : " + eto.getEmployeeId() + "<br>Name : " + eto.getEmployeeName() + "<br>Surname : " + eto.getEmployeeSurname() + "<br>Job Title : " + eto.getJob());
							}
							MessageBox.alert("ok", "ok", null);
				}
						else 
 
							MessageBox.alert("mauvaise ok", "mauvaise ok", null);
 
 
					}
					public void onFailure(Throwable caught) {
						// Show the RPC error message to the user
						MessageBox.alert("pas ok", "pas ok", null);
					}
				});*/
				Info.display(loginToServer, passToServer);
				instance.test2("an", new AsyncCallback<String>() {
 
					@Override
					public void onFailure(Throwable caught) {
						// TODO Auto-generated method stub
 
						MessageBox.alert("ju","not ok", null);						
 
					}
 
					@Override
					public void onSuccess(String result) {
						MessageBox.alert("hhh", "ok", null);						
					}
 
 
 
				});
			}
		});		
 
 
		/**
                 * Fired when the user clicks on the saveOrUpdateButton.
                 */
 
 
		/**
                 * Fired when the user types in the employeeInfoField.
                 */
 
 
		/**
                 * Send the employee info from the employeeInfoField to the server and wait for a response.
                 */
 
 
 
		// Add a handler to send the employee info to the server
 
		// Add a handler to send the employee id to the server
 
		// Add a handler to send the employee id to the server to delete an employee
 
		// Add a handler to send the employee id to the server to log an employee
	}
}

à noter que si j'utilise la méthode test 2 j'ai aucun probléme , mais en utilisant test je me trouve bloquer dans Onfailure().

j'éspére que vous avez une idée à propos de ma faute.