前言
如果你学习过spring，那么你一定接触和使用过Aop。大家都知道Spring的Aop是采用动态代理方式实现的。而在Spring的Aop中使用的动态代理通常有两种：
- java原生的动态代理
- cglib的动态代理
我们都学习过这两种代理方式的区别。java原生的动态代理所代理的对象必须要实现一个顶级接口，而cglib的动态代理则不需要这样的接口。在很长一段时间里很迷惑为什么java的动态代理一定要实现一个接口？
所以带着疑问，我看了一下java动态代理的源码，这才找到问题所在。
java代理大揭秘
java代理实现
首先我们来看下如何实现一个java的动态代理
//定义一个接口，描述所有具有歌唱技能的人
public interface IsSing {
public void sing();
}
//定义一个歌手类，实现IsSing是必须的，为什么需要实现这个接口，也是我们这次要解释的重点
public class Singer implements IsSing {
public void sing(){
System.out.println("唱了一首歌");
}
}
//定义一个处理类
//动态代理之所以能够增强原方法，就是因为这个类，在创建代理对象的时候需要将此类作为参数传入
public class SingerAgentHandler implements InvocationHandler {
private IsSing singer;
public SingerAgentHandler(IsSing isSing) {
this.singer=isSing;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("和粉丝互动");
//执行原来的方法
Object object=method.invoke(singer,args);
System.out.println("鞠躬表示感谢");
return object;
}
}
//进行测试
public class JavaAgentMain {
public static void main(String[] args) {
Singer singer=new Singer();
//创建一个代理对象
IsSing isSing= (IsSing) Proxy.newProxyInstance(Singer.class.getClassLoader()
,new Class[]{IsSing.class},new SingerAgentHandler(singer));
isSing.sing();
}
}
以上便是java动态代理的实现，可以看到，首先我们定义了一个IsSing的接口，之所以定义这个接口，是因为此接口是用以对拥有唱歌技能的一类人的抽象。该接口可以用来描述歌唱家，歌星，声乐老师等……，因为他们都有歌唱的技能（sing()）。
但是每个人在唱歌前后的状态和动作可能是不一样的，例如一个歌星在开演唱会，他可能在唱歌之前需要先和粉丝互动，而唱完歌之后可能需要对粉丝表示一些感谢之类的。这个时候sing（）这个方法可能就不能完全的描述一个歌星的行为了。于是我们需要对sing（）方法进行扩展，这也是代理存在的意义。
所谓代理，既在保留原有公用功能的基础上，对特定的需要进行更进一步描述的行为进行增强。
源码说明
//创建一个代理对象
IsSing isSing= (IsSing) Proxy.newProxyInstance(Singer.class.getClassLoader()
,new Class[]{IsSing.class},new SingerAgentHandler(singer));
可以看到，在创建一个代理对象的时候，我们传入了三个参数
- ClassLoader:类加载器，类加载器一般都是用来加载资源的
- 顶级接口（IsSing）:动态代理是动态的生成一个动态对象，从以上返回值就可以看出，他生成的对象必定是一个可以强转成IsSing的代理对象，即一个实现了IsSIng的对象
- 增强Handler:用以对原方法进行扩展
到这里，我们首先可以明确一点，java动态代理生成的对象会实现所定义的接口。
但我们知道要让两个类之间产生关系，除了implement外还可以使用extends。但为什么java动态代理中不采用extends呢？
我们比较一些两种方式的不同，大概就明白了采用“实现接口的方式”的必然性，因为大家都知道java的机制是不能进行多继承的，但可以进行多实现。
回到我们的主题：为什么java动态代理必须要实现一个接口？
我们现在可以给出一个猜测：因为java单继承的限制造成了java动态代理需要实现一个接口。
接下来我们来看源码：
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
//获取代理类
Class<?> cl = getProxyClass0(loader, intfs);
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//获取带有InvocationHandler.class的构造方法
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//返回代理对象
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
上面的源码中核心是Class<?> cl = getProxyClass0(loader, intfs);该方法获取到一个代理类。我们进入该方法
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//从缓存中获取，找到proxyClassCache 定义的地方可以看到
return proxyClassCache.get(loader, interfaces);
}
//其中包含一个ProxyClassFactory,该类负责动态生成一个代理对象
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
//动态生成代理对象的工厂
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
if (proxyPkg == null) {
//默认生成的代理对象的包围com.sun.proxy
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
//默认代理对象名称为$Proxy+数字
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//获取一个代理类的字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}
从上面源码我们知道，动态生成的代理类默认放在com.sun.proxy中，并且类名为$Proxy为前缀。
对我们测试方法改造下
public static void main(String[] args) {
Singer singer=new Singer();
//设置系统属性，设置后产生的代理类会保存到com.sun.proxy中
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
IsSing isSing= (IsSing) Proxy.newProxyInstance(Singer.class.getClassLoader(),new Class[]{IsSing.class},new SingerAgentHandler(singer));
isSing.sing();
}
反编译类文件可以看到
可以看到生成的代理类中继承了Poxy类，所以由于java的单继承特点，java生成代理类就必须只有implete接口这一条路可走了。
总结
总的来说，java提供的代理实现，之所以要求我们必须提供一个接口，是因为它在生成代理类的时候已经继承了Proxy类，只能通过实现的方式来建立与我们需要代理的类的联系。
扫一扫
2308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
