目录
- 1 注解
- 1.1 注解概述
- 1.2 自定义注解
- 1.3 元注解
- 1.4 注解解析
- 1.5 注解应用于 junit 框架
- 2 动态代理
- 2.1 问题引入
- 2.2 动态代理实现
1 注解
1.1 注解概述
Java 注解（Annotation）又称Java标注，是JDK 5.0引入的一种注释机制，Java语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注，至于到底做何种处理由业务需求来决定。
例如： JUnit 框架中，标记了注解 @Test 的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。
1.2 自定义注解
自定义注解就是自己做一个注解来使用。
自定义注解的格式
示例代码
public class AnnotationDemo1 {
@MyBook(name="《精通JavaSE2》",authors = {"小明", "dlei"} , price = 199.5)
private AnnotationDemo(){
}
@MyBook(name="《精通JavaSE1》",authors = {"小明", "dlei"} , price = 199.5)
public static void main(String[] args) {
@MyBook(name="《精通JavaSE2》",authors = {"小明", "dlei"} , price = 199.5)
int age = 21;
}
}
// 自定义注解
@interface MyBook {
String name() ;
String[] authors();
double price();
}
注意：
- value 属性，如果只有一个 value 属性的情况下，使用 value 属性的时候可以省略 value 名称不写
- 但是如果有多个属性 , 且多个属性没有默认值，那么 value 名称是不能省略的。
1.3 元注解
元注解：注解注解的注解。
常见的元注解有两个：
@Target：约束自定义注解只能在哪些地方使用，可使用的值定义在ElementType枚举类中，常用值如下- TYPE ，类，接口
- FIELD, 成员变量
- METHOD, 成员方法
- PARAMETER, 方法参数
- CONSTRUCTOR, 构造器
- LOCAL_VARIABLE, 局部变量
@Retention：申明注解的生命周期，可使用的值定义在ElementType枚举类中，常用值如下- SOURCE：注解只作用在源码阶段，生成的字节码文件中不存在
- CLASS ： 注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值 .
- RUNTIME ：注解作用在源码阶段，字节码文件阶段，运行阶段（开发常用）
示例代码
自定义注解
@Target({ElementType.METHOD,ElementType.FIELD}) // 元注解，规定其只能注解方法和成员变量
@Retention(RetentionPolicy.RUNTIME) // 一直活着，在运行阶段这个注解也不消失
public @interface MyTest {
}
//@MyTest // 只能注解方法和成员变量
public class AnnotationDemo2 {
@MyTest
private String name;
@MyTest
public void test(){
}
public static void main(String[] args) {
}
}
1.4 注解解析
注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。
与注解解析相关的接口
- Annotation：注解的顶级接口，注解都是 Annotation 类型的对象
- AnnotatedElement：该接口定义了与注解解析相关的解析方法
所有的类成分 Class, Method , Field , Constructor ，都实现了 AnnotatedElement 接口他们都拥有解析注解的能力
解析注解的技巧
- 注解在哪个成分上，我们就先拿哪个成分对象。
- 比如注解作用成员方法，则要获得该成员方法对应的 Method 对象，再来拿上面的注解
- 比如注解作用在类上，则要该类的 Class 对象，再来拿上面的注解
- 比如注解作用在成员变量上，则要获得该成员变量对应的 Field 对象，再来拿上面的注解
需求：注解解析的案例
分析
- 定义注解 Book ，要求如下：
- 包含属性： String value() 书名
- 包含属性： double price() 价格，默认值为 100
- 包含属性： String[] authors() 多位作者
- 限制注解使用的位置：类和成员方法上
- 指定注解的有效范围： RUNTIME
- 定义 BookStore 类，在类和成员方法上使用 Book 注解
- 定义 AnnotationDemo 测试类获取 Book 注解上的数据
示例代码
注解 Book
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
String value();
double price() default 100;
String[] author();
}
BookStore 类 和 AnnotationDemo类
import org.junit.Test;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
目标：完成注解的解析
*/
public class AnnotationDemo {
@Test
public void parseClass(){
// a.先得到类对象
Class c = BookStore.class;
// b.判断这个类上面是否存在这个注解
if(c.isAnnotationPresent(Book.class)){
//c.直接获取该注解对象
Bookk book = (Book) c.getDeclaredAnnotation(Book.class);
System.out.println(book.value());
System.out.println(book.price());
System.out.println(Arrays.toString(book.author()));
}
}
@Test
public void parseMethod() throws NoSuchMethodException {
// a.先得到类对象
Class c = BookStore.class;
Method m = c.getDeclaredMethod("test");
// b.判断这个方法上面是否存在这个注解
if(m.isAnnotationPresent(Book.class)){
//c.直接获取该注解对象
Bookk book = (Book) m.getDeclaredAnnotation(Book.class);
System.out.println(book.value());
System.out.println(book.price());
System.out.println(Arrays.toString(book.author()));
}
}
}
@Book(value = "《情深深雨濛濛》", price = 99.9, author = {"琼瑶", "dlei"})
class BookStore{
@Book(value = "《三少爷的剑》", price = 399.9, author = {"古龙", "熊耀华"})
public void test(){
}
}
1.5 注解应用于 junit 框架
模拟 Junit 框架
需求：定义若干个方法，只要加了 MyTest 注解，就可以在启动时被触发执行
分析：
- 定义一个自定义注解 MyTest ，只能注解方法，存活范围是一直都在。
- 定义若干个方法，只要有
@MyTest注解的方法就能在启动时被触发执行，没有这个注解的方法不能执
行
示例代码
自定义注解 MyTest
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD,ElementType.FIELD}) // 元注解，规定其只能注解方法和成员变量
@Retention(RetentionPolicy.RUNTIME) // 一直活着，在运行阶段这个注解也不消失
public @interface MyTest {
}
测试类
import java.lang.reflect.Method;
public class AnnotationDemo {
public void test1(){
System.out.println("===test1===");
}
@MyTest
public void test2(){
System.out.println("===test2===");
}
@MyTest
public void test3(){
System.out.println("===test3===");
}
/**
启动菜单：有注解的才被调用。
*/
public static void main(String[] args) throws Exception {
AnnotationDemo t = new AnnotationDemo();
// a.获取类对象
Class c = AnnotationDemo.class;
// b.提取全部方法
Method[] methods = c.getDeclaredMethods();
// c.遍历方法，看是否有MyTest注解，有就跑它
for (Method method : methods) {
if(method.isAnnotationPresent(MyTest.class)){
// 跑它
method.invoke(t);
}
}
}
}
2 动态代理
2.1 问题引入
模拟企业业务功能开发，并完成每个功能的性能统计
需求：模拟某企业用户管理业务，需包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时。
分析
- 定义一个 UserService 表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。
- 定义一个实现类 UserServiceImpl 实现 UserService ，并完成相关功能，且统计每个功能的耗
时。 - 定义测试类，创建实现类对象，调用方法。
本案例存在哪些问题？
- 业务对象的的每个方法都要进行性能统计，存在大量重复的代码。
2.2 动态代理实现
代理就是被代理者没有能力或者不愿意去完成某件事情，需要找个人代替自己去完成这件事，动态代理就是用来对业务功能（方法）进行代理的。
关键步骤
- 必须有接口，实现类要实现接口（代理通常是基于接口实现的）。
- 创建一个实现类的对象，该对象为业务对象，紧接着为业务对象做一个代理对象。
示例代码
用户业务接口 UserService
/**
模拟用户业务功能
*/
public interface UserService {
String login(String loginName , String passWord) ;
void selectUsers();
boolean deleteUsers();
void updateUsers();
}
实现类 UserServiceImpl
public class UserServiceImpl implements UserService{
@Override
public String login(String loginName, String passWord) {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
if("admin".equals(loginName) && "1234".equals(passWord)) {
return "success";
}
return "登录名和密码可能有毛病";
}
@Override
public void selectUsers() {
System.out.println("查询了100个用户数据！");
try {
Thread.sleep(2000);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public boolean deleteUsers() {
try {
System.out.println("删除100个用户数据！");
Thread.sleep(500);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
@Override
public void updateUsers() {
try {
System.out.println("修改100个用户数据！");
Thread.sleep(2500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
代理
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
参数一：类加载器，负责加载代理类到内存中使用。
参数二：获取被代理对象实现的全部接口。代理要为全部接口的全部方法进行代理
参数三：代理的核心处理逻辑
*/
public class ProxyUtil {
/**
生成业务对象的代理对象。
* @param obj
* @return
*/
public static <T> T getProxy(T obj) {
// 返回了一个代理对象了
return (T)Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 参数一：代理对象本身。一般不管
// 参数二：正在被代理的方法
// 参数三：被代理方法，应该传入的参数
long startTimer = System .currentTimeMillis();
// 马上触发方法的真正执行。(触发真正的业务功能)
Object result = method.invoke(obj, args);
long endTimer = System.currentTimeMillis();
System.out.println(method.getName() + "方法耗时：" + (endTimer - startTimer) / 1000.0 + "s");
// 把业务功能方法执行的结果返回给调用者
return result;
}
});
}
}
测试类
public class Test {
public static void main(String[] args) {
// 1、把业务对象，直接做成一个代理对象返回，代理对象的类型也是 UserService类型
UserService userService = ProxyUtil.getProxy(new UserServiceImpl());
System.out.println(userService.login("admin", "1234"));
System.out.println(userService.deleteUsers());
userService.selectUsers();
userService.updateUsers(); // 走代理
}
}
动态代理的优点
- 非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接本身做代理。
- 可以为被代理对象的所有方法做代理。
- 可以在不改变方法源码的情况下，实现对方法功能的增强。
- 不仅简化了编程工作、提高了软件系统的可扩展性，同时也提高了开发效率。
