java序列化和java反射机制认识

一、序列化是什么?
   序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。 
   序列化分为两大部分：序列化和反序列化。

     (1)序列化—将数据分解成字节流，以便存储在文件中或在网络上传输。

     (2)反序列化—就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例

可以参考：http://www.cnblogs.com/xdp-gacl/p/3777987.html

二、反射机制

 （1）什么是反射机制 
     反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字， 那么就可以通过反射机制来获得类的所有信息。

  （2）反射机制的优点与缺点 
        为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，静态编译：在编译时确定类型，绑定对象,即通过。动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中，它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该能。 
    它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

  （3）用反射机制能干什么事 

  a:创建对应的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;
}

}

  b:编写获得数据库连接类：

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/11" ;
            String user =   "root" ;
            String password =   "root" ;
            conn =   DriverManager.getConnection(url, user, password);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return   conn;
    }
}

 C:编写操作数据库的dao类

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 mList =   new ArrayList();
        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;
    }
}

d:开始测试效果：

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