使用cdi的org.springframework.beans.factory.BeanCreationException

Question

我正在尝试使用Spring Security Framework实现身份验证和授权，但我遇到了困难，我陷入了这个异常：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'clienteBO': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: protected br.com.logtec.dao.GenericCrudDAO br.com.logtec.business.GenericCrudBO.dao; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'crudDAO': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: protected javax.persistence.EntityManager br.com.logtec.dao.GenericCrudDAO.entityManager; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No matching bean of type [javax.persistence.EntityManager] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@javax.inject.Inject(), @br.com.logtec.factory.DataFactory()}

这些是我的相关课程：

@Named("clienteBO")
public class ClienteBO extends PersonificacaoBO<Cliente>{
private static final long serialVersionUID = 119528316663693560L;

public ClienteBO() {
    super();
}

@Override
public Feedback salvar(Cliente instancia) {
    instancia.getPessoa().setCliente(true);
    //TODO PEGAR EMPRESA DO USUARIO LOGADO
//      if(instancia.getEmpresa() == null) 
//          throw new RuntimeException("O cliente deve obrigatoriamente possuir uma empresa");
    return super.salvar(instancia);
}

@Override
public Feedback salvar(Cliente instancia, CrudDAO<Cliente> dao) {
    instancia.getPessoa().setCliente(true);
    return super.salvar(instancia, dao);
}

@Override
protected Exemplo criarExemplo(Cliente pesquisa) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    return super.criarExemplo(pesquisa);
}

@Override
public Feedback salvar(Collection<Cliente> instancias) {
    for (Cliente cliente : instancias) {
        cliente.getPessoa().setCliente(true);
    }
    return super.salvar(instancias);
}

@Override
public Feedback salvar(Collection<Cliente> instancias, CrudDAO<Cliente> dao) {
    for (Cliente cliente : instancias) {
        cliente.getPessoa().setCliente(true);
    }
    return super.salvar(instancias, dao);
}
}

public abstract class PersonificacaoBO<T extends Personificacao> extends GenericCrudBO<T>{
private static final long serialVersionUID = 5475960092794378740L;

@Override
protected Exemplo criarExemplo(T pesquisa) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    Exemplo exemplo = super.criarExemplo(pesquisa);
    exemplo.excludeField("pessoa.cliente");
    exemplo.excludeField("pessoa.funcionario");
    exemplo.excludeField("pessoa.fornecedor");
    exemplo.excludeField("pessoa.usuario");
    exemplo.excludeField("pessoa.contador");
    return exemplo;
}

}

@Named("crudBO")
public class GenericCrudBO<E extends EntidadeBase> implements CrudBO<E>{
private static final long serialVersionUID = 1L;
private static final String DEFAULT_ERROR_MESSAGE = "Um erro inesperado ocorreu, contate o administrador do sistema.";
private static final String DEFAULT_SUCESS_MESSAGE = "Operação realizada com sucesso!";

@Inject
@Named("crudDAO")
protected GenericCrudDAO<E> dao;

public GenericCrudBO() {
    super();
}
public GenericCrudBO(GenericCrudDAO<E> dao) {
    super();
    this.dao = dao;
}

public Feedback salvar(E instancia, CrudDAO<E> dao) {
    Feedback feedback;
    try {
        dao.atualizar(instancia);
        feedback = new Feedback(TipoFeedback.SUCESSO, EtapaFeedback.CADASTRO, DEFAULT_SUCESS_MESSAGE);
    } catch (RuntimeException e) {
        feedback = new Feedback(TipoFeedback.ERRO, EtapaFeedback.CADASTRO, DEFAULT_ERROR_MESSAGE);
        throw e;
    }
    return feedback;
}

public Feedback salvar(Collection<E> instancias, CrudDAO<E> dao) {
    try {
        dao.cadastrar(instancias);
        return new Feedback(TipoFeedback.SUCESSO, EtapaFeedback.CADASTRO, "Operação realizada com sucesso");
    } catch (Exception e) {
        return new Feedback(TipoFeedback.ERRO, EtapaFeedback.CADASTRO, "Erro ao salvar, contate o administrador");
    }
}

@Override
public Feedback salvar(Collection<E> instancias) {
    return salvar(instancias, dao);
}

public Feedback salvar(E instancia) {
    return salvar(instancia, dao);
}

@Override
public Feedback deletar(E entidade) {
    Feedback feedback;
    try {
        dao.deletar(entidade);
        feedback = new Feedback(TipoFeedback.SUCESSO, EtapaFeedback.CADASTRO, DEFAULT_SUCESS_MESSAGE);
    } catch (RuntimeException e) {
        feedback = new Feedback(TipoFeedback.ERRO, EtapaFeedback.DELECAO, DEFAULT_ERROR_MESSAGE);
    }
    return feedback;
}

public E pesquisarPorId(Class<E> clazz, Long id) {
    return dao.pesquisarPorId(clazz, id);
}

public E pesquisarPorId(E instancia) {
    return dao.pesquisarPorId(instancia);
}

public List<E> pesquisar(Class<E> clazz) {
    return dao.pesquisarTodos(clazz);
}

/**
 * Pesquisa para entidades simples sem composição
 */
@Override
public List<E> pesquisar(E pesquisa) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    Exemplo exemplo = criarExemplo(pesquisa);
    return dao.pesquisar(exemplo);
}

protected Exemplo criarExemplo(E pesquisa) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    Exemplo exemplo = new Exemplo(pesquisa);
    exemplo.excludeField("serialVersionUID");
    exemplo.setMatchingMode(MatchingMode.ANYWHERE);
    exemplo.excludeZeroes();
    return exemplo;
}

@Override
public int total(E pesquisa) {
    return this.dao.total(pesquisa);
}

public List<E> listarLazy(E pesquisa, int startingAt, int maxPerPage, String sortField, String sortOrder) {
    inicializarCamposPesquisa(pesquisa);
    return this.dao.listarLazy(pesquisa, startingAt, maxPerPage, sortField, sortOrder);
}

protected void inicializarCamposPesquisa(E pesquisa) {
    //método que deverá ser implementado pelas classes filhas que quiserem filtrar os resultados no lazyList
}

public String getListIds(List<EntidadeBase> entidades) {
    StringBuilder builder = new StringBuilder('(');
    EntidadeBase e = null;
    for (int i = 0; i < entidades.size(); i++) {
        e = entidades.get(i);
        builder.append(e.getId());
        if(i < entidades.size()-1) {
            builder.append(',');
        }
    }
    builder.append(')');
    return builder.toString();
}

@SuppressWarnings("unchecked")
protected Class<E> getClassType() {
    ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass();
    return (Class<E>) parameterizedType.getActualTypeArguments()[0];
}

}

@Named("crudDAO")
public class GenericCrudDAO<E extends EntidadeBase> implements CrudDAO<E>{

private static final long serialVersionUID = 1L;
private static final Logger LOGGER = Logger.getLogger(CrudDAO.class);

@Inject 
@DataFactory
protected EntityManager entityManager;

public GenericCrudDAO() {
    super();
}

public GenericCrudDAO(EntityManager entityManager) {
    super();
    this.entityManager = entityManager;
}

@Override
public void cadastrar(E instancia) {
    entityManager.getTransaction().begin();
    entityManager.persist(instancia);
    entityManager.getTransaction().commit();
}

public void cadastrar(Collection<E> instancias) {
    try {
        entityManager.getTransaction().begin();
        for(E e : instancias) {
            entityManager.merge(e);
        }
        entityManager.getTransaction().commit();
    } catch (Exception e) {
        entityManager.getTransaction().rollback();
        throw e;
    }
}

@Override
public void atualizar(E instancia) {
    entityManager.getTransaction().begin();
    entityManager.merge(instancia);
    entityManager.getTransaction().commit();
}

@Override
public void deletar(E instancia) {
    entityManager.getTransaction().begin();
    entityManager.remove(entityManager.merge(instancia));
    entityManager.getTransaction().commit();
}

public E pesquisarPorId(Class<E> clazz, Long id) {
    return (E) entityManager.find(clazz, id);
}

@SuppressWarnings("unchecked")
public E pesquisarPorId(E instancia) {
    Class<E> clazz = (Class<E>) instancia.getClass();
    return (E) entityManager.find(clazz, instancia.getId());
}

@SuppressWarnings("unchecked")
public List<E> pesquisarTodos(Class<E> clazz) {
    List<E> lista = new ArrayList<E>();
    lista = entityManager.createQuery(" FROM " + clazz.getName()).getResultList();
    return lista;
}

@Override
public List<E> pesquisar(Exemplo exemplo) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    return QBE.using(entityManager).getList(exemplo);
}

@Override
public E pesquisarUnico(Exemplo exemplo) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    return QBE.using(entityManager).getSingle(exemplo);
}

@Override
@SuppressWarnings("unchecked")
public List<E> pesquisar(String queryString) {
    return entityManager.createQuery(queryString).getResultList();
}

@SuppressWarnings("unchecked")
@Override
public List<E> pesquisar(String queryString, Map<String, Object> param) {
    String key = null;
    Query query = entityManager.createQuery(queryString);
    for(Map.Entry<String, Object> entry : param.entrySet()) {
        key = entry.getKey().trim();
        key = key.startsWith(":") ? key.substring(1) : key;
        query.setParameter(key, entry.getValue());
    }
    return query.getResultList();
}

public int total(E pesquisa) {
    Long count = 0L;

    try {;
        Query q = entityManager.createQuery("SELECT count(*) FROM "
                + pesquisa.getClass().getName());
        count = (Long) q.getSingleResult();
    } catch (Exception e) {
        LOGGER.error("Erro ao buscar total listagem lazy", e);
    }
    return count.intValue();
}

public void rollback() {
    entityManager.getTransaction().rollback();
}

@SuppressWarnings("unchecked")
protected Class<E> getClassType() {
    ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass();
    return (Class<E>) parameterizedType.getActualTypeArguments()[0];
}

@SuppressWarnings("unchecked")
public List<E> listarLazy(E pesquisa, int startingAt, int maxPerPage,
        String sortField, String sortOrder) {
    List<E> lista = new ArrayList<E>();
    try {
        Query q = entityManager.createQuery("FROM "
                + pesquisa.getClass().getName());
        q.setFirstResult(startingAt);
        q.setMaxResults(maxPerPage);
        lista = q.getResultList();
    } catch (Exception e) {
        LOGGER.error("Erro ao buscar listagem Lazy", e);
    }
    return lista;
}

}

我是Spring Security的开销者，如此，欢迎任何帮助，谢谢

Answer 1

如果我做对了，你想使用Spring Security作为安全性，使用CDI进行依赖注入。

在这种情况下，您需要确保Spring和CDI不会尝试管理相同的bean。即使您不直接使用Spring Core，现在您的类路径上也有Spring和CDI。当Spring在其类路径上发现javax.inject.Inject时，它会将@Inject视为@Autowired的同义词，并尝试将Spring bean注入带注释的注入目标。

这就是为什么你得到了例外 - 它的春天而不是CDI抱怨缺少豆子。