Spring详解之（代理模式 面向切面编程 注解实现）

动态代理和AOP面向切面编程

---

代理模式

1.什么是代理模式

代理模式的英文叫做Proxy或Surrogate，中文都可译为“代理”，所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。
在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用 。
代理就是为其他对象提供一个代理以控制对某个对象的访问。

2.代理模式的分类

3.JDK动态代理实现

（1）编写接口和接口实现类

public interface SomeService {
    public  void doSome();
    public  void  doFor();
}

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome() {
        System.out.println("doSome方法实现了");
    }
    @Override
    public void doFor() {
        System.out.println("doFor方法实现了");
    }
    }

(2)编写代理类

public class MyIncationHandler implements InvocationHandler {
    //目标对象
    private  Object target;    //实现类
    public MyIncationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //通过代理对象执行方法时，会调用这个invoke()
        Object res=null;
       //执行目标类的方法，通过method类实现
        res= method.invoke(target,args);
        return res;
    }
}

（3）通过代理执行方法

public class MyApp {
    public static void main(String[] args) {
        SomeServiceImpl someService = new SomeServiceImpl();
        //创建InvocationHandler对象
        InvocationHandler myIncationHandler = new MyIncationHandler(someService);
        //使用Proxy创建代理
        SomeService instance = (SomeService) Proxy.newProxyInstance(someService.getClass().getClassLoader(),
                someService.getClass().getInterfaces(), myIncationHandler);
        //通过代理执行方法
        instance.doSome();
    }
}

AOP相当于动态代理的规范化

AOP面向切面编程

1.什么是AOP（面向切面编程）

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2.AOP的业务逻辑

在不改变代码的情况下，添加新的功能

3.AOP在spring中的作用（基本术语）

• 切面(Aspect)：横切关注点 被模块化 的特殊对象。即，它是一个类。
• 目标对象(Target)：指将要被增强的对象，即包含主业务逻辑的类对象。
• 连接点(JoinPoint)：与切入点匹配的执行点。
• 切入点(PointCut)：切面通知 执行的 “地点”的定义。
• 通知(Advice)：切面必须要完成的工作。即，它是类中的一个方法。
• 织入(Weaving)：织入是将切面和业务逻辑对象连接起来, 并创建通知代理的过程。
• 增强器(Adviser)：Advisor由切入点和Advice组成。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。

4.五种类型的Advice及接口

5.XML中AOP的配置元素

6.注解中的AOP指令

使用AOP编程的三种方式

第一种方式：使用Spring的API 接口

(1)导包，添加AOP依赖

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        或者
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.6.RELEASE</version>
    </dependency>

(2)编写UserSerive接口及实现类

package Serive;
public interface UserSerive {
       public void add();
       public void delete();
       public void update();
       public void searth();
}

package Serive;
public class Impl implements UserSerive {
    public void add() { System.out.println("增加用户"); }
    public void delete() { System.out.println("删除用户"); }
    public void update() { }
    public void searth() { }
}

(3)编写两个插入类，实现AOP接口

package Serive.Config;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {
    //method 要执行的目标方法
    //objects：要调用这方法的参数
    //o：要调用的目标对象
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"de "+ method.getName()+"");
    }
}

package Serive.Config;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class LogAfter implements AfterReturningAdvice {
    public void afterReturning(Object o1, Method method, Object[] objects, Object o) throws Throwable {//o1:返回值
        System.out.println(o.getClass().getName()+"de "+ method.getName()+""+o1);
    }
}

(4)在XML中配置AOP

<?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="UserSerive" class="Serive.Impl"></bean>
    <bean id="Log" class="Serive.Config.Log"></bean>
    <bean id="LogAfter" class="Serive.Config.LogAfter"></bean>
    <!--espression：类名全称 public com.service.方法-->
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* Serive.Impl.*(..))"></aop:pointcut>
        <aop:advisor advice-ref="Log" pointcut-ref="pt"></aop:advisor>
        <aop:advisor advice-ref="LogAfter" pointcut-ref="pt"></aop:advisor>
    </aop:config>
    </beens>

注意：添加AOP命令空间

(5)测试运行

import Serive.UserSerive;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Text {
    @Test
    public void Text1(){
        ApplicationContext Context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        UserSerive userSerive = (UserSerive) Context.getBean("UserSerive");
        userSerive.add();
    }
}

第二种方式：自定义来实现AOP

• 比第一种方式简单，只需要编写一个插入类

package Serive.Config;
public class diy {
    public void before(){        System.out.println("=前面========");    }
    public  void after(){        System.out.println("==后面====");    }
    }
}

• 在XML中配置AOP

<bean id="UserSerive" class="Serive.Impl"></bean>
    <bean id="diy" class="Serive.Config.diy"></bean>
    <aop:config>
        <aop:aspect ref="diy">
        <aop:pointcut id="pt" expression="execution(* Serive.Impl.*(..))"></aop:pointcut>
         <aop:before method="before" pointcut-ref="pt"></aop:before>
            <aop:after method="after" pointcut-ref="pt"></aop:after>
        </aop:aspect>
    </aop:config>

注意：添加AOP命令空间

第三种方式：使用注解（常用的5大注解）

（1）编写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: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
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--声明目标对象-->
    <bean id="someService" class="org.example.service.SomeServiceImpl"></bean>
    <!--声明切面类对象-->
    <bean id="myAspect" class="org.example.util.ServiceTools"></bean>
    <!--声明自动代理生成器
    使用的是aspectj框架内部的功能，创建目标对象的代理对象，创建代理对象是在内存中实现的，修改目标对象的内存结构，创建为代理对象
    所以目标对象就是被修改的代理对象
    -->
    <aop:aspectj-autoproxy ></aop:aspectj-autoproxy>
</beans>

aspectj-autoproxy会把spring容器中的所有目标对象，一次性的都生成代理对象

（2）使用注解

execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?) 

@Aspect
public class ServiceTools {
    @Before(value = "execution(* *..SomeServiceImpl.*(..))")
    public    void  doLog(JoinPoint joinPoint){
        System.out.println("方法的签名"+joinPoint.getSignature());
        System.out.println("方法的名称"+joinPoint.getSignature().getName());
        //获取方法的实参        Object[] args = joinPoint.getArgs();
        System.out.println("非业务方法，方法的执行时间 "+ new Date());
    }
    @Around(value = "mypt()")
    public    Object  doTrans(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        Object res =null;
        System.out.println("环绕通知，方法之前");
        res=proceedingJoinPoint.proceed();
        System.out.println("环绕通知，方法之后");
        return  res;
    }
    @AfterReturning(value ="mypt()" ,
            returning = "re")
    public  void doAfter( Student re){

        System.out.println("后置方法实现了");
        re=new Student("yangao",20);
    }
    @After(value = "mypt()")
    public  void  endAfter(){
        System.out.println("最终方法执行了");
    }
    @AfterThrowing(value = "mypt()",throwing = "ex")
    public void paoThow(Exception ex){
        System.out.println("异常抛出"+ex.getMessage());
    }
    //@Pointcut 定义和管理切入点，如果你的项目中有多个切入点表达式是重复的，可以复用的
    @Pointcut(value ="execution(* *..SomeServiceImpl.*(..))")
    public void mypt(){}
}
}

JoinPoint

• 如果你的切面功能中需要用到方法的信息，就加入JoinPoint
• 这个JoinPoint参数的值是由框架赋予吧，必须是第一个位置的参数
• ProceedingJoinPoint 继承于joinpoint

@Around

• 他是功能最强的通知
• 在目标方法的前后都能增强功能
• 控制目标方法是否被调用执行
• 修改原来目标方法的执行结果，影响最后的调用结果
• @after 总会执行，不管有没有异常

spring默认采用的是：JDK动态代理，如果你期望目标类有接口，使用cglib代理

• <aop:aspectj-autoproxy proxy-target-class=“true”></aop:aspectj-autoproxy>