【转】spring 自定义注解（annotation）与 aop获取注解

  • Z时代
  • 2024-01-10
  • 分类：综合

本文内容纲要：【转】spring 自定义注解（annotation）与 aop获取注解

首先我们先介绍Java自定义注解。

在开发过程中，我们实现接口的时候，会出现@Override，有时还会提示写@SuppressWarnings。其实这个就是Java特有的特性，注解。

注解就是某种注解类型的一种实例，我们可以把它用在某个类上进行标注。下面这张图解释注解都是什么？

image

上图可以看出注解大体分为三种：元注解，标记注解，一般注解；

这一块其他的我就不多做介绍，我们这里主要说一下如何定义自己的注解，在这之前我们必须了解标准元注解和相关定义注解的语法。

元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：

1.@Target,

2.@Retention,

3.@Documented,

4.@Inherited

@Target

@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。

作用：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）

取值(ElementType)有：

  1. CONSTRUCTOR:用于描述构造器

  2. FIELD:用于描述符

  3. LOCAL_VARIABLE:用于描述局部变量

  4. METHOD:用于描述方法

  5. PACKAGE:用于描述包

  6. PARAMETER: 用于描述参数

  7. TYPE: 用于描述类、接口（包括注解类型）或者enum声明

@Retention

@Retention定义了该Annotation被保留的时间长短：某些Annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。

作用：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）

取值（RetentionPoicy）有：

  1. SOURCE:在源文件中有效（即源文件保留）

  2. CLASS:在class文件中有效（即class保留）

  3. RUNTIME:在运行时有效（即运行时保留）

 @Documented

@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。

 @Inherited

@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。

注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。

当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。

自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。

定义注解格式:

public @interface 注解名 {定义体}

　　 注解参数的可支持数据类型:

　　 1. 所有基本数据类型（int,float,boolean,byte,double,char,long,short)

　　 2. String类型

　　 3. Class类型

　　 4. enum类型

　　 5. Annotation类型

　　 6. 以上所有类型的数组

　　

　　Annotation类型里面的参数该怎么设定:

　　第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；

　　第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;

　　第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。

使用示例：

CacheRedis.java

import java.lang.annotation.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CacheRedis { String key(); int expireTime() default 600; }

CacheService.java

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; @Aspect @Component public class CacheService { Logger logger = LoggerFactory.getLogger(CacheService.class); @Pointcut(value = "@annotation(com.meizu.bro.service.test.CacheRedis)") public void pointCut(){} @Before(value = "pointCut() && @annotation(cacheRedis)") public void before(CacheRedis cacheRedis) { logger.info("the result of this method will be cached."); } @AfterReturning(value = "pointCut() && @annotation(cacheRedis)",returning = "result") public void after(CacheRedis cacheRedis,Object result) { String key = cacheRedis.key(); int expireTime = cacheRedis.expireTime(); //do something... logger.info("-----redis-----[key = " + key + "]"+"[expireTime = " + expireTime + "]"); logger.info("the result of this method is" + result + ",and has been cached."); } //@Around("pointCut() && @annotation(cacheRedis)") //public Object setCache(ProceedingJoinPoint joinPoint,CacheRedis cacheRedis) { // Object result = 1; // // Method method = getMethod(joinPoint);//自定义注解类 // //CacheRedis cacheRedis = method.getAnnotation(CacheRedis.class);//获取key值 // String key = cacheRedis.key(); // int expireTime = cacheRedis.expireTime(); // //获取方法的返回类型,让缓存可以返回正确的类型 // Class returnType =((MethodSignature)joinPoint.getSignature()).getReturnType(); // // logger.info("[key = " + key + "]"+"[expireTime = " + expireTime + "]"); // // return result; //} // //private Method getMethod(ProceedingJoinPoint joinPoint) { // //获取参数的类型 // Method method = null; // try { // Signature signature = joinPoint.getSignature(); // MethodSignature msig = null; // if (!(signature instanceof MethodSignature)) { // throw new IllegalArgumentException("该注解只能用于方法"); // } // msig = (MethodSignature) signature; // method = joinPoint.getTarget().getClass().getMethod(msig.getName(), msig.getParameterTypes()); // } catch (NoSuchMethodException e) { // logger.error("annotation no sucheMehtod", e); // } catch (SecurityException e) { // logger.error("annotation SecurityException", e); // } // return method; //} }

测试接口TestController.java

@Controller
public class TestController { @Autowired private TestService testService; @RequestMapping(value = "/test") public ModelAndView myTest() { int test = testService.test(10); return ViewUtil.buildStandardJsonViewByObj(test); } @RequestMapping(value = "/test1") public ModelAndView myTest1() { String yanyi = testService.test1("yanyi"); return ViewUtil.buildStandardJsonViewByObj(yanyi); } }

TestService.java

public interface TestYanyiService {
    int test(int i); String test1(String i1); }

TestServiceImpl.java

import org.springframework.stereotype.Service;
@Service
public class TestYanyiServiceImpl implements TestYanyiService { @Override @CacheRedis(key = "test",expireTime = 10) public int test(int i) { return 0; } @Override @CacheRedis(key = "test1") public String test1(String i1) { return i1; } }

代码完成后，需要在pom文件中导入以下依赖：

<dependency>
                <groupId>aopalliance</groupId> <artifactId>aopalliance</artifactId> <version>1.0</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.13</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.8.13</version> </dependency> <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.2.2</version> </dependency>

这一块要注意：aspectjweaver包的版本和JDK版本有关联。如果是JDK 1.7及以上的用户，需要aspectjweaver包的版本不能过低（JDK1.7 —— aspectJ1.7.3+）。否则会报错：报错error at ::0 can't find referenced pointcut。

接下来，在Spring配置文件里进行以下配置

<!-- 启动对@AspectJ注解的支持 -->  
<aop:aspectj-autoproxy/> 
<!--通知spring使用cglib而不是jdk的来生成代理方法 AOP可以拦截到Controller->  
<aop:aspectj-autoproxy proxy-target-class="true" />

ok! 完成后，调用测试接口，可以看到在控制窗口打印切面类前置和后置的相关log。这时候，我们就可以在里边实现自己的功能咯。（我这里准备实现redis缓存功能。）

本文内容总结：【转】spring 自定义注解（annotation）与 aop获取注解

原文链接：https://www.cnblogs.com/exmyth/p/11495006.html

以上是 【转】spring 自定义注解（annotation）与 aop获取注解 的全部内容， 来源链接： utcz.com/z/296911.html

回到顶部