手写AOP框架

最新推荐文章于 2024-03-07 22:00:16 发布
最新推荐文章于 2024-03-07 22:00:16 发布
阅读量228 收藏 1
点赞数 1
分类专栏： Java 文章标签： java 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yshjvc/article/details/124560453
版权

业务：图书购买业务

切面：事务

第一个版本

业务和切面紧耦合在一起，没有拆分

package ys.com.proxy1;

public class BookServiceImpl {
    public void buy(){
        try{
        System.out.println("事务开启");
        System.out.println("图书购买业务功能实现");
        System.out.println("事务提价");
        }catch(Exception e){
            System.out.println("事务回滚");
        }
    }
}

第二个版本

使用子类代理的方式拆分业务和切面

package ys.com.proxy2;

//使用子类代理的方式进行图书业务和事务切面的拆分
public class BookServiceImpl {
    //父类只有的业务
    public void buy(){
        System.out.println("图书购买功能实现");
    }
}

package ys.com.proxy2;

import ys.com.proxy2.BookServiceImpl;
//子类就是代理类，将父类的图书购买功能添加事务切面
public class SubBookServiceImpl extends BookServiceImpl {
    @Override
    public void buy() {
        try{
        //事务切面
        System.out.println("事务开启");
        //主业务实现
        super.buy();
        //事务切面
        System.out.println("事务提交");
        }catch (Exception e){
            System.out.println("事务回滚");
        }
    }
}

package ys.com.main;

import ys.com.proxy2.BookServiceImpl;
import ys.com.proxy2.SubBookServiceImpl;

public class myapp {
    public static void main(String[] args) {
        BookServiceImpl bookService=new SubBookServiceImpl();
        bookService.buy();
    }
}

第三个版本

使用静态代理拆分业务和切面。业务和业务接口已拆分，此时切面紧耦合在业务中

package ys.com.proxy3;

public interface Service {
    //规定业务功能
    void buy();
}

package ys.com.proxy3;

//目标对象，业务功能实现
public class BookServiceImpl implements Service{
    @Override
    public void buy() {
        System.out.println("图书购买功能实现");
    }
}

package ys.com.proxy3;

public class ProductServiceImpl implements Service{
    @Override
    public void buy() {
        System.out.println("商品购买业务实现");
    }
}

package ys.com.proxy3;

//静态代理已经实现了目标对象的灵活切换

public class Agent implements Service{
//    设计成员变量的类型为接口，为了灵活切换目标对象
    public  Service service;
//    使用构造方法传入目标对象
    public Agent(Service service){
        this.service =service;
    }
    @Override
    public void buy() {
        try {
            //        切面功能
            System.out.println("事务开启");
//            业务功能
            service.buy();
            //切面功能
            System.out.println("事务提交");
        }catch (Exception e){
            System.out.println("事务回滚");
        }

    }
}

package ys.com.main;

import ys.com.proxy3.Agent;
import ys.com.proxy3.BookServiceImpl;
import ys.com.proxy3.ProductServiceImpl;
import ys.com.proxy3.Service;


public class myapp {
    public static void main(String[] args) {
        Service service =new Agent(new ProductServiceImpl());
 // Service service =new Agent(new BookServiceImpl());
//不同功能的灵活切换
        service.buy();

    }
}

第四个版本

使用静态代理拆分业务和业务接口，切面和切面接口

图片摘自 动力节点

package ys.com.proxy4;

//静态代理已经实现了目标对象的灵活切换

public class Agent implements Service {
    //    设计成员变量的类型为接口，为了灵活切换目标对象
    public Service service;
    public AOP aop;

    //    使用构造方法传入目标对象
    public Agent(Service service, AOP aop) {
        this.service = service;
        this.aop = aop;
    }

    @Override
    public void buy() {
        try {
            //        切面功能
            aop.before();
//            业务功能
            service.buy();
            //切面功能
            aop.after();
        } catch (Exception e) {
            aop.exception();
        }

    }
}

package ys.com.proxy4;

//切面接口
public interface AOP {
//    void before();
//    void after();
//    void exception();
    default void before(){}
    default void after(){}
    default void exception(){}
//    使用default 修饰的方法可以空实现，即接口的实现类不需要实现全部的方法
}

package ys.com.proxy4;

//切面实现类 日志

public class AopLogImpl implements AOP{

    @Override
    public void before() {
        System.out.println("日志启动");
    }
}

package ys.com.proxy4;

public class AopTransImpl implements AOP{
//切面实现类 事务
    @Override
    public void before() {
        System.out.println("事务开启");
    }

    @Override
    public void after() {
        System.out.println("事务提交");
    }

    @Override
    public void exception() {
        System.out.println("事务回滚");
    }
}

package ys.com.proxy4;

//目标对象，业务功能实现
public class BookServiceImpl implements Service {
    @Override
    public void buy() {
        System.out.println("图书购买功能实现");
    }
}

package ys.com.proxy4;

public class ProductServiceImpl implements Service {
    @Override
    public void buy() {
        System.out.println("商品购买业务实现");
    }
}

package ys.com.proxy4;

public interface Service {
    //规定业务功能
    void buy();
}

package ys.com.main;

import ys.com.proxy4.*;


public class myapp {
    public static void main(String[] args) {
        Service service =new Agent(new BookServiceImpl(),new AopLogImpl());
        service.buy();

    }
}



//多个切面切入的功能
public class myapp {
    public static void main(String[] args) {
        Service service =new Agent(new BookServiceImpl(),new AopLogImpl());
        Service total =new Agent(service,new LogAop());
// 创建新的Service 对象，将前需要被切入的对象和切入的切面再次赋值给新的对象
        total.buy();

    }
}

第五个版本

使用动态代理完成第四个版本的优化

 

对Service接口进行修改

package ys.com.proxy5;

public interface Service {
    //规定业务功能
    void buy();
//    增加一个方法
   default String show(int age){return "22";}
}

 对BookServiceImpl实现类进行修改

package ys.com.proxy5;

//目标对象，业务功能实现
public class BookServiceImpl implements Service {
    @Override
    public void buy() {
        System.out.println("图书购买功能实现");
    }

    @Override
    public String show(int age) {
        System.out.println("show方法被调用"+age);
        return Service.super.show(age);
    }
}

新建java类，进行动态代理

package ys.com.proxy5;

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

public class ProxyFactory {
    public static Object getAgent(Service service,AOP aop){
        return Proxy.newProxyInstance(
//                类加载器
                service.getClass().getClassLoader(),
//                目标对象实现的所有的接口
                service.getClass().getInterfaces(),
//                代理功能的实现
//                匿名内部类实现
                new InvocationHandler() {
                    @Override
                    public Object invoke(
//                         生成的代理对象
                            Object proxy,
//                            正在被调用的目标方法
                            Method method,
//                            目标方法的参数
                            Object[] args) throws Throwable {
                        Object object = null;
                        try {
//                        切面
                            aop.before();
//                        业务
                          object=method.invoke(service,args);
//                        切面
                            aop.after();

                        } catch(Exception e){
//                            切面
                            aop.exception();
                        }
                        return object;

                    }
                }
        );
    }
}

修改主方法

package ys.com.main;

import ys.com.proxy5.*;


public class myapp {
    public static void main(String[] args) {
//      获取动态代理对象
        Service service =(Service)ProxyFactory.getAgent(new BookServiceImpl(),new AopLogImpl());
        Service service1=(Service)ProxyFactory.getAgent(service,new AopTransImpl());
        String s=service1.show(22);
        System.out.println(s);
        System.out.println("------------------------------------");
        service1.buy();
    }
}
安城倾目
关注
专栏目录
手写Spring框架之AOP
Tyshawn的博客
01-25 7311
简介 手写Spring框架第一篇博客(必读): 手写Spring框架 前面两篇博客已经实现了Bean容器, IOC功能和MVC功能, 本篇博客来实现AOP功能和事务管理. 在看下面的内容之前, 一定要先回顾下Spring AOP和动态代理. Spring AOP 动态代理 handwritten-mvc-framwork 实现 定义注解 (1) 切面注解 @Target(ElementType.T...
手写spring框架ioc+aop+mvc
11-01
在这个"手写 spring 框架 ioc+aop+mvc"的项目中，我们将深入理解这三个关键组件的实现原理。 1. **依赖注入（IOC）**： 依赖注入是 Spring 框架的核心特性，它允许我们解耦组件间的依赖关系，使得代码更加灵活和可...
简易的AOP框架
01-17
一个简单实现的AOP框架。里面涵盖： 有配置文件，自定义注解，Bean容器，示例用的servicebean，产生动态代理对象的工具类等。
从代理到 AOP，如何手写一个 AOP 框架？
大鹏的博客
06-14 1443
AOP 作为 OOP 的补充，提供了另外一种思考程序结构的编程思想。OOP 的模块化的单位是 Class，而 AOP 模块化的单位则为 Aspect。Aspect 将跨越多个 Class 的关注点模块化，如日志、事务等等。本篇从代理谈起，逐步过渡到 AOP，并实现一个简单的 AOP 框架，旨在加深自己和大家对 AOP 的理解。
手写AOP
littlewhitevg的博客
04-12 260
//不能再invoke 方法里面调用类似 proxy.toString()的方法,会stackoverflow的 原因: Object类里面的一部分可被子类继承的 方法也是被增强了的 可以通过反编译动态代理生成的类文件查看 一、AOP分析 问题1：AOP是什么？ Aspect Oriented Programming 面向切面编程,在不改变类的代码的情况下，对类方法进行功能增强。 问题2：我们...
手写实现AOP编程
吃果冻不吐果冻皮
11-10 5189
AOP 面向切面的编程， AOP可以实现“业务代码”与“关注点代码”分离 在Spring的AOP编程中， 如果加入容器的目标对象有实现接口，用JDK代理； 如果目标对象没有实现接口，用Cglib代理；总结： 关注点代码，就是指重复执行的代码。 业务代码与关注点代码分离，好处？ –关注点代码写一次即可； –开发者只需要关注核心业务； –运行时期，执行核心业务代
通过Aop手写一个日志框架
wjy_0208的博客
06-24 245
1.大致流程 2.编写aop采集日志 package com.example.test.aop; import cn.hutool.core.date.DateUtil; import cn.hutool.json.JSON; import cn.hutool.json.JSONUtil; import com.example.test.utils.Log; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotatio.
仿 Spring 手写 IoC、AOP 框架.rar
10-23
**手写AOP框架** 实现AOP框架，你需要考虑以下关键点： 1. **定义切面**：创建一个类或接口来表示切面，其中包含切点表达式（Pointcut Expression）和通知。 2. **匹配切点**：解析切点表达式，确定哪些方法会触发...
手写springAop框架3.zip
03-19
《手写Spring AOP框架详解》 在Java开发领域，Spring框架因其强大的功能和灵活性而备受推崇，其中AOP（面向切面编程）模块更是它的一大亮点。本文将深入探讨如何手写一个简单的Spring AOP框架，理解其背后的原理与...
【框架源码篇 03】Spring源码手写篇-手写AOP
10-21
【Spring源码篇 03】Spring源码手写篇-手写AOP Spring框架是Java开发中广泛使用的轻量级容器，它的核心特性之一就是面向切面编程（Aspect-Oriented Programming，简称AOP）。AOP允许程序员定义“横切关注点”，即...
Spring源码：手写AOP
最新发布
程序员Forlan的博客
03-07 1118
本文主要介绍如何实现SpringAOP，手撸源码
（二）手写spring AOP框架
Maybe_9527的博客
01-20 942
目录前言AOP是什么AOP框架要做什么AOP技术元素分析Advice设计插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 本篇基于（一）手写spring IOC容器手写AOP框架。采用问答形式，逐步梳理手写aop过程。 AOP是什么 Aspect Oriented Programmin
框架源码系列三：手写Spring AOP（AOP分析、AOP概念学习、切面实现、织入实现）...
weixin_33910434的博客
03-17 282
一、AOP分析 问题1：AOP是什么？ 　　Aspect Oriented Programming 面向切面编程,在不改变类的代码的情况下，对类方法进行功能增强。 问题2：我们需要做什么？ 在我们的框架中要向使用用户提供AOP功能，让他们可以通过AOP技术实现对类方法进行功能增强。 从"Aspect Oriented Programming 面向切面编程,在不改变类的代码的情况下，对...
自己手写一个AOP动态代理框架（2）
Fujie1997的博客
06-02 589
之前实现的自己手写一个AOP动态代理框架（1）只能根据控制器，业务层，DAO层等等注解的形式来进行切面，这里仿Spring,支持AspectJ的表达式进行定位类方法资源，然后进行代理。 集成AspectJ的语法树，即复用AspecJ的对资源的定位功能。也就是说可以使用 execution(* com.fuyouj.service..*.*(..))这样的表达式。 AspectJ简介 提供了完整的AOP实现。 定义了切面语法和切面语法的解析。 Spring支持方法级别的织入（满足80%的需求了），Aspe.
万字长文！自己手写一个AOP动态代理框架（1）
Fujie1997的博客
06-02 1029
前面提到过动态代理的有两种简单的实现方式，就是JDK动态代理和CGLIB。 不懂先看前文：SpringAOP的实现之代理模式 自己写嘛当然是乞丐版了，为了实现简单 但是又具有一定的通用性（拒绝对被代理类有实现接口的强硬要求）。所以采用CGLIB的方式实现AOP。 工程目录结构。 首先要实现注解一样的 AOP，要定义与AOP相关的注解。 定义2个AOP相关的注解标签。 //作用在类上 @Target(ElementType.TYPE) //运行时有效 @Retention(RetentionPolicy.R
手写Aop
Trygoto的博客
02-25 974
手写简单Aop,展示aop设计思路和基础原理 提示：本文章适合有一定java反射基础的程序员，博主还是个新手新手超新手，欢迎指正！！！本文是参考Java 编程逻辑一书… 文章目录手写简单Aop,展示aop设计思路和基础原理Aop 简介：一、Aop 的基础原理是动态代理，动态代理又有哪些呢？二、手写Aop实例1.创建自定义注解2.创建切面类 Aop 简介： 简介百度一大堆，这里简单说下博主自己的理解，Aop其实就是用来解决成品系统中添加辅助功能的一种方式。当你的系统所有功能都完成了，你调试 的时候发现没有
AOP: 切面编程项目：手写注解框架
C++ JAVA的专栏
08-16 198
注解框架一
手写Spring AOP框架实战：高仿真30类实现
在课程中，将使用30个类来搭建一个基本的Spring AOP框架，以覆盖核心功能，从而增强对Spring工作原理的理解。 课程目标明确，主要分为两个部分： 1. 实践高仿真Spring AOP模块，通过亲手编写代码来体验和学习设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值