我有一个现有的类，想要向其中添加一个方法。但是我希望该方法仅从特定类的特定方法中调用。是否有任何方法可以防止其他类/方法调用该方法？
例如，我有一个现有的A类。
public final class A
{
//other stuff available for all classes/methods
//I want to add a method that does its job only if called from a specific method of a class, for example:
public void method()
{
//proceed if called from Class B.anotherMethod() else throw Exception
}
}
一种方法是在method()内获取StackTrace，然后确认父方法。
我想要的是一种更干净、更可取的解决方案，比如设计模式之类的东西。
说实话，你已经让自己陷入了困境。
如果类A和B既不相关又不属于同一个包，则可见性无法解决问题。（即使它可以，反射也可以用来规避可见性规则。）
如果代码可以使用反射调用方法，则静态代码分析也无法解决该问题。
将B.this作为额外参数传递并检查其是否符合A.method(...)是无助的，因为某个其他类C也可以传递一个B实例。
这只留下了堆栈跟踪的方法1...或放弃并依赖程序员的良好意识2，不去调用他们不应该调用的方法。
理想的解决方案是重新审查导致出现此问题的设计和/或编码决策。
1- 请参阅其他答案以获取使用注释、安全管理器等来隐藏堆栈跟踪内容以免影响应用程序员的示例。但请注意，在幕后，您正在每次方法调用时添加可能数百甚至数千条指令开销。
2- 不要低估程序员的良好意识。大多数程序员看到不调用某些方法的建议时，很可能会遵循该建议。
doPrivileged。真是一团糟。 - Tom Hawtin - tacklinedoPrivileged。 - Paŭlo Ebermannpublic方法和奇怪的权限分配）。 - Tom Hawtin - tackline唯一确定在运行时检查的方法是获取堆栈跟踪。即使它是私有的，您也可以通过反射访问该方法。
一个更简单的方法是检查您的IDE中的用法。（前提是不通过反射调用）
public static void checkPermission(Class... expectedCallerClasses) {
StackTraceElement callerTrace = Thread.currentThread().getStackTrace()[3];
for (Class expectedClass : expectedCallerClasses) {
if (callerTrace.getClassName().equals(expectedClass.getName())) {
return;
}
}
throw new RuntimeException("Bad caller.");
}
使用它非常简单：只需指定哪个类可以调用该方法。例如，
public void stop() {
checkPermission(ShutdownHandler.class);
running = false;
}
合理使用protected
protected 关键字适用于同一包中的类。 - wkl在Java中完成这个任务的标准方法是将B类和A类放在同一个包中（可能是当前应用程序的子包），并使用默认可见性。
默认的Java可见性是“包私有”，这意味着该包中的所有内容都可以看到您的方法，但该包之外的任何内容都无法访问它。
package net.openid.conformance.archunit;
import com.google.gson.JsonElement;
import com.tngtech.archunit.base.DescribedPredicate;
import com.tngtech.archunit.core.domain.AccessTarget;
import com.tngtech.archunit.core.domain.JavaClass;
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.lang.ArchRule;
import net.openid.conformance.testmodule.OIDFJSON;
import org.junit.Test;
import static com.tngtech.archunit.core.domain.JavaCall.Predicates.target;
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.assignableTo;
import static com.tngtech.archunit.core.domain.properties.HasName.Predicates.*;
import static com.tngtech.archunit.core.domain.properties.HasOwner.Predicates.With.owner;
import static com.tngtech.archunit.lang.conditions.ArchPredicates.are;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
public class PreventGetAs {
@Test
public void doNotCallJsonElementGetAs() {
JavaClasses importedClasses = new ClassFileImporter().importPackages("net.openid.conformance");
JavaClasses allExceptOIDFJSON = importedClasses.that(DescribedPredicate.not(nameContaining("OIDFJSON")));
ArchRule rule = noClasses().should().callMethodWhere(
target(nameMatching("getAs[^J].*")) // ignores getAsJsonObject/getAsJsonPrimitive/etc which are fine
.and(target(owner(assignableTo(JsonElement.class)))
)).because("the getAs methods perform implicit conversions that might not be desirable - use OIDFJSON wrapper instead");
rule.check(allExceptOIDFJSON);
}
}
我知道你的使用情况中提到了“特定类中的特定方法”，但我认为你无法在设计时可靠地解决这个问题（而且我也想不出有哪种情况需要强制执行这个限制）。
以下示例创建了一个简单的设计时解决方案，用于限制访问类的方法仅限于特定类。但是，它可以轻松扩展到允许多个类。
通过定义一个公共内部类和一个私有构造函数来实现。该内部类作为所需方法的密钥。在下面的示例中，类Bar具有一个只能从Foo类的实例调用的方法。
public class Foo
{
public Foo()
{
Bar bar = new Bar();
bar.method(new FooPrivateKey());
}
public class FooPrivateKey
{
private FooPrivateKey()
{ }
}
}
public class Bar
{
public Bar()
{
}
public void method(FooPrivateKey fooPrivateKey)
{
if(fooPrivateKey == null)
{ throw new IllegalArgumentException("This method should only be called from the Foo class.");}
//Do originally intended work.
}
}
我认为这种方法并不适用于反射或者像 FooPrivateKey.class.newInstance() 这样的操作，但是它至少可以比简单的注释或文档更明显地提醒程序员，同时你也不必去研究像 Roberto Trunfio 和 Ronan Quillevere 所建议的更复杂的事情（这些也是完全可行的答案，只是在我看来对大多数情况来说过于复杂了）。
希望这对你的使用场景足够了。
您可以使用注释和反射来实现。我将报告一个类似的情况，即只能让外部类的特定方法调用该方法的情况。假设必须通过任何公共方法“保护”的类是Invoked，而Invoker是具有启用从Invoked调用一个或多个方法的方法的类。然后，您可以执行以下操作。
public class Invoked{
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public static @interface CanInvoke{}
public void methodToBeInvoked() {
boolean canExecute=false;
try {
//get the caller class
StackTraceElement element = (new Throwable()).getStackTrace()[1];
String className = element.getClassName();
Class<?> callerClass = Class.forName(className);
//check if caller method is annotated
for (Method m : callerClass.getDeclaredMethods()) {
if (m.getName().equals(methodName)) {
if(Objects.nonNull(m.getAnnotation(EnabledToMakeOperationRemoved.class))){
canExecute = true;
break;
}
}
}
} catch (SecurityException | ClassNotFoundException ex e) {
//In my case does nothing
}
if(canExecute){
//do something
}
else{
//throw exception
}
}
}
而 Invoker 类则是
public class Invoker{
private Invoked i;
@Invoked.CanInvoke
public void methodInvoker(){
i.methodToBeInvoked();
}
}
CanInvoke注释。canExecute变量为true。