1. 概述（Spring5）
-
Spring
-
IOC容器
控制反转。把创建对象的过程交给Spring管理
- Aop容器
面向切面，不修改源代码的情况下进行功能的增强。
-
JdbcTemplate
-
事务管理
-
Spring5新特性
1.1 入门
Spring boot
-
一个快速开发的脚手架
-
基于它可以快速地开发单个微服务
-
约定大于配置！！
SpringCloud
- 基于Spring boot实现的
现在大多数公司都在用SpringBoot进行快速开发。学习它的前提是学会Spring及SpringMVC。
Spring发展的弊端：
配置十分繁琐，人称“配置地狱”。
官网，GA表示稳定版本。
5.2.6
理解：
用xml配置文件进行配置。原来创建对象用new，现在用bean方式。
创建一个spring项目，最基本的只需要引入5个包。spring的core、context、beans、expression四个jar包以及一个commons-logging的jar包。
写一个入门案例。
在引入测@Test时，提示我要从maven下载junit依赖。然后我从settings里发现maven配置变成了从前的默认，就把它又改成了我已经下载配置好的maven地址和仓库。然后就很快引入了。
2. IOC容器
2.1 概念和原理
控制反转。 Inversion of Control
是OOP的一种设计原则，用来减低计算机代码之间的耦合度
其中最常见的方式叫做依赖注入（Dependency injection，即DI），另一种方式叫做依赖查找。
以前的做法：
-
UserDao 接口
-
UserDaoImpl 实现类
-
UserService 业务接口
-
UserServiceImpl 业务实现类
之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码。如果代码量十分大，那么修改成本十分高。
使用一个Set接口实现，已经发生了革命性的变化。
-
之前，是程序主动创建对象！控制权在程序员手上
-
使用了Set注入，程序不再具有主动性，而是被动接受对象。主动权给了用户。
这种思想就是控制反转，从本质上解决问题，程序员不必去管理对象的创建了，系统的耦合性大大降低，可以更加专注在业务实现上。
这是IOC的原型。
IOC本质：
我们使用面向对象编程时，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制。而控制反转后将对象的创建转移给第三方。
类似于工厂类设计模式。
别人要用一个实例。原来的方式是你封了一个类，你在里面new了一个实例。别人用的时候你会给他。别人要用到另一个实例的话你就要修改你new的代码。
现在是别人要用一个实例，他给你传一个参数（主动告诉你他要用什么），你的程序根据这个参数给他一个实例。
IOC是Spring框架的核心内容，使用多种方式完美实现IOC，可以使用XML配置，也可以用注解，新版本的Spring还可以实现零配置实现IOC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从IOC容器中取出需要的对象。
IOC底层原理：
xml解析+工厂模式+反射。
反射：得到类的字节码文件，class文件。
IOC过程：
- XML配置文件，配置创建的对象
- 有service类和dao类，创建工厂类
Class.forName(classValue);
class UserFactory {
public static UserDao getDao() {
String classValue = class属性值; // xml解析
Class clazz = Class.forName(classValue); // （传入包内全路径）通过反射创建对象
return (UserDao)clazz.newInstance();
}
}
复制代码IOC接口【重点，记住】：
1. IOC思想基于IOC容器，IOC容器底层就是工厂
2. Spring提供IOC实现两种方式：（两个接口）
-
BeanFactory
IOC容器基本实现方式，Spring内部的使用接口，不提供给开发人员使用。
特点：加载配置文件时不会创建对象，在获取对象（使用）（getBean）时才会创建对象。
-
ApplicationContext
BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。
特点：加载配置文件时就会把配置文件对象创建对象。
一般用第二种方式。why？
看起来第一种像懒加载，能节约资源，应该更好。
但是，
我们一般把这些耗时耗资源的操作都在我们项目启动时进行完毕。服务器启动过程中就去创建对象，而不是什么时候用什么时候创建。
3. ApplicationContext接口有实现类。
比如FileSystemXmlApplicationContext和ClassPathXmlApplicationContext。前者以磁盘路径，后者以包类路径。
总结：控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（DI）
2.2 IOC操作Bean管理
- what is Bean管理?
两个操作——1. Spring创建对象；2. Spring注入属性
- Bean管理操作两种方式
- 基于XML配置文件方式实现
- 基于注解方式实现
2.2.1 基于xml方式
一. 基于xml方式创建对象
<bean id="user" class="com.atguigu.spring5.User"></bean>
复制代码1st. 在spring配置文件中使用bean标签，标签里面添加对应属性，可以实现对象创建
2nd. 在bean标签有很多属性，介绍常用属性。
-
id属性：并非对象名字，而是别名，唯一标识
-
class属性：创建对象类的全路径（包类路径）
-
name属性：早期属性，作用和id一样。但name中可以加特殊符号。
3rd. 创建对象时，默认执行无参数构造方法，完成对象创建。
二. 基于xml方式注入属性
1st. DI：依赖注入，就是注入属性。
其一：使用set方法进行注入。book.setName("args")
其二：通过有参数的构造函数注入。new Book("args")
前者配置文件作用：（用set方法注入）
<bean id="book" class="com.atguigu.spring5.Book">
<property name="bname" value="易筋经"></property>
</bean>
复制代码使用property完成属性注入，name是属性名称（成员变量名），value是注入的值。
后者配置文件作用：（用有参构造注入）
<bean id="order" class="com.atguigu.spring5.Orders">
<constructor-arg name="oname" value="电脑"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
</bean>
复制代码对以上方法进行简化：
p名称空间注入，可以简化基于xml配置方式。（用的不多，了解即可）
- 字面量：
设置一个空值
<property>
<null />
</property>
复制代码属性值包含特殊字符
比如有个尖括号，可能会被识别为/
-
把尖括号进行转义，转义符号：
<> -
把特殊符号内容写到CDATA
<property>
<value>
<![CDATA[<<南京>>]]>
</value>
</property>
复制代码<![CDATA[内容]]>
- 注入属性-外部bean
- 注入属性-内部bean和级联赋值
- 外部bean注入：
通过service层去调DAO，这个过程就是引入外部bean。
1st 创建两个类：service类和dao类。
2nd 在service来调用dao的方法。
3rd 在spring配置文件中进行配置。
<!-- service 和 dao 对象进行创建 -->
<!-- 外部bean方式-->
<bean id="userService" class="com.phsite.service.UserService">
<!-- 注入userDao对象
name=属性名称
ref属性，创建userDao对象bean标签的id值。（下面那个）
-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.phsite.dao.UserDaoImpl"></bean>
复制代码- 内部bean注入
1st 一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门。
部门是一，员工是多。
2nd 在实体类之间表示一对多关系，员工所属部门用一个对象类型的属性进行表示。
3rd 在spring配置文件中进行配置
<!-- 内部bean方式 -->
<bean id="emp" class="com.phsite.bean.Emp">
<property name="ename" value="Lucy"></property>
<property name="gender" value="女"></property>
<property name="dept">
<bean id="dept" class="com.phsite.bean.Dept">
<property name="dname" value="安保部"></property>
</bean>
</property>
</bean>
复制代码小结：bean标签就是创建对象的。外部bena就是在一个bean外面创建一个新bean，然后在property中用ref属性把它引入进来；内部bean就是直接把bean写在property内部。
- 级联赋值
写法1：
<!--级联赋值操作-->
<bean id="emp" class="com.phsite.bean.Emp">
<property name="ename" value="Lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.phsite.bean.Dept">
<property name="dname" value="财务部"></property>
</bean>
复制代码写法2：
<!--级联赋值操作-->
<bean id="emp" class="com.phsite.bean.Emp">
<property name="ename" value="Lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
<property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.phsite.bean.Dept">
<property name="dname" value="财务部"></property>
</bean>
复制代码这里在property的name中设置dept.dname，我们必须要在Emp类中生成一个对于dept属性的get方法，不然它取不到值会报错。
三. xml注入集合属性
比如数组、list集合、map集合等。
-
注入数组类型属性
-
注入List集合类型属性
-
注入Map集合类型属性
-
在集合里设置对象类型值。
-
<!--创建多个course对象--> <bean id="course1" class="com.phsite.collectionType.Course"> <property name="cname" value="spring5框架"></property> </bean> <bean id="course2" class="com.phsite.collectionType.Course"> <property name="cname" value="myBatis框架"></property> </bean> 复制代码 -
<property name="courseList"> <list> <ref bean="course1"></ref> <ref bean="course2"></ref> </list> </property> 复制代码
-
-
把集合注入的部分提取出来（变成可公共使用的）。
- 在spring配置中引入一个新的名称空间util
<?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:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
复制代码- 用util标签完成list集合注入
<!--提取list集合类型属性注入，公共部分-->
<util:list id="bookList">
<!--如果是对象的话还是<ref></ref>-->
<value>易筋经</value>
<value>九阳神功</value>
</util:list>
<!--使用-->
<bean id="book" class="com.phsite.collectionType.Book">
<property name="list" ref="bookList"></property>
</bean>
复制代码四. FactoryBean
- Spring有两种bean，普通bean和工厂bean
- 普通bean：在配置文件中定义bean类型就是返回类型
- 工厂bean：在配置文件定义bean类型可以和返回类型不一样
第一步：创建类，让这个类作为工厂bean，实现接口FactoryBean
第二步：实现接口里的方法，在实现的方法中定义返回的bean类型。
Instance：
写法：
public class myBean implements FactoryBean<Course> {
// 定义返回Bean的方法
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("abc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
复制代码配置：
<bean id="mybean" class="com.phsite.factorybean.myBean">
</bean>
复制代码测试：
@Test
public void test3() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean3.xml");
Course course = context.getBean("mybean", Course.class);
System.out.println(course);
}
复制代码六. bean的作用域
在Spring里，默认情况下，bean是单实例对象！！！。
（你创建了俩对象，其实地址是一个！！）
- 如何设置单实例or多实例
spring配置文件，bean标签中有个属性用于设置单实例还是多实例
- scope属性
第一个值，默认值，singleton，表示单实例对象
第二个值 prototype，表示是多实例对象
其他的还有：request、session。
<bean id="book" class="com.phsite.collectionType.Book" scope="prototype">
<property name="list" ref="bookList"></property>
</bean>
复制代码- singleton和prototype的区别
-
前者单实例，后者多实例
-
设置scope为singleton时，加载spring配置文件时就会给你创建单实例对象。
-
设置scope为prototype时，不是在加载spring配置文件时创建对象，而是在调用getBean方法时才会创建多实例对象。
七. bean的生命周期
- what is 生命周期？
从对象创建到对象销毁的过程。
-
bean的生命周期
- 通过构造器创建bean实例（无参构造函数）
- 为bean的属性设置值和对其他bean的引用（调用set方法）
- 调用bean的初始化方法（需要在配置文件中配置初始化方法）
- bean可以使用了。（对象获取到了）
- 当容器关闭时，调用bean的销毁方法。（需要在配置文件中配置销毁方法）
-
展示
public class Orders {
// 无参数的构造函数
public Orders() {
System.out.println("第一步，执行无参数的构造，创建bean实例");
}
private String oname;
public void setOname(String oname) {
System.out.println("第二部，调用set方法设置属性值");
this.oname = oname;
}
// 创建一个执行的初始化方法
public void initMethod() {
System.out.println("第三步，执行初始化方法");
}
// 创建销毁的方法
public void destroyMethod() {
System.out.println("第五步，执行销毁的方法");
}
}
复制代码 <bean id="orders" class="com.phsite.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>
复制代码 @Test
public void testBean4() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步，获取创建的bean实例对象");
System.out.println(orders);
// 手动让bean实例销毁。
((ClassPathXmlApplicationContext) context).close();
}
复制代码效果：
第一步，执行无参数的构造，创建bean实例
第二部，调用set方法设置属性值
第三步，执行初始化方法
第四步，获取创建的bean实例对象
com.phsite.bean.Orders@1ca3b418
第五步，执行销毁的方法
复制代码注意：最后的close销毁函数是ClassPathXmlApplicationContext类才有的。ApplicationContext是没有的。
- bean的后置处理器，bean的生命周期一共有7步。
除了那五步，还有另外两步
-
通过构造器创建bean实例（无参构造函数）
-
为bean的属性设置值和对其他bean的引用（调用set方法）
-
把bean的实例传递给bean的后置处理器的方法postProcessBeforeInitialization
-
调用bean的初始化方法（需要在配置文件中配置初始化方法）
-
把bean的实例传递给bean的后置处理器的方法postProcessAfterInitialization
-
bean可以使用了。（对象获取到了）
-
当容器关闭时，调用bean的销毁方法。（需要在配置文件中配置销毁方法）
-
演示：
创建类，实现接口BeanPostProcessor，创建后置处理器。
public class myBeanPost implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之后执行的方法");
return bean;
}
}
复制代码 <bean id="orders" class="com.phsite.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>
<!--配置后置处理器-->
<bean id="myBeanPost" class="com.phsite.bean.myBeanPost"></bean>
复制代码第一步，执行无参数的构造，创建bean实例
第二部，调用set方法设置属性值
在初始化之前执行的方法
第三步，执行初始化方法
在初始化之后执行的方法
第四步，获取创建的bean实例对象
com.phsite.bean.Orders@74e28667
第五步，执行销毁的方法
复制代码八. xml自动装配
(实际中使用很少，主要还是注解方式，但是要知道xml也能实现自动装配)
之前我们在配置文件中自己写value、ref属性来手动装配。
现在不需要写这个配置
- what is 自动装配？
根据指定装配规则（属性名称或者属性类型），Spring将自动将匹配的属性值进行注入。
- 演示
根据属性名称自动装配
<!--手动装配-->
<!-- <bean id="emp" class="com.phsite.autowire.Emp">-->
<!-- <property name="dept" ref="dept"></property>-->
<!-- </bean>-->
<!-- <bean id="dept" class="com.phsite.autowire.Dept"></bean>-->
<!-- 自动装配
bean标签属性autowire，配置自动装配
autowire属性常用值
byName根据名称注入，注入值bean的id值和类的属性名称一样
byType根据类型注入
-->
<bean id="emp" class="com.phsite.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.phsite.autowire.Dept"></bean>
复制代码九. 外部属性文件
一个属性对应一个property，要写的配置太多了。
（引入druid依赖包。）
- 直接配置数据库信息
- 配置德鲁伊连接池
- 引入德鲁伊连接池依赖jar包。
<!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
复制代码- 引入外部属性文件配置数据库连接池
Ⅰ. 创建外部属性文件，properties格式文件，写上数据库信息
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root
复制代码注意，这里等号左边是随便起名的。用prop.xxx可以避免命名冲突
Ⅱ. 把外部properties属性文件引入spring配置文件
- 引入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 http://www.springframework.org/schema/context/spring-context.xsd">
复制代码- 在spring配置文件中使用标签引入
<!-- 引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties" />
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverclass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.username}"></property>
<property name="password" value="${prop.password}"></property>
</bean>
复制代码我们通常是将数据库配置写在一个properties文件中，然后在xml中引入进行配置。
2.2.2 基于注解方式
-
what is 注解
- 注解是代码特殊标记。格式：
@注解名称(属性名称=xx, 属性值=xxx, ...) - 使用注解，注解可以作用在类上面、方法上面、属性上面
- 使用注解的目的：为了简化xml配置
- 注解是代码特殊标记。格式：
-
Spring针对Bean管理中创建对象提供注解
- @Component，普通注解。
- @Service，一般用在service层
- @Controller，一般用在外部（web）层。
- @Repository，一把用在DAO（持久）层上。
上面4个注解功能是一样的，都可以用来创建bean实例。
- 基于注解方式实现对象创建
第一步，引入依赖
spring-aop的jar包。
第二步，开启组件扫描
告诉spring容器，我在哪个类要加注解。不开启是不能用注解的。
<!-- 开启组件扫描
1. 如果扫描多个包，多个包使用逗号隔开
2. 扫描包上层目录-->
<!-- <context:component-scan base-package="com.phsite.dao, com.phsite.service"></context:component-scan>-->
<context:component-scan base-package="com.phsite"></context:component-scan>
复制代码第三步，创建类，在类上面添加创建对象注解
// 在注解里value属性值可以省略不写
// 默认值是类名称，首字母小写
// UserService --> userService
@Component(value = "userService") // 和<bean id="userService" class=".."></bean>
public class UserService {
public void add() {
System.out.println("service add....");
}
}
复制代码- 开启组件扫描的细节问题
我们写扫描的路径为上级目录后，它默认会全都扫描。
我们希望进行有的扫描有的不扫描，是可以进行一些配置的。
<!--示例1
use-default-filters="false" 表示它现在不用默认的filter了，而是用我们自己配置的filter
context:include-filter 设置扫描哪些内容
这个就是设置扫描注解为Controller的类，带其他注解的就不扫描了。
-->
<context:component-scan base-package="com.phsite" use-default-filters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller" />
</context:component-scan>
<!--示例2
context:exclude-filter 设置哪些内容不扫描
-->
<context:component-scan base-package="com.phsite">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller" />
</context:component-scan>
复制代码- 基于注解方式实现属性注入
- @Autowired
根据属性类型进行自动装配（注入）。
第一步 把service和dao对象进行创建，在两个类上都添加创建对象的注解
@Repository
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("dao add.");
}
}
复制代码第二步 在service中注入dao对象，在service类添加dao类型属性，在属性上面使用注解
// 在注解里value属性值可以省略不写
// 默认值是类名称，首字母小写
// UserService --> userService
@Service(value = "userService") // 和<bean id="userService" class=".."></bean>
public class UserService {
// 定义dao类型属性
// 不需要添加set方法
// 添加注入属性注解
@Autowired // 根据类型进行注入
private UserDao userDao;
public void add() {
System.out.println("service add....");
userDao.add();
}
}
复制代码- @Qualifier
根据属性名称进行注入。
这个注解的使用，要和Autowired一起进行使用。
@Service(value = "userService") // 和<bean id="userService" class=".."></bean>
public class UserService {
// 定义dao类型属性
// 不需要添加set方法
// 添加注入属性注解
@Autowired // 根据类型进行注入
@Qualifier(value = "userDaoImpl1") // 根据名称进行注入
private UserDao userDao;
public void add() {
System.out.println("service add....");
userDao.add();
}
}
复制代码@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("dao add.");
}
}
复制代码只要value和名称对的上。
- @Resource
可以根据类型注入，也可以根据名称注入。
刚开始的时候找不到resource注解。是因为缺少javax.annotation的依赖。它不是spring里的，而是javax（扩展包）里提供的。说明spring官方推荐用上面两个。
@Resource(name = "userDaoImpl1")
private UserDao userDao;
复制代码- @Value
注入普通类型属性
@Value(value = "abc")
private String name;
复制代码- 完全注解开发
配置文件都不要。
Ⅰ. 创建配置类，替代xml的配置文件。
@Configuration // 作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.phsite"})
public class SpringConfig {
}
复制代码Ⅱ. 编写测试类
@Test
public void testService2() {
ApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfig.class);
// 加载配置类发生变动
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
复制代码SpringBoot本质就是Spring。实际中一般基于springboot来做到这个。
![[桜井宁宁]COS和泉纱雾超可爱写真福利集-一一网](https://www.proyy.com/skycj/data/images/2020-12-13/4d3cf227a85d7e79f5d6b4efb6bde3e8.jpg)
![[桜井宁宁] 爆乳奶牛少女cos写真-一一网](https://www.proyy.com/skycj/data/images/2020-12-13/d40483e126fcf567894e89c65eaca655.jpg)
