精华内容
下载资源
问答
  • 另一种是反射机制,它允许我们在运行时发现和使用类的信息。JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的...

    反射的概述

    要想理解反射的原理,首先要了解什么是类型信息。Java让我们在运行时识别对象和类的信息,主要有2种方式:一种是传统的RTTI,它假定我们在编译时已经知道了所有的类型信息;另一种是反射机制,它允许我们在运行时发现和使用类的信息。JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

    反射的应用场景:

    通过反射来给对象赋值,把Map或request里面的对象取出来赋给对象,就省下10来个set或get了

       @Test
    public void test1() throws Exception{
    	        
    		   	User p = new User();
    	        Method methods[] = p.getClass().getMethods();
    	        Map paramap=new HashMap<String, Object>();
    	        paramap.put("Nickname", "123");
    	        for(int i=0;i<methods.length;i++){
    	        	String methodname=methods[i].getName();
    	        	if(methodname.contains("set")){
    	        		if(paramap.containsKey(getFirstCharacterToUpper(methodname))){
    	        methods[i].invoke(p,paramap.get(methodname.substring(3,methodname.length())));   
    	        		}
    	        	}
    	        }
    	        System.out.println(p.getNickname());
    	    }
    	   private static String getFirstCharacterToUpper(String srcStr) {
    		   String str1=srcStr.substring(3,srcStr.length());
    		   return str1;
    		}

     

    当然在写的时候可以直接用标签@Valid,也不用用这个,如果两个bean相互赋值的话也可以直接用

    BeanUtils.copyProperties(publishCube, cube);

     

    总体还是感觉反射没啥子卵用,但是以前用反射做跟踪调试时用到过,导出文件过程中,用getclass确定这个对象是execle还是xml过就当这个吧

     

    展开全文
  • 浅谈反射应用场景

    2012-08-23 12:41:00
    我们就聊聊反射应用场景,或许大家会更感兴趣。反射应用中大多会与配置文件、特性等元素联系起来,接下来我们来看一些配置节点片段代码。 配置节点一 <httpModules> <add name="test" type=...

       今天和大家来聊一聊关于反射的话题,对于反射的基础知识我在这里就不再从头来过一遍了,园子里的文章大把。那聊什么呢?我们就聊聊反射的应用场景,或许大家会更感兴趣。反射在应用中大多会与配置文件、特性等元素联系起来,接下来我们来看一些配置节点片段代码。

    配置节点一
    <httpModules>
       <add name="test" type="MyModule.MyHttpModule,MyHttpModule"/>
     </httpModules>

     

    配置节点二
    <handlers>
    <add name="AjaxPro" verb="POST,GET" path="ajaxpro/*.ashx" type="AjaxPro.AjaxHandlerFactory,AjaxPro"/>
    </handlers>

     这两个配置节点相信大家都不陌生,节点一是为asp.net处理管道流程注册一个自定义处理模块,第二个配置节点是为asp.net特定目录下的某种特定文件注册一种自定义的处理程序,这里的例子是AjaxPro的配置节。对于httpModules和httpHandler理解有偏差的地方欢迎大家指正,我们接着往下。

     

         很多时候对于这样的配置文件我们只知道要这配置,程序运行起来之后也不会去思考一个为什么。这两个add配置节点里面都有一个type = "XXX.XXX,XXXX"的属性,属性值配置的是 "命名空间.类名,程序集名称"。这正好符合我们反射创建一个对象的必要条件,配置节点的值告诉了我们程序集的名称还有类的信息。通常的情况下反射还会和工厂模式结合起来形成反射工厂,asp.net会在应用程序启动时去读取web.config配置文件的信息,并去加载需要的程序集,然后通过反射的方式来创建我们注册的httpModules和httpHandler类型的对象。这样就可以很轻松的在httpModules和httpHandler中实现我们自定义的业务逻辑了。

          在我们的配置文件当中与上面类似的配置节点还有很多,但它们的原理基本都是一致的,就是通过反射来动态创建对象,实现框架组件的可插拔策略,从而使程序更灵活更具备扩展性。

    转载于:https://www.cnblogs.com/ShaYeBlog/archive/2012/08/23/2652259.html

    展开全文
  • 最近做项目时,用到了一点反射处理,下面简单聊一下什么是反射,及反射使用场景,场景很重要,没有场景,很难深入了解一个技术点。反射是什么,这种在我看来比较高大上的概念就先不聊了,大家在网上搜索一下也很多...

    最近做项目时,用到了一点反射处理,下面简单聊一下什么是反射,及反射的使用场景,场景很重要,没有场景,很难深入了解一个技术点。反射是什么,这种在我看来比较高大上的概念就先不聊了,大家在网上搜索一下也很多,我们直接按照需求走一遍。

    在ORM处理里,也就是数据库和Model关联时,假设Student表里有StudentID,SName,SClass字段,对应一个StuModel,具备同样的字段,我们怎么处理表和Model的映射关系呢。

    ※注:我们这里不连接真实的数据库了,用DataTable模拟数据库表。

    下面的代码出现了。

    Main处理:

    using System;
    using System.Collections.Generic;
    using System.Data;
    
    namespace ConsoleApp1
    {
        class Program
        {
            static void Main(string[] args)
            {
                Utils du = new Utils();
                DataTable dt = du.GetDBData();
                List<StuModel> lst = du.TableToStudent(dt);
                du.PrintStudent(lst);
                Console.Read();
            }
        }
    }

    Utils处理:

    using System;
    using System.Collections.Generic;
    using System.Data;
    
    namespace ConsoleApp1
    {
        class Utils
        {
            public DataTable GetDBData()
            {
                DataTable dt = new DataTable();
                DataRow dr;
                dt.Columns.Add("StudentID");
                dt.Columns.Add("SName");
                dt.Columns.Add("SClass");
    
                for (int i = 0; i < 10; i++)
                {
                    dr = dt.NewRow();
                    dr["StudentID"] = (i + 1).ToString();
                    dr["SName"] = i.ToString() + "AAA";
                    dr["SClass"] = ((i + 1) % 7).ToString();
                    dt.Rows.Add(dr);
                }
                return dt;
            }
    
            public List<StuModel> TableToStudent(DataTable dt)
            {
                List<StuModel> lst = new List<StuModel>();
                StuModel s;
                foreach (DataRow dr in dt.Rows)
                {
                    s = new StuModel();
                    s.StudentID = dr["StudentID"].ToString();
                    s.SName = dr["SName"].ToString();
                    s.SClass = dr["SClass"].ToString();
                    lst.Add(s);
                }
                return lst;
            }
    
            public void PrintStudent(List<StuModel> lst)
            {
                foreach (StuModel m in lst)
                {
                    Console.WriteLine(m.StudentID + ":" + m.SName + ":" + m.SClass);
                }
            }
        }
    }

     

    Model类:

    namespace ConsoleApp1
    {
        class StuModel
        {
            public string StudentID { get; set; }
            public string SName { get; set; }
            public string SClass { get; set; }
        }
    }

    貌似还可以,模块化了,代码也没有揉做一团。后来项目经理发话了,表加一个字段,SAge,码农们就动起来了,几乎时全盘改动,项目经理再加一个SGender,S。。。。,结局可能有两个,项目经理住院了,或者码农辞职了。。。

    那么,能不能不让项目经理挨打,也别让员工辞职呢。有!

    看下面一版写法:

    Utils处理:

    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Reflection;
    
    namespace ConsoleApp1
    {
        class Utils
        {
            public DataTable GetDBData()
            {
                DataTable dt = new DataTable();
                DataRow dr;
                dt.Columns.Add("StudentID");
                dt.Columns.Add("SName");
                dt.Columns.Add("SClass");
                dt.Columns.Add("SAge");
    
                for (int i = 0; i < 10; i++)
                {
                    dr = dt.NewRow();
                    dr["StudentID"] = (i + 1).ToString();
                    dr["SName"] = i.ToString() + "AAA";
                    dr["SClass"] = ((i + 1) % 7).ToString();
                    dr["SAge"] = i + 10;
                    dt.Rows.Add(dr);
                }
                return dt;
            }
    
            public List<StuModel> TableToStudent(DataTable dt)
            {
                List<StuModel> lst = new List<StuModel>();
                StuModel s ;           
                foreach (DataRow dr in dt.Rows)
                {
                    s = new StuModel();
                    Type t = s.GetType();
                    foreach (PropertyInfo p in t.GetProperties())
                    {
                        p.SetValue(s, dr[p.Name].ToString());
                    }
                    lst.Add(s);
                }
                return lst;
            }
    
            public List<string> PrintStudent(List<StuModel> listStu)
            {
                string str;
                List<string> lst = new List<string>();
                foreach (StuModel m in listStu)
                {
                    str = string.Empty;
                    Type t = m.GetType();
                    foreach (PropertyInfo p in t.GetProperties())
                    {
                        str += p.GetValue(m) + ":";//为了简化代码,最后的:我们不处理了。
                    }
                    lst.Add(str);
                }
                return lst;
            }
        }
    }

    ※注:StuModel里加一个SAge属性

    public string SAge { get; set; }

    按照这一版本写法,我们只需要保证Model和数据库的表字段完全一致就好了,我们把表数据转换成实体类之后的业务代码不用动,或者改动范围很小。减少改修时的规模和问题发生几率。

    反射其中一个用途就是运行时动态获取对象信息,不用反射,大多时候我们也能完成需求,用反射的的目的是提高代码的复用率,在需求变更时不要全盘修改。

     

     


     

     

     

     

     

     

     

     

     

     

    展开全文
  • 反射个人认为,就是得到程序集中的属性和方法。 实现步骤: 导入using System.Reflection; Assembly.Load("程序集")加载程序集,返回类型是一个Assembly foreach (Type type in assembly.GetTypes())  {  ...
    审查元数据并
    
    收集
    关于它的类型信息的能力
     
    
    反射个人认为,就是得到程序集中的属性和方法。
    实现步骤:
    导入using System.Reflection;
    Assembly.Load("程序集")加载程序集,返回类型是一个Assembly
    foreach (Type type in assembly.GetTypes())
        {
                    string t = type.Name;
         }
       得到程序集中所有类的名称
    Type type = assembly.GetType("程序集.类名");获取当前类的类型
    Activator.CreateInstance(type); 创建此类型实例
    MethodInfo mInfo = type.GetMethod("方法名");获取当前方法
    mInfo.Invoke(null,方法参数);

    我只能说,这面试深入的不够。

    于是我看到这篇文章http://blog.csdn.net/educast/article/details/2894892;2个列子很常见,对于反射的解释更加生活化;

    文章解释提详细的,在那些列子中有用呢,

    XML的信息读取的案例,用反射、泛型读取XML后动态创建实例并赋值http://www.cnblogs.com/murongxiaopifu/p/4175395.html

    问,从xml文件到需要的目标类实例需要几步?

    答,读取XML文件,实例化一个目标实例,赋值。

    ——————————————————————————————————————————————————————

    问题二:如何实例化一个目标实例。

    假设我们并不知道我们的这个动态读取XML创建实例并赋值的小工具要处理的是什么类型的对象,那问题就来了,总不能每一个不同的类都对应一套处理方法吧?那也太不智能且代码太难以复用了。所以这里我们实例化一个目标实例碰到的第一个问题就来了,也就是如何破解目标类型的问题?

    答案是使用泛型

    在实例化具体对象的时候,才确定类型,这样就可以避免由于类型不同而导致的代码无法复用的问题。

    那么,下面我们的小工具---XMLToEgg就要出场了,对,就是一个处理引用类型的泛型类。

    public static class XmlToEgg<T> where T : class
    {
        
    }

    可是光解决了实例类型的问题还是差一步啊,差点什么呢?对啊,那就是如何实例化一个泛型目标实例。这也就是我们在实例化一个目标实例时遇到的第二个问题。

    答案是使用反射。

    那下面继续上代码:

    复制代码
        /// <summary>
        /// Creates the class initiate.
        /// </summary>
        private static void CreateInitiate()
        {
            Type t = typeof(T);
            ConstructorInfo ct = t.GetConstructor(System.Type.EmptyTypes);
            target = (T)ct.Invoke(null);
        }
    复制代码

    假设我们的目标类的构造函数是不需要参数的,如果需要参数也很简单

    好了,到这里我们如何创建一个一开始我们不知道是什么类型,只有到创建的时候才知道是什么东西的类的实例的问题就解决了。

    展开全文
  • System.out.println("获取所有的方法"); Method[] methods = carEntityClass.getMethods(); for (Method method : methods) { System.out.println(method.getName()); }
  • android中用到反射的地方: 场景一: 在android的sdk中,有一些用hide标记的方法,或者是private方法 属性,这些方法不能直接...使用反射机制可以直接创建对象,方便代码管理。 下面我们研究下反射使用: 题外篇:
  • 主要介绍了Java 反射反射应用场景的相关资料,帮助大家更好的理解和学习Java反射的相关知识,感兴趣的朋友可以了解下
  • 反射反射机制java类加载机制类加载步骤:通过Class对象可反向做很多事反射的定义深入理解反射API获取Class对象的三种方法获取属性获取方法通过反射实现应用解耦反射的优缺点优点缺点反射应用场景 反射机制 java类...
  • 文章目录一、Java反射定义二、Java反射机制实现1、Class对象获取2、获取class对象的摘要信息3、获取class对象的属性、方法、构造函数等三、反射应用场景1、动态代理2、自定义注解实现日志管理 写在前面:Java反射...
  • 在我们平时的项目开发过程中,基本上很少会直接使用反射机制,但这不能说明反射机制没有用,实际上有很多设计、开发都与反射机制有关,例如模块化的开发,通过反射去调用对应的字节码;动态代理设计模式也采用了...
  • 反射机制及其应用场景

    万次阅读 多人点赞 2018-04-28 00:21:44
    反射----1 反射机制 反射应用场景 Tomcat服务器1. Java的反射机制(1).反射和类的关系在程序运行状态中,对任意一个类(指的是.class文件),都能够知道这个类的所有的属性和方法。(2).反射和类对象的关系 反射...
  • java反射机制应用场景

    2016-11-25 14:08:23
    java反射机制应用场景 2013-01-12 17:26 6412人阅读 评论(0) 收藏 举报  分类: java(19)  目录(?)[+] 转自:http://gcq04552015.iteye.com/blog/1497531 java...
  • 本篇文章主要介绍了Java反射机制及应用场景反射机制是很多Java框架的基石。非常具有实用价值,需要的朋友可以参考下。
  • 反射应用场景

    千次阅读 2018-03-06 17:03:41
    反射机制提供了哪些功能?在运行时判定任意一个对象所属的类在运行时构造任意一个类的对象;在运行时判定任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理;Java反射机制类:java....
  • 反射:在程序运行状态中,对任意一个类(指的是.class文件),都能够知道这个类的所有的属性和方法。 将类的各个组成部分封装为其他对象,这就是反射机制。 能动态获取对象的信息就称为反射反射的好处:1、...
  • Java反射机制及应用场景
  • 反射机制及使用场景

    2019-06-17 11:44:21
    反射机制及使用场景

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,947
精华内容 43,178
关键字:

反射的应用场景