java中的代理是什么：

代理就是通过代理对象去访问实际的目标对象，比如买火车票，我们可以去火车站买票，也可以从代售点买票，通过代售点的方式就是代理。在java中，代售点就是就是代理类，不仅可以实现目标对象，还可以增加一些额外的功能。据我所知java中的代理方式有两种，一种是静态代理，一种是动态代理。

什么是静态代理：

静态代理就是代码运行之前，这个代理类就已经存在了，还是以买火车票为例子，在代码中先创建一个通用的买票接口

/**
 * 卖票接口
 *
 * @Dte:2022/9/3
 */
public interface SellTickets {
    /**
     * 卖票方法
     */
    void sell();
}

然后需要一个真实的类

/**
 * 火车站 具有卖票功能，所以需要实现SellTickets接口
 *
 * @Dte:2022/9/3
 */
public class TrainStation implements SellTickets {

    @Override
    public void sell() {
        System.out.println("火车站卖票......");
    }
}

最后需要一个代理类

/**
 * 代售点
 *
 * @Dte:2022/9/3
 */
public class ProxyPoint implements SellTickets {

    private TrainStation station = new TrainStation();

    @Override
    public void sell() {
        System.out.println("代售点收取一些费用......");
        station.sell();
    }
}

代理类可以在不更改被代理对象的情况下去增加功能

/**
 * @Dte:2022/9/3
 */
public class Client {
    public static void main(String[] args) {
        //创建代售点对象
        ProxyPoint proxyPoint = new ProxyPoint();   
        //调用方法进行买票
        proxyPoint.sell();
    }
}

/**
代售点收取一些费用......
火车站卖票......
**/

静态代理的缺点

因为静态代理在代码运行之前就已经存在代理类了，所以每一个代理对象都需要去建一个代理类去代理，当需要代理的对象有很多时，就需要创建很多的代理类，降低了程序可维护性。所以有了动态代理。

什么是动态代理

动态代理指代理类不写在代码中，而是在运行过程中产生，java提供了两种动态代理，分别是jdk的动态代理和基于Cglib的动态代理。

JDK动态代理

要想用jdk动态代理，可以先写一个ProxyHandler类，这个类实现了InvocationHandler接口，并重写里面的invoke方法，invoke方法里有被代理对象的需要被增强的方法，到这里只是定义了被代理类的通用增强方法，要想真正使用的话，需要通过Proxy.newProxyInstance，它的目的是在运行期间生成代理类，它的参数是类加载器，目标类实现的接口，InvocationHandler对象，要注意的是Proxy.newProxyInstance的返回值需要用被代理类所实现的接口来接，接住的就是代理对象，如果代理对象中的方法被调用，就会调用InvocationHandler实现类中的invoke方法，这里面有需要增强的内容。

通用接口

/**
 * 卖票接口
 *
 */
public interface SellTickets {
    /**
     * 卖票方法
     */
    void sell();
}

具体类

/**
 * 火车站 具有卖票功能，所以需要实现SellTickets接口
 *
 */
public class TrainStation implements SellTickets {

    @Override
    public String sell() {
        System.out.println("火车站卖票......");
        return "我正在被打印";
    }
}

ProxyHandler类

public class ProxyHandler implements InvocationHandler {
    Object object;

    public ProxyHandler(Object object) {
        this.object = object;
    }

    /**
     * @param proxy  代理对象
     * @param method 要实现的方法
     * @param args   方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("注册账号......");
        Object invoke = method.invoke(object, args);
        return invoke;
    }
}

public class ProxyTest {
    public static void main(String[] args) {
        TrainStation trainStation = new TrainStation();
        InvocationHandler proxyHandler = new ProxyHandler(trainStation);
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(trainStation.getClass().getClassLoader()
                , trainStation.getClass().getInterfaces()
                , proxyHandler);
        String sell = sellTickets.sell();
        System.out.println(sell);
    }
}

/**
注册账号......
火车站卖票......
**/

动态代理的优势

静态代理的话需要对每一个被代理对象都创建一个代理对象，因为静态代理是在项目运行前就写好的。但是动态代理不是，动态代理是在运行期间才创建代理类，所以只需要创建一个动态代理类就可以。比如我在写一个被代理的对象招聘员工。

首先先写一个通用接口

/**
 * 招聘接口
 *
 */
public interface Recruit {
    /**
     * 招聘方法
     */
    void find();
}

再写一个被代理对象的类

public class TrainStationCenter implements Recruit {

    @Override
    public void find() {
        System.out.println("火车站总部在招人......");
    }
}

不写代理类源代码，直接用动态代理生成

public class ProxyTest {
    public static void main(String[] args) {
        TrainStationCenter trainStationCenter = new TrainStationCenter();
        InvocationHandler proxyHandler1 = new ProxyHandler(trainStationCenter);
        Recruit proxyInstance = (Recruit) Proxy.newProxyInstance(trainStationCenter.getClass().getClassLoader()
                , trainStationCenter.getClass().getInterfaces()
                , proxyHandler1);
        proxyInstance.find();
    }
}

/**
注册账号......
火车站总部在招人......
**/

通过动态代理，就可以使用一个动态代理类，去代理多个对象。

动态代理只能代理接口，要想代理类，可以使用cglib的动态代理类

首先写一个真实的类，比如火车站类，里面有卖票的方法

public class TrainStation {
    /**
     * 卖票方法
     */
    public void sell() {
        System.out.println("火车站卖票......");
    }
}

然后写一个ProxyHandler，它实现了MethodInterceptor接口，重写了intercept方法，类似于jdk中的invoke方法

public class ProxyHandler implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("注册......");
        Object o1 = methodProxy.invokeSuper(o, objects);
        return o1;
    }
}

不写代理类源代码，直接用cglib动态生成字节码

public class ProxyTest {
    public static void main(String[] args) {
        //创建Enhancer对象，类似于JDK动态代理中的Proxy类，下一步就是设置几个参数
        Enhancer enhancer = new Enhancer();
        //设置目标类的字节码文件
        enhancer.setSuperclass(TrainStation.class);
        //设置回调函数
        enhancer.setCallback(new ProxyHandler());
        //创建代理对象
        TrainStation trainStation = (TrainStation) enhancer.create();
        trainStation.sell();
    }
}
/**
注册账号......
火车站卖票......
**/

哪些地方用到了动态代理

spring中的AOP思想就是使用了动态代理，AOP通过动态代理对目标方法进行了增强，比如拦截器。