Spring之AOP面向切面编程

已于 2022-09-16 13:21:03 修改
阅读量1k 收藏 1
点赞数
文章标签： spring java 后端
于 2022-09-16 09:42:10 首次发布
aaa
本文链接：https://blog.csdn.net/djydjy3333/article/details/126884297
版权

什么是AOP

AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（例如性能监视、事务管理、安全检查、缓存、日志记录等）。

【扩展了解】AOP 是 OOP（面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构），思想延续 ！

在这里插入图片描述

AOP 思想： 基于代理思想，对原来目标对象，创建代理对象，在不修改原对象代码情况下，通过代理对象，调用增强功能的代码，从而对原有业务方法进行增强 ！
切面：需要代理一些方法和增强代码 。

AOP的应用场景

场景一： 记录日志
场景二： 监控方法运行时间 （监控性能）
场景三： 权限控制
场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）
场景五： 事务管理 （调用方法前开启事务， 调用方法后提交或者回滚、关闭事务 ）

Spring AOP编程两种方式

  • Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类植入增强代码。
  • AsPectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持。

简单的说，Spring内部支持两套AOP编程的方案：

  • Spring 1.2 开始支持AOP编程 （传统SpringAOP 编程），编程非常复杂 ---- 更好学习Spring 内置传统AOP代码
  • Spring 2.0 之后支持第三方 AOP框架（AspectJ ），实现另一种 AOP编程 – 推荐

AOP思想编程的机制

在这里插入图片描述

AOP的相关术语
Aspect(切面): 是通知和切入点的结合,通知和切入点共同定义了关于切面的全部内容—它的功能、在何时和何地完成其功能
joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
Pointcut(切入点):所谓切入点是指我们要对哪些joinpoint进行拦截的定义.
通知定义了切面的”什么”和”何时”，切入点就定义了”何地”.
Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Target(目标对象):代理的目标对象
weaving(织入):是指把切面应用到目标对象来创建新的代理对象的过程.切面在指定的连接点织入到目标对象
Introduction(引介):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

过案例解释AOP相关概念
需求：UserDao中有5个方法，分别是save()、update()、delete()、find()、login()；在访问UserDao的save()、update()、delete()方法之前，进行记录日志的操作。

在这里插入图片描述

AOP编程底层实现机制（了解）

AOP 就是要对目标进行代理对象的创建， Spring AOP是基于动态代理的，基于两种动态代理机制： JDK动态代理和CGLIB动态代理

JDK动态代理

JDK动态代理，针对目标对象的接口进行代理 ，动态生成接口的实现类 ！（必须有接口）

【过程要点】：
1、 必须对接口生成代理
2、 采用Proxy类，通过newProxyInstance方法为目标创建代理对象。
该方法接收三个参数 ：
（1）目标对象类加载器
（2）目标对象实现的接口
（3）代理后的处理程序InvocationHandler
使用 Proxy类提供 newProxyInstance 方法对目标对象接口进行代理

在这里插入图片描述
参数说明：
loader：定义代理类的类加载器
interfaces：代理类要实现的接口列表
h:指派方法调用的调用处理程序

注意：
JDK动态代理的缺点： 只能面向接口代理，不能直接对目标类进行代理 ，如果没有接口，则不能使用JDK代理。

实现InvocationHandler 接口中 invoke方法，在目标对象每个方法调用时，都会执行invoke

【示例】：需求：对目标对象中存在保存和查询的方法，在执行保存的方法的时候，记录日志
第一步：新建web工程：spring4，创建包
第二步：编写业务接口，接口中定义save()和find()的方法。

ICustomerService

package cn.itcast.spring.AOP;
//接口（表示代理的目标接口）
public interface ICustomerService {
    //保存
    public void save();
    //查询
    public int find();
}

第三步：编写业务类，类要实现接口
CustomerServiceImpl.java

package cn.itcast.spring.AOP;
//实现类
public class CustomerServiceImpl implements ICustomerService{
    @Override
    public void save() {
        System.out.println("客户保存了。。。。。");
    }

    @Override
    public int find() {
        System.out.println("客户查询数量了。。。。。");
        return 100;
    }
}

第四步：使用JDK代理完成
代理工厂：
有三种方案完成JDK动态代理：

方案一：在内部实现new InvocationHandler()，指定匿名类

JdkProxyFactory1.java

package cn.itcast.spring.AOP;

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

//专门用来生成jdk的动态代理对象的-通用
public class JdkProxyFactory1 {
    //成员变量
    private Object target;

    //注入target目标对象
    public JdkProxyFactory1(Object target) {
        this.target = target;
    }

    public Object getProxyObject() {
        //参数1：目标对象的类加载器
        //参数2：目标对象实现的接口
        //参数3：回调方法对象
        /**方案一：在内部实现new InvocationHandler()，指定匿名类*/
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                //如果是保存的方法，执行记录日志操作
                if (method.getName().equals("save")||method.getName().equals("find")) {
                    writeLog();
                }
                //目标对象原来的方法执行
                Object object = method.invoke(target, args);//调用目标对象的某个方法，并且返回目标对象方法的返回值
                return object;
            }
        });
    }

    //记录日志
    private static void writeLog() {
        System.out.println("\033[31;4m" +"1.增强代码：写日志了。。。"+ "\033[0m");
    }

}

方案二：传递内部类的对象，指定内部类

JdkProxyFactory2.java

package cn.itcast.spring.AOP;

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

//专门用来生成jdk的动态代理对象的-通用
public class JdkProxyFactory2{
    //成员变量
    private Object target;
    //注入target
    public JdkProxyFactory2(Object target) {
        this.target = target;
    }

    public Object getProxyObject(){
        //参数1：目标对象的类加载器
        //参数2：目标对象实现的接口
        //参数3：回调方法对象
        /**方案二：传递内部类的对象，指定内部类*/
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),new MyInvocationHandler());
    }

    //自己制定内部类:类的内部可以多次使用类型
    private class MyInvocationHandler implements InvocationHandler {

        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //如果是保存的方法，执行记录日志操作
            if(method.getName().equals("save")){
                writeLog();
            }
            //目标对象原来的方法执行
            Object object = method.invoke(target, args);//调用目标对象的某个方法，并且返回目标对象方法的返回值
            return object;
        }
    }

    //记录日志
    private static void writeLog(){
        System.out.println("\033[31;4m" +"2.增强代码：写日志了。。。"+ "\033[0m");
    }
}

方案三：直接使用调用类作为接口实现类，实现InvocationHandler接口

JdkProxyFactory3.java

package cn.itcast.spring.AOP;

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

//专门用来生成jdk的动态代理对象的-通用
public class JdkProxyFactory3 implements InvocationHandler {
    //成员变量
    private Object target;
    //注入target
    public JdkProxyFactory3(Object target) {
        this.target = target;
    }

    public Object getProxyObject(){
        //参数1：目标对象的类加载器
        //参数2：目标对象实现的接口
        //参数3：回调方法对象
        /**方案三：直接使用调用类作为接口实现类，实现InvocationHandler接口*/
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }

    //记录日志
    private static void writeLog(){
        System.out.println("\033[31;4m" +"3.增强代码：写日志了。。。"+ "\033[0m");
    }

//参数1：代理对象
//参数2：目标的方法对象
//参数3：目标的方法的参数
@Override
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    //如果是保存的方法，执行记录日志操作
    if(method.getName().equals("find")){
        writeLog();
    }
    //目标对象原来的方法执行
    Object object = method.invoke(target, args);//调用目标对象的某个方法，并且返回目标对象
    return object;
}

}

第五步：使用SpringTest.java进行测试
SpringTest.java

package cn.itcast.spring.AOP;

import org.junit.Test;

public class SpringTest {
    //目标：使用动态代理，对原来的方法进行功能增强,而无需更改原来的代码。
    //JDK动态代理：基于接口的（对象的类型，必须实现接口！）

    //方案一：在内部实现new InvocationHandler()，指定匿名类
    @Test
    public void testJdkProxy1() {
        //target（目标对象）
        ICustomerService target = new CustomerServiceImpl();
        //实例化注入目标对象
        JdkProxyFactory1 jdkProxyFactory1 = new JdkProxyFactory1(target);
        //获取Proxy Object代理对象:基于目标对象类型的接口的类型的子类型的对象
        ICustomerService proxy = (ICustomerService) jdkProxyFactory1.getProxyObject();
        //调用目标对象的方法
        proxy.save();
        System.out.println("————————————————————————————————————————");
        proxy.find();
        System.out.println("");
        System.out.println("");
    }

    //方案二：传递内部类的对象，指定内部类
    @Test
    public void testJdkProxy2() {
        //target（目标对象）
        ICustomerService target = new CustomerServiceImpl();
        //实例化注入目标对象
        JdkProxyFactory2 jdkProxyFactory2 = new JdkProxyFactory2(target);
        //获取Proxy Object代理对象:基于目标对象类型的接口的类型的子类型的对象
        ICustomerService proxy = (ICustomerService) jdkProxyFactory2.getProxyObject();
        //调用目标对象的方法
        proxy.save();
        System.out.println("————————————————————————————————————————");
        proxy.find();
        System.out.println("");
        System.out.println("");
    }

    //方案三：直接使用调用类作为接口实现类，实现InvocationHandler接口
    @Test
    public void testJdkProxy3() {
        //target（目标对象）
        ICustomerService target = new CustomerServiceImpl();
        //实例化注入目标对象
        JdkProxyFactory3 jdkProxyFactory3 = new JdkProxyFactory3(target);
        //获取Proxy Object代理对象:基于目标对象类型的接口的类型的子类型的对象
        ICustomerService proxy = (ICustomerService) jdkProxyFactory3.getProxyObject();
        //调用目标对象的方法
        proxy.save();
        System.out.println("————————————————————————————————————————");
        proxy.find();
    }
}

在这里插入图片描述

Cglib动态代理

Cglib动态代理基于父类，Cglib的引入为了解决类的直接代理问题(生成代理子类)，不需要接口也可以代理 ！

什么是cglib ？
CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。

在这里插入图片描述
该代理方式需要相应的jar包，但不需要导入。因为Spring core包已经包含cglib ，而且同时包含了cglib 依赖的asm的包（动态字节码的操作类库）

【示例】：需求：对目标对象中存在保存和查询的方法，在执行保存的方法的时候，记录日志

第一步： 引入依赖spring-context
pom.xml

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

spring-core中已经包含了cglib

第二步：编写业务类，创建类ProductService.java，类不需要实现接口
ProductService.java

package cn.itcast.spring.AOP;

//没有接口的类
public class ProductService {
    public void save() {
        System.out.println("商品保存了。。。。。");

    }

    public int find() {
        System.out.println("商品查询数量了。。。。。");
        return 99;
    }
}

第三步：使用cglib代理，创建类CglibProxyFactory.java
CglibProxyFactory.java

package cn.itcast.spring.AOP;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

//cglib动态代理工厂:用来生成cglib代理对象
public class CglibProxyFactory implements MethodInterceptor {
    //声明一个代理对象引用
    private Object target;
    //注入代理对象
    public CglibProxyFactory(Object target) {
        this.target = target;
    }

    //获取代理对象
    public Object getProxyObject(){
        //1.代理对象生成器(工厂思想)
        Enhancer enhancer = new Enhancer();
        //2.在增强器上设置两个属性
        //设置要生成代理对象的目标对象：生成的目标对象类型的子类型
        enhancer.setSuperclass(target.getClass());
        //设置回调方法
        enhancer.setCallback(this);
//		Callback
        //3.创建获取对象
        return enhancer.create();
    }


    //回调方法（代理对象的方法）
    //参数1：代理对象
    //参数2：目标对象的方法对象
    //参数3：目标对象的方法的参数的值
    //参数4：代理对象的方法对象
    @Override
    public Object intercept(Object proxy, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {
        //如果是保存的方法，执行记录日志操作
        if(method.getName().equals("save")){
            writeLog();
        }
        //目标对象原来的方法执行
        Object object = method.invoke(target, args);//调用目标对象的某个方法，并且返回目标对象方法的执行结果
        return object;
    }

    //写日志的增强功能
    //Advice通知、增强
    //记录日志
    private static void writeLog(){
        System.out.println("\033[31;4m" +"cglib.增强代码：写日志了。。。"+ "\033[0m");
    }

}

第四步：测试代码，使用SpringTest2.java进行测试
SpringTest2.java

package cn.itcast.spring.AOP;

import org.junit.Test;

public class SpringTest2 {
    //cglib动态代理：可以基于类（无需实现接口）生成代理对象
    @Test
    public void testCglibProxy(){
        //target目标：
        ProductService target = new ProductService();
        //weave织入，生成proxy代理对象
        //代理工厂对象，注入目标
        CglibProxyFactory cglibProxyFactory = new CglibProxyFactory(target);
        //获取proxy:思考：对象的类型
        //代理对象，其实是目标对象类型的子类型
        ProductService proxy=(ProductService) cglibProxyFactory.getProxyObject();
        //调用代理对象的方法
        proxy.save();
        System.out.println("————————————————————————————————————————");
        proxy.find();
    }
}

第五步：控制台输出结果
在这里插入图片描述

代理知识小结

区别：

  • Jdk代理：基于接口的代理，一定是基于接口，会生成目标对象的接口类型的子对象。
  • Cglib代理：基于类的代理，不需要基于接口，会生成目标对象类型的子对象。

代理知识总结：

  • spring在运行期，生成动态代理对象，不需要特殊的编译器.

  • spring有两种代理方式：
    1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。
    2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

  • 使用该方式时需要注意:
    1.对接口创建代理优于对类创建代理，spring推荐面向接口编程,因为这样会产生更加松耦合的系统，所以spring默认是使用JDK代理。对类代理是让遗留系统或无法实现接口的第三方类库同样可以得到通知，这种方式应该是备用方案。

    2.标记为final的方法不能够被通知。spring是为目标类产生子类。任何需要被通知的方法都被复写，将通知织入。final方法是不允许重写的。

    3.spring只支持方法连接点：不提供属性接入点，spring的观点是属性拦截破坏了封装。
    面向对象的概念是对象自己处理工作，其他对象只能通过方法调用的得到的结果。

提示：

  • Spring AOP 优先对接口进行代理 （使用Jdk动态代理）
  • 如果目标对象没有实现任何接口，才会对类进行代理 （使用cglib动态代理）
zhangsan3333
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
AOP面向切面编程简单介绍与应用
uniquebingb的博客
08-26 406
AOP (Aspect Oriented Programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。OOP （Object Oriented Programming） 面向对象编程。......
Spring的AOP面向切面编程
hanziang1996的博客
01-11 593
一、AOP的概述 AOP是基于反射与动态代理的实现，java有反射的中间层，让AOP的实现更加简单，而C++想实现相比会较为困难。 AOP为：(aspect oriented programming)，面向切面编程。是对OOP的补充，弥补OOP的不足。 作用：在不修改源码的前提下，给项目增加新的公共功能，如：权限，日志，事务（数据库中同时成功或同时失败的操作的集合）。 二、AOP的组成
spring day02——AOP
weixin_44383366的博客
01-26 276
1.AOP面向切面编程的相关概念      1.1什么是AOP ？ AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。 AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（例如性能监视、事务管理、安全检查、缓存、日志记录等）。 【扩展了解】AOP 是 OOP（面向对象编程（Object Oriented Program...
Java中的AOP编程实践与应用场景
技术研究中心
07-05 546
在Java开发中，AOP（Aspect-Oriented Programming，面向切面编程）是一种强大的编程范式，旨在将横切关注点与业务逻辑分离。AOP的核心思想是通过预编译方式和运行时动态代理，实现程序功能的动态切入，提高代码的模块化和可维护性。在Java开发中，Spring框架提供了强大的AOP支持，使得AOP编程变得简单而高效。本文介绍了AOP的基本概念、在Spring中的使用方法及其常见应用场景，希望能够帮助大家更好地理解和应用AOP，提高Java项目的开发效率和代码质量。注解将其标记为切面。
面向切面编程（AOP）的理解
热门推荐
Intlgj的专栏
06-14 6万+
<br />在传统的编写业务逻辑处理代码时，我们通常会习惯性地做几件事情：日志记录、事务控制及权限控制等，然后才是编写核心的业务逻辑处理代码。当代码编写完成回头再看时，不禁发现，扬扬洒洒上百行代码中，真正用于核心业务逻辑处理才那么几行，如图6-4所示。方法复方法，类复类，就这样子带着无可奈何遗憾地度过了多少个春秋。这倒也罢，倘若到了项目的尾声，突然决定在权限控制上需要进行大的变动时，成千上万个方法又得一一"登门拜访"，痛苦"雪上加霜"。 <br />如果能把图6-4中众多方法中的所有共有代码全部抽取出来，放
关于AOP及其在Spring中的应用<转载>
lom
10-17 201
AOP简介 OOP思想对现代编程产生了深远的影响，但在某些方面，OOP也有其不足之处。比如在logging（日志）、transaction（事务）等方面，应用OOP将这些内容封装为对象的行为则会产生大量的代码重复，虽然通过一些设计模式可以减少这种重复，但我们还有更好的解决办法，那就是AOP(Aspect Oriented Programming)。AOP是最近兴起的一种编程思想，它是OOP思想的...
Spring 的面向切面编程（AOP）的使用场景有哪些？
訾博（ZiBo）的博客
11-16 788
AOP 可以用于在方法执行前后切入国际化的逻辑，方便实现多语言支持。AOP 可用于实现权限控制，确保只有授权用户能够执行特定操作。，提高系统性能，而无需在每个方法中手动管理缓存。，而无需在每个方法中都添加日志记录代码。方法中的异常，实现一致的异常处理策略。可以使用 AOP 在方法调用前后进行。，帮助开发人员找出应用程序的。AOP 可以用于记录方法的。
SPRING-AOP面向切面编程
FBDriftz的博客
06-25 175
     面向切面编程即抽取程序的公共方法放在一个类里面(这个类被称为通知)，然后在需要该方法的时候通过AOP将这个公共方法插入进来，既可以节省代码量，又不需要修改源码。        此处以插入log日志为例子演示AOP的插入配置和过程一、JAR包                    spring的四大核心包加aop和aspects包 另外需要2个日志包 1个aop 1个aspect。 一共1...
Spring4AOP 面向切面编程实例之方法拦截
10-13
Spring4AOP 面向切面编程实例之方法拦截实例 一下利用Spring4的最后一个版本Spring4.3.9，实现简单的方法拦截实例。 Eclipse 建立java工程,导入必要的jar包，工程目录如下:
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
Java Spring AOP 面向切面编程的4种实现
最新发布
07-16
Spring AOP (面向切面编程框架): Spring框架内建了支持动态代理的功能，使用@AspectJ注解可以轻松地创建AOP代理。Spring AOP既支持JDK动态代理也支持CGLIB，会根据目标类是否实现了接口选择合适的底层技术。 Guice ...
Springaop原理及各种应用场景
01-27
AOP是AspectOrientedPrograming的简称，面向切面编程。AOP适合于那些具有横切逻辑的应用：如性能监测，访问控制，事务管理、缓存、对象池管理以及日志记录。AOP将这些分散在各个业务逻辑中的代码通过横向切割的方式抽取到一个独立的模块中。AOP 实现的关键就在于AOP框架自动创建的AOP代理，AOP代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP框架提供的命令进行编译，从而在编译阶段就可生成AOP代理类，因此也称为编译
16.2 Spring框架-AOP面向切面编程
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
spring4 AOP 面向切面编程@Aspect
08-10
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点从业务逻辑中分离出来，比如日志记录、事务管理、权限检查等。`@Aspect`是Spring AOP的核心注解，用于定义一个切面。下面我们将详细...
Spring中的面向切面编程
05-06 2万+
Spring中的面向切面编程
SpringAOP 常见应用场景
Zyw907155124的博客
06-08 2087
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
Spring AOP的应用场景
yangyanping20108的博客
04-13 325
Spring AOP @Aspect 定义计算服务类 package com.spring.study.aop.service; public class CalculatorService { public int div(int a, int b) { return a / b; } } 定义LogAspect拦截类 package com.spring.s...
spring aop应用场景
詹Sir的博客
08-31 6812
场景一： 记录日志 场景二： 监控方法运行时间 （监控性能） 场景三： 权限控制 场景四： 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ） 场景五： 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ） 提示：aop本质是动态对方法增强，避免代码入侵，优雅的实现横向扩展，是对oop的补充 ...
AOP面向切面编程的应用
lzwdlut的博客
10-21 1582
前两年看书的时候，了解到了面向切面编程方法(AOP)。对这个技术印象最深刻的特点就是可以实现业务逻辑和权限、异常处理等的分离。正好在做项目的时候，有些场景可以借鉴这个思想，于是在项目中借用开源的.net环境的KingAOP实现了菜单按钮权限控制、上下游节点的状态控制,效果还不错。 AOP介绍 网上查了一些资料，AOP已经发展很长时间，应该是个比较成熟的技术，在java Spring框架中貌似应...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值