Java基础（核心）4：反射（2：反射总结与应用）

1: 反射的理解

     反射就是把java类中的各种成分映射成一个个的Java对象
     反射就是把java类中的各种成分映射成一个个的Java对象
     反射就是把java类中的各种成分映射成一个个的Java对象

     反射通过有代价解释操作的挺高灵活性 常用于框架开发
     反射通过有代价解释操作的挺高灵活性 常用于框架开发
     反射通过有代价解释操作的挺高灵活性 常用于框架开发

    反射机制实际上就是上帝模式，如果说方法的调用是 Java 正确的打开方式，
    那反射机制就是上帝偷偷开的后门，只要存在对应的class，一切都能够被调用。
    静态编译： 在编译时确定类型，绑定对象
    动态编译：运行时确定类型，绑定对象  
    两者的区别在于，动态编译可以最大程度地支持多态，而多态最大的意义在于降低类的耦合性，
    因此反射的优点就很明显了：解耦以及提高代码的灵活性。
    优势：
        运行期类型的判断，动态类加载：提高代码灵活度     
    劣势：
        性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多

2: 反射的最常用见的应用 （invoke调用）

   1：获取该类 Class studentClass;
   2：获取该类对象
   3：获取该类方法
   4：使用invoke进行调用
   Class studentClass = Class.forName("com.entity.Student");
   Object student = studentClass.getConstructor().newInstance(); 
   Method setNameMethod = studentClass.getMethod(setName,String.class)
    setNameMethod方法调用    student对象  入参是"hesuijin")
   Object result = setNameMethod.invoke(student, "hesuijin");

   Class clazz 的方法
   public Method getMethod(String name,Class<?>... parameterTypes):
   name 方法名   
   parameterTypes 该方法的参数
  Method method 的方法
  public Object invoke(Object obj,Object... args):
  obj : 要调用方法的对象；
  args:调用方式时传入的参数；

    //invoke 源码 非常复杂
    //简单来说，Method的invoke()方法和正常调用方法再虚拟机的实现中最终是调用的同一个实现         
    @CallerSensitive
    public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        //1：检查override，如果override为true，跳过检查；否则继续；
        if (!override) {
        //2：快速检查，判断该方法的修饰符modifiers是否为public，如果是跳过检查；否则继续；
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                //3：详细检查，通过方法的(protected/private/package)修饰符或方法的声明类（例如子类可以访问父类的protected方法）
                //    与调用者caller之间的关系，判断caller是否有权限访问该方法。
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
         // read volatile
        MethodAccessor ma = methodAccessor;            
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

3: 反射的最常用见的应用 （JDK动态代理）

可以获取该接口类的代理实例对象  
该代理实例对象的方法都实现执行方法前后的日志打印

1：目标类的类加载
2：代理需要实现的接口，可指定多个
3：代理对象对应的自定义 InvocationHandler（重写invoke方法）
4：创建对应需要代理的实例

    public Object createProxy(Object proxiedObject) {
        // 目标类的类加载
        ClassLoader classLoader = proxiedObject.getClass().getClassLoader();
        // 代理需要实现的接口，可指定多个
        Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
        //代理对象对应的自定义 InvocationHandler
        DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
        //创建对应需要代理的实例
        return Proxy.newProxyInstance(classLoader, interfaces, handler);
    }

class DynamicProxyHandler implements InvocationHandler {
    private Object proxiedObject;
    public DynamicProxyHandler(Object proxiedObject) {
      this.proxiedObject = proxiedObject;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      //真正的执行相关方法
      log.info("执行前")
      Object result = method.invoke(proxiedObject, args);
       log.info("执行后")
      return result;
    }
  }

4：应用于 JDBC 的数据库的连接 ：

JDBC 的操作中，如果要想进行数据库的连接，则必须按照以下的几步完成
1：通过Class.forName()加载数据库的驱动程序 （通过反射加载，前提是引入相关了Jar包）
2：通过 DriverManager 类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码
3：通过Connection 接口接收连接

public class ConnectionJDBC {  
    //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String DBUSER = "root";  
    //连接数据库的密码  
    public static final String DBPASS = "";  
    public static void main(String[] args) throws Exception { 
          //表示数据库的连接对象  
        Connection con = null; 
        //1、使用CLASS 类加载驱动程序 ,反射机制的体现
        //根据传递包名加载类对象
        Class DriverManager = Class.forName(DBDRIVER); 
        //2、连接数据库  
        //调用构造方法 传递入参：DBURL,DBUSER,DBPASS
        con = DriverManager.getConstructor(DBURL,DBUSER,DBPASS); 
        System.out.println(con);  
         // 3、关闭数据库  
        con.close();
    }

5：应用于 Spring 框架的使用 ：

   Spring 通过 XML 配置模式装载 Bean 的过程：
            1：将程序内所有 XML 或 Properties 配置文件加载入内存中;
            2：Java 类里面解析 xml 或 properties 里面的内容，得到对应实体类的字节码字符串以及相关的属性信息; 
            3：使用反射机制，根据这个字符串获得某个类的 Class 实例; 
            4：动态配置实例的属性
   Spring这样做的好处是：
        不用每一次都要在代码里面去new或者做其他的事情
        以后要改的话直接改配置文件，代码维护起来就很方便了
        有时为了适应某些需求，Java类里面不一定能直接调用另外的方法，可以通过反射机制来实现

public class BeanFactory {
       private Map<String, Object> beanMap = new HashMap<String, Object>();
       /**
       * bean工厂的初始化.
       * @param xml xml配置文件
       */
       public void init(String xml) {
              try {
                     //读取指定的配置文件
                     SAXReader reader = new SAXReader();
                     ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
                     //从class目录下获取指定的xml文件
                     InputStream ins = classLoader.getResourceAsStream(xml);
                     Document doc = reader.read(ins);
                     Element root = doc.getRootElement();  
                     Element foo;
                     //遍历bean
                     for (Iterator i = root.elementIterator("bean"); i.hasNext();) {  
                            foo = (Element) i.next();
                            //获取bean的属性id和class
                            Attribute id = foo.attribute("id");  
                            Attribute cls = foo.attribute("class");
                            //利用Java反射机制，通过class的名称获取Class对象
                            Class bean = Class.forName(cls.getText());
                            //获取对应class的信息
                            java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
                            //获取其属性描述
                            java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
                            //设置值的方法
                            Method mSet = null;
                            //创建一个对象
                            Object obj = bean.newInstance();
                            //遍历该bean的property属性
                            for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {  
                                   Element foo2 = (Element) ite.next();
                                   //获取该property的name属性
                                   Attribute name = foo2.attribute("name");
                                   String value = null;
                                   //获取该property的子元素value的值
                                   for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
                                          Element node = (Element) ite1.next();
                                          value = node.getText();
                                          break;
                                   }
                                   for (int k = 0; k < pd.length; k++) {
                                          if (pd[k].getName().equalsIgnoreCase(name.getText())) {
                                                 mSet = pd[k].getWriteMethod();
                                                 //利用Java的反射极致调用对象的某个set方法，并将值设置进去
                                                 mSet.invoke(obj, value);
                                          }
                                   }
                            }
                            //将对象放入beanMap中，其中key为id值，value为对象
                            beanMap.put(id.getText(), obj);
                     }
              } catch (Exception e) {
                     System.out.println(e.toString());
              }
       }   
       //other codes
}