何为代理
代理，即代替主角完成一些额外的事情，例如，经纪人作为明星的代理人和出资洽谈片酬，排期等，而正真参与拍戏的还是明星本人，明星拍完戏后，再有经纪人代理明星去清理片酬等。
Java中的代理机制就是在目标方法执行前后执行一些额外的操作，例如安全检查，记录日志等。java中的代理分为静态代理和动态代理。
- 静态代理
直接上代码，模拟登陆操作：
public interface LoginService {
void login();
}
public class LoginServiceImpl implements LoginService {
@Override
public void login() {
System.out.println("login");
}
}
public class LoginServiceProxy implements LoginService {
private LoginService loginService;
public LoginServiceProxy() {
loginService = new LoginServiceImpl();
}
@Override
public void login() {
beforeLogin();
loginService.login();
afterLogin();
}
private void beforeLogin() {
System.out.println("before login");
}
private void afterLogin() {
System.out.println("after login");
}
}
public class Client {
@Test
public void test() {
LoginService loginService = new LoginServiceImpl();
LoginService loginServiceProxy = new LoginServiceProxy(loginService);
loginServiceProxy.login();
}
}
结果输出如下：
before login
login
after login
上面代理很好理解，使用聚合方式，在登陆前执行额外操作。静态代理方式可以看到具体代理类的代码，且代码由程序员编写，在编译之后会生成相应的class文件。
缺点是：如果需要对LoginService接口中有N个方法都代理，则需要在代理类中创建N个代理方法，并且需要编写重复的代理操作代码。
概念解释：
- 目标接口：即对目标操作的抽象，如LoginService;
- 目标类：即目标接口的实现类，如LoginServiceImpl;
- 目标对象：即目标类的实例；
- 代理类：即目标类的代理，如LoginServiceProxy;
- 代理对象：即代理类的实例。
动态代理
动态代理，即在运行时根据目标接口动态生成的代理类。动态代理方法生成的代理类在编译后不会生成实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中使用。
public interface UserService {
public String hello(String name);
}
public class UserServiceImpl implements UserService {
@Override
public String hello(String name) {
System.out.println("hello " + name);
return name;
}
}
/**
* 每次生成动态代理对象时，都需要指定一个实现了InvocationHandler接口的调用处理器对象作为参数
*/
public class InvocationHandlerImpl implements InvocationHandler {
//这个就是我们需要代理的真实对象，也就是真正执行业务逻辑的类
private Object target;
public InvocationHandlerImpl(Object target) {
this.target = target;
}
/**
* 该方法负责处理动态代理类上所有方法的调用
*
* @param proxy 最终生成的代理类实例
* @param method 被调用的方法
* @param args 调用上面方法时传入的参数
* @return method对应方法的返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
startTransaction();
//当代理对象调用真实对象的方法时，会自动跳转到代理对象关联的handler对象的invoke方法来进行调用
Object result = method.invoke(target, args);//代理对象和方法参数
commitTransaction();
return result;
}
private void startTransaction() {
System.out.println("开启事物");
}
private void commitTransaction() {
System.out.println("提交事物");
}
}
/**
* jdk动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
*/
public class JDKProxyTest {
public static void main(String[] args) {
//被代理的对象
UserService userDao = new UserServiceImpl() ;
//目标对象信息
System.out.println("目标对象信息：" + userDao.getClass());
/**
* 生成一个InvocationHandler对象，需要传入被代理对象作为参数
*/
InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(userDao);
Class<?> clazz = userDao.getClass();
/**
* JDK动态代理，有两个重要的类或接口：InvocationHandler, Proxy
* 每个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联了一个handler
* 当我们通过代理类对象调用这个方法时，这个方法的调用都会被转发为由InvocationHandler这个接口的invoke方法来调用
*
* 参数说明：
* 1，指定当前目标对象使用类加载器；2，一组目标对象实现的接口的类型；3，调用处理器生成动态代理类实例（事件处理器）
*
* 我们给代理对象提供了一组什么接口，那么这个代理对象就是实现这组接口，当然也可以强制转换为这组接口中的任意一个
*
* Proxy.newProxyInstance创建的代理对象是在jvm运行时动态生成的一个对象，命名方式都是以$开头，最后一个数字表示对象的标号
*/
//生成动态代理对象
UserService proxy = (UserService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), invocationHandler);
//代理对象信息
System.out.println("代理对象信息：" + proxy.getClass());
String result = proxy.hello("tanhq");
System.out.println("返回值：" + result);
createProxyClassFile();
}
public static void createProxyClassFile() {
String name = "UserServiceProxy";
byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{UserService.class});
try {
FileOutputStream out = new FileOutputStream("/Users/tanhq/test/" + name + ".class");
out.write(data);
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果：
目标对象信息：class com.dalingjia.proxy.jdk.UserServiceImpl
代理对象信息：class com.sun.proxy.$Proxy0
开启事物
hello tanhq
提交事物
返回值：tanhq
JDK动态代理方法实现代理的步骤如下：
- 编写目标接口；
- 编写目标接口的实现类，实现目标方法的具体逻辑；
- 编写一个代理处理器类实现InvocationHandler接口，重写invoke方法，用于指定运行时将生成的代理类需要完成的具体操作，包括startTransaction和commitTransaction。代理对象调用任何代理方法都会调用这个invoke方法；
- 使用Proxy.newProxyInstance静态方法创建代理对象，使用代理对象调用代理方法。
上面步骤主要涉及2个类：
- java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy
- InvocationHandler是一个接口，代理类的调用处理器，每个代理类都要实现该接口。该接口有一个invoke方法，代理对象调用任何目标对象的方法时都会调用这个invoke方法，在这个方法中进行目标类的目标方法的调用。
- Proxy提供静态方法用于创建动态代理类的实例，同时使用它创建的代理类的实例都是他的子类。该类主要关注这个方法public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)；
a，loader参数用于指示使用哪个类加载器加载这个代理类；
b，interfaces表示代理类实现的接口列表；
c，h表示使用哪个调用处理器
代理类解密
对于JDK动态代理，生成的代理类是什么样的？为什么调用代理类的任何方法时都一定会调用invoke方法？
动态代理是在运行时动态生成字节码，编译期看不到相应的class文件，所以不能直观的看到代理内容。先从newProxyInstance方法开始。
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);
}
//1, 生成代理Class对象
Class<?> cl = getProxyClass0(loader, intfs);
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//2，获取构造器
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;
}
});
}
//3，返回代理对象实例
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");
}
return proxyClassCache.get(loader, interfaces);
}
进入get方法：
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();
Object cacheKey = CacheKey.valueOf(key, refQueue);
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
//下面代码省略
}
主要看subKeyFactory.apply(key, parameter) ，继续深入
看到的接口的抽象方法，我们看他的实现类ProxyClassFactory的apply方法
我们会看到生成代理类的包名，以及类名
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
//1，上面代码省略，只看核心代码，生成代理类的包名
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
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) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
//2，生成代理类的类名，由一个原子类AtomicLong生成
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//3, 这里就是真正创建代理类的地方
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
try {
return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
继续分析代码，进入generateProxyClass方法
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
final byte[] var4 = var3.generateClassFile();
if (saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
int var1 = var0.lastIndexOf(46);
Path var2;
if (var1 > 0) {
Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
Files.createDirectories(var3);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class");
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}
我们可以很直白的看到，生成的代理类的字节码文件被输出到了某个目录下，这个字节码文件很难找到，但是我们可以重用generateProxyClass方法，再外面调用generateProxyClass方法，把生成的字节码文件输出到指定位置。也就是上面一开始写的createProxyClassFile();
public static void createProxyClassFile() {
String name = "UserServiceProxy";
byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{UserService.class});
try {
FileOutputStream out = new FileOutputStream("/Users/tanhq/test/" + name + ".class");
out.write(data);
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
我们把字节码文件输出到我的/Users/tanhq/test/目录下，找到它，然后用反编译工具JD-GUI打开。下面是我反编译后的字节码文件
import com.dalingjia.proxy.jdk.UserService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class UserServiceProxy extends Proxy implements UserService{
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public UserServiceProxy(InvocationHandler paramInvocationHandler)
{
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject)
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String toString()
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final String hello(String paramString)
{
try
{
return (String)this.h.invoke(this, m3, new Object[] { paramString });
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
public final int hashCode()
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("com.dalingjia.proxy.jdk.UserService").getMethod("hello", new Class[] { Class.forName("java.lang.String") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
}
从上面的代码我们可以很明显的发现在调用hello方法时调用了invoke方法，很明白的解释了为什么调用目标方法时一定会调用invoke方法。
95
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
