小贝子编程

java.lang.ClassNotFoundException: java.lang.instrument.Illeg



我从一个简单的项目开始，使用spring jpa和一个简单的maven类来测试这个基本行为。一切都很好。我的下一步是将这个单独的项目分成两个项目，以便让一个持久化项目负责数据访问，另一个用业务逻辑充实。这是一切都崩溃的地方。这与java模块相关的证据是，如果我删除两个项目上的module-info.java，一切都可以正常工作。如果我只是运行应用程序，我得到

Exception in thread "main" java.lang.NoClassDefFoundError: java/lang/instrument/IllegalClassFormatException
at spring.data.jpa@2.7.3/org.springframework.data.jpa.repository.config.JpaRepositoryConfigExtension.getConfigurationInspectionClassLoader(JpaRepositoryConfigExtension.java:239)
at spring.data.commons@2.7.3/org.springframework.data.repository.config.RepositoryConfigurationExtensionSupport.getRepositoryConfigurations(RepositoryConfigurationExtensionSupport.java:97)
at spring.data.commons@2.7.3/org.springframework.data.repository.config.RepositoryConfigurationDelegate.registerRepositoriesIn(RepositoryConfigurationDelegate.java:159)
at spring.data.commons@2.7.3/org.springframework.data.repository.config.RepositoryBeanDefinitionRegistrarSupport.registerBeanDefinitions(RepositoryBeanDefinitionRegistrarSupport.java:106)
at spring.context@5.3.23/org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.lambda$loadBeanDefinitionsFromRegistrars$1(ConfigurationClassBeanDefinitionReader.java:396)
at java.base/java.util.LinkedHashMap.forEach(LinkedHashMap.java:684)
at spring.context@5.3.23/org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsFromRegistrars(ConfigurationClassBeanDefinitionReader.java:395)
at spring.context@5.3.23/org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForConfigurationClass(ConfigurationClassBeanDefinitionReader.java:157)
at spring.context@5.3.23/org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitions(ConfigurationClassBeanDefinitionReader.java:129)
at spring.context@5.3.23/org.springframework.context.annotation.ConfigurationClassPostProcessor.processConfigBeanDefinitions(ConfigurationClassPostProcessor.java:343)
at spring.context@5.3.23/org.springframework.context.annotation.ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry(ConfigurationClassPostProcessor.java:247)
at spring.context@5.3.23/org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanDefinitionRegistryPostProcessors(PostProcessorRegistrationDelegate.java:311)
at spring.context@5.3.23/org.springframework.context.support.PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(PostProcessorRegistrationDelegate.java:112)
at spring.context@5.3.23/org.springframework.context.support.AbstractApplicationContext.invokeBeanFactoryPostProcessors(AbstractApplicationContext.java:746)
at spring.context@5.3.23/org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:564)
at spring.context@5.3.23/org.springframework.context.annotation.AnnotationConfigApplicationContext.<init>(AnnotationConfigApplicationContext.java:93)
at test/org.test.Main.main(Main.java:15)
Caused by: java.lang.ClassNotFoundException: java.lang.instrument.IllegalClassFormatException
at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:581)
at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178)
at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:522)
... 17 more

如果我调试它，它开始抱怨缺少类(Derby、hibernate等)。所有这些都让我相信问题是在java模块声明上，但我不知道如何解决这个问题。

这是我的文件结构:

- test
-- src.main.java
--- org.test
---- Config.java
---- Main.java
--- module-info.java
--- src.main.resources
---- org/test/application.properties
-- pom.xml

- test-persistence
-- src.main.java
--- org.test.persistence
---- CustomRepository.java
---- CustomRepositoryImpl.java
---- Entity.java
---- MyRepository.java
---- PersistenceConfiguration.java
--- module-info.java
-- pom.xml

文件如下:

测试pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>test</groupId>
<artifactId>test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<spring.version>5.3.23</spring.version>
<spring-data.version>2.7.3</spring-data.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<release>11</release>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>

<dependency>
<groupId>test</groupId>
<artifactId>test-persistence</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-instrument -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-instrument</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>
</dependencies>
</project>

测试模块信息:

module test {
requires testPersistence;
requires spring.context;
requires spring.beans;
requires spring.core;
requires spring.instrument;
opens org.test;
}

Config.java:

package org.test;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.test.persistence.PersistenceConfiguration;
@Configuration
@ComponentScan(basePackages = "org.test")
@Import(PersistenceConfiguration.class)
public class Config {
}

Main.java

package org.test;
import java.util.List;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.test.persistence.Entity;
import org.test.persistence.MyRepository;
public class Main {
public static void main(String[] args) {
System.out.println("Running java " + Runtime.version().feature());
AnnotationConfigApplicationContext appCtx = new AnnotationConfigApplicationContext(Config.class);
MyRepository repo = appCtx.getBean(MyRepository.class);
List<Entity> result = repo.findOrderedByLastUsedLimitedTo(2);
}
}

application.properties:

spring.jpa.generate-ddl=true
spring.jpa.defer-datasource-initialization=true
spring.jpa.database-platform=org.hibernate.dialect.DerbyDialect
spring.jpa.hibernate.ddl-auto=update
spring.datasource.driverClassName=org.apache.derby.iapi.jdbc.AutoloadedDriver
spring.datasource.url=jdbc:derby:eTimer;create=true

test-persistence pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>test</groupId>
<artifactId>test-persistence</artifactId>
<version>0.0.1-SNAPSHOT</version>

<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<spring.version>5.3.23</spring.version>
<spring-data.version>2.7.3</spring-data.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<release>11</release>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<!-- https://mvnrepository.com/artifact/javax.persistence/javax.persistence-api -->
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>${spring-data.version}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-instrument -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-instrument</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
</project>

test-persistence module-info.java:

module testPersistence {

requires java.persistence;
requires java.sql;
requires spring.data.commons;
requires spring.data.jpa;
requires spring.orm;
requires spring.jdbc;
requires spring.tx;
requires spring.context;
opens org.test.persistence;
exports org.test.persistence to test;
}

CustomRepository.java:

package org.test.persistence;
import java.util.List;
import org.springframework.stereotype.Repository;
@Repository
public interface CustomRepository {
List<Entity> findOrderedByDescriptionLimitedTo(int maxItems);
}

CustomRepositoryImpl.java:

package org.test.persistence;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
public class CustomRepositoryImpl implements CustomRepository {
@PersistenceContext
private EntityManager entityManager;
@Override
public List<Entity> findOrderedByDescriptionLimitedTo(int limit) {
return entityManager.createQuery("SELECT p FROM Entity p ORDER BY p.description", Entity.class)
.setMaxResults(limit).getResultList();
}
}

Entity.java:

package org.test.persistence;
import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@javax.persistence.Entity
@Table(name = "Entity")
public class Entity {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column
private String description;
public Entity() {
super();
}
public Entity(Long id, String description) {
super();
this.id = id;
this.description = description;
}
}

MyRepository.java:

package org.test.persistence;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface MyRepository extends JpaRepository<Entity, Long>, CustomRepository {
Entity save(Entity task);
}

PersistenceConfiguration.java:

package org.test.persistence;
import java.io.File;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
@Configuration
@EnableJpaRepositories("org.test.persistence")
@PropertySource("org/test/application.properties")
public class PersistenceConfiguration {
private static final String DRIVER_CLASS_NAME = "org.apache.derby.iapi.jdbc.AutoloadedDriver";
private static final String DATA_SOURCE_DRIVER_URL = "jdbc:derby:test;create=true";
private static final String DATA_SOURCE_USER = null;
private static final String DATA_SOURCE_PASSWORD = null;
@Bean("entityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

System.setProperty("derby.system.home", System.getProperty("user.home") + File.separatorChar + "test");

LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
entityManagerFactoryBean.setPackagesToScan("org.test");
entityManagerFactoryBean.setPersistenceUnitName("system");
entityManagerFactoryBean.setDataSource(systemDataSource());
HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
adapter.setDatabase(Database.DERBY);
adapter.setShowSql(true);
adapter.setGenerateDdl(true);
entityManagerFactoryBean.setJpaVendorAdapter(adapter);
return entityManagerFactoryBean;
}
@Bean
DataSource systemDataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName(DRIVER_CLASS_NAME);
dataSource.setUrl(DATA_SOURCE_DRIVER_URL);
dataSource.setUsername(DATA_SOURCE_USER);
dataSource.setPassword(DATA_SOURCE_PASSWORD);
return dataSource;
}
@Bean(name="transactionManager")
public PlatformTransactionManager systemTransactionManager() {
JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory((entityManagerFactory().getObject()));
return transactionManager;
}
}

帮助吗?

我和你有同样的问题，我强烈认为问题在于一件事。(可能是一个模块中的东西)想要访问另一个"东西";(也可能是在另一个模块的东西)。由于模块策略(通过使用module-info.java声明)-在导入模块之间访问的访问限制是什么-您得到ClassNotFoundException.

对此的解决方案是给予"access"一个模块到另一个模块。实际上，我没有找到一种方法来找出哪个模块想要访问什么。

在你的情况下，我认为有些东西想要访问java.lang.instrument.IllegalClassFormatException，在module-info.java文件中意味着什么，你需要opens ... to ...或export ... to ...(或可能只有requires ...)在java.instrument-模块内。

相关内容

最新更新


热门标签：

javascript python java c# php android html jquery c++ css ios sql mysql arrays asp.net json python-3.x ruby-on-rails .net sql-server django objective-c excel regex ruby linux ajax iphone xml vba spring asp.net-mvc database wordpress string postgresql wpf windows xcode bash git oracle list vb.net multithreading eclipse algorithm macos powershell visual-studio image forms numpy scala function api selenium