Spring(三)

Spring的AOP的基于AspectJ注解开发

Spring的基于AspectJ的注解的AOP开发

1、创建项目，引入jar包

 2、引入配置文件

3、编写目标类并配置

4、 编写切面类并配置

5、使用注解的AOP对象目标类进行增强

• 在配置文件中打开注解的AOP开发

• 在切面类上使用注解

6、编写测试类：

Spring的注解的·AOP的通知类型

@Before：前置通知

@AfterReturning：后置通知

@Around：环绕通知

@AfterThrowing：异常抛出通知

@After：最终通知

Spring的AOP的注解切入点的配置

Spring的JDBC的模板的使用

Spring是EE开发的一站式框架，有EE开发的每层的解决方案。Spring对持久层也提供了解决方案：ORM模块和JDBC的模板。

Spring提供了很多的模板用于简化开发。

JDBC模板使用的入门

1、创建项目，引入jar包

• 引入基本开发包
• 数据库驱动
• Spring的JDBC模板的jar包

2、创建数据库和表

create database spring4_day03;
use spring4_day03;
create table account(
	id int primary key auto_increment,
	name varchar(20),
	money double
);

3、使用JDBC的模板：保存数据

将连接池和模板交给Spring管理

引入Spring配置文件

使用Jdbc的模板

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

	@Resource(name="jdbcTemplate")
	private JdbcTemplate jdbcTemplate;

	@Test
	public void demo1() {
		jdbcTemplate.update("insert into account values(null,?,?)", "王强", 20000d);
	}
}

使用开源的连接池

DBCP的使用

• 引入jar包

 配置DBCP连接池

C3P0的使用

• 引入c3p0连接池jar包

• 配置c3p0连接池

抽取配置导属性文件

• 定义一个属性文件

• 在Spring的配置文件中引入属性文件

• 引入属性文件的值

使用JDBC的模板完成CRUD的操作

• 保存操作

@Test
//保存操作
public void demo1() {
	jdbcTemplate.update("insert into account values(null,?,?)", "789", 20000d);
}

• 修改操作

//修改操作
@Test
public void demo2() {
	jdbcTemplate.update("update account set name = ?,money = ? where id=1","xxx",500d);
}

• 删除操作

//删除操作
@Test
public void demo3() {
	jdbcTemplate.update("delete from account where id = ?",4);
}

• 查询操作

查询某个属性

//查询操作：
@Test
public void demo4() {
	String name = jdbcTemplate.queryForObject("select name from account where id = ?", String.class,1);
	System.out.println(name);
}
	
//统计查询
@Test
public void demo5() {
	Long count = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
	System.out.println(count);
}

查询返回对象或集合

//封装到一个对象中
@Test
public void demo6() {
	Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new MyRowMapper(),5);
	System.out.println(account);
}
	
//查询多条记录
@Test
public void demo7() {
	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的数据，导致一个事务中多次查询结果不一致
• 写问题
  • 丢失更新

解决读问题

• 设置事务的隔离级别
  • Read uncommitted：为提交读，任何读问题解决不了
  • Read committed：已提交读，解决脏读，但是不可重复读和虚读有可能发生。
  • Repeatable read：重复读，解决脏读和不可重复读，但是虚读有可能发生。
  • Serializable：解决所有问题

Spring的事务管理的API

• PlatformTransactionManager：平台事务管理器
  • 平台事务管理器：接口，是spring用于管理事务的真正的对象
    • DataSourceTransactionManager：底层使用JDBC管理事务
    • HibernateTransactionManager：底层使用Hibernate管理事务
• TransactionDefinition：事务定义信息
  • 事务定义：用于定义事务的相关的信息，隔离级别、超时信息、传播行为、是否只读
• TransactionStatus：事务的状态
  • 事务状态：用于记录在事务管理过程中，事务的状态的对象

事务管理的API的关系

Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态的对象中。

Spring的事务的传播行为

Spring中提供了七种事务的传播行为：

• 保证多个操作在同一个事务中
  • PROPAGATION_REQUIRED：默认值，如果A中有事务，使用A中的事务；如果A没有，创建一个新的事务，将操作包含进来。
  • PROPAGATION_SUPPORTS：支持事务，如果A中有事务，使用A中的事务；如果A没有事务，不使用事务。
  • PROPAGATION_MANDATORY：如果A中有事务，使用A中的事务；如果A没有事务，抛出异常。
• 保证多个操作不在同一个事务中
  • PROPAGATION_REQUIRES_NEW：如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作；如果A中没有事务，创建一个新事务，包含自身操作。
  • PROPAGATION_NOT_SUPPORTED：如果A中有事务，将A的事务挂起，不使用事务管理。
  • PROPAGATION_NEVER：如果A中有事务，报异常。
• 嵌套式事务
  • PROPAGATION_NESTED：嵌套事务，如果A中有事务，按照A的事务进行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点。

Spring的事务管理

搭建Spring的事务管理的环境

• 创建Service的接口和实现类

public class AccountServiceImpl implements AccountService {

	// 注入DAO
	private AccountDao accountDao;

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	@Override
	/**
	 * from：转出账号 to：转入账号 money:转账金额
	 */
	public void transfer(String from, String to, Double money) {
		accountDao.outMoney(from, money);
		accountDao.inMoney(to, money);
	}

}

• 创建DAO的接口和实现类

/**
 * 转账的DAO的实现类
 * @author dell
 *
 */
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

	@Override
	public void outMoney(String from, Double money) {
		this.getJdbcTemplate().update("update account set money = money - ? where name = ?",money,from);
	}

	@Override
	public void inMoney(String to, Double money) {
		this.getJdbcTemplate().update("update account set money = money + ? where name = ?",money,to);
	}

}

• 配置Service和DAO：交给Spring管理

<!-- 配置DAO==================== -->
<bean id="accountDao" class="com.ithou.tx.demo1.AccountDaoImpl">
		
</bean>
	
<!-- 配置service================ -->
<bean id="accountService" class="com.ithou.tx.demo1.AccountServiceImpl">
	<property name="accountDao" ref="accountDao"/>
</bean>

• 在DAO中编写扣钱和加钱方法

          配置连接池和JDBC的模板

<!-- 通过context标签引入 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
	
<!-- 配置C3P0连接池=================================== -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="${jdbc.driverClass}"/>
	<property name="jdbcUrl" value="${jdbc.url}"/>
	<property name="user" value="${jdbc.username}"/>
	<property name="password" value="${jdbc.password}"/>
</bean>

          在DAO注入Jdbc的模板

<!-- 配置DAO==================== -->
<bean id="accountDao" class="com.ithou.tx.demo1.AccountDaoImpl">
	<property name="dataSource" ref="dataSource"/>
</bean>

• 测试

注意：让DAO继承JdbcDaoSupport类之后，可以在配置文件的DAO中注入dataSource，从而不用配置Spring的JDBC模板，以简化配置文件。因为在JdbcDaoSupport类中有setDataSource方法，在此方法中，可以使用连接池dataSource创建一个jdbcTemplate。以下是其源代码。

public final void setDataSource(DataSource dataSource) {
	if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {
		this.jdbcTemplate = createJdbcTemplate(dataSource);
		initTemplateConfig();
	}
}

Spring的事务管理：一类：编程式事务（需要手动）--了解

第一步：配置平台事务管理器

<!-- 配置平台事务管理器================================= -->
<bean id="transactionManger" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="daraSource" ref="dataSource"/>	
</bean>

第二步：Spring提供了事务管理的模板类

<!-- 配置事务的管理的模板类 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
	<property name="transactionManager" ref="transactionManger"/>
</bean>

第三步：在业务层注入事务管理的模板

编写事务管理的代码

public void transfer(String from, String to, Double money) {
		
	transactionTemplate.execute(new TransactionCallbackWithoutResult() {
		@Override
		protected void doInTransactionWithoutResult(TransactionStatus arg0) {
			accountDao.outMoney(from, money);
			int i = 1/0;
			accountDao.inMoney(to, money);
		}
	});
}

测试

Spring的事务管理：二类：声明式事务管理（通过配置实现）--AOP

1、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>
		<!-- 事务管理的规则 -->
		<!-- <tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT"/>
		<tx:method name="update*" propagation="REQUIRED"/>
		<tx:method name="delete*" propagation="REQUIRED"/>
		<tx:method name="find*" read-only="true"/> -->
		<tx:method name="*" propagation="REQUIRED"/>
	</tx:attributes>
</tx:advice>

• 第五步：AOP的配置

<!-- aop的配置 -->
<aop:config>
	<aop:pointcut expression="execution(* com.ithou.tx.demo2.AccountServiceImpl.*(..))" id="pointcut1"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>

• 测试

2、注解方式的声明式事务管理

• 第一步：引入aop的开发包
• 第二步：恢复转账环境
• 第三步：配置事务管理器

<!-- 配置事务管理器============================ -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"/>
</bean>

• 第四步：开启注解事务

<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

• 第五步：在业务层添加注解