[Java知识库] Spring:IOC与AOP

2、IOC 底层原理

（1）xml 解析、工厂模式、反射

3、画图讲解 IOC 底层原理

?2.自定义IOC容器

1.需求

1. 创建java项目，导入自定义IOC相关坐标
2. 编写Dao接口和实现类
3. 编写Service接口和实现类
4. 编写测试代码

2.实现

依赖

  <dependencies>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

编写Dao接口和实现类

public interface UserDao {
    public void save();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("保存成功");
    }
}

Service接口和实现类

public interface UserService {
    public  void save();
}

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void save()  {
        userDao = (UserDao) BeanFactory.getBean("userDao");
        userDao.save();
    }

}

beans.xml 文件

<beans>
<!--    bean 表示一个需要创建的对象
        id: 表示该对象的名字
        class：表示该对象的类型
-->


    <bean id="userDao" class="com.qiku.dao.UserDaoImpl"></bean>

</beans>

BeanFactory 工厂类

package com.qiku.utils;

/**
 * 2022/6/23 15:05
 *
 * @author yrc
 * @version MySpring
 */


import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 根据配置文件中的信息 创建对象
 * 并将所有的对象存入一个容器之中
 */
public class BeanFactory {
//声明一个 map 充当 容器作用 ，用于包存所有的对象
public  static Map<String ,Object> ioc=new HashMap<>();

//程序启动时 自动初始化对象
    static {

    try {
        //1 读取配置文件
        InputStream resource =
                BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        //2 解析xml
        SAXReader saxReader = new SAXReader();
        //2.1 通过saxReader 将resource装换为document
        Document document = saxReader.read(resource);
        //3 编写xPath表达式
        String xPath="//bean";
        //4 获取所有的bean标签
        List<Element> nodes = document.selectNodes(xPath);
        System.out.println(nodes);
        //5 遍历 并创建对象 设置到map中
        for (Element e:nodes){
            String id = e.attributeValue("id");
            String className = e.attributeValue("class");
            System.out.println("id= "+id);
            System.out.println("id= "+className);
            Object obj = Class.forName(className).newInstance();
            //将 id 和obj存入ioc容器
            ioc.put(id,obj);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

//提供获取对象的方法
   public static Object getBean(String beanId){
        return ioc.get(beanId);
   }




}

测试类以及结果

?总结：

* 其实升级后的BeanFactory就是一个简单的Spring的IOC容器所具备的功能。

* 之前我们需要一个userDao实例，需要开发者自己手动创建 new UserDao();

* 现在我们需要一个userdao实例，直接从spring的IOC容器获得，对象的创建权交给了spring控制

* 最终目标：代码解耦合解耦合并不是没有关系了只是耦合度降低了

3.Spring相关的API

3.1 图解

?3.2.BeanFactory 接口

4、Spring相关配置文件和操作

4.1 Bean标签基本配置

4.2 Bean标签配置范围

4.3 Bean生命周期配置

4.4 Bean实例化三种方式

4.5 无参构造方法实例化

4.6 工厂静态方法实例化

4.7 工厂普通方法实例化

4.8 Bean依赖注入概述

依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

4.9 有参构造方法注入（一个是userdao? 另一个时 str?? 配置如下）

4.10 set方法注入

4.11 命名空间注入

4.12 set 普通数据类型的注入

4.13 集合数组 map properties 的注入

4.14? 配置文件模块化

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分
配置拆解到其他配置文件中，也就是所谓的配置文件模块化。

4.15 知识小结

5 Dbutils整合

5.1 xml的形式

5.2 注解的形式（无配置文件）

6 Spring整合Junit? 代码和5 的一样

6.1 为什么用 Spring测试

6.2 依赖

6.3 测试

三、AOP

1 AOP概念

2? AOP底层原理（JDK动态代理和CGLIB动态代理）

我们可以将业务代码和事务代码进行拆分，通过动态代理的方式，对业务方法进行事务的增强。这样就不会对业务层产生影响，解决了耦合性的问题啦！

常用的动态代理技术
JDK 代理 : 基于接口的动态代理技术·：利用拦截器（必须实现invocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理，从而实现方法增强

CGLIB代理：基于父类的动态代理技术：动态生成一个要代理的子类，子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截技术拦截所有的父类方法的调用，顺势织入横切逻辑，对方法进行增强

核心配置文件??? jdbc.properties 同上

数据库连接工具类和事务工具类

事务工具类

?2.1 JDK动态代理

2.2 CGLIB动态代理

package com.qiku.proxy;

import com.qiku.service.AccountService;
import com.qiku.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.stereotype.Component;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

@Component
public class CGLIBProxyFactory {

    @Autowired
    private AccountService accountService;
    @Autowired
    private TransactionManager transactionManager;

    public AccountService getAccountServiceProxy(){
        AccountService accountServiceProxy =null;
        /**
         * 参数一 ：目标对象的字节码文件
         * 参数二 ： 动作类 实现增强功能
        *
        * */
        accountServiceProxy= (AccountService) Enhancer.create(AccountService.class,
                new MethodInterceptor() {
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        Object result=null;

                        try {
                            transactionManager.beginTransaction();
                            result=method.invoke(accountService,objects);
                            transactionManager.commit();
                        } catch (Exception e) {
                            e.printStackTrace();
                            transactionManager.rollback();
                        } finally {
                            transactionManager.release();
                        }
                        return result;
                    }
                });
        return  accountServiceProxy;

    }
}

测试? 转账中间添加了int i=5/0? 事务捕捉到异常数据库未发生改变

service实现层代码

dao实现层代码

3.AOP术语

3.1 Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。
在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

4 编写通知类配置核心文件（两种方法一种是直接写poingtcut? 另一种是先定义再用pointcut-ref引入）

5 .AOP 自动代理

6 注解配置AOP详解

6.1 切点表达式

6.2通知类型

6.3 纯注解配置

6 .4 AOP优化转账案例

依然使用前面的转账案例，将两个代理工厂对象直接删除！改为spring的aop思想来实现
xml配置实现