Printemps 3.2 Autowire types génériques

Comment sur l'ajout d'un constructeur à l' GenericService et déplacer l'permettra à l'autowiring à l'extension de la classe, par exemple

class GenericService<T, T_DAO extends GenericDao<T>> {
    private final T_DAO tDao;

    GenericService(T_DAO tDao) {
        this.tDao = tDao;
    }
}

@Service
FooService extends GenericService<Foo, FooDao> {

    @Autowired
    FooService(FooDao fooDao) {
        super(fooDao);
    }
}

---

Mise à jour:

De Printemps 4.0 RC1, il est possible de autowire basé sur le type générique, ce qui signifie que vous peut écrire un service générique comme

class GenericService<T, T_DAO extends GenericDao<T>> {

    @Autowired
    private T_DAO tDao;
}

et de créer plusieurs types de beans Spring comme:

@Service
class FooService extends GenericService<Foo, FooDao> {
}

Ici est plus proche de la solution. Spécialisés DAOs sont annotés à la couche de gestion. Comme dans la question de l'OP, le mieux serait d'avoir une annoté DAO dans le EntityDAO modèle générique de lui-même. Type d'effacement semble ne permettant pas le type spécialisé de l'information pour obtenir transmis sur le ressort des usines [résultant dans les rapports de correspondance des haricots de toutes les spécialités DAOs]

Le Générique de l'Entité DAO modèle

public class EntityDAO<T> 
{
    @Autowired
    SessionFactory factory;

    public Session getCurrentSession()
    {
        return factory.getCurrentSession();
    }

    public void create(T record)
    {
        getCurrentSession().save(record);
    }

    public void update(T record)
    {
        getCurrentSession().update(record);
    }

    public void delete(T record)
    {
        getCurrentSession().delete(record);
    }

    public void persist(T record)
    {
        getCurrentSession().saveOrUpdate(record);
    }

    public T get(Class<T> clazz, Integer id)
    {
        return (T) getCurrentSession().get(clazz, id);
    }
}

Le Générique De L'Entité De La Couche De Gestion Modèle De

public abstract class EntityBusinessService<T>
implements Serializable
{
    public abstract EntityDAO<T> getDAO();

    //Rest of code.
}

Un Exemple Entité Spécialisée, DAO

@Transactional
@Repository
public class UserDAO
extends EntityDAO<User>
{
}

Un Exemple Entité Spécialisée En Classe Affaires

@Transactional
@Service
@Scope("prototype")
public class UserBusinessService
extends EntityBusinessService<User>
{
    @Autowired
    UserDAO dao;

    @Override
    public EntityDAO<User> getDAO() 
    {
        return dao;
    }

    //Rest of code
}

Vous devez utiliser permettra à l'autowiring dans les classes qui s'étend de ces génériques

Complet Solution Générique à l'aide de Printemps 4:

---

Domaine Classe

@Component
class Foo{
}

@Component
class Bar{
}

---

DAO Couche

interface GenericDao<T>{
//list of methods
}

class GenericDaoImpl<T> implements GenericDao<T>{
 @Autowired
 SessionFactory factory;

 private Class<T> domainClass; //Get Class Type of <T>

 public Session getCurrentSession(){
    return factory.getCurrentSession();
 }

 public DaoImpl() {
    this.domainClass = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), DaoImpl.class);
 }
 //implementation of methods
}

interface FooDao extends GenericDao<Foo>{
//Define extra methods if required
}

interface BarDao extends GenericDao<Bar>{
//Define extra methods if required
}

@Repository
class FooDao extends GenericDaoImpl<Foo> implements FooDao{
 //implementation of extra methods
}

@Repository
class BarDao extends GenericDaoImpl<Bar> implements BarDao{
 //implementation of extra methods
}

---

De La Couche De Service

interface GenericService<T>{
//List of methods
}

class GenericServiceImpl<T> implements GenericService<T>{
 @Autowire
 protected GenericDao<T> dao; //used to access DAO layer
}

class FooService extends GenericService<Foo>{
//Add extra methods of required
}

class BarService extends GenericService<Bar>{
//Add extra methods of required
}

@Service
class FooServiceImpl extends GenericServiceImpl<Foo> implements GenericService<Foo>{
//implementation of extra methods
}

@Service
class BarServiceImpl extends GenericServiceImpl<Bar> implements GenericService<Bar>{
//implementation of extra methods
}