Código de muestra para la integración de marco SSM basada en Maven

Conceptos básicos

1.1. Primavera

Spring es un marco de código abierto, un marco de desarrollo de Java liviano que surgió en 2003, derivado de algunas de las ideas y prototipos explicados por Rod Johnson en su libro de desarrollo y diseño de J2EE Expert uno a uno. Fue creado para abordar la complejidad del desarrollo de aplicaciones empresariales. Spring usa javabeans básicos para hacer cosas que anteriormente solo era posible por EJB. Sin embargo, los usos de Spring no se limitan al desarrollo del lado del servidor. Desde una simplicidad, probabilidad y una perspectiva de acoplamiento suelto, cualquier aplicación de Java puede beneficiarse de la primavera. En pocas palabras, Spring es una inversión ligera de control de control (COI) y marco de contenedores orientado a la sección (AOP).

1.2. SpringMVC

Spring MVC es un producto posterior de SpringFramework y se ha integrado en el flujo web de Spring. Spring MVC separa los roles de los controladores, objetos modelo, despachadores y objetos de controlador, y esta separación los hace más fáciles de personalizar.

1.3. Mybatis

MyBatis es un proyecto de código abierto de Apache. En 2010, este proyecto se trasladó de Apache Software Foundation a Google Code y pasó a llamarse MyBatis. MyBatis es un marco de capa de persistencia basado en Java. Ibatis proporciona marcos de capa de persistencia que incluyen mapas SQL y objetos de acceso a datos (DAO) myBatis elimina la configuración manual de casi todos los códigos y parámetros JDBC y la recuperación de conjuntos de resultados. MyBatis utiliza XML o anotaciones simples para la configuración y el mapeo original para mapear interfaces y Pojos de Java (objetos Java Old Old) en los registros en la base de datos.

Paso 1: Cree un proyecto web a través de Maven.

Paso 2: importe el archivo POM en el paquete JAR

(1) pom.xml

Copié todo el archivo de POM, y debe eliminar algunas de las cosas de inicialización y mantener la copia que generó por su propia POM.

 <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/maven-v4_0_0.xsd "> <modelVersion> 4.0.0 </modelversion> <MoupRupid> com.test </groupid> <artifactid> ssm </artifactid> <packaging> war </paquete> <versión 0.0.1-snapshot </version> <name> ssm maven </name> <Url> http://maven.apache.org </sl> <properties> <!-Spring Version Number-> <Spring.version> 4.0.2.Release </spring.version> <!-Número de versión de MyBatis-Versión de la versión-> <mybatis.version> 3.2.6 </mybatis.version> <!-Log4j Log Package Version->-Versión de paquete de archivos de log--<MyBatis.Version> 3.2.6 </mybatis.version> <!-Log4j Log Package Version-> Versión--Versión de paquete de archivos de Log4J-> < <slf4j.version>1.7.7</slf4j.version> <log4j.version>1.2.17</log4j.version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>${spring.version}</version> </dependency> <Spendency> <MoupRoD> org.springframework </groupid> <artifactid> spring-oxm </arfactid> <versever> $ {spring.version} </versewers> </dependency> <ependency> <proupid> org.springframework </proupid> <artifactid> spring-tx-tx </artifactid> <versions> $ {spring.versionwork </groupid> <artifiCtid> spring-tx </artifactid> <versions> $ zo </pendency> <epardency> <uproupid> org.springframework </proupid> <artifactid> spring-jdbc </arfactid> <version> $ {spring.version} </versión> </pendency> <epardency> <proupid> org.springframework </groupid> <artifactid> spring-webmvc </artfactiCt> <versión> $ {spring.version} </versión> </pendency> <ependency> <grupid> org.springframework </groupid> <artifactid> spring-aop </artifactid> <version> $ {spring.version} </versión> </dependence> <epardency> <proupid> org.springframework </groupid> <artifactID> spring-Context-Support </artifactid> <versión> $ {spring.version} </versión> </pendency> <pendency> <proupid> org.springframework </groupid> <artifactID> spring-test </artifactid> <lection> <lection ‘spring.version} </versewers> </spersion> <spendency <!-MyBATInsife-<StarIntence-<SHEPEDE> <SHEPEDE> <SPATEDE> <SPATEDE> <Groupid> org.mybatis </proupid> <artifactid> mybatis </artifactid> <versión> $ {mybatis.version} </ververys> </pepertency> <!-mybatis/spring paquete-> <fependency> <MoupId> org.mybatis </groupId> <artifactid> mybatis-spring </art de/artes <Versión> 1.2.2 </versión> </pendency> <!-Importar el paquete Java EE JAR-> <Spendency> <ProupId> javax </proupid> <artifactid> javaee-api </artifactid> <versión> 7.0 </versión> </dependence> <!-Importar mysql de enlace de la base de datos paquete-> <pendency> <proupid> mysql </groupid> <artifactid> mysql-confonector-java </artifactid> <ververy> 5.1.30 </versions> </dependence> <!-Importar el paquete jar de dbcp para configurar la base de datos en applicationContext.xml-> <pendency> <MoupRid> Commons-DBCP </GroupID> <Atifactid> commons-dbcpp </artfactid> <versión> 1.2.2 </ververy> </pendency> <!-Jstl Tag class-> <Spendency> <ProupId> jstl </groupid> <artifactid> jstl </artifactid> <versión> 1.2 </versión> </pendency> <!-Paquete de gestión de archivos de registro-> <!-Log Start-> <Efferency> <MoupRid> log4j </groupid> <AtifactId> log4j </arfactid> <versión> $ {log4j.version} </versión> </pendency> <!-Formato Objetos para facilitar la salida del registro-> <pendency> <Groupid> com.alibaba </groupid> <artifactid> fastjson </artifactID> <proonsion> 1.1.41 </version> </dependency> </dependency> <MoupRid> org.slf4j </groupid> <artifactid> slf4j-api </artifactid> <versions> $ {slf4j.version} </versewers> </pendency> <ependency> <proupid> org.slf4j </proupid> <artifactid> slf4j-log4j12 </artifactid>> <versión> $ {slf4j.version} </versión> </dependence> <!-log final-> <!-input json-> <pendency> <MoupRupid> org.codehaus.jackson </groupid> <artifactID> jackson-mapper-asl </artifactid> <versión> 1.9.13 </versión> </ververge> </pendency> <MoupRid> Commons-FileUpload </groupid> <artifactid> commons-FileUpload </artifactid> <verserse> 1.3.1 </versewers> </pendency> <pendency> <grupoD> commons-io </proupId> <artifactid> commons-io </artactid> <produce> 2.4 </lipeers> </pendency> <pendency> <Spendency> <MoupRid> Commons-Codec </groupid> <artifactid> commons-codec </artifactid> <versión> 1.9 </versión> </pendency> </dependencias> <construcción> <finalname> ssm </dinalName> </struct> </proyecto>

Paso 3: Mire la estructura general del proyecto, permítanme explicar primero que no tengo cosas relacionadas con SpringMVC aquí, porque primero integro la mybatis Spring, y al probar si es exitoso, integro con éxito SpringMVC.

Paso 4: crear una clase de modelo

 Usuario de clase pública {private int id; nombre de cadena privada; contraseña de cadena privada; PRIVADA String Password2; /*Proporcionar métodos establecidos y obtenidos, método de toString*/}

Paso 5: Crear base de datos, interfaz userdao y archivo de asignación de mapper

(1) Crear una mesa muy simple

(2) Interfaz de userdao

 interfaz pública userdao {User FindUserByID (usuario de usuario);}

(3) Uesrmapper.xml

 <? xml versión = "1.0" encoding = "utf-8"?> <! DocType mappublic "-// mybatis.org//dtd mapper 3.0 // en" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <! -> <mapper namespace = "com.ssm.dao.userdao"> <!-Información del usuario de consulta basada en ID-> <!-Id: identifique de manera única una declaración, que es la misma que el nombre del método userdao#{}: representa un marcador de posición. Si se pasa un parámetro de tipo simple en #{}, el nombre en #{} es arbitrary parametertype: el tipo de parámetro de entrada, que es el mismo que el parámetro en userDao () dulteType: el tipo de resultado de salida, que es el mismo que el userDao () type-> <select id = "finduserbyid" parametertype = "com.sssssssm.sssm.sssm.ssm.sm.sm.ssm.sm.sm.sm.sm.sm.sm.sm.sm. resultType = "com.ssm.model.user"> Seleccionar * de user <where> <if test = "name! = null"> y name = #{name} </if> <if test = "contraseña! = null"> y contraseña = #{contraseña} </if> </where> </elect> </pper>

Paso 5: Crear UserService y UserServiceImpl

(1) servicio de usuarios

 Interfaz pública UserService {Public User GetUserById (usuario de usuario); }

(2) UserServiceImpl

 importar org.springframework.stereotype.service; import com.ssm.dao.userdao; import com.ssm.model.user; import com.ssm.service.userService; @Service ("UserService") Public ClassSerVerPlpl implementa UserSerVice {@Resource Userdao Userdao; Usuario público getUserById (usuario de usuario) {return this.userdao.finduserById (usuario); }}

Paso 6: Crear archivo JDBC y registro de registro del archivo

(1) JDBC.Properties

 jdbc.driver = com.mysql.jdbc.driverjdbc.url = jdbc/: mysql/: // localhost/: 3306/test? useUnicode = true && caracteringoding = utf-8jdbc.username = rootjdbc.password = root = root = raíz

(2) Log4J.Properties

 log4j.rootlogger = info, console, archivo #define el destino de salida del registro como console log4j.appender.console = org.apache.log4j.consoleppender log4j.appender.console.target = system.out #can especifica flexiblemente el formato de salida de registro, la siguiente línea especifica el formato específico log4j.appender.consoleeLeOlole org.apache.log4j.patternlayout log4j.appender.console.layout.conversionPattern = [%c] -%m%n #cuando el tamaño del archivo alcanza el tamaño especificado, un nuevo archivo se genera log4j.appender.file = org.apache.log4j.rollingfileApepper #specify el directorio de salida de salida de salida el directorio de salida de salida. registros/ssm.log #define el tamaño máximo de archivo log4j.appender.file.maxfilesize = 10mb #output así log. Si lo cambia a depuración, significa registros de salida en la depuración o por encima del nivel log4j.appender.file.threshold = all log4j.appender.file.layout = org.apache.log4j.patternlayout log4j.appender.file.layout.conversionPattern = [%P] [%d {yyyyyyyyyyyyyy-dd HH/: mm/: ss}] [%c]%m%n

Paso 7: Integrar spring-mybatis.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: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/mvc" xsi: schemalocation = "http://www.springframework.org/schema/schem http://www.springframework.org/schema/Beans/Spring-Beans-3.1.xsd http://www.springframework.org/schema/ContextExt http://www.springFrframe..Org/schema/contextextextext-3.1.1.1.xsdd.xsdworkwork..Oschema/contextextextext-3.1.1.1.xsddd.xsdworkwork..Oschema/contextextextext-3.1.1.1.xsdd.xsdworkwork..oSchema/contextextextextex-3.1.1.1.xsdd.xsdworkwork..Oschema/contextextextex- http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd "> <!-escaneo automático-> <context: component-scan-backage =" com.sssm "/>! <bean id = "PropertyConfigurer"> <Property Name = "Ubicación" value = "classpath: jdbc.properties" /> < /bean> <!-2. grupo de conexiones de base de datos-> <bean id = "dataSource" destruye-method = "cierre"> <name de propiedad = "controlador value = "$ {jdbc.Url}" /> <propiedad name = "username" value = "$ {jdbc.username}" /> <propiedad name = "contraseña" value = "$ {jdbc.password}" /> < /bean> <!-Integrate Spring y myBatis para administrar myBatis 'sqlSession Session Session Factory-> << /> < /> < /bean>! < <Bean> <Property Name = "BasePackage" value = "com.ssm.dao"/> <Property name = "SQLSessionFactoryBeanName" value = "SQLSessionFactory"> </property> </le Bean> <!-(Management de transacciones) Manager de transacción, use JTatransactionManager para Global TX-> <Bean Id = "TransactionManager"> <Nombre de propiedad = "DataAct ref = "DataSource"/> </bean> </le beans>

Paso 8: crea una clase de prueba

Después de los pasos anteriores (LOG4J no coincide y no tiene efecto), hemos completado la integración de Spring y MyBatis, por lo que podemos escribir un código de prueba para probar si ha sido exitoso.

La clase de prueba se establece en SRC/Test/Java. Si la prueba es exitosa, significa que Spring y MyBatis se han integrado con éxito. La información de salida se imprime en la consola utilizando LOG4J.

(1) TestMybatis Clase de prueba

 paquete ssm; import javax.annotation.resource; import org.apache.log4j.logger; import org.junit.test; import org.junit.runner.runwith; import org.springframework.test.context.contextConfiguration; import; org.springframework.test.context.junit4.springjunit4classrunner; import com.ssm.model.user; import com.ssm.service.userService;/*Permita que la prueba se ejecute en el entorno de prueba de Spring*/@runwith (springjunit4classrunner.class)/*Se utilizará para especificar la ubicación del archivo de Spring Spring Spring, el archivo de SpringJunit4Classrunner.class)/*Se utilizará para especificar la ubicación del archivo de Spring Spring, el archivo de SpringJunit 4NeTRUNIT, la ClassRunner)/*Se utilizará para especificar la ubicación del archivo de Spring Spring, el archivo de SpringJunit de fondos de forma predeterminada. Cargado*/ @contextConfiguration (ubicaciones = {"classpath: spring-mybatis.xml"}) clase pública testMyBatis {@resource (name = "UserService") privado UserService UserService; @Test public void test1 () {user user = new User (); user.setName ("Zhang San"); user.setPassword ("123"); Usuario user1 = Userservice.getUserById (usuario); System.out.println (user1.ToString ()); }}

¡por fin! La clave es mirar la salida de fondo, que también es un momento para presenciar milagros. Si el objeto de salida se emite, significa que su configuración e integración son exitosas.

Luego comenzamos a integrar SpringMVC

Paso 9: Configurar springmvc.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: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/mvc" xsi: schemalocation = "http://www.springframework.org/schema/schem http://www.springframework.org/schema/Beans/Spring-Beans-3.1.xsd http://www.springframework.org/schema/ContextExt http://www.springFrframe..Org/schema/contextextextext-3.1.1.1.xsdd.xsdworkwork..Oschema/contextextextext-3.1.1.1.xsddd.xsdworkwork..Oschema/contextextextext-3.1.1.1.xsdd.xsdworkwork..oSchema/contextextextextex-3.1.1.1.xsdd.xsdworkwork..Oschema/contextextextex- http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd "> <!-Escanear automáticamente el paquete para que Springmvc crea que la clase de clase anotada en @Controller es el paquete es el paquete de controles. base-package="com.ssm.controller" /> <!-- Avoid download files when IE executes AJAX and return to JSON--> <bean id="mappingJacksonHttpMessageConverter" > <property name="supportedMediaTypes"> <list> <value>text/html;charset=UTF-8</value> </list> </property> </bean> <!-- Start Función de anotación de SpringMVC para completar la asignación de solicitudes y anotaciones POJOS-> <Bean> <Property Name = "MessageConverters"> <list> <ref Bean = "MappingjacksonhttpMessageConverter"/> <!-JSON Converter-> </list> </propiedad> </ bean> <! < Si no usa la carga de archivos, no necesita configurarlo. Por supuesto, si no coincide, entonces no hay necesidad de introducir el paquete de componente de carga en el archivo de configuración-> <bean id = "multipartresolver"> <!-codificación predeterminada-> <name de propiedad = "defaultEncoding" valor = "utf-8" /> <!-tamaño máximo de archivo-> <name de propiedad = "maxuploadsize" value = "10485760000" " /! <propiedad name = "maxinMemorySize" value = "40960"/> </bean> </les>

Paso 10: Configure el archivo web.xml

La introducción de Spring-Mybatis.xml y el servlet Spring-MVC configurado son para la integración SSM. La integración de los dos marcos anteriores no requirió ninguna configuración aquí.

 <? 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/Javaee/web-app_3_0.xsd" Versión = "3.0" Aplicación web </sipplave-name> <!-Archivos de configuración Spring y MyBatis-> <context-param> <amamname> contextConfigLocation </param-name> <amam-value> classpath: spring-mybatis.xml </param-value> </context-param> <!-Filtro de encodado-> <filter> <filter> name> encodingfilter </filtro> <Scilia-Class> org.springframework.web.filter.CharacteriCoDingFilter </filter-class> <async-supported> true </async-supported> <it-param> <amamamname> codificando </param-name> <amarry-Value> utf-8 </amam-value> </initero> </filtro> <filter-name> EncodingFilter </filter-name> <url-pattern>/*</url-pattern> </filtre-mapping> <!-spring oyeer-> <searcher-class> org.springframework.web.context.contextloaderListener </chearer-class> </oyear> <! <Oyerer-class> org.springframework.web.util.introspectORCleanupplistener </searer-class> </oyer> <!-spring mvc servlet-> <ervlet> <servlet-name> springmvc </servlet-name> <ervlet-class> org.springframework.web.servlet.dispatcherservlet </servlet-name> <ervlet-class> org.springframework.web.servlet.dispatcherservlet </Servlet-class> <Init-param> <amamname> contextConfigLocation </amamname> <amam-value> classpath: springmvc.xml </amam-value> </it-param> <load-on-startup> 1 </load-on-startup> <async-supported> true </async-spported> </servlet> <servlet> <servlet-mapping> <Servlet-name> springmvc </servlet-name> <!-Aquí puede configurar *.do, correspondiente al hábito de sufijo de los puntales-> <url-pattern>/</url-pattern> </servlet-mapping> <bequey-file-list> <deche-file> /index.jsp </ bequey-file> </beleve-file-list> </web-app>

Paso 11 Prueba final:

(1) Escriba login.jsp primero

 <%@ page lenguaje = "java" contentType = "text/html; charset = utf-8" PageEncoding = "UTF-8"%> <html> <fead> <title> User Login: </title> </head> <form) name = "UserName"> </input> <br> <br> <label> contraseña: </etiqueta> <input type = "text" id = "contraseña" name = "contraseña"> </input> <br> <br> <input type = "enviar" valor = "login"/> </form> </body> </html>>

interfaz:

(2) Escribir UserController

 import javax.servlet.http.httpservletRequest; import org.springframework.steretype.controller; import org.springframework.web.bind.annotation.requestMapping; import Com.ssm.dao.userdao; import Com.ssm.model.user; @controllerpantrollerProllerProllerProllerPublic @Resource userdao userdao; @RequestMapping ("/jsp/login") public String String login (httpservletRequest request) {String username = request.getParameter ("username"); Cadena contraseña = request.getParameter ("contraseña"); Usuario user = nuevo usuario (); // consulta la base de datos user.setName (nombre de usuario); user.setPassword (contraseña); User users = userDao.FinduserById (usuario); // Si hay estudiantes, significa que el inicio de sesión es exitoso si (uss! = Null) {return "susscss"; } // No escribí este JSP, siempre que sepa, puede escribir su propia devolución "err";}}

(3) Finalmente, susscss.jsp

 <%@ page lenguaje = "java" contentType = "text/html; charset = utf-8" pageEncoding = "utf-8"%> <html> <body> <p> La contraseña de la cuenta del usuario es correcta, el registro es exitoso </p> </body> </html>

¡Perfecto!

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.