Spring
简介
- Spring：春天—> 给软件行业带来了春天
- 2002，首次推出了Spring框架的雏形：interface21框架
- 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版
- Rod Johnson，Spring Frameework创始人，著名作者。
- spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
- SSH：Struct2 + Spring + Hibernate
- SSM: SpringMvc + Spring + Mybatis
官网：https://spring.io/projects/spring-framework
官方下载地址：repo.spring.io
Github：spring-projects/spring-framework: Spring Framework (github.com)
1 | <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> |
优点
- Spring是一个开源的免费的框架（容器）
- Spring是一个轻量级的、非入侵式的框架
- 控制反转（IOC），面向切面编程（AOP）
- 支持事务的处理，对框架整合的支持
总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架
组成
拓展
在Spring的官网有这个介绍：现代化的java开发，说白了就是基于Spring的开发
- Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速的开发单个微服务
- 约定大于配置
- Spring Cloud
- SpringCloud是基于SpringBoot实现的
现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用
IOC理论推导
IOC基础
- UserDao接口
- UserDaoImpl实现类
- UserService业务接口
- UserServiceImpl业务实现
在之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改代码！如果程序代码量十分大，修改一次的成本代价十分昂贵
我们使用一个set接口实现，已经发生了革命性的变化！
1 | private UserDao userDao; |
- 之前，程序是主动创建对象，控制权在程序猿手上
- 使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象
这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了，系统的耦合性大大降低，可以更加庄主的在业务的实现上！这是IOC的原型！
IOC本质
控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方ioc容器，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。
采用基于XML的配置，Bean定义信息和Bean实现类本身是分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式，Spring中实现控制反转的是IOC容器，其实现方法是依赖注入(DI)。
HelloSpring
编写Hello实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}编写我们的spring文件，这里命名为beans.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<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.xcw.pojo.Hello">
<property name="str" value="spring"/>
</bean>
</beans>测试
1
2
3
4
5
6
7
8
9
10public class MyTest {
public static void main(String[] args) {
//获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext( "beans.xml");
//我们的对象现在都在Spring中管理了，我们要使用，直接去里面取出来就可以了
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
IOC创建对象的方式
使用无参构造创建对象，默认！
使用有参构造创建对象
下标赋值
1
2
3
4<!--第一种，下标赋值-->
<bean id="user" class="com.xcw.pojo.User">
<constructor-arg index="0" value="xingchuwu"/>
</bean>类型
1
2
3
4<!--第二种，通过类型创建，不建议使用-->
<bean id="user" class="com.xcw.pojo.User">
<constructor-arg type="java.lang.String" value="xingchuwu1"/>
</bean>参数名
1
2
3
4<!--第三种，直接通过参数名来设置-->
<bean id="user" class="com.xcw.pojo.User">
<constructor-arg name="name" value="xingchuwu2"/>
</bean>
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了
Spring配置
别名
1 | <!--别名，如果添加了别名，我们也可以使用别名来获取到这个对象--> |
Bean的配置
1 | <!-- |
import
import，一般用于团队开发使用，可以将多个配置文件，导入合并为一个
假设，现在项目种种那个有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！
- 张三
- 李四
- 王五
- applicationContext.xml
1 | <import resource="beans.xml"/> |
使用的时候，直接使用总的配置就可以了
依赖注入
构造器注入
Set方式注入【重点】
- 依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，由容器来注入
【环境搭建】
复杂类型
1
2
3
4
5
6
7
8
9
10
11
12public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}真是测试对象
1
2
3
4
5
6
7
8
9
10public 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;
}beans.xml
1
2
3
4
5
6
7
8
9
10
11
<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.xcw.pojo.Student">
<!--第一种，普通值注入，value-->
<property name="name" value="行初雾"/>
</bean>
</beans>测试类
1
2
3
4
5
6
7public 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());
}
}
完善注册信息
1 |
|
拓展方式注入
我们可以使用p命令空间和c命令空间进行注入
官方介绍：
使用：
1 |
|
测试：
1 | public void test(){ |
注意点：p命名空间和c命名空间不能直接使用，需要导入xml约束
1 | xmlns:p="http://www.springframework.org/schema/p" |
bean的作用域
单例模式（Spring默认机制）
1
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>
原型模式：每次从容器中get的时候，都会产生一个新对象
1
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>
其余的request、session、application，这些只能在web开发中使用到
Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找，并自动给bean装配属性
在Spring中有三种装配的方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean【重要】
测试
环境搭建：一个人有两个宠物
ByName自动装配
1 | <!-- |
ByType自动装配
1 | <!-- |
使用注解实现自动装配
jdk1.5支持的注解，Spring2.5就支持注解了
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.
使用注解须知：
- 导入约束：context约束
- 配置注解的支持 context:annotation-config/
1 |
|
@Autowired
直接在属性上使用即可，也可以在set方法上使用
使用Autowired ，可以不编写set方法，前提是这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byName
科普：
1 | 字段标记了这个注解，说明这个字段可以为null |
1 | public Autowired { |
测试代码
1 | public class People { |
使用@Autowired自动装配的环境比较复杂时，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的的bean对象注入
1 | public class People { |
@Resource
1 | public class People { |
小结：
@Resource和@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType的方式实现，而且必须要求这个对象存在
- @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现，在两个都找不到的情况下，就报错
- 执行顺序不同：@Autowired通过byType的方式实现，@Resource默认通过byname的方式实现
使用注解开发
在Spring4之后，要使用注解开发，必须要保证aop的包导入
使用注解需要导入context约束，增加注解的支持
1 |
|
bean
@Component ：组件，放在类上，说明这个类被Spring管理了，就是bean
属性如何注入
1
2
3
4
5
6
7
public class User {
//相当于<property name="name" value="xingchuwu"/>
public String name;
}衍生的注解
@Component有几个衍生注解，在web开发中，会按照mvc三层架构分层
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
这四个注解的功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
自动装配值
1
2
3
4@Autowired ：自动装配通过类型，名字
如果Autowired不能唯一自动装配上属性，就需要通过@Qualifier(value="xxx")
@Nullable 字段标记了这个注解，说明这个字段可以为null
Resource ： 自动装配通过名字，类型作用域
@Scope(“prototype”)
小结
xml与注解：
- xml 更加万能，适用于任何场合，维护简单方便
- 注解 不是自己的类使用不了，维护相对复杂
xml与注解 最佳实践
- xml用来管理bean
- 注解只负责完成属性的注入
- 在使用的过程中，需要注意一个问题：想要让注解生效，就需要开启注解的支持
1
2
3<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.xcw.pojo"/>
<context:annotation-config/>
使用java的方式配置Spring
可以完全不适用Spring的xml配置，全权交给java来做
javaConfig 是Spring的一个子项目，在Spring 4 之后，他成为了一个核心功能
实体类
1 | //这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中 |
配置文件
1 | //这个也会被Spring容器托管，注册到容器中，因为它本来就是一个@Compon |
测试类
1 | public class MyTest { |
这种纯java的配置方式，在SpringBoot中随处可见
代理模式
为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一个附属操作
- 客户：访问代理对象的人
代码步骤：
接口
1
2
3
4//租房
public interface Rent {
public void rent();
}真实角色
1
2
3
4
5
6
7
8//房东
public class Host implements Rent{
public void rent() {
System.out.println("房东要出租房子");
}
}代理角色
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
30public class Proxy implements Rent{
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent() {
seeHouse();
host.rent();
heTong();
fare();
}
//看房
public void seeHouse(){
System.out.println("中介带你看房");
}
//合同
public void heTong(){
System.out.println("签租赁合同");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
}客户端访问代理角色
1
2
3
4
5
6
7
8
9
10
11
12public class Client {
public static void main(String[] args) {
//房东要出租房子
Host host = new Host();
//代理，中介代房东出租房子，代理一般会有一些附属操作
Proxy proxy = new Proxy(host);
//你不用面对房东，直接找中介租房即可
proxy.rent();
}
}
代理模式的好处：
- 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
- 公共业务就交给代理角色，实现了业务的分工
- 公共业务发生扩展的时候，方便集中管理
缺点：一个真实角色就会产生一个代理角色，代码量会翻倍~开发效率会变低
加深理解
聊聊AOP：
动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 — JDK动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javasist
需要了解两个类：Proxy ：代理，InvocationHandler：调用处理程序
动态代理的好处：
- 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
- 公共业务就交给代理角色，实现了业务的分工
- 公共业务发生扩展的时候，方便集中管理
- 一个动态代理类代理的是一个接口，一般就是对应的一些业务
- 一个动态代理类可以代理多个类，只要实现同一个接口即可
AOP
什么是AOP
AOP（Aspect Oriented Programming） 意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
Aop在Spring中的作用
==提供声明式事务；允许用户自定也切面==
- 横切关注点：跨越应用程序多个模块的方法或功能，即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志、安全、缓存、事务等等…
- 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类
- 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法
- 目标（Target）：被通知的对象
- 代理（Proxy）：向目标对应应用通知之后创建的对象
- 切入点（PointCut）：切面通知 执行的“地点”的定义
- 连接点（JointPoint）：与切入点匹配的执行点
SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice
即Aop在不改变原有代码的情况下，去增加新的功能
使用Spring实现AOP
【重点】使用AOP织入，需要导入一个依赖包
1 | <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> |
方式一：使用Spring的API接口【主要SpringAPI接口实现】
方式二：自定义来实现AOP【主要是切面定义】
方式三：使用注解实现
整合Mybatis
步骤：
- 导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop织入
- mybatis-spring【new】
- 编写配置文件
- 测试
回忆Mybatis
- 编写pojo实体类
- 实现mybatis的配置文件
- UserDao接口编写
- 接口对应的Mapper映射文件
- 测试类
Mybatis-spring
整合实现一：
编写数据源配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--
DataSource：使用Spring的数据源替换Mybatis的配置，c3p0 dbcp druid
这里使用Spring提供的JDBC：org.springframework.jdbc.datasource
-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="cjy521213"/>
</bean>
</beans>sqlSessionFactory
1
2
3
4
5
6
7<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/xcw/mapper/*.xml"/>
</bean>sqlSessionTemplate
1
2
3
4
5<!--SqlSessionTemplate：就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>需要给接口加实现类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class UserMapperImpl implements UserMapper{
//在原来，我们所有操作都使用sqlSession来执行，现在都使用SqlSessionTemplate
private SqlSessionTemplate sqlSession;
public void setSqlSession(SqlSessionTemplate sqlSession) {
this.sqlSession = sqlSession;
}
public List<User> getUser() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.getUser();
}
}将自己写的实现类，注入到Spring中
1
2
3<bean id="userMapper" class="com.xcw.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>测试使用即可
1
2
3
4
5
6
7
8
9
10
public void test() throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper1", UserMapper.class);
List<User> users = userMapper.getUser();
for (User user : users) {
System.out.println(user);
}
}
整合实现二：
mybatis-spring1.2.3版以上的才有这个 .
编写数据源配置
sqlSessionFactory
实现类
1
2
3
4
5public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
public List<User> getUser() {
return getSqlSession().getMapper(UserMapper.class).getUser();
}
}将自己写的实现类，注入到Spring中
1
2
3<bean id="userMapper2" class="com.xcw.mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>测试使用即可
1
2
3
4
5
6
7
8
9
10
public void test() throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
List<User> users = userMapper.getUser();
for (User user : users) {
System.out.println(user);
}
}
声明式事务
回顾事务
- 把一组业务当成一个业务来做，要么都成功，要么都失败
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性
事务ACID原则：
原子性
一致性
隔离性
- 多个业务可能操作同一个资源，防止数据损坏
持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中
spring中的事务管理
Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。
- 声明式事务：AOP
- 一般情况下比编程式事务好用。
- 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
- 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
- 编程式事务：需要在代码中，进行事务的管理
- 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
- 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码
使用Spring管理事务，注意头文件的约束导入 : tx
1 | xmlns:tx="http://www.springframework.org/schema/tx" |
1 | <!--配置声明式事务--> |
思考：
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况
- 如果我们不在Spring中去配置声明式事务，就需要在代码中手动配置事务
- 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！