AOP 与 Spring中AOP使用（上）

AOP简介

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，
通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

开发存在的问题

JDK动态代理

JDK动态代理必须依赖接口（必须有接口）

public interface GoodsDao {
    public void save();
    public void update();
}

接口实现类：

public class GoodsDaoImpl implements GoodsDao {
    @Override
    public void save() {
        System.out.println("保存操作");
    }

    @Override
    public void update() {
        System.out.println("更新操作");
    }
}

JDK动态代理类：

public class GoodsJDKProxy {
    public GoodsDao createProxy(GoodsDao goodsDao){
        // 增强功能
        GoodsDao goodsDaoProxy = (GoodsDao)Proxy.newProxyInstance(goodsDao.getClass().getClassLoader(), goodsDao.getClass().getInterfaces(),
                new InvocationHandler() {
                    // 当调用对象的时候，所有的方法都会来到这里
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if ("save".equals(method.getName())){
                            System.out.println("权限检验");
                            GoodsDao goodsDao1 = (GoodsDao)method.invoke(goodsDao, args);
                            System.out.println("退出");
                            return goodsDao1;
                        }
                        return method.invoke(goodsDao, args);
                    }
                });

        return goodsDaoProxy;
    }
}

测试：

@Test
public void test() {
	GoodsDao goodsDao = new GoodsDaoImpl();
//        goodsDao.save();

	GoodsJDKProxy goodsJDKProxy = new GoodsJDKProxy();
	GoodsDao proxy = goodsJDKProxy.createProxy(goodsDao);
	proxy.save();
	proxy.update();
}

cglib动态代理

Cglig是一个第三方开源代码生成类库，动态添加类的属性和方法。
在spring的核心包当中已经引入了cglib

采用的是继承方式来产生的代理对象

public class UserDao {
    public void save() {
        System.out.println("保存操作");
    }

    public void update() {
        System.out.println("更新操作");
    }
}

cglib动态代理类：

（1）匿名内部类写法：

public class UserDaoCglibProxy {
    public UserDao createCglibProxy(UserDao userDao){
        // 1.创建核心类
        Enhancer enhancer = new Enhancer();
        // 2.设置父类 增强为继承方式（自动创建子类继承父类）
        enhancer.setSuperclass(userDao.getClass());
        // 3.设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                if ("save".equals(method.getName())){
                    System.out.println("权限检验");
                    UserDao invoke = (UserDao)methodProxy.invokeSuper(o, objects);
                    System.out.println("退出");
                    return invoke;
                }
                return methodProxy.invokeSuper(o, objects);
            }
        });
        // 4.创建代理对象 就是把子类取出来
        UserDao obj = (UserDao)enhancer.create();
        return obj;
    }
}

public class UserDaoCglibProxy {
    public UserDao createCglibProxy(UserDao userDao){
        // 1.创建核心类
        Enhancer enhancer = new Enhancer();
        // 2.设置父类 增强为继承方式（自动创建子类继承父类）
        enhancer.setSuperclass(userDao.getClass());
        // 3.设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                if ("save".equals(method.getName())){
                    System.out.println("权限检验");
                    UserDao invoke = (UserDao)method.invoke(userDao, objects);
                    System.out.println("退出");
                    return invoke;
                }
                return method.invoke(userDao, objects);
            }
        });
        // 4.创建代理对象 就是把子类取出来
        UserDao obj = (UserDao)enhancer.create();
        return obj;
    }
}

（2）实现 MethodInterceptor 接口：

public class UserDaoCglibProxy implements  MethodInterceptor{
    public UserDao createCglibProxy(UserDao userDao){
        // 1.创建核心类
        Enhancer enhancer = new Enhancer();
        // 2.设置父类 增强为继承方式（自动创建子类继承父类）
        enhancer.setSuperclass(userDao.getClass());
        // 3.设置回调
        enhancer.setCallback(this);
        // 4.创建代理对象 就是把子类取出来
        UserDao obj = (UserDao)enhancer.create();
        return obj;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if ("save".equals(method.getName())){
            System.out.println("权限检验");
            UserDao invoke = (UserDao)methodProxy.invokeSuper(o, objects);
            System.out.println("退出");
            return invoke;
        }
        return methodProxy.invokeSuper(o, objects);
    }
}

测试：

public class UserDaoTest {
    @Test
    public void test(){
        UserDao userDao = new UserDao();
        UserDaoCglibProxy userDaoCglibProxy = new UserDaoCglibProxy();
        UserDao proxy = userDaoCglibProxy.createCglibProxy(userDao);
        proxy.save();
        proxy.update();
    }
}

Spring的AOP简介

AOP思想最早是由AOP联盟组织提出的
Spring使用这种思想最好的框架
AspectJ
- Spring的AOP有自己的实现方式，但是这种方式非常繁琐
- AspectJ 是一个AOP的框架
- Spring放弃了自己传统的方式，引入AspectJ作为自身AOP的开发

AOP相关术语

Joinpoint：连接点

可以被拦截到的方法

能够被增强的方法，这些方法就可以称为是连接点

Pointcut：切入点

真正被拦截的方法，真正被增加的方法

Advice：通知

增加的内容，通常都是封装成一个方法，这个方法我们就称为通知

Introduction：引介

类层面的增加
给原有的类添加一些新的属性方法
在开发中通常都是给方法进行增加

Target：被增加的对象

Weaving：织入

将通知应用到目标对象的过程

Proxy：代理对象

Aspect：切面

多个通知和多个切入点的集合

Spring中AOP使用

1.引入spring基本jar包

2.引入aop开发的相关jar包

3.配置文件中引入aop约束

applicationContext.xml

<?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: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/aop
		http://www.springframework.org/schema/aop/spring-aop.xsd">


</beans>

4.Spring测试

测试时，每次都需要获取工厂
通过spring-test，就不用每次获取
添加测试依赖包

5.测试