Recuperar valor de Hashtable

[e-junior 0]

Pessoal boa tarde.

 

Estou tentando recuperar o valor de um Hashtable mais não estou conseguindo, se alguem puder ajudar agradeço.

 

Já coloquei o valor na unha mais ele não é setado.

 

#####Container.java#####

   public class Container {  

       //objeto utilizado para armazenar dados da aplicação do lado cliente  
       private static Hashtable container = new Hashtable();   

       public static Hashtable getContainer(){  
           return container;  
       }  

       public static void setContainer(UsuarioVO usuarioVO){  
           container.put("usuario", usuarioVO);  
           //container.put("empresa", usuarioVO.getColaborador().getPessoa().getEmpresa());  
           container.put("empresa", 1);  
       }  

   }  

 

#####CargoGridInsertAction.java#####

   public final Response executeCommand(Object inputPar, UserSessionParameters userSessionPars, HttpServletRequest request, HttpServletResponse response, HttpSession userSession, ServletContext context) {  
           Session session = null;  
           try {  
               java.util.List<CargoVO> list = (ArrayList) inputPar;  

               CargoVO vo = list.get(0);  

               EmpresaVO empresa = (EmpresaVO) Container.getContainer().get("empresa");  
               vo.setEmpresa(empresa);  

               session = HibernateUtil.getSessionFactory().getCurrentSession();  
               session.beginTransaction();  
               session.save(vo);  
               session.flush();  
               session.getTransaction().commit();  
               return new VOListResponse(list,false,list.size());  
           } catch (Exception ex) {  
               ex.printStackTrace();  
               return new ErrorResponse(ex.getMessage());  
           } finally {  
               try {  
                   session.close();  
               } catch (Exception ex1) {  
               }  
           }  
       }  

 

#####CargoVO.java#####

@Entity  
@Table(name = "cargo")  
@NamedQueries({  
   @NamedQuery(name = "CargoVO.findAll", query = "SELECT c FROM CargoVO c")})  
public class CargoVO extends ValueObjectImpl implements Serializable {  
   private static final long serialVersionUID = 1L;  
   @Id  
   @GeneratedValue(strategy = GenerationType.IDENTITY)  
   @Basic(optional = false)  

   @Column(name = "ID")  
   private Integer id;  

   @Column(name = "NOME")  
   private String nome;  

   ...  

   @JoinColumn(name = "ID_EMPRESA", referencedColumnName = "ID")  
   @ManyToOne(optional = false)  
   private EmpresaVO empresa;  

   public EmpresaVO getEmpresa() {  
       return empresa;  
   }  

   public void setEmpresa(EmpresaVO empresa) {  
       this.empresa = empresa;  
   }  

[guidjos 65]

Em primeiro lugar, sempre que puder, declare a variável que armazenará a referência a seu novo objeto com o tipo da interface que a classe do objeto em questão implementa. No caso de Hashtable, a interface é Map. No caso de ArrayList, a interface é List. Isso permite que, mais pra frente, se sua equipe decidir que é melhor usar algum outro tipo de dados (por motivos que vocês não conhecem agora), contanto que a interface implementada não mude, vocês só precisam trocar umas poucas linhas de código - já que os métodos são praticamente todos iguais. Isso dá flexibilidade além de qualquer hierarquia de classes.

 

Aqui está um exemplo de uso simples de uma Hashtable:

 

import java.util.Map;
import java.util.Hashtable;

public class HTTest
{
   public static void main(String args[])
   {
Map<String, String> container = new Hashtable<String, String>();

container.put("Chave", "Valor");

       // extraindo valor baseado numa chave
System.out.println(container.get("Chave"));
   }
}

 

Em segundo lugar, defina os parâmetros de tipos para a Hashtable que pretende usar (como eu fiz acima). Faça isso sempre que estiver trabalhando com tipos genéricos. O único motivo pelo qual seu código compila (e aposto que seu compilador lhe avisa que seu código faz uso de operações perigosas) é que códigos antigos (de tempos anteriores à generificação da API) não forneciam informações sobre tipos de parâmetros, e é comum (leia necessário) trabalhar com eles. Todo e qualquer código novo, contudo, deve usar os parâmetros de tipos para garantir checagem de tipo em tempo de compilação. Como Java usa type erasure, em tempo de execução não há informação nenhuma sobre os tipos usados pelos genéricos - sem que os parâmetros de tipos ajudem o compilador a verificar todos os usos de suas classes em tempo de compilação, você pode ficar à mercê de erros em tempo de execução, e tem que rezar pra que seus testes os peguem.

 

Em terceiro, sugiro que reveja seu design. Sua classe Container retorna uma referência a um objeto mutável interno a ela. Da forma como está, ela serve simplesmente como uma instância estática de Hashtable. Se for fazer uma classe que provê acesso a uma Hashtable específica, forneça os métodos que deseja suportar na classe Container e faça esta classe chamar os métodos de Map. Se mais pra frente vocês decidirem implementar mais funcionalidades na Container, o fato de que qualquer cliente pode obter uma referência à Hashtable armazenada por ela pode gerar problemas de segurança. Isso deve ser levado em consideração sempre que qualquer campo de sua classe for mutável. Se a necessidade do método getContainer realmente existir, sugiro que retorne uma cópia da Hashtable (ou melhor, do Map) interna(o). Assim você garante que nenhum cliente vai modificá-la(o) sem que você saiba - isso só será feito usando os métodos que você implementar:

 

public static Map<String, UsuarioVO> get() {
   return new Hashtable<String, UsuarioVO>();
}

 

Obviamente, chamar o método acima desnecessariamente pode ser problemático por questões de performance (tanto tempo quanto espaço), principalmente se muitos elementos tiverem sido inseridos. É, contudo, a única forma de garantir os invariantes da classe Container.