IOC和AOP

一、IOC的理解

1.1 IOC的概念与原理

    IOC，即**控制反转**，把对象的创建、初始化、销毁交给 Spring 来管理，而不是由开发者控制，实现控制反转。IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂（BeanFactory 接口）。IOC的原理是基于xml解析、工厂设计模式、反射实现的。**使用IOC可以降低代码的耦合度**。

1.2 Spring 提供 IOC 容器实现两种方式

（1）BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用。
在加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
（2）ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人
员进行使用。在加载配置文件时候就会把在配置文件对象进行创建

1.3 IOC 操作 Bean 管理

     IOC操作Bean管理有两种形式，一种是基于xml方式，另一种是基于注解方式。
     基于**xml方式**的Bean管理，Spring主要提供了<bean><property>等标签。
     基于**注解方式**的Bean管理，Spring主要提供了@Component  @Service  @Controller   @Repository等注解。

IOC入门案例

*1.创建项目，导入spring的jar*包

**2.**按照如下目录结构创建接口及其实现类，做好准备工作

servlet****层

public class BookServlet {
BookService bookService;
@Test
public void add() {
System.out.println("BookServlet...add");
bookService.save();
}
}

*service***层 **

（xml方式）

//接口
public interface BookService {
void save();
}
//实现类
public class BookServiceImpl implements BookService {
private BookDao bookDao;
@Override
public void save() {
System.out.println("BookServiceImpl...save");
bookDao.insert();
}
}

（注解方式）

package com.zhy.service.impl;

import com.zhy.dao.BookDao;
import com.zhy.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BookServiceImpl implements BookService {
    @Autowired
    BookDao bookDao;
    @Override
    public void save() {
        System.out.println("BookServiceImpl........save");
        bookDao.insert();

    }
}

dao****层

（xml方式）

//接口
public interface BookDao {
public void insert();
}
//实现类
public class BookDaoImpl implements BookDao {
@Override
public void insert() {
System.out.println("BookDaoImpl...save");
}
}

（注解方式）

package com.zhy.dao.impl;

import com.zhy.dao.BookDao;
import org.springframework.stereotype.Component;

@Component
public class BookDaoImpl implements BookDao {
    @Override
    public void insert() {
        System.out.println("BookDaoImpl......insert");
    }
}

此时项目无法运行，因为没有做依赖对象的注入

*3.使用spring完成IOC的配置和DI*依赖注入

*1）创建spring***的核心配置文件 **

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--把所有对象创建到spring的IOC容器中，并起上名字
 id：表示给对象起名字
 class：类的全类名
 -->
    <bean id="bookDao" class="com.zhy.dao.impl.BookDaoImpl"></bean>
    <bean id="bookService1" class="com.zhy.service.impl.BookServiceImpl">
        <!--spring的依赖注入：property表示BookServiceImpl的属性，常规属性使用value赋值，
        类型属性使用ref引用-->
        <property name="name" value="张三"/>
        <property name="bookDao" ref="bookDao"/>
    </bean>

</beans>

bean标签表示把对应class的对象创建到IOC容器中，如果当前对象有依赖的其他对象，那么可以

通过property对依赖的对象使用ref引用容器中已经注册过的对象。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 让系统去扫描注解 -->
    <context:component-scan base-package="com.zhy"/>
</beans>

注意：BookServiceImpl需要给bookDao属性设置setter方法，框架才能自动注入

package com.zhy.service.impl;

import com.zhy.dao.BookDao;
import com.zhy.service.BookService;

public class BookServiceImpl implements BookService {

    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    String name;
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void save() {
        System.out.println("BookServiceImpl......save"+name);
        bookDao.insert();
    }

    public void fun() {
        System.out.println("BookServiceImpl......fun");
    }

}

*2）在servlet***中进行测试 **

1.首先获取IOC的容器；

2.从容器中获取bookService对象；

3.执行方法：servlet执行---service执行，由于spring完成了依赖注入------dao层执行

public class BookServlet {
BookService bookService;
@Test
public void add() {
System.out.println("BookServlet...add");
//1.获得IOC容器
ClassPathXmlApplicationContext context=new
ClassPathXmlApplicationContext("spring.xml");
//2.根据名字从容器中获取对象
bookService= (BookService) context.getBean("bookService");
bookService.save();
}
}

二、AOP的理解

2.1 AOP的概念

（1）AOP（面向切面编程），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得
业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗来说，就是不通过修改源代码方式，在主干功能里面添加新功能。

2.2 AOP的底层原理

AOP底层是使用动态代理来实现的，这里有两种情况的动态代理：

① 有接口的情况，使用 JDK 动态代理
即创建接口实现类代理对象，增强类的方法。
② 没有接口的情况，使用 CGLIB 动态代理
即创建子类的代理对象，增强类的方法。

2.3 AOP的专业术语

① 连接点：类里面可以被增强的方法，这些方法被称为连接点。

② 切入点：实际被真正增强的方法，称为切入点。

③ 通知（增强）：（1）实际增强的逻辑部分称为通知（增强）

                          （2）通知有多种类型：前置通知、后置通知、环绕通知、异常通知、最终通知

④ 切面：把通知应用到切入点的过程，称为切面。

2.4 AOP的操作

① Spring 框架一般都是基于 AspectJ 实现 AOP 操作 ，AspectJ 不是 Spring 的组成部分，独立于 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作。
② 基于 AspectJ 实现 AOP 操作
（1）基于 xml 配置文件实现
（2）基于注解方式实现
③ 在项目中引入 AOP 的相关依赖，主要有：aop、cglib、aspectj、aopalliance等依赖。
④ 切入点表达式
（1）切入点表达式作用：明确对哪个类里面的哪个方法进行增强。
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] 方法名称 )