Spring5学习笔记

0x00 笔注

本篇笔记纯参考B站UP主“狂神”的教程进行总结记录。

(纯参考教程视频和公众号笔记)

公众号文章:http://mp.weixin.qq.com/mp/homepage?__biz=Mzg2NTAzMTExNg==&hid=3&sn=456dc4d66f0726730757e319ffdaa23e&scene=18#wechat_redirect

bilibili视频站地址:https://www.bilibili.com/video/BV1WE411d7Dv

本篇笔记源码:链接: https://pan.baidu.com/s/1rByk2actuk_fn-lZsdE32A 提取码: uq37 复制这段内容后打开百度网盘手机App,操作更方便哦

感慨:不得不承认翻了那么多教程,狂神的教程给人通俗易懂,而且教程也不太占时间。

0x01 IDEA生成Maven-Spring5

1、创建一个Mevan项目,参照下图:

2、当项目创建成功后,点击项目名称再点击添加框架的支持。

3、选择Spring5后,点击确认即可。

0x02 概述及IOC理论推导

1、功能简介组成

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器(框架)。

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

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

  • 核心容器:核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转(IOC) 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

  • Spring 上下文:Spring 上下文是一个配置文件,向 Spring 框架提供上下文信息。Spring 上下文包括企业服务,例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

  • Spring AOP:通过配置管理特性,Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以,可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP,不用依赖组件,就可以将声明性事务管理集成到应用程序中。

  • Spring DAO:JDBC DAO 抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理,并且极大地降低了需要编写的异常代码数量(例如打开和关闭连接)。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
  • Spring ORM:Spring 框架插入了若干个 ORM 框架,从而提供了 ORM 的对象关系工具,其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
  • Spring Web 模块:Web 上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下文。所以,Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
  • Spring MVC 框架:MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口,MVC 框架变成为高度可配置的,MVC 容纳了大量视图技术,其中包括 JSP、Velocity、Tiles、iText 和 POI。

2、Spring其它系列对应关系概述

Spring Boot 是 Spring 的一套快速配置脚手架,可以基于Spring Boot 快速开发单个微服务;

Spring Cloud是基于Spring Boot实现的;

Spring Boot专注于快速、方便集成的单个微服务个体,Spring Cloud关注全局的服务治理框架;

Spring Boot使用了约束优于配置的理念,很多集成方案已经帮你选择好了,能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现,Spring Boot可以离开Spring Cloud独立使用开发项目,但是Spring Cloud离不开Spring Boot,属于依赖的关系。

SpringBoot在SpringClound中起到了承上启下的作用,如果你要学习SpringCloud必须要学习SpringBoot。

3、IOC基础原型

① 使用常规三层架构思路写1个dome应用代码。

② 两个接口类代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 持久层(DAO):

// 文件名:IUserDao.java
package top.sh1yan.test1;

public interface IUserDao {
void getUser();
}

// 文件名:IUserService.java
package top.sh1yan.test1;

public interface IUserService {
void getUser();
}

③ 两个实现类代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 业务层(逻辑层、service层)

// 文件名:UserDaoImpl.java
package top.sh1yan.test1;

public class UserDaoImpl implements IUserDao {
public void getUser() {
System.out.println("获取用户信息");
}
}

// 文件名:UserServiceImpl.java
package top.sh1yan.test1;

public class UserServiceImpl implements IUserService {
private IUserDao userDao = new UserDaoImpl();

public void getUser() {
userDao.getUser();
}
}

④ 测试一下效果:

1
2
3
4
5
6
7
8
9
10
11
12
13
// 文件名:Test01.java
package top.sh1yan.test1;

public class Test01 {
public static void main(String[] args) {
IUserService service = new UserServiceImpl();
service.getUser();
}
}

// 输出结果

获取用户信息

⑤ 变更下需求,增加两个Dao层的实现类:

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
// 业务层(逻辑层、service层)

// 文件名:UserDaoMySqlImpl.java
package top.sh1yan.test1;

public class UserDaoMySqlImpl implements IUserDao {
public void getUser() {
System.out.println("从MySQL数据中获取用户信息");
}
}

// 文件名:UserDaoOracleImpl.java
package top.sh1yan.test1;

public class UserDaoOracleImpl implements IUserDao {
public void getUser() {
System.out.println("从Oracle数据中获取用户信息");
}
}

// 文件名:UserServiceImpl.java
package top.sh1yan.test1;

public class UserServiceImpl implements IUserService {
private IUserDao userDao = new UserDaoMySqlImpl();
// private IUserDao userDao = new UserDaoOracleImpl();

public void getUser() {
userDao.getUser();
}
}

⑥ 从这里可以看出,当Dao进行变更时,需要不断的去修改Servier实现类,对后期功能升级时会逐步出现劣势。

⑦ 对于该问题的解决方案,可以使用set接口式方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 业务层(逻辑层、service层)

// 文件名:UserServiceTooImpl.java
package top.sh1yan.test1;

public class UserServiceTooImpl implements IUserService {
private IUserDao userDao;

public void setUserDao(IUserDao userDao){
this.userDao = userDao;
}

public void getUser() {
userDao.getUser();
}
}

⑧ 通过在测试类中进行使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 文件名:Test02.java
package top.sh1yan.test1;

public class test02 {
public static void main(String[] args) {
UserServiceTooImpl service = new UserServiceTooImpl();
service.setUserDao(new UserDaoImpl());
service.getUser();
service.setUserDao(new UserDaoMySqlImpl());
service.getUser();
service.setUserDao(new UserDaoOracleImpl());
service.getUser();
}
}

// 输出结果

获取用户信息
从MySQL数据中获取用户信息
从Oracle数据中获取用户信息

⑨ 整体应用代码从由程序去进行控制创建,现在是由我们自行控制创建,这就是基础原型。

4、IOC的本质

控制反转IoC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现IoC的一种方法,也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。

IoC是Spring框架的核心内容,使用多种方式完美的实现了IoC,可以使用XML配置,也可以使用注解,新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件,根据配置文件或元数据创建与组织对象存入容器中,程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。

控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)。

0x03 实现一个Bean应用

① 编写1个实体类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 路径:src\main\java\top\sh1yan\test2
// 文件名:HelloSpring.java
package top.sh1yan.test2;

public class HelloSpring {
private String name;

public String getName(){
return name;
}

public void setName(String name){
this.name = name;
}

public void show(){
System.out.println("Hello,"+name);
}
}

② 配置一下beans.xml文件

1
2
// 路径:src\main\resources
// 文件名:beans01.xml
1
2
3
4
5
6
7
8
9
10
<?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="hellospring" class="top.sh1yan.test2.HelloSpring">
<property name="name" value="Spring"/>
</bean>

</beans>

③ 测试运行一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 路径:src\test\java
// 文件名:test03.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test2.HelloSpring;

public class test03 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans01.xml");
HelloSpring helloSpring = context.getBean("hellospring",HelloSpring.class);
helloSpring.show();
}
}

// 运行结果

Hello,Spring

④ 思考总结:**

HelloSpring 对象类是由 Spring 容器创建的。

HelloSpring 对象是由Spring 容器设置的(beans.xml文件设置)。

整个代码执行流程叫控制反转:

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

反转 : 程序本身不创建对象 , 而变成被动的接收对象

对于参数值/参数类的设置叫依赖注入:

依赖注入 : 就是利用set方法来进行注入的

IOC是一种编程思想,由主动的编程变成被动的接收。

⑤ 对象类注入:

⑥ 新增 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans02.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?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="OracleImpl" class="top.sh1yan.test1.UserDaoOracleImpl"/>

<bean id="ServiceImpl" class="top.sh1yan.test1.UserServiceTooImpl">
<!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
<!--引用另外一个bean , 不是用value 而是用 ref-->
<property name="userDao" ref="OracleImpl"/>
</bean>

</beans>

⑦ 测试运行一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 路径:src\test\java
// 文件名:test04.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test1.UserServiceTooImpl;

public class test04 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans02.xml");
UserServiceTooImpl serviceToo02 = context.getBean("ServiceImpl",UserServiceTooImpl.class);
serviceToo02.getUser();
}
}

// 运行结果

从Oracle数据中获取用户信息

⑧ 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

0x04 IOC创建对象方式

1、使用无参构造方法来创建

① 创建实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 路径:src\main\java\top\sh1yan\test3
// 文件名:UserName.java
package top.sh1yan.test3;

public class UserName {
private String name;

public UserName(){
System.out.println("执行无参构造方法!");
}

public void setName(String name){
this.name = name;
}

public void show(){
System.out.println("name:"+name);
}
}

② 创建 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans03.xml
1
2
3
4
5
6
7
8
9
10
<?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="user" class="top.sh1yan.test3.UserName">
<property name="name" value="shiyan"/>
</bean>

</beans>

③ 运行一下测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 路径:src\test\java
// 文件名:test05.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test3.UserName;

public class test05 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans03.xml");
UserName user = context.getBean("user", UserName.class);
user.show();
}
}

// 运行结果

执行无参构造方法!
name:shiyan

④ 总结一下,可以看出生成实体类时,执行了无参构造。

2、使用有参构造方法来创建

① 创建实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 路径:src\main\java\top\sh1yan\test4
// 文件名:UserNameT.java
package top.sh1yan.test4;

public class UserNameT {
private String name;

public UserNameT(String name) {
this.name = name;
}

public void setName(String name) {
this.name = name;
}

public void show(){
System.out.println("name:"+ name );
}
}

② 创建 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans04.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?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">

<!-- 第一种根据index参数下标设置 -->
<bean id="usernamet01" class="top.sh1yan.test4.UserNameT">
<!-- index指构造方法 , 下标从0开始 -->
<constructor-arg index="0" value="shiyan01"/>
</bean>

<!-- 第二种根据参数名字设置 -->
<bean id="usernamet02" class="top.sh1yan.test4.UserNameT">
<!-- name指参数名 -->
<constructor-arg name="name" value="shiyan02"/>
</bean>

<!-- 第三种根据参数类型设置 -->
<bean id="usernamet03" class="top.sh1yan.test4.UserNameT">
<constructor-arg type="java.lang.String" value="shiyan03"/>
</bean>

</beans>

③ 运行一下测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 路径:src\test\java
// 文件名:test06.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test4.UserNameT;

public class test06 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans04.xml");
UserNameT usernamet01 = context.getBean("usernamet01", UserNameT.class);
usernamet01.show();
UserNameT usernamet02 = context.getBean("usernamet02", UserNameT.class);
usernamet02.show();
UserNameT usernamet03 = context.getBean("usernamet03", UserNameT.class);
usernamet03.show();
}
}

// 运行结果

name:shiyan01
name:shiyan02
name:shiyan03

3、xml 别名配置

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

1
2
<!--设置别名:在获取Bean的时候可以使用别名获取-->
<alias name="usernamet04" alias="unt4"/>

Bean的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--bean就是java对象,由Spring创建和管理-->

<!--
id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
如果配置id,又配置了name,那么name是别名
name可以设置多个别名,可以用逗号,分号,空格隔开
如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<bean id="usernamet05" name="unt5,unt6;unt7" class="top.sh1yan.test4.UserNameT">
<property name="name" value="shiyan04"/>
</bean>

0x05 依赖注入(DI)

1、基础概念

依赖注入(Dependency Injection,DI)。

依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源。

注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配。

2、构造器注入

在 0x04 中 1和2的实例代码中已经演示了。

3、Set 注入

:要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 而是 is 。

① 编写公共测试类:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
// 路径:src\main\java\top\sh1yan\test5
// 文件名:Address.java
package top.sh1yan.test5;

public class Address {
private String address;

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}
}

// 文件名:Student.java
package top.sh1yan.test5;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Student {

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 void setName(String name) {
this.name = name;
}

public void setAddress(Address address) {
this.address = address;
}

public void setBooks(String[] books) {
this.books = books;
}

public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}

public void setCard(Map<String, String> card) {
this.card = card;
}

public void setGames(Set<String> games) {
this.games = games;
}

public String getName() {
return name;
}

public Address getAddress() {
return address;
}

public String[] getBooks() {
return books;
}

public List<String> getHobbys() {
return hobbys;
}

public Map<String, String> getCard() {
return card;
}

public Set<String> getGames() {
return games;
}

public String getWife() {
return wife;
}

public Properties getInfo() {
return info;
}

public void setWife(String wife) {
this.wife = wife;
}

public void setInfo(Properties info) {
this.info = info;
}

public void show(){
System.out.println("name="+ name
+ ",address="+ address.getAddress()
+ ",books="
);
for (String book:books){
System.out.print("<<"+book+">>\t");
}
System.out.println("\n爱好:"+hobbys);

System.out.println("card:"+card);

System.out.println("games:"+games);

System.out.println("wife:"+wife);

System.out.println("info:"+info);

}
}

3.1、常量注入

① 创建 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
5
6
7
8
9
10
<?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="student01" class="top.sh1yan.test5.Student">
<property name="name" value="shiyan05"/>
</bean>

</beans>

② 执行下测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 路径:src\test\java
// 文件名:test07.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test5.Student;

public class test07 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans05.xml");
Student student01 = context.getBean("student01", Student.class);
System.out.println(student01.getName());
}
}

// 运行结果

shiyan05

3.2、Bean注入

注意点:这里的值是一个引用,ref

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
5
6
7
8
9
<!-- 2、Bean注入   -->
<bean id="addr01" class="top.sh1yan.test5.Address">
<property name="address" value="河南"/>
</bean>

<bean id="student02" class="top.sh1yan.test5.Student">
<property name="name" value="shiyan06"/>
<property name="address" ref="addr01"/>
</bean>

3.3、数组注入

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
5
6
7
8
9
10
11
12
<!-- 3、数组注入   -->
<bean id="student03" class="top.sh1yan.test5.Student">
<property name="name" value="shiyan07"/>
<property name="address" ref="addr01"/>
<property name="books">
<array>
<value>三体</value>
<value>三体Ⅱ·黑暗森林</value>
<value>三体Ⅲ·死神永生</value>
</array>
</property>
</bean>

3.4、List注入

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
5
6
7
8
9
10
<!-- 4、List注入   -->
<bean id="student04" class="top.sh1yan.test5.Student">
<property name="hobbys">
<list>
<value>听歌</value>
<value>看电影</value>
<value>爬山</value>
</list>
</property>
</bean>

3.5、Map注入

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
5
6
7
8
9
<!-- 5、Map注入 -->
<bean id="student05" class="top.sh1yan.test5.Student">
<property name="card">
<map>
<entry key="正数排列" value="123456"/>
<entry key="倒数排列" value="654321"/>
</map>
</property>
</bean>

3.6、set注入

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
5
6
7
8
9
10
<!-- 6、set注入 -->
<bean id="student06" class="top.sh1yan.test5.Student">
<property name="games">
<set>
<value>ava</value>
<value>codol</value>
<value>cf</value>
</set>
</property>
</bean>

3.7、Null注入

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
<!-- 7、Null注入 -->
<bean id="student07" class="top.sh1yan.test5.Student">
<property name="wife"><null/></property>
</bean>

3.8、Properties注入

1
2
// 路径:src\main\resources
// 文件名:beans05.xml
1
2
3
4
5
6
7
8
9
10
<!-- 8、Properties注入 -->
<bean id="student08" class="top.sh1yan.test5.Student">
<property name="info">
<props>
<prop key="学号">20200801</prop>
<prop key="性别"></prop>
<prop key="姓名">shiyan08</prop>
</props>
</property>
</bean>

4、p命名和c命名注入

4.1、P命名空间注入

① 创建无参数的构造函数 UserNamePC 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 路径:src\main\java\top\sh1yan\test6
// 文件名:UserNamePC.java
package top.sh1yan.test6;

public class UserNamePC {
private String name;
private int age;

public void setName(String name) {
this.name = name;
}

public void setAge(int age) {
this.age = age;
}

@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

② 创建 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans06.xml
1
2
3
4
5
6
7
8
9
10
11
<?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"
xmlns:p="http://www.springframework.org/schema/p">
<!-- 导入约束 -->

<!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
<bean id="unpc" class="top.sh1yan.test6.UserNamePC" p:name="shiyan09" p:age="18"/>

</beans>

③ 执行下测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 路径:src\test\java
// 文件名:test08.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test6.UserNamePC;

public class test08 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans06.xml");
UserNamePC unpc = context.getBean("unpc", UserNamePC.class);
System.out.println(unpc.toString());
}
}

// 运行结果

User{name='shiyan09', age=18}

4.2、C命名空间注入

① 对 UserNamePC 类添加有参构造器

1
2
3
4
5
6
7
// 路径:src\main\java\top\sh1yan\test6
// 文件名:UserNamePC.java

public UserNamePC(String name, int age) {
this.name = name;
this.age = age;
}

② 修改 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans06.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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"
xmlns:c="http://www.springframework.org/schema/c">
<!-- 导入约束 -->

<!-- xmlns:p="http://www.springframework.org/schema/p" -->

<!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
<!--<bean id="unpc" class="top.sh1yan.test6.UserNamePC" p:name="shiyan09" p:age="18"/>-->

<!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
<bean id="unpc" class="top.sh1yan.test6.UserNamePC" c:name="shiyan10" c:age="18"/>

</beans>

③ 总结,从这里就可以看出 p命名注入为无参注入,c命名注入为有参注入。

5、Bean的作用域

在Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象。

几种作用域中,request、session作用域仅在基于web的应用中使用(不必关心你所采用的是什么web应用框架),只能用在基于web的Spring ApplicationContext环境。

Singleton:当一个bean的作用域为Singleton,那么Spring IoC容器中只会存在一个共享的bean实例,并且所有对bean的请求,只要id与该bean定义相匹配,则只会返回bean的同一实例。Singleton是单例类型,就是在创建起容器时就同时自动创建了一个bean的对象,不管你是否使用,他都存在了,每次获取到的对象都是同一个对象。注意,Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成singleton,可以这样配置:

1
<bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

Prototype:当一个bean的作用域为Prototype,表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求(将其注入到另一个bean中,或者以程序的方式调用容器的getBean()方法)时都会创建一个新的bean实例。Prototype是原型类型,它在我们创建容器的时候并没有实例化,而是当我们获取bean的时候才会去创建一个对象,而且我们每次获取到的对象都不是同一个对象。根据经验,对有状态的bean应该使用prototype作用域,而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype,可以这样配置:

1
2
3
<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
或者
<bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request:当一个bean的作用域为Request,表示在一次HTTP请求中,一个bean定义对应一个实例;即每个HTTP请求都会有各自的bean实例,它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

1
<bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

针对每次HTTP请求,Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例,且该loginAction bean实例仅在当前HTTP request内有效,因此可以根据需要放心的更改所建实例的内部状态,而其他请求中根据loginAction bean定义创建的实例,将不会看到这些特定于某个请求的状态变化。当处理请求结束,request作用域的bean实例将被销毁。

Session:当一个bean的作用域为Session,表示在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义:

1
<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个HTTP Session,Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例,且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样,可以根据需要放心的更改所创建实例的内部状态,而别的HTTP Session中根据userPreferences创建的实例,将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候,在该HTTP Session作用域内的bean也会被废弃掉。

0x06 自动装配

1、自动装配说明

自动装配是使用spring满足bean依赖的一种方法。

spring会在应用上下文中为某个bean寻找其依赖的bean。

2、Spring中bean有三种装配机制

  • 在xml中显式配置;

  • 在java中显式配置;

  • 隐式的bean发现机制和自动装配;

3、自动装配的实现原理

组件扫描(component scanning):spring会自动发现应用上下文中所创建的bean;

自动装配(autowiring):spring自动满足bean之间的依赖,也就是我们说的IoC/DI;

组件扫描和自动装配组合发挥巨大威力,使得显示的配置降低到最少。

但推荐不使用自动装配xml配置 , 而使用注解。

4、搭建测试环境

① 创建3个实例类

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
43
44
45
46
47
48
49
50
51
// 路径:src\main\java\top\sh1yan\test7
// 文件名:Cat.java
package top.sh1yan.test7;

public class Cat {
public void shout() {
System.out.println("miao~");
}
}

// 文件名:Dog.java
package top.sh1yan.test7;

public class Dog {
public void shout() {
System.out.println("wang~");
}
}

// 文件名:User.java
package top.sh1yan.test7;

public class User {
private Cat cat;
private Dog dog;
private String str;

public Cat getCat() {
return cat;
}

public void setCat(Cat cat) {
this.cat = cat;
}

public void setDog(Dog dog) {
this.dog = dog;
}

public void setStr(String str) {
this.str = str;
}

public Dog getDog() {
return dog;
}

public String getStr() {
return str;
}
}

② 创建 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans07.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?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="dog" class="top.sh1yan.test7.Dog"/>
<bean id="cat" class="top.sh1yan.test7.Cat"/>

<bean id="user" class="top.sh1yan.test7.User">
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
<property name="str" value="shiyan11"/>
</bean>

</beans>

③ 执行下测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 路径:src\test\java
// 文件名:test09.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test7.User;

public class test09 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans07.xml");
User user = (User) context.getBean("user");
user.getCat().shout();
user.getDog().shout();
System.out.println(user.getStr());
}
}

// 运行结果

miao~
wang~
shiyan11

4.1、autowire byName (按名称自动装配)

由于在手动配置xml过程中,常常发生字母缺漏和大小写等错误,而无法对其进行检查,使得开发效率降低。

采用自动装配将避免这些错误,并且使配置简单化。

修改bean配置,增加一个属性 autowire=”byName”

1
2
// 路径:src\main\resources
// 文件名:beans07.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?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="dog" class="top.sh1yan.test7.Dog"/>
<bean id="cat" class="top.sh1yan.test7.Cat"/>

<bean id="user" class="top.sh1yan.test7.User" autowire="byName">
<!-- <property name="cat" ref="cat"/>-->
<!-- <property name="dog" ref="dog"/>-->
<property name="str" value="shiyan11"/>
</bean>

</beans>

总结:

当一个bean节点带有 autowire byName的属性时。

  1. 将查找其类中所有的set方法名,例如setCat,获得将set去掉并且首字母小写的字符串,即cat。
  2. 去spring容器中寻找是否有此字符串名称id的对象。
  3. 如果有,就取出注入;如果没有,就报空指针异常。

4.2、autowire byType (按类型自动装配)

使用autowire byType首先需要保证:同一类型的对象,在spring容器中唯一。如果不唯一,会报不唯一的异常。

将user的bean配置修改一下 : autowire=”byType”

1
2
// 路径:src\main\resources
// 文件名:beans07.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?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="dog" class="top.sh1yan.test7.Dog"/>
<bean id="cat" class="top.sh1yan.test7.Cat"/>

<bean id="user" class="top.sh1yan.test7.User" autowire="byType">
<!-- <property name="cat" ref="cat"/>-->
<!-- <property name="dog" ref="dog"/>-->
<property name="str" value="shiyan11"/>
</bean>

</beans>

4.3、使用注解装配

jdk1.5开始支持注解,spring2.5开始全面支持注解。

{导入约束、开启注解支持、在类中添加注解}

① 创建 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans08.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
<?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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
xmlns:context="http://www.springframework.org/schema/context">
<!-- 在spring配置文件中引入context文件头 -->

<!-- 开启属性注解支持 -->
<context:annotation-config/>
<bean id="dog" class="top.sh1yan.test7.Dog"/>
<bean id="cat" class="top.sh1yan.test7.Cat"/>

</beans>

② 在类中添加注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 路径:src\main\java\top\sh1yan\test7
// 文件名:User.java
package top.sh1yan.test7;

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

public class User {
@Autowired
private Cat cat;
@Autowired
private Dog dog;

public Cat getCat() {
return cat;
}

public Dog getDog() {
return dog;
}
}

③ 测试运行一下就出来结果了,这里不再测试了。

4.4 注解功能其它详解

@Autowired(required=false) 说明:false,对象可以为null;true,对象必须存对象,不能为null。

1
2
3
//如果允许对象为null,设置required = false,默认为true
@Autowired(required = false)
private Cat cat;

@Qualifier

@Autowired是根据类型自动装配的,加上@Qualifier则可以根据byName的方式自动装配

@Qualifier不能单独使用

配置文件修改内容,保证类型存在对象。且名字不为类的默认名字

1
2
3
4
<bean id="dog01" class="top.sh1yan.test7.Dog"/>
<bean id="dog02" class="top.sh1yan.test7.Dog"/>
<bean id="cat01" class="top.sh1yan.test7.Cat"/>
<bean id="cat02" class="top.sh1yan.test7.Cat"/>

在属性上添加Qualifier注解

1
2
3
4
5
6
@Autowired
@Qualifier(value = "cat02")
private Cat cat;
@Autowired
@Qualifier(value = "dog02")
private Dog dog;

@Resource

@Resource如有指定的name属性,先按该属性进行byName方式查找装配;

其次再进行默认的byName方式进行装配;

如果以上都不成功,则按byType的方式自动装配。

都不成功,则报异常。

4.5、注解小结

@Autowired与@Resource异同:

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上,或写在setter方法上。

2、@Autowired默认按类型装配(属于spring规范),默认情况下必须要求依赖对象必须存在,如果要允许null 值,可以设置它的required属性为false,如:@Autowired(required=false) ,如果我们想使用名称装配可以结合@Qualifier注解进行使用。

3、@Resource(属于J2EE复返),默认按照名称进行装配,名称可以通过name属性进行指定。如果没有指定name属性,当注解写在字段上时,默认取字段名进行按照名称查找,如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是,如果name属性一旦指定,就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象,但执行顺序不同。@Autowired先byType,@Resource先byName。

0x07 注解开发实例

1、生成简单实例

注:在spring4之后,想要使用注解形式,必须得要引入aop的包

① 创建 beans.xml 文件,并引入context约束,并配置扫描哪个包下文件。

1
2
// 路径:src\main\resources
// 文件名:beans09.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?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
http://www.springframework.org/schema/context/spring-context.xsd">
<!--引入约束-->

<!--指定注解扫描包-->
<context:component-scan base-package="top.sh1yan.test8"/>

</beans>

② 创建实例类并增加注解

1
2
3
4
5
6
7
8
9
10
11
// 路径:src\main\java\top\sh1yan\test8
// 文件名:UserShow.java
package top.sh1yan.test8;

import org.springframework.stereotype.Component;

@Component("usershow")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class UserShow {
public String name = "shiyan12";
}

③ 编写测试类进行测试运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 路径:src\test\java
// 文件名:test10.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test8.UserShow;

public class test10 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans09.xml");
UserShow usershow = context.getBean("usershow", UserShow.class);
System.out.println(usershow.name);
}
}

// 运行结果

shiyan12

2、属性注入

使用注解注入属性,分两种情况:

1、可以不用提供set方法,直接在直接名上添加@value(“值”)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 路径:src\main\java\top\sh1yan\test8
// 文件名:UserShow.java
package top.sh1yan.test8;

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

@Component("usershow")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class UserShow {
@Value("shiyan13")
// 相当于配置文件中 <property name="name" value="shiyan13"/>
public String name = "shiyan12";
}

2、如果提供了set方法,在set方法上添加@value(“值”);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 路径:src\main\java\top\sh1yan\test8
// 文件名:UserShow.java
package top.sh1yan.test8;

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

@Component("usershow")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class UserShow {
//@Value("shiyan13")
// 相当于配置文件中 <property name="name" value="shiyan13"/>
public String name = "shiyan12";

@Value("shiyan14")
public void setName(String name) {
this.name = name;
}
}

3、衍生注解

我们这些注解,就是替代了在配置文件当中配置步骤而已!更加的方便快捷!

@Component三个衍生注解

为了更好的进行分层,Spring可以使用其它三个注解,功能一样,目前使用哪一个功能都一样。

  • @Controller:web层
  • @Service:service层
  • @Repository:dao层

写上这些注解,就相当于将这个类交给Spring管理装配了!

4、自动装配注解

在 0x06的4.3和4.4中已经记录了。

5、作用域

@scope

singleton:默认的,Spring会采用单例模式创建这个对象。关闭工厂 ,所有的对象都会销毁。

prototype:多例模式。关闭工厂 ,所有的对象不会销毁。内部的垃圾回收机制会回收。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 路径:src\main\java\top\sh1yan\test8
// 文件名:UserShow.java
package top.sh1yan.test8;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component("usershow")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
@Scope("prototype")
public class UserShow {
//@Value("shiyan13")
// 相当于配置文件中 <property name="name" value="shiyan13"/>
public String name = "shiyan12";

@Value("shiyan14")
public void setName(String name) {
this.name = name;
}
}

6、总结分析

XML与注解比较:

XML可以适用任何场景 ,结构清晰,维护方便。

注解不是自己提供的类使用不了,开发简单方便。

xml与注解整合开发 :推荐最佳实践

xml管理Bean。

注解完成属性注入。

使用过程中, 可以不用扫描,扫描是为了类上的注解。

1
<context:annotation-config/>

作用:

进行注解驱动注册,从而使注解生效。

用于激活那些已经在spring容器里注册过的bean上面的注解,也就是显示的向Spring注册。

如果不扫描包,就需要手动配置bean。

如果不加注解驱动,则注入的值为null!

7、基于Java类进行配置

JavaConfig 原来是 Spring 的一个子项目,它通过 Java 类的方式提供 Bean 的定义信息,在 Spring4 的版本, JavaConfig 已正式成为 Spring4 的核心功能 。

① 编写示例类 Dog:

1
2
3
4
5
6
7
8
9
10
// 路径:src\main\java\top\sh1yan\test8
// 文件名:Dog.java
package top.sh1yan.test8;

import org.springframework.stereotype.Component;

@Component //将这个类标注为Spring的一个组件,放到容器中!
public class Dog {
public String name = "dog";
}

② 新建一个config配置包,编写一个MyConfig配置类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 路径:src\main\java\top\sh1yan\test8
// 文件名:MyConfig.java
package top.sh1yan.test8;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration //代表这是一个配置类
public class MyConfig {
@Bean //通过方法注册一个bean,这里的返回值就Bean的类型,方法名就是bean的id!
public Dog dog(){
return new Dog();
}
}

③ 测试运行一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 路径:src\test\java
// 文件名:test11.java
package top.sh1yan.test8;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration //代表这是一个配置类
public class MyConfig {
@Bean //通过方法注册一个bean,这里的返回值就Bean的类型,方法名就是bean的id!
public Dog dog(){
return new Dog();
}
}

// 运行结果

dog

7.1、导入其他配置

① 新建一个配置类:

1
2
3
4
5
6
7
8
9
// 路径:src\main\java\top\sh1yan\test8
// 文件名:MyConfig2.java
package top.sh1yan.test8;

import org.springframework.context.annotation.Configuration;

@Configuration //代表这是一个配置类
public class MyConfig2 {
}

② 修改下原配置文件:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 路径:src\main\java\top\sh1yan\test8
// 文件名:MyConfig.java
package top.sh1yan.test8;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration //代表这是一个配置类
@Import(MyConfig2.class) //导入合并其他配置类,类似于配置文件中的 inculde 标签
public class MyConfig {
@Bean //通过方法注册一个bean,这里的返回值就Bean的类型,方法名就是bean的id!
public Dog dog(){
return new Dog();
}
}

关于这种Java类的配置方式,我们在之后的SpringBoot 和 SpringCloud中还会大量看到,我们需要知道这些注解的作用即可!

0x08 AOP相关

1、什么是AOP

AOP(Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

2、AOP在Spring中的作用

提供声明式事务;允许用户自定义切面

以下名词需要了解下:

横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ….

切面(ASPECT):横切关注点 被模块化 的特殊对象。即,它是一个类。

通知(Advice):切面必须要完成的工作。即,它是类中的一个方法。

目标(Target):被通知对象。

代理(Proxy):向目标对象应用通知之后创建的对象。

切入点(PointCut):切面通知 执行的 “地点”的定义。

连接点(JointPoint):与切入点匹配的执行点。

SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice:

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能。

3、使用Spring实现Aop

【重点】使用AOP织入,需要导入一个依赖包(pox.xml)!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?xml version="1.0" encoding="UTF-8"?>
<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>top.sh1yan</groupId>
<artifactId>Spring5_Test_Dome</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
</dependencies>

</project>

3.1、通过 Spring API 实现

① 创建1个接口类:

1
2
3
4
5
6
7
8
9
10
11
12
// 路径:src\main\java\top\sh1yan\test9
// 文件名:IUserService.java
package top.sh1yan.test9;

public interface IUserService {

void add();
void delete();
void update();
void search();

}

② 创建三个实例类:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// 路径:src\main\java\top\sh1yan\test9
// 文件名:UserServiceImpl.java
package top.sh1yan.test9;

public class UserServiceImpl implements IUserService {

public void add() {
System.out.println("增加用户");
}

public void delete() {
System.out.println("删除用户");
}

public void update() {
System.out.println("更新用户");
}

public void search() {
System.out.println("查询用户");
}
}

// 文件名:FirstLogImpl.java
package top.sh1yan.test9;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class FirstLogImpl implements MethodBeforeAdvice {

//method : 要执行的目标对象的方法
//objects : 被调用的方法的参数
//o : 目标对象
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
}
}

// 文件名:AfterLogImpl.java
package top.sh1yan.test9;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLogImpl implements AfterReturningAdvice {

//o 返回值
//method被调用的方法
//args 被调用的方法的对象的参数
//o1 被调用的目标对象
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("执行了" + o1.getClass().getName()
+"的"+method.getName()+"方法,"
+"返回值:"+o);
}
}

③ 创建 beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans10.xml
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
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--添加约束-->

<!--注册bean-->
<bean id="usi01" class="top.sh1yan.test9.UserServiceImpl"/>
<bean id="fli" class="top.sh1yan.test9.FirstLogImpl"/>
<bean id="ali" class="top.sh1yan.test9.AfterLogImpl"/>

<!--aop的配置-->
<aop:config>
<!--切入点 expression:表达式匹配要执行的方法-->
<aop:pointcut id="pointcut" expression="execution(* top.sh1yan.test9.UserServiceImpl.*(..))"/>
<!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
<aop:advisor advice-ref="fli" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="ali" pointcut-ref="pointcut"/>
</aop:config>

</beans>

④ 运行测试下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 路径:src\test\java
// 文件名:test12.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test9.IUserService;

public class test12 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans10.xml");
// 动态代理的是接口,所以下面在实现的时候也需要转换成对应的接口类型
IUserService usi = (IUserService)context.getBean("usi01");
usi.add();
}
}

// 运行结果:

top.sh1yan.test9.UserServiceImpl的add方法被执行了
增加用户
执行了top.sh1yan.test9.UserServiceImpl的add方法,返回值:null

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块。

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理。

3.2、自定义类来实现Aop

① 这里依旧使用 userServiceImpl 实现类和对应的 IUserService 接口。

② 创建一个切入的实例类:

1
2
3
4
5
6
7
8
9
10
11
12
13
// 路径:src\main\java\top\sh1yan\test9
// 文件名:DiyPointcut.java
package top.sh1yan.test9;

public class DiyPointcut {

public void before(){
System.out.println("---------方法执行前---------");
}
public void after(){
System.out.println("---------方法执行后---------");
}
}

③ 创建一个 beans.xml 文件

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
// 路径:src\main\resources
// 文件名:beans11.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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--添加约束-->

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="top.sh1yan.test9.DiyPointcut"/>
<bean id="usi02" class="top.sh1yan.test9.UserServiceImpl"/>

<!--aop的配置-->
<aop:config>
<!--第二种方式:使用AOP的标签实现-->
<aop:aspect ref="diy">
<aop:pointcut id="diyPonitcut" expression="execution(* top.sh1yan.test9.UserServiceImpl.*(..))"/>
<aop:before pointcut-ref="diyPonitcut" method="before"/>
<aop:after pointcut-ref="diyPonitcut" method="after"/>
</aop:aspect>
</aop:config>

</beans>

④ 运行测试一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 路径:src\test\java
// 文件名:test13.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test9.IUserService;

public class test13 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans11.xml");
// 动态代理的是接口,所以下面在实现的时候也需要转换成对应的接口类型
IUserService diy = (IUserService) context.getBean("usi02");
diy.search();
}
}

// 运行结果

---------方法执行前---------
查询用户
---------方法执行后---------

3.3、使用注解实现

① 这里依旧使用 userServiceImpl 实现类和对应的 IUserService 接口。

②编写一个注解实现的增强类

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
// 路径:src\main\java\top\sh1yan\test9
// 文件名:AnnotationPointcut.java
package top.sh1yan.test9;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
@Before("execution(* top.sh1yan.test9.UserServiceImpl.*(..))")
public void before(){
System.out.println("---------方法执行前---------");
}

@After("execution(* top.sh1yan.test9.UserServiceImpl.*(..))")
public void after(){
System.out.println("---------方法执行后---------");
}

@Around("execution(* top.sh1yan.test9.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
System.out.println("签名:"+jp.getSignature());
//执行目标方法proceed
Object proceed = jp.proceed();
System.out.println("环绕后");
System.out.println(proceed);
}
}

② 创建一个beans.xml 文件

1
2
// 路径:src\main\resources
// 文件名:beans12.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--添加约束-->

<!--第三种方式:注解实现-->
<bean id="usi03" class="top.sh1yan.test9.UserServiceImpl"/>
<bean id="annotationPointcut" class="top.sh1yan.test9.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

</beans>

③ 测试运行一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 路径:src\test\java
// 文件名:test14.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import top.sh1yan.test9.IUserService;

public class test14 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans12.xml");
IUserService usi03 = (IUserService) context.getBean("usi03");
usi03.delete();
}
}

// 运行结果

环绕前
签名:void top.sh1yan.test9.IUserService.delete()
---------方法执行前---------
删除用户
环绕后
null
---------方法执行后---------

aop:aspectj-autoproxy:说明

1
2
3
通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理,织入切面。当然,spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作,但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了

<aop:aspectj-autoproxy />有一个proxy-target-class属性,默认为false,表示使用jdk动态代理织入增强,当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时,表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false,如果目标类没有声明接口,则spring将自动使用CGLib动态代理。

0x09 事务管理(后期在Mybatis中重点示例记录)

1、概述

事务在项目开发过程非常重要,涉及到数据的一致性的问题,不容马虎!

事务管理是企业级应用程序开发中必备技术,用来确保数据的完整性和一致性。

事务就是把一系列的动作当成一个独立的工作单元,这些动作要么全部完成,要么全部不起作用。

2、事务四个属性ACID

原子性(atomicity):事务是原子性操作,由一系列动作组成,事务的原子性确保动作要么全部完成,要么完全不起作用。

一致性(consistency):一旦所有事务动作完成,事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。

隔离性(isolation):可能多个事务会同时处理相同的数据,因此每个事务都应该与其他事务隔离开来,防止数据损坏。

持久性(durability):事务一旦完成,无论系统发生什么错误,结果都不会受到影响。通常情况下,事务的结果被写到持久化存储器中。

3、Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层,使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

编程式事务管理:

将事务管理代码嵌到业务方法中来控制事务的提交和回滚

缺点:必须在每个事务操作业务逻辑中包含额外的事务管理代码

声明式事务管理:

一般情况下比编程式事务好用。

将事务管理代码从业务方法中分离出来,以声明的方式来实现事务管理。

将事务管理作为横切关注点,通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

3.1、使用Spring管理事务

① 导入约束

1
2
3
4
xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">

4、事务管理器

无论使用Spring的哪种事务管理策略(编程式或者声明式)事务管理器都是必须的。

就是 Spring的核心事务管理抽象,管理封装了一组独立于技术的方法。

5、JDBC事务

1
2
3
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>

5.1、配置好事务管理器后我们需要去配置事务的通知

1
2
3
4
5
6
7
8
9
10
11
12
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!--配置哪些方法使用什么样的事务,配置事务的传播特性-->
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="search*" propagation="REQUIRED"/>
<tx:method name="get" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>

6、spring事务传播特性

事务传播行为就是多个事务方法相互调用时,事务如何在这些方法间传播。spring支持7种事务传播行为:

propagation_requierd:如果当前没有事务,就新建一个事务,如果已存在一个事务中,加入到这个事务中,这是最常见的选择。

propagation_supports:支持当前事务,如果没有当前事务,就以非事务方法执行。

propagation_mandatory:使用当前事务,如果没有当前事务,就抛出异常。

propagation_required_new:新建事务,如果当前存在事务,把当前事务挂起。

propagation_not_supported:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。

propagation_never:以非事务方式执行操作,如果当前事务存在则抛出异常。

propagation_nested:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与propagation_required类似的操作。

Spring 默认的事务传播行为是 PROPAGATION_REQUIRED,它适合于绝大多数的情况。

假设 ServiveX#methodX() 都工作在事务环境下(即都被 Spring 事务增强了),假设程序中存在如下的调用链:Service1#method1()->Service2#method2()->Service3#method3(),那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。

7、配置事务的重要性

如果不配置,就需要我们手动提交控制事务;

事务在项目开发过程非常重要,涉及到数据的一致性的问题,不容马虎!