Abra a porta do SpringBoot e sinta a alegria trazida pelo SpringBoot

Bem-vindo ao primeiro episódio de Introdução ao SpringBoot

Olá! Esta é a primeira vez que você usa o SpringBoot para abrir a porta para um novo mundo. Se quiser aprender como usar o SpringBoot, você pode ler este artigo com atenção para compreender o conhecimento básico do SpringBoot.

O que é SpringBoot?

SpringBoot é um tipo de Spring derivado de Spring, SpringMVC + myBatis. Pode-se dizer que SpringBoot integra todos os recursos de Spring e SpringMVC. Ele possui a tecnologia central de inversão de controle IOC do Spring e programação orientada a aspectos AOP, simplificando o processo de Spring a criação de objetos sublima o acoplamento do Spring de alguns códigos funcionais:

Depois de entender o que é SpringBoot, vamos direto ao ponto

xml e javaConfig

Spring usa xml como arquivo de configuração do contêiner. Após a versão 3.0, javaconfig foi adicionado e o arquivo de configuração da classe java é usado.

1.1.1 O que é javaConfig

javaConfig: É um método java puro fornecido pelo Spring que usa classes Java para configurar contêineres e configurar contêineres Spring IOC.
Vantagens:

Você pode usar a abordagem orientada a objetos. Uma classe de configuração pode herdar a classe de configuração e substituir métodos.
Evite configurações XML complicadas

Contêiner de configuração 1.1.2xml

Crie 01 projeto de pré-inicialização
pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
<!--            编译插件-->
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
<!--                插件的版本-->
                <version>3.5.1</version>
<!--                编译级别-->
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
<!--                    编码格式-->
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

Criar classe de dados

public class Student {
    
    
    private String name;
    private Integer age;
    private String sex;

Crie o arquivo de configuração Spring bean.xml no diretório de recursos


    <bean id="myStudent" class="com.demo.vo.Student">
        <property name="name" value="李明"/>
        <property name="age" value="22"/>
        <property name="sex" value="男"/>
    </bean>

teste de unidade

 /**
     * 使用xml配置文件
     */
    @Test
    public void test(){
    
    
        String config = "bean.xml";
        ApplicationContext app = new ClassPathXmlApplicationContext(config);
        Student myStudent = (Student) app.getBean("myStudent");
        System.out.println(myStudent);
    }

1.1.3 Contêiner de configuração JavaConfig

A anotação @Configuration usada principalmente por javaConfig
: colocada no topo da classe, esta classe é equivalente ao arquivo de configuração xml, no qual os beans podem ser declarados
@Bean: colocado no topo do método, o valor de retorno do método é o tipo de objeto, este objeto é injetado no contêiner Spring IOC

Crie uma classe de configuração (equivalente a um arquivo de configuração xml)

Crie uma classe de configuração no pacote com.demo.config

package com.demo.config;/**
 * @Author: Ma RuiFeng
 * @Description:
 * @Date: Created in 10:58 2022/2/25
 * @Modified By:
 */

import com.demo.vo.Student;
import org.springframework.context.annotation.*;

/**
 * @Configration: 表示当前类是作为配置文件使用的，就是用来配置容器的
 *            位置：类的上面
 *
 *      springconfig这个类就相当于bean.xml
 */

/**
 * @ImportResource（其他配置文件）: 在类的上面，可以指定多个value值
 */
@Configuration
@ImportResource(value={
    
    "classpath:catBean.xml","classpath:bean.xml"})
//用注解创建tiger对象
@PropertySource(value = "classpath:config.properties")
@ComponentScan(basePackages  = "com.demo.vo")
public class SpringConfig {
    
    

    /**
     * 创建方法，方法的返回值是对象，在方法的上面加入@Bean
     * 方法的返回值对象就注入到容器中
     *
     * @Bean：吧对象注入到spring容器中，作用相当于<bean></bean>
     *      位置 在方法的上面
     *      说明：@Bean，不指定对象的名称，默认是方法名是id
     */
    @Bean
    public Student createStudent(){
    
    
        Student student = new Student();
        student.setName("张三");
        student.setAge(22);
        student.setSex("男");
        return student;
    }

    /**
     * 指定对象在容器中的名称（指定<bean>的id属性）
     * @Bean 的name属性，指定对象的名称（id）
     */
    @Bean(name="listStudent")
    public Student makeStudent(){
    
    
        Student s1 = new Student();
        s1.setName("lisi");
        s1.setAge(25);
        s1.setSex("nv");
        return s1;
    }
}

Métodos de teste

package com.demo;/**
 * @Author: Ma RuiFeng
 * @Description:
 * @Date: Created in 10:41 2022/2/25
 * @Modified By:
 */

import com.demo.config.SpringConfig;
import com.demo.vo.Cat;
import com.demo.vo.Student;
import com.demo.vo.Tiger;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.security.AllPermission;

/**
 *
 *  @Description      :some description
 *  @author           :XXX
 *  @version
 *  @date             :2022/2/25 10:41
 *
 */


public class MyTest {
    
    
    /**
     * 使用xml配置文件
     */
    @Test
    public void test(){
    
    
        String config = "bean.xml";
        ApplicationContext app = new ClassPathXmlApplicationContext(config);
        Student myStudent = (Student) app.getBean("myStudent");
        System.out.println(myStudent);
    }
    /**
     * 使用configuration创建对象
     */
    @Test
    public void test2(){
    
    
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        Student createStudent = (Student) app.getBean("createStudent");
        System.out.println("使用javaconfig创建的bean对象："+createStudent);
    }
    /**
     * bean 的id自定义属性名
     */
    @Test
    public void test3(){
    
    
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        Student listStudent = (Student) app.getBean("listStudent");
        System.out.println("使用javaconfig创建的bean对象："+listStudent);
    }
    @Test
    public void test4(){
    
    
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        Cat myCat = (Cat) app.getBean("myCat");
        System.out.println("使用javaconfig创建的bean对象："+myCat);
    }
    @Test
    public void test5(){
    
    
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        Tiger myTiger = (Tiger) app.getBean("tiger");
        System.out.println("使用javaconfig创建的bean对象："+myTiger);
    }
}

1.1.4 @ImportResource

@ImportResource serve para importar a configuração xml, que equivale à
classe de dados de criação de recursos do arquivo xml.

public class Cat {
    
    
    private String Idcard;
    private String name;
    private Integer age;
//set//get方法

Crie o arquivo de configuração catBean.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="myCat" class="com.demo.vo.Cat">
        <property name="name" value="tomcat"/>
        <property name="age" value="10"/>
        <property name="idcard" value="104010201"/>
    </bean>
<!--    <context:property-placeholder location="classpath:config.properties"/>-->
<!--    <context:component-scan base-package="com.demo.vo"/>-->
<!--    <import resource="classpath:bean.xml"/>-->

Criar classe de configuração

@Configuration
@ImportResource(value={
    
    "classpath:catBean.xml","classpath:bean.xml"})
public class SpringConfig {
    
    }

Aula de teste

@Test
    public void test4(){
    
    
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        Cat myCat = (Cat) app.getBean("myCat");
        System.out.println("使用javaconfig创建的bean对象："+myCat);
    }

1.1.5 @PropertyResource

@PropertyResource é ler o arquivo de configuração do atributo de propriedades

Crie config.properties no diretório de recursos

tiger.name=东北虎
tiger.age=3

Criar classe de dados Tiger

@Component("tiger")
public class Tiger {
    
    
    @Value("${tiger.name}")
    private String name;
    @Value("${tiger.age}")
    private Integer age;
    //get/set方法

@Configuration
@PropertySource(value = "classpath:config.properties")
@ComponentScan(basePackages  = "com.demo.vo")
public class SpringConfig {
    
    


//使用@Bean声明bean

código de teste

 @Test
    public void test5(){
    
    
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        Tiger myTiger = (Tiger) app.getBean("tiger");
        System.out.println("使用javaconfig创建的bean对象："+myTiger);
    }

Neste ponto, o primeiro episódio de introdução ao SpringBoot terminou. Se houver algo que eu fiz de errado, fique à vontade para deixar uma mensagem. Farei alterações com o tempo. Espero que você possa dar suas valiosas opiniões.

SpringBoot: primeiros passos, episódio 1