Spring学习（一）

Spring 学习（一）

1. 简介

官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

优点

1. Spring是一个开源免费的框架 , 容器
2. Spring是一个轻量级的框架 , 非侵入式的
3. 控制反转 IoC , 面向切面 Aop
4. 对事物的支持 , 对框架的支持

IoC理论推导

原先我们需要

1. UserDao接口
2. UserDaoImpl实现类
3. UserService业务接口
4. UserServiceImpl业务实现类

用户的需求会影响代码，程序员需要根据用户的需求修改源代码（UserServiceImpl）

==>在UserServiceImpl中使用set接口实现

之前，程序是主动创建对象，控制权在程序员手上。

使用set注入后，程序不再具有主动性，而是变成被动的接受对象。

这种思想，从本质上解决了问题，我们不用再去管理对象的创建了，系统的耦合性大大降低，可以更加专注在业务的实现上，这是IOC的原型！

2. IoC本质

狂神说

​ 控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

​ 控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3. 第一个Spring 程序

3.1 导包

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
    </dependencies>

3.2 编写实体类

package com.wdd.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }
    //！！！！!set注入！！！！!
    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

3.3 编写Spring文件 beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 使用Spring来创建对象,在Spring这些都称为Bean

       类型 变量名 = new 类型（）
       Hello hello = new Hello()
       id = 变量名(对象)
       class = new 的对象
       property 相当于给对象中的属性设置一个值
-->
    <bean id="hello" class="com.wdd.pojo.Hello">
        <!--
        name = 变量名
        value = 变量值
        -->
            <property name="str" value="String"/>
    </bean>
</beans>

3.4 测试

import com.wdd.pojo.Hello;
import javafx.application.Application;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中管理了，我们要使用，直接去里面取出来就可以
        Hello hello = (Hello)context.getBean("hello");   //"hello"  为beans.xml中bean的id
        System.out.println(hello.toString());
    }
}

总结

Hello对象的创建者：Spring

Hello对象的属性如何设置？ 由Spring容器设置

以上过程就叫控制反转！！！

1. 控制：谁来控制对象的创建。

• 传统应用程序的对象是程序本身控制创建的
• 使用Spring后，由Spring来创建

2. 反转：程序本身不创建对象，而变成被动的接收对象

依赖注入：利用set方法进行注入

IoC是一种编程思想，由主动的编程变成被动的接收

---

再举一个例子

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="mysqlImpl" class="com.wdd.dao.UserDaoMysqlImpl"/>
    <bean id="oracleImpl" class="com.wdd.dao.UserDaoOracelImpl"/>
    <bean id="UserServiceImpl" class="com.wdd.service.UserServiceImpl">
        <!--
         ref:引用Spring容器中创建好的对象
         value:具体的值，基本数据类型
         -->
        <property name="userDao" ref="oracleImpl"/>
    </bean>
</beans>

测试

import com.wdd.service.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test(){
//        //用户实际调用的是业务层，dao层不需要接触
//        UserServiceImpl userService = new UserServiceImpl();
//        userService.setUserDao(new UserDaoSqlServerImpl());
//        userService.getUser();

        //获取ApplicationContext,拿到Spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //需要什么，直接get
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
        userServiceImpl.getUser();
    }
}

IoC : 对象由Spring 来创建 , 管理 , 装配 ！！！

4. IoC创建对象方式

4.1 无参构造（默认）

​ 使用无参构造创建对象，默认！

4.2 有参构造

• 下标赋值

   <!-- 有参构造
    方法一、下标赋值
    -->
  <bean id="user" class="com.wdd.pojo.User">
      <constructor-arg index="0" value="wddd"/>
  </bean>

• 类型

  <!--方法二、通过类型创建（不建议使用）-->
    <bean id="user" class="com.wdd.pojo.User">
        <constructor-arg type="java.lang.String" value="wdddf"/>
    </bean>

• 参数名

 <!-- 方法三、直接通过参数名设置 -->
    <bean id="user" class="com.wdd.pojo.User">
        <constructor-arg name="name" value="kkkkl"/>
    </bean>

4.3 总结

在配置文件加载的时候，容器中管理的对象就已经初始化

5. Spring配置

5.1 alias别名

<alias name="user" alias="uuu"/>

5.2 Bean的配置

 <!--
    id : bean 的唯一标识符，相当于对象名
    class ： bean 对象所对应的全限定名 ：包名 + 类型
    name : 也是别名，且更高级，可以同时取多个别名(可以用 ， 或者 空格 或者 ; 分隔)
    -->
    <bean id="userT" class="com.wdd.pojo.UserT" name="user2 u2">
        <property name="name" value="wddhh"/>
    </bean>

5.3 import导入

​ 一般用于团队开发使用，可以将多个配置文件，导入合并为一个。

假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="beans.xml"/>
    <import resource="beans2.xml"/>
    <import resource="beans3.xml"/>

</beans>