SSM商城案例

使用SSM架构实现原先的servlet&JSP的商城项目

第一步：maven项目的pom文件中引入项目所需要的jar

<?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>com.gton</groupId>
    <artifactId>SSM-Shopping</artifactId>
    <version>1.0-SNAPSHOT</version>
​
    <!--  打包方式-->
    <packaging>war</packaging>
​
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring.version>5.0.5.RELEASE</spring.version>
    </properties>
    <!-- 依赖管理 -->
    <dependencies>
        <!-- jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.4</version>
        </dependency>
        <!-- servlet -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- EL表达式与JSTL标准标签库 -->
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-impl</artifactId>
            <version>1.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.taglibs</groupId>
            <artifactId>taglibs-standard-jstlel</artifactId>
            <version>1.2.5</version>
        </dependency>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.3</version>
        </dependency>
​
        <!-- MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
            <scope>runtime</scope>
        </dependency>
        <!-- 图片服务器的客户端 -->
        <dependency>
            <groupId>fastdfs-client</groupId>
            <artifactId>fastdfs-client</artifactId>
            <version>1.25</version>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.6</version>
            <scope>provided</scope>
        </dependency>
        <!-- commons-beanutils将参数封转成对象 -->
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.8.3</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- 图片验证码 -->
        <dependency>
            <groupId>com.github.whvcse</groupId>
            <artifactId>easy-captcha</artifactId>
            <version>1.6.2</version>
        </dependency>
        <!-- 日志组件 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.1.7</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.7</version>
        </dependency>
        <!-- redis客户端与连接池 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!-- mybatis分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.1.6</version>
        </dependency>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>
​
    <build>
        <plugins>
            <!-- tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8088</port>
                    <path>/</path>
                    <uriEncoding>UTF-8</uriEncoding>
                </configuration>
            </plugin>
            <!-- maven插件控制 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
       
    </build>
​
</project>

注意xml文件的mapper可能找不到，是项目打包运行时资源过滤问题引起的，所以在pom文件的build里面加入资源过滤的配置：

<!--资源过滤-->
        <resources>
            <resource>
                <directory>src/main/resource</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

第一步配置spring核心配置文件：

主要是做到这几件事情：

  1. 组件注解扫描配置： <context:component-scan base-package="com.gton"/>

  2. springmvc注解驱动，以使得访问路径与方法的匹配可以通过注解配置： mvc:annotation-driven/

  3. SpringmVC静态页面处理，如html,css,js,images可以访问： mvc:default-servlet-handler/

  4. 配置JSP视图解析器：将视图定位到/WEB/INF/jsp 这个目录下

  5. 配置扫描web组件： <context:component-scan base-package="com.gton.controller"/>

  6. 加载JDBC配置文件，读取数据源： <context:property-placeholder location="classpath:jdbc.properties"/>

  7. 数据源配置加载阿里巴巴的德鲁伊数据库连接池：DruidDataSource

  8. Spring MVC 拦截器注册,购物车必须要先登录后才能访问，杜绝直接访问购物车

  9. spring整合mybatis，将SqlSessionFactory交给spring管理，加载mybatis核心配置文件

  10. 让spring去扫描Mapper接口所在的包

  11. spring配置事务管理器，配置事物注解驱动。简化事物繁琐配置

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 注解的组件扫描 -->
    <context:component-scan base-package="com.gton"/>
    <!-- 1.开启SpringMVC注解模式 -->
    <mvc:annotation-driven/>
    <!-- 2.静态资源默认servlet配置
       (1)加入对静态资源的处理：js,gif,png
       (2)允许使用"/"做整体映射
    -->
    <mvc:default-servlet-handler/>
​
​
    <!-- 3.配置jsp 显示ViewResolver;配置jsp视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
​
    <!-- 4.扫描web相关的bean -->
    <context:component-scan base-package="com.gton.controller"/>
​
    <!-- 加载properties配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- Spring MVC 拦截器注册 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/><!--只拦截匹配的请求路径-->
            <bean class="com.gton.servlet_filter.CommonInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
​
    <!-- 数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
​
    <!-- spring整合mybatis -->
    <!-- 1 将SqlSessionFactory交给spring管理 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 1.1 数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 1.2 加载Mybatis核心配置文件 -->
        <property name="configLocation" value="classpath:SqlMapConfig.xml"/>
    </bean>
​
    <!-- 2 让spring去扫描Mapper接口所在的包 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.gton.mapper"/>
    </bean>
​
    <!-- spring配置事务 -->
    <!-- 1 平台事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 2事务的注解驱动-->
    <tx:annotation-driven/>
</beans>

mybatis核心配置文件配置：

原始的：mybatis使用

1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息 2、sql映射文件;配置了每一个sql，以及sql的封装规则等。 3、将sql映射文件注册在全局配置文件中 4、写代码: 1）根据全局配置文件得到SqlsessionFactory; 2）使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查 一个sqlsession就是代表和数据库的一次会话，用完关闭 3)、使用sql的唯一标志来告诉MyBatis执行哪个SQL。SQL都是保存在SQL映射文件中的

5.函数式接口编程，sql映射文件的namespace指定Dao层接口文件，CRUD标签的id绑定值为namespace指定的命名空间的方法名，这样就绑定好了。。。调用dao层的接口，执行方法就完成了一次数据库CRUD的一次操作。。底层还是使用代理模式。所以不需要我们实现接口，通过自己的实例对象去执行业务逻辑。。mybatis自动为我们的接口创建一个匿名代理对象完成。。

spring整合mybatis后：

mybatis核心（全局）配置文件，不需要单独的数据源了，交给spring同一配置Druid的数据源，事务管理器也不需要了，使用Spring的事物管理器就好了。最主要的mybatis核心对象sqlsessionfactory对象交给spring去管理。所以然后只需要配置别名简化实体类的全限定名，设置数据库方言以及关联SQL映射文件mapper的位置（注册mapper--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">
<configuration>
    <typeAliases>
        <package name="com.gton.entity"/>
    </typeAliases>
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageHelper">
            <!-- 指定方言 -->
            <property name="dialect" value="mysql"/>
        </plugin>
    </plugins>
    <mappers>
        <package name="com.gton.mapper"/>
    </mappers>
</configuration>

jdbc.properties配置：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.11.44:3306/shop?characterEncoding=utf8&useSSL=false
jdbc.username=root
jdbc.password=123456

redis.properties配置：

jedis.host=192.168.11.44
jedis.port=6379
jedis.maxTotal=50
jedis.maxIdle=10

日志配置logback：

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    <property name="CONSOLE_LOG_PATTERN"
              value="%red(%date{yyyy-MM-dd HH:mm:ss}) %highlight(%-5level) %red([%thread]) %boldMagenta(%logger{50}) %cyan(%msg%n)"/>
    <!-- 控制台输出 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>
    <!-- 日志输出级别 -->
    <root level="INFO">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

建立jedis工具类，方便java操作redis

package com.gton.utiles;
​
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
​
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
​
public class JedisUtils {
    //创建连接池
    private static JedisPoolConfig config;
    private static JedisPool pool;
    static {
        try {
            InputStream resource = JedisUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
            Properties properties = new Properties();
            properties.load(resource);
            config = new JedisPoolConfig();
            config.setMaxTotal(Integer.parseInt(properties.getProperty("jedis.maxTotal")));
            config.setMaxIdle(Integer.parseInt(properties.getProperty("jedis.maxIdle")));
            pool = new JedisPool(config, properties.getProperty("jedis.host"), Integer.parseInt(properties.getProperty("jedis.port")));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //获取连接的方法
    public static Jedis getJedis() {
        return pool.getResource();
    }
    //释放连接
    public static void closeJedis(Jedis j) {
        j.close();
    }
}
​

建立UUID工具类，方便主键的创建：

package com.gton.utiles;
​
import java.util.UUID;
​
public class UUIDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replace("-", "").toUpperCase();
    }
    public static String getUUID64(){
        return getId()+getId();
    }
    public static String getCode(){
        return getId();
    }
    public static void main(String[] args) {
        // EA18278BF9D5430E9C34F33BA05D6C0F
        for (int i = 0; i < 10; i++) {
            System.out.println(getId());
        }
    }
}
​

商场项目思路：

web.xml配置SpringMVC的：DispatcherServlet,还有字符编码CharacterEncodingFilter拦截处理

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
​
<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_3_1.xsd"
         version="3.1" metadata-complete="true">
    <display-name>Archetype Created Web Application</display-name>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置springMVC需要加载的配置文件
         -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:applicationContext.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <!-- 默认匹配所有的请求 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>
​

默认的打开webapp下面的index文件，我这里设置它打开后自动重定向访问需求的URL

inde外部：主要是使用js和serlvet的方法实现三秒后自动跳转访问其他的URL

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
    <script>
        //使用匿名函数方法
        function countDown(){
            var time = document.getElementById("Time");
            //alert(time.innerHTML);
            //获取到id为time标签中的内容，现进行判断
            if(time.innerHTML == 0){
                //等于0时清除计时
                window.location.href="${pageContext.request.contextPath}/index/admin";
            }else{
                time.innerHTML = time.innerHTML-1;
            }
        }
        //1000毫秒调用一次
        window.setInterval("countDown()",1000);
    </script>
    <style>
        #Time,#p{
            font-size: 100px;
            text-align: center;
        }
    </style>
</head>
<body onload="countTime()">
​
<div align="center">
    <h1>郭童的一个：SSM商城项目启动完成。。。。。</h1>
    <h2>三秒后自动跳转</h2>
    <p id="Time">3</p>
</div>
<%
    response.setHeader("refresh", "3;URL=/index/admin");
%>
<%--<jsp:forward page="/index/admin"/>--%>
</body>
</html>
测试springmvc配置是否成功：
@Controller
public class HelloWord {
​
    @RequestMapping("/hello")
    @ResponseBody
    public String  SayHello(){
        System.out.println("hello  SpringMVC");
        return "Hello郭童";
    }
}

结果没问题:

image-20201006225506526

查看原型页面的index，发现有三个东西需要后台返回，{商品分类、最热的商品、最新的}

思路：当外部index重定向到原型页面index，需要先经过一次url请求，然后通过controller响应视图解析器返回这里的index页面，同时通过四大域对象的某一个携带这个页面所需要的三个参数，这个jsp页面通过JSTL&EL表达式取出域对象携带过来的参数，展示给jsp页面。。。。

一：设置url接收外部index重定向的请求，使用mvc三层架构完成数据库的数据获取，携带参数通过视图解析器返回给jsp页面：
二：从数据库获取数据需要封装到bean里面，方便·管理。。使用mybatisORM对象关系映射技术
三：实体类编写。。。。。。。此处省略，，
四：发送请求，该由controller组件接收，然后调用service层处理业务逻辑，service调用mapper操作数据库数据。。
controller：外部index三秒后自动重定向的是：/index/admin，
@Controller
@RequestMapping("/index")
public class IndexController {
    //依赖注入
    @Autowired
    private CategoryService  categoryService;
    @Autowired
    private ProductService productServices;
    //SPring MVC 请求处理
​
    @RequestMapping("/admin")
    public String indexPage(Model model){
​
        //2.找出最新的商品数据
        List<Product> productNews = productServices.findNews();
        //3.找出最热的商品数据
        List<Product> productHot = productServices.findHot();
        //存入model中，
​
        model.addAttribute("newsList",productNews);
        model.addAttribute("hotList",productHot);
        System.out.println("index请求处理成功。。。");
        return "index";
    }
    。。。。。。。。。。。。
}

我这里就不用了原生的servlet四大域对象，这里就用spring ui包下的model对象传递数据。。。。。

service：controller需要得到最新的产品以及最热的产品，这肯定不是简单几条数据，所以pagehelper分页

1.service接口

public interface ProductService {
​
    List<Product> findHot();
​
    List<Product> findNews();
}

2.service实现类：pagehelper分页,顺便练习一哈jdk8新特性stream流排个序

@Service
public class ProductServiceImpl implements ProductService {
​
    @Autowired
    private ProductMapper productMapper;
​
    public List<Product> findHot() {
        //分页:分页设置放在查询之前
        PageHelper.startPage(1, 8);
        List<Product> hotList = productMapper.findHotList();
        PageInfo<Product> pageInfo = new PageInfo<>(hotList);
        List<Product> products = pageInfo.getList();
        System.out.println("当前页码：" + pageInfo.getPageNum());
        System.out.println("每页的记录数：" + pageInfo.getPageSize());
        System.out.println("总记录数：" + pageInfo.getTotal());
        System.out.println("总页码：" + pageInfo.getPages());
        System.out.println("是否第一页：" + pageInfo.isIsFirstPage());
        return products;
    }
​
    public List<Product> findNews() {
        //分页
        PageHelper.startPage(1, 8);
        List<Product> NewsList = productMapper.findNewsList();
        PageInfo<Product> pageInfo = new PageInfo<>(NewsList);
        List<Product> products = pageInfo.getList();
        /* 显示的时候按照id排序:流处理
        Comparator comparator =   new Comparator<Product>() {
            @Override
            public int compare(Product o1, Product o2) {
​
                return Integer.parseInt(o1.getId())- Integer.parseInt(o2.getId());
            }
        };*/
        // sort排序:原集合不变，新集合按顺序排序
        //降序
       // products.stream().sorted(Comparator.comparing(Product::getId).reversed()).collect(Collectors.toList());
       //升序
        //products.stream().forEach(System.out::println);
        //List<Product> collect = products.stream().sorted((o1, o2) -> o1.getId().compareTo(o2.getId())).collect(Collectors.toList());
​
        products.sort((a,b)->a.getId().compareTo(b.getId()));
        System.out.println("当前页码：" + pageInfo.getPageNum());
        System.out.println("每页的记录数：" + pageInfo.getPageSize());
        System.out.println("总记录数：" + pageInfo.getTotal());
        System.out.println("总页码：" + pageInfo.getPages());
        System.out.println("是否第一页：" + pageInfo.isIsFirstPage());
        return products;
    }
}
mapper：接口+mapper.xml
public interface ProductMapper {
    List<Product> findHotList();
    List<Product> findNewsList();
}
<?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.gton.mapper.ProductMapper">
​
    <resultMap id="productMap" type="Product">
        <id column="pid" property="id"/>
        <result column="pname" property="name"/>
        <result column="market_price" property="marketPrice"/>
        <result column="shop_price" property="shopPrice"/>
        <result column="pimage" property="image"/>
        <result column="pdate" property="createDate"/>
        <result column="is_hot" property="isHot"/>
        <result column="pdesc" property="desc"/>
        <result column="pflag" property="flag"/>
        <result column="cid" property="cid"/>
    </resultMap>
    <select id="findHotList" resultMap="productMap">
        select * from product where is_hot = '1' order by cid asc
    </select>
​
    <select id="findNewsList" resultMap="productMap">
        select * from product order by pdate desc
    </select>
</mapper>
貌似最新和最热的写好了哈，然后就是产品种类的。。这个使用ajax异步请求
  $(function () {
        // 发送请求获取分类列表
        $.get('/index/categorys', function (categoryList) {
            var str = ''
            $.each(categoryList, function (index, category) {
                str += `<li><a href="/index/byCid?cid=\${category.cid}&currentPage=1&pageSize=10">\${category.cname}</a></li>`
            })
            $('#categoryUL').html(str)
        }, 'json')
    })
后台controller接收请求。这里不能用视图解析器了，直接把数据使用json对象形式传递回去

springmvc很人性，使用注解@ResponseBody//返回json格式不走视图解析器了。。

controller:产品种类
​
    @RequestMapping("/categorys")
    @ResponseBody//返回json格式
    public List<Category> categoryList(Model model){
        //1.查询全部的商品类别数据
       List<Category> categoryList = categoryService.findAll();
       return categoryList;
    }

service接口添加方法：List<Category> findAll();

service实现类：这里使用redis缓存技术，这些产品分类经常使用的，使用缓存提高效率

@Service
public class CategoryServiceImpl implements CategoryService {
​
    @Autowired
    private CategoryMapper categorymapper;
​
    public List<Category> findAll() {
        List<Category> categoryList = new ArrayList<>();
//        int allSize = categorymapper.findAll().size();//获取数据库的查询的数据的大小
        ObjectMapper mapper = new ObjectMapper();
        // 1 首先从redis缓存中查询
        Jedis jedis = JedisUtils.getJedis();
        String categoryListJson = jedis.get("categoryList");
        if (!StringUtils.isEmpty(categoryListJson)) {
            // 2 如果有就判断与MySQL数据库中的是否一致
            try {
                categoryList = mapper.readValue(categoryListJson, new TypeReference<List<Category>>() {
                });
//                int newAllSize = categoryList.size();
//                if (newAllSize!=allSize){
//                    //不一致，更新缓存
//                    categoryList = categorymapper.findAll();
//                    jedis.set("categoryList", mapper.writeValueAsString(categoryList));
//                    jedis.close();
//                    return categoryList;
//                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            // 3 如果没有再查询数据库
            categoryList = categorymapper.findAll();
            // 4 将查询到的结果存入缓存,再返回数据
            try {
                jedis.set("categoryList", mapper.writeValueAsString(categoryList));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }
        // 5 释放资源
        jedis.close();
        return categoryList;
    }
}
mapper:简单的sql逻辑直接使用注解方式比较快。。。。
@Select("select * from category")
List<Category> findAll();

。。。。。。。。其他的细节就不展示了。。。。看结果；；；；

 

 

 

 

posted on   白嫖老郭  阅读(125)  评论(0)  编辑  收藏  举报

编辑推荐：
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南

导航

< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示
AI IDE Trae