反射和动态代理

反射：将类的各个组成部分封装为其他对象

当程序要使用某个类时，计算机会先把这个类加载到内存中，就是将.class文件读入内存，并创建一个Class对象，在Class对象中，类的所有成员变量被放进Field[]数组中，所有方法被放进Method[]数组中，所有构造方法被放进Constructor[]数组中，所以通过class对象可以访问类中的所有内容。

反射的作用：在IDEA中，输入对象 + ‘.’ 之后会弹出对象中方法的提示，用的就是反射。

所有类都是一个Class的对象，通过Class可以看到类的完整结构，通过Class对象，甚至可以访问一个对象的私有变量和方法 

Class Person = new Class()

反射之中包含了一个「反」字，所以想要解释反射就必须先从「正」开始解释。

一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作。

Person person = new Person(); //直接初始化，「正射」
person.setName("张三");

但是也可以反过来，从Class调用Person

Class c1 = Class.forName("包名.Person");       //获得class对象
User user = (new)c1.newInsrance();       //  根据无参构造构造User对象
Method setName = c1.getDeclaredMethod("setName", String.class); //  获得setName方法
setName.invoke(user,"张三");  // 激活方法

 所以反射的过程可以分为4步：

1.获得class对象

2.构造原对象

3.获得方法

4.激活方法

动态代理的底层就是反射，也离不开这4步

动态代理：代理就是为了不直接访问对象，用另一个对象间接访问，比如一个做好的项目需要加功能，为了不把原来正确的代码改错，可以把新功能写在代理中

示例：

先定义一个接口和一个实现类

public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void update() {
        System.out.println("更新了一个用户");
    }

    public void query() {
        System.out.println("查询了一个用户");
    }
}

加入要加入日志功能，用代理实现

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    // proxy : 代理类
    // method : 代理类的调用处理程序的方法对象.
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());  // 日志
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String methodName){
        System.out.println("执行了"+methodName+"方法");
    }


}

public class Client {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理对象的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); //设置要代理的对象
        UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
        proxy.delete();
    }
}