Spring Boot: Spring MVC-Anwendung ausführen

Dieses Tutorial richtet sich an Anfänger, die die Grundlagen der Zusammenarbeit von Spring Boot und Spring MVC erlernen möchten. Am Ende dieses Tutorials könnten Sie eine einfache SPring MVC-Anwendung mit Spring Boot ausführen.

Frühlingsstiefel ist ein Spring IO-Projekt, das darauf abzielt, die Startkonfigurationen und die Verkabelung von Spring-Anwendungen zu reduzieren. Der Entwickler muss sich nur auf das Schreiben der Anwendung konzentrieren, während Spring Boot den Bereitstellungsprozess vereinfacht, indem es Ihre Anwendung ohne explizite Konfigurationen verpackt und bereitstellt. Es funktioniert einfach sofort!! Hier erkläre ich, wie man mit Spring Boot eine einfache Spring MVC-Anwendung ausführt, die auch CRUD-Operationen ausführt. Bevor Sie mit diesem Beispiel beginnen, erstellen Sie bitte ein Webprojekt in Eclipse.

  • Lesen Sie auch: Einführung in Spring Boot

Ich habe ein Beispiel geschrieben, das die folgenden Aufgaben erledigt:

  • Habe eine Webseite erstellt
  • Der Benutzer kann Mitarbeiter zur Datenbank hinzufügen
  • Der Benutzer kann die Liste der zur Datenbank hinzugefügten Mitarbeiter im Browser anzeigen (JSON-Ergebnis).
  • Die oben genannten Aufgaben werden mit Spring MVC, Hibernate und Spring Boot ausgeführt.

    Spring Boot und Spring MVC

    Erstellen Sie eine Domänenklasse

    Erstellen Sie zunächst eine Domänenklasse „Employee“, um die Details zu einem Mitarbeiter zu speichern. Es ist eine einfache POJO-Klasse.

    @Entity
    public class Employee {
    
        @Id
        @NotNull
        @Size(max = 64)
        @Column(name = "id", nullable = false, updatable = false)
        private String id;
    
        @NotNull
        @Size(max = 64)
        @Column(name = "name", nullable = false)
        private String name;
    
        @NotNull
        @Size(max = 64)
        @Column(name = "city", nullable = false)
        private String city;
    
        Employee() {
        }
    
        public Employee(final String id, final String name,final String city) {
            this.id = id;
            this.name = name;
            this.city = city;
        }
    
        public String getId() {
            return id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getCity() {
            return city;
        }
    
        public void setCity(String city) {
            this.city = city;
        }
    
        @Override
        public String toString() {
            return Objects.toStringHelper(this)
                    .add("id", id)
                    .add("name", name)
                    .add(city, city)
                    .toString();
        }
    }
    
    

    Erstellen Sie ein Spring Data JPA-Repository

    Spring Data JPA ist eine sehr einfache Möglichkeit, Daten im Back-End beizubehalten. Wenn Sie sich den folgenden Code ansehen, ist das alles, was Sie zum Beibehalten Ihrer Employee-Klasse schreiben werden. Spring Data implementiert intern die erforderlichen Dateien und führt die CRUD-Vorgänge in Ihrem Namen durch. Sie müssen lediglich die Schnittstelle wie unten beschrieben bereitstellen. Wenn Sie daran interessiert sind, Spring Data zu erlernen, lesen Sie bitte unser Spring Data JPA-Tutorial.

    public interface EmployeeRepository extends JpaRepository<Employee, String> {
    }
    

    Erstellen Sie eine Service-Implementierung

    @Service
    @Validated
    public class EmployeeServiceImpl implements EmployeeService {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(EmployeeServiceImpl.class);
        private final EmployeeRepository repository;
    
        @Inject
        public EmployeeServiceImpl(final EmployeeRepository repository) {
            this.repository = repository;
        }
    
        @Transactional
        public Employee save(@NotNull @Valid final Employee employee) {
            LOGGER.debug("Creating {}", employee);
            return repository.save(employee);
        }
    
        @Transactional(readOnly = true)
        public List<Employee> getList() {
            LOGGER.debug("Retrieving the list of all users");
            return repository.findAll();
        }
    
    }
    

    Erstellen Sie einen Spring MVC-Controller

    Für Spring-Entwickler ist das nichts Neues. Wir erstellen lediglich einen einfachen Spring MVC-Controller zum Hinzufügen und Auflisten der Mitarbeiterdetails.

    @RestController
    public class EmployeeController {
        private final EmployeeService employeeService;
    
        @Inject
        public EmployeeController(final EmployeeService employeeService) {
            this.employeeService = employeeService;
        }
    
        @RequestMapping(value = "/employee", method = RequestMethod.GET)
        public List<Employee> listEmployees() {
            List<Employee> employees = employeeService.getList();
            return employees;
        }
        @RequestMapping(value="/add",method = RequestMethod.GET)
        public void addEmployee(@RequestParam(value = "employeeName", required = false) String employeeName,
        		@RequestParam(value = "employeeId", required = false) String employeeId,
        		@RequestParam(value = "employeeCity", required = false) String employeeCity){
        	Employee employee = new Employee(employeeId,employeeName,employeeCity);
        	employeeService.save(employee);
        }
    }
    

    Erstellen Sie eine JSP-Datei

    <!DOCTYPE html>
    <html>
    <head>
        <title>Hello WebSocket</title>
    </head>
    <body>
    <form action="/add">
    	<input type="input" name="employeeName">
    	<input type="input" name="employeeId">
    	<input type="input" name="employeeCity">
    	<input type="submit">
    </form>
    </body>
    </html>
    

    Spring Boot-Anwendung

    Schließlich müssen wir die Spring Boot-Anwendung schreiben, um unser Beispiel auszuführen. Dies ist die Hauptanwendung, die von Spring Boot aufgerufen wird, wenn Sie versuchen, die Anwendung auszuführen.

    • Lesen Sie auch: RESTful API mit Spring Boot

    @EnableAutoConfiguration

    Diese Annotation versucht anhand des Klassenpfads die Beans zu finden, die zum Ausführen der Anwendung erforderlich sind. oder Beispiel: Wenn ja tomcat-embedded.jar Auf Ihrem Klassenpfad möchten Sie wahrscheinlich eine TomcatEmbeddedServletContainerFactory . Das Paket der Klasse, mit der Anmerkungen gemacht werden @EnableAutoConfiguration hat eine besondere Bedeutung und wird oft als „Standard“ verwendet. Es wird beispielsweise beim Scannen verwendet @Entity Klassen. Es wird generell empfohlen, dass Sie es platzieren @EnableAutoConfiguration in einem Root-Paket, sodass alle Unterpakete und Klassen durchsucht werden können.

    SpringApplication.run()

    Die SpringApplication-Klasse wird zum Bootstrap und zum Starten der Spring-Anwendung verwendet. Der Bootstrap einer Spring-Anwendung besteht darin, einen geeigneten Anwendungskontext zu erstellen, Beans zu laden, Befehlszeilen-Beans auszulösen usw.

    SpringBootServletInitializer

    Dies ist zum Ausführen der Webanwendung erforderlich. Dadurch wird der Servlet-Container aktiviert und Ihre Anwendung an den Servlet-Container gebunden.

    @Configuration
    @EnableAutoConfiguration
    @ComponentScan
    public class Application extends SpringBootServletInitializer {
    
        public static void main(final String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
        @Override
        protected final SpringApplicationBuilder configure(final SpringApplicationBuilder application) {
            return application.sources(Application.class);
        }
    }
    

    Maven-Konfigurationen

    Dies ist der wichtige Teil der Ausführung der Spring Boot-Anwendung. Spring Boot muss die Abhängigkeiten für die Ausführung einer Anwendung anhand der Build-Dateien identifizieren. Es kann eine Vielzahl von Build-Tools unterstützen, die offizielle Dokumentation von Spring Boot legt jedoch mehr Wert auf Maven- und Gradle-Konfigurationen. Aufgrund der einfachen Implementierung ist es daher ratsam, eines auszuwählen.

    spring-boot-starter-*

    Starter-POMs sind vordefinierte POM-Deskriptoren, die als integriert verfügbar sind. Sie müssen nicht nach den Abhängigkeiten suchen und diese konfigurieren. Wenn Sie beispielsweise nach Spring und JPA für den Datenzugriff suchen, müssen Sie nur angeben spring-boot-starter-data-jpa zu Ihrer POM-Datei hinzufügen.

    Spring-Boot-Maven-Plugin

    Mit diesem Plug-in können Sie Ihre Anwendung in eine ausführbare JAR- oder WAR-Datei packen. Dies wird ab Maven 3.2 unterstützt. In unserem Beispiel, wenn Sie das Projekt mit dem Befehl „mvn installieren”-Befehl würde Maven das Projekt erstellen und die ausführbare JAR-Datei im Zielordner erstellen. Bitte sehen Sie sich die folgende Ordnerstruktur an.

    Spring-Boot-Starter-Elternteil

    Wenn Sie die Eigenschaften von erben möchten spring-boot-starter-parent, Dann legen Sie einfach das übergeordnete Element fest. Wenn Sie das übergeordnete Element verwenden, können Versionsnummern für andere im POM verwendete Starter weggelassen werden. Wenn Sie für Ihre Projekte ein eigenes übergeordnetes Element haben, können Sie dieses anstelle des von Spring Boot bereitgestellten standardmäßigen übergeordneten Elements verwenden. Es sieht aus wie das:

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

    Die endgültige Paketstruktur für das Projekt sieht folgendermaßen aus. Hier habe ich Application.java unter einem Paket erstellt. Es empfiehlt sich jedoch, diese Datei im Root-Paket zu belassen.

    Der gesamte Quellcode kann am Ende dieses Tutorials heruntergeladen werden.

    spring-boot-spring-mvc

     <dependencies>
            <!-- Spring Boot -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <!-- Hibernate validator -->
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-validator</artifactId>
            </dependency>
            <!-- HSQLDB -->
            <dependency>
                <groupId>org.hsqldb</groupId>
                <artifactId>hsqldb</artifactId>
                <scope>runtime</scope>
            </dependency>
            <!-- Guava -->
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>${guava.version}</version>
            </dependency>
            <!-- Java EE -->
            <dependency>
                <groupId>javax.inject</groupId>
                <artifactId>javax.inject</artifactId>
                <version>1</version>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <!-- Spring Boot Maven -->
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    

    Führen Sie Spring Boot aus einer ausführbaren JAR-Datei aus

    Nachdem Sie die Anwendung erstellt haben, führen Sie diesen Befehl aus, um Ihre Anwendung auszuführen.

    java -jar target/mymodule-0.0.1-SNAPSHOT.jar
    

    Sobald Sie den obigen Befehl von Ihrer Befehlsanwendung aus ausführen, führt die Spring-Boot-Anwendung die Anwendung im Pfad http://localhost:8080/ aus. Sie können auf die Indexseite der Anwendung unter http://localhost:8080/index.jsp zugreifen:

    Spring Boot-Demo

    Sie können viele Zeilen hinzufügen. Wenn Sie auf die URL http://localhost:8080/employee zugreifen, erhalten Sie im Browserfenster etwa Folgendes:

    [{"id":"Krishna","name":"001","city":"Bangalore"},{"id":"Manisha Patil","name":"005","city":"Pune"},{"id":"Sanulla","name":"001","city":"Bangalore"},{"id":"Shunmuga Raja","name":"001","city":"Bangalore"}]
    

    Quellcode-Download

    Symbol

    Spring Boot Spring MVC

    1 Datei(en) 20,89 KB Download

    Zusammenfassung

    In diesem Artikel haben wir besprochen, wie man ein Maven-Projekt erstellt und die verschiedenen Komponenten erstellt, die für die Employee Manager Spring MVC-Anwendung erforderlich sind. Später haben wir die Spring Boot-Konfigurationsdetails und den Inhalt der Maven POM-Datei untersucht, die für die Spring Boot-Anwendung erforderlich sind. Abschließend haben wir über die Ausführung der ausführbaren JAR-Datei gesprochen, die mit dem Maven-Build gepackt wurde. Am Ende dieses Tutorials können Sie sich ein Bild davon machen, wie Spring Boot und Spring MVC zusammenarbeiten.

    Wenn Sie Fragen zu den Spring-Boot-Anwendungen haben, schreiben Sie diese bitte in den Kommentarbereich.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen