标签：
一、序列化是什么?
序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。
序列化分为两大部分：序列化和反序列化。
(1)序列化—将数据分解成字节流，以便存储在文件中或在网络上传输。
(2)反序列化—就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例
可以参考：http://www.cnblogs.com/xdp-gacl/p/3777987.html
二、反射机制
（1）什么是反射机制
反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字， 那么就可以通过反射机制来获得类的所有信息。
（2）反射机制的优点与缺点
为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，静态编译：在编译时确定类型，绑定对象,即通过。动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中，它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该能。
它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。
（3）用反射机制能干什么事
a:创建对应的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
|
publicclass UserInfo
{privateint id;private
String name;private
String pwd;privateint age;@Overridepublic
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;}} |
|
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
user = "root"; String
password = "root"; conn= DriverManager.getConnection(url,
user, password); }
catch (Exception e) { e.printStackTrace(); } return conn; }} |
C:编写操作数据库的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
93
94
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
|
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; }}
|
d:开始测试效果：
|
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
|
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); }} |
e、打印出来的结果：
标签：
原文地址：http://blog.csdn.net/qq_24892029/article/details/51204677
