如何禁止指定包的类导入另一包的类？（Java，无构建工具/访问修饰符修改）

方案一：Java 9+模块系统（推荐） #

你之前尝试模块系统未成功，应该是module-info.java的导出规则配置有误。这个方案能在编译阶段强制实现单向访问限制，完全符合你的需求。

1. 调整项目结构 #

将原有结构改为标准模块结构，新增module-info.java放在模块根目录（与包层级同级）：

-src
  -main 
    -java
      -module-info.java
      -main
        -firstpackage
          -A.java
        -secondpackage
          -B.java
        -thirdpackage
          -C.java

2. 编写模块描述文件 #

通过exports ... to语法精确控制包的访问权限：

module myapp {
    // 允许secondpackage、thirdpackage访问firstpackage的类
    exports main.firstpackage to main.secondpackage, main.thirdpackage;
    
    // 仅允许thirdpackage访问secondpackage的类（拒绝firstpackage）
    exports main.secondpackage to main.thirdpackage;
}

• 因为没有将main.secondpackage导出给main.firstpackage，所以firstpackage下的类无法访问secondpackage的任何public类；
• secondpackage可以正常访问firstpackage，thirdpackage能访问所有包，完全匹配你的要求。

3. 编译代码 #

使用javac的模块编译命令：

javac -d out --module-source-path src/main/java src/main/java/module-info.java src/main/java/main/firstpackage/A.java src/main/java/main/secondpackage/B.java src/main/java/main/thirdpackage/C.java

编译时，A类中导入或实例化B类的代码会直接报错，其他合法访问则正常通过。

方案二：编译时注解处理器（兼容Java 8+） #

如果需要兼容Java 8，可以自定义注解处理器，在编译阶段拦截非法访问。

1. 编写注解处理器 #

创建处理器类，专门检查firstpackage下的类是否违规导入secondpackage：

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import java.util.Set;

@SupportedAnnotationTypes("*")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class ImportRestrictionProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element rootElement : roundEnv.getRootElements()) {
            TypeElement typeElement = (TypeElement) rootElement;
            String currentPackage = processingEnv.getElementUtils()
                    .getPackageOf(typeElement).getQualifiedName().toString();

            // 只检查firstpackage下的类
            if ("main.firstpackage".equals(currentPackage)) {
                // 遍历所有导入的类型
                Set<? extends TypeElement> importedTypes = processingEnv.getElementUtils()
                        .getAllImportedTypes(typeElement);
                
                for (TypeElement importedType : importedTypes) {
                    String importedPackage = processingEnv.getElementUtils()
                            .getPackageOf(importedType).getQualifiedName().toString();
                    
                    // 发现导入secondpackage则抛出编译错误
                    if ("main.secondpackage".equals(importedPackage)) {
                        processingEnv.getMessager().printMessage(
                                Diagnostic.Kind.ERROR,
                                "禁止导入main.secondpackage中的类",
                                typeElement
                        );
                    }
                }
            }
        }
        return false;
    }
}

2. 编译处理器 #

javac ImportRestrictionProcessor.java

3. 编译主代码并启用处理器 #

javac -processor ImportRestrictionProcessor -d out src/main/firstpackage/A.java src/main/secondpackage/B.java src/main/thirdpackage/C.java

此时A类中任何访问B类的导入语句都会触发编译错误。如果要拦截直接使用全限定名（如new main.secondpackage.B()）的情况，需要扩展处理器使用Java Compiler Tree API解析语法树，检查实例化语句的类型。

内容的提问来源于stack exchange，提问作者robertiscoding