Logiciel de saisie des requêtes nommées dans un résumé, DAO, JPA

J'ai un résumé de DAO classe qui utilise le type paramétré E (Entité) et K (Clé Primaire). Dans chaque entité, j'ai un @NamedQuery. Je veux invoquer dynamiquement cette requête nommée sans connaître son nom exact et le nom du paramètre.

Comme un exemple, imaginer la suite de l'entité City

@Entity(name="CITY")
@NamedQuery(
    name="findCityByname",
    query="FROM CITY c WHERE name = :CityName"
)
public class City { 
    //...
}

et ce CityDao

public class CityDao extends AbstractDao<City, Long> {
    public CityDao() {
        super(City.class);
    }   
}

Comment dois-je mettre en œuvre les findByName() méthode dans AbstractDao de sorte que je n'ai pas besoin de connaître le nom exact et le nom du paramètre?

public abstract class AbstractDao<E, K> implements Dao<E, K> {

    @PersistenceContext
    protected EntityManager entityManager;
    protected Class<E> entityClass;

    protected AbstractDao(Class<E> entityClass) {
        this.entityClass = entityClass; 
    }

    @Override
    public E findByName(String name) {
        try {
            return (E) entityManager
                .createNamedQuery("findCityByName")
                .setParameter("CityName", name)
                .getSingleResult();
        } catch(Exception e) {
            return null;
        }
    }

    //...
}

OriginalL'auteur yoav.str | 2011-02-03

11

La convention de nommage pour les requêtes nommées est généralement <Entity Name>.findBy<PropertyAndAnotherProperty>, "de la Ville.findByName" dans votre exemple, je voudrais donc essayer de modifier les requêtes nommées à suivre ce modèle. Le paramètre de cette requête devrait également avoir le même nom, ou vous pouvez utiliser les paramètres positionnels. Votre méthode de recherche se transforme alors en
```
@Override
public E findByName(String name) {
    E entity = null;
    try {
        return (E)entityManager.createNamedQuery(myClass.getSimpleName() + ".findByName")
                               .setParameter("name", name)
                               .getSingleResult();
    } catch (Exception ex) {
        return null;
    }
}
```
OriginalL'auteur Jörn Horstmann

La méthode la plus simple est de passer le nom de la requête pour le constructeur de l'abstrait DAO:

public DaoAbstreact(Class myClass, String findByNameQueryName) {
    this.myClass = myClass; 
    this.findByNameQueryName = findByNameQueryName;
}

Puis de définir un public static final String dans la Ville pour conserver le nom:

public class ConcreteCityDao<City,Long> extends DaoAbstreact {    
    ConcreteCityDao(){
        super(City.class, City.FIND_BY_NAME_QUERY_NAME));
    }   
}

Vous pouvez également déclarer DaoAbstreact abstraite, et ensuite une méthode comme ceci:

public abstract String getFindByNameQueryName();

Et à mettre en œuvre que dans ConcreteCityDao.

Enfin, vous pourrez également introduire une énumération:

public enum NamedEntityType {
    CITY(City.class, "findCityByname"), 
    PERSON(Person.class, "findPersonByname");

    private final Class<?> entityClass;

    private final String findByNameQueryName;

    private NamedEntityType(Class<?> entityClass, String findByNameQueryName) {
         this.entityClass = entityClass;
         this.findByNameQueryName = findByNameQueryName;
    }

    public Class<?> getEntityClass() {
        return entityClass;
    }

    public String getFindByNameQueryName() {
        return findByNameQueryName;
    }
}

Alors votre DAO pouvez déterminer le type de la classe passée. Pour vous assurer que vous n'oubliez pas d'ajouter une entité à l'énumération, vous pouvez faire de chaque entité de mettre en œuvre une interface avec un getNamedEntityType() la méthode. Ensuite, vous pouvez spécifier que votre abstraite générique DAO acceptera uniquement les entités qui implémentent cette interface.

il est frappant de la notion de " je veux vivre avec le concept de tri de speck...

OriginalL'auteur Russ Hayward

Le moyen le plus évident serait de transmettre des valeurs de classes concrètes de la super-classe abstraite à l'aide de abstract méthode

public abstract class AbstractDao<E, K extends Serializable> implements Dao <E, K> {
    ...
    protected abstract String getFindByNameQueryName();

    @Override
    public E findByName(String EntityStr) { 
        ... entityManager.createNamedQuery(getFindByNameQueryName()) ...
    }
}

@Override
public class ConcreteCityDao<City,Long> extends DaoAbstreact{
    ...
    protected String getFindByNameQueryName() { 
        return "findCityByName";
    }
}

ou comme un argument du constructeur:

public abstract class AbstractDao<E, K extends Serializable> implements Dao<E, K> {
    public AbstractDao(Class<E> myClass, String findByNameQueryName) { ... }
    ...
}

@Override
public class ConcreteCityDao<City, Long> extends DaoAbstreact{
    public ConcreteCityDao() {
        super(City.class, "findCityByName");
    }
}

Bien que cela nécessite cohérent de nommage des paramètres de requête pour différentes entités.

Également note des améliorations mineures dans ces extraits.

OriginalL'auteur axtavt

0

Ce que vous avez l'air de vouloir consiste à annoter les annotations qui définissent les requêtes nommées, de telle manière que vous pouvez par programme à découvrir ce qu'est la "findByName" requête est (et éventuellement d'autres requêtes).

Puisque ce n'est pas possible en Java, vous pouvez utiliser le fait que @NamedQuery prend en charge les indicateurs de requête, qui sont définis comme étant spécifiques au fournisseur. Inconnu conseils sont ignorés. Vous pouvez ajouter vos propres données ici, que le générique de DAO peuvent lire de la entityClass:
```
@NamedQuery(
    name="findCityByname",
    query="FROM CITY c WHERE name = :CityName",
    hints=@QueryHint(name="genericDAO.type", value="findByName")
)
```
OriginalL'auteur Arjan Tijms

Vous devez vous connecter pour publier un commentaire.