Java Examples for javax.persistence.Cache

public void fpExternalJavax() {
    Cache c = new Cache() {

        @Override
        public boolean contains(Class arg0, Object arg1) {
            return false;
        }

        @Override
        public void evict(Class arg0, Object arg1) {
        }

        @Override
        public void evict(Class arg0) {
        }

        @Override
        public void evictAll() {
        }

        @Override
        public <T> T unwrap(Class<T> arg0) {
            return null;
        }
    };
}

public void updateByQuery(String jpql, Object... params) {
    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();
    Query query = em.createQuery(jpql);
    for (int i = 0; params != null && i < params.length; i = +2) {
        query.setParameter(params[i].toString(), params[i + 1]);
    }
    query.executeUpdate();
    em.getTransaction().commit();
    Cache cache = emf.getCache();
    if (cache != null) {
        cache.evictAll();
    }
}

@Test
public void test() {
    Cache cache = entityManager.getEntityManagerFactory().getCache();
    cache.evictAll();
    Statistics statistics = ((Session) (entityManager.getDelegate())).getSessionFactory().getStatistics();
    statistics.clear();
    CommonCourt commonCourt = testPersistenceObjectFactory.createCcCourt(CommonCourtType.APPEAL);
    commonCourtRepository.findOne(commonCourt.getId());
    commonCourtRepository.findOne(commonCourt.getId());
    Assert.assertTrue(cache.contains(CommonCourt.class, commonCourt.getId()));
    Assert.assertTrue(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(0).getId()));
    Assert.assertTrue(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(1).getId()));
    cache.evict(CommonCourt.class);
    cache.evict(CommonCourtDivision.class);
    Assert.assertFalse(cache.contains(CommonCourt.class, commonCourt.getId()));
    Assert.assertFalse(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(0).getId()));
    Assert.assertFalse(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(1).getId()));
    // 1 commonCourt + 2 ccDivision + 2 ccDivisionType
    Assert.assertEquals(5, statistics.getSecondLevelCachePutCount());
    Assert.assertEquals(2, statistics.getSecondLevelCacheHitCount());
    Assert.assertEquals(0, statistics.getSecondLevelCacheMissCount());
}

@Test
public void testCacheMecanicienSpecialiteEntity() {
    Cache l2 = emf.getCache();
    EntityManager em = emf.createEntityManager();
    assertFalse(l2.contains(JpaMecanicienSpecialiteEntity.class, 1L));
    // Mise en cache L2 sur find.
    JpaMecanicienSpecialiteEntity e1 = em.find(JpaMecanicienSpecialiteEntity.class, 1L);
    assertTrue(l2.contains(JpaMecanicienSpecialiteEntity.class, 1L));
    JpaMecanicienSpecialiteEntity e2 = em.find(JpaMecanicienSpecialiteEntity.class, 1L);
    assertSame(e1, e2);
    EntityManager em2 = emf.createEntityManager();
    JpaMecanicienSpecialiteEntity e3 = em2.find(JpaMecanicienSpecialiteEntity.class, 1L);
    // Pourquoi le L2 ne renvoi pas les même
    assertNotSame(e1, e3);
    // instance?
    assertEquals(e1, e3);
}

@Test
public void createQueryCacheAndEvictAllThenRetry() throws Exception {
    List<Author> beforeResults = getAuthorsWithQuery("Author query", "어�나�");
    log.warn("#####################################################################");
    HibernateEntityManagerFactory entityManagerFactory = (HibernateEntityManagerFactory) EntityTestUtils.getEntityManagerFactory();
    org.hibernate.Cache cache = entityManagerFactory.getSessionFactory().getCache();
    cache.evictEntityRegions();
    cache.evictQueryRegions();
    cache.evictDefaultQueryRegion();
    cache.evictCollectionRegions();
    log.warn("just eviected all.");
    List<Author> againResults = getAuthorsWithQuery("Author query again after evict all", "어�나�");
    assertThat(againResults).isEqualTo(beforeResults);
    log.warn("#####################################################################");
}

@Test
public void a() {
    ComponentProvider dummyComponentProvider = new ComponentProvider() {

        @Override
        public Component getComponent() {
            return new Component();
        }

        @Override
        public Verifier getVerifier() {
            return Mockito.mock(Verifier.class);
        }
    };
    EntityManagerFactory dummyEmf = new EntityManagerFactory() {

        @Override
        public EntityManager createEntityManager() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public EntityManager createEntityManager(Map map) {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public CriteriaBuilder getCriteriaBuilder() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public Metamodel getMetamodel() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public boolean isOpen() {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        public void close() {
        // TODO Auto-generated method stub
        }

        @Override
        public Map<String, Object> getProperties() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public Cache getCache() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public PersistenceUnitUtil getPersistenceUnitUtil() {
            // TODO Auto-generated method stub
            return null;
        }
    };
    // Mockito.mock(EntityManagerFactory.class);
    // provide the required services, so that the configuration constraints are fulfilled.
    context.registerService(ComponentProvider.class.getName(), dummyComponentProvider, null);
    Dictionary props = new Hashtable();
    props.put("osgi.unit.name", "JenkinsPU");
    context.registerService(EntityManagerFactory.class.getName(), dummyEmf, props);
    // check the service which should have been created by the configuration
    ServiceReference serviceReference = context.getServiceReference(ApplicationProvider.class.getName());
    // assertThat(serviceReference, is(notNullValue()));
    ApplicationProvider service = (ApplicationProvider) context.getService(serviceReference);
    Application applicationFromService = service.getApplication();
    assertTrue(applicationFromService.getName().equals("jenkins"));
}

public static boolean cached(EntityBase... entities) {
    EntityManager em = null;
    boolean cached = false;
    try {
        for (EntityBase entity : entities) {
            Cache cache = PersistUtilHelper.getEntityManagerFactory().getCache();
            cached = cache.contains(entity.getClass(), entity.getId());
        }
    } catch (ExceptionError |  e) {
        log.error("Threw a Execpton or Error, full stack trace follows:", e);
    }
    return cached;
}

@Override
protected void configure() {
    super.configure();
    // TODO this should be the hibernate implementation
    bind(EntityManagerFactory.class).toInstance(new EntityManagerFactory() {

        boolean open = true;

        public CriteriaBuilder getCriteriaBuilder() {
            return null;
        }

        public Metamodel getMetamodel() {
            return null;
        }

        public Map<String, Object> getProperties() {
            return null;
        }

        public Cache getCache() {
            return null;
        }

        public PersistenceUnitUtil getPersistenceUnitUtil() {
            return null;
        }

        public EntityManager createEntityManager() {
            return stubEntityManager;
        }

        public EntityManager createEntityManager(Map map) {
            return stubEntityManager;
        }

        public void close() {
            open = false;
        }

        public boolean isOpen() {
            return open;
        }
    });
}

@Test
public void testJPAAccessFactory() {
    ODataJPAFactoryImpl oDataJPAFactoryImpl = new ODataJPAFactoryImpl();
    JPAAccessFactory jpaAccessFactory = oDataJPAFactoryImpl.getJPAAccessFactory();
    ODataJPAContextImpl oDataJPAContextImpl = new ODataJPAContextImpl();
    Class<?> clazz = oDataJPAContextImpl.getClass();
    try {
        Field field = clazz.getDeclaredField("em");
        field.setAccessible(true);
        field.set(oDataJPAContextImpl, new JPAProcessorImplTest().getLocalEntityManager());
    } catch (SecurityException e) {
        fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2);
    } catch (NoSuchFieldException e) {
        fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2);
    } catch (IllegalArgumentException e) {
        fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2);
    } catch (IllegalAccessException e) {
        fail(ODataJPATestConstants.EXCEPTION_MSG_PART_1 + e.getMessage() + ODataJPATestConstants.EXCEPTION_MSG_PART_2);
    }
    EntityManagerFactory emf = new EntityManagerFactory() {

        @Override
        public boolean isOpen() {
            return false;
        }

        @Override
        public Map<String, Object> getProperties() {
            return null;
        }

        @Override
        public PersistenceUnitUtil getPersistenceUnitUtil() {
            return null;
        }

        @Override
        public Metamodel getMetamodel() {
            return null;
        }

        @Override
        public CriteriaBuilder getCriteriaBuilder() {
            return null;
        }

        @Override
        public Cache getCache() {
            return null;
        }

        @SuppressWarnings("rawtypes")
        @Override
        public EntityManager createEntityManager(final Map arg0) {
            return null;
        }

        @Override
        public EntityManager createEntityManager() {
            return null;
        }

        @Override
        public void close() {
        }
    };
    oDataJPAContextImpl.setEntityManagerFactory(emf);
    oDataJPAContextImpl.setPersistenceUnitName("pUnit");
    assertNotNull(jpaAccessFactory.getJPAProcessor(oDataJPAContextImpl));
    assertNotNull(jpaAccessFactory.getJPAEdmModelView(oDataJPAContextImpl));
}

public void testEmbeddableProtectedCaching() {
    EntityManager em = createDSEntityManager();
    beginTransaction(em);
    try {
        ForceProtectedEntityWithComposite cte = em.find(ForceProtectedEntityWithComposite.class, m_forcedProtectedEntityCompositId);
        CacheableRelationshipsEntity cre = em.find(CacheableRelationshipsEntity.class, m_cacheableRelationshipsEntityId);
        ProtectedEmbeddable pe = cte.getProtectedEmbeddable();
        ServerSession session = em.unwrap(ServerSession.class);
        commitTransaction(em);
        closeEM(em);
        ForceProtectedEntityWithComposite cachedCPE = (ForceProtectedEntityWithComposite) session.getIdentityMapAccessor().getFromIdentityMap(cte);
        CacheableRelationshipsEntity cachedCRE = (CacheableRelationshipsEntity) session.getIdentityMapAccessor().getFromIdentityMap(cre);
        assertNotNull("ForceProtectedEntityWithComposite was not found in the cache", cachedCPE);
        assertNotNull("CacheableRelationshipsEntity was not found in the cache", cachedCRE);
        cachedCPE.getProtectedEmbeddable().setName("NewName" + System.currentTimeMillis());
        //following code is commented out due to bug 336651
        //cachedCRE.getProtectedEmbeddables().get(0).setName("NewName"+System.currentTimeMillis());
        em = createDSEntityManager();
        beginTransaction(em);
        ForceProtectedEntityWithComposite managedCPE = em.find(ForceProtectedEntityWithComposite.class, cte.getId());
        CacheableRelationshipsEntity managedCRE = em.find(CacheableRelationshipsEntity.class, cre.getId());
        assertEquals("Cache was not used for Protected Isolation", cachedCPE.getProtectedEmbeddable().getName(), managedCPE.getProtectedEmbeddable().getName());
    //follwoing code is commented out due to bug 336651
    //assertEquals("Cache was not used for Protected Isolation", cachedCRE.getProtectedEmbeddables().get(0).getName(),managedCRE.getProtectedEmbeddables().get(0).getName());
    } finally {
        rollbackTransaction(em);
        closeEM(em);
    }
}

/**
   * Tests pre-DML executions.
   *
   * @throws Exception
   */
@Test
public void testExecutePreDMLUpdates() throws Exception {
    Module module = new Module() {

        @Override
        public void configure(Binder binder) {
            binder.bind(DBAccessor.class).toInstance(dbAccessor);
            binder.bind(OsFamily.class).toInstance(osFamily);
            binder.bind(EntityManager.class).toInstance(entityManager);
            binder.bind(Configuration.class).toInstance(configuration);
        }
    };
    EntityManagerFactory emFactory = EasyMock.createNiceMock(EntityManagerFactory.class);
    Cache emCache = EasyMock.createNiceMock(Cache.class);
    expect(entityManager.getEntityManagerFactory()).andReturn(emFactory).atLeastOnce();
    expect(emFactory.getCache()).andReturn(emCache).atLeastOnce();
    EntityTransaction mockTransaction = EasyMock.createNiceMock(EntityTransaction.class);
    Connection mockConnection = EasyMock.createNiceMock(Connection.class);
    Statement mockStatement = EasyMock.createNiceMock(Statement.class);
    expect(dbAccessor.getConnection()).andReturn(mockConnection).once();
    expect(mockConnection.createStatement()).andReturn(mockStatement).once();
    expect(mockStatement.executeQuery(EasyMock.anyString())).andReturn(EasyMock.createNiceMock(ResultSet.class));
    expect(entityManager.getTransaction()).andReturn(mockTransaction).atLeastOnce();
    dbAccessor.dropTable(UpgradeCatalog300.CLUSTER_CONFIG_MAPPING_TABLE);
    EasyMock.expectLastCall().once();
    replay(dbAccessor, entityManager, emFactory, emCache, mockConnection, mockTransaction, mockStatement, configuration);
    Injector injector = Guice.createInjector(module);
    UpgradeCatalog300 upgradeCatalog300 = injector.getInstance(UpgradeCatalog300.class);
    upgradeCatalog300.executePreDMLUpdates();
    verify(dbAccessor, entityManager, emFactory, emCache);
}

private void cleanCacheIfNecessary(String componentId, int latestVersion) {
    Cache c = entityManagerFactory.getCache();
    if (c.contains(ComponentSpec.class, componentId)) {
        EntityManager em = entityManagerFactory.createEntityManager();
        ComponentSpec cs = em.find(ComponentSpec.class, componentId);
        if (cs != null && cs.getObjVersion() < latestVersion) {
            c.evict(ComponentSpec.class, componentId);
        }
        em.close();
    }
}

@Override
public EmbeddedCacheManager getCacheContainer() {
    EmbeddedCacheManager cm;
    try {
        Cache cache = emf.getCache();
        JpaInfinispanRegionFactory region = cache.unwrap(JpaInfinispanRegionFactory.class);
        cm = region.getCacheManager();
    } catch (Exception e) {
        log.error("", e);
        cm = null;
    }
    return cm;
}

public Cache getCache() {
    throw new NoPlansToImplementException();
}

/**
     * @see org.jboss.arquillian.persistence.JpaCacheEvictionStrategy#evictCache(javax.persistence.EntityManagerFactory)
     */
@Override
public final void evictCache(EntityManager em) {
    final Cache cache = em.getEntityManagerFactory().getCache();
    if (cache != null) {
        cache.evictAll();
    }
}

@Override
public Cache getCache() {
    return null;
}

@Override
public Cache getCache() {
    throw new UnsupportedOperationException("getCache");
}

@Override
public Cache getCache() {
    return null;
}

public Cache getCache() {
    return emf.getCache();
}

public Cache getCache() {
    return getDelegate().getCache();
}

@Override
public Cache getCache() {
    return hibernateEmf.getCache();
}

@Override
public Cache getCache() {
    return null;
}

@Override
public Cache getCache() {
    return unwrap().getCache();
}

public Cache getCache() {
    return getDelegate().getCache();
}

@Override
public Cache getCache() {
    throw new UnsupportedOperationException("getCache");
}

public Cache getCache() {
    return entityManagerFactory.getCache();
}

@Override
public Cache getCache() {
    return null;
}

public Cache getCache() {
    return CacheDummy.getInstance();
}

@Override
public Cache getCache() {
    return hibernateEmf.getCache();
}

@Override
public Cache getCache() {
    return hibernateEmf.getCache();
}

@Override
public Cache getCache() {
    return factory.getCache();
}

/**
   * Returns the entity manager cache
   *
   * @since JPA 2.0
   */
public Cache getCache() {
    throw new UnsupportedOperationException(getClass().getName());
}

@Override
public Cache getCache() {
    assert false;
    return null;
}

public Cache getCache() {
    // TODO Auto-generated method stub
    return null;
}

public Cache getCache() {
    return getEntityManagerFactory().getCache();
}

@Override
public Cache getCache() {
    return emf.getCache();
}

@Override
public Cache getCache() {
    return getDelegate().getCache();
}

@Override
public Cache getCache() {
    return getDelegate().getCache();
}

public Cache getCache() {
    // TODO : cache the cache reference?
    if (!isOpen()) {
        throw new IllegalStateException("EntityManagerFactory is closed");
    }
    return new JPACache(sessionFactory);
}

public Cache getCache() {
    // TODO : cache the cache reference?
    if (!isOpen()) {
        throw new IllegalStateException("EntityManagerFactory is closed");
    }
    return new JPACache(sessionFactory);
}

@Override
public Cache getCache() {
    return emf.getCache();
}

@Override
public Cache getCache() {
    return getDelegate().getCache();
}

public Cache getCache() {
    // TODO : cache the cache reference?
    if (!isOpen()) {
        throw new IllegalStateException("EntityManagerFactory is closed");
    }
    return new JPACache(sessionFactory);
}

@Override
public Cache getCache() {
    return null;
}

@Override
public Cache getCache() {
    return null;
}

/**
	 * {@inheritDoc}
	 * 
	 */
@Override
public Cache getCache() {
    return null;
}

@Override
public Object invoke(Object... args) {
    Cache secondLevelCache = getEntityManagerFactory(args).getCache();
    if (secondLevelCache != null) {
        secondLevelCache.evictAll();
    }
    return null;
}

@Override
public Cache getCache() {
    return delegate().getCache();
}

@Override
public Object invoke(Object... args) {
    Cache secondLevelCache = getEntityManagerFactory(args).getCache();
    if (secondLevelCache != null) {
        secondLevelCache.evictAll();
    }
    return null;
}