什么是反射
反射就是指程序在运行的时候可以知道一个类的自身信息。
对于任何一个类：可以知道这个类的属性和方法。
对于任何一个对象：可以调用这个对象的任何一个方法和属性。
反射就是把java类中的各种成分映射成一个个的Java对象
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行 解剖，把个个 组成部分映射成一个个对象。
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
反射的功能
在运行时判断任意一个对象所属的类
在运行的时候构造任意一个类的对象
在运行时判断一个类所具有的成员变量和方法
在运行时调用任何一个对象的方法
生成动态代理（会有一篇关于动态代理的文章，在这里挖坑）
反射的优点和缺点
动态编译和静态编译
反射用到的是动态编译，既然有动态编译，就会有静态编译
那么动态编译和静态编译又有什么区别？
静态编译:在编译的时候进确定类型，如果绑定对象成功，new 是静态加载类，就编译通过。
1 代码示例
2 解释
当在Phone.java里面写好代码的时候，如果需要添加新的类，则需要直接在文件里面修改代码。假如需要添加一个华为手机，则我需要在Phone.java文件里面加个if语句判断传进来的参数是不是"huawei",这样增加了类之间的耦合性。
当删除一个类的时候Phone.java编译可能会出现错误。 假如我删除了小米手机这个类，phone.java文件没有删除if判断语句，那么phone.java在编译的时候则会失败。
没删除Xiaomi.java编译的时候是成功并且成功运行
删除Xiaomi.java编译的时候就会失败了，因为Xiaomi.java不存在
动态编译:在运行的时候确定类型，绑定对象。最大发挥了Java的多态，降低类之间的耦合性。
1 代码示例
Phone.java
2 解释
（1）对比静态编译，当我们需要往Phone.java里面传递新的类参数的时候，根本不需要修改Phone.java的代码，因为这里应用了Java的多态。只要新建一个新的类实现了PhoneInterface的接口，把类名传进去就可以调用。这里体现了 需要哪个类的对象就动态的创建哪个类的对象，也就是说动态的实现了类的加载。
（2）当删除一个类的时候，Phone.java文件不会编译失败。
比如说删除OnePlus.java
区别：这里说明了动态加载的在不修改Phone.java的前提下不会因为其它类的不存在而导致整个文件不能编译，而静态加载则会编译的时候绑定对象，从而导致编译失败。
优点
以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。
缺点
对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。
Class类和类类型
Class类
所有的类是java.lang.Class类的对象，Class类是所有类的类，反射的基础。
Class对象（类类型）
普通类构造对象是：Student s = new Student();
但Class对象则不是，看Class类的源码，构造器是私有的，则用户无法直接像普通类那样new一个Class的对象，只有JVM才可以构造Class对象。
private Class(ClassLoader loader) { // Initialize final field for classLoader. The initialization value of non-null // prevents future JIT optimizations from assuming this final field is null. classLoader = loader; }
但是我们可以通过一个已知的类获得Class对象
有以下三种方式：
Class s = Student.class;
Class s1 = new Student().getClass();
Class s2 = Class.forName("Student");
Class对象就是类类型，在这里表示的是Student类的类型，下面看一个图了解Class对象是什么和类在JVM中加载的过程
由图中可以看出，一个具体的Class对象就保存了具体类的基本属性和方法，并且可以调用。
Student类
反射相关操作
文章开始说过，反射会把一个类的成分（成员变量，方法，构造器）各自映射成一个个对象（Field对象，Method对象，Construct对象），
一个类中这些成员方法、构造方法、在加入类中都有一个类来描述。
java.lang.reflect.Constructor; java.lang.reflect.Field; java.lang.reflect.Method; java.lang.reflect.Modifier;
通过Class对象我们可以做什么呢？
获取成员方法Method
获取成员变量Field
获取构造函数Construct
获取成员方法
用法
例子
结果
只要知道包的限定名，就可以对Student这个类进行所有操作
获取成员变量信息
成员变量 = 成员类型+变量名
用法
获取成员变量，通过Class类的以下方法，变量是成员变量名
例子
获取构造函数信息
获取构造函数，Class的方法如下
用法
例子
Student类的私有构造函数
获取私有的构造函数，并且设置为public从而可以创建对象
结果
实现对数据库增，查。
原理
保存数据时：把pojo类的属性取出来，拼凑sql语句
查询数据的时：把查询到的数据包装成一个Java对象
一张数据表对应java的一个pojo对象，表中的每一个字段（column）对应pojo的每一个属性
数据表名和Pojo的类名相等，column和pojo的属性相等，不区分大小写（数据库中不区分大小写）
pojo的每一个属性的get和set方法，都是为了后续的操作
实例
数据表User
pojo User类
package dbtest;
public class User {
private int id;
private String name;
private String pwd;
private int age;
@Override
publicStringtoString()
{
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", pwd='" + pwd + '\'' +
", age=" + age +
'}';
}
publicintgetId(){
return id;
}
publicvoidsetId(intid){
this.id = id;
}
publicStringgetName(){
return name;
}
publicvoidsetName(String name){
this.name = name;
}
publicStringgetPwd(){
return pwd;
}
publicvoidsetPwd(String pwd){
this.pwd = pwd;
}
publicintgetAge(){
return age;
}
publicvoidsetAge(intage){
this.age = age;
}
}
数据库连接的工厂类
操作数据库的dao
package dbtest;
import org.springframework.web.bind.annotation.ResponseBody;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class SqlSession {
publicstaticStringgetSaveObjectSql(Object o)throws InvocationTargetException, IllegalAccessException{
String sql = "insert into ";
/*获取Class对象*/
Class c = o.getClass();
/*获取pojo所有的方法*/
Method[] methods = c.getDeclaredMethods();
/*获取全类名*/
String cName = c.getName();
/*通过全类名获取数据库名称*/
String tableName = cName.substring(cName.lastIndexOf(".")+1,cName.length());
sql+= tableName + "(";
/*字段名字*/
List<String> fieldList = new ArrayList<>();
/*字段对应的值*/
List valueList = new ArrayList();
/*遍历Class对象的Method对象，就可以执行相对于的方法了*/
for (Method method :
methods) {
String methodName = method.getName();
/*找出get方法，并设置值*/
if(methodName.startsWith("get") && !method.equals("getClass")){
String fieldName = methodName.substring(3,methodName.length());
fieldList.add(fieldName);
Object res = method.invoke(o,null);
if(res instanceof String){
valueList.add("\""+res+"\"");
}else{
valueList.add(res);
}
}
}
/*拼接sql语句的字段*/
for (int i = 0; i <fieldList.size() ; i++) {
if(i < fieldList.size() - 1){
sql += fieldList.get(i) + ",";
}else{
sql += fieldList.get(i) + ") values (";
}
}
/*拼接sql语句的值*/
for (int i = 0; i <valueList.size() ; i++) {
if(i < valueList.size()-1){
sql += valueList.get(i) + ",";
}else{
sql += valueList.get(i) + ")";
}
}
return sql;
}
/*保存数据的操作*/
publicintsaveObject(Object o)throws InvocationTargetException, IllegalAccessException, SQLException{
Connection connection = ConnectDBFactory.getDBConnection();
String sql = getSaveObjectSql(o);
PreparedStatement statement = connection.prepareStatement(sql);
int i = 0;
i = statement.executeUpdate();
return i;
}
/*
* 查询数据，查询出来的数据映射到pojo的每一个属性上
* */
publicObjectgetObject(String pname,intid)throws ClassNotFoundException{
/*通过包名获取数据表名*/
String tableName = pname.substring(pname.lastIndexOf(".")+1,pname.length());
String sql = "select * from " + tableName + " where Id = " + id;
Connection conn = ConnectDBFactory.getDBConnection();
Class c = Class.forName(pname);
Object obj = null;
try{
Statement statement = conn.createStatement();
ResultSet resultSet = statement.executeQuery(sql);
Method[] methods = c.getDeclaredMethods();
while(resultSet.next()){
obj = c.newInstance();
for (Method method :methods
) {
String methodName = method.getName();
if(methodName.startsWith("set")){
/*通过方法名获取数据库的列名*/
String columnName = methodName.substring(3,methodName.length());
/*获取参数的类型*/
Class[] params = method.getParameterTypes();
/*判断参数的类型*/
if(params[0] == String.class){
method.invoke(obj,resultSet.getString(columnName));
}
if(params[0] == int.class){
method.invoke(obj,resultSet.getInt(columnName));
}
}
}
}
}catch (Exception e){
e.printStackTrace();
}
return obj;
}
publicstaticvoidmain(String[] args){
try{
SqlSession session = new SqlSession();
User user = new User();
user.setAge(22);
user.setName("JiemingLi");
user.setId(44);
user.setPwd("123456");
int resNum = session.saveObject(user);
if(resNum > 0){
System.out.println("成功");
}else{
System.out.println("插入失败");
}
User res = (User)session.getObject("dbtest.User",44);
System.out.println(res);
}catch (Exception e){
e.printStackTrace();
}
}
}
结果
总结
Java反射非常好用，灵活性非常大，不用花费太多的时间去写操作数据库的代码，让重点在开发者的业务逻辑上。现在很多和数据库操作的框架都用到反射，只要配置文件，按照框架的规则就可以对数据库进行相对应的操作了。
