反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。
JDK的java.lang.reflect包提供了反射支持。

1.Class类

程序运行期间，Java会给每个对象都维护一个运行时类型标识。该对象保存着该类的信息。

三种获取Class类的方法：

• object.getClass()
• Class.forName(类的全路径名)
• Employee.class

2.反射

java.lang.reflect包下有三个类Field、Method、Constructor分别描述了域、方法、构造器。可以获取类的所有信息。
Class类的getFields、getMethods、getConstructors方法会返回响应的的信息。

两个简单例子

下面实现了两个相同的操作，不同的是在反射中我们可以事先没有得到该类，通过反射的方法去new 实例，并调用方法。

3.动态代理

代理类在程序运行时完成创建的代理方式被成为动态代理。

动态代理相对于静态代理来说，耦合性更低。像静态代理如果需要代理100个接口，就得写100个代理类，而动态代理只需要一个。

3.1 JDK动态代理

接口以及被代理对象

public interface House {
    void sell();
}

public class Bieshu implements House{
    @Override
    public void sell() {
        System.out.println("卖了大别墅~");
    }
}

InvocationHandler

public class HouseHandler implements InvocationHandler {
    private Object obj;


    public HouseHandler(Object obj){
        super();
        this.obj = obj;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
        System.out.println("出售前~");
        method.invoke(obj);
        System.out.println("出售后~");
        return null;
    }
}

main方法

    public static void main(String[] args) {
        Bieshu bieshu = new Bieshu();
        HouseHandler houseHandler = new HouseHandler(bieshu);
        Class<?> bieshuClass = bieshu.getClass();
        House proxyInstance = (House) Proxy.newProxyInstance(bieshuClass.getClassLoader(), bieshuClass.getInterfaces(), houseHandler);
        proxyInstance.sell();
    }


--------------------------------
出售前~
卖了大别墅~
出售后~ 

所以总的来说JDK代理就是两层代理，Proxy代理了InvocationHandler，而InvocationHandler代理了被代理类。

3.2 CGLib代理

代理的目的是构造一个和被代理对象有相同行为的对象，所以不一定需要通过持有的方式来实现，也可以通过继承，并重写父类方法来实现。CGLib就是如此。

被代理类

public class HelloService {

    public HelloService() {
        System.out.println("HelloService构造");
    }

    /**
     * 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的
     */
    final public String sayOthers(String name) {
        System.out.println("HelloService:sayOthers>>" + name);
        return null;
    }

    public void sayHello() {
        System.out.println("HelloService:sayHello");
    }
}

MethodInterceptor

public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
        // 这里增强
        System.out.println("收钱");

        return arg3.invokeSuper(arg0, arg2);
    }

}

main

    public static void main(String[] args) {
        // 通过CGLIB动态代理获取代理对象的过程
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(HelloService.class);
        // 设置enhancer的回调对象
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理对象
        HelloService proxy= (HelloService)enhancer.create();
        // 通过代理对象调用目标方法
        proxy.sayHello();
    }

3.3 两者的区别

• JDK动态代理是面向接口的

• CGLib动态代理是通过字节码底层继承来实现的。

• spring中当被代理类是实现类就会使用JDK代理，否则则用CGLib

• CGLib创建动态代理对象在运行中比JDK代理的快很多，所以使用单例时比较适合。

• CGLib创建动态代理对象在创建中比JDK代理的慢很多

• 目前随着JDK的版本提高，JDK动态代理的效率已经比CGLib高了。

public class ReflectTest {
    public static class BasketBall{
        private int price;

        public int getPrice() {
            return price;
        }
        public void setPrice(int price) {
            this.price = price;
        }
    }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 1.正常调用
        BasketBall basketBall = new BasketBall();
        basketBall.setPrice(10);

        // 2.反射调用
        System.out.println(basketBall.getClass().getName());
        String name = "reflect.ReflectTest$BasketBall";
        Class classBasketBall = Class.forName(name);
        Method method = classBasketBall.getMethod("setPrice", int.class);
        Constructor constructor = classBasketBall.getConstructor();
        Object instance = constructor.newInstance();
        method.invoke(instance,10);
        
    }
} 

3.4 AOP

AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。在OOP中允许定义从上到下的关系，但是对横向关系就无能为力了，AOP就提供了横向的处理能力。比如说日志，权限校验等功能会横切在代码中，这会导致代码不能复用。

spring 通过动态代理实现了AOP。