java 反射回顾

    最近一段时间把java基础又重新看一遍，感觉以前有很多不懂得地方，现在能明白了点，但是源码还是没有看，也是刚刚看完java反射，就过来把看过的都记下来，以备后面方便回顾；

     java反射机制，在spring框架中用到的比较多，像ioc和aop这个两个是spring的核心，大部分用到的都是反射原理，aop则用到的是动态代理；

     我总结了一下，我感觉看完一遍java反射机制，用大白话来说就是，不是明着要，而是背后玩手段，去强取豪夺，怎么背后玩手段那，请看一下内容：

     一.怎么样获得class对象：

       1.通过.class来获取对象；

       2.通过getClass来获取对象；

       3.通过class.forName(String clazzName)来获取class对象；

      第一种性能更好，因为这种代码在编译的时候就可以验证该类是否存在，并且不会调用其他的方法来获取class对象，可以直接就获取class对象；

      而第三种，则是传入一个包名，来获取class对象；

     通过class对象可以调用构造方法、属性、构造器

   二、使用反射来生成对象

      一般用反射来生成对象，spring中xml文件配置的时候，就是利用这个原理

      1. 利用class.newInstance()来创建对象，这个其实就是利用反射来进行new 一个对象的操作。

      2. 如果不想利用默认的构造函数去创建对象，可以调用带有参数的构造函数，然后去创建对象

     例如：

              Class clazz=Class.forName(String clazzName);//获取一个class对象

              Constructor ctor=clazz.getConstructor(String.Class);//获取带有参数的构造方法

              Object obj=ctor.newInstance(); //然后创建对象

  三、使用反射来调用方法

           利用反射来调用方法，每个method对象都有一个invoke(Object obj,String args)方法，obj则是主调对象，主调对象，则是你想要调用的那个类，而args则是传过来的参数例如：

              Method mt=class.getMethod("方法名称"，“参数类型”);

               mt.invoke(obj,"参数");

   spring就是这种将filed、和对象放在配置文件里面，然后进行解耦操作就是我们所说的springIoc操作

四、访问属性

      对象可以通过反射来访问属性，这种属性可以是私有也可以是公有的，并且调用该属性的set和get方法来传值和获取值

       Filed filed=class.getDeclaredFiled("属性名称");   //获取要反射的属性名称

       filed.setAccessible(true);//设置取消访问权限这样就可以对私有的属性进行访问操作了

       filed.set("对象名称","参数");

五、使用反射生成动态代理：

    动态代理：就是半路杀出个程咬金 ,哈哈，我感觉这解释太酷了，所谓代理，就是客户访问的其实是代理，不是实际的对象，代理实现了实际对象的接口的方法，但是却延迟了，访问实际对象的方法。简而言之就是半路插了一竿子；

     实现动态代理的同时总是跟着一个叫做InvocationHandler的这个方法，计算机，实现了某个目标对象的代理之后，紧跟着就是用InvocationHandler来去怎么样的去实现方法；

     动态代理则用Proxy它是所有代理的父类

     代码如下：

      public Interface Dog{

       void info();

       void  run();

       }

     public class GunDog implements Dog{

         public void info(){

            System.out.print("我是一条小狗");

        } 

         public void run(){

             System.out.print("我跑的很快");

          }

     }

    public class DogUtils{

      public void method1(){

         System.out.print("模拟方法1");

      }

     public void method2(){

         System.out.print(“模拟方法2”);

     }

     }

public class MyInvocationHandler implements InvocationHandler{

       private Object target;

      public void setTarget(Object target){

       this.target=target;

     }

    public Object invoke(Object proxy,Method method,Object[] args)throws Exception{

        DogUtils dogutils=new DogUtils ();

        dogutils.method1();

        Object obj=method.invoke(target,args);

        dogutils.method2();

         return obj;

    }

 }

public class MyProxyFactory {

    public Object static getProxy(Object target){

              MyInvocationHandler invocationHandler=new MyInvocationHandler ();

              invocationHandler.setTarget(target);

             return Proxy.newProxyInatance(target.getClass().getClassLoader(),target.getClass.getInterface,invocationHandler)

}

}

public class Test{

public static void main(String[] args){

      Dog dog=new GunDog ();

      Dog dog=(Dog)MyProxyFactory .getProxy(dog);

      dog.info();

      dog.run();

}

}