Spring

03spring笔记

一、AOP简介

一、AOP概念

1、AOP（Aspect Oriented Programing）面向切面编程，一种编程范式。
2、AOP弥补了OOP（OOP是面向对象的，是将类的共性向上抽取，抽取成一个父类），基于OOP基础上进行的横向开发。
2.1 OOP规定程序开发以类为主体模型，围绕对象进行，完成某个任务先构建模型。
2.2 AOP开发主要关注基于OOP开发中的共性功能，一切围绕共性功能进行，完成某个任务先构建可能遇到的所有共性功能（当所有功能都开发出来也就没有了共性和非共性之分）。
2.3 AOP的底层是动态代理，是面对方法的，把方法作为一个整体。

二、AOP的作用

目标：实现“插拔式组件体系结构”搭建。

三、AOP的优势

1、提高代码的可重用性。
2、业务代码编码更简洁。
3、业务代码维护更高效。
4、业务功能扩展更便捷。

四、AOP相关概念

***********************************************
1.Joinpoint(连接点) : 目标类的所有方法都是连接点 。
2.Pointcut(切入点) : 真正扩展的方法。
3.Advice(通知) : 扩展出来的方法。
***********************************************
4.Aspect(切面) : 具体在方法的什么位置追加扩展的功能。
5.Targer(目标对象) : UserServiceImpl实现类的对象。
6.Proxy(代理) : UserServiceImpl实现类的代理对象。
7.Weaving(织入) : 把目标代码和扩展代码整合到一起, 创建出来代理对象的过程。

五、AOP使用步骤

1、导入依赖
2、定义接口和实现类
3、定义扩展功能的MyAdvice, 提供一个方法
4、配置AOP

二、Aop配置(XML)

<!--1. 把所需要管理的类交给spring管理-->
<bean id="us" class="com.cwl.service.impl.UserServiceImpl"/>
<bean id="myAdvice" class="com.cwl.advice.MyAdvice" />

<!--
	2. 配置AOP
		aop:cofig : aop 的配置，专门用来配置aop的。
			aop:aspcet : aop的切面
				ref : 使用那个对象来做增强，做通知，做扩展！ 也就是扩展出来的是什么功能。
			aop:before : 表示前置增强，先调用扩展出来的功能方法，再调用目标方法。
				method : 扩展出来的对象中的方法，指具体的功能。
				pointcut : 就是切入点，具体是什么方法需要被扩展！
	
-->
<aop:config>
	<aop:aspect ref="myAdvice">
		<aop:before method="print" pointcut="execution(* com.cwl.service.impl.UserServiceImpl.add())" />
	</aop:aspect>
</aop:config>

<!-- execution(* com.cwl..*.*(..))  只会增强自己类中的方法-->
<aop:before method="print" printcut="execution(* com.cwl..*.*(..))"/>

<aop:config>
	<aop:aspect ref="myAdvice">
		<!--把切入点表达式提取到这个位置，为所有的通知中类使用 相当于局部变量-->
		<aop:pointcut id="myPointcut" expression="execution(* com.cwl..*.*(..)"/>
		<aop:before method="print" pointcut-ref="myPointcut">
	</aop:aspect>
</aop:config>

<aop:config>
	<!--把切入点的表达式提取到这个位置，为所有的aop:aspect标签使用 相当于全局变量-->
	<aop:pointcut id="myPointcut" expression="excution(* com.cwl..*.*(..))"/>
	<aop:aspect ref="myAdvice">
		<aop:before method="print" pointcut-ref="myPointcut">
	</aop:aspect>
</aop:config>

<!-- 通知种类 -->
<!--1. 前置增强 在目标方法之前执行-->
<aop:before method="" printcut="execution(* com.cwl..*.*(..))"/>
<!--2. 后置增强  目标方法有异常，也会执行-->
<aop:after method="" printcut="execution(* com.cwl..*.*(..))"/>
<!--3. 返回后增强 目标方法有异常，就不会执行-->
<aop:after-retruning method="" printcut="excution(* com.cwl..*.*(..))"/>
<!--4. 异常增强 只有目标方法抛出异常的时候才会执行-->
<aop:after-throwing method="" printcut="excution(* com.cwl..*.*(..)"/>
<!--5. 环绕增强-->
<aop:around method="" printcut="excution(* com.cwl..*.*(..))"/>

三、Aop配置(注解)

AOP注解使用步骤

1.@Component : 把这个类交给spring管理
2. @Aspect : 表示这个类是一切面增强类，专门用来增强功能的
3.在方法上打上通知类的注解
	前置增强注解: @Before
	后置增强注解: @After
	返回后增强注解: @After-retruning 
	异常增强注解: @After-throwing
	环绕增强注解: @Around
4.打开AOP注解开关和扫描包的开关
	4.1 applicationContext.xml中的
		扫描IOC和DI的注解开关
			<context:component-scan base-package="com.cwl"/>
		打开AOP注解的开关
			<aop:aspectj-autoproxy/>
	4.2 纯注解中的
		扫描包的开关
			@ComponentScan(com.cwl)
		打开AOP注解的开关
			@EnableAspectJAutoProxy

@Aspect
@Component
public class MyAdvice{

	@Pointcut("excution(* com.cwl..*.*(..))")
	public void abc(){}
	
	@Before("abc()")
	public void before(){
		sout(".........")
	}
	
	@Around("abc()")
	public Object around(ProceedingJoinPoint pjp) throw Throwable{
		Object ret = pjp.proced();
		return ret;
	}
}

四、事务管理

Spring事物核心对象

1、 对于简单的业务层转调数据层的单一操作，事物开启在业务层或者数据层无太大差别；当业务中包含多个数据层的调用时，需要在业务层开启事务，对数据层中多个操作进行组合并规属于同一个事物进行处理。
2、Spring为业务层提供了整套的事物解决方案：
2.1 PlatformTransactionManager（平台事务管理器实现类）
2.2 TransactionDefinition（定义了事物的基本信息）
2.3 TransactionStatus（定义事物在执行过程中某个时间点上的状态信息以及对应的状态操作）

PlatformTransactionManager

1. DataSourceTransactionManager ----> 适用于Spring JDBC 或 MyBatis(最为常用)
2. HibernateTransactionManager ----> 适用于Hibernate3.0
3. JpaTransactionManager ----> 适用于 JPA
4. JdoTransactionManager ----> 适用于JDO
5. JtaTranSactionManager ----> 适用于JTA

1. JPA（Java Persistence API）Java EE 标准之一，为POJO提供持久化标准规范，
	并规范了持久化开发的统一API，符合JPA规范的开发可以在不同的JPA框架下运行
2. JDO(Java Data Object )是Java对象持久化规范，用于存取某种数据库中的对象，
	并提供标准化API。与JDBC相比，JDBC仅针对关系数据库进行操作，JDO可以扩展
	到关系数据库、文件、XML、对象数据库（ODBMS）等，可移植性更强
3. JTA（Java Transaction API）Java EE 标准之一，允许应用程序执行分布式事务处
	理。与JDBC相比，JDBC事务则被限定在一个单一的数据库连接，而一个JTA事务可以有
	多个参与者，比如JDBC连接、JDO 都可以参与到一个JTA事务中

事务控制方式

1、编程式（写代码来完成事务的管理）
2、声明式（XML）

<!--配置事务-->
<!--
	tx:advice : 用来定义事务的规则
	id : 唯一标识符
	transaction-manager : 事务管理员
		tx:method : 使用它来给具体的每一个方法配置事务规则
			name : 方法名，可以写一个方法、一类方法、所有方法
			isolation : 隔离级别
			timeout : -1 表示永不超时，超时之后会回滚
			read-only : 是否只读， false 不是只读的事物，可以进行读写操作，
						否则只能进行读操作
			propagation : 传播行为
-->

<tx:advice id="txAdvice" transaction-manager="transactionManage">
        <tx:attributes>
            <tx:method name="transfer" isolation="DEFAULT" timeout="-1" read-only="false" propagation="REQUIRED"/>
            <tx:method name="add*" isolation="DEFAULT" timeout="-1" read-only="false" propagation="REQUIRED"/>
            <tx:method name="update*" isolation="DEFAULT" timeout="-1" read-only="false" propagation="REQUIRED"/>
            <tx:method name="delete*" isolation="DEFAULT" timeout="-1" read-only="false" propagation="REQUIRED"/>
            <tx:method name="find*" isolation="DEFAULT" timeout="-1" read-only="true" propagation="REQUIRED"/>
        </tx:attributes>
</tx:advice>

<!--aop配置-->
<!--
	aop:config : 用来配置aop
		aop:advisor : 专门用来配置事务的标签
			advice-ref : 具体事物规则
			pointcut : 切入点，负责找方法
-->

<aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.cwl.*.*(..))"/>
</aop:config>

注：事务传播行为

传播属性	 		 |事务管理员   | 事务协调员

REQUIRED  		 |开启T1      | 加入T1
				 |无          | 新建T2
				 
REQUIRES_NEW     |开启T1      | 新建T2
				 |无          | 新建T2
SUPPORTS         |开启T1      | 加入T1
				 |无          | 无
NOT_SUPPORTS     |开启T1      | 无   
				 |无          | 无   
MANDATORY        |开启T1      | 加入T1  
				 |开启T1      | ERROR
NEVER            |开启T1      | ERROR
				 |无          | 无   
NESTED           |设置savePoint，一旦事务回滚，事物将回滚到savePoint处，
				 | 交由客户响应提交/回滚

3、声明式（注解+XML）

<!--事务的配置-->
<!--让spring创建事务管理员对象--> 
<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"/>
</bean>
<!--注解事务的开关-->
<tx:annotation-driven />

@EnableTransactionManagement  //开启注解驱动
@Configuration
public class AppConfig{
	@Value(""${db.driver})
	private String driver;
	......
	@Bean
	public DruidDataSource dataSource(){
		.......
		return ds;
	}
	@Bean
	public SqlSessionFactoryBean sfb(DataSource ds){
		......
		return sfb;
	}
	@Bean
	public static MapperScannerConfigurer msc(){
		.......
		return msc;
	}
	@Bean
	public DataSourceTransactionManager tm(DataSource ds){
		DataSourceTransactionManager tm = new DataSourceTransactionManager();
		tm.setDataSource(ds);
		return tm;
	}
}

@Transactional  // 定义在方法、类、接口上方  作用：开启事务，并制定相关事务属性
@Service
public class TransactionalServiceImpl implements TransactionalService{}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestTransactionalServiceImpl{}

4、声明式（纯注解）

@EnableTransactionManagement  //开启注解驱动
@PropertySource("db.properties")
@componentScan("com.cwl")
@Configuration
public class AppConfig{}

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(class=AppConfig.class)
public class TestTransactionalServiceImpl{}