一、Spring概述
1.1 Spring 背景
- Spring：春天——>给软件行业带来了春天！
- 2002年，首次推出了Spring框架的雏形：interface21框架！
- Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。
- Rod Johnson,Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他拿到计算机学位之前，也拿到了音乐学位。
- Spring理念：使现有的技术更加容易使用，本身是一个大杂烩（Spring的嵌入不会影响原有的结构），整合了现有的技术框架！
– SSH Struct2 + Spring + Hibernate!
– SSM SpringMVC + Spring + Mybatis!
1.2 什么是Spring
依赖 spring-webmvc 👇🏾👇🏾
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
1.3 Spring的优点
- Spring是一个开源的免费的框架（容器）！
- Spring是一个轻量级的、非入侵式的框架！
- 控制反转（IOC），面向切面编程（AOP）！
- 支持事务的处理，对框架整合的支持！
总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！
1.4 Spring的组成（七大模块）
1.5 Spring拓展
在spring的官网有这个介绍（之前有这个图，现在没找到😂😂）：现代化的Java开发！说白就是基于Spring的开发！
Spring Boot
- 一个快速开发的脚手架。
- 基于SpringBoot可以快速的开发单个微服务。
- 约定大于配置！
Spring Cloud
- SpringCloud是基于SpringBoot实现的。
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全账务Spring及SpringMVC！承上启下的作用！
弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱”！
二、Spring IOC
2.1 IOC理论推导
(1)创建一个maven的spring项目（删掉src）
(2)导入依赖pom.xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
之前的做法👇🏾👇🏾
(3)创建一个maven子工程 spring-ioc1(如上)
UserDao.java
package com.zql.dao;
/**
* @Author:Daniel
* @Version 1.0
*/
public interface UserDao {
void getUser();
}
UserDaoImpl.java
package com.zql.dao;
/**
* @Author:Daniel
* @Version 1.0
*/
public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println("默认获取用户数据");
}
}
UserService.java
package com.zql.service;
/**
* @Author:Daniel
* @Version 1.0
*/
public interface UserService {
void getUser();
}
UserServiceImpl.java
package com.zql.service;
import com.zql.dao.UserDao;
import com.zql.dao.UserDaoImpl;
/**
* @Author:Daniel
* @Version 1.0
*/
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
MyTest.java
import com.zql.service.UserService;
import com.zql.service.UserServiceImpl;
/**
* @Author:Daniel
* @Version 1.0
*/
public class MyTest {
public static void main(String[] args) {
//用户实际调用的是业务层，dao层他们不需要接触
UserService userService = new UserServiceImpl();
userService.getUser();
}
}
如果再增加一个UserDaoMySqlImpl.java(……java)又得修改 👇🏾👇🏾
需求：这样用户每增加一个需求，程序员都要改动这个👇🏾👇🏾
在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求修改源代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！
我们使用一个Set接口实现，已经发生了革命性的变化！
private UserDao userDao;
//利用set实现动态值的注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
- 之前，程序员主动创建对象！控制权在程序员手上！
- 使用了Set注入后，程序不再具有主动性，而是变成了被动的接收对象！
这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了。系统的耦合性大大降低了，可以更加专注的在业务的实现上！这是IOC的原型！
2.2 IOC的本质
IOC本质
控制反转IOC(Inversion of Control),是一种设计思想，DI(依赖注入)是实现IOC的一种方法，也有人认为DI只是IOC的另外一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给了第三方，个人认为所谓的控制反转就是：获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（Dependency Injection,DI）.
2.2.1 测试案例
（1）创建一个maven的子工程 spring-helloIoc
(2) 实体 Hello.java
package com.zql.pojo;
import java.io.Serializable;
/**
* @Author:Daniel
* @Version 1.0
*/
public class Hello implements Serializable {
private String str;
public Hello() {
}
public Hello(String str) {
this.str = str;
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
(3)xml——>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.zql.pojo.Hello">
<property name="str" value="String"></property>
</bean>
</beans>
(4)MyTest.java
import com.zql.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Author:Daniel
* @Version 1.0
*/
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
- Hello对象是谁创建的？
Hello对象是由Spring创建的- Hello对象的属性是怎么设置的？
Hello对象的属性是由Spring容器设置的
这个过程就叫控制反转：
控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
反转：程序本身不创建对象，而变成被动的接收对象。
依赖注入：就是利用Set方法来进行注入的。
IOC是一种编程思想，由主动的编程变成被动的接收。
可以通过new ClassPathXmlApplicationContext浏览底层源码了解掌握更多。
2.2.2 测试（通过DI实现 2.1 IOC理论推导）
（1）创建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">
<bean id="myslImpl" class="com.zql.dao.UserDaoMySqlImpl"></bean>
<bean id="UserServiceImpl" class="com.zql.service.UserServiceImpl">
<property name="userDao" ref="myslImpl"></property>
</bean>
<!--
ref :引用Spring容器中创建好的对象
value :具体的值，基本的数据类型1
-->
</beans>
(2) 测试类 MyTest.java
import com.zql.dao.UserDaoImpl;
import com.zql.dao.UserDaoMySqlImpl;
import com.zql.service.UserService;
import com.zql.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Author:Daniel
* @Version 1.0
*/
public class MyTest {
public static void main(String[] args) {
//获取ApplicationContext;拿到Spring的容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手，天下我有，需要什么，就直接get什么！
UserServiceImpl service = (UserServiceImpl) context.getBean("UserServiceImpl");
service.getUser();
}
}
OK,到了现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！
2.3 IOC创建对象的方式(构造器注入)
- 使用无参构造创建对象，默认！
- 假设我们要使用有参构造创建对象。
2.3.1 下标赋值
Constructor argument index（注：官网标题）
<!--第一种 下标赋值 index-->
<bean id="user" class="com.zql.pojo.User">
<constructor-arg index="0" value="Daniel"></constructor-arg>
</bean>
2.3.2 类型
Constructor argument type matching
<!--第二种 通过类型赋值，不建议用-->
<bean id="user" class="com.zql.pojo.User">
<constructor-arg type="java.lang.String" value="Daniel"></constructor-arg>
</bean>
2.3.3 参数名
Constructor argument name
<!--第三种 直接通过参数名来设置-->
<bean id="user" class="com.zql.pojo.User">
<constructor-arg name="name" value="Daniel"></constructor-arg>
</bean>
2.3.4 测试案例
（1）创建子工程
（2）Use.java
package com.zql.pojo;
import java.io.Serializable;
/**
* @Author:Daniel
* @Version 1.0
*/
public class User implements Serializable {
private String name;
public User(String name) {
this.name = name;
System.out.println("user有参执行了");
}
//空参创建
/* public User() {
System.out.println("空参构造执行了");
}*/
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name"+name);
}
}
(3)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">
<!--1.空参执行-->
<!-- <bean id="user" class="com.zql.pojo.User">
<property name="name" value="Daniel"></property>
</bean>-->
<!--第一种 下标赋值 index-->
<!-- <bean id="user" class="com.zql.pojo.User">
<constructor-arg index="0" value="Daniel"></constructor-arg>
</bean>-->
<!-- 第二种 通过类型赋值，不建议用-->
<!-- <bean id="user" class="com.zql.pojo.User">
<constructor-arg type="java.lang.String" value="Daniel"></constructor-arg>
</bean>-->
<!--第三种 直接通过参数名来设置-->
<bean id="user" class="com.zql.pojo.User">
<constructor-arg name="name" value="Daniel"></constructor-arg>
</bean>
</beans>
(4)MyTest.java
import com.zql.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Author:Daniel
* @Version 1.0
*/
public class MyTest {
public static void main(String[] args) {
//Spring 容器就类似于婚介网站
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.show();
}
}
UserT.java
package com.zql.pojo;
import java.io.Serializable;
/**
* @Author:Daniel
* @Version 1.0
*/
public class UserT implements Serializable {
private String name;
public UserT() {
System.out.println("userT被创建了");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name"+name);
}
}
<bean id="userT" class="com.zql.pojo.UserT">
</bean>
总结:在配置文件加载的时候，容器中管理的对象就已经初始化了！
三、 Spring 配置说明
3.1 别名
<!--别名，如果配置了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="newUser"></alias>
3.2 Bean的配置
<!--
id：bean 的唯一标识符，也就是相当于我们学的对象名
class：bean 对象所对应的权限定名 ：包名+类名
name:也是别名，而且name可以同时取多个别名，可以用空格、分号，逗号隔开
-->
<bean id="userT" class="com.zql.pojo.UserT" name="t，user2 u2;u3">
<property name="name" value="Daniel"></property>
</bean>
3.3 import
这个import，一般用于团队开发使用，它可以将多个配置文件，导入合并为一个
假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有的人beans.xml合并为一个总的！
- 张三
- 李四
- 王二
- applicationContext.xml
<import resource="beans.xml" ></import>
<import resource="beans1.xml"></import>
<import resource="beans2.xml"></import>
使用的时候，直接使用总的配置就可以了
四、依赖注入
4.1 构造器注入（参考2.3）
4.2 Set方式注入（重点）
依赖注入：Set注入！
- 依赖：bean对象的创建依赖于容器！
- 注入：bean对象中的所有属性，由容器来注入！
4.2.1 环境搭建
（1）环境搭建(创建要给spring-03-di子工程)
（2）复杂类型
Address.java
package com.zql.pojo;
import java.io.Serializable;
/**
* @Author:Daniel
* @Version 1.0
*/
public class Address implements Serializable {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
（3）真是测试对象
Student.java
package com.zql.pojo;
import java.io.Serializable;
import java.util.*;
/**
* @Author:Daniel
* @Version 1.0
*/
public class Student implements Serializable {
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 "Student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
(4)beans.xml
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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="student" class="com.zql.pojo.Student">
<property name="name" value="Daniel"></property>
</bean>
</beans>
(5) 测试类
MyTest.java
import com.zql.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Author:Daniel
* @Version 1.0
*/
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}
}
4.2.2 完善上述（4.2.1）注入信息
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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.zql.pojo.Address"/>
<bean id="student" class="com.zql.pojo.Student">
<!--第一种 直接使用普通值注入-->
<property name="name" value="Daniel"></property>
<!--第二种 bean注入-->
<property name="address" ref="address"></property>
<!--array-->
<property name="books">
<array>
<value>Java</value>
<value>C++</value>
<value>C%</value>
</array>
</property>
<!--list-->
<property name="hobbys">
<list>
<value>跑步</value>
<value>打羽毛球</value>
<value>打乒乓球</value>
</list>
</property>
<!--map-->
<property name="card">
<map>
<entry key="姓名" value="王"></entry>
<entry key="性别" value="男"></entry>
<entry key="爱好" value="跳舞"></entry>
</map>
</property>
<!--set-->
<property name="games">
<set>
<value>王者</value>
<value>qq跑车</value>
<value>俄罗斯放开</value>
</set>
</property>
<!--null-->
<property name="wife">
<null></null>
</property>
<!--properties-->
<property name="info">
<props>
<prop key="序号">222</prop>
<prop key="身份证号">62242419999999999</prop>
<prop key="银行卡号">7878787878</prop>
</props>
</property>
</bean>
</beans>
测试得：
4.3 拓展方式注入（c命名和p命名空间注入）
可以进行p命名空间和c命名空间直接注入：
测试案例：
(1) 案例结构
(2) Person.java
package com.zql.pojo;
import java.io.Serializable;
/**
* @Author:Daniel
* @Version 1.0
*/
public class Person implements Serializable {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
(3) beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p命名空间注入，可直接注入属性值 -->
<bean id="person" class="com.zql.pojo.Person" p:name="Daniel" p:age="18"></bean>
<!--c命名空间注入，通过构造器注入-->
<bean id="person1" class="com.zql.pojo.Person" c:name="Jenny" c:age="889"></bean>
</beans>
(4) CPTest.java
import com.zql.pojo.Person;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Author:Daniel
* @Version 1.0
*/
public class CPTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Person person = context.getBean("person", Person.class);
System.out.println(person);
}
@Test
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Person person = context.getBean("person1", Person.class);
System.out.println(person);
}
}
注意：c命名空间和p命名空间不能直接 ，需要先导入xml约束！p命名空间可以不要空参和有参构造，但是c命名空间必须要
4.4 Bean的作用域
| Scope | Description |
|---|---|
| singleton | (Default) Scopes a single bean definition to a single object instance for each Spring IoC container. |
| prototype | Scopes a single bean definition to any number of object instances. |
| request | Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext. |
| session | Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext. |
| application | Scopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext. |
| websocket | Scopes a single bean definition to the lifecycle of a WebSocket. Only valid in the context of a web-aware Spring ApplicationContext. |
4.4.1 单例模式
Spring默认机制
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>
4.4.2 原型模式
每次从容器中get的时候，都会产生一个新对象！
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>
4.4.3 其余模式
其余的request、session、application这些个只能在web开发中使用到！
1889
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
