精华内容
下载资源
问答
  • 通过反射读取private属性

    千次阅读 2018-05-04 17:15:05
    获取两个对象指定字段的属性值并进行比较:实体Phone:package bean; public class Phone { private String id; private String brand; private String color; private int memory; private int storage;...

    获取两个对象中指定字段的属性值并进行比较:

    实体类Phone:

    package bean;
    
    public class Phone {
    
    	private String id;
    	private String brand;
    	private String color;
    	private int memory;
    	private int storage;
    	private int price;
    	
    	public String getId() {
    		return id;
    	}
    	
    	public void setId(String id) {
    		this.id = id;
    	}
    
    	public String getBrand() {
    		return brand;
    	}
    
    	public void setBrand(String brand) {
    		this.brand = brand;
    	}
    
    	public String getColor() {
    		return color;
    	}
    
    	public void setColor(String color) {
    		this.color = color;
    	}
    
    	public int getMemory() {
    		return memory;
    	}
    
    	public void setMemory(int memory) {
    		this.memory = memory;
    	}
    
    	public int getStorage() {
    		return storage;
    	}
    
    	public void setStorage(int storage) {
    		this.storage = storage;
    	}
    
    	public int getPrice() {
    		return price;
    	}
    
    	public void setPrice(int price) {
    		this.price = price;
    	}
    
    	public Phone() {
    		super();
    	}
    
    	public Phone(String id, String brand, String color, int memory, int storage, int price) {
    		super();
    		this.id = id;
    		this.brand = brand;
    		this.color = color;
    		this.memory = memory;
    		this.storage = storage;
    		this.price = price;
    	}
    	
    }

    实体类Difference:

    package bean;
    
    public class Difference implements Comparable<Difference>{
    
    	private int id;
    	private String fieldName;
    	private String oldValue;
    	private String newValue;
    	
    	public int getId() {
    		return id;
    	}
    	
    	public void setId(int id) {
    		this.id = id;
    	}
    	
    	public String getFieldName() {
    		return fieldName;
    	}
    	
    	public void setFieldName(String fieldName) {
    		this.fieldName = fieldName;
    	}
    	
    	public String getOldValue() {
    		return oldValue;
    	}
    	
    	public void setOldValue(String oldValue) {
    		this.oldValue = oldValue;
    	}
    	
    	public String getNewValue() {
    		return newValue;
    	}
    	
    	public void setNewValue(String newValue) {
    		this.newValue = newValue;
    	}
    
    	public Difference() {
    		super();
    	}
    	
    	public Difference(int id, String fieldName, String oldValue, String newValue) {
    		super();
    		this.id = id;
    		this.fieldName = fieldName;
    		this.oldValue = oldValue;
    		this.newValue = newValue;
    	}
    
    	@Override
    	public String toString() {
    		return "属性值:" + this.fieldName + ";旧值:" + this.oldValue + ";新值:" + this.newValue + "\r";
    	}
    
        @Override
        public int compareTo(Difference difference) {
            if (this.getId() - difference.getId() < 0)
                return 1;
            return -1;
        }
    }

    测试类:

    package test;
    
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collections;
    import java.util.List;
    
    import bean.Difference;
    import bean.Phone;
    
    public class TestPhone {
    
    	protected static final String[] COMPAREFIELDS = {"color", "memory", "storage", "price"};
    	
    	public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
    		
    		Phone oldPhone = new Phone("p1001", "SAMSUNG", "BLACK", 6, 128, 6999);
    		Phone newPhone = new Phone("p1002", "MI", "BLUE", 5, 1284, 2999);
    		
    		Field[] fields = oldPhone.getClass().getDeclaredFields();
    		
            List<Difference> differenceList = new ArrayList<>();
    
            for (Field field : fields) {
                String fieldName = field.getName();
                if (Arrays.asList(COMPAREFIELDS).contains(fieldName)) {
                    field.setAccessible(true); // 如果没有设置,会报错:java.lang.IllegalAccessException
                    if (!field.get(oldPhone).equals(field.get(newPhone))) {
                    	differenceList = createDifference(differenceList, fieldName, field.get(oldPhone), field.get(newPhone));
                    }
                }
            }
            System.out.println(differenceList.toString());
    	}
    	
    	public static List<Difference> createDifference(List<Difference> differenceList, String fieldName, Object oldValue, Object newValue) {
    		int id = differenceList.size() == 0 ? 1 : differenceList.get(0).getId() + 1;
    		Difference difference = new Difference(id, fieldName, oldValue.toString(), newValue.toString());
    		differenceList.add(difference);
    		Collections.sort(differenceList);
    		return differenceList;
    	}
    }

    输出结果:

    [属性值:price;旧值:6999;新值:2999
    , 属性值:storage;旧值:128;新值:1284
    , 属性值:memory;旧值:6;新值:5
    , 属性值:color;旧值:BLACK;新值:BLUE
    ]
    展开全文
  • 我们可以通过该PropertyDescriptor对bean的该属性进行读取和写入操作,也可以设置其getter / setter。 关键接口及内部属性 public PropertyDescriptor(String name, Class&amp;lt;...
    • 概述
      PropertyDescriptor描述Java Bean中通过一对存储器方法(getter / setter)导出的一个属性。我们可以通过该PropertyDescriptor对bean中的该属性进行读取和写入操作,也可以设置其getter / setter。

    • 关键接口及内部属性

    public PropertyDescriptor(String name, Class<?> beanClass) throws IntrospectionException
    public PropertyDescriptor(String name, Class<?> beanClass, String getMethodName, String setMethodName) throws IntrospectionException
    public PropertyDescriptor(String name, Method readMethod, Method writeMethod) throws IntrospectionException
    
    public Class<?> getPropertyType()
    public Method getReadMethod()
    public Method getWriteMethod()
    
    public void setReadMethod(Method readMethod) throws IntrospectionException
    public void setWriteMethod(Method writeMethod)
    public boolean equals(Object o)&nbsp;
    

    相关的PropertyDescriptor内部属性如下:
    Class<?> propertyType; //该属性的类型
    Method getMethod; //getter
    Method setMethod; //setter
    还有继承自其父类FeatureDescriptor的功能,用于指定该属性的编程名称

    • 简单应用
      Person类如下:
    package com.cwind.property;
    
    public class Person {
            private String name ;
            private int age ;
           
            public Person(){ this.name = ""; this.age = 0; }
            public Person(String name, int age) { super(); this.name = name; this. age = age; }
    
            public String getName() { return name; }
            public void setName(String name) { this. name = name; }
    
            public int getAge() { return age; }
            public void setAge(int age) { this. age = age; }
           
            public String getNameInUpperCase(){
                   return this .name .toUpperCase();
           }
            public void setNameToLowerCase(String name){
                   this.name = name.toLowerCase();
           }
    }
    
    ```java
    该类中除了name和age两个属性的标准getter和setter之外,还有增加了一个获取大写name的get方法和一个将name设置为小写的set方法。
    在测试类中,首先获得这两个方法对象。
    
    

    Class personClass = Class.forName(“com.cwind.property.Person”);
    Method read = personClass.getMethod(“getNameInUpperCase”, null);
    Method write = personClass.getMethod(“setNameToLowerCase”, String.class );

    //然后可以通过两种方式构造PropertyDescriptor
    PropertyDescriptor prop1 = new PropertyDescriptor( “name”, Person.class ); //使用其标准getter和setter
    PropertyDescriptor prop2 = new PropertyDescriptor( “name”, read, write); //使用read和write两个方法对象所自定义的getter和setter

    //下面构建一个Person对象
    Person person = new Person(“Kobe” , 36);
    System. out.println(prop1.getReadMethod().invoke(person, null)); // --实际调用Person.getName(), result: Kobe
    System. out.println(prop2.getReadMethod().invoke(person, null)); // --实际调用Person.getNameInUpperCase(), result: KOBE

    prop1.getWriteMethod().invoke(person, “James”); // --实际调用Person.setName(), person.name被设置为James
    prop2.getWriteMethod().invoke(person, “James”); // --实际调用Person.setNameToLowerCase(), person.name被设置为james

     - 利用PropertyDescriptor类抽象公共方法
    ```java
    /**
         * @Methodname:converter 数据转换工具将value转为name
         * 
         * 将List<SysDictionaryDo> dicList对象里的value属性值
         * 赋值给 List<T> list对象里的field属性
         */
        public static <T> void converter(List<T> list, List<SysDictionaryDo> dicList, String field) throws Exception {
            if (CollectionUtils.isEmpty(list)) {
                return;
            }
            PropertyDescriptor pd = new PropertyDescriptor(field, list.get(0).getClass());
            Method readMethod = pd.getReadMethod();
            Method writeMethod = pd.getWriteMethod();
            for (int i = 0; i < list.size(); i++) {
                T obj = list.get(i);
                String key = (String) readMethod.invoke(obj);
                for (SysDictionaryDo dic : dicList) {
                    if (dic.getValue().equals(key)) {
                        writeMethod.invoke(obj, dic.getName());
                    }
                }
            }
        }
    

    Java高级特性——反射

    展开全文
  • 针对web项目包中的文件发布到服务器上无法读取问题,特采用类反射机制获取文件的绝对路径。InputStream fis = PropertiesUtil.class.getClassLoader().getResourceAsStream(filePath); //从输入流中读取属性列表...
    针对web项目包中的文件发布到服务器上无法读取问题,特采用类反射机制获取文件的绝对路径。
    InputStream fis = PropertiesUtil.class.getClassLoader().getResourceAsStream(filePath);
                //从输入流中读取属性列表(键和元素对)
                prop.load(fis);
                //调用 Hashtable 的方法 put。使用 getProperty 方法提供并行性。
                //强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。
                String a=PropertiesUtil.class.getClassLoader().toString();
                System.out.println(a);
                OutputStream fos = new FileOutputStream(PropertiesUtil.class.getResource(filePath).getFile());
                prop.setProperty(parameterName, parameterValue);
                //以适合使用 load 方法加载到 Properties 表中的格式,
                //将此 Properties 表中的属性列表(键和元素对)写入输出流
                prop.store(fos, "Update '" + parameterName + "' value");
    接下来说下怎么操作,先调用类名.class.getResource(filepath).getFile()即可获取到发布到服务器上的文件,然后再站华为输入输出流,这里需要注意传入的filepath
    不以’/'开头时默认是从此类所在的包下取资源,以’/'开头则是从ClassPath根下获取,我要读取的文件在项目的包中就这样写"/com/sky/magnifier/config/systemplan.properties"

    展开全文
  • Java反射读取注解信息

    2020-02-20 10:46:07
    ORM (Object Relationship Mapping) ORM:对象关系映射 写程序用 Java 来写,存数据用数据库存储 ...将Java的Student使用第三方程序通过读取注解生成数 据库的表 实现步骤 1) 编...
    ORM (Object Relationship Mapping)
    ORM:对象关系映射
    写程序用 Java 来写,存数据用数据库存储

    1) 类与表结构对应

    2) 属性和字段对应
     
    3) 对象和记录对应
    使用注解完成类和表结构的映射关系
    功能描述
    Java中的Student类使用第三方程序通过读取注解生成数
    据库中的表
     实现步骤
    1) 编写 Student
    2) 编写注解
    3) 在类中使用注解
    4) 通过解析程序将注解读取出来 (通过框架解析)
    5) 拼接 SQL 语句,使用 JDBC 到数据库中执行创建表
    展开全文
  • 1.反射 定义:在程序运行期间,创建对象、调用方法的方式就是反射!我们可以不直接new一个对象实例,从方法区直接获取一个的...在内存中类加载时通过类属性来获取 类名.class 多用于传参 通过类实例化对象的方法
  • 将java的各个组成部分封装为对象,可以在程序运行过程操作这些对象,这就是java的反射机制。 反射具体能干那些事: 1、在运行时能够获取任意类型的详细信息 2、在运行时能够创建任意引用数据类型的对象 3、在...
  • 通过反射获取类、类对应的属性类中的方法、设置属性值、执行方法。 网上大多数的获取资源文件中的配置是直接使用注解的,所以我这里特定整理了直接使用代码读取资源,这样有利用理解spring中对资源的管理。 ...
  • 反射: JAVA反射机制是在运行状态,对于任意一个实体,都能够知道这个的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射...
  • 背景 由于公司的软件要和第甲方webservice对接而且涉及到其他后续的甲方都要对接,用...再从本地dll中通过反射进行调用。这样就需要管理我写的代码就行了,如果甲方代码变了我只需要删除之前生成的dll就行了。 针对对.
  • Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何的内部信息,并能直接操作任意对象的内部属性及方法。 加载完之后,在堆内存的方法区就产生了一个Class类型...
  • 最近在工作中碰到许多地方需要将各种类型的...于是对工具类进行了改写,使用反射读取到集合类中属性和数据,可实现直接从集合类中导出数据到excel。废话不多说,贴代码:usingSystem;usingSystem.Collections;usi...
  • c# 反射在ORM的应用

    2017-05-10 20:51:40
    在ORM编程中,一般把表或视图映射为一个类,把字段作为属性来使用,从数据库表或视图读取的数据需要映射到类的属性中,在更新数据库时也要读取类属性的值,通过反射就能做到这些。 假设主键字段在类中加上FPK_前缀...
  • 在程序加入注解就等于为程序打上某种标记,没有加,则等于没有任何标记,以后,javac编译器、开发工具和其他程序可以通过反射来了解你的及各种元素上有无何种标记,看你的程序有什么标记,就去干相应的事,标记...
  • 3.用反射通过配置文件的内容创建对象,并给对象的属性赋值(对象的属性的数据类型只有字符串和整数类型) 自定义的简单代码: public class Studen { //三个属性 private String name; private String gender; ...
  • 反射

    2020-05-25 21:07:44
    反射读取属性③Student代码展示④总结 ①什么是反射? 概念: 反射java语言的一种机制,通过这种机制可以动态的实例化对象、读写属性、调用方法 作用: 能够让代码更具灵活性,能够将未知的对象进行实例化 ②反射...
  • java中反射基本使用

    2020-11-07 15:59:46
    目录反射知识点总结1.反射概念---给成员变量赋值(Field类)2.使用反射获取构造方法并使用,...通过反射获取不同类的方法5.1)Test测试类:获取Work类中的love()方法5.2)读取src目录下的properties配置文件5.3)ArrayListI
  • Java反射

    2020-11-24 20:23:15
    **作用:**在开发的过程,当导入第三方jar包的时候,开发人员可以直接在java文件使用,可以通过反射来查看其中都包含哪些方法及属性。 实例 为方便查看自己建立一个java,生成对象 public class Item { ...
  • 通过反射技术,可以大大提高程序的稳定性,比如,新加功能时,只需要新加相应的功能,不需要改变框架。一般来说,运用方法+构造方法反射,就可以大大增强框架稳定性。 我们还可以把需要执行的功能,放到配置文件...
  • 从properties中读取配置创建对象

    千次阅读 2019-10-28 22:23:56
    主要做两个事,从properties配置文件中读取信息,通过反射创建对象 思路主要有两种,遍历得到的属性集合,然后设置属性 遍历属性集合,从配置文件中读取(不推荐,因为属性有多样化,会报错) try { ...
  • 反射就是在程序运行的过程,我们可以通过一个的字节码对象(Class对象),剖析出这个的一切细节,知道他有哪些属性、方法、构造函数,甚至还可以动态的实例化一个对象。 Class对象是什么? Java在经过编译时...
  • java反射机制

    2020-07-07 08:12:36
    的各个组成(属性、构造函数、方法等)部分封装成其他对象,这就是反射机制 反射的优点 可以在程序运行的时候创建对象 可以实现代码解耦 获取字节码对象(Class)的三种方式 通过Class.forName(“全类名”)...
  • java反射

    2020-09-14 17:59:38
    什么是反射 反射是java语言的一种机制,通过这种机制可以动态的实例化对象,读写属性,调用方法 ... 通过反射机制读取或写入属性 通过反射机制调用方法 Class对象 Class对象是什么 描述类型信息的...
  • Java反射原理

    2020-07-02 21:06:53
    反射:框架设计的灵魂 * 框架:半成品软件。可以在框架的基础上进行软件开发,简化编码 * 反射:将的各个组成部分封装为其他对象,这就是反射机制 ... 类名.class:通过类名的属性class获取 * 多用于参数的传递

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 351
精华内容 140
关键字:

通过反射读取类中属性