spring-boot
Spring boot + Spring Data JPA

Introduktion

Anmärkningar

Spring Boot och Spring Data JPA grundläggande exempel

Vi kommer att bygga en applikation som lagrar POJO: er i en databas. Programmet använder Spring Data JPA för att lagra och hämta data i en relationsdatabas. Dess mest övertygande funktion är förmågan att skapa förvarsimplementeringar automatiskt, vid körning, från ett arkivgränssnitt.

Huvudklass

package org.springboot;

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);
    }
}

Den main() metoden använder Spring Boot s SpringApplication.run() metod för att starta ett program. Observera att det inte finns en enda XML-rad. Ingen web.xml-fil heller. Denna webbapplikation är 100% ren Java och du behöver inte ta itu med att konfigurera VVS eller infrastruktur.

Enhetsklass

package org.springboot.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Greeting {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String text;

    public Greeting() {
        super();
    }

    public Greeting(String text) {
        super();
        this.text = text;
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

Här har du en Greeting med två attribut, id och text . Du har också två konstruktörer. Standardkonstruktorn finns bara för JPA: s skull. Du kommer inte att använda det direkt, så det kan betecknas som protected . Den andra konstruktören är den du använder för att skapa instanser av Greeting som ska sparas i databasen.

Greeting kommenteras med @Entity , vilket indikerar att det är en JPA-enhet. Avsaknad av en @Table anteckning antas att denna enhet kommer att kartläggas till en tabell med namnet "Hälsning".

Hälsningens id egenskap antecknas med @Id så att JPA kommer att känna igen den som objektets ID. id egenskapen kommenteras också med @GeneratedValue att indikera att ID ska genereras automatiskt.

Den andra egenskapen, text lämnas obemärkt. Det antas att det kommer att kartläggas till en kolumn som har samma namn som egenskapen själv.

Övergående egenskaper

I en enhetsklass som liknar den ovan, kan vi ha egenskaper som vi inte vill ha kvar i databasen eller skapas som kolumner i vår databas kanske för att vi bara vill ställa in dem vid körning och använda dem i vår applikation, därmed kan vi få den egenskapen kommenterad med @Transient-anteckningen.

package org.springboot.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Transient;

@Entity
public class Greeting {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String text;
    @Transient
    private String textInSomeLanguage;
    
    public Greeting() {
        super();
    }
 
    public Greeting(String text) {
        super();
        this.text = text;
        this.textInSomeLanguage = getTextTranslationInSpecifiedLanguage(text);
    }

    /* In this example, the typical getters and setters have been left out for brevity. */
}

Här har du samma hälsning klass som nu har en övergående egenskap textInSomeLanguage som kan initieras och användas vid körning och kommer inte att framhärdade i databasen.

DAO klass

package org.springboot.repository;

import org.springboot.model.Greeting;
import org.springframework.data.repository.CrudRepository;

public interface GreetingRepository extends CrudRepository<Greeting, Long> {

    List<Greeting> findByText(String text);
}

GreetingRepository utökar gränssnittet CrudRepository . Typ av enhet och ID som det fungerar med, Greeting och Long , anges i de generiska parametrarna på CrudRepository . Genom att utvidga CrudRepository ärver GreetingRepository flera metoder för att arbeta med Greeting , inklusive metoder för att spara, ta bort och hitta Greeting .
Se denna diskussion för jämförelse av CrudRepository , PagingAndSortingRepository , JpaRepository .

Spring Data JPA låter dig också definiera andra frågeställningsmetoder genom att helt enkelt deklarera deras metodsignatur. När det gäller GreetingRepository visas detta med en findByText() -metod.

I en typisk Java-applikation kan du förvänta dig att skriva en klass som implementerar GreetingRepository . Men det är det som gör Spring Data JPA så kraftfull: Du behöver inte skriva en implementering av arkivgränssnittet. Spring Data JPA skapar en implementering när du kör applikationen.

Serviceklass

package org.springboot.service;

import java.util.Collection
import org.springboot.model.Greeting;

public interface GreetingService {

    Collection<Greeting> findAll();
    Greeting findOne(Long id);
    Greeting create(Greeting greeting);
    Greeting update(Greeting greeting);
    void delete(Long id);

}

Service Bean

package org.springboot.service;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.repository.GreetingRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class GreetingServiceBean implements GreetingService {

    @Autowired
    private GreetingRepository greetingRepository;

    @Override
    public Collection<Greeting> findAll() {
        Collection<Greeting> greetings = greetingRepository.findAll();
        return greetings;
    }

    @Override
    public Greeting findOne(Long id) {
        Greeting greeting = greetingRepository.findOne(id);
        return greeting;
    }

    @Override
    public Greeting create(Greeting greeting) {
        if (greeting.getId() != null) {
            //cannot create Greeting with specified Id value
            return null;
        }
        Greeting savedGreeting = greetingRepository.save(greeting);
        return savedGreeting;
    }

    @Override
    public Greeting update(Greeting greeting) {
        Greeting greetingPersisted = findOne(greeting.getId());
        if (greetingPersisted == null) {
            //cannot find Greeting with specified Id value
            return null;
        }
        Greeting updatedGreeting = greetingRepository.save(greeting);
        return updatedGreeting;
    }

    @Override
    public void delete(Long id) {
         greetingRepository.delete(id);
    }

}

Controller Class

package org.springboot.web.api;

import java.util.Collection;
import org.springboot.model.Greeting;
import org.springboot.service.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping(value = "/api")
public class GreetingController {

    @Autowired
    private GreetingService greetingService;

    // GET [method = RequestMethod.GET] is a default method for any request. 
    // So we do not need to mention explicitly

    @RequestMapping(value = "/greetings", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Collection<Greeting>> getGreetings() {
        Collection<Greeting> greetings = greetingService.findAll();        
        return new ResponseEntity<Collection<Greeting>>(greetings, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> getGreeting(@PathVariable("id") Long id) {
        Greeting greeting = greetingService.findOne(id);
        if(greeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<Greeting>(greeting, HttpStatus.OK);
    }
    
    @RequestMapping(value = "/greetings", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> createGreeting(@RequestBody Greeting greeting) {
        Greeting savedGreeting = greetingService.create(greeting);
        return new ResponseEntity<Greeting>(savedGreeting, HttpStatus.CREATED);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.PUT, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    public ResponseEntity<Greeting> updateGreeting(@PathVariable("id") Long id, @RequestBody Greeting greeting) {
        Greeting updatedGreeting = null;
        if (greeting != null && id == greeting.getId()) {
            updatedGreeting = greetingService.update(greeting); 
        }
        if(updatedGreeting == null) {
            return new ResponseEntity<Greeting>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
        return new ResponseEntity<Greeting>(updatedGreeting, HttpStatus.OK);
    }

    @RequestMapping(value = "/greetings/{id}", method = RequestMethod.DELETE)
    public ResponseEntity<Greeting> deleteGreeting(@PathVariable("id") Long id) {
        greetingService.delete(id);
        return new ResponseEntity<Greeting>(HttpStatus.NO_CONTENT);
    }

}

Programegenskaper för MySQL-databas

#mysql config
spring.datasource.url=jdbc:mysql://localhost:3306/springboot
spring.datasource.username=root
spring.datasource.password=Welcome@123
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto = update

spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.DefaultNamingStrategy

#initialization
spring.datasource.schema=classpath:/data/schema.sql

SQL-fil

drop table if exists greeting;
create table greeting (
    id bigint not null auto_increment, 
    text varchar(100) not null, 
    primary key(id)
);

pom.xml-fil

<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>org</groupId>
<artifactId>springboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.2.1.RELEASE</version>
</parent>

<dependencies>
    <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>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

Bygga en körbar JAR

Du kan köra applikationen från kommandoraden med Maven. Eller så kan du bygga en enda körbar JAR-fil som innehåller alla nödvändiga beroenden, klasser och resurser och köra det. Detta gör det enkelt att skicka, versionera och distribuera tjänsten som en applikation under hela utvecklingslivscykeln, över olika miljöer och så vidare.

Kör applikationen med ./mvnw spring-boot:run . Eller så kan du bygga JAR-filen med ./mvnw clean package . Sedan kan du köra JAR-filen:

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