AOP补充案例

已于 2023-10-18 11:11:16 修改
阅读量89 收藏
点赞数 1
文章标签： java spring maven aop 代理模式
于 2021-07-20 14:39:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47264624/article/details/118934745
版权

Spring AOP

AOP案例引入

数据库事务说明

  1. 案例分析：
    • userMapper.insert(User对象)
    • deptMapper.insert(Dept对象)
  2. 说明：由于业务需求，要求方法要么同时入库，要么同时回滚，所以必须通过事务进行控制。

Spring实现事务控制（demo）

代码结构如下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OFYj6jNI-1626762937040)(SpringAOP_files/1.jpg)]

编辑UserMapper/UserMapperImpl

  1. 编辑UserMapper

     public interface UserMapper {
 	void addUser(User user);
 }

  2. 编辑UserMapperImpl

     @Repository
 public class UserMapperImpl implements UserMapper {

 	//事务的控制应该在哪一层完成？ dao/mapper service
 	public void addUser(User user) {
 		System.out.println("用户入库：" + user);
 	}

 }

编辑UserService/UserServiceImpl

  1. 编辑UserService

     public interface UserService {
 	void addUser(User user);
 }

  2. 编辑UserServiceImpl

     @Service
 public class UserServiceImpl implements UserService {
 	@Autowired
 	private UserMapper userMapper;

 	//事务的控制应该放到Service层中进行控制
 	public void addUser(User user) {
 		try {
 			System.out.println("事务开始");
 			userMapper.addUser(user);
 			System.out.println("事务结束");
 		}catch (Exception e){
 			e.printStackTrace();
 			System.out.println("事务回滚");
 		}
 	}
 }

编辑测试类

public class TestUser {
	/**
	 * Spring中规定：
	 *  如果传入的是接口的类型，则自动查找/注入该接口的实现类
	 *  前提：该接口只有一个实现类
	 * 注入接口的原则：
	 *  if(getBean(isinterface)){
	 *      Class targetClass = interface.getImpl();
	 *      //根据类型，动态获取对象
	 *      return 对象;
	 *  }
	 */

	@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(1111);
		user.setName("SpringAOP入门案例");
		userService.addUser(user);
	}
}

代码问题分析

问题1：Service层：本应该代码业务处理即可，但是由于控制紧紧的耦合在一起

问题2：代码冗余，不便于大批量开发

解决方案：采用代理模式进行编辑

代理模式

生活中代理的案例

  • 房屋中介代理模式：

    1. 房东：自己手里有房子，需要出租换钱
    2. 中介机构：
      • 本职工作 带客户看房/出租房屋
      • 收取中介费（服务费）
    3. 租客：满足自身的需求 租房

  • 代码思维建模：

    1. 对外暴露一个公共的接口（租房子）
    2. 客户与中介机构进行沟通，中介看起来和房东功能一致（代理看起来就是展示的对象）
    3. 完成用户额外的操作（收取服务费）

组成部分

  1. 要求代理者实现与被代理者相同的接口
  2. 在代理方法中实现功能的扩展
  3. 用户调用代理对象完成功能（用户认为代理就是目标对象）

调用流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sl9X5PzQ-1626762937042)(SpringAOP_files/2.jpg)]

静态代理

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

  • 角色划分：
    1. 目标对象 target UserServiceImpl类
    2. 目标方法 method addUser方法
    3. 代理：实现事务的控制
    4. 代理对象与目标对象实现相同的接口

修改目标对象名称

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hy3jf6vk-1626762937043)(SpringAOP_files/3.jpg)]

编辑代理类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Zzl6qJo-1626762937045)(SpringAOP_files/4.jpg)]

@Service("userService")
public class StaticProxy implements UserService {

	//要求引入目标的对象
	@Autowired
	private UserService target;

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

编辑UserServiceImpl

@Service("target")
public class UserServiceImpl implements UserService {
	@Autowired
	private UserMapper userMapper;

	//事务的控制应该放到Service层中进行控制
	public void addUser(User user) {
		userMapper.addUser(user);
	}

//    public void addUser(User user) {
//        try {
//            System.out.println("事务开始");
//            userMapper.addUser(user);
//            System.out.println("事务结束");
//        }catch (Exception e){
//            e.printStackTrace();
//            System.out.println("事务回滚");
//        }
//    }
}

编辑测试方法

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

静态代理弊端

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

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

动态代理机制

动态代理分类

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

编辑JDK动态代理

  1. 官网API：
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wq5E4IV9-1626762937046)(SpringAOP_files/6.jpg)]

  2. 背会知识点：

    • 关于匿名内部类用法说明：匿名内部类引用外部参数，要求参数必须final

    • invoke():该方法标识当代理对象执行时，回调该方法

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {}

    • 执行目标方法：

        result = method.invoke(target, args);

    • 目标方法执行：

        public class JDKProxyFactory {
  	// 要求用户传递目标对象
  	// 关于匿名内部类用法说明：匿名内部类引用外部参数，要求参数必须final
  	public static Object getProxy(final Object target){
  		// 调用Java API实现动态代理
  		/**
  		 * 参数分析：3个参数
  		 * 1. ClassLoader loader 类加载器（获取目标对象的Class(类型)）
  		 * 2. Class<?>[] interfaces JDK代理要求必须有接口（Java中可以多实现）
  		 * 3. InvocationHandler h 对目标方法进行扩展
  		 */
  		// 获取类加载器
  		ClassLoader classLoader = target.getClass().getClassLoader();
  		// 获取接口数组
  		Class<?>[] interfaces = target.getClass().getInterfaces();
  		final Object proxyInstance = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
  			// invoke()：代理对象调用方法时invoke执行,扩展方法编辑的位置
  			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  				Object result = null;
  				try {
  					// 添加事务的控制
  					System.out.println("事务开始");
  					// 执行目标方法 target代表真实的目标对象 method代表方法对象 args代表方法参数
  					// result标识目标方法执行的返回值
  					result = method.invoke(target, args);
  					System.out.println("事务提交");
  				}catch (Exception e){
  					e.printStackTrace();
  					System.out.println("事务回滚");
  				}
  				return result;
  			}
  		});
  		return  proxyInstance;
  	}
  }

JDK动态代理执行过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2sIVOqAv-1626762937048)(SpringAOP_files/5.jpg)]

动态代理优势

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

  • 编辑DeptService

      public interface DeptService {
  	void addDept();
  }

  • 编辑DeptServiceImpl

      @Service("deptService")
  public class DeptServiceImpl implements DeptService {
  	public void addDept() {
  		System.out.println("调用DeptMapper，实现入库");
  	}
  }

  • 编辑测试类

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

动态代理实现方案（二）

  • 业务需求：

    • 要求对Service层的方法记录其执行的时间
    • 通过执行时间长短进行针对性优化
    • 要求Service中有addUser()和delete()
    • 要求代码结构扩展性好，耦合性低

  • 编辑UserService

      public interface UserService {
  	void addUser();
  	void deleteUser();
  }

  • 编辑UserServiceImpl

      @Service("target")
  public class UserServiceImpl implements UserService {
  	public void addUser() {
  		System.out.println("添加用户");
  	}

  	public void deleteUser() {
  		System.out.println("删除用户");
  	}
  }

  • 编辑测试类

      public class Test {
  	@org.junit.Test
  	public void testJDKProxy(){
  		ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
  		UserService target = (UserService) context.getBean("target");
  		UserService proxy = (UserService) JDKProxyFactory.getProxy(target);
  		proxy.addUser();
  		proxy.deleteUser();
  	}
  }

动态代理实现方案（三）

  • 业务需求：

    • 要求进行日志控制
    • 要求方法执行时，获取方法的类名，方法民法 进行空服之台输出 以及方法执行时间
    • 要求代码结构扩展性好，耦合性低

  • 编辑DeptService

      public interface DeptService {
  	void addDept();
  	void searchDept();
  	void updateDept();
  	void deleteDept();
  }

  • 编辑DeptServiceImpl

      @Service("target")
  public class DeptServiceImpl implements DeptService {
  	public void addDept() {
  		System.out.println("添加部门");
  	}

  	public void searchDept() {
  		System.out.println("查找部门");
  	}

  	public void updateDept() {
  		System.out.println("修改部门");
  	}

  	public void deleteDept() {
  		System.out.println("删除部门");
  	}
  }

  • 编辑测试类

      public class Test {
  	@org.junit.Test
  	public void testProxy(){
  		ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
  		DeptService target = (DeptService) context.getBean("target");
  		DeptService proxy = (DeptService) JDKProxyFactory.getProxy(target);
  		proxy.addDept();
  		proxy.deleteDept();
  		proxy.searchDept();
  		proxy.updateDept();
  	}
  }

ij

public class JDKProxyFactory {
	// 要求用户传递目标对象
	// 关于匿名内部类用法说明：匿名内部类引用外部参数，要求参数必须final
	public static Object getProxy(final Object target){
		// 调用Java API实现动态代理
		/**
		 * 参数分析：3个参数
		 * 1. ClassLoader loader 类加载器（获取目标对象的Class(类型)）
		 * 2. Class<?>[] interfaces JDK代理要求必须有接口（Java中可以多实现）
		 * 3. InvocationHandler h 对目标方法进行扩展
		 */
		// 获取类加载器
		ClassLoader classLoader = target.getClass().getClassLoader();
		// 获取接口数组
		Class<?>[] interfaces = target.getClass().getInterfaces();
		final Object proxyInstance = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
			// invoke()：代理对象调用方法时invoke执行,扩展方法编辑的位置
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				Object result = null;
				try {
					// 添加事务的控制
					System.out.println("事务开始");
					// 执行目标方法 target代表真实的目标对象 method代表方法对象 args代表方法参数
					// result标识目标方法执行的返回值
					result = method.invoke(target, args);
					System.out.println("事务提交");
				}catch (Exception e){
					e.printStackTrace();
					System.out.println("事务回滚");
				}
				return result;
			}
		});
		return  proxyInstance;
	}
}

附AOP案例:https://blog.csdn.net/weixin_47264624/article/details/118990367

刘刘刘刘刘先生
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringAOP超详细教学
TheSevenSky
03-10 7961
SpringAOP 前言 我的这篇AOP博客有大量的图片和例子教会怎么使用AOP 配置那里如果没有学习Maven的话也别急 就是使用maven下载了jar包而已了 你完全可以自己手动导入 如果你有一些代码比如说 事务 或者 日志等操作 需要大量嵌入你的代码前后的话 那么无疑AOP是最好用的 AOP运行流程 : 首先调用前置通知(你可以认为最一开始初始的东西)-&amp;gt;你的逻辑代码(这里先不说环...
Spring AOP 入门与案例
weixin_47081743的博客
07-29 184
1 .Spring AOP 简介 1.1 AOP 概述 1.1.1 AOP 是什么? AOP(Aspect Orient Programming) 是一种设计思想,是软件设计领域中的面向切面编程,它是面向对象编程(OOP)的一种补充和完善.它以通过预编译方式和运行期动态代理方式,实现在不修改代码的情况下给程序动态统一添加额外功能的一种技术,如下图 实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块,一个模块有哪些对象,对象有哪些属性),面向切面的运行期代理方式,理解**为一个动态过
【Java】System.out.println
热门推荐
Ankie_的博客
04-08 1万+
System.out.println() System.out.println是一个Java语句，一般情况下是将传递的参数，打印到控制台 System是Java.lang包中的一个final类，该类提供的设施包括标准输入、标准输出和错误输出流、访问外部定义的属性和环境变量，一种加载文件和库的方法，以及用于加速复制数组等一部分的使用方法。 out是System类的静态成员字段，类型为PrintSt...
好好编程-物流项目10【用户管理-查询和添加】
波波烤鸭的博客
03-21 1955
  在实现登录功能之前我们来实现下用户管理。 初学者应该对这张图片铭记于心~ 用户管理 1.查询用户信息   将用户表中的数据展示在页面中 1.1 用户业务逻辑层 接口定义 package com.bobo.service; import java.util.List; import com.bobo.pojo.User; /** * 用户信息 * @author 波波烤鸭 * *...
MyBatis备忘：查询数据库实现登录功能的一个演示
yicha_i的博客
09-15 652
复习：entity&nbsp;&nbsp;DAO/DBHelper&nbsp;&nbsp;service&nbsp;&nbsp;action&nbsp;&nbsp;jsp 总结：使用mybatis后的区别：DBHelper里书写的是SqlSession，而不是自己来拿数据库连接了，当然这得写配置文件SqlMapConfig；service包里是一个接口对一个实现类，如IUserServic...
Aop小案例
weixin_56177676的博客
10-18 1932
demo_aop
Spring AOP 代码加案例详解
持续学习，持续更新
04-27 2438
学习AOP就要先学习代理模式，这样AOP的学习就简单了。代理模式是Java常见的设计模式之一，包含：静态代理和动态代理。通过案例感受静态代理：租房子问题。房东需要将房子出租，如果都亲力亲为太麻烦了：房东要自己出去贴广告，带租客看房，讨价还价，签合同，收租金，定期检查房子，定期保洁。这时候就需要中介代理了，房东就是要租房拿钱，额外的功能：签合同，讨价还价，定期检查房子 ，定期保洁都由中介代理去做，所以 代理 简化了 业主的功能,同时对房东的功能做了一个扩展。找中介的好处：（1）保护真实对象 （房东） （2
Spring AOP入门案例
weixin_45874103的博客
03-19 137
一、AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块，一个模块有哪些对象，对象有哪些属性)，面向切面理解为一个动态过程（在对象运行时动态进行功能扩展或控制对象执行）。 二、应用AOP所需要的相关概念 1.切面（aspect）...
Spring中的Aop简单实例讲解
BookSea的博客
07-02 3482
注重版权，转载请注明原作者和原文链接 作者：码农BookSea 原文链接：https://editor.csdn.net/md?articleId=107092569 Aop，即面向切面编程，面向切面编程的目标就是分离关注点 比如：一个骑士只需要关注守护安全，或者远征，而骑士辉煌一生的事迹由谁来记录和歌颂呢，当然不会是自己了，这个完全可以由诗人去歌颂，比如当骑士出征的时候诗人可以去欢送，当骑士英勇牺牲的时候，诗人可以写诗歌颂骑士的一生。那么骑士只需要关注怎么打仗就好了。而诗人也只需要关注写诗歌颂和欢送.
AOP的例子 记录日志
07-04
**切面编程（AOP）**是面向对象编程（OOP）的一种补充，它提供了一种模块化横切关注点的方式，比如日志记录、事务管理、性能监控等。在本例子中，我们将探讨如何使用Spring框架实现AOP来记录日志。 **一、AOP概念**...
spring aop详细代码示例
12-10
AOP（Aspect-Oriented Programming）这个东西，名字与 OOP 仅差一个字母，其实它是对 OOP 编程方式的一种补充，并非是取而代之。翻译过来就是“面向方面编程”，可我更倾向于翻译为“面向切面编程”。最好的演示案例...
aop 读写分离.rar
06-15
AOP是面向切面编程的缩写，它是面向对象编程的一个补充。在OOP中，我们通常关注于“对象”和“类”，而在AOP中，我们关注的是“切面”，即横切关注点，如日志、事务管理等。通过AOP，这些关注点可以被模块化，然后在...
Spring AOP技术在J2EE系统安全陛验证中的应用研究
07-07
AOP是一种补充和改进OOP的编程范式，旨在处理那些散布在多个类中的共同行为，而无需修改这些类的源代码。AOP的核心在于分离关注点，将系统中横切关注点的功能封装进可重用的模块，从而降低系统的耦合度，提高代码的...
基于OOP 和AOP的软件产品线实现技术研
11-14
为了克服OOP在处理横切关注点上的不足，面向方面编程（Aspect-Oriented Programming, AOP）作为一种补充技术被引入。AOP通过将横切关注点从业务逻辑中分离出来，并通过声明式的配置方式来实现这些关注点，从而显著...
Java面试篇（JVM相关专题）
聂可以的博客
08-09 2675
Java面试篇（JVM相关专题）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 309
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 281
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
软件测试需要具备的基础知识【功能测试】---后端知识（三）
最新发布
yang_xs的博客
08-12 814
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
"深入浅出SpringMVC请求流程及案例
在SpringMVC的主要流程之外，还有一些补充的流程步骤，比如数据绑定、数据验证、异常处理等。这些步骤都是围绕着请求的处理而展开的，保证了整个处理过程的完整性和准确性。 在介绍了SpringMVC的请求流程之后，本文...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刘刘刘刘刘先生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值