Spring Boot基础

最新推荐文章于 2024-07-15 18:50:55 发布

Will_Fighting

最新推荐文章于 2024-07-15 18:50:55 发布

阅读量73

点赞数

分类专栏： SpringBoot学习笔记文章标签： spring boot spring java

本文链接：https://blog.csdn.net/weixin_43938497/article/details/129974363

版权

SpringBoot学习笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Spring Boot基础

Spring Boot的基本概念和原理

Spring Boot是一款基于Spring Framework的开源框架，它致力于简化Spring应用的创建和开发过程。它采用“约定大于配置”的理念，提供了大量的默认配置和快速启动方式，使得开发者可以更加专注于业务逻辑的实现，而不必花费太多时间和精力在框架的配置和集成上。

下面将从以下几个方面介绍Spring Boot的基本概念和原理。

1.自动配置

Spring Boot采用了自动配置的机制，可以根据依赖和类路径中的内容自动推断和配置应用程序的行为。例如，如果项目中包含了Spring Data JPA的依赖，Spring Boot会自动配置一个EntityManagerFactory bean。如果项目中包含了Thymeleaf的依赖，Spring Boot会自动配置一个Thymeleaf的视图解析器。

在Spring Boot中，自动配置通过@EnableAutoConfiguration注解来实现。当一个类标记有这个注解时，Spring Boot会自动搜索并加载符合条件的配置类，并将它们的配置应用到当前的Spring ApplicationContext中。

例如，下面的代码演示了如何使用@EnableAutoConfiguration注解来开启自动配置。

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

在这个例子中，@SpringBootApplication注解是一个组合注解，包含了@EnableAutoConfiguration和其他常用的注解，例如@ComponentScan和@Configuration。

2.起步依赖

Spring Boot提供了大量的“起步依赖”，可以帮助开发者快速构建各种类型的应用程序。这些起步依赖可以通过Maven或Gradle等构建工具来引入，并自动管理依赖的版本和冲突。

例如，如果要开发一个Web应用程序，可以使用spring-boot-starter-web起步依赖。这个起步依赖会自动引入Spring MVC、Tomcat、Jackson等必要的依赖，使得开发者可以直接开始编写控制器和视图而不必手动配置和集成这些组件。

下面是一个使用spring-boot-starter-web起步依赖的例子。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

起步依赖的实现原理是通过定义一组依赖关系，然后使用Maven或者Gradle的依赖解析机制，自动下载和管理依赖关系。在应用程序的pom.xml或者build.gradle文件中，只需要声明起步依赖的坐标，就可以自动管理相关依赖。

3.Spring Boot Starter Parent

Spring Boot提供了一个Parent POM（Project Object Model），叫做spring-boot-starter-parent，它定义了一些常用的配置和依赖，可以帮助开发者更加方便地创建Spring Boot项目。

例如，spring-boot-starter-parent中定义了Spring Boot的版本号、Java版本、编码规范等信息，可以在子项目中继承这个Parent POM来获得这些默认的配置和依赖管理。这样做可以减少开发者的配置工作，提高开发效率。

下面是一个使用spring-boot-starter-parent的例子。

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

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

4.Spring Boot Actuator

Spring Boot Actuator是一个管理和监控Spring Boot应用程序的扩展库。它提供了许多内置的监控和管理功能，例如健康检查、性能指标、日志查看、线程Dump等。

要使用Spring Boot Actuator，只需要在应用程序的pom.xml文件中添加spring-boot-starter-actuator起步依赖即可。默认情况下，Spring Boot Actuator的API是开放的，可以通过HTTP端点来访问。如果需要控制访问权限，可以配置security相关的参数。

下面是一个使用spring-boot-starter-actuator起步依赖的例子。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

5.Spring Boot Test

Spring Boot Test是一个用于测试Spring Boot应用程序的扩展库。它提供了许多测试工具和注解，例如@SpringBootTest、@WebMvcTest、@DataJpaTest等。

@SpringBootTest注解用于加载完整的应用程序上下文，可以用于测试整个应用程序的集成情况。@WebMvcTest注解用于加载Web层的上下文，可以用于测试控制器和视图的行为。@DataJpaTest注解用于加载JPA层的上下文，可以用于测试数据访问对象的行为。

下面是一个使用@SpringBootTest注解的例子。

@SpringBootTest
class MyApplicationTests {

    @Test
    void contextLoads() {
    }

}

Spring框架的核心概念

Spring框架是一款优秀的Java开发框架，它的核心是IoC容器和AOP。下面，我将会对Spring框架的核心概念进行深入的讲解，并给出相应的代码示例。

1.IoC容器

IoC（Inversion of Control，控制反转）是Spring框架的核心，也是Spring框架的最大特点。在传统的编程模型中，对象的创建和管理是由程序员自己完成的，而在IoC模式下，对象的创建和管理是由框架来完成的。框架通过读取配置文件或注解等方式，自动创建对象，并注入依赖关系。

在Spring框架中，IoC容器负责管理和创建对象。Spring提供了两种IoC容器：BeanFactory和ApplicationContext。其中ApplicationContext是BeanFactory的子接口，提供了更多的功能，比如AOP、事件驱动等。

在下面的代码示例中，我们演示了如何通过ApplicationContext来创建一个对象。

@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }

    @Bean
    public UserController userController(UserService userService) {
        return new UserController(userService);
    }
}

public class UserController {

    private UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }
}

public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    UserController userController = context.getBean(UserController.class);
}

上面的代码中，我们使用@Configuration注解定义了一个配置类，其中定义了两个Bean：UserService和UserController。在UserController的构造函数中，我们使用了@Autowired注解注入了UserService。在main函数中，我们使用AnnotationConfigApplicationContext来创建一个ApplicationContext对象，并通过getBean方法获取了UserController对象。

2.AOP

AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架的另一个重要特点。AOP可以将一些通用的业务逻辑（比如事务管理、日志记录等）与具体的业务逻辑分离开来，从而提高代码的可重用性和可维护性。

在Spring框架中，AOP的实现依赖于动态代理技术和注解。通过注解，我们可以定义切点和切面，从而实现具体的业务逻辑和通用的业务逻辑的分离。

下面是一个简单的AOP示例，我们定义了一个日志切面，用于记录方法的执行时间和返回值。

@Aspect
@Component
public class LogAspect {

    @Around("execution(* com.exampl.service.*.*(..))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = point.proceed();
        long endTime = System.currentTimeMillis();
        System.out.println("method " + point.getSignature().getName() + " cost " + (endTime - startTime) + "ms, result " + result); 
        return result; 
    } 
}

@Service 
public class UserServiceImpl implements UserService {
    @Override
    public User getUserById(Long id) {
        // ...
    }    
}

上面的代码中，我们使用@Aspect注解定义了一个切面，使用@Around注解定义了一个环绕通知，该通知会拦截com.example.service包下所有的方法。在通知中，我们记录了方法的执行时间和返回值，并打印了出来。在UserServiceImp中的getUserById方法中，我们没有添加任何的日志相关的代码，但是在运行时，该方法的执行时间和返回值仍然会被记录和打印出来。

3.Spring MVC

Spring MVC是基于Spring框架的Web框架，它可以帮助我们快速地开发出RESTful风格的Web应用。Spring MVC提供了控制器、模型、视图等组件，使得我们可以将业务逻辑和视图分离开来。

在Spring MVC中，请求首先会被DispatcherServlet拦截，DispatcherServlet会将请求分发给对应的Controller处理。Controller中的业务逻辑可以调用Service层的服务进行处理，并将结果传递给View层进行渲染。最终，DispatcherServlet会将渲染后的结果返回给客户端。

下面是一个简单的Spring MVC示例，我们定义了一个UserController，用于处理用户相关的请求。

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    @ResponseBody
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

@Service
public class UserServiceImpl implements UserService {

    @Override
    public User getUserById(Long id) {
        // ...
    }
}

上面的代码中，我们使用@Controller注解定义了一个控制器，使用@RequestMapping注解定义了请求路径。在getUserById方法中，我们使用@GetMapping和@PathVariable注解定义了请求方法和路径参数。在方法中，我们调用了UserService的getUserById方法来获取用户信息，并使用@ResponseBody注解将返回结果转换为JSON格式返回给客户端。

以上就是我对于Spring框架的核心概念的分享。通过深入理解Spring框架的IoC容器、AOP和Spring MVC等核心概念，我们可以更加高效地使用Spring框架来开发Java应用程序。当然，除了以上三个核心概念，Spring框架还提供了很多其他的功能和特性，比如JDBC、事务管理、安全框架等，感兴趣的读者可以自行深入了解。

希望本文能够对初学者们对于Spring框架的理解有所帮助，同时也能为已经熟悉Spring框架的开发者们提供一些思路和灵感。当然，本文只是对于Spring框架核心概念的简要介绍，如果读者们想要深入了解Spring框架的使用和原理，建议多阅读官方文档和相关书籍，也可以参考Spring官方提供的一系列教程和示例代码。

总结一下几个重点：

Spring框架是一个基于IoC和AOP的Java开发框架，提供了许多组件和特性来简化Java开发。
Spring的IoC容器是Spring框架的核心组件之一，它可以管理Java对象的创建、配置和生命周期，并将这些对象组装成应用程序。
Spring的AOP功能是基于代理模式实现的，它可以将横切关注点与业务逻辑进行解耦，并提供了AspectJ风格的注解和XML配置两种方式。
Spring MVC是基于Spring框架的Web框架，可以帮助我们快速地开发出RESTful风格的Web应用，其中包括控制器、模型、视图等组件。

Bean在Spring Boot中的作用

Bean是Spring Boot中最基本的组件之一，它可以理解为一种Java对象，它的主要作用是在应用程序中管理Java对象的生命周期以及对象之间的依赖关系。在Spring Boot中，我们通过创建Bean来构建应用程序，并在运行时由Spring Boot容器来管理这些Bean。通过这种方式，我们可以轻松地实现应用程序中各个组件之间的解耦，提高代码的可重用性和可维护性。

Spring Boot如何管理Bean

Spring Boot通过自动配置来管理Bean，它使用了一种叫做“依赖注入”的方式，将需要用到的Bean注入到组件中。在Spring Boot中，Bean的创建和管理是由Spring IoC容器负责的。当我们在Spring Boot应用程序中定义一个Bean时，Spring Boot会自动将其注册到IoC容器中，并管理其生命周期。

下面是一个简单的示例代码，演示了如何在Spring Boot中创建Bean：

@Service
public class MyService {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

在上面的代码中，我们创建了一个名为“MyService”的Bean，并使用@Service注解将其标记为一个服务。这样一来，在我们的应用程序中就可以通过@Autowired注解来引用这个服务，并使用它的方法。例如：

@RestController
public class MyController {
    @Autowired
    private MyService myService;

    @GetMapping("/hello")
    public String hello() {
        myService.sayHello();
        return "Hello, World!";
    }
}

在上面的代码中，我们使用@RestController注解定义了一个名为“MyController”的控制器。在控制器中，我们使用@Autowired注解将MyService引入到控制器中，并在控制器中调用它的方法。这样一来，当我们在浏览器中访问“/hello”时，控制器就会调用MyService的sayHello()方法，并将其输出到控制台中。

需要注意的是，Spring Boot使用了自动配置来管理Bean，这意味着在大多数情况下，我们不需要手动注册Bean。当我们需要使用某个Bean时，Spring Boot会自动将其创建并注入到需要的组件中。如果我们需要对Bean进行配置，可以使用@Configuration注解创建一个配置类，并在其中进行Bean的配置。例如：

@Configuration
public class MyConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

在上面的代码中，我们使用@Configuration注解创建了一个名为“MyConfig”的配置类，并使用@Bean注解创建了一个名为“myService”的Bean。在Spring Boot应用程序中，我们可以通过导入这个配置类来使用这个Bean。例如：

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

在上面的代码中，我们使用@SpringBootApplication注解定义了一个Spring Boot应用程序，并通过@Import注解导入了MyConfig配置类，这样一来，我们就可以在应用程序中使用MyService这个Bean了。

除了@Configuration和@Bean注解外，Spring Boot还提供了很多其他的注解，例如@Service、@Repository、@Controller等，这些注解可以帮助我们快速创建和管理Bean。在实际开发中，我们需要根据实际情况选择适合的注解来创建和管理Bean。

总之，Bean是Spring Boot中最基本的组件之一，它的作用是管理Java对象的生命周期和对象之间的依赖关系。Spring Boot通过自动配置和依赖注入来管理Bean，我们可以通过注解来创建和配置Bean，并将其注册到IoC容器中，从而实现应用程序中各个组件之间的解耦。

Will_Fighting

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Boot基础

Spring Boot是一款基于Spring Framework的开源框架，它致力于简化Spring应用的创建和开发过程。它采用“约定大于配置”的理念，提供了大量的默认配置和快速启动方式，使得开发者可以更加专注于业务逻辑的实现，而不必花费太多时间和精力在框架的配置和集成上。下面将从以下几个方面介绍Spring Boot的基本概念和原理。
复制链接

扫一扫