一、Spring的AOP的基于AspectJ注解开发
1、Spring的基于AspectJ的注解的AOP开发
(1)、创建项目,引入jar包
(2)、引入配置文件
<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>
(3)、编写目标类并配置
- 配置
<!-- 配置目标类 -->
<bean id="orderDao" class="cn.itcast.spring.demo1.OrderDao"></bean>
(4)、编写切面类并配置
- 编写
public class MyAspectAnno {
public void before() {
System.out.println("前值增强======");
}
}
- 配置
<!-- 配置切面类 -->
<bean id="myAspect" class="cn.itcast.spring.demo1.MyAspectAnno"></bean>
(5)、使用注解的AOP对象目标类进行增强
- 在配置文件中打开注解的AOP开发
<!-- 在配置文件中开启注解的AOP开发 -->
<aop:aspectj-autoproxy/>
- 在切面类上使用注解
@Aspect
public class MyAspectAnno {
@Before(value="execution(* cn.itcast.spring.demo1.OrderDao.save(..))")
public void before() {
System.out.println("前值增强======");
}
}
(6)、编写测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {
@Resource(name="orderDao")
private OrderDao orderDao;
@Test
public void demo1() {
orderDao.save();
orderDao.update();
orderDao.delete();
orderDao.find();
}
}
2、Spring的注解的AOP的通知类型
(1)、@Before:前置通知
// 前置通知
@Before(value = "execution(* cn.itcast.spring.demo1.OrderDao.save(..))")
public void before() {
System.out.println("前值增强======");
}
(2)、@AfterReturning:后置通知
// 后置通知
@AfterReturning(value = "execution(* cn.itcast.spring.demo1.OrderDao.delete(..))", returning = "result")
public void afterRetruning(Object result) {
System.out.println("后置增强=====" + result);
}
(3)、@Around:环绕通知
// 环绕通知
@Around(value="execution(* cn.itcast.spring.demo1.OrderDao.update(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕前增强=====");
Object obj = joinPoint.proceed();
System.out.println("环绕后增强=====");
return obj;
}
(4)、@AfterThrowing:异常抛出通知
// 异常抛出通知
@AfterThrowing(value="execution(* cn.itcast.spring.demo1.OrderDao.find(..))", throwing="EX")
public void afterThrowing(Throwable EX) {
System.out.println("异常抛出增强=====" + EX.getMessage());
}
(5)、@After:最终通知
// 最终通知
@After(value="execution(* cn.itcast.spring.demo1.OrderDao.find(..))")
public void after() {
System.out.println("最终通知=====");
}
3、Spring的注解的AOP的切入点的配置
- 注解切入点配置:
// 切入点的注解:
@Pointcut(value="execution(* cn.itcast.spring.demo1.OrderDao.find(..))")
private void pointcut1() {}
- 切入点使用:
// 切入点使用
@After(value="MyAspectAnno.pointcut1()")
public void after() {
System.out.println("最终通知=====");
}
二、 Spring的JDBC的模板的使用
1、Spring的JDBC的模板
Spring是EE开发的一站式的框架,有EE开发的每层的解决方案。Spring对持久层也提供了解决方案:ORM模块和JDBC的模板。
Spring提供了很多的模板用于简化开发:
(1)、JDBC模板使用的入门
- 创建项目,引入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的模板:保存数据
public class JdbcDemo1 {
@Test
// jdbc模板类似于Dbutils
public void demo1() {
// 创建连接池:
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring4_day03");
dataSource.setUsername("root");
dataSource.setPassword("123");
// 创建JDBC模板:
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.update("insert into account values (null,?,?)", "宗晓", 10000d);
}
}
2、将连接池和模板交给Spring管理
(1)、引入Spring的配置文件
<!-- 配置Spring内置的连接池 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!-- 属性注入 -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring4_day03"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>
<!-- 配置Spring的JDBC的模板 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
(2)、使用JDBC的模板
- 需要引入spring_aop的jar包
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcDemo2 {
@Resource(name="jdbcTemplate")
private JdbcTemplate jdbcTemplate;
@Test
public void demo1() {
jdbcTemplate.update("insert into account values (null,?,?)", "赵文", 12000d);
}
}
3、使用开源的数据库连接池
(1)、DBCP的使用
-
引入jar包
-
配置DBCP连接池
<!-- 配置DBCP连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql:///spring4_day03"/>
<property name="username" value="root"/>
<property name="password" value="123"/>
</bean>
<!-- 配置Spring的JDBC的模板 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
(2)、C3P0的使用
-
引入c3p0连接池jar包
-
配置c3p0连接池
<!-- 配置C3P0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///spring4_day03"/>
<property name="user" value="root"/>
<property name="password" value="123"/>
</bean>
<!-- 配置Spring的JDBC的模板 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>
4、抽取配置到属性文件
(1)、定义一个属性文件
- 文件名为"jdbc.properties"
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring4_day03
jdbc.username=root
jdbc.password=123
(2)、在Spring的配置文件中引入属性文件
- 第一种方式
<!-- 第一种方式:通过一个bean标签引入(很少用) -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:jdbc.properties"/>
</bean>
- 第二种方式
<!-- 第二种方式:通过context标签引入 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
(3)、引入属性文件的值
<!-- 配置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>
(4)、测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcDemo2 {
@Resource(name="jdbcTemplate")
private JdbcTemplate jdbcTemplate;
@Test
public void demo1() {
jdbcTemplate.update("insert into account values (null,?,?)", "邓嘉", 18000d);
}
}
5、使用JDBC的模板完成CRUD的操作
(1)、保存操作
@Test
// 保存操作
public void demo1() {
jdbcTemplate.update("insert into account values (null,?,?)", "邓嘉", 18000d);
}
(2)、修改操作
@Test
// 修改操作
public void demo2() {
jdbcTemplate.update("update account set name = ?, money = ? where id = ?", "何斌", 13800d, 4);
}
(3)、删除操作
@Test
// 删除操作
public void demo3() {
jdbcTemplate.update("delete from account where id = ?", 4);
}
(4)、查询操作
- 查询某个属性
@Test
// 查询操作
public void demo4() {
String name = jdbcTemplate.queryForObject("select name from account where id = ?", String.class, 5);
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的事务管理
1、事务的回顾
(1)、什么事务
- 事务:逻辑上的一组操作,组成这组操作的各个单元,要么全都成功,要么全都失败。
(2)、事务的特性
- 原子性 :事务不可分割
- 一致性 :事务执行前后数据完整性保持一致
- 隔离性 :一个事务的执行不应该受到其他事务的干扰
- 持久性 :一旦事务结束,数据就持久化到数据库
(3)、如果不考虑隔离性引发安全性问题
- 读问题
- 脏读 :一个事务读到另一个事务未提交的数据
- 不可重复读 :一个事务读到另一个事务已经提交的update的数据,导致一个事务中多次查询结果不一致
- 虚读、幻读 :一个事务读到另一个事务已经提交的insert的数据,导致一个事务中多次查询结果不一致。
- 写问题
- 丢失更新
(4)、解决读问题
- 设置事务的隔离级别
- Read uncommitted :未提交读,任何读问题解决不了。
- Read committed :已提交读,解决脏读,但是不可重复读和虚读有可能发生。
- Repeatable read :重复读,解决脏读和不可重复读,但是虚读有可能发生。
- Serializable :解决所有读问题。
2、Spring的事务管理的API
(1)、PlatformTransactionManager:平台事务管理器
- 平台事务管理器:接口,是Spring用于管理事务的真正的对象。
- DataSourceTransactionManager :底层使用JDBC管理事务
- HibernateTransactionManager :底层使用Hibernate管理事务
(2)、TransactionDefinition:事务定义信息
- 事务定义:用于定义事务的相关的信息,隔离级别、超时信息、传播行为、是否只读
(3)、TransactionStatus:事务的状态
- 事务状态:用于记录在事务管理过程中,事务的状态的对象。
(4)、事务管理的API的关系:
Spring进行事务管理的时候,首先平台事务管理器根据事务定义信息进行事务的管理,在事务管理过程中,产生各种状态,将这些状态的信息记录到事务状态的对象中。
3、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中的操作,如果没有异常,执行通过,如果有异常,可以选择回滚到最初始位置,也可以回滚到保存点。
4、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的接口和实现类
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管理
<!-- 配置Service -->
<bean id="accountService" class="cn.itcast.tx.demo1.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
</bean>
<!-- 配置DAO -->
<bean id="accountDao" class="cn.itcast.tx.demo1.AccountDaoImpl">
</bean>
- 在DAO中编写扣钱和加钱方法:
- 配置连接池和JDBC的模板
<!-- 配置连接池和JDBC的模板 -->
<!-- 1、引入属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 2、配置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的实现类继承JdbcDaoSupport类。
<!-- 配置DAO -->
<bean id="accountDao" class="cn.itcast.tx.demo1.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
- 测试
5、Spring的事务管理:第一类:编程时事务(需要手动编写代码)——了解
(1)、第一步:配置平台事务管理器
<!-- 配置平台事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
(2)、第二步:Spring提供了事务管理的模板类
- 配置事务管理的模板类
<!-- 配置事务管理的模板 -->
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"></property>
</bean>
(3)、第三步:在业务层注入事务管理的模板
<!-- 配置Service -->
<bean id="accountService" class="cn.itcast.tx.demo1.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
<!-- 注入事务管理的模板 -->
<property name="transactionTemplate" ref="transactionTemplate"/>
</bean>
(4)、编写事务管理的代码
public void transfer(String from, String to, Double money) {
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
accountDao.outMoney(from, money);
int i = 1 / 0;
accountDao.inMoney(to, money);
}
});
}
疑问:跟着视频一步一步敲的,这里我不需要在参数是加“final”修饰,但是视频中得加,否则就会报错。不过在最后的测试中结果正常。
如果你知道解析,请写在评论区,谢谢!
(5)、测试
6、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="transfer" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
- 第五步:AOP的配置
<!-- AOP的配置 -->
<aop:config>
<aop:pointcut expression="execution(* cn.itcast.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"/>
- 第五步:在业务层添加注解
@Transactional
public class AccountServiceImpl implements AccountService {