3.Spring 注解切面开发以及jdbc事务的基本概念

​​​​​​Spring 使用 AspectJ 进行 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

引入 Spring 的配置文件

引入 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的事务管理

Spring 提供了很多持久层技术的模板类简化编程:

引入相关开发包:

创建一个测试类:

@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 内置的连接池的配置：

将模板配置到 Spring 中

<!-- 配置 JDBC 模板 -->
<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.配置 c3p0 连接池:

引入相应的 jar 包

  com.springsource.com.mchange.v2.c3p0-0.9.1.2.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.driverClass=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql:///spring_day02 
jdbc.username=root
jdbc.password=123

引入外部的属性文件

<!-- 引入外部属性文件： -->

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="location" value="classpath:jdbc.properties"/>

</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;
}


}
}

 

事务

      1 

什么是事务:

事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.

事务特性:

原子性 :强调事务的不可分割.

一致性 :事务的执行的前后数据的完整性保持一致.

隔离性 :一个事务执行的过程中,不应该受到其他事务的干扰

持久性 :事务一旦结束,数据就持久到数据库持久性 :事务一旦结束,数据就持久到数据库

如果不考虑隔离性引发安全性问题:

脏读 :一个事务读到了另一个事务的未提交的数据

不可重复读 :一个事务读到了另一个事务已经提交的 update 的数据导致多次查询结果不一致.虚幻读 :一个事务读到了另一个事务已经提交的 insert 的数据导致多次查询结果不一致.

虚幻读 :一个事务读到了另一个事务已经提交的 insert 的数据导致多次查询结果不一致.

​​​​​​​解决读问题:设置事务隔离级别

未提交读 :脏读，不可重复读，虚读都有可能发生

已提交读 :避免脏读。但是不可重复读和虚读有可能发生 可重复读 :避免脏读和不可重复读.但是虚读有可能发生. 串行化的 :避免以上所有读问题.

可重复读 :避免脏读和不可重复读.但是虚读有可能发生. 串行化的 :避免以上所有读问题.

串行化的 :避免以上所有读问题.

Mysql 默认:可重复读

Oracle 默认:读已提交

​​​​​​​Spring 进行事务管理一组 API

***** 真正管理事务的对象

org.springframework.jdbc.datasource.DataSourceTransactionManager

JDBC 或 iBatis 进行持久化数据时使用

org.springframework.orm.hibernate3.HibernateTransactionManager

Hibernate 版本进行持久化数据时使用

​​​​​​​TransactionDefinition:事务定义信息

 

​​​​​TransactionStatus:事务的状态

  记录事务的状态

​​​​​​​Spring 的这组接口是如何进行事务管理：

平台事务管理根据事务定义的信息进行事务的管理,事务管理的过程中产生一些状态,将这些状态记录到 TransactionStatus 里面

​​​​​​​事务的传播行为

PROPAGION_XXX	:事务的传播行为
* 保证同一个事务中
PROPAGATION_REQUIRED	支持当前事务，如果不存在 就新建一个(默认)
PROPAGATION_SUPPORTS	支持当前事务，如果不存在，就不使用事务
PROPAGATION_MANDATORY	支持当前事务，如果不存在，抛出异常

* 保证没有在同一个事务中
PROPAGATION_REQUIRES_NEW	如果有事务存在，挂起当前事务，创建一个新的事务
PROPAGATION_NOT_SUPPORTED	以非事务方式运行，如果有事务存在，挂起当前事务
PROPAGATION_NEVER	以非事务方式运行，如果有事务存在，抛出异常

PROPAGATION_NESTED	如果当前事务存在，则嵌套事务执行

​​​​​​​