功能绷Java注解 [英] Feature Toggling Java Annotations
问题描述
我怎样才能拥有拨动Java注解？
How can I feature toggle java annotations?
简单的功能切换： -
如果（启用切换）做X
Simple feature toggle:- if(toggle enabled) do x
Spring允许使用配置文件切换豆。
Spring allows the use of "profiles" to toggle beans.
我使用这些，他们是很好，但我想切换现场或类注解..我该怎么办呢？
I use these and they are fine but I'd like to toggle annotation on field or classes.. how can I do that?
使用的情况下，我有了JPA注释类。我希望能够通过配置，某些字段在特定环境时@Transient标注。
Use case, I have a class that has jpa annotations. I want to be able to mark via configuration that some fields are @transient when in certain environments.
推荐答案
其中一个可能的选择是使用的AspectJ根据其对声明注释并的能力春季的<一能力href=\"http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/aop.html#aop-aj-ltw\"相对=nofollow>加载时切面织。
One of the possible options is to use aspectj with its ability to declare annotations and spring's ability of load-time aspect weaving.
我想这说明不能有条件地声明，但你总是可以编译它们在一个单独的罐子，可以放入根据一定的环境，使加载时织就能够找到它的类路径。
I suppose that annotations cannot be declared conditionally, but you can always compile them in a separate jar that can be put into the classpath depending on the certain environment so that load-time weaver will be able to find it.
更新
虽然这里有很多有用的答案，我发现禁用/启用注解和AspectJ挺有意思的播放，因此样本如下。
While there are a lot of useful answers here, I found disabling/enabling annotations quite interesting playing with aspectj, so the sample is below.
注释AspectJ的支持删除，但目前此功能只适用于该领域的注解，所以非常有用的方法是完全不申报的注解，如果他们已经启用的最新版本 - 把罐子precompiled这将使注释到类路径正如我前面提到的方面。
The latest versions of aspectj support removing of annotations, but for now this feature is only available for the field annotations, so quite useful way is not to declare annotations at all and if they have to be enabled - to put the jar with precompiled aspects which will enable the annotations into the classpath as I mentioned earlier.
样品
第一罐
主类
package org.foo.bar;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("/applicationContext.xml");
MyClass myObj = context.getBean("myObj", MyClass.class);
System.out.println(myObj);
System.out.println(myObj.getValue1());
System.out.println(myObj.getValue2());
}
}
我们将在声明注解类
package org.foo.bar;
public class MyClass {
@MyAnn("annotated-field-1")
private String field1;
private String field2;
@MyAnn("annotated-method-1")
public String getValue1() {
String value = null;
try {
MyAnn ann = getClass().getDeclaredMethod("getValue1").getAnnotation(MyAnn.class);
if(ann != null) {
value = ann.value();
}
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
return value;
}
public String getValue2() {
String value = null;
try {
MyAnn ann = getClass().getDeclaredMethod("getValue2").getAnnotation(MyAnn.class);
if(ann != null) {
value = ann.value();
}
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
}
return value;
}
@Override
public String toString() {
String field1 = null;
try {
MyAnn ann = getClass().getDeclaredField("field1").getAnnotation(MyAnn.class);
if(ann != null) {
field1 = ann.value();
}
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
}
String field2 = null;
try {
MyAnn ann = getClass().getDeclaredField("field2").getAnnotation(MyAnn.class);
if(ann != null) {
field2 = ann.value();
}
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
}
StringBuilder sb = new StringBuilder();
sb.append("MyClass");
sb.append("{field1='").append(field1).append('\'');
sb.append(", field2='").append(field2).append('\'');
sb.append('}');
return sb.toString();
}
}
注释本身
package org.foo.bar;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface MyAnn {
String value();
}
应用程序上下文
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<context:load-time-weaver />
<bean id="myObj" class="org.foo.bar.MyClass" />
</beans>
第二罐
纵横
package org.foo.bar;
public aspect ToggleAnnotationAspect {
declare @field : private String org.foo.bar.MyClass.field1 : -@MyAnn;
declare @field : private String org.foo.bar.MyClass.field2 : @MyAnn("annotated-field-2");
declare @method : public String org.foo.bar.MyClass.getValue2() : @MyAnn("annotated-method-2");
}
META-INF / aop.xml文件
META-INF/aop.xml
<?xml version="1.0"?>
<aspectj>
<aspects>
<aspect name="org.foo.bar.ToggleAnnotationAspect"/>
</aspects>
</aspectj>
在classpath中运行没有第二个罐子应用
Running the application without the second jar in the classpath
java -javaagent:spring-instrument-3.1.3.RELEASE.jar \
-classpath app1.jar;<rest_of_cp> org.foo.bar.Main
将打印
MyClass{field1='annotated-field-1', field2='null'}
annotated-method-1
null
在classpath中运行的第二个罐子应用
Running the application with the second jar in the classpath
java -javaagent:spring-instrument-3.1.3.RELEASE.jar \
-classpath app1.jar;app1-aspects.jar;<rest_of_cp> org.foo.bar.Main
将打印
MyClass{field1='null', field2='annotated-field-2'}
annotated-method-1
annotated-method-2
因此，没有修改应用程序的源所做的。
So no modification to the application source were made at all.
这篇关于功能绷Java注解的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
