三、Spring的入门程序

第一个Spring程序

1. 创建新的空工程spring6

2. 设置JDK版本17，编译器版本17
   

3. 设置IDEA的Maven：关联自己的maven
   

4. 在空的工程spring6中创建第一个maven模块：spring6-001-first

5. 在pom.xml添加spring context依赖和junit依赖，

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
   
       <groupId>org.example</groupId>
       <artifactId>spring-001-first</artifactId>
       <version>1.0-SNAPSHOT</version>
       <!--打包方式jar-->
       <packaging>jar</packaging>
   
   
       <!--依赖-->
       <dependencies>
           <!--引入spring context依赖之后，表示将Spring的基础依赖引入了-->
           <!--想使用spring的jdbc，或者其他的tx，还需要再次添加依赖-->
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-context</artifactId>
               <version>6.0.2</version>
           </dependency>
   
           <!--junit依赖-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.13.2</version>
               <scope>test</scope>
           </dependency>
       </dependencies>
   
       <properties>
           <maven.compiler.source>17</maven.compiler.source>
           <maven.compiler.target>17</maven.compiler.target>
       </properties>
   
   </project>
   

   
   当加入spring context的依赖之后，会关联引入其他依赖：
   spring aop：面向切面编程
   spring beans：IoC核心
   spring core：spring的核心工具包
   spring jcl：spring的日志包
   spring expression：spring表达式

6. 定义bean：User

   package com.powernode.spring6.bean;
   
   /**
    * bean,封装用户信息
    */
   public class User {
   }
   

7. 使用IDEA工具自带的spring配置文件的模板创建：spring.xml。该文件放在类的根路径下
   名字可以任意
   

   <?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">
       <!--Spring配置文件-->
       <!--配置bean，spring才可以帮助我们管理这个对象-->
       <!--
           bean标签的两个重要属性
               id:这个bean的唯一标识，不能重复
               class:必须填写类的全限定类名（带包名）
       -->
       <bean id="userBean" class="com.powernode.spring6.bean.User"/>
   </beans>
   

8. 编写测试程序

   package com.powernode.spring6.test;
   
   import org.junit.Test;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;
   
   public class FirstSpringTest {
       @Test
       public void testFirstSpringCode(){
           // 第一步:获取Spring容器对象
           /*
           ApplicationContext : spring容器，是一个接口，接口下有很多实现类，有一个实现类ClassPathXmlApplicationContext
           ClassPathXmlApplicationContext 专门从类路径中加载spring配置文件的一个Spring上下文对象
           这行代码只要执行：就相当于启动了Spring容器，解析spring.xml文件，并且实例化所有的bean对象，放到spring容器当中。
            */
           ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
   
           // 第二步:根据bean的id从Spring容器中获取对象
           Object userBean = applicationContext.getBean("userBean");
           System.out.println(userBean);
   
       }
   }
   

详细剖析

1. bean标签的id属性不可以重复

2. 底层是通过反射机制调用无参数构造方法创建对象的

   // dom4j解析beans.xml文件，从中获取class的全限定类名
   // 通过反射机制调用无参数构造方法创建对象
   Class clazz = Class.forName("com.powernode.spring6.bean.User");
   Object obj = clazz.newInstance();
   

3. 创建好的对象是存储到一个Map集合当中
   

4. spring配置文件的名字可以是任意的

5. spring的配置文件可以有多个，在ClassPathXmlApplicationContext构造方法的参数上传递文件路径即可。
   通过源码可以看到:

   public ClassPathXmlApplicationContext(String... configLocations) throws BeansException {
        this(configLocations, true, (ApplicationContext)null);
   }
   

6. 在spring配置文件中配置的bean可以是任意类，只要这个类不是抽象的，并且提供了无参数构造方法。

7. getBean()方法调用时，如果bean的id不存在，不会返回null，而是出现异常

8. 使用getBean()方法的第二个参数来指定返回的bean的类型

   User userBean = applicationContext.getBean("userBean", User.class);
   

9. xml配置文件如果没有在类路径当中，使用FileSystemXmlApplicationContext类进行加载配置文件

   ApplicationContext applicationContext = new FileSystemXmlApplicationContext("d:/spring.xml");
   

   这种方式很少用。一般都是将配置文件放到类路径当中，这样可移植性更强。

10. ApplicationContext接口的超级父接口BeanFactory。

    BeanFactory（翻译为Bean工厂，就是能够生产Bean对象的一个工厂对象。）
    BeanFactory是IoC容器的顶级接口。
    Spring的IoC容器底层实际上使用了：工厂模式。
    Spring底层的IoC是通过 XML解析 + 工厂模式 + 反射机制 实现的

11. 不是在调用getBean()方法的时候创建对象，执行以下代码的时候，就会实例化对象。

     new ClassPathXmlApplicationContext("spring.xml");
    

Spring6启用Log4j2日志框架

从Spring5之后，Spring框架支持集成的日志框架是Log4j2

1. 引入Log4j2的依赖

   <!--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>
   

2. 在类的根路径下提供log4j2.xml配置文件（文件名固定为：log4j2.xml，文件必须放到类根路径下。）

   <?xml version="1.0" encoding="UTF-8"?>
   
   <configuration>
   
       <loggers>
           <!--
               level指定日志级别，从低到高的优先级：
                   ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF
           -->
           <root level="DEBUG">
               <appender-ref ref="spring6log"/>
           </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>
       </appenders>
   
   </configuration>
   

3. 配置好了就启用了Log4j2日志框架

4. 自己使用log4j2记录日志信息

   // 第一步：创建日志记录器对象
   // 获取FirstSpringTest类的日志记录器对象，也就是说只要是FirstSpringTest类中的代码执行记录日志的话，就输出相关的日志信息。
   Logger logger = LoggerFactory.getLogger(FirstSpringTest.class);
   
   // 第二步：记录日志，根据不同的级别来输出日志
   logger.info("一条消息");
   logger.debug("一条调试信息");
   logger.error("一条错误信息");