DAY04_Spring—Aop案例引入&代理机制

于 2024-01-18 17:28:44 发布
阅读量925 收藏 21
点赞数 19
分类专栏： 5.框架+vue+京淘购物 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57075290/article/details/135659408
版权
本文详细介绍了Spring框架如何实现AOP事务控制，包括静态代理和动态代理（如JDK代理）的使用，以及它们在处理数据库事务中的应用，强调了代理模式在解耦和代码复用中的作用。
摘要由CSDN通过智能技术生成

目录

1 AOP

1.1 AOP案例引入

1.1.1 数据库事务说明

  • 案例分析:
    • userMapper.insert(User对象)
    • deptMapper.insert(dept对象)
      • 由于业务需求 要求方法要么同时入库,要么同时回滚.所以必须通过事务进行控制.

1.2 Spring实现事务控制

1.2.1 代码结构如下

在这里插入图片描述

1.2.2 编辑User

public class User {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

1.2.3 编辑UserMapper/UserMapperImpl

  • 编辑UserMapper
import com.jt.pojo.User;

public interface UserMapper {
    void addUser(User user);
}
  • 编辑UserMapperImpl
import com.jt.pojo.User;
import org.springframework.stereotype.Repository;

@Repository
public class UserMapperImpl implements UserMapper {
    //？？事务控制应该在哪一层完成！！dao/mapper service
    @Override
    public void addUser(User user) {
        System.out.println("用户入库"+user);
    }
}

1.2.4 编辑UserService/UserServiceImpl

  • 编辑UserService
import com.jt.pojo.User;

public interface UserService {
    void addUser(User user);
}
  • 编辑UserServiceImpl
import com.jt.mapper.UserMapper;
import com.jt.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;
    //事务控制应该放在Service层中控制
    @Override
    public void addUser(User user) {
        try {
            System.out.println("事务开始");
            userMapper.addUser(user);
            System.out.println("事务结束");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("事务回滚");
        }
    }
}

1.2.5 编辑配置类

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration//标识我是一个配置类
@ComponentScan("com.jt")
public class SpringConfig {
}

1.2.6 编辑测试类

import com.jt.config.SpringConfig;
import com.jt.pojo.User;
import com.jt.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestUser {
    //Controller-Service-Mapper(Dao)
    //Spring中规定：
    //  如果传入的是接口的类型 则自动查找/注入 该接口的实现类
    //  该接口只有一个实现类
    @Test
    public void testTx(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        //写接口的类型/实现类的类型？
        UserService userService = context.getBean(UserService.class);
//        UserService userService = (UserService) context.getBean("userServiceImpl");
        User user = new User();
        user.setId(101);
        user.setName("SpringAop测试入门案例");
        userService.addUser(user);
    }
}

1.3 代码问题分析

  • Service层应该写代码业务，但是现在与事务控制紧紧的耦合在一起
  • 代码冗余不便于大批量开发

在这里插入图片描述

  • 解决方案:
    • 采用代理模式进行编辑.

1.4 代理模式

1.4.1 生活中代理案例

  • 房屋中介代理模式:
    • 房东: 自己手里有房子 需要出租换钱
    • 中介机构 1.本职工作 带客户看房/出租房屋 2.收取中介费(服务费)
    • 租客: 满足自身需求 租房子
  • 代码思维建模:
    • 暴露一个公共的接口(租房子)
    • 客户与中介机构进行沟通,中介看起来和房东功能一致.(代理看起来就是真实的对象)
    • 完成用户额外的操作(收取中介费)

1.4.2 代理模式

  • 组成部分
    • 要求代理者实现与被代理者相同的接口
    • 在代理方法中实现功能的扩展
    • 用户调用代理对象完成功能(用户认为代理就是目标对象)
  • 调用流程

在这里插入图片描述

1.5 静态代理

1.5.1 通过代理模式实现事务控制

  • 角色划分:
    • 目标对象target UserServiceImpl类
    • 目标方法 method addUser()方法
    • 代理: 实现事务控制.
    • 代理对象与目标对象实现相同的接口.

1.5.2 修改目标对象名称

在这里插入图片描述

1.5.3 编辑代理类

import com.jt.pojo.User;
import com.jt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("userService")
public class StaticProxy implements UserService {
    //要求引入目标对象
    @Autowired //ByType  byName
    //@Qualifier("target")
    private UserService target;

    //目的: 对原有方法进行扩展
    @Override
    public void addUser(User user) {
        try {
            System.out.println("事务开始");
            target.addUser(user);
            System.out.println("事务结束");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("事务回滚");
        }
    }
}

1.5.4 编辑测试类

@Test
public void testStaticProxy(){
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = (UserService) context.getBean("userService");
    User user = new User();
    user.setId(10001);
    user.setName("测试代理机制");
    //执行用户调用
    userService.addUser(user);
}

1.5 静态代理弊端

  • 静态代理只针对于某个接口 不能实现所有接口的代理 实用性较差

在这里插入图片描述

  • 静态代理中所有的方法,都需要手动的添加事务开始/事务提交代码 代码冗余 不够简洁

在这里插入图片描述

1.6 动态代理机制

1.6.1 动态代理分类

  • JDK代理:
    • 要求: 要求目标对象必须实现接口
    • 代理要求: 代理对象也必须实现目标对象的接口
    • 目标对象/代理关系: 目标对象与代理对象兄弟关系.
  • CGlib代理
    • 要求: 不管目标对象是否有接口,都可以为其创建代理对象
    • 代理要求: 要求代理对象必须继承目标对象
    • 目标对象/代理关系: 目标对象与代理对象是父子关系

在这里插入图片描述

1.6.2 编辑JDK动态代理

官网API:

在这里插入图片描述

  • 知识点：
    • 关于匿名内部类用法说明: 匿名内部类引用外部参数 要求参数必须final修饰
    • 该方法标识 当代理对象执行时,"回调"该方法.
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {}
    • 目标方法执行
    result = method.invoke(target,args);

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//能否利用一个工厂动态为目标对象创建代理
public class JDKProxyFactory {

    //要求用户传递目标对象
    //关于匿名内部类用法说明:  匿名内部类引用外部参数 要求参数必须final修饰
    public static Object getProxy(final Object target) {
        //1.调用java API实现动态代理
        /**
         *  参数分析: 3个参数
         *      1.ClassLoader loader, 类加载器(获取目标对象的Class)
         *      2.类<?>[] interfaces,  JDK代理要求 必须有接口
         *                             java中可以多实现
         *      3.InvocationHandler h  对目标方法进行扩展
         */
        //1.获取类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        //2.获取接口数组
        Class[] interfaces = target.getClass().getInterfaces();
        //3.通过动态代理创建对象
        Object proxy = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            //invoke方法: 代理对象调用方法时invoke执行,扩展方法的编辑位置
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //proxy: 代理对象本身
                //method: 用户调用的方法对象
                //args:   用户调用方法的参数

                // result 标识目标方法执行的返回值
                Object result = null;
                try {
                    //添加事务的控制
                    System.out.println("事务开始");
                    //执行目标方法
                    // target真实的目标对象,method方法对象,args方法参数
                    result = method.invoke(target, args);
                    System.out.println("事务提交");
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("事务回滚");
                }
                return result;
            }
        });
        return proxy;
    }
}
  • 测试代码
/**
     * 测试JDK动态代理
     */
    @Test
    public void testJDKProxy(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        //1.获取用户目标对象
        UserService target = (UserService) context.getBean("target");
        //2.获取代理对象
        UserService userService = (UserService) JDKProxyFactory.getProxy(target);
        //3.打印代理对象的类型
        System.out.println(userService.getClass());
        //4.用户完成调用
        User user = new User();
        user.setId(10001);
        user.setName("JDK动态代理完成");
        //执行用户调用
        userService.addUser(user);
    }

在这里插入图片描述

1.6.3 JDK动态代理执行过程

在这里插入图片描述

1.7 动态代理优势

将公共的部分写到动态代理中,之后其他的业务类调用即可

1.7.1 编辑DeptService/DeptServiceImpl

  • 编辑DeptService
public interface DeptService {
    void addDept();
}
  • 编辑DeptServiceImpl
import org.springframework.stereotype.Service;

@Service("deptService")
public class DeptServiceImpl implements DeptService {
    @Override
    public void addDept() {
        //添加事务
        System.out.println("调用DeptMapper实现入库操作");
        //提交事务
    }
}

1.7.2 编辑测试类

@Test
    public void testTx() {
        //1.获取目标对象
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        DeptService target = (DeptService) context.getBean("deptService");
        //2.获取代理对象
        DeptService deptService = (DeptService) JDKProxyFactory.getProxy(target);
        //通过代理对象 调用方法  扩展了方法!!!!!
        deptService.addDept();  //invoke
    }

在这里插入图片描述

1.8 动态代理实现Demo2

1.8.1 业务需求

  • 要求:
    • 对Service层的方法记录其执行的时间
    • service中 有 addUser方法/deleteUser方法.
    • 要求代码结构扩展性好,耦合性低.

1.8.2 编辑UserService/UserServiceImpl

  • 编辑UserService
public interface UserService {
    void addUser();
    void deleteUser();
}
  • 编辑UserServiceImpl
@Service("target")
public class UserServiceImpl implements UserService{
    @Override
    public void addUser() {
        System.out.println("新增用户");
    }
    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

1.8.3 编辑代理工厂

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxyFactory {
    //编辑静态方法获取代理对象
    public static Object getProxy(final Object target) {
        //3个参数  1.类加载器  2.对象的接口
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class[] interfaces = target.getClass().getInterfaces();
        Object proxy = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            //代理对象执行目标方法时执行
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //让用户执行目标方法
                Long startTime = System.currentTimeMillis(); //开始时间
                //执行目标方法 获取返回值 可能为null
                Object result = method.invoke(target);
                Long endTime = System.currentTimeMillis();  //结束时间
                System.out.println("程序执行:" + (endTime - startTime) + "毫秒");
                //将返回值传递给调用者
                return result;
            }
        });
        return proxy;
    }
}

1.8.4 编辑测试案例

@Test
    public void test01(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        //1.获取目标对象
        UserService target = (UserService) context.getBean("target");
        //2.获取代理对象
        UserService proxy = (UserService) JDKProxyFactory.getProxy(target);
        System.out.println(proxy.getClass());
        //3.调用业务方法
        proxy.addUser();
        proxy.deleteUser();
    }
_-Mr-sun
关注
  • 19
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring IOC和Spring AOP_spring aop_springIOC
09-24
spring基础Spring IOC和Spring AOP的原理及使用
spring-aop.rar_java aop_spring aop
09-23
SPRING AOP自主实现，还包括一些java基础，可以很快自主实现切面编程
AOP概念的引入，相关的概念，AOP技术
m0_61983575的博客
02-20 251
首先我们来看一下登录的原理 如上图所示这是一个基本的登录原理图，但是如果我们想要在这个登录之上添加一些新的功能，比如权限校验 那么我们能想到的就有两种方法： ①：通过对源代码的修改实现 ②：不通过修改源代码方式添加新的功能 （AOP） ​​​​​​ 1. AOP的概述 什么是AOP的技术？ 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程 AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构 AOP最早由A...
Spring_3 - AOP
reallllbj的博客
05-09 179
文章目录Spring_3 AOP一、AOP 的相关概念1、AOP概述(1) 什么是 AOP(2) AOP 的作用及优势(3) AOP 的实现方式2、AOP 的具体应用(1) 动态代理回顾(2) 动态代理常用的有两种方式(3) 使用 JDK 官方的 Proxy 类创建代理对象(4) 使用 CGLib 的 的 Enhancer 类创建代理对象二、Spring 中的 AOP1、 Spring 中 AOP 的细节(1) AOP 相关术语(2)spring AOP要明确的事(3) 关于代理的选择2、基于 XML 的
spring-AOP引入
怕秃头的潘s的博客
11-06 267
定义接口 package com.abc.service; public interface ISomeService {    public void first();    public void second();     } 实现类 package com.abc.service; public class SomeServiceImpl implemen
Spring Aop的引入
weixin_42067668的博客
03-28 835
介绍为什么要用到Aop， 在我们以前的开发中，加入一个转帐的功能，一共需要开启五个事务，这5个事务就会有与数据库使用jdbc技术（步骤1新建链接，2，链接数据库3.准备数据库执行语句，4，开始执行，5，返回结果6，结果处理，7，释放链接） 但是如果中间有出现异常的话，就会造成异常之前的事务处理成功，异常之后的事务执行失败，其根本原因是这个转账业务应该同一写到统一的线程中，由线程进行创建链接，全局...
Spring--AOP-引入
赵亚兰的博客
05-27 393
spring-aop.rar_aop1270_spring_spring aop
09-23
spring aop 源码用于spring 开源软件源码的获取
8_24_SpringAOP_springaop_
10-03
spring aop 的配置文件，新手可以用来学习学习
springAop.rar_AOP java_cglib_spring aop
09-21
spring aop 编程，cglib ,切面编程
Spring AOP 的引入(一)
qq_26837711的博客
11-19 219
假设有这么一个需求 在执行计算的时候，给控制台答应的格式为 begain  method  with [ args1,args2 ]  end method with result 看看原来的代码： 接口：ArithmethicCalculator  package com.dxf.ArithmethicCalculator; public int
Spring AOP（五）AOP的引入
DDLoveWorld的博客
02-18 998
转载自 https://blog.csdn.net/Sadlay/article/details/83478481 AOP的引入 引入就是在一个接口的基础上引入新的接口增强功能。 在上一篇博客中测试AOO的时候，我们打印了用户信息，如果用户信息为空，则抛出异常。 事实上，我们还可以检测用户信息是否为空，如果为空则不再打印，这样就没有异常产生了。 但现有的UserService接口并没有提供这样的功...
Spring引入AOP
weixin_45402151的博客
04-02 815
AOP即面向切面编程是一种通过预编译和运行期动态代理的方式实现在不修改源代码的情况下给程序动态统一添加功能的技术；aop的基础是它的两种动态代理，JDK动态代理和CGLIb动态代理，区别在于JDK动态代理需要实现接口而CGLIb动态代理 则不需要，在实际开发中根据实际情况来选择使用那种动态代理 简单的转账功能 准备 创建一个Maven项目，做好基本配置 创建数据库，添加数据 # 删除spring_aop数据库 drop database if exists spring_aop; # 创建spring_a
Spring 引入式AOP 实例
我是xxxx
07-24 304
Spring 引入式AOP 实例 package cn.com.chujie.spring.springAop; /** * 目标切点类 */ public interface Performance { /** * 目标切点方法 */ public void perform(); } package cn.com.chujie.spring.spri...
（13）Spring AOP为目标对象引入新接口
shuai的博客
12-09 580
正常用ioc获取一个bean 接口 package shuai.spring.study.service; public interface IHelloService { public void sayHello(); } 实现类 package shuai.spring.study.service.impl; import shuai.spring.study.servic
Spring| AOP之 引入(Introductions)
YvesHe的专栏
06-28 1420
在看此文章之前，你可能已经知道了，Spring是通过Before、After、AfterRunning、AfterThrowing以及Around 共5中通知方式为目标方法增加切面功能，比如一个需要在目标类执行一个目标方法之前和之后分别打印一份日志，就可以建立一个切面在这个方法前后打印日志。 但是如果我想在此目标类中再增加一个目标方法是，该怎么办呢？ 最简单的办法就是在建立此目标类的时候，增加此方...
2019最新 Spring5
07-02
Spring5 是一个重要的版本，距离SpringFramework4差不多四年。在此期间，大多数增强都是在 SpringBoot 项目中完成的。在本文中，我们将很快了解到Spring5发行版中的一些令人兴奋的特性。
SpringBoot项目中使用AOP
weixin_34273046的博客
02-18 323
为什么80%的码农都做不了架构师？>>> ...
springaop默认的动态代理
最新发布
08-17
Spring AOP 默认使用 JDK 动态代理来实现代理对象。JDK 动态代理是基于接口的代理，它通过生成实现目标接口的代理类来实现代理功能。在运行时，JDK 动态代理会动态生成一个代理类，并在代理类中通过反射调用被代理...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值