Spring框架

一、spring框架简介

1、spring框架是一个轻量级的开源的Java EE框架

2、spring提高了IOC和AOP

IOC：控制反转，把创建Java对象的权力交给spring容器来处理。

AOP：面向切面编程，在不改变源代码的前提下可以扩充功能。

3、spring的特点

方便解耦，简化开发，层层之间的依赖降低。

声明式事务的支持

方便程序测试 提供单元测试的jar

方便集成各种优秀框架 继承第三方框架 mybatis

二、为什么使用spring

目的：降低耦合，这里的耦合指的是对象与对象之间的耦合。

举个简单的例子来说，有一千个类需要使用A类，而当A类升级为B类时，这一千个类都需要去改动，这就是一种高耦合性。我们可以使用工厂的模式来解决这个问题，定义一个工厂，工厂中有一个获取对象的静态方法，返回值为接口接口类型，这里就体现了接口的多态的特点。我们自己接的解耦的方法有很多的不足，使用Spring框架就可以很好的解决这个问题。

三、程序的耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

它有如下分类：

（1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。

（2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。

（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。

（5）标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。

（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。

（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。

总结：耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。

内聚与耦合：内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。

四、IOC控制反转

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

五、如何使用spring

（1）引入相关依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.19</version>
    </dependency>
</dependencies>

（2）创建spring的配置文件

<?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">

</beans>

（3）创建一个Dao类

public interface IUserDao {
    public void show();
}



public class UserDao implements IUserDao{
    @Override
    public void show() {
        System.out.println("-------UserDao----------");
    }
}

创建Java对象，并且在spring的配置文件中注册Java类，表示把一个类交给spring容器来创建，即加入下面语句

id:bean的唯一标识。
class: 类的全路径
<bean id="userDao" class="com.gjx.UserDao"></bean>

（4）测试类

public class Test {
    public static void main(String[] args) {
        //加载spring的配置文件，会创建在spring配置文件中注册的Java对象，默认使用无参构造创建对象
        ApplicationContext app = new ClassPathXmlApplicationContext("spring-config.xml");
        //获取bean对象  多态的特点
        IUserDao userDao = (IUserDao) app.getBean("userDao");
        userDao.show();//测试结果：-------UserDao----------
    }
}

六、BeanFactory和ApplicationContext的区别

Spring容器顶层接口：获取Bean对象；管理类和类之间的关系(依赖关系)BeanFactory由org.springframework.beans.factory.BeanFactory接口定义 BeanFactory是工厂模式（Factory pattern）的实现，是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。  

ApplicationContext的实现类常见的有三个

ClassPathXmlApplicationContext：-classpath路径加载xml文件的

FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的

AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置。

BeanFactory加载配置文件：

两个对象都写了构造方法，在spring的配置文件中也都加入了这两个对象的bean，BeanFactory加载配置文件，获取哪个bean对象就创建哪个Java对象，这种加载方式称为懒汉模式，也叫做懒加载

public class Test {
    
    public static void main(String[] args) {
        //读取配置文件
        ClassPathResource resource = new ClassPathResource("spring-config.xml");
        //解析配置文件
        XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(resource);
        //获取bean对象，拿到哪个bean就创建哪个Java对象
        UserDao userDao = (UserDao) xmlBeanFactory.getBean("userDao");
        userDao.show();
    }
}

ApplicationContext加载配置文件

 在读取到配置文件的时候，就会马上创建Java对象，这种模式叫做饿汉模式

面试题：BeanFactory 和 ApplicationContext 的区别：
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
单例模式下创建对象的时间点不一样：
ApplicationContext：(饿汉模式)只要一读取配置文件，马上就会创建配置文件中配置的对象。
BeanFactory：(懒汉模式)什么时候getBean("id")，也就是说当根据id获取对象时，才会创建。

我们常用的时饿汉式加载。

七、获取bean的方式

（1） 通过bean.xml文件中bean标签的id的值获取bean(使用默认构造方法)

根据bean的id获取bean对象，进行强制转换

IUserDao iUserDao = (IUserDao) app.getBean("userDao");

（2）通过类型获取

要确保bean的类型唯一，不然会报错

IUserDao userdao = app.getBean(IUserDao.class);

（3）通过id+类型获取

IUserDao userDao = app.getBean("userDao",IUserDao.class);

八、bean的作用范围

bean对象的作用范围调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）

单例：无论创建多少次对象，他们始终指向同一个实例

scope：常用 singleton,prototype

​ singleton：单例的（默认值）当加载配置文件时，就会创建对象。

​ prototype：多例的（当getBean时才会创建对象）

​ request：作用于请求范围---同一个那么使用bean同一个。

​ session：作用于会话范围---同一个会话

九、DI（Dependency Injection）依赖注入

DI依赖注入：目的是给对象中的属性赋值

依赖注入的类型：基本数据类型，字符串类型，引用类型，集合类型

十、实现注入对象的属性值

（1）注入基本数据类型和字符串类型

第一步，创建一个类，提供set方法

public class Student {
    private String name;
    private Integer age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

    public void setAge(Integer age) {
        this.age = age;
    }
}

第二步，spring配置文件中，在bean标签中添加property标签，将类的属性注入值

（2）注入类对象类型

Student类中有一个属性，属性的类型为类对象类型

 在配置文件中

 

 （3）注入集合类型

 测试student类属性注入

public class Test {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring-config.xml");
        Student student = (Student) app.getBean("student");
        System.out.println(student);
        //Student{name='饺子皮', age=21, clazz=Clazz{clazzId=1, clazzName='软工数182'}, hobby=[打游戏, 看小说, 追剧]}
    }
}

 （4）注入set和map类型

测试结果：

Student{name='饺子皮', age=21, clazz=Clazz{clazzId=1, clazzName='软工数182'}, hobby=[打游戏, 看小说, 追剧], set=[123, 234, 345], map={品牌=小米, 颜色=蜜桃金}}

十一、自动注入

UserController类

public class UserController {

    private IUserDao userDao;

    public void fun(){
        userDao.show();
    }

    public IUserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public String toString() {
        return "UserController{" +
                "userDao=" + userDao +
                '}';
    }
}

public interface IUserDao {
    public void show();
}

public class UserDao implements IUserDao{
    public UserDao() {
        System.out.println("UserDao构造方法");
    }

    @Override
    public void show() {
        System.out.println("-------UserDao----------");
    }
}

public class UserDao2 implements IUserDao{
    public UserDao2() {
        System.out.println("UserDao2的构造方法");
    }

    @Override
    public void show() {
        System.out.println("-------UserDao2----------");
    }
}

user.xml配置文件

autowire：有两个属性值，一个是byType（根据类型自动注入），一个是byName（根据id名称自动注入）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="userController" class="com.gjx.user.UserController" autowire="byType"></bean>
    <bean id="userDao" class="com.gjx.user.UserDao">

    </bean>
</beans>

执行结果为执行了UserDao 中的show方法

十二、使用注解完成IOC和DI功能

第一步，配置文件中设置包扫描

<context:component-scan base-package="com.gjx.food"/>

第二步，创建controller

@Controller
// 表示控制层注解
// 如果没有设置bean的id 默认为类的名称首字母小写
// 相当于在spring配置文件钟<bean id=""  class=""/>
public class FoodController {
    //按照类型自动注入 如果需要自己指定名称注入，需要使用另一个注解配合使用
    @Autowired
    @Qualifier("foodDao")
    private IFood f1;

    @Autowired
    @Qualifier("foodDao02")
    private IFood f2;

    public void fun(){
        f1.show();
        f2.show();
    }
}

第三步，Dao接口和实现类

public interface IFood {
    public void show();
}

@Repository
public class FoodDao implements IFood{
    @Override
    public void show() {
        System.out.println("FoodDao");
    }
}

@Repository
public class FoodDao02 implements IFood{
    @Override
    public void show() {
        System.out.println("FoodDao02");
    }
}

第四步，测试类

public class Test {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("food.xml");
        FoodController foodController = (FoodController) app.getBean("foodController");
        foodController.fun();
        //FoodDao
        //FoodDao02
    }
}

@Controlle、@Respository、@Service、@Component
没有区别: 他们的底层都是用的@Component，实际意思就在于区分层的。
@Controller控制层
@Respository持久化层
@Service 业务层
@Component 最底层的bean注解。

注：MVC的开发模式