java反射知识点总结

publicfinal Class getClass(),
所有Java对象都具备这个方法。该方法用于返回与调用该方法对象所属类关联的Class对象，例如：
Date date1 = newDate();
Date date2 = newDate();
Class c1 =date1.getClass();
Class c2 =date2.getClass();
System.out.println(c1.getName()); //java.util.Date

System.out.println(c1 == c2); //true

上面的代码中，调用Date对象date1的getClass方法将返回用于封装Date类信息的Class对象。这里调用了Class类的getName方法：
publicString getName()
这个方法的含义很直观，即返回所封装的类的名称。
需要注意的是，代码中的date1和date2的getClass方法返回了相同的Class对象（c1==c2的值为true）。这是因为，对于相同的类，JVM只会载入一次，而与该类对应的Class对象也只会存在一个，无论该类实例化了多少对象。
另外，需要强调的是，当一个对象被其父类的引用或其实现的接口类型的引用所指向的时，getClass方法返回的是与对象实际所属类关联的Class对象。例如：
List list = newArrayList();
System.out.println(list.getClass().getName()); //java.util.ArrayList

上面的代码中，语句list.getClass()方法返回的是list所指向对象实际所属类java.util.ArrayList对应的 Class对象而并未java.util.List所对应的Class对象。有些时候可以通过这个方法了解一个对象的运行时类型，例如：
HashSet set = newHashSet();
Iterator it = set.iterator();
System.out.println(it.getClass().getName()); //java.util.HashMap$KeyIterator

从代码可以看出，HashSet的iterator方法返回的是实现了Iterator接口的HashMap内部类（KeyIterator）对象。
因为抽象类和接口不可能实例化对象，因此不能通过Object的getClass方法获得与抽象类和接口关联的Class对象。

使用类名加“.class”的方式即会返回与该类对应的Class对象。例如：
Class clazz = String.class;
System.out.println(clazz.getName()); //java.lang.String

这个方法可以直接获得与指定类关联的Class对象，而并不需要有该类的对象存在。

Class有一个著名的static方法forName：
public staticClass forName(String className) throws ClassNotFoundException
该方法可以根据字符串参数所指定的类名获取与该类关联的Class对象。如果该类还没有被装入，该方法会将该类装入JVM。
该方法声明抛出ClassNotFoundException异常。顾名思义，当该方法无法获取需要装入的类时（例如，在当前类路径中不存在这个类），就会抛出这个异常。
例如，如果当前类路径中存在Foo类：
package org.whatisjava.reflect;
public classFoo {
publicFoo() {
System.out.println("Foo()");
}
static{
System.out.println("Foo is initialized");
}
}
运行下面的代码：
Class clazz = Class.forName("org.whatisjava.reflect.Foo");
控制台会有如下输出：
Foo isinitialized
Class.forName("org.whatisjava.reflect.Foo")首先会将reflection.Foo类装入JVM，并 返回与之关联的Class对象。JVM装入Foo类后对其进行初始化，调用了其static块中的代码。需要注意的是：forName方法的参数是类的完 整限定名（即包含包名）。

1.类似spring ioc源码
public classBeanFactory {  
    private static Map<String, Object> beanMap = new HashMap<String, Object>();  
    public voidinit(String xml) {  
        try{           
            //从class目录下获取指定的xml文件  
            ClassLoader classLoader =Thread.currentThread().getContextClassLoader();  
            InputStream ins =classLoader.getResourceAsStream(xml);  
            //解析xml  
            SAXReader reader = newSAXReader();  
            Document doc =reader.read(ins);  
            Element root =doc.getRootElement();  
            Element beanNode;   
            //遍历bean  
            for (Iterator i = root.elementIterator("bean"); i.hasNext();) {  
                beanNode =(Element) i.next();  
                //获取bean的属性id和class  
                Attribute id = beanNode.attribute("id");  
                Attribute className = beanNode.attribute("class");  
                //利用Java反射机制，通过class的名称获取Class对象  
                Class beanClass =Class.forName(className.getText());  
                //实例化对象  
                Object obj =beanClass.newInstance();  
                //设置对象属性值  
setBeanProperty(beanNode,beanClass,obj);  
                //将对象放入beanMap中，其中key为id值，value为对象  
beanMap.put(id.getText(), obj);  
            }  
        } catch(Exception e) {  
            System.out.println(e.toString());  
            e.printStackTrace();  
        }  
    }  
    //设置对象属性值  
    @SuppressWarnings("unchecked")  
    private static voidsetBeanProperty(Element beanNode,Class beanClass,Object obj) throws Exception{  
        //设置值的方法  
        Method method = null;  
        //获取对应class的信息  
        java.beans.BeanInfo beanInfo =java.beans.Introspector.getBeanInfo(beanClass);  
        //获取其属性描述  
        java.beans.PropertyDescriptor proDescriptor[] =beanInfo.getPropertyDescriptors();  
        //遍历该bean的property属性  
        for (Iterator ite = beanNode.elementIterator("property"); ite.hasNext();) {  
            Element beanPro =(Element) ite.next();  
            //获取该property的name属性  
            Attribute name = beanPro.attribute("name");  
            Attribute ref = beanPro.attribute("ref");  
            Object proVal = null;  
            if(ref!=null){  
                 proVal=beanMap.get(ref.getValue());  
            }else{  
                //获取该property的子元素value的值  
                for (Iterator ite1 = beanPro.elementIterator("value"); ite1.hasNext();) {  
                    Element node =(Element) ite1.next();  
                    proVal =node.getText();  
                    break;  
                }  
            }  
            for (int k = 0; k < proDescriptor.length; k++) {  
                if(proDescriptor[k].getName().equalsIgnoreCase(name.getText())) {  
                    method =proDescriptor[k].getWriteMethod();  
                    //利用Java的反射极致调用对象的某个set方法，并将值设置进去  
method.invoke(obj, proVal);  
                }  
            }  
        }  
    }   
    /** 
     * * 通过bean的id获取bean的对象. * 
     *  
     * @param beanName 
     *            bean的id * 
     * @return 返回对应对象 
     */  
    public staticObject getBean(String beanName) {  
        Object obj = beanMap.get(beanName);  
        returnobj;  
    }  
    static{  
        BeanFactory factory = newBeanFactory();  
        factory.init("config.xml");  
    }  
  

2.利用java反射生成sql语句
public classNetJavaSession {
    /**
     * 解析出保存对象的sql语句
     *
     * @param object
     *            ：需要保存的对象
     * @return：保存对象的sql语句
     */
    public static String getSaveObjectSql(Object object) {
        //定义一个sql字符串
        String sql = "insert into ";
        //得到对象的类
        Class c = object.getClass();
        //得到对象中所有的方法
        Method[] methods =c.getMethods();
        //得到对象中所有的属性
        Field[] fields =c.getFields();
        //得到对象类的名字
        String cName =c.getName();
        //从类的名字中解析出表名
        String tableName = cName.substring(cName.lastIndexOf(".") + 1,
                cName.length());
        sql += tableName + "(";
        List<String> mList = new ArrayList<String>();
        List vList = newArrayList();
        for(Method method : methods) {
            String mName =method.getName();
            if (mName.startsWith("get") && !mName.startsWith("getClass")) {
                String fieldName = mName.substring(3, mName.length());
                mList.add(fieldName);
                System.out.println("字段名字----->" +fieldName);
                try{
                    Object value = method.invoke(object, null);
                    System.out.println("执行方法返回的值：" +value);
                    if(value instanceof String) {
                        vList.add(""" + value + """);
                        System.out.println("字段值------>" +value);
                    } else{
                        vList.add(value);
                    }
                } catch(Exception e) {
                    e.printStackTrace();
                }
            }
        }
        for (int i = 0; i < mList.size(); i++) {
            if (i < mList.size() - 1) {
                sql += mList.get(i) + ",";
            } else{
                sql += mList.get(i) + ") values(";
            }
        }
        for (int i = 0; i < vList.size(); i++) {
            if (i < vList.size() - 1) {
                sql += vList.get(i) + ",";
            } else{
                sql += vList.get(i) + ")";
            }
        }
        returnsql;
    }
    public static List getDatasFromDB(String tableName, intId) {
        return null;
    }
    /**
     * 将对象保存到数据库中
     *
     * @param object
     *            ：需要保存的对象
     * @return：方法执行的结果;1:表示成功，0:表示失败
     */
    public int saveObject(Object object) {
        Connection con =Connect2DBFactory.getDBConnection();
        String sql = getSaveObjectSql(object);
        try{
            //Statement statement=(Statement) con.createStatement();
            PreparedStatement psmt =con.prepareStatement(sql);
            psmt.executeUpdate();
            return 1;
        } catch(SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }
    /**
     * 从数据库中取得对象
     *
     * @param arg0
     *            ：对象所属的类
     * @param id
     *            ：对象的id
     * @return:需要查找的对象
     */
    public Object getObject(String className, intId) {
        //得到表名字
        String tableName = className.substring(className.lastIndexOf(".") + 1,
                className.length());
        //根据类名来创建Class对象
        Class c = null;
        try{
            c =Class.forName(className);
        } catch(ClassNotFoundException e1) {
            e1.printStackTrace();
        }
        //拼凑查询sql语句
        String sql = "select * from " + tableName + "where Id=" +Id;
        System.out.println("查找sql语句：" +sql);
        //获得数据库链接
        Connection con =Connect2DBFactory.getDBConnection();
        //创建类的实例
        Object obj = null;
        try{
            Statement stm =con.createStatement();
            //得到执行查寻语句返回的结果集
            ResultSet set =stm.executeQuery(sql);
            //得到对象的方法数组
            Method[] methods =c.getMethods();
            //遍历结果集
            while (set.next()) {
                obj =c.newInstance();
                //遍历对象的方法
                for(Method method : methods) {
                    String methodName =method.getName();
                    //如果对象的方法以set开头
                    if (methodName.startsWith("set")) {
                        //根据方法名字得到数据表格中字段的名字
                        String columnName = methodName.substring(3,
                                methodName.length());
                        //得到方法的参数类型
                        Class[] parmts =method.getParameterTypes();
                        if (parmts[0] == String.class) {
                            //如果参数为String类型，则从结果集中按照列名取得对应的值，并且执行改set方法
                            method.invoke(obj, set.getString(columnName));
                        }
                        if (parmts[0] == int.class) {
                            method.invoke(obj, set.getInt(columnName));
                        }
                    }
                }
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
        returnobj;
    }
}