1.Spring5基础知识
本篇文章是根据B站狂神说Java系列的Spring5的笔记记录 —— 第一篇Spring5入门了解
gitee：https://gitee.com/ywq869819435/spring5
1、Spring
1.1、简介
- 2002首次推出了Spirng的雏形：interface21
- 2004.3月发布spring 1.0
- 理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的技术框架！
- SSH： Struct2 + Spring + Hibernate
- SSM：SpringMvc + Spring + Mybatis
1.2、优点
- spring是一个开源的免费的框架(容器)！
- Spring是一个轻量级、非入侵式（不会破坏原项目的运行）的框架！
- 两个特点：控制反转(IOC)和面向切面编程(AOP)
- 支持事物的处理，对框架整合的支持
总结
spring就是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架
1.3、组成
Spring-Core(核心容器)：
Core包是框架的最基础部分，并提供依赖注入（Dependency Injection）管理Bean容器功能。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正地允许你从程序逻辑中分离出依赖关系和配置。
Spring-Context：(Spring核心容器<上下文模块>)
核心模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。这个模块扩展了BeanFactory的概念，增加了消息、事件传播以及验证的支持。另外，这个模块提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括了对模版框架例如Velocity和FreeMarker集成的支持。
Spring-Aop：
Spring在它的AOP模块中提供了对面向切面编程的丰富支持。例如方法拦截器（servletListener ,controller…）和切点，可以有效的防止代码上功能的耦合，这个模块是在Spring应用中实现切面编程的基础。Spring的AOP模块也将元数据编程引入了Spring。使用Spring的元数据支持，你可以为你的源代码增加注释，指示Spring在何处以及如何应用切面函数。
Spring-Dao:
使用JDBC经常导致大量的重复代码，取得连接、创建语句、处理结果集，然后关闭连接、旧代码中迁移自定义工具类JDBCUtil 也让开发变得繁琐。Spring的Dao模块对传统的JDBC进行了抽象，还提供了一种比编程性更好的声明性事务管理方法。
Spring-Web:
Web上下文模块建立于应用上下文模块之上，提供了WEB开发的基础集成特性，例如文件上传。另外，这个模块还提供了一些面向服务支持。利用Servlet listeners进行IOC容器初始化和针对Web的applicationcontext。
Spring Web MVC:
(Model-View-Controller)Spring为构建Web应用提供了一个功能全面的MVC框架。它提供了一种清晰的分离模型，在领域模型代码和web form之间。并且，还可以借助Spring框架的其他特性。
Spring-ORM:
关系映射模块，ORM包为流行的“关系/对象”映射APIs提供了集成层，包括JDO，Hibernate和iBatis（MyBatis）。通过ORM包，可以混合使用所有Spring提供的特性进行“对象/关系”映射，方便开发时小组内整合代码。
1.4、扩展
- Spring Boot
- 一个快速的开发的脚手架
- 基于Spring Boot可以快速的开发单个微服务
- 约定大于配置！
- Spring Cloud
- Spring Cloud 是基于Spring Boot 实现的
- 写在大部分的公司都在使用SpringBoot进行快速发开，学习SpringBoot的前提，需要完全掌握Spring以及SpringMVC！承上启下的作用
- 弊端：Spring发展太久之后，违背了原来的理念！配置十分繁琐，人称“配置地狱”
2、IoC理论推导
思想原型
private UserDao userDao;
// 利用set进行动态值的注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
- 在开发系统的时候，往往会存在将对象的创建类型选择或者其他方面的控制权交有程序本身去单一的实现，这样往往存在需求变化的时候需要更改大量源码的问题，成本很高，耦合性高。
- 之后设计理念中强调，控制反转，将控制权交由客户，客户就可以更快捷的根据自己的需求去选择对应的对象。系统的耦合性就大大降低了，可以更加专注于业务的实现，程序上就不需要大幅度的更改。
IOC本质
-
控制反转IOC（Inversion of Control），是一种设计思想，DI（依赖注入）是显示IOC的一种方法，没有IOC的程序中，使用面向对象编程没对象的创建于对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓的控制反转就是：获得依赖对象的方式反转了
-
图示：ABCD这个对象原来是直接相互关联的，这时候其实中间可以加多一个IOC容器去控制选择的对象
-
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
-
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
3、HelloSpring(例子)
3.1、新建一个模块
3.2、代码内容
code
-
实体类
package com.yang.entity; public class Hello { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } public void show(){ System.out.println("Hello"+ name ); } } -
xml配置文件
<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="hello" class="com.yang.entity.Hello"> <property name="name" value="Spring"/> bean> beans> -
测试
import com.yang.entity.Hello; 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中的管理了，要使用直接去里面取出来就可以了 // getBean: 参数即为spring配置文件中bean的id Hello hello = (Hello) context.getBean("hello"); hello.show(); } }
分析
- Hello对象是由Spring创建的
- hello对象的属性是由Spring容器设置的
- 这个由Spring容器创建的过程就是控制反转
- 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
- 反转 : 程序本身不创建对象 , 而变成被动的接收对象
- 依赖注入 : 本质就是利用set方法来进行注入的（对象中必须有set方法）
- IOC是一种编程思想 , 由主动的编程变成被动的接收
- 实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配
简单示例
Spring容器：
<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="impl" class="com.yang.dao.UserDaoImpl"/>
<bean id="mysqlImpl" class="com.yang.dao.UserDaoMysqlImpl"/>
<bean id="oracleImpl" class="com.yang.dao.UserDaoOracleImpl"/>
<bean id="userServiceImpl" class="com.yang.service.UserServiceImpl">
<property name="userDao" ref="mysqlImpl" />
bean>
beans>
测试启动类：
class testUser {
@Test
void getUser() {
// 写好spring容器配置之后这一段代码不需要再使用
// UserSerivce userSerivce = new UserServiceImpl();
// userSerivce.getUser();
// 写好spring容器配置之后使用如下代码，获取ApplicationContext：
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
// 有容器之后需要什么就get什么
UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
userServiceImpl.getUser();
}
}
具体其他类就不再展示。
4、IoC创建对象的方式
-
默认使用无参构造创建对象
-
需要使用有参构造写法如下：
<bean id="user" class="com.yang.entity.User"> <constructor-arg name="name" value="ywq"/> bean> -
在配置文件加载的时候，容器中管理的对象就已经初始化了
public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); User user = (User) context.getBean("user"); User user2 = (User) context.getBean("user"); // 这里输出true表明地址相同，只实例化了一个User对象 System.out.println(user == user2); user.show(); }
5、Spring配置说明
5.1、Alias别名
<alias name="user" alias="userAlias"/>
在getBean的时候除了用user可以获取对象，还就可以用别名userAlias
5.2、Bean的配置
<bean id="userT" class="com.yang.entity.UserT" name="user2,u2" scope="" autowire="">
<proerty name="name" value="ywq"/>
bean>
5.3、Import
一般用于团队开发使用（一般命名：applicationContext.xml），导入其他的配置文件，合并这些配置文件，使用的时候只需要使用总配置就好
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
6、DI依赖注入
6.1、构造器注入
之前使用的就是构造器注入
<bean id="userT" class="com.yang.entity.UserT">
bean>
6.2、Set方式注入【重点】
- 依赖注入：本质是set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，由容器来注入
6.3、扩展方式注入
-
p命名空间：对应简化依赖注入的标签(property)
<bean id="user" class="com.yang.entity.User" p:name="ywq" p:age="21" /> -
c命名空间：对应简化构造器注入的标签(constructor-arg),需要有有参构造器的时候才能使用
<bean id="user2" class="com.yang.entity.User" c:name="ywq" c:age="21"/> -
注意：p和c命名空间需要导入xml约束
xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"
6.4、示例
实体类
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbies;
private Map<String,String> card;
private Set<String> games;
private Properties info;
private String wife;
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> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
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 Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
@Override
public String toString() {
return "student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbies=" + hobbies +
", card=" + card +
", games=" + games +
", info=" + info +
", wife='" + wife + '\'' +
'}';
}
}
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 + '\'' +
'}';
}
}
注入的XML
<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="address" class="com.yang.entity.Address">
<property name="address" value="天河区"/>
bean>
<bean id="student" class="com.yang.entity.Student">
<property name="name" value="ywq"/>
<property name="address" ref="address"/>
<property name="books">
<array>
<value>《红楼梦》value>
<value>《西游记》value>
<value>《三国演义》value>
<value>《水浒传》value>
array>
property>
<property name="hobbies">
<list>
<value>听歌value>
<value>写bugvalue>
<value>看电影value>
list>
property>
<property name="card">
<map>
<entry key="身份证" value="123456789012345678"/>
<entry key="校园卡" value="23156523"/>
map>
property>
<property name="games">
<set>
<value>CFvalue>
<value>LOLvalue>
set>
property>
<property name="wife">
<null/>
property>
<property name="info">
<props>
<prop key="学号">20210112prop>
<prop key="性别">男prop>
props>
property>
bean>
beans>
测试启动类
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
System.out.println(student.toString());
}
}
6.5、Bean的作用域
1.The singleton Scope(单例模式)
单例模式，默认采用这种模式，就是该实体类全局指只实例化一次，也就是在配置类加载的时候就已经实例化，之后的引用都是这个先加载好的对象的地址
<bean id="user2" class="com.yang.entity.User"
c:name="ywq" c:age="21" scope="singleton"/>
2.prototype(原型模式)
每一个从容器中get的时候都会产生一个新对象，也就是每一次都是重新申请一块空间进行存储
<bean id="user2" class="com.yang.entity.User"
c:name="ywq" c:age="21" scope="prototype"/>
3.request、session、application
这些只能在web开发中使用
- request：请求创建，在请求完之后这个对象就消失了
- session：创建完之后一直存在session里面
- application：全局都存在
7、Bean的自动装配
- 自动装配：Spring满足Bean依赖的一种方式，就是Spring在上下文中自动寻找，并自动给Bean装配属性
- 在Spring中有三种装配的方式
- 在xml中显示的配置
- 在Java中显示的配置
- 隐式的自动装配
7.1 、测试环境
测试启动
@Test
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Person person = context.getBean("person", Person.class);
person.getDog().shout();
person.getCat().shout();
}
配置xml
<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="cat" class="com.yang.entity.Cat"/>
<bean id="dog" class="com.yang.entity.Dog"/>
<bean id="person" class="com.yang.entity.Person">
<property name="name" value="ywq"/>
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
bean>
beans>
实体类
public class Person {
private Cat cat;
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Cat {
public void shout(){
System.out.println("喵喵");
}
}
public class Dog {
public void shout(){
System.out.println("汪汪");
}
}
7.2、ByName自动装配
<bean id="cat" class="com.yang.entity.Cat"/>
<bean id="dog2" class="com.yang.entity.Dog"/>
<bean id="person" class="com.yang.entity.Person" autowire="byName">
<property name="name" value="ywq"/>
bean>
在id=“dog”的时候，这里自动装配之后是
id=“dog2”改变之后是
7.3、ByType自动装配
- 需要保证类型全局唯一，id不相同没关系，甚至id都没有配置，因为是根据class的值来匹配
- 会自动在容器上下文中查找，和自己对象属性值类型后面的值对应的bean的id,需要保证类型全局唯一
小结
- byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性和set方法的值一致
- byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致
7.4、使用注解实现自动装配
配置
- jdk1.5支持的注解，Spring2.5就支持注解了。
- 具体使用注解还是xml注入，需要根据具体情况决定，一般使用注解会方便很多
注解使用的注意点：
-
导入约束：
<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"> -
配置注解的支持
<context:annotation-config/>
相关注解
@Autowired
-
可以在属性上直接使用，也可以在set方法上使用
-
使用这个注解，如果自动装配的属性在IoC(Spring)容器中，可以不写set方法
-
可以配置属性required
- 默认为true，表示为
- false，表示这个对象或者属性可以为null，效果可以跟字段加上@Nullable一致
-
在自动装配的过程中
- 首先采用ByType的模式匹配，如果结果刚好唯一就给该bean装配
- 若查询结果不唯一，采用ByName的模式匹配
- 若查询结果为空，则抛出异常。解决方法时，使得required=false
-
当使用过程出现，配置了多个相同的类型(先匹配类型，发现用重复的class)，而名称(没有查到id与属性名称相等的属性)无匹配到的时候，可以采用**@Qualifier**(value=“可以匹配的名称”)来解决自动装配匹配不到的问题
<bean id="cat11" class="com.yang.entity.Cat"/> <bean id="cat22" class="com.yang.entity.Cat"/>
@Resource
-
可以在属性或者方法上使用
-
自动装配的过程跟@Autowired不相同，默认情况下
- 首先按照byName模式【按id匹配】进行查找
- 若byName模式无法查找到，则采用byType模式【按class匹配】去查找
-
设置属性（只有name和type两种属性）
-
只设置name：按照设置name值去查找配置里面对应的id值，找不到则抛出异常
-
只设置type：按照设置type值去查找配置里面对应的class值，查到多个或者没有都会抛异常
-
设置name和type两者：从Spring上下文中找到唯一匹配的bean(name，type都一致)进行装配，找不到则抛出异常
-
-
功能齐全点，效率会比@Autowired差一点点，但是按照现在硬件条件可以忽略
Resource与Autowired区别
- 都是自动装配，可以写在变量或者方法上面
- 前者默认首先byName，后者默认首先byType，且要求这个号对象必须存在
- 前者可以直接指定name和type，后者需要配置其他注解
@Nullable
表示这个对象或者属性可以为null
@Qualifier
指定这个属性或者方法名称的别名
8、使用注解开发
在Spring4之前，不推荐注解开发，之后推荐
就绪
依赖
在Spring4之后，要使用注解开发，必须要保证AOP的包导入
xml
使用注解需要导入context约束，增加注解的支持
<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">
<context:component-scan base-package="com.yang.**"/>
<context:annotation-config/>
beans>
8.1、注入Bean和属性
@Component
表明这个类是一个bean组件，放在类上（说明这个类被Spring管理了）
@Value
表明属性的注入，可以放在set上也可以放在属性上（相当于）
/*表明是组件,等价于8.2、衍生注解
@Component 有几个衍生注解，也就是细化的注解，本身的功能【注入bean(对象)】都差不多，主要是增加了代码的可读性（当这类bean不好区分的时候采用Component），在web开发中，会按照mvc三层架构分层
- dao ：习惯使用@Repository进行标注
- service：习惯使用@Service进行标注
- controller：习惯使用@Controller进行标注
四个注解的功能都是一样的，都是代表将某个类注册到Spring容器中，装配Bean
8.3、自动装配的注解
- @Autowired：自动装配先通过类型，然后名字
- @Qualifier(value=“xxx”): 如果Autowired不能唯一自动装配上属性，则需要通过这个注解起别名
- @Resource：自动装配先通过名称，然后类型
- @Nullable：字段标记了这个注解,说明这个字段可以为null
- @Scope(“xxx”)：采用什么模式进行实例化【singleton单例模式、prototype原型模式】
小结
xml与注解：
- xml更加万能，适用于任何场合！维护简单方便
- 注解 不是自己的类使用不了，维护相对复杂
xml与注解最佳实践：
-
xml用来管理bean（只注入类【bean】）
-
注解只负责完成属性的注入（注入属性值）
-
使用的过程中，只需要注意一个问题：必须让注解生效，就是需要开启注解的支持
<context:component-scan base-package="com.yang.**"/> <context:annotation-config/>
9、使用Java的方式配置Spring
- 已经支持java的代码去替代Spring的xml配置了（完全由Java处理，Spring5页推荐这样去完成，更加灵活）
创建配置类
@Configuration
- 其源码就包含@Component注解，也就是本身就是一个组件，会被Spring托管
- @Configuration代表这是一个配置类，就和之前看的xml内的
示例
@Configuration
public class MyConfig {
}
两种注入Bean的方式
@Bean
使用@Bean注解
- 注册一个在方法上写Bean,就相当于
- 方法名等于bean标签中的id属性
- 返回值等于bean标签中的class属性
示例
配置类
@Configuration
public class MyConfig {
// 注册一个bean,就相当于要注入的类
public class User {
private String name;
public String getName() {
return name;
}
@Value("ywq")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
测试启动类
public class MyTest {
@Test
void test1(){
// 如果完全使用了配置类方法去做，只能通过AnnotationConfig上下文获取容器，通过配置类的class对象加载
ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
User user = context.getBean("getUser", User.class);
System.out.println(user.getName());
}
}
@ComponentScan+@Component
@ComponentScan
- 配置扫描包，包下的类自动装配组件(有@Component注解的类)
- 其中bean标签中的属性id值为类名,class为类的类型
示例
配置类
@Configuration
@ComponentScan("com.yang.entity")
public class MyConfig {
}
要注入的类
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("ywq")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
测试启动类
public class MyTest {
@Test
void test1(){
// 如果完全使用了配置类方法去做，只能通过AnnotationConfig上下文获取容器，通过配置类的class对象加载
ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
User user = context.getBean("user", User.class);
System.out.println(user.getName());
}
}
导入其他配置类
@Import(value = [需要导入的配置类的类型])
示例
主配置类
@Configuration
@ComponentScan("com.yang.entity")
@Import(value = ImportConfig.class)
public class MyConfig {
}
要导入的配置类
@Configuration
public class ImportConfig {
}