spring boot 移动端接口 spring boot开发接口

转载

网络锐评 2023-08-20 21:50:46

文章标签 spring boot 移动端接口 java spring json 文章分类 spring boot 后端开发

一、创建一个简单的接口，返回json

1、创建相应的包和类

一般我们会分包进行创建，我这里简单创建了一个controller 的包，里面写相关的接口controller
 然后再test包下我创建了一个Application 类，这个名词可以自己起。这个类是运行springboot的入口，需要进行配置下。
 Application 代码如下：

2、Application 类代码讲解

package com.test;

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

@SpringBootApplication
public class Application {

    public static void main(String[] args){
        SpringApplication.run(Application.class,args);
    }
}

@SpringBootApplication 注解：
@SpringBootApplication注解一般放在项目的一个启动类上，用来把启动类注入到容器中，用来定义容器扫描的范围，用来加载classpath环境中一些bean
@SpringBootApplication =@Configuration+@EnableAutoConfiguration+@ComponentScan
springboot 把这几个注解整合了。只需要写一个就可以

然后在main方法中添加SpringApplication.run(Application.class,args); 来启动应用程序

3、TestController类讲解

package com.test.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;

@RestController
public class TestController {
    //测试用的集合
    Map<String,Object> params=new HashMap<>();

    /**
     * 第一个接口测试
     * @param name
     * @return
     */
    @RequestMapping("/test")
    public Object getTest(String name){
        params.clear();
        params.put("name",name);
        return  params;
    }
}

这里用到了两个注解，@RestController、 @RequestMapping
@RestController and @RequestMapping是springMVC的注解，不是springboot特有的
(1) @RestController
@RestController 是spring4 新加入的注解，相当于**@Controller +@ResponseBody** 两个注解的功能和
@Controller的作用表示该类是一个控制器，可以接受用户的输入并调用模型和视图去完成用户的需求。控制器本身不输出也不处理任何东西。我们写的接口也就是控制器里面的方法。
@ResponseBody 表示请求以json映射的方式返回。
所以@RestController注解的类就可以接受请求——返回json
(2) @RequestMapping
这个注解可以加载类和方法上，我理解是表示资源的映射吧，为web请求指明路径。可以定义不同的映射规则
注解在方法上表示当前方法时一个web请求的处理方法，注解在类上，应该是常用的请求地址或路由啥的

上面方法中在@RequestMapping("/test") 方法中的"/test" 就是外部访问的接口地址，暂时我们没有指定请求方法

这样外部就能通过 http://localhost:8080/test?name=张三来进行调用这个接口。

spring boot 移动端接口 spring boot开发接口_json

二、 get、post请求实战

1，get请求实战

package com.test.controller;
import com.test.domain.User;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
@RestController
public class GetController {

    Map<String, Object> params = new HashMap<>();

    /**
     * 从路径中取值
     *
     * @param cityID
     * @param userID
     * @return
     */
    @RequestMapping(path = "/{city_id}/{user_id}")
    public Object getUserID(@PathVariable("city_id") String cityID,
                            @PathVariable("user_id") String userID) {

        params.clear();
        params.put("cityID", cityID);
        params.put("userID", userID);
        return params;
    }

    /**
     * 测试@GetMapping注解，以get方式请求接口
     * @param id
     * @param name
     * @return
     */
    @GetMapping(value = "/v1/getUser")
    public Object getMappingTest(String id, String name) {

        params.clear();
        params.put("name", name);
        params.put("id", id);
        return params;
    }

    /**
     * 测试，设置参数默认值，别名、以及是否必传参数
     * @param id
     * @param username
     * @return
     */
    @RequestMapping("/v1/getUser1")
    public Object getMyappingTest1(@RequestParam(defaultValue = "888",name = "uid") String id, @RequestParam(required = true) String username){
        params.clear();
        params.put("username", username);
        params.put("id", id);
        return params;
    }
    /**
     * 功能描述：bean对象传参
     * 注意：1、注意需要指定http头为 content-type为application/json
     * 		2、使用body传输数据
     * @param user
     * @return
     */
    @RequestMapping("/v1/save_user")
    public Object saveUser(@RequestBody User user){
        params.clear();
        params.put("user", user);
        return params;
    }

    /**
     * 功能描述：测试获取http头信息
     * @param accessToken
     * @param id
     * @return
     */
    @GetMapping("/v1/get_header")
    public Object getHeader(@RequestHeader("access_token") String accessToken, String id){
        params.clear();
        params.put("access_token", accessToken);
        params.put("id", id);
        return params;
    }

    /**
     * 以HttpServletRequest获取所有请求数据
     * @param request
     * @return
     */
    @GetMapping("/v1/test_request")
    public Object testRequest(HttpServletRequest request){
        
        params.clear();
        String id = request.getParameter("id");
        params.put("id",id);
        return params;
    }
    @PostMapping("/v1/login")
    public Object login(@RequestParam(required = true) String  userName, @RequestParam(required = true)String passWrod){
        params.clear();
        params.put("name",userName);
        params.put("pwd",passWrod);
        return params;
    }
    @PostMapping("/v1/class")
    public Object loginTest(User user){
        params.clear();
        params.put("name",user.getName);
        params.put("pwd",user.getPassword);
        return params;
    }

    @PutMapping("/v1/put")
    public Object put(String id){
        params.clear();
        params.put("id", id);
        return params;
    }


    @DeleteMapping("/v1/del")
    public Object del(String id){
        params.clear();
        params.put("id", id);
        return params;
    }
}

注解简介：		1、单一参数@RequestMapping(path = "/{id}", method = RequestMethod.GET)
				1) public String getUser(@PathVariable String id ) {}
				
				2）@RequestMapping(path = "/{depid}/{userid}", method = RequestMethod.GET) 可以同时指定多个提交方法
				getUser(@PathVariable("depid") String departmentID,@PathVariable("userid") String userid)

				3）get、post、put、delete四种注解的封装
				@GetMapping = @RequestMapping(method = RequestMethod.GET)
				@PostMapping = @RequestMapping(method = RequestMethod.POST)
				@PutMapping = @RequestMapping(method = RequestMethod.PUT)
				@DeleteMapping = @RequestMapping(method = RequestMethod.DELETE)

				4）@RequestParam(value = "name", required = true)
					可以设置默认值，可以设置别名name=""，可以设置是否必传 requeid=true或false

				4)@RequestBody 请求体映射实体类,以json映射javaBean
					需要指定http头为 content-type为application/json charset=utf-8

				5）@RequestHeader 请求头，比如鉴权,可以获取请求头
					@RequestHeader("access_token") String accessToken

				6）HttpServletRequest request自动注入获取参数，可以拿到任何请求数据

2，@RequestParam和@PathVariable的用法与区别

详细区别
@RequestParam和@PathVariable
相同点与区别

@RequestParam和@PathVariable都能够完成类似的功能——因为本质上，它们都是用户的输入，只不过输入的部分不同，一个在URL路径部分，另一个在参数部分。要访问一篇博客文章，这两种URL设计都是可以的：
通过@PathVariable，例如/blogs/1
通过@RequestParam，例如blogs?blogId=1
那么究竟应该选择哪一种呢？建议：

1、当URL指向的是某一具体业务资源（或资源列表），例如博客，用户时，使用@PathVariable

2、当URL需要对资源或者资源列表进行过滤，筛选时，用@RequestParam

例如我们会这样设计URL：

/blogs/{blogId}
/blogs?state=publish而不是/blogs/state/publish来表示处于发布状态的博客文章
更多用法

一旦我们在方法中定义了@RequestParam变量，如果访问的URL中不带有相应的参数，就会抛出异常——这是显然的，Spring尝试帮我们进行绑定，然而没有成功。但有的时候，参数确实不一定永远都存在，这时我们可以通过定义required属性：

@RequestParam(value = “id”, required = false)
当然，在参数不存在的情况下，可能希望变量有一个默认值：

@RequestParam(value = “id”, required = false, defaultValue = “0”)

三，常用注解

@Data，

@Data : 注解在类上, 为类提供读写属性, 此外还提供了 equals()、hashCode()、toString() 方法
@Data

public class ActivityListParam{

private Integer id;

private Integer page;

private Integer count;

...

}

以往我的做法，还会通过快捷方法生成Getter,Setter,equals,hashCode,toString方法。但这个类里只声明了变量，没有各种方法，而在类名上加@Data注解，导入依赖：lombok.Data。在另一个类中导入该入参类后，通过activityListParam.是可以点出没有写的Get,Set等方法。因此，我理解为：@Data注解在类上时，简化java代码编写，为该类提供读写属性，还提供了equals(),hashCode(),toString()方法
   @Getter/@Setter : 注解在类上, 为类提供读写属性

@Configuration和@Bean

注意：@Configuration注解的配置类有如下要求：

@Configuration不可以是final类型；
@Configuration不可以是匿名类；
嵌套的configuration必须是静态类。
@Configuration 和 @Bean 注解
带有 @Configuration 的注解类表示这个类可以使用 Spring IoC 容器作为 bean 定义的来源。@Bean 注解告诉 Spring，一个带有 @Bean 的注解方法将返回一个对象，该对象应该被注册为在 Spring 应用程序上下文中的 bean。

例子如下：
HelloWorld.java

package com.how2java.w3cschool.baseonjava;

public class HelloWorld {
    private String message;

    public void getMessage() {
        System.out.println("Your message is:" + message);
    }

    public void setMessage(String message) {
        this.message = message;
    }

}

HelloWorldConfig.java

package com.how2java.w3cschool.baseonjava;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/*
 * 带有 @Configuration 的注解类表示这个类可以使用 Spring IoC 容器作为 bean 定义的来源。
 * @Bean 注解告诉 Spring，一个带有 @Bean 的注解方法将返回一个对象，该对象应该被注册为在 Spring 应用程序上下文中的 bean。
 */
@Configuration
public class HelloWorldConfig {
    // 带有 @Bean 注解的方法名称作为 bean 的 ID，它创建并返回实际的 bean。也就是此时的bean
    // id为helloWorld，你的配置类可以声明多个 @Bean。
    // 一旦定义了配置类，你就可以使用 AnnotationConfigApplicationContext 来加载并把他们提供给 Spring 容器
    @Bean
    public HelloWorld helloWorld() {
        return new HelloWorld();
    }
}

MainApp.java

package com.how2java.w3cschool.baseonjava;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);

        HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
        helloWorld.setMessage("Hello World!");
        helloWorld.getMessage();
    }

}

如果在HelloWorldConfig.java中忘了@Bean的注解，将会遇到以下的错误
“No unique bean of type [com.how2java.w3cschool.baseonjava.HelloWorld] is defined: expected single bean but found 0: ”

@Configuration和@Bean，@ComponentScan和@Component四个之间的关联

从Spring3.0，@Configuration用于定义配置类，可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

@Configuation等价于
@Bean 等价于
@ComponentScan等价于<context:component-scan base-package=“com.dxz.demo”/>
@Component 等价于

前言
@Configuration 用于定义配置类，可替换XML配置文件，被注解的类内部包含一个或多个@Bean注解方法。可以被AnnotationConfigApplicationContext或者AnnotationConfigWebApplicationContext 进行扫描。用于构建bean定义以及初始化Spring容器。

实例
@Configuration 加载Spring方法
Car.java

public class Car {
    private String name;

    public String getName() {
        return name;
    }

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

}

定义Config类

@Configuration
public class Config {
    public Config() {
        System.out.println("TestConfig容器初始化...");
    }

    @Bean(name = "getMyCar")
    public Car getCar() {
        Car c = new Car();
        c.setName("dankun");
        return c;
    }
}

实例化

public void testConfig() {
        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        Car car = (Car)context.getBean("car");
        System.out.println(car.getName());
    }
// 输出
// TestConfig容器初始化...
// dankun

@Configuration + @Component

@Configuration也附带了@Component的功能。所以理论上也可以使用@Autowared功能。上述代码可以改成下面形式
Car.java

@Component
public class Car {
    @Value("dankun")
    private String name;

    public String getName() {
        return name;
    }

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

}

Config.java

@Configuration
@ComponentScan("com.wuyue.annotation")
public class Config {
    public Config() {
        System.out.println("TestConfig容器初始化...");
    }

测试主入口

public class TestConfig {
    @Test
    public void testConfig() {
        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
        Car car = (Car)context.getBean("car");
        System.out.println(car.getName());
    }
}
// 输出
// TestConfig容器初始化...
// dankun

总结
@Configuation等价于
@Bean 等价于
@ComponentScan等价于<context:component-scan base-package=“com.dxz.demo”/>
@Component 等价于
@Bean VS @Component
两个注解的结果是相同的，bean都会被添加到Spring上下文中。
@Component 标注的是类,允许通过自动扫描发现。@Bean需要在配置类@Configuation中使用。
@Component类使用的方法或字段时不会使用CGLIB增强。而在@Configuration类中使用方法或字段时则使用CGLIB创造协作对象
假设我们需要将一些第三方的库组件装配到应用中或者我们有一个在多个应用程序中共享的模块，它包含一些服务。并非所有应用都需要它们。

如果在这些服务类上使用@Component并在应用程序中使用组件扫描，我们最终可能会检测到超过必要的bean。导致应用程序无法启动
但是我们可以使用 @Bean来加载

因此，基本上，使用@Bean将第三方类添加到上下文中。和@Component，如果它只在你的单个应用程序中

@EnableSwagger2，

@Api：用在请求的类上，表示对类的说明
tags=“说明该类的作用，可以在UI界面上看到的注解”
value=“该参数没什么意义，在UI界面上也看到，所以不需要配置”

@ApiOperation：用在请求的方法上，说明方法的用途、作用
value=“说明方法的用途、作用”
notes=“方法的备注说明”

@Controller、@RestController注解区别

@Controller
方法的返回值。默认是跳转路径。
如果想返回json对象，必须在方法的上面加@ResponseBody
@RestController
方法返回值，默认是json对象，也就是相当于@Controller里面的方法上添加了@ResponseBody如果方法返回值，需要跳转，那么方法的返回类型必须是View 或者ModelAndView.
一，@Controller
只是定义了一个控制器类，而使用 @RequestMapping 注解的方法才是处理请求的处理器。

@Controller
public class HospitalController {
 //注入Service服务对象
 @Autowired
 private HospitalService hospitalService;
 
 
 @RequestMapping(method = RequestMethod.POST, value = "/findAllHospital")
 @ResponseBody
 public Map findAllHospital(final HttpServletRequest request ,
 @RequestBody Map parmMap , HttpServletResponse response){
  
  Map map=parmMap ;//@RequestBody注解原因,系统会自动把request数据变成parmMap 
  ........
  ........
  return map;
   
 } 
  
 }

用@Controller定义一个控制器类，
用@RequestMapping给出外界访问方法的路径，或者说触发路径，触发条件。
用@ResponseBody标记Controller类中的方法。把return的结果变成JSON对象返回。（如果没有这个注解，这个方法只能返回要跳转的路径即跳转的html/JSP页面。有这个注解，可以不跳转页面，只返回JSON数据）
二、@RestController注解
@RestController 也是Spring框架提供的注解。（Spring4.0之后新增的）
@RestController 注解相当于 @Controller ＋ @ResponseBody 合在一起的作用。

Controller类中的方法返回值，默认是json对象，也就是相当于@Controller里面的方法上添加了@ResponseBody
如果方法返回值，需要跳转，那么方法的返回类型必须是View 或者ModelAndView.

@RestController
public class HospitalController {
 //注入Service服务对象
 @Autowired
 private HospitalService hospitalService;
 
 
 @RequestMapping(method = RequestMethod.POST, value = "/findAllHospital")
 //方法上面可以不需要@ResponseBody注解，因为类上面用的是@RestController注解
 public Map findAllHospital(final HttpServletRequest request ,
 @RequestBody Map parmMap , HttpServletResponse response){
  
  Map map=parmMap ;//@RequestBody注解原因,系统会自动把request数据变成parmMap 
  ........
  ........
  return map;
   
 } 
  
 }

swagger2的使用 @Api，@ApiOperation等

最常用的5个注解
@Api：修饰整个类，描述Controller的作用
@ApiOperation：描述一个类的一个方法，或者说一个接口
@ApiParam：单个参数描述
@ApiModel：用对象来接收参数
@ApiProperty：用对象接收参数时，描述对象的一个字段

其它若干
@ApiResponse：HTTP响应其中1个描述
@ApiResponses：HTTP响应整体描述
@ApiClass
@ApiError
@ApiErrors
@ApiParamImplicit
@ApiParamsImplicit
4.1、@Api修饰整个类，描述Controller的作用

4.2、@ApiOperation

用于描述一个方法或者接口

可以添加的参数形式：@ApiOperation(value = “接口说明”, httpMethod = “接口请求方式”, response = “接口返回参数类型”, notes = “接口发布说明”）

4.3、@ApiParam单个参数描述

@ApiParam(required = “是否必须参数”, name = “参数名称”, value = “参数具体描述”,dateType="变量类型”,paramType="请求方式”）

4.4、@ApiImplicitParam 一个请求参数

@ApiImplicitParam(required = “是否必须参数”, name = “参数名称”, value = “参数具体描述”,dateType="变量类型”,paramType="请求方式”）

@ApiOperation(value = "根据用户名获取用户的信息",notes = "查询数据库中的记录",httpMethod = "POST",response = String.class)
@ApiImplicitParam(name = "userName",value = "用户名",required = true,dataType = "String",paramType = "query")

4.5、@ApiImplicitParams 多个请求参数

参数和@ApiImplicitParam一致，只是这个注解可以添加多个参数而已

@ApiImplicitParams({
            @ApiImplicitParam(name = "nickName",value = "用户的昵称",paramType = "query",dataType = "String",required = true),
            @ApiImplicitParam(name = "id",value = "用户的ID",paramType = "query",dataType = "Integer",required = true)
    })
    public String getUserInfoByNickName(String nickName, Integer id) {
        return "1234";
    }

其余的都类似。

整个controller的代码如下

@RestController
@RequestMapping("/swagger")
@Api(value = "swagger2的demo例子")
public class SwaggerController {
    @RequestMapping("/swagger")
    @ResponseBody
    @ApiOperation(value = "根据用户名获取用户的信息",notes = "查询数据库中的记录",httpMethod = "POST",response = String.class)
    @ApiImplicitParam(name = "userName",value = "用户名",required = true,dataType = "String",paramType = "query")
    public String getUserInfo(String userName) {
        return "1234";
    }
    @RequestMapping(value = "/getuserinfobynickname",method = {RequestMethod.GET,RequestMethod.POST})
    @ResponseBody
    @ApiOperation(value = "根据用户昵称获取用户信息",notes = "查询数据库中的记录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "nickName",value = "用户的昵称",paramType = "query",dataType = "String",required = true),
            @ApiImplicitParam(name = "id",value = "用户的ID",paramType = "query",dataType = "Integer",required = true)
    })
    public String getUserInfoByNickName(String nickName, Integer id) {
        return "1234";
    }
    @RequestMapping(value = "/getuserinfobyid",method = {RequestMethod.GET,RequestMethod.POST})
    @ResponseBody
    @ApiOperation(value = "根据用户id获取用户信息",notes = "查询数据库中的记录",httpMethod = "POST")
    public String getUserInfoById(@ApiParam(name = "nickName",value = "用户的昵称",required = true,defaultValue = "123-默认值")
                                          String nickName,@ApiParam(name = "id",value = "用户ID",required = true) Integer id) {
        return "1234";
    }
    @RequestMapping(value = "/userregister",method = {RequestMethod.GET,RequestMethod.POST})
    @ResponseBody
    @ApiOperation(value = "register",notes = "注册的实体类")
    public Register userRegister(Register register) {
        return register;
    }
}

对应的实体说明

@ApiModel(value = "用户注册的实体")
public class Register {
    @ApiModelProperty(name = "userName",notes = "用户名",dataType = "String",required = true)
    private String userName;

    @ApiModelProperty(name = "nickName",notes = "用户昵称",dataType = "String",required = true)
    private String nickName;

    @ApiModelProperty(name = "age",notes = "用户年龄",dataType = "int",required = true)
    private int age;
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Register{" +
                "userName='" + userName + '\'' +
                ", nickName='" + nickName + '\'' +
                ", age=" + age +
                '}';
    }
}

@EnableAutoConfiguration，

@EnableAutoConfiguration：能够自动配置spring的上下文，试图猜测和配置你想要的bean类，通常会自动根据你的类路径和你的bean定义自动配置

@ResponseBody，

1 @Controller
 2 @RequestMapping("/")
 3 public class HelloController {
 4    @RequestMapping(value = "/helloWorld", method = RequestMethod.GET)
 5    @ResponseBody
 6    public String helloWorld()  {
 7       return"Hello World";
 8    }
 9  }
10 
11 运行以上代码，在浏览器地址栏输入： http://localhost:8080/helloWorld
12 运行结果，页面上输出  Hello World 

如果不加@responseBody注解，运行结果会怎样？

spring boot 移动端接口 spring boot开发接口_spring boot 移动端接口_02

结果表明：如果在一个方法上使用了@RequestMapping注解，这时候，方法的返回值通常解析为跳转的路径， 也就是说，要跳转到指定的jsp页面。在这个代码实例中，要跳转到的是 Hello World.jsp 页面。 因为工程中尚未添加这个jsp文件，所以报出了 404 错误 （The requested resource is not available）。 
如果添加了 @ResponseBody 这个注解， 则表明该方法的返回值直接写入到 HTTP Response Body 中。  这就是说，如果返回的是JSON， 就得必须添加 @ResponseBody 这个注解
一般在异步获取数据时使用，在使用@RequestMapping后，返回值通常解析为跳转路径，加上@responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。比如异步获取json数据，加上@responsebody后，会直接返回json数据。

@SpringBootApplication，

之前用户使用的是3个注解注解他们的main类。分别是@Configuration,@EnableAutoConfiguration,@ComponentScan。由于这些注解一般都是一起使用，spring boot提供了一个统一的注解@SpringBootApplication。

@SpringBootApplication = (默认属性)@Configuration + @EnableAutoConfiguration + @ComponentScan。

@SpringBootApplication 
public class ApplicationMain { 
    public static void main(String[] args) { 
        SpringApplication.run(Application.class, args); 
    } 
}

分开解释@Configuration,@EnableAutoConfiguration,@ComponentScan。

1、@Configuration：提到@Configuration就要提到他的搭档@Bean。使用这两个注解就可以创建一个简单的spring配置类，可以用来替代相应的xml配置文件。

<beans> 
    <bean id = "car" class="com.test.Car"> 
        <property name="wheel" ref = "wheel"></property> 
    </bean> 
    <bean id = "wheel" class="com.test.Wheel"></bean>

相当于：

@Configuration 
public class Conf { 
    @Bean 
    public Car car() { 
        Car car = new Car(); 
        car.setWheel(wheel()); 
        return car; 
    } 
    @Bean  
    public Wheel wheel() { 
        return new Wheel(); 
    } 
}

@Configuration的注解类标识这个类可以使用Spring IoC容器作为bean定义的来源。@Bean注解告诉Spring，一个带有@Bean的注解方法将返回一个对象，该对象应该被注册为在Spring应用程序上下文中的bean。

2、@EnableAutoConfiguration：能够自动配置spring的上下文，试图猜测和配置你想要的bean类，通常会自动根据你的类路径和你的bean定义自动配置。

3、@ComponentScan：会自动扫描指定包下的全部标有@Component的类，并注册成bean，当然包括@Component下的子注解@Service,@Repository,@Controller。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。