1 、什么是Java反射机制
要让Java程序能够运行,就得让Java类被JVM加载。Java类如果不被JVM加载就不能正常运行。正常情况下,我们运行的所有的程序在编译期时候就已经把那个类被加载了。
但是在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法?答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 反射(Reflection)机制。
Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。
换言之,Java可以加载一个运行时才得知名称的class,获得其完整结构。
2 、Java 反射机制主要提供了以下功能:
在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。
在运行时新建新类对象
3 、Java反射机制API
在JDK中,主要由以下类来实现Java反射机制,这些类都位于java.lang.reflect包中:
Class类:代表一个类。
Field 类:代表类的成员变量(成员变量也称为类的属性)。
Method类:代表类的方法。
Constructor 类:代表类的构造方法。
Array类:提供了动态创建数组,以及访问数组的元素的静态方法。
通过Class类获取成员变量、成员方法、接口、超类、构造方法等
在java.lang.Object 类中定义了getClass()方法,因此对于任意一个Java对象,都可以通过此方法获得对象的类型。Class类是Reflection API 中的核心类,它有以下方法
getName():获得类的完整名字。
getFields():获得类的public类型的属性。
getDeclaredFields():获得类的所有属性。
getMethods():获得类的public类型的方法。
getDeclaredMethods():获得类的所有方法。
getMethod(String name, Class[] parameterTypes):获得类的特定方法,name参数指定方法的名字,parameterTypes 参数指定方法的参数类型。
getConstructors():获得类的public类型的构造方法。
getConstructor(Class[] parameterTypes):获得类的特定构造方法,parameterTypes 参数指定构造方法的参数类型。
newInstance():通过类的不带参数的构造方法创建这个类的一个对象。
//下面给出一个综合运用的例子:
public class RefConstructor {
public static void main(String args[]) throws Exception {
RefConstructor ref = new RefConstructor();
ref.getConstructor();
}
public void getConstructor() throws Exception {
Class c = null;
c = Class.forName("java.lang.Long");
Class cs[] = {java.lang.String.class};
System.out.println("\n-------------------------------\n");
Constructor cst1 = c.getConstructor(cs);
System.out.println("1、通过参数获取指定Class对象的构造方法:");
System.out.println(cst1.toString());
Constructor cst2 = c.getDeclaredConstructor(cs);
System.out.println("2、通过参数获取指定Class对象所表示的类或接口的构造方法:");
System.out.println(cst2.toString());
Constructor cst3 = c.getEnclosingConstructor();
System.out.println("3、获取本地或匿名类Constructor 对象,它表示基础类的立即封闭构造方法。");
if (cst3 != null) System.out.println(cst3.toString());
else System.out.println("-- 没有获取到任何构造方法!");
Constructor[] csts = c.getConstructors();
System.out.println("4、获取指定Class对象的所有构造方法:");
for (int i = 0; i < csts.length; i++) {
System.out.println(csts[i].toString());
}
System.out.println("\n-------------------------------\n");
Type types1[] = c.getGenericInterfaces();
System.out.println("1、返回直接实现的接口:");
for (int i = 0; i < types1.length; i++) {
System.out.println(types1[i].toString());
}
Type type1 = c.getGenericSuperclass();
System.out.println("2、返回直接超类:");
System.out.println(type1.toString());
Class[] cis = c.getClasses();
System.out.println("3、返回超类和所有实现的接口:");
for (int i = 0; i < cis.length; i++) {
System.out.println(cis[i].toString());
}
Class cs1[] = c.getInterfaces();
System.out.println("4、实现的接口");
for (int i = 0; i < cs1.length; i++) {
System.out.println(cs1[i].toString());
}
System.out.println("\n-------------------------------\n");
Field fs1[] = c.getFields();
System.out.println("1、类或接口的所有可访问公共字段:");
for (int i = 0; i < fs1.length; i++) {
System.out.println(fs1[i].toString());
}
Field f1 = c.getField("MIN_VALUE");
System.out.println("2、类或接口的指定已声明指定公共成员字段:");
System.out.println(f1.toString());
Field fs2[] = c.getDeclaredFields();
System.out.println("3、类或接口所声明的所有字段:");
for (int i = 0; i < fs2.length; i++) {
System.out.println(fs2[i].toString());
}
Field f2 = c.getDeclaredField("serialVersionUID");
System.out.println("4、类或接口的指定已声明指定字段:");
System.out.println(f2.toString());
System.out.println("\n-------------------------------\n");
Method m1[] = c.getMethods();
System.out.println("1、返回类所有的公共成员方法:");
for (int i = 0; i < m1.length; i++) {
System.out.println(m1[i].toString());
}
Method m2 = c.getMethod("longValue", new Class[]{});
System.out.println("2、返回指定公共成员方法:");
System.out.println(m2.toString());
}
}
运行时复制对象
示例:ReflectTester类有一个copy(Object object)方法,这个方法能够创建一个和参数object 同样类型的对象,然后把object对象中的所有属性拷贝到新建的对象中,并将它返回
这个例子只能复制简单的JavaBean,假定JavaBean 的每个属性都有public 类型的getXXX()和setXXX()方法。
public class ReflectTester {
public Object copy(Object object) throws Exception {
// 获得对象的类型
Class<?> classType = object.getClass();
System.out.println("Class:" + classType.getName());
// 通过默认构造方法创建一个新的对象
Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
// 获得对象的所有属性
Field fields[] = classType.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
String fieldName = field.getName();
String firstLetter = fieldName.substring(0, 1).toUpperCase();
// 获得和属性对应的getXXX()方法的名字
String getMethodName = "get" + firstLetter + fieldName.substring(1);
// 获得和属性对应的setXXX()方法的名字
String setMethodName = "set" + firstLetter + fieldName.substring(1);
// 获得和属性对应的getXXX()方法
Method getMethod = classType.getMethod(getMethodName, new Class[]{});
// 获得和属性对应的setXXX()方法
Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});
// 调用原对象的getXXX()方法
Object value = getMethod.invoke(object, new Object[]{});
System.out.println(fieldName + ":" + value);
// 调用拷贝对象的setXXX()方法
setMethod.invoke(objectCopy, new Object[]{value});
}
return objectCopy;
}
public static void main(String[] args) throws Exception {
Customer customer = new Customer("Tom", 21);
customer.setId(new Long(1));
Customer customerCopy = (Customer) new ReflectTester().copy(customer);
System.out.println("Copy information:" + customerCopy.getId() + " " + customerCopy.getName() + " "
+ customerCopy.getAge());
}
}
class Customer {
private Long id;
private String name;
private int age;
public Customer() {
}
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
输出结果:
Class:com.langsin.reflection.Customer
id:1
name:Tom
age:21
Copy information:1 Tom 21
解说:
ReflectTester 类的copy(Object object)方法依次执行以下步骤
(1)获得对象的类型:
Class classType=object.getClass();
System.out.println(“Class:”+classType.getName());(2)通过默认构造方法创建一个新对象:
Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
以上代码先调用Class类的getConstructor()方法获得一个Constructor 对象,它代表默认的构造方法,然后调用Constructor对象的newInstance()方法构造一个实例。(3)、获得对象的所有属性:
Field fields[]=classType.getDeclaredFields();
Class 类的getDeclaredFields()方法返回类的所有属性,包括public、protected、默认和private访问级别的属性(4)获得每个属性相应的getXXX()和setXXX()方法,然后执行这些方法,把原来对象的属性拷贝到新的对象中
思考:4、Java反射机制好在哪里?
增加程序的灵活性
为什么要用反射机制?直接创建对象不就可以了吗?
这就涉及到了动态与静态的概念
- 静态编译:在编译时确定类型,绑定对象,即通过。
- 动态编译:运行时确定类型,绑定对象。动态编译最大限度发挥了java的灵活性,体现了多态的应用,有以降低类之间的藕合性。
一句话,反射机制的优点就是可以实现动态创建对象和编译,体现出很大的灵活性,特别是在J2EE的开发中.它的灵活性就表现的十分明显。
比如,一个大型的软件,不可能一次就把把它设计的很完美,当这个程序编译后,发布了,当发现需要更新某些功能时,我们不可能要用户把以前的卸载,再重新安装新的版本,假如这样的话,这个软件肯定是没有多少人用的。采用静态的话,需要把整个程序重新编译一次才可以实现功能的更新,而采用反射机制的话,它就可以不用卸载,只需要在运行时才动态的创建和编译,就可以实现该功能。
它的缺点是对性能有影响。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。
JDBC上的使用
Class.forName(“com.mysql.jdbc.Driver.class”).newInstance();
在使用jdbc时侯,在编写访问数据库时写到想吐,有八个表,每个表都有增删改查中操作那时候还不知道有反射机制这个概念,所以就对不同的表创建不同的dao类,这样不仅开发速率低,而且代码冗余的厉害,最要命的是看着差不多的,然后直接复制修改,由于容易犯各种低级的错误(大小写啊,多一个或少一个字母啊……),一个错误就可以让你找半天。
有了java反射机制,什么都好办了,只需要写一个dao类,四个方法,增删改查,传入不同的对象,就OK啦,无需为每一个表都创建dao类,反射机制会自动帮我们完成剩下的事情,这就是它的好处。说白了,反射机制就是专门帮我们做那些重复的有规则的事情,所以现在很多的自动生成代码的软件就是运用反射机制来完成的
数据连接类:
/**
* 数据连接类
*/
public class UtilDao {
static Properties properties = null;
public UtilDao(){
//读取属性文件
properties = new Properties();
java.io.InputStream in = (java.io.InputStream) this.getClass()
.getResourceAsStream("/mysqlDB.properties");
try {
properties.load(in);
} catch (IOException ex) {
System.out.println(ex.getMessage());
ex.printStackTrace();
}
}
public Connection getConn(){
Connection connection = null;
try{
Class.forName(properties.getProperty("DBDriver"));
connection = DriverManager.getConnection(properties.getProperty("url"),properties.getProperty("name"),properties.getProperty("pass"));
}catch (Exception err) {
System.out.println("连接ConDB-->getCon()____JDBC错误!");
err.printStackTrace();
return null;
}
return connection;
}
/**
* 以下是关闭重载方法
*/
public void closeAll(ResultSet rs,Statement st ,CallableStatement cs ,Connection conn) throws SQLException{
if(rs!=null){
rs.close();
}
if(st!=null){
st.close();
}
if(cs!=null){
cs.close();
}
if(conn!=null){
conn.close();
}
}
public void closeAll(ResultSet rs,Statement st,Connection conn) throws SQLException{
if(rs!=null){
rs.close();
}
if(st!=null){
st.close();
}
if(conn!=null){
conn.close();
}
}
public void closeAll(ResultSet rs,PreparedStatement ps,Connection conn) throws SQLException{
if(rs!=null){
rs.close();
}
if(ps!=null){
ps.close();
}
if(conn!=null){
conn.close();
}
}
public void closeAll(PreparedStatement ps,Connection conn) throws SQLException{
if(ps!=null){
ps.close();
}
if(conn!=null){
conn.close();
}
}
public void closeAll(Statement st,Connection conn) throws SQLException{
if(st!=null){
st.close();
}
if(conn!=null){
conn.close();
}
}
public void closeAll(Connection conn) throws SQLException{
if(conn!=null){
conn.close();
}
}
}
属性文件
DBDriver=com.mysql.jdbc.Driver
url=jdbc\:mysql\://localhost\:3306/hzw
name=root
pass=root
characterEncoding=utf8
数据层接口:
/**
* 访问数据方法接口
*/
@SuppressWarnings("unchecked")
public interface IDao<T> {
/**
* 分页查询方法
* @param objClass 类对象
* @param sql 查询语句
* @param params 参数
* @return 分页数据
* @throws Exception
*/
public List<T> findList(Object objClass,String sql, List params)throws Exception;
/**
* 查询一条数据
* @param objClass 类对象
* @param sql 查询语句
* @param params 参数
* @return 一条数据信息
* @throws Exception
*/
public T findInfo(Object objClass,String sql ,List params)throws Exception;
}
数据层接口实现:
/**
* 访问数据方法实现类
*/
@SuppressWarnings({"unchecked","unused"})
public class DaoImpl<T> implements IDao<T> {
private UtilDao dao = new UtilDao();
private Connection conn = null;
private ResultSet rs = null;
private PreparedStatement ps = null;
/*
* 查询一条数据
*/
public T findInfo(Object objClass,String sql, List params) throws Exception {
Class c = objClass.getClass();
try{
conn = dao.getConn();
ps = conn.prepareStatement(sql);
for (int i = 0; i < params.size(); i++) {
if(params.get(i)!=null){
Object obj = params.get(i);
if(obj.getClass().getName().equals("java.lang.String")){
ps.setString(i+1, obj.toString());
}else if(obj.getClass().getName().equals("java.lang.Integer")){
ps.setInt(i+1, Integer.valueOf(obj.toString()));
}else{
ps.setObject(i+1, obj);
}
}
}
rs = ps.executeQuery();
Class type = null ; //属性类型
if(rs.next()){
objClass = c.newInstance();
List<String> list = Reflect003.getKeys(c);
Method method = null;
for (int i = 0; i < list.size(); i++) {
String key = list.get(i);
String mName = "set"+key.substring(0,1).toUpperCase()+key.substring(1);
String typeName = c.getDeclaredField(key).getType().getName();
if(typeName.equals("int")){
type = int.class;
method = c.getMethod(mName, type);
method.invoke(objClass, rs.getInt(key));
}else if(typeName.equals("java.lang.String")){
type = java.lang.String.class;
method = c.getMethod(mName, type);
method.invoke(objClass, rs.getString(key));
}
}
}
}catch(Exception e){
System.out.println("访问数据方法实现类findInfo方法出错");
e.printStackTrace();
}finally{
dao.closeAll(rs,ps,conn);
}
return (T)objClass;
}
/*
* 分页查询方法
*/
public List<T> findList(Object objClass,String sql, List params)
throws Exception {
/*
* 创建返回值对象
*/
List<Object> info = new ArrayList<Object>();
//获得Class对象
Class c = objClass.getClass();
try{
conn = dao.getConn();
ps = conn.prepareStatement(sql);
for (int i = 0; i < params.size(); i++) {
if(params.get(i)!=null){
Object obj = params.get(i);
/*
* 判断参数的原始类型
* 暂时判断Integer跟String类型
*/
if(obj.getClass().getName().equals("java.lang.String")){
ps.setString(i+1, obj.toString());
}else if(obj.getClass().getName().equals("java.lang.Integer")){
ps.setInt(i+1, Integer.valueOf(obj.toString()));
}else{
ps.setObject(i+1, obj);
}
}
}
rs = ps.executeQuery();
Class type = null ; //属性类型
while(rs.next()){
//创建一个实例
objClass = c.newInstance();
//获取所有的字段名称
List<String> list = Reflect003.getKeys(c);
Method method = null;//声明Method对象
for (int i = 0; i < list.size(); i++) {
String key = list.get(i);
String mName = getSetMethodName(key); //组装set方法名称
String typeName = c.getDeclaredField(key).getType().getName(); //获取字段类型名称
/*
* 判断字段类型
*/
if(typeName.equals("int")){
type = int.class; //赋值属性类型
method = c.getMethod(mName, type); //获得Method实例
method.invoke(objClass, rs.getInt(key)); //调用该set方法
}else if(typeName.equals("java.lang.String")){
type = java.lang.String.class;
method = c.getMethod(mName, type);
method.invoke(objClass, rs.getString(key));
}
}
info.add(objClass);
}
}catch(Exception e){
System.out.println("访问数据方法实现类findList方法出错");
e.printStackTrace();
}finally{
dao.closeAll(rs,ps,conn);
}
return (List<T>)info;
}
/**
* 组装set方法
* @param columnName 字段名
* @return
*/
private static String getSetMethodName(String columnName) {
return "set" + columnName.substring(0, 1).toUpperCase()
+ columnName.toLowerCase().substring(1);
}
}
获取所有字段的方法:
/**
* 获取字段名称类
*/
public class Reflect003 {
public static List<String> getKeys(Class<?> c){
List<String> list = new ArrayList<String>();
try{
//根据Class的静态方法获取所以字段名称、不包括继承字段
Field[] fs = c.getDeclaredFields();
for (int i = 0; i < fs.length; i++) {
list.add(fs[i].getName());
}
}catch(Exception e){
e.printStackTrace();
}
return list;
}
}
java 反射机制构建JSON字符串
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import com.test.hzw.bean.test_user;
import com.test.hzw.dao.impl.DaoImpl;
/**
* Json转换测试类
*/
@SuppressWarnings({"unchecked","unused"})
public class Reflect004 {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
DaoImpl dao = new DaoImpl();
test_user u = new test_user();
String sqlPage = "SELECT * FROM test_user WHERE id <= ";
sqlPage += " (SELECT id FROM test_user ORDER BY id LIMIT "+(2-1)*20+", 1) ";
sqlPage += " ORDER BY id LIMIT 20 " ;
/*
* 从数据库查询并获得集合
*/
List<test_user> listT = (List<test_user>)dao.findList(u, sqlPage, new ArrayList());
String s = ToJsonByList(listT);
System.out.println(s);
System.out.println(ToJsonByAll(listT.get(0)).toString());
}
/**
* 根据List集合生成Json数组格式字符串(只支持bean方式)
*/
public static <T> String ToJsonByList(List<T> list){
StringBuffer b = new StringBuffer("[");
if(list!=null&&list.size()>0){
for (int i = 0; i < list.size(); i++){
Object o = list.get(i);
try {
//调用ToJsonByBean方法
StringBuffer s = ToJsonByBean(o);
if(s!=null&&!s.equals("")){
b.append(s).append(",");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
b.append("]");
return b.replace(b.lastIndexOf(","),b.lastIndexOf(",") + 1 ,"").toString();
}
/**
* 根据javaBean生成Json对象格式字符串
* @param object 任意javaBean类型对象
* @return 拼接好的StringBuffer对象
*/
public static StringBuffer ToJsonByBean(Object object) throws Exception{
Class clazz = object.getClass(); //获得Class对象
Field[] fields = clazz.getDeclaredFields(); //获得Class对象的字段数组
StringBuffer sb = new StringBuffer("{");
/*
* 循环字段数组
*/
for (Field field : fields) {
String fieldName = field.getName(); //获得字段名称
//获得字段对应的get方法对象
Method method = clazz.getMethod("get" + change(fieldName), null);
//调用get方法获得字段的值
Object property = method.invoke(object, null);
/*
* 生成json字符串数据
*/
if(property == null){
sb.append("\""+fieldName+"\":\"\",");
}else{
if (field.getType().getName().equals("java.lang.Boolean"))
sb.append("\""+fieldName+"\":"+Boolean.valueOf(property.toString())+",");
else
sb.append("\""+fieldName+"\":\""+property+"\",");
}
}
sb.append("}");
return sb.replace(sb.lastIndexOf(","),sb.lastIndexOf(",") + 1 ,"");
}
/**
* @param src 源字符串
* @return 字符串,将src的第一个字母转换为大写,src为空时返回null
*/
public static String change(String src) {
if (src != null) {
StringBuffer sb = new StringBuffer(src);
sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
return sb.toString();
} else {
return null;
}
}
/**
* 生成Json数组格式字符串
* @param object 任意类型对象
* @return 拼接好的StringBuffer对象
*/
public static StringBuffer ToJsonByAll(Object object) throws Exception{
Class clazz = object.getClass();
Field[] fields = clazz.getDeclaredFields();
StringBuffer sb = new StringBuffer("{[");
for (Field field : fields) {
String fieldName = field.getName();
Method method = clazz.getMethod("get" + change(fieldName), null);
Object property = method.invoke(object, null);
if(property == null){
sb.append("\"\",");
}else{
sb.append("\"" + property + "\",");
}
}
sb.append("]}");
return sb.replace(sb.lastIndexOf(","),sb.lastIndexOf(",") + 1 ,"");
}
}
用反射机制实现对数据库数据的增、查例子
基本原理;保存数据时,把需要保存的对象的属性值全部取出来再拼凑sql语句
查询时,将查询到的数据全部包装成一个java对象。
游戏规则:俗话说的好,无规矩不成方圆,特别是程序来说,它只能做有规则的事情,没有规则的它干不了,好,那就
先定规则
1)数据库的每一个表对象一个pojo类,表中的每一个字段对应pojo类的中的一个属性。
并且pojo类的名字和表的名字相同,属性名和字段名相同,大小写没有关系,因为数据库一般不区分大小写
2)为pojo类中的每一个属性添加标准的set和get方法。
有了游戏规则,那么开始游戏吧。
1、首先数据库的有一个表,假设数据库名称为:blogsystem,里面的一个表名userinfo。如图:
2、创建对应的pojo类:
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;
}
}
3、编写获得数据库连接的工厂类:
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;
}
}
4、编写操作数据库的dao类
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;
}
}
5、测试
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);
}
}
总的来说,java反射机制是一个很好用的东西,用它可以解决很多死的东西,因为反射机制的灵活行很大,有了他,我们就不要花太多的时间来写操做数据库的代码了,而是方法更多的时间在项目的逻辑功能上,这个可以很大的减少开发时间,而且代码的可读性好。先在的很多开源框架都是才用的反射机制,它只要配置文件,然后按规则来调用他的方法就可以了。