【Spring】AOP注解开发及JDBC整合

作者: 日落perfe | 来源:发表于2017-07-19 10:05 被阅读0次

AOP注解开发光速入门

步骤一：引入相关的jar及配置文件

 * spring 的传统 AOP 的开发的包
      spring-aop-4.2.4.RELEASE.jar
      com.springsource.org.aopalliance-1.0.0.jar
 * aspectJ 的开发包
      com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
      spring-aspects-4.2.4.RELEASE.jar

引入AOP约束
<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>

步骤二：编写目标类

public class ProductDao {
     public void save(){
        System.out.println("保存商品...");
     }
     public void update(){
        System.out.println("修改商品...");
     }
     public void delete(){
        System.out.println("删除商品...");
     }
     public void find(){
        System.out.println("查询商品...");
     }
}

<!-- 目标类============ -->
<bean id="productDao" class="cn.itcast.spring.demo4.ProductDao"></bean>

步骤三：开启aop注解自动代理

<aop:aspectj-autoproxy/>

常用AspectJ 的AOP注解

    @Aspect:定义切面类的注解
    通知类型:
        * @Before  :前置通知
        * @AfterReturing :后置通知
        * @Around  :环绕通知
        * @After :最终通知
        * @AfterThrowing :异常抛出通知.
    @Pointcut:定义切入点的注解

** 步骤四：编写切面类**

@Aspect
public class MyAspectAnno {
    @Before("MyAspectAnno.pointcut1()")
    public void before(){
      System.out.println("前置通知===========");
    }
    @Pointcut("execution(* cn.itcast.spring.demo4.ProductDao.save(..))")
     private void pointcut1(){}
}

<!-- 配置切面类 -->
<bean id="myAspectAnno" class="cn.itcast.spring.demo4.MyAspectAnno"></bean>

步骤五：其他通知的注解

@Aspect
public class MyAspectAnno {
    @Before("MyAspectAnno.pointcut1()")
    public void before(){
      System.out.println("前置通知===========");
    }
    @AfterReturning("MyAspectAnno.pointcut2()")
    public void afterReturning(){
      System.out.println("后置通知===========");
   }
    @Around("MyAspectAnno.pointcut3()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
      System.out.println("环绕前通知==========");
      Object obj = joinPoint.proceed();
      System.out.println("环绕后通知==========");
      return obj;
    }
    @AfterThrowing("MyAspectAnno.pointcut4()")
    public void afterThrowing(){
      System.out.println("异常抛出通知========");
    }
    @After("MyAspectAnno.pointcut4()")
    public void after(){
      System.out.println("最终通知==========");
    }
    @Pointcut("execution(* cn.itcast.spring.demo4.ProductDao.save(..))")
    private void pointcut1(){}
    @Pointcut("execution(* cn.itcast.spring.demo4.ProductDao.update(..))")
    private void pointcut2(){}
    @Pointcut("execution(* cn.itcast.spring.demo4.ProductDao.delete(..))")
    private void pointcut3(){}
    @Pointcut("execution(* cn.itcast.spring.demo4.ProductDao.find(..))")
    private void pointcut4(){}
}

Spring与JDBC整合

Spring 提供了很多持久层技术的模板类简化编程
其实就是提供了一个可以进行数据库操作的对象，封装了JDBC技术
使用入门
步骤一：引入相关开发包
步骤二：创建一个测试类

@Test
// JDBC 模板的基本使用：
public void demo1(){
      DriverManagerDataSource dataSource = new DriverManagerDataSource();
      dataSource.setDriverClassName("com.mysql.jdbc.Driver");
      dataSource.setUrl("jdbc:mysql:///spring_day03");
      dataSource.setUsername("root");
      dataSource.setPassword("123");
      JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
      jdbcTemplate.update("insert into account values (null,?,?)", " 会 希
     ",10000d);
}

步骤三：将连接池的配置交给Spring管理
- 1.Spring 内置的连接池的配置
```

```

<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring_day02"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
```

测试类编写
**** 引入 spring-aop.jar
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo2 {
        @Resource(name="jdbcTemplate")
        private JdbcTemplate jdbcTemplate;
        @Test
        public void demo1(){
        jdbcTemplate.update("insert into account values (null,?,?)", " 凤 姐
",10000d);
        }
}

- **2.Spring中配置DBCP连接池**

【引入dbcp连接池的jar包】

【配置连接池】

<!-- 配置 DBCP 连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///spring_day02"/>
        <property name="username" value="root"/>
        <property name="password" value="123"/>
</bean>

- **Spring中配置c3p0连接池**

【引入相应的 jar 包】

【配置连接池】

<!-- 配置 C3P0 连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"/>
        <property name="user" value="root"/>
        <property name="password" value="123"/>
</bean>

步骤四： JDBC模板CRUD的操作

RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {
      @Resource(name="jdbcTemplate")
      private JdbcTemplate jdbcTemplate;
      @Test
      // 插入操作
      public void demo1(){
        jdbcTemplate.update("insert into account values (null,?,?)", " 冠 希
",10000d);
      }
      @Test
      // 修改操作
      public void demo2(){
        jdbcTemplate.update("update account set name=?,money =? where id = ?", "
思雨",10000d,5);
      }
      @Test
      // 删除操作
      public void demo3(){
        jdbcTemplate.update("delete from account where id = ?", 5);
      }
      @Test
      // 查询一条记录
      public void demo4(){
        Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new MyRowMapper(), 1);
        System.out.println(account);
      }
      @Test
      // 查询所有记录
      public void demo5(){
        List<Account> list = jdbcTemplate.query("select * from account", new
MyRowMapper());
        for (Account account : list) {
          System.out.println(account);
        }
      }
      class MyRowMapper implements RowMapper<Account>{
        @Override
        public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
          Account account = new Account();
          account.setId(rs.getInt("id"));
          account.setName(rs.getString("name"));
          account.setMoney(rs.getDouble("money"));
          return account;
        }  
      }
}

Spring中控制事务
- 事务回顾

    什么是事务:
    事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败
    
    事务特性:
原子性 :强调事务的不可分割.
一致性 :事务的执行的前后数据的完整性保持一致.
隔离性 :一个事务执行的过程中,不应该受到其他事务的干扰
持久性 :事务一旦结束,数据就持久到数据库

    如果不考虑隔离性引发安全性问题:
脏读  :一个事务读到了另一个事务的未提交的数据
不可重复读 :一个事务读到了另一个事务已经提交的 update 的数据导致多次查询结果不一致.
虚幻读 :一个事务读到了另一个事务已经提交的 insert 的数据导致多次查询结果不一致.

    解决读问题: 设置事务隔离级别
未提交读  :脏读，不可重复读，虚读都有可能发生
已提交读  :避免脏读。但是不可重复读和虚读有可能发生
可重复读  :避免脏读和不可重复读.但是虚读有可能发生.
串行化的  :避免以上所有读问题.
Mysql 默认:可重复读
Oracle 默认:读已提交

Spring PlatformTransactionManager: 平台事务管理器

***** 真正管理事务的对象
org.springframework.jdbc.datasource.DataSourceTransactionManager 使用SpringJDBC或iBatis进行持久化数据时使用
org.springframework.orm.hibernate3.HibernateTransactionManager 使用Hibernate进行持久化数据时使用

TransactionDefinition:事务定义信息

    事务定义信息:
    * 隔离级别
    * 传播行为
    * 超时信息
    * 是否只读

TransactionStatus:记录事务的状态
事务的传播行为

PROPAGION_XXX  :事务的传播行为
    * 保证同一个事务中
PROPAGATION_REQUIRED 支持当前事务，如果不存在 就新建一个(默认)
PROPAGATION_SUPPORTS 支持当前事务，如果不存在，就不使用事务PROPAGATION_MANDATORY  支持当前事务，如果不存在，抛出异常
   * 保证没有在同一个事务中
PROPAGATION_REQUIRES_NEW  如果有事务存在，挂起当前事务，创建一个新的事务
PROPAGATION_NOT_SUPPORTED  以非事务方式运行，如果有事务存在，挂起当前事务
PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常
PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行

Spring声明式事务管理XML方式思想就是 AOP

配置事务管理器
<!-- 事务管理器 -->
<bean  id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSource"/>
</bean>
配置事务的通知
<!-- 配置事务的增强 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
      <!--
      isolation="DEFAULT" 隔离级别
      propagation="REQUIRED" 传播行为
      read-only="false"  只读
      timeout="-1"  过期时间
      rollback-for="" -Exception
      no-rollback-for="" +Exception
      -->
      <tx:method name="transfer" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
配置 aop 
<aop:config>
    <aop:pointcut expression="execution(*cn.itcast.transaction.demo2.AccountServiceImpl.transfer(..))" id="pointcut1"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>

Spring声明式事务管理注解方式

<!-- 配置事务管理器 -->
<bean  id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!-- 开启注解事务管理 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

在使用事务的类上添加一个注解：@Transactional

【Spring】AOP注解开发及JDBC整合

AOP注解开发光速入门

Spring与JDBC整合

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读