欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

SpringIOC和AOP理解之深入浅出（建议收藏）

程序员文章站 2022-03-29 17:18:57
Spring框架介绍概念：Spring是一个开源的框架，并且是一个轻量级的java开发框架前身：interface21是他的前身Spring理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的主流技术框架优点：方便解耦，简化开发 （高内聚低耦合）Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理spring工厂是用于生成beanAOP编程的支持Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能声明式事务的支...

Spring框架介绍

概念：Spring是一个开源的框架，并且是一个轻量级的java开发框架
前身：interface21是他的前身
Spring理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的主流技术框架
优点：

  • 方便解耦，简化开发 （高内聚低耦合）
    Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理
    spring工厂是用于生成bean
  • AOP编程的支持
    Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
  • 声明式事务的支持
    只需要通过配置就可以完成对事务的管理，而无需手动编程
  • 方便程序的测试
    Spring对Junit4支持，可以通过注解方便的测试Spring程序
  • 方便集成各种优秀框架
    Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
  • 降低JavaEE API的使用难度
    Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
  • Spring是一个开源的免费框架（容器）
  • Spring是一个轻量级的，非入侵式的框架
  • Spring支持事务的处理，对框架的整合的支持
  • 总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架

控制反转（IOC容器）

IOC原型：
之前： userDao 接口 userDaoImpl实现类 userService业务接口 userServiceImpl业务实现类
缺点： 代码量大，修改成本高，若是多个业务需要频繁修改对象
解决： 在userServiceImpl使用set注入来被动创建对象
SpringIOC和AOP理解之深入浅出（建议收藏）
SpringIOC和AOP理解之深入浅出（建议收藏）
区别： 之前是程序主动创建对象，是程序员来控制的。现在使用set注入后不在具有主动性，变成了被动接收对象，不用再修改业务模块的代码
优点： 这种思想本质上的解决了问题，程序员不需要再管理对象的创建，系统的耦合性大大降低，更加专注于业务的实现上。

IOC本质：

1.控制反转loC(Inversion of Control),是一种设计思想，DI(依赖注入)是实现IoC的一种方法
2.没有loC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，
3.控制反转是一种通过描述(XML或注解)并通过第3方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)

接下来由一个小案例让大家感受一下IOC

案例：HelloSpring
两个Dao层实现类，一个业务层实现类由spring创建并统一管理
SpringIOC和AOP理解之深入浅出（建议收藏）
业务层实现类对象含有Dao实现类的对象参数SpringIOC和AOP理解之深入浅出（建议收藏）
由spring创建并统一管理后，直接操作xml文件即可修改获取的对象，对象统一管理创建，无须在硬代码中频繁创建对象，耦合性极大降低。
SpringIOC和AOP理解之深入浅出（建议收藏）
总结：
●hello对象是由谁创建的？
hello对象是由Spring创建的
●Hello 对象的属性是怎么设置的?
hello对象的属性是由Spring容器设置的，
这个过程就叫控制反转:
控制: 谁来控制对象的创建？传统应用程序的对象是由程序本身控制创建的，使用Spring后,对象是由Spring来创建
反转: 程序本身不创建对象,而变成被动的接收对象.
依赖注入: 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收.
OK,到了现在,我们彻底不用再程序中去改动了,要实现不同的操作,只需要在xm|配置文件中进行修改
所谓的IoC, 一句话搞定对象由Spring来创建，管理，装配!

注意： 在配置文件加载的时候，也就使用getBean的时候，容器中的对象就已经初始化了！

接下来讲解一下IOC的几种注入方式

Bean的配置

1.关于bean的配置：
id : bean的唯一标识符，也就是相当于对象的引用
class : bean对象所对应的类:包名+类型
name : 也是别名,而且name可以同时取多个别名
例子：<bean id="grade" class="com.auc.bean.Grade" name="grade2"></bean>
2.关于import的配置：
import一般用于团队开发使用，他可以将多个配置文件，导入合并为一个；

IOC------依赖注入

  1. 普通值注入
<property name="name" value="刘大帅"/>
  1. bean注入
<property name="hello" ref="hello"></property>
  1. 数组注入
<property name="books">
    <array>
        <value>西游记</value>
        <value>水浒传</value>
        <value>红楼梦</value>
    </array>
</property>
  1. list集合注入
<property name="hobbys">
    <list>
        <value>玩游戏</value>
        <value>听音乐</value>
    </list>
</property>
  1. list集合注入
<property name="hobbys">
    <list>
        <value>玩游戏</value>
        <value>听音乐</value>
    </list>
</property>
  1. map集合注入
<property name="card">
    <map>
        <entry key="身份证" value="123123"></entry>
        <entry key="手机哈" value="12311"></entry>
    </map>
</property>
  1. properties配置文件注入
 <property name="info">
            <props>
                <prop key="学号">JX200201</prop>
            </props>
 </property>

IOC------拓展注入

  1. p命名空间注入，可以直接注入属性的值: property
 <bean id="user2" class="com. kuang . pojo.User" p:name=" 秦疆" p:age="18"/>
  1. c命名空间注入，通过构造器注入: construct-args
 <bean id="user2" class="com. kuang . pojo.User" c:age="18" c:name="伟伟"/>

Bean的作用域
1.单例模式(Spring默认机制)-(singleton)

<bean id="user2" class="com. kuang. pojo.User" c:age="18" c:name="伟伟" scope="singleton"/>

2.原型模式:每次从容器中get的时候，都会产生一新对象!(prototype)

 <bean id="accountservice" class="com. something. DefaultAccountservice" scope="prototype"/>

3.其余的request. session. application. 这些个只能在web开发中使用到!

SpringIOC和AOP理解之深入浅出（建议收藏）

IOC------Bean的自动装配

1.ByName自动装配：byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid

<bean id="people" class="com. kuang. pojo. People" autowire="byName">
	<property name="name" Value=" 小伟伟呀"/>
</bean>

2.ByType自动装配： byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean

<bean class="com. kuang. pojo.Cat"/>
<bean class="com. kuang. pojo.Cat"/> 
<bean id="peop1e" class="com. kuang. pojo. People" autowi re="byType">
    <property name="name" value="小伟伟呀"/>
</bean>

小结:
●byname的时候，需要保证所有bean的id唯一， 并且这个bean需要和自动注入的属性的set方法的值一致!
●bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注 入的属性的类型一致!

IOC------注解实现自动装配

要使用注解须知:

  1. 导入约束: context约束
  2. 配置注解的支持: context annotation-config. [重要]

方式

  1. 指定要主描的包，这个包下的注解就会生效
<context:component-scan base-package="com.kuang.pojo" /> <context:annotation-config/>
  1. @component
@Component 组件等价于<bean id= "user" class= "com. kuang. pojo. User"/>
@Component:组件放在类上，说明这个类被Spring管理了，就是bean；
  1. @Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层;
dao [@Repository]
service [@Service]
servlet [ @Controller]

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，进行装配
作用域注解： @Scope("")

4. @Autowired
直接在属性.上使用即可!也可以在set方式上使用!
使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC(Spring) 容器

注意：
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解[@Autowired] 完成的时候、我们可以使用@Qualifier(value=“xx”)去配置@Autowired的使用，指定一个唯一的bean对象注入!

pub1ic class People {
    @Autowired
    @qualifier(value="cat111")
    private cat cat;
     @Autowired
     @qualifier(value=" dog222")
     private Dog dog;
}

总结：
@Resource和@ Autowired的区别:
●都是用来自动装配的，都可以放在属性字段上
●@ Autowired通过byType的方式实现，而且必须要求这个对象存在! [常用]
●@ Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现! 如果两个都找不到的情况下，就报错!

xml与注解：
xml 更加万能,适用于任何场合! 维护简单方便；
注解不是自己类使用不了，维护相对复杂。
xml与注解最佳实践：
xml用来管理bean；
注解只负责完成属性的注入；
我们在使用的过程中，只需要注意一个问题: 必须让注解生效,就需要开启注解的支持

SpringAOP（面向切面编程）

官方概念： AOP，即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系。
例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

个人理解：
1.首先，AOP是OOP面向对象开发的扩展补充：面向切面编程。因为正常开发流程中为OOP纵向开发，由dao-service-servlet-web，当我们需要对其中一个模块进行添加其他额外功能时，此时为横向开发，已经不适用于使用OOP思想开发。为了不修改原有代码，减小耦合性，便使用到了AOP横向开发。他将需要扩展的定义为一个切面，对其进行添加想要的功能。
2.在实现面向切面编程中，使用了代理模式，代理模式是将要扩展的功能交给代理对象来操作。
首先要使用反射包中的InvocationHandler：用来执行代理对象的方法 Proxy：用来获取代理实例
（而Spring对AOP提供了支持，Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理）

SpringIOC和AOP理解之深入浅出（建议收藏）

Spring对AOP的支持

Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。
Spring创建代理的规则为：
1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了
2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB
AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：

  1. 定义普通业务组件
  2. 定义切入点，一个切入点可能横切多个业务组件
  3. 定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。

Aop在Spring中的作用

提供声明式事务;允许用户自定义切面
横切关注点: 跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事务等等
切面(ASPECT) : 横切关注点被模块化的特殊对象。即，它是一个类。
通知(Advice) : 切面必须要完成的工作。即,它是类中的一个方法
目标(Target) : 被通知对象
代理(Proxy) : 向目标对象应用通知之后创建的对象
切入点(PointCut) : 切面通知执行的"地点"的定义。
连接点(JointPoint) : 与切入点匹配的执行点

SpringIOC和AOP理解之深入浅出（建议收藏）
Aop实现方式

注意：使用AOP织入，需要导入依赖包

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.4</version>
</dependency>

方式一：使用Spring API接口

<--方式一:使用原生:Spring API接口1-->
<!--配置aop:需要导入aop的约束-->
<aop:config>
     <!--切入点:expression:表达式execution( 要执行的位置! *****-->
<aop:pointcut id=" pointcut" expression="execution(* com.kuang.service.UserServiceImp1.*(..))"/>
     <!--执行环绕增加! -->
<aop:advisor advice-ref="log" pointcut-ref=" pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>

方式二：自定义来实现AOP

自定义的类：
public class DiyPointCut {
    public void before( ){
        System. out . print1n("=======方法执行前========");
    }
    public void |after(){
        System. out . print1n("=======方法执行后========");
    }
}

<!--自定义类-->
<bean id="diy" class="com. kuang. diy.DiyPointCut"/>
<aop :config>
        <!--自定义切面，ref 要引用的类-->
<aop:aspect ref="diy">
        <!--切入点-->
<aop:pointcut id=" point" expression=" execution(*com.kuang.service.UserServiceImp1.*(..))"/>
        <!--通知-->
<aop: before method= "before" pointcut-ref="point"/>
<aop:after method="after" pointcut -ref="point"/>
</aop:aspect>
</aop : config>

方式三：使用注解实现

@Aspect //标注这个类是一个 切面
    public class AnnotationPointCut {
        @Before("execution(* com. kuang. service.UserServiceImp1.*(..))")
        public void before(){
            System. out. println("=====方法执行前=====");
        }
        @After("execution(* com. kuang. service . UserServiceImp1.*(..))")
        public void after(){
            System. out. print1n("=====方法执行后=====");
        }
        //在环绕增强中，我们可以给定一个参数， 代表我们要获取处理切入的点;:
        @Around("execution(* com. kuang. service . UserServiceImp1. *(..))")
        public void around(ProceedingJoinPoint jp) throws Throwable {
            System.out.print1n("环绕前");
            Signature signature = jp.getSignature();//获得签名
            System.out.println("signature :"+signature);
            object proceed = jp.proceed(); //执行方法
            System.out.print1n("环绕后");
            System.out.println( proceed);
}

<bean id=" annotationPointCut" class=" com. kuang. diy . AnnotationPointCut"/>
<!--开启注解支持! JDK(默认 proxy-target-class= "false")  cglib (proxy-target-class="true") -->
<aop: aspectj-autoproxy  proxy-target-class= "true"/>

代理模式
优点:
●可以使真实角色的操作更加纯粹 不用去关注一些公共的业务
●公共也就就交给代理角色!实现了业务的分工
●公共业务发生扩展的时候，方便集中管理
缺点:
●一个真实角色就会产生一个代理角色;代码量会翻倍 ，开发效率会变低

AOP面向切面编程-----代理模式

  1. 静态代理
    角色分析：
    抽象角色：一般会使用接口或者抽象类来解决；
    真实角色：被代理的角色；
    代理角色：代理真实角色，代理真实角色后,我们一般会做一些附属操作；
    客户：访问代理对象的人。
  2. 动态代理
    动态代理和静态代理角色一样；
    动态代理的代理类 是动态生成的，不是我们直接写好的；
    动态代理分为两大类：
    基于接口：JDK动态代理；
    基于类：cglib；
    java字节码实现：javasist。

以下是AOP理解小案例

//动态代理的写法
//等我们会用这个类，自动生成代理类!
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;
    public void setRent(Rent rent) {
        this.rent = rent;
        }
    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }
    //处理代理实例，并返回结果
    public object invoke(object proxy, Method method, object[] args) throws Throwable {|
    //动态代理的本质，就是使用反射机制实现!
            Object result =method.invoke(rent, args);
            seeHouse(); 
            return result;
            fare();|
    }
    public void seeHouse(){
        System. out . print1n("中介带看房子");
    }
    public void fare(){
        System.out.print1n("收中介费");
    }
}

//主函数调用
public class Client {
public static void main(String[] args) {
        //真实角色
        Host host = new Host( ) ;
        //代理角色:现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHand1er() ;
        //通过调用程序处理角色来处理我们要调用的接口对象!
        pih. setRent(host);
       Rent proxy = (Rent) pih. getProxy();
       proxy .rent();
    }
}

以上是我个人对spring AOP IOC的的个人理解 ， 希望大家多多探讨一起学习交流~

个人推荐优秀文章：

文章1

文章2

本文地址：https://blog.csdn.net/weixin_45105261/article/details/112004029

相关标签： spring java 设计模式 aop ioc

上一篇： [itext] java生成pdf

下一篇： 同clientId多端登录下jwt+auth2+security使用RedisTokenStore刷新token后长token不可用：Invalid refresh token问题

推荐阅读