3
respostas

Estou tentando criar uma implementação igual a da aula mais como uma classe que criei e não estou conseguindo obter o caminho da classe para fazer o load.

Segue o codigo abaixo. Mas te eu tenho o objeto e pego a classe dele , como faço para obter o valor que estamos inserindo como value do mapa ?

Nos exemplos alimentamos o mapa da seguinte forma :

  Map<String, String> myMap = new HashMap<String, String>();
        myMap.put("ArrayList","java.util.ArrayList");

Neste Caso quero fazer algo :

  Map<String, String> myMap = new HashMap<String, String>();
        myMap.put("MInhaClasse", new MinhaClasse().getClass().getPath());  

Obs.: getPath não existe é apenas para deixar claro o que estou tentando fazer.

Segue abaixo o meu código: ( Tudo esta dentro da mesma classe )

public class ClassMap{
        private Map<String,String> map;

        public void setMap(Map<String, String> map) {
            this.map = map;
        }

        // Here we do the loading of the class and return
        public Class getClass(String keyClass) throws Exception{
            String v = map.get(keyClass);
            if(v != null){
                return Class.forName(v);
            }else{
                throw new RuntimeException("Not found with this key");
            }
        }

        // To create new instance of a empty object
        public <E> E getObject(String keyClass) throws Exception {
            return (E) getClass(keyClass).newInstance();
        }

        // To create new instance of a object with values
        public <E> E getObjectWithParams(String keyClass, Object... params) throws Exception {
            Class<?> myClassImplementation = getClass(keyClass);
            Class<?>[] constructorTypes = new Class<?>[params.length];
            // Get the types of params
            for(int i=0; i < constructorTypes.length; i++ ){
                constructorTypes[i] = params[i].getClass();
            }
            // Create the constructor by quantity and types of params
            Constructor<?> constructor = myClassImplementation.getConstructor(constructorTypes);
            return (E) constructor.newInstance(params);
        }

    }

    public class myClassTeste {

        private String A;
        private String B;
        private String C;

        public myClassTeste(){

        }

        public myClassTeste(String a, String b, String c) {
            A = a;
            B = b;
            C = c;
        }

        public String getA() {
            return A;
        }

        public void setA(String a) {
            A = a;
        }

        public String getB() {
            return B;
        }

        public void setB(String b) {
            B = b;
        }

        public String getC() {
            return C;
        }

        public void setC(String c) {
            C = c;
        }

    }

    @Test
    public void testClassMap(){
        // create new instance of a object with values
        ClassMap classMap2 = new ClassMap();
        Map<String, String> myMap2 = new HashMap<String, String>();
        myMap2.put("myClassTeste", new myClassTeste().getClass().getName());
        classMap2.setMap(myMap2);

        try {
            String[] values = {"A","B","C"};
            ArrayList<?> myOjectWithValues = classMap2.getObjectWithParams("myClassTeste", values );
            myOjectWithValues.forEach(s -> System.out.println());
        }catch (Exception r){
            System.out.println(r);
        }

    }
3 respostas

Você pode recuperar esse valor utilizando o método get() da classe map, em que você passa a chave como parâmetro. Segue um exemplo:

map.get(chave)

Não da porque para eu usar o map.get(chave) teria que ter setado o valor dentro do map. Eu já resolvi o código porém a minha dúvida de como através de um objeto obter o caminho dele dentro da aplicação ainda persiste.

Para que um objeto seja acessível, precisa haver alguma referência para ele. A partir do momento que não existe referência para ele, ele fica elegível para ser recolhido pelo Garbage Collector. Não existe uma forma de obter, a partir da referência de uma classe, os objetos dela que não foram instanciados.