Metodo di rapida costruzione di microframe di spring-boot

spring-boot è un set di framework per un ambiente di costruzione rapida, il cui principio di progettazione è ridurre al minimo la configurazione xml, per semplificare la configurazione iniziale e lo sviluppo di nuove applicazioni Spring. Questo framework utilizza un metodo specifico per la configurazione, in modo che i programmatori non debbano definire configurazioni di esempio.

Non faccio troppe chiacchiere, per sapere cosa è spring-boot in dettaglio, puoi cercare su Baidu.

Sito ufficiale:http://projects.spring.io/spring-boot

1. spring-boot è un progetto mavan, quindi tutti i jar utilizzati sono gestiti tramite Maven, naturalmente, utilizzare Maven è anche molto comodo.

Prima di tutto, ecco la struttura del mio progetto:

　 　　　　

Il pacchetto generato da spring-boot è uno stato di jar eseguibile, utilizza il server Tomcat integrato, quindi non è necessario trasformare il progetto in un progetto EJB.

2. Impostare il file pom.xml

Chi è a conoscenza di Maven sa che Maven gestisce i pacchetti jar tramite il file di dipendenza pom.xml, quindi il cuore è anche questo file 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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lclc.boot</groupId>
  <artifactId>boot-cache</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <!-- Eredita le predefinizioni da Spring Boot -->
  <parent>
    <!-- classe padre di base di Spring Boot, che contiene molti jar necessari, se non si utilizza la classe padre, è necessario dipendere da questi jar -->
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.1.3.RELEASE</version>
  </parent>
  <dependencies>
    <!-- dipendenze di avvio del programma web, attraverso questa dipendenza è possibile introdurre i jars necessari per il web come Tomcat integrato -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- dipendenze di avvio del programma spring-data-jpa, implementato sottostante da hibernate, se non si utilizza questa struttura, si può dipendere da altri framework ORM -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- dipendenze di avvio del programma thymeleaf, spring-boot supporta meglio l'engine di modello thymeleaf, si consiglia di utilizzare questa struttura per l'engine di modello -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- Dipendenza mysql, per utilizzare spring-data-jpa è necessario specificare una dialettica del database, utilizzata per connettersi al database, ossia il driver mysql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
  </dependencies>
  <dependencyManagement>
    <dependencies>
    </dependencies>
  </dependencyManagement>
  <build>
    <plugins>
      <!-- Plugin costruito tramite maven -->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
  <!-- Repository, per utilizzare la versione RELEASE di spring-boot sono necessari questi -->
  <repositories>
    <repository>
      <id>spring-snapshots</id>
      <url>http://repo.spring.io/snapshot</url>
      <snapshots>
        <enabled>true</enabled>
      </snapshots>
    </repository>
    <repository>
      <id>spring-milestones</id>
      <url>http://repo.spring.io/milestone</url>
    </repository>
  </repositories>
  <pluginRepositories>
    <pluginRepository>
      <id>spring-snapshots</id>
      <url>http://repo.spring.io/snapshot</url>
    </pluginRepository>
    <pluginRepository>
      <id>spring-milestones</id>
      <url>http://repo.spring.io/milestone</url>
    </pluginRepository>
  </pluginRepositories>
</project>

3. Usa maven update per scaricare i pacchetti jar　　

4. Poiché utilizziamo il motore thymeleaf, questo motore necessita di una cartella templates per memorizzare le pagine statiche, al fine di effettuare il reindirizzamento alla pagina前台.

Quindi aggiungi questa cartella sotto resources e includi una pagina di default index.html (nota: questa cartella deve avere un file html, altrimenti il lancio di thymeleaf genererà un'eccezione)

5. Scrivere application.properties

Questo file di configurazione contiene alcune configurazioni di spring-boot, spring-boot configura alcuni framework integrati tramite questo file. Dalla struttura del mio progetto si può vedere che ho due file application.properties:

application.properties: file di configurazione principale, spring-boot legge direttamente questo file. Nota: i file di configurazione devono essere collocati nella directory resources, ossia nella directory di root del progetto.

application-dev.properties: file di configurazione dell'ambiente di sviluppo, questo è il mio file di configurazione dell'ambiente di sviluppo. Per semplificare alcune fasi di sviluppo, è necessario avere alcune configurazioni diverse rispetto all'ambiente di distribuzione, come la cache delle pagine. Questo file viene letto per la configurazione tramite l'attributo spring.profiles.active dell'application.properties.

Il codice degli ultimi due file:

Prima di tutto c'è application.properties:

# PROFILES
## dev | prod | test
spring.profiles.active=dev
# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080
server.session-timeout=30
server.context-path=
server.tomcat.max-threads=0
server.tomcat.uri-encoding=UTF-8
# THYMELEAF (ThymeleafAutoConfiguration)
spring.thymeleaf.encoding=UTF-8
# DataSource
spring.datasource.initialize=false
spring.datasource.test-on-borrow=false
spring.datasource.test-on-return=false
spring.datasource.test-while-idle=true
spring.datasource.max-wait-millis=30000
spring.datasource.validation-query=SELECT 1
spring.datasource.time-between-eviction-runs-millis=20000
spring.datasource.min-evictable-idle-time-millis=28700

Poi c'è application-dev.properties:

# page cache
spring.thymeleaf.cache=false
# DATASOURCE 
spring.datasource.platform=mysql
spring.datasource.url=jdbc:mysql://localhost/test_development?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.max-active=5
spring.datasource.max-idle=2
spring.datasource.min-idle=1
spring.datasource.initial-size=1
spring.datasource.initialize=false
# JPA
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=false
spring.jpa.properties.hibernate.use_sql_comments=true

6. Così la configurazione è stata completata, ora vediamo come utilizzare spring-boot per avviare un programma web

Il pacchetto creato da spring-boot è un jar eseguibile, naturalmente può anche essere creato come war eseguibile, avviare il server non richiede più come prima di configurare un tomcat per l'avvio, è completamente un'applicazione java che si avvia

Esegue attraverso un metodo main di un file di avvio

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
  public static void main(String[] args){
    SpringApplication springApplication = new SpringApplication (Application.class);
    springApplication.run (args);
  }
}

Spiegiamo prima il codice presente in questo file.

@Configuration: etichetta questo file come un'opzione di configurazione

@EnableAutoConfiguration: utilizza la configurazione automatica

@ComponentScan: scannabile

SpringApplication: gestore di avvio.

Attenzione, poiché viene utilizzato il metodo di annotazione, è necessario configurare il percorso di scansione. Spring-boot utilizza il pacchetto del gestore di avvio come percorso di root di scansione. Scansiona il pacchetto e i sottopacchetti al suo interno, quindi è necessario mettere Application.java nel percorso radice, ovvero nel pacchetto com.test.

7. Poi esegui.

Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento, e speriamo che tu sostenga fortemente il tutorial di urla.

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright spetta agli autori, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene i diritti di proprietà, non è stato editato manualmente e non assume responsabilità legali correlate. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una email a: notice#oldtoolbag.com (al momento dell'invio dell'email, sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata, questo sito eliminerà immediatamente il contenuto sospetto di violazione del copyright.