选择题springboot_为什么选择SpringBoot？

最新推荐文章于 2024-06-12 10:40:37 发布

cunhu4317

最新推荐文章于 2024-06-12 10:40:37 发布

阅读量214

点赞数

文章标签：数据库 spring java mysql spring boot

原文链接：https://www.javacodegeeks.com/2016/03/why-springboot.html

版权

选择题springboot

使用Spring MSpring进行许可是一种非常流行的基于Java的框架，用于构建Web和企业应用程序。与许多其他只关注一个领域的框架不同，Spring框架通过其投资组合项目提供了广泛的功能来满足现代业务需求。

Spring框架提供了以多种方式(例如XML ， Annotations和JavaConfig)配置bean的灵活性。随着功能数量的增加，复杂性也随之增加，配置Spring应用程序变得繁琐且容易出错。

Spring团队创建了SpringBoot来解决配置的复杂性。但是在深入探讨SpringBoot之前，我们将快速浏览一下Spring框架，并了解SpringBoot试图解决什么样的问题。

在本文中，我们将介绍：

Spring框架概述
使用Spring MVC和JPA(Hibernate)的Web应用程序
快速了解SpringBoot

Spring框架概述

如果您是Java开发人员，那么您很有可能听说过Spring框架，并且很可能已在项目中使用了它。 Spring框架主要是作为一个依赖注入容器创建的，但不仅如此。

春天之所以流行，有几个原因：

Spring的依赖注入方法鼓励编写可测试的代码
易于使用，但功能强大的数据库事务管理功能
Spring简化了与其他Java框架(如JPA / Hibernate ORM，Struts / JSF等Web框架)的集成。
用于构建Web应用程序的最新Web MVC框架

与Spring框架一起，还有许多其他Spring姐妹项目，这些项目有助于构建满足现代业务需求的应用程序：

Spring数据：简化从关系和NoSQL数据存储的数据访问。
Spring Batch：提供强大的批处理框架。
Spring Security：强大的安全框架，可保护应用程序。
Spring Social：支持与Facebook，Twitter，LinkedIn，GitHub等社交网站的集成。
Spring Integration：企业集成模式的实现，以使用轻量级消息传递和声明性适配器促进与其他企业应用程序的集成。

还有许多其他有趣的项目可以满足其他各种现代应用程序开发需求。有关更多信息，请访问http://spring.io/projects 。

最初，Spring框架提供了用于配置bean的基于XML的方法。后来，Spring引入了用于配置bean的基于XML的DSL，注释和基于JavaConfig的方法。

让我们快速看一下每种配置样式的外观。

基于XML的配置

<bean id="userService" class="com.sivalabs.myapp.service.UserService">
    <property name="userDao" ref="userDao"/>
</bean>

<bean id="userDao" class="com.sivalabs.myapp.dao.JdbcUserDao">
    <property name="dataSource" ref="dataSource"/>
</bean>

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="username" value="root"/>
    <property name="password" value="secret"/>
</bean>

基于注释的配置

@Service
public class UserService
{
    private UserDao userDao;

    @Autowired
    public UserService(UserDao dao){
        this.userDao = dao;
    }
    ...
    ...
}

@Repository
public class JdbcUserDao
{
    private DataSource dataSource;

    @Autowired
    public JdbcUserDao(DataSource dataSource){
        this.dataSource = dataSource;
    }
    ...
    ...
}

基于JavaConfig的配置

@Configuration
public class AppConfig
{
    @Bean
    public UserService userService(UserDao dao){
        return new UserService(dao);
    }

    @Bean
    public UserDao userDao(DataSource dataSource){
        return new JdbcUserDao(dataSource);
    }

    @Bean
    public DataSource dataSource(){
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("secret");
        return dataSource;
    }
}

哇... Spring提供了许多用于完成同一任务的方法，我们甚至可以混合使用这些方法，就像可以在同一应用程序中同时使用基于JavaConfig和基于注释的配置样式一样。

这是很大的灵活性，它是一种好方法和一种坏方法。刚接触Spring框架的人可能会感到困惑关于采用哪种方法。到目前为止，Spring团队建议遵循基于JavaConfig的方法，因为它可以提供更大的灵活性。

但是，没有一种千篇一律的解决方案。必须根据自己的应用程序需求选择方法。

好的，现在您已经大致了解了各种样式的Spring bean配置。

让我们快速看一下典型的SpringMVC + JPA / Hibernate Web应用程序配置的配置。

使用Spring MVC和JPA(Hibernate)的Web应用程序

在了解什么是SpringBoot以及它提供了什么样的功能之前，让我们看一下典型的Spring Web应用程序配置的外观，痛点是什么，然后我们将讨论SpringBoot如何解决这些问题。

步骤1：配置Maven依赖项

我们需要做的第一件事是配置pom.xml中所需的所有依赖项。

<?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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sivalabs</groupId>
    <artifactId>springmvc-jpa-demo</artifactId>
    <packaging>war</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>springmvc-jpa-demo</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>      
        <failOnMissingWebXml>false</failOnMissingWebXml>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.7.13</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.13</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.13</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>1.4.190</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.11.Final</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring4</artifactId>
            <version>2.1.4.RELEASE</version>
        </dependency>
    </dependencies>
</project>

我们已经将所有Maven jar依赖项配置为包括Spring MVC，Spring Data JPA，JPA / Hibernate，Thymeleaf和Log4j。

步骤2：使用JavaConfig配置服务/ DAO层bean。

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages="com.sivalabs.demo")
@PropertySource(value = { "classpath:application.properties" })
public class AppConfig 
{
    @Autowired
    private Environment env;

    @Bean
    public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer()
    {
        return new PropertySourcesPlaceholderConfigurer();
    }
    
    @Value("${init-db:false}")
    private String initDatabase;
    
    @Bean
    public PlatformTransactionManager transactionManager()
    {
        EntityManagerFactory factory = entityManagerFactory().getObject();
        return new JpaTransactionManager(factory);
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory()
    {
        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();

        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(Boolean.TRUE);
        vendorAdapter.setShowSql(Boolean.TRUE);

        factory.setDataSource(dataSource());
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setPackagesToScan("com.sivalabs.demo");

        Properties jpaProperties = new Properties();
        jpaProperties.put("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
        factory.setJpaProperties(jpaProperties);

        factory.afterPropertiesSet();
        factory.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
        return factory;
    }

    @Bean
    public HibernateExceptionTranslator hibernateExceptionTranslator()
    {
        return new HibernateExceptionTranslator();
    }
    
    @Bean
    public DataSource dataSource()
    {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
        dataSource.setUrl(env.getProperty("jdbc.url"));
        dataSource.setUsername(env.getProperty("jdbc.username"));
        dataSource.setPassword(env.getProperty("jdbc.password"));
        return dataSource;
    }
    
    @Bean
    public DataSourceInitializer dataSourceInitializer(DataSource dataSource) 
    {
        DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
        dataSourceInitializer.setDataSource(dataSource);
        ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
        databasePopulator.addScript(new ClassPathResource("data.sql"));
        dataSourceInitializer.setDatabasePopulator(databasePopulator);
        dataSourceInitializer.setEnabled(Boolean.parseBoolean(initDatabase));
        return dataSourceInitializer;
    }   
}

在AppConfig.java配置类中，我们执行了以下操作：

使用@Configuration批注将其标记为Spring Configuration类。
使用@EnableTransactionManagement启用基于注释的事务管理
已配置@EnableJpaRepositories以指示在何处查找Spring Data JPA存储库
使用@PropertySource批注和PropertySourcesPlaceholderConfigurer Bean定义配置的PropertyPlaceHolder Bean，该定义从application.properties文件加载属性。
为DataSource ，JPA EntityManagerFactory ， JpaTransactionManager定义的bean。
配置的DataSourceInitializer bean通过在应用程序启动时执行data.sql脚本来初始化数据库。

我们需要在application.properties中配置属性占位符值，如下所示：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=admin
init-db=true
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=update

我们可以创建一个简单的sql脚本data.sql，以将示例数据填充到USER表中。

delete from user;
insert into user(id, name) values(1,'Siva');
insert into user(id, name) values(2,'Prasad');
insert into user(id, name) values(3,'Reddy');

我们可以使用以下基本配置创建log4j.properties文件：

log4j.rootCategory=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %t %c{2}:%L - %m%n

log4j.category.org.springframework=INFO
log4j.category.com.sivalabs=DEBUG

步骤3：配置Spring MVC Web层bean

我们将必须为i18n配置Thymeleaf ViewResolver ，静态ResourceHandlers ， MessageSource等。

@Configuration
@ComponentScan(basePackages = { "com.sivalabs.demo"}) 
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter
{
    @Bean
    public TemplateResolver templateResolver() {
        TemplateResolver templateResolver = new ServletContextTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/views/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode("HTML5");
        templateResolver.setCacheable(false);
        return templateResolver;
    }

    @Bean
    public SpringTemplateEngine templateEngine() {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver());
        return templateEngine;
    }

    @Bean
    public ThymeleafViewResolver viewResolver() {
        ThymeleafViewResolver thymeleafViewResolver = new ThymeleafViewResolver();
        thymeleafViewResolver.setTemplateEngine(templateEngine());
        thymeleafViewResolver.setCharacterEncoding("UTF-8");
        return thymeleafViewResolver;
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry)
    {
        registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer)
    {
        configurer.enable();
    }

    @Bean(name = "messageSource")
    public MessageSource configureMessageSource()
    {
        ReloadableResourceBundleMessageSource messageSource = new ReloadableResourceBundleMessageSource();
        messageSource.setBasename("classpath:messages");
        messageSource.setCacheSeconds(5);
        messageSource.setDefaultEncoding("UTF-8");
        return messageSource;
    }
}

在我们的WebMvcConfig.java配置类中，我们执行了以下操作：

使用@Configuration批注将其标记为Spring Configuration类。
使用@EnableWebMvc启用基于注释的Spring MVC配置
通过注册TemplateResolver ， SpringTemplateEngine ， ThymeleafViewResolver Bean来配置Thymeleaf ViewResolver。
已注册的ResourceHandlers Bean将指示从/ resources /目录提供对URI / resources / **的静态资源的请求。
已配置的MessageSource bean从类路径的ResourceBundle消息-{country-code} .properties中加载i18n消息。

目前，我们没有任何消息要配置，因此请在src / main / resources文件夹中创建一个空的messages.properties文件。

步骤4：注册Spring MVC FrontController servlet DispatcherServlet。

在Servlet 3.x规范之前，我们必须在web.xml中注册Servlet / Filters。从Servlet 3.x规范开始，我们可以使用ServletContainerInitializer以编程方式注册Servlet /过滤器。

Spring MVC提供了一个方便的类AbstractAnnotationConfigDispatcherServletInitializer来注册DispatcherServlet 。

public class SpringWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer
{

    @Override
    protected Class<?>[] getRootConfigClasses()
    {
        return new Class<?>[] { AppConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses()
    {
        return new Class<?>[] { WebMvcConfig.class };
    }

    @Override
    protected String[] getServletMappings()
    {
        return new String[] { "/" };
    }

    @Override
    protected Filter[] getServletFilters() {
       return new Filter[]{ new OpenEntityManagerInViewFilter() };
    }
}

在我们的SpringWebAppInitializer.java配置类中，我们执行了以下操作：

我们已经将AppConfig.class配置为RootConfirationClasses ，它将成为父ApplicationContext ，其中包含由所有子( DispatcherServlet )上下文共享的bean定义。
我们已经将WebMvcConfig.class配置为ServletConfigClasses ，它是包含WebMvc bean定义的子ApplicationContext 。
我们已经将“ /”配置为ServletMapping，这意味着所有请求都将由DispatcherServlet处理。
我们已经将OpenEntityManagerInViewFilter注册为Servlet过滤器，以便在呈现视图时可以延迟加载JPA Entity延迟集合。

第5步：创建一个JPA实体和Spring Data JPA存储库

为用户实体创建一个JPA实体User.java和一个Spring Data JPA存储库。

@Entity
public class User
{
    @Id @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;

    //setters and getters
}

public interface UserRepository extends JpaRepository<User, Integer>
{
}

步骤6：创建一个SpringMVC控制器

创建一个SpringMVC控制器来处理URL “ /”并呈现用户列表。

@Controller
public class HomeController
{
    @Autowired UserRepository userRepo;

    @RequestMapping("/")
    public String home(Model model)
    {
        model.addAttribute("users", userRepo.findAll());
        return "index";
    }
}

步骤7：创建一个百里香叶视图/WEB-INF/views/index.html呈现用户列表。

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" 
      xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="utf-8"/>
<title>Home</title>
</head>
<body>
    <table>
        <thead>
            <tr>
                <th>Id</th>
                <th>Name</th>
            </tr>
        </thead>
        <tbody>
            <tr th:each="user : ${users}">
                <td th:text="${user.id}">Id</td>
                <td th:text="${user.name}">Name</td>
            </tr>
        </tbody>
    </table>
</body>
</html>

现在我们已经准备好运行该应用程序。但是在此之前，我们需要在IDE中下载并配置服务器，例如Tomcat或Jetty或Wildfly等。

您可以下载Tomcat 8并在您喜欢的IDE中进行配置，运行该应用程序，然后将浏览器指向http：// localhost：8080 / springmvcjpa-demo 。您应该在表中看到用户详细信息列表。是的...我们做到了。

但是，等等。仅显示从数据库表中提取的用户详细信息列表是否不是一项繁重的工作？ 让我们诚实和公平。 所有这些配置不仅仅针对这一用例。 此配置也是其余应用程序的基础。但是同样，如果您想快速启动并运行，这是太多的工作要做。 另一个问题是，假设您要开发具有类似技术堆栈的另一个SpringMVC应用程序？好了，您复制粘贴配置并进行调整。 对？ 但是请记住一件事：如果您必须一次又一次地执行相同的操作，则应该找到一种自动的方法来执行此操作。

除了一遍又一遍地写相同的配置，您在这里还看到其他问题吗？

好吧，让我列出我们在这里看到的问题。

您需要寻找特定Spring版本的所有兼容库并进行配置。
95％的时间，我们以相同的方式配置DataSource ， EntitymanagerFactory ， TransactionManager等bean。如果Spring可以自动为我完成任务，那不是很好。
同样，我们通常以相同的方式配置SpringMVC bean，例如ViewResolver ， MessageSource等。

如果Spring可以自动为我完成任务，那就太好了！！！

想象一下，如果Spring能够自动配置bean呢？如果可以使用简单的可自定义属性自定义自动配置怎么办？

例如，您不想将DispatcherServlet url-pattern映射到“ /”，而是将其映射到“ / app /”。与其将百里香叶视图放置在“ / WEB-INF / views”文件夹中，不如将它们放置在“ / WEB-INF / templates /”文件夹中。

因此，基本上，您希望Spring自动执行操作，但提供了以更简单的方式覆盖默认配置的灵活性吗？

好了，您即将进入SpringBoot的世界，梦想成真！

快速了解SpringBoot

欢迎使用SpringBoot！ SpringBoot确实可以满足您的需求。它会自动为您执行操作，但如果需要，您可以覆盖默认值。

与其从理论上解释，不如说我以身作则。

因此，让我们实现与之前构建的应用程序相同的应用程序，但是这次使用SpringBoot。

步骤1：创建一个基于Maven的SpringBoot项目

创建一个Maven项目并按如下方式配置依赖项：

<?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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sivalabs</groupId>
    <artifactId>hello-springboot</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>hello-springboot</name>

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

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

哇，我们的pom.xml突然变得很小！

步骤2：按如下所示在application.properties中配置数据源/ JPA属性。

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=admin
spring.datasource.initialize=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

您可以将相同的data.sql文件复制到src / main / resources文件夹中。

步骤3：为该实体创建JPA实体和Spring Data JPA存储库接口。

创建与springmvc-jpa-demo应用程序相同的User.java，UserRepository.java和HomeController.java 。

步骤4：创建Thymeleaf视图以显示用户列表

将我们在springmvc-jpa-demo应用程序中创建的/WEB-INF/views/index.html复制到新项目的src / -main / resources / templates文件夹中。

步骤5：创建SpringBoot EntryPoint类。

使用以下主要方法创建一个Java类Application.java ：

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

现在将Application.java作为Java应用程序运行，并将浏览器指向http：// localhost：8080 / 。您应该以表格格式看到用户列表。酷！

好吧好吧，我听到你在喊“发生了什么事？？”。

让我解释一下发生了什么。

1.轻松的依赖管理

首先要观察的是我们正在使用一些名为spring-boot-starter- *的依赖项。记住我说过“ 95％的时间我使用相同的配置”。因此，默认情况下，当您添加springboot-starter-web依赖项时，它将在开发Spring MVC应用程序(例如spring-webmvc，jackson-json，validation-api和tomcat)时提取所有常用的库。
我们添加了spring-boot-starter-data-jpa依赖性。这拉动了所有spring-data-jpa依赖关系，并添加了Hibernate库，因为大多数应用程序都将Hibernate用作JPA实现。

2.自动配置

不仅spring-boot-starter-web添加了所有这些库，而且还使用合理的默认值配置了常用注册的bean，例如DispatcherServlet，ResourceHandlers，MessageSource等bean。
我们还添加了spring-boot-starter-thymeleaf ，它不仅添加了thymeleaf库依赖关系，而且还自动配置了ThymeleafViewResolver bean。
我们尚未定义任何DataSource，EntityManagerFactory，TransactionManager等bean，但是会自动创建它们。如果我们在类路径中有任何内存数据库驱动程序(例如H2或HSQL) ，则SpringBoot将自动创建内存数据源，然后使用合理的默认值自动注册EntityManagerFactory和TransactionManager bean，但我们使用的是MySQL，因此我们需要明确提供MySQL连接详细信息。我们已经在application.properties文件中配置了这些MySQL连接详细信息，并且SpringBoot使用这些属性创建了一个DataSource 。

3.嵌入式Servlet容器支持

最重要和令人惊讶的事情是我们创建了一个简单的Java类，并带有一些神奇的注释@SpringApplication有一个main方法，通过运行该main方法，我们可以运行该应用程序并在以下位置访问它http：// localhost：8080 / 。

Servlet容器来自哪里？

我们添加了spring-boot-starter-web ，它会自动拉出spring-boot-starter-tomcat，并且当我们运行main()方法时，它将tomcat作为嵌入式容器启动，这样我们就不必在任何应用程序上部署应用程序外部安装的tomcat服务器。

顺便提一下，您观察到我们在pom.xml中的打包类型是'jar'而不是'war' 。精彩！

好的，但是如果我想使用Jetty服务器而不是tomcat怎么办？

简单，将spring-bootstarter-tomcat从spring-boot-starter-web中排除，并包括spring-boot-starter-jetty 。

而已。但是，这看起来很神奇！！！

我可以想象你在想什么。您在想，SpringBoot看起来很酷，它会自动为我做很多事情。但是，我仍然不完全了解它在幕后的运作方式。对？

我能理解。观看魔术表演通常很有趣，但是在软件开发中却不是。不用担心，我们将在以后的文章中仔细研究每件事，并详细解释幕后情况。但是，我不想在本文中将所有内容转储到您的耳朵上，让您不知所措。

概要

在本文中，我们快速浏览了各种Spring配置样式，并了解了配置Spring应用程序的复杂性。另外，我们通过创建一个简单的Web应用程序快速浏览了SpringBoot。在下一篇文章中，我们将深入研究SpringBoot并了解其工作原理。

翻译自: https://www.javacodegeeks.com/2016/03/why-springboot.html

选择题springboot

cunhu4317

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
选择题springboot_为什么选择SpringBoot？

选择题springboot 使用Spring MSpring进行许可是一种非常流行的基于Java的框架，用于构建Web和企业应用程序。与许多其他只关注一个领域的框架不同，Spring框架通过其投资组合项目提供了广泛的功能来满足现代业务需求。 Spring框架提供了以多种方式(例如XML ， Annotations和JavaConfig)配置bean的灵活性。随着功能数量的增加，复杂性也随之...
复制链接

扫一扫