Spring框架学习笔记（四）：手动实现 Spring 底层机制(初始化 IOC容器+依赖注入+BeanPostProcessor 机制+AOP)

1 Spring 整体架构示意图

2 阶段 1 -- 编写自己的 Spring 容器，实现多层扫描包

编写自己的 Spring 容器，实现多层扫描包，排除包下不是bean的，得到 bean 对象，放入到临时ioc容器中

代码实现：

（1）准备代码创建两个注解ComponentScan.java、Component.java，ComponentScan.java注解用于指定需要扫描的包，Component.java用于标识bean，即加了该注解的类就是bean，没加就不是

package com.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
    //表示ComponentScan注解可以传入一个value属性,指定要扫描的包
    String value() default "";
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    //表示Component注解可以传入一个value属性,指定id值
    String value() default "";
}

（2）创建配置类 SpringConfigXml 用来替代xml文件，创建 MonsterService.java、MonsterDao.java用来作为需要放入容器中的bean

import com.spring.annotation.ComponentScan;

/**
 * 这是一个配置类，用来替代xml文件
 */
@ComponentScan(value = "com.spring")
public class SpringConfigXml {
}

import com.spring.annotation.Component;

@Component(value = "monsterDao")
public class MonsterDao {
}

import com.spring.annotation.Component;

/**
 * MonsterService 是一个 Service
 * 1.如果指定value，注入容器时，以指定的value值为准
 * 2.如果没用指定value，则默认为类名首字母小写
 */
@Component(value = "monsterService")//把MonsterService注入到我们自己的spring容器中
public class MonsterService {
}

（3）创建 SpringApplicationContext.java 充当容器类

import com.spring.annotation.Component;
import com.spring.annotation.ComponentScan;
import java.io.File;
import java.net.URL;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 该类作用类似于Spring原生ioc容器
 */
@SuppressWarnings("all")
public class SpringApplicationContext {
    //拿到配置类.class文件
    private Class configClass;
    //ioc存放的就是通过反射创建的对象
    private final ConcurrentHashMap<String, Object> ioc = new ConcurrentHashMap<>();

    //构造器
    public SpringApplicationContext(Class configClass) {
        this.configClass = configClass;
//        System.out.println("this.configClass=" + this.configClass);
        //获取要扫描的包
        //1.先获取到ComponentScan注解
        ComponentScan componentScan = (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
        //2.获取到注解的value值
        String path = componentScan.value();
//        System.out.println("要扫描的包= " + path);

        //得到要扫描的包下的所有class文件(在target目录下)
        //1.得到类的加载器
        ClassLoader classLoader = SpringApplicationContext.class.getClassLoader();
        //2.通过类的加载器获取到要扫描的包的资源路径
        path = path.replace(".", "/");//一定要把.替换成/
        URL resource = classLoader.getResource(path);
//        System.out.println(resource);
        //3.将要加载的资源(.class) 路径下的文件进行遍历
        File file = new File(resource.getFile());
        readAllFiles(file, path, classLoader);
    }

    //递归遍历所有包，实现扫描多层包结构
    public void readAllFiles(File file, String path, ClassLoader classLoader) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                if (f.isFile()) {
                    dealFile(f,path,classLoader);
                } else if (f.isDirectory()) {
                    readAllFiles(f, path, classLoader);
                }
            }

        } else if (file.isFile()) {
            dealFile(file,path,classLoader);
        }
    }

    public void dealFile(File f, String path, ClassLoader classLoader){
        //获取到.class文件的绝对路径
        String fileAbsolutePath = f.getAbsolutePath();
        //这里只处理.class文件
        if (fileAbsolutePath.endsWith(".class")) {
            //获取到类全类名
            //1.获取到类名
            String className = fileAbsolutePath.substring
                    (fileAbsolutePath.lastIndexOf("\\") + 1, fileAbsolutePath.indexOf(".class"));
//                System.out.println(className);
            //2.拼接成全类名
            String temp = fileAbsolutePath.replace("\\","/");
            String classFullName = temp.substring(temp.indexOf(path),temp.indexOf(".class"));
            classFullName = classFullName.replace("/",".");
//                    System.out.println(classFullName);
            //3.判断该类是不是需要注入容器，看该类是不是有注解 @Component @Service @Repository @Controller
            try {
                //这时，就得到了该类的Class对象
                //1. Class clazz = Class.forName(classFullName) 可以反射加载类
                //2. classLoader.loadClass(classFullName); 也可以反射类的Class
                //3. 区别是 : 上面方式会调用该类的静态方法, 下面方法不会
                //4. aClass.isAnnotationPresent(Component.class) 判断该类是否有 @Component
                Class<?> aClass = classLoader.loadClass(classFullName);
                //判断该类是否有 @Component @Service @Repository @Controller
                if (aClass.isAnnotationPresent(Component.class)) {
                    //org.springframework.util.StringUtils包中的静态方法uncapitalize可以将字符串首字母小写
//                            String keyVal = StringUtils.uncapitalize(className);
                    String keyVal = className.substring(0, 1).toLowerCase() + className.substring(1);
                    //获取到value值，替换指定id
                    if (aClass.isAnnotationPresent(Component.class)) {
                        Component annotation = aClass.getDeclaredAnnotation(Component.class);
                        String value = annotation.value();
                        if (!value.equals("")) {
                            keyVal = value;
                        }
                    }
                    //这时候就可以创建该类的对象，并放入到ioc容器中
                    Class<?> clazz = Class.forName(classFullName);
                    Object o = clazz.newInstance();
                    ioc.put(keyVal, o);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    //通过id获取到bean对象
    public Object getBean(String id){
        return ioc.get(id);
    }
}

3 阶段 2 -- 将bean信息封装到BeanDefinition对象中，并放入到 Map，初始化单例池

将bean信息封装到BeanDefinition对象中，并放入到 Map，初始化单例池，修改getbean方法，如果是单例返回单例池中的对象，如果是多例则临时创建一个对象

代码实现：

（1）创建注解 Scope.java 用来标识bean为单例还是多例，prototype为多例，singleton为单例

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Scope {
    String value(); //不需要给默认值
}

（2）修改 MonsterService.java ，增加Scope注解，用于测试

@Scope(value = "prototype")
@Component(value = "monsterService")//把MonsterService注入到我们自己的spring容器中
public class MonsterService {
}

（3）创建 BeanDefinition.java，封装bean对象

/**
 * 1. 在扫描时，将 bean 信息，封装到 BeanDefinition 对象中
 * 2. 然后将 BeanDefinition 对象 , 放入到 spring 容器的集合中
*/
public class BeanDefinition {
    private Class clazz;//bean对应的class对象
    private String scope;//bean的作用域，singleton/prototype
}

（4）修改 SpringApplicationContext.java, 将扫描到的 Bean 信息封装到 BeanDefinition 对象中，并保存到 BeanDefinitionMap，实现getBean方法

import com.spring.annotation.Component;
import com.spring.annotation.ComponentScan;
import com.spring.annotation.Scope;

import java.io.File;
import java.net.URL;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 该类作用类似于Spring原生ioc容器
 */
@SuppressWarnings("all")
public class SpringApplicationContext {
    //拿到配置类.class文件
    private Class configClass;
    //如果对象是单例的，就直接放在这个 单例 bean 对象池
    private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
    //将 bean 的定义，放在这个 beanDefinitionMap 集合
    private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();

    //构造器
    public SpringApplicationContext(Class configClass) {
        //通过扫描，得到 beanDefinition 的 map
        beanDefinitionsByscan(configClass);
    }

    private void beanDefinitionsByscan(Class configClass) {
        this.configClass = configClass;
//        System.out.println("this.configClass=" + this.configClass);
        //获取要扫描的包
        //1.先获取到ComponentScan注解
        ComponentScan componentScan = (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
        //2.获取到注解的value值
        String path = componentScan.value();
//        System.out.println("要扫描的包= " + path);

        //得到要扫描的包下的所有class文件(在target目录下)
        //1.得到类的加载器
        ClassLoader classLoader = SpringApplicationContext.class.getClassLoader();
        //2.通过类的加载器获取到要扫描的包的资源路径
        path = path.replace(".", "/");//一定要把.替换成/
        URL resource = classLoader.getResource(path);
//        System.out.println(resource);
        //3.将要加载的资源(.class) 路径下的文件进行遍历
        File file = new File(resource.getFile());
        readAllFiles(file, path, classLoader);

        //通过beanDefinitionMap ， 初始化singletonObjects 单例池
        //遍历所有的beanDefinition对象
        Enumeration<String> keys = beanDefinitionMap.keys();
        while (keys.hasMoreElements()){
            //得到beanName
            String beanName = keys.nextElement();
            //通过beanName 得到对应的beanDefinition对象
            BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
            //判断该bean是singleton还是prototype
            if ("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
                //将该bean实例放入到singletonObjects 集合
                Object bean = createBean(beanDefinition);
                singletonObjects.put(beanName, bean);
            }
        }

    }

    //递归遍历所有包
    private void readAllFiles(File file, String path, ClassLoader classLoader) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                if (f.isFile()) {
                    dealFile(f,path,classLoader);
                } else if (f.isDirectory()) {
                    readAllFiles(f, path, classLoader);
                }
            }

        } else if (file.isFile()) {
            dealFile(file,path,classLoader);
        }
    }

    private void dealFile(File f, String path, ClassLoader classLoader){
        //获取到.class文件的绝对路径
        String fileAbsolutePath = f.getAbsolutePath();
        //这里只处理.class文件
        if (fileAbsolutePath.endsWith(".class")) {
            //获取到类全类名
            //1.获取到类名
            String className = fileAbsolutePath.substring
                    (fileAbsolutePath.lastIndexOf("\\") + 1, fileAbsolutePath.indexOf(".class"));
//                System.out.println(className);
            //2.拼接成全类名
            String temp = fileAbsolutePath.replace("\\","/");
            String classFullName = temp.substring(temp.indexOf(path),temp.indexOf(".class"));
            classFullName = classFullName.replace("/",".");
//                    System.out.println(classFullName);
            //3.判断该类是不是需要注入容器，看该类是不是有注解 @Component @Service @Repository @Controller
            try {
                //这时，就得到了该类的Class对象
                //1. Class clazz = Class.forName(classFullName) 可以反射加载类
                //2. classLoader.loadClass(classFullName); 也可以反射类的Class
                //3. 区别是 : 上面方式会调用该类的静态方法, 下面方法不会
                //4. aClass.isAnnotationPresent(Component.class) 判断该类是否有 @Component
                Class<?> aClass = classLoader.loadClass(classFullName);
                //判断该类是否有 @Component
                if (aClass.isAnnotationPresent(Component.class)) {
                    //org.springframework.util.StringUtils包中的静态方法uncapitalize可以将字符串首字母小写
//                            String keyVal = StringUtils.uncapitalize(className);
                    String keyVal = className.substring(0, 1).toLowerCase() + className.substring(1);
                    //获取到value值，替换指定id
                    Component annotation = aClass.getDeclaredAnnotation(Component.class);
                    String value = annotation.value();
                    if (!value.equals("")) {
                        keyVal = value;
                    }
                    //这时候就可以创建该bean的定义对象
                    Class<?> clazz = Class.forName(classFullName);
                    BeanDefinition beanDefinition = new BeanDefinition();
                    beanDefinition.setClazz(clazz);
                    //如果存在Scope注解，就设置该注解的值，如果不存在，则设为单例 singleton
                    if (clazz.isAnnotationPresent(Scope.class)){
                        Scope s = clazz.getDeclaredAnnotation(Scope.class);
                        String val = s.value();
                        beanDefinition.setScope(val);
                    }else {
                        beanDefinition.setScope("singleton");
                    }
                    //将 BeanDefinition 对象放入 map 集合中
                    beanDefinitionMap.put(keyVal, beanDefinition);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    //通过id获取到bean对象
    public Object getBean(String id){
        if (beanDefinitionMap.containsKey(id)) {
            BeanDefinition bean = beanDefinitionMap.get(id);
            String scope = bean.getScope();
            if (scope.equals("singleton")) {
                //如果是单例的，就直接从单例池中获取
                return singletonObjects.get(id);
            } else {
                //如果bean是多实例的，就临时创建一个对象
                Class clazz = bean.getClazz();
                return createBean(bean);
            }
        }else {
            throw new NullPointerException("没有该bean");
        }
    }

    private Object createBean(BeanDefinition bean){
        Class clazz = bean.getClazz();
        try {
            return clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

（5）创建主程序，测试

public class AppMain {
    public static void main(String[] args) {
        SpringApplicationContext ioc = new SpringApplicationContext(SpringConfigXml.class);
        MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");
        MonsterService monsterService2 = (MonsterService)ioc.getBean("monsterService");
        MonsterDao monsterDao = (MonsterDao)ioc.getBean("monsterDao");
        MonsterDao monsterDao1 = (MonsterDao)ioc.getBean("monsterDao");
        System.out.println(monsterService);
        System.out.println(monsterService2);
        System.out.println(monsterDao);
        System.out.println(monsterDao1);
        System.out.println("ok~");
    }
}

（6）运行效果

分析：可以看到，多例 bean 每次 getbean 返回的是不同的对象，而单例 bean 每次 getbean 返回的是同一个对象

4 阶段 3 -- 完成依赖注入

完成依赖注入

（1）创建 Autowired.java注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Autowired 自动依赖注入
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface Autowired {
}

（2）修改 MonsterDao.java，MonsterService.java，加入 Autowired 注解

import com.spring.annotation.Component;

@Component(value = "monsterDao")
public class MonsterDao {
    public void hi() {
        System.out.println("hi 我是 monster Dao");
    }
}

import com.spring.annotation.Autowired;
import com.spring.annotation.Component;
import com.spring.annotation.Scope;

/**
 * MonsterService 是一个 Service
 * 1.如果指定value，注入容器时，以指定的value值为准
 * 2.如果没用指定value，则默认为类名首字母小写
 */
@Scope(value = "prototype")
@Component(value = "monsterService")//把MonsterService注入到我们自己的spring容器中
public class MonsterService {

    //表示该属性，是通过容器完成依赖注入
    //说明：这里只实现了按照属性名来进行组装
    @Autowired
    private MonsterDao monsterDao;
    public void m1() {
        //调用 monsterDao 的 hi()
        monsterDao.hi();
    }
}

（3）修改 SpringApplicationContext.java 类中的 createBean 方法，实现依赖注入

private Object createBean(BeanDefinition bean){
    Class clazz = bean.getClazz();
    try {
        Object instance = clazz.newInstance();
        //完成依赖注入
        Field[] fields = clazz.getDeclaredFields();
        //遍历当前要创建的对象的所有字段
        for (Field field : fields) {
            //判断这个字段是否有@Autowired注解
            if (field.isAnnotationPresent(Autowired.class)){
                //如果该属性有@Autowired, 就进行组装
                //得到这个字段名字
                String fieldName = field.getName();
                //因为属性是private，需要爆破
                field.setAccessible(true);
                //进行组装，通过getBean方法获取到要组装的对象
                field.set(instance, getBean(fieldName));
            }
        }
        return instance;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

（4）编写主程序，查看依赖是否注入成功

public class AppMain {
    public static void main(String[] args) {
        SpringApplicationContext ioc = new SpringApplicationContext(SpringConfigXml.class);
        MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");
        monsterService.m1();
        System.out.println("ok~");
    }
}

（5）运行效果

依赖注入成功！

5 阶段 4 -- bean后置处理器实现

实现自己的 bean 后置处理器

（1）创建 InitializingBean.java 接口, 实现该接口的 Bean , 需要实现 Bean 初始化方法

/**
 * 1. 根据原生Spring 定义了一个InitializingBean
 * 2. 该InitializingBean接口有一个方法void afterPropertiesSet() throws Exception;
 * 3. afterPropertiesSet() 在Bean的 setter后执行,即就是初始化方法
 * 4. 当一个Bean实现这个接口后，就实现afterPropertiesSet() , 这个方法就是初始化方法
 */
public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

（2）修改MonsterService.java、MonsterDao.java, 实现 InitializingBean 接口

import com.spring.annotation.Autowired;
import com.spring.annotation.Component;
import com.spring.annotation.Scope;
import com.spring.processor.InitializingBean;

/**
 * MonsterService 是一个 Service
 * 1.如果指定value，注入容器时，以指定的value值为准
 * 2.如果没用指定value，则默认为类名首字母小写
 */
@Scope(value = "prototype")
@Component(value = "monsterService")//把MonsterService注入到我们自己的spring容器中
public class MonsterService implements InitializingBean {

    //表示该属性，是通过容器完成依赖注入
    //说明：这里只实现了按照属性名来进行组装
    @Autowired
    private MonsterDao monsterDao;
    public void m1() {
        //调用 monsterDao 的 hi()
        monsterDao.hi();
    }

    /**
     * afterPropertiesSet就是在bean的setter方法执行完毕后被spring容器调用
     * 即就是初始化方法
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("MonsterService 初始化方法被调用 程序员在这里加入初始化的业务..");
    }
}

import com.spring.annotation.Component;
import com.spring.processor.InitializingBean;

@Component(value = "monsterDao")
public class MonsterDao implements InitializingBean {
    public void hi() {
        System.out.println("hi 我是 monster Dao");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("MonsterDao 初始化方法被调用...");
    }
}

（3）修改 SpringApplicationContext.java 类中的createBean方法 , 在创建好 Bean 实例后，判断是否需要进行初始化

private Object createBean(BeanDefinition bean){
    Class clazz = bean.getClazz();
    try {
        Object instance = clazz.getDeclaredConstructor().newInstance();
        //完成依赖注入
        Field[] fields = clazz.getDeclaredFields();
        //遍历当前要创建的对象的所有字段
        for (Field field : fields) {
            //判断这个字段是否有@Autowired注解
            if (field.isAnnotationPresent(Autowired.class)){
                //如果该属性有@Autowired, 就进行组装
                //得到这个字段名字
                String fieldName = field.getName();
                //因为属性是private，需要爆破
                field.setAccessible(true);
                //进行组装，通过getBean方法获取到要组装的对象
                field.set(instance, getBean(fieldName));
            }
        }

        System.out.println("====创建好实例=====" + instance);
        //这里判断是否要执行Bean初始化方法
        //1. 判断当前创建的Bean对象是否实现了InitializingBean
        //2. instanceof 可以用来判断某个对象的运行类型是不是某个类型或者
        //  某个类型的子类型
        if (instance instanceof InitializingBean){
            // 转型成接口类型调用方法
            ((InitializingBean) instance).afterPropertiesSet();
            // 也可以使用反射调用
//                Method initMethod = clazz.getDeclaredMethod("afterPropertiesSet");
//                initMethod.invoke(instance);
        }
        return instance;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

（4）编写主程序，测试

public class AppMain {
    public static void main(String[] args) {
        SpringApplicationContext ioc = new SpringApplicationContext(SpringConfigXml.class);
        MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");
        System.out.println("ok~");
    }
}

（5）运行效果

成功实现初始化方法！

（6）现在开始实现后置处理器，创建 BeanPostProcessor.java 接口，创建MyBeanPostProcessor.java 类实现该接口，增加一个Car类，用于测试

/**
 * 1. 参考原生Spring容器定义一个接口BeanPostProcessor
 * 2. 该接口有两个方法postProcessBeforeInitialization 和 postProcessAfterInitialization
 * 3. 这两个方法，会对Spring容器的所有Bean生效
 */
public interface BeanPostProcessor {

    /**
     * postProcessBeforeInitialization在Bean的初始化方法前调用
     */
    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    /**
     * postProcessAfterInitialization在Bean的初始化方法后调用
     */
    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

package com.spring.component;

import com.spring.annotation.Component;
import com.spring.processor.InitializingBean;

@Component
public class Car implements InitializingBean {
    String name = "小黄";
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Car的初始化方法..");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

import com.spring.annotation.Component;
import com.spring.processor.BeanPostProcessor;

/**
 * 1. 这是我们自己的一个后置处理器
 * 2. 实现了BeanPostProcessor
 * 3. 我们可以重写before和after方法
 * 4. 在Spring容器中，仍然把HspBeanPostProcessor当做一个Bean对象， 要注入到容器
 * 5. 需要加上@Component 标识
 * 6. 我们要让HspBeanPostProcessor成为真正的后置处理器, 需要在容器中加入业务代码
 * 7. 还要考虑多个后置处理器对象注入到容器问题
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {

        //后置处理器会对所有的bean生效，这里就可以对Car对象进行单独的处理
        if (bean instanceof Car){
            System.out.println("这是一个Car对象，我可以处理");
        }

        System.out.println("后置处理器HspBeanPostProcessor Before调用 bean类型="
                + bean.getClass() + " bean的名字=" + beanName);
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("后置处理器HspBeanPostProcessor After调用 bean类型="
                + bean.getClass() + " bean的名字=" + beanName);
        return bean;
    }
}

（7）修改 SpringApplicationContext.java 容器类

添加属性，存放后置处理器对象

//定义一个属性beanPostProcessorList, => 存放后置处理器
private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();

修改dealFile方法，在以下位置加入以下代码，将后置处理器对象放入集合中

//判断该类是否有 @Component
if (aClass.isAnnotationPresent(Component.class)) {

    //1. 为了方便，这里将后置处理器放入到一个ArrayList
    //2. 如果发现是一个后置处理器, 放入到 beanPostProcessorList
    //3. 在原生的Spring容器中, 对后置处理器还是走的getBean, createBean
    //   , 但是需要我们在singletonObjects 加入相应的业务逻辑,这里进行了简化

    //判断当前的这个class对象有没有实现BeanPostProcessor
    //说明, 这里我们不能使用 instanceof 来判断clazz是否实现了BeanPostProcessor
    //原因: clazz不是一个实例对象，而是一个类对象/clazz, 可以使用isAssignableFrom
    if (BeanPostProcessor.class.isAssignableFrom(aClass)) {
        BeanPostProcessor beanPostProcessor =
                (BeanPostProcessor) aClass.newInstance();
        //放入到beanPostProcessorList
        beanPostProcessorList.add(beanPostProcessor);
        return;
    }
    。。。。。
}

修改create方法，增加一个参数beanName，并在初始化方法前后调用后置处理器方法

private Object createBean(BeanDefinition bean, String beanName)

create方法修改部分代码如下

System.out.println("====创建好实例=====" + instance);

//在Bean的初始化方法前，调用后置处理器的before方法
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
    //在后置处理器的before方法中，可以对容器的bean实例进行处理
    //然后返回处理后的实例
    Object current = beanPostProcessor.postProcessBeforeInitialization(instance,beanName);
    //这样处理，如果返回null，对bean对象不会造成影响,后置处理器中对bean做出的修改依然会生效
    if (current != null){
        instance = current;
    }
}


//这里判断是否要执行Bean初始化方法
//1. 判断当前创建的Bean对象是否实现了InitializingBean
//2. instanceof 可以用来判断某个对象的运行类型是不是某个类型或者
//  某个类型的子类型
if (instance instanceof InitializingBean){
    // 转型成接口类型调用方法
    ((InitializingBean) instance).afterPropertiesSet();
    // 也可以使用反射调用
    // Method initMethod = clazz.getDeclaredMethod("afterPropertiesSet");
    //  initMethod.invoke(instance);
}

//在Bean的初始化方法后，调用后置处理器的after方法
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
    //在后置处理器的after方法中，可以对容器的bean实例进行处理
    //然后返回处理后的实例
    Object current = beanPostProcessor.postProcessAfterInitialization(instance,beanName);
    //这样处理，如果返回null，对bean对象不会造成影响
    if (current != null){
        instance = current;
    }
}

（8）编写主类测试

package com.spring;

import com.spring.component.MonsterService;
import com.spring.ioc.SpringApplicationContext;
import com.spring.ioc.SpringConfigXml;

public class AppMain {
    public static void main(String[] args) {
        SpringApplicationContext ioc = new SpringApplicationContext(SpringConfigXml.class);
        MonsterService monsterService = (MonsterService)ioc.getBean("monsterService");
        System.out.println("ok~");
    }
}

（9）运行结果

后置处理器成功作用在所有bean上

6 阶段 5 -- AOP机制实现

实现一个简单的AOP，这里做了简化，使用的硬编码，写死了

（1）创建注解Aspect.java，Before.java，AfterReturning.java

package com.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Aspect {
    String value() default "";
}

package com.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Before {
    String value();
    String argNames() default "";
}

package com.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface AfterReturning {
    String value() default "";

    String pointcut() default "";

    String returning() default "";

    String argNames() default "";
}

（2）创建接口 SmartAnimalable.java，实现类 SmartDog.java，切面类 SmartAnimalAspect.java

package com.spring.component;

@SuppressWarnings("all")
public interface SmartAnimalable {
    //求和
    float getSum(float i, float j);
    //求差
    float getSub(float i, float j);
}

package com.spring.component;

import com.spring.annotation.Component;

@Component
public class SmartDog implements SmartAnimalable {
    @Override
    public float getSum(float i, float j) {
        float result = i + j;
        System.out.println("SmartDog-getSum方法内部打印result = " + result);
        return result;
    }

    @Override
    public float getSub(float i, float j) {
        float result = i - j;
        System.out.println("SmartDog-getSub方法内部打印result = " + result);
        return result;
    }
}

package com.spring.component;

import com.spring.annotation.AfterReturning;
import com.spring.annotation.Aspect;
import com.spring.annotation.Before;
import com.spring.annotation.Component;

/**
 * SmartAnimalAspect当做一个切面类来使用
 */
@Aspect
@Component
public class SmartAnimalAspect {

    @Before(value = "execution com.spring.aop.aspectj.SmartDog getSum")
    public static void showBeginLog() {

        System.out.println("前置通知..");
    }

    @AfterReturning(value = "execution com.spring.aop.aspectj.SmartDog getSum")
    public static void showSuccessLog() {

        System.out.println("返回通知..");
    }
}

（3）修改 MyBeanPostProcessor.java 类中的 postProcessAfterInitialization方法，实现AOP，返回代理对象

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    System.out.println("后置处理器HspBeanPostProcessor After调用 bean类型="
            + bean.getClass() + " bean的名字=" + beanName);

    //实现AOP，返回代理对象，即对Bean进行包装
    if ("smartDog".equals(beanName)){
        //使用jdk的动态代理，返回bean的代理对象
        Object proxyInstance = Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                SmartAnimalAspect.showBeginLog();
                Object res = method.invoke(bean,args);
                SmartAnimalAspect.showSuccessLog();
                return res;
            }
        });
        return proxyInstance;
    }
    return bean;
}

（4）创建 AOPTest.java

package com.spring;

import com.spring.annotation.AfterReturning;
import com.spring.annotation.Before;
import com.spring.component.SmartAnimalAspect;

import java.lang.reflect.Method;

public class AOPTest {
    public static void main(String[] args) throws Exception {

        //1. 获取SmartAnimalAspect的class对象
        Class<SmartAnimalAspect> smartAnimalAspectClass = SmartAnimalAspect.class;
        //2. 遍历该类的所有方法
        for (Method declaredMethod : smartAnimalAspectClass.getDeclaredMethods()) {
            //如果切面类的方法有Before注解
            if (declaredMethod.isAnnotationPresent(Before.class)) {
                //得到切面类的切入方法名
                System.out.println("m:= " + declaredMethod.getName());
                //得到Before(value="xxxx")
                //得到Before注解
                Before annotation = declaredMethod.getAnnotation(Before.class);
                //得到Before注解的value
                System.out.println("value:= " + annotation.value());

                //调用切入方法[通过反射调用]
                declaredMethod.invoke(smartAnimalAspectClass.newInstance(), null);

            } else if (declaredMethod.isAnnotationPresent(AfterReturning.class)) {

                //如果发现切面类有AfterReturning注解，同样可以进行处理..
                System.out.println("m:= " + declaredMethod.getName());
                AfterReturning annotation = declaredMethod.getAnnotation(AfterReturning.class);
                System.out.println("value:= " + annotation.value());

                //调用切入方法[反射调用]
                declaredMethod.invoke(smartAnimalAspectClass.newInstance(), null);
            }
        }
    }
}

（5）运行结果