java.lang.NoSuchMethodError: org.hibernate.persister.entity.EntityPersister.getIdentifier

Sua classe Model não deveria ser uma entidade?

Será que não tá faltando um entity anotado nela?

@Entity
@MappedSuperclass
public class Model implements Serializable {

Posta o seu dao, quero ver aonde você ta persistindo os dados.

E uma outra coisa também, não suas model não deveria ter um identificador? algo como id? Sei que você está dando extends, na classe que já tem um id, mais tenta colocar nas classes um id e faz o teste.

E por ultimo uma duvida, qual versão está usando do hibernat?

Cara, alterei aqui para adicionar o @Entity mas como eu já imaginava não deu certo, pois essa classe não é persistida então creio que não há necessidade de anotar com @Entity.

Segue o dao.

DAOImpl.java

@Repository
public class DAOImpl<Entidade extends Model> implements DAO<Entidade> {

    private static final long serialVersionUID = 7538940694726270539L;

    @PersistenceContext
    protected EntityManager entityManager;

    public void setEntityManager(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public Entidade salvar(Entidade entidade) {
        if (entidade.getId() != null) {
            return entityManager.merge(entidade);
        }
        entityManager.persist(entidade);
        return entidade;
    }

    public void salvar(List<Entidade> entidades) {
        for (Entidade entidade : entidades) {
            salvar(entidade);
        }
        entityManager.flush();
    }

    public void remover(Entidade entidade) {
        entityManager.remove(entidade);
        entityManager.flush();
    }

    public void remover(List<Entidade> entidades) {
        for (Entidade entidade : entidades) {
            remover(entidade);
        }
    }

    public List<Entidade> obterTodos() {
        return entityManager.createQuery("FROM " + getClasseEntidade().getSimpleName(), getClasseEntidade()).getResultList();
    }

    public Entidade obterPorId(Long idEntidade) {
        return entityManager.find(getClasseEntidade(), idEntidade);
    }

    @SuppressWarnings("unchecked")
    public List<Entidade> obterPorParametro(Entidade entidade, Integer indiceInicio, Integer quantidade) {
        Criteria criterio = criarCriteriaExample(entidade, MatchMode.START);
        if(indiceInicio!=null){
            criterio.setFirstResult(indiceInicio);
            criterio.setMaxResults(quantidade);
        }
        return criterio.list();
    }

    public Entidade obterPorReferencia(Long id) {
        return this.entityManager.getReference(getClasseEntidade(),id);
    }    
    public int quantidade(Entidade entidade) {
        return ((Number) criarCriteriaExample(entidade, MatchMode.ANYWHERE).setProjection(Projections.rowCount()).uniqueResult()).intValue();
    }

    /**
     * Cria um criteria e adiciona a entidade passada por parametro como exemplo para a pesquisa.
     * Este metodo deve ser sobrescrito para adicionar outros parametros na busca.
     *
     * @param entidade
     * @return
     */
    protected Criteria criarCriteriaExample(Entidade entidade, MatchMode match) {
        Example criteriaExample = Example.create(entidade);
        return getSession().createCriteria(getClasseEntidade()).add(criteriaExample.enableLike(match).ignoreCase().excludeZeroes());
    }

    /**
     * Obtem a classe do conjunto de entidades que o ManagerBean corrente gerencia
     *
     * @return
     */
    @SuppressWarnings("unchecked")
    protected Class<Entidade> getClasseEntidade() {
        return (Class<Entidade>) ((java.lang.reflect.ParameterizedType) this.getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
    }

    protected Session getSession() {
        if (entityManager.getDelegate() instanceof EntityManagerImpl) {
            return ((EntityManagerImpl) entityManager.getDelegate()).getSession();
        } else if (entityManager.getDelegate() instanceof Session) {
            return (Session) entityManager.getDelegate();
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    public List<Entidade> executarQuery(String query, Map<String, Object> parametros, Integer indice, Integer qtdItemMaximo) {
        Query queryNamed = null;
        try {
            queryNamed = entityManager.createNamedQuery(query);
        } catch (Exception e) {
            queryNamed = entityManager.createQuery(query, getClasseEntidade());
        }
        if (indice!=null){
            queryNamed.setFirstResult(indice);
            queryNamed.setMaxResults(qtdItemMaximo);
        }
        if(parametros!=null){
            Set<String> keyParametros = parametros.keySet();
            for (String nomeParamentro : keyParametros) {
                queryNamed.setParameter(nomeParamentro, parametros.get(nomeParamentro));
            }
        }
        return queryNamed.getResultList();
    }

    @SuppressWarnings("unchecked")
    public Entidade executarQuery(String query, Map<String, Object> parametros) {
        Query queryNamed = entityManager.createNamedQuery(query);
        if(parametros!=null){
            Set<String> keyParametros = parametros.keySet();
            for (String nomeParamentro : keyParametros) {
                queryNamed.setParameter(nomeParamentro, parametros.get(nomeParamentro));
            }
        }
        return (Entidade) queryNamed.getSingleResult();
    }    

    public int executarComando(String query, Map<String, Object> parametros) {
        Query queryNamed = entityManager.createNamedQuery(query);
        if(parametros!=null){
            Set<String> keyParametros = parametros.keySet();
            for (String nomeParamentro : keyParametros) {
                queryNamed.setParameter(nomeParamentro, parametros.get(nomeParamentro));
            }
        }
        return queryNamed.executeUpdate();
    }

    @SuppressWarnings("unchecked")
    public List<String> executarQueryString(String query, Map<String, Object> parametros, Integer indice, Integer qtdItemMaximo) {
        Query queryNamed = entityManager.createNamedQuery(query, String.class);
        if (indice!=null){
            queryNamed.setFirstResult(indice);
            queryNamed.setMaxResults(qtdItemMaximo);
        }
        if(parametros!=null){
            Set<String> keyParametros = parametros.keySet();
            for (String nomeParamentro : keyParametros) {
                queryNamed.setParameter(nomeParamentro, parametros.get(nomeParamentro));
            }
        }
        return queryNamed.getResultList();
    }    

}

CulturaDAOImpl.java

@Repository
public class CulturaDAOImpl extends DAOImpl<Cultura> implements CulturaDAO {

    private static final long serialVersionUID = -4919834906533535707L;
    static Logger logger = Logger.getLogger(CulturaDAOImpl.class);

    @Override
    public void excluir(Cultura cultura) {
        @SuppressWarnings("unchecked")
        Map<String, Object> parametros = new HashedMap();
        parametros.put("pId",cultura.getId());
        executarComando("Cultura.excluir", parametros);
    }    

    @Override
    public List<Cultura> obterTodos() {
        return executarQuery("Cultura.todos", null, null, null);
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<GraficoPizza> culturaAtivaPorArea(Area a, Date data) {
        String jpql = "SELECT new "
                + GraficoPizza.class
                + " (cul.nome, count(*)) from Plantio p JOIN p.cultivo c JOIN c.cultura cult JOIN p.setor s JOIN s.irrigante i WHERE i.area = :pArea AND c.dataInicio <= :pData AND (p.dataFim IS NULL OR p.dataFim >= :pData) GROUP BY cul.nome ";
        return (List<GraficoPizza>) this.entityManager.createQuery(jpql)
                .setParameter("pArea", a).setParameter("pData", data)
                .getSingleResult();
    }

    @Override
    public Criteria criarCriteriaExample(Cultura entidade, MatchMode match) {

        Criteria criteria = super.criarCriteriaExample(entidade, match);

        criteria = prepararCriteria(entidade, criteria);        
        return criteria;
    }

    private Criteria prepararCriteria(Cultura entidadeLocal, Criteria criteria) {
        Criteria a = null;
        if (entidadeLocal.getAtividade() != null) {
            a = criteria.createCriteria("atividade");
            a.add(Restrictions.eq("id", entidadeLocal.getAtividade().getId()));
        }
        if (entidadeLocal.getSortField().equals("nome")) {
            if (entidadeLocal.getSortOrder().equals(SortOrder.DESCENDING)) {
                criteria.addOrder(Order.desc("nome"));
            }else{
                criteria.addOrder(Order.asc("nome"));
            }
        }
        return criteria;

    }

    @Override
    @SuppressWarnings("unchecked")
    public List<GraficoPizzaIndicadores> totalHaPorCulturaPorMunicipio(Municipio m) {
        List<GraficoPizzaIndicadores> retorno = new ArrayList<GraficoPizzaIndicadores>();
        String jpql      = "SELECT distinct(cult.nome) as nome, sum(a.areatotal) as total from AtividadeEconomica a JOIN a.cultura cult WHERE a.municipio = :pMunicipio and a.dataFim IS NULL GROUP BY cult.nome ORDER BY total desc";
        String jpqlTotal = "SELECT sum(a.areatotal) as total from AtividadeEconomica a JOIN a.cultura cult WHERE a.municipio = :pMunicipio and a.dataFim IS NULL";
        BigDecimal total = this.entityManager.createQuery(jpqlTotal, BigDecimal.class).setParameter("pMunicipio", m).getSingleResult();
        List<Object[]> objs = (List<Object[]>) this.entityManager.createQuery(jpql).setParameter("pMunicipio", m).getResultList();
        for (Object[] p : objs) {
            String nome = (String) p[0];
            double qtd = new BigDecimal(p[1].toString(), BigDecimalUtil.MC).doubleValue();

            GraficoPizzaIndicadores g = new GraficoPizzaIndicadores( nome, qtd, total.doubleValue(), "ha");
            retorno.add(g);
        }

        return retorno;
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<GraficoPizzaIndicadores> totalHaPorCulturaPorBacia(BaciaHidrografica b) {
        List<GraficoPizzaIndicadores> retorno = new ArrayList<GraficoPizzaIndicadores>();
        String jpql      = "SELECT distinct(cult.nome) as nome, sum(a.areatotal) as total from AtividadeEconomica a JOIN a.cultura cult JOIN a.municipio m WHERE m.bacia = :pBacia GROUP BY cult.nome ORDER BY total DESC";
        String jpqlTotal = "SELECT sum(a.areatotal) as total from AtividadeEconomica a JOIN a.cultura cult JOIN a.municipio m WHERE m.bacia = :pBacia";
        BigDecimal total = this.entityManager.createQuery(jpqlTotal, BigDecimal.class).setParameter("pBacia", b).getSingleResult();
        List<Object[]> objs = (List<Object[]>) this.entityManager.createQuery(jpql).setParameter("pBacia", b).getResultList();
        for (Object[] p : objs) {
            String nome = (String) p[0];
            double qtd = new BigDecimal(p[1].toString(), BigDecimalUtil.MC).doubleValue();

            GraficoPizzaIndicadores g = new GraficoPizzaIndicadores( nome, qtd, total.doubleValue(), "ha");
            retorno.add(g);
        }

        return retorno;
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<GraficoPizzaIndicadores> totalCicloCulturaPorBacia(BaciaHidrografica b) {
        List<GraficoPizzaIndicadores> retorno = new ArrayList<GraficoPizzaIndicadores>();
        String jpql      = "SELECT distinct(ind.cicloCultura) as nome, count(*) as total from Indicadores ind JOIN ind.atividadeEconomica a JOIN a.cultura cult JOIN a.municipio m WHERE m.bacia = :pBacia AND a.dataFim IS NULL GROUP BY ind.cicloCultura ORDER BY total DESC";
        String jpqlTotal = "SELECT count(*) as total from Indicadores ind JOIN ind.atividadeEconomica a JOIN a.cultura cult JOIN a.municipio m WHERE m.bacia = :pBacia AND a.dataFim IS NULL";
        BigDecimal total = new BigDecimal((Long)this.entityManager.createQuery(jpqlTotal).setParameter("pBacia", b).getSingleResult());
        List<Object[]> objs = (List<Object[]>) this.entityManager.createQuery(jpql).setParameter("pBacia", b).getResultList();
        for (Object[] p : objs) {
            String nome = (p[0].toString().equals("0.50") ? "Permanente" : (p[0].toString().equals("0.75") ? "Tempo Long" : "Tempo Curto"));
            double qtd = new BigDecimal(p[1].toString(), BigDecimalUtil.MC).doubleValue();

            GraficoPizzaIndicadores g = new GraficoPizzaIndicadores( nome, qtd, total.doubleValue(), "un");
            retorno.add(g);
        }

        return retorno;
    }

}