栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

[Study]Spring

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

[Study]Spring

文章目录
  • 一、IOC(控制反转)
    • 1.1 Spring5 概述
    • 1.2 Spring 入门案例
    • 1.3 IOC 概念及原理
    • 1.4 DI(依赖注入)
    • 1.5 公共注入工具
    • 1.6 工厂 bean
    • 1.7 单、多实例
    • 1.8 bean 生命周期
    • 1.9 自动装配
    • 1.10 引入外部文件
    • 1.11 组件扫描策略
    • 1.12 IOC 实现(配置 + 注解 )
    • 1.13 IOC 实现(完全注解)
  • 二、AOP(面向切面编程)
    • 2.1 AOP 概述
    • 2.2 JDK 动态代理实现
    • 2.3 AspectJ 实现 AOP(注解 + 配置)
    • 2.4 AspectJ 实现 AOP(配置文件)
    • 2.5 AspectJ 实现 AOP(完全注解)
  • 三、JdbcTemplate
    • 3.1 Spring 中 JdbcTemplate 的实现
    • 3.2 JdbcTemplate 中的 CRUD
  • 四、Transaction(事务操作)
    • 4.1 事务概念
    • 4.2 声明式事务(注解 + 配置)
    • 4.3 声明式事务(配置文件)
    • 4.4 声明式事务(完全注解)
    • 4.5 @Transactional 常用参数
    • 4.6 事务传播行为
  • 五、Spring5 新特性
    • 5.1 整合 Log4j 日志框架
    • 5.2 整合 Junit 单元测试框架
    • 5.3 @Nullable 注解
    • 5.4 函数式注册对象
    • 5.5 Webflux(前置知识:SpringMVC、SpringBoot、Maven、Java8 新特性)

一、IOC(控制反转) 1.1 Spring5 概述
  1. Spring 是轻量级开源的 JavaEE 框架,可以解决企业开发的复杂性。Spring 有两个核心部分 IOC 和 Aop

    1. IOC(Inversion of Control):控制反转,把创建对象的过程交给 Spring 进行管理
    2. Aop(Aspect Oriented Programming):面向切面编程,不修改源代码的情况下增强功能
  2. Spring 特点:

    1. 方便解耦、简化开发
    2. AOP 的支持
    3. 方便程序的测试
    4. 方便集成其它框架
    5. 降低 JavaEE API 的使用难度
    6. 方便进行事务操作
  3. Spring5 组成示意图

1.2 Spring 入门案例
  1. 新建 maven 工程,引入 Spring 依赖

    
        org.springframework
        spring-core
        5.3.18
    
    
        org.springframework
        spring-context
        5.3.18
    
    
    
        junit
        junit
        4.13.1
        test
    
    
  2. 在 resources 目录下新建 bean 类的 xml 配置文件,写入配置信息

    
    
        
    
    
  3. 在 Test 类中读取配置文件,获取 bean 实例并调用其方法

    @Test
    public void print() {
        // 加载 Spring 配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 创建对象,底层框架创建对象时默认执行无参构造器
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.print();
    }
    
1.3 IOC 概念及原理
  1. IOC(Inversion of Control)控制反转,是面向对象编程中的一种设计原则,用来降低代码间的耦合度。把对象创建及对象之间的调用过程都交给 Spring 进行管理。底层主要使用了 xml 解析技术、工厂设计模式、反射等技术

  2. IOC 容器管理 bean 实例过程

    1. 在 xml 文件中配置 bean 类的路径
    2. 通过 xml 解析技术获取 bean 类的全路径
    3. 利用反射技术创建类的实例对象
  3. Spring 提供 IOC 容器的两种方式

    1. BeanFactory:IOC 容器基本实现,Spring 底层框架使用,一般情况下不建议开发人员使用,特点是加载配置文件的时不会创建对象,在获取或使用对象的时候才创建对象
    2. ApplicationContext:BeanFactory 的子接口,提供了比 BeanFactory 更多的功能,特点是加载配置文件的同时创建对象,开发人员使用
  4. 使用 IOC 时依赖的 Spring 核心 jar 包

    1. spring-expression
    2. spring-core
    3. spring-context
    4. spring-beans
1.4 DI(依赖注入)
  1. DI(Dependency Injection)依赖注入,是 IOC 的一种具体实现,Spring 中支持 setter 方法和有参构造器注入属性

  2. setter 方法注入属性

    
    
        
        
    
    
  3. 有参构造器注入属性

    
        
        
    
    
  4. p 名称空间注入属性

    
    
  5. 注入空值 null

    
    
        
            
        
    
    
  6. 注入特殊符号 > 或 <

    
    
        
            >]]>
        
    
    
    
        >">>"/>
    
    
  7. 注入外部 bean:外部 bean 可以被多个 bean 对象引用

    
    
        
        
    
    
  8. 注入内部 bean:内部 bean 只能被某个对象的某个属性引用

    
    
        
        
        
            
                
            
        
    
    
  9. 级联赋值

    
    
        
        
        
    
    
        
    
    
    
    
        
        
        
        
        
    
    
    
  10. 注入 Array

    
        
        
            
                Java
                Cpp
            
        
        
    
  11. 注入 List

    
        
        
            
                Database
                MySQL
            
        
        
    
  12. 注入 Set

    
        
        
            
                1
                2
            
        
        
    
  13. 注入 Map

    
        
        
            
                
                
            
        
    
    
  14. 注入集合(集合中含有其它 bean)

    
        
        
            
                
                
            
        
    
    
    
        
    
    
        
    
    
1.5 公共注入工具
  1. 引入 util 名称空间
  2. 抽取 util:list 注入工具 courseList
  3. 在其它 bean 中直接使用 courseList 完成注入

    


    



    
    


	
    

1.6 工厂 bean
  1. 普通 bean 和工厂 bean 的区别

    1. 普通 bean:在配置文件中定义的 bean 类型就是返回的类型
    2. 工厂 bean:实际返回的 bean 类型可以和配置文件中声明的类型不一致
  2. 工厂 bean 的使用:自定义类实现 FactoryBean 接口,在实现的 getObject 方法中根据需要返回具体的 bean 类型,此时实际返回的类型跟在 xml 配置文件中声明类型与可以不一致

    public class Bean implements FactoryBean {
        @Override
        public boolean isSingleton() {
            return FactoryBean.super.isSingleton();
        }
    
        @Override
        public Course getObject() {
            Course course = new Course();
            course.setName("Spring5");
            return course;
        }
    
        @Override
        public Class getObjectType() {
            return null;
        }
    }
    
1.7 单、多实例
  1. Spring 中默认创建的对象为单实例,可以通过配置 scope="prototype" 属性设置多实例 (每次获取对象时都创建新的对象)

  2. 单实例对象在加载配置文件的时候就会创建,而多实例对象只有在获取对象的时候才创建

    
    
        
    
    
1.8 bean 生命周期
  1. 通过无参构造器创建 bean 实例

  2. 调用 setter 方法为 bean 的字段赋值和完成对其它 bean 的引用

  3. 调用 bean 的初始化方法(初始化方法需要进行配置:在 bean 标签中使用 init-method 属性调用自定义的初始化方法)

  4. 若创建了后置处理器(自定义类实现 BeanPostProcessor 接口,在 xml 配置文件中使用 bean 标签进行配置此实现类的 bean),则在第三步之后会把 bean 实例传递给后置处理器的 postProcessBeforeInitialization 方法,可在此方法中对初始化后的 bean 进行进一步处理,Spring 会为当前配置文件中的所有 bean 实例都添加后置处理器,而后进行第五步;未配置后置处理器则直接进行第五步

    public class BeanPost implements BeanPostProcessor {
       @Override
       public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
          return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
       }
    
       @Override
       public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
          return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
       }
    }
    
  5. 获取到 bean 对象,正常使用 bean

  6. 当容器关闭的时候,调用 bean 的销毁方法(销毁方法需要进行配置:在 bean 标签中使用 destory-method 属性调用自定义的销毁方法,当调用 context.close(); 销毁 bean 对象时此自定义销毁方法会被调用)

1.9 自动装配

自动装配:根据指定的装配规则(属性名称或属性类型),Spring 自动将匹配的属性值进行注入,使用 bean 标签中的 autowire 属性指定自动装配,autowire 属性有两个常用的值 byName 和 byType

  1. byName:根据属性名进行注入,注入值 bean 的 id 值和类属性名称一致
  2. byType:根据类型注入(要求配置文件中有且仅有一个该类型的 bean 实例)



    

1.10 引入外部文件
  1. 引入 context 名称空间

  2. 使用 context:property-placeholder 标签引入配置文件

    # Jdbc.properties
    jdbc.driver=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/panda?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    jdbc.username=admin
    jdbc.password=admin
    
  3. 最后使用 ${} 读取配置文件中的属性信息

    
    
    
        
        
        
        
    
    
1.11 组件扫描策略
  1. 组件扫描策略一:默认的扫描过滤器, exclude-filter 指定不扫描含有 Controller 注解的组件

    
        
        
    
    
  2. 组件扫描策略二:使用自定义的扫描过滤器, include-filter 指定只扫描含有 Service 注解的组件

    
        
        
    
    
1.12 IOC 实现(配置 + 注解 )
  1. Spring 针对 bean 管理提供的四个常用注解

    1. @Component:任意组件
    2. @Repository:Dao 层
    3. @Service:Service 层
    4. @Controller:Web 层
  2. 使用注解方式创建对象的步骤

    1. 引入 aop 依赖:spring-aop
    2. 配置文件中引入 context 名称空间
    3. 配置文件中开启组件扫描
    4. 类上使用注解声明此类是组件类,归 Spring 管理
    // value 值可以省略,默认为首字母小写的类名 
    //                 <=> 
    // 
    @Service(value = "userService")
    public class UserService {
        public void addUser() {
            System.out.println("User added");
        }
    }
    
  3. 注解方式注入属性

    1. @Autowired:根据属性类型进行自动装配(Spring 提供的注解)
    @Service
    public class UserService {
        // 在 UserDaoImpl 类上加上 @Repository 注解以创建 UserDaoImpl 的实例
        @Autowired
        private UserDao userDao;
    
        public void addUser() {
            System.out.println("User added");
            userDao.saveUser();
        }
    }
    
    1. @Qualifier:根据属性名称进行注入,使用时需和 @Autowired 一起使用(Spring 提供的注解)
    2. @Resource:可以根据类型注入、也可以根据名称注入 @Resource (name="userDaoImpl")(javax 包中提供的注解)
    3. @Value:注入普通类型如整型、布尔型等
    @Value("3")
    private Integer integer;
    
1.13 IOC 实现(完全注解)
  1. 创建配置类(类上加上 @Configuration 注解声明此类是配置类)以替代 xml 配置文件,并在配置类上使用 @ComponentScan 声明扫描的组件

    @Configuration
    @ComponentScan(basePackages = {"com.bear.spring"})
    public class UserConfig {
    }
    
  2. 在对应类上使用注解声明此类是 Spring 的组件

    1. @Component:任意组件
    2. @Repository:Dao 层组件
    3. @Service:Service 层组件
    4. @Controller:Web 层组件
    @Component
    public class User {......}
    
  3. 获取对象时使用 AnnotationConfigApplicationContext 加载配置类,获取配置信息

    @Test
    public void print() {
         // 加载配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(UserConfig.class);
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.print();
    }
    
二、AOP(面向切面编程) 2.1 AOP 概述
  1. AOP(Aspect Oriented Programming)面向切面编程,通过预编译方式和运行期间动态实现程序功能的一种技术。利用 AOP 可以对业务逻辑的各个部分进行隔离,从而使业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高开发的效率

    通俗描述:在不改变源代码的基础上,在主功能上添加新功能

  2. AOP 的底层使用动态代理

    1. 有接口时使用 JDK 动态代理:创建接口实现类的代理对象,增强类中方法的功能
    2. 无接口时使用 CGLIB 动态代理:创建子类的代理对象,增强类中方法的功能
  3. AOP 操作所需依赖:在 Spring 框架中一般都是基于 AspectJ 实现 AOP 操作,AspectJ 不是 Spring 的组成部分,需单独引入

    
        org.springframework
        spring-aop
        5.3.18
    
    
        org.aspectj
        aspectjweaver
        1.6.12
    
    
        cglib
        cglib
        2.2.2
    
    
  4. AOP 操作术语

    1. 连接点:类中可以被增强的方法称为连接点
    2. 切入点:实际被增强的方法称为切入点
    3. 通知(增强):方法中实际被增强的逻辑部分就称为通知。分为前置通知、后置通知、环绕通知、异常通知、最终通知
    4. 切面:把通知应用到切入点的过程就叫做切面(是一个动作)
  5. 切入点表达式:配置对哪个类的哪个方法进行增强 execution([权限修饰符][返回类型][类全路径][方法名称][参数列表])

    
    execution[* com.bear.aop.dao.impl.UserDaoImpl.saveUser(..)]
    
2.2 JDK 动态代理实现

使用 java.lang.reflect.Proxy 类中的 newProxyInstance 方法实现 JDK 动态代理

public class UserDaoProxy{
	public static void main(String[] args) {
	    // 有接口情况实现 JDK 动态代理,增强原有方法功能
	    UserDao userDao = (UserDao) Proxy.newProxyInstance(UserDaoProxy.class.getClassLoader(), new Class[]{UserDao.class}, new InvocationHandler() {
	        @Override
	        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	            // 1. 方法调用之前执行逻辑
	            System.out.println("被执行的方法 " + method.getName() + "n参数:" + Arrays.toString(args));
	            // 2. 调用原来的方法
	            Object obj = method.invoke(new UserDaoImpl(), args);
	            /// 3. 方法执行之后的逻辑
	            System.out.println("用户保存成功");
	            return obj;
	        }
	    });
	    userDao.saveUser("admin", "admin");
	}
}
2.3 AspectJ 实现 AOP(注解 + 配置)
  1. 在配置文件中开启组件扫描(引入 context 和 aop 名称空间)

    
    
    
  2. 使用注解创建 BookDao 对象和 BookDaoProxy 代理对象 (类上加上 @Aspect 注解)

    @Repository
    public class BookDao {
        public void saveBook() {
            System.out.println("BookDaoImpl execute the saveBook() method");
        }
    }
    
    
    @Aspect
    @Component
    public class BookDaoProxy {
    }
    
  3. 在配置文件中开启 AspectJ 生成代理对象

    
    
    
  4. 在代理类中编写增强方法,使用注解配置不同类型的通知(切入表达式)

    @Aspect
    @Component
    public class BookDaoProxy {
        @Before(value = "execution(* com.bear.aop.dao.BookDao.saveBook(..))")
        public void before() {
            System.out.println("前置通知");
        }
    
        @After(value = "execution(* com.bear.aop.dao.BookDao.saveBook(..))")
        public void after() {
            System.out.println("最终通知");
        }
    
        @AfterReturning(value = "execution(* com.bear.aop.dao.BookDao.saveBook(..))")
        public void afterReturn() {
            System.out.println("后置通知或返回通知");
        }
    
        @AfterThrowing(value = "execution(* com.bear.aop.dao.BookDao.saveBook(..))")
        public void afterThrow() {
            System.out.println("异常通知");
        }
    
        @Around(value = "execution(* com.bear.aop.dao.BookDao.saveBook(..))")
        public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            System.out.println("环绕之前");
            // 执行被增强的方法
            proceedingJoinPoint.proceed();
            System.out.println("环绕之后");
        }
    }
    
  5. 测试一把

    @Test
    public void aopTest() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 获取对象
        BookDao bookDao = context.getBean("bookDao", BookDao.class);
        bookDao.saveBook();
    }
    
  6. AOP 中各通知执行顺序的说明

    1. 被增强的方法中无异常产生时:环绕之前、前置、被增强的方法、环绕之后、最终、后置

    1. 被增强的方法中有异常产生时:@AfterReturning(返回通知) 和 @Around 环绕之后的通知不再执行

    1. 有多个类对同一个类的同一个方法同时进行增强时,可以设置增强类的优先级,在增强类上加上 @Order(int) 注解,参数值越小优先级越高
  7. AspectJ 抽取各种通知中相同的切入点,即可在其它通知中直接引入公共切入点配置的通知

    // 公共切入点
    @Pointcut(value = "execution(* com.bear.aop.dao.BookDao.saveBook(..))")
    public void pub() {
    }
    
    // 引入公共切入点通知
    @Before(value = "pub()")
    public void before() {
        System.out.println("前置通知");
    }
    
2.4 AspectJ 实现 AOP(配置文件)
  1. 在配置文件中开启组件扫描(引入 context 和 aop 名称空间)

    
    
    
  2. 在配置文件中创建两个类 BookDao 和 BookDaoProxy 的 bean 实例

    
    
    
  3. 在配置文件中开启 AspectJ 生成代理对象

    
    
    
  4. 在配置文件中配置切入点与切面

    
    
        
        
        
        
            
            
        
    
    
  5. 测试一把

    @Test
    public void aopTest() {
        // 加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 获取对象
        BookDao bookDao = context.getBean("bookDao", BookDao.class);
        bookDao.saveBook();
    }
    
2.5 AspectJ 实现 AOP(完全注解)
  1. 创建配置类(类上加上 @Configuration 注解),替代 xml 配置文件
  2. 在配置类上使用 @ComponentScan 注解扫描组件
  3. 使用注解创建 BookDao 对象和 BookDaoProxy 代理对象 (类上加上 @Aspect 注解)
  4. 配置类上使用 @EnableAspectJAutoProxy 开启生成代理对象
  5. 在代理类中编写增强方法,使用注解配置不同类型的通知(切入表达式)
  6. 测试时使用 AnnotationConfigApplicationContext 加载配置类
三、JdbcTemplate 3.1 Spring 中 JdbcTemplate 的实现
  1. 引入 maven 依赖

    
        org.springframework
        spring-jdbc
        5.3.18
    
    
        org.springframework
        spring-orm
        5.3.18
    
    
        mysql
        mysql-connector-java
        8.0.28
    
    
        com.alibaba
        druid
        1.1.10
    
    
  2. 在 xml 配置文件中开启组件扫描、配置数据源信息、配置 JdbcTemplate 对象并注入数据源

    
    
    
    
    
    
        
        
        
        
    
    
    
    
        
    
    
  3. 创建 Dao 类并注入 jdbcTemplate 对象

    @Repository
    public class UserDaoImpl {
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        public void getJdbcTemplate() {
            System.out.println(jdbcTemplate);
        }
    }
    
  4. 测试一把

    @Test
    public void jdbcTest() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("jdbc.xml");
        // 获取对象
        UserDaoImpl userDaoImpl = applicationContext.getBean("userDaoImpl", UserDaoImpl.class);
        System.out.println(userDaoImpl);
        userDaoImpl.getJdbcTemplate();
    }
    
3.2 JdbcTemplate 中的 CRUD
  1. JdbcTemplate INSERT 功能实现

    @Repository
    public class UserDaoImpl implements UserDao {
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Override
        public int saveUser(User user) {
            String sql = "insert into t_user values (?,?,?);";
            return jdbcTemplate.update(sql, user.getId(), user.getUsername(), user.getPassword());
        }
    }
    
  2. JdbcTemplate SELECT 功能实现

    // 查询返回单个值
    String sql = "select count(id) from t_user;";
    return jdbcTemplate.queryForObject(sql, Integer.class);
    // 查询返回单条记录
    String sql = "select * from t_user where id = ?;";
    return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), id);
    // 查询返回记录 List 集合
    String sql = "select * from t_user;";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
    
  3. JdbcTemplate 批处理功能实现

    @Overried
    public int[] batchSaveUser(List usersList) {
        String sql = "insert into t_user (`username`,`password`) values (?,?)";
        return jdbcTemplate.batchUpdate(sql, usersList);
    }
    
    
    @Test
    public void batchInsertTest(){
    	List objectsList = new ArrayList<>();
    	Object[] user1 = {"1", "1"};
    	Object[] user2 = {"2", "2"};
    	Object[] user3 = {"3", "3"};
    	objectsList.add(user1);
    	objectsList.add(user2);
    	objectsList.add(user3);
    	int[] res = userDao.batchSaveUser(objectsList);
    	System.out.println(Arrays.toString(res));
    }
    
四、Transaction(事务操作) 4.1 事务概念
  1. 定义:事务是数据库操作的最基本单元,逻辑上一组操作要么都成功,若有一个失败则所有操作全都失败

  2. Spring 中事务管理的两种方式:编程式事务管理和声明式事务管理(常用,底层运用到了 AOP),事务操作一般添加到 JavaEE 三层结构中的 Service 层

  3. 事务的 ACID 四大特性

    特性描述
    原子性(atomicity)事务是一个不可分割的工作单位,要么都发生,要么都失败
    一致性(consistency)事务保证数据库从一个一致性状态转换到另一个一致性状态
    隔离性(isolation)多个并发事务之间根据隔离级别不同相互隔离
    持久性(durability)事务一旦提交,对数据的改变就是永久性的
  4. 事务操作中因隔离级别不同容易出现的问题

    问题描述
    脏读(dirty read)一个事务读取到另一个事务尚未提交的操作
    幻读(phantom read)一个事务读取到另一个事务已提交的插入操作
    不可重复读(nonrepeatable read)一个事务读取到另一个事务已提交的修改操作
  5. MySQL 中的事务隔离级别

    隔离级别脏读不可重复读幻读
    读未提交(read uncommintted)YYY
    读已提交(read committed)NYY
    可重复读(repeatable read)(默认)NNY
    可串行化(serializable)NNN
4.2 声明式事务(注解 + 配置)
  1. 在配置文件中创建事务管理器并注入数据源

    
    
        
        
        
        
    
    
    
    
        
    
    
  2. 引入 tx 名称空间,开启事务注解

    
    
  3. 在 Service 类或方法上使用 @Transactional 声明此类所有方法或当前方法开启事务操作

    @Transactional
    public boolean transfer(String username1, String username2, int amount) {
        int res1 = userDao.addBalanceByUsername(amount, username1);
        // int d = 1/0;
        int res2 = userDao.subBalanceByUsername(amount, username2);
        return res1 == 1 && res2 == 1;
    }
    
  4. 测试一把

    @Test
    public void transfer() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        UserServiceImpl userServiceImpl = context.getBean("userServiceImpl", UserServiceImpl.class);
        if (userServiceImpl.transfer("spring", "bear", 100)) {
            System.out.println("转账成功");
        } else {
            System.out.println("转账失败");
        }
    }
    
4.3 声明式事务(配置文件)
  1. 配置事务管理器并注入数据源

    
    
        
        
        
        
    
    
    
    
        
    
    
  2. 引入 tx 名称空间,开启事务注解

    
    
  3. 配置通知(类方法中被增强的逻辑部分)和事务参数

    
    
    	
    	
    		
    	
    
    
  4. 配置切入点(被增强的方法)和切面(将通知应用到切入点的过程)

    
    
        
        
        
        
    
    
  5. 测试一把

    @Test
    public void transfer() {
    	ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    	UserServiceImpl userServiceImpl = context.getBean("userServiceImpl", UserServiceImpl.class);
    	if (userServiceImpl.transfer("spring", "bear", 100)) {
    		System.out.println("转账成功");
    	} else {
    		System.out.println("转账失败");
    	}
    }
    
4.4 声明式事务(完全注解)
  1. 创建配置类以替代 xml 配置文件,使用 @EnableTransactionManagement 开启事务

    @Configuration
    @EnableTransactionManagement
    @ComponentScan(basePackages = "com.bear.aop")
    public class TransactionConfig {
        
        @Bean
        public DruidDataSource getDruidDataSource() {
            DruidDataSource druidDataSource = new DruidDataSource();
            druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
            druidDataSource.setUrl("jdbc:mysql://localhost:3306/spring");
            druidDataSource.setUsername("spring");
            druidDataSource.setPassword("spring");
            return druidDataSource;
        }
    
        
        @Bean
        public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
            // Spring 在 IOC 容器中根据类型找到已创建的 dataSource
            return new JdbcTemplate(dataSource);
        }
    
        
        @Bean
        public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }
    }
    
  2. 在 Service 类或方法上使用 @Transactional 声明此类所有方法或当前方法开启事务操作

    @Transactional
    public boolean transfer(String username1, String username2, int amount) {
        int res1 = userDao.addBalanceByUsername(amount, username1);
        // int d = 1/0;
        int res2 = userDao.subBalanceByUsername(amount, username2);
        return res1 == 1 && res2 == 1;
    }
    
  3. 测试一把

    @Test
    public void configTransfer() {
        // 使用 AnnotationConfigApplicationContext 加载配置类获取实例
        ApplicationContext context = new AnnotationConfigApplicationContext(TransactionConfig.class);
        UserServiceImpl userServiceImpl = context.getBean("userServiceImpl", UserServiceImpl.class);
        if (userServiceImpl.transfer("spring", "bear", 100)) {
            System.out.println("转账成功");
        } else {
            System.out.println("转账失败");
        }
    }
    
4.5 @Transactional 常用参数
参数描述
propagation(事务传播行为)多事务方法之间进行调用,在这个过程中事务的管理方式,Spring 中共有 7 中事务传播行为
isolation(事务隔离级别)可选【读未提交、读已提交、可重复读、可串行化】四种常用隔离级别
timeout(超时时间)事务需要在指定的时间内提交(单位为秒),若未提交则回滚。Spring 中默认超时时间设置为 -1 即不超时
readonl(是否只读)
rollbackFor(回滚)设置出现了哪些异常时进行回滚
noRollbackFor(不回滚)设置尽管出现了某些异常,事务照常提交,不进行回滚

4.6 事务传播行为

多事务方法之间进行调用,在这个过程中事务的管理方式,Spring 中共有 7 中事务传播行为,REQUIRED 为默认事务传播行为

传播属性定义
REQUIRED如果有事务在运行,当前的方法就在这事务内运行,否则就启动一个新的事务,并在自己的事务内运行
REQUIRED_NEW当前的方法必须启动新事务,并在它自己的事务内运行,如果有事务正在运行就将其挂起
SUPPORTS如果有事务在运行,当前的方法就在这个事务内运行,否则它可以不运行在事务中
NOT_SUPPORTES当前的方法不应该运行在事务中,如果有运行的事务就挂起
MANDATORY当前的方法必须运行在事务内部,如果没有正在运行的事务,就抛出异常
NEVER当前的方法不应该运行在事务中,如果有运行的事务,就抛出异常
NESTED如果有事务运行,当前的方法就在这个事务的嵌套事务内运行。否则就启动一个新事务,并在它自己的事务内运行
五、Spring5 新特性 5.1 整合 Log4j 日志框架
  1. Spring5.0 框架自带了通用的日志封装,已经移除了 Log4jConfigListener,官方建议使用 Log4j2。整个 Spring5 框架的代码基于 Java8,运行时兼容 JDK9,许多过时的类和方法已删除

  2. Spring5 整合 Log4j 实现自定义日志输出

    1. 导入 Log4j 和 slf 依赖
    
        org.apache.logging.log4j
        log4j-core
        2.17.1
    
    
        org.apache.logging.log4j
        log4j-slf4j-impl
        2.17.1
        test
    
    
    1. maven 工程 resources 目录下创建 log4j2.xml 配置文件
    
    
    
    
        
        
            
            
                
                
            
        
        
        
        
            
                
            
        
    
    
    1. 测试一把
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    
    public class UserLog {
        private static final Logger LOGGER = LoggerFactory.getLogger(UserLog.class);
    
        public static void main(String[] args) {
            LOGGER.warn("warnings");
            LOGGER.info("warnings");
        }
    }
    
5.2 整合 Junit 单元测试框架
  1. 整合 JUnit4:首先引入 Spring 测试框架依赖,然后使用注解方式创建测试类

    
        org.springframework
        spring-test
        5.3.17
        test
    
    
        junit
        junit
        4.13.1
        test
    
    
    // 指定单元测试框架的版本
    @RunWith(SpringJUnit4ClassRunner.class)
    // 加载配置文件
    @ContextConfiguration("classpath:bean.xml")
    public class JUnitTest {
        @Autowired
        private UserServiceImpl userService;
    
        @Test
        public void test() {
            userService.transfer("spring", "bear", 1000);
        }
    }
    
  2. 整合 JUnit 5:引入相关依赖,类上使用新注解修饰

    
        org.springframework
        spring-test
        5.3.17
        test
    
    
        org.junit.jupiter
        junit-jupiter-api
        5.8.2
        test
    
    
    // 以下两个注解可用符合注解替代: @SpringJUnitConfig(locations = "classpath:bean.xml")
    @ExtendWith(SpringExtension.class)
    @ContextConfiguration("classpath:bean.xml")
    public class JUnit5Test {
        @Autowired
        private User user;
    
        @Test
        public void junit5Test() {
            System.out.println(user);
        }
    }
    
5.3 @Nullable 注解

Spring5 框架核心容器 IOC 支持 @Nullable 注解,该注解可以使用在方法上、属性上、参数上,作用是允许此注解修饰的内容为空

@Autowired
@Nullable
private JdbcTemplate jdbcTemplate;
5.4 函数式注册对象

Spring5 核心容器支持函数式风格 GenericApplicationContext 注册对象

@Test
public void genericApplicationContextTest() {
    // 函数式风格创建对象并交给 Spring 进行管理
    GenericApplicationContext genericApplicationContext = new GenericApplicationContext();
    genericApplicationContext.refresh();
    genericApplicationContext.registerBean("user", User.class, () -> new User());
    // 从 Spring 容器中获取对象
    Object user = genericApplicationContext.getBean("user");
    System.out.println(user);
}
5.5 Webflux(前置知识:SpringMVC、SpringBoot、Maven、Java8 新特性)
  1. 响应式编程(Java实现)

  2. 响应式编程(Reactor)

  3. 响应式编程(Reactor总结)

  4. 执行流程和核心 API

  5. 注解编程模型

  6. 函数式编程模型(Handler)

  7. 函数式编程模型(Router 和服务器)

  8. 函数式编程模型(WebClient)

  9. 课程总结

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/949386.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号