Spring基础_万物皆bean

一、初识Spring框架

1、时代变迁

原始时代我们用一个jsp搞定一切，但如此开发大型项目时我们遇到了问题，前端美化的代码和后端的代码交织，代码中又有html、js、css样式，又有业务逻辑和数据库访问代码，杂乱不清晰，美工和开发打架。

于是mvc分层架构封建时代出现，把我们写代码的地方硬性分成3个地方，Model层封装数据，View视图层页面展现，Controller控制层访问转发。代码之间的耦合度降低。概念有了，需要实际干活的。于是随着mvc分层概念的深入人心，业界涌现出很多实现框架，最著名的莫过于struts1和struts2。随着前端框架的成熟，后端框架也应运而生如：dbutils、jdbcTemplate、hibernate、ibatis、mybatis。

一个前端WEB层框架有了，一个后端数据库层访问框架有了，那中间呢？谁来胜任？spring破石而出。

2、Spring的野心

了解了历史，有个问题值得我们去深思？spring到底想干什么？

它想把全球最好的技术组合到一起，为企业提供高质量的企业级的应用程序框架，减轻开发者开发的难度，减少重复的代码。

目标很宏大，那如何下手呢？如果是你，你会怎么实现？第一步要干什么呢？

我们拿经典的框架来举例子。

struts2作为WEB框架深受企业爱戴，它会自己管理action，来创建其实例，这样在程序中就可以访问action的资源。hibernate作为持久层优秀的框架，它也自己管理持久对象。可以看到，各个诸侯都自己管理对象，而要想让它们对象复用，那真是繁琐。前面就有失败者WebService，为了管理不同的开发语言的对象而层层包装转换，辛苦制定的规则，还借着J2EE规范之名，也推广不开。

如何破局呢？想发号施令，想让人听从，最好的解决办法就是扼住他们的咽喉。在java的世界里最重要的无疑就是对象的生命周期管理。于是spring以此为切入点，实现自己的统治。官宣所有对象由我来管理，struts2你不再管理对象，由我来管理，你要用从我这拿。hibernate你也不再管理对象，由我来管理，你要用从我这拿。你说管就能管的吗？这两个征战数年战功赫赫的大将军会听一个初出茅庐乳臭未干野小子的话？他们当然不会听，spring的话可以不听，但他们都要听开发者的。开发一个完整的系统有四个核心，WEB层支持、业务逻辑层、持久层支持、事务支持。而这就是它们的软肋，这就是它们的命门所在，它们只能完成一部分工作，不是一个整体解决方案。而spring并没有抹杀它们，而是依然给它们高官厚禄，承认它们的市场地位，还赠与一个事务管理。一边打压一边拉拢，它们两位看看大势已去，只能俯首称臣。于是兵不血刃，一场变革悄然兴起，一个经典的三层框架诞生SSH （Strut2+Spring+Hibernate）。

故事很传奇，听的人很开心。可spring真就这么简单吗？如果这样想，你就大错特错了。例如：spring怎么来实现对象的管辖？怎么让不同技术之间能简单的互相配合？这才是spring的决胜之处。

为实现这些spring可是绞尽脑汁、煞费苦心呢。它创新的形成了一套新的理论体系，可谓前无古人后无来者。其中最核心的是：IoC控制反转、DI依赖注入、Bean工厂、SpringAOP面向切面编程、事务控制。

并且spring并没有停止不前，这只是统治地球的第一步，随着spring占领市场后，开始对有功之臣进行清洗，struts2不再优秀，致命bug层出不穷，刚好落井下石，spring推出了springmvc，最终终结了struts2。hibernate想用jdbcTemplate和jdo替代，却被mybatis超越，目前还未统一。世界又达到新的平衡，经典的新三大框架诞生，SSM（SpringMVC+Spring+MyBatis）。Spring并没有放弃，而是另辟蹊径，推出新的产品SpringBoot+SpringCloud 微服务，目前新的趋势已经尘埃落定，一统江湖！

3、官网

http://spring.io

4、框架组成

Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。Spring框架的不光是技术牛，而是它的核心思想更牛，它不重复发明轮子，而是"拿来主义"，把业界做的最好的技术黏合起来形成一个强大的企业级的应用框架。

Spring 框架是一个分层架构，由7个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如下图所示：

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

Spring 框架的功能可以用在任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定J2EE服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE环境（Web或EJB）、独立应用程序、测试环境之间重用。

Spring以一种非侵入式的方式来管理你的代码，Spring提倡"最少侵入"，这也就意味着你可以适当的时候安装或卸载Spring ，但这点越来越模糊。

5、核心概念

6、三大核心组件的关系

Bean、Context、Core三大核心组件的关系：

Bean 包装的是 Object，而 Object 必然有数据，如何给这些数据提供生存环境就是 Context要解决的问题，对 Context 来说它就是要发现每个 Bean 之间的关系，为它们建立这种关系并且要维护好这种关系。所以 Context 就是一个Bean关系的集合，这个关系集合又叫 Ioc 容器，一旦建立起这个 Ioc 容器后 Spring 就可以为你工作了。那 Core 组件又有什么用武之地呢？其实Core 就是发现、建立和维护每个 Bean 之间的关系所需要的一些类的工具，从这个角度看来，Core 这个组件叫 Util 更能让你理解。

把Bean 比作一场演出中的演员的话，那 Context 就是这场演出的舞台背景，而 Core应该就是演出的道具了。只有他们在一起才能具备能演出一场好戏的最基本的条件。当然有最基本的条件还不能使这场演出脱颖而出，还要他表演的节目足够的精彩，这些节目就是 Spring 能提供的特色功能了。

7、主要jar组成

二、Spring框架两大核心：IoC和DI

1、概念

IoC（Inversion of Control）简单来说就是将对象Object的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理，而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。

在创建对象的过程中Spring可以依据对象的关系，自动把其它对象注入（无需创建对象，直接拿着使用）进来，这个过程称之为DI（Dependency Injection）依赖注入。

总结下Spring核心就干了两件事：
1）创建对象
2）设置对象的关联关系

2、loc

IOC（Inversion of Control），控制反转。

就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。

3、DI

DI（Dependency Injection）依赖注入 。

相对于IoC而言，依赖注入(DI)更加准确地描述了IoC的设计理念。所谓依赖注入，即组件之间的依赖关系由容器在应用系统运行期来决定，也就是由容器动态地将某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。

三、IoC的XML方式

1、项目结构，创建springboot工程

2、创建类，Hello.java

package cn.tedu.spring;

public class Hello {
    void hi(){
        System.out.println("hello spring ioc~ ");
    }
}
1
2
3
4
5
6
7

3、创建配置文件，配置类的信息，applicationContext.xml

选中resources-右键-new-xml config…-spring config-输入文件名-回车

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

    <!--
        配置一个类的信息 id是bean的唯一标识  class是类的全路径
        配置一个类的信息id是bean的唯一标识class是类的全路径当配置完成时，spring框架自动ioc，帮你new 。
        Map<String,Object> - {hello = new Hello()}
        Map<String,0bject> - {hello = Class.forName( " cn.tedu. spring.Hello").newInstance() }

    -->
    <bean id="hello" class="cn.tedu.spring.Hello"></bean>
    <bean id="Hello" class="cn.tedu.spring.Hello"></bean>

</beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4、创建TestIoC.java，读取配置文件，直接获取对象

package cn.tedu.test;

import cn.tedu.spring.Hello;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestIOC {

    @Test //单元测试
    public void ioc(){
        //读取配置文件，获取对象
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext("spring-config.xml");

        //获取对象--参数配置文件里的bean的id属性
        Object o = spring.getBean("hello");
        System.out.println(o);
        Object o1 = spring.getBean("Hello");
        System.out.println(o1);

        //获取Hello方法
        //向下造型
        Hello h = (Hello)o;
        h.hi();

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

5、总结

这就是spring框架的IoC，控制反转。之前我们自己new出新类。new User();变成由一个初始化的xml配置文件来创建，也就是由spring容器来创建。遍历xml配置文件，读取到<bean>，获取到class属性的类的全路径，利用反射创建这个类。

在java范畴中万物皆Object,在Spring中万物皆Bean。Bean是Spring的核心、基础、根源。

四、IoC的注解方式

哪个类想让spring框架new，就在类上使用注解：@Component / @Service / @Controller

1、创建springboot工程

2、pom.xml

<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>cn.tedu</groupId>
	<artifactId>spring</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<!-- 集中定义依赖版本号 -->
	<properties>
		<junit.version>4.10</junit.version>
		<spring.version>4.1.3.RELEASE</spring.version>
	</properties>

	<dependencies>
		<!-- 单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>

		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

	</dependencies>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3、创建类，使用注解

package cn.tedu.spring2;

import org.springframework.stereotype.Component;

//Map<类名首字母要小写,类的对象> - {user=new User()}
@Component
public class User {
    public void get(){
        System.out.println("hello springioc");
    }
}
1
2
3
4
5
6
7
8
9
10
11

4、创建配置文件，只需要指定包的路径

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

    <!-- 包扫描：只需要指定从哪个包开始扫描,
        用了@Component注解的类,自动ioc
        base-package需要指定一个包的路径
    -->
    <context:component-scan base-package="cn.tedu.spring2"></context:component-scan>

</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13

@Component / @Service / @Controller全部扫描，包扫描需要创建配置文件，指定包的路径

5、读取配置文件，获取对象

package cn.tedu.test;

import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
//测试 注解开发
public class TestIOC2 {
    @Test
    public void ioc2(){
        //1,读取核心配置文件
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext(
                        "spring-config2.xml");
        //2,getBean -- 参数是类名，但是首字母要变成小写才行
        Object o = spring.getBean("user");
        System.out.println(o);//cn.tedu.spring2.User@37d4349f

        Object o2 = spring.getBean("userInfo");
        System.out.println(o2);//cn.tedu.spring2.UserInfo@2805d709

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

6、总结

五、模拟SpringIoC的实现

1、概念

SpringIoC控制反转底层实现利用了java自身提供的反射技术来创建对象

Class.forName(classPath).newInstance();
1

通过这种方式，spring控制了对象的生命周期，可以随时自行增强对象，如DI依赖注入，如AOP，环绕通知在类创建前后增强功能，如Transaction事务加强等。

2、开发步骤

1）创建容器管理bean，并初始化容器->； [user,dept,hello]
2）创建spring容器，并初始化容器->； {hello=new Hello(),user=new Uer() }
3）提供getBean()，根据bean的名字，从spring容器中获取对应的对象

3、创建Bean类，描述类的信息，Bean.java

抽象Bean的定义，取代java中的Object，Spring框架中万物皆Bean。

3.1、自己导入get、set、tostring、构造方法

package cn.tedu.myioc;

//描述一个类的信息，Spring把每个类当做一个bean
public class Bean {
    private String beanName; //类的名字
    private String beanPath;//类的全路径

    //contructors
    public Bean() {
    }

    public Bean(String beanName, String beanPath) {
        this.beanName = beanName;
        this.beanPath = beanPath;
    }

    //get set tostring
    public String getBeanName() {
        return beanName;
    }

    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }

    public String getBeanPath() {
        return beanPath;
    }

    public void setBeanPath(String beanPath) {
        this.beanPath = beanPath;
    }

    @Override
    public String toString() {
        return "Bean{" +
                "beanName='" + beanName + '\'' +
                ", beanPath='" + beanPath + '\'' +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3.2、使用lombook注解，自动提供get、set、tostring、构造方法

package cn.tedu.myioc;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//描述一个类的信息，spring把每个类当做一个bean
@Data //自动提供 get set tostring equals hashCode
@NoArgsConstructor	//提供无参构造
@AllArgsConstructor //提供全参构造
public class Bean1 {
    private String beanName; //类的名字
    private String beanPath;//类的全路径
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4、创建Spring容器，并指定要维护的类，提供getBean()，根据beanName获取对象

package cn.tedu.myioc;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MyIOC {
    //1,创建list,存好多bean
    private List<Bean> beans = new ArrayList<>();
    public MyIOC() throws Exception {
        Bean b1 = new Bean("hello","cn.tedu.myioc.Hello");
        Bean b2 = new Bean("user","cn.tedu.myioc.User");
        beans.add(b1);
        beans.add(b2);
        //new
        init();
    }
    Map<String,Object> map = new HashMap<>();
    //2,创建map,存对象 { hello=new Hello() , user=new User()}
    public void init() throws Exception {
        //遍历list，获取每个bean
        for(Bean b : beans){
            String key = b.getBeanName();
            String quanlujing = b.getBeanPath();
            Object value = Class.forName(quanlujing).newInstance();
            map.put(key,value);
        }
    }
    //3,getBean()--根据key获取value
    public Object getBean(String beanname){
        return map.get(beanname) ;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

5、创建类

6、测试

package cn.tedu.myioc;
public class Test1 {
    public static void main(String[] args) throws Exception {
        MyIOC my = new MyIOC();

        //根据类名，获取类的对象
        Object o = my.getBean("hello");
        System.out.println(o);//cn.tedu.myioc.Hello@54bedef2

        //根据类名，获取类的对象
        Object o2 = my.getBean("user");
        System.out.println(o2);//cn.tedu.myioc.User@5caf905d
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7、总结

六、DI

1、概述

依赖注入，前提是先使用注解@Component完成IOC
两个类(对象)间的关系，使用@Autowried完成DI

2、测试

2.1)、创建Dept类，Dept.java

package cn.tedu.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Component //交给spring进行IOC
//@Data   //自动提供 get set tostring equals hashCode
//@NoArgsConstructor
//@AllArgsConstructor
public class Dept {
   public String name ="java研发部门";

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2)、创建User类，User.java

package cn.tedu.pojo;

import lombok.Data;
import org.springframework.stereotype.Component;

@Component//交给spring进行IOC
//@Data //自动提供 get set tostring equals hashCode
public class User {
    String name = "张三";

    //描述User类和Dept类的关注
    private  Dept d ;

    public Dept getD() {
        return d;
    }

    public void setD(Dept d) {
        this.d = d;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", d=" + d +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2.3)、测试

创建单元测试类，测试是否能获取对象信息

package cn.tedu.di;

import cn.tedu.pojo.Dept;
import cn.tedu.pojo.User;

public class Test1 {
    public static void main(String[] args) {
        User u = new User();
    //先设置部门信息，否则永远获取的是null
        u.setD(new Dept());
        //获取用户的部门信息
        Dept dept = u.getD();
        //获取部门名称
        System.out.println(dept.name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3、SpringDI

关联studen和teacher类

1、创建Teacher类，Teacher.java

package cn.tedu.vo;

import org.springframework.stereotype.Component;

@Component//ioc
public class Teacher {
    public String name = "jack" ;
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、创建Student类，Student.java

package cn.tedu.vo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component//ioc
public class Student {
    public String name = "张三" ;
    // 表示两个类之间的关系
    @Autowired//DI依赖注入,自动装配,自动布线
    Teacher t ;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", t=" + t +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3、 创建核心配置文件，配置包扫描的路径

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

    <!--包扫描：扫描指定包路径下的所有类
        哪些类有@Component注解,就帮哪些类new-ioc
    -->
    <context:component-scan base-package="cn.tedu.vo"></context:component-scan>
</beans>

1
2
3
4
5
6
7
8
9
10
11
12

4、测试

package cn.tedu.di;

import cn.tedu.vo.Student;
import cn.tedu.vo.Teacher;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//测试springdi
public class Test2 {
    public static void main(String[] args) {
        //1,读取核心配置文件
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext(
                        "spring-config.xml");
        //2,根据类名，获取对象
        //右侧返回的是Object父类，左侧要子类--需要强转--向下转型--是为了使用子类的功能
        Teacher t = (Teacher) spring.getBean("teacher");
        System.out.println(t);//Teacher{name='jack'}

        Student s = (Student) spring.getBean("student");
        //DI：在获取学生信息的同时，也获取到了关联的老师信息
        System.out.println(s);//Student{name='蔡徐坤', t=Teacher{name='jack'}}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5、总结