session.connection () im Ruhezustand veraltet?

Wir müssen in der Lage sein, die zugehörige java.sql.ConnectionSitzung im Ruhezustand abzurufen. Es funktioniert keine andere Verbindung, da diese Verbindung möglicherweise einer laufenden Transaktion zugeordnet ist.

Wie soll ich das tun, wenn session.connection () jetzt veraltet ist?

Sie müssen jetzt die Arbeits-API verwenden:

session.doWork(
    new Work() {
        public void execute(Connection connection) throws SQLException 
        { 
            doSomething(connection); 
        }
    }
);

Oder in Java 8+:

session.doWork(connection -> doSomething(connection)); 

Wenn session.connect()es jetzt veraltet ist, wie soll ich das machen?

Sie müssen Session#doWork(Work)und die WorkAPI verwenden, wie im Javadoc erwähnt:

connection()
     Veraltet. (geplant für die Entfernung in 4.x). Der Austausch hängt vom Bedarf ab. für die direkte Verwendung von JDBC-Inhalten doWork(org.hibernate.jdbc.Work); zum Öffnen einer "temporären Sitzung" verwenden (TBD).

Sie haben einige Zeit vor Hibernate 4.x, aber die Verwendung einer veralteten API sieht irgendwie so aus:

:) :)

Update: Laut RE: [hibernate-dev] Verbindungs-Proxy auf der Hibernate-dev-Liste scheint es, dass die ursprüngliche Absicht der Ablehnung darin bestand, die Verwendung von zu verhindern, Session#connection()da es als "schlechte" API angesehen wurde / wird, aber es sollte zu dieser Zeit bleiben. Ich denke, sie haben ihre Meinung geändert ...

Versuche dies

((SessionImpl)getSession()).connection()

Tatsächlich gibt getSession den Typ der Sitzungsschnittstelle zurück. Sie sollten sehen, was die ursprüngliche Klasse für die Sitzung ist. Geben Sie cast in die ursprüngliche Klasse ein und erhalten Sie die Verbindung.

VIEL GLÜCK!

Es gibt noch eine andere Option, an der immer noch viele Casts beteiligt sind, aber zumindest muss sie nicht reflektiert werden, wodurch Sie die Überprüfung der Kompilierungszeit zurückerhalten können:

public Connection getConnection(final EntityManager em) {
  HibernateEntityManager hem = (HibernateEntityManager) em;
  SessionImplementor sim = (SessionImplementor) hem.getSession();
  return sim.connection();
}

Sie könnten das natürlich mit ein paar instanceofÜberprüfungen noch "schöner" machen , aber die obige Version funktioniert für mich.

Hier ist eine Möglichkeit, dies in Hibernate 4.3 zu tun, und es ist nicht veraltet:

  Session session = entityManager.unwrap(Session.class);
  SessionImplementor sessionImplementor = (SessionImplementor) session;
  Connection conn = sessionImplementor.getJdbcConnectionAccess().obtainConnection();

Das benutze ich und arbeite für mich. Downcast das Session-Objekt in ein SessionImpl und erhalte das Verbindungsobjekt einfach:

SessionImpl sessionImpl = (SessionImpl) session;
Connection conn = sessionImpl.connection();

Wo sessionist der Name Ihres Sitzungsobjekts im Ruhezustand?

connection()wurde nur auf der Schnittstelle veraltet. Es ist noch verfügbar am SessionImpl. Sie können das tun, was der Frühling tut, und das einfach so nennen.

Hier ist der Code aus dem HibernateJpaDialectFrühjahr 3.1.1

public Connection getConnection() {
        try {
            if (connectionMethod == null) {
                // reflective lookup to bridge between Hibernate 3.x and 4.x
                connectionMethod = this.session.getClass().getMethod("connection");
            }
            return (Connection) ReflectionUtils.invokeMethod(connectionMethod, this.session);
        }
        catch (NoSuchMethodException ex) {
            throw new IllegalStateException("Cannot find connection() method on Hibernate session", ex);
        }
    }

Ich habe diesen Artikel gefunden

package com.varasofttech.client;

import java.sql.Connection;
import java.sql.SQLException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.internal.SessionImpl;
import org.hibernate.jdbc.ReturningWork;
import org.hibernate.jdbc.Work;

import com.varasofttech.util.HibernateUtil;

public class Application {

public static void main(String[] args) {

    // Different ways to get the Connection object using Session

    SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
    Session session = sessionFactory.openSession();

    // Way1 - using doWork method
    session.doWork(new Work() {
        @Override
        public void execute(Connection connection) throws SQLException {
            // do your work using connection
        }

    });

    // Way2 - using doReturningWork method
    Connection connection = session.doReturningWork(new ReturningWork<Connection>() {
        @Override
        public Connection execute(Connection conn) throws SQLException {
            return conn;
        }
    });

    // Way3 - using Session Impl
    SessionImpl sessionImpl = (SessionImpl) session;
    connection = sessionImpl.connection();
    // do your work using connection

    // Way4 - using connection provider
    SessionFactoryImplementor sessionFactoryImplementation = (SessionFactoryImplementor) session.getSessionFactory();
    ConnectionProvider connectionProvider = sessionFactoryImplementation.getConnectionProvider();
    try {
        connection = connectionProvider.getConnection();
        // do your work using connection
    } catch (SQLException e) {
        e.printStackTrace();
    }
}
}

Es hat mir geholfen.

Mit Hibernate> = 5.0 erhalten Sie Folgendes Connection:

Connection c = sessionFactory.
getSessionFactoryOptions().getServiceRegistry().
getService(ConnectionProvider.class).getConnection();

Versuchen Sie für Hibenat 4.3 Folgendes:

public static Connection getConnection() {
        EntityManager em = <code to create em>;
        Session ses = (Session) em.getDelegate();
        SessionFactoryImpl sessionFactory = (SessionFactoryImpl) ses.getSessionFactory();
        try{
            connection = sessionFactory.getConnectionProvider().getConnection();
        }catch(SQLException e){
            ErrorMsgDialog.getInstance().setException(e);
        }
        return connection;
    }

Versuche dies:

public Connection getJavaSqlConnectionFromHibernateSession() {

    Session session = this.getSession();
    SessionFactoryImplementor sessionFactoryImplementor = null;
    ConnectionProvider connectionProvider = null;
    java.sql.Connection connection = null;
    try {
        sessionFactoryImplementor = (SessionFactoryImplementor) session.getSessionFactory();
        connectionProvider = (ConnectionProvider) sessionFactoryImplementor.getConnectionProvider().getConnection();
        connection = connectionProvider.getConnection();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return connection;
}

    Connection conn = null;
    PreparedStatement preparedStatement = null;
    try {
        Session session = (org.hibernate.Session) em.getDelegate();
        SessionFactoryImplementor sfi = (SessionFactoryImplementor) session.getSessionFactory();
        ConnectionProvider cp = sfi.getConnectionProvider();
        conn = cp.getConnection();
        preparedStatement = conn.prepareStatement("Select id, name from Custumer");
        ResultSet rs = preparedStatement.executeQuery();
        while (rs.next()) {
            System.out.print(rs.getInt(1));
            System.out.println(rs.getString(2));
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (preparedStatement != null) {
            preparedStatement.close();
        }
        if (conn != null) {
            conn.close();
        }
    }

Hier ist eine Java 8-Methode, um die Connectionvon einem verwendeten zurückzugeben, EntityManagerohne tatsächlich etwas damit zu tun:

private Connection getConnection(EntityManager em) throws SQLException {
    AtomicReference<Connection> atomicReference = new AtomicReference<Connection>();
    final Session session = em.unwrap(Session.class);
    session.doWork(connection -> atomicReference.set(connection));
    return atomicReference.get();
}