Java Code Examples for javax.persistence.EntityManager#clear()

private <T> void dump(Class<T> cls, EntityManager em) throws Exception {
	/** 创建最终存储文件的目录 */
	File directory = new File(dir, cls.getName());
	FileUtils.forceMkdir(directory);
	FileUtils.cleanDirectory(directory);
	int count = 0;
	int size = Config.dumpRestoreData().getBatchSize();
	String id = "";
	List<T> list = null;
	do {
		list = this.list(em, cls, id, size);
		if (ListTools.isNotEmpty(list)) {
			count = count + list.size();
			id = BeanUtils.getProperty(list.get(list.size() - 1), JpaObject.id_FIELDNAME);
			File file = new File(directory, count + ".json");
			FileUtils.write(file, pureGsonDateFormated.toJson(list), DefaultCharset.charset);
		}
		em.clear();
		Runtime.getRuntime().gc();
	} while (ListTools.isNotEmpty(list));
	this.catalog.put(cls.getName(), count);
}
 

private void doInTransaction(InTransaction inTransaction) throws Exception {
    System.out.println(entityManagerFactory);
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    entityManager.getTransaction().begin();

    try {
        TestEntity simpleEntity = new TestEntity("Test", "descr");
        entityManager.persist(simpleEntity);

        // flush and clear persistence context
        entityManager.flush();
        entityManager.clear();

        inTransaction.process(entityManager);
    } finally {
        entityManager.getTransaction().rollback();
        entityManager.close();
    }
}
 

public static void clear(final EntityManager em, JpaQueryFactory factory) {
	factory.initalize(new JpaQueryFactoryContext() {
		@Override
		public MetaPartition getMetaPartition() {
			MetaLookupImpl metaLookup = new MetaLookupImpl();
			JpaMetaProvider metaProvider = new JpaMetaProvider(em.getEntityManagerFactory());
			metaLookup.addProvider(metaProvider);
			metaLookup.initialize();
			return metaProvider.getPartition();
		}

		@Override
		public EntityManager getEntityManager() {
			return em;
		}
	});
	clear(em, factory.query(MovieEntity.class).buildExecutor().getResultList());
	clear(em, factory.query(PersonEntity.class).buildExecutor().getResultList());
	em.flush();
	em.clear();
}
 

private void doInTransaction(InTransaction inTransaction) throws Exception {
    EntityManager entityManager = entityManagerFactory.createEntityManager();
    entityManager.getTransaction().begin();

    try {
        TestEntity simpleEntity = new TestEntity("Test", "descr");
        entityManager.persist(simpleEntity);

        // flush and clear persistence context
        entityManager.flush();
        entityManager.clear();

        inTransaction.process(entityManager);
    } finally {
        entityManager.getTransaction().rollback();
        entityManager.close();
    }
}
 

@Test
public void shouldLoadUsersFromJsonDataset() {
    for (DataSetExecutorImpl executor : executors) {
        DataSetConfig DataSetConfig = new DataSetConfig("datasets/json/users.json");
        executor.createDataSet(DataSetConfig);
        EntityManager em = instance(executor.getExecutorId() + "-pu").em();
        em.clear();
        User user = (User) em.createQuery("select u from User u left join fetch u.followers where u.id = 1").getSingleResult();
        assertThat(user).isNotNull();
        assertThat(user.getId()).isEqualTo(1);
        assertThat(user.getTweets()).hasSize(1);
        Assert.assertEquals("dbunit rules json example", user.getTweets().get(0).getContent());
        assertThat(user.getFollowers()).isNotNull().hasSize(1);
        Follower expectedFollower = new Follower(2,1);
        assertThat(user.getFollowers()).contains(expectedFollower);
    }

}
 

private void clearEntityManager() {
	try {
		EntityManager em = getEntityManager();
		
		if(em != null) {
			em.clear();
		}
	} catch(Exception excp) {
		LOG.warn("DbAuditProvider.clearEntityManager(): failed", excp);
	}
}
 

public void save(A a) {
	final EntityManager em = createEntityManager();
	em.getTransaction().begin();
	em.merge(a);
	em.getTransaction().commit();
	em.clear();
	em.close();
}
 

@Test
public void testProduceEntityManagerMultipleTimesBakedByHolder() {
    // GIVEN
    final EntityManager em = mock(EntityManager.class);
    EntityManagerHolder.INSTANCE.setEntityManager(em);
    final EntityManagerProducerProxy producer = new EntityManagerProducerProxy(delegate);

    // WHEN
    final EntityManager instance1 = producer.produce(context);
    final EntityManager instance2 = producer.produce(context);

    // THEN (only proxies are created)
    assertThat(instance1, not(nullValue()));
    assertThat(instance2, not(nullValue()));
    assertThat(instance2, not(equalTo(instance1)));

    // WHEN (methods are invoked on the proxies)
    instance1.clear();
    instance2.clear();

    // THEN (the actual instance is retrieved from the holder and used)
    verify(em, times(2)).clear();

    // WHEN (further method is invoked on the proxies)
    instance1.close();
    instance2.close();

    // THEN (previously retrieved instance used)
    verify(em, times(2)).close();

    // WHEN
    producer.dispose(instance1);
    producer.dispose(instance2);

    // THEN (nothing happens since the instance is managed by the test environment)
    verifyNoMoreInteractions(delegate);
}
 

@Test
public void testProduceAndUseEntityManagerHavingAnInstanceBackedByTheHolder() {
    // GIVEN
    final EntityManager em = mock(EntityManager.class);
    EntityManagerHolder.INSTANCE.setEntityManager(em);
    final EntityManagerProducerProxy producer = new EntityManagerProducerProxy(delegate);

    // WHEN
    final EntityManager instance = producer.produce(context);

    // THEN (only a proxy is created)
    assertThat(instance, not(nullValue()));
    verifyNoMoreInteractions(delegate);

    // WHEN (method is invoked on the proxy)
    instance.clear();

    // THEN (the actual instance is retrieved from the holder and used)
    verifyNoMoreInteractions(delegate);
    verify(em).clear();

    // WHEN (further method is invoked on the proxy)
    instance.close();

    // THEN (previously retrieved instance used)
    verifyNoMoreInteractions(delegate);
    verify(em).close();

    // WHEN
    producer.dispose(instance);

    // THEN (nothing happens since the instance is managed by the test environment)
    verifyNoMoreInteractions(delegate);
}
 

@Test
public void testProduceAndUseEntityManagerWithoutHavingAnInstanceBackedByTheHolder() {
    // GIVEN
    final EntityManagerProducerProxy producer = new EntityManagerProducerProxy(delegate);

    // WHEN
    final EntityManager instance = producer.produce(context);

    // THEN (only a proxy is created)
    assertThat(instance, not(nullValue()));
    verifyNoMoreInteractions(delegate);

    // WHEN (method is invoked on the proxy)
    instance.clear();

    // THEN (the actual instance is created and used)
    verify(delegate).produce(context);
    verify(producedEntityManagers.get(0)).clear();

    // WHEN (further method is invoked on the proxy)
    instance.close();

    // THEN (previously created instance used)
    verifyNoMoreInteractions(delegate);
    verify(producedEntityManagers.get(0)).close();

    // WHEN
    producer.dispose(instance);

    // THEN (delegate.dispose is called for it)
    verify(delegate).dispose(producedEntityManagers.get(0));
    verifyNoMoreInteractions(delegate);
}
 

private void clearEntityManager() {
	try {
		EntityManager em = getEntityManager();

		if (em != null) {
			em.clear();
		}
	} catch (Exception excp) {
		logger.warn("DBAuditDestination.clearEntityManager(): failed", excp);
	}
}
 

protected <E extends Serializable> E persist(E item) {
    EntityManager manager = factory.createEntityManager();
    manager.getTransaction().begin();
    manager.persist(item);
    manager.getTransaction().commit();

    manager.clear();

    manager.close();

    return item;
}
 

protected void verifyDatabaseTable() {
    EntityManager manager = factory.createEntityManager();
    verifyDatabaseTable(manager, tableType.getAnnotation(Table.class).name());

    manager.clear();

    manager.close();
}
 

@Test
public void shouldSeedUserDataSet() {
    for (DataSetExecutorImpl executor : executors) {
        DataSetConfig DataSetConfig = new DataSetConfig("datasets/yml/users.yml").
            useSequenceFiltering(true);
        executor.createDataSet(DataSetConfig);
        EntityManager em = instance(executor.getExecutorId() + "-pu").em();
        em.clear();//jpa cache
        User user = (User) em.createQuery("select u from User u where u.id = 1").getSingleResult();
        assertThat(user).isNotNull();
        assertThat(user.getId()).isEqualTo(1);
    }

}
 

public static void clear(final EntityManager em, JpaQueryFactory factory) {
    factory.initalize(new JpaQueryFactoryContext() {
        @Override
        public EntityManager getEntityManager() {
            return em;
        }

        @Override
        public MetaPartition getMetaPartition() {
            JpaMetaProvider jpaMetaProvider = new JpaMetaProvider(em.getEntityManagerFactory());
            MetaLookupImpl metaLookup = new MetaLookupImpl();
            metaLookup.addProvider(jpaMetaProvider);
            metaLookup.initialize();
            return jpaMetaProvider.getPartition();
        }
    });
    clear(em, factory.query(OneToOneTestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(OneToOneOppositeEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(ManyToManyTestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(ManyToManyOppositeEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(TestSubclassWithSuperclassPk.class).buildExecutor().getResultList());
    clear(em, factory.query(RelatedEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(TestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(OtherRelatedEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(CountryTranslationEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(CountryEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(LangEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(BasicAttributesTestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(RenamedTestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(UuidTestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(JpaTransientTestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(CustomTypeTestEntity.class).buildExecutor().getResultList());
    clear(em, factory.query(OverrideIdTestEntity.class).buildExecutor().getResultList());
    em.flush();
    em.clear();
}
 

private <T> long store(Class<T> cls, EntityManager em) throws Exception {
	File directory = new File(this.dir, cls.getName());
	if ((!directory.exists()) || (!directory.isDirectory())) {
		throw new Exception("can not find directory: " + directory.getAbsolutePath() + ".");
	}
	long count = 0;
	List<File> files = new ArrayList<>(FileUtils.listFiles(directory, new String[] { "json" }, false));
	/** 对文件进行排序,和dump的时候的顺序保持一直 */
	Collections.sort(files, new Comparator<File>() {
		public int compare(File o1, File o2) {
			String n1 = FilenameUtils.getBaseName(o1.getName());
			String n2 = FilenameUtils.getBaseName(o2.getName());
			Integer i1 = Integer.parseInt(n1);
			Integer i2 = Integer.parseInt(n2);
			return i1.compareTo(i2);
		}
	});
	/** 尽量在最后进行清空操作 */
	this.clean(cls, em);
	File file = null;
	for (int i = 0; i < files.size(); i++) {
		file = files.get(i);
		System.out.println("restoring " + (i + 1) + "/" + files.size() + " part of data: " + cls.getName() + ".");
		JsonArray raws = this.convert(file);
		em.getTransaction().begin();
		for (JsonElement o : raws) {
			T t = pureGsonDateFormated.fromJson(o, cls);
			em.persist(t);
			count++;
		}
		em.getTransaction().commit();
		em.clear();
		Runtime.getRuntime().gc();
	}
	System.out.println("restore data: " + cls.getName() + " completed, count: " + count + ".");
	return count;

}
 

@MCRCommand(syntax = "generate md5sum files in directory {0}",
    help = "writes md5sum files for every content store in directory {0}")
public static void writeMD5SumFile(String targetDirectory) throws IOException {
    File targetDir = getDirectory(targetDirectory);
    EntityManager em = MCREntityManagerProvider.getCurrentEntityManager();
    MCRStreamQuery<MCRFSNODES> streamQuery = MCRStreamQuery.getInstance(em,
        "from MCRFSNODES where type='F' order by storeid, storageid", MCRFSNODES.class);
    Map<String, MCRContentStore> availableStores = MCRContentStoreFactory.getAvailableStores();
    String currentStoreId = null;
    MCRContentStore currentStore = null;
    File currentStoreBaseDir = null;
    BufferedWriter bw = null;
    String nameOfProject = MCRConfiguration2.getString("MCR.NameOfProject").orElse("MyCoRe");
    try {
        Iterator<MCRFSNODES> fsnodes = streamQuery.getResultStream().iterator();
        while (fsnodes.hasNext()) {
            MCRFSNODES fsNode = fsnodes.next();
            String storeID = fsNode.getStoreid();
            String storageID = fsNode.getStorageid();
            String md5 = fsNode.getMd5();
            em.detach(fsNode);
            if (!storeID.equals(currentStoreId)) {
                //initialize current store
                currentStoreId = storeID;
                currentStore = availableStores.get(storeID);
                if (bw != null) {
                    bw.close();
                }
                File outputFile = new File(targetDir,
                    new MessageFormat("{0}-{1}.md5", Locale.ROOT).format(new Object[] { nameOfProject, storeID }));
                LOGGER.info("Writing to file: {}", outputFile.getAbsolutePath());
                bw = Files.newBufferedWriter(outputFile.toPath(), Charset.defaultCharset(),
                    StandardOpenOption.CREATE);
                try {
                    currentStoreBaseDir = currentStore.getBaseDir();
                } catch (Exception e) {
                    LOGGER.warn("Could not get baseDir of store: {}", storeID, e);
                    currentStoreBaseDir = null;
                }
            }
            String path = currentStoreBaseDir != null ? currentStore.getLocalFile(storageID).getAbsolutePath()
                : storageID;
            //current store initialized
            String line = new MessageFormat("{0}  {1}\n", Locale.ROOT).format(new Object[] { md5, path });
            bw.write(line);
        }
    } finally {
        if (bw != null) {
            try {
                bw.close();
            } catch (IOException e1) {
                LOGGER.warn("Error while closing file.", e1);
            }
        }
        em.clear();
    }
}
 

@Override
public void release(final EntityManager em) {
    em.clear();
    em.close();
}
 

public ISoapBoxEntity findById(Class<? extends ISoapBoxEntity> entityClass, Long id) {
	EntityManager manager = ConnectionDB.getManager();
	manager.clear();
	return manager.find(entityClass, id);
}
 

private <T extends StorageObject> long store(final Class<T> cls, final EntityManager em,
		final StorageMappings storageMappings) throws Exception {
	final File classDirectory = new File(this.dir, cls.getName());
	if ((!classDirectory.exists()) || (!classDirectory.isDirectory())) {
		throw new Exception("can not find directory: " + classDirectory.getAbsolutePath() + ".");
	}
	long count = 0;
	final List<File> files = new ArrayList<File>(
			FileUtils.listFiles(classDirectory, new String[] { "json" }, false));
	/** 对文件进行排序,和dump的时候的顺序保持一直 */
	Collections.sort(files, new Comparator<File>() {
		public int compare(final File o1, final File o2) {
			final String n1 = FilenameUtils.getBaseName(o1.getName());
			final String n2 = FilenameUtils.getBaseName(o2.getName());
			final Integer i1 = Integer.parseInt(n1);
			final Integer i2 = Integer.parseInt(n2);
			return i1.compareTo(i2);
		}
	});
	/** 尽量将删除的工作放在后面 */
	this.clean(cls, em, storageMappings);
	StorageMapping mapping = null;
	File file = null;
	for (int i = 0; i < files.size(); i++) {
		file = files.get(i);
		/** 必须先转换成 jsonElement 不能直接转成泛型T,如果直接转会有类型不匹配比如Integer变成了Double */
		logger.print("restoring " + (i + 1) + "/" + files.size() + " part of storage: " + cls.getName() + ".");
		final JsonArray raws = this.convert(file);
		if (null != raws) {
			em.getTransaction().begin();
			for (final JsonElement o : raws) {
				final T t = pureGsonDateFormated.fromJson(o, cls);
				if (Config.dumpRestoreStorage().getRedistribute()) {
					mapping = storageMappings.random(cls);
				} else {
					mapping = storageMappings.get(cls, t.getStorage());
				}
				if (null == mapping) {
					throw new Exception(
							"can not find storageMapping class: " + cls.getName() + ", name:" + t.getName());
				}
				final File source = new File(classDirectory, FilenameUtils.getBaseName(file.getName())
						+ StorageObject.PATHSEPARATOR + FilenameUtils.getName(t.path()));
				try (FileInputStream input = new FileInputStream(source)) {
					t.saveContent(mapping, input, t.getName());
				}
				em.persist(t);
				count++;
			}
			em.getTransaction().commit();
			em.clear();
			Runtime.getRuntime().gc();
		}
	}
	return count;
}