Spring框架的两个重要概念IOC 和 AOP

背景：Spring框架，是项目管理框架，它主要是为javaEE开发提供更好的解决方案;

定义：Spring ,是IOC容器.

Spring两大重量级概念：控制反转 IOC  Inverse Of  Control  和  面向切面编程 AOP   Aspect  Oriented  Programming

1.控制反转

    定义：控制反转，反转属性的赋值权,将属性的赋值，从原来代码中直接赋值，反转到配置文件中，通过配置，进而满足双方的依赖关系；

    目的：将原来具有依赖关系的双方，耦合打散，使的整个项目中组件之间的，既可以正常协作，又关系松散，使得整个项目更加，便于维护，使得系统更加稳健；

    实现手段：在配置文件中为bean 的属性进行赋值，也就是所谓的依赖注入 Dependency Injection;

   依赖注入的方式一般三种：

1.借助set方法为属性进行赋值

基本属性：

       <bean  id="唯一标识"   class="全限定名.类名">

<!--基本属性-->

<property name="name"  value="tom"></property>

<!--对象类型-->

<property name="user"   ref="userOne"/>

                <!--数组或者集合-->

                 <property  name="nameList">

<list>

<value>true</value>

<value>jack</value>

 <value>32</value>

</list>

</property>

<!--map-->

<property  name="myMap">

<map>

<entry  key="name"  value="jim"></entry>

<entry  key="age"  value="23"></entry>

</map>

</property>

<!--properties-->

<property name="props">

<props>

<prop key="url">jdbc:orace</prop>

<prop key=“name”>root<prop>

</props>

</property>

       </bean>

2.构造注入，通过构造方法为属性赋值

       <bean id="constructor"   class="......">

<constructor-arg  name="name"   value="b"></constructor-arg>.

<constructor-arg  name="age"   value="23"></constructor-arg>.

       </bean>  

构造注入，是高内聚的体现，使用于对象在创建时候就赋值，且后续不允许修改

3.自动注入

    自动注入分两种，一种按类型注入，一种按名称注入。

 按类型注入，就是将IOC工程中，与此组件同类型的组件注入给此组件，如果工厂中存在多个同类的组件，则会抛出异常；

 按名称注入，就是将组件属性同名的组件注入给此组件。

扩展：

1.bean的声明周期是怎么样的？

工厂中的bean，工厂中的单例bean，会随着工厂的启动而创建，非单例bean,会在每次使用的时候，才会创建。

工厂中的bean,是在工厂关闭的时候，销毁。

因此，bean的整个声明历程，构造--set--init--销毁

2.bean的生成原理：反射——空参构造，例外，如果是使用构造注入，则选用指定的构造方法；

3.bean的销毁方法和bean的初始化方法

<bean  id=""   class=""    destroy-method="自定义销毁方法"        >  

</bean>

          <bean  id=""   class=""    destroy-method="自定义初始化方法"        >  

</bean>

4.bean的创建模式

<bean  id=""   class=""      scope="singleton"    >  单例模式

</bean>

          <bean  id=""   class=""   scope="prototype"       >  非单例模式

</bean>

5.复杂对象的创建；

5.1定制FactoryBean 在其中定制复杂对象的创建流程

public class TestFactory implements FactoryBean<SessionFactory>{
/**
* 主体逻辑 用于定制复杂对象的生产流程
*/ 
@Override
public SessionFactory getObject() throws Exception {
Configuration cfg=new Configuration().configure();
return cfg.buildSessionFactory();
}
/**
* 返回类对象
*/
@Override
public Class getObjectType() {
return SessionFactory.class;
}
/**
* 设置复杂对象的创建模式：单例/非单例
* return true;单例
* return false;非单例
*/
@Override
public boolean isSingleton() {
return true;
}
}

5.2 配置

<!--声明复杂对象-->

<bean id="" class="">

</bean>

5.3使用时，从工厂中获得bean,如果此bean是一个FactoryBean,则返回的不是该bean本身的对象，而是需要调用其getObject（）,得到返回值给用户

2、AOP面向切面编程

背景：在日常业务层中，有两个逻辑：额外功能 和 核心业务，稳定的核心业务和不稳定的额外功能经常耦合在一起， 在多个业务功能，额外功能也会出现大量的冗余。

面向切面编程本质是使用代理模式，代理类的方式，实现核心业务功能和额外功能的灵活组装；

Aop定义：,就是通过adivce的介入，将核心业务的额外功能抽取出来，定制为单独组件，使得业务层中，核心业务和额外功能的耦合被打散，且消除额外功能的耦合。

代理最终解决了耦合和冗余问题；

代理分静态代理，动态代理；

动态代理的生成原理：反射
  生成机制：
    *JDK代理机制：通过实现接口的方式，约束代理和目标有同样的功能实现。
*CGLIB代理机制：通过继承目标的方式，约束代理和目标有同样的功能实现。
*spring会判断目标中是否有接口实现，如果有则使用jdk，否则使用cglib