Java注解

最新推荐文章于 2024-09-14 21:48:00 发布
最新推荐文章于 2024-09-14 21:48:00 发布
阅读量426 收藏
点赞数
分类专栏： Java注解 文章标签： java javadoc api 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011024652/article/details/52452893
版权

一、注解的基本概念

注解是JDK1.5及以后版本引入的，它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的，它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。（摘自 百度百科）
按照运行机制，注解可以分为三类：1、源码注解：即注解只在源代码中存在，在编译成.class文件后就不存在了；2、编译时注解：即在源码和编译的.class文件中都存在，例如常见的JDK 注解@Override、@Deprecated、@SuppressWarings；3、运行时注解：即注解在运行时仍然存在，甚至可能会影响程序的运行逻辑，例如Spring框架中用到的@Autowired注解。
我们也可以按照来源来将注解划分为三类：1、来自JDK的注解，就比如前面提到的@Override、@Deprecated、@SuppressWarings；2、来自第三方框架的注解，例如Spring的@Autowired；3、当然还有我们自己定义的注解。
还有一种特殊的注解，元注解，就是指注解的注解，这在自定义注解时经常使用。

二、自定义注解

我们可以通过自定义注解来实现我们自己想要的功能，下面通过一个简单的例子来讲解一下自定义注解的一些知识，下面的代码是一个简单的自定义注解。 
package com.imooc.annotation;

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

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Description {

	String name();
	
	int age() default 18;
	
}
首先我们可以看到，我们是使用@interface关键字定义注解的，其中注解里定义的类似于一个方法的例如String name();其实是注解的成员，注解的成员通常以无参无异常的方式声明的，我们也可以用default关键字为成员指定一个默认值。这里需要注意的是注解的成员的类型是受限的，只能是基本数据类型或者String，Class，Annotation，Enumeration这几种类型，如果一个注解只有一个成员，那么这个成员就必须取名为value()，在使用注解时可以不显式声明成员名称和等于号（=）。注解也可以没有成员，没有成员的注解称为标识注解。
除了注解定义的成员，我们发现在注解定义上面还有几个注解，这些注解就是元注解，下面来简单分析以下这几个元注解：@Target表示定义的注解的作用域，通常作用域有constructor(构造方法声明)，field（字段声明），local_variable（局部变量声明），method（方法声明），package（包声明），parameter（参数声明），type（类，接口声明）；@Retention表示定义的注解的运行周期，主要包括source：只在源码显示，编译时会丢弃，class：编译时会记录到class中，运行时忽略，runtime：运行时存在，可以通过反射读取；@Inherited表示被注解可以被子类继承；@Documented表示生成JavaDoc文档时会将注解写入文档。
当我们自定义了一个注解后就可以使用这个注解了，使用注解的语法是：@注解名(成员名=成员值,成员名=成员值……）

三、解析注解

在我们自定义了注解之后，可以通过反射获取类、方法或成员上 运行时的注解信息，从而实现动态控制程序运行时逻辑的目的。下面通过一个实例来解析上面的例子中定义的注解。我们先定义一个类，类名为Boy，在这个类上和类的方法上使用注解，代码如下。 
package com.imooc.annotation;

@Description(name="A Class boy", age=20)
public class Boy {

	@Override
	@Description(name="A Method boy", age=20)
	public String name() {
		return null;
	}

	@Override
	public int age() {
		return 0;
	}

}
然后我们再写一个解析注解的类TestAnnotation，通过反射来获取注解的信息。 
package com.imooc.annotation;

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

public class TestAnnotation {

	public static void main(String[] args) {
		//1、获取Class信息
		Class clazz = Boy.class;
		
		//2、通过反射判断类上是否存在注解
		if(clazz.isAnnotationPresent(Description.class)) {
			//3、获取到类上的注解
			Description desc  = (Description) clazz.getAnnotation(Description.class);
			//4、获取类上注解的信息
			System.out.println("name=" + desc.name() + "，age=" + desc.age());
			
			//5、通过反射获取类的方法
			Method[] methods = clazz.getMethods();
			for (Method method : methods) {
				//6、判断方法上是否有注解
				if(method.isAnnotationPresent(Description.class)) {
					//7、获取方法上的注解
					Description methodDesc = method.getAnnotation(Description.class);
					//8、获取方法上注解的信息
					System.out.println("第一种方式获得注解：name=" + methodDesc.name() + "，age=" + methodDesc.age());
				}
				
				//9、获取方法上所有的注解信息
				Annotation[] anns = method.getAnnotations();
				for (Annotation annotation : anns) {
					//10、遍历注解获取对应的注解信息
					if(annotation instanceof Description) {
						Description methodDesc = (Description) annotation;
						System.out.println("第二种方式获得注解：name=" + methodDesc.name() + "，age=" + methodDesc.age());
					}
				}
				
			}
			
		}
	}

}
运行程序，程序执行如下结果，说明我们自定义的注解解析成功了。 
name=A Class boy，age=20
第一种方式获得注解：name=A Method boy，age=20
第二种方式获得注解：name=A Method boy，age=20
接下来我们思考一下，定义一个接口Person，然后让Boy实现这个接口，然后在Person上使用注解，代码如下： 
package com.imooc.annotation;

@Description(name="A Class boy", age=20)
public interface Person {
	@Description(name="A Method boy", age=20)
	public String name();
	
	public int age();
	
}
package com.imooc.annotation;


public class Boy implements Person {

	@Override
	public String name() {
		return null;
	}

	@Override
	public int age() {
		return 0;
	}

}
这时再运行TestAnnotation，我们发现控制台并没有打印任何输出，这说明@Inherited这个元注解对与接口的implements是不起作用的，那如果我们将接口Person改成抽象类，让Boy继承这个抽象类结果会是怎样呢？ 
package com.imooc.annotation;

@Description(name="A Class boy", age=20)
public abstract class Person {
	@Description(name="A Method boy", age=20)
	public String name(){
		return null;
	}
	
	public int age(){
		return 0;
	}
	
}

package com.imooc.annotation;


public class Boy extends Person {

	@Override
	public String name() {
		return null;
	}

	@Override
	public int age() {
		return 0;
	}

}
运行程序，控制台打印如下输出。 
name=A Class boy，age=20
这说明@Inherited这个元注解对继承extends是起作用的，但是只会继承类上的注解，并不会继承该类方法上的注解。

四、一个简单实例的记录

这里简单记录一个注解实现的实例，主要用于根据数据库表和表中的字段进行组合，自动生成相应的SQL，下面是代码。 
package com.imooc.annotation.test;

@Table("user")
public class UserBean {

	@Column("id")
	private int id;
	
	@Column("user_name")
	private String userName;
	
	@Column("nick_name")
	private String nickName;
	
	@Column("age")
	private int age;
	
	@Column("sex")
	private String sex;
	
	@Column("city")
	private String city;
	
	@Column("email")
	private String email;
	
	@Column("phone")
	private String phone;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getNickName() {
		return nickName;
	}

	public void setNickName(String nickName) {
		this.nickName = nickName;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}
}

package com.imooc.annotation.test;

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

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

	String value();
	
}

package com.imooc.annotation.test;

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

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

	String value();
	
}

package com.imooc.annotation.test;

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

public class SQLUtil {

	public static void main(String[] args) throws Exception {
		UserBean user = new UserBean();
		user.setId(1);
		user.setUserName("Jack");
		user.setEmail("test@qq.com,test@126.com,test@163.com");
		
		System.out.println(generateSQL(user));
	}
	
	
	public static String generateSQL(Object obj) throws Exception {
		StringBuffer sb = new StringBuffer();
		
		Class clazz = obj.getClass();
		if(clazz.isAnnotationPresent(Table.class)) {
			Table table = (Table) clazz.getAnnotation(Table.class);
			sb.append("select * form ").append(table.value()).append(" where 1=1 ");
			
			Field[] fields = clazz.getDeclaredFields();
			for(Field field : fields) {
				if(field.isAnnotationPresent(Column.class)) {
					Column column = field.getAnnotation(Column.class);
					String columnName = column.value();
					
					String getMethodName = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
					Method getMethod = clazz.getMethod(getMethodName);
					Object returnValue = getMethod.invoke(obj);
					
					if(returnValue instanceof String) {
						if(returnValue != null) {
							if(((String) returnValue).contains(",")) {
								String[] spiltStrs = ((String) returnValue).split(",");
								sb.append(" and " + columnName + " in(");
								
								for (String spiltStr : spiltStrs) {
									sb.append(" '" + spiltStr + "', ");
								}
								sb.append(") ");
							} else {
								sb.append(" and " + columnName + "='" + returnValue + "' ");
							}
						}
					}
					
					if(returnValue instanceof Integer) {
						if((int)returnValue != 0) {
							sb.append(" and " + columnName + "=" + returnValue + " ");
						}
					}
				}
			}
			
			
		}
			
		return sb.toString();
	}

}











蛋蛋要学编程
关注
专栏目录
秒懂，Java 注解 （Annotation）你可以这样学
frank 的专栏
06-27 27万+
文章开头先引入一处图片。 这处图片引自老罗的博客。为了避免不必要的麻烦，首先声明我个人比较尊敬老罗的。至于为什么放这张图，自然是为本篇博文服务，接下来我自会说明。好了，可以开始今天的博文了。 Annotation 中文译过来就是注解、标释的意思，在 Java 中注解是一个很重要的知识点，但经常还是有点让新手不容易理解。 我个人认为，比较糟糕的技术文档主要特征之一就是：用专业名词来...
11.1.2 跟踪依赖性和副作用
心想事成
01-07 657
11.1.2 跟踪依赖性和副作用   不可变性的诸多好处之一是它的清晰。如果函数的参数为集合，返回数字，那么,,就可以放心地假设结果是根据集合的内容计算的，但并不会修改集合。我们不必要看得出这个结论的任何代码，也不必要检查其实现，或者任何它调用的其他函数。我们首先看一个例子，演示使用可变对象时是多么容易引入错误。
java 注解生命周期
u013217730的博客
11-11 2909
对注解概念不了解的可以先看这个：Java注解基础概念总结 前面有提到注解按生命周期来划分可分为3类： 1、RetentionPolicy.SOURCE：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃；2、RetentionPolicy.CLASS：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期；3、RetentionPolicy.RU...
Java自定义注解问题追踪及解决
键圣的博客
06-02 3058
警告：在搜索路径中找不到指定的 AnnotationProcessorFactory "com.dusk.annoation.database.InterfaceExtractorProcessorFactory"。 警告：未找到注释处理器，但存在注释。 多么令人沮丧的场景啊！ 。 这是使用apt处理自定义注解的时候发生的场景。 先上解决方案再谈引申： 这是因为你的Annotati
java注解使用及使用注解实现观察者模式
09-22 2113
注解的使用不会影响代码的uqj
java自定义注解，保存用户操作日志
炮孩子的博客
05-09 2660
关于注解，很多人都清楚它们的用途，像@Autowired，@Controller，@Service等等 而自定义注解，就是我们自己创建一个注解。 自定义注解的格式： public @interface 注解名 {定义体} 本文使用自定义注解结合springAop，记录用户的操作日志。 说到Aop切面编程，这种官方词语，看着就慌。 举个例子，现在你要吃
java 注解
jcsyl_mshot的博客
10-23 338
注解分类 一、运行机制划分: 源码注解 编译时注解 （只在编译器时起作用） 运行时注解（运行阶段起作用,影响运行逻辑,例如@Autowired） 二、按照来源划分: jdk自带注解 @Override @Depreted @SuppressWarning(“deprecation”) 自定义注解 java第三方注解 Spring注解 SpringBoot注解 自定义注解 一、 实现 使用@...
java注解之运行时修改字段的注解值操作
08-24
Java 注解是 Java 语言的一种特殊的注释方式，用于标注Java代码。注解可以在编译期、运行期对代码进行处理和修改。常见的 Java 注解有 @Override、@Deprecated 等。 Java 注解的分类 Java 注解可以分为三种：源码...
Java 注解
12-22
提到注解，我们会不由的想到注释，其实注解和注释不是一个东西，注释的作用就是解释代码，方便理解和阅读，说白了就是给程序员看的。而注解则不是，注解的作用比较大，可以进行编译检查、生成doc文档或者进行代码...
Java注解简单使用实例解析
08-18
Java注解简单使用实例解析 Java注解简单使用实例解析是Java语言中的一种 元数据形式，用于提供补充信息给编译器、虚拟机或其他工具。在Java中，注解可以出现在各种语法元素上，如类、方法、字段、参数等。今天，...
Java-网络
2301_81543552的博客
09-14 355
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 351
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 438
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 596
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 414
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
最新发布
m0_66572126的博客
09-14 451
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 605
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
Java注解与注释深度解析
"全面解析Java中的注解与注释，包括注解和注释的基本概念、用途，以及常见的Java内置注解的详细说明" 在Java编程中，注解（Annotation）和注释（Comment）虽然名字相似，但它们的功能却大相径庭。注解是一种元数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值