初尝SpringBoot_一些注解的说明_jntoo.db.debug=true-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_44818449/article/details/118155278

主程序类

package com.atguigu.boot;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.web.servlet.WebMvcProperties;
import org.springframework.cache.interceptor.CacheAspectSupport;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * 主程序类;主配置类
 * @SpringBootApplication：这是一个SpringBoot应用
 */

//一个顶三个，例如要修改默认配置，修改默认扫描的包，则可以使用 @ComponentScan("com.atguigu.boot")
@SpringBootApplication
//@SpringBootConfiguration
//@EnableAutoConfiguration
//@ComponentScan("com.atguigu.boot")
public class MainApplication {


    public static void main(String[] args) {
        //1、返回我们IOC容器--->run   里面包含了当前应用的所有组件，例如DispatcherServlet中央调度器组件
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        int beanDefinitionCount = run.getBeanDefinitionCount();
        System.out.println(beanDefinitionCount);

        String[] beanNamesForType = run.getBeanNamesForType(CacheAspectSupport.class);
        System.out.println("======"+beanNamesForType.length);

        //3、从容器中获取组件

        String[] beanNamesForType1 = run.getBeanNamesForType(WebMvcProperties.class);
        System.out.println("======"+beanNamesForType1.length);



//
//        Pet tom01 = run.getBean("tom", Pet.class);
//        Pet tom02 = run.getBean("tom", Pet.class);
//        System.out.println("组件："+(tom01 == tom02));
//      //组件只注册了一次，获取在多次也是同一个组件，组件就是容器中的对象
//
//        MyConfig bean = run.getBean(MyConfig.class);
//        System.out.println(bean);
//      //com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
        //MyConfig这个配置类，本身也是组件，也就是对象

//      //如果@Configuration(proxyBeanMethods = true)获取到的就是代理对象，代理对象调用方法。
//      //SpringBoot总会检查这个组件是否在容器中有，有就拿，没有就创建
//      //保持组件单实例,无论这个方法在外面调用多少遍，都是拿到容器中的那个实例，为false则不会是同一个对象调方法了
//        MyConfig bean = run.getBean(MyConfig.class);
//        User user = bean.user01();
//        User user1 = bean.user01();
//        System.out.println(user == user1); true,无论这个方法在外面调用多少遍，都是拿到容器中的那个实例
//
//
        //组件依赖，用户的宠物就是容器中的宠物，必须是单实例，如果proxyBeanMethods = false，那么宠物就变了，它又帮我们new了一个
//        MyConfig bean = run.getBean(MyConfig.class);
//        User user01 = run.getBean("user01", User.class);
//        Pet tom = run.getBean("tom", Pet.class);
//        System.out.println("用户的宠物："+(user01.getPet() == tom));
//
//
//      //获取组件,看看通过import导入的组件有没有生效，组件名字为全类名
//        String[] beanNamesForType = run.getBeanNamesForType(User.class);
//        System.out.println("======");
//        for (String s : beanNamesForType) {
//            System.out.println(s);
//        }
//        DBHelper bean1 = run.getBean(DBHelper.class);
//        System.out.println(bean1);

        boolean tom = run.containsBean("tom");
        System.out.println("容器中Tom组件："+tom);

        boolean user01 = run.containsBean("user01");
        System.out.println("容器中user01组件："+user01);

        boolean tom22 = run.containsBean("tom22");
        System.out.println("容器中tom22组件："+tom22);


        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println("haha："+haha);
        System.out.println("hehe："+hehe);

    }
}

MyConfig

package com.atguigu.boot.config;


import ch.qos.logback.core.db.DBHelper;
import com.atguigu.boot.bean.Car;
import com.atguigu.boot.bean.Pet;
import com.atguigu.boot.bean.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.web.filter.CharacterEncodingFilter;


/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件（组件就是对象），默认也是单实例的，注册一次，取多少次都是同一个对象
 * 2、配置类本身也是组件
 * 3、默认proxyBeanMethods为true：代理bean的方法   意思：容器会不会被代理，会
 *      Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 *      Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *      组件依赖必须使用Full模式默认。其他默认是否Lite模式，例如user里面养了一个pet必须是同一个，user对象依赖了Pet对象，他们有依赖关系
 *
 *      使用：用true每次都会检查有没有这个组件，很费劲，所有在没有依赖关系的时候一般都调成false，启动加载会非常的快
 *
 * 4、@Import({User.class, DBHelper.class})
 *      给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
 *
 *
 * 5、@ImportResource("classpath:beans.xml")一些久项目还有spring配置文件，我们可以用它导入Spring的配置文件，并让它生效
 *
 */

@Import({User.class, DBHelper.class})     //导入注解，把指定类型的组件（对象）导入进来
@Configuration(proxyBeanMethods = false)  //组件（对象）添加注解 ，告诉SpringBoot这是一个配置类 == 配置文件，并且可以指定组件添加的方式以单例还是多例
//@ConditionalOnBean(name = "tom")        //条件注解之一：容器中有tom组件（对象）才给里面的对象进行注入，也可以放@bean上面，而且种类有很多
@ConditionalOnMissingBean(name = "tom")   //条件注解之一：容器中没有tom组件（对象）才给里面的对象进行注入，也可以放@bean上面，而且种类有很多
@ImportResource("classpath:beans.xml")    //资源引入注解：相当于把bean.xml里面的东西解析并且放到容器里面
//@EnableConfigurationProperties(Car.class) //开启属性配置绑定功能，有两个功能
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中          所有组件的添加，无论任何方式都是放在容器中的
public class MyConfig {


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

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

    @Bean("tom22")   //不以
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }

//    @Bean
//    public CharacterEncodingFilter filter(){
//        return null;
//    }
}

Controller

package com.atguigu.boot.controller;


import com.atguigu.boot.bean.Car;
import com.atguigu.boot.bean.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Import;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

//@ResponseBody
//@Controller

@Slf4j          //lombok依赖中的注解,注入一个log属性，用于打印日志，这里打印一个请求进来了....
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        log.info("请求进来了....");
        return "Hello, Spring Boot 2!"+"你好：";
    }

    //利用spring的自动注入，把spring容器中的car拿过来就行，将容器中的car给他赋值
    @Autowired
    Car car;


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



}

application.properties

#可以在配置文件中修改项目的任意配置
#例如端口号
server.port=8080
#例如文件最大上传大小
spring.servlet.multipart.max-file-size=10MB

#演示@ConfigurationProperties读取配置文件信息，给Car赋值
mycar.brand=YD
mycar.price=100000


#server.servlet.encoding.charset=GBK

#运行后可以查看给我们配置了哪些东西，Did not match就是没帮我们配置的
#debug=true

#尝试修改springboot默认配置的东西，修改默认启动图片，我们修改它
spring.banner.image.location=classpath:222.jpg

#引入一个场景，改一改配置，我们的spring boot就用起来了，至于业务代码就看公司的要求了

还有一些bean对象就没写了