SpringBoot2基础入门 学习(一)

 <!-- 
<!-- 阿里云仓库：提供大量组件,不配置自己联网下载到本地仓库~ --> 
  <mirrors>
      <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>central</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      </mirror>
  </mirrors>
 <!-- 告诉Maven统一编辑项目 jdk1.8~ -->
  <profiles>
         <profile>
              <id>jdk-1.8</id>
              <activation>
                <activeByDefault>true</activeByDefault>
                <jdk>1.8</jdk>
              </activation>
              <properties>
                <maven.compiler.source>1.8</maven.compiler.source>
                <maven.compiler.target>1.8</maven.compiler.target>
                <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
              </properties>
         </profile>
  </profiles>

<!-- 集成一个父项目 -->	
	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>
    
<!-- spring-boot对一些开发所需的资源Jar有自动的管理都存在在对应的 starter-xxx管理.
	 这里使用 spring-boot-starter-web 引入所有的web组件！
	 一切都由SpringBoot帮你做好了。
 -->	
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication  //标注主程序类,这是一个Springboot应用! 
//@SpringBootApplication(scanBasePackages = "指定扫描包下注解~") 	//默认扫描该类的包及子包~
public class SpringBootRun {
    public static void main(String[] args) {
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);
    }
}

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

//作用:该类是一个Controller控制器 且 下所有方法的返回值为一个JSON
//相当于是一个:@Controller 和 @ResponseBody 注解的集合,内部SpringBoot 自定义了完善的属性配置,当然也可以通过配置修改覆盖...
@RestController
public class HelloController {
    //相当于: 以前SpringMVC的 @RequestMapping get方式请求~
    //@RequestMapping(value = "/show" ,method = RequestMethod.GET)
    @GetMapping(value = "/show")    //@GetMapping用于处理请求方法的GET类型，@PostMapping用于处理请求方法的POST类型等。
    public String Hello(){
        return "Hello Wrod!!";
    }
}

   <!-- 使SpringBoot工程支持,项目打成jar包，直接在目标服务器执行即可 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.6.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

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

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.1.3.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
...

<properties>
  <activemq.version>5.15.8</activemq.version>
  ...
  <solr.version>7.4.0</solr.version>
  <!-- Spring家族依赖组件~ -->
  <spring.version>5.1.5.RELEASE</spring.version>
  <spring-amqp.version>2.1.4.RELEASE</spring-amqp.version>
  <spring-batch.version>4.1.1.RELEASE</spring-batch.version>
  <spring-cloud-connectors.version>2.0.4.RELEASE</spring-cloud-connectors.version>
  <spring-data-releasetrain.version>Lovelace-SR5</spring-data-releasetrain.version>
  <spring-framework.version>${spring.version}</spring-framework.version>
  <spring-security.version>5.1.4.RELEASE</spring-security.version>
  <spring-session-bom.version>Bean-SR3</spring-session-bom.version>
  <spring-ws.version>3.0.6.RELEASE</spring-ws.version>
  <sqlite-jdbc.version>3.25.2</sqlite-jdbc.version>
  <statsd-client.version>3.1.0</statsd-client.version>
  <sun-mail.version>${javax-mail.version}</sun-mail.version>
  <thymeleaf.version>3.0.11.RELEASE</thymeleaf.version>
  <tomcat.version>9.0.16</tomcat.version>				<!-- Tomcat -->
  <unboundid-ldapsdk.version>4.0.9</unboundid-ldapsdk.version>
  <undertow.version>2.0.17.Final</undertow.version>
  <versions-maven-plugin.version>2.7</versions-maven-plugin.version>
  <webjars-hal-browser.version>3325375</webjars-hal-browser.version>
  <webjars-locator-core.version>0.35</webjars-locator-core.version>
</properties>

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.1.3.RELEASE</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-json</artifactId>
    <version>2.1.3.RELEASE</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>2.1.3.RELEASE</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.0.14.Final</version>
    <scope>compile</scope>
  </dependency>
  <!-- .... -->
</dependencies>

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
//以上一些Java的注解无伤大雅！
@SpringBootConfiguration     // 标明该类为配置类
@EnableAutoConfiguration     // 启动自动配置功能
@ComponentScan(              // 包扫描器
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
...
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage                             // 自动配置包
@Import({AutoConfigurationImportSelector.class}) // 自动配置类扫描导入
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

@Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
public @interface AutoConfigurationPackage {}
 
//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

protected AutoConfigurationImportSelector.AutoConfigurationEntry
        getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
 AnnotationMetadata annotationMetadata) {
  if (!this.isEnabled(annotationMetadata)) {
    return EMPTY_ENTRY;
  } else {
    AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
         // 获取所有Spring Boot提供的后续自动配置类XxxAutoConfiguration
    List<String> configurations = 
this.getCandidateConfigurations(annotationMetadata, attributes);
    configurations = this.removeDuplicates(configurations);
    Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
    this.checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
         // 筛选并过滤出当前应用环境下需要的自动配置类XxxAutoConfiguration
    configurations = this.filter(configurations, autoConfigurationMetadata);
    this.fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationImportSelector.AutoConfigurationEntry(
configurations, exclusions);
  }
}

public class User {
    private int id=0;
    private String name="默认";
    //get/set
    //toString()....

//配置类学习
@Configuration
public class ConfigXX {
    //Bean
    //就相当于以前的: <Bean></Bean>
    @Bean           //以方法名作为组件的id  返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public String str(){
        return "字符";
    }
    @Bean("myUser") //指定组件id名,将该对象存储到spring的上下文中 （环境中）
    public User user() {
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
    @Bean("tom")
    public User userTom(){
        User user = new User();
        user.setId(1);
        user.setName("tom");
        return user;
    }
}

@SpringBootApplication  //标注主程序类,这是一个Springboot应用!
public class SpringBootRun {
    public static void main(String[] args) {
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        //查看容器里面所有的组件,Bean
        String[] names = run.getBeanDefinitionNames();
        System.out.println("-----------所有的组件Bean----------");
        for (String name : names) {
            //因为,有很多是默认的所以会有很多~
            System.out.println(name);
        }

        //从容器中根据id获取指定组件
        String str = (String)run.getBean("str");   //方法返回Object类型——》强制转换
        System.out.println(str);
        //查询Spring上下文存在该元素
        boolean isok = run.containsBean("str");
        System.out.println(isok);
        
        User myUser = (User)run.getBean("myUser");
        System.out.println(myUser);

        User tom1 = (User)run.getBean("tom");
        User tom2 = (User)run.getBean("tom");
        System.out.println(tom1==tom2);     //比较结果:true 结论@Configuration默认模式是Full 单例
    	//被@Configuration注解的类同时也被注入
        ConfigXX cfx = (ConfigXX)run.getBean(ConfigXX.class);
        System.out.println(cfx.user()==cfx.user());     //结果为true 调用new 的方法同样是true;
	}
}

<?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="w" class="com.wsm.entity.User"></bean>
</beans>

@SpringBootApplication                  //标注主程序类,这是一个Springboot应用!
@ImportResource("classpath:beanConf.xml")  //classpath表示就是资源目录下; 这里不多解释了...
public class SpringBootRun {
    public static void main(String[] args) {
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        User user = (User) run.getBean("w");
        System.out.println(user);
    }
}

@SpringBootApplication                  //标注主程序类,这是一个Springboot应用!
@Import({User.class})
public class SpringBootRun {
    public static void main(String[] args) {
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        User u = run.getBean(User.class);
        System.out.println(u);
    }
}

@Configuration
@ConditionalOnBean(name = "abc")    //检查上下文中是否存在abc，如果存在,才执行下面的所有的创建操作      
//@ConditionalOnMissingBean(name = "abc") 
//检查上下文中是否存在abc，如果没有存在,执行下面的所有的创建操作
public class ConfigXX {
    //Bean
    //就相当于以前的: <Bean></Bean>
    @Bean           //以方法名作为组件的id  返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public String str(){
        return "字符";
    }
    @Bean("tom")
    public User userTom(){
        User user = new User();
        user.setId(1);
        user.setName("tom");
        return user;
    }
    @Bean("myUser") //指定组件id名,将该对象存储到spring的上下文中 （环境中）
    public User user() {
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

@SpringBootApplication
public class SpringBootRun {
    public static void main(String[] args) {
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        //查看容器里面所有的组件,Bean
        String[] names = run.getBeanDefinitionNames();
        System.out.println("-----------所有的组件Bean----------");
        for (String name : names) {
            //因为,有很多是默认的所以会有很多~
            System.out.println(name);
        }
    }
}

//配置类注解，被自动扫描发现
//@Component
@ConfigurationProperties(prefix = "stu")                     //指明前缀
@PropertySource("classpath:application.properties")        //指明配置源文件位置
public class Student {
    private int id;
    private String name;
    //get/set/toString()....
}

# 修改SpringBoot的端口 默认8080
server.port=9090     
#根据@ConfigurationProperties 声明类的前缀进行 .属性=值 注入;
stu.id=10001
stu.name=admin

#.properties文件
#键值注入 字符串不需要引号..

@SpringBootApplication
@EnableConfigurationProperties({Student.class})
public class SpringBootRun {
    public static void main(String[] args) {
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        Student stu = run.getBean(Student.class);
        System.out.println(stu);
    }
}

@ConfigurationProperties(prefix = "person")
public class Person {
    private String userName;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private User user;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    //get/set/toString()
}

person:
  userName: 张三
  boss: true
  birth: 2020/01/01 15:20:30
  age: 20
  user:                             #对象User类型
    id: 1001
    name: 张三
  interests: ['test01','test02']    #字符串数组
  animal:                           #字符串集合
  - cat                                 #字符串值
  - dog
  score:                            #Map类型 String,Object类型
    english:                          #Map元素键1
      first: 100                        #Map键1的值：又是一个Map类型
      last: 20
    math: [10,20,30,40]               #Map元素键2：也是一个Map类型
    chinese: {one: 50,two: 60,three: 70}
  salarys: [4555.5,4666.5,4777.5]

@SpringBootApplication
@EnableConfigurationProperties({Student.class, Person.class})
public class SpringBootRun {
    public static void main(String[] args) {
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        Person person = run.getBean(Person.class);
        System.out.println(person);
    }
}

<!-- 加入依赖 -->
<?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>SpringBoot128</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
    </dependencies>
</project>

@Component
@ConfigurationProperties(prefix = "hello")		//使用配置绑定 前缀hello
public class HelloProperties {
    private String msg = "SpringBoot";			
	//默认值 SpringBoot,如果引入自动配置的项目可以通过 .properties .yml 文件中,进行更改！						
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

public class Hello {
    private  String msg;
    public String say(){	
        return  "hello"+getMsg();		//打印输出Hello + msg
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

@Configuration   //这是一个配置类
@ConditionalOnClass(Hello.class)    //是否存在 Hello的类,没有不执行类中操作...
@EnableConfigurationProperties(HelloProperties.class)   //开启使用 @ConfigurationProperties 注解的类生效。
@ConditionalOnProperty(prefix = "hello", value = "enabled", matchIfMissing = true)
//prefix 数组，获取property名称的前缀，可有可无
//name 数组，property完整名称或部分名称，与prefix组合使用组成完整属性名称，与value不可同时存在
//value 数组，获取property完整名称或部分名称，与prefix组合使用成完整属性名称，与name不可同时存在
//havingValue 比较获取的属性值与havingValue给定的值是否相同，相同才加载配置类
//matchIfMissing 缺少property时是否加载，如果为true，没有该property属性也会正常加载，反之报错。
//是否存在 hello 属性则执行下面操作..
public class HelloAutoConfigration {

    @Autowired
    private HelloProperties helloProperties;
    @Bean
    @ConditionalOnMissingBean
    public Hello createHello() {
        Hello hello = new Hello();
        hello.setMsg(helloProperties.getMsg());
        return hello;
    }
}

import com.wsm.Hello;           //引入依赖的类型;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController  //@Controller @ResponseBody
public class HelloController {

    @Autowired
    private Hello hello;        //注入

    @GetMapping(value = "/showMsg")
    public String shoMsg(){
        return  hello.say();
    }
}

<!-- 引入自定义配置依赖 -->
<dependency>
    <groupId>org.example</groupId>
    <artifactId>SpringBoot128</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>