Spring---Spring中AOP

1. 传统的Spring AOP:

AOP:不是由Spring定义.AOP联盟的组织定义.

Spring中的通知:(增强代码)

前置通知 org.springframework.aop.MethodBeforeAdvice

* 在目标方法执行前实施增强

后置通知 org.springframework.aop.AfterReturningAdvice

* 在目标方法执行后实施增强

环绕通知 org.aopalliance.intercept.MethodInterceptor

* 在目标方法执行前后实施增强

异常抛出通知 org.springframework.aop.ThrowsAdvice

* 在方法抛出异常后实施增强

引介通知 org.springframework.aop.IntroductionInterceptor(课程不讲.)

* 在目标类中添加一些新的方法和属性

2. Spring中的切面类型

Advisor : Spring中传统切面.

* Advisor:都是有一个切点和一个通知组合.

* Aspect:多个切点和多个通知组合.

 

Advisor : 代表一般切面，Advice本身就是一个切面，对目标类所有方法进行拦截(* 不带有切点的切面.针对所有方法进行拦截)

PointcutAdvisor : 代表具有切点的切面，可以指定拦截目标类哪些方法(带有切点的切面,针对某个方法进行拦截)

IntroductionAdvisor : 代表引介切面，针对引介通知而使用切面

3. Spring的AOP开发

（1）不带有切点的切面（面向所有的方法，对所有方法进行增强）

a.  导入jar包

* spring-aop-3.2.0.RELEASE.jar

* com.springsource.org.aopalliance-1.0.0.jar

b. 编写被代理对象（接口和实现类）

public interface CustomerDao {
	public void add();
	public void delete();
	public void update();
	
}

public class customerDaoimpls implements CustomerDao{

	@Override
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("添加用户");
	}

	@Override
	public void delete() {
		// TODO Auto-generated method stub
		System.out.println("删除用户");
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("更新用户");
	}

}

c. 编写增强的代码（这里以前置增强为例）

public class BeforeAdvice implements MethodBeforeAdvice{
	
	/**
	 * method:执行的方法
	 * args:参数
	 * target:目标对象
	 */
	public void before(Method method, Object[] args, Object target)
			throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("前置增强");
	}

	

}

d. 生成代理（使用配置文件来生成代理）

* 生成代理Spring基于ProxyFactoryBean类.底层自动选择使用JDK的动态代理还是CGLIB的代理.

* 属性:

target : 代理的目标对象

proxyInterfaces : 代理要实现的接口

如果多个接口可以使用以下格式赋值

<list>

    <value></value>

    ....

</list>

proxyTargetClass : 是否对类代理而不是接口，设置为true时，使用CGLib代理

interceptorNames : 需要织入目标的Advice

singleton : 返回代理是否为单实例，默认为单例

optimize : 当设置为true时，强制使用CGLib

配置文件：

<!-- bean definitions here -->
<!--  定义目标对象 -->
	<bean id="customerdao" class="com.aop_2.customerDaoimpls"/>
<!-- 定义增强 -->
	<bean id ="beforeadvice" class="com.aop_2.BeforeAdvice"/>
	
	<!-- Spring利用配置生成代理 -->
	<bean id="customerdaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 设置目标对象 -->
		<property name="target" ref="customerdao"/>
		
		<!-- 设置实现的接口 ,value为实现类路径-->
		<property name="proxyInterfaces" value="com.aop_2.CustomerDao"/>
		<!-- 设置增强 -->
		<property name="interceptorNames" value="beforeadvice"/>
	</bean>
</beans>

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:ApplicationContext.xml")
public class SpringTest {
    @Autowired
    @Qualifier("customerdaoProxy")  //追代理对象
    private CustomerDao customerDao;
    
    @Test
    public void test(){
        customerDao.add();
        customerDao.delete();
        customerDao.update();
        
    }
}

测试结果：

前置增强
添加用户
前置增强
删除用户
前置增强
更新用户（对每个方法都实现了增强）

（2） 带有切点的切面（针对目标对象的某些方法进行增强）

PointcutAdvisor 接口:

DefaultPointcutAdvisor 最常用的切面类型，它可以通过任意Pointcut和Advice 组合定义切面

RegexpMethodPointcutAdvisor 构造正则表达式切点切面（通过正则表达式设定哪些方法需要增强）

示例：

a .创建目标

<span style="font-family:宋体;">public class OrderDao {
	public void add(){
		System.out.println("添加订单");
	}
	public void update(){
		System.out.println("更新订单");
	}
	public void delete(){
		System.out.println("删除订单");
	}
}
</span>

b .编写增强的类（以环绕增强为例）

public class AroundAdvice implements MethodInterceptor{

	public Object invoke(MethodInvocation methodinvocation) throws Throwable {
		System.out.println("环绕增强前。。。。。。。");
		//执行目标对象的方法
		Object b1 = methodinvocation.proceed();
		System.out.println("环绕增强后。。。。。。。");
		// TODO Auto-generated method stub
		return b1;
	}
	
}

c. 配置文件中生成代理

<!-- 带有切点的切面=========================================== -->
    <!-- 目标对象 -->
    <bean id="orderdao" class="com.aop_3.OrderDao"></bean>
    
    <!-- 定义增强 -->
    <bean id="aroundadvice" class="com.aop_3.AroundAdvice"></bean>
    
    <!-- 正则表达式定义切点 -->
    <bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <!-- 定义表达式,规定哪些方法执行拦截 -->
        <!-- . 任意字符  * 任意个 -->
        <!-- <property name="pattern" value=".*"/> -->
        <!-- <property name="pattern" value="cn\.itcast\.spring3\.demo4\.OrderDao\.add.*"/> -->
        <!-- <property name="pattern" value=".*add.*"></property> -->
        <property name="patterns" value=".*add.*,.*find.*"></property>
        <!-- 应用增强 -->
        <property name="advice" ref="aroundadvice"/>
    </bean>
    <!-- 生成代理对象 -->
    
    
    <bean id="orderdaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 配置目标 -->
        <property name="target" ref="orderdao"></property>
        <!-- 针对类的处理 -->
        <property name="proxyTargetClass" value="true"></property>
        <!-- 在目标上应用增强 -->
        <property name="interceptorNames" value="myPointcutAdvisor"></property>
    </bean>
</beans>

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:ApplicationContext.xml")
public class SpringTest {
    @Autowired
    @Qualifier("orderdaoProxy")  //追代理对象
    private OrderDao orderdao;
    
    @Test
    public void test(){
        orderdao.add();
        orderdao.delete();
        orderdao.update();
        
    }
}

结构：根据表达式设定的方法  会出现环绕增强的效果。

以上两种都是基于ProxyFattoryBean的代理，由上可以看出，每有一个目标对象，都要生成一个代理，后期维护工作量很大。自动代理可以解决这一问题。

3. 自动代理

前面的案例中，每个代理都是通过ProxyFactoryBean织入切面代理，在实际开发中，非常多的Bean每个都配置ProxyFactoryBean开发维护量巨大

 

自动创建代理(*****基于后处理Bean.在Bean创建的过程中完成的增强.生成的Bean就是代理.)

BeanNameAutoProxyCreator 根据Bean名称创建代理

DefaultAdvisorAutoProxyCreator 根据Advisor切面本身包含信息创建代理

* AnnotationAwareAspectJAutoProxyCreator 基于Bean中的AspectJ 注解进行自动代理

BeanNameAutoProxyCreator :按名称生成代理

示例：

配置文件：

<bean id="customerdao" class="com.aop_2.customerDaoimpls"/>
	<!-- 目标对象 -->
	<bean id="orderdao" class="com.aop_3.OrderDao"></bean>
	
	
<!-- 定义增强 -->
	<bean id ="beforeadvice" class="com.aop_2.BeforeAdvice"/>
		<!-- 定义增强 -->
	<bean id="aroundadvice" class="com.aop_3.AroundAdvice"></bean>
	
	<!-- 自动代理，基于后处理Bean,后处理Bean不需要配置ID -->
	<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
		<property name="beanNames" value="*dao"></property>
		<property name="interceptorNames" value="aroundadvice"></property>
	</bean>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:ApplicationContext2.xml")
public class SpringTest {
	@Autowired
	@Qualifier("orderdao")  //追代理对象
	private OrderDao orderdao;
	
	@Autowired
	@Qualifier("<span style="background:rgb(224,224,224);"></span>customerdao<span style="background:rgb(224,224,224);"></span>")  //追代理对象
<span style="background:rgb(224,224,224);"></span>	private CustomerDao customerdao;
	
	@Test
	public void test(){
		orderdao.add();
		orderdao.delete();
		orderdao.update();
		
		customerdao.add();
		customerdao.delete();
		customerdao.update();
		
	}
}

结果：

orderdao，<span style="background:rgb(224,224,224);"><span style="font-family:宋体;"></span></span><pre name="code" class="java">customerdao

里面的方法都被增强。

DefaultAdvisorAutoProxyCreator :根据切面中定义的信息生成代理

示例：

<!--  定义目标对象 -->
	<bean id="customerdao" class="com.aop_2.customerDaoimpls"/>
	<!-- 目标对象 -->
	<bean id="orderdao" class="com.aop_3.OrderDao"></bean>
	
	
<!-- 定义增强 -->
	<bean id ="beforeadvice" class="com.aop_2.BeforeAdvice"/>
		<!-- 定义增强 -->
	<bean id="aroundadvice" class="com.aop_3.AroundAdvice"></bean>
	
	<!-- 定义一个带切点的切面 -->
	<bean id="pointadvisoe" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
		<property name="pattern" value=".*add.*"></property>
		<property name="advice" ref="aroundadvice"></property>
	</bean>
	
	<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>
	
	
</beans>

结果：根据切面中定义的add方法进行增强。

区分基于ProxyFattoryBean的代理与自动代理区别?

***** ProxyFactoryBean:先有被代理对象,将被代理对象传入到代理类中生成代理.

   自动代理基于后处理Bean.在Bean的生成过程中,就产生了代理对象,把代理对象返回.生成Bean已经是代理对象