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

Spring

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

Spring

Spring xml配置


maven 基本jar包
        
            org.springframework
            spring-beans
            5.2.8.RELEASE
        
        
            org.springframework
            spring-context
            5.2.8.RELEASE
        
        
            org.springframework
            spring-core
            5.2.8.RELEASE
        
        
            org.springframework
            spring-expression
            5.2.8.RELEASE
        
        
            commons-logging
            commons-logging
            1.2
        
		
            org.springframework
            spring-aop
            5.2.8.RELEASE
        
        
        
            com.springsource.org.aspectj.weaver
            com.springsource.org.aspectj.weaver
            1.6.8.RELEASE
        
        
            com.springsource.net.sf.cglib
            com.springsource.net.sf.cglib
            2.2.0
        
        
            com.springsource.org.aopalliance
            com.springsource.org.aopalliance
            1.0.0
        
        
            mysql
            mysql-connector-java
            5.1.34
        
        
            com.alibaba
            druid
            1.1.10
        
        
            org.springframework
            spring-jdbc
            5.2.6.RELEASE
        
        
            org.springframework
            spring-tx
            5.2.6.RELEASE
        
        
            org.springframework
            spring-orm
            5.2.6.RELEASE
        
        
            org.apache.logging.log4j
            log4j-api
            2.11.2
        
        
            org.apache.logging.log4j
            log4j-core
            2.11.2
        
        
            org.apache.logging.log4j
            log4j-slf4j-impl
            2.11.2
        
        
            org.slf4j
            slf4j-api
            1.7.30
        
		
            org.springframework
            spring-test
            5.2.6.RELEASE
        
一. Spring框架概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PAgtMLgh-1655347222171)(C:UsersshangDesktopSpring_libSnipaste_2022-05-25_18-59-07.png)]

二. 核心:IOC容器

IOC: 控制反转

  • 把创建对象的过程交给 Spring 进行管理
  • 目的:降低耦合度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-87awk35b-1655347222172)(C:UsersshangDesktopSpring_libioc1.png)]


1. 底层原理
  1. xml解析,工厂模式,反射

    • //1. 加载 Spring 配置文件
              //ClassPathXmlApplicationContext : 类路径,src下
              ApplicationContext context = new  ClassPathXmlApplicationContext("demo01.xml");
      
              //2. 获取配置创建的对象
              User user = context.getBean("user", User.class);
      
  2. Spring两种方式实现 IOC 容器(两个接口)

    • BeanFactory:IOC 容器基本实现,是 Spring 内部使用的接口,加载配置文件时不会创建里面的对象,使用时才会创建对象
    • ApplicationContext:BeanFactory接口的子接口,提供更强大的功能,一般用这个,加载配置文件时把配置文件中的对象进行加载
    • ApplicationContext实现类:FileSystemXmlApplicationContext:配置文件系统路径,全路径, ClassPathXmlApplicationContext:src下路径,类路径

2. Bean管理
  1. 什么是 Bean 管理

    • Spring创建对象
    • Spring注入属性
  2. 基于 xml 方式

    • 基于 xml 创建对象

      • bean 标签加属性

        id:唯一标识

        class:类全路径

        name:和 id 作用一样,id中不能加特殊符号,name中可以加特殊符号

      • 创建对象时默认执行无参构造

    • 基于 xml 注入属性

      • DI:依赖注入

        1. set 方法注入

          
          
        2. 构造器注入

          
          
        3. p 标签注入

          p:bname="bname属性的值" 简化 id和value
          
      • 注入其他类型的值

        1. 字面量

          • null:

          • 包含特殊符号

            1. 把 <> 进行转义 <>

            2. 把带特殊符号内容写到 CDATA

              
              	>]]>
              
              
      • 注入属性

        1. 外部 bean

          
          
          
          
        2. 内部 bean和级联赋值

          //内部bean
          
          	
              //内部 bean
          	
              	
                  	        
                  
              
              
              //级联赋值1
              
          
              //级联赋值2,需要 dept 有 getDname()方法
              //向dept对象内属性设置值,需要先得到 dept对象
              
          
          
          
                      
          
          
      • 注入集合属性

        1. 数组:

          
          	
              	值1
                  值2
              
          
          
        2. list

          
          	
              	值1
                  值2
              
          
          
        3. map

          
          	
              	
                  
              
          
          
        4. list集合值是对象

          
              
                  
                      
                      
                  
              
          
          
          
          	
          
          
          	
          
          
          //提取 list集合类型属性注入
          
          	1
          	2
          
          
          
          	
          
          
  3. FactoryBean

    • Spring两种 bean,普通bean:返回class类型;工厂bean:返回不是class类型
    • 创建类实现 FactoryBean,并实现接口中的方法,在实现的方法中定义返回的 bean 类型,可以使用泛型控制bean类型
  4. bean的作用域

    • Spring默认情况下创建的 bean 是单实例对象(getBean() 返回同一个对象)

    • 在 bean 标签中设置单实例或多实例

      scope 属性值:
      1. 默认值单实例	singleton
      2. 多实例		  prototype	:不是在加载 Spring 配置文件时创建对象,在调用getBean()方法时创建多实例的对象
      3. 每次创建对象会放到request域中				request
      4. 每次创建对象会放到session域中				session
      
  5. bean 生命周期

    • 从对象创建到对象销毁的过程

      1. 通过构造器创建 bean 实例(无参构造器)

      2. 为 bean 中的属性设置值和对其他 bean 的引用(调用 set 方法)

      3. 调用 bean 的初始化的方法 (需要配置)

        • //bean 的类中自定义一个初始化方法
          public void initMethod(){
              System.out.println("第三步,执行初始化方法");
          }
          
        • //bean 增加标签
          
          
      4. bean 可以使用 (对象获取到了)

      5. 容器关闭时,调用 bean 销毁的方法 (需要配置销毁方法)

        • //bean 的类中自定义一个销毁的方法
          public void destroyMethod(){
              System.out.println("第五步,执行销毁的方法");
          }
          
        • //bean 增加标签
          
          
        • 手动调用:context.close() //可能需要强转

    • bean 的后置处理器

      1. 通过构造器创建 bean 实例(无参构造器)

      2. 为 bean 中的属性设置值和对其他 bean 的引用(调用 set 方法)

      3. 把 bean 的实例传给 bean 的后置处理器的方法

      4. 调用 bean 的初始化的方法 (需要配置)

      5. 把 bean 的实例传给 bean 的后置处理器的方法

      6. bean 可以使用 (对象获取到了)

      7. 容器关闭时,调用 bean 销毁的方法 (需要配置销毁方法)

        其中3, 5 需要创建的bean的后置处理器类实现 BeanPostProcessor接口,并重写其中两个方法

        同时配置bean的后置处理器

        
        //这样会给当前xml文件中所有bean添加后置处理器
        
  6. xml 自动装配

    • 自动装配:根据指定装配规则(属性名称或属性类型),Spring 自动将匹配的属性值进行注入

    • bean 标签属性 autowire,配置自动装配

      autowire属性常用的两个值

      ​ byName 根据属性名称注入,注意注入值 bean 的 id 值和类属性名称一样

      //emp 类中 dept属性
      
      
      

      ​ byType 根据属性类型注入,不能定义多个相同类型的 bean

      //emp 类中 dept属性
      
      
      
  7. 外部属性文件

    • 创建外部属性文件,properties 格式文件

      prop.driver=value1
      
    • 把外部 properties 属性文件引入到 Spring 配置文件中

      1. 引入 context 名称空间

      2. 在 Spring 配置文件使用标签引入外部属性

        //引入外部属性文件
        
        
        
        	
        
        
  8. 基于注解方式

    • Spring 针对 Bean 管理中创建对象提供注解(类,方法,属性)

      1. @Component 普通注解
      2. @Service Sevrvice(业务逻辑)层
      3. @Controller Web层
      4. @Repository Dao(持久)层
    • 注解创建对象

      1. 引入依赖

      2. 开启组件扫描(指定扫描位置,如果有注解就创建对象)

        //开启组件扫描
        //	1. 如果扫描多个包,多个包使用 , 隔开
        //	2. 扫描包上层目录
        
        //1. 全扫描
        
        
        //2. 指定扫描什么
        
        	 //在包中表示只扫描带 Controller的注解
        
        
        //3. 扫描且指定不扫描什么
        
             //在包中表示不扫描带 Controller的注解
        
        
      3. 创建类,在类上面添加创建对象注解

        @Component(value = "userService") // 	id 和 value 等价	注解里 value 属性值可以不写,默认类名称首字母小写
        public class UserService{
            
        }
        
    • 基于注解进行属性注入

      1. @Autowired 根据属性类型进行自动注入

        1. 创建 service和 dao 对象,在 service 和 dao 类创建对象注解

        2. 在 service 注入 dao 对象,在 service 类添加

        3. dao 类型属性,在属性上面使用注解

        @Service
        public class UserService(){
            
            //定义 dao 属性
            //不需要添加 set 方法
            @Autowired
            private UserDao userDao;
        }
        
      2. @Qualifier 根据属性的名称进行注入

        • 和 @Autowired 一起使用

          @Service
          public class UserService(){
              
              //定义 dao 属性
              //不需要添加 set 方法
              @Autowired
              @Qualifier(value="userDaoImpl")
              private UserDao userDao;
          }
          
      3. @Resource 可以根据属性类型注入,可以根据属性名称注入,javax扩展包中的注解,上面两个都是 Spring 提供的

        @Service
        public class UserService(){
            
            //定义 dao 属性
            //不需要添加 set 方法
            @Resource //根据类型进行注入
            @Resource(name="userDaoImpl") //根据名称进行注入
            private UserDao userDao;
        }
        
      4. @Value 注入普通类型属性

        @Service
        public class UserService(){
            
            @Value(value = "abc")
            private String name;
        }
        
      5. 完全注解开发

        1. 创建配置类,替代 xml 配置文件

          @Configuration	//作为配置类,替代 xml 配置文件
          @ComponentScan(basePackages="包路径")	//组件扫描
          public class SpringConfig{
              
          }
          
        2. 编写测试类

          public void test01(){
              //1. 加载配置类
              ApplicationContext context
                  = new AnnotationconfigApplicationContext(SpringConfig.class);
              //得到对象
              UserService userService = context.getBean("userService", UserService.class);
          }
          
三. 核心:Aop

AOP: 面向切面

  • 不修改源代码进行功能增强

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FWVAC8tk-1655347222173)(C:UsersshangAppDataRoamingTyporatypora-user-imagesimage-20220527160453959.png)]

1. 底层原理
  1. AOP底层使用动态代理(两种情况)

    1. 有接口

      • 使用 JDK 动态代理,创建 UserDao 接口实现类代理对象,增强类的方法

        1. 使用 Proxy 类里面的方法( **static Object newProxyInstance(ClassLoader loader, 类 interfaces, InvocationHandler h) **返回指定接口的代理类实例,该接口将方法调用分配给指定的调用处理程序)创建代理对象
        2. 方法中三个参数
          1. 类加载器
          2. 增强方法所在类,这个类实现的接口,支持多个接口
          3. 实现这个接口 InvocationHandler ,创建代理对象,写增强方法
        //1. 创建接口,定义方法
        public interface UserDao(){
            
            public int add(int a, int b);
        }
        //2. 创建接口实现类,实现方法
        public class UserDaoImpl implements UserDao{
            
            @Override
            public int add(int a, int b){
                return a + b;
            }
        }
        //3. 使用 Proxy 类创建接口代理对象
        public class JDKProxy {
        
            public static void main(String[] args) {
        
                //创建接口实现类代理对象
                Class[] interfaces = {UserDao.class};
        //        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
        //            @Override
        //            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //                return null;
        //            }
        //        });
                UserDaoImpl userDao = new UserDaoImpl();
                //返回动态代理对象
                UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
                int result = dao.add(1, 2);
                System.out.println(result);
            }
        }
        //创建代理对象代码
        class UserDaoProxy implements InvocationHandler{
        
            //1. 把创建的是谁的代理对象,把谁传过来
            //有参数构造传递
            private Object obj;
            public UserDaoProxy(Object obj){
                this.obj = obj;
            }
        
            //增强的逻辑
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                //方法之前
                System.out.println("add方法之前执行");
                //被增强方法执行
                Object res = method.invoke(obj, args);
                //方法之后
                System.out.println("add方法之后执行");
        
                return res;
            }
        }
        
    2. 没有接口

      • 使用 CGLIB 动态代理,创建 User 类子类的代理对象,增强类的方法

2. AOP 术语
  1. 连接点 类里面的哪些方法可以被增强,这些方法就叫连接点
  2. 切入点 实际被真正增强的方法称为切入点
  3. 通知(增强) 实际增强的逻辑部分称为通知,例 : add()方法之后又干了别的事,别的事就是通知
    • 通知有多种类型
      1. 前置通知 add()之前
      2. 后置通知 add()之后
      3. 环绕通知 add()前后都执行
      4. 异常通知 add()出现异常执行
      5. 最终通知 finally执行
  4. 切面 把通知应用到切入点的过程,(把全限判断加入到登录方法中的过程),是动作

3. AOP 操作
  1. 准备

    • Spring框架一般都是基于 AspectJ 实现 AOP 操作

      • AspectJ:不是 Spring 组成部分,独立 AOP 框架,一般把 AspectJ 和 Spring 框架一起使用进行 AOP操作
    • 基于 AspectJ 实现 AOP 操作

      1. 基于 xml 配置文件实现
      2. 基于注解方式实现
    • 切入点表达式

      1. 作用:知道对哪个类的哪个方法进行增强

      2. 语法结构:

        execution([权限修饰符][返回类型][类全路径][方法名称](参数列表))

        权限修饰符可以不写,返回类型必须写,可以是 * 代表任意的,方法名称可以为 * ,表示增强所有方法,参数列表 … 时表示方法任意参数,同名方法都会被增强

  2. AspectJ注解

    1. 创建类,在类中定义方法

      public class User{
          public void add(){
              
          }
      }
      
    2. 创建增强类(编写增强逻辑)

      public class UserProxy{
          
          //让此方法作为 User.add()的前置方法
          public void before(){
              
          }
      }
      
    3. 进行通知的配置

      • 在 Spring 配置文件中开启注解的扫描

        
        
      • 使用注解创建 User 和 UserProxy 对象

        @Component //创建对象
        public class User{
            public void add(){
            }
        }
        @Component  //创建对象
        @Aspect	//生成代理对象
        public class UserProxy{
            
            //让此方法作为 User.add()的前置方法
            //Before注解表示作为一个前置通知,注解为 aspectj下的注解
            @Before(value = "execution(* com.spring.User.add(..))")
            public void before(){
                
            }
            
            //返回值之后执行,后置通知(返回通知)有异常不执行,After之后
            @AfterReturning(value = "execution(* com.spring.User.add(..))")
            public void afterReturning(){
                
            }
            
            //add()方法返回之后执行,最终通知,不管有没有异常都执行
            @After(value = "execution(* com.spring.User.add(..))")
            public void after(){
                
            }
            
            //异常通知,add()出现异常时执行
            @AfterThrowing(value = "execution(* com.spring.User.add(..))")
            public void afterThrowing(){
                
            }
            
            //环绕通知,add()之前和之后都执行
            @Around(value = "execution(* com.spring.User.add(..))")
            public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
                //add()方法之前,且在 before之前
                System.out.println("之前");
                
                //被增强的方法执行
                proceedingJoinPoint.proceed();
                    
                //add()方法之后,且在 after之后
                System.out.println("之后");
            }
        }
        
      • 在增强的类上面添加注解 @Aspect

      • 在 Spring 配置文件中开启生成代理对象

        //开启 Aspect 生成代理对象
        
        
      • 配置不同类型的通知

        1. 在增强类里面,在作为通知的方法上添加通知类型的注解,使用切入点表达式配置
    4. 相同切入点抽取

      @Pointcut(value = "execution(* com.spring.User.add(..))")	//切入点注解
      public void pointDemo(){
          
      }
      //此时其他方法使用此切入点
      @Before(value = "pointDemo()")
      public void before(){
          
      }
      
    5. 多个增强类对同一个方法进行增强,可以设置增强类优先级

      1. 增强类上添加注解 @Order(数字类型值),数字类型值越小,优先级越高
  3. AspectJ配置文件

  4. 完全使用注解开发

    • 创建配置类,不需要创建xml文件
    //配置类
    @Configuration
    @ComponentScan(basePackages = "")   //开启注解扫描
    @EnableAspectJAutoProxy(proxyTargetClass = true默认false)		//开启Aspect生成代理对象
    public class ConfigAop{
        
    }
    
四. JdbcTemplate

Spring 框架对 JDBC 进行封装,使用 JdbcTemplate 方便实现对数据库操作

  1. 配置数据库连接池

    
    	
        
        
        
    
    
  2. 配置 JdbcTemplate 对象,注入 DataSource

    
    	//注入 dataSource
        
    
    
  3. 创建 service类和 dao类,在 dao 注入 jdbcTemplate

    1. 开启组件扫描

      
      
    2. Service

      @Service
      public class BookService{
          
          //注入 dao
          @Autowired
          private BookDao bookDao;
      }
      
    3. Dao

      @Repository
      public class BookDaoImpl implements BookDao{
          
          //注入 JdbcTemplate
          @Autowired
          private JdbcTemplate jdbcTemplate;
          
          //添加
          //update(Stirng sql, Object... args)
          public void add(Book book){
              //1. 创建 sql
              String sql = "insert into t_book values(?, ?, ?)";
              //2. 调用方法实现
              int update = jdbcTemplate.update(sql, book.getId(), book.getUsername(), book.getStatus());
          }
          
          //修改
          public void add(Book book){
              String sql = "update t_book set username=? where user_id=?";
              int update = jdbcTemplate.update(sql, book.getUsername(), book.getId());
          }
          
          //删除
          public void delete(String id){
              String sql = "delete from t_book where user_id=?";
              int update = jdbcTemplate.update(sql, id);
          }
          
          //查询返回某个值,例:查有多少条记录,返回某个值
          public int selectCount(){
              String sql = "select count(*) from t_book";
              //queryForObject(String sql, Class requiredType返回类型的class)
              Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
          	
              return count;
          }
          
          //查询返回对象,例:查询一本图书的详细信息
          public Book findBookInfo(String id){
              String sql = "select * from t_book where user_id=?";
              //queryForObject(String sql, RowMapper rowMapper, Object... args)
      		//RowMapper 是接口,返回不同类型数据,使用这个接口里面实现类完成数据封装
              Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper(Book.class), id);
              return book;
          }
          
          //查询返回集合, 例:查询列表,分页
      	public List findAllBook(){
              String sql = "select * from t_book";
              //query(String sql, RowMapper rowMapper, Object... args);
              List bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Book.class));
              return bookList;
          }
          
          //批量添加
      	//batchUpdate(String sql, List batchArgs);
          //List集合,表示添加的多条记录数据
          public void batchAddBook(List batchArgs){
              String sql = "insert into t_book values(?)";
              //底层:遍历 List,对每个 Object[]执行sql
              int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
          }
          
          //批量修改
      	//batchUpdate(String sql, List batchArgs);
          //List集合,表示修改的多条记录数据
          public void batchAddBook(List batchArgs){
              String sql = "update t_book set username=? where user_id=?";
              //底层:遍历 List,对每个 Object[]执行sql
              int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
          }
          
          //批量删除
      	//batchUpdate(String sql, List batchArgs);
          //List集合,表示删除的多条记录数据
          public void batchAddBook(List batchArgs){
              String sql = "delete from t_book where user_id=?";
              //底层:遍历 List,对每个 Object[]执行sql
              int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
          }
      }
      
五. 事务管理

事务四个特性(ACID)

  1. 原子性:不可分割,要么都成功,要么都失败
  2. 一致性:操作前和操作后总量不变
  3. 隔离性:多个事务操作时不会产生影响
  4. 持久性:提交之后表中数据真正发生变化
1. Spring事务管理
  1. 事务添加到 JavaEE 三层结构里面 Service 层

  2. 在 Spring 进行事务管理操作

    两种方式

    1. 编程式(不方便):写代码,开启事务,try…catch…手动回滚事务

    2. 声明式(一般使用)(底层 AOP)

      • 基于注解

        1. 在 Spring 配置文件事务管理器

          //创建事务管理器
          
          	//注入数据源
               
          
          
        2. 在 Spring 配置文件开启事务注解

          
          
        3. 在 Service 类上(或 Service 类方法上添加事务注解)@Transactional

          @Transactional中的属性

          • propagation:事务传播行为

            多事务方法之间直接进行调用,这个过程事务是如何管理的

            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n0QJohnn-1655347222173)(C:UsersshangDesktopSpring_lib事务1)]

            事务方法:对数据库表数据进行变化的操作

          • isolation:事务隔离级别

            多事务操作之间不会产生影响

            有三个读的问题

            1. 脏读:一个未提交的事务读取到了另一个未提交事务的数据
            2. 不可重复读:一个未提交的事务读取到了另一个提交事务的数据
            3. 幻读:一个未提交的事务读到了另一个提交事务添加的数据

            设置事务隔离级别

            [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4V870dK1-1655347222174)(C:UsersshangDesktopSpring_lib事务2)]

            mysql默认可重复读

          • timeout:超时时间

            事务在一定时间内提交,超过时间不提交会进行回滚,默认 -1(不超时),以秒为单位

          • readOnly:是否只读

            默认 false,表示可以查询和增删改,设置为 true后只能查询

          • rollbackFor:回滚

            设置出现哪些异常进行事务回滚

          • noRollbackFor:不回滚

            设置出现哪些异常不进行事务回滚

      • 基于 xml

    3. 完全注解开发

      1. 创建

        @Configuration	//配置类
        @ComponentScan(basePackages = "")	//开启组件扫描
        @EnableTransactionManagement	//开启事务
        public class TxConfig{
            
            //创建数据库连接池
            @Bean
            public DruidDataSource getDruidDataSource(){
                DruidDataSource dataSource = new DruidDataSource();
                dataSource.setDriverClassName("");
                dataSource.setUrl("");
                dataSource.setUsername("");
                dataSource.setPassword("");
                return dataSource;
            }
            
            //创建 JdbcTemplate对象
            @Bean
            public JdbcTemplate getJdbcTemplateJ(DataSource dataSource){
                JdbcTemplate jdbcTemplate = new JdbcTemplate();
                
                //注入 dataSource
                jdbcTemplate.setDataSource(dataSource);
                return jdbcTemplate;
            }
            
            //创建事务管理器
            @Bean
            public DataSourceTransactionManager  getDataSourceTransactionManager(DataSource dataSource){
                DataSourceTransactionManager transcationManager = new DataSourceTransactionManager();
                transactionManager.setDataSource(dataSource);
                return transactionManager;
            }
        }
        
  3. Spring事务管理 API

    • 提供一个接口,代表事务管理器,这个接口针对不同框架提供不同实现类
    • 接口:PlatformTransactionManager
    • 针对 JdbcTemplate 实现类:DataSourceTransaactionManager
六. Spring5 新特性
  1. 整个 Spring5 框架的代码基于 Java 8 ,运行时兼容 JDK9,许多不建议的类和方法被删除

  2. Spring5 框架自带了通用的日志封装

    • 已经移除了 Log4jConfigListener,官方建议 Log4j2

    • Spring5整合 Log4j2

      1. 创建 log4j2.xml

        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        //手动在控制台输出日志
        public class UserLog{
            
            public static final Logger log = loggerFactory.getLogger(UserLog.class);
            public static void main(String[] args){
                log.info("h");
                log.warn("");
            }
        }
        
  3. 核心容器支持 @Nullable 注解

    • 可以使用在方法,属性,参数,表示方法,属性,参数返回值可以为空
  4. 支持 Lambda表达式

    //1. 创建 GenericApplicationContext对象
    GenericApplicationContext context = new GenericApplicationContextJ();
    //2. 调用 context 的方法对象注册
    context.refresh();
    context.registerBean(User.class, ()-> new User());
    //3. 获取在 Spring 注册的对象
    context.getBean("User类的路径");
    
  5. Spring5 支持整合 JUnit5

    1. 整合 JUnit4

      @RunWith(SpringJUnit4ClassRunner.class)		//指定单元测试框架
      @ContextConfiguration("classpath:bean1.xml")	//加载配置文件
      public class JTest{
          
          @Autowired
          private UserService userService; //已经注入了 
          
          @Test
          public void test1(){
              userService.select();
          }
      }
      
    2. 整合 JUnit5

      //方法1
      @ExtendWith(SpringExtension.class)
      @ContextConfiguration("classpath:bean1.xml")	//加载配置文件
      public class JTest{
          
          @Autowired
          private UserService userService; //已经注入了 
          
          @Test
          public void test1(){
              userService.select();
          }
      }
      
      //方法2
      @SpringJUnitConfig(locations = "classpath:bean.xml")
      public class JTest{
          
          @Autowired
          private UserService userService; //已经注入了 
          
          @Test
          public void test1(){
              userService.select();
          }
      }
      
  6. SpringWebFlux

    1. 介绍
    2. 响应式编程
    3. WebFlux执行流程和核心 API
    4. SpringWebFlux(基于注解编程模型)
  ```java
  @RunWith(SpringJUnit4ClassRunner.class)		//指定单元测试框架
  @ContextConfiguration("classpath:bean1.xml")	//加载配置文件
  public class JTest{
      
      @Autowired
      private UserService userService; //已经注入了 
      
      @Test
      public void test1(){
          userService.select();
      }
  }
  ```
  1. 整合 JUnit5

    //方法1
    @ExtendWith(SpringExtension.class)
    @ContextConfiguration("classpath:bean1.xml")	//加载配置文件
    public class JTest{
        
        @Autowired
        private UserService userService; //已经注入了 
        
        @Test
        public void test1(){
            userService.select();
        }
    }
    
    //方法2
    @SpringJUnitConfig(locations = "classpath:bean.xml")
    public class JTest{
        
        @Autowired
        private UserService userService; //已经注入了 
        
        @Test
        public void test1(){
            userService.select();
        }
    }
    
  2. SpringWebFlux

    1. 介绍
    2. 响应式编程
    3. WebFlux执行流程和核心 API
    4. SpringWebFlux(基于注解编程模型)
    5. SpringWebFlux(基于函数编程模型)
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/979124.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

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

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