07第七章SSM框架整合(spring+springMvc+myBatis整合、JSON数据转换、Ajax异步加载、pageHelper分页)

最新推荐文章于 2024-05-14 21:51:30 发布

虚千寒雨燕

最新推荐文章于 2024-05-14 21:51:30 发布

阅读量255

点赞数

分类专栏： spring&springMVC基础文章标签： ssm spring mybatis springmvc

本文链接：https://blog.csdn.net/BiuBiuyu/article/details/115764183

版权

spring&springMVC基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

一、SSM框架环境搭建

spring + springMVC + Mybatis

环境要求

IDEA

MySQL 5.7.19

Tomcat 9

Maven 3.6

1.创建普通的maven项目在添加web项目

在这里插入图片描述

next 下一步就可以了创建完成，右键项目勾选web项目选版本号4.0 ok

在这里插入图片描述

2.在pom.xml中导入依赖

<!-- pom.xml -->
    <!-- 依赖：junit，数据库驱动，连接池，servlet，jsp，mybatis，mybatis-spring,spring -->
    <dependencies>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>

        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>

        <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>

        <!-- web中的常用依赖：servlet jsp jstl -->
        <!-- servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>

        <!-- jsp -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>

        <!--jstl标签库-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- MyBatis 整合依赖: mybatis& mybatis-spring -->
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>

        <!-- mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <!-- Spring 整合依赖 -->
        <!-- spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.3</version>
        </dependency>

        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>

        <!-- 织入事态代理 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

        <!-- jackson json转换包-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.2</version>
        </dependency>

        <!-- 阿里 FastJSON -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

        <!--        日志文件-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

    </dependencies>

    <!-- 静态资源导出问题 /资源过滤设置 -->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

3.创建包骨架结构

在这里插入图片描述

pojo层

package com.xqh.pojo;

public class Adm {
    private String adm_id;
    private String adm_name;
    private String adm_post;

    public String getAdm_id() {
        return adm_id;
    }

    public void setAdm_id(String adm_id) {
        this.adm_id = adm_id;
    }

    public String getAdm_name() {
        return adm_name;
    }

    public void setAdm_name(String adm_name) {
        this.adm_name = adm_name;
    }

    public String getAmd_post() {
        return adm_post;
    }

    public void setAmd_post(String amd_post) {
        this.adm_post = adm_post;
    }

    @Override
    public String toString() {
        return "Adm{" +
                "adm_id='" + adm_id + '\'' +
                ", adm_name='" + adm_name + '\'' +
                ", amd_post='" + adm_post + '\'' +
                '}';
    }
}

dao接口层

// java interface
package com.xqh.dao;

import com.xqh.pojo.Adm;

import java.util.List;

public interface AdmMapper {
    //增加
    int addAdm(Adm adm);

    //删除
    int deleteAdmById(int adm_id);

    //修改
    int updateAdm(Adm adm);

    //查询一条数据
    Adm selectAdm(int adm_id);

    //查询所有数据
    List<Adm> selectAllAdm();
}

<!--  dao层 AdmMapper.xml 映射文件 -->
<?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="com.xqh.dao.AdmMapper">
    <insert id="addAdm" >
        insert into  tb_adm values(null,#{adm_name},#{adm_post})
    </insert>



    <delete id="deleteAdmById">
        delete from tb_adm when adm_id=#{adm_id}
    </delete>



    <update id="updateAdm">
        update  tb_adm set adm_name=#{adm_name}, adm_post=#{adm_post}
            when adm_id=#{adm_id}
    </update>



    <select id="selectAdm" resultType="com.xqh.pojo.Adm">
        select * from tb_adm when adm_id=#{adm_id}
    </select>


    <select id="selectAllAdm" resultType="com.xqh.pojo.Adm">
        select * from tb_adm
    </select>

</mapper>

service接口层

//java service interface
package com.xqh.service;

import com.xqh.pojo.Adm;

import java.util.List;

public interface AdmService {
    //增加
    int addAdm(Adm adm);

    //删除
    int deleteAdmById(int adm_id);

    //修改
    int updateAdm(Adm adm);

    //查询一条数据
    Adm selectAdm(int adm_id);

    //查询所有数据
    List<Adm> selectAllAdm();
}

// service层 实现类
package com.xqh.service;

import com.xqh.dao.AdmMapper;
import com.xqh.pojo.Adm;

import java.util.List;

public class AdmServiceImpl implements AdmService{
//调用dao层的操作，设置一个set接口，方便Spring管理
    private AdmMapper admMapper;

    public void setAdmMapper(AdmMapper admMapper) {
        this.admMapper = admMapper;
    }


    @Override
    public int addAdm(Adm adm) {
        return admMapper.addAdm(adm);
    }

    @Override
    public int deleteAdmById(int adm_id) {
        return admMapper.deleteAdmById(adm_id);
    }

    @Override
    public int updateAdm(Adm adm) {
        return admMapper.updateAdm(adm);
    }

    @Override
    public Adm selectAdm(int adm_id) {
        return admMapper.selectAdm(adm_id);
    }

    @Override
    public List<Adm> selectAllAdm() {
        return admMapper.selectAllAdm();
    }
}

controller层(servlet)

package com.xqh.controller;

import com.xqh.pojo.Adm;
import com.xqh.service.AdmService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
@RequestMapping("/adm")
public class AdmController {
    //controller 调用 service 层
    @Autowired
    @Qualifier("AdmServiceImpl")
    private AdmService admService;

    @RequestMapping("/allAdm")
    public String list(Model model) {
        List<Adm> list = admService.selectAllAdm();
        model.addAttribute("list", list);
        return "allAdm";
    }
}

java测试类

package text;

import com.xqh.pojo.Adm;
import com.xqh.service.AdmService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        AdmService tbAdmService = (AdmService)context.getBean("AdmServiceImpl");
        for (Adm Adm : tbAdmService.selectAllAdm()) {
            System.out.println(Adm);

        }

    }
}

jsp/allAdm.jsp

<%--
  Created by IntelliJ IDEA.
  User: 虚千寒
  Date: 2021/4/11
  Time: 16:49
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${list}
</body>
</html>

index.jsp

<%--
  Created by IntelliJ IDEA.
  User: 虚千寒
  Date: 2021/4/11
  Time: 16:44
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <h3>
    <a href="${pageContext.request.contextPath}/adm/allAdm">进入用户页面</a>
  </h3>
  </body>
</html>

4.创建数据源database.properties文件

jdbc.driver=com.mysql.jdbc.Driver
# mysql8.0 以上要在连接后加时区设置 &serverTimezone=Asia/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/mybatis_test?characterEncoding=utf-8&useSSL=false&useUnicode=true
jdbc.username=root
jdbc.password=root123

5.创建MyBatis核心配置文件 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>

    <typeAliases>
        <package name="com.xqh.pojo"/>
    </typeAliases>

    <mappers>
        <mapper resource="com/xqh/dao/AdmMapper.xml"/>
    </mappers>
</configuration>

6.创建dao层文件 spring-dao.xml

<?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"
       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">
	
    <!-- 配置整合mybatis -->
    <!-- 1.关联数据库配置文件 -->
    <context:property-placeholder location="classpath:dataBase.properties"/>

    <!-- 2.连接池
        dbcp:半自动化操作， 不能自动接连
        c3p0:自动化操作(自动化的加载配置文件，并且可以自动设置到对象中)
        druid : hikari
     -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>



        <!-- c3po连接池的私有属性 -->
        <!--        最大最小连接数量-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>

        <!--        关闭连接后不自动commit-->
        <property name="autoCommitOnClose" value="false"/>

        <!--        获取连接超时 时间设置(超过多少时间就提示警告)-->
        <property name="checkoutTimeout" value="10000"/>

        <!--        当获取连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>

    </bean>


    <!-- 3.配置SqlSessionFactory对象  相当于MyBatisUtil的合体版 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 引用数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 绑定Mybatis的配置文件 -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/> 
    </bean>


	<!-- 4.配置扫描Dao接口包，动态实现Dao接口注入到spring容器中 -->
    <!--解释 ：https://www.cnblogs.com/jpfss/p/7799806.html-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 自动注册容器 -->
        <property name="basePackage" value="com.xqh.dao"/>  <!-- 不给  报错误提示 Property 'basePackage' is required -->
    </bean>

</beans>

7.创建service层文件spring-service.xml

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

    <!-- 1.扫描service下的包 -->
    <context:component-scan base-package="com.xqh.service"/>

    <!-- 2.将我们的所有业务类，注入到spring，可用通过配置，或注解  为后期获得beanId 做准备 -->
    <bean id="TbAdmServiceImpl" class="com.xqh.service.TbAdmServiceImp">
        <property name="tbAdmMapper" ref="tbAdmMapper"/>
    </bean>

    <!-- 3.声明事务配置 -->
    <bean id="transationManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据源 -->
        <property name="dataSource"  ref="dataSource"/>
    </bean>

    <!-- 4.aop事务支持 -->

</beans>

8.创建mvc文件spring-mvc.xml

<?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/cache http://www.springframework.org/schema/cache/spring-cache.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">


    <!-- 1.注解驱动 含处理器映射器 和 适配器 -->
    <mvc:annotation-driven/>
    <!-- 2.静态资源过滤 -->
    <mvc:default-servlet-handler/>
    <!-- 3.扫描包：controller -->
    <context:component-scan base-package="com.xqh.controller"/>

    <!-- 4.视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"/> <!-- 注意 jsp后面要写/ -->
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 4.1JSON乱码问题配置 -->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>


<!--    拦截器配置 访问页面权限使用-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.xqh.interceptor.Myinterceptor"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/user/**"/>
            <bean class="com.xqh.interceptor.LoginInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

9.创建spring核心配置文件管理applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">


    <!-- 引入关联spring -->
    <import resource="spring-dao.xml"/>
    <import resource="spring-service.xml"/>
    <import resource="spring-mvc.xml"/>

</beans>

10.配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 1.注册DispatcherServlet处理器 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!-- DispatcherServlet  要绑定一个springmvc配置文件 -->
        <!-- 关联一个springmvc的配置文件：【servlet-name】-servlet.xml  这里用他们的总配置文件applicationContext！！-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value><!-- 注意不要写错 -->
        </init-param>

        <!-- 启动级别1 tomcat服务器启动就会启动-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--     请求配置-->
    <!-- / 匹配所有的请求： (不匹配.jsp页面) -->
    <!-- /* 匹配所有的请求： (包括.jsp页面) 视图解析器会拼接 前缀和后缀 变成死循环-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


    <!-- 2.乱码过滤 -->
<!--        spring 自带的 过滤器fileter-->
        <filter>
            <filter-name>encoding</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>encoding</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>

    <!-- session过期时间 -->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>



</web-app>

11.配置Tomcat 及lib文件

第一个ssm程序运行成功

二、JSON数据转换

1.writeValueAsString转换jSON

-1 导入依赖

!--        jackson json转换包-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.2</version>
        </dependency>

-2 不封装工具类

//controller 层
/*
     json转换
     */
    @RequestMapping(value = "/j1")//produces = "application/json;charset=utf-8"设置json编码格式 可在spring中统一配置优化代码
    @ResponseBody//配合@Controller 使用的  若类的注解为@RestController则可以不用
    public String json() throws JsonProcessingException {
        //jackson. ObjectMapper
        ObjectMapper mapper = new ObjectMapper();

        User user = new User("1","虚千寒","18");

        String str = mapper.writeValueAsString(user);//抛出异常 转换为json数据格式{"id":"1","name":"虚千寒","age":"18"}
        return str;

//        return user.toString();

    }

/*
    json转换 集合接收及输出
    */
    @RequestMapping(value = "/j2")
    @ResponseBody//配合@Controller 使用的  若类的注解为@RestController则可以不用
    public String json2() throws JsonProcessingException {

        ArrayList<User> list = new ArrayList<>();

        User user = new User("1","虚千寒","18");
        User user1 = new User("1","虚千寒","18");
        User user2 = new User("1","虚千寒","18");
        User user3 = new User("1","虚千寒","18");

        list.add(user);
        list.add(user1);
        list.add(user2);
        list.add(user3);

        return new ObjectMapper().writeValueAsString(list);

    }

-3 封装工具类

//工具类
package com.xqh.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;


public class JsonUtils {

    //单个参数的构造方法
    public static String getJson(Object object){
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    //多个参数的构造方法
    public static String getJson(Object object,String dateFormat){
        ObjectMapper mapper = new ObjectMapper();

        mapper.configure(SerializationFeature.WRAP_EXCEPTIONS,false);
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        mapper.setDateFormat(sdf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

//controller 层
/*
    json转换 工具类实现
    */
    @RequestMapping(value = "/j3")
    @ResponseBody//配合@Controller 使用的  若类的注解为@RestController则可以不用
    public String json3() throws JsonProcessingException {
        Date date = new Date();

        return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");


    }

    /*
    json转换 工具类实现
    */
    @RequestMapping(value = "/j4")
    @ResponseBody//配合@Controller 使用的  若类的注解为@RestController则可以不用
    public String json4() throws JsonProcessingException {

        ArrayList<User> list = new ArrayList<>();

        User user = new User("1","虚千寒","18");
        User user1 = new User("1","虚千寒","18");
        User user2 = new User("1","虚千寒","18");
        User user3 = new User("1","虚千寒","18");

        list.add(user);
        list.add(user1);
        list.add(user2);
        list.add(user3);


        return JsonUtils.getJson(list);
    }

2.使用fastjson 类

导入依赖

		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
        </dependency>

//controller 层
/*
    FastJson json数据转换器  不用写工具类
     */
    @RequestMapping("/fj1")
    @ResponseBody
    public String fastJson2(){
        Date date = new Date();

        return JSON.toJSONStringWithDateFormat(date,"yyyy-MM-dd HH:mm:ss"); //可不用工具类
    }

    /*
    FastJson json数据转换器  不用写工具类
     */
    @RequestMapping("/fj2")
    @ResponseBody
    public String fastJson1(){
        ArrayList<User> list = new ArrayList<>();

        User user = new User("1","虚千寒","18");
        User user1 = new User("1","虚千寒","18");
        User user2 = new User("1","虚千寒","18");
        User user3 = new User("1","虚千寒","18");

        list.add(user);
        list.add(user1);
        list.add(user2);
        list.add(user3);

        return JSON.toJSONString(list); //可不用工具类
    }

三、Ajax异步加载数据

写js 需要jquery jar包

//controller 层
package com.xqh.controller;

import com.xqh.pojo.TbAdm;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@RestController
public class AjaxTextController {
    @RequestMapping("/a1")
    public void ajax(String name, HttpServletResponse response) throws IOException {
        System.out.println("a1:param=>"+name);

        if("xqh".equals(name)){
            response.getWriter().print("true   data:"+name +"状态：");
        }else{
            response.getWriter().print("false  data:"+name +"状态：");
        }
    }
	//---------上面这个servlet可以不写 只是在浏览器调试中查看 ajax是否访问成功------------------------------------------------------------------------
    /*
    异步加载数据
     */
    @RequestMapping("/a2")
    public List<TbAdm> a2(){
        ArrayList<TbAdm> userList = new ArrayList<>();

        //添加数据
        userList.add(new TbAdm(1,"虚千寒",223));
        userList.add(new TbAdm(1,"雨燕",223));
        userList.add(new TbAdm(1,"xqh晓",223));
        userList.add(new TbAdm(1,"acer",223));

         return userList;
    }
}

<!-- jsp 层 -->
<%--
  Created by IntelliJ IDEA.
  User: 虚千寒
  Date: 2021/4/12
  Time: 15:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Ajax</title>

    <script src="${pageContext.request.contextPath}/static/jquery/jquery-3.3.1.js"></script>
    <style>
        table,tr,td {
            border: 1px solid slategray;
            border-collapse: collapse;
            text-align: center;
        }
        /*给table表头设置宽度解决 防止数据添加时抖动*/
        th {
            border: 1px solid slategray;
            border-collapse: collapse;
            width: 50px;
        }
        table {
            margin-top: 20px;
            width: 300px;
        }
    </style>

    <script>  
        // ajax 获取后端数据 
        $(function(){
            $("#btn").click(function () {
                /*
                %.post( url, param[可以省略], success回调函数)
                 */
                $.post("${pageContext.request.contextPath}/a2",function (data) {
                   var html="";
                   for (let i = 0; i < data.length; i++ ){
                       html += "<tr>" +
                           "<td>" + data[i].adm_id + "</td>" +
                           "<td>" + data[i].adm_name + "</td>" +
                           "<td>" + data[i].adm_post + "</td>" +
                           "<tr>"
                   }

                   $("#content").html(html);  // 在下面的table 中添加数据
                })
            })
        })

    </script>

</head>

<body>
            <input type="text" placeholder="测试添加数据时是否刷新页面！">
            <input type="button" value="加载数据" id="btn">
      <main>
        <table >
            <tr>
                <th>id</th>
                <th>name</th>
                <th>post</th>
            </tr>

            <tbody id="content">

            </tbody>
        </table>

    </main>
</body>
</html>

四、拦截器权限认证

拦截器可以在控制层Controller方法前后执行对应的操作，以实现登录拦截，权限控制等功能。

1.编写controller层

package com.xqh.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpSession;

@Controller
@RequestMapping("/user")
public class LoginController {
    @RequestMapping("/login") // 登录判断 去往主页面还是当前页面  (submit提交路径)
    public String login(HttpSession session, String username, String password, Model model){
        System.out.println(username);
        System.out.println(password);

        //把用户的信息存在session中：
        session.setAttribute("userLoginInfo",username);
//        model.addAttribute("username",username);//默认requestScope 接受

        if(username.equals("") || username ==null ){ //登录的条件 用户名不能为空 否则跳转到登录页面
            return "login";
        }
        return "main";
    }

    @RequestMapping("/main")  //主页面跳转
    public String main(){
        return "main";
    }

    @RequestMapping("goLogin") //登录界面路径
    public String goLogjin(){
        return "login";
    }

    @RequestMapping("goOut") // 用户注销 路径(submit)
    public String goOut(HttpSession session){
        session.removeAttribute("userLoginInfo");
//        session.invalidate();// 此方法必须要关闭浏览器才可以
        return "login";
    }
}

2.写Interceptor拦截类

package com.xqh.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        //放行： 判断什么情况下 登录   //  默认returna true；放行所有路径     false拦截路径 无法访问 进去会使空白页面

        //去往登录页面 放行！
        if(request.getRequestURI().contains("goLogin")){
            return true;
        }

        //说明我在提交登录 第一次提交是获取不到数据的 所以第一次不能拦截  要获取数据
        if(request.getRequestURI().contains("login") ){
            return true;
        }

        //第一次登录，也是没有session的所以要放行 登录页面  跳转 不关闭浏览器再一次登录 就可以正常跳转主页面
        if(session.getAttribute("userLoginInfo") != null ) {
            System.out.println(session.getAttribute("userLoginInfo"));
             return true;
        }

        //都不成功转到登录页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);
        return  false;
    }
}

3. jsp 页面

-1 login.jsp

<%--
  Created by IntelliJ IDEA.
  User: 虚千寒
  Date: 2021/4/12
  Time: 21:28
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登录页面！！！</h1>
<form action="${pageContext.request.contextPath}/user/login" method="post">
    用户名：<input type="text" name="username"/>
    密码：<input type="text" name="password"/>
    <input type="submit" value="提交">
</form>
</body>
</html>

-2 main.jsp页面

<%--
  Created by IntelliJ IDEA.
  User: 虚千寒
  Date: 2021/4/12
  Time: 21:27
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>    
<h3>首页！！！</h3>
${sessionScope.userLoginInfo}
<p>
    <a href="${pageContext.request.contextPath}/user/goOut">注销</a>
</p>
</body>
</html>

-3 index.jsp 页面

<%--
  Created by IntelliJ IDEA.
  User: 虚千寒
  Date: 2021/4/11
  Time: 12:47
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
      <title>$Title$</title>
  </head>
  <body>
   <h3>
     <a href="${pageContext.request.contextPath}/adm/allAdm">进入用户页面</a>
   </h3>


  <h1><a href="${pageContext.request.contextPath}/user/goLogin">登录页面</a> </h1>
  <h1><a href="${pageContext.request.contextPath}/user/main">首页</a> </h1>
  </body>



</html>

五、分页插件 pageHelper

1.分页插件依赖

<!-- 分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.2.0</version>
        </dependency>

2.controller层

// controller 层 
		
        PageHelper.startPage( pageNumberInt, 3); //导入插件方法 第一个参数：总页数中的第几页，第二个参数：一页有几条数据

        ArrayList<Tb_Blog> tb_blogs = MyBatisTool.session.getMapper(BlogMapper.class).selectBlogAndAuthor(map);
        PageInfo pages = new PageInfo(tb_blogs);// 使用插件中的类 获取页面信息

        request.getSession().setAttribute("blogAndAuthor",tb_blogs);
        //上一页
        request.getSession().setAttribute("prePage",(pages.getPrePage() == 0 ?1:pages.getPrePage()));
        //当前页面
        request.getSession().setAttribute("pageNum",pages.getPageNum());
        //下一页
        request.getSession().setAttribute("nextPage",(pages.getNextPage()== 0?pages.getPages():pages.getPageNum()+1) );
        //总页数
        request.getSession().setAttribute("pages",pages.getPages());

// 可以打开 PageInfo类 查看里面的参数
  //当前页
    private int pageNum;
    //每页的数量
    private int pageSize;
    //当前页的数量
    private int size;

    //由于startRow和endRow不常用，这里说个具体的用法
    //可以在页面中"显示startRow到endRow 共size条数据"

    //当前页面第一个元素在数据库中的行号
    private long startRow;
    //当前页面最后一个元素在数据库中的行号
    private long endRow;
    //总页数
    private int pages;

    //前一页
    private int prePage;
    //下一页
    private int nextPage;

    //是否为第一页
    private boolean isFirstPage = false;
    //是否为最后一页
    private boolean isLastPage = false;
    //是否有前一页
    private boolean hasPreviousPage = false;
    //是否有下一页
    private boolean hasNextPage = false;
    //导航页码数
    private int navigatePages;
    //所有导航页号
    private int[] navigatepageNums;
    //导航条上的第一页
    private int navigateFirstPage;
    //导航条上的最后一页
    private int navigateLastPage;

3.mybaits-config核心配置文件中配置分页拦截器

 <typeAliases>
        <package name="com.xqh.model"/>
    </typeAliases>

    <!--    分页拦截器  注意顺序 要在typeAliases标签下-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!-- 设置数据库类型 Oracle,Mysql,MariaDB,SQLite,Hsqldb,PostgreSQL六种数据库-->
            <property name="helperDialect" value="mysql"/>
        </plugin>
    </plugins>

4.jsp配置分页tab

	  <div class="bottom" style="position: relative;top: 270px;left: 650px">

            <span><a href="Servlet?pageNumber=1">第一页</a></span>&nbsp;&nbsp;&nbsp;
            <span><a href="Servlet?pageNumber=${sessionScope.prePage}"> < </a></span>&nbsp;&nbsp;&nbsp;
            <span>当前页${sessionScope.pageNum}</span>&nbsp;&nbsp;&nbsp;
            <span><a href="Servlet?pageNumber=${sessionScope.nextPage}"> > </a></span>&nbsp;&nbsp;&nbsp;
            <span><a href="Servlet?pageNumber=${sessionScope.pages}">最后一页</a></span>&nbsp;
            <span> 总页数${sessionScope.pages}</span>
        </div>

六、SSM框架总结

搭建步骤

创建javaweb+maven的项目
pom.xml导入maven依赖
创建项目骨架 pojo、dao、service、controller等的包
创建database.properties 数据源文件
创建MyBatis核心配置文件（mappers 映射 )
创建ApplicationContext.xml文件 (spring总控制文件最后只需要导入分支文件即可)
1. 创建ApplicationContext文件分支 spring-dao.xml (数据库的连接 SqlSessionFactory对象 dao层类自动注册bean)
2. spring-service.xml (扫描service层注入ioc 注入连接池)
3. spring-mvc.xml (注解驱动静动态资源配置视图解析器扫描controller层)

7.配置web.xml (处理器控制器导入spring文件，语言编码过滤器)

虚千寒雨燕

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
07第七章SSM框架整合(spring+springMvc+myBatis整合、JSON数据转换、Ajax异步加载、pageHelper分页)

文章目录一、SSM框架环境搭建1.创建普通的maven项目在添加web项目2.在pom.xml中导入依赖3.创建包骨架结构4.创建数据源database.properties文件5.创建MyBatis核心配置文件 mybatis-config.xml6.创建dao层文件 spring-dao.xml7.创建service层文件spring-service.xml8.创建mvc文件spring-mvc.xml9.创建spring核心配置文件管理applicationContext.xml10.配置web.x
复制链接

扫一扫