Factory, Generics e Reflection

Mude a assinatura para

public final class ManagerFactory {

public synchronized <E extends Entity > Manager <E> (Class<E> entity) {
}

Valeu, Taborda.

A assinatura ficou assim: public synchronized <E extends Entity> Manager<E, Long> getManager(final Class<E> entity) { }

Mas mesmo assim continuo tendo as mesmas advertências graças à: domainManager = domainManagerClass.newInstance();

Será que há como colocar parâmetro de tipo numa instância criada por reflection?

Sem o resto do codigo fica difficil, por exemplo, que tipo é domainManagerClass ?

Se for Manager<E> o domainManagerClass.newInstance() deve retornar Manager<E> tb.

Tb tens que declarar <E> em todos os Manager dentro do método como em

Manager<E> domainManager = null;

sergiotaborda:

Tb tens que declarar <E> em todos os Manager dentro do método como em

Manager<E> domainManager = null;

/**
 * Fábrica de <tt>Manager</tt>s.
 *
 * Os Manager's são armazenados em cache sob demanda, de modo que
 * só exista uma instância para cada Manager.
 *
 * @author Rafael Fiume
 *
 * @see DomainManager
 * @see ManagerClass
 */
public final class ManagerFactory {

    /**
     * A única instância de <tt>ManangerFactory</tt>.
     *
     * @see Singleton GoF patterns // PENDING colocar link
     */
    private static ManagerFactory factory;

    /**
     * Cache para os <tt>Manager</tt> instanciados através de
     * {@link #getManager(Class)}.
     */
    private static Map<Class, Manager> cache = new HashMap<Class, Manager>();

    private ManagerFactory() {
        super();
    }

    /**
     * Retorna uma instância de <tt>ManagerFactory</tt>.
     */
    public synchronized static ManagerFactory getInstance() {
        if (factory == null) {
            factory = new ManagerFactory();
        }
        return factory;
    }

    /**
     * Cria sob demanda a implementação de <tt>Manager</tt> definida
     * para o tipo de <tt>Entity</tt>. Depois de instanciado,
     * o <tt>Manager</tt> é armazenado em cache.
     *
     * @param  entity a entidade cujo <tt>Manager</tt> deverá ser criado.
     * @return Retorna implementação de <tt>Manager</tt> adeqüada ao tipo de
     *         <tt>iboi.domain.Entity</tt>.
     * @throws DomainManagerFactoryException caso não exista um
     *         <tt>Manager</tt> definido para o tipo de <tt>Entity</tt>.
     *
     * @see DomainManager
     * @see ManagerClass
     * @see iboi.domain.Entity
     */
    @SuppressWarnings("")
    public synchronized <E extends Entity> Manager<E, Long> getManager(final Class<E> entity) {

        if (!entity.isAnnotationPresent(ManagerClass.class)) {
            throw new ManagerFactoryException(
                    "Não existe um EntityManager para essa entidade.");
        }

        final ManagerClass domainManagerClassAnnotation =
                entity.getAnnotation(ManagerClass.class);

        final Class&lt? extends Manager&gt domainManagerClass =
                domainManagerClassAnnotation.value();

        Manager<E, Long> domainManager = null;

        if (cache.containsKey(domainManagerClass)) {
            return cache.get(domainManagerClass);

        } else {
            try {
                // aqui gera warning
                domainManager = domainManagerClass.newInstance();
            } catch (Exception ex) {
                throw new ManagerFactoryException(ex);
            } 
            cache.put(domainManagerClass, domainManager);
        }

        return domainManager;
    }
}

Quando instancio um Manager via reflection, eu ainda obtenho um Manager sem parâmetro de tipo:

found : capture#7 of ? extends iboi.domain.service.manager.Manager
required: iboi.domain.service.manager.Manager<E,java.lang.Long>
domainManager = domainManagerClass.newInstance();

Como visto, domainManagerClass é apenas uma instância de Class<? extends Manager>.

Alguma idéia?

Class &lt? extends Entity&gt não serve. Experimenta

(...)

        final Manager<E,Long> domainManagerClass =
                (Manager<E,Long>)domainManagerClassAnnotation.value();

            (..)

Não podes usar ‘?’. O que tu queres é vincular todos os tipos Manager à entidade que passas com o argumento e que é referenciada por E.

sergiotaborda:

Class &lt? extends Entity&gt não serve. Experimenta

(...)

        final Manager<E,Long> domainManagerClass =
                (Manager<E,Long>)domainManagerClassAnnotation.value();

            (..)

Não podes usar ‘?’. O que tu queres é vincular todos os tipos Manager à entidade que passas com o argumento e que é referenciada por E.

Isso não vai dar certo, Taborda. domainManagerClass é uma instância de Class, não de Manager.

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface ManagerClass { Class&lt? extends Manager&gt value(); }

Eu uso a anotação ManagerClass na entidade pare definir qual o seu Manager. <EDITADO> Isto é, qual a sua classe Manager, e não uma instância dessa classe. A instância eu quero obter pela factory. </EDITADO>

<EDITADO value=“de novo”>Onde você viu Class &lt? extends Entity&gt ??</EDITADO>

coloque

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) public @interface ManagerClass { Class<Manager>? extends Entity&gt value(); }

E troque domainManagerClass para Class<Manager><E,Long>&gt

Boa sugestão!

Fiz as mudanças sugeridas, mas ainda não funcionou. Ao invés de warnings, estou com erro agora.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ManagerClass {
    Class&lt? extends Manager&lt? extends Entity, Long&gt&gt value();
}

Class<Manager><? extends Entity, Long>> faz mais sentido do que Class<? extends Manager> , que era como estava antes.

public final class ManagerFactory {

   . . .
    
    public synchronized <E extends Entity> Manager<E, Long> getManager(final Class<E> entity) {

        if (!entity.isAnnotationPresent(ManagerClass.class)) {
            throw new ManagerFactoryException(
                    "Não existe um EntityManager para essa entidade.");
        }

        final ManagerClass domainManagerClassAnnotation =
                entity.getAnnotation(ManagerClass.class);

        final Class<Manager><E, Long>&gt domainManagerClass =
                domainManagerClassAnnotation.value();

        Manager<E, Long> domainManager = null;

        if (cache.containsKey(domainManagerClass)) {
            return (Manager<E, Long>) cache.get(domainManagerClass);

        } else {
            try {
                domainManager = domainManagerClass.newInstance();
            } catch (Exception ex) {
                throw new ManagerFactoryException(ex);
            } 
            cache.put(domainManagerClass, domainManager);
        }

        return domainManager;
    }
}

De novo, Class<Manager><E, Long>> domainManagerClass... está mais exato do que antes, Class<? extends Manager> domainManagerClass...

Porém,

compilador:

found : java.lang.Class<capture#886 of ? extends iboi.domain.service.manager.Manager><? extends iboi.domain.Entity,java.lang.Long>>
required: java.lang.Class<iboi.domain.service.manager.Manager><E,java.lang.Long>>
domainManagerClassAnnotation.value();

Pra mim era óbvio que as duas coisas são o mesmo, mas o mundo (e a JDK) não são cheios de surpresas?

RafaelRio:

Porém,

compilador:

found : java.lang.Class<capture#886 of ? extends iboi.domain.service.manager.Manager>&lt? extends iboi.domain.Entity,java.lang.Long&gt&gt
required: java.lang.Class<iboi.domain.service.manager.Manager><E,java.lang.Long>&gt
domainManagerClassAnnotation.value();

O compilador está embaçando com o <E extends Entity> na assinatura de getManager, dizendo que é diferente do &lt? extends Entity&gt de value em ManagerClass. :shock:

Pra mim era óbvio que as duas coisas são o mesmo, mas o mundo (e a JDK) não são cheios de surpresas?

O erro eu solucionei com Class&lt? extends Manager&gt domainManagerClass…. Ou seja, de volta a estaca zero.

Será que tem jeito?

Aehh!! Não é que tem jeito?!

Pra fazer funcionar declarei

private final Manager<E, Long> manager;

e incializei com a factory invocando o método com o argumento de tipo

ManagerFactory.getInstance().<E>getManager(entityClass);

A idéia é pedir “me dê um gerenciador para tal entidade”, assim o cliente não precisa saber quem é a implementação do manager para tal entidade. Esses detalhes ficam com a factory. Ao mesmo tempo, usar classes genéricas, seguir o mantra open for extension, closed for modification e utilizar reflection na factory para evitar montes de if/elses.

RafaelRio:

Aehh!! Não é que tem jeito?!

Parabéns. Desculpe não ter continuado o dialogo , mas estou meio sem tempo. Vc reparou que usa um Long como tipo generico fixo (ou seja, é sempre um long e não extends Long) ? Isso significa que na realidade isso é um tipo estático
Se as suas chaves são sempre Long não precisa definir o tipo como generico.
Em opção elas podem ser de uma certa interface. vc usa essa interface estáticamente e pode implementá-la com Long ou qq outro objeto. Pense nisso…

Tranqüilo, Taborda! Mesmo porque ainda não está tudo resolvido (diria que 50%) apesar das minhas vibrações. O cliente que usa a factory está ok. No entanto, ainda estou com problemas em mapear o manager da anotação para a fábrica e instanciar o manager correto via reflection (isso eu ainda não sei se tem jeito) :(. Também tenho que arranjar outra forma de declarar e inicializar o cache. :roll:

sergiotaborda:

Vc reparou que usa um Long como tipo generico fixo (ou seja, é sempre um long e não extends Long) ? Isso significa que na realidade isso é um tipo estático
Se as suas chaves são sempre Long não precisa definir o tipo como generico.

A verdade é que eu ainda não decidi exatamente o que fazer com a chave primária. Se eu seguir sua sugestão, todas as entidades terão que ter ID tipo Long; se eu precisar definir o tipo como argumento na factory, terei que expor os clientes a esse tipo de detalhe…

Mas isso é o de menos agora, não estou preocupado. A prioridade é fazer a coisa funcionar direito (eliminar todos os warnings), e, conforme eu for progredindo, eu escrevo aqui. É claro que estou interessado em sugestões!