SSM-spring篇

spring-AOP

什么是AOP

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

代理

想要理解AOP就需要先明白代理，aop实现原理为代理模式。代理模式分为：动态代理和静态代理。
首先我们先了解一下静态代理：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户：访问代理对象的人！

模拟场景：

• 接口：

//租房
public interface Rent{
    public void rent();
}

• 真实角色

//房东
   public class Host implements Rent{
    public void rent(){
        System.out.println("房东要出租房子！");
    }
   }

• 代理角色

public class Proxy implements Rent{
    private Host host;
    public Proxy(){}
    public Proxy(Host host){
        this.host=host;
    }
    public void rent(){
        seeHouse();
        host.rent();
        hetong();
        fare();    
    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }
    public void hetong(){
        System.out.println("签租赁合同");
    }
    public void fare(){
         System.out.println("收中介费");
    }
}

• 客户端访问代理角色

public  class Client{
    public static void main(String[] args){
        //房东要租房子
        Host host=new Host();
        //代理，中介帮房东租房子，但是呢？代理角色一般会有一些附属操作！
        Proxy proxy=new Proxy(host);
        //你不用面对房东，直接找中介租房即可！
        proxy.rent();
    }
}

静态代理的好处：

• 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
• 公共也就交给 代理角色，实现了业务的分工
• 公共业务发生扩展的时候，方便集中管理

接下来我们看一下动态代理：

• 动态代理 和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理

​ 基于接口—jdk动态代理

​ 基于类：cglib

需要了解两个类：Proxy：生成动态代理这个实例的，InvocationHandler：调用处理程序并返回结果

代码理解：

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("添加一个");
    }

    @Override
    public void delete() {
        System.out.println("删除一个");
    }

    @Override
    public void update() {
        System.out.println("修改一个");
    }

    @Override
    public void query() {
        System.out.println("查询");
    }
}

动态代理类：

public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
         //动态代理的本质，就是使用反射机制实现！
        Object result=method.invoke(target,args);
        return result;
    }
    public void log(String msg){
        System.out.println("[Debug]:使用了"+msg+"方法");
    }
}

实现类：

public class Client {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userServiceImpl=new UserServiceImpl();
        //代理对象
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象！
        pih.setTarget(userServiceImpl);
        UserService proxy = (UserService) pih.getProxy();//这里的proxy就是动态生成的，我们并没有写~
        proxy.update();
    }
}

动态代理的好处：

• 可以是真实角色的操作更加纯粹，不用去关注一些公共的业务
• 公共也就交给代理角色，实现了业务的分工
• 公共业务发生扩展的时候，方便集中管理
• 一个动态代理类代理的是一个接口，一般就是对应的类业务
• 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

AOP

了解了代理模式这样我们更容易明白aop的底层实现！

AOP在spring中的作用
提供声明式事务；允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
• 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知 执行的 “地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能 。

AOP的实现方式有三种：

需要导入一个依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

1.使用Spring的API接口：
代码理解：

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("添加一个");
    }

    @Override
    public void delete() {
        System.out.println("删除一个");
    }

    @Override
    public void update() {
        System.out.println("修改一个");
    }

    @Override
    public void query() {
        System.out.println("查询");
    }
}

public class Log implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //args：参数
    //target：目标对象
    @Override
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

<!--注册bean-->
    <bean id="userService" class="com.service.UserServiceImpl"/>
    <bean id="log" class="com.service.log.Log"/>
    <bean id="afterLog" class="com.service.log.AfterLog"/>
    <!--方式一：使用原生Spring API接口-->
    <!--配置aop：需要导入aop约束-->
    <aop:config>
        <!--切入点： expression：表达式，execution(修饰符  返回值  包名.类名/接口名.方法名(参数列表))-->
        <aop:pointcut id="pointcut" expression="execution(public * com.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

测试类：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

2.自定义类：
使用方式一的原代码 ， 业务类和方式一一样，不变；
自定义一个切面类：

public class DiyAspectj {
    public void before(){
        System.out.println("===方法之前===");
    }
    public void after(){
        System.out.println("===方法之后===");
    }
}

<!--方式二：自定义类-->
    <bean id="diy" class="com.service.diy.DiyAspectj"/>
    <aop:config>
        <!--自定义切面，ref: 要引用的类-->
        <aop:aspect ref="diy" >
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

3.注解配置
业务类和方式一一样，不变

@Aspect
public class AnnotationPointCut {
    @Pointcut("execution(* com.service.UserServiceImpl.*(..))")
    public void pointcut(){};
    @Before("pointcut()")
    public void before(){
        System.out.println("===方法执行前===");
    }
    @After("pointcut()")
    public void after(){
        System.out.println("===方法执行后===");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("pointcut()")
    public void around(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");
//        Signature signature = jp.getSignature(); //获取签名
//        System.out.println("signature:"+signature);

        Object proceed = jp.proceed(); //执行方法
        System.out.println("环绕后");

//        System.out.println(proceed);
    }
}

<!--方式三-->
    <bean id="annotationPointCut" class="com.service.diy.AnnotationPointCut"/>
    <!--开启注解支持！ JDK(默认 proxy-target-class="false") cglib(默认proxy-target-class="true")-->
    <aop:aspectj-autoproxy />

测试类同上；

这样我们就基本理解spring的核心之一AOP技术。
完毕~