注解与反射及注解处理器的简单编写实例应用

最新推荐文章于 2022-01-23 20:17:49 发布
最新推荐文章于 2022-01-23 20:17:49 发布
阅读量175 收藏 1
点赞数 1
分类专栏： 通用笔记 文章标签： java 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47234534/article/details/110919392
版权

文章目录

注解与反射

心得：注解与反射是真的真的非常重要，在框架中大量应用，其相互配合编写的**注解处理器**，功能异常强大。

理解反射个人觉得最重要的是理解Java类的加载过程，也就是笔记中二的4567点，知道底层怎么来的之后学习起来就很快了。

一、注解
1、基本概念
  • 从JDK5.0开始有的
  • Annotation不是程序本身，但可以对程序作出解释，和注解comment区别开。和注释不同，他可以被其它程序（如编译器）等读取
  • 可以通过反射获得注解内容
  • 基本格式：@注解名(参数)
  • 作用范围：类、方法、变量、参数和包等
2、内置注解

内置注解一共有7个，可以根据包的位置分为两类

java.lang包下的注解

  1. @Override 检查方法是否为重写方法。
  2. @Deprecated 标记过时的方法
  3. @SuppressWarnings 抑制警告

java.lang.annotaion包下的注解

也称为元注解（meta-annotation)，是作用在其它注解的注解

  1. @Target 说明被标记的注解是应用于何处的注解，即说明其它注解的作用范围。不加默认是所有都生效
  2. @Retention（英文原意：保留） 说明被标记的注解保留程度，是在代码SOURCE中，还是在CLASS文件中，或者运行时RUNTIME。不加默认为ClASS
  3. @Documented 说明被标记的注解是否可以包含是用户文档doc中
  4. @Inherited 说明被标记的注解如果应用在父类中，子类也可以使用，即具有继承性

Java7之后加的注解

  1. @SafeVarargs 7开始，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告
  2. @FunctionalInterface 8开始，标识一个匿名函数或函数式接口。
  3. @Repeatable 8开始，标识某注解可以在同一个声明上使用多次。
3、自定义注解
/**用@interface自定义注解，会自动继承java.lang.annotation.Annotation接口，
使其成为一个注解接口
用反射可知，注解本质是一个接口类型
**/
public @interface 注解名 {
    /*
    每一个方法实际上是声明了一个配置参数
    方法的名称为参数的名称
    返回类型是参数的类型，返回类型只能是 《基本类型、Class、String、enum以及Annotation,还有它们的数组》
    */
    String[] values();//即类型 + 参数名 + （）
    int age default 3;//可以用default设置默认值。经常用0和空字符串来默认定义。
                      //如果有参数，而参数又没有默认值，则在使用注解的时候，一定要传入参数
}
二、反射
1、反射概述

  1. 反射是一种计算机处理方式，是提供封装程序集、模块和类型的对象。有程序可以访问、检测和修改它本身状态或行为的这种能力。能提供封装程序集、类型的对象（程序集包含模块，而模块包含类型，类型又包含成员）。

    简记:反射是分析类的一种能力

  2. Java是运行时结构不可变的，是静态语言。

  3. Java不是动态语言，但可以称为“准动态”语言，即Java有一定的动态性。可以通过反射获得类似动态语言的特性，使Java更加灵活。

  4. 是一种解释操作，会使程序性能降低

  5. 正常方式：引入需要的“包类”名称》通过new实例化》取得实例化对象

    反射方式：已有实例化对象》得到Class对象》取到完整的“包类”名称

2、获得反射对象

所有类的实例对象，获得的类对象全都是同一个对象。

即一个类在内存中只有一个Class对象，是一个模板。

一个类被加载后，类的整个结构都会被封闭在Class对象中.

要得到父类类型，要通过子类的Class对象获得，不能直接由子类直接获得。

/**方法一
用Class对象的静态方法得到**/
Class.forName("完全限定名，如java.lang.String");

/**方法二
用实例化对象的getClass（）方法**/
实例对象.getClass();//继承自Object

/**方法三 最推荐，安全可靠，性能高
直接从类名 + class获得**/
类名.class;//继承于Object

/**方法四
基本包装类型有TYPE属性**/
Integer.TYPE
3、类型的Class对象
        Class c1 = User.class;//普通对象类型
        Class c2 = Comparable.class;//接口类型
        Class c3 = Target.class;//注解类型，本质是接口类型
        Class c4 = RetentionPolicy.class;//枚举类型,本质是对象类型

        Class c5 = int.class;//基本数据类型
        Class c6 = Integer.class;//基本数据包装类型,本质是对象类型
        Class c7 = void.class;//空类型
        Class c8 = int[].class;//一维数组,本质是对象类型
        Class c9 = int[][].class;//二维数组,本质是对象类型
        //相同类型下，如果是同维的数组，则长度无关，Class是相同的；如果是不同维的，则Class是不同的
===============================================
输出如下：
class User
interface java.lang.Comparable
interface java.lang.annotation.Target
class java.lang.annotation.RetentionPolicy
int
class java.lang.Integer
void
class [I
class [[I
4、Java内存分析
  1. 栈：
    • 存放基本数据类型（会包括基本类型的具体数值）
    • 存放对象引用
  2. 堆：
    • 存放new的对象和数组（本质是对象），即存放实体
    • 可以被所有的线程共享，不会存放别的对象的引用
  3. 方法区：
    • 是一个特殊堆（好像又说不是堆，具体以后分析）
    • 包含了所有的Class和static变量
    • 可以被所有的线程共享
5、类加载过程

推荐书籍：《深入理解Java虚拟机》

分为三个过程：

  1. 加载(Load)：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象
  2. 链接(Link)：将Java类的二进制代码合并到JVM的运行状态之中的过程，分为三步
    • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
    • 准备：正式为类变量（static)分配内存，并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配 （跟实际代码相关，其它两个跟虚拟机相关）
    • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
  3. 初始化(Initialize)：JVM负责对类进行初始化
    • 执行类构造器 clinit() 方法的过程。类构造器 clinit() 方法是由编译时期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
    • 当初始化一个类的时候，如果发现父类还没有进行初始化，则需要先触发其父类的初始化
    • 虚拟机会保证一个类的 clinit() 方法在多线程环境中被正确加锁和同步
6、类初始化

类的主动引用：

一定会发生类的初始化

  • 当虚拟机启动，先初始化main方法所在类
  • new一个类的对象
  • 调用类的静态成员（除了final常量）和静态方法
  • 反射调用时。Class.forName会，但 类.class 不会，初始化被延迟到了对静态方法或者是非常数静态域进行首次引用时才执行。
  • 当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类

类的被动引用：

不会发生类的初始化

  • 当访问一个静态域，只有真正声明这个域的类才会被初始化。如：当通过子类名引用父类的静态变量，不会慌到子类的初始化
  • 通过数组定义类的引用。如User[] userList = new User[5]; 原因是，这只是声明了User类型的数组，并开辟了内存空间（在栈中），没有具体的值。
  • 引用常量不会触发类的初始化（常量在链接阶段就存放调用类的常量池中了）
7、类加载器

基本概念

  • 类加载器的作用是用来把类装载进内存的。
  • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
  • 自底向上检查类是否已经被加载（双亲委派机制），自顶向下尝试加载类。

类加载器分类

一共有四种类型的类加载器，自下而上权限增大

  • BootstrapClassLoader引导类加载器 用c++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。
  • Extension ClassLoader扩展类加载器 负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
  • System(Application) Classloader系统类加载器 负责Java -classpath 或 -D java.class.path 所指的目录下的类与jar包装入工作，是最常用的加载器
  • 自定义类加载器
/**逐层获取类加载器：通过ClassLoader类的静态方法**/
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
ClassLoader extensionClassLoader = systemClassLoader.getParent();
ClassLoader bootStrapClassLoader = extensionClassLoader.getParent();
System.out.println(systemClassLoader);
System.out.println(extensionClassLoader);
System.out.println(bootStrapClassLoader);
/**输出如下：
sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@45ee12a7
null  --说明是引导加载器加载的
**/

/***********************************************************************************/
/**得到具体类的类加载器：通过Class对象的getClassLoader()方法得到**/
System.out.println(User.class.getClassLoader());
System.out.println(Class.forName("java.lang.String").getClassLoader());
/**输出如下：
sun.misc.Launcher$AppClassLoader@18b4aac2
null   --说明是引导加载器加载的
**/

/***********************************************************************************/
/**得到系统可以加载类的路径**/
System.out.println(System.getProperty("java.class.path"));
/**输出如下：
        /*C:\Program Files\Java\jdk1.8.0_181\jre\lib\charsets.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\deploy.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\cldrdata.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\dnsns.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jaccess.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jfxrt.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\localedata.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\mysql-connector-java-5.1.40-bin.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\nashorn.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\servlet-api.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunec.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\zipfs.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\javaws.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\jce.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfr.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfxswt.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\jsse.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\management-agent.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\plugin.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\resources.jar;
        C:\Program Files\Java\jdk1.8.0_181\jre\lib\rt.jar;
        C:\Users\aj\IdeaProjects\JavaSE\out\production\JavaSE;
        C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.1\lib\idea_rt.jar
        **/
8、获得类的运行结构

Class c1 = Class.forName(“com.hao.User”);

获得类名

c1.getName();//得到完全限定名
c1.getSimpleName();//只得到类名

获得字段

Field[] fields = c1.getDeclaredFields();//得到所有声明的字段
Field[] fields = c1.getFields();//得到public修饰的字段
c1.getDeclaredField("name");//指定名字
c1.getField("name");

获得构造器

c1.getConstructors();//得到所有public构造器
c1.getDeclaredConstructors();//得到所有构造器
//传入参数是因为有重载的存在
c1.getConstructor(String.class, int.class);//得到指定的public构造器
c1.getDeclaredConstructor(String.class, int.class);//得到指定的构造器

获得方法

c1.getMethods();//得到本类及父类，父父类直到Object的所有public方法
c1.getDecleardMethods();//得到本类所有方法
//传入参数为方法名（构造方法因为与类名一样，所以不用该参数）
//还有方法的形参，因为重载
//如果没有参数，则传入null
c1.getMethod("setName", String.class);
c1.getDecleardMethod("setName", String.class);

除了获得所有公有方法的操作外，其它都不涉及到父类。

9、反射调用

创建对象

/**方法一:
（1）类必须有一个无参数构造器
（2）类的构造器的权限要足够
否则，要用构造器反射来创建对象
**/
c1.newInstance();
/**方法二**/
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
User user = constructor.newInstance("你好", 123);
/**constructor.setAccessible(true);如果是私有的**/

操作字段

Field name = c1.getDeclaredField("name");
name.setAccessible(true);//如果是私有的
//设置方法，参数是 具体对象 + 设置的值
name.set(user, "我是");
//访问器方法，返回类型是Object类型，可以强转
name.get(user);

操作方法

Method getName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user, "名字");//返回类型为Object，可以强制转换为方法的实际类型

权限访问

  1. Method、Field和Constructor对象都有setAccessible()方法
  2. 作用是启动和禁用安全检查的开关,true为允许执行访问
  3. 设置为true可以提高反射的效率，如果代码要频繁使用。
10、操作泛型
三、双剑合一

利用反射，可以编写**注解处理器。**

基本方法

所有注解能标注的对象，都有相应的得到注解的方法。这里只举例类获得对象的方法。

        c1.getAnnotation(MyValidation.class);
        c1.getDeclaredAnnotation(MyValidation.class);
        c1.getAnnotations();
        c1.getDeclaredAnnotations();
//判断是否存在这样一个注解
field.isAnnotationPresent(FieleAnnotation.class);
实例一：表单验证

对前端送来的用户对象进行验证（只是示例用法）

自定义注解

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyValidation {
    int maxSize();
    int minSize();
    String tips() default "格式不正确";
}

加了注解的用户类

class User {
    @MyValidation(maxSize = 10, minSize = 6, tips = "账号名要在6到10位之间")
    private String name;
    @MyValidation(maxSize = 8, minSize = 8, tips = "密码只能是8位")
    private String password;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

测试

public class TestMain3{
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        User user = new User();
        user.setName("beautiful");
        user.setPassword("12345");
        //假设前端送来这么一个User对象

        Class c1 = user.getClass();
        Field[] fields = c1.getDeclaredFields();//拿到所有字段
        for (Field field : fields) {
            field.setAccessible(true);
            MyValidation myValidation = field.getAnnotation(MyValidation.class);//拿到所有字段的MyValidation注解
            String value = (String)field.get(user);//拿到值
            if (value.length() > myValidation.maxSize() || value.length() < myValidation.minSize()) {//判断长度
                System.out.println(myValidation.tips());//给出提示信息
            }
        }
    }
}

结果

密码只能是8位

Process finished with exit code 0
实例二：ORM

ORM: Object relationship Mapping 对象关系映射，即对象与数据库表记录进行映射

假设数据库有一个table_user表，用于存放用户信息，其中有栏目name和password，现在可以通过程序自动把用户对象信息填入对应表对应栏目中。

自定义注解

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface TableAnnotaion {
        String value();//值代表数据库的表名
    }

    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @interface FieleAnnotation {
        String column();//字段要对应的数据库表中的栏目
        String type();//栏目的类型
    }

用了注解的用户类

    @TableAnnotaion("table_user")
    class User {
        @FieleAnnotation(column = "name", type = "varchar")
        private String name;
        @FieleAnnotation(column = "password", type = "varchar")
        private String password;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }
    }

测试

public class TestMain3 {
    public static void main(String[] args) throws IllegalAccessException {
        User user = new User();
        user.setName("beautiful");
        user.setPassword("12345");
        //假设前端送来这么一个User对象,要将其写入数据库

        Class<? extends User> c1 = user.getClass();
        TableAnnotaion tableAnnotaion = c1.getAnnotation(TableAnnotaion.class);
        String tableName = tableAnnotaion.value();//从类注解中拿到类对应的表名
        Field[] fields = c1.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            String fieldValue = (String)field.get(user);//拿到字段值
            FieleAnnotation fieldAnnotation = field.getAnnotation(FieleAnnotation.class);
            String column = fieldAnnotation.column();//从字段注解中拿到数据库栏目
            String type = fieldAnnotation.type();//从字段注解中拿到数据库栏目类型
            System.out.println(c1.getSimpleName() + "对象的" + field.getName() + "字段,值为" + fieldValue + "要写入表" + tableName + "中的" + column + "栏目" + "类型为" + type );
        }
    }
}

输出

User对象的name字段,值为beautiful要写入表table_user中的name栏目类型为varchar
User对象的password字段,值为12345要写入表table_user中的password栏目类型为varchar
Meow_Sir
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 自定义注解及处理器的实现
Programming Talk
06-09 186
注解是一种用于提供元数据的机制，可以用于类、方法、字段、参数等。注解本身不会影响程序的执行，但可以通过反射等机制在运行时获取注解信息，从而实现一些特殊功能。在Java中定义自定义注解非常简单，只需要使用@interface关键字。Retention;Target;在这个示例中，我们在myMethod方法上使用了自定义注解，并为其元素赋值。同时，在方法上使用了默认值的注解。
Retrofit中的注解反射与动态代理
soulli的专栏
03-07 627
注解的应用场景 1.源码：APT注解处理器 Annotatino Processing Tool, 作用是处理代码中的注解, 用来生成代码, 用代码生成代码的工具。 2.字节码：字节码增强 打开运行时JVM的钥匙，动态代理 、AOP也与字节码增强有关。 3.运行时：反射 是java被视为动态语言的关键 ...
Java反射
m0_46308149的博客
12-04 133
反射 静态语言和动态语言 **动态语言：**是一类在运行时可以改变其结构的语言：例如新的函数、对象】甚至代码可以被引进，一有的函数可以被删除或是其他结构上的变换。通俗点说就是在运行时代码可以根据某些条件改变自身结构。 主要动态语言：C#、JavaScript、PHP、Python等。 **静态语言：**与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。 Java不是动态语言，但Java可以称之为“准动态语言”。即Java具有一定的动态性，我们可以利用反射机制获得类似动态语言的特
Java-反射、注解、注解处理器
吴唐人的博客
07-14 255
目录1. 反射1. 对象获取的方法2. 常用API2. 注解3. 注解处理器 1. 反射 Java反射机制是在运行状态中对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，能够调用它的任意方法和属性，从对象出发，通过反射（Class类）可以取得类的完整信息。简单说就是在运行过程中获得类、对象、方法的所有信息 1. 对象获取的方法 通过对象获取obj.getClass() 通过完整类路径获取Class.fromName("com.java.String") 通过类名获取Object.clas
注解（2）：编写注解处理器
游王子的博客
05-06 305
如果没有用来读取注解的工具，那注解也不会比注释更有用。使用注解过程中，很重要的一个部分就是创建与使用注解处理器。java SE5扩展了反射机制的API，以帮助程序员构造这类工具。同时，它还提供了一个外部工具apt帮助程序员解析带有注解的java源代码。 下面是一个非常简单的注解处理器，我们将用它来读取PasswordUtils类，并使用反射机制查找@UseCase标记。我们为其提...
android 注解创建对象,Android编译时注解框架系列2
weixin_39672194的博客
05-25 119
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？概述先讲一下编写《Android编译时注解框架》的初衷吧，APT其实并不难，可以说是简单且高效，但关于APT的资料却并不多，甚至很多人都不知道这么一个技术。国内关于APT的博客屈指可数，唯二找到的几篇初级讲解一个是用Eclipse写得，一个是用AndroidStudio加Intellij。刚开始着实踩了不少坑，但事实是，...
大数据之Linux(一):常用基本命令3
weixin_43597208的博客
05-03 422
1)、more 文件内容分屏查看器，多用于文本较大的文件 基本语法 more 要查看的文件 操作 功能说明 操作 功能说明 空白键 (space) 代表向下翻一页 Enter 代表向下翻『一行』 q 代表立刻离开 more ，不再显示该文件内容 案例实操 （1）采用more查看文件 [root@hadoop101 ~]# more smartd.conf 2）、less 分屏显示文件内容 less指令在显示文件内容时，并不是一次将整个文件加载之后才显示，而是根据显
注解和反射机制的学习笔记
03-05
例如，我们可以编写一个框架，该框架在运行时扫描带有特定注解的类，然后利用反射来动态实例化和操作这些类。这在Spring框架中广泛应用，其中的@Component、@Service、@Repository和@Controller等注解就是用于标记...
编程技能强化作业答案（JDBC+网络编程+注解+反射）.zip
06-15
- 自定义注解：创建自己的注解并编写处理器以执行特定逻辑。 4. **反射（Reflection）**： 反射是Java的一种强大的特性，允许程序在运行时检查类、接口、字段和方法的信息，并动态调用方法。反射的应用场景包括：...
反射，注解原理和使用的方法
01-17
- 自定义注解处理器可以利用反射来动态地创建对象、调用方法，实现灵活的代码生成和运行时行为控制。 理解并熟练掌握反射和注解，能帮助开发者编写出更加灵活、可扩展的代码。在实际项目中，合理运用这两个特性，...
计算机网络重点回顾
热门推荐
weixin_51261234的博客
12-11 14万+
计算机网络 一.计算机网络概述 计算机网络的概念：（*） 1.计算机网络的定义： ​ 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路链接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。 2.计算机网络的组成： 终端系统/资源子网：提供共享的软件资源和硬件资源 通信子网：提供信息交换的网络结点和通信线路。 3.计算机网络的类型： 按照拓朴分类： 星型结构 树形结构 总线型结构 环形结构 网状结构 按照范围分
Mybatis知识点详解及遇到问题解决方案，动态代理，注解与反射
weixin_51261234的博客
08-22 2864
1.Mybatis： 初见Mybatis： MyBatis简介 环境说明： jdk 8 + MySQL 5.7.19 maven-3.6.1 IDEA 学习前需要掌握： JDBC MySQL Java 基础 Maven Junit 什么是Mybatis： MyBatis 是一款优秀的持久层框架 MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程 MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 实体类 【Plain
计算机网络
weixin_44233888的博客
04-30 796
OSI七层模型的作用 应用层 FTP、DNS、Telnet、SMTP、HTTP、WWW、NFS 提供各种服务的 表示层 作用：数据格式化，代码转换，数据加密 没有协议 会话层 作用：建立、管理和终止连接 传输层： 提供端到端的可靠传输（差错和流量控制，保证报文的正确传输。）传输层的作用是向高层屏蔽下层数据通信的细节，即向用户透明地传送报文、 建立、维护/管理端到端的连接 TCP、UDP、IPX 网络层： 提供路由和寻址的功能，使两终端系统能够互连且决定最佳路径，并具有一定的拥塞控制和流量控
Java注解和注解处理器使用详解
jcpp9527的博客
08-19 3039
文章转自：http://www.race604.com/annotation-processing/ 在这篇文章中，我将阐述怎样写一个注解处理器(Annotation Processor)。在这篇教程中，首先，我将向您解释什么是注解器，你可以利用这个强大的工具做什么以及不能做什么；然后，我将一步一步实现一个简单的注解器。 一些基本概念 在开始之前，我们首先申明一个
java注解之注解处理器
惜阳
10-08 2928
摘要  Java5中提供了apt工具来进行编译期的注解处理。apt是命令行工具，与之配套的是一套描述“程序在编译时刻的静态结构”的API：Mirror API（com.sun.mirror.*）。通过Mirror API可以获取到被注解的Java类型元素的信息，从而提供自定义的处理逻辑。具体的处理工具交给apt来处理。编写注解处理器的核心是两个类：注解处理器（com.sun.mirror.apt....
Java注解（三）：自定义Java编译时注解处理器
lucyLee的博客
01-23 7091
1. 絮絮叨叨 要么是注解跟我有仇，要么是公司配发的笔记本跟我有仇，要么是因为心急吃不了热豆腐 痛定思痛：从头开始，新建一个Java项目，实现一个超级简单的注解@Hello 在 process()方法中简单打印 getSupportedSourceVersion()方法返回的结果 在此，记录一下如何定义一个简单的Java编译时注解处理器 1.1 AbstractProcessor 自定义Java编译时注解处理器，一般都是通过继承AbstractProcessor实现的 AbstractProcesso
Java注解解析-搭建自己的注解处理器（CLASS注解使用篇）
weixin_33858485的博客
09-05 519
写在前面 该文章是继Java注解解析-基础+运行时注解(RUNTIME)之后，使用注解处理器处理CLASS注解的文章。通过完整的Demo例子介绍整个注解处理器的搭建流程以及注意事项，你将知道如何去搭建自己的注解处理器。前提是你知道如何去写自定义注解，不清楚的可以点击我上面的链接哦～ 介绍 顾名思义注解处理器就是javac包中专门用来处理注解的工具。所有的注解处理器都必须继承抽象类Abstr...
Android 反射的一些重要方法
no_loafer的博客
04-22 613
一、反射是什么？ 反射是运行状态中我们可以通过反射获取到类的所有信息，包括构造方法、成员变量、属性、方法等，对其可以进行操作。 二、反射中的一些方法使用。 1.class getName(): 获取全类名，带包名 getSimpleName(): 获取类名 Class.forName("类名全路径")：返回类对象 getPackage(): 获取包名,有前缀package...
Java 注解 Annotation 详解
天行健，君子以自强不息；地势坤，君子以厚德载物。
08-28 1612
微服务设计：去中心化的技术治理与数据管理什么叫注解注解(Annotation)就是 Java 提供了一种元程序中的元素关联任何信息和着任何元数据(metadata)的途径和方法。Annot...
Java反射与动态代理深入解析
- 注解处理器可以读取这些注解并在编译期间或运行时执行相应的处理，如代码生成、验证、配置等。 通过深入理解并熟练掌握反射、动态代理和Annotation，开发者可以编写出更加灵活、功能丰富的Java应用，特别是在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Meow_Sir

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值