Tomcat / JKS / Keytool - 重新生成私钥？(Tomcat / JKS / Keytool - regenerate private key?)

 您只需在编译时使用注释。 如果注释类在运行时不可用，则它们将不存在。 
 
 例如，如果客户端代码在域模型类上调用AnnotatedElement.getAnnotations（），并且编译的注释在类路径中不可用，则不会返回它们。 
 
 如果使用maven，则应声明注释依赖项，并使用scope可选。 可选的依赖项不会包含在客户端中。 因此，只有客户声明它们时才可用。 
 
 例如： 
 
 如果Proj-A在Proj-B上有可选的依赖项（？ - >） 
 
 Proj-A ?-> Proj-B 
 
 并且Proj-X将Proj-A引用为编译依赖项，它将不会获得可选的依赖项Proj-B。 
 
 Proj-X -> Proj-A 
 
 因为传递依赖性解析以可选依赖关系结束。 
 
 期望在名为annotations.jar的jar文件中包含以下annotations.jar 
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ARuntimeAnnotation {

}
 
 并且你有一个model.jar包含的以下模型类 
 
@ARuntimeAnnotation
public class Model {

}
 
 并且model.jar与model.jar有依赖关系，因为它需要它来编译。 
 
<depdendency>
       <groupId>someGroup</groupId>
       <artifactId>annotations</artifactId>
       <scope>optional</scope>
 </dependency>
 
 如果此依赖项是可选的，那么它将不会自动成为某人的传递依赖关系，它仅依赖于model.jar 。 
 
 现在客户想要使用Model类。 因此它对model.jar有依赖性。 
 
 <depdendency>
       <groupId>someGroup</groupId>
       <artifactId>model</artifactId>
 </dependency>
 
 如果客户端还想要查看注释ARuntimeAnnotation那么它还必须包含annotations.jar作为依赖项，因为它是可选的。 
 
 如果客户端不包含对annotations.jar的依赖，则以下调用将返回一个空数组： 
 
 Model.class.getAnnotations(); // will be empty if the annotations.jar is not available at runtime

You only have to use the annotations at compile time. If the annotation classes are not available at runtime they will simply not exist.
 
E.g. if the client code calls AnnotatedElement.getAnnotations() on a domain model class and the annotations it was compiled with are not available in the class path they will not be returned.
 
If you use maven you should declare the annotation dependencies with scope optional. Optional dependencies will not be included in the client. Thus they are only available if the client declares them.
 
For example:
 
If Proj-A has a optional dependency ( ?-> ) on Proj-B
 
 Proj-A ?-> Proj-B 
 
and a Proj-X references Proj-A as a compile dependency it will not get the optional dependency Proj-B. 
 
 Proj-X -> Proj-A 
 
because transitive dependency resolution ends on an optional dependency.
 
Expect that you have the following annotation in a jar file called annotations.jar
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ARuntimeAnnotation {

}
 
and you have the following model class contained in a model.jar
 
@ARuntimeAnnotation
public class Model {

}
 
and the model.jar has a dependency to the annotations.jar because it needs it to compile.
 
<depdendency>
       <groupId>someGroup</groupId>
       <artifactId>annotations</artifactId>
       <scope>optional</scope>
 </dependency>
 
If this dependency is optional it will not be automatically become a transitive dependency of someone how only has a dependency on the model.jar.
 
Now a client wants to use the Model class. Thus it has a dependency to model.jar.
 
 <depdendency>
       <groupId>someGroup</groupId>
       <artifactId>model</artifactId>
 </dependency>
 
If the client also wants to see the annotation ARuntimeAnnotation it must also include the annotations.jar as a dependency, because it is optional.
 
If the client does not include dependency on the annotations.jar the following call will return an empty array:
 
 Model.class.getAnnotations(); // will be empty if the annotations.jar is not available at runtime