【JAVA】浅谈AOP
AOP （面向切面编程）Aspect Oriented Programming的缩写
优点：
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
主要功能
日志记录，性能统计，安全控制，事务处理，异常处理等等。
主要意图
将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
AOP相关概念
1.方面（Aspect）
2.连接点（Joinpoint）
3.通知（Advice）: 各种类型的通知包括“around”、“before”和“throws”通知。
许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。
Spring中定义了四个advice: BeforeAdvice, AfterAdvice, ThrowAdvice和DynamicIntroductionAdvice
4.切入点（Pointcut）
5.引入（Introduction）: 添加方法或字段到被通知的类。
6.目标对象（Target Object）: 被通知或被代理对象。
7.AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。
8.织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。
实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。
在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
Spring AOP代理对象的生成
Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。
- 静态代理
- JDK动态代理
- CGlib动态代理
静态代理很简单，咱们自己在写代码的时候都会写到这种类似静态代理的代码。简单来说，就是把被代理类作为参数传给代理类的构造方法，让代理类替被代理类实现更强大的功能。
public class StaticProxyTest {
public static void main(String[] args) {
UserService userService = new UserService();
LogProxy logProxy = new LogProxy(userService);
logProxy.addUser();
logProxy.deleteUser();
}
}
interface IUserService{
void addUser();
void deleteUser();
}
class UserService implements IUserService{
@Override
public void addUser() {
System.out.println("添加用户");
}
@Override
public void deleteUser() {
System.out.println("删除用户");
}
}
//日志代理
class LogProxy implements IUserService{
//目标类
private UserService target;
public LogProxy(UserService target){
this.target = target;
}
@Override
public void addUser() {
System.out.println("记录日志开始");
target.addUser();
System.out.println("记录日志结束");
}
@Override
public void deleteUser() {
System.out.println("记录日志开始");
target.deleteUser();
System.out.println("记录日志结束");
}
}
动态代理在Spring源码中，用到的动态代理主要有两种，JDK动态代理以及CGLib动态代理。
两者主要区别是：
JDK动态代理一般针对实现了接口的类生成代理。
目标对象没有实现接口，则默认会采用CGLIB代理。如果目标对象实现了接口，可以强制使用CGLIB实现代理（添加CGLIB库)其实，上面的区别阐述虽然不够完全，但足以区分二者。
相同点：两种动态代理本质上都是字节码组装
JDK动态代理的代理类一般需要实现接口
/**
* Description: jdk动态代理
*/
public class JdkProxyTest {
public static void main(String[] args) {
IPersonService personService = JdkDynamicProxy.getProxy();
personService.addPerson();
personService.deletePerson();
}
}
interface IPersonService{
void addPerson();
void deletePerson();
}
class PersonService implements IPersonService{
@Override
public void addPerson() {
System.out.println("添加人物");
}
@Override
public void deletePerson() {
System.out.println("删除人物");
}
}
/**
* newProxyInstance方法参数说明：
* ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法是固定的
* Class<?>[] interfaces:指定目标对象实现的接口的类型,使用泛型方式确认类型
* InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法
*/
class JdkDynamicProxy{
public static IPersonService getProxy(){
IPersonService personService = new PersonService();
IPersonService proxy = (IPersonService) Proxy.newProxyInstance(IPersonService.class.getClassLoader(), new Class<?>[]{IPersonService.class}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("记录日志开始");
Object obj = method.invoke(personService, args);
System.out.println("记录日志结束");
return obj;
}
});
return proxy;
}
}
CGLib动态代理
public class CglibProxyTest {
public static void main(String[] args) {
CglibProxy proxy = new CglibProxy();
Train t = (Train)proxy.getProxy(Train.class);
t.move();
}
}
class Train {
public void move(){
System.out.println("火车行驶中...");
}
}
class CglibProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxy(Class clazz){
//设置创建子类的类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
/**
* 拦截所有目标类方法的调用
* obj 目标类的实例
* m 目标方法的反射对象
* args 方法的参数
* proxy代理类的实例
*/
@Override
public Object intercept(Object obj, Method m, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("日志开始...");
//代理类调用父类的方法
proxy.invokeSuper(obj, args);
System.out.println("日志结束...");
return null;
}
}
原理分析
下面我们来研究一下Spring如何使用JDK来生成代理对象，具体的生成代码放在JdkDynamicAopProxy这个类中，假设我们要对下面这个用户管理进行代理：
//用户管理接口
package com.tgb.proxy;
public interface UserMgr {
void addUser();
void delUser();
}
//用户管理的实现
package com.tgb.proxy;
public class UserMgrImpl implements UserMgr {
@Override
public void addUser() {
System.out.println("添加用户.....");
}
@Override
public void delUser() {
System.out.println("删除用户.....");
}
}
按照代理模式的实现方式，肯定是用一个代理类，让它也实现UserMgr接口，然后在其内部声明一个UserMgrImpl，然后分别调用addUser和delUser方法，并在调用前后加上我们需要的其他操作。但是这样很显然都是写死的，我们怎么做到动态呢？别急，接着看。 我们知道，要实现代理，那么我们的代理类跟被代理类都要实现同一接口，但是动态代理的话我们根本不知道我们将要代理谁，也就不知道我们要实现哪个接口，那么要怎么办呢？我们只有知道要代理谁以后，才能给出相应的代理类，那么我们何不等知道要代理谁以后再去生成一个代理类呢？想到这里，我们好像找到了解决的办法，就是动态生成代理类！
这时候我们亲爱的反射又有了用武之地，我们可以写一个方法来接收被代理类，这样我们就可以通过反射知道它的一切信息——包括它的类型、它的方法等等。
JDK动态代理的两个核心分别是InvocationHandler和Proxy，下面我们就用简单的代码来模拟一下它们是怎么实现的：
InvocationHandler接口：
package com.tgb.proxy;
import java.lang.reflect.Method;
public interface InvocationHandler {
public void invoke(Object o, Method m);
}
实现动态代理的关键部分，通过Proxy动态生成我们具体的代理类：
package com.tgb.proxy;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;
public class Proxy {
/**
*
* @param infce 被代理类的接口
* @param h 代理类
* @return
* @throws Exception
*/
public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception {
String methodStr = "";
String rt = "\r\n";
//利用反射得到infce的所有方法，并重新组装
Method[] methods = infce.getMethods();
for(Method m : methods) {
methodStr += " @Override" + rt +
" public "+m.getReturnType()+" " + m.getName() + "() {" + rt +
" try {" + rt +
" Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
" h.invoke(this, md);" + rt +
" }catch(Exception e) {e.printStackTrace();}" + rt +
" }" + rt ;
}
//生成Java源文件
String srcCode =
"package com.tgb.proxy;" + rt +
"import java.lang.reflect.Method;" + rt +
"public class $Proxy1 implements " + infce.getName() + "{" + rt +
" public $Proxy1(InvocationHandler h) {" + rt +
" this.h = h;" + rt +
" }" + rt +
" com.tgb.proxy.InvocationHandler h;" + rt +
methodStr + rt +
"}";
String fileName = "d:/src/com/tgb/proxy/$Proxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(srcCode);
fw.flush();
fw.close();
//将Java文件编译成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMgr.getJavaFileObjects(fileName);
CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
t.call();
fileMgr.close();
//加载到内存，并实例化
URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.tgb.proxy.$Proxy1");
Constructor ctr = c.getConstructor(InvocationHandler.class);
Object m = ctr.newInstance(h);
return m;
}
}
这个类的主要功能就是，根据被代理对象的信息，动态组装一个代理类，生成Proxy1.java文件，然后将其编译成Proxy1.class。这样我们就可以在运行的时候，根据我们具体的被代理对象生成我们想要的代理类了。这样一来，我们就不需要提前知道我们要代理谁。也就是说，你想代理谁，想要什么样的代理，我们就给你生成一个什么样的代理类。
然后，在客户端我们就可以随意的进行代理了。
package com.tgb.proxy;
public class Client {
public static void main(String[] args) throws Exception {
UserMgr mgr = new UserMgrImpl();
//为用户管理添加事务处理
InvocationHandler h = new TransactionHandler(mgr);
UserMgr u = (UserMgr)Proxy.newProxyInstance(UserMgr.class,h);
//为用户管理添加显示方法执行时间的功能
TimeHandler h2 = new TimeHandler(u);
u = (UserMgr)Proxy.newProxyInstance(UserMgr.class,h2);
u.addUser();
System.out.println("\r\n==========华丽的分割线==========\r\n");
u.delUser();
}
}
事务处理：
package com.tgb.proxy;
import java.lang.reflect.Method;
public class TransactionHandler implements InvocationHandler {
private Object target;
public TransactionHandler(Object target) {
super();
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
System.out.println("开启事务.....");
try {
m.invoke(target);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("提交事务.....");
}
}
运行结果：
开始时间:2014年-07月-15日 15时:48分:54秒
开启事务.....
添加用户.....
提交事务.....
结束时间:2014年-07月-15日 15时:48分:57秒
耗时：3秒
==========华丽的分割线==========
开始时间:2014年-07月-15日 15时:48分:57秒
开启事务.....
删除用户.....
提交事务.....
结束时间:2014年-07月-15日 15时:49分:00秒
耗时：3秒
项目中使用AOP遇到的坑
1.在Spring配置文件中配置了事务管理器，如下：
<!--事务管理器配置,单数据源事务-->
<tx:annotation-driven transaction-manager="transactionManager" />
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
2.配置了事务管理器后，加入了@Transactional注解
@Service
@Transactional
public class AccountService{
//to do something
}
上面配置默认启用JDK动态代理，JDK只能代理接口不能代理类。而我的项目中用的是这个配置，却因为没有定义Service接口导致项目启动报错。
如果需要使用CGLIB动态代理：配置如下：
<tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/>
