1. Java注解(Annotation)

Java注解是附加在代码中的一些元信息，用于一些工具在编译、

运行时进行解析和使用，起到说明、配置的功能。

注解相关类都包含在java.lang.annotation包中。

2. Java注解分类

2.1 JDK基本注解

2.2 JDK元注解

2.3 自定义注解

3. JDK基本注解

3.1 @Override

重写

3.2 @Deprecated

已过时

3.3 @SuppressWarnings(value = "unchecked")

压制编辑器警告

Java元注解

作用：元注解用于修饰其他的注解

@Retention：定义注解的保留策略

@Retention(RetentionPolicy.SOURCE)             //注解仅存在于源码中，在class字节码文件中不包含

@Retention(RetentionPolicy.CLASS)              //默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，

@Retention(RetentionPolicy.RUNTIME)            //注解会在class字节码文件中存在，在运行时可以通过反射获取到

@Target：指定被修饰的Annotation可以放置的位置(被修饰的目标)

@Target(ElementType.TYPE)                      //接口、类

@Target(ElementType.FIELD)                     //属性

@Target(ElementType.METHOD)                    //方法

@Target(ElementType.PARAMETER)                 //方法参数

@Target(ElementType.CONSTRUCTOR)               //构造函数

@Target(ElementType.LOCAL_VARIABLE)            //局部变量

@Target(ElementType.ANNOTATION_TYPE)           //注解

@Target(ElementType.PACKAGE)                   //包

注：可以指定多个位置，例如：

@Target({ElementType.METHOD, ElementType.TYPE})，也就是此注解可以在方法和类上面使用

@Inherited：指定被修饰的Annotation将具有继承性

@Documented：指定被修饰的该Annotation可以被javadoc工具提取成文档.

自定义注解

注解分类(根据Annotation是否包含成员变量,可以把Annotation分为两类):

标记Annotation:

没有成员变量的Annotation; 这种Annotation仅利用自身的存在与否来提供信息

元数据Annotation:

包含成员变量的Annotation; 它们可以接受(和提供)更多的元数据;

如何自定义注解？

使用@interface关键字,其定义过程与定义接口非常类似,需要注意的是:

Annotation的成员变量在Annotation定义中是以无参的方法形式来声明的,其方法名和返回值类型定义了该成员变量的名字和类型,

而且我们还可以使用default关键字为这个成员变量设定默认值；

注意：只有名字为“value”属性，赋值时可以省略属性名

案例一(获取类与方法上的注解值)

packagecom.ssm.yuan.p1;public enumTranscationModel {

Read, Write, ReadWrite

}

1 packagecom.ssm.yuan.p1;2

3 import java.lang.annotation.*;4

5 /**

6 *7 * MyAnnotation3注解可以用在方法上8 * 注解运行期也保留9 * 可继承10 */

11 @Target(ElementType.METHOD)12 @Retention(RetentionPolicy.RUNTIME)13 @Inherited14 @Documented15 public @interfaceMyAnnotation3 {16 TranscationModel[] models() defaultTranscationModel.ReadWrite;17 }

1 packagecom.ssm.yuan.p1;2

3 import java.lang.annotation.*;4

5 /**

6 *7 * MyAnnotation2注解可以用在方法上8 * 注解运行期也保留9 * 不可继承10 */

11 @Target(ElementType.METHOD)12 @Retention(RetentionPolicy.RUNTIME)13 @Documented14 public @interfaceMyAnnotation2 {15 TranscationModel model() defaultTranscationModel.ReadWrite;16 }

1 packagecom.ssm.yuan.p1;2

3 import java.lang.annotation.*;4

5 /**

6 *7 * MyAnnotation1注解可以用在类、接口、属性、方法上8 * 注解运行期也保留9 * 不可继承10 */

11 @Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})12 @Retention(RetentionPolicy.RUNTIME)13 @Documented14 public @interfaceMyAnnotation1 {15 String name();16 }

1 packagecom.ssm.yuan.p1;2

3 importorg.junit.Test;4

5 /**

6 *7 */

8 public classDemo1Test {9 @Test10 public void list() throwsException {11 //获取类上的注解

12 MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);13 System.out.println(annotation1.name());//abc14

15 //获取方法上的注解

16 MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);17 System.out.println(myAnnotation2.model());//Read

18

19

20

21 }22

23 @Test24 public void edit() throwsException {25 MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);26 for(TranscationModel model : myAnnotation3.models()) {27 System.out.println(model);//Read,Write

28 }29 }30 }

1 packagecom.ssm.yuan.p1;2

3 /**

4 *5 * 获取类与方法上的注解值6 */

7 @MyAnnotation1(name = "abc")8 public classDemo1 {9

10 @MyAnnotation1(name = "xyz")11 privateInteger age;12

13 @MyAnnotation2(model =TranscationModel.Read)14 public voidlist() {15 System.out.println("list");16 }17

18 @MyAnnotation3(models ={TranscationModel.Read, TranscationModel.Write})19 public voidedit() {20 System.out.println("edit");21 }22 }

案例一测试结果

案例二(获取类属性上的注解属性值)

1 packagecom.ssm.yuan.p2;2

3 importjava.lang.annotation.ElementType;4 importjava.lang.annotation.Retention;5 importjava.lang.annotation.RetentionPolicy;6 importjava.lang.annotation.Target;7

8 /**

9 */

10 //@Retention(RetentionPolicy.SOURCE)

11 @Retention(RetentionPolicy.RUNTIME)12 @Target(ElementType.FIELD)13 public @interfaceTestAnnotation {14 String value() default "默认value值";15

16 String what() default "这里是默认的what属性对应的值";17 }

1 packagecom.ssm.yuan.p2;2

3 /**

4 *5 * 获取类属性上的注解属性值6 */

7 public classDemo2 {8 @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")9 private staticString msg1;10

11 @TestAnnotation("这就是value对应的值1")12 private staticString msg2;13

14 @TestAnnotation(value = "这就是value对应的值2")15 private staticString msg3;16

17 @TestAnnotation(what = "这就是what对应的值")18 private staticString msg4;19 }

1 packagecom.ssm.yuan.p2;2

3 importorg.junit.Test;4

5 /**

6 */

7 public classDemo2Test {8 @Test9 public void test1() throwsException {10 TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);11 System.out.println(msg1.value());12 System.out.println(msg1.what());13 }14

15 @Test16 public void test2() throwsException{17 TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);18 System.out.println(msg2.value());19 System.out.println(msg2.what());20 }21

22 @Test23 public void test3() throwsException{24 TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);25 System.out.println(msg3.value());26 System.out.println(msg3.what());27 }28

29 @Test30 public void test4() throwsException{31 TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);32 System.out.println(msg4.value());33 System.out.println(msg4.what());34 }35 }

案例三(获取参数修饰注解对应的属性值)

1 packagecom.ssm.yuan.p3;2

3 import java.lang.annotation.*;4

5 /**

6 *7 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空8 */

9 @Documented10 @Target({ElementType.PARAMETER})11 @Retention(RetentionPolicy.RUNTIME)12 public @interfaceIsNotNull {13 boolean value() default false;14 }

1 packagecom.ssm.yuan.p3;2

3 /**

4 *5 * 获取参数修饰注解对应的属性值6 */

7 public classDemo3 {8

9 public void hello1(@IsNotNull(true) String name, @IsNotNull(false) Integer age) {10 System.out.println("hello:" +name);11 }12

13 public voidhello2(@IsNotNull String name) {14 System.out.println("hello:" +name);15 }16 }

1 packagecom.ssm.yuan.p3;2

3 importorg.junit.Test;4

5 importjava.lang.reflect.Parameter;6

7 /**

8 */

9 public classDemo3Test {10

11 @Test12 public void hello1() throwsException {13 Demo3 demo3 = newDemo3();14 for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class, Integer.class).getParameters()) {15 IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);16 if(annotation != null){17 System.out.println(annotation.value());//true

18 }19 }20 }21

22 @Test23 public void hello2() throwsException {24 Demo3 demo3 = newDemo3();25 for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {26 IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);27 if(annotation != null){28 System.out.println(annotation.value());//false

29 }30 }31 }32 }

Aop自定义注解的应用

1 packagecom.ssm.yuan.springaop;2

3 importjava.lang.annotation.ElementType;4 importjava.lang.annotation.Retention;5 importjava.lang.annotation.RetentionPolicy;6 importjava.lang.annotation.Target;7

8 /**

9 */

10 @Target(ElementType.METHOD)11 @Retention(RetentionPolicy.RUNTIME)12 public @interfaceMyLog {13 String desc();14 }

1 packagecom.ssm.yuan.component;2

3 importcom.ssm.yuan.springaop.MyLog;4 importorg.aspectj.lang.JoinPoint;5 importorg.aspectj.lang.annotation.Aspect;6 importorg.aspectj.lang.annotation.Before;7 importorg.aspectj.lang.annotation.Pointcut;8 importorg.aspectj.lang.reflect.MethodSignature;9 importorg.slf4j.Logger;10 importorg.slf4j.LoggerFactory;11 importorg.springframework.stereotype.Component;12

13 /**

14 */

15 @Component16 @Aspect17 public classMyLogAspect {18 private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);19

20 /**

21 * 只要用到了com.yuan.p2.annotation.springAop.MyLog这个注解的，就是目标类22 */

23 @Pointcut("@annotation(com.ssm.yuan.springaop.MyLog)")24 private voidMyValid() {25 }26

27 @Before("MyValid()")28 public voidbefore(JoinPoint joinPoint) {29 MethodSignature signature =(MethodSignature) joinPoint.getSignature();30 logger.debug("[" + signature.getName() + " : start.....]");31

32 MyLog myLog = signature.getMethod().getAnnotation(MyLog.class);33 logger.debug("【目标对象方法被调用时候产生的日志，记录到日志表中】："+myLog.desc());34 }35 }

Controller层

1 packagecom.ssm.yuan.controller;2

3 importcom.ssm.yuan.springaop.MyLog;4 importorg.springframework.stereotype.Component;5

6 /**

7 */

8 @Component9 public classLogController {10

11 @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")12 public voidtestLogAspect(){13 System.out.println("随便写点东西。。。。");14 }15 }

SpringBaseTest

packagecom.ssm.yuan;importcom.ssm.yuan.model.Surfaceregistration;importcom.ssm.jt.util.PageBean;importorg.junit.Before;importorg.junit.runner.RunWith;importorg.springframework.test.context.ContextConfiguration;importorg.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations={"classpath:spring.xml"})public classSpringBaseTest {

}

Controller层测试

1 packagecom.ssm.yuan.controller;2

3 importcom.ssm.yuan.SpringBaseTest;4 importorg.junit.Test;5 importorg.springframework.beans.factory.annotation.Autowired;6

7 /**

8 */

9 public class LogControllerTest extendsSpringBaseTest {10 @Autowired11 privateLogController logController;12

13 @Test14 public voidtestLogAspect(){15 logController.testLogAspect();16 }17 }

谢谢观看！！！