Sobre dados da primavera
Um projeto de topo da comunidade da primavera é usado principalmente para simplificar o acesso de dados (relacional e não relacional). Se usarmos dados de primavera para desenvolver programas, podemos economizar muitas operações de acesso a dados de baixo nível, como escrever declarações de consulta de dados, classes DAO etc. Precisamos apenas escrever algumas interfaces abstratas e definir operações relacionadas. A Spring criará instâncias de proxy durante a operação para implementar as operações definidas em nossa interface.
Sobre o subprojeto de dados da primavera
Os dados do Spring possuem muitos subprojetos, além do Spring Data JPA, também existem os seguintes subprojetos.
Spring Data Commons
Dados da primavera MongoDB
Dados da primavera redis
Spring Data Solr
Spring Data Gemfire
REST DADOS DA PRIMAÇÃO
Dados da primavera neo4j
Sobre a primavera JPA
Os dados da primavera JPA são um sub-projeto de dados da mola. É usado principalmente para simplificar a implementação da camada de acesso a dados. Usando o Spring Data JPA, você pode implementar facilmente adição, exclusão, modificação, paginação, classificação etc.
Exemplo, bota de primavera + dados de mola jpa
1. Adicione o arquivo pom.xml
Como mostrado abaixo:
<? xml versão = "1.0" coding = "utf-8"?> <Projeto xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.ww3.org/2001/xmlschaMance xsi: schemalocation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <lodelversion> 4.0.0 </modelversion> <poroud> com.exemple </groupidrsion> 4.0.0 </modelversion> <vroupId> com.exemple </groupid> <Versão> 0.0.1-SNAPSHOT </Version> <batyaging> jar </acheging> <name> Spring-Data-jpa-Exemplo </Name> <cription> Projeto Demo para Boot Spring </cription> <DorfactId> <rugnid> org.springframework.boot </groupid> <ArtifactId> <runer-sersiSs-SERSSTARTER-PARTRONT- <RelityPath/> <!-Lookup Parent from Repository-> </axer> <Properts> <Project.build.sourceEncoding> utf-8 </project.build.sourceEncoding> <javputpatencoding.outputEncoding> utf-8 </project.reporting.outputing. </properties> <dependencies> <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> <pendência> <puperid> org.springframework.boot </frugiD> <TRATIFACTID> Spring-boot-starter-test </artifactId> <cope> teste </scope> </dependency> <pendency> <voundid> mysql </proupid> <Tristifactid> mysqlclcncnnonk> <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> </bilt> </ject>
Entre eles, o Spring-Boot-Starter-Parent carregará todas as configurações padrão exigidas pelo aplicativo de inicialização da primavera;
Spring-Boot-Starter-Data-JPA baixará todas as dependências exigidas pelo Spring Data JPA;
Adicione a Spring-Boot-Starter-Web porque nosso projeto é um aplicativo da Web;
Além disso, nosso banco de dados é MySQL, portanto, também é necessária a dependência do MySQL-Connector-Java;
Como o cache é usado, adicione outra dependência do cache do Spring-Boot-Starter;
2. Escreva o usuário da entidade
pacote com.example.Domain; importar java.io.Serializable; importar javax.persistence.column; importar javax.persistence.entity; importar javax.persistence.id; import javax. O usuário implementa serializável {private estático final serialversionuid = 1L; @ID Long Id; @Column (name = "name") string name; @Column (name = "endereço") endereço da sequência; public Long getId () {return id; } public void setId (longo id) {this.id = id; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } public string getAddress () {retornar endereço; } public void setAddress (endereço da string) {this.address = endereço; }}Não há mais nada a dizer. Preste atenção à anotação @NamedQuery aqui. Significa aproximadamente que o método FindByName que definimos na interface do repositório não usa a implementação de consulta padrão, mas usa essa instrução de consulta personalizada para consultar. Se não houver anotação aqui, a implementação padrão será usada.
3. Escreva a interface do repositório
Aqui, escreveremos duas interfaces de repositório, que são usadas apenas para exemplos, e podem ser mescladas em uma na prática:
UserJparePository
pacote com.example.repository; importar org.springframework.data.jpa.repository.jparepository; importação com.example.domain.user; interface pública userjparepository estende jparepository <usuário, long> {}A interface UserJparePository aqui implementa a interface jparepository;
De fato, o jparepository implementa a interface PagingAndSortingRepository, a interface PagingAndSortingRepository implementa a interface Crudrepositório e a interface Crudrepositório implementa a interface do repositório;
Uma breve explicação:
A interface do repositório é uma interface de identificação e está vazia por dentro;
A interface Crudrepositório define os métodos de adição, exclusão, modificação e pesquisa;
A interface PagingAndSortingRepository é usada para paginação e classificação;
Como a interface jparepositório herda todas as interfaces acima, ela possui todos os métodos declarados por eles;
Observe também que, em busca do método FindAll como exemplo, a lista de retorna da interface jparepository, PagingAndSortingRepository e Crudrepository Return Iterator;
UserRepository
pacote com.example.repository; importar java.util.list; importar org.springframework.data.jpa.repository.Query; importar org.springframework.amata.repository.repository; importrg.springframework.data.repository.repository; import org.sprworkworksworks; UserRepository estende o repositório <user, long> {list <suser> findBynamAndDress (nome da string, endereço da string); @Query (value = "do usuário u wheren nome =: name") list <suser> findbyname1 (@param ("name") nome da string); @Query (value = "Selecione * de #{ #entityName} u where u.name =? 1", nativeQuery = true) list <suser> findByname2 (nome da string); Lista <suser> findByName (nome da string);}A interface do userRepository aqui define principalmente alguns métodos de consulta;
Por exemplo, podemos executar diretamente sem definir outras declarações de consulta aqui. Os dados da primavera JPA implementarão automaticamente o método com base no nome do atributo e no nome do método da classe de entidade; PS: Como declaramos a anotação @NamedQuery na classe de entidade, de fato, o método FindByName usará a declaração de consulta anotada pela anotação @NamedQuery para consulta;
Além disso, o método findByName1 aqui usa a consulta HQL;
O método findByName2 usa a consulta de instrução SQL original;
4. Escreva serviço
Interface de serviço:
pacote com.example.service; importar java.util.list; importar com.example.Domain.User; interface pública IUSERSERVICE {public list <suser> findall (); public void saveuser (livro do usuário); usuário público findOne (longo id); Public Void Delete (Long ID); Lista pública <suser> findByName (nome da string);}Classe de implementação da interface:
pacote com.example.service.impl; importar java.util.list; importar org.springframework.beans.factory.annotation.autowired; import org.springframework.cache.annoTation.cacheable; import.sPringFrameWork.TeReTypeTyPe.Service; com.example.Domain.User; importar com.example.repository.UserRepository; importar com.example.repository.UserJparePository; importação com.example.service.iusserService;@Service@transactalPublic Classe UserviceImpl implementing Isertatory Isertatory {@AutoTowired private @AUTOWIRED PRIVADO PRIVADO PRIVRADOREPOSIITY USERPOSIENTY; list public <suser> findAll () {return userjparepository.findall (); } list public <suser> findByName (nome da string) {list <suser> userList1 = userRepository.findbyname1 (nome); LIST <usery> userList2 = userRepository.findbyname2 (nome); LIST <usery> userList3 = userRepository.findbynameanddress (nome, "3"); System.out.println ("UserList1:" + UserList1); System.out.println ("UserList2:" + UserList2); System.out.println ("UserList3:" + UserList3); return userRepository.findbyname (nome); } public void saveUser (livro do usuário) {userjparepository.save (livro); } @Cacheable ("usuários") public user findOne (longo id) {system.out.println ("páginas em cache"); return userjparepository.findone (id); } public void Delete (longo id) {userJparePository.Delete (ID); }}Não há nada a dizer sobre isso, basta chamar o método da interface do repositório.
5. Escreva controlador
Não há nada a dizer sobre o controlador, basta ligar para o serviço. Observe que o controlador aqui é anotado usando a anotação @restcontroller, e o nome do caminho da URL é nomeado de acordo com o estilo RESTful;
pacote com.example.web; importar java.util.list; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.web.bind.annotation.pathiable; import org.springframework.web.bind.bind.bind.bind.paths; org.springframework.web.bind.annotation.restcontroller; importar com.example.domain.user; importar com.example.service.iusserService;@RestController@requestMapping (value = "Users") public classe userController {@autired private iSerSerService; @RequestMapping (value = "/add/{id}/{name}/{endereço}") public user addUser (@pathvariable int id, @pathvariable string nome, @pathvariable string endereço) {user user = new user (); user.setId (id); user.setName (nome); user.setAddress (endereço); UserService.SaveUser (Usuário); devolver usuário; } @RequestMapping (value = "/Delete/{id}") public void Deletebook (@PathVariable int id) {Userservice.Delete (ID); } @RequestMapping (value = "/") list <vuária> getBooks () {return userservice.findall (); } @ReQuestMapp (value = "/{id}") public user getUser (@pathvariable int id) {usuário user = userservice.findone (id); devolver usuário; } @ReQuestMapping (value = "/search/name/{name}") list public <suser> getBookByName (@Pathvariable String nome) {list <suser> users = userService.findbyName (nome); devolver usuários; }}6. Configure o DataSource
Adicione a seguinte configuração ao arquivo Application.Properties:
spring.jpa.show-sql = truelogging.level.org.springframework.data = dencuGspring.jpa.hibernate.ddl-auto = spring.datasource.url = jdbc: mysql: // lochost: 33 06/Demospring.datasource.username = rootspring.datasource.password = rootspring.datasource.driver-class-name = com.mysql.jdbc.driver
Se você usar o STS IDE, essas configurações de atributo serão solicitadas automaticamente, para que você possa salvar pesquisas.
Se você deseja visualizar a configuração do spring.dataSource, pode consultar esta classe: DataSourceProperties.java
7. Escreva uma aula de inicialização
É relativamente simples. Observe que o nível do pacote ao qual essa classe pertence deve ser maior ou igual a outras classes para garantir que as anotações de outras classes possam ser digitalizadas.
pacote com.example; importar org.springframework.boot.springApplication; importar org.springframework.boot.autoconfigure.springbootapplication; importação org.springframework.cache.annotation.notation.Clemplicing;@springbootApplication @ableCachingworking.cache.annotation.enablecaching; springPplication @ableCaching.cache.cache.annotation.enablecaching; springPplatication @ableCaching.cache.cache.annotation.enablecaching; springPplication @ableCaching.CacheMation.annotation.enablecaching; springPplication @fablecachings. void main (string [] args) {springapplication.run (springdatajpaexampleApplication.class, args); }}Execute e teste o programa
Inicie o método principal ou digite -o em um pacote JAR para ser executado;
Digite o seguinte URL no navegador e teste -o:
http: // localhost: 8080/usuários/
http: // localhost: 8080/usuários/add/100/110/111
http: // localhost: 8080/usuários/delete/100
http: // localhost: 8080/usuários/2
http: // localhost: 8080/usuários/pesquisa/nome/2
Código fonte do programa
https://github.com/peterchenhdu/spring-data-jpa-example
Referências
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/
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.