Spring 之 AOP

1.什么是AOP
AOP（Aspect Oriented Programming），义为面向切面编程，采取横向抽取的方式，是面向对象机制的一种补充。 AOP 应用于 性能监控，安全检查，事务管理，缓存。
OOP面向对象是对实体的属性和行为的一种抽象封装。AOP则是针对业务处理过程中，面向的是处理过程的一个阶段。

1. AOP中的一些基本概念
   Joincut:连接点，指的是哪些方法可以被连接。
   Pointcut:切入点，指的是对哪些Pointcut 进行拦截
   advice:指的是对pointcut进行增强的代码，比如writeLog()
   target:目标对象。被增强的对象。
   introduction: 引介。指的是一种特殊方式的advice。是类级别的增强。在原有类上添加一个属性或者方法。
   waving:把增强（advice）应用到目标对象(target)来创建新的代理对象(proxy)的过程。
   proxy:代理对象
   aspect：允许有多个切点和通知的组合，是切入点和通知的结合
   3.AOP实现
   JDK 动态代理：实现了接口的类生成代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import com.brook.dao.UserDao;
public class JDKProxy implements InvocationHandler {
    public JDKProxy(UserDao userdao) {
        super();
        this.userDao =  userdao;
    }

    private UserDao userDao;

    public UserDao createProxy()
    {
        UserDao proxy =(UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), this);
        return proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {

        if("add".equals(method.getName()))
        {

            System.out.println("------------------日志记录");
            Object result = method.invoke(userDao, args);
            return result;
        }

        return method.invoke(userDao, args);
    }
}

//Demo code
@Test
public void demo1() throws Exception
{
    UserDao userdao = new UserDaoImpl();
    JDKProxy proxy = new JDKProxy(userdao);
    UserDao dao =  proxy.createProxy();     
    dao.add();
    dao.delete();
}
//问题：InvokeHandler 的invoke方法的第一个参数Object proxy 有什么作用

CGLib 代理机制：对类生成代理

public class CGLibProxy implements MethodInterceptor {
    private ProductDao productDao;

    public CGLibProxy (ProductDao productDao)
    {
        this.productDao = productDao;
    }


    public ProductDao createProxy(){

        Enhancer enhencer = new Enhancer();
        enhencer.setSuperclass(productDao.getClass());
        enhencer.setCallback(this);
        return (ProductDao) enhencer.create();

    }


    @Override
    public Object intercept(Object proxy, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
        System.out.println("----------------------记录日志");
        Object obj = methodProxy.invokeSuper(proxy, args);
        return obj;
    }   
}
//Demo code:
    ProductDao productDao =new  ProductDao();
    CGLibProxy cgLigProxy = new CGLibProxy(productDao);
    ProductDao proxy = cgLigProxy.createProxy();
    proxy.add();

两种代理方式有什么不同：
JDK 代理是针对接口的代理
CGLib 代理是针对方法的。如果需要代理的类没有实现接口，就使用CGLib中的代理。
4.Spring中的AOP
a.自动注入
按照name进行自动注入

public class MyAroundAdvice implements MethodInterceptor {
//环绕增强
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {

        System.out.println("----前置增强");
        Object result = methodInvocation.proceed();
        System.out.println("----后置增强");
        return result;
    }

}

//配置
    <bean id="beforeAdvice" class="com.brook.spring.advisor.MyMethodBeforeAdvisor"></bean>
    <bean id="customerDao" class="com.brook.spring.advisor.CustomerDaoImpl"></bean>
    <bean id="orderDao" class="com.brook.spring.advisor.OrderDao"></bean>
    <bean id="aroundAdvice" class="com.brook.spring.advisor.MyAroundAdvice"></bean>
    <!-- 按照beanName进行注入 -->
    <!-- 基于后处理bean,不需要id-->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="beanNames" value="*Dao"></property>
        <property name="interceptorNames" value="aroundAdvice"></property>
    </bean>
//Demo
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
class Demo{
    @Autowired
    @Qualifier("customerDao")
    private CustomerDao customerDao;

    @Autowired
    @Qualifier("orderDao")
    private OrderDao orderDao;

    @Test
    public void test1(){
        orderDao.add();
    }
}