Spring----01----概述&&搭建&&配置详解

目录

  • Spring----01----概述&&配置详解
    • 1. Spring框架
    • 2. Spring框架搭建
      • 2.1 导入依赖
      • 2.2 创建一个类
      • 2.3 创建Spring配置文件
      • 2.4 测试
      • 2.5 Spring简单原理
    • 3. Spring进阶介绍
      • 3.1 BeanFactory&ApplicationContext(概念)
      • 3.2 IOC与DI
        • 3.2.1 IOC
        • 3.2.2 DI
        • 3.2.3 IOC与DI之间的关系
    • 4.Spring配置详解
      • 4.1 Spring创建对象方式
        • 4.1.1 由Spring调用构造方法创建(使用最多)
        • 4.1.2 使用静态工厂方法创建对象
        • 4.1.3 使用动态工厂方法创建对象
      • 4.2 对象的作用域&生命周期

Spring----01----概述&&配置详解

1. Spring框架

Spring----01----概述&&搭建&&配置详解_第1张图片

  • Spring框架的作用范围横跨项目的三层;
  • Spring是项目中对象的管家;
  • 2003年由Rob Johnson创建。

2. Spring框架搭建

2.1 导入依赖


        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.2.6.RELEASEversion>
        dependency>

2.2 创建一个类

public class User {
    
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

2.3 创建Spring配置文件

规范:Spring官方没有对配置文件的 名字|位置 规定规范,但是开发通常将配置文件放到/resource/applicationContsext.xml中。
Spring----01----概述&&搭建&&配置详解_第2张图片


<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 name="user" class="com.leo.domain.User">bean>
    
beans>

2.4 测试

public class App {
    public static void main(String[] args) {
        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        User user = (User) ac.getBean("user");
        System.out.println(user);
    }   
}

2.5 Spring简单原理

  1. spring读取xml配置文件,读取配置文件中的诸多对象信息(完整类名);
  2. 根据完整类名,获得Class字节码文件(Class.forName(类名));
  3. 通过反射技术,创建出对象(newInstance);
  4. 创建出的对象会放入到一个Map结构中,其中name属性值作为键,对象作为值;
  5. 我们从spring容器中获得对象时,就可以根据键去取出值(对象)。

3. Spring进阶介绍

3.1 BeanFactory&ApplicationContext(概念)

Spring----01----概述&&搭建&&配置详解_第3张图片
上图是BeanFactory的继承关系图

Spring----01----概述&&搭建&&配置详解_第4张图片
上图是ApplicationContext的继承关系图

     ApplicationContext是更加常用的容器类型;
     BeanFactory是spring框架刚刚出现时,诞生的原始的容器类型;
     ApplicationContext是spring框架后续随着发展诞生的拥有更多功能的容器类型;
     ApplicationContext接口是BeanFactory接口的子类,ApplicationContext拥有BeanFactory的全部功能;
     BeanFactory是只具备容器的基本功能;

     ApplicationContext对容器功能进行了极大的丰满:

  • 默认初始化所有的Singleton,也可以通过配置取消预初始化。
  • 继承MessageSource,因此支持国际化;
  • 资源访问,比如访问URL和文件;
  • 事件机制;
  • 同时加载多个配置文件;
  • 以声明式方式启动并创建Spring容器。

3.2 IOC与DI

3.2.1 IOC

     IOC:inverse of control 反转控制。
     理解:开发人员以前创建对象时,都是需要用到什么对象就去手动创建什么对象,如果对象中有依赖关系存在,就需要手动去维护依赖关系,例如:我们需要A对象,但A对象依赖于B对象,我们就需要先手动创建B对象,然后手动创建A对象,再把B对象注入到A对象中,总结说,就是整个对象的生命周期都是由开发人员手动维护的。
     上面这段话可以理解为传统的控制方式,或者说正向的控制对象方式。
     什么是反转控制呢?
     将对象的创建以及依赖关系的注入全部交给程序帮我们完成,而不再是由我们自己去控制你程序完成,那么就可以称之为反转控制,反转的是对象的创建方式。

3.2.2 DI

     DI:Dependency Injection 依赖注入
     理解: 将依赖的属性注入到对象的过程,即为依赖注入。
     例如:Servlet依赖于Service,Service依赖于Dao等,我们将Service注入到Servlet的过程就是依赖注入,依赖注入的方   式有两种,一种是set方法注入,还用一种是构造方法注入,这两种方式,Spring都支持。

3.2.3 IOC与DI之间的关系

     我们要实现IOC设计必须要有DI技术的支持。

4.Spring配置详解

4.1 Spring创建对象方式

4.1.1 由Spring调用构造方法创建(使用最多)

<bean name="user" class="com.leo.domain.User">
    bean>

4.1.2 使用静态工厂方法创建对象

工厂方法:

public class UserFactory {

    //创建User对象并返回
    public static User getUser1(){
        User u = new User();
        u.setName("jerry");
        u.setId(2);
        return  u;
    }
}

配置文件:

 
    <bean name="user2" class="com.leo.factory.UserFactory"  factory-method="getUser1">bean>

测试:

public class App {

    public static void main(String[] args) {

        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        User user = (User) ac.getBean("user2");
        System.out.println(user);

    }

}

4.1.3 使用动态工厂方法创建对象

工厂方法:

 	//创建User对象并返回 -> 动态工厂方法
    public User getUser2(){
        User u = new User();
        u.setName("jack");
        u.setId(3);
        return  u;
    }

xml配置:

	
    <bean name="userFactory" class="com.leo.factory.UserFactory">bean>
    
    <bean name="user3" factory-bean="userFactory" factory-method="getUser2">bean>

测试:

public class App {

    public static void main(String[] args) {

        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        User user = (User) ac.getBean("user3");
        System.out.println(user);

    }
}

4.2 对象的作用域&生命周期

配置:

	
    <bean name="user4" class="com.leo.domain.User" scope="singleton"  destroy-method="destory" init-method="init">bean>

测试:

    @Test
    public void fun1() {
        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        //同一个User4只存在一个实例
        User user1 = (User) ac.getBean("user4");
        User user2 = (User) ac.getBean("user4");

        //true => 只有一个User4实例(singleton)
        //false => 每次从容器中获取的都是不同的对象(prototype)
        System.out.println(user1 == user2);
    }
  	@Test
    public void fun2() {

        //1.创建spring容器 -> 创建所有singleton对象
        ClassPathXmlApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");

        //2.关闭spring容器 -> 销毁所有singleton对象
        ac.close();
    }

你可能感兴趣的:(SSM框架学习笔记,spring,ioc,java,设计模式)