1、为什么要动态代理
动态代理的作用其实就是在不修改原代码的前提下，对已有的方法进行增强。
关键点：
- 不修改原来已有的代码（满足设计模式的要求）
- 对已有方法进行增强
比如，我们想在每次调用某个类的save方法时，都在日志文件里写下日志信息，这时候，在不影响原来的代码的封装的前提下，我们可以手动的去创建一个该类的代理类，来代替该类帮我们实现一些附加的方法。
2、实现方式
JAVA中，实现动态代理有两种方式，一种是JDK提供的，一种是第三方库CgLib提供的。特点如下：
- JDK动态代理：被代理的目标类需要实现接口
CgLib方式：可以对任意类实现动态代理
3、具体实现
3.1基于接口的 JDK 动态代理
现在有一个 saveUser() 方法，我想在不改变这个方法代码的情况下，在方法前后做一下增强，分别打印一条日志，模拟一下业务代码的增强效果。
这里我们创建一个工具类，用来编写两种代理模式的代码：MyProxyUtil。
1、接口类：UserService
public interface UserService {
void saveUser();
}
2、实现类：UserServiceImpl
public class UserServiceImpl implements UserService {
@Override
public void saveUser() {
System.out.println("调用 saveUser() 方法");
}
}
OK，现在我们假设上边的类已经封装好了，而我们也不能再去直接修改它的代码了，但我们想在每次调用UserServiceImpl的saveUser方法时都加上一个事务，让每次被调用之前都写下日志，在每次调用过后也在日志里写一个东西，怎么办呢？
我们可以定义如下一个Transaction类，专门来存储我们下要让其附加的事务：
3、工具类方法：MyProxyUtil.getProxyByJDK()
public static UserService getProxyByJDK(UserService service) {
UserService userService = (UserService) Proxy.newProxyInstance(service.getClass().getClassLoader(),
service.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 下面的代码是反射中 API 的用法
// 改行代码，实际调用的是目标对象的方法
System.out.println("记录日志-开始");
Object obj = method.invoke(service, args);
System.out.println("记录日志-结束");
return obj;
}
});
return userService;
}
这里的 Proxy 是 JDK 中的 api，newProxyInstance() 方法中的参数如下：
- 第一个参数：目标对象的类加载器
- 第二个参数：目标对象的接口
- 第三个参数：代理对象的执行处理器
注意：使用 JDK 的动态代理目标对象必须是接口
4、测试类：
@Test
public void testJDKProxy() {
// 创建目标对象
UserService userService = new UserServiceImpl();
// 生成代理对象
UserService proxy = MyProxyUtil.getProxyByJDK(userService);
// 调用目标对象方法
userService.saveUser();
System.out.println("===================================");
// 调用代理对象方法
proxy.saveUser();
}
结果：
调用 saveUser() 方法
===================================
记录日志-开始
调用 saveUser() 方法
记录日志-结束从结果可以看出，我们在未修改 saveUser() 方法的前提下，在执行 saveUser() 前后均添加了模拟代码，这就是所谓的增强。
3.2、基于继承的 CGLib 动态代理
CGLib 动态代理相对于 JDK 动态代理局限性就小了很多，目标对象不需要实现接口，底层是通过继承目标对象产生代理子对象。（代理子对象中继承了目标对象的方法，并可以对该方法进行增强）
这里使用的接口类、实现类以及测试代码均和上一小节相同，不再给出，这里我想计算一下 saveUser() 执行需要多长时间，前提依旧是不改变 saveUser() 的代码，下面我们来看一下实现过程吧。
1、工具类方法：MyProxyUtil.getProxyByCglib()
public static UserService getProxyByCglib(UserService service) {
// 创建增强器
Enhancer enhancer = new Enhancer();
// 设置需要增强的类的对象
enhancer.setSuperclass(UserServiceImpl.class);
// 设置回调方法
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
long begin = System.currentTimeMillis();
System.out.println("记录程序开始时间 => " + begin);
Object object = methodProxy.invokeSuper(o, args);
long end = System.currentTimeMillis();
System.out.println("记录程序结束时间 => " + end);
System.out.println("记录程序运行总时长 => " + (end - begin));
return object;
}
});
UserService userService = (UserService) enhancer.create();
return userService;
}
注意：这里我们如果想要使用 Enhancer，需要导入 Spring 相关依赖包。
2、测试代码：
@Test
public void testCglibProxy() {
// 创建目标对象
UserService userService = new UserServiceImpl();
// 生成代理对象
UserService proxy = MyProxyUtil.getProxyByCglib(userService);
// 调用目标对象方法
userService.saveUser();
System.out.println("===================================");
// 调用代理对象方法
proxy.saveUser();
}
结果输入与上面一致
4、Spring AOP
在 Spring 中，这两种都有使用到
比如在jdbc中sql语句前通过openTransaction方法开启事务，通过conn.commit();来提交事务，发生异常时通过conn.rollback();手动回滚事务。这些数据库的事务语句穿插在我们的业务代码中，显得累赘，麻烦，所以在AOP中通过一个@transactional注解即实现了上面的功能，这样就显得很简洁明了了
以下是Aop中的主要概念：
•切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
•通知(Advice): 切面必须要完成的工作
•目标(Target):被通知的对象
•代理(Proxy): 向目标对象应用通知之后创建的对象
•连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。
切点（pointcut）：每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。
AOP的实现原理为代理模式，一个用代理实现的代码如下：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class ArithmeticCalculatorLoggingProxy {
private ArithmeticCalculator target;
public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {
super();
this.target = target;
}
//返回代理对象
public ArithmeticCalculator getLoggingProxy(){
ArithmeticCalculator proxy = null;
ClassLoader loader = target.getClass().getClassLoader();
Class [] interfaces = new Class[]{ArithmeticCalculator.class};
InvocationHandler h = new InvocationHandler() {
/**
* proxy: 代理对象。 一般不使用该对象
* method: 正在被调用的方法
* args: 调用方法传入的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
String methodName = method.getName();
//打印日志
System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));
//调用目标方法
Object result = null;
try {
//前置通知
result = method.invoke(target, args);
//返回通知, 可以访问到方法的返回值
} catch (NullPointerException e) {
e.printStackTrace();
//异常通知, 可以访问到方法出现的异常
}
//后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值
//打印日志
System.out.println("[after] The method ends with " + result);
return result;
}
};
/**
* loader: 代理对象使用的类加载器。
* interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法.
* h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法
*/
proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
return proxy;
}
}
在使用的时候需要将原始的类传递到此代理类，然后用代理类来实现对业务类的所有操作，在实际使用时是比较麻烦的。
aop使用实例
实现一个接口move以及实现类，表示向某个方向移动：
package com.yefeng.spring.spring4;
public interface Move {
public void up(int i);
public void down(int i);
public void left(int i);
public void right(int i);
}
package com.yefeng.spring.spring4;
import org.springframework.stereotype.Component;
@Component
public class MyMove implements Move {
@Override
public void up(int i) {
System.out.println("I'm moving up " + i + " steps!");
}
@Override
public void down(int i) {
System.out.println("I'm moving down " + i + " steps!");
}
@Override
public void left(int i) {
System.out.println("I'm moving left " + i + " steps!");
}
@Override
public void right(int i) {
System.out.println("I'm moving right " + i + " steps!");
}
}
编写打印日志类，注意此处在before注解后，需要加入通知的方法，并且括号中的参数一定要和方法的参数一致。例如下中，括号中int不能省略。可以用*表示所有含有一个int参数的方法。
package com.yefeng.spring.spring4;
import java.util.Arrays;
import java.util.List;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoggingMove {
//下面的（）中int 不能省略
//@Before("execution(public void com.yefeng.spring.spring4.Move.up(int))")
//此处中类名为接口或者实现类都可以
// @Before("execution(public void com.yefeng.spring.spring4.MyMove.up(int))")
@Before("execution(public void com.yefeng.spring.spring4.MyMove.*(int))")
public void beforeMove(JoinPoint joinPoint){
String name = joinPoint.getSignature().getName();
List<Object> args = Arrays.asList(joinPoint.getArgs());
System.out.println("I'm ready to move " + name +" " + args);
}
}
在spring bean配置文件中加入自动扫面bean以及aop动态代理支持，注意需要加入命名空间context,aop：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<context:component-scan base-package="com.yefeng.spring.spring4"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
测试
package com.yefeng.spring.spring4;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author yefengzhichen
* 2016年7月5日
*/
public class App
{
public static void main( String[] args )
{
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationConetsx.xml");
Move move = (Move) ctx.getBean("myMove");
move.up(3);
move.down(2);
}
}
执行结果
I'm ready to move up [3]
I'm moving up 3 steps!
I'm ready to move down [2]
I'm moving down 2 steps!
SpringBoot应用实例
@Aspect
@Order(-1)
@Component
public class AspectAopClass {
private static Logger logger = LoggerFactory.getLogger(AspectAopClass.class);
@Around("execution(* io.metamatrix.gcsp.service.impl.*.*(..))")
public Object myPointCut(ProceedingJoinPoint joinPoint) throws Throwable {
String className = joinPoint.getSignature().getDeclaringTypeName();
String methodName = joinPoint.getSignature().getName();
logger.info("{}.{} begin ",className,methodName);
long begin = System.currentTimeMillis();
logger.info("{}.{} end {executed in {} msec}",className,methodName,System.currentTimeMillis()-begin);
Object result = joinPoint.proceed();
return result;
}
@Pointcut("execution(* io.metamatrix.gcsp.service.impl.*.*(..))")
public void aspectMethod(){
}
// @Before(value = "aspectMethod()")
// public void beforeMethod(){
// String id = UUID.randomUUID().toString();
// logger.info("{} start--------------------->",id);
// }
// @Before(value = "myPointCut(ProceedingJoinPoint)")
// public String writeLine(){
// String id = UUID.randomUUID().toString();
// logger.info("{}----------------->",id);
// return "success";
// }
}
动态代理简单实现
在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。
创建一个动态代理对象步骤，具体代码见后面：
- 创建一个InvocationHandler对象
//创建一个与代理对象相关联的InvocationHandler InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);
- 使用Proxy类的getProxyClass静态方法生成一个动态代理类stuProxyClass
Class<?> stuProxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class<?>[] {Person.class});
- 获得stuProxyClass 中一个带InvocationHandler参数的构造器constructor
Constructor<?> constructor = PersonProxy.getConstructor(InvocationHandler.class);
- 通过构造器constructor来创建一个动态实例stuProxy
Person stuProxy = (Person) cons.newInstance(stuHandler);
就此，一个动态代理对象就创建完毕，当然，上面四个步骤可以通过Proxy类的newProxyInstances方法来简化：
//创建一个与代理对象相关联的InvocationHandler InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu); //创建一个代理对象stuProxy，代理对象的每个执行方法都会替换执行Invocation中的invoke方法 Person stuProxy= (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);
动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。是因为所有被代理执行的方法，都是通过在InvocationHandler中的invoke方法调用的，所以我们只要在invoke方法中统一处理，就可以对所有被代理的方法进行相同的操作了。
动态代理的过程，代理对象和被代理对象的关系不像静态代理那样一目了然，清晰明了。因为动态代理的过程中，我们并没有实际看到代理类，也没有很清晰地的看到代理类的具体样子，而且动态代理中被代理对象和代理对象是通过InvocationHandler来完成的代理过程的，其中具体是怎样操作的，为什么代理对象执行的方法都会通过InvocationHandler中的invoke方法来执行。带着这些问题，我们就需要对java动态代理的源码进行简要的分析，弄清楚其中缘因
代理类的生成是由该行代码实现（为了方便理解以下源码为简化后的伪代码，只保留了最重要的部分）
Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),userService.getClass().getInterfaces(),h);
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
final Class<?>[] intfs = interfaces.clone();
// 获取代理类的Class对象
Class<?> cl = getProxyClass0(loader, intfs);
//根据参数获取构造函数
final Constructor<?> cons = cl.getConstructor(constructorParams);
//生成代理类的实例
return newInstance(cons, ih);
} private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
return cons.newInstance(new Object[] {h} );
}newInstance方法很简单，就是通过反射来实例化对象
在接着看getProxyClass0方法
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
return proxyClassCache.get(loader, interfaces);
}首先会在缓存中查到是否该类加载器已经加载过该代理类，如果找到则直接返回，否则使用ProxyClassFactory来生成代理类
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
long num = nextUniqueNumber.getAndIncrement();
//拼接代理类名
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//生成字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces);
// 通过类加载器生成代理类的Class对象
return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
}了解：Cglib的ASM
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
