Este artigo apresenta um exemplo de construção da Building Spring+Spring MVC+JPA para Maven Project. É compartilhado com você. Os detalhes são os seguintes:
Adicione o suporte à inicialização da primavera e apresente pacotes relacionados:
1. O projeto MAVEN é indispensável para pom.xml. Para a introdução do Spring Boot, consulte o site oficial:
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.9.RELEASE</version> </parent> <dependencies> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <COPE> fornecido </cope> <!-compilar e publicar pacotes de jar indesejados-> </dependency> <pendence> <puperid> org.springframework </frugiD> <ArtifactId> spring-webmvc </ArtifactId> </dependency> <purvion> <voundid> ourg.springframework.Brot.Brot.BringFame.BringFame.BringFame.BringFame.Blame.Bl. </ArtifactId> Spring-Boot-Starter-Web </starfactId> </dependency> <!-JPA Jar <GrupId> org.springframework.boot </roupiD> <TRATIFACTID> Spring-boot-Starter-Data-Redis </ArtifactId> </Dependency> <!-MySQL Driver-> Dependency> <vroupId> mySql </Grupoid> <FarifactId> <Sepenty> <voundid> MySQL </Grupoid> <Farifactid> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.2.2</version> </dependency> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.2.2</version> </dependency> <!-- shiro ehcache -> <Depencency> <roupidId> org.apache.shiro </groupiD> <TRATIFACTID> shiro-ehcache </artifactId> <versão> 1.2.2 </versão </dependency> </dependencies> <bruct> <clugins> <plugId> org.springFramework.Boot </grupo> artiftft> <tgins> <plugId> org.springFramework.Boot </grupo> artiftft> <Comestuions> <Execution> <tecies> <Goal> reembalagem </as Goal> </metas> </secution> </execuções> </plugin> </plugins> <finalName> nome </finalName> </fruct>
2. O código acima introduz a inicialização da mola. Spring MVC e JPA, bem como Jar Driver para o banco de dados MySQL;
Escreva uma aula de inicialização e instale o arquivo de configuração:
1. A aula de inicialização é a seguinte:
importar org.springframework.boot.springApplication; importar org.springframework.boot.autoconfigure.enableAutoconfiguration; importar org.springframework.boot.autoconfigure.springbootApplication; org.springframework.data.jpa.repository.config.enablejpauditing; importar java.io.ioexception; importar com.my.config.commonproperties;@shingbootapplication@enabautoconfiguration@enabajpaudition] thringbootapplication@enabautoconfiguration@enabajpaAditingPlicpublic Application {publicleAtoconfiguration@enabajpaAditingP) loc = Commonproperties.loadProperties2System (System.getProperty ("spring.config.Location")); System.getProperties (). SetProperty ("Application.version", CommonProperties.getVersion (Application.class)); System.getProperties (). SetProperty ("App.home", loc + "/.."); SpringApplication.run (application.class, args); }}2. Coloque o arquivo de configuração fora do caminho de classe para facilitar a modificação sem reembalar. Os projetos de inicialização da primavera geralmente são transformados em pacotes JAR:
importar java.io.file; importar java.io.fileInputStream; importar java.io.ioException; importar java.util.properties; importar org.springframework.util.stringutils; public class. public static final string default_app_home = "./"; public static final string getApphome () {return System.getProperty ("./", "./"); } public static string loadProperties2System (localização da string) lança IoException {String configLocation = Location; Arquivo cnf; if (! stringUtils.haslength (location)) {configLocation = "./config"; CNF = novo arquivo (configlocation); if (! cnf.exists () ||! cnf.isdirectory ()) {configLocation = "../config"; CNF = novo arquivo (configlocation); }} else {cnf = novo arquivo (localização); } Arquivo [] arg2 = cnf.listfiles (); int arg3 = arg2.Length; for (int arg4 = 0; arg4 <arg3; ++ arg4) {arquivo file = arg2 [arg4]; if (file.isfile () && file.getName (). endswith (". Propriedades")) {Propriedades ppt = new Properties (); FileInputStream fi = new FileInputStream (arquivo); Arg8 arg8 = nulo; tente {ppt.load (fi); System.getProperties (). Putall (ppt); } catch (arg17 argable) {arg8 = arg17; jogar arg17; } finalmente {if (fi! = null) {if (arg8! = null) {try {fi.close (); } catch (arg16) {arg8.addsuprimido (arg16); }} else {fi.close (); }}}} retornar configlocation; } public static string getversion (classe <?> clazz) {pacote pkg = clazz.getpackage (); String ver = pkg! = Nulo? pkg.getImplementationVersion (): "indefinido"; retornar ver == null? "indefinido": ver; }Coloque o arquivo de configuração na pasta de configuração do diretório do pacote JAR no mesmo nível, incluindo configuração de log, arquivo Application.yml, outros arquivos de configuração, etc.;
Escreva classes de configuração automática
Usado para digitalizar a empresa*, em vez do arquivo de configuração Spring.xml da Spring MVC:
importar org.springframework.context.annotation.comONENTSCAN; importar org.springframework.context.annotation.configuration;@configatury@componentscan (BasEpackages = {"com.my.rs", "com.my.service", "com.my.reposy.my.my.rs", "com.my.my.service", "com.my.rep.repos" org.springframework.boot.autoconfigure.web.httpmessageConverters; importar org.springframework.context.annotation.bean; importar org.springframework.context.annotation.configuration; importação org.springframework.web.servlet.config.annotation.resourceHandlerRegistry; importar org.springframework.web.servlet.config.annotation.webmvcconfigureRadApter;/** ** ** precenfiguration**/@ @Bean público httpmessageConverters customConverters () {return httpMessageConverters (); } @Override public void AddResourceHandlers (Recurso-HandlerRegistry Registry) {//registry.addresourceHandler("/** ") // .addresourcelocations (" Classpath:/meta-Inf/Resources/** "); }Escreva RS, Serviço, Repositório
package com.my.rs;import java.util.List;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.requestparam; importar org.springframework.web.bind.annotation.Responsebody; importar com.my.entity.user; @requestmapping ({"/api/user"}) interface pública userrs { @RequestMapping (value = "/add", método = {requestMethod.post}) @ResponseBody Public User SaveUser (usuário do usuário do @RequestBody); @RequestMapping (Value = "/Update", Method = {requestMethod.Post}) @ResponseBody Public User UpdateUser (usuário do usuário do @RequestBody); @RequestMapping (Value = "/Delete", Method = {requestMethod.Post, requestMethod.Delete}) public void DeleteUser (@RequestParam String [] UserIDS); @RequestMapping (Value = "/get", Method = {requestMethod.get}) @ResponseBody Public User GetUser (@RequestParam String UserID); @RequestMapping (value = "/Query/all", Method = {requestMethod.get}) list <vsery> queryall (); @RequestMapping (Value = "/Query/Byname", Method = {requestMethod.get}) Lista pública <suser> querybyName (@RequestParam String Name); @RequestMapping (value = "/Query/byParentId", Method = {requestMethod.get}) Lista pública <suser> QueryChildren (@RequestParam String parentid); // sem parâmetro paginação query @requestMapping (value = "/query/page", método = {requestmethod.get}) list <vsery> querybypage (@RequestParam int pageno, @RequestParam Int Pagesize, @RequestBody (exigido) usuário); package com.my.rs.impl;import java.util.List;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.restcontroller; importar com.my.entity.user; importar com.my.rs.userrs; import com.my.service.userService; @RestControllerPublic Classe userrSImplPlemmentsMerRSerS.GerStrice; publicger Logger Logger. @Autowired UserService _userService; @Override Public User SaveUser (usuário do usuário do @RequestBody) {Try {return _userService.Save (Usuário); } catch (throwable e) {logger.error (e.getMessage (), e); jogar e; }} @Override updateUser do usuário público (usuário do usuário do @RequestBody) {return _userService.update (usuário); } @Override public void DeleteUser (String [] UserIDS) {for (string userID: userIDs) {_userService.deleteById (UserID); }} @Override list public <suser> queryall () {return _userService.Queryall (); } @Override Public List <suser> querybyName (nome da string) {return _userService.findbyName (nome); } @Override Public List <suser> querychildren (string parentid) {return _userService.findbyparentId (parentid); } @Override Public User GetUser (string userID) {return _userService.findbyId (userID); } @Override Public List <suser> querybypage (int pageno, int PageSize, usuário do usuário) {return null; }} pacote com.my.service; importar java.util.list; importar org.springframework.beans.factory.annotation.autowired; importar org.springframework.steroType.Service; import com.my.entity.user; import.my.repository.UserRePository; BaseService <suser> {@aUTowired UserRepository _UserRepository; Lista pública <suser> findByName (nome da string) {return _userRepository.findbyName (nome); } list public <suser> findByparentId (string parentid) {return _userRepository.findbyparentId (parentid); }} pacote com.my.repository; importar java.util.list; importar com.my.entity.User; interface pública userRepository estende BaseRpository <suser> {list <suser> findByName (nome da string); Lista <suser> findByparentId (String parentid);}O acima adota um modelo em camadas, que é um pouco pesado, mas é mais conveniente modificar a lógica de negócios de cada camada posteriormente.
As aulas relacionadas à JPA são as seguintes:
pacote com.my.service; importar java.io.Serializable; importar javax.persistence.entityManager; import javax.transaction.transaction; importar org.springframework.bean.factory.annotation.autowired; BaseService <e estende serializável> {@aUTowired BaseRepository <e> _baseRepository; @Autowired EntityManager Em; public E Save (e baseUnit) {return _BaseRepository.SaveAndflush (BaseUnit); } public e atualização (e baseUnit) {return _BaseRepository.SaveAndflush (baseUnit); } public void DeleteById (string id) {_baseRepository.Delete (ID); } public java.util.list <E> queryall () {return _baseRepository.findall (); } public e findById (string id) {return _baseRepository.getone (id); }} pacote com.my.repository; importar java.io.Serializable; importar org.springframework.data.jpa.repository.jparepository; importação org.springframework.data.repository.norepositoryBean; @norePositionBeanPaRFUBLICCUBLICCUBLICIC.Repository.norepositório; Serializable> {}Classe de entidade: relacionada aos campos de banco de dados, você precisa prestar atenção à anotação na classe pai @mappedsuperclass
pacote com.my.entity; importar java.util.ArrayList; importar java.util.list; importar javax.persistence.Entity; importar javax.persistence.Manytomany; importação de org.hibernate.annotações.dynamicInsERt; importar.Inbanate.annotações.Dernate.annotações.dynicInsERt; importar.Inbanate.annotações.dynate.dynate.dynate. org.hibernate.validator.constraints.email; @entity (name = "db_user")@dynamicinsert@dynamicupdatepublic user user estende baseunit { / *** status da conta* / public static stickstatus { / ** *** / normal / inabable, // / *** -3101319619397064425L; senha de sequência privada; sal de corda privada; / ** status da conta*/ status de conta privada; / ** Email de autenticação*/ @EMAIL (message = "User.Email Atributo deve cumprir o formato de email") email de sequência privada; / ** Número do telefone celular*/ Private String mobileno; / ** Número de identificação*/ String privada CardID; @ManyTomany (TargetEntity = Role.class) Lista privada <String> Roleids; /** Apelido. Opcional. */ apelido de sequência privada; public String getCardid () {return CardID; } public String getEmail () {retornar email; } public string getMobileno () {return mobileno; } public String getNickName () {return apelido; } public string getPassword () {return senha; } public list <tring> getRoleIds () {if (roleids == null) {roleids = new ArrayList <> (); } retornar papéis; } public string getSalt () {return sal; } public AccountStatus getStatus () {retornar status; } public void setCardid (String cardId) {this.cardid = cardId; } public void setEmail (string email) {this.email = email; } public void setMobileno (String mobileno) {this.mobileno = mobileno; } public void setNickName (String apelido) {this.nickname = apelido; } public void setPassword (string senha) {this.password = senha; } public void setRoleids (list <string> roleids) {this.Roleids = roleids; } public void SetSalt (String sal) {this.salt = sal; } public void SetStatus (status da conta de conta) {this.status = status; }} pacote com.my.entity; importar java.io.Serializable; importar java.util.date; importar javax.persistence.id; importar javax.persistence.mappedsuperclass; importação javax.validation.constraints.notnull; importação javax.validation.Sonstraints.SansTants.SansTants.SansTants.SansTants.SansTants.SansTaints.SansTants.Sanstraints.Sanstraints.Sanstraints.SansTants.SansTants.SansTants.SansTants.SansTants.SansTants.SansTants.SansTants.SansTants.SansTants.SansTants.SansTants.SansTrax.SansTrax. org.springframework.data.annotation.createdby; importar org.springframework.data.annotation.createddate; importar org.springframework.data.annotation.lastmodifiedby; import org.springframework.data.annotation.lastmodifiedby; impornits; Serializável {@id @NotNull public String ID; / ** * ID da unidade pai */ @size (max = 32, message = "BaseUnit.ParentID Comprimento do atributo não pode ser maior que 32") public string parentid; / ** Tipo de unidade pai*/ public parenttype parenttype; / *** Nome da unidade*/ @NotNull (message = "BaseUnit.Name Attribute não pode estar vazio") Nome da sequência pública; @Createdby public string createby; @CreatedDate Data pública criada; @Lastmodifiedby public string lastModifiedby; / *** Última data atualizada*/ @LASTModifiedDate Data pública LastModifiedDate; public string getId () {return id; } public void setId (string id) {this.id = id; } / *** Obtenha o nome da unidade** @return obrigatória* / public string getName () {return name; } / ** * * @return uuid, excluindo {} e - * / public string getParentId () {return parentid; } public parenttype getParentType () {return parenttype; } public string getStationId () {return stationId; } public string getthumbnailid () {return thumbnailid; } public string getCreateBy () {return createby; } public void setCreateBy (String createby) {this.Createby = Createby; } public data getCreatedate () {return criatedate; } public void setCreatedate (data criado) {this.createdate = criatedate; } / ** * Defina o nome da unidade * * @param nome * requerido * / public void setName (nome da string) {this.name = name; } / ** * Defina o ID da unidade pai * * @param parentid * uuid, excluindo {} e - * / public void setParentId (String parentid) {this.parentId = parentid; } public String getLastModifiedBy () {return lastModifiedBy; } public void setLastModifiedBy (string lastModifiedby) {this.LastModifiedBy = lastModifiedBy; } public data getLastModifiedDate () {return lastModifiedDate; } public void setLastModifiedDate (date lastModifiedDate) {this.LastModifiedDate = lastModifiedDate; }}Arquivo de configuração:
Servidor: Porta: 16800 ContextPath:/Loging: Config: ./config/logback.xml Spring: http: Multipart: Enabled: False DataSource: URL: JDBC: MySQL: //127.0.0.1: 3306/db? Useunicode = True & Caracterem com.mysql.jdbc.driver jpa: banco de dados: mysql show-sql: true hibernate: ddl-auto: update Jackson: serialização: indent_output: true
#Hibernate: o comportamento específico da classe de entidade mantendo a estrutura da tabela de banco de dados. Atualização significa que, quando as propriedades da mudança de classe da entidade alteram, a estrutura da tabela será atualizada. Aqui também podemos levar o valor a criar. Isso cria significa que a última tabela gerada foi excluída na startup e regenerar a tabela de acordo com a classe da entidade. Neste momento, os dados da tabela anterior serão limpos; Ele também pode pegar o valor Criar-Drop, o que significa que a tabela é gerada com base na classe de entidade na inicialização, mas quando o Factory Session for fechado, a tabela será excluída; Validar significa que a classe de entidade e a tabela de dados são consistentes na inicialização; Não significa que nada é feito. #show-sql significa hibernate imprime a instrução SQL real no console ao operar #jackson significa saída formatada json string
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.