Este artículo presenta un ejemplo de Building Spring Boot+Spring MVC+JPA para el proyecto Maven. Se comparte contigo. Los detalles son los siguientes:
Agregar soporte de arranque de primavera e introducir paquetes relacionados:
1. El proyecto Maven es indispensable para pom.xml. Para la introducción de Spring Boot, consulte el sitio web oficial:
<Parent> <MoupRoD> org.springframework.boot </proupid> <artifactid> spring-boot-starter-parent </arfactid> <version> 1.5.9.release </versión> </parent> <pendencies> <pendency> <proupid> javax.servlet </proupid> <artifactid> javax.servlet-api </artifactil> <cope> proporcionó </cope> <!-compilar y publicar paquetes jar no deseados-> </pendency> <pendency> <uproupid> org.springframework </groupid> <artifactid> spring-webmvc </arfactid> </pendency> <epardency> <grupid> org.springframe.boot </groupid> <artifactID> spring-boot-starter-web </artifactid> </pendency> <!-JPA Jar Package, operando la base de datos-> <pendency> <MoupRupid> org.springframework.boot </groupId> <artifactID> spring-boot-data-data-jpa </artifactid> </pendency> <spendency> <MoupRid> org.springframework.boot </groupid> <artifactid> spring-boot-starter-data-redis </arfactid> </pepertency> <!-MySQL Driver-> <Spendency> <ProupId> MySQL </GroupId> <ArtifactiD> mySql-Connector-Java </artifactid> <//Dependency> <MoupRid> org.apache.shiro </proupid> <artifactid> shiro-core </artifactid> <versions> 1.2.2 </verSion> </pendency> <pendency> <proupid> org.apache.shiro </proupid> <artifactid> shiro-spring </artifactid> <versions> 1.2.2 </versión> </dependiente <! -> <Spendency> <MoupRoD> org.apache.shiro </groupid> <artifactid> shiro-ehcache </artifactid> <verserse> 1.2.2 </versión> </pendency> </pendencs> <stract> <glugins> <proupid> org.springframework.boot </proupid> <artifactid> <Excacionions> <Esecution> <SoTe> <SoT> Repackage </meta> </metas> </secution> </ecucesions> </tugin> </plugins> <finalName> name </finalName> </bield>
2. El código anterior presenta el arranque de primavera. Spring MVC y JPA, así como un tarro de controlador para la base de datos MySQL;
Escriba una clase de inicio e instale el archivo de configuración:
1. La clase de inicio es la siguiente:
importar org.springframework.boot.springapplication; import org.springframework.boot.autoconfigure.enableautoconfiguration; import og.springframework.boot.autoconfigure.springbootapplication; import org.springframework.data.jpa.repository.config.enablejpaauditing; import java.io.ioException; import com.my.config.commonproperties;@springbootapplication 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 el archivo de configuración fuera del classpath para facilitar la modificación sin reempaquetar. Los proyectos de arranque de primavera generalmente se convierten en paquetes JAR:
import java.io.file; import java.io.fileInputStream; import java.io.ioexception; import java.util.properties; import org.springframework.util.stringutils; pública clase final CommonProperties {public static static final string ppt_key_app_home = "app.home"; public static final String Default_app_home = "./"; public static final String getAppHome () {return System.getProperty ("./", "./"); } public static String LoadProperties2System (ubicación de cadena) lanza IOException {String configLocation = ubicación; Archivo cnf; if (? cnf = nuevo archivo (configLocation); if (! cnf.exists () ||! cnf.isDirectory ()) {configLocation = "../config"; cnf = nuevo archivo (configLocation); }} else {cnf = nuevo archivo (ubicación); } Archivo [] arg2 = cnf.listFiles (); int arg3 = arg2.length; para (int arg4 = 0; arg4 <arg3; ++ arg4) {file file = arg2 [arg4]; if (file.isfile () && file.getName (). Endswith (". Properties")) {Properties ppt = new Properties (); FileInputStream fi = new FileInputStream (archivo); Arg8 de lanzamiento de lanzamiento = nulo; intente {ppt.load (fi); System.getProperties (). Putall (PPT); } catch (Throwable Arg17) {arg8 = arg17; arrojar arg17; } Finalmente {if (fi! = null) {if (arg8! = null) {try {fi.close (); } catch (Throwable Arg16) {arg8.addsupressed (arg16); }} else {fi.close (); }}}} return configLocation; } public static string getVersion (class <?> Clazz) {paquete pkg = clazz.getpackage (); Cadena ver = PKG! = NULL? pkg.getImplementationVersion (): "Undefinado"; return ver == nulo? "Undefinado": ver; }Coloque el archivo de configuración en la carpeta de configuración del directorio del paquete JAR en el mismo nivel, incluida la configuración de registro, el archivo Application.yml, otros archivos de configuración, etc.;
Escribir clases de configuración automática
Se utiliza para escanear la compañía*, en lugar del archivo de configuración Spring MVC Spring.xml:
importar org.springframework.context.annotation.componentscan; import org.springframework.context.annotation.configuration;@configuration@componentscan (basepackages = {"com.my.rs", "com.my.service", "com.my.Repository"}) de clase pública appAutoconfonfonfigure org.springframework.boot.autoconfigure.web.httpmessageConverters; import org.springframework.context.annotation.bean; importar org.springframework.context.annotation.configuration; import og.springframework.web.servlet.configannotation org.springframework.web.servlet.config.annotation.webmvcconfigurerAdapter;/*** preconfiguration**/ @configurationPublic de clase myConfiguration extiende webMVCConfigurerAdapter {@Bean public HttpMessageConverters CustomConverters () {return New HttpMMess () } @Override public void addResourceHandlers (Registry de recursos de HandshandlerRegistry) {//registry.addresourceHandler("/** ") // .addResourcelocations (" classpath:/metainf/recursos/** "); }Escribir RS, servicio, repositorio
paquete 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.requestparam; import org.springframework.web.bind.annotation.responseBody; import @RequestMapping (valor = "/add", método = {requestmethod.post}) @ResponseBody User Public User SaveUser (@RequestBody User User); @RequestMapping (valor = "/update", método = {requestMethod.post}) @ResponseBody User UpdateUser (@RequestBody User User); @RequestMapping (valor = "/delete", método = {requestmethod.post, requestmethod.delete}) public void deleteuser (@RequestParam String [] userIds); @RequestMapping (valor = "/get", método = {requestmethod.get}) @ResponseBody User Public User GetUser (@RequestParam String userId); @RequestMapping (value = "/query/all", método = {requestMethod.get}) Lista pública <serem> QUIERYALL (); @RequestMapping (value = "/QUERY/BYNAME", Method = {requestMethod.get}) Lista pública <Ser User> QueryByName (@RequestParam String Name); @RequestMapping (valor = "/consulta/byparentid", método = {requestMethod.get}) Lista pública <seremir> QueryChildren (@RequestParam String ParentId); // Sin consulta de paginación de parámetros @RequestMapping (valor = "/consulta/página", método = {requestMethod.get}) Lista pública <seremy> QueryByPage (@RequestParam INT Pageno, @RequestParam int Pagesize, @RequestBody (requerido = Falso) usuario);} paquete com.my.rs.impl; import java.util.list; import org.slf4j.logger; import org.slf4j.loggerFactory; import org.springframework.beanss.factory.annotation.aUtowired; import org.springframework.web.bind.annotation.requestbody; import org.springframework.web.bind.annotation.restController; import com.my.entity.user; import com.my.rs.userrs; import com.my.service.userService; @restcontrollerpublic clase userRsImplmpleml implementa userrs {lo público logger = loggerFactory.getLogger (userM.ClAsPlIms implementa userrs {lo público logger = loggerFactory.getLogger (userM.ClAsPLIMS.CLASSMAss; @AutoWired UserService _Userservice; @Override Public User SaveUser (@RequestBody User User) {try {return _userservice.save (usuario); } catch (lanzable e) {logger.error (e.getMessage (), e); tirar E; }} @Override Public User UpdateUser (@RequestBody User User) {return _Userservice.Update (usuario); } @Override public void DeleteUser (String [] UserIds) {for (String UserId: UserIds) {_Userservice.DeleteById (userId); }} @Override Public List <Serer> QUIERYALL () {return _userservice.queryAll (); } @Override Public List <Serer> QueryByName (nombre de cadena) {return _userservice.findByName (nombre); } @Override Public List <Ser User> QueryChildren (String ParentId) {return _userservice.findbyParentId (parentId); } @Override Public User GetUser (String UserId) {return _userservice.findById (userId); } @Override Public List <Serer> QueryByPage (int Pageno, int PageSize, usuario de usuario) {return null; }} paquete com.my.service; import java.util.list; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.stereotype.service; import com.my.entity.user; import com.my.repository.userRepository; @ServicePepeServiceService Extends ExtENDES @AUtowired UserRepository _UserRepository; Lista pública <serem> findByName (nombre de cadena) {return _usErRepository.FindByName (nombre); } Lista pública <serem> FindByParentId (String ParentId) {return _userRepository.FindByParentId (ParentId); }} paquete com.my.repository; import java.util.list; import com.my.entity.user; interfaz pública userRepository extiende BaseRepository <serer> {list <serer> findByName (nombre de cadena); Lista <serem> FindByParentId (String ParentId);}El anterior adopta un modelo en capas, que es un poco engorroso, pero es más conveniente modificar la lógica comercial de cada capa más adelante.
Las clases relacionadas con JPA son las siguientes:
paquete com.my.service; import java.io.Serializable; import javax.persistence.entityManager; import javax.transaction.transactional; import org.springframework.beans.factory.annotation.aUtowired; import com.my.repository.baserePosterory;/*** algunos métodos comunes son puttéjuse*/@transaccional*/@transaccionAtal@transaccionAts@transaccionAts@transaccionAl@transaccional*/@transaccional@transaccional@transaccional@transaccionAts@transaccionAl@transaccionAl@transaccionAt@transaction BaseService <e extiende serializable> {@aUtowired BaseRepository <E> _BASEPository; @Autowired EntityManager EM; public e save (e baseUnit) {return _basePository.saveandflush (baseUnit); } public E Update (e baseUnit) {return _basePository.SaveandFlush (baseUnit); } public void DeleteById (ID de cadena) {_BasePository.Delete (id); } public java.util.list <E> queryall () {return _BasePository.findall (); } public e findByid (ID de cadena) {return _BasePository.getone (id); }} paquete com.my.repository; import java.io.Serializable; import org.springframework.data.jpa.repository.jparepository; import org.springframework.data.rePository.norepositoryBean; @norepositoryBeanBeanPublic Interface Baseeposory <E> Extends JParepository <E, e, @norepository. Serializable> {}Clase de entidad: Relacionado con los campos de la base de datos, debe prestar atención a la anotación en la clase principal @MaptSuperClass
paquete com.my.entity; import java.util.arrayList; import java.util.list; import javax.persistence.entity; import javax.persistence.manytomany; importar org.hibernate.annotations.dynamicinsert; import og.hibernate.annotations.dynamicupdate; importación; import org.hibernate.validator.constraints.email; @Entity (name = "db_user")@dynamicinsert@dynamicupdatepublic clase user extiende baseUnit { / *** estado de cuenta* / public static enum cuentas { / *** normal* / enable, // / *** discapacitada* / desactivable} static static longstatus { / *** normal* / enable, // / *** Disable* / desactivable} static static longitud de larga duración final -3101319619397064425L; contraseña de cadena privada; sal de cuerda privada; / ** Estado de la cuenta*/ estado de cuenta privada; / ** Correo electrónico de autenticación*/ @email (mensaje = "user.Email Attribute debe cumplir con el formato de correo electrónico") Correo electrónico de cadena privada; / ** Número de teléfono móvil*/ String private Mobileno; / ** Número de identificación*/ String private CardID; @ManyTomany (TargetEntity = Role.Class) Lista privada <String> rolyIds; /** Apodo. Opcional. */ apodo de cadena privada; public String getCardId () {return CardID; } public String getEmail () {return email; } public String getMobileno () {return mobileno; } public String getNickName () {return Npokname; } public String getPassword () {return Password; } Public List <String> getRoleIds () {if (rolyIds == null) {rolyIds = new ArrayList <> (); } return rolyIds; } public String getSalt () {return sal; } Public AccountStatus getStatus () {Estado de retorno; } public void setCardId (String CardId) {this.cardid = cardID; } public void setEmail (correo electrónico de cadena) {this.email = correo electrónico; } public void setMobileno (string mobileno) {this.mobileno = mobileno; } public void setNickName (String Nickname) {this.nickName = Nickname; } public void setPassword (String Password) {this.password = contraseña; } public void setRoleIds (list <string> rolyIds) {this.roleIds = rolyIds; } public void setSalt (string sal) {this.salt = sal; } public void setStatus (estado de cuenta) {this.status = status; }} paquete com.my.entity; import java.io.serializable; import java.util.date; import javax.persistence.id; import javax.persistence.mappedSuperClass; import javax.validation.constraints.notnull; import javax.validation.constraints.size; import org.springframework.data.annotation.createdby; import org.springframework.data.annotation.createDdate; import org.springframework.data.annotation.lastModifiedBy; import og.springframframe.data.annotation.lastmodmodmodmodmeds {@Id @Notnull Public String ID; / ** * ID de unidad principal */ @size (max = 32, mensaje = "baseUnit.Parentid La longitud del atributo no puede ser mayor que 32") Cadena pública ParentId; / ** Tipo de unidad principal*/ Public ParentType ParentType; / *** Nombre de la unidad*/ @notnull (mensaje = "BaseUnit.Name Atribute no puede estar vacío") Nombre de cadena pública; @CreatedBy Public String CreateBy; @CreatedDate Public Date Creatate; @LastModifiedby Public String LastModifiedBy; / *** Última fecha actualizada*/ @LastModifiedDate Fecha pública LastModifiedDate; public String getId () {return id; } public void setid (ID de cadena) {this.id = id; } / *** Obtenga el nombre de la unidad** @return requerido* / public string getName () {return name; } / ** * * @return uuid, excluyendo {} y - * / 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; } fecha pública GetCreateDate () {return creatate; } public void setCreatedate (date creatateate) {this.createdate = creatateate; } / ** * Establezca el nombre de la unidad * * * @param nombre * requerido * / public void setName (nombre de cadena) {this.name = name; } / ** * Establezca la ID de unidad principal * * @param parentid * uuid, excluyendo {} y - * / public void setParentid (string parentId) {this.parentId = parentId; } public String getLastModifiedBy () {return LastModifiedBy; } public void setLastModifiedBy (String LastModifiedBy) {this.lastModifiedBy = LastModifiedBy; } fecha pública getLastModifiedDate () {return LastModifiedDate; } public void setLastModifiedDate (fecha lastModifiedDate) {this.lastModifiedDate = lastModifiedDate; }}Archivo de configuración:
servidor: puerto: 16800 contextpath:/logging: config: ./config/logback.xml spring: http: multipart: habilitado: falso dataSource: url: jdbc: mysql: //127.0.0.1: 3306/db? useUnicode = true & caracteringoding = utf-8 username: contraseña de root: 123456: 123456: contraseña de 123456: com.mysql.jdbc.driver JPA: base de datos: mysql show-sql: verdadero hibernado: ddl-auto: actualización jackson: serialización: indent_output: verdadero
#Hibernate: el comportamiento específico de la clase de entidad que mantiene la estructura de la tabla de la base de datos. Actualización significa que cuando las propiedades de la clase de entidad cambian, la estructura de la tabla se actualizará. Aquí también podemos tomar el valor de creación. Esta creación significa que la última tabla generada se eliminó al inicio y regenere la tabla de acuerdo con la clase de entidad. En este momento, se borrarán los datos en la tabla anterior; También puede tomar el valor Create-Drop, lo que significa que la tabla se genera en función de la clase de entidad al inicio, pero cuando la sesión de sesión está cerrada, la tabla se eliminará; Validar significa que la clase de entidad y la tabla de datos son consistentes en el inicio; Ninguno significa que no se hace nada. #show-sql significa que hibernate imprime la instrucción SQL real en la consola cuando opera #jackson significa salida formateada JSON cadena
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.