精华内容
下载资源
问答
  • .NET和JAVA 反射对比

    2017-06-01 19:10:00
    反射是一个程序集发现及运行的过程,通过反射可以得到*.exe或*.dll等程序集内部的信息。使用反射可以看到一个程序集内部的接口、类、方法、字段、属性、特性等等信息。在System.Reflection命名空间内包含多个反射...

    反射是一个程序集发现及运行的过程,通过反射可以得到*.exe或*.dll等程序集内部的信息。使用反射可以看到一个程序集内部的接口、类、方法、字段、属性、特性等等信息。在System.Reflection命名空间内包含多个反射常用的类,下面表格列出了常用的几个类。

     

    .NET 版

    类型 作用
    Assembly 通过此类可以加载操纵一个程序集,并获取程序集内部信息
    EventInfo 该类保存给定的事件信息
    FieldInfo 该类保存给定的字段信息
    MethodInfo 该类保存给定的方法信息
    MemberInfo 该类是一个基类,它定义了EventInfo、FieldInfo、MethodInfo、PropertyInfo的多个公用行为
    Module 该类可以使你能访问多个程序集中的给定模块
    ParameterInfo 该类保存给定的参数信息      
    PropertyInfo 该类保存给定的属性信息

     

    一、System.Reflection.Assembly类

         通过Assembly可以动态加载程序集,并查看程序集的内部信息,其中最常用的就是Load()这个方法。

         Assembly assembly=Assembly.Load("MyAssembly");

     

    二、System.Type类

         Type是最常用到的类,通过Type可以得到一个类的内部信息,也可以通过它反射创建一个对象。一般有三个常用的方法可得到Type对象。

    1. 利用typeof() 得到Type对象

      Type type=typeof(Example);

    2. 利用System.Object.GetType() 得到Type对象

      Example example=new Example();

      Type type=example.GetType();

    3. 利用System.Type.GetType() 得到Type对象

      Type type=Type.GetType("MyAssembly.Example",false,true);

      注意参数0是类名,参数1表示若找不到对应类时是否抛出异常,参数1表示类名是否区分大小写

       例子:

       我们最常见的是利用反射与Activator结合来创建对象。

       Assembly assembly= Assembly.Load("MyAssembly");

       Type type=assembly.GetType("Example");

       object obj=Activator.CreateInstance(type);

     

    三、反射方法

        1.通过 System.Reflection.MethodInfo能查找到类里面的方法

        代码:

        Type type=typeof(Example);

        MethodInfo[] listMethodInfo=type.GetMethods();

        foreach(MethodInfo methodInfo in listMethodInfo)

             Cosole.WriteLine("Method name is "+methodInfo.Name);

      

       2.我们也能通过反射方法执行类里面的方法

       代码(经常用到):

       Assembly assembly= Assembly.Load("MyAssembly");

       Type type=assembly.GetType("Example");

       object obj=Activator.CreateInstance(type);

       MethodInfo methodInfo=type.GetMethod("Hello World");  //根据方法名获取MethodInfo对象

       methodInfo.Invoke(obj,null);  //参数1类型为object[],代表Hello World方法的对应参数,输入值为null代表没有参数

     

    更多详细点击这里

     

    下面代码是获取程序集的

     1 System.Reflection.Assembly ass = Assembly.LoadFrom(Server.MapPath("bin/Reflection.dll")); //加载DLL
     2 foreach (Type temp in alltype)
     3 {
     4     Console.WriteLine(temp.Name);  //打印出MyClass程序集中的所有类型名称 MyClass , Demo
     5 }
     6 System.Type t = ass.GetType("Reflection.Test");//获得类型
     7 object o = System.Activator.CreateInstance(t);//创建实例
     8 
     9 System.Reflection.MethodInfo mi = t.GetMethod("Hello Word");//获得方法
    10 
    11 mi.Invoke(o, null)"});//调用方法

    参考:

    http://www.cnblogs.com/knowledgesea/archive/2013/03/02/2935920.html

    http://www.cnblogs.com/wangshenhe/p/3256657.html

     

    JAVA 版

     

    转载于:https://www.cnblogs.com/bigbrid/p/6930381.html

    展开全文
  • 反射对比两个实体。

    2012-05-24 16:07:34
    public static bool IsEqual(T x, T y)  {  PropertyInfo[] infos = typeof(T).GetProperties();  foreach (PropertyInfo info in infos ?? new PropertyInfo[0])  {
    public static bool IsEqual<T>(T x, T y)
            {
                PropertyInfo[] infos = typeof(T).GetProperties();
                foreach (PropertyInfo info in infos ?? new PropertyInfo[0])
                {
                    if (info.GetValue(x, new object[0]) == null || info.GetValue(y, new object[0]) == null)
                    {
                        return true;
                    }
                    else
                    {
                        if (info.Name.ToUpper() == "CREATEDON" || info.Name.ToUpper() == "MODIFIEDON") continue;
                        if (info.GetValue(x, new object[0]).GetHashCode() != info.GetValue(y, new object[0]).GetHashCode())
                        {
                            return false;
                        }
                    }
                }
                return true;
            }
    展开全文
  • 对各种方法实现get方法的性能进行了一个测试...通过Java Class类自带的反射获得Method测试4.使用Java自带的Property类获取Method测试5.BeanUtils的getProperty测试1 测试用Bean类测试定义了如下一个bean类。 public...

    对各种方法实现get方法的性能进行了一个测试。

    总共有5个测试,,每个测试都是执行1亿次

    1. 直接通过Java的get方法

    2.通过高性能的ReflectAsm库进行测试

    3.通过Java Class类自带的反射获得Method测试

    4.使用Java自带的Property类获取Method测试

    5.BeanUtils的getProperty测试

    1 测试用Bean类

    测试定义了如下一个bean类。

    6de016d966602bfe03745ad2e599328d.gif

    public class SimpleBean {

    private String name;

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    }

    f9360a9b74da0316134ef56011443697.gif

    注意定义要严格遵守JavaBean规范,否则在使用和反射相关工具时会出现NoSuchMethodException异常,或者导致性能非常差,JavaBean规范中最重要的几点如下:

    1.类必须是public, 拥有public无参构造器,这样能够通过反射newInstance()动态构建对象.

    String className = ...;

    Class beanClass = Class.forName(className);

    Object beanInstance = beanClass.newInstance();

    2.因为反射newInstance使用的是无参构造器, 所以对象实例化和配置是分开的

    3.每一个property都有一个public的getter和setter方法, 命名方式是get/set+首字母大写的property名

    经测试在SimpleBean为public时,1亿次调用method.invoke方法:

    javaReflectGet 100000000 times using 218 ms

    而SimpleBean为默认包可见时,1一亿次调用method.invoke方法:

    javaReflectGet 100000000 times using 12955 ms

    2.测试代码

    d818f4092e4b4a21bba7eb983fd1d27d.gif

    public class TestIterator {

    private long times = 100_000_000L;

    private SimpleBean bean;

    private String formatter = "%s %d times using %d ms";

    @Before

    public void setUp() throws Exception {

    bean = new SimpleBean();

    bean.setName("haoyifen");

    }

    //直接通过Java的get方法

    @Test

    public void directGet() {

    Stopwatch watch = Stopwatch.createStarted();

    for (long i = 0; i < times; i++) {

    bean.getName();

    }

    watch.stop();

    String result = String.format(formatter, "directGet", times, watch.elapsed(TimeUnit.MILLISECONDS));

    System.out.println(result);

    }

    //通过高性能的ReflectAsm库进行测试,仅进行一次methodAccess获取

    @Test

    public void reflectAsmGet() {

    MethodAccess methodAccess = MethodAccess.get(SimpleBean.class);

    Stopwatch watch = Stopwatch.createStarted();

    for (long i = 0; i < times; i++) {

    methodAccess.invoke(bean, "getName");

    }

    watch.stop();

    String result = String.format(formatter, "reflectAsmGet", times, watch.elapsed(TimeUnit.MILLISECONDS));

    System.out.println(result);

    }

    //通过Java Class类自带的反射获得Method测试,仅进行一次method获取

    @Test

    public void javaReflectGet() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {

    Method getName = SimpleBean.class.getMethod("getName");

    Stopwatch watch = Stopwatch.createStarted();

    for (long i = 0; i < times; i++) {

    getName.invoke(bean);

    }

    watch.stop();

    String result = String.format(formatter, "javaReflectGet", times, watch.elapsed(TimeUnit.MILLISECONDS));

    System.out.println(result);

    }

    //使用Java自带的Property属性获取Method测试,仅进行一次method获取

    @Test

    public void propertyGet() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, IntrospectionException {

    Method method = null;

    BeanInfo beanInfo = Introspector.getBeanInfo(SimpleBean.class);

    PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

    for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {

    if (propertyDescriptor.getName().equals("name")) {

    method = propertyDescriptor.getReadMethod();

    break;

    }

    }

    Stopwatch watch = Stopwatch.createStarted();

    for (long i = 0; i < times; i++) {

    method.invoke(bean);

    }

    watch.stop();

    String result = String.format(formatter, "propertyGet", times, watch.elapsed(TimeUnit.MILLISECONDS));

    System.out.println(result);

    }

    //BeanUtils的getProperty测试

    @Test

    public void beanUtilsGet() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {

    Stopwatch watch = Stopwatch.createStarted();

    for (long i = 0; i < times; i++) {

    BeanUtils.getProperty(bean, "name");

    }

    watch.stop();

    String result = String.format(formatter, "beanUtilsGet", times, watch.elapsed(TimeUnit.MILLISECONDS));

    System.out.println(result);

    }

    }

    a74b0445f9f51745bcf33c8e0fbd2f54.gif

    3.测试结果

    在4核i5-4590@3.30GHz机器上跑以上测试,经过多次测量,基本在以下数值范围附近,测试数据如下:

    1. directGet 100000000 times using 37 ms

    2. reflectAsmGet 100000000 times using 39 ms

    3. javaReflectGet 100000000 times using 222 ms

    4. propertyGet 100000000 times using 335 ms

    5. beanUtilsGet 100000000 times using 20066 ms

    4.结果分析

    1.使用reflectAsm库的性能能和直接调用get方法持平

    2.Java自带的反射性能大致为直接get的1/6和1/9.

    3.BeanUtils的getProperty非常的慢,为直接get性能的1/500,为Java自带反射性能的1/100和1/60.

    转载至:https://www.cnblogs.com/Frank-Hao/p/5839096.html

    展开全文
  • Java反射与Golang反射简单对比

    千次阅读 2020-08-15 15:35:41
    前段时间学习了golang的基础语法,发现其反射的概念与Java的差别挺大,做个简单对比,记录一下。 为了测试Java反射,创建如下User类: public class User { public String username; private String password; ...

    0x00 前言

    前段时间学习了golang的基础语法,发现其反射的概念与Java的差别挺大,做个简单对比,记录一下。
    为了测试Java反射,创建如下User类:

    public class User {
        public String username;
        private String password;
        
    	public User() {}
    
    	public User(String username, String password) {
            this.username = username;
            this.password = password;
        }
    
        public void publicMethod() {
            System.out.println("publicMethod is running ...");
        }
    
        private void privateMethod() {
            System.out.println("private is running ...");
        }
    }
    

    按照上面的User类,创建如下Golang结构:

    type User struct {
    	Username string
    	password string
    }
    
    func (u User) PublicMethod() {
    	fmt.Println("PublicMethod is running ... ")
    }
    
    func (u User) privateMethod() {
    	fmt.Println("privateMethod is running ...")
    }
    

    0x01 操作公有字段

    1.1 Java反射操作公有字段

    Java操作User类的公有字段username时,有如下几步:
    1、获取User类的Class对象
    2、获取username字段对应的Field对象
    3、通过Field对象操作指定User对象的username字段值

    public static void main(String[] args) throws Exception {
    		// 获取User类的Class对象,方法很多,这里采用Class.forName()方法
            Class clazz = Class.forName("hldf.reflecttest.User");
            // 获取User类中的username字段对应的Field对象
            Field field = clazz.getField("username");
            
            User user = new User("zhangsan", "123456");
            // 获取user对象的username字段值
            String username = (String) field.get(user);
            System.out.println(username); // 输出zhangsan
    
            // 设置user对象的username字段值为lisi
            field.set(user, "lisi");
            username = (String) field.get(user);
            System.out.println(username); // 输出lisi
        }
    

    1.2 Golang反射操作公有字段

    Golang操作User结构的公有字段Username时,只需要通过reflect.ValueOf()方法获取User结构对应的reflect.Value对象来进行读取和修改操作即可:

    func main() {
    	user := User{"zhangsan", "123456"}
    	// 获取user对象对应的Value对象
    	v := reflect.ValueOf(user)
    	// 获取user对象的Username字段对应的Value对象
    	field := v.FieldByName("Username")
    	fmt.Println(field.String()) // 输出 zhangsan
    
    	// 修改结构的字段时必须传入指针类型
    	v = reflect.ValueOf(&user)
    	// 调用FieldByName方法的Value对象不能是指针类型生成的,
    	// 因此需先调用Elem方法获取指针指向的实际值
    	field = v.Elem().FieldByName("Username")
    	// 修改字段值
    	field.SetString("lisi")
    	fmt.Println(field.String()) // 输出 lisi
    }
    

    0x02 操作私有字段

    2.1 Java反射操作私有字段

    按照上面1.1中所述方式操作User类的私有字段password时是不会成功的,需做如下修改:
    1、使用Class类的getDeclaredField方法获取私有字段password的Field对象
    2、调用Field对象的setAccessible方法获取修改私有字段的权限

    public static void main(String[] args) throws Exception {
            Class clazz = Class.forName("hldf.reflecttest.User");
            // 获取私有字段对应的Field对象时需使用getDeclaredField方法
            Field field = clazz.getDeclaredField("password");
    
            // 获取修改私有字段password的权限
            field.setAccessible(true);
    
            User user = new User("zhangsan", "123456");
            String password = (String) field.get(user);
            System.out.println(password); // 输出123456
    
            field.set(user, "654321");
            password = (String) field.get(user);
            System.out.println(password); // 输出654321
        }
    

    2.2 Golang反射操作私有字段

    使用上面Golang反射操作公有字段的方法操作私有字段时,读取操作可成功执行,但修改操作出现异常,且Golang没有提供类似Java的setAccessible方法来获取修改私有字段的权限的方法,因此Golang无法修改结构的私有字段:

    func main() {
    	// 私有字段值可读取成功
    	user := User{"zhangsan", "123456"}
    	v := reflect.ValueOf(user)
    	field := v.FieldByName("password")
    	fmt.Println(field.String()) // 输出 123456
    
    	// 修改私有字段时,抛出异常
    	v = reflect.ValueOf(&user)
    	field = v.Elem().FieldByName("password")
    	field.SetString("654321") // 抛出异常,提示无法操作未导出的字段
    	fmt.Println(field.String()) 
    }
    

    0x03 调用公有方法

    3.1 Java反射调用公有方法

    Java操作User类的公有方法publicMethod与上面操作公有字段username类似:
    1、获取User类的Class对象
    2、获取publicMethod方法对应的Method对象
    3、通过Method对象操作指定User对象的publicMethod方法

    public static void main(String[] args) throws Exception {
            Class clazz = Class.forName("hldf.reflecttest.User");
            
            // 获取User类中publicMethod方法对应的Method对象
            Method publicMethod = clazz.getMethod("publicMethod");
            
            User user = new User();
            // 调用user对象的publicMethod方法
            publicMethod.invoke(user);
        }
    

    3.2 Golang反射调用公有方法

    与上面操作结构的字段一样,这里同样只用到了reflect.Value对象:

    func main() {
    	v := reflect.ValueOf(User{})
    	
    	// 获取user对象的PublicMethod方法对应的Value对象
    	publicMethod := v.MethodByName("PublicMethod")
    	
    	// 调用方法,PublicMethod方法为无参方法,因此传入的参数值为空
    	publicMethod.Call(nil)
    }
    

    0x04 调用私有方法

    4.1 Java反射调用私有方法

    同样,按照上面3.1中所述方法调用User类的私有方法privateMethod时是不会成功的,同样需做如下修改:
    1、使用Class类的getDeclaredMethod方法获取私有方法privateMethod的Field对象
    2、调用Method对象的setAccessible方法获取调用私有方法的权限

    public static void main(String[] args) throws Exception {
            Class clazz = Class.forName("hldf.reflecttest.User");
         
            Method privateMethod = clazz.getDeclaredMethod("privateMethod");
    
            // 获取调用私有方法的权限
            privateMethod.setAccessible(true);
    
            User user = new User();
            privateMethod.invoke(user);
        }
    

    4.2 Golang反射调用私有方法

    与上面修改私有字段结果相同,Golang同样没有提供获取调用私有方法权限的方法:

    func main() {
    	v := reflect.ValueOf(User{})
    	
    	privateMethod := v.MethodByName("privateMethod") // 获取的值为空
    	
    	privateMethod.Call(nil) //抛出异常
    }
    

    0x05 总结

    1、Java中的类(Class类)、字段(Field类)、方法(Method类)等均有相应的类来进行表示,因此需通过这些类来对对象进行操作,并且调用这些类的方法时需传入实际要被操作的对象值;而Golang中对字段、方法等的操作只需要使用reflect.ValueOf()方法,获取到实际要被操作的对象对应的reflect.Value对象,然后通过调用Value对象的方法即可直接操作对象。
    2、Java提供了setAccessible方法来获取操作私有字段和私有方法的权限,而Golang未提供类似机制,因此Golang无法通过反射来操作私有字段和私有方法。

    展开全文
  • 反射实现实体对比,根据需要对比字段进行对比使用反射获取实体对象方法和值 使用反射获取实体对象方法和值 import lombok.extern.slf4j.Slf4j; import java.beans.Introspector; import java.beans....
  • 反射性能对比分析

    2021-03-09 08:42:36
    } //反射方式调用 public static void test02()throws NoSuchMethodException, InvocationTargetException,IllegalAccessException { User user = new User(); Class c1 = user.getClass(); Method getName = c1....
  • 0x00 前言前段时间学习了golang的基础语法,发现其反射的概念与Java的差别挺大,做个简单对比,记录一下。 为了测试Java反射,创建如下User类:public class User {public String username;private String password;...
  • java各种反射性能对比

    2016-12-24 19:15:20
    java各种反射性能对比 对各种方法实现get方法的性能进行了一个测试。 总共有5个测试,,每个测试都是执行1亿次 1. 直接通过Java的get方法 2.通过高性能的ReflectAsm库进行测试 3.通过Java Class类自带的反射...
  • 5 解析 方式1,采用了最基本的java反射方式,使用Filed,循环bean的Field,得到Object,再转换为Integer类型。 方式2,采用了看似最简洁的BeanUitls,根据属性名,获取属性值。这样最耗时。 方式3,采用了获取bean...
  • 对各种方法实现get方法的性能进行了一个测试...通过Java Class类自带的反射获得Method测试4.使用Java自带的Property类获取Method测试5.BeanUtils的getProperty测试1 测试用Bean类测试定义了如下一个bean类。public ...
  • 5 解析 方式1,采用了最基本的java反射方式,使用Filed,循环bean的Field,得到Object,再转换为Integer类型。 方式2,采用了看似最简洁的BeanUitls,根据属性名,获取属性值。这样最耗时。 方式3,采用了获取bean...
  • Java各种反射性能对比

    2020-02-29 21:42:31
    对各种方法实现get方法的性能进行了一个测试。 总共有5个测试,,每个测试都是执行1亿次 1. 直接通过Java的get方法 ...3.通过Java Class类自带的反射获得Method测试 4.使用Java自带的Property类获取Method测...
  • 大家好,本节我们来详解反射,那么关于这次课的话,我们直接来通过代码来演示反射的常用方法,以及java相应的反射实现。 关于反射的原理、反射的使用场景以及具体的示例我计划放到下节课,因为我觉得光理论是很枯燥...
  • java编程中,使用反射来增强灵活性(如各类框架)、某些抽象(如各类框架)及减少样板代码(如Java Bean)。因此,反射在实际的java项目中被大量使用。由于项目里存在反射的性能瓶颈,使用的是ReflectASM高性能反射库来...
  • 导读这篇文章主要介绍了Java反射获取实例的速度对比分析,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧之前代码有一个逻辑,是在初始化时读取某个包下的所有class文件,放入到一个HashMap里。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,491
精华内容 596
关键字:

反射对比