目录
第一个springboot案例:
第一步:创建程序,导入依赖
第二步编写代码;
Controller的编写:
所有springboot默认配置文件再这里找:
打包运行:
cmd运行jar:
总结:
注意点:取消掉cmd的快速编辑模式:
总结:
查看主程序类中的所有组件:
默认的包扫描路径:
springboot有一个默认的包扫描,我们无需以前的包扫描配置:
SpringBoot 中@Bean注解的使用(配置类的实现)
一、基本介绍
Spring Boot 推荐使用 java 配置完全代替 XML 配置,java 配置是通过 @Configration 和 @Bean 注解实现的。二者作用如下:
@Configration 注解:声明当前类是一个配置类,相当于 Spring 中的一个 XML 文件
@Bean 注解:作用在方法上,声明当前方法的返回值是一个 Bean,将此bean放到IOC容器中。类似于xml中bean标签。**
@Bean 基础声明
Spring的@Bean注解用于告诉方法,产生一个Bean对象,然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次,随后这个Spring将会将这个Bean对象放在自己的IOC容器中。
SpringIOC 容器管理一个或者多个bean,这些bean都需要在@Configuration注解下进行创建,在一个方法上使用@Bean注解就表明这个方法需要交给Spring进行管理。
二、简单样例
(1)首先创建一个自定义的配置类 MyConfig:
使用 @Configration 注解将该类声明为一个配置类,代替spring中的xml文件。
在 newUser() 方法上添加 @Bean 注解则会往 Spring 容器中添加一个名为 newUser的 Bean,该 Bean 即为方法的返回值,Bean的类型就是方法返回值类型。
package com.fan.conf;
import com.fan.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//此类是一个配置类,代替xml中的各种配置
@Configuration//声明此类是一个配置类,相当于spring中的一个xml文件
public class MyConfig {
@Bean(name = "user")//声明当前方法返回一个Bean,并放到ioc中,name属性可以指定此bean的别名id
public User newUser(){//此bean默认的id,就是方法名字newUser
//User类在我的pojo包下
return new User("张三",18);
}
}
(2)下面我们在一个 Controller 中获取并使用这个 Bean,代码如下:
package com.fan.controller;
import com.fan.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController//声明我是一个组件,可以通过包扫描来发现我,并把此组件放入IOC中
public class MyConfigTestController {
@Autowired
private User user;//依赖注入,通过配置类中的@Bean注解
@RequestMapping("/user")
public User testBeanAnnntation(){
System.out.println("测试@Bean注解:"+user);
return user;
}
}
(3)访问这个 Controller,运行结果如下:
控制台输出:测试@Bean注解:User(name=张三, age=18, pet=null)
三、@Bean 注解详解
1,使用说明
@Bean 注解作用在方法上
@Bean 指示一个方法返回一个 Spring 容器管理的 Bean
@Bean 方法名与返回类名一致,首字母小写
@Bean 一般和 @Component 或者 @Configuration 一起使用
@Bean 注解默认作用域为单例 singleton 作用域,可通过 @Scope(“prototype”) 设置为原型作用域
2,Bean 名称(类似于xml中bean标签中的id)
(1)默认情况下 Bean 名称就是方法名,比如下面 Bean 名称便是 myBean:
@Bean
public User myBean() {
return new User();
}
(2)@Bean 注解支持设置别名。比如下面除了主名称 myBean 外,还有个别名 user(两个都可以使用)
@Bean("user")
public User myBean() {
return new User();
}
3)@Bean 注解可以接受一个 String 数组设置多个别名。比如下面除了主名称 myBean 外,还有别名 myBean1、myBean2(三个都可以使用)
@Bean({"myBean1", "myBean2"})
public User myBean() {
return new User();
}
3,@Bean 与其他注解一起使用
(1)@Bean 注解常常与 @Scope、@Lazy,@DependsOn 和 @link Primary 注解一起使用:
@Profile 注解:为在不同环境下使用不同的配置提供了支持,如开发环境和生产环境的数据库配置是不同的
@Scope 注解:将 Bean 的作用域从单例改变为指定的作用域
@Lazy 注解:只有在默认单例作用域的情况下才有实际效果
@DependsOn 注解:表示在当前 Bean 创建之前需要先创建特定的其他 Bean
(2)比如下面样例,Bean 的作用域默认是单例的,我们配合 @Scope 注解将其改成 prototype 原型模式(每次获取 Bean 的时候会有一个新的实例)
@Bean()
@Scope("prototype")
public User myBean() {
return new User();
}
4,Bean 初始化和销毁时调用相应的方法
(1)实际开发中,经常会遇到在 Bean 使用之前或使用之后做些必要的操作,Spring 对 Bean 的生命周期的操作提供了支持:我们可以通过 @Bean 注解的 initMethod 和 destrodMethod 进行指定 Bean 在初始化和销毁时需要调用相应的方法。
(2)下面是一个简单的样例:
public class MyBean {
public void init() {
System.out.println("MyBean开始初始化...");
}
public void destroy() {
System.out.println("MyBean销毁...");
}
public String get() {
return "MyBean使用...";
}
}
@Bean(initMethod="init", destroyMethod="destroy")
public MyBean myBean() {
return new MyBean();
}
SpringBoot 中@Configration(proxyBeanMethods = false) 注解
一、基本使用说明
@Configration 注解作用在类、接口(包含注解)上
@Configuration 用于定义配置类,可替换 xml 配置文件
@Configration 注解类中可以声明一个或多个 @Bean 方法
@Configration 注解作用的类不能是 final 类型
嵌套的 @Configration 类必须是 static 的
二、结合@Bean的一些使用:
当我们使用@Bean在配置类中向容器中注册一些bean后(类似于xml通过bean标签向IOC容器中注册bean一样),我们也可以通过这种方式获取bean,来测试我们是否把注册的bean交给了spring来管理:
当我们在@Configration(proxyBeanMethods = false) 上使用proxyBeanMethods 此属性的时候,就出产生以下问题:
1. Full 模式 Lite 模式
proxyBeanMethods = true 或不写,是Full模式
proxyBeanMethods = false 是lite模式
不带@Configuration的类叫Lite配置类
2.@Configuration配置类是有主次之分的,主配置类是驱动整个程序的入口,可以是一个,也可以是多个(若存在多个,支持使用@Order排序)
3.Full模式下通过方法调用指向的仍旧是原来的Bean
利用cglib代理增强,bean是单例的,@Bean方法调用生成实例时,如果已经存在这个bean,直接返回
4. lite模式下,直接返回新实例对象。
Spring 5.2.0+的版本,建议你的配置类均采用Lite模式去做,即显示设置proxyBeanMethods = false。Spring Boot在2.2.0版本(依赖于Spring 5.2.0)起就把它的所有的自动配置类的此属性改为了false,即@Configuration(proxyBeanMethods = false),提高Spring启动速度
三、声明多个 @Bean 方法,有组件之间的依赖
(1)@Configration 注解类中可以声明多个 @Bean 方法,并且 bean 与 bean 之间是可以有依赖关系的。如果一个 bean 的定义依赖其他 bean,则直接调用对应的 JavaConfig 类中依赖 bean 的创建方法就可以了。
代码演示bean组件依赖:
注意:只有当在@Configration(proxyBeanMethods = true) 的时候,组件之间的依赖才成立,false则不成立
MyConfig配置类:
package com.fan.conf;
import com.fan.pojo.Pet;
import com.fan.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration(proxyBeanMethods = true)
public class MyCofig {
@Bean
public User user01(){
User user = new User("张三", 18);
user.setPet(tomcatPet());//这里是调用方法,返回一个对象
return user;
}
@Bean(name = "tom")
public Pet tomcatPet(){//注意,此时的方法名作为组件的id,即id="tomcatPet()"
return new Pet("tomcat");
}
}
主启动类:
package com.fan.controller;
import com.fan.conf.MyCofig;
import com.fan.pojo.Pet;
import com.fan.pojo.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@SpringBootApplication(scanBasePackages = "com.fan")
public class MainApp {
public static void main(String[] args) {
//ConfigurableApplicationContext也属于spring容器
ConfigurableApplicationContext run = SpringApplication.run(MainApp.class, args);
//从容器种获取组件
User user01 = (User) run.getBean("user01");
//从容器中获取组件
Pet tom1 = (Pet) run.getBean("tom");
Pet tom2 = (Pet) run.getBean("tom");
System.out.println("比较从容器中两次获取的对象是否是同一个:"+(tom1 == tom2));
//获取配置类:
MyCofig bean = run.getBean(MyCofig.class);
User user1 = bean.user01();
User user2 = bean.user01();
//此处相等的原因是因为属性@Configuration(proxyBeanMethods = true)
System.out.println("从配置类中调用两次获取对象的方法:"+(user1 == user2));//true,当proxyBeanMethods为false,此处返回false
//测试组件之间的依赖是否成立,当@Configuration(proxyBeanMethods = true)时,是成立的
User user_01 = run.getBean("user01",User.class);//从容器中获取一个user对象
Pet pet_01 = user_01.getPet();//从user对象中间接的获取一个pet对象
//直接从容器中获取pet对象
Pet tom = run.getBean("tom", Pet.class);
//比较这两个对象是否相等
System.out.println("测试组件之间的依赖关系:"+(pet_01 == tom));
}
}
两个需要依赖的实体类:
package com.fan.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Pet {
private String name;
}
package com.fan.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private String name;
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
private Pet pet;
}
总结@Configration:
SpringBoot中@Import的使用
测试:
条件装配注解:
外部xml配置文件的绑定生效:
导入XML配置
如果绝对必须使用基于XML的配置,我们建议您仍然从一个@Configuration类开始。然后,您可以使用@ImportResource批注来加载XML配置文件。
配置文件绑定的注解:
第一种方式:
使用@ConfigurationProperties和@Component注解到bean定义类上,这里@Component代指同一类实例化Bean的注解。
代码演示第一种:
application.properties配置文件;
mycar.brand=BWM
mycar.price=3500000
pojo包下的Car类:
package com.fan.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
//我们现在想把这个javabean放到容器中,并且把属性赋值和springboot的配置文件一起使用
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component//需要使用两个注解配合使用
@ConfigurationProperties(prefix = "mycar")//设置前缀,用来指明配置文件中的引用
public class Car {
private String brand;//品牌
private Integer price;//价格
}
然后Controller中测试;
package com.fan.controller;
import com.fan.pojo.Car;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController//让其返回json到数据区
public class HelloController {
@Autowired//按照类型自动注入,看car对象有没有在容器中
private Car car;
//测试我们的car是放到容器中了,属性是否设置进去了
@RequestMapping("/hello")
public Car hello(){
System.out.println("测试绑定属性文件:" + car);
return car;
}
}
结果展示:
方式二:需要将需要用到的两个注解放到配置类中,如下图:
@EnableConfigurationProperties注解的作用是:使使用 @ConfigurationProperties 注解的类生效。
代码演示
实体类:
package com.fan.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
//我们现在想把这个javabean放到容器中,并且把属性赋值和springboot的配置文件一起使用
@Data
@AllArgsConstructor
@NoArgsConstructor
@ConfigurationProperties(prefix = "mycar")
public class Car {
private String brand;//品牌
private Integer price;//价格
}
配置类:
package com.fan.conf;
import ch.qos.logback.core.db.DBHelper;
import com.fan.pojo.Car;
import com.fan.pojo.Pet;
import com.fan.pojo.User;
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({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
@EnableConfigurationProperties(Car.class)//相当于开启Car配置绑定功能和把这个Car组件放到容器中
public class MyCofig {
@Bean
public User user01(){
User user = new User("张三", 18);
user.setPet(tomcatPet());//这里是调用方法,返回一个对象
return user;
}
@Bean(name = "tom")
public Pet tomcatPet(){//注意,此时的方法名作为组件的id,即id="tomcatPet()"
return new Pet("tomcat");
}
}
测试成功显示:
总结:
核心注解(@SpringBootApplication注释):
使用@SpringBootApplication注释
许多Spring Boot开发人员喜欢他们的应用程序使用自动配置,组件扫描,并能够在其“应用程序类”上定义额外的配置。单个@SpringBootApplication注释可用于启用这三个功能,即:
@EnableAutoConfiguration:启用Spring Boot的自动配置机制
@ComponentScan:@Component在应用程序所在的软件包上启用扫描
@Configuration:允许在上下文中注册额外的bean或导入其他配置类
package com.example.myapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
按需开启自动配置项:
自动配置
Spring Boot自动配置会尝试根据您添加的jar依赖项自动配置您的Spring应用程序。例如,如果HSQLDB位于类路径上,并且尚未手动配置任何数据库连接bean,那么Spring Boot会自动配置内存数据库。
禁用特定的自动配置类
如果发现正在应用不需要的特定自动配置类,则可以使用exclude属性@SpringBootApplication来禁用它们,如以下示例所示:
import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
public class MyApplication {
}
逐步取代自动配置
自动配置是非侵入性的。在任何时候,您都可以开始定义自己的配置,以替换自动配置的特定部分。例如,如果您添加自己的DataSourcebean,则默认的嵌入式数据库支持将退出。
如果您需要找出当前正在应用的自动配置以及原因,请使用–debug开关启动您的应用程序。这样做可以启用调试日志以供选择核心记录器,并将条件报告记录到控制台。
lombok使用简化javabean的开发:
第一步,maven中引入lombok
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
第二步:
在编译器中添加插件
这里以IDEA为例,在setting的plugin里搜索lombok plugin,安装插件。
第三步,使用:
package com.fan.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data//set,get和toString等
@AllArgsConstructor
@NoArgsConstructor
public class User {
private String name;
private Integer age;
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
private Pet pet;
}
常用的几个注解:
@Data : 注在类上,提供类的get、set、equals、hashCode、canEqual、toString方法
@AllArgsConstructor : 注在类上,提供类的全参构造
@NoArgsConstructor : 注在类上,提供类的无参构造
@Setter : 注在属性上,提供 set 方法
@Getter : 注在属性上,提供 get 方法
@EqualsAndHashCode : 注在类上,提供对应的 equals 和 hashCode 方法
@Log4j/@Slf4j : 注在类上,提供对应的 Logger 对象,变量名为 log
lombok的日志打印功能:
lombok.extern.slf4j.Slf4j;
springboot的热更新dev-tools:
第一步:maven中引入依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
然后ctrl+F9就可以快速启动;
具体参考:
https://blog.csdn.net/u012190514/article/details/79951258
快速创建一个springboot项目:springboot的初始化向导
选择初始的依赖坐标jar:
然后我们发现我们的依赖主要是这样的:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
创建一个HelloController让我们的springboot跑起来:
代码如下:
package com.fan.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class HelloController {
@ResponseBody//让此映射方法,返回一个json字符串给前端页面
@RequestMapping("/hello")//映射的路径
public String hello(){
return "hello,springbootxxx";
}
}
运行主程序类:
浏览器测试: