Example usage for org.springframework.core GenericTypeResolver resolveTypeArgument

Introduction

In this page you can find the example usage for org.springframework.core GenericTypeResolver resolveTypeArgument.

Prototype

@Nullable
public static Class<?> resolveTypeArgument(Class<?> clazz, Class<?> genericIfc) 

Source Link

Document

Resolve the single type argument of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare a concrete type for its type variable.

Usage

From source file:org.brutusin.rpc.actions.http.VersionAction.java

public static void main(String[] args) {
    Class<?> resolveTypeArgument = GenericTypeResolver.resolveTypeArgument(VersionAction.class,
            RpcAction.class);
    System.out.println(resolveTypeArgument);
}

---

From source file:com.vehicles.service.GenericServiceImpl.java

private void init(GenericRepository<T> repository) {
    this.repository = repository;
    this.clazz = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), GenericServiceImpl.class);
}

---

From source file:fr.mby.utils.spring.aop.support.AopHelper.java

/**
 * Test if an object which implement or extend a parameterized object will be able to handle a specific type.
 * Example : NumberList implements List<Number> { ... } NumberList can store any subtypes of Number : Number,
 * Integer, Long, ... This method return true if called like this supportsType(numberList, Integer.class,
 * List.class) This method return false if called like this supportsType(numberList, String.class, List.class)
 * /*from  www . j  av  a  2  s  . c  o  m*/
 * @param object
 *            the instantiated object we want to test against
 * @param type
 *            the type we want to test if the object can hanldle
 * @param genericIfc
 *            the type of the parameterized object (not the parameter type)
 * @return true if the object implementing the genericIfc supports the specified type
 */
public static <T> boolean supportsType(final Object object, final Class<?> type, final Class<?> genericIfc) {
    Class<?> typeArg = GenericTypeResolver.resolveTypeArgument(object.getClass(), genericIfc);
    if (typeArg == null || typeArg.equals(genericIfc)) {
        final Class<?> targetClass = AopUtils.getTargetClass(object);
        if (targetClass != object.getClass()) {
            typeArg = GenericTypeResolver.resolveTypeArgument(targetClass, genericIfc);
        }
    }

    final boolean test = typeArg == null || typeArg.isAssignableFrom(type);

    final String logMsg;
    if (test) {
        logMsg = "[{}] supports type: [{}] for genericIfc [{}].";
    } else {
        logMsg = "[{}] doesn't support type: [{}] for genericIfc [{}].";
    }

    AopHelper.LOG.debug(logMsg, object.getClass().getSimpleName(), type.getSimpleName(),
            genericIfc.getSimpleName());

    return test;
}

---

From source file:org.socialsignin.spring.data.dynamodb.mapping.event.AbstractDynamoDBEventListener.java

/**
 * Creates a new {@link AbstractDynamoDBEventListener}.
 *//*from  ww w  .  ja  va 2 s.c o  m*/
public AbstractDynamoDBEventListener() {
    Class<?> typeArgument = GenericTypeResolver.resolveTypeArgument(this.getClass(),
            AbstractDynamoDBEventListener.class);
    this.domainClass = typeArgument == null ? Object.class : typeArgument;
}

---

From source file:cz.zcu.pia.social.network.backend.services.dao.GenericDAO.java

/**
 * Constructor
 */
public GenericDAO() {
    this.genericType = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), GenericDAO.class);
}

---

From source file:com.springsource.greenhouse.activity.badge.StandardBadgeSystem.java

public void add(BadgeAwarder<? extends Action> badgeAwarder) {
    Class<? extends Action> actionType = (Class<? extends Action>) GenericTypeResolver
            .resolveTypeArgument(badgeAwarder.getClass(), BadgeAwarder.class);
    badgeAwarders.put(actionType, badgeAwarder);
}

---

From source file:org.vaadin.spring.events.internal.EventBusListenerWrapper.java

public EventBusListenerWrapper(EventBus owningEventBus, EventBusListener<?> listenerTarget, String topic,
        boolean includingPropagatingEvents) {
    super(owningEventBus, listenerTarget, topic, includingPropagatingEvents);
    payloadType = GenericTypeResolver.resolveTypeArgument(listenerTarget.getClass(), EventBusListener.class);
    Assert.notNull(payloadType, "Could not resolve payload type");
}

---

From source file:org.lamop.riche.dao.DAOGenericImpl.java

public DAOGenericImpl() {
    persistentClass = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), DAOGenericImpl.class);
}

---

From source file:org.cloudfoundry.tools.timeout.monitor.BridgedHttpServletResponseMonitorFactory.java

@SuppressWarnings("unchecked")
protected Class<? extends T> getProxyClass() {
    return (Class<? extends T>) GenericTypeResolver.resolveTypeArgument(getClass(),
            BridgedHttpServletResponseMonitorFactory.class);
}

---

From source file:org.jnap.core.persistence.factory.DaoFactory.java

private boolean isDaoDefinedForEntity(ConfigurableListableBeanFactory beanFactory,
        Class<? extends PersistentModel> entityClass) {
    if (alreadyDefinedDaos == null) {
        alreadyDefinedDaos = new HashSet<Class<? extends PersistentModel>>();
        for (String beanName : beanFactory.getBeanNamesForType(Dao.class, true, false)) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            final Class<?> daoType = ClassUtils.resolveClassName(beanDefinition.getBeanClassName(),
                    DaoFactory.class.getClassLoader());
            Class daoEntityClass = GenericTypeResolver.resolveTypeArgument(daoType, Dao.class);
            alreadyDefinedDaos.add(daoEntityClass);
            daoNameCache.put(daoEntityClass, beanName);
        }//from  www.ja v a  2s. c om
    }
    return alreadyDefinedDaos.contains(entityClass);
}

---

• «
• 1
• 2
• 3
• 4
• »