CodeVault文档站
  • 后端
  • Java
  • 进阶
Yyzop
2022-06-27
目录

Java的注解和动态代理

# 注解和动态代理

# 1.注解

# 1.1注解的概述

Java 注解（Annotation）又称 Java 标注，是 JDK5.0 引入的一种注释机制。

Java 语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。

public class UserServiceTest {
    @Test  -----------------------》 注解（Annotation）
    public void testLogin(){
    }    
    @Test  -----------------------》 注解（Annotation）
    public void testChu(){
    }
}

注解的作用是什么呢？

对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定。

例如：JUnit框架中，标记了注解@Test的方法就可以被当成测试方法执行，而没有标记的就不能当成测试方法执行。

# 1.2自定义注解

格式

自定义注解就是自己做一个注解来使用。

public @interface 注解名称 {
    public 属性类型 属性名() default 默认值 ;
}

特殊属性

  • value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写!!
  • 但是如果有多个属性, 且多个属性没有默认值，那么value名称是不能省略的。
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyBook {
    String value();
    String name();
    String[] authors();
    double price() default 100;
}

class test1 {
    @MyBook(value = "test",name = "user",authors = {"pass1","pass2"},price = 9.9)
    public static void main(String[] args) {

    }
    @MyBook(value = "test",name = "user",authors = {"pass1","pass2"},price = 9.9)
    public test1(){

    }
}

# 1.3元注解

元注解：注解注解的注解。

元注解有两个：

  • @Target : 约束自定义注解只能在哪些地方使用，
  • @Retention ：申明注解的生命周期

@Target中可使用的值定义在ElementType枚举类中，常用值如下

  • TYPE，类，接口
  • FIELD, 成员变量
  • METHOD, 成员方法
  • PARAMETER, 方法参数
  • CONSTRUCTOR, 构造器
  • LOCAL_VARIABLE, 局部变量

@Retention中可使用的值定义在RetentionPolicy枚举类中，常用值如下

  • SOURCE： 注解只作用在源码阶段，生成的字节码文件中不存在
  • CLASS： 注解作用在源码阶段，字节码文件阶段，运行阶段不存在，默认值.
  • RUNTIME：注解作用在源码阶段，字节码文件阶段，运行阶段（开发常用）
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
    String value();
}

# 1.4注解的解析

注解的操作中经常需要进行解析，注解的解析就是判断是否存在注解，存在注解就解析出内容。

与注解解析相关的接口

  • Annotation: 注解的顶级接口，注解都是Annotation类型的对象
  • AnnotatedElement:该接口定义了与注解解析相关的解析方法

image-20220626232448815

所有的类成分Class, Method , Field , Constructor，都实现了AnnotatedElement接口他们都拥有解析注解的能力.

解析注解的技巧

注解在哪个成分上，我们就先拿哪个成分对象。

  • 比如注解作用成员方法，则要获得该成员方法对应的Method对象，再来拿上面的注解
  • 比如注解作用在类上，则要该类的Class对象，再来拿上面的注解
  • 比如注解作用在成员变量上，则要获得该成员变量对应的Field对象，再来拿上面的注解

需求：注解解析的案例

分析

①定义注解Book，要求如下： - 包含属性：String value() 书名 - 包含属性：double price() 价格，默认值为 100 - 包含属性：String[] authors() 多位作者 - 限制注解使用的位置：类和成员方法上 - 指定注解的有效范围：RUNTIME

②定义BookStore类，在类和成员方法上使用Book注解

定义AnnotationDemo01测试类获取Book注解上的数据

package com.example.d1_junit.demo4;

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

// 定义元注解Target
@Target({ElementType.TYPE,ElementType.METHOD})
// 定义元注解Retention
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
    String value();
    double price() default 100;
    String[] authors();
}

创建BookStore的类

package com.example.d1_junit.demo4;

@Book(value = "《情深深雨蒙蒙》",price = 99.9,authors = {"张三","李四"})
public class BookStore {

    @Book(value = "《三少爷的剑》",price = 99.9,authors = {"古龙","李四"})
    public void test(){

    }
}

创建AnnotationDemo01测试类

package com.example.d1_junit.demo4;

import org.junit.Test;

import java.lang.reflect.Method;
import java.util.Arrays;

public class AnnotationDemo {
    @Test
    public void parseClass() {
        // 先得到类对象
        Class c = BookStore.class;
        // 判断这个类上面是否存在这个注解
        if (c.isAnnotationPresent(Book.class)){
            // 直接获取该注解对象
            Book book = (Book) c.getDeclaredAnnotation(Book.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.authors()));
        }
    }
    @Test
    public void parseMethod() throws Exception{
        // 先得到类对象
        Class c = BookStore.class;
        Method m = c.getDeclaredMethod("test");
        // 判断这个类上面是否存在这个注解
        if (m.isAnnotationPresent(Book.class)){
            // 直接获取该注解对象
            Book book = (Book) m.getDeclaredAnnotation(Book.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.authors()));
        }
    }
}

运行结果：

《情深深雨蒙蒙》
99.9
[张三, 李四]
《三少爷的剑》
99.9
[古龙, 李四]

# 1.5模拟Junit框架

需求

定义若干个方法，只要加了MyTest注解，就可以在启动时被触发执行

分析

①定义一个自定义注解MyTest，只能注解方法，存活范围是一直都在。

②定义若干个方法，只要有@MyTest注解的方法就能在启动时被触发执行，没有这个注解的方法不能执行。

package com.example.d1_junit.demo4;

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

定义一个测试类，用来测试跑注解

package com.example.d1_junit.demo4;

import java.lang.reflect.Method;

public class AnnotationDemo1 {
    @MyTest
    public void test1(){
        System.out.println("===test1===");
    }

    public void test2(){
        System.out.println("===test2===");
    }

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

    public static void main(String[] args) throws Exception {
        AnnotationDemo1 t = new AnnotationDemo1();
        // 获取类
        Class c = AnnotationDemo1.class;
        // 提取全部方法
        Method[] m = c.getDeclaredMethods();
        // 遍历方法，查看是否有MyTest注解，有就跑它
        for (Method method : m) {
            if (method.isAnnotationPresent(MyTest.class)){
                // 跑它
                method.invoke(t);

            }
        }
    }
}

运行结果：

===test1===
===test3===

# 2动态代理

代理就是被代理者没有能力或者不愿意去完成某件事情，需要找个人代替自己去完成这件事，动态代理就是用来对业务功能（方法）进行代理的。

# 2.1关键步骤

1.必须有接口，实现类要实现接口（代理通常是基于接口实现的）。

3.创建一个实现类的对象，该对象为业务对象，紧接着为业务对象做一个代理对象。

image-20220627004314966

# 2.2动态代理的优点

  • 非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接本身做代理。
  • 可以为被代理对象的所有方法做代理。
  • 可以在不改变方法源码的情况下，实现对方法功能的增强。
  • 不仅简化了编程工作、提高了软件系统的可扩展性，同时也提高了开发效率。

# 2.3案例实施

需求

模拟某企业用户管理业务，需包含用户登录，用户删除，用户查询功能，并要统计每个功能的耗时。

分析

①定义一个UserService表示用户业务接口，规定必须完成用户登录，用户删除，用户查询功能。

②定义一个实现类UserServiceImpl实现UserService，并完成相关功能，且统计每个功能的耗时。

③定义测试类，创建实现类对象，调用方法。

创建接口：

package com.example.d1_junit.demo5;

public interface UserService {
    String login(String loginName,String loginpass);
    void selectUsers();
    boolean deleteUsers();
}

创建实现类UserServiceImpl和测试类

package com.example.d1_junit.demo5;


import com.sun.deploy.net.proxy.ProxyUtils;

public class UserServiceLmpl implements UserService{

    @Override
    public String login(String loginName, String loginpass) {
        try {
            Thread.sleep(1000);
            if ("admin".equals(loginName) && "1234".equals(loginpass)){
                return "success";
            }
            return "登录用户或者密码有问题";
        }catch (Exception e) {
            e.printStackTrace();
            return "error";
        }
    }

    @Override
    public void selectUsers() {
        System.out.println("查询了100个用户数据！");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    @Override
    public boolean deleteUsers() {
        try {
            System.out.println("删除了100个用户");
            Thread.sleep(500);
            return true;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return false;
        }
    }

    public static void main(String[] args) {
        // 1.把业务对象，直接做成一个代理对象返回，代理对象的类型也是 UserService类型
        UserService userService = ProxyUtil.getProxy(new UserServiceLmpl());
        System.out.println(userService.login("admin","1234"));
        System.out.println(userService.deleteUsers());
        userService.selectUsers();
    }
}

创建动态代理：

package com.example.d1_junit.demo5;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
    public static Object newProxyInstance(Classloader loader, Class<?>[] interface,InvocationHandler h)
    参数一: 类加载器，负责加载代理类到内存中使用。
    参数二: 获取被代理对象实现的全部接口。代理要为全部接口的全部方法进行代理。
    参数三: 代理的核心处理逻辑
*/

public class ProxyUtil {

    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 startTime = System.currentTimeMillis();

                        // 马上触发方法的真正执行 (触发真正的业务功能)
                        Object result = method.invoke(obj,args);
                        long endtTime = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法耗时：" + (endtTime - startTime) / 1000.0 + "s");

                        // 把业务功能方法执行的结果返回给调用者
                        return result;
                    }
                });
    }
}

测试类的运行结果：

login方法耗时：1.011s
success
删除了100个用户
deleteUsers方法耗时：0.508s
true
查询了100个用户数据！
selectUsers方法耗时：2.007s
上次更新: 2023/11/28, 22:03:59
Java的单元测试和反射
Java的XML和设计模式

← Java的XML和设计模式→

最近更新
01
学习文档
11-28
02
如何成为FISCO社区的MVP 总结篇
11-28
03
一文搞懂Truffle测试
11-28
更多文章>
Theme by Vdoing | Copyright © 2023-2023 YYzop & Hior | MIT License