Spring框架知识点

1. Spring概述

1.1 什么是框架？

框架（Framework）：框（指其约束性）架（指其支撑性），在软件设计中指为解决一个开放性问题而 设计的具有一定约束性的支撑结构。在此结构上可以根据具体问题扩展、安插更多的组成部分，从而更 迅速和方便地构建完整的解决问题的方案。

1、框架本身一般不完整到可以解决特定问题

2、框架天生就是为扩展而设计的

3、框架里面可以为后续扩展的组件提供很多辅助性、支撑性的方便易用的实用工具（utilities）， 也就是说框架时常配套了一些帮助解决某类问题的库（libraries）或工具（tools）。

如何学习框架呢？

1、知道框架能做什么

2、学习框架的语法，一般框架完成一个功能需要一定的步骤

3、框架的内部实现原理（扩展）

4、尝试实现一个框架（提升）

1.2 Spring是什么

Spring官网 Spring | Home

Spring具有控制反转（IoC）和面向切面（AOP）两大核心。Java Spring 框架通过声明式方式灵活地进 行事务的管理，提高开发效率和质量。

Spring 框架还是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术 和框架的能力。

1.3 Spring的优势

1、方便解耦，简化开发

2、方便集成各种优秀框架

3、降低 Java EE API 的使用难度

Spring 对 Java EE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了封装， 使这些 API 应用的难度大大降低

4、方便程序的测试

5、AOP 编程的支持

6、声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无须手动编程。

1.4 Spring的体系结构

Spring 为我们提供了一站式解决方案，但Spring 是模块化的，允许咱们挑选和选择适用于项目的模块， 不需要把剩余部分也引入。

Spring 框架提供约 20 个模块，可以根据应用程序的要求来选择。

2、Spring核心之IoC控制反转

2.1 IoC的概念

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。

IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建，因此，控制权由程序代码转移到了 Spring 容器中，控 制权发生了反转，这就是 Spring 的 IoC 思想。

例如：Javaweb中servlet并没有new就可以使用里面的dopostdoget方法，这就是tomcat服务器创建的对象，就是这种思想

2.2 Spring入门案例

2.2.1 创建maven项目

2.2.2 pom.xml文件添加依赖和插件

2.2.3 创建一个实体类

2.3.4 创建Spring的配置文件application.xml

2.3.5 使用Spring容器创建对象

2.3.6 获取Spring容器

Spring 提供了两种 IoC 容器，分别为 BeanFactory 和 ApplicationContext（BeanFactory的子类）

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource(Spring配置文件 的名称));

ApplicationContext applicationContext=new ClassPathXmlApplicationContext(Spring配 置文件的名称);   

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

2.3.7 通过上下文对象获取容器中的对象

容器中其他API

//容器中其他API
        //容器中对象的个数
        int beanDefinitionCount = applicationContext.getBeanDefinitionCount();
        System.out.println("容器中对象的个数:"+beanDefinitionCount);
        //容器中所有对象的名字
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        System.out.println("容器中对象的名字为：");
        for (String name : beanDefinitionNames) {
            System.out.println(name);
        }

 2.3.8 创建非自定义对象

<!--
        创建非自定义对象
    -->
    <bean id="data1" class="java.util.Date"></bean>

//获取日期对象（非自定义）
        Object data1 = applicationContext.getBean("data1");
        System.out.println(data1);

2.3.9 bean标签的属性 

public void init(){
        System.out.println("--------------init--------------");
    }

    public void destroy(){
        System.out.println("-----------------destroy--------------");
    }

<bean id="team1" class="com.kkb.pojo.Team" scope="singleton" lazy-init="true" init-method="init" destroy-method="destroy"></bean>
    <bean id="team2" class="com.kkb.pojo.Team" scope="prototype"></bean>

@Test
    public void test02(){
        String springConfig="application.xml";
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(springConfig);
        Team team1 = (Team) applicationContext.getBean("team1");
        Team team11 = (Team) applicationContext.getBean("team1");
        System.out.println(team1);
        System.out.println(team11);
        Team team2 = (Team) applicationContext.getBean("team2");
        Team team22 = (Team) applicationContext.getBean("team2");
        System.out.println(team2);
        System.out.println(team22);
        applicationContext.close();//关闭容器
    }

结果：

team-默认的构造方法 id=null,name=null,location=null
--------------init--------------
com.kkb.pojo.Team@32502377
com.kkb.pojo.Team@32502377
team-默认的构造方法 id=null,name=null,location=null
team-默认的构造方法 id=null,name=null,location=null
com.kkb.pojo.Team@2c1b194a
com.kkb.pojo.Team@4dbb42b7
-----------------destroy--------------

2.3 Spring容器创建对象的方式

2.3.1 使用默认的构造方法

2.3.2 使用带参数的构造方法

public Team(Integer id, String name, String location) {
        this.id = id;
        this.name = name;
        this.location = location;
        System.out.println("team-带参数的构造方法 id="+id+",name="+name+",location="+location);
    }

 <!--spring容器创建对象的方式：
    1、通过默认构造方法
    测试类：
    测试结果：
    2、通过带参数的构造方法
    3、通过工厂方法：实例方法，静态方法-->
    <!--1、通过默认构造方法-->
    <bean id="team1" class="com.kkb.pojo.Team"></bean>
    <!-- 2、通过带参数的构造方法-->
    <bean id="team2" class="com.kkb.pojo.Team">
        <!--name:表示参数的名称-->
        <constructor-arg name="id" value="1001"/>
        <constructor-arg name="name" value="公牛"/>
        <constructor-arg name="location" value="纽约"/>
    </bean>
    <bean id="team3" class="com.kkb.pojo.Team">
        <!--index:表示参数的下标索引-->
        <constructor-arg index="0" value="1002"/>
        <constructor-arg index="1" value="篮网"/>
        <constructor-arg index="2" value="华盛顿"/>
    </bean>

 @Test
    public void  CreateTypeTest01(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("createType.xml");
    }

结果：

team-默认的构造方法 id=null,name=null,location=null
team-带参数的构造方法 id=1001,name=公牛,location=纽约
team-带参数的构造方法 id=1002,name=篮网,location=华盛顿

2.3.3 使用工厂类

package com.kkb.pojo;
public class MyFactory {
    /**
     * 实例方法
     * @return
     */
    public Team instanceFun(){
        System.out.println("MyFactory------instanceFun");
        return new Team(1003,"湖人","洛杉矶");
    }
    /**
     * 静态方法
     * @return
     */
    public static Team staticFun(){
        System.out.println("MyFactory------staticFun");
        return new Team(1004,"小牛","达拉斯");
    }
    public static void main(String[] args) {
        MyFactory.staticFun();
        MyFactory factory=new MyFactory();
        factory.instanceFun();
    }
}

<!--3、通过工厂方法：
3.1 静态方法
Team team1 = MyFactory.staticFun();-->
    <bean id="staticTeam" class="com.kkb.pojo.MyFactory" factory-method="staticFun"></bean>

    <!--3、通过工厂方法：
3.2 实例方法
MyFactory factory=new MyFactory();
Team team = factory.instanceFun();-->
    <bean id="factory" class="com.kkb.pojo.MyFactory"></bean>
    <bean id="instanceTeam" factory-bean="factory" factory-method="instanceFun"></bean>

结果：

MyFactory------staticFun
team-带参数的构造方法 id=1004,name=小牛,location=达拉斯
MyFactory------instanceFun
team-带参数的构造方法 id=1003,name=湖人,location=洛杉矶

2.4 基于XML的DI（依赖注入）

：是组件之间依赖关系由容器在运行期决定，形象的说，即 由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为 了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过 简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资 源来自何处，由谁实现。

IoC 是一个概念，是一种思想，其实现方式多种多样。依赖注入就是其中用的比较多的一种方式。

Ioc和DI是同一个概念的不同角度描述。IoC是一种思想，概念，DI是实现它的手段。Spring框架使用依 赖注入实现IoC.

Spring 容器是一个超级大工厂，负责创建、管理所有的 Java 对象，这些 Java 对象被称为 Bean。 Spring 容器管理着容器中 Bean 之间的依赖关系，Spring 使用“依赖注入”的方式来管理 Bean 之间的依 赖关系。