SpringBoot2入门及其部分注解分析

最新推荐文章于 2023-06-26 21:08:22 发布

LanQiLi

最新推荐文章于 2023-06-26 21:08:22 发布

阅读量165

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/LanQiLi/article/details/116450358

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.创建maven项目，在pom.xml中引入springboot相关配置

<?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>SpringBootTest2</artifactId>
  <version>1.0-SNAPSHOT</version>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
  </parent>


  <name>SpringBootTest2</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-autoconfigure</artifactId>
      <version>2.3.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

2.创建需要跳转的页面，以及页面上的值

package com.llq.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String handler01(){
        return "hellow,SpringBoot2";
    }
}

3.创建主程序

package com.llq;

import com.llq.bean.Pet;
import com.llq.bean.User;
import com.llq.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/*
主程序类
用该注解告诉SpringBoot这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        
}

直接运行，访问localhost:8888/hello则可出现效果

具体项目（暂时）

-------------------------------------------------------------------

创建俩个类

package com.llq.bean;

public class Pet {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public Pet(String name) {
        this.name = name;
    }

    public Pet() {
    }

    @Override
    public String toString() {
        return "Pet{" +
                "name='" + name + '\'' +
                '}';
    }
}

package com.llq.bean;

public class User {

    private String name;
    private int age;
    private Pet pet;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setPet(Pet pet) {
        this.pet = pet;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public Pet getPet() {
        return pet;
    }

    public User() {
    }

    public User(String name, int age, Pet pet) {
        this.name = name;
        this.age = age;
        this.pet = pet;
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", pet=" + pet +
                '}';
    }
}

创建配置类

package com.llq.config;

import com.llq.bean.Pet;
import com.llq.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/*
配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
配置类本身也是组件
proxyBeanMethods：代理bean的方法
Full(proxyBeanMethods = true)
lite(proxyBeanMethods = false)
组件依赖
 */
@Configuration(proxyBeanMethods = true)//告诉SpringBoot这是一个配置类,proxyBeanMethods = true为默认，表示单利，false为多列表
public class MyConfig {

    /*
    外部无论对配置类中的这个组件注册方式调用多少次，获取的都是之前注册容器中的单实例对象
     */
    @Bean//给容器中添加组件，以方法名作为组件的id，返回类型是组件的类型，返回的值就是组件在容器中的实例
    public User user01(){
        User user = new User("小明", 18);
        user.setPet(littlePet());
        return user;
    }

    @Bean("Pet")//该注解里面的值为组件id
    public Pet littlePet(){
        return new Pet("小黑");
    }
}

测试

package com.llq;

import com.llq.bean.Pet;
import com.llq.bean.User;
import com.llq.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/*
主程序类
用该注解告诉SpringBoot这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //查看容器里面的组件
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for(String str:beanDefinitionNames){
            System.out.println(str);
        }
        //从容器中获取组件
        Pet pet1 = run.getBean("Pet", Pet.class);
        Pet pet2 = run.getBean("Pet", Pet.class);
        System.out.println("组件："+(pet1==pet2));

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        User user1 = bean.user01();
        User user2 = bean.user01();
        /*
        @Configuration(proxyBeanMethods = true)时，下面都返回true
        @Configuration(proxyBeanMethods = false)时，下面都返回false
         */
        System.out.println(user1==user2);
        System.out.println(user1.getPet()==pet1);
    }
}

关于@import注解

package com.llq;

import ch.qos.logback.core.db.DBHelper;
import com.llq.bean.Pet;
import com.llq.bean.User;
import com.llq.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

/*
主程序类
用该注解告诉SpringBoot这是一个SpringBoot应用

@Import({User.class, DBHelper.class})
给容器中自动创建出这俩个类型的组件，默认无参构造方法，如果User中没有无参构造，则报错。默认组件名字为全类名
 */
@SpringBootApplication
@Import({User.class, DBHelper.class})
public class MainApplication {

    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //查看容器里面的组件
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for(String str:beanDefinitionNames){
            System.out.println(str);
        }
        //从容器中获取组件
        Pet pet1 = run.getBean("Pet", Pet.class);
        Pet pet2 = run.getBean("Pet", Pet.class);
        System.out.println("组件："+(pet1==pet2));

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        User user1 = bean.user01();
        User user2 = bean.user01();
        /*
        @Configuration(proxyBeanMethods = true)时，下面都返回true
        @Configuration(proxyBeanMethods = false)时，下面都返回false
         */
        System.out.println(user1==user2);
        System.out.println(user1.getPet()==pet1);

        System.out.println("-----------------");
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        for (String str:beanNamesForType) {
            System.out.println(str);//user01
            //com.llq.bean.User
        }
        String[] beanNamesForType1 = run.getBeanNamesForType(DBHelper.class);
        for (String str:beanNamesForType1) {
            System.out.println(str); //ch.qos.logback.core.db.DBHelper
        }
        
        
       
    }
}

关于@Conditional注解

按住ctrl+h，出现，

这里以ConditionalOnBean作为演示

package com.llq.config;

import com.llq.bean.Pet;
import com.llq.bean.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
/*
配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
配置类本身也是组件
proxyBeanMethods：代理bean的方法
Full(proxyBeanMethods = true)
lite(proxyBeanMethods = false)
组件依赖
 */
//表明只有含有id为Pet的组件时，MyConfig类下面的所有组件才能执行，否则不执行
@Configuration(proxyBeanMethods = true)//告诉SpringBoot这是一个配置类,proxyBeanMethods = true为默认，表示单利，false为多列表
@ConditionalOnBean(name = "user01")
public class MyConfig {

    /*
    外部无论对配置类中的这个组件注册方式调用多少次，获取的都是之前注册容器中的单实例对象
     */


    @Bean//给容器中添加组件，以方法名作为组件的id，返回类型是组件的类型，返回的值就是组件在容器中的实例
    public User user01(){
        User user = new User("小明", 18);
        user.setPet(littlePet());
        return user;
    }


    @Bean("Pet")//该注解里面的值为组件id
    public Pet littlePet(){
        return new Pet("小黑");
    }
}

package com.llq;

import ch.qos.logback.core.db.DBHelper;
import com.llq.bean.Pet;
import com.llq.bean.User;
import com.llq.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

/*
主程序类
用该注解告诉SpringBoot这是一个SpringBoot应用

@Import({User.class, DBHelper.class})
给容器中自动创建出这俩个类型的组件，默认无参构造方法，如果User中没有无参构造，则报错。默认组件名字为全类名
 */
@SpringBootApplication
@Import({User.class, DBHelper.class})
public class MainApplication {

    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //查看容器里面的组件
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for(String str:beanDefinitionNames){
            System.out.println(str);
        }
        /*//从容器中获取组件
        Pet pet1 = run.getBean("Pet", Pet.class);
        Pet pet2 = run.getBean("Pet", Pet.class);
        System.out.println("组件："+(pet1==pet2));

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        User user1 = bean.user01();
        User user2 = bean.user01();
        *//*
        @Configuration(proxyBeanMethods = true)时，下面都返回true
        @Configuration(proxyBeanMethods = false)时，下面都返回false
         *//*
        System.out.println(user1==user2);
        System.out.println(user1.getPet()==pet1);

        System.out.println("-----------------");
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        for (String str:beanNamesForType) {
            System.out.println(str);
        }
        String[] beanNamesForType1 = run.getBeanNamesForType(DBHelper.class);
        for (String str:beanNamesForType1) {
            System.out.println(str);
        }*/

        boolean user01 = run.containsBean("user01");
        System.out.println(user01);

        boolean pet = run.containsBean("Pet");
        System.out.println(pet);
    }
}

当存在id为user01的组件时候，MyConfig执行（这点我感觉是我代码的问题，我试了很多次结果都与这个相反，先留着，以后更正）

关于@ImportResource注解，我们导入第三方项目的时候，可能别人使用的是ssm等框架，这个时候里面的配置文件在springboot里面都是不可以使用的，例如

package com.llq;

import ch.qos.logback.core.db.DBHelper;
import com.llq.bean.Pet;
import com.llq.bean.User;
import com.llq.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;

/*
主程序类
用该注解告诉SpringBoot这是一个SpringBoot应用

@Import({User.class, DBHelper.class})
给容器中自动创建出这俩个类型的组件，默认无参构造方法，如果User中没有无参构造，则报错。默认组件名字为全类名
 */
@SpringBootApplication
@Import({User.class, DBHelper.class})
public class MainApplication {

    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //查看容器里面的组件
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for(String str:beanDefinitionNames){
            System.out.println(str);
        }
        /*//从容器中获取组件
        Pet pet1 = run.getBean("Pet", Pet.class);
        Pet pet2 = run.getBean("Pet", Pet.class);
        System.out.println("组件："+(pet1==pet2));

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        User user1 = bean.user01();
        User user2 = bean.user01();
        *//*
        @Configuration(proxyBeanMethods = true)时，下面都返回true
        @Configuration(proxyBeanMethods = false)时，下面都返回false
         *//*
        System.out.println(user1==user2);
        System.out.println(user1.getPet()==pet1);

        System.out.println("-----------------");
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        for (String str:beanNamesForType) {
            System.out.println(str);
        }
        String[] beanNamesForType1 = run.getBeanNamesForType(DBHelper.class);
        for (String str:beanNamesForType1) {
            System.out.println(str);
        }*/

      /*  boolean user01 = run.containsBean("user01");
        System.out.println(user01);

        boolean pet = run.containsBean("Pet");
        System.out.println(pet);*/

        boolean bean1 = run.containsBean("bean1");
        System.out.println(bean1);

        boolean bean2 = run.containsBean("bean2");
        System.out.println(bean2);
    }
}

输出结果为false，但是我们可以使用该注解在任意一个类的上方，之后便可以读取该配置文件，如下代码所示

package com.llq;

import ch.qos.logback.core.db.DBHelper;
import com.llq.bean.Pet;
import com.llq.bean.User;
import com.llq.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;

/*
主程序类
用该注解告诉SpringBoot这是一个SpringBoot应用

@Import({User.class, DBHelper.class})
给容器中自动创建出这俩个类型的组件，默认无参构造方法，如果User中没有无参构造，则报错。默认组件名字为全类名
 */
@SpringBootApplication
@Import({User.class, DBHelper.class})
@ImportResource("classpath:bean2.xml")
public class MainApplication {

    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //查看容器里面的组件
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for(String str:beanDefinitionNames){
            System.out.println(str);
        }
        /*//从容器中获取组件
        Pet pet1 = run.getBean("Pet", Pet.class);
        Pet pet2 = run.getBean("Pet", Pet.class);
        System.out.println("组件："+(pet1==pet2));

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        User user1 = bean.user01();
        User user2 = bean.user01();
        *//*
        @Configuration(proxyBeanMethods = true)时，下面都返回true
        @Configuration(proxyBeanMethods = false)时，下面都返回false
         *//*
        System.out.println(user1==user2);
        System.out.println(user1.getPet()==pet1);

        System.out.println("-----------------");
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        for (String str:beanNamesForType) {
            System.out.println(str);
        }
        String[] beanNamesForType1 = run.getBeanNamesForType(DBHelper.class);
        for (String str:beanNamesForType1) {
            System.out.println(str);
        }*/

      /*  boolean user01 = run.containsBean("user01");
        System.out.println(user01);

        boolean pet = run.containsBean("Pet");
        System.out.println(pet);*/

        boolean bean1 = run.containsBean("bean1");
        System.out.println(bean1);

        boolean bean2 = run.containsBean("bean2");
        System.out.println(bean2);
    }
}

输出true

关于@ConfigurationProperties注解，以往做项目的时候，例如数据库连接池之类的配置文件，都需要注入到javabean中，使用该注解可以快速注入到javabean中，而且更加方便，代码如下

配置文件application.properties

mycar.brand=BYD
mycar.price=100000

package com.llq.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/*
只有在容器中的组件，才会拥有springboot提供的强大功能，因此在这里要加入@Component
 */
@Component
@ConfigurationProperties(prefix = "mycar")//以mycar开头
public class Car {
    private String brand;
    private Integer price;

    public String getBrand() {
        return brand;
    }

    public Integer getPrice() {
        return price;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

package com.llq.controller;

import com.llq.bean.Car;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    Car car;

    @RequestMapping("/car")
    public Car car(){
        return car;
    }

    @RequestMapping("/hello")
    public String handler01(){
        return "hellow,SpringBoot2";
    }
}

输入http://localhost:8080/car，得到所需页面

还可以省略@Conponent注解，在主程序头上加上@EnableConfigurationProperties注解，具体如下，所得结果不变

package com.llq;

import ch.qos.logback.core.db.DBHelper;
import com.llq.bean.Car;
import com.llq.bean.Pet;
import com.llq.bean.User;
import com.llq.config.MyConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;

/*
主程序类
用该注解告诉SpringBoot这是一个SpringBoot应用

@Import({User.class, DBHelper.class})
给容器中自动创建出这俩个类型的组件，默认无参构造方法，如果User中没有无参构造，则报错。默认组件名字为全类名
 */
@SpringBootApplication
@Import({User.class, DBHelper.class})
@ImportResource("classpath:bean2.xml")
@EnableConfigurationProperties(Car.class)
/*
@EnableConfigurationProperties作用：
开启car配置绑定功能
把这car组件自动注册到容器中，可以省略@Conponent注解
 */
public class MainApplication {

    public static void main(String[] args) {
        //返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        //查看容器里面的组件
        String[] beanDefinitionNames = run.getBeanDefinitionNames();
        for(String str:beanDefinitionNames){
            System.out.println(str);
        }
        /*//从容器中获取组件
        Pet pet1 = run.getBean("Pet", Pet.class);
        Pet pet2 = run.getBean("Pet", Pet.class);
        System.out.println("组件："+(pet1==pet2));

        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        User user1 = bean.user01();
        User user2 = bean.user01();
        *//*
        @Configuration(proxyBeanMethods = true)时，下面都返回true
        @Configuration(proxyBeanMethods = false)时，下面都返回false
         *//*
        System.out.println(user1==user2);
        System.out.println(user1.getPet()==pet1);

        System.out.println("-----------------");
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        for (String str:beanNamesForType) {
            System.out.println(str);
        }
        String[] beanNamesForType1 = run.getBeanNamesForType(DBHelper.class);
        for (String str:beanNamesForType1) {
            System.out.println(str);
        }*/

      /*  boolean user01 = run.containsBean("user01");
        System.out.println(user01);

        boolean pet = run.containsBean("Pet");
        System.out.println(pet);*/

        boolean bean1 = run.containsBean("bean1");
        System.out.println(bean1);

        boolean bean2 = run.containsBean("bean2");
        System.out.println(bean2);
    }
}

LanQiLi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot2入门及其部分注解分析

1.创建maven项目，在pom.xml中引入springboot相关配置<?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 htt...
复制链接

扫一扫