Java学习-注解、动态代理

在乎且叭叭

已于 2022-09-05 17:48:09 修改

阅读量434

点赞数

分类专栏： Java 文章标签： java 学习开发语言

于 2022-09-01 16:27:56 首次发布

本文链接：https://blog.csdn.net/weixin_46051964/article/details/126630699

版权

Java 专栏收录该内容

36 篇文章 2 订阅

订阅专栏

1 注解

1.1 元注解

@Target中可使用的值定义在ElementType枚举类中，常用值如下
TYPE,类,接口
FIELD,成员变量
METHOD,成员方法
PARAMETER,方法参数
CONSTRUCTOR,构造器
LOCAL_ VARIABLE, 局部变量

@Retention中可使用的值定义在RetentionPolicy枚举类中，常用值如下
SOURCE:注解只作用在源码阶段,生成的字节码文件中不存在
CLASS: 注解作用在源码阶段,字节码文件阶段,运行阶段不存在，默认值.
RUNTIME:注解作用在源码阶段,字节码文件阶段，运行阶段(开发常用)

1.2 注解的解析

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

与注解解析相关的接口

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

Annotation[] getDeclaredAnnotations()获得当前对象上使用的所有注解，返回注解数组。
T getDeclaredAnnotation(Class<T> annotationClass)根据注解类型获得对应注解对象
boolean isAnnotationPresent(Class < Annotation> annotationClass)判断当前对象是否使用了指定的注解，如果使用了则返回true,否则false

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

解析注解的技巧
●注解在哪个成分上，我们就先拿哪个成分对象。
●比如注解作用成员方法，则要获得该成员方法对应的Method对象,再来拿上面的注解
●比如注解作用在类. 上,则要该类的Class对象，再来拿上面的注解
●比如注解作用在成员变量. 上，则要获得该成员变量对应的Field对象，再来拿_上面的注解

案例：

需求:注解解析的案例
分析
①定义注解Book,要求如下:
-包含属性: String value()书名
-包含属性: double price() 价格，默认值为100
-包含属性: String[] authors()多位作者
-限制注解使用的位置:类和成员方法上
指定注解的有效范围: RUNTIME
②定义BookStore类,在类和成员方法上使用Book注解
③定义AnnotationDemo01 测试类获取Book注解.上的数据

演示：

注解：

package com.zwit.d7_annotation;

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[] authors();

}

在类和方法上使用注解

package com.zwit.d7_annotation;

@Book(value = "《三体》",price = 189,authors = {"刘慈欣"})
public class BookStor {
    @Book(value = "《小王子》",price = 58,authors = "布吉岛")
    public void test(){
    }
}

测试获取注解

package com.zwit.d7_annotation;

import org.junit.Test;

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

public class AnnotationDemo01 {
    @Test
    public void parseClass(){
        //a.先得到类对象
        Class c = BookStor.class;
        //b.判断这个类是否存在该注解
        if (c.isAnnotationPresent(Book.class)){
            //c.直接获取该注解对象
            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{
        //a.先得到类对象
        Class c = BookStor.class;
        //拿到方法对象
        Method test = c.getDeclaredMethod("test");
        //b.判断这个类是否存在该注解
        if (test.isAnnotationPresent(Book.class)){
            //c.直接获取该注解对象
            Book book = (Book)test.getDeclaredAnnotation(Book.class);
            System.out.println(book.value());
            System.out.println(book.price());
            System.out.println(Arrays.toString(book.authors()));
        }
    }
}

1.3 注解应用

模拟Junit框架

需求

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

分析
①定义一个自定义注解MyTest，只能注解方法,存活范围是一直都在。
②定义若干个方法，只要有@MyTest注解的方法就能在启动时被触发执行,没有这个注解的方法不能执行。

MyTest注解：

package com.zwit.d7_annotation;

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

测试：

package com.zwit.d7_annotation;

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

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

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

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

    public static void main(String[] args) throws Exception {
        AnnotationDemo02 a = new AnnotationDemo02();
        //获取类对象
        Class c = AnnotationDemo02.class;
        //获取所有方法对象
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(MyTest.class)){
                method.invoke(a);
            }
        }
    }
}

1.4 注解的用处（老杜）

案例：自定义一个注解@Id，要求用在类上面，可以使用反射机制，要求此类中必须有一个int age属性，否则报异常。

自定义注解：

package com.zwit.r3_annotation;

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Id {


}

使用注解：

package com.zwit.r3_annotation;

@Id()
public class MyClass {
    int age;
    String name;
    char sex;
}

自定义异常：

package com.zwit.r3_annotation;

/**
 * 自定义异常
 */
public class HasNotIdPropertyException extends RuntimeException{
    public HasNotIdPropertyException(){

    }

    public HasNotIdPropertyException(String s){
        super(s);
    }
}

测试：

package com.zwit.r3_annotation;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("com.zwit.r3_annotation.MyClass");


        if (c.isAnnotationPresent(Id.class)){
            boolean isOk = false;
            //如果使用了@Id注解，判断此类中的属性是否有int age
            //获取属性
            Field[] fields = c.getDeclaredFields();
            for (Field field : fields) {
                if (field.getName().equals("age") && field.getType().getSimpleName().equals("int")){
                    //说明有int age
                    isOk = true;//表示合法
                    break;
                }
            }
            //判断是否合法
            if (!isOk){
                throw new HasNotIdPropertyException("被@Id标注的类必须有一个int类型的age属性");
            }
        }


    }
}

2 动态代理

2.1 概述

什么是代理?
代理指:某些场景下对象会找-一个代理对象，来辅助自己完成一些工作，如:歌星(经济人)，买房的人(房产中介)。
代理主要干什么，他是如何工作的?
代理主要是对对象的行为额外做一些辅助操作。

如何创建代理对象
●Java中代理的代表类是: java.lang.reflect.Proxy 。
●Proxy提供了一个静态方法，用于为对象产生一个代理对象返回。

接口：

package com.zwit.proxy;

public interface Skill {
    void sing();//唱
    void dance();//跳
}

类：

package com.zwit.proxy;

public class Star implements Skill{
    String name;

    public Star(String name) {
        this.name = name;
    }

    @Override
    public void sing() {
        System.out.println(name + "在跳舞。。。");
    }

    @Override
    public void dance() {
        System.out.println(name + "在唱歌。。。");
    }
}

代理对象：

package com.zwit.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class StarAgentProxy {
    public static Skill getProxy(Object obj){
        //为杨超越这个对象生成一个代理对象
        /**
         public static Object newProxyInstance(ClassLoader loader,
                 Class<?>[] interfaces,
                 InvocationHandler h)
         */
        return (Skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("===收首付款===");
                        //method:正在调用的方法；args：方法中的参数
                        Object rs = method.invoke(obj,args);
                        System.out.println("===收尾款，接回杨超越===");
                        return rs;
                    }
                });
    }
}

测试：

package com.zwit.proxy;

public class Test {
    public static void main(String[] args) {
        //1.创建一个对象，必须实现接口
        Star s1 = new Star("杨超越");
        //s1.sing();
        //s1.dance();

        Skill s2 = StarAgentProxy.getProxy(s1);
        s2.sing();
        s2.dance();
    }
}

2.2 案例

模拟企业业务功能开发，并完成每个功能的性能统计
需求
●模拟某企业用户管理业务,需包含用户登录,用户删除，用户查询功能，并要统计每个功能的耗时。
分析
①定义一个UserService表示用户业务接口, 规定必须完成用户登录,用户删除，用户查询功能。
②定义一个实现类UserServicelmpl实现UserService, 并完成相关功能，且统计每个功能的耗时。
③定义测试类,创建实现类对象,调用方法。

接口：

package com.zwit.d9_proxy2;

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

方法重写：

package com.zwit.d9_proxy2;

public class UserServiceImpl implements UserService{
    @Override
    public String login(String loginName, String password) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String s = "用户名或密码错误，请重新输入";
        if ("admin".equals(loginName) && "123456".equals(password)){
            return "登陆成功！";
        }
        return s;
    }

    @Override
    public void deleteUsers() {
        System.out.println("删除了1000个用户");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String selectUsers() {
        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String s = "查询了10000个数据";
        return s;
    }
}

接口代理：

package com.zwit.d9_proxy2;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil {
    public static UserService getProxy(UserService obj){
        return (UserService) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        long start = System.currentTimeMillis();
                        Object rs = method.invoke(obj, args);
                        long end = System.currentTimeMillis();
                        System.out.println(method.getName() + "方法用时:" + (end - start)/1000.0 + "s");
                        return rs;
                    }
                });
    }
}

测试：

package com.zwit.d9_proxy2;

public class Test {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        /*System.out.println(userService.login("admin", "123456"));
        System.out.println(userService.selectUsers());
        userService.deleteUsers();*/

        UserService u = ProxyUtil.getProxy(userService);
        System.out.println(u.login("admin", "123456"));
        System.out.println(u.selectUsers());
        u.deleteUsers();
    }
}

动态代理的优点

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

在乎且叭叭

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java学习-注解、动态代理

什么是代理?代理指:某些场景下对象会找-一个代理对象，来辅助自己完成一些工作，如:歌星(经济人)，买房的人(房产中介)。代理主要干什么，他是如何工作的?代理主要是对对象的行为额外做一些辅助操作。如何创建代理对象●Java中代理的代表类是: java.lang.reflect.Proxy。●Proxy提供了一个静态方法，用于为对象产生一个代理对象返回。//唱//跳}}@OverrideSystem.out.println(name + "在跳舞。。。");}...
复制链接

扫一扫