Initial SessionFactory creation failed.java.lang.NullPointerException

public static void main(String[] args) {
  
   Session sessao = HibernateUtil.getSessionFactory().openSession();
    
    AutorDAO dao = new AutorDAO();
    Autor a = new Autor();
    a.setCodAutor(1);
    a.setNome("Antonio marcos");
    
    sessao.save(a);
    
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Persistencia;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Criterion;

public abstract class GenericHibernateDAO<T, ID extends Serializable>
        implements GenericDAO<T, ID> {
    
    private Class<T> entidadePersistente;
    private Session sessao;
 
    public GenericHibernateDAO() {
        this.entidadePersistente = (Class<T>) ((ParameterizedType) getClass()
                                .getGenericSuperclass()).getActualTypeArguments()[0];
    }
 
    @SuppressWarnings("unchecked")
    public void setSession(Session s) {
        this.sessao = s;
    }
 
    protected Session getSession() {
        if (sessao == null)
            sessao = HibernateUtil.getSessionFactory().openSession();
        else
            if (!sessao.isOpen())
                sessao = HibernateUtil.getSessionFactory().openSession();
        return sessao;
    }
 
    public Class<T> getEntidadePersistente() {
        return entidadePersistente;
    }
 
    //@SuppressWarnings("unchecked")
    @Override
    public T findById(ID id) {
        T entidade = (T) getSession().load(getEntidadePersistente(), id);
        return entidade;
    }
 
    @SuppressWarnings("unchecked")
    @Override
    public List<T> findAll() {      
        return findByCriteria();
    }
 
    @SuppressWarnings("unchecked")
    @Override
    public T salvar(T entidade) {
        Transaction transacao = getSession().beginTransaction();
        getSession().save(entidade);
        transacao.commit();
        getSession().close(); 
        return entidade;
    }
 
    @Override
    public void remover(T entidade) {
        Transaction transacao = getSession().beginTransaction();
        getSession().delete(entidade);
        transacao.commit();
        getSession().close(); 
    }
    
    @Override
    public void atualizar(T entidade) {
        Transaction transacao = getSession().beginTransaction();
        getSession().saveOrUpdate(entidade);
        transacao.commit();
        getSession().close(); 
    }    
 
    public void flush() {
        getSession().flush();
    }
 
    public void clear() {
        getSession().clear();
    }
 
    /**
     * Use this inside subclasses as a convenience method.
     */
    @SuppressWarnings("unchecked")
    protected List<T> findByCriteria(Criterion... criterion) {
        Criteria crit = getSession().createCriteria(getEntidadePersistente());
        for (Criterion c : criterion) {
            crit.add(c);
        }
        return crit.list();
   }

}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Persistencia;

import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;

public class HibernateUtil {

    private static final SessionFactory sessionFactory;
    
    static {
        try {
            // Create the SessionFactory from standard (hibernate.cfg.xml) 
            // config file.
            sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            // Log the exception. 
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
    
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}