使用注解
在一般的Java开发中,最常接触到的可能就是@Override和@SupressWarnings这两个注解了。使用@Override的时候只需要一个简单的声明即可。这种称为标记注解(marker annotation ),它的出现就代表了某种配置语义。而其它的注解是可以有自己的配置参数的。配置参数以名值对的方式出现。使用 @SupressWarnings的时候需要类似@SupressWarnings({"uncheck", "unused"})这样的语法。在括号里面的是该注解可供配置的值。由于这个注解只有一个配置参数,该参数的名称默认为value,并且可以省略。而花括号则表示是数组类型。在JPA中的@Table注解使用类似@Table(name = "Customer", schema = "APP")这样的语法。从这里可以看到名值对的用法。在使用注解时候的配置参数的值必须是编译时刻的常量。
从某种角度来说,可以把注解看成是一个XML元素,该元素可以有不同的预定义的属性。而属性的值是可以在声明该元素的时候自行指定的。在代码中使用注解,就相当于把一部分元数据从XML文件移到了代码本身之中,在一个地方管理和维护。
开发注解
在一般的开发中,只需要通过阅读相关的API文档来了解每个注解的配置参数的含义,并在代码中正确使用即可。在有些情况下,可能会需要开发自己的注解。这在库的开发中比较常见。注解的定义有点类似接口。下面的代码给出了一个简单的描述代码分工安排的注解。通过该注解可以在源代码中记录每个类或接口的分工和进度情况。
@Retention(RetentionPolicyRUNTIME)@Target(ElementTypeTYPE)
public @interface Assignment {
String assignee();
int effort();
double finished() default 0;
}
@interface用来声明一个注解,其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称,返回值类型就是参数的类型。可以通过default来声明参数的默认值。在这里可以看到@Retention和@Target这样的元注解,用来声明注解本身的行为。@Retention用来声明注解的保留策略,有CLASS、RUNTIME和SOURCE这三种,分别表示注解保存在类文件、JVM运行时刻和源代码中。只有当声明为RUNTIME的时候,才能够在运行时刻通过反射API来获取到注解的信息。@Target用来声明注解可以被添加在哪些类型的元素上,如类型、方法和域等。
处理注解
在程序中添加的注解,可以在编译时刻或是运行时刻来进行处理。在编译时刻处理的时候,是分成多趟来进行的。如果在某趟处理中产生了新的Java源文件,那么就需要另外一趟处理来处理新生成的源文件。如此往复,直到没有新文件被生成为止。在完成处理之后,再对Java代码进行编译。JDK 5中提供了apt工具用来对注解进行处理。apt是一个命令行工具,与之配套的还有一套用来描述程序语义结构的Mirror API。Mirror API(comsunmirror)描述的是程序在编译时刻的静态结构。通过Mirror API可以获取到被注解的Java类型元素的信息,从而提供相应的处理逻辑。具体的处理工作交给apt工具来完成。编写注解处理器的核心是AnnotationProcessorFactory和AnnotationProcessor两个接口。后者表示的是注解处理器,而前者则是为某些注解类型创建注解处理器的工厂。
以上面的注解Assignment为例,当每个开发人员都在源代码中更新进度的话,就可以通过一个注解处理器来生成一个项目整体进度的报告。 首先是注解处理器工厂的实现。
public class AssignmentApf implements AnnotationProcessorFactory {public AnnotationProcessor getProcessorFor(Set<AnnotationTypeDeclaration> atds, AnnotationProcessorEnvironment env) {
if (atdsisEmpty()) {
return AnnotationProcessorsNO_OP;
}
return new AssignmentAp(env); //返回注解处理器
}
public Collection<String> supportedAnnotationTypes() {
return CollectionsunmodifiableList(ArraysasList("annotationAssignment"));
}
public Collection<String> supportedOptions() {
return CollectionsemptySet();
}
}
AnnotationProcessorFactory接口有三个方法:getProcessorFor是根据注解的类型来返回特定的注解处理器;supportedAnnotationTypes是返回该工厂生成的注解处理器所能支持的注解类型;supportedOptions用来表示所支持的附加选项。在运行apt命令行工具的时候,可以通过-A来传递额外的参数给注解处理器,如-Averbose=true。当工厂通过 supportedOptions方法声明了所能识别的附加选项之后,注解处理器就可以在运行时刻通过AnnotationProcessorEnvironment的getOptions方法获取到选项的实际值。注解处理器本身的基本实现如下所示。
public class AssignmentAp implements AnnotationProcessor {private AnnotationProcessorEnvironment env;
private AnnotationTypeDeclaration assignmentDeclaration;
public AssignmentAp(AnnotationProcessorEnvironment env) {
thisenv = env;
assignmentDeclaration = (AnnotationTypeDeclaration) envgetTypeDeclaration("annotationAssignment");
}
public void process() {
Collection<Declaration> declarations = envgetDeclarationsAnnotatedWith(assignmentDeclaration);
for (Declaration declaration : declarations) {
processAssignmentAnnotations(declaration);
}
}
private void processAssignmentAnnotations(Declaration declaration) {
Collection<AnnotationMirror> annotations = declarationgetAnnotationMirrors();
for (AnnotationMirror mirror : annotations) {
if (mirrorgetAnnotationType()getDeclaration()equals(assignmentDeclaration)) {
Map<AnnotationTypeElementDeclaration, AnnotationValue> values = mirrorgetElementValues();
String assignee = (String) getAnnotationValue(values, "assignee"); //获取注解的值
}
}
}
}
注解处理器的处理逻辑都在process方法中完成。通过一个声明(Declaration)的getAnnotationMirrors方法就可以获取到该声明上所添加的注解的实际值。得到这些值之后,处理起来就不难了。
在创建好注解处理器之后,就可以通过apt命令行工具来对源代码中的注解进行处理。 命令的运行格式是apt -classpath bin -factory annotationaptAssignmentApf src/annotation/work/java,即通过-factory来指定注解处理器工厂类的名称。实际上,apt工具在完成处理之后,会自动调用javac来编译处理完成后的源代码。
JDK 5中的apt工具的不足之处在于它是Oracle提供的私有实现。在JDK 6中,通过JSR 269把自定义注解处理器这一功能进行了规范化,有了新的javaxannotationprocessing这个新的API。对Mirror API也进行了更新,形成了新的javaxlangmodel包。注解处理器的使用也进行了简化,不需要再单独运行apt这样的命令行工具,Java编译器本身就可以完成对注解的处理。对于同样的功能,如果用JSR 269的做法,只需要一个类就可以了。
@SupportedSourceVersion(SourceVersionRELEASE_6)@SupportedAnnotationTypes("annotationAssignment")
public class AssignmentProcess extends AbstractProcessor {
private TypeElement assignmentElement;
public synchronized void init(ProcessingEnvironment processingEnv) {
superinit(processingEnv);
Elements elementUtils = processingEnvgetElementUtils();
assignmentElement = elementUtilsgetTypeElement("annotationAssignment");
}
public boolean process(Set< extends TypeElement> annotations, RoundEnvironment roundEnv) {
Set< extends Element> elements = roundEnvgetElementsAnnotatedWith(assignmentElement);
for (Element element : elements) {
processAssignment(element);
}
}
private void processAssignment(Element element) {
List< extends AnnotationMirror> annotations = elementgetAnnotationMirrors();
for (AnnotationMirror mirror : annotations) {
if (mirrorgetAnnotationType()asElement()equals(assignmentElement)) {
Map< extends ExecutableElement, extends AnnotationValue> values = mirrorgetElementValues();
String assignee = (String) getAnnotationValue(values, "assignee"); //获取注解的值
}
}
}
}
仔细比较上面两段代码,可以发现它们的基本结构是类似的。不同之处在于JDK 6中通过元注解@SupportedAnnotationTypes来声明所支持的注解类型。另外描述程序静态结构的javaxlangmodel包使用了不同的类型名称。使用的时候也更加简单,只需要通过javac -processor annotationpapAssignmentProcess Demo1java这样的方式即可。
上面介绍的这两种做法都是在编译时刻进行处理的。而有些时候则需要在运行时刻来完成对注解的处理。这个时候就需要用到Java的反射API。反射API提供了在运行时刻读取注解信息的支持。不过前提是注解的保留策略声明的是运行时。Java反射API的AnnotatedElement接口提供了获取类、方法和域上的注解的实用方法。比如获取到一个Class类对象之后,通过getAnnotation方法就可以获取到该类上添加的指定注解类型的注解。
实例分析
下面通过一个具体的实例来分析说明在实践中如何来使用和处理注解。假定有一个公司的雇员信息系统,从访问控制的角度出发,对雇员的工资的更新只能由具有特定角色的用户才能完成。考虑到访问控制需求的普遍性,可以定义一个注解来让开发人员方便的在代码中声明访问控制权限。
@Retention(RetentionPolicyRUNTIME)@Target(ElementTypeMETHOD)
public @interface RequiredRoles {
String[] value();
}
下一步则是如何对注解进行处理,这里使用的Java的反射API并结合动态代理。下面是动态代理中的InvocationHandler接口的实现。
public class AccessInvocationHandler<T> implements InvocationHandler {final T accessObj;
public AccessInvocationHandler(T accessObj) {
thisaccessObj = accessObj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
RequiredRoles annotation = methodgetAnnotation(RequiredRolesclass); //通过反射API获取注解
if (annotation != null) {
String[] roles = annotationvalue();
String role = AccessControlgetCurrentRole();
if (!ArraysasList(roles)contains(role)) {
throw new AccessControlException("The user is not allowed to invoke this method");
}
}
return methodinvoke(accessObj, args);
}
}
在具体使用的时候,首先要通过ProxynewProxyInstance方法创建一个EmployeeGateway的接口的代理类,使用该代理类来完成实际的 *** 作。
import javalangannotationRetention;
import javalangannotationRetentionPolicy;
import javalangreflectInvocationTargetException;
import javalangreflectMethod;
@Retention(RetentionPolicyRUNTIME)
@interface GetView {
String Method();
String Value();
}
public class Temp {
@GetView(Method = "aa", Value = "bb")
public void test() {
Systemoutprintln("In test method");
}
public static void main(String[] args) throws ClassNotFoundException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException {
Temp temp = new Temp();
Method method = tempgetClass()getMethod("test");
Systemoutprintln(methodisAnnotationPresent(GetViewclass));
methodinvoke(temp);
GetView view = methodgetAnnotation(GetViewclass);
Systemoutprintln(viewMethod());
Systemoutprintln(viewValue());
}
}
您好,估计您的意思是想类似Eclipse的做法解释这个Annotation哪些有定义默认值,哪些没有。
这个可以Class clz = Validateclass
Method[] ms = clzgetDeclaredMethods();
然后判断ms[i]getDefaultValue()返回如果不是null就表示有定义默认值了。
//每个注解就是一个类
@注解接口类(接口属性=值)
//创建一个自定义注解
@Retention(RetentionPolicyRUNTIME) //运行时获得
@Target(ElementTypeMETHOD) //针对方法的注解
public @interface 自注标{
int 属性1();
}
//注解加在自己的普通类上
class A{
@自注标(属性1=123)
public void hello(){
}
}
//在自己框架 *** 作下游开发者的代码时,通过反射得到该注解的值123
自注标 a=AgetClass()getMethod("hello")getAnnotation(自注标class);
int i=a属性1();//就能获得用户注解值。进行相应的动作
一、组件注解
1、 @Component(“xxx”)
指定某个类是容器的bean, @Component(value="xx") 相当于 ,其中 value 可以不写。
用于标注类为spring容器bean的注解有四个, 主要用于区别不同的组件类,提高代码的可读性:
a、 @Component, 用于标注一个普通的bean
b、 @Controller 用于标注一个控制器类(控制层 controller)
c、 @Service 用于标注业务逻辑类(业务逻辑层 service)
d、 @Repository 用于标注DAO数据访问类 (数据访问层 dao)
对于上面四种注解的解析可能是相同的,尽量使用不同的注解提高代码可读性。
注解用于修饰类,当不写value属性值时,默认值为类名首字母小写。
2、 @Scope(“prototype”)
该注解和 @Component 这一类注解联合使用,用于标记该类的作用域,默认 singleton 。
也可以和 @Bean 一起使用,此时 @Scope 修饰一个方法。关于@Bean稍后有说明
3、 @Lazy(true)
指定bean是否延时初始化,相当于 ,默认false。@Lazy可以和@Component这一类注解联合使用修饰类,也可以和@Bean一起使用修饰方法
注 :此处初始化不是指不执行 init-method ,而是不创建bean实例和依赖注入。只有当该bean(被@Lazy修饰的类或方法)被其他bean引用(可以是自动注入的方式)或者执行getBean方法获取,才会真正的创建该bean实例,其实这也是BeanFactory的执行方式。
4、 @DepondsOn({“aa”,“bb”})
该注解也是配合 @Component 这类注解使用,用于强制初始化其他bean
上面的代码指定,初始化bean “userAction"之前需要先初始化“aa”和“bb”两个bean,但是使用了@Lazy(true)所以spring容器初始化时不会初始化"userAction” bean。
5、 @PostConstructor和@PreDestroy
@PostConstructor 和 @PreDestroy 这两个注解是j2ee规范下的注解。这两个注解用于修饰方法,spring用这两个注解管理容器中spring生命周期行为。
a、 @PostConstructor 从名字可以看出构造器之后调用,相当于 。就是在依赖注入之后执行
b、 @PreDestroy 容器销毁之前bean调用的方法,相当于
6、 @Resource(name=“xx”)
@Resource 可以修饰成员变量也可以修饰set方法。当修饰成员变量时可以不写set方法,此时spring会直接使用j2ee规范的Field注入。
@Resource有两个比较重要的属性,name和type
a、 如果指定了name和type,则从Spring容器中找到唯一匹配的bean进行装配,找不到则抛出异常;
b、 如果指定了name,则从spring容器查找名称(id)匹配的bean进行装配,找不到则抛出异常;
c、 如果指定了type,则从spring容器中找到类型匹配的唯一bean进行装配,找不到或者找到多个,都会抛出异常;
d、 如果既没有指定name,又没有指定type,则自动按照byName方式进行装配
如果没有写name属性值时
a、 修饰成员变量,此时name为成员变量名称
b、 修饰set方法,此时name 为set方法的去掉set后首字母小写得到的字符串
7、 @Autowired(required=false)
@Autowired可以修饰构造器,成员变量,set方法,普通方法。@Autowired默认使用byType方式自动装配。required标记该类型的bean是否是必须的,默认为必须存在(true)。
可以配合 @Qualifier(value="xx") ,实现按beanName注入:
a、 required=true(默认),为true时,从spring容器查找和指定类型匹配的bean,匹配不到或匹配多个则抛出异常
b、 使用 @Qualifier("xx") ,则会从spring容器匹配类型和 id 一致的bean,匹配不到则抛出异常
@Autowired会根据修饰的成员选取不同的类型:
a、 修饰成员变量。该类型为成员变量类型
b、 修饰方法,构造器。注入类型为参数的数据类型,当然可以有多个参数
8、demo
业务逻辑层:
数据访问层:
测试类:
输出结果:
可以看到虽然UserDao 使用@Lazy,但是还是在spring容器初始化的时候还是创建了UserDao实例。原因很简单,因为在UserService中需要注入UserDao,所以在此时创建的UserDao实例也属于延时初始化。
在上面我们还使用了两个接口InitializingBean 和DisposableBean,这两个接口用于管理 singleton 作用域的bean的生命周期,类似init-method和destroy-method。不同之处就是调用的循序不一致:
a、 初始化调用顺序 :@PostConstructor > InitializingBean > init-method 用于指定bean依赖注入后的行为
b、 销毁调用顺序 @PreDestroy > DisposableBean > destroy-method 用于定制bean销毁之前的行为
该注解是AspectJ中的注解,并不是spring提供的,所以还需要导入aspectjweaverjar,aspectjrtjar,除此之外还需要依赖aopalliancejar
依赖包:
UserDaojava
配置文件 applicationContextxml:
测试类:
1、 @Aspect
修饰Java类,指定该类为切面类。当spring容器检测到某个bean被@Aspect修饰时,spring容器不会对该bean做增强处理(bean后处理器增强,代理增强)
2、 @Before
修饰方法,before增强处理。用于对目标方法(切入点表达式表示方法)执行前做增强处理。可以用于权限检查,登陆检查。
常用属性:
value: 指定切入点表达式 或者引用一个切入点
对comexampleaop 包下所有的类的所有方法做 before增强处理:
结果:
如果同一条切入点表达式被使用多次,可以使用更友好的方式。定义一个切入点:
增强方法可以接受一个JoinPoint 类型的参数,用于获取被执行目标方法的一下属性。
结果:
3、 @AfterReturning
修饰方法,afterreturning增强处理。目标方法正常结束后做增强处理。
常用属性:
a、 pointcut/value:指定切入点表达式
b、 returning:指定一个参数名,用于接受目标方法正常结束时返回的值。参数名称需要在增强方法中定义同名的参数。
注意:
a、 如果使用了returning 。那么增强方法中的数据类型必须是返回结果的类型或者父类型,否则不会调用该增强处理。
b、 使用了returning 还可以用来 修改返回结果 。
以上面的例子来说,目标方法返回结果类型应该满足下面的条件
修改返回值:
结果:
可以看到 AfterReturning 修改了返回结果。
4、 @AfterThrowing
修饰方法,afterthrowing增强处理。当目标程序方法抛出 异常或者异常无法捕获时,做增强处理。
常用属性:
a、 pointcut/value :指定切入点表达式
b、 throwing:指定一个形参,在增强方法中定义同名形参,用于访问目标方法抛出的异常
参数类型必须是 Throwable 的子类,同样也会有上面@AfterReturning 参数类型匹配的问题。
5、 @After
修饰方法 ,after增强处理。无论方法是否正常结束,都会调用该增强处理(@After= @AfterReturning+@AfterThrowing)。但是该增强方式无法获取目标方法的返回结果,也获取目标方法抛出的异常。所以一般用于进行释放资源,功能类似于 finally。
常用属性:
a、 value :指定切入点表达式
结果:
从上面的结果来看 After 增加处理 ,因为不能接受返回结果作为参数,所以不能修改返回结果。
6、 @Around
修饰方法, around增强处理。该处理可以目标方法执行之前和执行之后织入增强处理(@Before+@AfterReturning)。
Around增强处理通常需要在线程安全的环境下使用,如果@Before和@AfterReturning可以处理就没必要使用@Around。
常用属性:
a、 value :指定切入点表达式
当定义一个Aound增前处理时,增强方法第一形参需要时ProceedingJoinPoint类型。ProceedingJoinPoint有一个Object proceed()方法,用于执行目标方法。当然也可以为目标方法传递数组参数,来修改目前方法的传入参数。
around小结:
a、 Around增强处理通常需要 在线程安全 的环境下使用
b、 调用 proceed()可以获取返回结果,所以可以修改目标方法的返回值
c、 proceed(Object[] var1) 可以修改入参,修改目标方法的入参
d、 可以进行目标方法执行之前和执行之后织入增强处理
around 和 afterReturning 都可以修改返回结果。不过两者的原理不同:
a、 around:可以任意修改,或者返回不相关的值。这个返回值完全可以自主控制
b、 afterReturning,通过方法参数 ,使用对象引用的方式来修改对象。修改对象引用地址那么修改时无效的
除此之外从输出结果来看,增强处理是有序的:
around 和 afterReturning小结:
a、 只有 around 和 afterReturning 可以获取并修改返回结果。需要注意两种方式修改的区别。
b、 around 需要线程安全
c、 虽然增强处理都需要 切入点表达式,并不是都支持 pointcut 属性,所以最好都是用value 属性指定。当注解只需要value属性时,value可以省略
7、 @Pointcut
修饰方法,定义一个切入点表达式用于被其他增强调用。使用该方式定义切入点方便管理,易复用。
切入点方法定义和测试方法定义类似,具有以下特点:
a、 无返回值 (void)
b、 无参数
c、 方法体为空
d、 方法名就是切入点名称
e、 方法名不能为 execution
切入点表达式
切入点表达式可以通过 && 、 || 、 ! 连接
1)、execution 表达式:
2)、within 表达式:
a、匹配指定类下的所有方法。
b、匹配执行包及其子包下所有类的所有方法。
所以within可以看做execution的简写,不需要指定返回类型、方法名、参数( 最小作用单位是类 )
3)、 @annotation:匹配使用指定注解修饰的目标方法;
匹配使用@CustomMethodAnnotation注解的目标方法。
4)、 @within: 用于匹配使用指定注解修饰的类下的所有方法
within 作用范围是类,@within的作用范围与其一致。不同的是@within 指定的不是类而是注解
匹配使用@ResponseBody 注解的类 下的所有方法。
AOP小结:
1)、 Around增强处理通常需要 在线程安全 的环境下使用
2)、 使用 around 和 afterReturning 可以获取并修改返回结果
3)、 增强处理指定 切入点表达式时,最好使用value 属性
4)、 切入点 名称(方法名)不能为 execution
5)、 AfterReturning 指定了 returning 属性接受目标方法返回结果,注意 参数类型需要和返回结果类型一致(满足 resutType instanceof argsType )
增强方式的顺序:
1、 @Bean(name=“xxx”)
修饰方法,该方法的返回值为spring容器中管理的bean。当然该注解和上面的@Component效果一样,主要用于做区分。
@Bean 通常使用在 @Configuration 修饰的配置类中,该注解功能相当于 元素
常用的属性:
a、 name:bean id 。name可以省略,省略时bean名称为方法名。也可以指定多个名称(逗号隔开)。
b、 autowire: 是否自动注入,默认AutowireNO
c、 initMethod:bean的初始化方法。在依赖注入之后执行
d、 destroyMethod: spring容器关闭时bean调用的方法
当然 @Bean 还可以配合 @Scope 指定bean的作用域
2、 @ConfigurationProperties
用于从属性文件中获取值 applicationproperties 或者 applicationyml 。当然了 如果在配置文件中引入其他配置文件,也可以获取到属性值。
包含的属性:
a、 value | prefix 两者互为别名。指定前缀,默认为""
b、 ignoreUnknownFields:默认为true。是否忽略未知字段,当实体中的字段在配置文件中不存在时,是忽略还是抛出异常
c、 ignoreInvalidFields: 默认false。 是否忽略不合法的字段,此处的不合法是指类型不合适,配置文件中存在改配置但是无法转化为指定的字段类型。
Mybatis属性配置
applicationproperties:
ConfigurationProperties 可以配置前缀,然后会根据实体的变量名拼接前缀,去配置文件中查询配置。
3、 @Configuration
修饰一个Java类,被修饰的类相当于一个xml配置文件。功能类似于 。在springboot中大量使用了该注解,该注解提供了一种使用Java类方式配置bean。
可以发现 @Configuration使用了@Component 注解修饰。
实例 :
配置Mybatis会话工厂
4、 @Import
功能和 类似,修饰Java类,用于向当前类导入其他配置类。 可以导入多个配置文件,通常用于导入不在包扫描范围内的配置文件。可以被扫描的配置类可以直接访问,没有必要使用@Import 导入。
比如 SpringBoot的启动类指定的包扫描路径为 comexample
数据库的配置文件在 com包下。
在MyBatisConfig 中引入 DataSourceConfig, 就会解析DataSourceConfig。将解析出的Bean交给容器管理
5、 @ImportResource
修饰Java类,用于向类引入xml配置文件。
用于导入包含bean定义的配置文件,功能和 类似。默认情况下可以处理后缀为 groovy 和xml 的配置文件
6、 @Value("${expression}")
修饰成员变量或者 方法、构造器的参数,用于属性值注入(在配置文件中配置的值)。
注意: @Value不能对 static 属性注入。
如果的确需要注入到静态变量,可以通过以下方式间接进行注入:
1)、设置一个私有静态 实例
2)、通过构造函数或者 @PostConstruct 注解为 静态实例 赋值,指向本身(this)
3)、对成员属性注入内容
4)、提供静态方法,使用静态实例获取成员属性
7、@PropertySource(value=“classpath:jdbcproperties”)
该注解用来加载属性文件。
常用属性:
a、 ignoreResourceNotFound: 当资源文件找不到的时候是否会忽略该配置,而不是抛出错误。一般用于可选项
b、 encoding : 资源文件使用什么编码方式
c、 value : 指定属性文件位置。可以配置多个属性文件,不可以使用通配符。
在 PropertySource 中可以指定多个路径,并且会将属性文件中的值加载到 Environment 中。
@ConfigurationProperties 和 @PropertySource
它们的使用有一些差异:
1)、 @PropertySource 使用该注解加载的是 相对独立的属性文件,可以同时加载多个文件 (xxxproperties),而且 不支持自动注入 , 不支持前缀注入
2)、 @ConfigurationProperties 用于加载配置文件(applicationproperties | applicationyml)。该注解功能更强大:
a、 支持前缀注入 ( prefix )
b、 相同属性名的自动注入
c、 $("") 支持EL表达式注入
应用实例:
在以往的开发中通常会将数据库连接信息存放在单独的属性文件中(jdbcproperties)。而在spring boot 中我们会将数据库的信息存放在配置文件中,这会极大便利开发工作。
jdbcproperties:
可以通过 @Value 注解将配置文件的值注入到实体类中
也可以注入Environment ,通过Environment 获取值
1、 @ResponseBody
控制器方法返回值会使用 >
以上就是关于java注解的类型可以是哪些全部的内容,包括:java注解的类型可以是哪些、JAVA-Spring注解实现AOP权限拦截,如何取得方法上自定义Annotation的值呢、java Anotation怎样取得每一个注解成员的默认值等相关内容解答,如果想了解更多相关内容,可以关注我们,你们的支持是我们更新的动力!
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)