Sping aop XML与注解方式

墨蓝 2022-03-29 03:16 195阅读 0赞

# spring的 aop: #

### aop:面向方面的编程,面向切面的编程,面向横切的编程 ###

方面就是新的业务功能,
            把新的方面的功能横切到老的业务的前或后

### spring的aop的底层用的是动态代理 ###

如果目标类有接口就默认用jdk动态代理
           如果目标类没有接口就用默认cglib动态代理
           如果目标类有接口且不是final的,还想用cglib动态代理则需要单独配置

### spring aop中定义个一套独有的表达式规则用于指定某些业务方法横切新功能 ###

## 实现spring aop的步骤: ##

### 1.创建一个工程 工程是基础 ###

### 2.导入jar包 spring的功能基础 ###

#### spring的基础jar ####

spring-context.jar
       spring-core.jar
       spring-beans.jar
       spring-expression.jar
       commons-logging.jar

#### spring aop的jar ####

spring-aop.jar
      aspectjweaver-1.8.7.jar
      aopalliance-1.0.jar

### 3.创建java类 ###

#### 老的业务类: ####

UserDao.java   UserDaoImpl.java
         UserService.java    UserServiceImpl.java

新的业务功能/新方面的功能/新的切面的功能,简称为方面/切面  
由动态代理创建代理类用于调用接口方法,在接口方法中耦合切面和老业务功能

#### 4.创建spring的配置文件 ####

springaop的xml版本
    springaop的annotation版本
    无论是xml版本还是注解版本
         a.实例化老业务和新业务的对象(ioc)
         b.根据业务需求,设定对象的注入关系(di)
         c.写spring的特有的表达式规则,用于指定哪些方法需要横切新的功能<aop:XXX>

#### 5.启动spring的容器读取spring的配置文件 ####

#### 6.从spring容器中取出对应的对象备用 ####

### xml版本: ###

#### 新业务功能: ####

TransactionManager.java

/** * 此类是一个新功能类,用于给原有业务添加事务处理的功能 * 符合单一职责原则,此类只做事务管理 * @author Administrator * */
     	public class TransactionManager { 
     		/** * 事务的开启 * 在前置通知方法中得到目标的参数及其他信息 */
     		public void begin(JoinPoint joinPoint){ 
     			System.out.print("事务开启");
     			System.out.println("目标方法的参数:"+joinPoint.getArgs()[0].getClass());
     			User user=(User)joinPoint.getArgs()[0];
     			System.out.println("目标方法的参数的值:"+user.getName()+" "+user.getPassword());
     			System.out.println("目标方法的名称:"+joinPoint.getSignature().getName());
     			System.out.println("调用目标方法的目标对象"+joinPoint.getTarget().getClass());
     			
     		}
     		/** * 事务提交 * 在后置通知中得到目标方法的参数及其他信息,还可以得到目标方法的返回值 * 注意:如果有JoinPoint joinPoint参数一定要放参数的第一个位置 */
     		public void commit(JoinPoint joinPoint,Object returnValue){ 
     			System.out.println("事务提交");
     			System.out.println("目标方法的返回值:"+returnValue);
     		}
     		/** * 事务的回滚 * 在异常通知中得到目标方法的参数及其他信息,不能得到目标方法的返回值,但能得到异常信息 */
     		public void rollback(JoinPoint joinPoint,Throwable ex){ 
     			System.out.println("事务回滚");
     			System.out.println("目标方法的异常信息:"+ex.getMessage());
     		}
     		public void finalMethod(JoinPoint joinPoint){ 
     			System.out.println("finally");
     		}
     		/** * 环绕通知,可以完全替换前4个通知 * 用环绕通知有一个最大的好处,能够控制目标方法的执行 * @param pjp * @return * @throws Throwable */
     		public Object around(ProceedingJoinPoint pjp) throws Throwable { 
     		    Object retVal =null;
     		    try{ 
     		    	//前置通知
     		    	System.out.println("前置通知");
     		    	System.out.println("目标方法的参数:"+pjp.getArgs()[0].getClass());
     				User user=(User)pjp.getArgs()[0];
     				System.out.println("目标方法的参数的值:"+user.getName()+" "+user.getPassword());
     				System.out.println("目标方法的名称:"+pjp.getSignature().getName());
     				System.out.println("调用目标方法的目标对象"+pjp.getTarget().getClass());
     		    	
     				retVal = pjp.proceed();//调用目标方法
     		    	//后置通知
     		    	System.out.println("后置通知");
     		    	System.out.println("目标方法的返回值:"+retVal);
     		    }catch(Exception e){ 
     		    	//异常通知
     		    	System.out.println("异常通知");
     		    	e.printStackTrace();
     		    }finally{ 
     		    	//最终通知
     		    	System.out.println("最终通知");
     		    }	    
     		    return retVal;
     		}
     	}

spring的配置文件 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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation=" http://www.springframework.org/schema/beans file:///c:/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/aop file:///c:/schema/aop/spring-aop-4.3.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/context file:///c:/schema/context/spring-context-4.3.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    			
    		   
    		   <bean id="userDao" class="com.arno.dao.impl.UserDaoImpl"></bean>
    		   <bean id="userService" class="com.arno.service.impl.UserServiceImpl">
    		   	    <property name="userDao" ref="userDao"></property>
    		   </bean>   
    		   
    		   <bean id="tm" class="com.arno.other.TransactionManager">
    		   </bean>
    		   
    		   
    		   <aop:config proxy-target-class="true">
    		        
    		        <aop:aspect id="myTransactionAspect" ref="tm">
    		            
    		        	<aop:pointcut id="businessService" expression="execution(* com.arno.service..*.*(..))"/>
    		        	<aop:pointcut id="businessService1" expression="execution(* com.arno.service..*.*(..)) and args(user)"/>
    		        	
    		
    		
    		
    				    
    		
    		
    		
    		
    				    
    		
    		
    		
    		
    				    
    		
    		
    		
    		            
    		            <aop:around pointcut-ref="businessService" method="around"/>
    		        </aop:aspect>
    		        
    		   </aop:config>  
    		</beans>

#### 有关于spring aop中的那些让你发狂的几个概念解释: ####

##### 切面 aspect: #####

切面是一个类,是一个新业务的功能类;
                切面类中有很多个通知方法
            	比如:TransactionManager.java

##### 连接点 joinpoint: #####

连接点就是用代理对象调用目标方法的那句话
               只有用代理对象调用了目标方法,才有可能把新的业务横切到老的业务上
               没有连接点,老的业务和新的业务永远不会耦合
            比如:userService.addUser(new  User());//userService是代理对象

##### 通知 advice: #####

通知就是一些功能方法,每个功能就是一个通知,通知存在于切面类中
                可以有很多个通知的方法
         比如: begin方法  前置通知
                    commit方法   后置通知
                    rollback方法   异常通知
                    finalMethod方法   最终通知
                    around方法             环绕通知
          环绕通知能完全替代上面的4个通知,环绕通知能控制目标方法的执行
          环绕通知和前4中不要同时使用

##### 切入点 pointcut: #####

切入点是把切面中的通知,切在什么地方,一般指的老业务中的方法上
                    切入点是且在方法上
                    切入点一般要配合execution表达式和within表达式一同使用

##### execution表达式 #####

修饰符   返回值  包名.类名.方法名(参数) throws 异常类型

###### spring的官方案例: ######

§ the execution of any public method:匹配任意公有方法
    			公有的 任意返回类型,任意包任意类,任意方法名称,任意参数
    			execution(public * *(..))
    			§ the execution of any method with a name beginning with "set":
    			任意返回类型,任意包,任意类,任意以set开头的方法,任意参数
    			execution(* set*(..))
    			§ the execution of any method defined by the AccountService interface:
    			任意返回类型,com.xyz.service.AccountService接口中的任意方法,任意参数
    			execution(* com.xyz.service.AccountService.*(..))
    			§ the execution of any method defined in the service package:
    			任意返回类型,com.xyz.service包下任意类或接口,任意方法,任意参数
    			execution(* com.xyz.service.*.*(..))
    			§ the execution of any method defined in the service package or a sub-package:
    			任意返回类型,com.xyz.service包及其子包中的任意类,任意方法,任意参数
    			execution(* com.xyz.service..*.*(..))

##### winthin表达式: #####

###### spring官方案例: ######

any join point (method execution only in Spring AOP) within the service package:
    		   com.xyz.service包中的任意接口或类
    		   within(com.xyz.service.*)
    			any join point (method execution only in Spring AOP) within the service package or a sub-package:
    			com.xyz.service包及其子包中的任意类
    		   within(com.xyz.service..*)

##### 总结execution控制粒度细,控制到方法 winthin控制粒度粗,控制类 #####

目标对象 targetObject:是老业务类的对象 比如UserServiceImpl的对象

### aop代理: ###

用spring的aop的底层用的是动态代理,aop代理就是用springaop生成的代理对象
    织入weaving:把新的功能织入到老的功能上去,引申义就是横切/切入

#### springaop的注解版本: ####

TransactionManager.java

/** * 此类是一个新功能类,用于给原有业务添加事务处理的功能 * 符合单一职责原则,此类只做事务管理 * @author Administrator * */
    @Component("tm")
    @Aspect
    public class TransactionManager { 
    	@Pointcut("execution(* com.arno.service..*.*(..))")
    	public void myTransactionPointCut() { }
    	/** * 事务的开启 * 在前置通知方法中得到目标的参数及其他信息 */
    	//@Before(value="myTransactionPointCut()")
    	public void begin(JoinPoint joinPoint){ 
    		System.out.print("事务开启");
    		System.out.println("目标方法的参数:"+joinPoint.getArgs()[0].getClass());
    		User user=(User)joinPoint.getArgs()[0];
    		System.out.println("目标方法的参数的值:"+user.getName()+" "+user.getPassword());
    		System.out.println("目标方法的名称:"+joinPoint.getSignature().getName());
    		System.out.println("调用目标方法的目标对象"+joinPoint.getTarget().getClass());
    		
    	}
    	/** * 事务提交 * 在后置通知中得到目标方法的参数及其他信息,还可以得到目标方法的返回值 * 注意:如果有JoinPoint joinPoint参数一定要放参数的第一个位置 */
    	//@AfterReturning(value="myTransactionPointCut()",returning="returnValue")
    	public void commit(JoinPoint joinPoint,Object returnValue){ 
    		System.out.println("事务提交");
    		System.out.println("目标方法的返回值:"+returnValue);
    	}
    	/** * 事务的回滚 * 在异常通知中得到目标方法的参数及其他信息,不能得到目标方法的返回值,但能得到异常信息 */
    	//@AfterThrowing(value="myTransactionPointCut()",throwing="ex")
    	public void rollback(JoinPoint joinPoint,Throwable ex){ 
    		System.out.println("事务回滚");
    		System.out.println("目标方法的异常信息:"+ex.getMessage());
    	}
    	//@After(value="myTransactionPointCut()")
    	public void finalMethod(JoinPoint joinPoint){ 
    		System.out.println("finally");
    	}
    	/** * 环绕通知,可以完全替换前4个通知 * 用环绕通知有一个最大的好处,能够控制目标方法的执行 * @param pjp * @return * @throws Throwable */
    	@Around(value="myTransactionPointCut()")
    	public Object around(ProceedingJoinPoint pjp) throws Throwable { 
    	    Object retVal =null;
    	    try{ 
    	    	//前置通知
    	    	System.out.println("前置通知");
    	    	System.out.println("目标方法的参数:"+pjp.getArgs()[0].getClass());
    			User user=(User)pjp.getArgs()[0];
    			System.out.println("目标方法的参数的值:"+user.getName()+" "+user.getPassword());
    			System.out.println("目标方法的名称:"+pjp.getSignature().getName());
    			System.out.println("调用目标方法的目标对象"+pjp.getTarget().getClass());
    	    	
    			retVal = pjp.proceed();//调用目标方法
    	    	//后置通知
    	    	System.out.println("后置通知");
    	    	System.out.println("目标方法的返回值:"+retVal);
    	    }catch(Exception e){ 
    	    	//异常通知
    	    	System.out.println("异常通知");
    	    	e.printStackTrace();
    	    }finally{ 
    	    	//最终通知
    	    	System.out.println("最终通知");
    	    }	    
    	    return retVal;
    	}
    }

spring.xml文件:

##### 一个需求或目的: #####

老的业务
    新的业务
    新的业务横切到老的业务上

代理模式能够实现

#### 静态代理: ####

用静态代理类方式把老业务和新的业务耦合在一起
     在编译期间就确认老业务和新业务的耦合关系

#### 动态代理: ####

##### jdk的动态代理 #####

动态生成代理类(由jdk底层来创建,程序员是看不见的)
         用动态生成的代理类和InvocationHandler接口一起做到老业务和新业务的耦合
         代理类是在运行期间才出现的,所以叫做动态代理
          代理类和目标类是兄弟关系

##### cglib动态代理 #####

动态生成代理类(由asm.jar来创建,程序员是看不见的)
         用动态生成的代理类和MethodInterceptor接口一起做到老业务和新业务的耦合
         代理类是在运行期间才出现的,所以叫做动态代理
         代理类是目标类的子类

**动态代理实现,会把新的业务功能全部横切到老业务的方法的前或后  
spring aop解决了把新业务横切到老业务的部分方法的前或后**