如何搞定spring核心面试点ioc和aop

spring 底层原理

ioc

概念和原理:

• 控制反转，把对象创建和对象之间的调用过程都交给spring管理
• 为了耦合度降低
  用到的方法 xml解析 、反射、工厂模式

以后只需要改xml配置中的路径，降低了耦合

ioc接口

1. ioc思想基于ioc容器完成，ioc容器底层就是对象工厂
2. spring提供IOC容器实现的两种方式（两个接口）

BeanFactory 是IOC容器的基本实现，spring内部使用的接口 * 加载配置文件的时候不会创建对象，在使用时才去创建对象
ApplicationContext : 是BeanFactory接口的子接口，提供更多更强大的功能 * 加载配置文件时就会创建对象

ioc的bean管理

有两种bean，一种是普通bean（由Beanfactory得到）,一种是工厂bean（由FactoryBean得到，往往生产某一个独特的具有复杂属性的对象,定义类型和返回类型可以不一样，如下例子）

FactoryBean使用方法
实现FactoryBean接口 <>泛型里面的类型为返回值类型

package com.zhou.factoryBean;

import com.zhou.Cat;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Cat> {
    @Override
    public Cat getObject() throws Exception {
        
        Cat cat = new Cat();
        return cat;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

import com.zhou.Cat;
import com.zhou.People;
import com.zhou.factoryBean.MyBean;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test1(){
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("beans1.xml");


        Cat mybean = beanFactory.getBean("mybean", Cat.class);
        System.out.println(mybean);
        mybean.shut();


        //        MyBean mybean = (MyBean)beanFactory.getBean("mybean");
//        System.out.println(mybean);


/*      People people =(People) applicationContext.getBean("people");
      people.getCat().shut();
      people.getDog().shut();*/

    }
}

Bean的生命周期

生命周期：从对象创建到对象销毁的过程
如果不加上后置处理器的话有5步

1. 通过构造器创建bean实例（使用无参构造方法）
2. 使用set方法给bean对象的属性设置值和对其它bean的引用
3. 调用bean的初始化方法，需要在xml中配置init-method
4. bean对象就可以使用了（对象获取到了）
5. 当容器关闭的时候，调用bean的destroy销毁方法（需要在xml中配置destroy-method）

package com.zhou.life;

public class LifeBean {
    private String name;

    public LifeBean() {
        System.out.println("第一步：通过构造器创建bean实例（无参构造方法）");
    }


    public LifeBean(String name) {
        this.name = name;

        System.out.println("有参构造方法");
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("第二步：通过set方法给bean对象的属性赋值及对其它对象的引用");
    }


    public void init(){
        System.out.println("第三步：init方法");
    }

    public void destroy(){
        System.out.println("第五步：容器关闭的时候调用bean的销毁方法");
    }
}

xml配置文件

<?xml version="1.0" encoding="GBK"?>
<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">

<bean id="lifebean" class="com.zhou.life.LifeBean" init-method="init" destroy-method="destroy" >
    <property name="name" value="周大哥" ></property>
</bean>

</beans>

测试函数

    @Test
    public void test2(){


        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean2.xml");

        LifeBean lifebean = applicationContext.getBean("lifebean", LifeBean.class);

        System.out.println(lifebean+"第四步：bean对象获取到了");


        applicationContext.close();

    }

加入后置处理器后：

1. 通过构造器创建bean实例（使用无参构造方法）
2. 使用set方法给bean对象的属性设置值和对其它bean的引用
3. postProcessBeforeInitialization调用了
4. 调用bean的初始化方法，需要在xml中配置init-method
5. postProcessAfterInitialization调用了
6. bean对象就可以使用了（对象获取到了）
7. 当容器关闭的时候，调用bean的destroy销毁方法（需要在xml中配置destroy-method）

需要配置后置处理器,以后每个bean的实例化都会调用

    <bean id="myPostProcessor" class="com.zhou.life.MyPostProcessor"></bean>

package com.zhou.life;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;


//后置处理器
public class MyPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization"+"调用了");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization"+"调用了");

        return bean;
    }
}

aop面向切面编程

不通过修改源代码的方式，在主干功能里面添加新功能

情况一 有接口的情况：使用jdk动态代理
创建接口实现类的代理对象，增强类的方法

情况二：没有接口，使用cglib动态代理 创建子类的代理对象，增强类的方法