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

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注入来被动创建对象


区别： 之前是程序主动创建对象，是程序员来控制的。现在使用set注入后不在具有主动性，变成了被动接收对象，不用再修改业务模块的代码
优点： 这种思想本质上的解决了问题，程序员不需要再管理对象的创建，系统的耦合性大大降低，更加专注于业务的实现上。

IOC本质：

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

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

案例：HelloSpring
两个Dao层实现类，一个业务层实现类由spring创建并统一管理

业务层实现类对象含有Dao实现类的对象参数
由spring创建并统一管理后，直接操作xml文件即可修改获取的对象，对象统一管理创建，无须在硬代码中频繁创建对象，耦合性极大降低。

总结：
●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="刘大帅"/>

2. bean注入

<property name="hello" ref="hello"></property>

3. 数组注入

<property name="books">
    <array>
        <value>西游记</value>
        <value>水浒传</value>
        <value>红楼梦</value>
    </array>
</property>

4. list集合注入

<property name="hobbys">
    <list>
        <value>玩游戏</value>
        <value>听音乐</value>
    </list>
</property>

4. list集合注入

<property name="hobbys">
    <list>
        <value>玩游戏</value>
        <value>听音乐</value>
    </list>
</property>

5. map集合注入

<property name="card">
    <map>
        <entry key="身份证" value="123123"></entry>
        <entry key="手机哈" value="12311"></entry>
    </map>
</property>

6. 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"/>

2. 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开发中使用到!

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/>

2. @component

@Component 组件等价于<bean id= "user" class= "com. kuang. pojo. User"/>
@Component:组件放在类上，说明这个类被Spring管理了，就是bean；

3. @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容器负责管理）

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) : 与切入点匹配的执行点

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