[转]java反射机制

原文地址:http://www.cnblogs.com/jqyp/archive/2012/03/29/2423112.html

一、什么是反射机制
        简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，
    那么就可以通过反射机制来获得类的所有信息。
二、哪里用到反射机制
        有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码，
    Class.forName("com.mysql.jdbc.Driver.class").newInstance();但是那时候只知道那行代码是生成
    驱动对象实例，并不知道它的具体含义。听了反射机制这节课后，才知道，原来这就是反射，现在很多开
    框架都用到反射机制，hibernate、struts都是用反射机制实现的。
三、反射机制的优点与缺点
        为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，
    静态编译：在编译时确定类型，绑定对象,即通过。
    动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多
    态的应用，有以降低类之间的藕合性。
    一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中
    它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编
    译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如
    这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能
    的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功
    能。
       它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它
    满足我们的要求。这类操作总是慢于只直接执行相同的操作。
四、利用反射机制能获得什么信息
         一句话，类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了
    首先得根据传入的类的全名来创建Class对象。
    Class c=Class.forName("className");注明：className必须为全名，也就是得包含包名，比如，cn.netjava.pojo.UserInfo;
    Object obj=c.newInstance();//创建对象的实例
    OK，有了对象就什么都好办了，想要什么信息就有什么信息了。  
    获得构造函数的方法
    Constructor getConstructor(Class[] params)//根据指定参数获得public构造器

Constructor[] getConstructors()//获得public的所有构造器

Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得public和非public的构造器

Constructor[] getDeclaredConstructors()//获得public的所有构造器
    获得类方法的方法
    Method getMethod(String name, Class[] params),根据方法名，参数类型获得方法

Method[] getMethods()//获得所有的public方法

Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型，获得public和非public的方法

Method[] getDeclaredMethods()//获得所以的public和非public方法
    获得类中属性的方法
    Field getField(String name)//根据变量名得到相应的public变量

Field[] getFields()//获得类中所以public的方法

Field getDeclaredField(String name)//根据方法名获得public和非public变量

Field[] getDeclaredFields()//获得类中所有的public和非public方法
    常用的就这些，知道这些，其他的都好办……
五、用反射机制能干什么事
        刚开始在使用jdbc时侯，在编写访问数据库时写到想吐，有八个表，每个表都有增删改查中操作
    那时候还不知道有反射机制这个概念，所以就对不同的表创建不同的dao类,这样不仅开发速率地，而且代码
    冗余的厉害，最要命的是看着差不多的，然后直接复制修改，由于容易犯各种低级的错误（大小写啊，多一
    个或少一个字母啊……）,一个错误就可以让你找半天。
        有了java反射机制，什么都好办了，只需要写一个dao类，四个方法，增删改查，传入不同的对象，就OK啦，
    无需为每一个表都创建dao类，反射机制会自动帮我们完成剩下的事情，这就是它的好处。说白了，反射机制就是专门
    帮我们做那些重复的有规则的事情，所以现在很多的自动生成代码的软件就是运用反射机制来完成的，只要你按照规则
    输入相关的参数，所以低级的程序员慢慢的就被抹杀了，为什么？因为代码都不用写了，随便一个人都会开发，还要程
    序员干什么啊？所以我们只有一条出路，那就是努力努力再努力，成为高级程序员，专门开发傻瓜软件，让其他程序员  到 一边凉快去，呵呵~
六、用反射机制实现对数据库数据的增、查例子
    基本原理；保存数据时，把需要保存的对象的属性值全部取出来再拼凑sql语句
                 查询时，将查询到的数据全部包装成一个java对象。
    游戏规则：俗话说的好，无规矩不成方圆，特别是程序来说，它只能做有规则的事情，没有规则的它干不了，好，那就
              先定规则
              1）数据库的每一个表对象一个pojo类，表中的每一个字段对应pojo类的中的一个属性。
                 并且pojo类的名字和表的名字相同，属性名和字段名相同，大小写没有关系，因为数据库一般不区分大小写 
              2）为pojo类中的每一个属性添加标准的set和get方法。
    有了游戏规则，那么开始游戏吧。

1、首先数据库的有一个表，假设数据库名称为：blogsystem,里面的一个表名userinfo。如图：

2、创建对应的pojo类：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

package cn.netjava.pojo;

public class UserInfo {

private int id;

private String name;

private String pwd;

private int age;

@Override

public String toString() {

    return "UserInfo [id=" + id + ", name=" + name + ", pwd=" + pwd + ", age="

            + age + "]";

}

public int getId() {

    return id;

}

public void setId(int id) {

    this.id = id;

}

public String getName() {

    return name;

}

public void setName(String name) {

    this.name = name;

}

public String getPwd() {

    return pwd;

}

public void setPwd(String pwd) {

    this.pwd = pwd;

}

public int getAge() {

    return age;

}

public void setAge(int age) {

    this.age = age;

}

}

2、编写获得数据库连接的工厂类：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

package cn.netjava.factory;

import java.sql.Connection;

import java.sql.DriverManager;

public class Connect2DBFactory {

    public static Connection getDBConnection() {

        Connection conn = null;

        try {

            Class.forName("com.mysql.jdbc.Driver");

            String url = "jdbc:mysql://localhost:3306/blogsystem";

            String user = "root";

            String password = "netjava";

            conn = DriverManager.getConnection(url, user, password);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return conn;

    }

}

3、好戏开始啦，编写操作数据库的dao类


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

package cn.netjava.session;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.List;

import cn.netjava.factory.Connect2DBFactory;

import cn.netjava.pojo.UserInfo;

public class NetJavaSession {

    /**

     * 解析出保存对象的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 = new ArrayList();

        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) + ")";

            }

        }

        return sql;

    }

    public static List getDatasFromDB(String tableName, int Id) {

        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, int Id) {

        // 得到表名字

        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();

        }

        return obj;

    }

}

4、开始测试效果怎么样：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

package cn.netjava.tester;

import cn.netjava.pojo.UserInfo;

import cn.netjava.session.NetJavaSession;

public class Tester {

    public static void main(String args[]) {

        //获得NetJavaSession对象

        NetJavaSession session = new NetJavaSession();

        //创建一个UserInfo对象

        UserInfo user = new UserInfo();

        //设置对象的属性

        user.setId(6988);

        user.setAge(44);

        user.setPwd("pwd");

        user.setName("champion");

        //将对象保存到数据库中

        String sql = session.getSaveObjectSql(user);

        System.out.println("保存对象的sql语句：" + sql);

        //查找对象

        UserInfo userInfo = (UserInfo) session.getObject(

                "cn.netjava.pojo.UserInfo", 6988);

        System.out.println("获取到的信息：" + userInfo);

    }

}

5、打印出来的结果：

七、总节一下

总的来说，java反射机制是一个很好用的东西，用它可以解决很多死的东西，因为反射机制的灵活行很大，有了他，我们就不要花太多的时间来写操做数据库的
代码了，而是方法更多的时间在项目的逻辑功能上，这个可以很大的减少开发时间，而且代码的可读性好。先在的很多开源框架都是才用的反射机制，它只要配置文
件，然后按规则来调用他的方法就可以了。

时间： 2024-10-09 21:03:45

[转]java反射机制的相关文章

java反射机制（一）—— 利用反射机制实例化对象

一.Java有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载.探知.使用编译期间完全未知的classes.换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体.或对其fields设值.或唤起其methods.(度娘文库是这么说的) 二.这篇文章主要介绍一下通过反射机制去实例化一个类的对象,然后调用其方法.本文主要介绍两种方式,第一种就是通过构造函数来实例化,第二种就是通过Cl

【java】java反射机制，动态获取对象的属性和对应的参数值，并属性按照字典序排序，Field.setAccessible()方法的说明【可用于微信支付 签名生成】

方法1:通过get()方法获取属性值 package com.sxd.test.controller; public class FirstCa{ private Integer num; private String name; private Boolean flag; public Integer getNum() { return num; } public void setNum(Integer num) { this.num = num; } public String getNam

Java 反射机制

使用 Java 反射机制可以在运行时期检查 Java 类的信息,检查 Java 类的信息往往是你在使用 Java 反射机制的时候所做的第一件事情,通过获取类的信息你可以获取以下相关的内容: Class 对象 类名 修饰符 包信息 父类 实现的接口 构造器 方法 变量 注解 除了上述这些内容,还有很多的信息你可以通过反射机制获得,如果你想要知道全部的信息你可以查看相应的文档 JavaDoc for java.lang.Class 里面有详尽的描述. 在本节中我们会简短的涉及上述所提及的信息,上述的

Java反射机制浅析

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. "程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言".从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言.但是JAVA有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载.探知.使用

java反射机制分析

本文转自:http://www.cnblogs.com/gulvzhe/archive/2012/01/27/2330001.html 浅显易懂,值得收藏 Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象, 都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制.反射的概念是由Smith在1982年 首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力.这一概念的提出很快引发了

java 反射机制：运行时的类信息(为框架服务的Bug存在)

反射机制:JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 换一种引出反射的说法是:当通过反射与一个未知的类型的对象打交道是,JVM只是简单地检查这个类,看它是属于哪个特定的类(就想RTTI那样).在用它做其他事情之前必须先加载那个类的Class对象.因此,那个类的.class文件对于JVM来说必须是可获取的:那么在本地机器上,要么通过网络获得

工厂类分离与java反射机制

网易 博客 发现 小组 风格 手机博客 玩LOFTER,免费冲印20张照片!> 创建博客登录 加关注 黙言-在路上 奋斗 首页 日志 相册 音乐 收藏 博友 关于我 黙言 加博友   关注他 他的网易微博 最新日志 Javascript 操作select控件 Oracle 存储过程基本语法 将域名和tomcat6进行绑定的 svn 423 Locked JS的trim()方法 jbpm4.4 结束流程时报错 随机阅读 让员工每年有一次机会当主角 外国女性如何舍身"套"色狼 亚洲电

java反射机制简介

1.字节码.所谓的字节码就是当java虚拟机加载某个类的对象时,首先需要将硬盘中该类的源代码编译成class文件的二进制代码(字节码),然后将class文件的字节码加载到内存中,之后再创建该类的对象 2.java反射的基础是Class类(注意不是小写的class),Class类实例代表着内存中的一份字节码.常见的获取Class类对象的方法如下(第一种为对象的方法,第二种为类的方法): Dog dog = new Dog(); Class dogClass = dog.getClass(); Cl

【转载】Java反射机制详解

转自:http://baike.xsoftlab.net/view/209.html#3_8 1反射机制是什么 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 2反射机制能做什么 反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类: 在运行时构造任意一个类的对象: 在运行时判断任意一个类所具有的成员变量和方法: 在运行时调用任意一个

Java反射机制（Reflection）

Java反射机制(Reflection) 一.反射机制是什么 Java反射机制是程序在运行过程中,对于任意一个类都能够知道这个类的所有属性和方法;对于任意一个对象都能够调用它的任意一个方法和属性,这种动态获取类信息以及动态调用对象方法的功能就是JAVA语言的反射机制. 二.反射机制能干什么 (1)在运行时判断任意一个对象所属的类 (2)在运行时构造任意一个类的对象 (3)在运行时判断任意一个类所具有的成员变量和方法 (4)在运行时调用任意一个对象的方法 (PS:注意反射机制都是在程序运行时,而不