码迷，mamicode.com
首页 > 编程语言 > 详细

java自定义注解

时间：2019-11-23 22:22:34      阅读：78      评论：0      收藏：0      [点我收藏+]

标签：inter   efault   文件中   bool   demo1   pre   策略   context   default   

课程目标

1、Java注解简介

2、Java元注解（重点）

3、自定义注解

4、Aop自定义注解的应用（重点）

 

Java注解简介

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工具提取成文档.

 

 

案例一（获取类与方法上的注解值）：

 

TranscationModel
package com.jt.p2;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:41
 */
public enum  TranscationModel {
    Read, Write, ReadWrite
}
MyAnnotation1
package com.jt.p2;

import java.lang.annotation.*;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:40
 *
 * MyAnnotation1注解可以用在类、接口、属性、方法上
 * 注解运行期也保留
 * 不可继承
 */
@Target({ElementType.TYPE, ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation1 {
    String name();
}
package com.jt.p2;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:43
 *
 * 获取类与方法上的注解值
 */
@MyAnnotation1(name = "abc")
public class Demo1 {

    @MyAnnotation1(name = "xyz")
    private Integer age;

    @MyAnnotation2(model = TranscationModel.Read)
    public void list() {
        System.out.println("list");
    }

    @MyAnnotation3(models = {TranscationModel.Read, TranscationModel.Write})
    public void edit() {
        System.out.println("edit");
    }
}
package com.jt.p2;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:49
 *
 * 获取类属性上的注解属性值
 */
public class Demo2 {
    @TestAnnotation(value = "这就是value对应的值_msg1", what = "这就是what对应的值_msg1")
    private static String msg1;

    @TestAnnotation("这就是value对应的值1")
    private static String msg2;

    @TestAnnotation(value = "这就是value对应的值2")
    private static String msg3;

    @TestAnnotation(what = "这就是what对应的值")
    private static String msg4;
}

 

package com.jt.p2;

import java.lang.annotation.*;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:40
 *
 *  MyAnnotation2注解可以用在方法上
 *  注解运行期也保留
 *  不可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation2 {
    TranscationModel model() default TranscationModel.ReadWrite;
}

 

 

package com.jt.p2;

import java.lang.annotation.*;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:42
 *
 * MyAnnotation3注解可以用在方法上
 * 注解运行期也保留
 * 可继承
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MyAnnotation3 {
    TranscationModel[] models() default TranscationModel.ReadWrite;
}
package com.jt.p2;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:48
 */
//@Retention(RetentionPolicy.SOURCE)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface TestAnnotation {
    String value() default "默认value值";

    String what() default "这里是默认的what属性对应的值";
}
package com.jt.p3;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 19:03
 *
 * 获取参数修饰注解对应的属性值
 */
public class Demo3 {

    public void hello1(@IsNotNull(true) String name) {
        System.out.println("hello:" + name);
    }

    public void hello2(@IsNotNull String name) {
        System.out.println("hello:" + name);
    }
}

 

 

package com.jt.p3;

import java.lang.annotation.*;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 19:02
 *
 * 非空注解：使用在方法的参数上，false表示此参数可以为空，true不能为空
 */
@Documented
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface IsNotNull {
    boolean value() default false;
}

 

 

package com.jt.springAop;

import org.springframework.stereotype.Component;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 19:10
 */
@Component
public class LogController {

    @MyLog(desc = "这是结合spring aop知识，讲解自定义注解应用的一个案例")
    public void testLogAspect(){
        System.out.println("这里随便来点啥");
    }
}

 

 

package com.jt.springAop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 19:08
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
    String desc();
}

 

 

package com.jt.springAop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 19:09
 */
@Component
@Aspect
public class MyLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(MyLogAspect.class);

    /**
     * 只要用到了com.jt.p2.annotation.springAop.MyLog这个注解的，就是目标类
     */
    @Pointcut("@annotation(com.jt.springAop.MyLog)")
    private void MyValid() {
    }

    @Before("MyValid()")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        logger.debug("[" + signature.getName() + " : start.....]");

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

 

 

package com.jt.p2;

import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author jt
 * @site www.jt.com
 * @company xxx公司
 * @create  2018-12-13 19:17
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:spring.xml"})
public class BaseTestCase {

}
package com.jt.p2;

import org.junit.Test;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:44
 */
public class Demo1Test {
    @Test
    public void list() throws Exception {
//        获取类上的注解
        MyAnnotation1 annotation1 = Demo1.class.getAnnotation(MyAnnotation1.class);
        System.out.println(annotation1.name());//abc

//        获取方法上的注解
        MyAnnotation2 myAnnotation2 = Demo1.class.getMethod("list").getAnnotation(MyAnnotation2.class);
        System.out.println(myAnnotation2.model());//Read



    }

    @Test
    public void edit() throws Exception {
        MyAnnotation3 myAnnotation3 = Demo1.class.getMethod("edit").getAnnotation(MyAnnotation3.class);
        for (TranscationModel model : myAnnotation3.models()) {
            System.out.println(model);//Read,Write
        }
    }
}

 

 

package com.jt.p2;

import org.junit.Test;

/**
 * @author jt
 * @site www.jt.com
 * @company
 * @create  2019-10-23 18:49
 */
public class Demo2Test {
    @Test
    public void test1() throws Exception {
        TestAnnotation msg1 = Demo2.class.getDeclaredField("msg1").getAnnotation(TestAnnotation.class);
        System.out.println(msg1.value());
        System.out.println(msg1.what());
    }

    @Test
    public void test2() throws Exception{
        TestAnnotation msg2 = Demo2.class.getDeclaredField("msg2").getAnnotation(TestAnnotation.class);
        System.out.println(msg2.value());
        System.out.println(msg2.what());
    }

    @Test
    public void test3() throws Exception{
        TestAnnotation msg3 = Demo2.class.getDeclaredField("msg3").getAnnotation(TestAnnotation.class);
        System.out.println(msg3.value());
        System.out.println(msg3.what());
    }

    @Test
    public void test4() throws Exception{
        TestAnnotation msg4 = Demo2.class.getDeclaredField("msg4").getAnnotation(TestAnnotation.class);
        System.out.println(msg4.value());
        System.out.println(msg4.what());
    }
}
package com.jt.p3;

import org.testng.annotations.Test;

import java.lang.reflect.Parameter;

import static org.testng.Assert.*;

/**
 * @author jt
 * @site www.jt.com
 * @company xxx公司
 * @create  2019-11-23 19:16
 */
public class Demo3Test {

    @Test
    public void hello1() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello1", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//true
            }
        }
    }

    @Test
    public void hello2() throws Exception {
        Demo3 demo3 = new Demo3();
        for (Parameter parameter : demo3.getClass().getMethod("hello2", String.class).getParameters()) {
            IsNotNull annotation = parameter.getAnnotation(IsNotNull.class);
            if(annotation != null){
                System.out.println(annotation.value());//false
            }
        }
    }
}
package com.jt.springAop;

import com.jt.p2.BaseTestCase;
import org.springframework.beans.factory.annotation.Autowired;
import org.testng.annotations.Test;

import static org.testng.Assert.*;

/**
 * @author jt
 * @site www.jt.com
 * @company xxx公司
 * @create  2019-11-23 19:39
 */
public class LogControllerTest extends BaseTestCase {

    @Autowired
    private  LogController logController;

    @Test
    public void testTestLogAspect() {
        logController.testLogAspect();
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

java自定义注解

标签：inter   efault   文件中   bool   demo1   pre   策略   context   default   

原文地址：https://www.cnblogs.com/ztbk/p/11919549.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！