import java.util.List;

public class MyUtils {
    @SuppressWarnings("unchecked")
    public static <T> List<T> cast(Object value) {
        return (List<T>) value;
    }

    @Override
    public String toString() {
        return super.toString();
    }

    @SafeVarargs
    static void process(List<String>... stringLists) {
        for (List<String> list : stringLists) {
            System.out.println(list);
        }
    }

    @FunctionalInterface
    interface Foo {
        void bar();
    }

    @Deprecated
    static void oldMethod() {
        // some code
    }
    // some code
}

[可见修饰符] @interface 注解名称{
    注解属性列表
}

@Target(ElementType.METHOD) // 该注解只能用于方法上
@Retention(RetentionPolicy.RUNTIME) // 该注解在运行时有效
public @interface Author {
    String name();  // 作者姓名
    String date();  // 作品发布日期
}

//自定义注解
public @interface MyAnnotation{
   // 注解元素1 
   String author();
   
   // 注解元素2 
   int version() default 1;
   
   // 注解元素3 
   String[] tags() default {};
   
   // 注解元素4 
   Class<?> testClass();

   // 注解元素5 
   String color() default "blue";

   // 注解元素6
   Type type() default Type.CLASS;
 
   // 注解元素7
   Override overrides();
}

//枚举类型
public enum Type {
    CLASS,
    INTERFACE,
    ENUM,
    ANNOTATION_TYPE;
}

//注解类型
public @interface Override{
   
}

public class Person {
    private String name;
    private int age;

    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

package com.zhz.designpatterns.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionTest {
    public static void main(String[] args) throws Exception {
        // 获取Person类的Class对象
        Class<?> clazz = Class.forName("com.zhz.designpatterns.test.Person");

        // 获取Person类的构造函数
        Constructor<?> constructor = clazz.getConstructor(String.class, int.class);

        // 创建Person对象
        Object person = constructor.newInstance("Tom", 20);

        // 获取Person对象的name字段
        Field field = clazz.getDeclaredField("name");
        field.setAccessible(true);
        String name = (String) field.get(person);
        System.out.println("Name: " + name);

        // 调用Person对象的方法
        Method method = clazz.getDeclaredMethod("printInfo");
        method.invoke(person);
    }
}

/**
 * 自定义注解，注解类成员变量 value，类型为 String
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

/**
 * 用自定义注解标记方法
 */
public class MyService {

    @MyAnnotation("这是我的服务实现方法")
    public void doService() {
        // ...
    }
}

/**
 * 通过反射机制获取MyService类的所有方法，并根据注解标记生成文档
 */
public class AnnotationDemo {
    public static void main(String[] args) throws Exception {
        Class<MyService> myServiceClass = MyService.class;
        Method[] methods = myServiceClass.getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(MyAnnotation.class)) {
                MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
                System.out.println(annotation.value());
            }
        }
    }
}

package com.zhz.designpatterns.test;
import java.lang.annotation.*;

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

package com.zhz.designpatterns.test;
import java.lang.annotation.*;

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

package com.zhz.designpatterns.test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

public class SimpleDaoGenerator {
    public static void generateDao(Class<?> clazz) {
        // 判断是否有 @SimplePojo 注解
        if(!clazz.isAnnotationPresent(SimplePojo.class)){
            return;
        }
        SimplePojo annotation = clazz.getAnnotation(SimplePojo.class);

        // 生成DAO接口
        String daoInterfaceName = clazz.getSimpleName() + "Dao";
        System.out.println("public interface " + daoInterfaceName + " {");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            String fieldName = field.getName();
            Class<?> fieldType = field.getType();
            System.out.println("\tpublic void set" + capitalize(fieldName) +
                        "(" + fieldType.getSimpleName() + " " + fieldName + ");");
            System.out.println("\tpublic " + fieldType.getSimpleName() + " get" +
                        capitalize(fieldName) + "();");
        }
        System.out.println("}");

        // 生成DAO实现类
        String daoImplName = clazz.getSimpleName() + "DaoImpl";
        System.out.println("public class " + daoImplName +
                    " implements " + daoInterfaceName + " {");
        for (Field field : fields) {
            String fieldName = field.getName();
            Class<?> fieldType = field.getType();
            String fieldSimpleName = fieldType.getSimpleName();
            String methodName = capitalize(fieldName);
            System.out.println("\tprivate " + fieldSimpleName + " " + fieldName + ";");
            System.out.println("\tpublic void set" + methodName + "(" + fieldSimpleName +
                        " " + fieldName + ") {");
            System.out.println("\t\t" + "this." + fieldName + " = " + fieldName + ";");
            System.out.println("\t}");
            System.out.println("\tpublic " + fieldSimpleName + " get" + methodName + "() {");
            System.out.println("\t\t" + "return " + fieldName + ";");
            System.out.println("\t}");
        }
        System.out.println("}");
    }

    // 首字母大写
    private static String capitalize(String s) {
        if(s == null || s.length() == 0){
            return s;
        }
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }
}

package com.zhz.designpatterns.test;
public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        //person为包路径
        SimpleDaoGenerator.generateDao(Class.forName("com.zhz.designpatterns.test.Person"));
    }
}

/**
 * 注解，标记注册用户时密码不能为空
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = PasswordValidator.class)
public @interface Password {
    String message() default "密码不能为空";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

/**
 * 验证器，判断用户密码是否为空
 */
public class PasswordValidator implements ConstraintValidator<Password, String> {
    public void initialize(Password constraint) {
    }

    public boolean isValid(String password, ConstraintValidatorContext context) {
        if (password == null || password.trim().length() == 0) {
            return false;
        }
        return true;
    }
}

/**
 * Java Bean，标记用户注册信息
 */
public class User {
    @Password
    private String password;
}

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

    String[] value();
}

module module1 {
    requires module2;

    // 其他配置
}

@DependsOn("module1")
module module2 {
    // 其他配置
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface MyAnnotation {
    int value();
}

package com.example.helloworld;

public final class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, JavaPoet!");
  }
}

MethodSpec main = MethodSpec.methodBuilder("main")
    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
    .returns(void.class)
    .addParameter(String[].class, "args")
    .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
    .build();

TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
    .addMethod(main)
    .build();

JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
    .build();

javaFile.writeTo(System.out);

public void writeTo(Appendable out) throws IOException {
    // First pass: emit the entire class, just to collect the types we'll need to import.
    CodeWriter importsCollector = new CodeWriter(NULL_APPENDABLE, indent, staticImports);
    emit(importsCollector);
    Map<String, ClassName> suggestedImports = importsCollector.suggestedImports();

    // Second pass: write the code, taking advantage of the imports.
    CodeWriter codeWriter = new CodeWriter(out, indent, suggestedImports, staticImports);
    emit(codeWriter);
  }

void emit(CodeWriter codeWriter, String enclosingName, Set<Modifier> implicitModifiers)
      throws IOException {
    codeWriter.emitJavadoc(javadoc);
    codeWriter.emitAnnotations(annotations, false);
    codeWriter.emitModifiers(modifiers, implicitModifiers);

    if (!typeVariables.isEmpty()) {
      codeWriter.emitTypeVariables(typeVariables);
      codeWriter.emit(" ");
    }

    if (isConstructor()) {
      codeWriter.emit("$L(", enclosingName);
    } else {
      codeWriter.emit("$T $L(", returnType, name);
    }

    boolean firstParameter = true;
    for (Iterator<ParameterSpec> i = parameters.iterator(); i.hasNext(); ) {
      ParameterSpec parameter = i.next();
      if (!firstParameter) codeWriter.emit(",").emitWrappingSpace();
      parameter.emit(codeWriter, !i.hasNext() && varargs);
      firstParameter = false;
    }

    codeWriter.emit(")");

    if (defaultValue != null && !defaultValue.isEmpty()) {
      codeWriter.emit(" default ");
      codeWriter.emit(defaultValue);
    }

    if (!exceptions.isEmpty()) {
      codeWriter.emitWrappingSpace().emit("throws");
      boolean firstException = true;
      for (TypeName exception : exceptions) {
        if (!firstException) codeWriter.emit(",");
        codeWriter.emitWrappingSpace().emit("$T", exception);
        firstException = false;
      }
    }

    if (hasModifier(Modifier.ABSTRACT)) {
      codeWriter.emit(";\n");
    } else if (hasModifier(Modifier.NATIVE)) {
      // Code is allowed to support stuff like GWT JSNI.
      codeWriter.emit(code);
      codeWriter.emit(";\n");
    } else {
      codeWriter.emit(" {\n");

      codeWriter.indent();
      codeWriter.emit(code);
      codeWriter.unindent();

      codeWriter.emit("}\n");
    }
  }

ext.deps = [
    ...
    javapoet: 'com.squareup:javapoet:1.8.0',
    ...
  ]

dependencies {
    ...
    compile deps.javapoet
    ...
}

@Override 
  public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
    Map<TypeElement, BindingSet> bindingMap = findAndParseTargets(env);

    for (Map.Entry<TypeElement, BindingSet> entry : bindingMap.entrySet()) {
      TypeElement typeElement = entry.getKey();
      BindingSet binding = entry.getValue();

      JavaFile javaFile = binding.brewJava(sdk);
      try {
        javaFile.writeTo(filer);
      } catch (IOException e) {
        error(typeElement, "Unable to write binding for type %s: %s", typeElement, e.getMessage());
      }
    }

    return false;
  }

@Retention(RetentionPolicy.CLASS)
@Target(ElementType.TYPE)
public @interface HelloAnnotation {
}

@AutoService(Processor.class)
public class HelloProcessor extends AbstractProcessor {
    private Filer filer;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        filer = processingEnv.getFiler(); // for creating file
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement element : annotations) {
            if (element.getQualifiedName().toString().equals(HelloAnnotation.class.getCanonicalName())) {
                // main method
                MethodSpec main = MethodSpec.methodBuilder("main")
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .returns(void.class)
                        .addParameter(String[].class, "args")
                        .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
                        .build();
                // HelloWorld class
                TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
                        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                        .addMethod(main)
                        .build();

                try {
                    // build com.example.HelloWorld.java
                    JavaFile javaFile = JavaFile.builder("com.example", helloWorld)
                            .addFileComment(" This codes are generated automatically. Do not modify!")
                            .build();
                    // write to file
                    javaFile.writeTo(filer);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return true;
    }

    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return Collections.singleton(HelloAnnotation.class.getCanonicalName());
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

}

@HelloAnnotation
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        HelloWorld.main(null);
    }
}

//  This codes are generated automatically. Do not modify!
package com.example;

import java.lang.String;
import java.lang.System;

public final class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, JavaPoet!");
  }
}

service TestDemo {
    rpc doRequest (MyRequest) returns (MyResponse) { // 请求接口定义
    }
    
    message MyRequest { // 请求内容实体
        string content;
    }
    
    message MyResponse { // 返回内容实体
        int32 status_code;
        string entity;
    }
}

package com.example;

public class MyProcessor extends AbstractProcessor {

    @Override
    public synchronized void init(ProcessingEnvironment env){ }

    @Override
    public boolean process(Set<? extends TypeElement> annoations, RoundEnvironment env) { }

    @Override
    public Set<String> getSupportedAnnotationTypes() { }

    @Override
    public SourceVersion getSupportedSourceVersion() { }

}

@AutoService(Processor.class)
public class MyProcessor extends AbstractProcessor {
    ...
}

classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'

apt project(':xxx-compiler')

public class Person {

    private Integer age;
    private String name;

    public Integer getAge() {
        return age;
    }

    @Builder
    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    @Builder
    public void setName(String name) {
        this.name = name;
    }
}

public class PersonBuilder {
 
    private Person object = new Person();
 
    public Person build() {
        return object;
    }
 
    public PersonBuilder setName(java.lang.String value) {
        object.setName(value);
        return this;
    }
 
    public PersonBuilder setAge(int value) {
        object.setAge(value);
        return this;
    }
}

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

}

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.ExecutableType;
import javax.tools.Diagnostic;
import javax.tools.JavaFileObject;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * @author throwable
 * @version v1.0
 * @description
 * @since 2018/5/27 11:21
 */
@SupportedAnnotationTypes(value = {"club.throwable.processor.builder.Builder"})
@SupportedSourceVersion(value = SourceVersion.RELEASE_8)
public class BuilderProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement typeElement : annotations) {
            Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(typeElement);
            Map<Boolean, List<Element>> annotatedMethods
                    = annotatedElements.stream().collect(Collectors.partitioningBy(
                    element -> ((ExecutableType) element.asType()).getParameterTypes().size() == 1
                            && element.getSimpleName().toString().startsWith("set")));
            List<Element> setters = annotatedMethods.get(true);
            List<Element> otherMethods = annotatedMethods.get(false);
            otherMethods.forEach(element ->
                    processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
                            "@Builder must be applied to a setXxx method "
                                    + "with a single argument", element));
            Map<String, String> setterMap = setters.stream().collect(Collectors.toMap(
                    setter -> setter.getSimpleName().toString(),
                    setter -> ((ExecutableType) setter.asType())
                            .getParameterTypes().get(0).toString()
            ));
            String className = ((TypeElement) setters.get(0)
                    .getEnclosingElement()).getQualifiedName().toString();
            try {
                writeBuilderFile(className, setterMap);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    private void writeBuilderFile(
            String className, Map<String, String> setterMap)
            throws IOException {
        String packageName = null;
        int lastDot = className.lastIndexOf('.');
        if (lastDot > 0) {
            packageName = className.substring(0, lastDot);
        }
        String simpleClassName = className.substring(lastDot + 1);
        String builderClassName = className + "Builder";
        String builderSimpleClassName = builderClassName
                .substring(lastDot + 1);

        JavaFileObject builderFile = processingEnv.getFiler().createSourceFile(builderClassName);

        try (PrintWriter out = new PrintWriter(builderFile.openWriter())) {

            if (packageName != null) {
                out.print("package ");
                out.print(packageName);
                out.println(";");
                out.println();
            }
            out.print("public class ");
            out.print(builderSimpleClassName);
            out.println(" {");
            out.println();
            out.print("    private ");
            out.print(simpleClassName);
            out.print(" object = new ");
            out.print(simpleClassName);
            out.println("();");
            out.println();
            out.print("    public ");
            out.print(simpleClassName);
            out.println(" build() {");
            out.println("        return object;");
            out.println("    }");
            out.println();
            setterMap.forEach((methodName, argumentType) -> {
                out.print("    public ");
                out.print(builderSimpleClassName);
                out.print(" ");
                out.print(methodName);

                out.print("(");

                out.print(argumentType);
                out.println(" value) {");
                out.print("        object.");
                out.print(methodName);
                out.println("(value);");
                out.println("        return this;");
                out.println("    }");
                out.println();
            });
            out.println("}");
        }
    }
}

public class Main {

    public static void main(String[] args) throws Exception{
      //PersonBuilder在编译之后才会生成，这里需要编译后才能这样写
      Person person  = new PersonBuilder().setAge(25).setName("doge").build();
    }
}

package club.throwable.processor.builder;

public class PersonBuilder {
    private Person object = new Person();

    public PersonBuilder() {
    }

    public Person build() {
        return this.object;
    }

    public PersonBuilder setName(String value) {
        this.object.setName(value);
        return this;
    }

    public PersonBuilder setAge(Integer value) {
        this.object.setAge(value);
        return this;
    }
}

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class CustomClassLoader extends ClassLoader {

    private final String basePath;

    public CustomClassLoader(String basePath) {
        this.basePath = basePath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] classBytes = loadClassBytes(name);
            return defineClass(name, classBytes, 0, classBytes.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Failed to load class: " + name, e);
        }
    }

    private byte[] loadClassBytes(String name) throws IOException {
        String fileName = name.replace('.', '/') + ".class";
        Path path = Paths.get(basePath, fileName);
        return Files.readAllBytes(path);
    }

    public static void main(String[] args) throws ClassNotFoundException {
        String classPath = "path/to/classes"; // Replace with your class files location
        CustomClassLoader customClassLoader = new CustomClassLoader(classPath);
        Class<?> customClass = customClassLoader.loadClass("com.example.MyClass");

        // Now you can create instances of your custom class
        // For example, you can create an instance and invoke its methods
        try {
            Object instance = customClass.getDeclaredConstructor().newInstance();
            customClass.getMethod("someMethod").invoke(instance);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Class<?> clazz = Class.forName("com.example.MyClass");

Constructor<?> constructor = clazz.getDeclaredConstructor();
Object instance = constructor.newInstance();

Method method = clazz.getDeclaredMethod("someMethod");
method.invoke(instance);

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

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

public class MyClass {
    @MyAnnotation("Hello, World!")
    public void someMethod() {
        // Method body
    }
}

Method method = MyClass.class.getDeclaredMethod("someMethod");
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
if (annotation != null) {
    String value = annotation.value();
    System.out.println(value); // 输出 "Hello, World!"
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface MyInterface {
    void doSomething();
}

class MyRealObject implements MyInterface {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

class MyProxyHandler implements InvocationHandler {
    private MyInterface target;

    public MyProxyHandler(MyInterface target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface realObject = new MyRealObject();
        MyInterface proxyObject = (MyInterface) Proxy.newProxyInstance(
            Main.class.getClassLoader(),
            new Class<?>[]{MyInterface.class},
            new MyProxyHandler(realObject)
        );

        proxyObject.doSomething();
    }
}

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

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value() default "";
}

class MyClass {
    @MyAnnotation("Hello, World!")
    public void someMethod() {
        // Method body
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        MyClass myClass = new MyClass();
        Method method = myClass.getClass().getMethod("someMethod");

        if (method.isAnnotationPresent(MyAnnotation.class)) {
            MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
            String value = annotation.value();
            System.out.println(value); // 输出 "Hello, World!"
        }
    }
}

package com.zhz.designpatterns.test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.*;

public abstract class AnnotationUtils {

    public AnnotationUtils() {
    }

    /**
     * 获取一个方法的所有注解
     *
     * @param method
     * @return
     */
    public static Annotation[] getAnnotations(Method method) {

        return method.getAnnotations();
    }

    /**
     * 获取方法的一个注解类型
     *
     * @param method
     * @param annotationType
     * @return
     */
    public static Annotation getAnnotation(Method method, Class annotationType) {
        return method.getAnnotation(annotationType);
    }

    /**
     * 查找一个方法的注解类型
     *
     * @param method
     * @param annotationType
     * @return
     */
    public static Annotation findAnnotation(Method method, Class annotationType) {
        Annotation annotation = getAnnotation(method, annotationType);
        Class cl = method.getDeclaringClass();
        do {
            if (annotation != null)
                break;
            cl = cl.getSuperclass();
            if (cl == null || cl.equals(Object.class))
                break;
            try {
                Method equivalentMethod = cl.getDeclaredMethod(method.getName(), method.getParameterTypes());
                annotation = getAnnotation(equivalentMethod, annotationType);
            } catch (NoSuchMethodException ex) {
            }
        } while (true);
        return annotation;
    }

    /**
     * 查找一个类的某种注解类型
     *
     * @param clazz
     * @param annotationType
     * @return
     */
    public static Annotation findAnnotation(Class clazz, Class annotationType) {
        Annotation annotation = clazz.getAnnotation(annotationType);
        if (annotation != null) {
            return annotation;
        }
        Class[] clazzes = clazz.getInterfaces();
        int len = clazzes.length;
        for (Class ifc : clazzes) {
            annotation = findAnnotation(ifc, annotationType);
            if (annotation != null) {
                return annotation;
            }
        }

        if (clazz.getSuperclass() == null || Object.class.equals(clazz.getSuperclass())) {
            return null;
        } else {
            return findAnnotation(clazz.getSuperclass(), annotationType);
        }
    }

    /**
     * 查找包含某种注解类型的Class类型的Class
     *
     * @param annotationType
     * @param clazz
     * @return
     */
    public static Class findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz) {
        if (clazz == null || clazz.equals(Object.class)) {
            return null;
        } else {
            return isAnnotationDeclaredLocally(annotationType, clazz) ? clazz : findAnnotationDeclaringClass(annotationType, clazz.getSuperclass());
        }
    }

    /**
     * 检查一个类是否包含一个特定的注解类型
     *
     * @param annotationType
     * @param clazz
     * @return
     */
    public static boolean isAnnotationDeclaredLocally(Class<? extends Annotation> annotationType, Class<?> clazz) {
        boolean declaredLocally = false;
        Iterator i = Arrays.asList(clazz.getDeclaredAnnotations()).iterator();
        do {
            if (!i.hasNext()) {
                break;
            }
            Annotation annotation = (Annotation) i.next();
            if (!annotation.annotationType().equals(annotationType)) {
                continue;
            }
            declaredLocally = true;
            break;
        } while (true);
        return declaredLocally;
    }

    public static boolean isAnnotationInherited(Class<? extends Annotation> annotationType, Class<?> clazz) {
        return clazz.isAnnotationPresent(annotationType) && !isAnnotationDeclaredLocally(annotationType, clazz);
    }

    /**
     * 获取注解所有的属性
     *
     * @param annotation
     * @return
     */
    public static Map<String,Object> getAnnotationAttributes(Annotation annotation) {
        Map<String,Object> attrs = new HashMap<>();
        Method[] methods = annotation.annotationType().getDeclaredMethods();
        for (Method method : methods) {
            if (method.getParameterTypes().length != 0 || method.getReturnType() == Void.TYPE) {
                continue;
            }
            try {
                attrs.put(method.getName(), method.invoke(annotation, new Object[0]));
            } catch (Exception ex) {
                throw new IllegalStateException("Could not obtain annotation attribute values", ex);
            }
        }

        return attrs;
    }

    public static Object getValue(Annotation annotation) {
        return getValue(annotation, "value");
    }

    /**
     * 获取注解对应的属性值
     *
     * @param annotation
     * @param attributeName
     * @return
     */
    public static Object getValue(Annotation annotation, String attributeName) {
        try {
            Method method = annotation.annotationType().getDeclaredMethod(attributeName, new Class[0]);
            return method.invoke(annotation, new Object[0]);
        } catch (Exception ex) {
            return null;
        }
    }

    public static Object getDefaultValue(Annotation annotation) {
        return getDefaultValue(annotation, VALUE);
    }

    public static Object getDefaultValue(Annotation annotation, String attributeName) {
        return getDefaultValue(annotation.annotationType(), attributeName);
    }

    public static Object getDefaultValue(Class<?> annotationType) {
        return getDefaultValue(annotationType, VALUE);
    }

    public static Object getDefaultValue(Class<?> annotationType, String attributeName) {
        try {
            Method method = annotationType.getDeclaredMethod(attributeName, new Class[0]);
            return method.getDefaultValue();
        } catch (Exception ex) {
            return null;
        }
    }

    static final String VALUE = "value";
}