Este artigo apresentará o projeto Java mais básico, no Web Project, na integração de Spring, Springmvc, SpringDatajpa+Hibernate.
Geralmente, podemos construir um projeto através de um modelo ou importar um projeto diretamente. No entanto, este artigo escolhe começar com o projeto Java mais básico, com o objetivo de mostrar mais princípios.
Obviamente, ainda começamos com o projeto Maven mais básico. De fato, o processo de construção de projetos comuns não-maven é quase o mesmo. O pacote JAR precisa ser adicionado manualmente ao projeto, enquanto o projeto Maven apenas altera o arquivo de configuração.
O seguinte é iniciado oficialmente.
1. Crie o projeto Java mais básico com base no Maven (se você não usar o Maven, também pode usar projetos tradicionais)
Para criar um novo projeto, selecione Maven Project, Next:
Verifique como criar um projeto simples, próximo:
O ID do grupo é a ordem inversa do seu nome de domínio, que geralmente corresponde ao nome do pacote do código -fonte do projeto. O ID do artefato é o único nome do projeto neste ID do grupo. Pode ser preenchido de qualquer maneira de acordo com seus hobbies e depois terminar:
Este é o resultado da estrutura do diretório do projeto como esta:
pom.xml é o arquivo principal do Maven.
2. Defina o projeto para o modo dinâmico da Web
Em seguida, converta o projeto em um projeto da web, clique com o botão direito do mouse para abrir as propriedades do projeto, conforme mostrado na figura, clique em Facets do Projeto no menu à esquerda e, em seguida, clique em converter para facetados em ...:
À direita, marcamos o módulo da web dinâmico e clicamos em OK:
Neste momento, um diretório adicional do webContent aparecerá:
No diretório Web-Inf, adicione o arquivo web.xml, como segue:
<? xml versão = "1.0" coding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd "version =" 3.0 "> <lor-name> springdatajpa </libername-name> <lumer-File-list> <lorde-file> index.html </welcome> </-file>
Em seguida, adicione uma página de boas -vindas Index.html:
<html> <head> </head> <body> <h1> Olá palavra! </h1> </body> </html>
A estrutura do diretório é a seguinte:
Neste momento, você pode clicar com o botão direito do mouse no projeto e executar no servidor. Você pode ver o efeito:
3. Integre a primavera+Springmvc
Crie um novo pacote e adicione algumas interfaces e classes (o código específico será listado posteriormente). A estrutura do pacote é como mostrado na figura:
Se você precisar adicionar um pacote JAR, basta modificar o arquivo POM diretamente. Se for um projeto normal, basta adicioná -lo ao projeto pressionando o pacote JAR no pom.xml.
Primeiro, adicione a versão da primavera usada para facilitar o gerenciamento unificado e adicione todos os pacotes JAR necessários. O seguinte é adicionar todos os pacotes JAR necessários aqui. O Pom.xml concluído é o seguinte:
<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> <puperid> com.anxpp </groupiD> <stifactId> springdatajpa </stifactid> <sipers> <sersert> <stifthot> springdatajpa </stifactId> <sipers> 0,1-snapShot> springdatajpa </artifactid> <erpress> 0,1-snapShot> <pring.version> 4.2.5.Release </spring.version> </sperties> <pendências> <!-Spring Core Package-> <pendency> <voundid> org.springframework </foupid> <stifactId> spring-core </stifactid> <versão> $ {spring.version} </versão> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>${spring.version}</version> </dependency> <Depencency> <PuerpId> org.springframework </frugiD> <TROTIFACTID> Spring-tx </ArtifactId> <versão> $ {spring.version} </versão </dependency> <pendency> <purrgId> org.springframework </purfactid> <sersion> spring-jdbc </art. </dependency> <pendency> <puperid> org.springframework </frupiD> <TRAFACTID> spring-webmvc </artifactId> <versão> $ {spring.version} </version> </dependency> <pendency> <pringa> org.springFramework </suerDid> <stiftId> <spendency> primavera <pringa> org.springframework </brugid> <Versão> $ {spring.version} </version> </dependency> <pendency> <voundid> org.springframework </groupiD> <TROTIFACTID> spring-context-support </artifactId <versão> $ {spring.version} </versão </dependence> <pedence> <ursion> ou spring.version} </versão> </dependency> <ursion> <rugId> ou. <TRAFACTID> Spring-test </starifactId> <versão> $ {spring.version} </siers> </dependency> <pendency> <purboundid> org.springframework </frugid> <TRAFACTID> spring -form </artifactid> <versão> $ {spring.version} </versão> </dependência <PuerpId> org.springframework.data </foupidId> <TRAFACTID> Spring-Data-jpa </starfactId> <versão> 1.10.1.Adicione o arquivo de configuração do Spring ApplicationContext.xml no diretório Web-Inf e adicione o seguinte conteúdo:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/Context http://www.springframework.org/schema/Context/spring-context-4.2.xsd http://www.springframework.org/4.2.xsd http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd "> <!-ligue para ioc. MVC ANOTAÇÃO DO MVC-> <MVC: Anotação orientada /> </ Beans>
Modificar web.xml e adicione a mola a:
<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xmls/javaee/web-web-web-web-web-/java.sun.com/ <liber-name> springdatajpa </sisplay-name> <lister> <lister-class> org.springframework.web.context.contextLoaderListener </listener-class> </listener> <Context-Param> <amam-name> contextconfiglocation </param-name> <-value> <cleatjue> webam> <amam-name> contextconfiglocation </param-name> <-value> </context-param> <Vertlet> <Verlet-name> springmvc </servlet-name> <Servlet-class> org.springframework.web.servlet.dispatcherServlet </servlet-class> <itir--param> <amam-name> contextconfiglocation </paramname> <am-value-value> ClassLue> ClassLue> ClassLue> ClassLeT> ClassLeT*: SpringClocation </paramnEx-Vath-TinMel> ClassLue> ClassLeT> ClassLueM> </init-param> <adar load-on-startup> 1 </olload-on-startup> </servlet> <Servlet-mapping> <Verlet-Mapping> <Verlet-name> springmvc </servlet-nam </list-list> </web-App>
Vamos começar a escrever o código abaixo, tome cuidado para não esquecer de escrever as anotações, a hierarquia do pacote foi dada no início desta seção.
Usuário da entidade:
pacote com.anxpp.demo.core.entity; public class Usuário {ID inteiro privado; nome de string privado; usuário público (ID inteiro, nome da string) {this.id = id; this.name = nome; } public integer getId () {return id; } public void SetId (ID inteiro) {this.id = id; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } @Override public string tostring () {return "id:"+id+", nome:"+nome; }}Interface da camada do userdao:
pacote com.anxpp.demo.core.dao; importar com.anxpp.demo.core.entity.user; interface pública Userdao {user getUser (ID do número inteiro, nome da string);}A camada DAO implementa Userdaoimpl:
pacote com.anxpp.demo.core.dao.impl; importar org.springframework.tereotype.repository; importar com.anxpp.demo.core.dao.userdao; import com.anxpp.doMo.core.entity.emer; getUser (ID inteiro, nome da string) {return novo usuário (id, nome); }}Interface da camada de serviço UserService:
pacote com.anxpp.demo.core.service; importar com.anxpp.demo.core.entity.user; interface pública UserService {user getUser (ID do número inteiro, nome da string);}Implementação da camada de serviço:
pacote com.anxpp.demo.core.service.impl; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.tereotype.service; import com.anxpp.demo.core. com.anxpp.demo.core.service.userService; @ServicePublic Class UserServiceImpl implementa UserService {@AUTOWIRED UserDAO Userdao; @Override Public User GetUser (ID inteiro, nome da string) {return userdao.getUser (id, nome); }}Democontrolador da camada do controlador:
pacote com.anxpp.demo.controller; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.tereotype.controller; importação org.springframework.web.bind.annotation.requestMapping; org.springframework.web.bind.annotation.ResponseBody; importar com.anxpp.demo.core.service.userService;@controlador@requestmapping ("/") classe pública Democontroller {@autowired usersserviice; @RequestMapping ("/") @ResponseBody public String Index () {return "Index"; } @RequestMapping ("/getUser") @ResponseBody Public String getUser (ID inteiro, nome da string) {return userservice.getUser (id, nome) .tostring (); }}Não é possível executar diretamente no servidor, porque o pacote JAR não será lançado juntos, precisamos configurar o seguinte:
Clique com o botão direito do mouse no projeto para selecionar propriedades e configurá-lo de acordo com a figura abaixo:
Neste momento, você pode executar o teste, o efeito é o seguinte:
Neste ponto, ainda não operamos o banco de dados.
4. Adicione e retorne o suporte de dados do formato JSON
Agora, geralmente usamos o JSON como formato de transmissão de dados. Vamos adicionar suporte para devolver o JSON para Springmvc.
Primeiro, adicione o pacote JAR:
<dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.5.0</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.5.0</version> </dependency> <Depencency> <PuerpId> com.fasterxml.jackson.core </frupid> <ArtifactId> Jackson-Annotações </ArtifactId> <versão> 2.5.0 </sipers> </dependency>
Em seguida, reescreva o método getUser () da seguinte forma:
@RequestMapping ("/getUser") @ResponseBody Public Map <String, Object> getUser (ID do número inteiro, nome da string) {map <string, object> map = new hashmap <string, object> (); map.put ("estado", "sucesso"); map.put ("Data", UserService.getUser (id, nome)); mapa de retorno; }Após a reprise, o efeito de acesso é o seguinte:
Neste momento, você pode retornar os dados JSON.
5. Configure acesso estático de recursos
De um modo geral, não podemos acessar os recursos no diretório Web-Inf diretamente. Se nosso site for composto pelo HTML+AJAX, você poderá criar um novo diretório HTML fora do Web-Inf e configurar o filtro padrão para web.xml. No entanto, tenha cuidado para colocá -lo antes do filtro Springmvc:
<Verlet-mapping> <Verlet-name> padrão </servlet-name> <url-tattern>*.
Se você precisar acessar recursos no diretório da Web-Inf, verificando os documentos oficiais da Spring, você descobrirá que existem duas maneiras
1. Handatrita um mapeador de recursos:
@Configuration @EnableWebMvcPublic Classe WebConfig estende WebMVCConfigureRAdApter {@Override public void AddResourceHandlers (RecursondlerRegistry Registry) {Registry.addresourceHandler ("/Recursos/**") .AddResourCações "/Publicler ("/**). .setCacheControl (CacheControl.maxage (1, timeunit.hours) .cachepublic ()); }}Como você pode ver, você também pode definir o tempo de cache, e a maneira mais simples é configurar o XML:
<MVC: Recursos Mapping = "/Resources/**" Location = "/Public-RESOURCES/"> <MVC: Cache-Control Max-Arane = "3600" Cache-Public = "True"/> </MVC: Recursos>
Você também pode adicionar o seguinte:
<!-O acesso a arquivos de recursos estáticos será entregue ao manipulador de servlet padrão para processamento, acessando o caminho que não pode ser mapeado para o controlador-> <mvc: default-servlet-Handler />
6. Solução de código de lixo
Geralmente usamos o AJAX para enviar solicitações, mas também usamos a barra de endereços para testar diretamente. Solicitar envios Get and Post.
Envie solicitações usando o POST, geralmente não haverá código ilegal chinês, mas se o código distorcido aparecer, você poderá resolver o problema adicionando um filtro de codificação ao web.xml:
<Filter> <filter-Name> caracterencoding </filter-name> <filter-Class> org.springframework.web.filter.characterencodingFilter </ftrids-class> <itir-paparam> <amam-name> Encoding </param-name> <aparaM> utf-8 </param-value> <amam-name> forcencoding </param-name> <amam-value> true </param-value> </init-param> </filter> <filter-mapping> <filter-name> caracterencoding </filter-name> <url-tattern>/*</url-tattern> </filter-mapping>
O exposto acima só pode resolver o código de postagem chinês e chinês. Para GET (incluindo o método de envio direto da barra de endereços do navegador), precisamos modificar a configuração do TomCat, encontre -o no Server.xml no diretório conf e modifique -o da seguinte forma:
<Connector ConnectionTimeout = "20000" Port = "8080" Protocol = "http/1.1" Redirectport ("8443" uriencoding = "utf-8"/>Se estamos apenas testando e o projeto não estiver implantado, podemos encontrar diretamente o Server.xml no servidor no Eclipse e fazer as mesmas alterações acima:
7. Integre a SpringDatajpa+Hibernate
Você pode aprender sobre JPA: Introdução às especificações e exemplos da JPA (solução de persistência de dados Java)
SpringDatajpa também é uma solução tão leve e o hibernato preferido implementa JPA.
Primeiro de tudo, o pacote JAR, o pacote SpringDatajpa jar, foi adicionado ao integrar o Spring. Abaixo está o pacote JAR de Hibernate (e MySQL Driver).
<!-Hibernate-> <Depency> <PuerpId> org.hibernate </groupiD> <ArtifactId> hibernate-core </stutifactId> <versão> $ {hibernate.version} </sipers> </dependency> <pendency> <groupid> org.ibernate </grupidid> <stiftid> HUM HURATENATENATIDE </GroupIrate> </grupo> </dependency> <viceRenate> </siperStid> </dependência <version>${hibernate.version}</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-entitymanager</artifactId> <version>${hibernate.version}</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <TarifactId> hibernate-c3p0 </stifactId> <versão> $ {hibernate.version} </version> </dependency> <pendesency> <pupiid> mysql </groupid> <stifactId> mysql-conector-java </artifactid> <uses> 5.1.9A versão de gerenciamento unificada é:
<!-Hibernate Version Number-> <Hibernate.version> 5.1.0.Final </hibernate.version>
Adicione a persistência do arquivo de configuração da JPA ao diretório Meta-Inf. O banco de dados usa o MySQL ao apresentar este artigo. E adicione o seguinte conteúdo:
<?xml version="1.0" encoding="UTF-8"?><persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi: schemalocation = "http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence_1_0.xsd"> <persistence-nit name = "Demo" provedor> org.eclipse.persistence.jpa.persistenceProvider </provider-> <stroper> org.hibernate.ejb.hibernatePersistence </provider> <class> com.ninelephas.meerkat.pojo.user </class> <! name = "hibernate.connection.driver_class" value = "com.mysql.jdbc.driver"/> <propriedades name = "hibernate.connection.url" value = "jdbc: mysql: //127.0.1: 3306/Demo? CreatedAtAtAtaseIFNOnTexist =/127.0.1: 3306/Demo? CreatedAtAtaseIfnno name = "hibernate.connection.username" value = "root" /> <names name = "hibernate.connection.password" value = "root" /> <names name = "hibernate.dialect" value = "org.hibernate.dialect.mysqldialect" /> < /< /propriedades> < /persistência
O conteúdo completo após adicionar suporte ao JPA ao arquivo de configuração da primavera ApplicationContext.xml:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: mvc = "http://www.springframework.org/schema/mvc" xmlns: jpa = "http://www.springframework.org/schema/data/jpa" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd "> <!-ativar a ioc" compostation-> comanenten: /> <bean id = "entityManagerFactory"> <propriedade name = "jPavendorAdapter"> <Bean> <propriedade name = "generateddl" value = "true" /> <names name = "database" valuenen (mysql " /> </shean> < /propriedade> <names /" persistenceunitname ") Scan-> <mvc: anotação-driven/> <ean> <propriedade name = "viewResolvers"> <list> <ean> <propriedade name = "prefixi" value = "/web-inf/view/"/> <nome da propriedade = "sufixo". name = "defaultViews"> <lista> <bean/> </list> </property> </bean> <!-O acesso a arquivos de recursos estáticos deixará o caminho que não pode ser mapeado para o controlador para o manipulador de servlet padrão para o processamento-> <mvc: default -erl-handler/> <!-transação gerente-> Ref = "EntityManagerFactory" /> </ Bean> <!-Ativar transação de anotação-> <tx: transação acionada por anotação-manager = "transação
Modifique a entidade:
pacote com.anxpp.demo.core.entity; importar javax.persistence.entity; importar javax.persistence.GeneratedValue; importar javax.persistence.generationTyPe; GenerationType.auto) ID inteiro privado; nome de string privado; public user () {} public user (nome da string) {this.name = name; } public integer getId () {return id; } public void SetId (ID inteiro) {this.id = id; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } @Override public string tostring () {return "id:"+id+", nome:"+nome; }}Você pode excluir a implementação da camada DAO. Lembramos de herdar a interface da camada DAO do poderoso jparepository:
interface pública userdao estende jparepository <usuário, serializable> {user findbyId (ID inteiro);}Parece particularmente conciso e não requer a implementação da escrita? SpringDatajpa nos ajudará automaticamente a concluí -lo.
Modifique a interface da camada de serviço:
pacote com.anxpp.demo.core.service; importar java.util.list; importar com.anxpp.demo.core.entity.user; interface pública UserService {user findbyId (ID inteiro); Usuário salvar (nome da string); Lista <suser> findAll ();}Modifique a implementação da camada de serviço:
pacote com.anxpp.demo.core.service.impl; importar java.util.list; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.tereotype.service; com.anxpp.demo.core.entity.user; importar com.anxpp.demo.core.service.userService; @ServicePublic Class UserServiceImpl implementa UserService {@AUTOWIRED UserDAO UserDAO; @Override Public User FindById (ID de Inteiro) {return userdao.findbyId (ID); } @Override Public User Save (nome da string) {return userdao.save (novo usuário (nome)); } @Override Public List <suser> findAll () {return userdao.findall (); }}Modifique o controlador para fornecer várias interfaces de teste:
pacote com.anxpp.demo.controller; importar java.util.hashmap; importar java.util.map; importar org.springframework.beans.factory.annotation.autowired; importestringfringframework.teroType.Controlller; import.springfringfringfringfringframework.teroType.Controlller; import.springfringfringfringfringfringframework.terotepe org.springframework.web.bind.annotation.ResponseBody; importar com.anxpp.demo.core.service.userService;@controlador@requestmapping ("/") classe pública Democontroller {@autowired usersserviice; @RequestMapping ("/") @ResponseBody public String Index () {return "Index"; } @RequestMapping ("/info") public String info () {return "info"; } @RequestMapping ("/findall") @ResponseBody Public Map <String, Object> getUser () {map <string, object> map = new hashmap <string, object> (); map.put ("estado", "sucesso"); map.put ("Data", UserService.findall ()); mapa de retorno; } @ReQuestMapping ("/findById") @ResponseBody Public Map <String, Object> findById (ID do número inteiro) {map <string, object> map = new Hashmap <string, object> (); map.put ("estado", "sucesso"); map.put ("Data", UserService.findbyId (ID)); mapa de retorno; } @ReQuestMapping ("/add") @ResponseBody Public Map <String, Object> Salvar (nome da string) {map <string, object> map = new hashmap <string, object> (); map.put ("estado", "sucesso"); map.put ("Data", UserService.Save (nome)); mapa de retorno; }}Efeito de corrida:
Então, e se você precisar adicionar dados que procuram um sobrenome especificado com um ID maior que o valor especificado?
Se for SQL, escreveremos dessa maneira (? Representa parâmetros):
Selecione * do usuário onde ID>? E nome como '?%';
Mas aqui, nem precisamos escrever SQL (ou HQL) e apenas adicionar um método à interface da camada DAO:
Lista <suser> findByidGreaterthanandnamelike (ID inteiro, nome da string);
Você não precisa duvidar que o método acima seja bem -sucedido se for executado (Nota: use a implementação do serviço, lembre -se de nome+"%" ao chamar esse método)!
O exposto acima é o conhecimento relevante apresentado a você sobre a construção de Springmvc+SpringDatajpa+Hibernate a partir do projeto Java mais básico. Espero que seja útil para todos. Se você quiser saber mais informações, preste atenção ao site wulin.com!