spring5学习（ioc、aop、事务，webflux）

百度云资料地址：

链接：https://pan.baidu.com/s/1RNLCemXqV2fehqE7bE4JeA 提取码：tzrd

gitee代码地址：

https://gitee.com/liushanshan126/spring-guigu-study

一、示例代码

创建 xml文件

创建测试案例，获取容器中的bean

二、IOC容器

1、IOC中重要的接口BeanFactory和ApplicationContext的区别

1. ApplicationContext是BeanFactory子接口，ApplicationContext可以实现更多的功能，实际开发中使用ApplicationContext
2. BeanFactory:加载xml文件的时候不加载bean对象，使用getBean时才会创建bean对象
3. ApplicationContext：加载xml文件的时候就会创建bean对象

2、bean管理xml方式

3、bean注入，set注入（属性注入）

4、bean注入，构造函数注入（有参和无参注入）

5、p标签（简化开发代码，p = property）

在beans中加入：xmlns:p=“http://www.springframework.org/schema/p”
使用方式如下：

6、外部bean注入到当前bean中的属性中(在bean容器中有2个bean)

7、内部对象注入到当前bean中的属性中（在bean容器中只有1个bean）

8、注入属性，级联赋值

参考6

9、xml注入集合属性（数组、list、set、map）

阶段总结

1. 将对象创建出来放入bean容器中，使用bean来创建
2. 使用其他bean对象，使用ref（放入集合，属性注入，构造函数注入等都使用ref方法）

10、把集合注入部分提取出来，使用util

11、普通bean和工厂bean（factorybean）

普通bean：上面使用到的都是普通bean，在配置文件中定义bean类型就是返回类型
工厂bean：在配置文件定义bean类型可以和返回类型不一样

11.1 工厂bean（FactoryBean） 的实现方式

1. 第一步创建类，让这个类作为工厂bean，实现接口FactoryBean
2. 第二步实现接口里面的方法，在实现的方法中定义返回的bean类型

11.2 工厂bean（FactoryBean）的代码实现方式

12、bean的作用域(就是bean的范围，单例或者多例)

默认bean为单例，可以手动设置为多例
式例：

12.1 bean作用域（bean是单例/多例）的总结

1. singleton单实例，prototype多实例
2. 设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象
   设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象

13、bean的生命周期（***）

xml配置：

实体类配置：

测试类配置和实现结果：

后置处理器配置：

14、自动装配

byType和byName，可以省略property（有ref）的属性注入

15、外部引用（**）

1：需要引入context的bean
2：需要一个外部文件properties或者yml
3：使用context标签将外部文件引入进来
4:使用${}获取外部文件里面的配置

16、基于注解的方式将对象注入到aop容器中（**）

1：放入aop包

2：创建类加入注解

3：创建xml，进行自动扫描

4：测试

17、开启组件扫描配置详解（使用或者不使用默认过滤器，允许或者不允许某种注解使用）

18、@Autowired、@Qualifier、@Resource的使用

1：@Autowired：根据属性类型进行属性注入
2：@Qualifier：根据属性名称进行属性注入
@Autowired可以单独使用，类型不能满足则使用名称，可以加入@Qualifiery一起使用

3：@Resource：可以根据类型或者名称来进行属性注入

19、完全注解开发（使用配置类代替xml文件）

三、aop

1、概念

（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
（3）使用登录例子说明AOP

2、底层原理（aop底层使用jdk动态代理或者gblib动态代理）

2.1 jdk动态代理

有接口的情况

2.1.1 jdk动态代理实现代码

1：接口和实现类

2：使用proxy类中的方法

实际上的student就是一个代理对象，使用里面的方法就会调用里面的invoke方法
3：动态代理类

2.2 gblib动态代理

没有接口的情况

3、专业术语（连接点、切入点、通知；切面 =切入点+通知）

4、使用aspectj进行aop的操作（***）（aspectj为具体实现aop的方法）

4.0、切入点表达式（**）

4.1、需要用到的包

4.2、xml文件配置

4.3、需要被代理对象

4.4 、代理对象（测试前置通知，后置通知（返回通知），环绕通知，异常通知，最终通知）

package com.bear.aoptest.aspectj测试;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * <简述> aspectj测试
 * <详细描述>
 *
 * @author LiuShanshan
 * @version $Id$
 */
@Aspect
@Component
public class AspectJTest {
	// ** execution为aspect固定语句
	
    // 前置通知
    @Before(value = "execution(* com.bear.aoptest.aspectj测试.Teacher.*(..))")
    public void before(JoinPoint point){         // JoinPoint切入点，被增强的方法
//        Object[] args = point.getArgs();
//        for (Object arg : args) {
//            System.out.println(arg);
//        }
        System.out.println("before，在方法执行之前执行");
    }

    // 后置通知（返回通知）
    @AfterReturning(value = "execution(* com.bear.aoptest.aspectj测试.Teacher.*(..))")
    public void afterReturning(){
        System.out.println("afterReturning");
    }

    // 异常通知
    @AfterThrowing(value = "execution(* com.bear.aoptest.aspectj测试.Teacher.*(..))")
    public void afterThrowing() throws Throwable {
        System.out.println("异常通知");
    }

    // 环绕通知
    @Around(value = "execution(* com.bear.aoptest.aspectj测试.Teacher.*(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知之前");
        // 增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知之后");
    }

    // 最终通知
    @After(value = "execution(* com.bear.aoptest.aspectj测试.Teacher.*(..))")
    public void after(){
        System.out.println("after,方法执行之后执行");
    }

}

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

4.5、测试代码

4.6、小优化（将相同的切入点代码提取出来）

4.7 有多个增强类多同一个方法进行增强，使用order，设置增强类优先级

4.8 使用配置类（去除xml文件，使用配置类）

四、事务

1、使用事务的注解为：@Transactional， 注解里面比较重要的参数为：propagation（事务的传播行为）、isolation（事务隔离级别）、timeout、readonly、rollbackFor、noRollbackFor

1.1、propagation

7种事务的隔离级别：

1.2、ioslation：事务隔离级别

可重复读是mysql的默认隔离级别

1.3、timeout：超时时间（1）事务需要在一定时间内进行提交，如果不提交进行回滚（2）默认值是-1 ，设置时间以秒单位进行计算

1.4、readOnly：是否只读（1）读：查询操作，写：添加修改删除操作（2）readOnly默认值false，表示可以查询，可以添加修改删除操作（3）设置readOnly值是true，设置成true之后，只能查询

1.5、rollbackFor：回滚（1）设置出现哪些异常进行事务回滚

1.6、noRollbackFor：不回滚（1）设置出现哪些异常不进行事务回滚

2、使用注解类的方式配置事务

配置类：

package com.bear.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.Transactional;

import javax.sql.DataSource;

/**
 * <简述>
 * <详细描述>
 *
 * @author LiuShanshan
 * @version $Id$
 */
@Configuration
@ComponentScan("com.bear") // 组件扫描
@EnableTransactionManagement // 开启事务
public class TxConfig {
    //创建数据库连接池
    @Bean()
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///test");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        //到ioc容器中根据类型找到dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

}

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

servie层（配置事务的一层）：

测试代码：

// 配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(ConfigTest.class);
        ServiceTest serviceTest = context.getBean("serviceTest", ServiceTest.class);
        serviceTest.get();
1
2
3
4

五、Webflux（Spring5框架新功能）（未完待续—找不到实际用的地方）

1、什么是webflux（异步非阻塞的spring模块（框架））

1. 是Spring5添加新的模块，用于web开发的，功能和SpringMVC类似的，Webflux使用当前一种比较流程响应式编程出现的框架。
2. 使用传统web框架，比如SpringMVC，这些基于Servlet容器，Webflux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现的。

2、webflux的特点

第一非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程
第二函数式编程：Spring5框架基于java8，Webflux使用Java8函数式编程方式实现路由请求

3、与springmvc的比较

第一两个框架都可以使用注解方式，都运行在Tomet等容器中
第二SpringMVC采用命令式编程，Webflux采用异步响应式编程