Web基础（十）----注解

一、什么是注解，注解作用

注解就是符合一定格式的语法 @xxxx
注解作用：
注释：在阅读程序时清楚----给程序员看的
注解：给jvm看的，给机器看的。jvm读到注解的时候，会完成一定的功能。
注解在目前而言最主流的应用：代替配置文件
关于配置文件与注解开发的优缺点：
注解优点：开发效率高 成本低  

注解缺点：耦合性大 并且不利于后期维护

案例：

我们创建一个web工程，dynamic web module version选3.0. 3.0支持注解形式的servlet，默认没有web.xml. @WebServlet("/DemoServlet")。

package com.ken.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/demo")
public class DemoServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

	public DemoServlet() {
		super();
	}

	protected void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		response.getWriter().write("DemoServlet...");
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}
}

运行效果：

注解的缺点：改servlet的名称之后要编译。

注解的有点：开发快。

开发过程中不太会修改的东西，用注解；很可能被改的就用xml。

二、jdk5提供的注解

@Override：告知编译器此方法是覆盖父类的
@Deprecated：标注过时
@SuppressWarnings：压制警告，被修饰的类或方法如果存在编译警告，将被编译器忽略

deprecation，忽略过时

rawtypes，忽略类型安全

unused，忽略不使用

unchecked，忽略安全检查

null，忽略空指针

all，忽略所有
发现的问题：
不同的注解只能在不同的位置使用(方法上、字段上、类上)

三、自定义注解（了解）

1）怎样去编写一个自定义的注解
2）怎样去使用注解
3）怎样去解析注解-----使用反射知识

3.1 定义注解

public @interface MyAnno {
	//注解的属性
	String name();
	int age() default 28;
}

3.2 使用注解

public class MyAnnotest {

	@MyAnno(name = "zhangsan")
	public void show(){
		
	}
}

如果注解只有一个属性，并且属性的名称是value，那么使用注解的时候的键值对的键是可以省略的，比如：

定义主注解

public @interface MyAnno {
	// 注解的属性
	// String name();
	// int age() default 28;
	String value();
}

使用注解

public class MyAnnotest {
	@MyAnno("zhangsan")
	public void show(){
		
	}
}

注解的属性是数组的案例：

定义注解

public @interface MyAnno {
	// 注解的属性
	// String name();
	// int age() default 28;
	// String value();
	String[] value();
}

使用注解

public class MyAnnotest {
	@MyAnno({ "aaa", "bbb" })
	public void show() {

	}
}

注解属性类型只能是以下几种
1.基本类型
2.String
3.枚举类型
4.注解类型
5.Class类型

6.以上类型的一维数组类型

3.3 解析使用了注解的类

介入一个概念：元注解：代表修饰注解的注解，作用：限制定义的注解的特性

@Target
代表注解修饰的范围：类上使用，方法上使用，字段上使用
FIELD:字段上可用此注解
METHOD:方法上可以用此注解
TYPE:类/接口上可以使用此注解

@Retention
SOURCE: 注解在源码级别可见
CLASS：注解在字节码文件级别可见
RUNTIME：注解在整个运行阶段都可见

-----------------

-----------------

@override在源码中可见，编译之后，就没有了。

注意：要想解析使用了注解的类 ， 那么该注解的Retention必须设置成Runtime
关于注解解析的实质：从注解中解析出属性值
字节码对象存在于获得注解相关的方法
isAnnotationPresent(Class<? extends Annotation> annotationClass) ： 判断该字节码对象身上是否使用该注解了
getAnnotation(Class<A> annotationClass) ：获得该字节码对象身上的注解对象

工程：

AnnoDemo

package com.ken.servlet;

import java.util.ArrayList;
import java.util.List;

@SuppressWarnings("all")
public class AnnoDemo {

	public static void main(String[] args) {

		List list = new ArrayList();
		// System.out.println(list);
	}

	//定义方法过时
	@Deprecated
	public static void show() {

	}

	public static void show(String xxx) {

	}
}

MyAnno

package com.ken.servlet;

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

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnno {
	// 注解的属性
	String name();

	int age() default 28;
	// String value();
	// String[] value();
}

MyAnnoParser

package com.ken.servlet;

import java.lang.reflect.Method;

public class MyAnnoParser {
	public static void main(String[] args) throws NoSuchMethodException, SecurityException {
		//解析show方法上面的@MyAnno
		//直接的目的是获得show方法上的@MyAnno中的参数
		
		//获得show方法的字节码对象
		Class clazz = MyAnnotest.class;
		Method method = clazz.getMethod("show", String.class);//这个method就是show方法的字节码对象
		//获得show方法上的@MyAnno
		MyAnno annotation = method.getAnnotation(MyAnno.class);
		//获得@MyAnno上的属性的值
		System.out.println(annotation.name());
		System.out.println(annotation.age());
		
		//根据业务需求写逻辑代码
	}
}

MyAnnotest

package com.ken.servlet;

@MyAnno(name = "zhangsan")
public class MyAnnotest {
	@MyAnno(name = "zhangsan")
	public void show(String str) {
		System.out.println("show running...");
	}
}

四、模拟单元测试

MyTest

package com.ken.case1;

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 MyTest {

	//不需要属性
}

TestDemo

package com.ken.case1;

import org.junit.Test;

public class TestDemo {

	// 程序员开发中测试用的
	@Test
	public void test1() {
		System.out.println("test1 running...");
	}

	@MyTest
	public void test2() {
		System.out.println("test2 running...");
	}

	@MyTest
	public void test3() {
		System.out.println("test3 running...");
	}
}

MyTestParser

package com.ken.case1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MyTestParser {

	public static void main(String[] args)
			throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {

		// 获得TestDemo
		Class clazz = TestDemo.class;

		// 获得所有的方法
		Method[] methods = clazz.getMethods();
		if (methods != null) {
			for (Method method : methods) {
				// 获得注解使用了@MyTest的方法
				boolean annotationPresent = method.isAnnotationPresent(MyTest.class);
				if (annotationPresent) {
					// 该方法使用了@MyTest
					method.invoke(clazz.newInstance(), null);
				}
			}
		}
	}
}