注解：
可以看作是对 一个 类／方法 的一个扩展的模版，每个 类／方法 按照注解类中的规则，来
为 类／方法 注解不同的参数，在用到的地方可以得到不同的 类／方法 中注解的各种参数
与值。
注解的原理：
注解本质是一个继承了Annotation的特殊接口，其具体实现类是Java运行时生成的动
态代理类。而我们通过反射获取注解时，返回的是Java运行时生成的动态代理对象
$Proxy1。通过代理对象调用自定义注解（接口）的方法，会最终调用
AnnotationInvocationHandler的invoke方法。该方法会从memberValues这个Map中
索引出对应的值。而memberValues的来源是Java常量池
java.lang.annotation提供了四种元注解，专门注解其他的注解（在自定义注解的时候，
需要使用到元注解）：
@Documented –注解是否将包含在JavaDoc中
@Retention –什么时候使用该注解
@Target –注解用于什么地方
@Inherited – 是否允许子类继承该注解
1.）@Retention– 定义该注解的生命周期
● RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任
何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注
解。
● RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解
默认使用这种方式
● RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用
反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。
2.）Target – 表示该注解用于什么地方。默认值为任何元素，表示该注解用于什么地
方。可用的ElementType参数包括
● ElementType.CONSTRUCTOR:用于描述构造器
● ElementType.FIELD:成员变量、对象、属性（包括enum实例）
● ElementType.LOCAL_VARIABLE:用于描述局部变量
● ElementType.METHOD:用于描述方法
● ElementType.PACKAGE:用于描述包
● ElementType.PARAMETER:用于描述参数● ElementType.TYPE:用于描述类、接口(包括注解类型) 或enum声明
3.)@Documented–一个简单的Annotations标记注解，表示是否将注解信息添加在java
文档中。
4.)@Inherited – 定义该注释和子类的关系
@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承
的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个
annotation将被用于该class的子类。
自定义注解：
自定义注解类编写的一些规则:
1. Annotation型定义为@interface, 所有的Annotation会自动继承
java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
2. 参数成员只能用public或默认(default)这两个访问权修饰
3. 参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本
数据类型和String、Enum、Class、annotations等数据类型,以及这一些类型的数组.
4. 要获取类方法和字段的注解信息，必须通过Java的反射技术来获取 Annotation对象,
因为你除此之外没有别的获取注解对象的方法
5. 注解也可以没有定义成员, 不过这样注解就没啥用了
PS:自定义注解需要使用到元注解
aop的讲解
（1）AOP是什么？AOP与拦截器的区别？
太抽象的不说，如果你知道Struts2的拦截器，拦截器就是应用的AOP的思想，它用于拦截
Action以进行一些预处理或结果处理。而Spring的AOP是一种更通用的模式，可以拦截
Spring管理的Bean，功能更强大，适用范围也更广，它是通过动态代理与反射机制实现的。
（ 更 详 细 的 解 释 可 参 看 博
客 http://blog.csdn.net/zhangliangzi/article/details/51648032 ）
（2）使用AOP需要的一些概念。
1.通知(Advice)
通知定义了在切入点代码执行时间点附近需要做的工作。
Spring支持五种类型的通知：
Before(前) org.apringframework.aop.MethodBeforeAdvice
after(后)
After-returning(返回后) org.springframework.aop.AfterReturningAdvice
After-throwing(抛出后) org.springframework.aop.ThrowsAdvice
Arround(周围) org.aopaliance.intercept.MethodInterceptorIntroduction(引入) org.springframework.aop.IntroductionInterceptor
2.连接点(Joinpoint)
程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法调用时、异常
抛出时、方法返回后等等。
3.切入点(Pointcut)
通知定义了切面要发生的“故事”，连接点定义了“故事”发生的时机，那么切入点就
定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允许我们方便的用正
则表达式来指定。
4.切面(Aspect)
通知、连接点、切入点共同组成了切面：时间、地点和要发生的“故事”。
5.引入(Introduction)
引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）。
6.目标(Target)
即被通知的对象，如果没有AOP，那么通知的逻辑就要写在目标对象中，有了AOP之后它
可以只关注自己要做的事，解耦合！
7.代理(proxy)
应用通知的对象，详细内容参见设计模式里面的动态代理模式。
8.织入(Weaving)
把切面应用到目标对象来创建新的代理对象的过程，织入一般发生在如下几个时机:
(1)编译时：当一个类文件被编译时进行织入，这需要特殊的编译器才可以做的到，例
如AspectJ的织入编译器；
(2)类加载时：使用特殊的ClassLoader在目标类被加载到程序之前增强类的字节代码；
(3)运行时：切面在运行的某个时刻被织入,SpringAOP就是以这种方式织入切面的，原
理应该是使用了JDK的动态代理技术。
切点表达式
在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义
pointcut"切入点" 例如定义切入点表达式
expression="execution(* com.fh.service..*.*(..))"
expression="execution(* com.fh.action.login.LoginAction.login(..))"
execution()是最常用的切点函数，其语法如下所示： 整个表达式可以分为五个部分：
1、execution(): 表达式主体。
2、第一个*号：表示返回类型，*号表示所有的类型。
3、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，
com.sample.service.impl包、子孙包下所有类的方法。
4、第二个*号：表示类名，*号表示所有的类。5、*(..):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参
数，两个句点表示任何参数。
三、使用AOP的几种方式
1.经典的基于代理的AOP
[email protected]注解驱动的切面
3.纯POJO切面
如何使用
@AspectJ 进行注解配置
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.8</version>
</dependency>
1.配置
在springMVC中增加配置
头部文件中加入
xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
2.加入配置
<!-- 开启注解模式 -->
<aop:aspectj-autoproxy/>
<!-- 扫描注解路径 -->
<context:component-scan base-package="com.fh.aop" />
3.定义自定义注解接口
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ILogAcpect {
String methodInfo() default "";String modelName() default "";
}
4.配置注解版的AOP切面类
@Aspect
@Component
public class LogAspect {
@Pointcut("execution(* com.fh.controller..*.*(..))")
private void doMethod() {
}
@Before("doMethod()")
public void beforeAdvice(JoinPoint joinPoint) {
HttpServletRequest request = ((ServletRequestAttributes)
RequestContextHolder.getRequestAttributes())
.getRequest();
// 请求的IP
String ip = request.getRemoteAddr();
System.out.println(ip);
try {
// 当前访问的类路径
String targetName =
joinPoint.getTarget().getClass().getName();
// 当前访问的方法名
String methodName = joinPoint.getSignature().getName();
// 获取当前类中的公共方法
Class targetClass = Class.forName(targetName);
Method[] methods = targetClass.getMethods();
String params = "";
if (joinPoint.getArgs() != null &&
joinPoint.getArgs().length > 0) {
params = Arrays.toString(joinPoint.getArgs());
}
Object[] arguments = joinPoint.getArgs();String logName = "";
String modelName = "";
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs =
method.getParameterTypes();
if (clazzs.length == arguments.length) {
if
(method.getAnnotation(ILogAcpect.class) != null) {
logName =
method.getAnnotation(ILogAcpect.class).methodInfo();
modelName =
method.getAnnotation(ILogAcpect.class).modelName();
}
break;
}
}
}
// 通过类路径获取所有的方法
System.out.println("日志输出的明细为:" + logName);
System.out.println("日志输出访问模块:" + modelName);
System.out.println("访问参数:" + params);
System.out.println("访问的类路径:" + targetName);
System.out.println("访问的方法名:" + methodName);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@After("doMethod()")
public void afterAdvice() {
System.out.println("afterAdvice");
}@AfterThrowing(pointcut = "doMethod()", throwing = "e")
public void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
System.err.println("异常通知:" + e.getMessage());
}
}
原文地址：https://www.cnblogs.com/ycq-qiang/p/11161952.html