Boa tarde,
Estou utilizando o hibernate 3.2.6 e estou precisando pegar uma conexão atraves da Session só que o eclipse está me mostrando
que o metodo session.connection() está deprecated, como faço para recuperar um objeto connection no hibernate ?
Obrigado …
Ainda não disponibilizaram uma alternativa. Será disponibilizado em futuras versões.
como faço então para recuperar uma connection sigo utilizando o session.connection() ?
sim, até disponibilizarem uma solução alternativa
Estava com o mesmo problema e encontrei a solução.
Considerando que tenha acesso a um objeto Connection, na tua classe de conexão, basta criar um método acesse e retorne, desse objeto, o seguinte: buildSettings().getConnectionProvider().getConnection().
Exemplo: se tiveres um objeto Configuration com o nome cfg, basta fazer cfg.buildSettings().get[…].
Só para constar: o fato de um método ser depreciado não significa que seja impossível utilizá-lo… 
Veja se este exemplo de HibernateUtil pode te ajudar
package br.com.azi.util.hibernate;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
import br.com.azi.util.xml.XmlFileReader;
/**
* Classe utilitária para gerenciamento do Hibernate, tem como objetivos:
* <ul>
* <li>Inicializar uma única instância da SessionFactory do Hibernate;</li>
* <li>Abrir Sessions do Hibernate;</li>
* <li>Associar Sessions a ThreadsLocais;</li>
* <li>Fechar Sessions associadas.</li>
* </ul>
* O pacote de anotações para o Hibernate (Hibernate Annotations) requer uma classe
* especial para a construção do SessionFactory. Por questões de compatibilidade com
* aplicações que já utilizam a classe HibernateUtil, foi criado o método setSessionFactory()
* que recebe como parâmetro um objeto da classe SessionFactory que substituirá o objeto criado
* anteriormente dentro da classe. Desta maneira não alteramos a inicialização anterior da classe.
* Utilize este método caso o projeto utilize Hibernate Annotations.<br/><br/>
* <i>Atenção!</i> Uma exceção pode ser disparada no momento em que HibernateUtil for carregada na memória,
* caso o arquivo de configuração do hibernate utilize a sintaxe permitida para o Hibernate Annotations. Se a
* intenção for utilizar annotations no projeto para efetuar o mapeamento das classes, ignore a exceção e
* utilize o método setSessionFactory() para atribuir um factory válido para a aplicação.
*/
public class HibernateUtil
{
private static SessionFactory sessionFactory;
private static Configuration configuration;
private static boolean annotationActive = false;
private static final ThreadLocal threadSession = new ThreadLocal();
public static void initialize()
{
try
{
sessionFactory = configuration.configure().buildSessionFactory();
System.out.println( ">> HIBERNATE INICIADO COM SUCESSO." );
}
catch ( Throwable e )
{
System.out.println( ">> FALHA NA INICIAÇÃO DO HIBERNATE." );
e.printStackTrace();
}
}
public static Configuration getConfiguration() {
if( configuration == null )
configuration = (annotationActive)? new AnnotationConfiguration(): new Configuration();
return configuration;
}
public static void setConfiguration(Configuration cfg) {
HibernateUtil.configuration = cfg;
}
public static boolean isAnnotationActive() {
return annotationActive;
}
public static void setAnnotationActive(boolean annotationActive) {
HibernateUtil.annotationActive = annotationActive;
}
public static void reinitialize(){
closeSession();
initialize();
getSession();
}
/**
* Inicializa as propriedades de um objeto persistido.
*/
public static void initializeProperties( Object obj )
{
if ( !Hibernate.isInitialized( obj ) )
{
Hibernate.initialize( obj );
}
}
/**
* Atualiza um objeto persistido.
*/
public static void refreshObject( Object obj )
{
Session s = HibernateUtil.getSession();
s.refresh( obj );
}
/**
* Limpa a session corrente.
*/
public static void clearSession()
{
Session s = HibernateUtil.getSession();
s.clear();
}
/**
* Retorna uma Session existente, ou então abre uma nova e associa a ThreadLocal.
* @return uma sessão do Hibernate
*/
public static Session getSession()
{
if( sessionFactory == null ){
initialize();
closeSession();
}
Session s = (Session) threadSession.get();
if ( s == null )
{
s = sessionFactory.openSession();
threadSession.set( s );
}
return s;
}
/**
* Fecha a Session associada a ThreadLocal.
*/
public static void closeSession()
{
Session s = (Session) threadSession.get();
threadSession.set( null );
if ( s != null && s.isOpen() )
{
s.close();
}
}
/**
* Retorna uma Connection JDBC independente. <br> OBS: É necessário chamar o método <tt>close()</tt> da conexão a fim de fecha-la.
* Caso o arquivo hibernate.cfg.xml esteja configurado para utilizar um DataSource gerenciado pelo servidor de aplicativo, este
* método irá fazer uso dele. Caso contrário, irá criar manualmente uma nova conexão JDBC com o servidor de banco de dados.
*
* @return uma Connection JDBC
*/
public static Connection getConnection() {
/*
* Abre o arquivo hibernate.cfg.xml para obter as configurações de acesso ao banco de dados.
*/
XmlFileReader xmlReader;
try {
xmlReader = new XmlFileReader( HibernateUtil.class.getResource( "/hibernate.cfg.xml" ) );
} catch (Exception e) {
throw new RuntimeException("Não foi possível abrir o arquivo /hibernate.cfg.xml para leitura.", e);
}
/*
* Se a origem da conexão JDBC for um DataSource gerenciado pelo servidor de aplicativo, utiliza o nome JNDI do
* mesmo para se obter e repassar a conexão.
*/
String jdbcDataSource = xmlReader.getNodeValue("//hibernate-configuration/session-factory/property[@name='connection.datasource']");
if(jdbcDataSource != null) {
try {
Context ctx = new InitialContext();
DataSource ds = (DataSource)ctx.lookup(jdbcDataSource);
return ds.getConnection();
} catch (NamingException e) {
throw new RuntimeException("Não foi possível obter o objeto DataSource a partir do contexto JNDI.", e);
} catch (SQLException e) {
throw new RuntimeException("Não foi possível obter a conexão JDBC a partir do objeto DataSource.", e);
}
}
/*
* Lê as propriedades da conexão JDBC utilizadas pelo Hibernate.
*/
String driverName = xmlReader.getNodeValue( "//hibernate-configuration/session-factory/property[@name='connection.driver_class']" );
String url = xmlReader.getNodeValue( "//hibernate-configuration/session-factory/property[@name='connection.url']" );
String username = xmlReader.getNodeValue( "//hibernate-configuration/session-factory/property[@name='connection.username']" );
String password = xmlReader.getNodeValue( "//hibernate-configuration/session-factory/property[@name='connection.password']" );
/*
* Cria manualmente uma conexão JDBC com o servidor de banco de dados.
*/
try {
Class.forName( driverName );
return DriverManager.getConnection( url, username, password );
} catch (ClassNotFoundException e) {
throw new RuntimeException("A classe do driver de conexões JDBC não foi encontrada.", e);
} catch (SQLException e) {
throw new RuntimeException("Não foi possível obter manualmente uma conexão JDBC com o servidor de banco de dados.", e);
}
}
}Acho que o pessoal do Hibernate aprontou mais uma das boas.
Eu PRECISO pegar a conexão associada a SESSION porque essa conexão VEIO do POOL DE CONEXÕES que o Hibernate gerencia internamente.
Pegar essa conexão de qualquer outra maneia que não seja essa vai te obrigar a gerenciar um outro pool de conexões por fora do Hibernate, ou seja, vc termina com 2 pools de conexões rodando na sua aplicação.
E o mais importante: se a session já fez alterações numa connection dentro de uma transação, essas alterações estão disponíveis APENAS nessa connection até ela comitar, ou seja, qualquer outra coisa não vai servir.
CONCLUSÃO:
Precisamos de qualquer jeito obter a connection associada a session do hibernate, isto é, a que ele está usando para aquela sessão, e nenhuma outra.
Quem depreciou session.connection() é um maluco.
Ou apenas me diga como eu pego a connection da session sem usar session.connection() e eu reconsidero minha opinião.
Estou com este problema, já q está previsto para cair fora na versão 4 do hibernate
Sugestão vinda direto do problema
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2603
doSomeLegacyJunk( session.getConnection() );vira isto
session.doWork(
new Work() {
public void execute(Connection connection) throws SQLException {
doSomeLegacyJunk( connection );
}
});ainda não testei …
Sei que o tópico é antigo, mas quando fiz a busca só encontrei ele falando sobre esse assunto, então resolvi postar a forma que descobri.
((SessionFactoryImplementor) HibernateUtil.getSessionFactory()).getConnectionProvider().getConnection();alguém tem ideia de como pegar a connection? não encontro mais elas nas sugestões relacionadas, claro estou usando a ultima versão do hibernate e pelo jeito retiraram qualquer versão dele.
Sei que quer a conexão, mas qual seu objetivo final com ela? Só para tentar ajudar sem talvez não precisar dela. No Hibernate do .NET não tem essa palhaçada de tentar esconder a conexão. Se for verdade mesmo que escondem a conexão, esses arquitetos do Hibernate do Java tem que parar de tratar como criança os desenvolvedores.
O ireport utiliza a connection para gerar o relatório (eu utilizo java) também tem outros métodos de passar o resultset e o list, porém no meu caso passar a connection para o ireport seria mais confortável para mim…
Tem esse exemplo ai, não sei se serve pra você: http://stackoverflow.com/questions/3526556/session-connection-deprecated-on-hibernate
Ta ai
((SessionFactoryImplementor) HibernateUtil.getSessionFactory()).getConnectionProvider().getConnection();