Spring04

做梦追仙

已于 2022-12-27 18:27:56 修改

阅读量721

点赞数

分类专栏： Spring 文章标签： java spring 缓存

于 2022-12-26 14:14:22 首次发布

本文链接：https://blog.csdn.net/weixin_44251806/article/details/128443832

版权

Spring 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

Spring AOP

AOP用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。

AOP的引入

业务需求：完成用户功能的处理代码
系统需求：日志，安全，事务等
如果把系统需求加入到处理业务需求的类中，那么业务类就会变得很复杂和零乱。甚至可能会喧宾夺主，而且以后要变更系统需求的时候，将给软件带来很大的维护量

日志功能

代码混乱：越来越多的非业务需求(日志和验证等)加入后,原有的业务方法急剧膨胀.每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点
代码分散：以日志需求为例,只是为了满足这个单一需求,就不得不在多个模块（方法）里多次重复相同的日志代码.如果日志需求发生变化,必须修改所有模块

核心业务功能（例如登录）横切系统功能（例如记录日志）
1、继承=Java中的单根继承
2、工具类=耦合
3、代理模式

代理模式

在代理模式Proxy Pattern中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上

Spring AOP使用的动态代理，属于运行时增强。所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。

优点

能够协调调用者和被调用者，在一定程度上降低了系统的耦合度
客户端可以针对抽象类进行编程，增加和更换代理类无须修改源代码，符合开闭原则，系统具有较好的灵活性和可扩展性

缺点

由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢
实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

注意事项

和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口
和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

代理模式

代理模式一般可以分为静态代理和动态代理两种

静态代理

代理代码是由自己去编写固定的代码，缺点很明显，静态代理只能服务于一种类型的对象，不利于业务的扩展

interface 接口{}
class 具体实现 implements 接口{}
class 代理实现 implements 接口{
    private 接口 被代理对象;
}

动态代理

它是用反射机制动态的生成代理的对象，不需要知道谁代理谁

动态代理具体实现有2种方式：JDK动态代理和CGLib动态代理
JDK动态代理是依靠反射机制实现的，且面向接口
InvocationHandler接口，未来调用代理对象的任何方法实际上都是在调用InvocationHandler接口中的方法
Proxy类用于生成代理对象，代理对象没有具体的实现类

代理模式总结

代理模式一般可以分为静态代理和动态代理两种
静态代理，代理代码是由自己去编写固定的代码，缺点很明显，静态代理只能服务于一种类型的对象，不利于业务的扩展
动态代理，它是用反射机制动态的生成代理的对象，不需要知道谁代理谁

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理,在不修改源代码的情况下给程序增加动态控制功能的一种技术

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码，实际上是OOP的一种补充，不存在谁体态谁的问题
经典应用：事务管理、性能监视、安全检查、缓存、日志等

登录处理流程
Servlet–>Service–>DAO -->Database
Filter
filterChain.doFilter(request,response);
Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
- 代理模式——默认使用的是JDK的动态代理，同时也可以支持CGLib的动态代理
- JDK的动态代理要求必须有对应的接口，但是CGLib的代理不需要接口
AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩
展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

分散关注的思路

将通用需求功能从不相关类之中分离出来
能够使得很多类共享一个行为，一旦行为发生变化，不必修改很多类，只要修改这个行为就可以
AOP就是这种实现分散关注的编程方法，它将“关注”封装在“方面”中
具体应用中Filter、Interceptor等都是AOP的实现

AOP实现原理

spring的aop底层将采用代理机制进行实现
SpringAOP的基本原理就是动态代理机制，将AOP编程的代价降到最低
- 接口 + 实现类：spring采用jdk的动态代理Proxy
- 没有接口只有实现类：spring采用CGlib字节码增强

面试================================================

JDK动态代理具体实现原理：

通过实现InvocationHandler接口创建自己的调用处理器；
通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理；
通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；
通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；

public class 回调方法 implements InvocationHandler {
    private 歌星 target;
    public 回调方法(歌星 target){
        this.target=target;
    }
    @Override
    //调用代理对象的任何方法时，实际上都是这姓invoke这个方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("签订演艺合同....");
        Object res=method.invoke(this.target,args);  //调用具体被代理对象中的方法
        System.out.println("收钱收钱~~~");
        return res;
    }
}

//反射包中的Proxy类提供了静态方法用于创建对应的代理对象.参数1是对应的类加载器，参数2为Class[]类型，指定代理的接口，参数3为InvocationHandler,是调用代理对象中的方法时的回调处理歌星 proxy= (歌星) Proxy.newProxyInstance(歌星.class.getClassLoader(),new Class[]{歌星.class},new 回调方法(obj));proxy.唱歌(); — InvocationHandler中的invoke

JDK动态代理是面向接口的代理模式，如果被代理目标没有接口那么Spring也无能为力，Spring通过Java的反射机制生产被代理接口的新的匿名实现类，重写了其中AOP的增强方法。

CGLib动态代理

CGLib是一个强大、高性能的Code生产类库，可以实现运行期动态扩展java类，Spring在运行期间通过CGlib继承要被动态代理的类，重写父类的方法，实现AOP面向切面编程。

两者对比

JDK动态代理是面向接口的。
CGLib动态代理是通过字节码底层继承要代理类来实现（如果被代理类被final关键字所修饰，那么抱歉会失败）。

使用注意事项

如果要被代理的对象是个实现类，那么Spring会使用JDK动态代理来完成操作（Spirng默认采用JDK动态代理实现机制）；
如果要被代理的对象不是个实现类那么Spring会强制使用CGLib来实现动态代理。

教科书答案

CGLib所创建的动态代理对象在实际运行时候的性能要比JDK动态代理高不少，有研究表明，大概要高10倍；
但是CGLib在创建对象的时候所花费的时间却比JDK动态代理要多很多，有研究表明，大概有8倍的差距；
因此，对于singleton的代理对象或者具有实例池的代理，因为无需频繁的创建代理对象，所以比较适合采用CGLib动态代理，反正，则比较适用JDK动态代理。经过多次试验，JDK动态代理的运行速度已经逐渐提高了，在低版本的时候，运行的性能可能不如CGLib【2倍】，但是在1.8版本中运行多次，基本都可以得到一致的测试结果，那就是JDK动态代理已经比CGLib动态代理快了[大致2倍]！

AOP术语

Joinpoint连接点：程序执行过程中的某个特定的点
Advice通知：在某个特定的Joinpoint上切面执行的动作
Aspect切面：横切多个对象的关注点的模块化
Pointcut切入点：符合某种规则的连接点
AOP代理：AOP框架创建的对象，用来代理我们的目标对象

使用Spring框架的AOP

1、添加依赖 spring-aop spring-aspects和IoC容器依赖spring-context-support
2、业务接口

public interface 歌星 {
    public void 唱歌();
}

3、添加对应的业务实现

public class 刘德华 implements 歌星{
    @Override
    public void 唱歌() {
        System.out.println("冷冷的冰雨冷松的拍~~~~");
    }
}

4、定义前置处理，需要在具体的业务逻辑处理之前执行的逻辑

public class 前置处理 implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("所调用的方法:"+method);
        if(args!=null && args.length>0)
            System.out.println("调用方法的参数:"+args);
        else
            System.out.println("方法没有参数");
        System.out.println("目标对象:"+target);
        System.out.println("签订演艺合同-----");
    }
}

5、在IoC容器中申明

    <!--被代理对象 -->
    <bean id="gexing" class="com.yan1.aop.刘德华"/>
    <!-- 调用代理对象方法时的前置处理 -->
    <bean id="lanjie" class="com.yan1.aop.前置处理"/>
    <!-- 用于生成代理对象，未来调用时不是直接使用目标对象，而是使用代理对象  -->
    <bean id="daili" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces"> <!--代理接口 -->
            <value>com.yan1.aop.歌星</value>
        </property>
        <property name="interceptorNames"> <!-- 拦截器 -->
            <value>lanjie</value>
        </property>
        <property name="target" ref="gexing"/> <!-- 被代理对象 -->
    </bean>