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通过动态代理对目标方法进行了增强,比如拦截器。