Spring学习笔记

1.Spring

1.1简介

• 2002年，首次推出Spring框架的雏形：interface21框架
• Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,于*2004年3月24日,*发布了1.0正式版。
• Rod Johnson ，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
• spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！

下载地址：

• 官网：https://spring.io/projects/spring-framework#overview
• 官方下载地址： http://repo.spring.io/release/org/springframework/spring
• GitHub：https://github.com/spring-projects/spring-framework

1.2优点

• Spring是一个开源的免费的框架（容器）！
• Spring是一个轻量级的、非入侵式的框架！
• 控制反转（IOC） ， 面向切面编程（AOP）！
• 支持事务的处理，对框架整合的支持！

总结：spring是一个轻量级的控制反转（IOC）面向切面编程（AOP）的框架

1.3组成

1.4拓展

在Spring的官网有这个介绍：现代化的Java开发！就是基于Spring的开发！

• Spring Boot
  • 一个快速开发的脚手架。
  • 基于SpringBoot可以快速的开发单个微服务。
  • 约定大于配置！
• Spring Cloud
  • SpringCloud 是基于SpringBoot实现的。

2.IOC理论推导

分层开发：

• dao层

1. UserDao接口
2. UserDaoImpl 1
3. UserDaoImpl 2
4. … 有多个实现类

• service

1. UserService接口
2. User ServiceImpl

我们通过UserServiceImpl来调用dao层，但是dao曾有多个实现类，我们需要修改SeviceImpl中的代码来实现不同的dao实现类的调用。控制权在业务层 在程序员手中。

如果我们在serviceImpl中通过set传入userDao,业务层不用去知道dao具体实现的类，这个交给用户，用户传入哪个就用哪个。将控制权交给用户。

    private UserDao userDao;

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

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

2.1IOC本质

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

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

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

3.HelloSpring

3.1导入spring相关jar包

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.2</version>
        </dependency>

3.2创建applicationContext.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">
   

</beans>

3.3编写相关代码

3.3.1编写实体类

package com.mahui.pojo;

public class Hello {
   
    private String string;

    public String getString() {
   
        return string;
    }

    public void setString(String string) {
   
        this.string = string;
    }

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

3.3.2编写bean

在applicationContext.xml中编写bean

  <bean id="hello" class="com.mahui.pojo.Hello">
        <!--name：属性名 value：属性值-->
        <property name="string" value="Spring"/>
    </bean>

3.3.3测试

public class MyTest {
   
    public static void main(String[] args) {
   
        //通过ClassPathXmlApplicationContext加载配置
       ApplicationContext Context = new ClassPathXmlApplicationContext("beans.xml");
        //从容器中拿出对象
        Hello hello = (Hello) Context.getBean("hello");

        System.out.println(hello.toString());
    }

3.4思考问题？

1. hello 对象谁创建的？

   hello是由spring创建的

2. hello对象的属性是怎么设置的？

   hello对象的属性是由spring属性设置的

这个过程成为控制反转：

• 控制：谁来控制对象的创建，传统的应用程序的对象是由程序本身创建的，但是使用spring之后，对象是由spring创建
• 反转：程序本身不创建对象，而变成被动的接收对象
• 依赖注入：利用set方法进行注入
• IOC是一种编程思想，有主动的编程，变为被动的接收，即对象由spring创建管理和装配

4.IOC创建对象的方式

4.1通过无参构造创建（默认）

   <bean id="user" class="com.mahui.pojo.User">
        <property name="name" value="小明"/>
     </bean>

4.2通过有参构造创建

4.2.1 通过参数类型

不建议使用通过参数类型来

    通过参数类型创建对象
    <bean id="user" class="com.mahui.pojo.User">
        <constructor-arg type="java.lang.String" value="小红"/>
    </bean>

4.2.2通过参数的下标

 通过参数下标创建对象
    <bean id="user" class="com.mahui.pojo.User">
        <constructor-arg index="0" value="小名"/>
    </bean>

4.2.3通过参数名来创建

    <!--通过参数名字创建对象-->
    <bean id="user" class="com.mahui.pojo.User">
        <constructor-arg name="name" value="小张"/>
    </bean>

5.Spring配置

5.1 别名

   <!--添加了别名，我们可以通过别名获得这个对象，也可以通过其原来的名字获得对象-->
    <alias name="user" alias="user2"/>

5.2Bean的配置

    
    <!--
        id ：bean的唯一标识，也就是对象名
        class：bean对象所对应的全限定名：包名+类型
        name：也就是别名 可以同时取多个别名
    -->
    <bean id="user" class="com.mahui.pojo.User" name="user3 user4;u5,u6">
        <property name="name" value="小明"/>
     </bean>

5.3import

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

• applicationContext.xml

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

使用的时候使用总的xml配置就可以了。

6.依赖注入

6.1构造器注入

上边ioc创建对象的方式已经写过

6.2set方式注入

• 依赖注入
  • 依赖：bean对象的创建依赖于容器
  • 注入：bean对象的属性由容器注入

6.2.1创建复杂环境

address

package com.mahui.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

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

people

package com.mahui.pojo;

import java.util.*;

public class People {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

6.2.2xml中注入

<?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="address" class="com.mahui.pojo.Address" >
        <property name="address" value="陕西西安"/>
    </bean>
    <bean id="people" class="com.mahui.pojo.People">
        <!--普通注入-->
        <property name="name" value="张三"/>
        <!--bean注入-->
        <property name="address" ref="address"/>
        <!--数组-->
        <property name="books">
            <array>
                <value>活着</value>
                <value>平凡的世界</value>
                <value>自在独行</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>玩游戏</value>
            </list>
        </property>
        <!--set-->
        <property name="games">
            <set>
                <value>cf</value>
                <value>lol</value>
            </set>
        </property>
        <!--map-->
        <property name="card">
            <map>
                <entry key="身份证" value="11111"/>
                <entry key="银行卡" value="11111"/>
            </map>
        </property>
        <!--null-->
        <property name="wife" >
            <value>null</value>
        </property>
        <property name="info">
            <props>
                <prop key="driver">12233</prop>
                <prop key