zoukankan html css js c++ java

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.测试

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">

    <bean id="goodsDao" class="com.xzh.spring.demo2.GoodsDaoImpl"/>
</beans>

实现类：

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

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

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name="goodsDao")
    private GoodsDao goodsDao;
    @Test
    public void test() {
        this.goodsDao.save();
    }
}

6.编写一个切面类

public class MyAspect {
    public void check(){
        System.out.println("权限检验");
    }

    public void exit(){
        System.out.println("退出");
    }
}

7.将切面交给spring

<?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">

    <bean id="goodsDao" class="com.xzh.spring.demo2.GoodsDaoImpl"/>
    <bean id="myAspect" class="com.xzh.spring.demo3.MyAspect"/>
</beans>

8.配置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: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">

    <bean id="goodsDao" class="com.xzh.spring.demo2.GoodsDaoImpl"/>
    <bean id="myAspect" class="com.xzh.spring.demo3.MyAspect"/>
    <!--配置AOP-->
    <aop:config>
        <!--切点：给那个方法做增强-->
        <aop:pointcut id="savePoint" expression="execution(* com.xzh.spring.demo2.GoodsDaoImpl.save(..))"/>
        <!--配置切面：增强的功能是什么-->
        <aop:aspect ref="myAspect">
            <aop:before method="check" pointcut-ref="savePoint"/>
            <aop:after method="exit" pointcut-ref="savePoint"/>
        </aop:aspect>
    </aop:config>
</beans>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name="goodsDao")
    private GoodsDao goodsDao;
    @Test
    public void test() {
        this.goodsDao.save();
        this.goodsDao.update();
    }
}

查看全文

相关阅读:
标签的讲解
 属性分类
 LeetCode 003. 无重复字符的最长子串双指针
 Leetcode 136. 只出现一次的数字异或性质
 Leetcode 231. 2的幂数学
 LeetCode 21. 合并两个有序链表
 象棋博弈资源
 acwing 343. 排序 topsort floyd 传播闭包
 Leetcode 945 使数组唯一的最小增量贪心
 Leetcode 785 判断二分图 BFS 二分染色

原文地址：https://www.cnblogs.com/xzh0717/p/10847528.html

最新文章
go函数可见性
 go 继承
 1的个数
 梦断代码3
梦断代码2
浪潮之巅2
浪潮之巅3
单元测试
 场景调研
 二维数组中的最大联通子数组

热门文章
改进方案博客汇总
 站立会议9
矢量图标
 提高背景的性能优化
 排版
 浮动讲解
 列表应用
 单词
 css中背景的应用
 css