精华内容
下载资源
问答
  • Java 内省机制

    2014-11-02 22:58:46
    Java 内省机制

    1 内省机制的定义

           内省是   Java   语言对   Bean   类属性、事件的一种缺省处理方法。
         例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name属性,这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法,通过这些 API 可以使你不需要了解这个规则(但你最好还是要搞清楚),这些 API 存放于包 java.beans中。
         涉及到的几个重要的类:BeanInfo,Introspector,PropertyDescriptor

    2 和反射的关系

        内省其实就是用反射来实现的。

    3 代码实现

    package pkgOne;
    
    import java.beans.BeanInfo;
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;
    import java.lang.reflect.Method;
    
    public class LearnIntrospector {
    	public static void printName(Student student)throws Exception {
    		PropertyDescriptor descriptor=new PropertyDescriptor("name", Student.class);
    		Method getName=descriptor.getReadMethod();
    		String name=(String)getName.invoke(student);
    		System.out.println("name:"+name);
    		
    	}
    	public static void setName(Student student)throws Exception {
    		PropertyDescriptor descriptor=new PropertyDescriptor("name", Student.class);
    		Method setName=descriptor.getWriteMethod();
    		setName.invoke(student, "newName");
    		System.out.println("name:"+student.getName());
    	}
    	
    	public static void printAllProperties(Student student) throws Exception {
    		BeanInfo beanInfo=Introspector.getBeanInfo(Student.class);
    		PropertyDescriptor[] descriptors=beanInfo.getPropertyDescriptors();
    		for (PropertyDescriptor propertyDescriptor : descriptors) {
    			Method readMethod=propertyDescriptor.getReadMethod();
    			System.out.println(readMethod.invoke(student));
    		}
    		
    	}
    	public static void main(String[] args)throws Exception {
    		Student llq=new Student(1, "llq", 24);
    		printName(llq);
    		System.out.println("----------------");
    		setName(llq);
    		System.out.println("-----------------");
    		printAllProperties(llq);
    	}
    }
    
    运行结果:
    name:llq
    ----------------
    name:newName
    -----------------
    24
    class pkgOne.Student
    1
    newName
    invoke getOther method
    100
    


    4 应用场景

        Web 开发框架 Struts 中的 FormBean 就是通过内省机制来将表单中的数据映射到类的属性上,因此要求 FormBean 的每个属性要有 getter/setter 方法。但也并不总是这样,什么意思呢?就是说对一个 Bean 类来讲,我可以没有属性,但是只要有 getter/setter 方法中的其中一个,那么 Java 的内省机制就会认为存在一个属性,比如类中有方法 setMobile ,那么就认为存在一个 mobile 的属性,这样可以方便我们把 Bean 类通过一个接口来定义而不用去关心具体实现,不用去关心 Bean中数据的存储。(参考自:http://geeksun.iteye.com/blog/539222


    展开全文
  • JAVA内省机制

    2019-06-06 16:32:00
    内省是反射的一种特例 由于在框架底层中要频繁地操作javabean,而利用反射操作比较麻烦。...Java内省机制是针对JavaBean进行操作的 public class Person { private String name; public String getName...

     

    内省是反射的一种特例

    由于在框架底层中要频繁地操作javabean,而利用反射操作比较麻烦。所以为了方便操作javabean,sun公司开发出一套API提高效率

     

    Java内省机制是针对JavaBean进行操作的

     

    public class Person {
        
        private String name;
        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;
        }
        private int age;
     
    }

     

     

     

     

    public class TestIntrospector {
     
        @Test
        public void tes1() throws Exception {
            Class<?> cl = Class.forName("com.irish.aop.cc.Person");
            //在bean上进行内省
            BeanInfo beaninfo = Introspector.getBeanInfo(cl, Object.class);
            PropertyDescriptor[] pro = beaninfo.getPropertyDescriptors();
            Person p = new Person();
            System.out.print("Person的属性有:");
            for (PropertyDescriptor pr : pro) {
                System.out.print(pr.getName() + " ");
            }
            System.out.println("");
            for (PropertyDescriptor pr : pro) {
                Method writeme = pr.getWriteMethod();
                if (pr.getName().equals("name")) {
                    writeme.invoke(p, "xiong");
                }
                if (pr.getName().equals("age")) {
                    writeme.invoke(p, 23);
                }
                Method method = pr.getReadMethod();
                System.out.print(method.invoke(p) + " ");
     
            }
        }
     
        @Test
        public void test2() throws Exception {
            PropertyDescriptor pro = new PropertyDescriptor("name", Person.class);
            Person preson=new Person();
            Method  method=pro.getWriteMethod();
            method.invoke(preson, "xiong");
            System.out.println(pro.getReadMethod().invoke(preson));
        }
    }

     

     

     

    怎么让后台的Model对象统一的接收表单提交过来的参数

    Servlet

        public void doPost(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            request.setCharacterEncoding("UTF-8");
            user u=new user();
            populate(request.getParameterMap(),u);
            System.out.println(u);
            
        }
        
        private void populate(Map<String,String[]> map,user u){
            try {
                Map<String,String[]> params=map;
                //1 获得 java Bean的描述信息
                BeanInfo info =Introspector.getBeanInfo(user.class);
                //2 获得 User中的属性信息
                PropertyDescriptor [] pds =info.getPropertyDescriptors();
                //3 遍历属性信息
                for (PropertyDescriptor pd : pds) {
                    String[] param=params.get(pd.getName());
                    if (param!=null && param.length>0) {
                        pd.getWriteMethod().invoke(u, param[0]);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

     

    JavaBean

    public class user {
        private String name;
        private String password;
        public user(){
            
            super();
        }
        
        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;
        }
        
        @Override
        public String toString() {
            return "user [name=" + name + ", password=" + password + " ]";
        }
    }

    Jsp

        <body>
            <form action="/JavaBean/BServlet" method="post" >
                用户名:<input type="text" name="name" /><br>
                密码:<input type="password" name="password" /><br>
            
                <input type="submit" /><br>
            </form>
        </body>

     

    转载于:https://www.cnblogs.com/moris5013/p/10985765.html

    展开全文
  • Java内省机制

    2016-08-30 13:25:55
    Java内省机制 1).内省(Introspector)是Java 语言对Bean类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来...
     

    Java内省机制


    1).内省(Introspector)是Java 语言对Bean类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性,这就是默认的规则。 

       Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法,通过这些 API 可以使你不需要了解这个规则(但你最好还是要搞清楚),这些 API 存放于包 java.beans 中。

    2).直接通过属性的描述器java.beans.PropertyDescriptor类,来访问属性的getter/setter 方法;

    相关代码:

    [java]  view plain  copy
    1. public class Point {     
    2.     private Integer x;     
    3.     private Integer y;     
    4.         
    5.     public Point(Integer x, Integer y) {     
    6.         super();     
    7.         this.x = x;     
    8.         this.y = y;     
    9.     }     
    10.         
    11.    public Integer getX() {     
    12.        return x;     
    13.    }        
    14.    public void setX(Integer x) {     
    15.        this.x = x;     
    16.    }     
    17.        
    18.    public Integer getY() {     
    19.        return y;     
    20.    }      
    21.    public void setY(Integer y) {     
    22.        this.y = y;     
    23.    }     
    24.   }     
    25.    
    26.    import java.beans.PropertyDescriptor;     
    27.    import java.lang.reflect.Method;     
    28.        
    29.    public class Reflect {     
    30.        
    31.    public static void main(String[] args) throws Exception {     
    32.        Point point = new Point(25);     
    33.        String proName = "x";     
    34.        
    35.        getProperty(point, proName);     
    36.        setProperty(point, proName);     
    37.    }     
    38.        
    39.    private static void setProperty(Point point, String proName) throws Exception {     
    40.        PropertyDescriptor proDescriptor = new PropertyDescriptor(proName, Point.class);     
    41.        Method methodSetX = proDescriptor.getWriteMethod();     
    42.        methodSetX.invoke(point, 8);     
    43.        System.out.println(point.getX());// 8     
    44.    }     
    45.        
    46.    private static void getProperty(Point point, String proName) throws Exception {     
    47.        PropertyDescriptor proDescriptor = new PropertyDescriptor(proName, Point.class);     
    48.        Method methodGetX = proDescriptor.getReadMethod();     
    49.        Object objx = methodGetX.invoke(point);     
    50.        System.out.println(objx);// 2     
    51.    }     
    52.   }      

    3).通过类 Introspector 来获取某个对象的 BeanInfo 信息,然后通过 BeanInfo 来获取属性的描述器( PropertyDescriptor ),通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法,然后我们就可以通过反射机制来调用这些方法。

    相关代码:
    把2中的getProperty()修改成如下形式:

    [java]  view plain  copy
    1. private static void getProperty(Point point, String proName) throws Exception {     
    2.         BeanInfo beanInfo = Introspector.getBeanInfo(point.getClass());     
    3.         PropertyDescriptor[] proDescriptors = beanInfo.getPropertyDescriptors();     
    4.         for(PropertyDescriptor prop: proDescriptors){     
    5.           if(prop.getName().equals(proName)){     
    6.             Method methodGetx = prop.getReadMethod();     
    7.             System.out.println(methodGetx.invoke(point));//8     
    8.             break;     
    9.           }     
    10.        }     
    11.    }   

    4).我们又通常把javabean的实例对象称之为值对象 (Value Object),因为这些bean中通常只有一些信息字段和存储方法,没有功能性方法。一个JavaBean类可以不当JavaBean用,而当成普通类 用。JavaBean实际就是一种规范,当一个类满足这个规范,这个类就能被其它特定的类调用。一个类被当作javaBean使用时,JavaBean的 属性是根据方法名推断出来的,它根本看不到java类内部的成员变量(javabean的成员变量通常都是私有private的)。

    5).除了反射用到的类需要引入外,内省需要引入的类如下所示,它们都属于java.beans包中的类,自己写程序的时候也不能忘了引入相应的包或者类。

    import java.beans.BeanInfo;
    import java.beans.IntrospectionException;
    import java.beans.Introspector;
    import java.beans.PropertyDescriptor;

    6).下面讲解一些开源的工具类Beanutils,需要额外下载的,commons-beanutils.jar,要使用它还必须导入commons-logging.jar包,不然会出异常;
    相关代码一:

    [java]  view plain  copy
    1. public static void main(String[] args) throws Exception {     
    2.         Point point = new Point(25);     
    3.         String proName = "x";     
    4.         BeanUtils.setProperty(point, proName, "8");     
    5.         System.out.println(point.getX());// 8     
    6.         System.out.println(BeanUtils.getProperty(point, proName));// 8     
    7.         System.out.println(BeanUtils.getProperty(point, proName).getClass().getName());// java.lang.String     
    8.         
    9.         BeanUtils.setProperty(point, proName, 8);     
    10.        System.out.println(BeanUtils.getProperty(point, proName).getClass().getName());// java.lang.String     
    11.    }     
    12.    //我们看到虽然属性x的类型是Integer,但是我们设置的时候无论是Integer还是String,BeanUtils的内部都是当成String来处理的。  

    相关代码二:
    BeanUtils支持javabean属性的级联操作;

    [java]  view plain  copy
    1. public static void main(String[] args) throws Exception {     
    2.     Point point = new Point(25);//在point中加一个属性 private Date birth = new Date();并产生setter/getter方法     
    3.     String proName = "birth";     
    4.     Date date= new Date();     
    5.     date.setTime(10000);     
    6.     BeanUtils.setProperty(point, proName, date);     
    7.     System.out.println(BeanUtils.getProperty(point, proName));     
    8.          
    9.     BeanUtils.setProperty(point, "birth.time"10000);     
    10.     System.out.println(BeanUtils.getProperty(point, "birth.time"));//10000     
    11. }     
    12. //之所以可以 BeanUtils.setProperty(point, "birth.time", 10000);这样写,那是因为Date类中有getTime()和setTime()方法,即Date类中相当于有time这个属性。   

    相关代码三:
    BeanUtils和PropertyUtils对比:

    [java]  view plain  copy
    1. public static void main(String[] args) throws Exception {     
    2.     Point point = new Point(25);     
    3.     String proName = "x";     
    4.     BeanUtils.setProperty(point, proName, "8");     
    5.     System.out.println(BeanUtils.getProperty(point, proName));//8     
    6.     System.out.println(BeanUtils.getProperty(point, proName).getClass().getName());//java.lang.String     
    7.          
    8. // PropertyUtils.setProperty(point, proName, "8");//exception:argument type mismatch     
    9.     PropertyUtils.setProperty(point, proName, 8);     
    10.     System.out.println(PropertyUtils.getProperty(point, proName));//8     
    11.     System.out.println(PropertyUtils.getProperty(point, proName).getClass().getName());//java.lang.Integer     
    12. }     
    13. //BeanUtils它以字符串的形式对javabean进行转换,而PropertyUtils是以原本的类型对javabean进行操作。如果类型不对,就会有argument type mismatch异常。  

    6).理解了相应的原理,那些现成的工具用起来就会更舒服,如Beanutils与 PropertyUtils工具。这两个工具设置属性的时候一个主要区别是PropertyUtils.getPropety方法获得的属性值的类型为该 属性本来的类型,而BeanUtils.getProperty则是将该属性的值转换成字符串后才返回。

    总结

    Web 开发框架 Struts 中的 FormBean 就是通过内省机制来将表单中的数据映射到类的属性上,因此要求 FormBean 的每个属性要有 getter/setter 方法。但也并不总是这样,什么意思呢?就是说对一个 Bean 类来讲,我可以没有属性,但是只要有 getter/setter 方法中的其中一个,那么 Java 的内省机制就会认为存在一个属性,比如类中有方法 setMobile ,那么就认为存在一个 mobile 的属性。

    将 Java 的反射以及内省应用到程序设计中去可以大大的提供程序的智能化和可扩展性。有很多项目都是采取这两种技术来实现其核心功能,例如我们前面提到的 Struts ,还有用于处理 XML 文件的 Digester 项目,其实应该说几乎所有的项目都或多或少的采用这两种技术。在实际应用过程中二者要相互结合方能发挥真正的智能化以及高度可扩展性。

    展开全文
  • java内省机制

    2017-04-03 11:43:05
    JavaBean:一种可重用的,遵循一定的设计规范的类...java内省机制:通过反射操作JavaBean的属性,一般应用于框架底层 一般步骤: 1.获取JavaBean的BeanInfo对象,此方法需抛异常 BeanInfo info = Introspector.ge

    JavaBean:一种可重用的,遵循一定的设计规范的类

    规范如下:1.类是public类型

    2.有公告无参构造器

    3.属性私有,包含属性的get、set方法


    java内省机制:通过反射操作JavaBean的属性,一般应用于框架底层


    一般步骤:

    1.获取JavaBean的BeanInfo对象,此方法需抛异常
    BeanInfo info = Introspector.getBeanInfo(Person.class);
    或BeanInfo info = Introspector.getBeanInfo(Person.class,Object.class); //获取Person的BeanInfo,到Object类停止


    2.从BeanInfo中获取属性描述器
    PropertyDescriptor[] pds = info.getPropertyDescriptors();


    3.获取属性的类型及名称,get,set方法
    pds[i].getName();
    pds[i].getPropertyType();
    pds[i].getReadMethod();
    pds[i].getWriteMethod();


    将JavaBean转化成Map,要抛异常
    public static Map<String,Object> bean2Map(Object bean){
    Map<Srting,Object> map = new HashMap<>();
    Introspector.getBeanInfo(bean.getClass(),Object.class); //核心获取属性名和值
    PropertyDescriptor[] pds = info.getPropertyDescriptors();
    for(PropertyDescriptor pd : pds){
    Srting key = pd.getName(); //获取属性的值
    Object value = pd.getReadMethod().invoke(bean);
    map.put(key,value); //存入Map中
    }
    return map;
    }


    将Map转化成JavaBean,要抛异常
    public static <T> T Map2bean(Map<String,Object> beanMap,Class<T> type){ //返回一个泛型
    //通过反射获得返回的对象
    T obj = type.newInstance();
    BeanInfo info = Introspector.getBeanInfo(type,Object.class);
    PropertyDescriptor[] pds = info.getPropertyDescriptors();
    for(PropertyDescriptor pd : pds){
    //从Map中获取到属性的值,并且设置给javabean对象
    Srting key = pd.getName();
    Object value = beanMap.get(key);
    pd.getWriteMethod().invoke(obj,value);
    }
    return obj;
    }
    泛型方法,返回值必须和泛型有关,参数列表中的形参至少有一个跟泛型有关

    展开全文
  • java 内省机制

    2019-04-30 00:05:41
    内省(Introspector)是Java语言对Bean类属性、事件的一种缺省处理方法。 个人理解: 说白了就是通过反射获取javabean的setting方法并通过method执行 内省的两种实现方式: 1.通过Introspector接口获取...

空空如也

空空如也

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

java内省机制

java 订阅