Public

delete

save

<init>

find

load

update

Return the Hibernate SessionFactory that should be used to create Hibernate
Sessions.

getSessionFactory

Execute the action specified by the given action object within a native Session.
This execute varian

executeWithNativeSession

findByNamedParam

merge

afterPropertiesSet

Create a close-suppressing proxy for the given Hibernate Session. The proxy also
prepares returned Q

createSessionProxy

Disable the specified filters on the given Session.

disableFilters

Execute the action specified by the given action object within a Session.

doExecute

Enable the specified filters on the given Session.

enableFilters

findByCriteria

findByNamedQueryAndNamedParam

Return the names of Hibernate filters to be activated, if any.

getFilterNames

Return whether to check that the Hibernate Session is not in read-only mode in
case of write operati

isCheckWriteOperations

HibernateTemplate

Parsing JSON documents to java classes using gson

An abstraction for a native pointer data type. A Pointer instance represents, on
the Java side, a na

com.sun.jna.Pointer

An "abstract" representation of a file system entity identified by a pathname.
The pathname may be a

java.io.File

java.net.Socket

This class represents an in-memory collection of keys and certificates. It
manages two types of entr

java.security.KeyStore

A Java representation of the SQL TIMESTAMP type. It provides the capability of
representing the SQL 

java.sql.Timestamp

An unbounded priority Queue based on a priority heap. The elements of the
priority queue are ordered

java.util.PriorityQueue

getSharedPreferences

startActivity

Return the original filename in the client's filesystem.This may contain path
information depending 

getOriginalFilename

/**
 * Helper class that simplifies Hibernate data access code. Automatically
 * converts HibernateExceptions into DataAccessExceptions, following the
 * {@code org.springframework.dao} exception hierarchy.
 *
 * The central method is {@code execute}, supporting Hibernate access code
 * implementing the {@link HibernateCallback} interface. It provides Hibernate Session
 * handling such that neither the HibernateCallback implementation nor the calling
 * code needs to explicitly care about retrieving/closing Hibernate Sessions,
 * or handling Session lifecycle exceptions. For typical single step actions,
 * there are various convenience methods (find, load, saveOrUpdate, delete).
 *
 * Can be used within a service implementation via direct instantiation
 * with a SessionFactory reference, or get prepared in an application context
 * and given to services as bean reference. Note: The SessionFactory should
 * always be configured as bean in the application context, in the first case
 * given to the service directly, in the second case to the prepared template.
 *
 * NOTE: Hibernate access code can also be coded against the native Hibernate
 * {@link Session}. Hence, for newly started projects, consider adopting the standard
 * Hibernate style of coding against {@link SessionFactory#getCurrentSession()}.
 * Alternatively, use {@link #execute(HibernateCallback)} with Java 8 lambda code blocks
 * against the callback-provided {@code Session} which results in elegant code as well,
 * decoupled from the Hibernate Session lifecycle. The remaining operations on this
 * HibernateTemplate are deprecated in the meantime and primarily exist as a migration
 * helper for older Hibernate 3.x/4.x data access code in existing applications.
 *
 * @author Juergen Hoeller
 * @since 4.2
 * @see #setSessionFactory
 * @see HibernateCallback
 * @see Session
 * @see LocalSessionFactoryBean
 * @see HibernateTransactionManager
 * @see org.springframework.orm.hibernate5.support.OpenSessionInViewFilter
 * @see org.springframework.orm.hibernate5.support.OpenSessionInViewInterceptor
 */

// Hibernate 5.2's createQuery method declares a new subtype as return type,

// so we need to use reflection for binary compatibility with 5.0/5.1 here.

/**
	 * Create a new HibernateTemplate instance.
	 */

/**
	 * Create a new HibernateTemplate instance.
	 * @param sessionFactory the SessionFactory to create Sessions with
	 */

/**
	 * Set the Hibernate SessionFactory that should be used to create
	 * Hibernate Sessions.
	 */

/**
	 * Return the Hibernate SessionFactory that should be used to create
	 * Hibernate Sessions.
	 */

/**
	 * Obtain the SessionFactory for actual use.
	 * @return the SessionFactory (never {@code null})
	 * @throws IllegalStateException in case of no SessionFactory set
	 * @since 5.0
	 */

/**
	 * Set one or more names of Hibernate filters to be activated for all
	 * Sessions that this accessor works with.
	 * Each of those filters will be enabled at the beginning of each
	 * operation and correspondingly disabled at the end of the operation.
	 * This will work for newly opened Sessions as well as for existing
	 * Sessions (for example, within a transaction).
	 * @see #enableFilters(Session)
	 * @see Session#enableFilter(String)
	 */

/**
	 * Return the names of Hibernate filters to be activated, if any.
	 */

/**
	 * Set whether to expose the native Hibernate Session to
	 * HibernateCallback code.
	 * Default is "false": a Session proxy will be returned, suppressing
	 * {@code close} calls and automatically applying query cache
	 * settings and transaction timeouts.
	 * @see HibernateCallback
	 * @see Session
	 * @see #setCacheQueries
	 * @see #setQueryCacheRegion
	 * @see #prepareQuery
	 * @see #prepareCriteria
	 */

/**
	 * Return whether to expose the native Hibernate Session to
	 * HibernateCallback code, or rather a Session proxy.
	 */

/**
	 * Set whether to check that the Hibernate Session is not in read-only mode
	 * in case of write operations (save/update/delete).
	 * Default is "true", for fail-fast behavior when attempting write operations
	 * within a read-only transaction. Turn this off to allow save/update/delete
	 * on a Session with flush mode MANUAL.
	 * @see #checkWriteOperationAllowed
	 * @see org.springframework.transaction.TransactionDefinition#isReadOnly
	 */

/**
	 * Return whether to check that the Hibernate Session is not in read-only
	 * mode in case of write operations (save/update/delete).
	 */

/**
	 * Set whether to cache all queries executed by this template.
	 * If this is "true", all Query and Criteria objects created by
	 * this template will be marked as cacheable (including all
	 * queries through find methods).
	 * To specify the query region to be used for queries cached
	 * by this template, set the "queryCacheRegion" property.
	 * @see #setQueryCacheRegion
	 * @see org.hibernate.Query#setCacheable
	 * @see Criteria#setCacheable
	 */

/**
	 * Return whether to cache all queries executed by this template.
	 */

/**
	 * Set the name of the cache region for queries executed by this template.
	 * If this is specified, it will be applied to all Query and Criteria objects
	 * created by this template (including all queries through find methods).
	 * The cache region will not take effect unless queries created by this
	 * template are configured to be cached via the "cacheQueries" property.
	 * @see #setCacheQueries
	 * @see org.hibernate.Query#setCacheRegion
	 * @see Criteria#setCacheRegion
	 */

How to use refreshmethodin org.springframework.orm.hibernate5.HibernateTemplate

Best Java code snippets using org.springframework.orm.hibernate5.HibernateTemplate.refresh (Showing top 4 results out of 315)

How to use
refresh
method
in
org.springframework.orm.hibernate5.HibernateTemplate