public interface Annotation {boolean equals(Object obj);int hashCode();String toString();/***获取注解类型 */Class<? extends Annotation> annotationType();
}

public @interface TestAnnotation1 {
}
​
public interface TestAnnotation2 extends Annotation  {
}

// javap -c TestAnnotation1.class
Compiled from "TestAnnotation1.java"                                                                 
public interface com.hncboy.corejava.annotation.TestAnnotation1 extends java.lang.annotation.Annotation {}
​
// javap -c TestAnnotation2.class
Compiled from "TestAnnotation2.java"                                                                 
public interface com.hncboy.corejava.annotation.TestAnnotation2 extends java.lang.annotation.Annotation {}

public @interface TestAnnotation1 {
}
/** 错误的定义，注解不能继承注解 */
@interface TestAnnotation2 extends TestAnnotation1 {
}
/** 错误的定义，注解不能继承接口 */
@interface TestAnnotation3 extends Annotation {
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {}

@interface Reference {boolean contain() default false;
}
​
enum Week {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
}
​
public @interface TestAnnotation {
​/*** int 基本数据类型* @return*/int type() default -1;
​/*** boolean 基本数据类型* @return*/boolean status() default false;
​/*** String 类型* @return*/String name() default "";
​/*** Class 类型* @return*/Class<?> loadClass() default String.class;
​/*** 枚举类型* @return*/Week today() default Week.Sunday;
​/*** 注解类型* @return*/Reference reference() default @Reference(contain = true);
​/*** 枚举数组类型* @return*/Week[] value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
}

public enum ElementType {/*** 用于描述类、接口（包括注解类型）、枚举的定义*/TYPE,
​/*** 用于描述成员变量、对象、属性（包括枚举常量）*/FIELD,
​/*** 用户描述方法*/METHOD,
​/*** 用于描述参数*/PARAMETER,
​/*** 用于描述构造器*/CONSTRUCTOR,
​/*** 用于描述局部变量*/LOCAL_VARIABLE,
​/*** 用于描述注解的（元注解）*/ANNOTATION_TYPE,
​/*** 用于描述包*/PACKAGE,
​/** 表示该注解能写在类型变量的声明语句中* @since 1.8*/TYPE_PARAMETER,
​/*** 表示该注解能写在使用类型的任何语句中（声明语句、泛型和强制转换语句中的类型）* @since 1.8*/TYPE_USE
}

@Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface AnyWhere {
}
​
public interface Boy {
}
​
public class Test<@AnyWhere T> extends @AnyWhere Object implements @AnyWhere Boy {
​private @AnyWhere T test1(@AnyWhere T t) throws @AnyWhere Exception {return t;}private void test2() {Test<Integer> test = new @AnyWhere Test<>();@AnyWhere List<@AnyWhere Integer> list = new ArrayList<>();}
}

public enum RetentionPolicy {/*** 表示该注解只存在于源码阶段，*/SOURCE,
​/*** 表示该注解存在于源码阶段和编译后的字节码文件里*/CLASS,
​/*** 表示该注解存在于源码阶段、编译后的字节码文件和运行时期，且注解的内容将会被 JVM 解释执行* 该范围的注解可通过反射获取到*/RUNTIME
}

public interface AnnotatedElement {/*** default 方法是 Java8 新增的* 如果指定类型的注解存在该类型上，则返回 true，否则返回 false。此方法的主要目的是方便访问一些已知的注解** @param annotationClass 该泛型参数表示所有继承了Annotation 接口的接口，也就是注解* @return 返回该类型上是否有指定的注解*/default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {return getAnnotation(annotationClass) != null;}/*** 根据注解的 Class 查询注解*/<T extends Annotation> T getAnnotation(Class<T> annotationClass);/*** 返回该类型上的所有注解，包含继承的*/Annotation[] getAnnotations();/*** 返回该类型上的所有注解，不包含继承的*/Annotation[] getDeclaredAnnotations();
}

@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation1 {String status() default "hncboy";
}
​
@Retention(RetentionPolicy.CLASS)
public @interface TestAnnotation2 {String value() default "hncboy";
}
​
@TestAnnotation1(status = "hncboy2")
@TestAnnotation2("hncboy2")
public class TestAnnotation {
​public static void main(String[] args) throws ClassNotFoundException {Class<?> clazz = Class.forName("com.hncboy.corejava.annotation.TestAnnotation");// 获取该类的所有注解Annotation[] annotations = clazz.getAnnotations();for (Annotation annotation : annotations) {System.out.println(annotation.annotationType());System.out.println(annotation.toString());}}
}

interface com.hncboy.corejava.annotation.TestAnnotation1
@com.hncboy.corejava.annotation.TestAnnotation1()(status=hncboy2)

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {/*** 返回可以应用注解类型的各种范围的枚举数组* 名字为 value 时可以省略属性名* @return*/ElementType[] value();
}

@Target(ElementType.METHOD)
@Target(value = ElementType.METHOD)
@Target({ElementType.METHOD, ElementType.TYPE})
@Target(value = {ElementType.METHOD, ElementType.TYPE})

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {/*** 返回保留策略* @return*/RetentionPolicy value();
}

@Retention(RetentionPolicy.RUNTIME)
@Retention(value = RetentionPolicy.RUNTIME)

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

@Retention(value = RetentionPolicy.RUNTIME)
@Documented
public @interface TestAnnotation {}@TestAnnotation
public class Test {}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface TestAnnotation {
}@TestAnnotation
public class Father {
}public class Son extends Father {
}

public class Test {public static void main(String[] args) {System.out.println(Father.class.isAnnotationPresent(TestAnnotation.class));System.out.println(Son.class.isAnnotationPresent(TestAnnotation.class));}
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {/*** 指可重复注解的类型，包含注解类型* @return*/Class<? extends Annotation> value();
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Activities {Activity[] value();
}@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Activities.class)
public @interface Activity {String value();
}@Activity("打代码")
@Activity("吃饭")
@Activity("睡觉")
public class Hncboy {
}@Activities({@Activity("打代码"), @Activity("吃饭"), @Activity("睡觉")})
public class Hncboy {
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}

@Deprecated
public class TestDeprecated {@DeprecatedString s = "hncboy";@Deprecatedpublic void test() {}
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {/*** 带有注解的元素中的编译器将禁止的警告集。* 使用 unchecked 忽略无法识别的警告*/String[] value();
}

public class Test {@SuppressWarnings({"rawtypes", "unused"})private List test() {return new ArrayList();}
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MyBean {String value() default "";
}@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponent {String value() default "";
}@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyComponentScan {String value() default "";
}

@MyComponent("a")
public class A {public A() {System.out.println("调用 A 的无参构造器");}@MyBean("b")public static B createBInstance() {System.out.println("调用 A 的静态方法 createBInstance");return new B();}@MyBean("c")public C createCInstance() {System.out.println("调用 A 的实例方法 createCInstance");return new C();}
}class B {}
class C {}

/*** 定义 map 存放 bean*/
public class IOCContainer {private static HashMap<String, Object> container = new HashMap<>();public static void putBean(String id, Object object) {container.put(id, object);}public static Object getBean(String id) {return container.get(id);}
}

@MyComponentScan("com.hncboy.corejava.annotation.spring")
public class Test {public static void main(String[] args) throws Exception {Test test = new Test();// 获取 MyComponentScan 注解中的包名String scanPackage = test.getScanPackage();HashSet<String> classPathSet = new HashSet<>();// 扫描包下的所有类并将类的全限定名放进 classPathSet
        test.doScanPackage(classPathSet, scanPackage);// 遍历扫描包下的所有类for (String className : classPathSet) {// 通过类的全限定名获取 ClassClass<?> clazz = Class.forName(className);// 判断该类是否实现了 MyComponent 注解if (clazz.isAnnotationPresent(MyComponent.class)) {// 方式1：通过构造器实例化
                IOCContainer.putBean(className, clazz.newInstance());}Method[] methods = clazz.getDeclaredMethods();for (Method method : methods) {// 判断方法是否有 MyBean 注解if (method.isAnnotationPresent(MyBean.class)) {// 获取 bean 值String beanName = method.getAnnotation(MyBean.class).value();// 判断该方法是否是静态方法或实例方法if (Modifier.isStatic(method.getModifiers())) {// 方式2：通过静态工厂实例化IOCContainer.putBean(beanName, method.invoke(null));} else {// 方式3：通过实例工厂实例化// 首先获取该类的实例对象，再调用实例方法进行实例化
                        IOCContainer.putBean(beanName, method.invoke(IOCContainer.getBean(className)));}}}}}/*** 获取 MyComponentScan 注解中的包名** @return*/private String getScanPackage() {Class<?> clazz = this.getClass();if (!clazz.isAnnotationPresent(MyComponentScan.class)) {return "";}MyComponentScan scanPackage = clazz.getDeclaredAnnotation(MyComponentScan.class);return scanPackage.value();}/*** 扫描该包下的类** @param classPathSet* @param scanPackage*/private void doScanPackage(HashSet<String> classPathSet, String scanPackage) {// 通过正则表达式将包名中的 . 替代为 /，并获取到该路径的 class urlURL url = this.getClass().getResource("/" + scanPackage.replaceAll("\\.", "/"));// 获取该 url 下的所有 File（目录/文件）File classDir = new File(url.getFile());// 遍历所有 Filefor (File file : classDir.listFiles()) {// 判断该 file 如果是目录的话if (file.isDirectory()) {// 拼接该目录的名字并递归遍历该目录doScanPackage(classPathSet, scanPackage + "." + file.getName());} else {// 如果文件不是以 .class 结尾if (!file.getName().endsWith(".class")) {continue;}// 通过 包名+目录名+除去.class的类名 拼接该类的全限定名String clazzName = (scanPackage + "." + file.getName().replace(".class", ""));// 将该类的全限定名放入 classPathSet
                classPathSet.add(clazzName);}}}
}

调用 A 的无参构造器
调用 A 的静态方法 createBInstance
调用 A 的实例方法 createCInstance