Spring

什么是Spring？一个轻量级控制反转（IOC）和面向切面（AOP）的容器框架。

官方下载地址：JFrog

GitHub：https://github.com/spring-projects/spring-framework

官方文档：Core Technologies

Maven：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

Spring优点：开源、免费、轻量级、非入侵式、控制反转（IOC）、面向切面编程（AOP）、支持事务、支持框架整合。

Spring弊端：配置繁琐

Spring组成：

 

 拓展：

Spring Boot：

1.一个快速开发的脚手架

2.基于Spring Boot可以快速地开发单个微服务

3.约定大于配置

Spring Cloud：基于Spring Boot实现的

准备工作：新建一个工程，删除src目录，并且在pom.xml中导入依赖：

控制反转（IOC）：

IOC理论推导：

我们原来实现代码的方式：

1.UserDao接口

 2.UserDaoImpl实现类

 3.UserService业务接口

public interface UserService {
    public void getUser();
}

4.UserServiceImpl业务实现类

 但是如果我们又有一个UserDaoImpl2的实现类：

想要在service层调用的话，就需要修改原来的代码。如果之前有1000个new UserDaoImpl()，就要把这1000个都改成new UserDaoImpl2()，修改的代价很高。

优化：

 使用set的方式注入的话，想改成UserDaoImpl2，就直接new一个UserDaoImpl2的对象，传进去就行了，不需要修改原来的代码。

使用set方法实现，已经发生了革命性的变化：之前是程序主动创建对象，控制权在程序员手里。使用了set注入之后，程序不再具有主动性，而是变成了被动地接收对象。系统的耦合性降低。这也是IOC的原型。

IOC的本质：

控制反转是一种设计思想，通过XML或者注解和第三方，去生产或者获取对象的一种方式。在Spring中实现控制反转的是IOC容器，它的实现方法是依赖注入（DI）。

IOC：对象由容器来创建、管理、装配。

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

HelloSpring：

新建一个Module，导入相关的jar包（因为之前已经在Project里面导过了，所以不需要再导了）

然后在com/pojo包下，新建一个Hello实体类：

然后在resources目录下，新建applicationContext.xml文件：

测试：

 IOC创建对象的方式：

1.使用无参构造创建对象（默认）

 2.使用有参构造创建对象

第一种，下标：

第二种，参数类型（不建议使用）：

第三种，属性名：

 注意：在配置文件加载的时候，容器中管理的所有对象，就已经被初始化了。

Spring配置说明：
1.别名

 2.Bean的配置

 3.import

这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个：

 依赖注入（DI）：

1.构造器注入（前面已经说过了）

2.通过set方式注入（重点）

依赖：bean对象的创建依赖于容器

注入：bean对象中的所有属性，由容器来注入

  

3.拓展方式注入：

①p命名空间注入

②c命名空间注入

 注意点：p命名和c命名空间不能直接使用，需要导入xml约束

p命名约束：

xmlns:p="http://www.springframework.org/schema/p"

c命名约束：

xmlns:c="http://www.springframework.org/schema/c"

Bean的作用域：

作用域	解释
singleton	默认的，单例模式，不管从容器中get多少次，都是同一个对象
prototype	原型模式，每次从容器中get的时候，都会产生一个新对象
request	只能在web开发中使用
application	只能在web开发中使用
websocket	只能在web开发中使用

singleton：

prototype： 

Bean的自动装配：

自动装配是Spring满足bean依赖的一种方式。

Spring会在上下文中自动寻找，并自动给bean装配属性。

先写3个类，表示一个人有一只猫和一条狗：

  

在Spring中，有3种装配方式：

1.在xml中配置<bean></bean> 

2.在java中显式地配置

3.隐式地自动装配bean【重要】

①byName：

需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致。

 ②byType：

需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致。

 ③使用注解实现自动装配

jdk1.5开始支持注解，Spring2.5开始支持注解

使用注解的支持：

①导入约束：context约束

②配置注解的支持：<context:annotation-config/>

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

 @Autowired

1.可以在属性上使用。并且使用Autowired之后，我们就可以不用编写set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合类型byType

2.可以在set方法上使用

科普：

如果@Autowired自动装配的环境比较复杂，自动装配无法通过注解【@Autowired】完成的时候，我们可以使用@Qualifier注解配套使用

@Resource 

小结：

@Resource和@Autowired的相同点：都是用来自动装配的，都可以放在属性字段上

不同点：@Autowired通过byType的方式实现，而且必须要求这个对象存在。@Resource默认通过byName的方式实现，如果找不到名字，就通过byType实现，如果两个都找不到，就报错。

使用注解开发：

在spring4之后，要使用注解开发，必须要保证aop的包导入

使用注解需要导入context约束，增加注解的支持。

@Component：组件，放在类上，说明这个类被Spring管理了，就是bean。

bean、属性的注入和作用域：

衍生的注解：

@Component有几个衍生的注解，我们在web开发中，会按照mvc三层架构分层：

①dao层：@Repository

②service层：@Service

③controller层： @Controller

这4个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

小结：

xml与注解：xml更加万能，适用于任何场合，维护简单方便。注解不是自己类使用不了，维护相对复杂。

xml与注解的最佳实践：xml用来管理bean，注解只负责完成属性的注入。

我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启对注解的支持。

使用JavaConfig实现配置：

完全不使用Spring的xml配置了，全权交给Java来做。

JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能。

实体类：

 配置类（相当于以前的配置文件）：

 测试：

 这种纯Java的配置方式，在SpringBoot中随处可见。

静态代理、动态代理以及AOP的思想：

可以参考我之前写的博客：设计模式之代理模式——通俗易懂_丘桔的博客-CSDN博客

AOP：

什么是AOP？面向切面编程。底层是动态代理。

使用Spring实现AOP：

先导入依赖：

再写一个简单的增删改查功能：

  

 AOP的实现方式1：原生的Spring API接口【主要是实现Spring API接口】

编写日志：

然后在applicationContext.xml中注册bean和配置aop：

 测试：

 AOP的实现方式2：自定义来实现AOP【主要是定义切面】

编写日志：

然后在applicationContext.xml中注册bean和配置aop：

AOP的实现方式3：使用注解实现

编写日志：

 然后在applicationContext.xml中注册bean，并且开启注解支持：

 整合MyBatis：

方式一：

步骤：

1.导入相关jar包：junit、mybatis、mysql数据库、spring相关的、aop织入、mybatis-spring【专门整合spring和mybatis的】

mybatis-spring的官方文档：mybatis-spring –

2.编写实体类：

3.编写UserMapper接口

4.编写dao层的实现（UserMapper.xml）和核心配置文件（mybatis-config.xml）：

 5.在spring-dao.xml中，配置数据源、SqlSessionFactory、SqlSessionTemplate：

6.配置service层的实现类UserMapperImpl：

其实这里相当于原来的：
public class UserServiceImpl implements UserService{
    UserDaoImpl userDaoImpl = new UserDaoImpl();
    public List<User> selectUser(){
        return userDaoImpl.selectUser();
    }
}

7.将UserMapperImpl注入到spring容器中，并且将spring-dao.xml导入applicationContext-mybatis.xml：

8.测试：

方式二： 

service层的实现类：

并且使用这种方式，就不需要在spring-dao.xml中配置SqlSessionTemplate了。因为继承了SqlSessionDaoSupport，可以直接通过getSqlSession()方法，获得SqlSession。

然后在applicationContext-mybatis.xml中配置bean：

声明式事务：

回顾事务：

什么是事务？把一组业务捆绑在一起，要么全部成功，要么全部失败。

分类：

1.声明式事务：AOP

给userDao接口新增两个方法，删除和增加用户；

//添加一个用户
int addUser(User user);
 
//根据id删除用户
int deleteUser(int id);

 mapper文件，我们故意把 deletes 写错，测试！

 <insert id="addUser" parameterType="com.kuang.pojo.User">
 insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
 </insert>
 
 <delete id="deleteUser" parameterType="int">
 deletes from user where id = #{id}
</delete>

 编写接口的实现类，在实现类中，我们去操作一波

public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {
 
    //增加一些操作
    public List<User> selectUser() {
        User user = new User(4,"小明","123456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(4);
        return mapper.selectUser();
    }
 
    //新增
    public int addUser(User user) {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return mapper.addUser(user);
    }
    //删除
    public int deleteUser(int id) {
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        return mapper.deleteUser(id);
    }
 
}

测试 

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserMapper mapper = (UserMapper) context.getBean("userDao");
    List<User> user = mapper.selectUser();
    System.out.println(user);
}

报错：sql异常，delete写错了

结果 ：插入成功！

没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务！

以前我们都需要自己手动管理事务，十分麻烦！

但是Spring给我们提供了事务管理，我们只需要配置即可；

在spring-dao.xml中配置：

spring事务传播特性：

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

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

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 的事务传播机制都工作在同一个事务中。

就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！

配置AOP：

导入aop的头文件！

<!--配置aop织入事务-->
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.kuang.dao.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>

进行测试：

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    UserMapper mapper = (UserMapper) context.getBean("userDao");
    List<User> user = mapper.selectUser();
    System.out.println(user);
}

 2.编程式事务：需要在代码中，进行事务的管理