SSM (primavera, primavera MVC, MyBatis)
Primero, integre el marco Spring y el marco mybatis: (Debe probarse para ver si se puede obtener el contenido de la base de datos antes de continuar con el siguiente paso de integración del marco Springmvc. Si está familiarizado con él, puede intentar usar la prueba de registro log4j. Este método es mejor, consulte el blog para obtener más detalles :) (36 mensajes) Plantilla de marco SSM (configuración alta: todos los archivos de configuración requeridos se configuran a la vez)_blog de un día321-blog de CSDN
Estructura de directorios:
Plantilla para el archivo pom.xml:
Lo primero que debe hacer es importar el paquete de dependencia, en el archivo pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<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>
<groupId>org.example</groupId>
<artifactId>SSM_2</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<!-- 单元测试包-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- 最常用的包，这个包包括core,beans,-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.18</version>
</dependency>
<!--Spring-beans包，bean标签-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.3.18</version>
</dependency>
<!--jdbc包，进行数据库操作的包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.18</version>
</dependency>
<!--事务管理包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.3.18</version>
</dependency>
<!--数据库源的包-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
<!--进行mybatis操作的包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<!-- mybatis-spring的包，进行整合的包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>
</dependencies>
<!-- 这个是IDEA必须存在的，指在用途是告诉IDEA，Mapper.xml文件的位置，因为一般默认情况下IDEA是不会去Java目录的，尽管你添加Java路径都没用-->
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
</resources>
</build>
</project>
plantilla de archivo applicationContext.xml:
Después de importar el archivo pom.xml del paquete dependiente, configure el archivo applicationContext.xml para conectarse a la base de datos, administrar eventos y configurar la asignación entre el archivo Mapper y mybatis. (Tres pasos, el último paso del mapeo debe configurarse después de crear el archivo de configuración principal de mybatis y el archivo Mapper).
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--由spring管理 配置数据源数据库连接(从jdbc属性文件中读取参数) -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="url" value="jdbc:mysql://localhost:3307/student?serverTimezone=Asia/Shanghai"/>
<property name="username" value="root"/>
<property name="password" value="dada"/>
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
</bean>
<!-- 整合 mybatis -->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean"
p:dataSource-ref="dataSource"
p:configLocation="classpath:mybatis-config.xml"/>
<!-- mybatis自动扫描 将Mapper接口生成代理注入到Spring -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
p:sqlSessionFactoryBeanName="sqlSessionFactory"
p:basePackage="dao" />
<!-- 配置事务管理器 完成手动事务管理 由spring管理事务-->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--
支持注解驱动的事务管理，指定事务管理器。
配置事务 提供回滚，发生异常数据回滚 需要在类/方法上写注解 @Transactional -->
<tx:annotation-driven transaction-manager="txManager"/>
<!-- 需要注意，这一句不能遗漏，因为我是在Controller类编写的Test测试，用的注解方法，需要用这个扫描注释注解-->
<context:component-scan base-package="controller"/>
</beans>Después de configurar el archivo applicationContext.xml, primero configure la asignación de acuerdo con el tercer paso de este archivo. Debe configurar el archivo mybatis-config.xml (indique la ubicación del archivo de asignación Mapper.xml. Preste atención a esta configuración, y también debe configurar la etiqueta bulid en pom.xml anteriormente) y el archivo Mapper.xml (el archivo principal, utilizado para almacenar información de asignación de SQL).
Archivo mybatis-config.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd" >
<configuration>
<mappers>
<mapper resource="mybatis/UserMapper.xml"/>
</mappers>
</configuration>
Archivo Mapper.xml: (ubicado en el paquete mybatis en el directorio de Java)
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="dao.UserDao">
<select id="queryAll" resultType="po.User" parameterType="po.User">
select *from register
</select>
</mapper>Este archivo de mapeo se usa para mi prueba y su función es consultar toda la información de la base de datos.
Archivo de prueba:
UserTestController.java: (capa de controlador)
package controller;
import dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import po.User;
import java.util.List;
@Controller("userTestImpl")
public class UserTestImpl {
@Autowired
private UserDao userDao;
public void test(){
User user = new User();
List<User> userList = userDao.queryAll(user);
for (int i = 0; i <userList.size() ; i++) {
System.out.println(userList.get(i));
}
}
}
Para probar la clase TestUser:
package controller;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestUser {
public static void main(String args[]){
ApplicationContext appcon = new ClassPathXmlApplicationContext("applicationContext.xml");
UserTestImpl ut= (UserTestImpl) appcon.getBean("userTestImpl");
ut.test();
}
}
Debe agregarse que antes de la clase de prueba, se debe escribir la interfaz de la clase POJO y la capa dao. (Esto es simple, así que no lo presentaré).
Finalmente, se obtiene un resultado de prueba: indicando que la conexión a la base de datos es exitosa. Luego puede intentar escribir el marco SpringMVC en él.
Agregue el marco Springmvc:
La estructura del directorio después de agregar el marco SpringMVC:
Los paquetes dependientes que deben agregarse al archivo pom.xml:
En primer lugar, el primer paso: seguir importando el paquete de dependencia de pom.xml (para el paquete de dependencia de SpringMVC, solo necesita agregar spring-webmvc. El paquete de dependencia de jstl es usar el método de etiqueta jstl en la página de presentación de JSP)
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.18</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>Archivo web.xml: (nuevo archivo de configuración)
El segundo paso: configurar el archivo web.xml.
<?xml version="1.0" encoding="UTF-8"?>
<web-app
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
id="WebApp_ID" version="4.0">
<!-- 引入Spring 的配置-->
<!-- ContextLoaderListener 需要 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!-- Bootstraps the root web application context before servlet initialization -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 引入SpringMVC 的配置-->
<!-- 这个Spring Web应用程序的前端控制器(DispatcherServlet)，负责
处理所有应用程序请求 -->
<servlet>
<servlet-name>springDispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- 将所有请求映射到 DispatcherServlet 进行处理 -->
<servlet-mapping>
<servlet-name>springDispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 针对 前端与控制器 数据传递时 的字符过滤器(避免中文乱码) -->
<filter>
<filter-name>encoder</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encoder</filter-name>
<servlet-name>springDispatcherServlet</servlet-name>
</filter-mapping>
</web-app>Al configurar este archivo, cometí un pequeño error: porque estaba buscando una plantilla en Internet, y luego estaba en esta oración:
<!-- Asigne todas las solicitudes a DispatcherServlet para su procesamiento-->
<servlet-mapping>
<servlet-name>springDispatcherServlet</servlet-name>
<url-pattern>/</url-pattern> //Este es el lugar, la plantilla que encontré es *.do //resultando al final cuando ingreso el índice en el navegador, 404 debe cambiarse a /. Entonces no habrá problema.
</servlet-mapping>
Agregue la configuración de la plantilla del archivo springmvc.xml:
Este archivo se utiliza para mapear la interacción de datos entre la capa del Controlador y JSP. devolver "iniciar sesión"
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
<!--扫包-->
<context:component-scan base-package="controller"/>
</beans>UserController: (interacción de código entre la capa de control y la capa JSP)
Paso 3: Continúe y cree el código en ejecución.
Primero, separe la lógica empresarial del controlador y represéntelo con una capa de servicio. (Aquí todavía uso el contenido de consultar todos los datos como prueba)
Por lo tanto, el método de escritura de la capa de servicio es en realidad el mismo que el de la capa dao. Es relativamente fácil de saltar.
Principalmente la capa del controlador, se crea un UserController. Principalmente interactúa con JSP.
package controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import po.User;
import service.UserService;
import java.util.List;
@Controller
public class UserController {
@Autowired
private UserService userService;
@RequestMapping("/queryAll")
public String queryAll(User user, Model model){
List<User> list= userService.queryAll(user);
model.addAttribute("userList",list);
return "show";
}
// 这个是为了方便输入index就显示下面那个index.jsp的页面。
@RequestMapping("/index")
public String index(Model model){
model.addAttribute("user",new User());
return "index";
}
}
El código de la capa JSP:
índice.jsp:
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<form:form modelAttribute="user" method="post" action="${pageContext.request.contextPath}/queryAll">
<input type="submit" value="查看所有信息">
</form:form>
</body>
</html>
mostrar.jsp:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<table>
<tr>
<th>账号</th>
<th>密码</th>
<th>性别</th>
<th>姓名</th>
</tr>
<c:forEach items="${userList}" var="user">
<tr>
<th>${user.account}</th>
<th>${user.password}</th>
<th>${user.sex}</th>
<th>${user.name}</th>
</tr>
</c:forEach>
</table>
</body>
</html>
Aquí se comete un error muy común:
<c:forEach elementos="${lista de usuarios}" var="usuario">
En esta línea, escribí userList, sin usar el formato correcto de la expresión EL ${}. El problema resultante es el uso de user.account. No lo solicitará.
Haga clic y tire:
${userList} Al igual que esta expresión EL, corresponde al modelo de capa del controlador.add("userList", Object ).
Entonces, ¿cómo asegurarnos de que obtenga la expresión EL que necesitamos? Depende principalmente de qué página se devuelve.
Resultado final de la prueba:
Una plantilla para un marco SSM completo está completa.
En el futuro, se deben agregar otras funciones, por lo que el lugar que se debe cambiar se debe cambiar de dos partes.
Parte: mapeo SQL para agregar funciones (Mapper.xml y mybatis-config.xml)
Otra parte: agregar el mapeo correspondiente a Controller y Jsp.
(Los archivos de configuración como pom.xml, application, springmvc, web.xml solo necesitan configurarse una vez)
Primero cambie el archivo de mapeo de Mapper.xml del marco mybatis y cambie la especificación de mybatis-config.xml. Es mejor probar de nuevo si se obtienen los datos.
Luego agregue la clase UserController y la clase JSP correspondiente del marco SpringMVC. (Los datos de estos dos deben reflejarse entre sí, lo que requiere atención).
Clase de controlador de usuario:
@RequestMapping("/index") especifica la página de entrada del navegador.
modelo.addAttribute("usuario",nuevo Usuario());
return "index"; Devuelve los datos de model.addr a la página index.jsp.
JSP类（index.jsp、show.jsp）：
<form:form modelAttribute="user" corresponde a los datos devueltos por el modelo de index.jsp
action="${pageContext.request.contextPath}/queryAll"> corresponde al método @RequestMapping("/queryAll") del controlador de queryALL.
<c:forEach items="${userList}" var="user"> De manera similar, los datos del modelo userList en el método correspondiente a queryAll
Finalmente, a través de la práctica, descubrí que, además de la capa Controll, puede volver a interactuar con datos JSP, o puede interactuar con datos JSP en la capa de servicio. Porque la capa de servicio es responsable de la lógica empresarial. Por lo tanto, si los datos se obtienen de JSP, primero se envían a la capa del controlador y luego la capa del controlador se envía a la capa de servicio para la interacción de datos.
Resumen: (debes prestar atención a la diferencia)
Al igual que el ejemplo anterior, para consultar toda la información del usuario, obtiene toda la información desde dentro de la base de datos. Entonces, los datos se obtienen de la capa dao y luego se entregan al Servicio, y luego se entregan a la capa del Controlador. Finalmente, se entrega a la capa JSP para su visualización.
De esta forma, el controlador proporciona datos a la capa JSP y proporciona datos a JSP a través de model.addrute.
Sin embargo, si es para iniciar sesión o consultar dicha información de formulario a pedido, obtiene datos de JSP y los envía al Controlador, y luego el Controlador pasa los datos al Servicio para su consulta y, finalmente, la capa de Servicio devuelve el resultado a la capa JSP para su visualización. (Este es un uso común. Practique iniciando sesión)
De esta manera, JSP proporciona datos a la capa del Controlador a través de form:action="${pagecontext/request/contextPath}/el nombre de @RequestMapping de un determinado Controlador." Este método proporciona datos a la capa del controlador.
De esta forma, la capa del controlador no necesita devolver datos como model.addrbut(). Es decir, los datos proporcionados por JSP no requieren vinculación de datos. Regrese directamente a la capa de servicio y la capa de servicio proporciona datos a la capa JSP.