java 反射机制

 为什么要用反射机制？

    静态编译：在编译时确定类型，绑定对象,即通过。 
    动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多 态的应用，有以降低类之间的藕合性

    反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它 ，满足我们的要求。这类操作总是慢于只直接执行相同的操作。 

使用java的反射机制，一般需要遵循三步：

1. 1. 获得你想操作类的Class对象
   2. 通过第一步获得的Class对象去取得操作类的方法或是属性名
   3. 操作第二步取得的方法或是属性

     Java运行的时候，某个类无论生成多少个对象，他们都会对应同一个Class对象，它表示正在运行程序中的类和接口。如何取得操作类的Class对象，常用的有三种方式：

1. 1. 调用Class的静态方法forName，如上例；
   2. 使用类的.class语法，如：Class<?> cls = String.class；
   3. 调用对象的getClass方法，如：String str = "abc"；Class<?> cls = str .getClass()；
   4. 如果某类只有带参数的构造函数fromClass.getDeclaredConstructor(int.class,String.class).newInstance(24,"wanggc");
   5. 在获得类的方法、属性、构造函数时，会有getXXX：返回的是访问权限为public的方法和属性，包括父类中的；
   6. getDeclaredXXX：返回的是所有访问权限的方法和属性，不包括父类的。

     例子：

         

package cn.netjava.pojo;

 

publicclass UserInfo {

privateint id;

private String name;

private String pwd;

privateint age;

 

@Override

public String toString() {

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

            + age+ "]";

}

publicint 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;

}

publicint 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;

 

publicclass 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;

 

publicclass NetJavaSession {

    /**

     * 解析出保存对象的sql语句

     *

     * @paramobject

     *            ：需要保存的对象

     * @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;

 

    }

 

    /**

     * 将对象保存到数据库中

     *

     * @paramobject

     *            ：需要保存的对象

     * @return：方法执行的结果;1:表示成功，0:表示失败

     */

    publicint 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

     *            ：对象所属的类

     * @paramid

     *            ：对象的id

     * @return:需要查找的对象

     */

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

            // 得到执行查寻语句返回的结果集

            ResultSetset = 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;

 

publicclass 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、打印出来的结果：

参考文献：

           http://www.cnblogs.com/jqyp/archive/2012/03/29/2423112.html