一、IOC

1. Spring是轻量级的开源的javaEE框架
2. Spring有两个核心部分: IOC 和 AOP
   1. IOC : 控制反转,把创建对象的过程交给Spring进行管理
   2. AOP: 面向切面,不修改源代码进行功能增强
3. Spring特点：
   1. 方便解耦，简化开发
   2. AOP编程支持
   3. 方便程序测试
   4. 方便和其他框架进行整合
   5. 方便进行事务操作
   6. 降低API开发难度

    

        
            commons-logging
            commons-logging
            1.2
        
        
            org.springframework
            spring-beans
            5.2.12.RELEASE
        
        
            org.springframework
            spring-context
            5.2.12.RELEASE
        
        
            org.springframework
            spring-core
            5.2.12.RELEASE
        
        
            org.springframework
            spring-expression
            5.2.12.RELEASE
        
    

1. 什么是IOC
   1. 控制反转，把对象创建和对象之间的调用过程交给Spring进行管理
   2. 使用IOC的目的就是降低耦合度
2. IOC底层原理
   1. 通过xml解析读取xml配置文件中配置的bean标签，获取到配置的全类名
   2. Bean工厂类通过反射Class.forName(全类名)创建Class的对象
   3. 通过一个Bean工厂类将对象返回，完成对象的创建

1. IOC思想基于IOC容器完成，IOC容器底层就是一个对象工厂

2. Spring提供IOC容器有两种基本方式(两个接口)

   1. BeanFactory:IOC的基本实现，Spring内部使用的接口，开发人员不建议使用
      • 特点：加载配置文件的时候不会创建对象，在获取对象(getBean())才会创建对象
   2. ApplicationContext:BeanFactory接口的子接口，提供更多更强大的功能，开发人员使用
      • 特点：加载配置文件的时候就会把在配置文件中的对象进行创建

3. 继承树

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wrOrR4wQ-1633095315463)(C:UsersAdministrator.DESKTOP-O7Q3NEAAppDataRoamingTyporatypora-user-imagesimage-20210926134223580.png)]

1. Bean管理是指两个操作
   • Spring创建对象
   • Spring为对象注入属性
2. Bean管理有两种方式
   • 基于xml配置文件方式实现
   • 基于注解方式实现

1. 创建对象: 在spring的配置文件中使用bean标签,默认调用的是类的无参构造器

2. 注入属性:两种方式注入属性

   1. 使用通过setter方法注入属性，要求类必须提供setter方法

   2. 通过constructor构造器注入属性，此时不再调用类的无参构造器，创建对象

   3. p命名空间注入，本质上还是setter方法注入，不做解释

3. 如何给属性注入null等特殊符号

   1. 注入null值

   2. 注入特殊符号

          
      
              
                  ]]>
              
          
      

4. 如何注入外部bean

   1. 使用ref进行注入

   2. 使用内部bean注入

   3. 使用级联注入

5. 集合类型怎么注入

       
           
               
                   数组1
                   数组2
               
           
           
               
                   
                   
                   
               
           
           
               
           
           
               
                   set1
                   set2
                   set3
               
           
       
       
           
           
       
       
           
           
       
       
           
           
       
   

• 普通bean:在配置文件中定义bean类型就是返回类型，上面的都是普通bean

• 工厂bean(FactoryBean) : 通过配置工厂，返回工厂要返回的类型

  • 实现步骤：

    1. 创建类，让这个类实现FactoryBean接口,重写getObject()方法，指定返回的对象

       public class CourseFactory implements FactoryBean {
           @Override
           public Course getObject() throws Exception {
               Course course = new Course();
               course.setName("一本书");
               return course;
           }
           @Override
           public Class getObjectType() {
               return null;
           }
           @Override
           public boolean isSingleton() {
               return false;
           }
       }
       

    2. 在配置文件中配置工厂类

    3. 测试

           @Test
           public void test1(){
               ApplicationContext context = 
                   new ClassPathXmlApplicationContext("application.xml");
               Course bean = context.getBean("bean", Course.class);
               System.out.println(bean);
           }
       

• singleton 和 prototype的区别?
  1. singleton 是单例的 prototype是多例的
  2. scope的属性值为singleton时，在加载Spring配置文件的时候就会创建实例对象，而设置scope的属性值为prototype时，在调用getBean()方法时才创建对象

1. 第一步:调用无参构造器
2. 第二步:调用setter方法注入属性
3. 第三步:我在bean初始化方法前执行，Bean的后置处理器postProcessBeforeInitialization()方法
4. 第四步:调用初始化方法，需要配置
5. 第五步:我在bean初始化方法后执行，bean的后置处理器postProcessAfterInitialization()方法
6. 第六步:bean正在被使用
7. 第七步:调用销毁方法，需要配置

public class LifeBean {
    private String name;
    public LifeBean() {
        System.out.println("第一步:调用无参构造器");
    }
    public void setName(String name) {
        System.out.println("第二步:调用setter方法注入属性");
        this.name = name;
    }
    public void initMethod(){
        System.out.println("第四步:调用初始化方法，需要配置");
    }
    public void userBean(){
        System.out.println("第六步:bean正在被使用");
    }
    public void destroyMethod(){
        System.out.println("第七步:调用销毁方法，需要配置");
    }
}

后置处理器BeanPost

public class BeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第三步:我在bean初始化方法前执行，Bean的后置处理器");
        return null;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第五步:我在bean初始化方法后执行，bean的后置处理器");
        return null;
    }
}

测试

    
    @Test
    public void test2(){
        ClassPathXmlApplicationContext context = 
            new ClassPathXmlApplicationContext("application.xml");
        LifeBean life = context.getBean("lifeBean", LifeBean.class);
        life.userBean();
        //关闭容器时bean被销毁
        context.close();
    }

• bean中有一个属性为autowire完整自动装配属性值指定装配规则
  • 属性值为byName : 根据属性名称自动装配
  • 属性值为byType : 根据属性类型自动装配

• 以druid数据库连接池为例

  • druid.properties

    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql://127.0.0.1:3306/mnyuansql
    username=root
    password=1234
    

  • application.xml 要引入context命名空间