java对所有扩展类只访问一次静态变量

Question

我的要求是，我有一个auth类，它提供身份验证令牌（它是String），并且该令牌可以在所有其他类中使用。我写了一小段代码，但不幸的是，所有其他类都在单独生成身份验证令牌。所以每个类有一个身份验证令牌。但我很快做了如下改变。请看看这是一个正确的方法还是有更好的方法

public class AuthProvider {
    public static String authKey;
    public static String provideAuth() {
        AuthProvider pro = new AuthProvider();
        String key = pro.generateAuthKey();
        authKey = key;
        return key;
    }
    private String generateAuthKey() {
        Random rand = new Random();
        int n = rand.nextInt(5000) + 1;
        return String.valueOf(n);
    }
}

上面的一个是我的身份验证提供者类，它向所有其他类提供身份验证令牌

现在，我的名为“FirstClass”的子类需要auth令牌来执行其他操作，如下所示

public class FirstClass extends AuthProvider {

    public String getValueFromFirstClass() {
        AuthProvider.provideAuth();
        String s = AuthProvider.authKey;
        return "FirstClassAuth: " + s;
    }
}

我的第二个子类名为SecondClass，它将成为主类，因为main方法调用这个类中的方法，该方法也负责从FirstClass中获取某个值

public class SecondClass extends AuthProvider {

    public String getValueFromSecondClass() {
        FirstClass firstClass = new FirstClass();
        String firstClassString = firstClass.getValueFromFirstClass();
        String s = AuthProvider.authKey;
        return "SecondClass Auth: " + s + " -------- " + firstClassString;
    }
    public static void main(String[] args) {
        SecondClass class2 = new SecondClass();
        System.out.println(class2.getValueFromSecondClass());
    }
}

所以我的要求是。。我不需要每个子类有两个不同的“AuthToken”。我可以在FirstClass和SecondClass中使用一个身份验证令牌。所以我所做的是对的？还是有更好的方法

Answer 1

这就是我的方法，使用带有static初始化块的全局常量：

public class AuthProvider {
    public static final String AUTH_KEY;

    static {
        AUTH_KEY = String.valueOf(new Random().nextInt(5000) + 1);
    }
}

然后，在任何其他类中，您都可以使用AuthProvider.AUTH_KEY来检索该值

Answer 2

我强烈建议您在这里使用单例和依赖注入：

public class AuthProvider {
    private static final AuthProvider _instance = new AuthProvider();
    private final String authKey;

    public AuthProvider() {
        authKey = String.valueOf(new Random().nextInt(5000) + 1);
    }

    public static AuthProvider getInstance() {
        return _instance;
    }

    public String getAuthKey() {
        return authKey;
    }
}

public class FirstClass {
    private AuthProvider authProvider;

    public FirstClass(AuthProvider authProvider) {
        this.authProvider = authProvider;
    }

    public String getValueFromFirstClass() {
        String s = authProvider.getAuthKey();
        return "FirstClassAuth: " + s;
    }
}

编辑1:

SecondClass在这种情况下，看起来像：

public class SecondClass {
    private AuthProvider authProvider;

    public SecondClass(AuthProvider authProvider) {
        this.authProvider = authProvider;
    }

    public String getValueFromSecondClass() {
        FirstClass firstClass = new FirstClass(authProvider);
        String firstClassString = firstClass.getValueFromFirstClass();
        String s = authProvider.getAuthKey();
        return "SecondClass Auth: " + s + "      " + firstClassString;
    }
    public static void main(String[] args) {
        SecondClass class2 = new SecondClass(AuthProvider.getInstance());
        System.out.println(class2.getValueFromSecondClass());
    }
}

同样，这不是最好的解决方案。通常我们将main方法拆分为一个名为Application.java的单独类，该类只有main方法

编辑2:

我们之所以避免使用extends，是因为该关键字与相关，是一种范式。在你的例子中，看起来你想使用AuthProvider和表达依赖关系——这在英语中听起来像FirstClass和SecondClass没有AuthProvider就无法完成他们的工作

这是由构造函数DI（依赖项注入）完成的，如果不提供AuthProvider的实例，就不能使用（实例化）这两个类

如果你不是在构建一个Web应用程序，你甚至不需要把AuthProvider作为一个单身汉：

public class AuthProvider {
    private final String authKey;

    public AuthProvider() {
        authKey = String.valueOf(new Random().nextInt(5000) + 1);
    }

    public String getAuthKey() {
        return authKey;
    }
}

然后将main方法更改为：

public static void main(String[] args) {
    SecondClass class2 = new SecondClass(new AuthProvider());
    System.out.println(class2.getValueFromSecondClass());
}

DI将把它传播到FirstClass