java学习笔记 -Spring6

Spring6要求JDK版本为17及以上

添加Spring依赖

1
2
3
4
5
6
<!--spring6-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.2</version>
</dependency>

Log4j2

依赖

1
2
3
4
5
6
7
8
9
10
11
<!--log4j2的依赖-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.19.0</version>
</dependency>
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j2-impl</artifactId>
    <version>2.19.0</version>
</dependency>

配置文件

  • 在类的根路径下提供log4j2.xml配置文件（文件名固定为：log4j2.xml，文件必须放到类根路径下。）
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
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <loggers>
        <!--
            level指定日志级别，从低到高的优先级：
                TRACE < DEBUG < INFO < WARN < ERROR < FATAL
                trace：追踪，是最低的日志级别，相当于追踪程序的执行
                debug：调试，一般在开发中，都将其设置为最低的日志级别
                info：信息，输出重要的信息，使用较多
                warn：警告，输出警告的信息
                error：错误，输出错误信息
                fatal：严重错误
        -->
        <root level="DEBUG">
            <appender-ref ref="spring6log"/>
            <appender-ref ref="RollingFile"/>
            <appender-ref ref="log"/>
        </root>
    </loggers>

    <appenders>
        <!--输出日志信息到控制台-->
        <console name="spring6log" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss SSS} [%t] %-3level %logger{1024} - %msg%n"/>
        </console>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，适合临时测试用-->
        <File name="log" fileName="d:/spring6_log/test.log" append="false">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %class{36} %L %M - %msg%xEx%n"/>
        </File>

        <!-- 这个会打印出所有的信息，
            每次大小超过size，
            则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，
            作为存档-->
        <RollingFile name="RollingFile" fileName="d:/spring6_log/app.log"
                     filePattern="log/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
            <PatternLayout pattern="%d{yyyy-MM-dd 'at' HH:mm:ss z} %-5level %class{36} %L %M - %msg%xEx%n"/>
            <SizeBasedTriggeringPolicy size="50MB"/>
            <!-- DefaultRolloverStrategy属性如不设置，
            则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>
    </appenders>
</configuration>

使用

1
2
3
4
5
6
7
8
9
10
11
@Test
    public void testUserObject(){
        //1、加载配置文件，创建对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //2、获取创建对象
        User user = (User) context.getBean("user");
        //3、调用测试方法
       user.add();
       //4、手动写日志
        logger.info("#### 执行调用成功... ####");
    }

IOC容器

  • IoC 是 Inversion of Control 的简写
  • IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别

控制反转（IoC）

  • 为了降低程序耦合度，提高程序扩展力

依赖注入

  • DI（Dependency Injection）：依赖注入，依赖注入实现了控制反转的思想
  • 指Spring创建对象的过程中，将对象依赖属性通过配置进行注入

ApplicationContext的主要实现类

类型名 简介
ClassPathXmlApplicationContext 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象
FileSystemXmlApplicationContext 通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象
ConfigurableApplicationContext ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。
WebApplicationContext 专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。

基于XML管理Bean

  1. 创建类
1
2
3
4
5
6
package com.zhibi.spring6;
public class User {
    public void hello(){
        System.out.println("....hello");
    }
}
  1. 配置xml文件
1
2
3
4
5
6
7
<?xml version="1.0" encoding="UTF-8"?>
<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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.zhibi.spring6.bean.User"></bean>
</beans>
  1. 测试类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class TestUser {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //1. 根据bean id获取
        User user = (User)context.getBean("user");
        System.out.println("1. 根据bean id获取" + user);

        //2. 根据类型获取bean
        User user1 = context.getBean(User.class);
        System.out.println("2. 根据类型获取bean" +user1);

        //3. 根据id和类型
        User user2 = context.getBean("user", User.class);
        System.out.println("3. 根据id和类型" + user2);
    }
}

依赖注入setter注入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!--set方法注入-->
    <bean id="book" class="com.zhibi.spring6.di.Book">
        <!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 -->
        <!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关） -->
        <!-- value属性：指定属性值 -->
        <property name="bname" value="再学一万年"></property>
        <property name="author" value="执笔"></property>
        <!-- <property name="other">-->
        <!--<null></null>-->
        <!-- </property> 设置other为null-->
        <!-- <property name="other" value="&lt;&gt;"></property>-->
        <property name="other">
            <value><![CDATA[a < b]]></value>
        </property>
    </bean>

依赖注入构造器注入

1
2
3
4
5
6
<!--构造器注入-->
    <bean id="book-con" class="com.zhibi.spring6.di.Book">
        <!-- index属性：指定参数所在位置的索引（从0开始） name属性：指定参数名-->
        <constructor-arg name="bname" value="再来亿遍"></constructor-arg>
        <constructor-arg index="1" value="执笔"></constructor-arg>
    </bean>

特殊值处理

字面量赋值

int a = 10;

声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字

而如果a是带引号的：’a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。

1
2
<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="name" value="张三"/>
null值
1
2
3
<property name="name">
    <null />
</property>

注意：

1
<property name="name" value="null"></property>

以上写法，为name所赋的值是字符串null

xml实体
1
2
3
<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替 -->
<property name="expression" value="a &lt; b"/>
CDATA节
1
2
3
4
5
6
7
<property name="expression">
    <!-- 解决方案二：使用CDATA节 -->
    <!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->
    <!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->
    <!-- 所以CDATA节中写什么符号都随意 -->
    <value><![CDATA[a < b]]></value>
</property>

为对象类型属性赋值