Acerca de los datos de primavera
Un proyecto superior en la comunidad de Spring se utiliza principalmente para simplificar el acceso de datos (relacionales y no relacionales). Si utilizamos los datos de Spring para desarrollar programas, podemos guardar muchas operaciones de acceso a datos de bajo nivel, como escribir declaraciones de consulta de datos, clases de DAO, etc. Solo necesitamos escribir algunas interfaces abstractas y definir operaciones relacionadas. Spring creará instancias proxy durante la operación para implementar las operaciones definidas en nuestra interfaz.
Acerca de Spring Data Subproject
Los datos de Spring tienen muchos subproyectos, además de los datos de Spring JPA, también están los siguientes subproyectos.
Spring Data Commons
Datos de primavera MongoDB
Datos de resorte Redis
Spring Data Solr
Spring Data Gemfire
Descanso de datos de resorte
Datos de resorte neo4j
Acerca de los datos de primavera JPA
Spring Data JPA es un subproyecto de datos de resorte. Se utiliza principalmente para simplificar la implementación de la capa de acceso a datos. Con Spring Data JPA, puede implementar fácilmente la adición, eliminación, modificación, paginación, clasificación, etc.
Ejemplo, Spring Boot + Spring Data JPA
1. Agregue el archivo pom.xml
Como se muestra a continuación:
<? xml versión = "1.0" encoding = "utf-8"?> <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschemainstance" 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> <MoupRoupid> com.example </spopiid> <artifactid> Demo </ArtiMo </arti <versión> 0.0.1-snapshot </versión> <packaging> jar </packaging> <name> spring-data-jpa-example </name> <solding> Proyecto de demostración para arranque de primavera </scoldi> <rated> <MoupRupid> org.springframework.boot </groupid> <artifactID> spring-boot-starter-parent </artifactid> <proonsion> <verserse. <RelativePath/> <!-Búsqueda de padres desde el repositorio-> </parent> <properties> <proyect.build.sourceEncoding> UTF-8 </project.build.sourceEncoding> <jection.Reporting.outputenCoding> UTF-8 </project.Reporting.outputenCoding> <Java.version> </propiedades> <pendencies> <pendency> <grupoD> org.springframework.boot </groupid> <artifactid> spring-boot-starter-data-jpa </artifactid> </pendency> <pendency> <proupid> org.springing.Boot </groupid> <artifactid> spring-boot-sharter-web </artid-web </artid-web </artid-web </arthfframe> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> </dependencies> <build> <plugins> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </proyecto>
Entre ellos, Spring-Boot-Starter-Parent cargará todas las configuraciones predeterminadas requeridas por la aplicación Spring Boot;
Spring-Boot-Starter-Data-JPA descargará todas las dependencias requeridas por Spring Data JPA;
Agregue Spring-Boot-Starter-Web porque nuestro proyecto es una aplicación web;
Además, nuestra base de datos es MySQL, por lo que también se requiere dependencia de MySQL-Connector-Java;
Dado que se usa caché, agregue otra dependencia de la fracción de arranque de primavera;
2. Escribir usuario de entidad
paquete com.example.domain; import java.io.Serializable; import javax.persistence.column; import javax.persistence El usuario de la clase implementa serializable {private static final long SerialVersionUid = 1l; @Id Long ID; @Column (nombre = "nombre") nombre de cadena; @Column (name = "Dirección") Dirección de cadena; public Long getId () {return id; } public void setid (ID long) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public String getAddress () {Dirección de retorno; } public void setAddress (dirección de cadena) {this.address = dirección; }}No hay nada más que decir. Presta atención a la anotación @NamedQuery aquí. Significa aproximadamente que el método FindByName que definimos en la interfaz del repositorio no utiliza la implementación de consulta predeterminada, sino que usa esta declaración de consulta personalizada para consultar. Si no hay anotación aquí, se utilizará la implementación predeterminada.
3. Escribe la interfaz del repositorio
Aquí escribiremos dos interfaces de repositorio, que solo se usan para ejemplos, y se pueden fusionar en una en la práctica:
UserJParepository
paquete com.example.repository; import org.springframework.data.jpa.repository.jparpository; import com.example.domain.user; interfaz pública userjparepository extiende jParepository <user, long> {}La interfaz UserJParepository aquí implementa la interfaz jParepository;
De hecho, JParepository implementa la interfaz Paging y SortingRepository, la interfaz Paging y SortingRepository implementa la interfaz CrudRepository, y la interfaz CrudRepository implementa la interfaz del repositorio;
Una breve explicación:
La interfaz del repositorio es una interfaz de identificación, y está vacía por dentro;
La interfaz CrudRepository define los métodos de agregar, eliminar, modificar y buscar;
La interfaz Paging y SortingRepository se utiliza para la paginación y la clasificación;
Dado que la interfaz jParepository hereda todas las interfaces anteriores, tiene todos los métodos declarados por ellos;
También tenga en cuenta que tomar el método Findall como ejemplo, la interfaz JParepository devuelve la lista, Paging ySortingRepository y CrudRepository Devuelve iterator;
UserRepository
paquete com.example.rePository; import java.util.list; import org.springframework.data.jpa.repository.query; import org.springframework.data.repository.repository; import org.springingwork.rapositoria.Querery.query.param; import. extiende el repositorio <user, long> {list <ser user> findByNameAndAddress (nombre de cadena, dirección de cadena); @Query (value = "De user u where u.name =: name") Lista <serem> findByName1 (@Param ("Nombre") Nombre de cadena); @Query (valor = "Seleccionar * de #{ #entityName} U Where U.Name =? 1", nationalQuery = true) List <Serem> findByName2 (nombre de cadena); Lista <serem> findByName (nombre de cadena);}La interfaz UserRepository aquí define principalmente algunos métodos de consulta;
Por ejemplo, podemos ejecutar directamente sin definir otras declaraciones de consulta aquí. Spring Data JPA implementará automáticamente el método basado en el nombre del atributo y el nombre del método de la clase Entity; PD: Dado que declaramos la anotación @namedQuery en la clase de entidad, de hecho, el método FindByName utilizará la declaración de consulta anotada por la anotación @NamedQuery a la consulta;
Además, el método FindByName1 aquí utiliza la consulta de instrucción HQL;
El método FindByName2 utiliza la consulta de instrucción SQL original;
4. Servicio de escritura
Interfaz de servicio:
paquete com.example.service; import java.util.list; import com.example.domain.user; interfaz pública IUSERService {Public List <Ser Usem> findAll (); public void saveUser (libro de usuarios); Usuario público Findone (ID de larga); Public Void Eliminar (ID largo); Lista pública <serem> findByName (nombre de cadena);}Clase de implementación de la interfaz:
paquete com.example.service.impl; import java.util.list; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.cache.annotation.cachable; import org.springfrfrframe.stereType.service; importar org.springfring.trans. com.example.domain.user; import com.example.repository.userRepository; import com.example.repository.userJpareSpository; import @AUtowired private userRepository userRepository; Lista pública <serem> findall () {return userJParepository.findall (); } Lista pública <serem> findByName (nombre de cadena) {list <serem> userList1 = userRepository.FindByName1 (nombre); Lista <serem> userList2 = userRepository.FindByName2 (nombre); Lista <serem> UserList3 = UserRepository.FindByNameAndAddress (nombre, "3"); System.out.println ("UserList1:" + UserList1); System.out.println ("UserList2:" + UserList2); System.out.println ("UserList3:" + UserList3); return UserRepository.FindByName (nombre); } public void saveUser (libro de usuarios) {userJParepository.save (libro); } @Cacheable ("Usuarios") Public User Findone (ID Long) {System.out.println ("Páginas en caché"); return userJParepository.findone (id); } public void Delete (ID Long) {userJParepository.Delete (id); }}No hay nada que decir sobre esto, solo llame al método de interfaz de repositorio.
5. Controlador de escritura
No hay nada que decir sobre el controlador, solo llame al servicio. Tenga en cuenta que el controlador aquí se anota usando la anotación @RestController, y el nombre de la ruta de URL se nombra de acuerdo con el estilo RESTFUL;
paquete com.example.web; import java.util.list; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.web.bind.annotation.pathvariable; import og.springfframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.restController; import com.example.domain.user; import com.example.service.iuserservice;@reestcontroller@requestmapping (valor = "/usuarios") Class de clase pública osocontroller {@autowed iUserService IUSERVICE ORSERVICE; @RequestMapping (value = "/add/{id}/{name}/{dirección}") Adduser de usuario público (@PathVariable int user.setID (id); user.setName (nombre); user.setaddress (dirección); UserService.SaveUser (usuario); devolver el usuario; } @RequestMapping (valor = "/delete/{id}") public void deletebook (@PathVariable int id) {UserService.Delete (id); } @RequestMapping (valor = "/") Lista pública <serem> getBooks () {return Userservice.findall (); } @RequestMapping (valor = "/{id}") Public User getUser (@PathVariable int id) {user User = Userservice.findone (id); devolver el usuario; } @RequestMapping (valor = "/búsqueda/name/{name}") Lista pública <Ser User> GetBookByName (@PathVariable String Name) {List <Ser User> Users = Userservice.FindByName (name); devolver usuarios; }}6. Configure el dataSource
Agregue la siguiente configuración al archivo Application.Properties:
spring.jpa.show-sql = truelogging.level.org.springframework.data = debugspring.jpa.hibernate.ddl-auto = spring.datasource.url = jdbc: mysql: // localhost: 33 06/DemaSpring.datasource.username = rootspring.datasource.password = rootspring.datasource.driver-classs-name = com.mysql.jdbc.driver
Si usa STS IDE, estas configuraciones de atributos se solicitarán automáticamente, por lo que puede guardar las búsquedas.
Si desea ver la configuración de Spring.DataSource, puede consultar esta clase: DataSourceProperties.java
7. Escribe una clase de inicio
Es relativamente simple. Tenga en cuenta que el nivel del paquete al que pertenece esta clase debe ser mayor o igual a otras clases para garantizar que se puedan escanear las anotaciones de otras clases.
paquete com.example; import org.springframework.boot.springapplication; import org.springframework.boot.autoconfigure.springbootapplication; import org.springframework.cache.annotation.enablecaching;@springpaplication Main (String [] args) {SpringApplication.run (SpringDataJpaExAMPleAplication.Class, Args); }}Ejecutar y probar el programa
Inicie el método principal, o escribalo en un paquete jar para ejecutar;
Ingrese la siguiente URL en el navegador y pruebe:
http: // localhost: 8080/usuarios/
http: // localhost: 8080/users/add/100/110/111
http: // localhost: 8080/usuarios/eliminar/100
http: // localhost: 8080/usuarios/2
http: // localhost: 8080/usuarios/búsqueda/nombre/2
Código fuente del programa
https://github.com/peterchenhdu/spring-data-jpa-example
Referencias
http://docs.spring.io/spring-data/jpa/docs/1.11.0.release/reference/html/
http://javabeat.net/spring-data-jpa/
https://spring.io/guides/gs/caching/
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.