Este artículo presentará el proyecto Java más básico, al proyecto web, a la integración de Spring, SpringMVC, SpringDAdAJPA+Hibernate.
Por lo general, podemos construir un proyecto a través de una plantilla o importar un proyecto directamente. Sin embargo, este artículo elige comenzar con el proyecto Java más básico, con el propósito de mostrar más principios.
Por supuesto, todavía comenzamos con el proyecto Maven más básico. De hecho, el proceso de construcción de los proyectos no sorturantes ordinarios es casi el mismo. El paquete JAR debe agregarse manualmente al proyecto, mientras que el proyecto Maven solo cambia el archivo de configuración.
Lo siguiente se inicia oficialmente.
1. Cree el proyecto Java más básico basado en Maven (si no usa Maven, también puede usar proyectos tradicionales)
Para crear un nuevo proyecto, seleccione el proyecto Maven, siguiente:
Compruébalo como crear un proyecto simple, siguiente:
El ID del grupo es el orden inverso de su nombre de dominio, que generalmente corresponde al nombre del paquete del código fuente del proyecto. Artifact ID es el único nombre del proyecto en este ID de grupo. Se puede llenar de cualquier manera de acuerdo con sus pasatiempos y luego terminar:
Este es el resultado de la estructura del directorio del proyecto como esta:
Pom.xml es el archivo central de Maven.
2. Establezca el proyecto en modo web dinámico
A continuación, convierta el proyecto en un proyecto web, haga clic con el botón derecho para abrir las propiedades del proyecto, como se muestra en la figura, haga clic en Facetas del proyecto en el menú de la izquierda y luego haga clic en Convertir a Faceted desde ...:::
A la derecha, marcamos el módulo web dinámico y hacemos clic en Aceptar:
En este momento, aparecerá un directorio de contenido web adicional:
En el directorio web-INF, agregue el archivo web.xml, de la siguiente manera:
<? xml versión = "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/javaeeeeeeeeeeee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd "version =" 3.0 "> <Spantname-name> SpringDataJpa </sipplave-name> <Welcome-File-List> <Dleven las veces> Index.html </ beeding-file> </legente-file-list> </beapp>
Luego agregue una página de bienvenida index.html:
<html> <head> </head> <body> <h1> hola palabra! </h1> </body> </html>
La estructura del directorio es la siguiente:
En este momento, puede hacer clic derecho en el proyecto y ejecutar en el servidor. Puedes ver el efecto:
3. Integrar Spring+SpringMVC
Cree un nuevo paquete y agregue algunas interfaces y clases (el código específico se enumerará más adelante). La estructura del paquete es como se muestra en la figura:
Si necesita agregar un paquete JAR, simplemente modifique el archivo POM directamente. Si se trata de un proyecto normal, simplemente agréguelo al proyecto presionando el paquete JAR en pom.xml.
Primero, agregue la versión de resorte utilizada para facilitar la administración unificada y luego agregue todos los paquetes de jar requeridos. Lo siguiente es agregar todos los paquetes de jar necesarios aquí. El pom.xml completado es el siguiente:
<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.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd "> <modelVersion> 4.0.0 </modelversion> <MoupRoid> com.anxpp </groupid> <artifactID> springJPA </artifactID> <Persion> 0.0.1-snapshot </lipsion> <ProtESS> <Vering.Version> 4.2.5.Release </spring.version> </propiies> <pendencies> <!-Spring Core Package-> <Spendency> <MoupRid> org.springframework </proupid> <artifactID> Spring-core </arifactid> <versión> $ {Spring.Version} </Version> </Dependency> <Spendency> <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> <Spendency> <MoupRoMID> org.springframework </groupid> <artifactid> spring-tx </artifactid> <versión> $ {spring.version} </versión> </pendency> <epardency> <proupid> org.springframework </spupoid> <artifactid> spring-jdbc </artifactid> <versión> $ {springsion} </pendency> <ependency> <uproupid> org.springframework </proupid> <artifactid> spring-webmvc </arfactid> <version> $ {spring.version} </versión> </pendency> <ependency> <grupo> org.springframework </groupid> <artifactid> spring-aaop </artifactid> <Persion> $ {spring.version} </ververy> </pendency> <epardency> <uproupid> org.springframework </proupid> <artifactid> spring-context-support </artifactid> <versión> $ {spring.version} </versión> </pendency> <epardency> <grupid> org.springframework </groupid> <artifactID> spring-test </artifactid> <versión> $ {spring.version} </versión> </pendency> <pendency> <uproupid> org.springframework </groupid> <artifactid> spring-anm </arfactid> <lection> $ {spring.version} </production> </pendency> <pendency> <MoupRid> org.springframework.data </groupid> <artifactid> spring-data-jpa </arfactid> <versever> 1.10.1.release </ververy> </pendency> </pendencs> </jection>Agregue el archivo de configuración de Spring ApplicationContext.xml en el directorio web-INF y agregue el siguiente contenido:
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: p = "http://www.springfrwork.org/schema/p" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: mvc = "http://www.springframework.org/schema/mvc" xsi: schemalation 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/aop http://www.springfframework.orgsschema/aop/spring-aop-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.20 Anotación de la exploración-> <MVC: Driven de anotación /> < /frijoles>
Modifique Web.xml y agregue el resorte a:
<? xml versión = "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/xml/ns/javaeeee/web-app_3_0.xsd" Versión = "3.0"> " <Spant-Name> SpringDataJPA </sipplay-name> <Oyerer> <Oyerer-class> org.springframework.web.context.contextloaderListener </oyer-class> </oyeyer> <contextparam> </context-param> <servlet> <serlet-name> springmvc </servlet-name> <ervlet-class> org.springframework.web.servlet.dispatcherservlet </servlet-class> <itinparam> </init-param> <load-on-startup> 1 </load-on-startup> </servlet> <ervlet-mapping> <ervlet-mapping> <ervlet-name> springmvc </servlet-name> <url-pattern>/*</ url-pattern> </servlet-mapping> </Welcome-File-List> </beb-app>
Comencemos a escribir el código a continuación, tenga cuidado de no olvidar escribir las anotaciones, la jerarquía del paquete se ha dado al comienzo de esta sección.
Usuario de la entidad:
paquete com.anxpp.demo.core.entity; usuario de clase pública {ID de entero privado; nombre de cadena privada; Usuario público (ID de entero, nombre de cadena) {this.id = id; this.name = name; } public integer getId () {return id; } public void setid (ID de entero) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } @Override public string toString () {return "id:"+id+", nombre:"+nombre; }}Interfaz de la capa userdao:
paquete com.anxpp.demo.core.dao; import com.anxpp.demo.core.entity.user; interfaz pública userdao {user getUser (ID de Integer, nombre de cadena);}La capa DAO implementa userDaoImpl:
Paquete com.anxpp.demo.core.dao.impl; import org.springframework.stereotype.repository; import getUser (ID de entero, nombre de cadena) {return New User (id, nombre); }}Interfaz de la capa de servicio UserService:
paquete com.anxpp.demo.core.service; import com.anxpp.demo.core.entity.user; interface pública ussereService {user getUser (ID de entero, nombre de cadena);}Implementación de la capa de servicio:
paquete com.anxpp.demo.core.service.impl; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.stereotype.service; import com.anxpp.demo.core.dao.userdao; import.anxpp.demo.core.core.entity ;user; com.anxpp.demo.core.service.userservice; @ServicePublic Public UserServiceImpl implementa UserService {@aUtoWired userdao userDao; @Override Public User getUser (ID de Integer, nombre de cadena) {return userDao.getuser (id, nombre); }}Democontrolador de capa de controlador:
paquete com.anxpp.demo.controller; import org.springframework.beans.factory.annotation.autewired; import org.springframework.stereotype.controller; importar org.springframework.web.bind.annotation.requestmapping; import org.springframe.web.webind. com.anxpp.demo.core.service.userservice;@controler@requestmapping ("/") public class Democontroller {@aUtowired UserService UserService; @RequestMapping ("/") @ResponseBody public String index () {return "índice"; } @RequestMapping ("/getUser") @ResponseBody Public String getUser (ID de Integer, name de cadena) {return UserService.getuser (id, nombre) .ToString (); }}Esto no es posible ejecutarse directamente en el servidor, porque el paquete JAR no se lanzará juntos, necesitamos configurar lo siguiente:
Haga clic derecho en el proyecto para seleccionar propiedades y configurarlo de acuerdo con la figura a continuación:
En este momento, puede ejecutar la prueba, el efecto es el siguiente:
En este punto, todavía no hemos operado la base de datos.
4. Agregar y devolver el soporte de datos de formato JSON
Ahora, a menudo usamos JSON como formato de transmisión de datos. Agreguemos soporte para devolver JSON para SpringMVC.
Primero agregue el paquete jar:
<Spendency> <MoupRid> com.fasterxml.jackson.core </groupid> <artifactid> jackson-databind </artifactid> <verserse> 2.5.0 </versión> </pendency> <pendency> <proupid> com.fasterxml.jackson.core </groupid> <artifactid> jackson-core </artifactid> <versión> <versión> <versión> 2.5.0. </pendency> <pendency> <grupid> com.fasterxml.jackson.core </groupid> <artifactid> jackson-annotations </artifactid> <versión> 2.5.0 </versión> </pendency>
Luego reescribe el método getUser () de la siguiente manera:
@RequestMapping ("/getUser") @ResponseBody Public Map <String, Object> GetUser (ID de Integer, Nombre de cadena) {Map <String, Object> MAP = New HashMap <String, Object> (); map.put ("estado", "éxito"); map.put ("Data", UserService.getuser (id, nombre)); mapa de retorno; }Después de la repetición, el efecto de acceso es el siguiente:
En este momento, puede devolver los datos JSON.
5. Configurar el acceso de recursos estáticos
En términos generales, no podemos acceder directamente a los recursos en el directorio web-INF. Si nuestro sitio web está compuesto de HTML+AJAX, puede crear un nuevo directorio HTML fuera de Web-INF y configurar el filtro predeterminado para Web.xml. Sin embargo, tenga cuidado de ponerlo antes del filtro SpringMVC:
<Servlet-mapping> <Servlet-name> predeterminado </servlet-name> <url-pattern>*. html </url-Pattern> </servlet-mapping>
Si debe acceder a los recursos en el directorio web-INF, al verificar los documentos oficiales de Spring, encontrará que hay dos maneras
1. Escritura a mano un mapeador de recursos:
@Configuration @enableWebMVCPublic Class WebConfig extiende WebMVCConfigurerAdapter {@Override public void addResourceHandlers (ResourceHandlerRegistry Registry) {Registry.AddresourceHandler ("/recursos/**") .DdRESourCelocations ("/Public-revesces/") .SetCacheControl (Cachecontrol.maxage (1, TimeUnit.Hours) .Cachepublic ()); }}Como puede ver, también puede establecer el tiempo de caché, y la forma más simple es configurar el XML:
<mvc: recursos mapping = "/recursos/**" ubicación = "/presente-resources/"> <mvc: cache-confontrol max-age = "3600" cache-public = "true"/> </mvc: recursos>
También puede agregar lo siguiente:
<
6. Solución del código de basura
Por lo general, usamos AJAX para enviar solicitudes, pero también usamos la barra de direcciones para probar directamente. Los envíos de solicitudes obtienen y publicarán.
Envíe solicitudes con POST, generalmente no habrá código confuso chino, pero si aparece el código confuso, puede resolver el problema agregando un filtro de codificación a Web.xml:
<Tilter> <Sterry-Name> CaracterIncoding </filter-name> <filter-class> org.springframework.web.filter.CharacterEncodingFilter </filter-class> <it-param> <amamname> encoding </amamname> <amam-value> utf-8 </amam-value> </it-param> <elit-param> <amamname> ForceEncoding </amamname> <amam-value> true </amam-value> </it-param> </sille> <filter-mapping> <filter-name> caracterescoding </filtre-name> <url-pattern>/*</url-pattern> </filter-mapping>
Lo anterior solo puede resolver el Código de Post confiado chino. Para Get (incluido el método de envío directo de la barra de direcciones del navegador), necesitamos modificar la configuración de Tomcat, encontrarlo en server.xml en el directorio de conf y modificarlo de la siguiente manera:
<Connection ConnecttimeOut = "20000" Port = "8080" Protocol = "http/1.1" redirectPort = "8443" uriEncoding = "utf-8"/>
Si solo estamos probando y el proyecto no está implementado, podemos encontrar directamente server.xml debajo del servidor en Eclipse y hacer los mismos cambios que anteriormente:
7. Integre SpringDatajpa+Hibernate
Puede aprender sobre JPA: Introducción a las especificaciones y ejemplos de JPA (solución de persistencia de datos Java)
SpringDataJPA también es una solución tan liviana, y la Hibernate preferida implementa JPA.
En primer lugar, el paquete JAR, el paquete SpringDataJPA JAR, se agregó al integrar Spring. A continuación se muestra el paquete jar de Hibernate (y el controlador MySQL).
< <Persion> $ {hibernate.version} </verververs> </pepertency> <epardency> <proupid> org.hibernate </groupid> <artifactid> hibernate-entitymanager </artifactid> <versión> $ {hibernate.version} </sione> </dependency> <defeferency> <grupid> org.hibernate </groupnate </groupnate </group <artifactid> hibernate-c3p0 </artifactid> <versión> $ {hibernate.version} </versewers> </dependence> <peperse> <uproupid> mysql </groupid> <artifactid> mysql-connector-java </artifactid> <preonsion> 5.1.9 </lipeers> </pendency>La versión de gestión unificada es:
<
Agregue el archivo de configuración de JPA persistence.xml al directorio meta-INF. La base de datos usa MySQL al presentar este artículo. Y agregue el siguiente contenido:
<? xml versión = "1.0" encoding = "utf-8"?> <Persistence versión = "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-unit name = "delo" transacción-type = "recurse_local"> <!-<!--<!-; Provider> org.eclipse.persistence.jpa.persistenceProvider </Provider-> <Svider> org.hibernate.ejb.hibernatepersistence </svider> <class> com.ninelephas.meerkat.pojo.user </class> < name = "Hibernate.Connection.Driver_Class" value = "com.mysql.jdbc.driver"/> <propiedad name = "hibernate.connection.url" valor = "jdbc: mysql: //127.0.0.1: 3306/delo? valor = "root" /> <propiedad name = "hibernate.connection.password" value = "root" /> <propiedad name = "hibernate.dialect" value = "org.hibernate.dialect.mysqldialect" /> < /propiedades> < /persistence-unit> < /persistence>
El contenido completo después de agregar soporte JPA al archivo de configuración de Spring ApplicationContext.xml:
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: context = "http://www.springframework.org/schema/context" xmlns: aop = "http://www.springframework.org/schema/aop" xmlns: p = "http://www.springfrwork.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/beanss http://www.springframework.org/schema/Beans/spring-Beans-4.2.2sd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springfframework.orgsschema/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.2.20 http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd "> < id = "EntityManagerFactory"> <Property name = "jpavendorAdapter"> <Bean> <Property Name = "GeneratedDl" value = "true" /> <Property name = "database" value = "mysql" /> < /bean> </spertity> <propiedad name = "persistenceunitname" value = "damo" /> </bean>! <mvc: annotation-driven/> <bean> <propiedad name = "viewResOlvers"> <list> <Bean> <Property name = "prefix" valor = "/web-inf/ver/"/> <propiedad name = "sufix" value = ". Html"/> </bean> </list> </propiedad> < /> </list> </property> </bean> <!-El acceso a los archivos de recursos estáticos dejará la ruta que no se puede asignar al controlador al controlador de servlet predeterminado para procesar-> <mvc: default-servlet-handler/> <!-Configurar el administrador de transacciones-> <bean id = "transaccionManager"> <name de propiedad = "entityManager" reh = "en la participación de transacciones fábricas/> <! Transacción de anotación-> <tx: transacción-manager-manager de anotación = "transaccionManager" /> <!-Configurar datos de escaneo de datos de datos Spring-> <jpa: repositories base-package = "com.anxpp.demo" /> < /beans>
Modificar la entidad:
paquete com.anxpp.demo.core.entity; import javax.persistence.entity; import javax.persistence.GeneratedValue; import javax.persistence.generationType; import javax.persistence.id; import javax.persistence.table; @entity @tablePublic Classser {@id @id @idvalue (estrategia = GenerationType.auto) ID de entero privado; nombre de cadena privada; Public User () {} Public User (nombre de cadena) {this.name = name; } public integer getId () {return id; } public void setid (ID de entero) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } @Override public string toString () {return "id:"+id+", nombre:"+nombre; }}Puede eliminar la implementación de la capa DAO. Recordamos heredar la interfaz de la capa DAO desde el poderoso jParepository:
La interfaz pública userdao extiende jParepository <User, Serializable> {User FindById (ID de Integer);}¿Parece particularmente conciso y no requiere una implementación de escritura? SpringDataJPA nos ayudará automáticamente a completarlo.
Modificar la interfaz de la capa de servicio:
paquete com.anxpp.demo.core.service; import java.util.list; import com.anxpp.demo.core.entity.user; pública interfaz usereService {user findByid (ID de Integer); Usuario Guardar (nombre de cadena); Lista <serem> findall ();}Modificar la implementación de la capa de servicio:
paquete com.anxpp.demo.core.service.impl; import java.util.list; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.stereotype.service; import Com.anxpp.demo.core.dao.userdao; import com.anxpp.demo.core.entity.user; import com.anxpp.demo.core.service.userservice; @ServicePublic UserServiceImpl implementa UserService {@aUtowired userDao userDao; @Override Public User FindById (ID de Integer) {return userDao.findById (id); } @Override Public User Guardar (nombre de cadena) {return userDao.save (nuevo usuario (nombre)); } @Override Public List <Ser User> findall () {return userDao.findall (); }}Modifique el controlador para proporcionar múltiples interfaces de prueba:
paquete com.anxpp.demo.controller; import java.util.hashmap; import java.util.map; import org.springframework.beans.factory.annotation.aUtowired; import org.sspringframework.stereotype.controller; import org.springframework.webind.annotation org.springframework.web.bind.annotation.ResponseBody; import com.anxpp.demo.core.service.userservice;@controler@requestmapping ("/") public class Democontroller {@aUtowired UserSerService UserSerService; @RequestMapping ("/") @ResponseBody public String index () {return "índice"; } @RequestMapping ("/info") public String info () {return "info"; } @RequestMapping ("/findall") @ResponseBody Map público <string, object> getUser () {map <string, object> map = new Hashmap <String, Object> (); map.put ("estado", "éxito"); map.put ("Data", UserService.Findall ()); mapa de retorno; } @RequestMapping ("/findById") @ResponseBody Map público <String, Object> FindById (ID de Integer) {MAP <String, Object> MAP = new HashMap <String, Object> (); map.put ("estado", "éxito"); map.put ("Data", UserService.FindById (id)); mapa de retorno; } @RequestMapping ("/add") @ResponseBody Public Map <String, Object> Save (String Name) {Map <String, Object> MAP = New HashMap <String, Object> (); map.put ("estado", "éxito"); map.put ("Data", UserService.save (nombre)); mapa de retorno; }}Efecto de ejecución:
Entonces, ¿qué pasa si necesita agregar un datos que busque un apellido especificado con una ID mayor que el valor especificado?
Si es SQL, escribiremos de esta manera (? Representa los parámetros):
Seleccionar * del usuario donde ID>? Y nombre como '?%';
Pero aquí, ni siquiera necesitamos escribir SQL (o HQL) y simplemente agregar un método a la interfaz de la capa DAO:
Lista <serem> findByidGreaterThanandnamElike (ID de entero, nombre de cadena);
No es necesario dudar de que el método anterior tendrá éxito si se ejecuta (nota: ¡Use la implementación del servicio, recuerde el nombre+"%" al llamar a este método)!
Lo anterior es el conocimiento relevante que se le presentó sobre la construcción de SpringMVC+SpringDataJPA+Hibernate del proyecto Java más básico. Espero que sea útil para todos. Si desea saber más información, ¡preste atención al sitio web de Wulin.com!