初始Spring(伍)之AOP

123小步

已于 2022-05-07 21:16:51 修改

阅读量429

点赞数 1

分类专栏： Spring 文章标签： spring java 后端

于 2022-05-07 16:27:56 首次发布

本文链接：https://blog.csdn.net/abc98526/article/details/124607748

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

方式二:自定义类来实现AOP[主要是切面定义]

方式三:使用注解实现

10，代理模式

为什么要学习代理模式?因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】

代理模式分类:

静态代理
动态代理

10.1，静态代理

角色分析:

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

代码步骤:

1.接口

package com.xiao.demo01;

//租房
public interface Rent {

    public void rent();
}

2.真实角色

package com.xiao.demo01;

//房东
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东要出租房子");
    }
}

3.代理角色

package com.xiao.demo01;

public class Proxy {
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    public void rent(){
        host.rent();
    }

    //看房
    public void seeHost(){
        System.out.println("中介带你看房!");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费!");
    }

    //签合同
    public void hetong(){
        System.out.println("签租赁合同!");
    }
}

4.客户端访问代理角色

package com.xiao.demo01;

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但是呢代理一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        proxy.rent();
        proxy.seeHost();
        proxy.hetong();
        proxy.fare();
    }
}

代理模式的好处:

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

缺点:

一个真实角色就会产生一个代理角色：代码量会翻倍~开发效率会变低

10.2，静态代理加深理解

1.接口:

package com.xiao.demo02;

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

2.实现类

package com.xiao.demo02;


//真实对象
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("查询一个用户");
    }
}

当我们需要增加一些功能，尽量不要改动原来的业务代码可以尽量在Sercive层加一个代理来实现！

package com.xiao.demo02;

public class UserServiceProxy implements UserService{
    UserServiceImpl userService =new UserServiceImpl();

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }


    //日志方法
    public void log(String out){
        System.out.println("使用了"+out+"方法");
    }
}

package com.xiao.demo02;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.add();
    }
}

10.3，动态代理

动态代理与静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的！
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口--JKD动态代理 [这里使用]
- 基于类:cglib
- java字节码实现:javassist

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

InvocationHandler:实现标记接口的作用

Proxy：提供了创建动态代理类和实例的静态方法

实现检测方法运行时间实例:

package com.xiao.demo03;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Date;

//用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    Object rent;

    public void setRent(Object rent) {
        this.rent = rent;
    }

    //生成得到代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
    }


    //处理代理实例并且返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        Date startTime = new Date();
        Object invoke = method.invoke(rent, args);
        System.out.println(datetime(method.getName(), startTime, new Date()));
        return invoke;
    }

    //计算方法执行时间
    private static String datetime(String methodName, Date startTime, Date endTime) {
        return methodName + "方法总耗时:" + (endTime.getTime() - startTime.getTime());
    }

}

一个动态代理类可以代理多个类,只要是实现了同一个接口的即可！

11，AOP

11.1，什么是AOP?

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

11.2， AOP在Spring中的作用

提供声明式事务：允许用户自定义切面

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

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

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

11.3，使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.9.1</version>
            <scope>runtime</scope>
        </dependency>

方式一:使用Spring的API接口

1.编写类:

package com.xiao.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

//前置日志
public class Log implements MethodBeforeAdvice {

    /**
     * @param method     执行目标对象的方法
     * @param args       执行目标对象的参数
     * @param target     执行的目标对象
     * @throws Throwable 报出异常
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        assert target != null;
        System.out.println(target.getClass().getName()+"类的"+method.getName()+"方法被执行了!");
    }
}

package com.xiao.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

//后置日志
public class AfterLog implements AfterReturningAdvice {

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

2.XML配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.2.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">


    <!-- 注册Bean -->
    <bean id="log" class="com.xiao.log.Log"/>
    <bean id="afterLog" class="com.xiao.log.AfterLog"/>
    <bean id="userService" class="com.xiao.service.UserServiceImpl"/>

    <!-- 方式一使用原生的Spring API接口 -->
    <!-- 配置AOP:需要导入AOP的约束 -->
    <aop:config>
        <!-- 切入点 : expression表达式:execution(要执行位置! * * * * *)-->
        <aop:pointcut id="pointcut" expression="execution(* com.xiao.service.UserServiceImpl.*(..) )"/>
        
        <!-- 执行环绕增强 -->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

3.测试类

import com.xiao.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注意：动态代理代理的是接口！
        UserService userService = classPathXmlApplicationContext.getBean("userService", UserService.class);
        userService.add();
    }
}

方式二:自定义类来实现AOP[主要是切面定义]

定义类:

package com.xiao.diy;

public class DiyPointCut {

    public void before(){
        System.out.println("--------- 方法执行前 ---------");
    }

    public void after(){
        System.out.println("--------- 方法执行后 ---------");
    }

}

配置

    <!-- 方式二：自定义类 -->
    <bean id="diy" class="com.xiao.diy.DiyPointCut"/>

    <aop:config>
        <aop:aspect ref="diy">
            <!-- 切入点 -->
            <aop:pointcut id="pointcut" expression="execution(* com.xiao.service.UserServiceImpl.*(..))"/>

            <!-- 通知 -->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

测试:

import com.xiao.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注意：动态代理代理的是接口！
        UserService userService = classPathXmlApplicationContext.getBean("userService", UserService.class);
        userService.add();
    }
}

方式三:使用注解实现

类:

package com.xiao.diy;


import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class DiyPointCut {

    @Before("execution(* com.xiao.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("--------- 方法执行前 ---------");
    }

    @After("execution(* com.xiao.service.UserService.*(..))")
    public void after(){
        System.out.println("--------- 方法执行后 ---------");
    }

}

配置xml:

    <!-- 注册bean -->
    <bean id="diyPointCut" class="com.xiao.diy.DiyPointCut"/>
    <!-- 开启哦注解支持 -->
    <aop:aspectj-autoproxy/>

测试:

import com.xiao.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        //注意：动态代理代理的是接口！
        UserService userService = classPathXmlApplicationContext.getBean("userService", UserService.class);
        userService.delete();
    }
}

123小步

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
初始Spring(伍)之AOP

10，代理模式为什么要学习代理模式?因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】代理模式分类:静态代理动态代理10.1，静态代理角色分析:抽象角色：一般会使用接口或抽象类来解决真实角色：被代理的角色代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作！客户:访问代理对象的人！代码步骤:1.接口package com.xiao.demo01;//租房public interface Rent {.
复制链接

扫一扫