反射+注解

最新推荐文章于 2023-05-29 18:03:06 发布

cao_fang_zi

最新推荐文章于 2023-05-29 18:03:06 发布

阅读量881

点赞数

文章标签：博客

笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

反射具体原理是什么我还真不知道，这篇博客主要是接受在应用中怎么应用反射去实现我们的目的：记载下来主要是方便自己以后查看
一，反射机制的作用：
1，反编译：.class–>.java
2,通过反射机制访问java对象的属性，方法，构造方法等；
这样好像更容易理解一些，下边我们具体看怎么实现这些功能。
二，sun为我们提供了那些反射机制中的类：
java.lang.Class;字节码对象，用来形容类
java.lang.reflect.Constructor;描绘所有构造方法
java.lang.reflect.Field; 描绘所有字段
java.lang.reflect.Method;描绘所有方法
java.lang.reflect.Modifier;描绘所有修饰符
三，具体功能实现：
1，首先我们需要获取指定类的字节码对象（假定这个类就是Employee）

//第一种方式： 通过字节码对象的静态方法与类全路径名称 
Classc1 = Class.forName("com.bean.Employee");  
//第二种方式：  
//java中每个类型都有class 属性.  
Classc2 = Employee.class; 
//第三种方式：  
//java语言中任何一个java对象都有getClass 方法  
Employeee = new Employee();  
Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)

2.创建指定类的对象（newInstance（））：//创建此Class 对象所表示的类的一个新实例 Objecto = c.newInstance(); //调用了Employee的无参数构造方法.
3.接着就可以根据自己的需求去获指定内容了
获取字段

            //获取类的字节码对象  
                Class c = Class.forName("java.lang.Integer");  
                  //获取所有声明的属性对象Field 
                Field[] fs = c.getDeclaredFields(); 
                 //定义可变长的字符串，用来存储属性  
                StringBuffer sb = new StringBuffer();  
                //通过追加的方法，将每个属性拼接到此字符串中  
                //最外边的public定义  
                sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");  
                //里边的每一个属性  
                for(Field field:fs){  
                    sb.append("\t");//空格  
                    sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如public，static等等  
                    sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字  
                    sb.append(field.getName()+";\n");//属性的名字+回车  
                }  
                sb.append("}"); 
                System.out.println(sb);

接下来罗列所有相关的方法
a.获得构造函数的方法
Constructor getConstructor(Class[] params)//根据指定的参数类型获得被public修饰的构造器
Constructor[] getConstructors()//获得所有被public修饰的构造器
Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得（public和非public都能够获取到）的构造器
Constructor[] getDeclaredConstructors()//获得所有构造器（public和非public都能够获取到）
b.获得类的成员方法
Method getMethod(String name, Class[] params),根据方法名，参数类型获得指定的被public修饰的方法（只有一个）
Method[] getMethods()//获得所有的public修饰的方法方法（多个）
Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型，获得方法任何修饰符修饰的都可以
Method[] getDeclaredMethods()//获得所以的public和非public方法
c.获得类中的字段
Field getField(String name)//根据变量名得到相应的public修饰的变量
Field[] getFields()//获得类中所有public的方法
Field getDeclaredField(String name)//根据方法名获得申明的变量
Field[] getDeclaredFields()//获得类中所有的public和非public方法
获取到想应的对象之后，我们就可以通过对象去调用相应的方法去回去需要的内容了
Field[] fields = cls.getDeclaredFields();
field.getModifiers()) //获得属性的修饰符，例如public，static等等
field.getType().getSimpleName() //属性的类型的名字
field.getName() //属性的名称
field.getAnnotation() //获取注解
field.set() //设值

getReturnType()获得方法的返回类型
getParameterTypes()获得方法的传入参数类型

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //根据对象获取对象的字节码对象
        Class<User> userClass = User.class;
        User user=null;
        try {
            //根据字节码对象获取对象
           user = userClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        //获取所有的字段
        Field[] fields = userClass.getDeclaredFields();

        //便利所有的字段
        for (Field field : fields) {
        //field.getName()获取字段的名称
            Log.e(TAG,field.getName());
           if(field.getName().equals("name")){
               //暴力破解（对于私有的类型，这是必须的。要不就获取不到，建议都是用）
               field.setAccessible(true);
               try 
               //field.get(user);获取该字段对象的值
                   String uStr = (String) field.get(user);
                   Log.e(TAG,"uStr:"+uStr);
               } catch (IllegalAccessException e) {
                   e.printStackTrace();
               }
           }
        }

        try {
            //获取指定方法名和指定参数类型的方法
            Method setName = userClass.getDeclaredMethod("setName", String.class);
            Log.e(TAG,"name:"+user.getName());
            try {
                //暴力破解该方法
                setName.setAccessible(true);
                //invoke(user,"隔壁老王八");调用该方法
                setName.invoke(user,"隔壁老王八");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            Log.e(TAG,"name:"+user.getName());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

        //获取指定的类型的注解对象
        UserAnno annotation = userClass.getAnnotation(UserAnno.class);
        //获取该类中指定注解的值
        String uname = annotation.uname();
        Log.e(TAG,uname);
    }
}

五,注解
注解是一种标记，在程序中加上某种注解就等于为程序打上了某种标记，在javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上是否存在标记，存在什么标记，就去干相应的事。标记可以加在包，类，字段，方法，方法的参数以及局部变量上。
要深入学习注解，我们就必须能定义自己的注解，并使用注解，在定义自己的注解之前，我们就必须要了解Java为我们提供的元注解和相关定义注解的语法。
元注解：

　　元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：
　　　　1.@Target,
　　　　2.@Retention,
　　　　3.@Documented,
　　　　4.@Inherited
　　这些类型和它们所支持的类在java.lang.annotation包中可以找到。下面我们看一下每个元注解的作用和相应分参数的使用说明。
　　　　@Target：
　　　@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。
　　作用：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
　　取值(ElementType)有：
　　　　1.CONSTRUCTOR:用于描述构造器
　　　　2.FIELD:用于描述域
　　　　3.LOCAL_VARIABLE:用于描述局部变量
　　　　4.METHOD:用于描述方法
　　　　5.PACKAGE:用于描述包
　　　　6.PARAMETER:用于描述参数
　　　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明

@Target(ElementType.METHOD)
public @interface Table {
    /**
     *public String tableName()注解参数名称
     * default "className"注解参数的值
     */
    public String tableName() default "className";
}

@Retention：

　　@Retention定义了该Annotation被保留的时间长短：某些Annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。

　　作用：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）
　　取值（RetentionPoicy）有：
　　　　1.SOURCE:在源文件中有效（即源文件保留）
　　　　2.CLASS:在class文件中有效（即class保留）
　　　　3.RUNTIME:在运行时有效（即运行时保留）
　　Retention meta-annotation类型有唯一的value作为成员，它的取值来自java.lang.annotation.RetentionPolicy的枚举类型值。具体实例如下：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    public String name() default "fieldName";
    public String setFuncName() default "setField";
    public String getFuncName() default "getField"; 
    public boolean defaultDBValue() default false;
}

Column注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射，获取到该注解的属性值，从而去做一些运行时的逻辑处理
@Documented:

　　@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。
@Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Column { public String name() default "fieldName"; public String setFuncName() default "setField"; public String getFuncName() default "getField"; public boolean defaultDBValue() default false; }
@Inherited：

　　@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。

　　注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。

　　当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。

六.自定义注解
使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。
定义注解格式：
　　public @interface 注解名 {定义体}
　　注解参数的可支持数据类型：

　　　　1.所有基本数据类型（int,float,boolean,byte,double,char,long,short)
　　　　2.String类型
　　　　3.Class类型
　　　　4.enum类型
　　　　5.Annotation类型
　　　　6.以上所有类型的数组

Annotation类型里面的参数该怎么设定:
　　第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；　　
　　第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;　　
　　第三,如果只有一个参数成员,最好把参数名称设为”value”,后加小括号.例:下面的例子FruitName注解就只有一个参数成员。　　package annotation; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 水果名称注解 * @author peida * */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface FruitName { String value() default ""; }

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface FruitColor {
    //声明一个枚举
    public enum Color{ BULE,RED,GREEN};
    Color fruitColor() default Color.GREEN;
}

应用

public class Apple {
    @FruitName("Apple")//给指定的注解赋值
    private String appleName;//给指定的属性添加注解，可以通过反射的方式就可以获取到该属性的注解，当该注解只有一个成员时候，可以不用声明成员的名称，而直接赋值。另外要是在注解声明的时候没有赋值默认值，那么在使用的时候就必须指定值
    @FruitColor(fruitColor=Color.RED)
    private String appleColor;

注解处理器类库(java.lang.reflect.AnnotatedElement)：

　　Java使用Annotation接口来代表程序元素前面的注解，该接口是所有Annotation类型的父接口。除此之外，Java在java.lang.reflect 包下新增了AnnotatedElement接口，该接口代表程序中可以接受注解的程序元素，该接口主要有如下几个实现类：

　　Class：类定义
　　Constructor：构造器定义
　　Field：累的成员变量定义
　　Method：类的方法定义
　　Package：类的包定义
AnnotatedElement 接口是所有程序元素（Class、Method和Constructor）的父接口，所以程序通过反射获取了某个类的AnnotatedElement对象之后，程序就可以调用该对象的如下四个个方法来访问Annotation信息：
方法1： T getAnnotation(Class annotationClass): 返回改程序元素上存在的、指定类型的注解，如果该类型注解不存在，则返回null。
　　方法2：Annotation[] getAnnotations():返回该程序元素上存在的所有注解。
　　方法3：boolean is AnnotationPresent(Class

}

水果名称：Apple
水果颜色：RED
供应商编号：1 供应商名称：陕西红富士集团供应商地址：陕西省西安市延安路89号红富士大厦`
　
　注解与反射在android中的应用实例
　声明注解、

/**
 * 成员属性注解.
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewAnno {
    int value();
}
/**
 * 方法的注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OnClick {
    int value();
}
/**
 * 类注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface LayoutAnno {
    int value();
}

-------------------使用注解---------------------
//为当前的activity添加注解，并赋值给注解
@LayoutAnno(R.layout.activity_main2)
public class Main2Activity extends AppCompatActivity {
    @ViewAnno(R.id.show_btn)
    private Button button;
    String msg;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //调用注解处理器（这是由自己定义的）
        ViewUtils.init(this);
        button.setText("哟哟哟切克闹");
    }
    //为方法添加注解
    @OnClick(R.id.show_btn)
    private void showToast(View v){
        Toast.makeText(Main2Activity.this, "哎哟！不错哦", Toast.LENGTH_SHORT).show();
    }
}

--------------------------处理器--------------------------------
public class ViewUtils {
    public static void init(final Activity activity){
        //1、获取指定activity的class对象
        Class<? extends Activity> aClass = activity.getClass();
        //2、获取该对象下class 注解，这里应该先判断是否有这个注解
        LayoutAnno layoutAnno = aClass.getAnnotation(LayoutAnno.class);
        if(layoutAnno!=null){
            //3、通过Class注解的参数 进行 绑定视图操作
            int layoutRes = layoutAnno.value();
            //为activity对象绑定布局
            activity.setContentView(layoutRes);
        }

        //TODO 获取所有的字段（包括button等view字段）
        Field[] fields = aClass.getDeclaredFields();

        for (Field field : fields) {
            //获取某一个成员变量的ViewAnno
            ViewAnno viewAnno = field.getAnnotation(ViewAnno.class);
            //如果存在 获取其ID
            if(viewAnno!=null){
                //获取注解的值
                int viewRes = viewAnno.value();
                View view = activity.findViewById(viewRes);
                try {
                    //破解 避免private
                    field.setAccessible(true);
                    //设置值 第一个参数 作用的对象 第二个参数 对应成员变量的值
                    field.set(activity,view);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }

        //TODO 绑定事件
        Method[] methods = aClass.getDeclaredMethods();
        for (final Method method : methods) {
            //获取具有OnClick注解的 方法
            OnClick methodAnno= method.getAnnotation(OnClick.class);
            //如果有 那么 执行以下操作
            if(methodAnno!=null){
                int viewRes = methodAnno.value();
                View view = activity.findViewById(viewRes);
                view.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        try {
                            method.setAccessible(true);
                            //执行方法
                            method.invoke(activity,v);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    }
---------------接下来的代码是注解在fragment中的使用------------------
    public static void init(final Fragment fragment){
        //1、获取类型
        Class<? extends Fragment> aClass = fragment.getClass();
        //TODO 获取所有的View
        Field[] fields = aClass.getDeclaredFields();

        for (Field field : fields) {
            //获取某一个成员变量的ViewAnno
            ViewAnno viewAnno = field.getAnnotation(ViewAnno.class);
            //如果存在 获取其ID
            if(viewAnno!=null){
                //获取注解的值
                int viewRes = viewAnno.value();
                View view = fragment.getView().findViewById(viewRes);
                try {
                    //破解 避免private
                    field.setAccessible(true);
                    //设置值 第一个参数 作用的对象 第二个参数 对应成员变量的值
                    field.set(fragment,view);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
        //TODO 绑定事件
        Method[] methods = aClass.getDeclaredMethods();
        for (final Method method : methods) {
            //获取具有OnClick注解的 方法
            OnClick methodAnno= method.getAnnotation(OnClick.class);
            //如果有 那么 执行以下操作
            if(methodAnno!=null){
                int viewRes = methodAnno.value();
                View view = fragment.getView().findViewById(viewRes);
                view.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        try {
                            method.setAccessible(true);
                            //执行方法
                            method.invoke(fragment,v);
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }
        }
    }
}

这里写图片描述
在开发中我们全然不必去这么做，因为android已经为我们提供了这样的插件ButterKnife（可以直接在android 设置中去下载该插件）

cao_fang_zi

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
反射+注解

反射具体原理是什么我还真不知道，这篇博客主要是接受在应用中怎么应用反射去实现我们的目的：记载下来主要是方便自己以后查看一，反射机制的作用： 1，反编译：.class–>.java 2,通过反射机制访问java对象的属性，方法，构造方法等；这样好像更容易理解一些，下边我们具体看怎么实现这些功能。
复制链接

扫一扫