DAY01_Spring—Spring框架介绍&IOC&Spring工厂模式

1 什么是框架

• 说明:
  • 将公共的模块(功能) 进行高级的抽取(接口/父级)形成了通用的代码体.
• 使用:
  • 引入特定的jar包/class/方法 既可以使用框架中的功能.
• 实际意义:
  • 简化代码的开发.提高软件的扩展性.

2 Spring框架

2.1 Spring介绍

Spring框架为任何类型的部署平台上的基于Java的现代企业应用程序提供了全面的编程和配置模型。

Spring的一个关键元素是在应用程序级别的基础架构支持：Spring专注于企业应用程序的“管道”，以便团队可以专注于应用程序级别的业务逻辑，而不必与特定的部署环境建立不必要的联系。
总结: Spring的主要的作用将其他框架进行整合,以一种统一的通用的方法进行管理(“角色:框架的大管家”)

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于JEE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。

• Bean:
  • 被spring容器管理的对象称之为Bean

2.2 MVC模型说明

在大型项目中由于模块众多,如果将所有的项目都写到一起则代码特别的混乱.不便于后期的维护. 所以通过MVC设计模型,将代码进行分级.
实现步骤: 分为3级

• M(Model) 持久层 代码与数据库进行交互的代码(Mybatis-dao层)
• C(Control) 控制层 完成某项业务的具体操作过程(Controller层----Service层)
• V(View) 视图层 一般指用户看到的内容(页面)

2.3 IOC思想

2.3.1 问题说明

传统的代码是直接通过new的方式创建对象. 这样的方式将对象与对象紧紧的绑定到一起,不便于代码的扩展.所以需要进行松耦合处理.

2.3.2 IOC说明

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

将对象的创建的权利交给Spring管理, 由Spring(第三方)管理对象的生命周期(创建/初始化/使用/销毁).

3 Spring IOC具体实现

3.1 环境准备

3.1.1 关于JDK说明

3.1.2 检查JDK环境配置

1).环境变量配置

2).检查path路径

检查环境变量中,有几个JDK 如果不确定,则将自己的JDK配置为第一项…

3.2 创建项目

3.3 关于Maven 命令

3.3.1 install 命令

• 将项目打包处理

打包之后的结果:

3).本地仓库位置

4).maven坐标

坐标的主要作用就是用来检索jar包文件的. maven通过这样的方式管理了几乎所有的开源jar包.(中央仓库/私服镜像)

<groupId>com.jt</groupId>
<artifactId>spring_demo_1_ioc</artifactId>
<version>1.0-SNAPSHOT</version>

5).本地仓库中的jar包主要的作用就是被自己的项目进行依赖 (松耦合)

3.3.2 clean 命令

• 将target文件目录删除

3.4 添加jar包文件

3.4.1 spring版本说明

3.4.2 引入Spring jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jt</groupId>
    <artifactId>spring_demo_1_ioc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--Spring核心包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.22</version>
        </dependency>

        <!--引入SpringBean-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.22</version>
        </dependency>

        <!--引入context包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.22</version>
        </dependency>

        <!--引入表达式jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.22</version>
        </dependency>

        <!--引入日志依赖-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

        <!--引入测试包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

3.5 编辑实体对象

3.6 编辑application.xml

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

    <!--1.动态生成Spring配置文件  注意头标签-->

    <!--2.Spring容器管理对象
        id: Spring容器中对象的唯一标识 不能重复 一般类名首字母小写
        class: 类的全路径 包名.类名
    -->
    <bean id="user" class="com.jt.pojo.User"></bean>


</beans>

3.7 Spring入门案例

package com.jt;

import com.jt.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser {
   

    //测试方法返回值必须为void, 方法名不能是类名
    @Test
    public void testSpring01(){
   
        //1.通过加载配置文件,创建Spring容器对象  容器创建对象创建
        ApplicationContext context =
                new ClassPathXmlApplicationContext("application.xml");

        //2.从容器中获取对象  通过bean的Id获取对象
        User user = (User) context.getBean("user");
        /*User user2 = context.getBean(User.class);
        User user3 = context.getBean("user",User.class);*/

        //3.执行方法
        user.say();
    }
}

4 Spring IOC原理

4.1 Spring容器如何创建对象

1).当Spring程序执行时,首先会根据配置文件的内容进行解析

2).当程序解析到bean标签时,则会根据反射的机制实例化对象

@Test
    public void demo2() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
   
    //1.通过类的路径实例化类型...
    Class userClass = Class.forName("com.jt.pojo.User");
    //2.实例化对象
    User user = (User) userClass.newInstance();
    user.say();
}

3).将实例化好的对象保存到超大的Map集合中<K,V> bean中的Id当做map的Key,实例化好的对象当做Value
Map<id,对象>

4). 从容器中获取对象. 则从Map集合中通过id获取对象即可.

User user = (User) context.getBean("user");

4.2 关于反射机制补充说明

反射机制 必然调用对象的无参构造方法,所以特别注意!!!

public class User {
   
    //反射机制调用时，必然调用对象的无参构造，所以写构造方法时必须先写无参构造
    public User() {
   
        System.out.println("我是一个无参构造");
    }

    public void say() {
   
        System.out.println("您好Spring框架");
    }
}

5 工厂模式

5.1 问题

通过spring容器创建的对象一般是通过反射机制调用.但是有的时候由于业务需要需要实例化抽象类的对象/复杂的接口对象 Spring提供了工厂模式用于实例化复杂对象!!!

5.2 静态工厂模式

• 静态方法特点:
  • 静态方法调用可以通过类名直接调用. static
  • 静态属性 内存当中独一份.

5.2.1 编辑静态工厂

import java.util.Calendar;

public class StaticFactory {
   
    //通过静态工厂获取数据
    public static Calendar getCalendar() {
   
        return Calendar.getInstance();
    }
}

5.2.2 编辑配置文件

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

   <!--静态工厂实例化对象的写法 方法必须是static-->
   <bean id="calendar1" class="com.jt.factory.StaticFactory" factory-method="getCalendar"/>
</beans>

5.2.3 编辑测试方法

@Test
public void testStatic(){
   
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    Calendar calendar1 = (Calendar) context.getBean("calendar1");
    System.out.println("获取当前时间"+calendar1.getTime());
}

5.3 实例化工厂模式

• 调用:
  • 对象.方法()

5.3.1 编辑实例化工厂

import java.util.Calendar;

public class InstanceFactory {
   
    //获取Calendar对象
    public Calendar getCalendar(){
   
        return Calendar.getInstance();
    }
}

5.3.2 编辑xml配置文件

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

   <!--1.静态工厂实例化对象的写法 方法必须是static-->
   <bean id="calendar1" class="com.jt.factory.StaticFactory" factory-method="getCalendar"/>

   <!--2.实例化工厂   步骤1:将工厂交给spring容器管理   步骤2: 通过对象调用方法 -->
   <bean id="instanceFactory" class="com.jt.factory.InstanceFactory"></bean>
   <bean id="calendar2" factory-bean="instanceFactory" factory-method="getCalendar"></bean>

</beans>

5.3.3 编辑测试类

@Test
public void testInstance(){
   
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    Calendar calendar2 = (Calendar) context.getBean("calendar2");
    System.out.println("获取当前时间"+calendar2.getTime());
}

5.4 Spring工厂模式

如果需要创建复杂对象首选工厂模式

5.4.1 编辑工厂代码

import org.springframework.beans.factory.FactoryBean;

import java.util.Calendar;

public class SpringFactory implements FactoryBean<Calendar> {
   
    //工厂模式实例化对象的方法
    @Override
    public Calendar getObject() throws Exception {
   
        return Calendar.getInstance();
    }

    //获取类型
    @Override
    public Class<?> getObjectType() {
   
        return Calendar.class;
    }

    //默认条件下spring容器中都是单例对象  节省空间 单例对象  多例对象
    //多线程问题  多例对象 ?????  安全性问题!
    //多个资源对共享数据进行操作!!!!
    //对象.方法() 没有安全性问题  提倡使用单例
    @Override
    public boolean isSingleton() {
   
        return true;
    }
}

5.4.2 编辑xml配置文件

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

    <!--静态工厂实例化对象的写法 方法必须是static-->
    <bean id="calendar1" class="com.jt.factory.StaticFactory" factory-method="getCalendar"/>

    <!--2.实例化工厂   步骤1:将工厂交给spring容器管理   步骤2: 通过对象调用方法 -->
    <bean id="instanceFactory" class="com.jt.factory.InstanceFactory"></bean>
    <bean id="calendar2" factory-bean="instanceFactory" factory-method="getCalendar"></bean>

    <!--3.spring工厂模式 -->
    <bean id="calendar3" class="com.jt.factory.SpringFactory"></bean>
</beans>

5.4.3 编辑测试类代码

@Test
public void testSpringFactory(){
   
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    Calendar calendar3 = (Calendar) context.getBean("calendar3");
    System.out.println("获取当前时间"+calendar3.getTime());
}

5.4.4 回调执行原理