Spring5框架 笔记总结
Posted IT_Holmes
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring5框架 笔记总结相关的知识，希望对你有一定的参考价值。
文章目录
1. Spring5
1.1 Spring5 概述
Spring 是轻量级的开源的JavaEE框架。
Spring 可以解决企业应用开发的复杂性。
Spring 有两个核心部分： IOC(Inversion of Control, 控制反转) 和 AOP( Aspect Oriented Programming ， 面向切面编程)
Spring是分层的Java SE/EE应用 full-stack 轻量级开源框架，以IOC和AOP为内核。
IOC(Inversion of Control, 控制反转) : 把创建对象过程交给spring进行。
AOP(Aspect Oriented Programming , 面向切面编程)：不修改源代码进行功能增强。
Spring的特点：
- 方便解耦，简化开发（将对象间的依赖关系交由Spring进行控制，避免过度耦合）。
- AOP编程支持。
- 方便程序的测试。
- 方便集成整合各种优秀框架(Struts，Hibemate等)。
- 方便进行事务操作（Spring ，通过声明式方式灵活的进行事务管理）。
- 降低Java API的开发难度。
1.2 其他框架
SSH框架 ： Struct2 + Spring + Hibernate(自动)
SSM框架 ： SpringMVC + Spring + Mybatis(半自动)
学习顺序：
Spring Boot
- 一个快速开发的脚手架。
- 基于SpringBoot可以快速的开发单个微服务。
Spring Cloud
- Spring Cloud 是基于Spring Boot实现的，用来管理它的。
2. Spring5 的相关jar包下载
Spring5下载相关jar包：https://spring.io/projects/spring-framework#learn
注意GA 和 snapshot的区别：
General Availability,正式发布的版本。
想要下载其他版本的可以访问该地址：
https://repo.spring.io/ui/native/release/org/springframework/spring
Spring大体上的一个模块框架：
Core Container：核心容器 ，这个是最基础要掌握的，上面的操作都是基于核心容器来实现的。
3. Spring5 IOC容器
3.1 为什么要用IOC？
做程序讲究高内聚，低耦合。
一般我们的声明对象调用方法，都是new 对象，调用该对象的方法，但是如果我们修改了对象方法的名字，那么一下子啊就要改所有调用该方法的对象，这样耦合度太高了。
对于上面这种情况可以通过工厂模式来达到一个解耦效果：(通过UserFactory，大大降低了UserService和UserDao直接的耦合。)
但是，工厂模式下的耦合度还不是最低的，还可以通过IOC来实现这降低耦合！！
3.2 什么是 IOC？
IOC控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。
没有IOC冲虚，一系列的对象创建都是由程序自己完成，控制反转后将对象的创建转移给第三方，也就是获得依赖对象的方式反转了。
使用IOC目的：为了耦合度降低。
IOC的底层原理由三个部分组成：
- xml解析。
- 工厂模式。
- 反射
也就是说学spring之前，java的工厂模式和java反射都要知道！
IOC总结：
采用xml方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述(XML或注解) 并通过第三方去生产或获取特定的对象方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入(Dependency Injection , ID)
3.3 IOC 接口
IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
spring提供了实现IOC容器的两种方式：(也就是两个接口)
- BeanFactory接口：该接口是IOC容器最基本的实现方式，是spring内部自带的接口，不提供开发人员进行使用。
- ApplicationContext接口：它是BeanFactory接口的子接口，提供了更多更强大的功能，一般是开发人员使用的。
上面两个都能实现IOC容器。
2. Spring 实例
所谓的IOC就是：对象由Spring来创建，管理，装配。
创建一个maven项目，在pom.xml中导入spring的相关依赖：
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.9</version>
</dependency>
</dependencies>
如下案例：
创建一个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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用spring来创建对象，在Spring中这些都称作为Bean-->
<!--反转：程序本身不创建对象，而变成被动的接受对象。-->
<bean id="hello" class="com.itholmes.pojo.Hello">
<!--property属性作用就是为str设置一个值。-->
<!--依赖注入：就是利用set方法进行注入的，也就是这里的str必须在自己的类中有set方法，来修改它才行！！！-->
<property name="str" value="Spring"/>
<!--
property中，ref属性和value属性不同：
ref:引用spring容器中创建好的对象。
value:具体的值，基本数据类型。
-->
</bean>
</beans>
在maven中的main/java中创建hello.java类
package com.itholmes.pojo;
/*
概述：
@Date:Create in 9:36 2021/12/27
*/
public class Hello
private String str;
public String getStr()
return str;
public void setStr(String str)
this.str = str;
@Override
public String toString()
return "Hello" +
"str='" + str + '\\'' +
'';
在maven的test/java中测试能否通过xml文件创建管理类：
/*
概述：
@Date:Create in 9:48 2021/12/27
*/
import com.itholmes.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Mytest
public static void main(String[] args)
//获取spring的上下文对象context，也就是获取ApplicationContext：拿到Spring的容器。
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在Spring中管理了，我们要使用，直接去里面取出来调用就可以了。
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
bean属性ref的使用：
注意：idea提示创建上下文参数
上面的意思可以理解为创建一个新的程序上下文参数，配置该文件到spring项目中去。
完成上面操作，我们在类中可以看到相关的标签已经导入进来：
3. Spring IOC创建对象的方式
3.1 使用无参构造器创建对象(默认)
IOC在配置xml文件控制反转时，创建对象也是分无参数和有参数的，默认的就是无参数构造器。
3.2 有参数构造器创建对象
方式一，index下标的方式：
<!--第一种：使用index下标赋值。-->
<bean id="user" class="com.itholmes.pojo.User">
<constructor-arg index="0" value="张三"/> <!--第一个参数-->
<constructor-arg index="1" value="18"/> <!--第二个参数-->
</bean>
方式二：通过使用类型创建，不建议使用！
<!--第二种：通过使用类型创建，不建议使用！-->
<bean id="user" class="com.itholmes.pojo.User">
<!--注意基本类型可以直接用int，short等等，但是String引用类型必须写全，平时我们代码中直接写的String的也只是java.lang.String的别名而已。-->
<constructor-arg type="java.lang.String" value="张三"/>
<constructor-arg type="int" value="18"/>
</bean>
第三种：通过使用参数名和name属性来传递参数，建议使用。
<!--第三种：通过使用参数名和name属性来传递参数。-->
<bean id="user" class="com.itholmes.pojo.User">
<constructor-arg name="name" value="张三"/>
<constructor-arg name="age" value="18"/>
</bean>
我们平时说的spring容器就是下面的context：
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了。
这句话意思不难理解，就是我们所有配置在beans中的内容，都将会在new ClassPathXmlApplicationContext(“beans”); 执行完后将beans中所有的配置的类对象，全部加载创建完毕。之后我们想调用谁就调用谁，也就是在一个容器当中想用谁就用谁。
4. Spring 配置
4.1 别名
alias别名：就是给user起了个别名,同样我们可以使用别名获取到这个对象。
<!--alias别名：就是给user起了个别名,同样我们可以使用别名获取到这个对象。-->
<alias name="user" alias="alias_user"/>
4.2 Bean标签 的配置属性
对于Bean标签的配置属性，基本的如下：
<!--
id: bean的唯一标识符，也就是对应对象名。
class: bean对象所对应的全限定名，全限定名就是包名加类名。
name: 这里的name是当前bean的别名,并且name可以取多个别名。（中间分隔，可以用空格，逗号，分号都可以进行分隔效果。）
-->
<bean id="AddrT" class="com.itholmes.pojo.AddrT" name="T,T2,abcT3">
</bean>
4.3 import标签
import标签，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个。
import标签功能很强大，如果遇到相同的内容，就会覆盖一起，别名也是一样的。
5. 依赖注入
5.1 什么是依赖注入？
在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入(Dependency Injection , ID)
5.2 构造器注入
构造器，在第三节的Spring IOC创建对象的方式中已经说明。
5.3 Set方式注入(重点)
依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器。
- 注入：bean对象中的所有属性，由容器来注入！
set注入效果如下：
<?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">
<bean id="addr_id" class="com.itholmes.pojo.Address">
<property name="address" value="上海"/>
</bean>
<bean id="student" class="com.itholmes.pojo.Student">
<!--name属性指向的是类中的变量属性名。-->
<!--第一种，普通值注入：value属性-->
<property name="name" value="张三"/>
<!--第二种，Bean值注入：ref属性-->
<property name="address" ref="addr_id"/>
<!--第三种，数组注入：array标签-->
<property name="books">
<array>
<value>三国演义</value>
<value>水浒传</value>
<value>红楼梦</value>
<value>西游记</value>
</array>
</property>
<!--第四种，list集合注入：list标签-->
<property name="hobbys">
<list>
<value>听歌</value>
<value>玩游戏</value>
<value>打篮球</value>
</list>
</property>
<!--第五种，map集合注入：map标签和entry标签使用-->
<property name="card">
<map>
<entry key="学号" value="123"/>
<entry key="姓名" value="itholmes"/>
</map>
</property>
<!--第六种，Set集合注入：set标签-->
<property name="game">
<set>
<value>123</value>
<value>456</value>
<value>789</value>
</set>
</property>
<!--第七种，null值注入：null-->
<property name="wife">
<null/>
</property>
<!--空字符串的注入如下：-->
<!--<property name="wife" value=""/>-->
<!--第八种，Properties注入：props标签和prop标签-->
<property name="info">
<props>
<prop key="username">root</prop>
<prop key="password">root</prop>
<prop key="url">jdbc:mysql://localhost:3306/</prop>
<prop key="driver">com.mysql.jdbc.Driver</prop>
</props>
</property>
</bean>
</beans>
student类:
package com.itholmes.pojo;
/*
概述：
@Date:Create in 9:12 2021/12/28
*/
import java.util.*;
public class Student
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> game;
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> getGame()
return game;
public void setGame(Set<String> game)
this.game = game;
public String getWife() Spring5框架 笔记总结