A-A+
Java Proxy的小结
最近太热了,北京的疫情又有所反弹,天天戴个大口罩子,什么事情都不想干了,只想大字型躺在床上——保持呼吸。
今天稍微能够提振心情,简单的记录一下我最近的内部分享,有兴趣的看官凑合读读吧。
首先从静态代理说起。
静态代理的例子分为几步:
1. 声明个接口(I)。
2. 创建个实现类(A),实现接口。
3. 创建个实现类(B),实现接口,同时构造函数的参数类型为接口(I)。
4. B中的实现方法,最终调用的是A的实现方法。
用代码来说就是:
接口(I):
public interface IUserDao {
void saveUser();
void editUser(String id);
}
实现类(A):
public class UserDao implements IUserDao {
@Override
public void saveUser() {
System.out.println("保存");
}
@Override
public void editUser(String id) {
System.out.println(id);
}
}
实现类(B):
public class UserProxyDao implements IUserDao {
private IUserDao userDao;
public UserProxyDao(IUserDao userDao) {
this.userDao = userDao;
}
@Override
public void saveUser() {
userDao.saveUser();
}
@Override
public void editUser(String id) {
System.out.println("在editUser之前");
userDao.editUser(id);
System.out.println("在editUser之后");
}
}
测试一下:
public static void main(String[] args) {
UserProxyDao userProxyDao = new UserProxyDao(new UserDao());
userProxyDao.editUser("1");
}
总结:
没什么难以理解的,要是不怕麻烦,声明百八十个类,就能把想干的事干了。
不过,程序员不就是一帮懒的不能再懒的人,总想一劳永逸,于是就有了动态代理。
本文以JDK动态代理来说明。动态代理就是把实现类(B)搞成通用的,构造函数里面传个A,就给返回A的实例化对象。如果传入了个C,就返回C的实例化对象。
怎么实现呢,代码也挺简单的:
public class ProxyFactory {
private Object object;
public ProxyFactory(Object object) {
this.object = object;
}
public Object getInstance() {
return Proxy.newProxyInstance(
object.getClass().getClassLoader(),
object.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("在" + method.getName() + "之前");
Object returnValue = method.invoke(object, args);
System.out.println("在" + method.getName() + "之后");
return returnValue;
}
});
}
}
测试一下:
public static void main(String[] args) {
//可以随便扔进去对象了
ProxyFactory proxyFactory = new ProxyFactory(new UserDao());
IUserDao userDao = (IUserDao) proxyFactory.getInstance();
userDao.editUser("1");
}
到这里,就可以发挥脑洞去想想Spring是怎么实现对象代理的。
有兴趣的话可以看看:
org.springframework.aop.framework.DefaultAopProxyFactory
老规矩,如有问题,欢迎指正。太热了,还是大字型继续躺着吧。
