Spring对DAO层和Service层的加强

最新推荐文章于 2020-07-16 17:01:10 发布

Lyric__

最新推荐文章于 2020-07-16 17:01:10 发布

阅读量357

点赞数

分类专栏： Spring 文章标签： Spring

本文链接：https://blog.csdn.net/lr19941226/article/details/80799642

版权

本文详细介绍了Spring的AOP注解入门，包括如何使用AOP对DAO层进行增强，以及不同方式的通知使用。接着深入讲解了Spring的事务管理，如JDBC模板的使用，事务的回顾、传播行为、隔离级别，以及编程式和声明式事务管理的配置和应用，重点放在声明式事务管理的XML和注解方式上。

摘要由CSDN通过智能技术生成

Spring对DAO的增强体现在Dao对数据库的操作上(通俗的讲就是使用一个jdbc的模板)
Spring对Service层的增强体现在对事务的管理上,通过aop的思想将事务很好的整合了

一.Spring的AOP的注解入门

(一) AOP对DAO的增强

1. 创建web项目,引入jar包

2. 创建相关的包和类

创建包com.cdut.aop.demo1，创建接口：

public interface CustomerDao {

    public void save();
    public void update();
    public void find();
    public Integer delete();

}

创建类CustomerDaoImpl.java

public class CustomerDaoImpl implements CustomerDao {
   

    @Override
    public void save() {
        System.out.println("这是一个=保存=客户的方法");
    }

    @Override
    public void update() {
        System.out.println("这是一个=更新=客户的方法");
    }

    @Override
    public void find() {
        System.out.println("这是一个=查找=客户的方法");
    }

    @Override
    public Integer delete() {
        System.out.println("这是一个=删除=客户的方法");
        return null;
    }

}

3. 编写切面类,并且完成配置

@Aspect
public class MyAspectAnno {
   

    //方式一:在自定义的切面类里面讲通知和切点绑定
    @Before("MyAspectAnno.pointcut1() || MyAspectAnno.pointcut2()")
    public void before(){
        System.out.println("this is 前置");
    }

    @Pointcut("execution(* com.cdut.spring.demon.CustomerDaoImpl.save(..))")
    private void pointcut1(){};

    @Pointcut("execution(* com.cdut.spring.demon.CustomerDaoImpl.update(..))")
    private void pointcut2(){};


    //方式二: 直接在通知上织入
    @After("execution(* com.cdut.spring.demon.CustomerDaoImpl.find(..)))")
    public void after(){
        System.out.println("这个是后置的增强");
    }
}

4. 创建核心配置文件,配置实现类

src创建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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx.xsd">

    </beans>

     <!--开启自动代理  -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <!--配置目标类: 其实就是CustomerDaoImpl -->
    <bean id="customerDao" class="com.cdut.spring.demon.CustomerDaoImpl"> </bean>

    <!-- 配置切面类 -->
    <bean id="myAspectAnno" class="com.cdut.spring.demon.MyAspectAnno"></bean>
    </beans>

5.编写测试类

注意Spring和JUnit的整合

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demon {
   

    //注入一个CustomerDao对象
    @Resource(name="customerDao")
    private CustomerDao customerDao;

    @Test
    public void test01(){
        customerDao.find();
        customerDao.save();
        customerDao.update();
        customerDao.delete();
    }
}

6. 输出结果显示

这是一个=查找=客户的方法
这个是后置的增强
this is 前置
这是一个=保存=客户的方法
this is 前置
这是一个=更新=客户的方法
这是一个=删除=客户的方法

7.总结

这个小案例是使用Spring的AOP思想对DAO的一种增强.
- Spring的AOP思想就是代理模式的体现–横向编程
流程分析:
- 首先是编写基本的类,注意在编写切面类的是后需要将通知和切点进行绑定
- 第一种方式:先将通知和一个自定义的切点的绑定, 再将自定义的切点和连接点进行绑定
- 第二种方式:一步到位直接在通知上面将连接点绑定不用去自定义一个切点了
- 然后在配置文件中开启自动代理. 将目标类和 切面类配置进去
- 最后编写一个测试类进行测试

(二) Spring的AOP的注解通知

1 其他通知的使用

前置通知、后置通知、环绕通知、异常通知、后置通知

@Aspect
public class MyAspectAnno {

    @Before("execution(* com.cdut.spring.demon.CustomerDaoImpl.save(..))")
    public void before(JoinPoint joinpoint){
        System.out.println("前置增强==========");
    }

    @AfterReturning(value="execution(* com.cdut.spring.demon.CustomerDaoImpl.delete(..))",returning="result")
    public void afterReturning(JoinPoint joinpoint,Object result){
        System.out.println("后置增强=========="+result);
    }

    @AfterThrowing(value="execution(* com.cdut.spring.demon.CustomerDaoImpl.find(..))",throwing="ex")
    public void afterThrowing(JoinPoint joinpoint,Throwable ex){
        System.out.println("异常抛出增强======"+ex.getMessage());
    }

    @After(value="execution(* com.cdut.spring.demon.CustomerDaoImpl.find(..))")
    public void after(JoinPoint joinpoint){
        System.out.println("最终通知========");
    }


    @Around(value="execution(* com.cdut.spring.demon.CustomerDaoImpl.update(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out