Spring4_Day03
Spring的AOP的基于Aspectj注解开发
Spring的基于AspectJ的AOP注解开发（入门）
入门案例
- 目标类（被增强的类）
package com.lld.Spring.demo01;
/**
* 被增强的类:目标类
* @author Administrator
*
*/
public class OrderDao {
public void save(){
System.out.println("订单保存了");
}
public void update(){
System.out.println("订单更新了");
}
public void delete(){
System.out.println("订单删除了");
}
public void find(){
System.out.println("订单查找了");
}
}
- 切面类（增强的类）
package com.lld.Spring.demo01;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
/**
* 切面类:使用注解开发
* @author Administrator
*
*/
@Aspect //表名该类是增强类
public class MyAspectAnno {
//Before代表前置增强:value里面写execution表达式(跟xml配置相同)
@Before(value="execution(* com.lld.Spring.demo01.OrderDao.save(..))")
public void before(){
System.out.println("前置增强............");
}
}
- 配置文件
<?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">
<!-- 配置开启注解开发 -->
<aop:aspectj-autoproxy />
<!-- 被增强的类:目标类 -->
<bean id="OrderDao" class="com.lld.Spring.demo01.OrderDao" />
<!-- 增强的类:切面类 -->
<bean id="MyAspectAnno" class="com.lld.Spring.demo01.MyAspectAnno" />
</beans>
- 测试类（开启了Junit整合开发）
package com.lld.Spring.demo01;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* 测试类:开启了Junit开发
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class demo {
@Resource(name="OrderDao")
private OrderDao Order;
@Test
public void demo01(){
Order.delete();
Order.update();
Order.save();
Order.find();
}
}
Spring的注解AOP的通知类型
- @Before：前置通知
- @AfterReturning：后置通知
- @Around：环绕通知
- AfterThrowing：异常抛出通知
- @After：最终通知
package com.lld.Spring.demo01;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
/**
* 切面类:使用注解开发
* @author Administrator
*
*/
@Aspect //表名该类是增强类
public class MyAspectAnno {
//Before代表前置增强:value里面写execution表达式(跟xml配置相同)
@Before(value="execution(* com.lld.Spring.demo01.OrderDao.save(..))")
public void before(){
System.out.println("前置增强............");
}
@Around(value="execution(* com.lld.Spring.demo01.OrderDao.find(..))")
public Object Around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("环绕增强前............");
Object obj = joinPoint.proceed();
System.out.println("环绕增强后............");
return obj;
}
@AfterThrowing(value="execution(* com.lld.Spring.demo01.OrderDao.update(..))",throwing="ex")
public void AfterThrowing(Throwable ex){
System.out.println("异常抛出增强............"+ex.getMessage());
}
@AfterReturning(value="execution(* com.lld.Spring.demo01.OrderDao.delete(..))",returning="result")
public void AfterReturning(Object result){
System.out.println("后置增强............"+result);
}
}
Spring的注解的AOP的切入点的配置
package com.lld.Spring.demo01;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
/**
* 切面类:使用注解开发
* @author Administrator
*
*/
@Aspect //表名该类是增强类
public class MyAspectAnno {
//Before代表前置增强:value里面写execution表达式(跟xml配置相同)
@Before(value="MyAspectAnno.pointcut2()")
public void before(){
System.out.println("前置增强............");
}
@Around(value="MyAspectAnno.pointcut4()")
public Object Around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("环绕增强前............");
Object obj = joinPoint.proceed();
System.out.println("环绕增强后............");
return obj;
}
@AfterThrowing(value="MyAspectAnno.pointcut3()",throwing="ex")
public void AfterThrowing(Throwable ex){
System.out.println("异常抛出增强............"+ex.getMessage());
}
@AfterReturning(value="MyAspectAnno.pointcut1()",returning="result")
public void AfterReturning(Object result){
System.out.println("后置增强............"+result);
}
@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.delete(..))")
private void pointcut1(){}
@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.save(..))")
private void pointcut2(){}
@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.update(..))")
private void pointcut3(){}
@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.find(..))")
private void pointcut4(){}
}
Spring的JDBC模板的使用
Spring的JDBC模板
- Spring是EE开发的一站式的框架，有EE开发的每层的解决方案。Spring对持久层也提供了解决方案：ORM模块和JDBC的模板。
- Spring提供了很多的模板用于简化开发：
Spring的JDBC模板使用入门
- 创建项目
- 引入jar包
- 基本开发包
- 数据库驱动
- Spring的JDBC模板
- 创建数据库
CREATE DATABASE Spring4_Day03_JDBC;
USE Spring4_Day03_JDBC;
CREATE TABLE account(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20),
money DOUBLE
);
- 使用JDBC模板保存数据
package com.lld.Spring.JDBC;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
public class JDBCDemo {
@Test
public void demo01(){
//创建连接池
DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
//设置连接驱动
driverManagerDataSource.setDriverClassName("com.mysql.jdbc.Driver");
//设置uri
driverManagerDataSource.setUrl("jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC");
//设置用户名
driverManagerDataSource.setUsername("root");
//设置密码
driverManagerDataSource.setPassword("1");
//创建JDBC模板
JdbcTemplate jdbcTemplate = new JdbcTemplate(driverManagerDataSource);
//进行保存
jdbcTemplate.update("insert into account values(null,?,?)","曲秃秃",250d);
}
}
将连接池和模板交给Spring管理
- 引入Spring的配置文件并进行配置
<?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">
<!-- 配置Spring的内置的连接池======================== -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC"/>
<property name="username" value="root"/>
<property name="password" value="1"/>
</bean>
<bean id="JdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="DataSource" ref="dataSource"></property>
</bean>
</beans>
- 引入spring_aop的jar包
- 使用JDBC模板
package com.lld.Spring.JDBC;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JDBCDemo2 {
@Resource(name="JdbcTemplate")
private JdbcTemplate jdbcTemplate;
@Test
public void demo01(){
jdbcTemplate.update("insert into account values(null,?,?)","666",100d);
}
}
使用开源的数据库连接池
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://39.106.68.251/Spring4_Day03_JDBC"/>
<property name="username" value="root"/>
<property name="password" value="1"/>
</bean>
C3P0的使用
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC"/>
<property name="user" value="root"/>
<property name="password" value="1"/>
</bean>
抽取配置到属性文件
<!-- 引入属性文件================================== -->
<!-- 第一种方式通过一个bean标签引入的（很少） -->
<!-- <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:jdbc.properties"/>
</bean> -->
<!-- 方式二 -->
<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>
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC
jdbc.username=root
jdbc.password=1
使用JDBC模板完成CRUD操作
- 保存操作
- 修改操作
- 删除操作
- 查询操作
package com.lld.Spring.JDBC;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.lld.Spring.domain.account;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JDBCDemo2 {
@Resource(name="JdbcTemplate")
private JdbcTemplate jdbcTemplate;
/**
* 插入操作
*/
@Test
public void demo01(){
jdbcTemplate.update("insert into account values(null,?,?)","888",100d);
}
/**
* 删除操作
*/
@Test
public void demo02(){
jdbcTemplate.update("delete from account where id=?",1);
}
/**
* 修改操作
*/
@Test
public void demo03(){
jdbcTemplate.update("update account set name=? where id=?",123,5);
}
/**
* 统计操作
*/
@Test
public void demo04(){
Long forObject = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
System.out.println(forObject);
}
/**
* 查询单个值
*/
@Test
public void demo05(){
String forObject = jdbcTemplate.queryForObject("select name from account where id=2",String.class);
System.out.println(forObject);
}
/**
* 查询一个对象
*/
@Test
public void demo06(){
account query = jdbcTemplate.queryForObject("select * from account where id=?", new MyrowMapper(),6);
System.out.println(query);
}
/**
* 查询多个对象
*/
public void demo07(){
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 rSet, int rowNum) throws SQLException {
account account = new account();
account.setId(rSet.getInt("id"));
account.setName(rSet.getString("name"));
account.setMoney(rSet.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提供的事务管理模板类
- 在业务层注入事务管理模板
- 编写事务管理代码
事务管理（声名式）
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">
<!-- 配置Service============= -->
<bean id="accountService" class="com.itheima.tx.demo2.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!-- 配置DAO================= -->
<bean id="accountDao" class="com.itheima.tx.demo2.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置连接池和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>
<!-- 配置事务管理器=============================== -->
<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" read-only="false"/>
</tx:attributes>
</tx:advice>
<!-- aop的配置 -->
<aop:config>
<aop:pointcut expression="execution(* com.itheima.tx.demo2.AccountServiceImpl.*(..))" id="pointcut1"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
</aop:config>
</beans>
注解方式
<?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">
<!-- 配置Service============= -->
<bean id="accountService" class="com.itheima.tx.demo3.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!-- 配置DAO================= -->
<bean id="accountDao" class="com.itheima.tx.demo3.AccountDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置连接池和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>
<!-- 配置事务管理器=============================== -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 开启注解事务================================ -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
- 在要是用事务的类上添加注解@Transactional
package com.itheima.tx.demo3;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;
/**
* 转账的业务层的实现类
* @author jt
*
*/
@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED)
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);
int d = 1/0;
accountDao.inMoney(to, money);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
