Java InstrumentationLoadTimeWeaver类代码示例

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
	LoadTimeWeaver serverSpecificLoadTimeWeaver = createServerSpecificLoadTimeWeaver(classLoader);
	if (serverSpecificLoadTimeWeaver != null) {
		if (logger.isInfoEnabled()) {
			logger.info("Determined server-specific load-time weaver: " +
					serverSpecificLoadTimeWeaver.getClass().getName());
		}
		this.loadTimeWeaver = serverSpecificLoadTimeWeaver;
	}
	else if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
		logger.info("Found Spring's JVM agent for instrumentation");
		this.loadTimeWeaver = new InstrumentationLoadTimeWeaver(classLoader);
	}
	else {
		try {
			this.loadTimeWeaver = new ReflectiveLoadTimeWeaver(classLoader);
			logger.info("Using a reflective load-time weaver for class loader: " +
					this.loadTimeWeaver.getInstrumentableClassLoader().getClass().getName());
		}
		catch (IllegalStateException ex) {
			throw new IllegalStateException(ex.getMessage() + " Specify a custom LoadTimeWeaver or start your " +
					"Java virtual machine with Spring's agent: -javaagent:org.springframework.instrument.jar");
		}
	}
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
public void setBeanClassLoader(ClassLoader classLoader) {
	LoadTimeWeaver serverSpecificLoadTimeWeaver = createServerSpecificLoadTimeWeaver(classLoader);
	if (serverSpecificLoadTimeWeaver != null) {
		if (logger.isInfoEnabled()) {
			logger.info("Determined server-specific load-time weaver: " +
					serverSpecificLoadTimeWeaver.getClass().getName());
		}
		this.loadTimeWeaver = serverSpecificLoadTimeWeaver;
	}
	else if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
		logger.info("Found Spring's JVM agent for instrumentation");
		this.loadTimeWeaver = new InstrumentationLoadTimeWeaver(classLoader);
	}
	else {
		try {
			this.loadTimeWeaver = new ReflectiveLoadTimeWeaver(classLoader);
			logger.info("Using a reflective load-time weaver for class loader: " +
					this.loadTimeWeaver.getInstrumentableClassLoader().getClass().getName());
		}
		catch (IllegalStateException ex) {
			throw new IllegalStateException(ex.getMessage() + " Specify a custom LoadTimeWeaver or start your " +
					"Java virtual machine with Spring's agent: -javaagent:org.springframework.instrument.jar");
		}
	}
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
@Override
public void destroy() {
	if (this.loadTimeWeaver instanceof InstrumentationLoadTimeWeaver) {
		logger.info("Removing all registered transformers for class loader: " +
				this.loadTimeWeaver.getInstrumentableClassLoader().getClass().getName());
		((InstrumentationLoadTimeWeaver) this.loadTimeWeaver).removeTransformers();
	}
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
@Override
public void afterPropertiesSet() {
	if (this.loadTimeWeaver == null && InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
		this.loadTimeWeaver = new InstrumentationLoadTimeWeaver(this.resourcePatternResolver.getClassLoader());
	}
	preparePersistenceUnitInfos();
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
protected LocalContainerEntityManagerFactoryBean createEntityManagerFactoryBean(
		String persistenceXml, Properties props, String entityManagerName) throws Exception {

	// This will be set by DummyPersistenceProvider
	actualPui = null;
	actualProps = null;

	LocalContainerEntityManagerFactoryBean containerEmfb = new LocalContainerEntityManagerFactoryBean();

	containerEmfb.setPersistenceUnitName(entityManagerName);
	containerEmfb.setPersistenceProviderClass(DummyContainerPersistenceProvider.class);
	if (props != null) {
		containerEmfb.setJpaProperties(props);
	}
	containerEmfb.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
	containerEmfb.setPersistenceXmlLocation(persistenceXml);
	containerEmfb.afterPropertiesSet();

	assertEquals(entityManagerName, actualPui.getPersistenceUnitName());
	if (props != null) {
		assertEquals(props, actualProps);
	}
	//checkInvariants(containerEmfb);

	return containerEmfb;

	//containerEmfb.destroy();
	//emfMc.verify();
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
public static void initialize(final String args, final Instrumentation inst) {
    if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
        throw new IllegalStateException(
                "Instrumentation is already available, the agent should have been loaded already!");
    }

    InstrumentationSavingAgent.premain(args, inst);
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
public static void main(String[] args) {
	DynamicInstrumentationLoader.waitForInitialized();
	DynamicInstrumentationLoader.initLoadTimeWeavingContext();
	if (!InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
		throw new IllegalStateException("Instrumentation not available!");
	} else {
		System.out.println("Instrumentation available!");
	}
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
public void destroy() {
	if (this.loadTimeWeaver instanceof InstrumentationLoadTimeWeaver) {
		logger.info("Removing all registered transformers for class loader: " +
				this.loadTimeWeaver.getInstrumentableClassLoader().getClass().getName());
		((InstrumentationLoadTimeWeaver) this.loadTimeWeaver).removeTransformers();
	}
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
public LoadTimeWeaver getLoadTimeWeaver() {
    return new InstrumentationLoadTimeWeaver();
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
@Bean
public LoadTimeWeaver loadTimeWeaver() {
    return new InstrumentationLoadTimeWeaver();
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
private String detectWeavingMode() {
    LOGGER.info("PersistenceConfiguration.detectWeavingMode()");
    return InstrumentationLoadTimeWeaver.isInstrumentationAvailable() ? "true" : "static";
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
public static boolean isInitialized() {
    return InstrumentationLoadTimeWeaver.isInstrumentationAvailable();
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
@Bean
public LoadTimeWeaver instrumentationLoadTimeWeaver() {
	return new InstrumentationLoadTimeWeaver();
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
public void afterPropertiesSet() {
	if (this.loadTimeWeaver == null && InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
		this.loadTimeWeaver = new InstrumentationLoadTimeWeaver(this.resourcePatternResolver.getClassLoader());
	}
	preparePersistenceUnitInfos();
}
 

import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver; //导入依赖的package包/类
/**
 * Subclasses should override this method if they wish to disable shadow class loading.
 * <p>The default implementation deactivates shadow class loading if Spring's
 * InstrumentationSavingAgent has been configured on VM startup.
 */
protected boolean shouldUseShadowLoader() {
	return !InstrumentationLoadTimeWeaver.isInstrumentationAvailable();
}