下面列出了怎么用javax.persistence.FlushModeType的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public List<PermissionTicket> findByResource(final String resourceId, String resourceServerId) {
TypedQuery<String> query = entityManager.createNamedQuery("findPermissionIdByResource", String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("resourceId", resourceId);
query.setParameter("serverId", resourceServerId);
List<String> result = query.getResultList();
List<PermissionTicket> list = new LinkedList<>();
PermissionTicketStore ticketStore = provider.getStoreFactory().getPermissionTicketStore();
for (String id : result) {
PermissionTicket ticket = ticketStore.findById(id, resourceServerId);
if (Objects.nonNull(ticket)) {
list.add(ticket);
}
}
return list;
}
@Override
public void findByScopeIds(List<String> scopeIds, String resourceId, String resourceServerId, Consumer<Policy> consumer) {
// Use separate subquery to handle DB2 and MSSSQL
TypedQuery<PolicyEntity> query;
if (resourceId == null) {
query = entityManager.createNamedQuery("findPolicyIdByNullResourceScope", PolicyEntity.class);
} else {
query = entityManager.createNamedQuery("findPolicyIdByResourceScope", PolicyEntity.class);
query.setParameter("resourceId", resourceId);
}
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("scopeIds", scopeIds);
query.setParameter("serverId", resourceServerId);
StoreFactory storeFactory = provider.getStoreFactory();
query.getResultList().stream()
.map(id -> new PolicyAdapter(id, entityManager, storeFactory))
.forEach(consumer::accept);
}
@Override
public List<Policy> findByType(String type, String resourceServerId) {
TypedQuery<String> query = entityManager.createNamedQuery("findPolicyIdByType", String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("serverId", resourceServerId);
query.setParameter("type", type);
List<String> result = query.getResultList();
List<Policy> list = new LinkedList<>();
for (String id : result) {
Policy policy = provider.getStoreFactory().getPolicyStore().findById(id, resourceServerId);
if (Objects.nonNull(policy)) {
list.add(policy);
}
}
return list;
}
@Override
public List<Policy> findByScopeIds(List<String> scopeIds, String resourceServerId) {
if (scopeIds==null || scopeIds.isEmpty()) {
return Collections.emptyList();
}
// Use separate subquery to handle DB2 and MSSSQL
TypedQuery<PolicyEntity> query = entityManager.createNamedQuery("findPolicyIdByScope", PolicyEntity.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("scopeIds", scopeIds);
query.setParameter("serverId", resourceServerId);
List<Policy> list = new LinkedList<>();
StoreFactory storeFactory = provider.getStoreFactory();
for (PolicyEntity entity : query.getResultList()) {
list.add(new PolicyAdapter(entity, entityManager, storeFactory));
}
return list;
}
public static FlushModeType getFlushModeType(FlushMode flushMode) {
if ( flushMode == FlushMode.ALWAYS ) {
log.debug( "Interpreting Hibernate FlushMode#ALWAYS to JPA FlushModeType#AUTO; may cause problems if relying on FlushMode#ALWAYS-specific behavior" );
return FlushModeType.AUTO;
}
else if ( flushMode == FlushMode.MANUAL ) {
log.debug( "Interpreting Hibernate FlushMode#MANUAL to JPA FlushModeType#COMMIT; may cause problems if relying on FlushMode#MANUAL-specific behavior" );
return FlushModeType.COMMIT;
}
else if ( flushMode == FlushMode.COMMIT ) {
return FlushModeType.COMMIT;
}
else if ( flushMode == FlushMode.AUTO ) {
return FlushModeType.AUTO;
}
throw new AssertionFailure( "unhandled FlushMode " + flushMode );
}
public static FlushMode interpretFlushMode(Object value) {
if ( value == null ) {
return FlushMode.AUTO;
}
if ( FlushMode.class.isInstance( value ) ) {
return (FlushMode) value;
}
else if ( FlushModeType.class.isInstance( value ) ) {
return getFlushMode( (FlushModeType) value );
}
else if ( String.class.isInstance( value ) ) {
return interpretExternalSetting( (String) value );
}
throw new IllegalArgumentException( "Unknown FlushMode source : " + value );
}
public static FlushMode interpretExternalSetting(String externalName) {
if ( externalName == null ) {
return null;
}
try {
log.debug( "Attempting to interpret external setting [" + externalName + "] as FlushMode name" );
return FlushMode.valueOf( externalName.toUpperCase( Locale.ROOT) );
}
catch ( IllegalArgumentException e ) {
log.debug( "Attempting to interpret external setting [" + externalName + "] as FlushModeType name" );
}
try {
return getFlushMode( FlushModeType.valueOf( externalName.toLowerCase( Locale.ROOT ) ) );
}
catch ( IllegalArgumentException ignore ) {
}
throw new MappingException( "unknown FlushMode : " + externalName );
}
@Override
public void findByType(String type, String owner, String resourceServerId, Consumer<Resource> consumer) {
TypedQuery<ResourceEntity> query;
if (owner != null) {
query = entityManager.createNamedQuery("findResourceIdByType", ResourceEntity.class);
} else {
query = entityManager.createNamedQuery("findResourceIdByTypeNoOwner", ResourceEntity.class);
}
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("type", type);
if (owner != null) {
query.setParameter("ownerId", owner);
}
query.setParameter("serverId", resourceServerId);
StoreFactory storeFactory = provider.getStoreFactory();
query.getResultList().stream()
.map(entity -> new ResourceAdapter(entity, entityManager, storeFactory))
.forEach(consumer);
}
private static <T> T withoutFlush(EntityManager entityManager, boolean flushAtEnd,
Function<EntityManager, T> task) {
FlushModeType fm = entityManager.getFlushMode();
entityManager.setFlushMode(FlushModeType.COMMIT);
try {
T result = task.apply(entityManager);
if (flushAtEnd) {
entityManager.flush();
}
return result;
} catch (RuntimeException e) {
throw e;
} finally {
entityManager.setFlushMode(fm);
}
}
@Override
public List<PermissionTicket> findByScope(String scopeId, String resourceServerId) {
if (scopeId==null) {
return Collections.emptyList();
}
// Use separate subquery to handle DB2 and MSSSQL
TypedQuery<String> query = entityManager.createNamedQuery("findPermissionIdByScope", String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("scopeId", scopeId);
query.setParameter("serverId", resourceServerId);
List<String> result = query.getResultList();
List<PermissionTicket> list = new LinkedList<>();
PermissionTicketStore ticketStore = provider.getStoreFactory().getPermissionTicketStore();
for (String id : result) {
PermissionTicket ticket = ticketStore.findById(id, resourceServerId);
if (Objects.nonNull(ticket)) {
list.add(ticket);
}
}
return list;
}
@Override
public List<PermissionTicket> findByOwner(String owner, String resourceServerId) {
TypedQuery<String> query = entityManager.createNamedQuery("findPolicyIdByType", String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("serverId", resourceServerId);
query.setParameter("owner", owner);
List<String> result = query.getResultList();
List<PermissionTicket> list = new LinkedList<>();
PermissionTicketStore ticketStore = provider.getStoreFactory().getPermissionTicketStore();
for (String id : result) {
PermissionTicket ticket = ticketStore.findById(id, resourceServerId);
if (Objects.nonNull(ticket)) {
list.add(ticket);
}
}
return list;
}
@Override
public List<Policy> findDependentPolicies(String policyId, String resourceServerId) {
TypedQuery<String> query = entityManager.createNamedQuery("findPolicyIdByDependentPolices", String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("serverId", resourceServerId);
query.setParameter("policyId", policyId);
List<String> result = query.getResultList();
List<Policy> list = new LinkedList<>();
for (String id : result) {
Policy policy = provider.getStoreFactory().getPolicyStore().findById(id, resourceServerId);
if (Objects.nonNull(policy)) {
list.add(policy);
}
}
return list;
}
@Override
public Set<ContentItem> loadChildren(CollectionItem collection, Date timestamp) {
Set<ContentItem> children = new HashSet<ContentItem>();
TypedQuery<ContentItem> query = null;
// use custom HQL query that will eager fetch all associations
if (timestamp == null) {
query = this.em.createNamedQuery("contentItem.by.parent", ContentItem.class).setParameter("parent",
collection);
} else {
query = this.em.createNamedQuery("contentItem.by.parent.timestamp", ContentItem.class)
.setParameter("parent", collection).setParameter("timestamp", timestamp);
}
query.setFlushMode(FlushModeType.COMMIT);
List<ContentItem> results = query.getResultList();
for (ContentItem content : results) {
initializeItem(content);
children.add(content);
}
return children;
}
@Override
public List<Resource> findGrantedOwnerResources(String owner, int first, int max) {
TypedQuery<String> query = entityManager.createNamedQuery("findGrantedOwnerResources", String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("owner", owner);
if (first > -1 && max > -1) {
query.setFirstResult(first);
query.setMaxResults(max);
}
List<String> result = query.getResultList();
List<Resource> list = new LinkedList<>();
ResourceStore resourceStore = provider.getStoreFactory().getResourceStore();
for (String id : result) {
Resource resource = resourceStore.findById(id, null);
if (Objects.nonNull(resource)) {
list.add(resource);
}
}
return list;
}
public User updateUser(User user) {
// Prevent auto flushing when querying for existing users
this.em.setFlushMode(FlushModeType.COMMIT);
User findUser = findUserByUsernameOrEmail(getBaseModelObject(user).getId(), user.getUsername(),
user.getEmail());
if (findUser != null) {
if (findUser.getEmail().equals(user.getEmail())) {
throw new DuplicateEmailException(user.getEmail());
} else {
throw new DuplicateUsernameException(user.getUsername());
}
}
user.updateTimestamp();
this.em.merge(user);
this.em.flush();
return user;
}
@Override
public void findByScope(List<String> scopes, String resourceServerId, Consumer<Resource> consumer) {
TypedQuery<ResourceEntity> query = entityManager.createNamedQuery("findResourceIdByScope", ResourceEntity.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("scopeIds", scopes);
query.setParameter("serverId", resourceServerId);
StoreFactory storeFactory = provider.getStoreFactory();
query.getResultList().stream()
.map(id -> new ResourceAdapter(id, entityManager, storeFactory))
.forEach(consumer);
}
private void flushIfNecessary(
EntityManager entityManager,
AnnotationMetadata annotationMetadata) {
if (annotationMetadata.hasAnnotation(QueryHint.class)) {
FlushModeType flushModeType = getFlushModeType(annotationMetadata);
if (flushModeType == FlushModeType.AUTO) {
entityManager.flush();
}
}
}
private FlushModeType getFlushModeType(AnnotationMetadata annotationMetadata) {
return annotationMetadata.getAnnotationValuesByType(QueryHint.class)
.stream()
.filter(av -> FlushModeType.class.getName().equals(av.stringValue("name").orElse(null)))
.map(av -> av.enumValue("value", FlushModeType.class))
.findFirst()
.orElse(Optional.empty()).orElse(null);
}
@Test
@SuppressWarnings("unchecked")
public void testQueryNoPersonsShared() {
Query q = this.sharedEntityManager.createQuery("select p from Person as p");
q.setFlushMode(FlushModeType.AUTO);
List<Person> people = q.getResultList();
assertEquals(0, people.size());
try {
assertNull(q.getSingleResult());
fail("Should have thrown NoResultException");
}
catch (NoResultException ex) {
// expected
}
}
/**
* Get the DB connection from Hibernate and run some work on it. Since we
* will use it to run queries/stored procs, this will also flush the session
* to ensure that stored procs will see changes made in the Hibernate cache
*/
private <T> T doWithStolenConnection(ReturningWork<T> work) throws HibernateException {
Session session = HibernateFactory.getSession();
if (session.getFlushMode().equals(FlushModeType.AUTO)) {
session.flush();
}
return session.doReturningWork(work);
}
@Override
public <T> T call(Callable<T> callable) {
return sessionManager.call(new Callable<T>() {
@Override
public T call() throws Exception {
if (getTransaction().isActive()) {
return callable.call();
} else {
Session session = sessionManager.getSession();
FlushModeType prevFlushModeType = session.getFlushMode();
Transaction tx = session.beginTransaction();
try {
session.setFlushMode(FlushModeType.AUTO);
T result = callable.call();
tx.commit();
return result;
} catch (Throwable t) {
tx.rollback();
throw ExceptionUtils.unchecked(t);
} finally {
Collection<Runnable> runnables = completionRunnables.remove(tx);
if (runnables != null) {
for (Runnable runnable: runnables) {
try {
runnable.run();
} catch (Exception e) {
logger.error("Error running completion callback", e);
}
}
}
session.setFlushMode(prevFlushModeType);
}
}
}
});
}
public <T extends JpaObject> EntityManager get(Class<T> cls) throws Exception {
Class<T> clazz = (Class<T>) entityManagerContainerFactory.assignableFrom(cls);
EntityManager em = fromEntityManagers(clazz);
if (null == em) {
em = entityManagerContainerFactory.createEntityManager(clazz);
em.setFlushMode(FlushModeType.COMMIT);
entityManagerMap.put(cls, em);
}
return em;
}
private boolean execute() throws Exception {
final List<String> storageContainerEntityNames = new ArrayList<>();
storageContainerEntityNames.addAll((List<String>) Config.resource(Config.RESOURCE_STORAGECONTAINERENTITYNAMES));
List<String> classNames = new ArrayList<>();
classNames.addAll(this.catalog.keySet());
classNames = ListTools.includesExcludesWildcard(classNames, Config.dumpRestoreStorage().getIncludes(),
Config.dumpRestoreStorage().getExcludes());
logger.print("restore storage find {} to restore.", classNames.size());
final File persistence = new File(Config.dir_local_temp_classes(), DateTools.compact(this.start) + "_dump.xml");
PersistenceXmlHelper.write(persistence.getAbsolutePath(), classNames);
final StorageMappings storageMappings = Config.storageMappings();
int count = 0;
for (int i = 0; i < classNames.size(); i++) {
final Class<StorageObject> cls = (Class<StorageObject>) Class.forName(classNames.get(i));
final EntityManagerFactory emf = OpenJPAPersistence.createEntityManagerFactory(cls.getName(),
persistence.getName(), PersistenceXmlHelper.properties(cls.getName(), Config.slice().getEnable()));
final EntityManager em = emf.createEntityManager();
em.setFlushMode(FlushModeType.COMMIT);
try {
final DumpRestoreStorageCatalogItem item = this.catalog.get(cls.getName());
logger.print(
"restore storage({}/{}): {}, count: {}, normal: {} will be restore, invalidStorage: {} and empty: {} will be ignore, size: {}M.",
(i + 1), classNames.size(), cls.getName(), item.getCount(), item.getNormal(),
item.getInvalidStorage(), item.getEmpty(), (item.getSize() / 1024 / 1024));
count += this.store(cls, em, storageMappings);
} finally {
em.close();
emf.close();
}
logger.print("restore storage completed, total count: {}, elapsed: {} minutes.", count,
(System.currentTimeMillis() - start.getTime()) / 1000 / 60);
}
return false;
}
@SuppressWarnings("unchecked")
public boolean execute() throws Exception {
List<String> containerEntityNames = new ArrayList<>();
containerEntityNames.addAll((List<String>) Config.resource(Config.RESOURCE_CONTAINERENTITYNAMES));
List<String> classNames = new ArrayList<>();
classNames.addAll(this.catalog.keySet());
classNames = ListTools.includesExcludesWildcard(classNames, Config.dumpRestoreData().getIncludes(),
Config.dumpRestoreData().getExcludes());
classNames = ListTools.includesExcludesWildcard(containerEntityNames, classNames, null);
logger.print("find: {} data to restore, path: {}.", classNames.size(), this.dir.getAbsolutePath());
File persistence = new File(Config.dir_local_temp_classes(), DateTools.compact(this.start) + "_dump.xml");
PersistenceXmlHelper.write(persistence.getAbsolutePath(), classNames);
long count = 0;
for (int i = 0; i < classNames.size(); i++) {
Class<JpaObject> cls = (Class<JpaObject>) Class.forName(classNames.get(i));
EntityManagerFactory emf = OpenJPAPersistence.createEntityManagerFactory(cls.getName(),
persistence.getName(), PersistenceXmlHelper.properties(cls.getName(), Config.slice().getEnable()));
if (emf != null) {
EntityManager em = emf.createEntityManager();
em.setFlushMode(FlushModeType.COMMIT);
try {
logger.print("restore data({}/{}): {}, count: {}.", (i + 1), classNames.size(), cls.getName(),
catalog.get(cls.getName()));
count = count + this.store(cls, em);
} finally {
em.close();
emf.close();
}
} else {
logger.warn("can not create 'EntityManagerFactory' for Entity:[" + cls.getName() + "]");
}
}
logger.print("restore data completed, total count: {}, elapsed: {} minutes.", count,
(System.currentTimeMillis() - start.getTime()) / 1000 / 60);
return true;
}
@Override
public void findByResourceType(String resourceType, String resourceServerId, Consumer<Policy> consumer) {
TypedQuery<PolicyEntity> query = entityManager.createNamedQuery("findPolicyIdByResourceType", PolicyEntity.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("type", resourceType);
query.setParameter("serverId", resourceServerId);
query.getResultList().stream()
.map(id -> new PolicyAdapter(id, entityManager, provider.getStoreFactory()))
.forEach(consumer::accept);
}
/**
* Returns a thread safe {@link EntityManager}.
*
* @return thread safe {@link EntityManager}
*/
private static EntityManager getEntityManager(String persistenceUnitName) {
EntityManager entityManager = entityManagerMap.get(persistenceUnitName);
if (entityManager == null || !entityManager.isOpen()) {
EntityManagerFactory entityManagerFactory = getEntityManagerFactory(persistenceUnitName);
entityManager = entityManagerFactory.createEntityManager();
entityManager.setFlushMode(FlushModeType.COMMIT); // Flushing will happen on committing the transaction.
entityManagerMap.put(persistenceUnitName, entityManager);
}
return entityManager;
}
private void findByOwnerFilter(String ownerId, String resourceServerId, Consumer<Resource> consumer, int firstResult, int maxResult) {
boolean pagination = firstResult > -1 && maxResult > -1;
String queryName = pagination ? "findResourceIdByOwnerOrdered" : "findResourceIdByOwner";
if (resourceServerId == null) {
queryName = pagination ? "findAnyResourceIdByOwnerOrdered" : "findAnyResourceIdByOwner";
}
TypedQuery<String> query = entityManager.createNamedQuery(queryName, String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("owner", ownerId);
if (resourceServerId != null) {
query.setParameter("serverId", resourceServerId);
}
if (pagination) {
query.setFirstResult(firstResult);
query.setMaxResults(maxResult);
}
ResourceStore resourceStore = provider.getStoreFactory().getResourceStore();
List<String> result = query.getResultList();
for (String entity : result) {
Resource cached = resourceStore.findById(entity, resourceServerId);
if (cached != null) {
consumer.accept(cached);
}
}
}
public void setFlushMode(final FlushModeType flushMode) {
final EntityManager entityManager = getEntityManager();
try {
final Timer timer = Op.setFlushMode.start(this.timer, this);
try {
entityManager.setFlushMode(flushMode);
} finally {
timer.stop();
}
} finally {
closeIfNoTx(entityManager);
}
}
@Override
public FlushModeType getFlushMode() {
getProducer().checkOpen();
return ( flushMode == null ?
getProducer().getFlushMode() :
FlushModeTypeHelper.getFlushModeType( flushMode )
);
}
@Override
public List<Scope> findByResourceServer(final String serverId) {
TypedQuery<String> query = entityManager.createNamedQuery("findScopeIdByResourceServer", String.class);
query.setFlushMode(FlushModeType.COMMIT);
query.setParameter("serverId", serverId);
List<String> result = query.getResultList();
List<Scope> list = new LinkedList<>();
for (String id : result) {
list.add(provider.getStoreFactory().getScopeStore().findById(id, serverId));
}
return list;
}