spring6学习笔记

概述

• spring是什么
  
• spring狭义和广义划分
  
  
• spring framework的特点
  
• spring6的模块组成和版本要求
  

入门

• 入门案例实现步骤
  
• 入门案例程序开发
  创建项目spring6
  
  创建子模块spring-01
  
  引入子模块依赖

<!--        spring context依赖-->
<!--        当你引入spring context依赖之后，表示将spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.2</version>
        </dependency>
<!--        junit-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.6.3</version>
        </dependency>

• 入门案例程序分析

创建测试类User

package com.hhxy.spring6;

public class User {
    public void add() {
        System.out.println("2add。。。。。。。。");
    }

    public static void main(String[] args) {
        User user = new User();
        user.add();
    }

    //无参构造方法
    public User() {
        System.out.println("0无参数构造");
    }
}

添加配置文件

<?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">

    <!--完成user对象创建
        bean标签
        id属性：唯一标识
        class属性：要创建对象所在类的全路径（包名称+类名称）
        -->
    <bean id="user" class="com.hhxy.spring6.User"></bean>

</beans>

创建测试方法

public class TestUser {

    @Test
    public void TestUserObject() {
        //加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //获取创建的对象
        User user = (User) context.getBean("user");
        System.out.println(user);

        //使用对象调用方法进行测试
        user.add();
    }
  //反射创建对象
    @Test
    public void TestUserObject1() throws Exception {
        //获取类class对象
        Class clazz = Class.forName("com.hhxy.spring6.User");
        //调用方法创建对象
        User user = (User) clazz.getDeclaredConstructor().newInstance();
        System.out.println(user);
    }

}

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

添加配置文件

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

手动添加日志

//创建Logger对象
    private Logger logger = LoggerFactory.getLogger(TestUser.class);

//手动写日志
        logger.info("##执行调用成功了！！！");

IoC

• 概述
  
• 环境搭建
  创建子项目spring6-ioc-xml
• 获取bean

public class User {

    private String name;
    private Integer age;

    public void run() {
        System.out.println("run.........");
    }

}

public class TestUser {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

        //根据id获取bean
        User user1 = (User) context.getBean("user");
        System.out.println("根据id获取bean："+user1);

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

        //根据id和类型获取bean
        User user3 = context.getBean("user",User.class);
        System.out.println("根据id和类型获取bean："+user3);
    }
}

若一个对象创建了两次，则不能根据类型获取bean

<!--    获取bean演示，user对象创建-->
    <bean id="user" class="com.hhxy.spring6.User"></bean>
    <bean id="user1" class="com.hhxy.spring6.User"></bean>

• 接口实现类获取bean

public interface UserDao {
    void run();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void run() {
        System.out.println("run..........");
    }
}

public class TestUserDao {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //根据类型获取接口对应的bean
        UserDao userDao = context.getBean(UserDao.class);
        System.out.println(userDao);
        userDao.run();
    }
}

诺一个接口实现类创建了两次也会报错

<!--    一个接口实现类获取过程-->
    <bean id="userDao" class="com.hhxy.spring6.bean.UserDaoImpl"></bean>
    <bean id="personDaoImpl" class="com.hhxy.spring6.bean.PersonDaoImpl"></bean>

public class PersonDaoImpl implements UserDao {
    @Override
    public void run() {
        System.out.println("run2.......");
    }
}