IOC和AOP-后端-CSS教程

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主要提供了@***ponent @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 ***.zhy.service.impl;

import ***.zhy.dao.BookDao;
import ***.zhy.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.***ponent;

@***ponent
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 ***.zhy.dao.impl;

import ***.zhy.dao.BookDao;
import org.springframework.stereotype.***ponent;

@***ponent
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="***.zhy.dao.impl.BookDaoImpl"></bean>
    <bean id="bookService1" class="***.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:***ponent-scan base-package="***.zhy"/>
</beans>

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

package ***.zhy.service.impl;

import ***.zhy.dao.BookDao;
import ***.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([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

spring 后端

转载请说明出处内容投诉
CSS教程_站长资源网 » IOC和AOP

唯一

分享到：

一、IOC的理解 1.1 IOC的概念与原理