SSM整合实现CRUD

用户11097514

发布于 2024-05-30 17:09:52

910

发布于 2024-05-30 17:09:52

文章被收录于专栏：技术分享技术分享

关于SSM的整合及其实现CRUD功能和分页功能

相关配置文件

pom.xml

各个依赖的配置，直接复制即可

    <!-- 控制Maven在构建过程中相关配置 --
    <build
        <!-- 构建过程中用到的插件 --
        <plugins
            <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 --
            <plugin
                <groupIdorg.mybatis.generator</groupId
                <artifactIdmybatis-generator-maven-plugin</artifactId
                <version1.3.0</version
                <!-- 插件的依赖 --
                <dependencies
                    <!-- 逆向工程的核心依赖 --
                    <dependency
                        <groupIdorg.mybatis.generator</groupId
                        <artifactIdmybatis-generator-core</artifactId
                        <version1.3.2</version
                    </dependency
                    <!-- 数据库连接池 --
                    <dependency
                        <groupIdcom.mchange</groupId
                        <artifactIdc3p0</artifactId
                        <version0.9.2</version
                    </dependency
                    <!-- MySQL驱动 --
                    <dependency
                        <groupIdmysql</groupId
                        <artifactIdmysql-connector-java</artifactId
                        <version8.0.26</version
                    </dependency
                </dependencies
            </plugin
        </plugins
    </build



<!--    Spring的版本，不需要一个个管理，直接配置好，然后用${}来引用--
    <properties
        <spring.version5.3.1</spring.version
    </properties

    <dependencies
        <!--上下文依赖--
        <dependency
            <groupIdorg.springframework</groupId
            <artifactIdspring-context</artifactId
            <version${spring.version}</version
        </dependency
        <!--管理bean的依赖--
        <dependency
            <groupIdorg.springframework</groupId
            <artifactIdspring-beans</artifactId
            <version${spring.version}</version
        </dependency
        <!--springmvc--
        <dependency
            <groupIdorg.springframework</groupId
            <artifactIdspring-web</artifactId
            <version${spring.version}</version
        </dependency
        <dependency
            <groupIdorg.springframework</groupId
            <artifactIdspring-webmvc</artifactId
            <version${spring.version}</version
        </dependency
        <!--事务解析器(事务管理器)的那个类，就在jdbc中，所以需要引用这个依赖--
        <dependency
            <groupIdorg.springframework</groupId
            <artifactIdspring-jdbc</artifactId
            <version${spring.version}</version
        </dependency
        <!--管理切面的依赖--
        <dependency
            <groupIdorg.springframework</groupId
            <artifactIdspring-aspects</artifactId
            <version${spring.version}</version
        </dependency
        <!--Spring整和Junit测试的--
        <dependency
            <groupIdorg.springframework</groupId
            <artifactIdspring-test</artifactId
            <version${spring.version}</version
        </dependency
        <!-- Mybatis核心 --
        <dependency
            <groupIdorg.mybatis</groupId
            <artifactIdmybatis</artifactId
            <version3.5.7</version
        </dependency
        <!--mybatis和spring的整合包，会提供一些特殊的类--
        <dependency
            <groupIdorg.mybatis</groupId
            <artifactIdmybatis-spring</artifactId
            <version2.0.6</version
        </dependency
        <!-- 连接池 --
        <dependency
            <groupIdcom.alibaba</groupId
            <artifactIddruid</artifactId
            <version1.0.9</version
        </dependency
        <!-- junit测试 --
        <dependency
            <groupIdjunit</groupId
            <artifactIdjunit</artifactId
            <version4.12</version
            <scopetest</scope
        </dependency
        <!-- MySQL驱动 --
        <dependency
            <groupIdmysql</groupId
            <artifactIdmysql-connector-java</artifactId
            <version8.0.16</version
        </dependency
        <!-- log4j日志 --
        <dependency
            <groupIdlog4j</groupId
            <artifactIdlog4j</artifactId
            <version1.2.17</version
        </dependency
        <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper --
        <!--分页插件--
        <dependency
            <groupIdcom.github.pagehelper</groupId
            <artifactIdpagehelper</artifactId
            <version5.2.0</version
        </dependency
        <!-- 日志 slf4g --
        <dependency
            <groupIdch.qos.logback</groupId
            <artifactIdlogback-classic</artifactId
            <version1.2.3</version
        </dependency
        <!-- ServletAPI 前端控制器就是间接继承里面的httpServlet --
        <dependency
            <groupIdjavax.servlet</groupId
            <artifactIdjavax.servlet-api</artifactId
            <version3.1.0</version
            <scopeprovided</scope
        </dependency
        <!--处理json数据的依赖--
        <dependency
            <groupIdcom.fasterxml.jackson.core</groupId
            <artifactIdjackson-databind</artifactId
            <version2.12.1</version
        </dependency
        <!--实现文件上传的依赖，下载不需要--
        <dependency
            <groupIdcommons-fileupload</groupId
            <artifactIdcommons-fileupload</artifactId
            <version1.3.1</version
        </dependency
        <!-- Spring5和Thymeleaf整合包 --
        <dependency
            <groupIdorg.thymeleaf</groupId
            <artifactIdthymeleaf-spring5</artifactId
            <version3.0.12.RELEASE</version
        </dependency

    </dependencies

web.xml

作用：

web项目启动的时候,首先对web.xml文件进行一个加载,只有此文件没有异常的时候,我们加载的web项目才算是真正的跑起来,而web.xml文件的内容加载也是由一定的顺序的.

代码实现

<?xml version="1.0" encoding="UTF-8"?
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

    <!-- 配置Spring的编码过滤器 --
    <filter
        <filter-nameCharacterEncodingFilter</filter-name
        <filter-classorg.springframework.web.filter.CharacterEncodingFilter</filter-class
        <init-param
            <param-nameencoding</param-name
            <param-valueUTF-8</param-value
        </init-param
        <init-param
            <param-nameforceEncoding</param-name
            <param-valuetrue</param-value
        </init-param
    </filter
    <filter-mapping
        <filter-nameCharacterEncodingFilter</filter-name
        <url-pattern/*</url-pattern
    </filter-mapping

    <!-- 配置处理请求方式PUT和DELETE的过滤器 --
    <filter
        <filter-nameHiddenHttpMethodFilter</filter-name
        <filter-classorg.springframework.web.filter.HiddenHttpMethodFilter</filter-class
    </filter
    <filter-mapping
        <filter-nameHiddenHttpMethodFilter</filter-name
        <url-pattern/*</url-pattern
    </filter-mapping

    <!-- 配置SpringMVC的前端控制器 --
    <servlet
        <servlet-nameSpringMVC</servlet-name
        <servlet-classorg.springframework.web.servlet.DispatcherServlet</servlet-class
        <!-- 设置SpringMVC的配置文件的位置和名称 --
        <init-param
            <param-namecontextConfigLocation</param-name
            <param-valueclasspath:SpringMVC.xml</param-value
        </init-param
        <!--将DispatcherServlet的初始化时间提前到服务器启动时--
        <load-on-startup1</load-on-startup
    </servlet
    <servlet-mapping
        <servlet-nameSpringMVC</servlet-name
        <url-pattern/</url-pattern
    </servlet-mapping

    <!-- 设置Spring的配置文件的位置和名称 --
    <context-param
        <param-namecontextConfigLocation</param-name
        <param-valueclasspath:Spring.xml</param-value
    </context-param
    <!-- 配置Spring的监听器 ：作用再Spring服务启动时加载Spring的配置文件来获取ioc容器--
    <listener
        <listener-classorg.springframework.web.context.ContextLoaderListener</listener-class
    </listener
</web-app

SpringMVC.xml

作用：

用户发送请求，被 SpringMVC 的前端控制器 DispatcherServlet 拦截，配置拦截器
由 DispatcherServlet 查询HanderMapping，找到处理请求的Controller
Controller调用业务逻辑进行处理后，返回ModelAndView，进行试图控制
DispatcherServlet 查询视图解析器，找到ModelAndView指定的视图
视图负责将结果显示到客户端

代码展示

<?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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd"

   <!--扫描组件- SpringMVC只需要扫描控制层组件--
    <context:component-scan base-package="SSM.controller"</context:component-scan
    <!--配置视图解析器--
    <bean id="viewResolver"
          class="org.thymeleaf.spring5.view.ThymeleafViewResolver"
        <property name="order" value="1"/
        <property name="characterEncoding" value="UTF-8"/
        <property name="templateEngine"
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine"
                <property name="templateResolver"
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver"
                        <!-- 视图前缀 --
                        <property name="prefix" value="/WEB-INF/templates/"/
                        <!-- 视图后缀 --
                        <property name="suffix" value=".html"/
                        <property name="templateMode" value="HTML5"/
                        <property name="characterEncoding" value="UTF-8" /
                    </bean
                </property
            </bean
        </property
    </bean

    <!--配置文件（图片）上传的解析器--
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"/
<!--    <mvc:interceptors--
<!--        <mvc:interceptor--
<!--            &lt;!&ndash;        对于path的路径中， /* 只能拦截根目录下的一层路径， /**可以拦截目录下所有的路径&ndash;&gt;--
<!--            <mvc:mapping path="/**"/--
<!--            &lt;!&ndash;            exclude除了XXX之外，需要拦截的请求路径&ndash;&gt;--
<!--            <mvc:exclude-mapping path="/abc"/--
<!--            &lt;!&ndash;配置拦截器的实现类，实现HandlerInterceptor(处理程序拦截器)接口&ndash;&gt;--
<!--            <bean class="SSM.interceptor.FirstInterceptor"/--
<!--            &lt;!&ndash;            <ref bean="firstInterceptor"/&ndash;&gt;--
<!--        </mvc:interceptor--
<!--    </mvc:interceptors--
    <!-- 配置默认的servlet处理静态资源 --
    <mvc:default-servlet-handler /
    <!-- 开启MVC的注解驱动 --
    <mvc:annotation-driven /
<!--    &lt;!&ndash; 配置访问首页的视图控制 &ndash;&gt;--
    <mvc:view-controller path="/" view-name="index"</mvc:view-controller
    <mvc:view-controller path="/to/add" view-name="add"</mvc:view-controller
    <mvc:view-controller path="/update" view-name="update"</mvc:view-controller
<!--    <mvc:view-controller path="/update2" view-name="update"</mvc:view-controller--
</beans

Spring.xml

作用：

IOC容器、aop、装载bean、spring事务。
配置Mapper接口扫描，通过SqlSession创建代理实现类对象，并将这些对象交给IOC容器来管理.省去dao层。
实现对MyBatis相关组件修改，可代替mybatis的配置文件

代码展示

<?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:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"

    <!--    扫描处理controller层之外的其他层--
    <context:component-scan base-package="SSM"
        <!--排除对控制层组件的扫描--
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/
    </context:component-scan

    <!--配置事务管理器--
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
        <property name="dataSource" ref="dataSource"
        </property
    </bean

    <!--开启事务的管理驱动 ,将使用@Annotation标识的方法或类中所有的方法进行事务管理--
    <tx:annotation-driven transaction-manager="transactionManager"/



<!--    配置数据源的扫描--
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/
        <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/
        <property name="username" value="root"/
        <property name="password" value="root"/
    </bean
    <!--配置SqlSessionFactory工厂
   配置sqlSessionBean ：可以帮助我们直接在Spring的ioc中获取sqlSessionFactory对象
   --
<!--    <bean class="org.mybatis.spring.SqlSessionFactoryBean"--
<!--        设置mybatis核心配置文件的bean--
<!--        <property name="configLocation" value="classpath:mybatis-config.xml"</property--
<!--        <property name="dataSource" ref="dataSource"</property--
<!--        <property name="typeAliasesPackage" value="SSM.pojo.Employee"</property--
        <!--将下划线映射为小驼峰--
<!--        <property name="configurationProperties" value="mapUnderscoreToCamelCase"</property--
        <!--  这个标签设置原因是因为，映射文件所在的包，和mapper所在的包不一致时才设置
    <property name="mapperLocations" value="classpath:mappers/*.xml"</property--
<!--        <property name="plugins"--
<!--            <array--
<!--                <bean class="com.github.pagehelper.PageInterceptor"--
<!--                </bean--
<!--            </array--
<!--        </property--
<!--    </bean--
    <!--配置SqlSessionFactory工厂
    配置sqlSessionBean ：可以帮助我们直接在Spring的ioc中获取sqlSessionFactory对象
    --
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
        <property name="configLocation" value="classpath:mybatis-config.xml"
        </property
        <property name="dataSource" ref="dataSource"
        </property
        <property name="configurationProperties" value="mapUnderscoreToCamelCase"

        </property
     </bean
    <!--配置mapper接口的扫描，可以将指定包下的所有mapper接口，通过SqlSession创建
    代理实现类对象，并将这些对象交给IOC容器来管理--
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
        <property name="basePackage" value="SSM.mapper"
        </property
    </bean
</beans

MyBatis-config.xml

作用：

mybatis是对jdbc的封装，它让数据库底层操作变的透明。
mybatis的操作都是围绕一个sqlSessionFactory实例展开的。
mybatis通过配置文件关联到各实体类的Mapper文件，Mapper文件中配置了每个类对数据库进行的sql语句映射。
在每次与数据库交互时，通过sqlSessionFactory拿到一个sqlSession对象，再执行sql命令。

代码实现

<?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"

<!--MyBatis的核心配置文件--
<configuration
    <settings
        <!-- 是否开启自动驼峰命名规则（camel case）映射，即从数据库列名 A_COLUMN 到属性名 aColumn 的类似映射 --
        <setting name="mapUnderscoreToCamelCase" value="true"/
    </settings
    <!--    引入properties文件  , 这样的话,以后就可以直接在当前文件中时使用 的方式来访问驱动类--
    <typeAliases
        <!--::用下面这个标签 他的别名就是pojo中的类名 ,且不区分大小写--
        <package name="SSM.pojo"/
    </typeAliases
<!--    将下划线映射为驼峰--
<!--    <settings--
<!--        <setting name="mapUnderscoreToCamelCase" value="true"/--
<!--    </settings--
    <!--配置分页插件--
    <plugins
        <!--设置分页插件--
        <plugin interceptor="com.github.pagehelper.PageInterceptor"
        </plugin
    </plugins
    <!--设置连接数据库的环境--
    <environments default="development"
        <!--          id  与default的内容是一样的--
        <environment id="development"
            <transactionManager type="JDBC"/
            <dataSource type="POOLED"
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"/
                <property name="username" value="root"/
                <property name="password" value="root"/
            </dataSource
        </environment
    </environments
    <!--mybatis映射文件--
    <mappers
        <!--
    这个的要求是:1. 映射文件所在的包 和mapper接口所在的包一样
               2. 映射文件的名字和mapper接口的名字保持一致
--
        <package name="SSM.mapper"/
    </mappers
</configuration

log4j.xml

作用：(暂时不明)

ConsoleAppender: 日志输出到控制台；
FileAppender：输出到文件；
RollingFileAppender：输出到文件，文件达到一定阈值时，自动备份日志文件;
DailyRollingFileAppender：可定期备份日志文件，默认一天一个文件，也可设置为每分钟一个、每小时一个；
WriterAppender：可自定义日志输出位置

代码展示

<?xml version="1.0" encoding="UTF-8" ?
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender"
        <param name="Encoding" value="UTF-8" /
        <layout class="org.apache.log4j.PatternLayout"
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}
%m (%F:%L) \n" /
        </layout
    </appender
    <logger name="java.sql"
        <level value="debug" /
    </logger
    <logger name="org.apache.ibatis"
        <level value="info" /
    </logger
    <root
        <level value="debug" /
        <appender-ref ref="STDOUT" /
    </root
</log4j:configuration

generatorConfig.xml

作用：

实现MyBatis逆向工程的配置文件，具体操作详见 本人前面的文章

代码展示

<?xml version="1.0" encoding="UTF-8"?
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"
<generatorConfiguration
        <!--
targetRuntime: 执行生成的逆向工程的版本
        MyBatis3Simple: 生成基本的CRUD（简洁版）
        MyBatis3: 生成带条件的CRUD（终极版）
--
        <context id="DB2Tables" targetRuntime="MyBatis3"

                <!-- 1. 数据库的连接信息 --
                <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                    connectionURL="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC"
                    userId="root"
                    password="root"
                </jdbcConnection

                <!-- 2. javaBean 数据库表对应的实体类--
                <javaModelGenerator targetPackage="SSM.pojo" targetProject=".\src\main\java"
                        <property name="enableSubPackages" value="true" /
                        <property name="trimStrings" value="true" /
                </javaModelGenerator

                <!-- 3. SQL映射文件的生成策略 --
                <sqlMapGenerator targetPackage="SSM.mapper" targetProject=".\src\main\resources"
                        <property name="enableSubPackages" value="true" /<!--作用: 是否启动子包--
                </sqlMapGenerator

        <!--        4. java客户端生成器--
                <!-- 4. Mapper接口的生成策略 --
                <javaClientGenerator type="XMLMAPPER" targetPackage="SSM.mapper" targetProject=".\src\main\java"
                        <property name="enableSubPackages" value="true" /
                </javaClientGenerator

                <!-- 5. 逆向分析的表 --
                <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName --
                <!-- domainObjectName属性指定生成出来的实体类的类名 --
                <table tableName="t_emp" domainObjectName="Employee"/
        </context

</generatorConfiguration

功能实现

以Employee实例为例

具体的字段： emp_id , emp_name , age , gender , email

对应属性： empId , empName , age , gender , email

列表功能

实现详解：

当服务器启动时，首先加载出index.html页面，我们进行点击进入列表页面时。此时前端就会发送一个请求到我们的controller层。

此时controller层组件就会匹配相对应的控制器方法，我们的请求为“/employee” ，匹配到后控制层就进行操作

因为控制层实现了service的自动装箱，所以通过就可以直接调用service层的方法处理需求

同时因为我们再Spring.xml中实现了对mapper接口的扫描，我们就不需要再进行调用DAO层，直接就可以操作数据库(已经通过SqlSession创建代理实现类对象)

同样的service层实现了对mapper的自动装箱，此时就可以直接调用mapper接口中的方法，对数据库进行操作，实现查询所有用户的功能返回给Controller层的方法中

在控制层我们就可以调用Model来实现数据向request域对象中共享数据

model.addAttribute("list",list);

最后将数据返回到前端

前端代码：

<body
    <table
        <tr
            <th colspan="6"员工列表</th
        </tr
        <tr
            <th编号</th
            <th姓名</th
            <th年龄</th
            <th性别</th
            <th邮箱</th
            <th操作</th
            <td<a th:href="@{/to/add}"添加员工</a</td
        </tr
        <tr th:each="employee : ${list}"
            <td th:text="${employee.empId}"</td
            <td th:text="${employee.empName}"</td
            <td th:text="${employee.age}"</td
            <td th:text="${employee.gender}"</td
            <td th:text="${employee.email}"</td
            <td
                <a th:href="@{'/delete/'+${employee.empId}}"删除</a
                <a th:href="@{'/update/'+${employee.empId}}"修改</a
            </td
        </tr

    </table

后端代码

//Controller层

@RequestMapping(value = "/employee",method = RequestMethod.GET)
public String getAllEmployee(Model model){

    List<Employee list = employeeService.getAllEmployee();
    model.addAttribute("list",list);
    return "employee_list";
}


//Service层
@Autowired
private EmployeeMapper mapper;
@Override
public List<Employee getAllEmployee() {
    return mapper.getAllEmployee();
}


//mapper接口
List<Employee getAllEmployee();



//EmployeeMapper.xml
<select id="getAllEmployee" resultType="Employee"
        select emp_id, emp_name,age,gender,email from t_emp
</select

分页功能

实现详解：

前面的步骤基本一样，前端发送请求到控制器层，Controller匹配相应的控制器方法进行实现
在前端传回的pageNum时，我们需要将Num交给service层，在service层开启分页功能，然后继续再service层查询到所有员工信息，再将数据交给PageInfo，通过他来获取分页相关的数据，最后返回pageInfo对象
最后将数据通过Model共享到Request域中，实现数据分页的显示

前端代码

<body
    <table
        <tr
            <th colspan="6"员工列表</th
        </tr
        <tr
            <th编号</th
            <th姓名</th
            <th年龄</th
            <th性别</th
            <th邮箱</th
            <th操作</th
            <td<a th:href="@{/to/add}"添加员工</a</td
        </tr
        <tr th:each="employee : ${page.list}"
            <td th:text="${employee.empId}"</td
            <td th:text="${employee.empName}"</td
            <td th:text="${employee.age}"</td
            <td th:text="${employee.gender}"</td
            <td th:text="${employee.email}"</td
            <td
                <a th:href="@{'/delete/'+${employee.empId}}"删除</a
                <a th:href="@{'/update/'+${employee.empId}}"修改</a
            </td
        </tr

    </table
    <div style="text-align: center"
<!--        <a th:if="${page.hasPreviousPage}" th:href="@{/employee/page/1}"首页</a--
<!--        <a th:if="${page.hasPreviousPage}" th:href="@{'/employee/page/' + ${page.prePage}}"上一页</a--
        <span th:if="${page.hasPreviousPage}"<a th:href="@{/employee/page/1}"首页</a
            <a th:href="@{'/employee/page/'+${page.prePage}}"上一页</a
        </span
        <span th:each="num : ${page.navigatepageNums}"
            <a th:if="${page.pageNum==num}" th:href="@{'/employee/page/'+${num}}" th:text="'['+${num}+']'" style="color:#d51313;"</a
            <a th:if="${page.pageNum!=num}" th:href="@{'/employee/page/'+${num}}" th:text="${num} "</a
        </span
        <span th:if="${page.hasNextPage}"
            <a th:href="@{'/employee/page/'+${page.nextPage}}"下一页</a
            <a th:href="@{'/employee/page/'+${page.pages}}"末页</a
        </span
    </div
</body

后端代码

//Controller层

@RequestMapping(value = "/employee/page/{pageNum}",method = RequestMethod.GET)
public String getAllEmployeeByDev(@PathVariable("pageNum") Integer pageNum, Model model){
        PageInfo<Employee page =employeeService.getAllEmployeeByDev(pageNum);
        model.addAttribute("page",page);
        return "employee_list";
    }

//Service层
@Override
public PageInfo<Employee getAllEmployeeByDev(Integer pageNum) {
    //开启分页公能
    PageHelper.startPage(pageNum,4);
    //查询所有的员工信息
    List<Employee list = mapper.getAllEmployee();
    //获取分页相关的数据
    PageInfo<Employee pageInfo = new PageInfo<(list,3);

    return pageInfo;
}


//mapper接口
List<Employee getAllEmployee();



//EmployeeMapper.xml
<select id="getAllEmployee" resultType="Employee"
        select emp_id, emp_name,age,gender,email from t_emp
</select

添加功能

实现详解

前端通过点击添加功能的标签，将页面跳转到添加页面，添加页面通过form表单将数据input完成后回响给控制层，控制层通过匹配action的值匹配到相应的控制器方法
控制器方法将得到的数据封装到Employee类中，然后再通过service将数据保存到数据库
最后通过重定向将页面跳转到列表页面

前端代码

<td<a th:href="@{/to/add}"添加员工</a</td

<body
    <form th:action="@{/addEmp}" method="post"
    <!--  修改添加上去  <input type="hidden" name="_method" value="put"--
        姓名: <input type="text" name="empName" value="AA"<br
        年龄: <input type="text" name="age" value="11"
        <br
        性别: <input type="radio" name="gender" value="M"M
        <input type="radio" name="gender" value="F"F
        <br
        email: <input type="text" name="email" value="XXX@qq.com"
        <br
        <input type="submit" value="addEmp"
    </form
</body

后端代码

//Controller层

@RequestMapping (value = "/addEmp",method = RequestMethod.POST)
public String addEmp(Employee employee){
    employeeService.addEmp(employee);
    //重定向至原来的页面
    return "redirect:/";
}

//Service层
@Override
public int addEmp(Employee employee) {
    return mapper.insert(employee);
}



//mapper接口
int insert(Employee employee);




//EmployeeMapper.xml
<!--  int insert(Employee record);--
    <insert id="insert"
    insert into t_emp(emp_name,age,gender,email)    values(#{empName},#{age},#{gender},#{email})
    </insert

修改功能

实现详解

前端通过点击对应用户后面的修改按钮将所要修改的数据传到控制层由相关的控制层方法接收后开始在数据库中查询用户
将查询到的用户信息通过Model共享到request域中，然后通过请求转发到修改页面将需要修改的数据显示出来
修改完成后通过form表单提交数据，通过action匹配控制层中的相应控制器方法，再通过service将数据修改后保存，实现数据的修改
最后重定向回当初的页面

前端代码

<a th:href="@{'/update/'+${employee.empId}}"修改</a

<!DOCTYPE html
<html lang="en" xmlns:th="http://www.thymeleaf.otg"
<head
    <meta charset="UTF-8"
    <title修改</title
</head
    <body
        <form th:action="@{/updateEmp}" method="post"
            <input type="hidden" name="_method" value="put"
            <input type="hidden" name="empId" th:field="${employee.empId}" 

            姓名: <input type="text" name="empName" th:field="${employee.empName}"<br
            年龄: <input type="text" name="age" th:field="${employee.age}"
            <br
            性别: <input type="radio" name="gender" value="M" th:field="${employee.gender}"M
            <input type="radio" name="gender" value="F" th:field="${employee.gender}" F
            <br
            email: <input type="text" name="email" th:field="${employee.email}"
            <br
            <input type="submit" value="update"
        </form
    </body
</html

后端代码


//Controller层

@RequestMapping("/update/{empId}")
public String getEmpById(@PathVariable("empId") Integer empId,Model model){
    //首先查询到id为要删除的人的id，然后将数据共享到add页面 ，最后实现的添加
    //employeeService.updateEmp();
    Employee employee = employeeService.getById(empId);
    System.out.println(employee);
    model.addAttribute("employee",employee);
    //        将数据共享到add页面显示出来，然后进行修改
    return "/update";
}

//Service层
@Override
public Employee getById(Integer id) {
    return mapper.selectByPrimaryKey(id);
}



//mapper接口
Employee selectByPrimaryKey(Integer empId);




//EmployeeMapper.xml
<!--      Employee selectByPrimaryKey(Integer empId);--
<select id="selectByPrimaryKey" resultType="Employee"
    select emp_id, emp_name,age,gender,email from t_emp where emp_id = #{empId}
</select
    
 
//修改回显的数据Controller层
@RequestMapping(value = "/updateEmp", method = RequestMethod.PUT)
public String updateEmployee(Employee employee){
    employeeService.save(employee);
    return "redirect:/employee/page/1";
}
//service层
@Override
public void save(Employee employee) {
    mapper.save(employee);
}   

<!--      Employee save(Employee employee);--
    <update id="save"
      update t_emp set emp_name = #{empName} ,age = #{age} ,gender = #{gender},email = #{email} where emp_id = #{empId}
    </update

删除功能

实现详解

前端通过点击对应用户后面的删除按钮，将要删除的用户的id传入Contrller层，找到对应的控制器方法，通过service调用mapper接口中的方法实现在数据库中删除用户信息
通过重定向返回对应的页面

前端代码

<a th:href="@{'/delete/'+${employee.empId}}"删除</a

后端代码


//Controller层
@RequestMapping(value = "/delete/{empId}")
public String deleteEmp(@PathVariable("empId") Integer empId){
    employeeService.deleteEmp(empId);
    return "redirect:/employee/page/1";
}

//service层
@Override
public void deleteEmp(Integer empId) {
    mapper.deleteEmp(empId);
}

//mapper方法
void deleteEmp(Integer empId);

<!--  void deleteEmp(Integer empId);--
<delete id="deleteEmp"
    delete from t_emp where emp_id = #{empId}
</delete>

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2023-01-09，如有侵权请联系 cloudcommunity@tencent.com 删除

配置

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度