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

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

public class UserController {
    
    @RequirePermission("user:view")
    public void viewUserInfo() {
        // ...
    }

    @RequirePermission("user:edit")
    public void editUserInfo() {
        // ...
    }
}

public class PermissionInterceptor {
    
    public void checkPermission(Method method) throws IllegalAccessException {
        RequirePermission requirePermission = method.getAnnotation(RequirePermission.class);
        if (requirePermission != null) {
            String requiredPermission = requirePermission.value();
            if (!hasPermission(requiredPermission)) {
                throw new IllegalAccessException("Permission denied: " + requiredPermission);
            }
        }
    }
    
    private boolean hasPermission(String requiredPermission) {
        // 实现具体的权限检查逻辑，如从数据库或缓存中查询用户是否具有所需权限
        // ...
        return true;
    }
}

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;
import java.util.Set;

@SupportedAnnotationTypes("com.example.MyAnnotation")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class MyAnnotationProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // 在此处处理注解，例如生成代码或资源文件
        // ...

        // 返回 true 表示已处理完毕，不再调用其他处理器；返回 false 则继续调用其他处理器
        return true;
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface Entity {
    String tableName() default "";
}

public class EntityAnnotationProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(Entity.class)) {
            if (element.getKind() == ElementKind.CLASS) {
                // 获取实体类信息，生成 DAO 接口和实现类
                // ...
            }
        }
        return true;
    }
}

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.8.1</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <annotationProcessorPaths>
          <path>
            <groupId>com.example</groupId>
            <artifactId>my-annotation-processor</artifactId>
            <version>1.0.0</version>
          </path>
        </annotationProcessorPaths>
      </configuration>
    </plugin>
  </plugins>
</build>

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

public class LogProcessor {
    
    public void processLogAnnotation(Class<?> clazz) {
        for (Method method : clazz.getDeclaredMethods()) {
            Log logAnnotation = method.getAnnotation(Log.class);
            if (logAnnotation != null) {
                String logMessage = logAnnotation.value();
                // 根据注解的属性值进行日志处理
                // ...
            }
        }
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Inject {
}

public class DependencyInjector {

    private Map<Class<?>, Object> dependencyMap = new HashMap<>();

    public void register(Class<?> clazz, Object instance) {
        dependencyMap.put(clazz, instance);
    }

    public void injectDependencies(Object target) throws IllegalAccessException {
        Class<?> clazz = target.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Inject.class)) {
                Object dependency = dependencyMap.get(field.getType());
                if (dependency != null) {
                    boolean accessible = field.isAccessible();
                    field.setAccessible(true);
                    field.set(target, dependency);
                    field.setAccessible(accessible);
                } else {
                    throw new IllegalStateException("No registered dependency for " + field.getType());
                }
            }
        }
    }
}

public class UserService {
    // ...
}

public class UserController {
    @Inject
    private UserService userService;
    
    public void handleRequest() {
        // 使用 userService 处理请求
        // ...
    }
}

public class Main {
    public static void main(String[] args) throws IllegalAccessException {
        DependencyInjector injector = new DependencyInjector();
        injector.register(UserService.class, new UserService());

        UserController userController = new UserController();
        injector.injectDependencies(userController);

        userController.handleRequest();
    }
}

public @interface Cache {
    int durationMinutes() default 30;
}