关于java:动力节点杜聚宾老师Spring6学习笔记3Spring的入门程序

官网地址：[https://spring.io/]

官网地址（中文）：http://spring.p2hp.com/

关上 Spring 官网后，能够看到 Spring Framework，以及通过 Spring Framework 衍生的其它框架，把 Spring Framework，下载下来。

docs：spring 框架的 API 帮忙文档

libs：spring 框架的 jar 文件（ 用 spring 框架就是用这些 jar 包 ）

schema：spring 框架的 XML 配置文件相干的束缚文件

3.2 Spring 的 jar 文件

关上 libs 目录，会看到很多 jar 包：

spring-core-5.3.9.jar：字节码（这个是撑持程序运行的 jar 包）
spring-core-5.3.9-javadoc.jar：代码中的正文
spring-core-5.3.9-sources.jar：源码

咱们来看一下 spring 框架都有哪些 jar 包：

留神：
如果你只是想用 Spring 的 IoC 性能，仅须要引入：spring-context 即可。将这个 jar 包增加到 classpath 当中。
如果采纳 maven 只须要引入 context 的依赖即可。

<!--Spring6 的正式版公布之前，这个仓库地址是须要的 -->
<repositories>
  <repository>
    <id>repository.spring.milestone</id>
    <name>Spring Milestone Repository</name>
    <url>https://repo.spring.io/milestone</url>
  </repository>
</repositories>

<dependencies>
  <!--spring context 依赖：应用的是 6.0.0-M2 里程碑版 -->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.0.0-M2</version>
  </dependency>
</dependencies>

3.3 第一个 Spring 程序

后期筹备：

• 关上 IDEA 创立 Empty Project：spring6

• 设置 JDK 版本 17，编译器版本 17

• 设置 IDEA 的 Maven：关联本人的 maven

• 在空的工程 spring6 中创立第一个模块：spring6-001-first

第一步：增加 spring context 的依赖，pom.xml 配置如下

<?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>com.powernode</groupId>
    <artifactId>spring6-001-first</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

    <dependencies>
        <!--spring context 依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0-M2</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

</project>

留神：打包形式 jar。
当退出 spring context 的依赖之后，会关联引入其余依赖：
spring aop：面向切面编程
spring beans：IoC 外围
spring core：spring 的外围工具包
spring jcl：spring 的日志包
spring expression：spring 表达式

第二步：增加 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>com.powernode</groupId>
    <artifactId>spring6-001-first</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <repositories>
        <repository>
            <id>repository.spring.milestone</id>
            <name>Spring Milestone Repository</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

    <dependencies>
        <!--spring context 依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.0-M2</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>

第三步：定义 bean：User

package com.powernode.spring6.bean;

/**
 * bean，封装用户信息。* @author 能源节点
 * @version 1.0
 * @since 1.0
 */
public class User {
}

第四步：编写 spring 的配置文件：beans.xml。该文件放在类的根门路下。

上图是应用 IDEA 工具自带的 spring 配置文件的模板进行创立。
配置文件中进行 bean 的配置。

<?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="userBean" class="com.powernode.spring6.bean.User"/>
</beans>

bean 的 id 和 class 属性：

• id 属性：代表对象的惟一标识。能够看做一个人的身份证号。
• class 属性：用来指定要创立的 java 对象的类名，这个类名必须是全限定类名（带包名）。

第五步：编写测试程序

package com.powernode.spring6.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Spring6Test {

    @Test
    public void testFirst(){
        // 初始化 Spring 容器上下文（解析 beans.xml 文件，创立所有的 bean 对象）ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        // 依据 id 获取 bean 对象
        Object userBean = applicationContext.getBean("userBean");
        System.out.println(userBean);
    }
}

第七步：运行测试程序

3.4 第一个 Spring 程序具体分析

<bean id="userBean" class="com.powernode.spring6.bean.User"/>

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Object userBean = applicationContext.getBean("userBean");

1. bean 标签的 id 属性能够反复吗？

   package com.powernode.spring6.bean;

   /**

   • @author 能源节点
   • @version 1.0
   • @className Vip
   • @since 1.0
     **/

   public class Vip {
   }

<?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="userBean" class="com.powernode.spring6.bean.User"/>
    <bean id="userBean" class="com.powernode.spring6.bean.Vip"/>
</beans>

运行测试程序：

通过测试得出：在 spring 的配置文件中 id 是不能重名。

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

   package com.powernode.spring6.bean;

   /**

   • bean，封装用户信息。
   • @author 能源节点
   • @version 1.0
   • @since 1.0
     */

   public class User {

    public User() {System.out.println("User 的无参数构造方法执行");
    }

   }

在 User 类中增加无参数构造方法，如上。
运行测试程序：

通过测试得悉：创建对象时的确调用了无参数构造方法。
如果提供一个有参数构造方法，不提供无参数构造方法会怎么呢？

package com.powernode.spring6.bean;

/**
 * bean，封装用户信息。* @author 能源节点
 * @version 1.0
 * @since 1.0
 */
public class User {/*public User() {System.out.println("User 的无参数构造方法执行");
    }*/

    public User(String name){System.out.println("User 的有参数构造方法执行");
    }
}

运行测试程序：

通过测试得悉：spring 是通过调用类的无参数构造方法来创建对象的，所以要想让 spring 给你创建对象，必须保障无参数构造方法是存在的。
Spring 是如何创建对象的呢？原理是什么？

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

3. 把创立好的对象存储到一个什么样的数据结构当中了呢？

4. spring 配置文件的名字必须叫做 beans.xml 吗？

   ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“beans.xml”);

通过以上的 java 代码能够看出，这个 spring 配置文件名字是咱们负责提供的，显然 spring 配置文件的名字是随便的。

5. 像这样的 beans.xml 文件能够有多个吗？

再创立一个 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">
    <bean id="vipBean" class="com.powernode.spring6.bean.Vip"/>
</beans>

package com.powernode.spring6.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Spring6Test {

    @Test
    public void testFirst(){
        // 初始化 Spring 容器上下文（解析 beans.xml 文件，创立所有的 bean 对象）ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml","spring.xml");

        // 依据 id 获取 bean 对象
        Object userBean = applicationContext.getBean("userBean");
        Object vipBean = applicationContext.getBean("vipBean");

        System.out.println(userBean);
        System.out.println(vipBean);
    }
}

运行测试程序：

通过测试得悉，spring 的配置文件能够有多个，在 ClassPathXmlApplicationContext 构造方法的参数上传递文件门路即可。这是为什么呢？通过源码能够看到：

6. 在配置文件中配置的类必须是自定义的吗，能够应用 JDK 中的类吗，例如：java.util.Date？

   <?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="userBean" class="com.powernode.spring6.bean.User"/>
    <!--<bean id="userBean" class="com.powernode.spring6.bean.Vip"/>-->
   
    <bean id="dateBean" class="java.util.Date"/>

   </beans>

   package com.powernode.spring6.test;

   import org.junit.Test;
   import org.springframework.context.ApplicationContext;
   import org.springframework.context.support.ClassPathXmlApplicationContext;

   public class Spring6Test {

    @Test
    public void testFirst(){
        // 初始化 Spring 容器上下文（解析 beans.xml 文件，创立所有的 bean 对象）ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml","spring.xml");
   
        // 依据 id 获取 bean 对象
        Object userBean = applicationContext.getBean("userBean");
        Object vipBean = applicationContext.getBean("vipBean");
        Object dateBean = applicationContext.getBean("dateBean");
   
        System.out.println(userBean);
        System.out.println(vipBean);
        System.out.println(dateBean);
    }

   }

运行测试程序：

通过测试得悉，在 spring 配置文件中配置的 bean 能够任意类，只有这个类不是形象的，并且提供了无参数构造方法。

7. getBean() 办法调用时，如果指定的 id 不存在会怎么？

运行测试程序：

通过测试得悉，当 id 不存在的时候，会出现异常。

8. getBean() 办法返回的类型是 Object，如果拜访子类的特有属性和办法时，还须要向下转型，有其它方法能够解决这个问题吗？

   User user = applicationContext.getBean(“userBean”, User.class);

9. ClassPathXmlApplicationContext 是从类门路中加载配置文件，如果没有在类门路当中，又应该如何加载配置文件呢？

<?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="vipBean2" class="com.powernode.spring6.bean.Vip"/>
</beans>

ApplicationContext applicationContext2 = new FileSystemXmlApplicationContext("d:/spring6.xml");
Vip vip = applicationContext2.getBean("vipBean2", Vip.class);
System.out.println(vip);

没有在类门路中的话，须要应用 FileSystemXmlApplicationContext 类进行加载配置文件。
这种形式较少用。个别都是将配置文件放到类门路当中，这样可移植性更强。

10. ApplicationContext 的超级父接口 BeanFactory。

    BeanFactory beanFactory = new ClassPathXmlApplicationContext(“spring.xml”);
    Object vipBean = beanFactory.getBean(“vipBean”);
    System.out.println(vipBean);

BeanFactory 是 Spring 容器的超级接口。ApplicationContext 是 BeanFactory 的子接口。

3.5 Spring6 启用 Log4j2 日志框架

从 Spring5 之后，Spring 框架反对集成的日志框架是 Log4j2. 如何启用日志框架：
第一步：引入 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>

第二步：在类的根门路下提供 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>

第三步：应用日志框架

Logger logger = LoggerFactory.getLogger(FirstSpringTest.class);
logger.info("我是一条日志音讯");