Est-il possible pour une classe d'hériter de la annotaions de la super-classe

Je suis en utilisant le Framework Spring transactionnelle annotations pour les opérations de gestion et j'ai une classe abstraite annoté @Transactional comme on le voit ci-dessous:

package org.tts.maqraa.service;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.persistence.EntityManager;
import javax.persistence.EntityNotFoundException;
import javax.persistence.PersistenceContext;
import javax.persistence.PersistenceContextType;
import javax.persistence.Query;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Parts of this code have been copied from JARVANA site.
* 
* @author Younis alomoush
* 
*/
@Transactional(propagation=Propagation.REQUIRED)
public abstract class AbstractMaqraaService implements MaqraaService {
private Logger logger = LoggerFactory.getLogger(this.getClass());
private int defaultMaxResults = DEFAULT_MAX_RESULTS;
@PersistenceContext(type=PersistenceContextType.TRANSACTION)
private EntityManager em;
/**
* The {@link EntityManager} which is used by all query manipulation and
* execution in this DAO.
* 
* @return the {@link EntityManager}
*/
public  EntityManager getEntityManager(){
return em;
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#getTypes()
*/
public abstract Set<Class<?>> getTypes();
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#store(java.lang.Object)
*/
@Transactional(propagation = Propagation.REQUIRED)
public <T extends Object> T store(T toStore) {
return getEntityManager().merge(toStore);
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#remove(java.lang.Object)
*/
@Transactional(propagation = Propagation.REQUIRED)
public void remove(Object toRemove) {
toRemove = getEntityManager().merge(toRemove);
getEntityManager().remove(toRemove);
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#flush()
*/
@Transactional(propagation = Propagation.REQUIRED)
public void flush() {
getEntityManager().flush();
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#refresh(java.lang.Object)
*/
@Transactional(propagation = Propagation.SUPPORTS)
public void refresh(Object o) {
try {
if (o != null) {
if (o instanceof java.util.Collection) {
for (Iterator<?> i = ((Collection<?>) o).iterator(); i
.hasNext();) {
try {
refresh(i.next());
} catch (EntityNotFoundException x) {
//This entity has been deleted - remove it from the
//collection
i.remove();
}
}
} else {
if (getTypes().contains(o.getClass())) {
getEntityManager().refresh(o);
}
}
}
} catch (EntityNotFoundException x) {
//This entity has been deleted
}
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#setDefaultMaxResults(int)
*/
@Transactional(propagation = Propagation.SUPPORTS)
public void setDefaultMaxResults(int defaultMaxResults) {
this.defaultMaxResults = defaultMaxResults;
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#getDefaultMaxResults()
*/
public int getDefaultMaxResults() {
return defaultMaxResults;
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQueryByNameSingleResult(java
* .lang.String)
*/
@SuppressWarnings("unchecked")
public <T extends Object> T executeQueryByNameSingleResult(String queryName) {
return (T) executeQueryByNameSingleResult(queryName, (Object[]) null);
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQueryByNameSingleResult(java
* .lang.String, java.lang.Object[])
*/
@SuppressWarnings("unchecked")
public <T extends Object> T executeQueryByNameSingleResult(
String queryName, Object... parameters) {
Query query = createNamedQuery(queryName, DEFAULT_FIRST_RESULT_INDEX,
1, parameters);
return (T) query.getSingleResult();
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQueryByName(java.lang.String)
*/
public <T extends Object> List<T> executeQueryByName(String queryName) {
return executeQueryByName(queryName, DEFAULT_FIRST_RESULT_INDEX,
getDefaultMaxResults());
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQueryByName(java.lang.String,
* java.lang.Integer, java.lang.Integer)
*/
public <T extends Object> List<T> executeQueryByName(String queryName,
Integer firstResult, Integer maxResults) {
return executeQueryByName(queryName, firstResult, maxResults,
(Object[]) null);
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQueryByName(java.lang.String,
* java.lang.Object[])
*/
public <T extends Object> List<T> executeQueryByName(String queryName,
Object... parameters) {
return executeQueryByName(queryName, DEFAULT_FIRST_RESULT_INDEX,
getDefaultMaxResults(), parameters);
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQueryByName(java.lang.String,
* java.lang.Integer, java.lang.Integer, java.lang.Object[])
*/
@SuppressWarnings("unchecked")
public <T extends Object> List<T> executeQueryByName(String queryName,
Integer firstResult, Integer maxResults, Object... parameters) {
Query query = createNamedQuery(queryName, firstResult, maxResults,
parameters);
return query.getResultList();
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#createNamedQuery(java.lang.String,
* java.lang.Integer, java.lang.Integer)
*/
public Query createNamedQuery(String queryName, Integer firstResult,
Integer maxResults) {
return createNamedQuery(queryName, firstResult, maxResults,
(Object[]) null);
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#createNamedQuery(java.lang.String,
* java.lang.Integer, java.lang.Integer, java.lang.Object[])
*/
public Query createNamedQuery(String queryName, Integer firstResult,
Integer maxResults, Object... parameters) {
Query query = getEntityManager().createNamedQuery(queryName);
if (parameters != null) {
for (int i = 0; i < parameters.length; i++) {
query.setParameter(i + 1, parameters[i]);
}
}
query.setFirstResult(firstResult == null || firstResult < 0 ? DEFAULT_FIRST_RESULT_INDEX
: firstResult);
if (maxResults != null && maxResults > 0)
query.setMaxResults(maxResults);
return query;
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#executeQuery(java.lang.String,
* java.lang.Integer, java.lang.Integer, java.lang.Object[])
*/
@SuppressWarnings("unchecked")
public <T extends Object> List<T> executeQuery(String queryString,
Integer firstResult, Integer maxResults, Object... parameters) {
Query query = createQuery(queryString, firstResult, maxResults,
parameters);
return query.getResultList();
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#executeQuery(java.lang.String,
* java.lang.Object[])
*/
@SuppressWarnings("unchecked")
public <T extends Object> List<T> executeQuery(String queryString,
Object... parameters) {
Query query = createQuery(queryString, DEFAULT_FIRST_RESULT_INDEX,
getDefaultMaxResults(), parameters);
return query.getResultList();
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQuerySingleResult(java.lang.
* String)
*/
@SuppressWarnings("unchecked")
public <T extends Object> T executeQuerySingleResult(String queryString) {
return (T) executeQuerySingleResult(queryString, (Object[]) null);
}
/*
* (non-Javadoc)
* 
* @see
* org.skyway.spring.util.dao.JpaDao#executeQuerySingleResult(java.lang.
* String, java.lang.Object[])
*/
@SuppressWarnings("unchecked")
public <T extends Object> T executeQuerySingleResult(String queryString,
Object... parameters) {
Query query = createQuery(queryString, DEFAULT_FIRST_RESULT_INDEX, 1,
parameters);
return (T) query.getSingleResult();
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#createQuery(java.lang.String,
* java.lang.Integer, java.lang.Integer)
*/
public Query createQuery(String queryString, Integer firstResult,
Integer maxResults) {
return createQuery(queryString, firstResult, maxResults,
(Object[]) null);
}
/*
* (non-Javadoc)
* 
* @see org.skyway.spring.util.dao.JpaDao#createQuery(java.lang.String,
* java.lang.Integer, java.lang.Integer, java.lang.Object[])
*/
public Query createQuery(String queryString, Integer firstResult,
Integer maxResults, Object... parameters) {
Query query = getEntityManager().createQuery(queryString);
if (parameters != null) {
for (int i = 0; i < parameters.length; i++) {
query.setParameter(i + 1, parameters[i]);
}
}
query.setFirstResult(firstResult == null || firstResult < 0 ? DEFAULT_FIRST_RESULT_INDEX
: firstResult);
if (maxResults != null && maxResults > 0)
query.setMaxResults(maxResults);
return query;
}
public final void log(LogLevel logLevel, String message,
Object... messageParam) {
switch (logLevel) {
case TRACE:
if (logger.isTraceEnabled()) {
logger.trace(message, messageParam);
}
break;
case DEBUG:
if (logger.isDebugEnabled()) {
logger.debug(message, messageParam);
}
break;
case INFO:
if (logger.isInfoEnabled()) {
logger.info(message, messageParam);
}
break;
case WARN:
if (logger.isWarnEnabled()) {
logger.warn(message, messageParam);
}
break;
case ERROR:
if (logger.isErrorEnabled()) {
logger.error(message, messageParam);
}
break;
default:
throw new IllegalArgumentException("Log Level is not defined: "
+ logLevel);
}
}
public final void log(LogLevel logLevel,  String message, Throwable throwable) {
switch (logLevel) {
case TRACE:
if (logger.isTraceEnabled()) {
logger.trace(message, throwable);
}
break;
case DEBUG:
if (logger.isDebugEnabled()) {
logger.debug(message, throwable);
}
break;
case INFO:
if (logger.isInfoEnabled()) {
logger.info(message, throwable);
}
break;
case WARN:
if (logger.isWarnEnabled()) {
logger.warn(message, throwable);
}
break;
case ERROR:
if (logger.isErrorEnabled()) {
logger.error(message, throwable);
}
break;
default:
throw new IllegalArgumentException("Log Level is not defined: "
+ logLevel);
}
}
public enum LogLevel{
TRACE, DEBUG, INFO, WARN, ERROR;
}
}

Aussi, j'ai une autre classe de béton

package org.tts.maqraa.service;
import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.tts.maqraa.data.Student;
public class StudentsService extends AbstractMaqraaService {
@Override
public Set<Class<?>> getTypes() {
Set<Class<?>> set = new HashSet<Class<?>>();
set.add(Student.class);
return set;
}
public Student registerStudent(Student student) {
Annotation [] annotation = StudentsService.class.getAnnotations();
System.out.println(annotation);
return this.store(student);
}
public Student editStudent(Student student){
return this.store(student);
}
public void deregisterStudent(Student student){
this.remove(student);
}
public List<Student> findAllStudents(){
return this.executeQueryByName("Student.findAll");
}
}

Si vous remarquez que la méthode d'inscrire l'étudiant a déjà fourni le code pour examiner les annotations où j'ai vraiment trouver le @Transactional annotation.

C'est une contradiction là où j'ai un autre lien parle de l'héritage des annotations et il dit qu'il n'y a pas d'héritage à tous.

examen ce lien: http://fusionsoft-online.com/articles-java-annotations.php

Quelqu'un peut-il m'aider à résoudre cette contradiction ?

InformationsquelleAutor Mohammed Amr | 2012-05-15

16

Annotation de l'héritage fonctionne essentiellement de la même façon que l'héritage des méthodes ou des champs.

Puisque vous pouvez accéder aux annotations uniquement par le biais de la réflexion, il existe deux méthodes de base dans Class:
- getAnnotations() retourne toutes les annotations sur la classe actuelle et de ses super-classes
- getDeclaredAnnotations() retourne toutes les annotations sur la classe actuelle
Le problème de l'article, vous lié parle, c'est que Method#getAnnotation(...) accède declaredAnnotations() de la classe de la méthode a été définie, qui, comme indiqué ci-dessus renvoie uniquement les annotations définies dans la classe et non pas ceux de la super-classes.

Cela signifie que si vous remplacez une des méthodes annotées avec @Transactional vous devez ajouter l'annotation là (ou si les cadres se penche également dans la classe d'annotation, il doit trouver le @Transactional déclaré sur AbstractMaqraaService).

InformationsquelleAutor Thomas
36

Oui c'est possible si l'annotation a @Hérité ajouté. Par exemple, le @Transactional annotation a @Inherited.

De la documentation:

Indique qu'un type d'annotation est automatiquement héritée. Si un
Hérité de la méta-annotation est présente sur un type d'annotation
déclaration, et les requêtes de l'utilisateur le type d'annotation sur une classe
déclaration et la déclaration de la classe n'a pas d'annotation pour cette
le type, la classe de super-classe sera automatiquement interrogé pour
le type d'annotation. Ce processus sera répété jusqu'à ce qu'une annotation
pour ce type n'est trouvé, ou le haut de la hiérarchie de classe (Objet) est
atteint. Si aucun super-classe a une annotation de ce type, alors la
la requête indique que la classe en question n'a aucune annotation.

Noter que cette méta-annotation de type a aucun effet si la annoté
type est utilisé pour annoter rien d'autre qu'une classe. Notez également que
cette méta-annotation seules causes des annotations hérité de
super-classes; annotations sur la mise en œuvre des interfaces n'ont aucun effet.

Docs de @Transactional:
```
@Target(value={METHOD,TYPE})
@Retention(value=RUNTIME)
@Inherited
@Documented
public @interface Transactional
```
Hors sujet: Vous ne pouvez pas sous-type d'une annotation bien qu'en Java.
- Notez que @Hérité ne fonctionne que lorsqu'il est appliqué à une classe (pas de méthode ou de l'interface)
InformationsquelleAutor mprabhat

Vous devez vous connecter pour publier un commentaire.