spring（二） AOP注入

AOP概念

l  AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码

l  经典应用：事务管理、性能监视、安全检查、缓存 、日志等

l  Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码

l  AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

Aop的实现原理

l aop底层将采用代理机制进行实现。

专业术语

1.target：目标类，需要被代理的类。例如：UserService

2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法

3.PointCut 切入点：已经被增强的连接点。例如：addUser()

4.advice 通知/增强，增强代码。例如：after、before

5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.

6.proxy 代理类

7. Aspect(切面): 是切入点pointcut和通知advice的结合

一个线是一个特殊的面。

一个切入点和一个通知，组成成一个特殊的面。

1.execution()  用于描述方法 【掌握】

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

修饰符，一般省略

public             公共方法

*                    任意

返回值，不能省略

void               返回没有值

String             返回值字符串

*                   任意

包，[省略]

com.itheima.crm                   固定包

com.itheima.crm.*.service       crm包下面子包任意 （例如：com.itheima.crm.staff.service）

com.itheima.crm..                 crm包下面的所有子包（含自己）

com.itheima.crm.*.service..     crm包下面任意子包，固定目录service，service目录任意包

类，[省略]

UserServiceImpl                    指定类

*Impl                                   以Impl结尾

User*                                   以User开头

*                                         任意

方法名，不能省略

addUser                              固定方法

add*                                   以add开头

*Do                                     以Do结尾

*                                         任意

(参数)

()                                        无参

(int)                                     一个整型

(int ,int)                               两个

(..)                                       参数任意

throws ,可省略，一般不写。

2.within:匹配包或子包中的方法(了解)

within(com.itheima.aop..*)

3.this:匹配实现接口的代理对象中的方法(了解)

this(com.itheima.aop.user.UserDAO)

4.target:匹配实现接口的目标对象中的方法(了解)

target(com.itheima.aop.user.UserDAO)

5.args:匹配参数格式符合标准的方法(了解)

args(int,int)

6.bean(id)  对指定的bean所有的方法(了解)

bean('userServiceId')

=======================================================================================

实例 :AOP基于xml配置开发

UserAOP.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" xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd"> 

     <bean id="aspectUser" class="com.spring_aop1.AspectUser"></bean>
     <bean id="user" class="com.spring_aop1.User"></bean>

     <aop:config>
         <!-- expression="execution(返回值  包名.类名.方法名(参数类型))   id="任意":切入点名  -->
         <aop:pointcut expression="execution(* com.spring_aop1.*.*(..))" id="myPointcut"/>

         <aop:aspect ref="aspectUser">
             <aop:before method="password" pointcut-ref="myPointcut"/>
             <aop:after-returning method="after" pointcut-ref="myPointcut" returning="obj"/>
         <!-- <aop:around method="around" pointcut-ref="myPointcut" /> -->
             <aop:around method="aroundR" pointcut-ref="myPointcut" />

             <aop:after-throwing method="throwable" pointcut-ref="myPointcut" throwing="e"/>
         </aop:aspect>

     </aop:config>

 </beans>

User.java

 package com.spring_aop1;

 public class User {

     private String str;

     public String getStr() {
         return str;
     }
     public void setStr(String str) {
         this.str = str;
     }

     public void insert(){
         System.out.println("insert====ok");
     }
     public void delete(){
         System.out.println("delete====ok");
     }
     public void update(){
         System.out.println("update====ok");
     }
     public void selete(){
         System.out.println("insert====ok");
     }

 }

AspectUser.java

 package com.spring_aop1;

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;

 public class AspectUser {

     /**
      *  定义一个前置通知
      * */
     public void password(){
         System.out.println("前置通知:密码验证=====成功");
     }

     /**
      *  定义一个后置通知(可得方法返回值)
      *  @param jp  execution(void com.spring_aop.User.save())
      *  @param obj
      * */
     public void after(JoinPoint jp,Object obj){
         String name = jp.getSignature().getName();

         System.out.println("后置通知:after获取一个返回值类型====切入点");
         System.out.println("after返回值信息为:"+name);
     }

     /**
      *  定义一个环绕通知
      *  @param pjp  execution(void com.spring_aop.User.save())
      * */
     public void around(ProceedingJoinPoint pjp) throws Throwable{
         System.out.println("环绕通知:around执行环绕通知前执行");
         pjp.proceed();
         System.out.println("环绕通知:around执行环绕通知后执行");
     }
     /**
      *  定义一个环绕通知(可得方法返回值)
      * @throws Throwable
      * */
     public Object aroundR(ProceedingJoinPoint pjp) throws Throwable{
         System.out.println("环绕通知:around执行环绕通知前执行");
         Object obj = pjp.proceed();
         System.out.println("环绕通知:around执行环绕通知后执行");

         String s = pjp.getSignature().getName();
         System.out.println("around返回值的类型:"+obj+"  around返回方法名:"+s);
         return obj;
     }

     /**
      *  定义一个异常通知(可得方法返回值)
      * @throws Throwable
      * */
     public void throwable(JoinPoint jp,Throwable e){
         System.out.println("到我这里来，说明 你发生了异常======");
     }

 }

Test.java

 package com.spring_aop1;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class UserTest {

     public static void main(String[] args) {

         String str = "com/spring_aop1/UserAop.xml";
         ApplicationContext context = new ClassPathXmlApplicationContext(str);

         User user = (User)context.getBean("user");
         user.insert();

     }

 }

实例 :AOP基于注解开发

UserAOP.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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
         http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd">

     <!-- 自动扫描 配置  扫描所有注解 :使用注解注入 -->
     <context:component-scan base-package="com.spring_aop2"></context:component-scan>

     <!-- 添加AOP的注解扫描 -->
     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 </beans>

User.java

 package com.spring_aop2;

 import org.springframework.stereotype.Component;

 @Component(value="user")
 public class User {

     private String str;

     public String getStr() {
         return str;
     }
     public void setStr(String str) {
         this.str = str;
     }

     public void insert(){
         System.out.println("insert====ok");
     }
     public void delete(){
         System.out.println("delete====ok");
     }
     public void update(){
         System.out.println("update====ok");
         int i = 1/0;
     }
     public void selete(){
         System.out.println("insert====ok");
     }

 }

AspectUser.java

 package com.spring_aop2;

 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.After;
 import org.aspectj.lang.annotation.AfterReturning;
 import org.aspectj.lang.annotation.AfterThrowing;
 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.springframework.stereotype.Component;

 @Component("aspectUser") //组件
 @Aspect  //声明这是一个切面类
 public class AspectUser {

     /**
      *    <aop:pointcut
      *        expression="execution(* com.spring_aop2.*.*(..))"
      *    id="myPointcut" />
      * */
     @Pointcut("execution(* com.spring_aop2.*.*(..))")
     private void myPoint(){}

     /**
      *  定义一个前置通知
      * */
     @Before("execution(* com.spring_aop2.*.*(..))") //指向切入点的Id(私有方法的方法名)
     public void password(){
         System.out.println("前置通知:密码验证=====成功");
     }

     /**
      *  定义一个后置通知(可得方法返回值)
      *  @param jp  execution(void com.spring_aop.User.save())
      *  @param obj
      * */
     @AfterReturning(value="myPoint()",returning="obj")
     public void after(JoinPoint jp,Object obj){
         String name = jp.getSignature().getName();

         System.out.println("后置通知:获取一个返回值类型====切入点");
         System.out.println("after返回值信息为:"+name);
     }

     /**
      *  定义一个环绕通知
      *  @param pjp  execution(void com.spring_aop.User.save())
      * */
     @Around("execution(* com.spring_aop.*.*(..))")
     public void around(ProceedingJoinPoint pjp) throws Throwable{
         System.out.println("环绕通知:around执行环绕通知前执行");
         pjp.proceed();
         System.out.println("环绕通知:around执行环绕通知后执行");
     }
     /**
      *  定义一个环绕通知(可得方法返回值)
      * @throws Throwable
      * */
     public Object aroundR(ProceedingJoinPoint pjp) throws Throwable{
         System.out.println("环绕通知:around执行环绕通知前执行");
         Object obj = pjp.proceed();
         System.out.println("环绕通知:around执行环绕通知后执行");

         String s = pjp.getSignature().getName();
         System.out.println("around返回值的类型:"+obj+"  around返回方法名:"+s);
         return obj;
     }

     /**
      *  定义一个异常通知(可得方法返回值)
      * @throws Throwable
      * */
     @AfterThrowing(value="myPoint()",throwing="e")
     public void throwable(JoinPoint jp,Throwable e){
         System.out.println("到我这里来，说明 你发生了异常======");
     }

 }

Test.java

 package com.spring_aop2;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class UserTest {

     public static void main(String[] args) {

         String str = "com/spring_aop2/UserAop.xml";

         ApplicationContext context = new ClassPathXmlApplicationContext(str);

         User user = (User)context.getBean("user");
         user.insert();
         //user.update();

     }

 }