Spring框架的两大核心（ioc和aop）

一、ioc：控制反转（Inversion of Control）思想

1.1、由spring来负责控制对象的生命周期和对象间的关系（SSM框架中的依赖关系）通过注解扫描的方式（底层使用反射）装入一个

1.2、作用：解耦（入下图）

这就是没使用ioc思想下的关系图（耦合度太高）

1.3、控制反转思想前提 —— 依赖注入（DI）（一般都是set注入）

Dependency Injection，说的是创建对象实例时，同时为这个对象注入它所依赖的属性。相当于把每个bean与bean之间的关系交给容器管理。而这个容器就是spring。
例如我们通常在 Service 层注入它所依赖的 Dao 层的实例；在 Controller层注入 Service层的实例。
DI 给对象属性赋值的过程叫做依赖注入！

spring中采取set注入给对象属性赋值如下

<bean id="p1" class="com.zqs.bean.Person">
	<property name="id" value="001">
	<property name="name" value="赵青松">
	<peoperty hobbly value="打篮球">
</bean>

这里已经实现了控制反转了

1.4、控制反转思想的实现

也就是依赖倒置的思想

依赖倒置前：
eg：（造飞机）：先造螺丝钉-造使用螺丝钉的配件-造使用配件的组件-造使用组件的飞机

飞机上有螺丝钉这一参数，导致后面调用都会传这个参数，直到最后

依赖倒置后
**eg：**先造机身-根据机身造组件-根据组件造配件-根据配件造螺钉

依赖倒置后，只需要造飞机不管后面的参数，最后再改最底层的（螺丝钉）

以上就是依赖倒置的概念（我们调用方法时不需要考虑下一层的是怎么构造的，只需要new 下一层对象，只需要维护最底层即可）

1.5、spring中的控制反转

spring 则是通过 IOC 容器来创建对象，也就是说我们将创建对象的控制权交给了 IOC 容器。我们可以用一句话来概括 IOC：
IOC 让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。

二、aop：面向切面编程思想

2.1、概述：

散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切

AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志打印、事务处理。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

2.2、实现方式

这里就会使用到代理模式（动态代理）

1、JDK代理动态代理： 先创建一个代理类实现一个接口（InvocationHandler），然后调用invoke方法，返回一个结果（真实对象的方法+新加的方法），然后调用Proxy的静态方法Proxy.newProxyInstance（），创建一个代理对象，然后就可以调用方法了；
UserDao ud = (UserDao) Proxy.newProxyInstance(UserDaoImpl.class.getClassLoader(), UserDaoImpl.class.getInterfaces(), handler);
这里得到的代理对象必须要有一个UserDao的接口.

2、CGLib代理： Spring底层用的CGLIB代理！
如果没有最终共同实现的的接口的话就要用到CGLIB代理。

程序运行后给真实对新（目标对象）生成一个子类重写父类方法（父类方法+增强的代码），相当于一个代理对象

具体如下

//真实对象（目标对象）
 * public class UserDaoImpl { 
   

   public int addUser(User u) { 
   
       System.out.println("正在新增user对象数据库:"+u);
       return 1;
   }

   public int deleteUser(int id) { 
   
       System.out.println("正在删除user编号为:"+id);
       return 1;
   }

   public int updateUser(User u) { 
   
       System.out.println("正在更新user对象数据库:"+u);
       return 1;
   }

}```

```java
//拦截类
public class UserMethodInterceptor implements MethodInterceptor{ 
   

Transaction tx;

public UserMethodInterceptor(Transaction tx) { 
   
    this.tx = tx;
}

//拦截的方法
public Object intercept(Object o, Method method, Object[] agrs, MethodProxy methodProxy) throws Throwable { 
   
    tx.openTransaction();
    Object result = methodProxy.invokeSuper(o, agrs);
    tx.commitTransaction();
    return result;
}
}

public class Transaction { 
   

/** * 开启 事务 */
   public void openTransaction(){ 
   
   System.out.println("开启Mysql事务");
   }

/** * 提交 事务 */
   public void commitTransaction(){ 
   
   System.out.println("提交Mysql事务");
   }
   }

@Test
public void test1() throws Exception{ 
   

    // 在指定目录下生成动态代理类
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\classcglib");

    UserMethodInterceptor interceptor=new UserMethodInterceptor(new Transaction());

    Enhancer enhancer=new Enhancer();
    //设置父类是谁，根据父类生成子类
    enhancer.setSuperclass(UserDaoImpl.class);
    //一旦调用代理对象的方法
    enhancer.setCallback(interceptor);
    //生成了一子类 代理类 多态！
    UserDaoImpl ud = (UserDaoImpl)enhancer.create();

    System.out.println("此处的UD是代理对象(目标类的子类)!!!!");

    //com.bruce.dao.impl.UserDaoImpl$$EnhancerByCGLIB$$f9eec3e4@2471cca7
    // com.bruce.dao.impl.UserDaoImpl$$EnhancerByCGLIB$$f9eec3e4
    System.out.println(ud.getClass().toString());

    int count = ud.addUser(new User(1, "老王", "1234", "美女"));
    System.out.println(count);

    System.out.println("--------------------------------------------------------");

    int result = ud.deleteUser(1);
    System.out.println(result);
}

今天的文章Spring的IOC和AOP思想分享到此就结束了，感谢您的阅读。