反射

  反射之中包含了一个'反'字，那就肯定有正，那我们就先从'正'开始
一般情况下，我们使用类的时候必定知道他是什么类，是用来做什么的，于是我们直接对这个类进行实例化，之后使用类的对象进行操作。
  反射则是一开始我们并知道我要初始化的这个类的对象是什么，自然也无法使用new关键字来创建对象了，这个时候，我们就要引入JDK 给我们提供的反射api 进行反射调用，反射就是在运行时才知道要操作的类是什么，并且可以再运行时获取类的完整构造，并调用对应的方法。
Reflection（反射）是java被视为动态语言的关键，反射几只允许程序在执行期借助Reflection API 取得任何类的内部信息，并直接操作任意对象的内部属性及方法。

Java反射机制主要提供了一下功能

• 在运行时构造任意一个类的对象
• 在运行时获取任意一个类所具有的成员变量和方法
• 在运行时调用任意一个对象的方法（属性）

  java是一门面向对象的语言，在面向对象的世界里，万事万物皆对象，既然万事万物皆对象，那么我们的类是不是对象呢？我们写的每一个类都可以看成一个对象，是java.lang.Class类的对象，每一个类对应的Class放在哪里呢？当我们写完一个类的java文件，编译成class文件的时候，编译期都会将这个类的对应的calss对象放在class的末尾，里面都保存了些什么？大家可以理解保存了类的元数据信息,一个类的元数据信息包括什么？有哪些属性，方法，构造器，实现了哪些接口等等，那么这些信息在java里都有对应的类来表示。

Class

Class是一个类，封装了当前对象多对应的类的信息

  一个类中有属性，方法，构造器等，比如说有一个person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个称呼用来描述类，这就是Class，他应该有类名,属性，方法，构造器等，Class是用来描述类的类（这个有点拗口）
  Class类就像是对象本身自己照镜子一样，可以看到自己的全部，有哪些属性，方法，构造器，实现了哪些接口等
  对于每个类而且，JRE都为期保留一个不变的Class类型的对象，一个Class对象包含了特定某个类的有关信息。
  对象只能由系统建立对象,一个类（而不是一个对象）在JVM中只会有一个Class实例

获取Class对象的三种方式

        //实例化对象的标准用法，也就是所谓的正
        Servant servant = new Servant();
        //获取class三种方法
        Class servantClass = Servant.class;
        Class servantClass1 = servant.getClass();
        Class servantClass3 = Class.forName("com.company.Reflect.Servant");

Class类的常用方法

方法

接下来我们就来使用反射来获取属性，方法，构造器等。

ps：因为都是固定的调一些API 此处就直接上代码了

public class Person {
    String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
        System.out.println("this is setName()");
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
        System.out.println("this is setAge()");
    }
    //包含一个带参的构造器和一个不带参的构造器
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    private void privateMethod(){
        System.out.println("this is private method");
    }
}

构造器相关

public class TestConstructor {
    /*构造器相关*/
    public void testConstructor() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        String className ="com.company.Reflect.Person";
        Class<Person> clazz = (Class<Person>) Class.forName(className);
        System.out.println("获取全部constructor对象");
        Constructor<Person>[] constructors = (Constructor<Person>[]) clazz.getConstructors();
        for (Constructor<Person> constructor:constructors) {
            System.out.println(constructor);
        }

        System.out.println("获取某一个constructor对象 需要参数列表-----");
        Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor);

        System.out.println("调用构造器的 newInstance() 方法创建对象-----");
        Person hellow = constructor.newInstance("hellow", 18);
        System.out.println(hellow.getName());
    }
}

接下来我们看一下打印结果

打印结果

方法相关

public class TestMethod {
    public void testMethod() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        String className ="com.company.Reflect.Person";
        Class clazz =Class.forName(className);
        System.out.println("获取clazz中对应类中的素有方法 不能获取private方法，且获取从父类继承来的所有方法");
        Method[] methods = clazz.getMethods();
        for (Method method :methods) {
            System.out.println(" "+method.getName()+"()");
        }
        System.out.println("--------------------------");
        System.out.println("获取所有方法，包括私有方法 所有声明的方法，都可以获取到，且只获取当前类的方法");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method method :declaredMethods) {
            System.out.println(" "+method.getName()+"()");
        }
        System.out.println("--------------------------");
        System.out.println("获取指定的方法 需要参数名称和参数列表，无参数则不需要写");
        Method method = clazz.getDeclaredMethod("setAge", int.class);
        System.out.println(method);
        System.out.println("--------------------------");

        System.out.println("执行方法，第一个参数表示执行那个对象的方法，剩下的参数时执行方法时需要的参数");
        Object instance = clazz.newInstance();
        method.invoke(instance,18);

        System.out.println("执私有方法的执行，必须在调用invoke之前加上一句 method.setAccessible(ture)");
        Method privateMethod = clazz.getDeclaredMethod("privateMethod");
        System.out.println(privateMethod);
        System.out.println("--------------------------");
        System.out.println("执行私有方法");
        privateMethod.setAccessible(true);
        privateMethod.invoke(instance);

    }

打印结果

当不加setAccessible(true)时的结果

不加时报错结果

属性相关

动态模式

代理模式和静态代理

  代理模式 给某一个对象提供一个代理对象，并有代理对象控制对原对象的引用，通俗的来讲代理模式就是我们生活中常见的中介
  举个例子：张三想买某种生活用品，虽然他可以自己去找，但是有点浪费时间和精力，或者自己不好意思去买，于是张三就通过中介Mark来买，Mark来帮张三买一个，张三只是负责选择喜欢的尺寸，然后付钱给Mark就可以了

目的：
1.通过引入代理对象的方式来间接访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性；
2.通过代理对象对原有的业务增强；
代理模式一般会有三个角色：

• 抽象角色：指代理角色和真实角色对外提供的公共方法，一般为一个接口
• 真实角色：需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供代理角色调用。也就是真正的业务逻辑在此。
• 代理角色：需要实现抽象角色接口，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。将统一的流程控制都放到代理角色中处理！
    而访问者不再访问真实角色，而是去访问代理角色。
    静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。一般来说，被代理对象和代理对象是一对一的关系，当然一个代理对象对应多个被代理对象也是可以的。
    静态代理，一对一则会出现时静态代理对象量多、代码量大，从而导致代码复杂，可维护性差的问题，一对多则代理对象会出现扩展能力差的问题。

接下来我们用代码来简单的表述一下静态代理

//代表真实角色
public class AaFactory implements ManToolsFactory {
    @Override
    public void saleManTools(String size) {
        System.out.println("按需求定制了一个size为"+size+"的女model");
    }
}
//抽象角色
public interface ManToolsFactory {
    void saleManTools(String size);
}

/*代理角色*/
public class Mark1 implements ManToolsFactory {
    
    public ManToolsFactory factory;

    public Mark1(ManToolsFactory factory) {
        this.factory = factory;
    }
    
    /*后置处理器*/
    private void doSthAfter() {
        System.out.println("精美包装，快递一条龙服务");
    }

    /*前置处理器*/
    private void doSthBefore() {
        System.out.println("根据需求，进行市场调研和产品分析");
    }

    @Override
    public void saleManTools(String size) {
        doSthBefore();
        factory.saleManTools(size);
        doSthAfter();
    }
}

public static void main(String[] args) {
        ManToolsFactory factory = new AaFactory();
        Mark mark = new Mark(factory);
        mark.saleManTools("D");
    }

静态代理运行结果

  通过运行我们发现确实完成了整个工作逻辑，但是有一个问题，如果这时张三的老婆来了，但是需求不同，需要另一种生活用品，这时怎么办呢？智能是再去增加一个新的抽象接口，去做新的逻辑，这样就造成了一个问题，需要不停去新增，不停的去修改,这就违反了面向对象的开闭原则。同时扩展能力差 可维护性差，所以在一般的正常使用中我们都是采用动态代理来实现。

动态代理

  是指在使用时再创建代理类和实例
  优点
  只需要1个动态代理类就可以解决创建多个静态代理的问题，避免重复、多余代码,更强的灵活性
  缺点
  效率低，相比静态代理中 直接调用目标对象方法，动态代理则需要先通过Java反射机制 从而 间接调用目标对象方法
  应用场景局限，因为 Java 的单继承特性（每个代理类都继承了 Proxy 类），即只能针对接口 创建 代理类，不能针对类创建代理类。
  在java的动态代理机制中，有两个重要的类或接口，一个是InvocationHandler接口、另一个则是 Proxy类，这个类和接口是实现我们动态代理所必须用到的。
  InvocationHandler接口是给动态代理类实现的，负责处理被代理对象的操作的，而Proxy是用来创建动态代理类实例对象的，因为只有得到了这个对象我们才能调用那些需要代理的方法。

下面简单的通过代码来实现一下

public class AaFactory implements ManToolsFactory {
    @Override
    public void saleManTools(String size) {
        System.out.println("按需求定制了一个size为"+size+"的女model");
    }
}

public class BbFactory implements WomanToolsFactory {
    @Override
    public void saleWomanTools(float length) {
        System.out.println("按需求定制了一个高度为"+length+"的男model");
    }
}

public class MarkCompany implements InvocationHandler {

    /*持有的真实对象*/
    private Object factory;

    public Object getFactory() {
        return factory;
    }

    public void setFactory(Object factory) {
        this.factory = factory;
    }

    /*通过proxy获得动态代理对象*/
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(factory.getClass().getClassLoader(),factory.getClass().getInterfaces(),this);
    }


    /*通过动态代理对象方法进行增强*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        doSthBefore();
        Object result = method.invoke(factory, args);
        doSthAfter()；
        return result;
    }

    /*后置处理器*/
    private void doSthAfter() {
        System.out.println("精美包装，快递一条龙服务");
    }

    /*前置处理器*/
    private void doSthBefore() {
        System.out.println("根据需求，进行市场调研和产品分析");
    }
}

public interface ManToolsFactory {
    void saleManTools(String size);
}

public interface WomanToolsFactory {

    void saleWomanTools(float length);

}

public static void main(String[] args) {
        /*动态代理*/
        ManToolsFactory manToolsFactory = new AaFactory();
        MarkCompany company = new MarkCompany();
        company.setFactory(manToolsFactory);
        ManToolsFactory employee = (ManToolsFactory) company.getProxyInstance();
        employee.saleManTools("E");

        WomanToolsFactory womanToolsFactory = new BbFactory();
        company.setFactory(womanToolsFactory);
        WomanToolsFactory employee1 = (WomanToolsFactory) company.getProxyInstance();
        employee1.saleWomanTools(1.9f);
    }

动态代理运行结果

通过打印结果可以看到我们同样的实现了需求，但是工作量要比静态代理少，同时后期维护的话要更省事

  今天的介绍，对于庞大的java来说只是冰山一角，只是通过了一个小的demo来介绍一下反射和代理，所说的这些并不能面面俱到，只能对自己的学习所一个总结，以便于以后的查阅。