Java项目【仿牛客网1-2】

爱被打了一巴掌 2024-03-22 19:21 16阅读 0赞

## 仿牛客网第一章 ##

### 一、技术架构 ###

*  Spring Boot
 *  Spring、Spring MVC、MyBatis
 *  Redis、Kafka、Elasticsearch
 *  Spring Security、Spring Actuator

说明：

> 1.SpringBoot是Spring的简化，更方便管理对象，对其他技术整合  
> 2.SpringMVC用于处理浏览器的请求  
> 3.MyBatis用来访问数据库  
> 4.Redis用作缓存，默认存在内存，性能好【对系统监控、运维人员掌握系统状态】  
> 5.Kafka用作消息队列  
> 6.Elasticsearch用作全文搜索  
> 7.Spring Security可以管理系统权限  
> 8.Spring Actuator用作系统上线后的状态监控

开发环境

构架工具Maven【最流行，创建、编译、测试、打包项目、生成文档】

集成开发工具：IDEA

数据库：MySQL【关系型】、Redis【NoSQL数据库】

版本控制工具Git【备份、团队协作】

### 二、环境搭建 ###

1.Apache Maven：可以帮助我们构建项目、管理项目中的jar包  
安装且配置环境变量后使用命令mvn -version检查如下图：  
[![img][]][img 1]**maven常用命令：**

mvn compile : 编译maven项目，会出现target目录
    mvn clean   : 删除编译后的内容，target目录会被删除 
    mvn test    ：执行test中的方法，会首先编译test类

2.IDE：IntelliJ IDEA  
3.快速构建springboot项目：[Spring Initializer][]  
4.Spring boot的核心作用：起步依赖，自动配置，端点监控

随时记：
    server.port=80  //设置访问端口号
    server.servlet.context-path=/community  
        //设置默认路径 项目的访问路径

### 三、Spring入门 ###

1.Spring Framework

*  Spring Core : IoC、AOP
 *  Spring Data Access : Transactions、Spring MyBatis
 *  Web Servlet : Spring MVC
 *  Integration : Email、Scheduling、AMQP、Security

2.Spring IoC

*  Inversion of Control - 控制反转，是一种面向对象编程的设计思想。
 *  Dependency Injection - 依赖注入，是IoC思想的实现方式。
 *  IoC Container - IoC容器，是实现依赖注入的关键，本质上是一个工厂。  
    [![img][img 2]][img_img 2]  
    3.Ioc展示

此类其实是一个配置类

package com.hsw.community;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    @SpringBootApplication  //表示是一个配置文件
    public class CommunityApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(CommunityApplication.class, args);
            //启动Tomcat，自动创建Spring容器、自动扫描对象，将对象装配到容器中
            //扫描配置类以及子包下的对象，同时要有类似Controller的注解
        }
    }

如何使用spring容器？

@SpringBootTest  //标识程序入口 配置类
    @ContextConfiguration(classes = CommunityApplication.class)  //使用配置类 
    //实现ApplicationContaxtAware接口并实现相应方法即可从参数中获取ApplicationContext
    class CommunityApplicationTests implements ApplicationContextAware {
        
        private ApplicationContext applicationContext;
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        
            this.applicationContext = applicationContext;
        }
        @Test
        public void testApplication(){
        
            System.out.println(applicationContext);
            //常用方法
            applicationContext.getBean(Dao.class);
            applicationContext.getBean("mybatisDao",Dao.class);
        }
    }
    随时记
    /**使用场景比如我们有Dao接口下有两个实现类hibernateDao和mybatisDao
    *我们用applicationContext获取bean时希望获取mybatisDao则加入此注解即可
    */
    @Primary  
    @Repority("mybatisDao")  //自定义bean的名字
    @PostConstruct  //在构造器之后调用
    @PreDestroy  //销毁之前调用
    @Scope("prototype")  //spring默认的bean都是单例的加此注解会在每次getBean方法调用时实例化对象

在配置类中配置要使用的bean(很笨拙的方法)

@Configuration //标识配置类
    public class AlphaConfig {
        
        @Bean
        public SimpleDateFormat simpleDateFormat(){
        
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    }
    随时记
    @bean  //bean的名称就是方法名如上simpleDateFormat
    @Autowired  //依赖注入，获取bean
    @Qualifier("xxx")  //把名字为xxx的bean注入，一般和Autowired一起使用

### 四、SpringMVC入门 ###

Spring MVC 用于Web开发

> HTTP：HyperText Transfer Protocol。
> 
> 用于传输HTML等内容的应用层协议。
> 
> 规定了浏览器和服务器之间如何通信，以及通信时的数据格式。

> 浏览器和服务器通信的步骤：
> 
> ①建立TCP连接
> 
> ②发送HTTP请求报文
> 
> ![image-20230518143635606][]
> 
> ③服务器返回响应报文信息
> 
> ![image-20230518143722478][]
> 
> ④关闭连接或者保持开启

*  三层架构 - 表现层、业务层、数据访问层【分层目的：解耦、有利于代码维护】
 *  MVC是一种设计模式，解决的是**表现层**的问题
    
     *  Model：模型层
     *  View：视图层
     *  Controller：控制层
 *  核心组件【实际就是一个类】 - **前端控制器：DispatcherServlet**
    
    > DispatcherServlet管理是基于Spring容器Servlet WebApplicationContext
    > 
    > 管理Controller、视图以及映射相关注解
    
    [![img][img 3]][img_img 3]
    
    **DispatcherServlet工作流程**
    
    > 请求、处理都由DispatcherServlet前端控制器处理
    > 
    > 1.根据映射注解或方法，找到controller，并调用
    > 
    > 2.controller把数据封装到model中返回给前端控制器
    > 
    > 3.控制器调用视图模板，并把model传递给视图模板
    > 
    > 4.视图模板动态替换、生成html，返回给前端控制器
    > 
    > 5.前端控制器将html返回给浏览器
    
    [![img][img 4]][img_img 4]

![image-20230518145612712][]

**Thymeleaf 模板引擎：生成动态的HTML。**

*  Thymeleaf【理念先进】
    
     *  倡导自然模板，即以**HTML文件**为模板。
 *  常用语法
    
     *  标准表达式、判断与循环、模板的布局。
        
        > 模板文件包含网页基本结构以及一些表达式【可以被model数据替换】
        > 
        > model数据
        
        [![img][img 5]][img_img 5]

随时记 实际为配置类
    spring.thymeleaf.cache=false  //开发中关闭thymeleaf的缓存，上线后开启[降低服务器压力]
    //有缓存，开发时，页面可能有延迟
    //Thymeleaf配置类，实际配置过程就是给某个bean设置属性【给一个配置类注入数据】
    @EnableConfigurationProperties(ThymeleafProperties.class)
    public class ThymeleafAutoConfiguration 
    @ConfigurationProperties(prefix = "spring.thymeleaf")
    public class ThymeleafProperties {

简单举几个例子  
1.mvc 底层对象直观了解

@Controller
    @RequestMapping("/demo")
    public class AlphaController {
        
        @RequestMapping("/test")
        public void demo(HttpServletRequest request, HttpServletResponse response){
        //声明请求对象、响应对象
            //获取请求数据
            System.out.println(request.getContextPath());
            System.out.println(request.getMethod());
            Enumeration<String> headerNames = request.getHeaderNames();//请求行
            while(headerNames.hasMoreElements()){
        
                String name = headerNames.nextElement();
                String value = request.getHeader(name);
                System.out.println("header:"+name+"  的值是->"+value);
            }
            //返回响应数据
            response.setContentType("text/html;charset=utf-8");//声明类型
            try(PrintWriter writer = response.getWriter()) {
        
                writer.write("我会变强的");
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

2.快速获取request中的参数【get 获取浏览器中一些参数】

/students?current=1&limit=20

@RequestMapping(path = "/testRequestParam",method = RequestMethod.GET)//声明请求路径、请求方式
    @ResponseBody //响应
    //  /testRequestParam?i=10&j=100
    public String testRequestParam(
        //request中i这个参数赋值给i，也可以不传值，不传值默认为1【不传值的情况、第一次访问】
        @RequestParam(name = "i",required = false,defaultValue = "1") int i,
        @RequestParam(name = "j",required = false,defaultValue = "100")int j){
        
        System.out.println(i);
        System.out.println(j);
        return "hello world";
        }

3.快速获取路径中的值【get 浏览器输入时，直接将参数放到路径上】

> get请求，在地址栏上传递数据，且传递数据量有限

/students/123

@RequestMapping(path = "/testPathVariable/{id}",method = RequestMethod.GET)
    @ResponseBody
    //  /testPathVariable/123
    public String testPathVariable(@PathVariable("id") int id){
        //路径变量，赋值给id
        System.out.println(id);  //123
        return "hello world";
    }
    随时记：
    @RequestParam  //经过DispatcherServlet处理后会从request对象中获取参数
    @PathVariable("xxx")  //快速获取路径中的值如上所示

4.表单中数据的获取【post 浏览器向服务器提交数据】

<form method="post" action="/demo/testPost">
            <p>
                名字：<input name="name" type="text" >
            </p>
            <p>
                年龄：<input name="age" type="text">
            </p>
            <p>
                <input type="submit" value="submit">
            </p>
        </form>
    @RequestMapping(path = "/testPost",method = RequestMethod.POST)
    @ResponseBody
    public String testPost(String name,int age){
        System.out.println(name);
        System.out.println(age);
        return "hello world";
    }
    随时记：
    直接让方法参数名和表单中定义的名字相等即可获取

5.填充模板数据【响应HTML数据】

@RequestMapping(path = "/teacher",method = RequestMethod.GET)//声明请求路径、请求方式
        public ModelAndView testThymeleaf(){
          
            ModelAndView mv = new ModelAndView();//返回数据，返回model数据以及View数据
            //动态传值
            mv.addObject("name","狂徒张三");
            mv.addObject("age","100");
            mv.setViewName("teacher.html");//模板的路径和名字
            return mv;
        }

teacher.html位于templates下

<!DOCTYPE html>
    <html lang="en"  xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <p th:text="${name}"></p>
        <p th:text="${age}"></p>
    </body>
    </html>

简化controller中的方式【更方便、简洁】

@RequestMapping(path = "/teacher",method = RequestMethod.GET)
        public String testThymeleaf(Model model){
        //返回数据，类型为model
            model.addAttribute("name","电棍");
            model.addAttribute("age","1000");
            return "teacher.html";//返回view的路径
        }

6.响应json数据（用于异步请求，java对象->json字符串->js对象）

> 异步请求：当前网页不刷新，但是访问服务器、数据库

@RequestMapping(path = "/testJson",method = RequestMethod.GET)//请求访问路径，请求方式
    @ResponseBody //返回json字符串，不加默认返回html
    public Map<String,Object> testJson(){
        
        Map<String,Object> map = new HashMap<>();//声明类型
        map.put("name","猪猪侠");
        map.put("age",19);
        return map;//返回json字符串、【属性：属性值】
    }
    
    //返回一个集合
    @RequestMapping(path = "/testJsons",method = RequestMethod.GET)//请求访问路径，请求方式
    @ResponseBody //返回json字符串，不加默认返回html
    public List<Map<String,Object>> testJsons(){
        
        List<Map<String,Object>> list = new ArrayList<>();//声明类型
        
        Map<String,Object> map = new HashMap<>();
        map.put("name","猪猪侠");
        map.put("age",19);
        list.add(map);
        
      	map = new HashMap<>();
        map.put("name","迷糊老师");
        map.put("age",55);
        list.add(map);
        
        return list;
    }

### 五、MyBatis入门 ###

> 提前安装MySQL Server以及MySQL WorkBench【比较好用的客户端】
> 
> 初始化、安装服务、启动服务==》访问MySQL
> 
> 第一次登录MySQL之后不能做任何操作，需要修改临时密码

MyBatis

使用MyBatis，底层能够自动的实现接口【前提：每个增删改查的方法依赖的SQL】

*  核心组件 【Spring Boot会自动创建前3个】
    
     *  SqlSessionFactory：用于创建SqlSession的工厂类。
     *  SqlSession：MyBatis的核心组件，用于向数据库执行SQL。
     *  主配置文件：XML配置文件，可以对MyBatis的底层行为做出详细的配置。【连接数据库参数、连接池等配置】
     *  Mapper接口：就是DAO接口，在MyBatis中习惯性的称之为Mapper。
     *  Mapper映射器：用于编写SQL，并将SQL和实体类映射的组件，采用XML、注解均可实现。
 *  示例
    
     *  使用MyBatis对用户表进行CRUD操作。

[参考手册1][1]  
[参考手册2][2]  
引入依赖【导入jar包】

<dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.0.1</version>
            </dependency>

添加配置【application.properties文件里配置】

# DataSourceProperties 配置MySQL连接池【又叫数据源：统一管理连接、管理连接上限（避免数据库瘫痪）】
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/community?characterEncoding=utf-8&useSSL=false&serverTimezone=Hongkong
    spring.datasource.username=root
    spring.datasource.password=123456
    spring.datasource.type=com.zaxxer.hikari.HikariDataSource 
    spring.datasource.hikari.maximum-pool-size=15
    spring.datasource.hikari.minimum-idle=5
    spring.datasource.hikari.idle-timeout=30000
    # MybatisProperties
    #resources目录下新建一个mapper目录存放xml文件
    mybatis.mapper-locations=classpath:mapper/*.xml
    mybatis.type-aliases-package=com.hsw.community.entity
    #启动自动设置主键
    mybatis.configuration.useGeneratedKeys=true
    #下划线命名方式和驼峰命名方式匹配 如：header_url==headerUrl
    mybatis.configuration.mapUnderscoreToCamelCase=true

创建entity包并创建User类

import java.util.Date;
    public class User {
        
        private int id;
        private String username;
        private String password;
        private String salt;
        private String email;
        private int type;
        private int status;
        private String activationCode;
        private String headerUrl;
        private Date createTime;

> 写完属性之后，按【Alt】+【Insert】添加属性的get和set方法
> 
> 生成toString的方法，方便观察打印数据

访问数据库，只用写接口，不需要写具体的类

在dao包下创建UserMapper接口【①注解②方法】

@Mapper
    @Repository
    public interface UserMapper {
        
        User selectById(int id);
        User selectByName(String username);
        User selectByEmail(String email);
        int insertUser(User user);
        int updateStatus(int id, int status);
        int updateHeader(int id, String headerUrl);
        int updatePassword(int id, String password);
    }

在mapper文件夹下建立user-mapper.xml文件【mapper映射结构】

<?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.hsw.community.dao.UserMapper"> 
        
        <sql id="insertFields">
            username, password, salt, email, type, status, activation_code, header_url, create_time
        </sql>
        <sql id="selectFields">
            id, username, password, salt, email, type, status, activation_code, header_url, create_time
        </sql>
        
        <select id="selectById" resultType="User"> 
            select <include refid="selectFields"></include>
            from user
            where id = #{id}
        </select>
        <select id="selectByName" resultType="User">
            select <include refid="selectFields"></include>
            from user
            where username = #{username}
        </select>
        <select id="selectByEmail" resultType="User">
            select <include refid="selectFields"></include>
            from user
            where email = #{email}
        </select>
    	
        <insert id="insertUser" parameterType="User" keyProperty="id"> 
            insert into user (<include refid="insertFields"></include>)
            values(#{username}, #{password}, #{salt}, #{email}, #{type}, #{status}, #{activationCode}, #{headerUrl}, #{createTime})
        </insert>
        <update id="updateStatus">
            update user set status = #{status} where id = #{id}
        </update>
        <update id="updateHeader">
            update user set header_url = #{headerUrl} where id = #{id}
        </update>
        <update id="updatePassword">
            update user set password = #{password} where id = #{id}
        </update>
    </mapper>

测试一波

@SpringBootTest
    @ContextConfiguration(classes = CommunityApplication.class)
    public class MapperTest {
        
        @Autowired
        private UserMapper userMapper;//注入userMapper，进行测试
        @Test
        public void testSelectUser(){
        
            User user = userMapper.selectById(101);
            System.out.println(user);
        }
    }

遇到的问题：

> 最初在UserMapper 接口上只是用了@Mapper注解也能跑但是idea总是提示找不到bean  
> 单独加@Repository其实也能跑  
> 这里把两个都写上去了其实没必要

随时记：
    因为mapper.xml文件中的sql语句写错很难被发现，为了排错可以设置日志级别为debug便于调错
    #logger
    logging.level.com.hsw.community=debug

### 六、开发社区首页 ###

> Web项目，主要解决浏览器和服务器信息交互的问题

![img][img 6]

> 请求提交给服务器的视图层【主要由Controller和模板构成】,controller处理请求时访问业务层，业务组件处理具体的业务，过程会访问数据库，调用DAO访问组件

开发流程：**功能拆解**【实现功能==》不断完善】

*  1次请求的执行过程
 *  分步实现
    
     *  开发社区首页，显示前10个帖子
     *  开发分页组件，分页显示所有的帖子

社区首页

1.  开发社区首页，显示前10个帖子
    
    **数据访问层**
    
    1.  创建实体类
    2.  写对应dao【即Mapper】
    3.  写对应xml【配置文件】
        
        **业务层**
    4.  创建service,因为在首页得到的DiscussPost并不携带userid,所以需要创建DiscusspostService和UserService来实现首页展示10个帖子的功能
        
        **视图层**：静态资源和模板（html、图片…)
    5.  写controller,将查询到的数据注入到model中
    6.  修改index.html
2.  开发分页组件，分页显示所有的帖子
    
    1.  创建page类,在Page中设置当前页码,显示上限，数据总数，查询路径
    2.  在开发社区首页的controller方法中，第一次访问自动注入page，page会自动注入到model中，然后我们让前端在跳转页面的时候在参数上添加页数，我们的SpringMVC会自动注入Page页面
    3.  index.html首页中修改分页组件

[![image.png][]][image.png 1]\[(htt

【**1-3数据访问层**】

1.创建实体类

public class DiscussPost {
        
        private int id;
        private int userId;
        private String title;
        private String content;
        //0-普通; 1-置顶;
        private int type;
        //0-正常; 1-精华; 2-拉黑;
        private int status;
        private Date createTime;
        private int commentCount;
        private double score;
    }

生成get、set方法；方便打印==》生成ToString方法

2.写对应dao【通常一张表，创建一个Mapper】

首页的查询功能

@Repository
    public interface DiscussPostMapper {
        
        /**
         * @param userId 考虑查看我的帖子的情况下设置动态sql，看mapper就知道了【动态sql，若首页帖子则无userId；个人主页，则有userId】
         * @param offset
         * @param limit
         * @return
         */
        List<DiscussPost> selectDiscussPosts(int userId,int offset,int limit);//offset每页起始行号，limit每页最多的数据
        //如果需要动态拼接条件（<if>里使用）并且这个方法有且只有一个参数需要用@Param起别名
        //@Param用于给参数取别名
        int selectDiscussPostRows(@Param("userId") int userId);//查询总共多少帖子
    }

3.mapper目录下写个discusspost-mapper.xml

xml容易出错，测试

注入==》方法

4.【**业务层**】创建DiscussPostService类和UserService类

@Service //让其能被容器访问到
    public class DiscussPostService {
        
        //调用Mapper，注入Mapper
        @Autowired
        private DiscussPostMapper discussPostMapper;
        //业务处理方法
        public List<DiscussPost> findDiscussPosts(int userId,int offset,int limit){
        
            return discussPostMapper.selectDiscussPosts(userId,offset,limit);
        }
        public int findDiscussPostRows(int userId){
        
            return discussPostMapper.selectDiscussPostRows(userId);
        }
    }
    @Service
    public class UserService {
        
        @Autowired
        private UserMapper userMapper;
        //因为上边只有userId根据此方法可得到userName
        public User findUserById(int id){
        
            return userMapper.selectById(id);
        }
    }

5.【**视图层**】复制静态资源和模板  
[![img][img 7]][img_img 7]  
6.【**视图层**】写HomeController

package com.hongna.community.entity;
    
    /**
     * 封装分页相关的信息.
     */
    public class Page {
        
    
        // 当前页码
        private int current = 1;
        // 显示上限
        private int limit = 10;
        // 数据总数(用于计算总页数)
        private int rows;
        // 查询路径(用于复用分页链接)
        private String path;
    
        public int getCurrent() {
        
            return current;
        }
    
        public void setCurrent(int current) {
        
            if (current >= 1) {
        
                this.current = current;
            }
        }
    
        public int getLimit() {
        
            return limit;
        }
    
        public void setLimit(int limit) {
        
            if (limit >= 1 && limit <= 100) {
        
                this.limit = limit;
            }
        }
    
        public int getRows() {
        
            return rows;
        }
    
        public void setRows(int rows) {
        
            if (rows >= 0) {
        
                this.rows = rows;
            }
        }
    
        public String getPath() {
        
            return path;
        }
    
        public void setPath(String path) {
        
            this.path = path;
        }
    
        /**
         * 获取当前页的起始行
         *
         * @return
         */
        public int getOffset() {
        
            // current * limit - limit
            return (current - 1) * limit;
        }
    
        /**
         * 获取总页数
         *
         * @return
         */
        public int getTotal() {
        
            // rows / limit [+1]
            if (rows % limit == 0) {
        
                return rows / limit;
            } else {
        
                return rows / limit + 1;
            }
        }
    
        /**
         * 获取起始页码
         *
         * @return
         */
        public int getFrom() {
        
            int from = current - 2;
            return from < 1 ? 1 : from;
        }
    
        /**
         * 获取结束页码
         *
         * @return
         */
        public int getTo() {
        
            int to = current + 2;
            int total = getTotal();
            return to > total ? total : to;
        }
    
    }
    package com.hsw.community.controller;
    import com.hsw.community.entity.DiscussPost;
    import com.hsw.community.entity.Page;
    import com.hsw.community.entity.User;
    import com.hsw.community.service.DiscussPostService;
    import com.hsw.community.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    @Controller //Controller注解，Controller 可以不加访问路径
    public class HomeController {
        
        //调用service，注入service
        @Autowired
        private DiscussPostService discussPostService;
        @Autowired
        private UserService userService;
        //增加处理请求的方法
        @RequestMapping(path="/index",method = RequestMethod.GET)
        //方法调用之前SpringMVC会自动实例化Model和Page，并将Page注入到Model中，所以可以直接访问page对象
        //若是路径中带有参数如index?current=2  current的值会自动封装进page中
        public String getIndexPage(Model model,Page page){
        
            page.setRows(discussPostService.findDiscussPostRows(0));
            page.setPath("/index");
            //list不包含userName
            List<DiscussPost> list = discussPostService.findDiscussPosts(0, page.getOffset(), page.getLimit());
            //定义一个集合discussPosts，包含post以及userName
            List<Map<String,Object>> discussPosts = new ArrayList<>();
            if(list!=null){
        
                for (DiscussPost post:list) {
        
                    Map<String,Object> map = new HashMap<>();
                    map.put("post",post);
                    User user = userService.findUserById(post.getUserId());
                    map.put("user",user);
                    discussPosts.add(map);
                }
            }
            model.addAttribute("discussPosts",discussPosts);
            //model.addAttribute("page",page);
            return "/index";
        }
    }

7.完成index.html  
渲染页面中的帖子

<ul class="list-unstyled">
    					<li class="media pb-3 pt-3 mb-3 border-bottom" th:each="map:${discussPosts}">
    						<a href="site/profile.html">
    							<img th:src="${map.user.headerUrl}" class="mr-4 rounded-circle" alt="用户头像" style="width:50px;height:50px;">
    						</a>
    						<div class="media-body">
    							<h6 class="mt-0 mb-3">
    								
    								<a href="#" th:utext="${map.post.title}">备战春招，面试刷题跟他复习，一个月全搞定！</a>
    								<span class="badge badge-secondary bg-primary" th:if="${map.post.type==1}">置顶</span>
    								<span class="badge badge-secondary bg-danger" th:if="${map.post.status==1}">精华</span>
    							</h6>
    							<div class="text-muted font-size-12">
    								
    								
    								<u class="mr-3" th:utext="${map.user.username}">寒江雪</u> 发布于 <b th:text="${#dates.format(map.post.createTime,'yyyy-MM-dd HH:mm:ss')}">2019-04-15 15:32:18</b>
    								<ul class="d-inline float-right">
    									<li class="d-inline ml-2">赞 11</li>
    									<li class="d-inline ml-2">|</li>
    									<li class="d-inline ml-2">回帖 7</li>
    								</ul>
    							</div>
    						</div>						
    					</li>
    				</ul>
    				 
    				<nav class="mt-5" th:if="${page.rows>0}">
    					<ul class="pagination justify-content-center">
    						<li class="page-item">
    							
    							<a class="page-link" th:href="@{${page.path}(current=1)}">首页</a>
    						</li>
    						
    						<li th:class="|page-item ${page.current==1?'disabled':''}|">
    							<a class="page-link" th:href="@{${page.path}(current=${page.current-1})}">上一页</a></li>
    						<li th:class="|page-item ${i==page.current?'active':''}|" th:each="i:${#numbers.sequence(page.from,page.to)}">
    							<a class="page-link" th:href="@{${page.path}(current=${i})}" th:text="${i}">1</a>
    						</li>
    						<li th:class="|page-item ${page.current==page.total?'disabled':''}|">
    							<a class="page-link" th:href="@{${page.path}(current=${page.current+1})}">下一页</a>
    						</li>
    						<li class="page-item">
    							<a class="page-link" th:href="@{${page.path}(current=${page.total})}">末页</a>
    						</li>
    					</ul>
    				</nav>
    			</div>
    		</div>

### 七、项目调试技巧 ###

*  响应状态码的含义
 *  服务端断点调试技巧
 *  客户端断点调试技巧
 *  设置日志级别，并将日志输出到不同的终端

**1.响应状态码的含义**

1XX：指临时性的响应，需要执行者继续操作即可解决的状态码
    2XX：指已经成功地处理了请求，用户可以正常的打开了这个页面。
    3XX：进行重定向相关操作
    4XX：客户端的错误
    5XX：服务器端的错误

详细介绍：[点此][Link 1]  
[一些常用状态码的总结][Link 2]

*  301：被请求的资源已永久移动到新位置，并且将来任何对此资源的引用都应该使用本响应返回的若干个 URI 之一。如果可能，拥有链接编辑功能的客户端应当自动把请求的地址修改为从服务器反馈回来的地址。除非额外指定，否则这个响应也是可缓存的。
 *  302：请求的资源现在临时从不同的 URI 响应请求。由于这样的重定向是临时的，客户端应当继续向原有地址发送以后的请求。只有在Cache-Control或Expires中进行了指定的情况下，这个响应才是可缓存的。【**浏览器自主的再发一次请求**】
 *  404：请求失败，请求所希望得到的资源未被在服务器上发现。
 *  500：服务器遇到了不知道如何处理的情况。

**2.服务端断点调试技巧**

*  打断点
 *  以debug模式启动服务器
 *  F8逐行执行，F7进入所调用的方法内部
 *  F9程序继续执行直到遇到下一个断点，如果没有断点了那么程序会执行完毕
 *  管理断点的功能，如下图可以快速去除所有断点  
    [![img][img 8]][img_img 8]

**3.客户端断点调试技巧**

*  打断点
 *  调试

主要用于调试js，如下图  
[![img][img 9]][img_img 9][![img][img 10]][img_img 10]  
**4.设置日志级别，并将日志输出到不同的终端**  
springboot默认日志logback：[官网][Link 3]

package org.slf4j; 
    public interface Logger {
        
      //我们可以在配置文件中启动不同的级别，则其以上级别日志可以显示低级别日志不会显示。
      // Printing methods: 
      public void trace(String message);
      public void debug(String message);
      public void info(String message); 
      public void warn(String message); 
      public void error(String message); 
    }

写个测试类

package com.hsw.community;
    import org.junit.jupiter.api.Test;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.ContextConfiguration;
    @SpringBootTest
    @ContextConfiguration(classes = CommunityApplication.class)
    public class LoggerTest {
        
        private static final Logger logger = LoggerFactory.getLogger(LoggerTest.class);
        @Test
        public void testLogger1(){
        
            System.out.println(logger.getName());
            logger.trace("hello trace");
            //程序调试日志
            logger.debug("hello debug");
            //普通级别日志
            logger.info("hello info");
            logger.warn("hello warn");
            //错误日志
            logger.error("hello log");
        }
    }

添加配置文件

# logger
    logging.level.com.hsw.community=debug

输出结果

com.hsw.community.LoggerTest
    2020-05-04 15:25:59.505 DEBUG 2644 --- [           main] com.hsw.community.LoggerTest             : hello debug
    2020-05-04 15:25:59.505  INFO 2644 --- [           main] com.hsw.community.LoggerTest             : hello info
    2020-05-04 15:25:59.505  WARN 2644 --- [           main] com.hsw.community.LoggerTest             : hello warn
    2020-05-04 15:25:59.505 ERROR 2644 --- [           main] com.hsw.community.LoggerTest             : hello log

更改配置文件

logging.level.com.hsw.community=warn

在此运行测试类查看输出结果

com.hsw.community.LoggerTest
    2020-05-04 15:28:54.515  WARN 9020 --- [           main] com.hsw.community.LoggerTest             : hello warn
    2020-05-04 15:28:54.515 ERROR 9020 --- [           main] com.hsw.community.LoggerTest             : hello log

日志输出到文件中的配置

#文件都是以log结尾
    logging.file.name=d:work.log

注意：这么搞有个问题，不同级别日志混杂不易查看且文件庞大。  
解决方法：使用配置文件配置（放到resource目录下）

<?xml version="1.0" encoding="UTF-8"?>
    <configuration>
        
        <contextName>community</contextName>
        
        <property name="LOG_PATH" value="D:/work/data"/>
        
        <property name="APPDIR" value="community"/>
        
        <appender name="FILE_ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            <file>${LOG_PATH}/${APPDIR}/log_error.log</file>
            
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${LOG_PATH}/${APPDIR}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>5MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                
                <maxHistory>30</maxHistory>
            </rollingPolicy>
            
            <append>true</append>
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
                
                <pattern>%d %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
                
                <charset>utf-8</charset>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                
                <level>error</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
        
        <appender name="FILE_WARN" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${LOG_PATH}/${APPDIR}/log_warn.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${LOG_PATH}/${APPDIR}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>5MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <maxHistory>30</maxHistory>
            </rollingPolicy>
            <append>true</append>
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
                <pattern>%d %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
                <charset>utf-8</charset>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>warn</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
        
        <appender name="FILE_INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <file>${LOG_PATH}/${APPDIR}/log_info.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${LOG_PATH}/${APPDIR}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>5MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                <maxHistory>30</maxHistory>
            </rollingPolicy>
            <append>true</append>
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
                <pattern>%d %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
                <charset>utf-8</charset>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>info</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
        
        <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
            <encoder>
                <pattern>%d %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
                <charset>utf-8</charset>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>debug</level>
            </filter>
        </appender>
        <logger name="com.hsw.community" level="debug"/>
        <root level="info">
            <appender-ref ref="FILE_ERROR"/>
            <appender-ref ref="FILE_WARN"/>
            <appender-ref ref="FILE_INFO"/>
            <appender-ref ref="STDOUT"/>
        </root>
    </configuration>

### 八、版本控制 ###

> 作用：代码备份、历史记录、团队协作

*  认识Git
    
     *  Git的简介
        
        > 分布式的版本控制
        > 
        > 本地仓库，无问题，推送到远程仓库
     *  Git的安装和配置
 *  Git常用命令
    
     *  将代码提交到本地仓库
     *  将代码上传至远程仓库
 *  IDEA集成Git
    
     *  commit 提交到本地仓库
     *  push 推送到远程仓库
     *  pull 从远程仓库拉下来代码

Git官网：[点此][Link 4]  
推荐阅读：[书籍][Link 5]  
1.配置用户名和邮箱

$ git config --global user.name "hsw"
    $ git config --global user.email hsw@hust.com

2.把代码放进本地代码库

*  找到目标代码文件夹，右键gitbash Here
 *  $ git init  
    Initialized empty Git repository in I:/ideaworkspace/test/.git/  
    本地文件出现隐藏文件夹  
    [![img][img 11]][img_img 11]
 *  git status 查看状态  
    [![img][img 12]][img_img 12]
 *  添加所有文件 git add \*  
    [![img][img 13]][img_img 13]
 *  git status 查看状态(绿了只是加到了本地仓库中，但未提交）  
    [![img][img 14]][img_img 14]
    
     *  git commit -m ‘test git’ (-m是指备注)  
        [![img][img 15]][img_img 15]
 *  git status 查看状态  
    [![img][img 16]][img_img 16]
 *  修改代码（加了一个注释）后查看状态 git status  
    [![img][img 17]][img_img 17]
 *  然后可以git add，git commit提交修改的代码

3.上传至远程仓库之生成密钥 $ ssh-keygen -t rsa -C “邮箱地址”  
[![img][img 18]][img_img 18]

*  复制密钥  
    [![img][img 19]][img_img 19]
 *  远程仓库使用牛客网

[![img][img 20]][img_img 20]

*  创建项目

[![img][img 21]][img_img 21]\- 本地关联远程仓库，起别名

$ git remote add 仓库名 仓库地址

[![img][img 22]][img_img 22]

*  上传至远程仓库

$ git push -u 仓库名 分支名

[![img][img 23]][img_img 23]\- 传完之后  
[![img][img 24]][img_img 24]\- 远程仓库内容克隆到本地  
[![img][img 25]][img_img 25]  
输入命令

$ git clone https://git.nowcoder.com/xxx/xxxx.git

[![img][img 26]][img_img 26]  
4.idea集成git  
[![img][img 27]][img_img 27]

*  创建本地仓库（相当于执行init和add）  
    [![img][img 28]][img_img 28]
 *  提交本地仓库  
    [![img][img 29]][img_img 29]

[![img][img 30]][img_img 30]

*  上传远程仓库  
    [![img][img 31]][img_img 31]

[![img][img 32]][img_img 32]  
[![img][img 33]][img_img 33]

*  上传成功  
    [![img][img 34]][img_img 34]

## 牛客网第二章 ##

> 产品的角度考虑功能怎么去思考、实现，注意产品细节
> 
> 运用Spring Boot，以及SSM框架【Spring Boot、Spring MVC、MyBatis】

## 一、发送邮件 ##

*  邮箱设置
    
     *  启用客户端SMTP服务
 *  Spring Email技术
    
     *  导入 jar 包
     *  邮箱参数配置
     *  使用 JavaMailSender 发送邮件
 *  模板引擎
    
     *  使用 Thymeleaf 发送 HTML 邮件

### 邮箱设置 ###

跟教程一致选用新浪邮箱，开启SMTP服务

[![image][]][image]

### Spring Email ###

**1.导入jar包**

在[mavenrepository][]中搜索Spring mail的相关jar包

[![image][image 1]][image 1]

[![image][image 2]][image 2]

[![image][image 3]][image 3]

把上述红框内容复制到pom文件中

**2.邮箱参数设置**

此项目配置如下 application.properties里面配置

spring.mail.host: smtp.163.com
    spring.mail.port: 466
    spring.mail.username: xxxx@163.com
    spring.mail.password: xxx(此处写你的授权码)
    spring.mail.protocol: smtps
    spring.mail.properties.mail.smtp.ssl.enable=true

**注意**

password设置的值是授权码,可以参考[此链接][Link 6]说明

**3.使用JavaMailSender发送邮件**

建立一个工具包util，写一个工具类MailClien，方便复用,

@Component
    
    public class MailClient {
        
    
        private static final Logger logger = LoggerFactory.getLogger(MailClient.class);
    
        @Autowired
    
        private JavaMailSender mailSender;
    
        //直接使用配置文件中的用户名
    
        @Value("${spring.mail.username}")
    
        private String from;
    
        public void sendMail(String to,String subject,String content){
        
    
            try {
        
    
                MimeMessage message = mailSender.createMimeMessage();
    
                MimeMessageHelper helper = new MimeMessageHelper(message);
    
                helper.setFrom(from);
    
                helper.setTo(to);
    
                helper.setSubject(subject);
    
                //不加true说明支持字符文本，加true说明支持html文本
    
                helper.setText(content,true);
    
                mailSender.send(helper.getMimeMessage());
    
            } catch (MessagingException e) {
        
    
                logger.error("发送邮件失败"+e.getMessage());
    
            }
    
        }
    
    }

测试一波

@SpringBootTest
    
    @ContextConfiguration(classes = CommunityApplication.class)
    
    public class MailTest {
        
    
        @Autowired
    
        private MailClient client;
    
        @Autowired
    
        private TemplateEngine templateEngine;
    
        //测试发送普通邮件
    
        @Test
    
        public void testMail(){
        
    
            client.sendMail("xxxx@qq.com","Test","hello world");
    
        }
    
        //测试发送html文件，这里想要根据用户名设置对应的html所以用了Thymeleaf
    
        @Test
    
        public void testHtmlMail(){
        
    
            Context context = new Context();
    
            context.setVariable("username","hsw");
    
            String html = templateEngine.process("mail/demo", context);
    
            //System.out.println(html);
    
            client.sendMail("xxxx@qq.com","TestHtml",html);
    
        }
    
    }

html

<!DOCTYPE html>
    
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    
    <head>
    
        <meta charset="UTF-8">
    
        <title>邮件示例</title>
    
    </head>
    
    <body>
    
        <p>欢迎你，<span style="color: red" th:text="${username}"/></p>
    
    </body>
    
    </html>

## 二、开发注册功能 ##

*  访问注册页面
    
     *  点击顶部区域内的链接，打开注册页面。
 *  提交注册数据
    
     *  通过表单提交数据。
     *  服务端验证账号是否已存在、邮箱是否已注册。
     *  服务端发送激活邮件。
 *  激活注册账号
    
     *  点击邮件中的链接，访问服务端的激活服务

个人思想

*  点击注册页面，然后打开注册页面
 *  在首页模板中设置跳转,因为通过th:fragment共用了模板,所以只需要修改首页模板
    
    通过lang3工具包，检测前台传过来的数据是否为空
    
    如果为空或者邮箱等已被占用返回前台消息错误提醒
 *  在service中完成注册功能，并通过service进行加盐
    
    通过templateEngine和Email发送激活邮件
    
    /activation/\{userId\}/\{code\} 通过后面两个属性，我们可以得到userId和激活码，我们通过方法找到userId,并校验数据库中的code是否正确(激活状态),如果是则会校验status值是否已被修改为1，不是则修改成功。通过templateEngine我们可以实现动态的注入返回页面

[![image.png][image.png 2]][image.png 2]

### 访问注册页面 ###

开发顺序一般为：数据访问层、业务层、视图层。

1.共用头部

一般头部的代码都是一样的

[![image][image 4]][image 4]可以用Thymeleaf提供的th:fragment标签来共用这部分代码，如下index.html中部分内容

[![image][image 5]][image 5]

[![image][image 6]][image 6]

2.把纯html的注册页面修改成Thymeleaf的格式

先修改index.html中内容

[![image][image 7]][image 7]

因为共用头部了，index.html修改了这部分内容之后register.html就不用修改了

### 提交注册数据 ###

**首先导入一个常用的包 commons lang**

主要是字符串判空等功能

[![image][image 8]][image 8]

pom中添加如下

<dependency>
    
        <groupId>org.apache.commons</groupId>
    
        <artifactId>commons-lang3</artifactId>
    
        <version>3.9</version>
    
    </dependency>

**添加配置信息**

因为开发、上线域名不一样所以用户打开邮箱激活的链接也不一样所以给他弄成可变的

#community
    
    community.path.domain=http://localhost:8080

**写个工具类**【很简答，直接调用就行，不需要容器托管】

package com.hsw.community.util;
    
    import org.apache.commons.lang3.StringUtils;
    
    import org.springframework.util.DigestUtils;
    
    import java.util.UUID;
    
    public class CommunityUtil {
        
    
        // 生成随机字符串
    
        public static String generateUUID(){
        
    
            return UUID.randomUUID().toString().replace("-","");
    
        }
    
        //MD5加密
    
        //MD5只能加密不能解密
        //原串加salt拼接新串加密防破解
    
        public static String md5(String key){
        
    
            //null,空串，空格都会判空
    
            if(StringUtils.isBlank(key)){
          //commons lang包里的功能
    
                return null;
    
            }
    
            return DigestUtils.md5DigestAsHex(key.getBytes());
    
        }
    
    }

**正式开发功能**

1.Dao已经写完

2.编写Service

在userService中添加如下代码

@Autowired
    
        private MailClient mailClient;
    
        @Autowired
    
        TemplateEngine templateEngine;
    
        @Value("${community.path.domain}")
    
        private String domain;
    
        @Value("${server.servlet.context-path}")
    
        private String contextPath;
    
        public Map<String,Object> register(User user){
        
    
            Map<String,Object> map = new HashMap<>();
    
            //空值处理
    
            if(user==null){
        
    
                throw new IllegalArgumentException("参数不能为空");
    
            }
    
            if(StringUtils.isBlank(user.getUsername())){
        
    
                //因为这不是异常需要返回给客户端
    
                map.put("usernameMsg","账号不能为空");
    
                return map;
    
            }
    
            if(StringUtils.isBlank(user.getPassword())){
        
    
                map.put("passwordMsg","密码不能为空");
    
                return map;
    
            }
    
            if(StringUtils.isBlank(user.getEmail())){
        
    
                map.put("emailMsg","邮箱不能为空");
    
                return map;
    
            }
    
            //验证账号
    
            User u = userMapper.selectByName(user.getUsername());
    
            if(u!=null){
        
    
                map.put("usernameMsg","该账号已经存在");
    
                return map;
    
            }
    
            //验证邮箱
    
            u = userMapper.selectByEmail(user.getEmail());
    
            if(u!=null){
        
    
                map.put("emailMsg","邮箱已经注册");
    
                return map;
    
            }
    
            //注册用户
    
            //1.随机生成盐
    
            user.setSalt(CommunityUtil.generateUUID().substring(0,5));
    
            //2.加盐并加密
    
            user.setPassword(CommunityUtil.md5(user.getPassword()+user.getSalt()));
    
            //'0-普通用户; 1-超级管理员; 2-版主;'
    
            user.setType(0);
    
            //'0-未激活; 1-已激活;'
    
            user.setStatus(0);
    
            user.setActivationCode(CommunityUtil.generateUUID());
    
            //牛客头像地址0-1000
    
            user.setHeaderUrl(String.format("http://images.nowcoder.com/head/%dt.png", new Random().nextInt(1000)));
    
            user.setCreateTime(new Date());
    
            //插入后user内会回填id 具体看user-mapper.xml
    
            userMapper.insertUser(user);
    
            //激活邮件
    
            Context context = new Context();
    
            context.setVariable("email",user.getEmail());
    
            //url规定这么搞：http://localhost:8080/community/activation/101/code    #101-用户id，#code-激活码
            //域名+项目名+功能的访问名+用户id+激活码
    
            String url = domain+contextPath+"/activation/"+user.getId()+"/"+user.getActivationCode();
    
            context.setVariable("url",url);
    
            String html = templateEngine.process("/mail/activation", context);
    
            mailClient.sendMail(user.getEmail(),"牛客网激活账号",html);
    
            return map;
    
        }

3.邮件模板内容

mail目录下activation.html

<!doctype html>
    
    <html lang="en" xmlns:th="http://www.thymeleaf.org"> 
    
    <head>
    
        <meta charset="utf-8">
    
        <link rel="icon" href="https://static.nowcoder.com/images/logo_87_87.png"/>
    
        <title>牛客网-激活账号</title>
    
    </head>
    
    <body>
    
        <div>
    
            <p>
    
                <b th:text="${email}">xxx@xxx.com</b>, 您好!
    
            </p>
    
            <p>
    
                您正在注册牛客网, 这是一封激活邮件, 请点击 
    
                <a th:href="${url}">此链接</a>,
    
                激活您的牛客账号!
    
            </p>
    
        </div>
    
    </body>
    
    </html>

4.写controller

在LoginController类中增加如下内容

@Autowired
    
        private UserService userService;
    
        @RequestMapping(value = "/register",method = RequestMethod.POST)
    
        public String register(Model model, User user){
        
    
            Map<String, Object> map = userService.register(user);
    
            if(map==null||map.isEmpty()){
        
    
                model.addAttribute("msg","注册成功,我们已经向您的邮箱发送一封邮件，请查收并激活账号");
    
                model.addAttribute("target","/index");
    
                return "site/operate-result";
    
            }else{
        
    
                //注册失败返回注册页面
    
                model.addAttribute("usernameMsg",map.get("usernameMsg"));
    
                model.addAttribute("passwordMsg",map.get("passwordMsg"));
    
                model.addAttribute("emailMsg",map.get("emailMsg"));
    
                return "/site/register";
    
            }
    
        }

注册失败处理重新回到register.html页面

处理register.html页面

*  为每个字段增加name属性便于springmvc封装进user
 *  注册过程中的错误处理
    
     *  th:value添加默认值  
        [![image][image 9]][image 9]
     *  输出错误信息
        
        利用botStrap写的页面，下面的div的显示基于上面的input
        
        如果input具有is-invalid属性，则下面的div显示，否则不显示
        
        [![image][image 10]][image 10]

注册成功的中间页面

site/operate-result.html

[![image][image 11]][image 11]

### 激活注册账号 ###

1.util包中定义几个激活状态常量

让UserService实现此接口

package com.hsw.community.util;
    
    public interface CommunityContant {
        
    
        //激活成功
    
        int ACTIVATION_SUCCESS = 0;
    
        //重复激活
    
        int ACTIVATION_REPEAT = 1;
    
        //激活失败
    
        int ACTIVATION_FAILURE = 2;
    
    }

2.业务层中UserService类增加新方法

public int activion(int userId,String code){
        
    
            User user = userMapper.selectById(userId);
    
            if(user==null){
        
    
                return ACTIVATION_FAILURE;
    
            }else if(user.getStatus()==1){
        //重复激活
    
                return ACTIVATION_REPEAT;
    
            }else if(!code.equals(user.getActivationCode())){
        //激活失败
    
                return ACTIVATION_FAILURE;
    
            }else{
        
    
                //设置激活状态、激活成功
    
                userMapper.updateStatus(userId,1);
    
                return ACTIVATION_SUCCESS;
    
            }
    
        }

3.controller层增加方法

LoginController类

//url规定这么搞：http://localhost:8080/community/activation/101/code    #101-用户id，#code-激活码
    
        @RequestMapping(path="/activation/{userId}/{code}",method = RequestMethod.GET)
    
        public String activation(Model model,
    
                                 @PathVariable("userId")int userId,
    
                                 @PathVariable("code") String code){
        
    
            int result = userService.activion(userId, code);
    
            if(result==ACTIVATION_SUCCESS){
        
    
                model.addAttribute("msg","激活成功，您的账号可以使用");
    
                model.addAttribute("target","/login");
    
            }else if(result==ACTIVATION_REPEAT){
        
    
                model.addAttribute("msg","无效操作，该账号已经激活");
    
                model.addAttribute("target","/login");
    
            }else{
        
    
                model.addAttribute("msg","激活失败，激活码不正确请重新注册");
    
                model.addAttribute("target","/register");
    
            }
    
            return "site/operate-result";
    
        }
    
    //访问登录页面的请求+login.html添加上声明
        @RequestMapping(value = "/login",method = RequestMethod.GET)
    
        public String getLoginPage(Model model){
        
    
            return "site/login";
    
        }

处理下site下的login页面 login.html

就是加入Thymeleaf中的东西。

## 三、 会话管理 ##

HTTP的基本性质

*  HTTP是简单的
 *  HTTP是可扩展的
 *  HTTP是无状态的，有会话的

*  是服务器发送到浏览器，并保存在浏览器端的一小块数据。
 *  浏览器下次访问该服务器时，会自动携带块该数据，将其发送给服务器。

Session

*  是JavaEE的标准，用于在服务端记录客户端信息。
 *  数据存放在服务端更加安全，但是也会增加服务端的内存压力。
 *  服务器分布式部署的时候存放session并没有十分完美的解决方案，所以一般我们都把数据存放进数据库中（redis）解决此问题。

## 四、生成验证码 ##

Kaptcha

*  导入 jar 包
 *  编写 Kaptcha 配置类
 *  生成随机字符、生成图片

个人想法：

[参考手册][Link 7]

**Kaptcha核心接口**

[![image][image 12]][image 12]

**默认实现类**

[![image][image 13]][image 13]

**1.导包**

<dependency>
    
        <groupId>com.github.penggle</groupId>
    
        <artifactId>kaptcha</artifactId>
    
        <version>2.3.2</version>
    
    </dependency>

**2.配置**

因为并没有整合进spring所以我们需要自己做整合，写一个配置类

@Configuration
    
    public class KaptchaConfig {
        
    
        @Bean
    
        public Producer kaptchaProducer(){
        
    
            Properties properties = new Properties();
    
            properties.setProperty("kaptcha.image.width","100");
    
            properties.setProperty("kaptcha.image.height","40");
    
            properties.setProperty("kaptcha.textproducer.font.size","32");
    
            properties.setProperty("kaptcha,textproducer.font.color","0,0,0");
    
            properties.setProperty("kaptcha.textproducer.char.string","0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
    
            properties.setProperty("kaptcha.textproducer.char.length","4");
    
            properties.setProperty("kaptcha.noise.impl","com.google.code.kaptcha.impl.NoNoise");
    
            DefaultKaptcha kaptcha = new DefaultKaptcha();
    
            Config config = new Config(properties);
    
            kaptcha.setConfig(config);
    
            return kaptcha;
    
        }

**3.LoginController增加新方法**

@Autowired
    
        private Producer kaptchaProducer;
    
        @RequestMapping(path="/kaptcha",method = RequestMethod.GET)
    
        public void getKaptcha(HttpServletResponse response, HttpSession session){
        
    
            //生成验证码
    
            String text = kaptchaProducer.createText();
    
            BufferedImage image = kaptchaProducer.createImage(text);
    
            //将验证码存入session
    
            session.setAttribute("kaptcha",text);
    
            //将图片输出给浏览器
    
            response.setContentType("image/png");
    
            try {
        
    
                ServletOutputStream outputStream = response.getOutputStream();
    
                ImageIO.write(image,"png",outputStream);
    
            } catch (IOException e) {
        
    
                logger.error("响应验证码获取失败:"+e.getMessage());
    
            }
    
        }

**4.修改login.html**

[![image][image 14]][image 14][![image][image 15]][image 15]

## 五、开发登陆、退出功能 ##

*  访问登录页面
 *   *  点击顶部区域内的链接，打开登录页面。
 *  登录
 *   *  验证账号、密码、验证码。
     *  成功时，生成登录凭证，发放给客户端。
     *  失败时，跳转回登录页。
 *  退出
 *   *  将登录凭证修改为失效状态。
     *  跳转至网站首页。

**登陆凭证相关**

现在先存到数据库中

[![image][image 16]][image 16]

### 访问登录页面 ###

上边已经完成

### 登陆 ###

**1.写dao层LoginTicketMapper类**

@Repository
    
    public interface LoginTicketMapper {
    
        @Insert({
    
                "insert into login_ticket(user_id,ticket,status,expired)" ,
    
                " values(#{userId},#{ticket},#{status},#{expired})"
    
        })
    
        @Options(useGeneratedKeys = true,keyProperty = "id")
    
        int insertLoginTicket(LoginTicket loginTicket);
    
        @Select({
    
            "select id,user_id,ticket,status,expired from login_ticket where ticket=#{ticket}"
    
        })
    
        LoginTicket selectByTicket(String ticket);
    
        @Update({
    
                "update login_ticket set status=#{status} where ticket=#{ticket}"
    
        })
    
        int updateStatus(String ticket,int status);
    
    }

**2.写service层**

@Service
    
    public class LoginService {
        
    
        @Autowired
    
        LoginTicketMapper loginTicketMapper;
    
        @Autowired
    
        UserMapper userMapper;
    
        public Map<String,Object> login(String username, String password,int expiredSeconds){
        
    
            Map<String,Object> map = new HashMap<>();
    
            //空值的处理
    
            if(StringUtils.isBlank(username)){
        
    
                map.put("usernameMsg","用户名不能为空");
    
                return map;
    
            }else if(StringUtils.isBlank(password)){
        
    
                map.put("passwordMsg","密码不能为空");
    
                return map;
    
            }
    
            //验证账号
    
            User user = userMapper.selectByName(username);
    
            if(user==null){
        
    
                map.put("usernameMsg","用户不存在");
    
                return map;
    
            }
    
            //验证状态
    
            if(user.getStatus()==0){
        
    
                map.put("usernameMsg","该账号未激活");
    
                return map;
    
            }
    
            //验证密码
    
            password = CommunityUtil.md5(password+user.getSalt());
    
            if(!password.equals(user.getPassword())){
        
    
                map.put("passwordMsg","密码不正确");
    
                return map;
    
            }
    
            //生成登陆凭证
    
            LoginTicket loginTicket = new LoginTicket();
    
            loginTicket.setUserId(user.getId());
    
            loginTicket.setTicket(CommunityUtil.generateUUID());
    
            loginTicket.setStatus(user.getStatus());
    
            loginTicket.setExpired(new Date(System.currentTimeMillis()+expiredSeconds*1000));
    
            loginTicketMapper.insertLoginTicket(loginTicket);
    
            map.put("loginTicket",loginTicket.getTicket());
    
            return map;
    
        }
    
    }

**3.写controller层**

@Autowired
    
        LoginService loginService;
    
        @Value("${server.servlet.context-path}")
    
        String context_path;
    
        //用于处理表单数据
    
        @RequestMapping(value = "/login",method = RequestMethod.POST)
    
        public String Login(String username,String password,String code,boolean rememberMe,
    
                            Model model,
    
                            HttpSession session,
    
                            HttpServletResponse response){
        
    
            String kaptcha = (String)session.getAttribute("kaptcha");
    
            //检查验证码 ， 业务层只处理业务逻辑 这种验证码校验可在这里直接做
    
            if(StringUtils.isBlank(kaptcha)||StringUtils.isBlank(code)||!StringUtils.equalsIgnoreCase(code,kaptcha)){
        
    
                model.addAttribute("codeMsg","验证码不正确");
    
                return "site/login";
    
            }
    
            //检查账号，密码
    
            int expiredSeconds = rememberMe?REMEMBERME_SECONDS:DEFAULT_SECONDS;
    
            Map<String, Object> msg = loginService.login(username, password, expiredSeconds);
    
            if(msg.containsKey("loginTicket")){
        
    
                Cookie cookie = new Cookie("ticket",(String)msg.get("loginTicket"));
    
                cookie.setPath(context_path);
    
                cookie.setMaxAge(expiredSeconds);
    
                response.addCookie(cookie);
    
                //重定向到首页
    
                return "redirect:/index";
    
            }else{
        
    
                model.addAttribute("usernameMsg",msg.get("usernameMsg"));
    
                model.addAttribute("passwordMsg",msg.get("passwordMsg"));
    
                return "site/login";
    
            }
    
        }

**4.login.html页面的更改**

[![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxMTc4OA_size_16_color_FFFFFF_t_70]][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxMTc4OA_size_16_color_FFFFFF_t_70]

### 退出 ###

在LoginService类中加一个方法

public void logout(String ticket){
        
    
            if(StringUtils.isBlank(ticket)){
        
    
                return;
    
            }
    
            //1表示无效
    
            loginTicketMapper.updateStatus(ticket,1);
    
        }

**2.controller层增加一个跳转方法**

@RequestMapping(path="/logout",method = RequestMethod.GET)
    
        public String logout(@CookieValue("ticket") String ticket){
        
    
            loginService.logout(ticket);
    
            return "redirect:/login";
    
        }

**3.修改index页面**

[![image][image 17]][image 17]

自我思考：这样搞每次登陆都会在login\_ticket表中增加一条登陆记录啊，不知道后续功能咋实现先把问题搁这。

## 六、显示登陆信息 ##

*  拦截器示例
 *   *  定义拦截器，实现HandlerInterceptor
     *  配置拦截器，为它指定拦截、排除的路径
 *  拦截器应用
 *   *  在请求开始时查询登录用户
     *  在本次请求中持有用户数据
     *  在模板视图上显示用户数据
     *  在请求结束时清理用户数据

### 拦截器示例 ###

**1.定义一个拦截器类在interceptor包下**

问题：参数中的handler是啥？

@Component
    
    public class AlphaInterceptor implements HandlerInterceptor {
        
    
        private Logger logger = LoggerFactory.getLogger(AlphaInterceptor.class);
    
        //在controller之前执行
    
        @Override
    
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
    
            logger.debug("preHander:"+handler.toString());
    
            return true;
    
        }
    
        //在controller之后执行
    
        @Override
    
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        
    
            logger.debug("postHander:"+handler.toString());
    
        }
    
        //在模板引擎之后执行
    
        @Override
    
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        
    
            logger.debug("afterCompletion:"+handler.toString());
    
        }
    
    }

**2.写一个配置类**

@Configuration
    
    public class WebMvcConfig implements WebMvcConfigurer {
        
    
        @Autowired
    
        private AlphaInterceptor alphaInterceptor;
    
        @Override
    
        public void addInterceptors(InterceptorRegistry registry) {
        
    
            registry.addInterceptor(alphaInterceptor)    //不写下几行会拦截一切请求
    
            .excludePathPatterns("/**/*.css","/**/*.js","/**/*.jpg","/**/*.jpeg")  //这么写会排除拦截一些静态资源
    
            .addPathPatterns("/register","/login")      //这么写会增加拦截的路径
    
            ;
    
        }

**3.访问/login页面查看日志**

[![image][image 18]][image 18]

真相大白：handler是指拦截的目标

### 拦截器应用 ###

**业务逻辑**

[![image.png][image.png 3]][image.png 3]

**1.新建一个拦截器LoginTicketInterceptor**

@Component
    
    public class LoginTicketInterceptor implements HandlerInterceptor {
        
    
        @Autowired
    
        UserService userService;
    
        @Autowired
    
        HostHolder hostHolder;
    
        //可以简单理解为controller之前通过ticket取用户登录信息
    
        @Override
    
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
    
            //从cookie中取凭证
    
            String ticket = CookieUtil.getValue(request, "ticket");
    
            if(ticket!=null){
        
    
                //查询凭证
    
                LoginTicket loginTicket = userService.findLoginTicket(ticket);
    
                //检查凭证是够有效
    
                if(loginTicket!=null&&loginTicket.getStatus()==0&&loginTicket.getExpired().after(new Date())){
        
    
                    //根据凭证查询用户
    
                    User user = userService.findUserById(loginTicket.getUserId());
    
                    //在本次请求中持有用户
    
                    hostHolder.setUser(user);
    
                }
    
            }
    
            return true;
    
        }
    
        //在controller之后把用户信息传递给模板
    
        @Override
    
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        
    
            User user = hostHolder.getUser();
    
            if(user!=null && modelAndView!=null){
        
    
                modelAndView.addObject("loginUser",user);
    
            }
    
        }
    
        @Override
    
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        
    
            hostHolder.clear();
    
        }
    
    }

util包下HostHolder类可以模拟服务端的Session功能，存放是否有登陆的User

防止多线程出事用ThreadLocal

@Component
    
    public class HostHolder {
        
    
        private ThreadLocal<User> users = new ThreadLocal<User>();
    
        public void setUser(User user){
        
    
            users.set(user);
    
        }
    
        public User getUser(){
        
    
            return users.get();
    
        }
    
        public void clear(){
        
    
            users.remove();
    
        }
    
    }

CookieUtil根据key取cookie因为常用所以封装成一个工具类

public class CookieUtil {
        
    
        public static String getValue(HttpServletRequest request,String key){
        
    
            if(request==null||key==null){
        
    
                throw new IllegalArgumentException("参数为空");
    
            }
    
            Cookie[] cookies = request.getCookies();
    
            for(Cookie cookie:cookies){
        
    
                if(cookie.getName().equals(key)){
        
    
                    return cookie.getValue();
    
                }
    
            }
    
            return null;
    
        }
    
    }

**2.在配置中加入拦截器**

@Configuration
    
    public class WebMvcConfig implements WebMvcConfigurer {
        
    
        @Autowired
    
        private AlphaInterceptor alphaInterceptor;
    
        @Autowired
    
        private LoginTicketInterceptor loginTicketInterceptor;
    
        @Override
    
        public void addInterceptors(InterceptorRegistry registry) {
        
    
            registry.addInterceptor(alphaInterceptor)    //不写下几行会拦截一切请求
    
            .excludePathPatterns("/**/*.css","/**/*.js","/**/*.jpg","/**/*.jpeg")  //这么写会排除拦截一些静态资源
    
            .addPathPatterns("/register","/login")      //这么写会增加拦截的路径
    
            ;
    
            registry.addInterceptor(loginTicketInterceptor)
    
                    .excludePathPatterns("/**/*.css","/**/*.js","/**/*.jpg","/**/*.jpeg");
    
        }
    
    }

**3.模板中头部的处理**

[![image][image 19]][image 19]

## 七、账号设置 ##

*  上传文件
 *   *  请求：必须是POST请求
     *  表单：enctype=“multipart/form-data”
     *  Spring MVC：通过 MultipartFile 处理上传文件
 *  开发步骤
 *   *  访问账号设置页面
     *  上传头像
     *  获取头像

[![image.png][image.png 4]][image.png 4]

### 上传文件之访问账号设置页面 ###

1.新建一个UserController类，增加一个方法，请求方式为get

@Controller
    
    @RequestMapping("/user")
    
    public class UserController {
        
    
        @RequestMapping(path="/setting",method = RequestMethod.GET)
    
        public String getSettingPage(){
        
    
            return "/site/setting";
    
        }
    
    }

2.修改site/setting.html文件改成Thymeleaf的形式

[![image][image 20]][image 20]

3.修改index.html

[![image][image 21]][image 21]

### 上传头像和获取头像 ###

1.在UserController类中完成

multipartFile 类可以控制从前台传入的文件。

@Controller
    
    @RequestMapping("/user")
    
    public class UserController {
        
    
        @Autowired
    
        UserService userService;
    
        @Value("${server.servlet.context-path}")
    
        private String contextPath;
    
        @Value("${community.path.domain}")
    
        private String domain;
    
        @Value("${community.path.upload}")
    
        private String uploadPath;
    
        @Autowired
    
        private HostHolder hostHolder;
    
        private Logger logger = LoggerFactory.getLogger(UserController.class);
    
        @RequestMapping(path="/setting",method = RequestMethod.GET)
    
        public String getSettingPage(){
        
    
            return "/site/setting";
    
        }
    
        /**
    
         * 把文件存到服务器中
    
         * @param multipartFile
    
         * @param model
    
         * @return
    
         */
    
        @RequestMapping(path="/upload",method = RequestMethod.POST)
    
        public String uploadHeader(MultipartFile multipartFile, Model model){
        
    
            if(multipartFile==null){
        
    
                model.addAttribute("error","您没有上传任何图片");
    
                return "/site/setting";
    
            }
    
            String fileName = multipartFile.getOriginalFilename();
    
            String suffix = fileName.substring(fileName.lastIndexOf("."));
    
            //System.out.println(suffix.equals(".jpg"));
    
            if(StringUtils.isBlank(suffix)||!(suffix.equals(".png")||suffix.equals(".jpg"))){
        
    
                model.addAttribute("error","文件格式错误，请重新上传");
    
                return "/site/setting";
    
            }
    
            fileName = CommunityUtil.generateUUID()+suffix;
    
            File dst = new File(uploadPath+"/"+fileName);
    
            try {
        
    
                multipartFile.transferTo(dst);
    
            } catch (IOException e) {
        
    
                logger.error("上传失败："+e.getMessage());
    
                throw new RuntimeException("服务器发生失败，上传出现异常"+e);
    
            }
    
            //更新headerUrl这里规定格式张这样
    
            //http://localhost:8080/community/user/header/filename
    
            String headerUrl = domain+contextPath+"/user/header/"+fileName;
    
            User user = hostHolder.getUser();
    
            userService.uploadHeader(user.getId(),headerUrl);
    
            return "redirect:/user/setting";
    
        }
    
        /**
    
         * 当用户读取headerUrl时从本地读取后返回
    
         * @param filename
    
         * @param response
    
         */
    
        @RequestMapping(path = "header/{filename}",method = RequestMethod.GET)
    
        public void getImg(@PathVariable("filename")String filename, HttpServletResponse response){
        
    
            //服务器存放地址
    
            filename = uploadPath+"/"+filename;
    
            try (ServletOutputStream os = response.getOutputStream();
    
                 InputStream is = new FileInputStream(filename);)
    
            {
        
    
                int len = 0;
    
                byte[] buffer = new byte[1024];
    
                while((len=is.read(buffer))!=-1){
        
    
                    os.write(buffer,0,len);
    
                }
    
            } catch (IOException e) {
        
    
                logger.error("读取文件失败:"+e.getMessage());
    
            }
    
        }
    
    }

2.修改setting.html文件

[![image][image 22]][image 22]

### 密码修改 ###

1.增加UserService中的方法

public int updatePassword(int userId,String password){
        
    
            return userMapper.updatePassword(userId,password);
    
        }

2.增加UserController中的方法

@RequestMapping(path="password",method = RequestMethod.POST)
    
        public String changePassword(Model model,
    
                String oldPassword,
    
                String newPassword,
    
                String confirmPassword){
        
    
            if(StringUtils.isBlank(oldPassword)){
        
    
                model.addAttribute("olderror","请输入原密码");
    
                return "/site/setting";
    
            }
    
            if(StringUtils.isBlank(newPassword)){
        
    
                model.addAttribute("newerror","请输入新密码");
    
                return  "/site/setting";
    
            }
    
            if(StringUtils.isBlank(confirmPassword)){
        
    
                model.addAttribute("confirmerror","请输入确认密码");
    
                return "/site/setting";
    
            }
    
            if(!newPassword.equals(confirmPassword)){
        
    
                model.addAttribute("confirmerror","两次密码不一致请重新输入");
    
                return "/site/setting";
    
            }
    
            User user = hostHolder.getUser();
    
            String password = user.getPassword();
    
            if(!CommunityUtil.md5(oldPassword+user.getSalt()).equals(password)){
        
    
                model.addAttribute("olderror","原密码输入错误，请重新输入");
    
                return "/site/setting";
    
            }
    
            newPassword = CommunityUtil.md5(newPassword+user.getSalt());
    
            userService.updatePassword(user.getId(),newPassword);
    
            return "redirect:/logout";
    
        }

3.修改setting.html

[![image][image 23]][image 23]

## 八、检查登陆状态 ##

*  使用拦截器
 *   *  在方法前标注自定义注解
     *  拦截所有请求，只处理带有该注解的方法
 *  自定义注解
 *   *  常用的元注解：  
        @Target、@Retention、@Document、@Inherited
     *  如何读取注解：  
        Method.getDeclaredAnnotations()  
        Method.getAnnotation(Class annotationClass)

### 一个问题 ###

虽然没有登录用户看不到[![image][image 24]][image 24]

但是如果用户知道url也可直接到相关界面

[![image][image 25]][image 25]

### 自定义注解 ###

[![image.png][image.png 5]][image.png 5]

**常用的元注解**

*  @Target：声明自定义注解可以作用在什么类型上，类上方法上等
 *  @Retention：声明自定义注解保留的时间
 *  @Document：声明自定义注解生成文档的时候要不要把注解也带上去
 *  @Inherited：用于继承的，一个子类继承父类，父类有注解，子类要不要继承这个注解

**读取注解的方法**

*  Method.getDeclaredAnnotations()
 *  Method.getAnnotation(Class< T > annotationClass)

### 使用拦截器解决问题 ###

1.定义自定义注解，主要作用就是标识

@Target(ElementType.METHOD)
    
    @Retention(RetentionPolicy.RUNTIME)
    
    public @interface LoginRequired {
    
    }

2.对需要拦截的方法上加此注解

[![image][image 26]][image 26]

3.新建拦截器进行处理

@Component
    
    public class LoginRequiredInterceptor implements HandlerInterceptor {
        
    
        @Autowired
    
        private HostHolder hostHolder;
    
        @Override
    
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        
    
            if(handler instanceof HandlerMethod){
        
    
                HandlerMethod handlerMethod = (HandlerMethod) handler;
    
                Method method = handlerMethod.getMethod();
    
                LoginRequired annotation = method.getAnnotation(LoginRequired.class);
    
                if(annotation!=null&&hostHolder.getUser()==null){
        
    
                    response.sendRedirect(request.getContextPath()+"/login");
    
                    //false表示不让继续执行
    
                    return false;
    
                }
    
            }
    
            return true;
    
        }
    
    }

4.WebMvcConfig类上加上这个拦截器

[![image][image 27]][image 27]

[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/99b39e7033e94807b2c35d5f4da2d379.png
[img 1]: https://xiaochen-pictures.oss-cn-guangzhou.aliyuncs.com/computer-pictures/1674971433996.png
[Spring Initializer]: https://start.spring.io/
[img 2]: https://img-blog.csdnimg.cn/img_convert/e26df82994eb569aad96d7a70a987c02.png
[img_img 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/36f7c1c0c1e347948ef5c30e9fb74e32.png
[image-20230518143635606]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/96499d9b511241dcad9443093297d3de.png
[image-20230518143722478]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a04282c08757421c90d0b980fb9afceb.png
[img 3]: https://img-blog.csdnimg.cn/img_convert/841d2419185b4875544ac8a77c611191.png
[img_img 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/d7067444da3e4d508da35f5b1bf01802.png
[img 4]: https://img-blog.csdnimg.cn/img_convert/9166fe293ba12c7bc67e282cad7fd5cb.png
[img_img 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7e1ef14f822c4a8393f83481c0739524.png
[image-20230518145612712]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/9293cd6016ec4ef586535af0809f853c.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/c7372e4338d36003701f1b9c9b278686.png
[img_img 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/373a715db5b5488788ad10ceabb2623b.png
[1]: https://mybatis.org/mybatis-3/
[2]: http://mybatis.org/spring/
[img 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a26ea7c9ca9b47398df7cfb6eb53f9fe.png
[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/99965479760442ca9346c18dda165651.png
[image.png 1]: https://xiaochen-pictures.oss-cn-guangzhou.aliyuncs.com/computer-pictures/1674971434100.png
[img 7]: https://img-blog.csdnimg.cn/img_convert/761ad11d038404727d0681ab3c7aad00.png
[img_img 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a8a7939522e9437e846ef7d4f1f212df.png
[Link 1]: https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Status
[Link 2]: https://blog.csdn.net/weixin_37176124/article/details/80852724
[img 8]: https://img-blog.csdnimg.cn/img_convert/afa7c727688bb121aa78bcd47aa395fb.png
[img_img 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/96d39f9b2bf143d197188264d2829840.png
[img 9]: https://img-blog.csdnimg.cn/img_convert/14b3473aca69ac72f247e5b4595aa5bb.png
[img_img 9]: https://xiaochen-pictures.oss-cn-guangzhou.aliyuncs.com/computer-pictures/1674971434144.png
[img 10]: https://img-blog.csdnimg.cn/img_convert/bcfa86ef0755ce7e3c752d3b6efe13f2.png
[img_img 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c0ef921ee67e4938b81129010b5a812d.png
[Link 3]: https://logback.qos.ch/
[Link 4]: https://git-scm.com/
[Link 5]: https://git-scm.com/book/zh/v2
[img 11]: https://img-blog.csdnimg.cn/img_convert/c49c6ee87a94915a7a9d939c595bf214.png
[img_img 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f73a28977f174d98aa104605dcf6efe5.png
[img 12]: https://img-blog.csdnimg.cn/img_convert/4248a7e0c551d56bcfc82103ffe1c0ea.png
[img_img 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c38fe2c359424f588e45e38fad25ab7d.png
[img 13]: https://img-blog.csdnimg.cn/img_convert/0c7031318dd0fafda8f9ea1f2e89ae82.png
[img_img 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/caac859e9fb94ae2b231e15f7006952b.png
[img 14]: https://img-blog.csdnimg.cn/img_convert/5a2a2ea85b080e3bbc3591d20e80892f.png
[img_img 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/713e7e80df034ed5836885270ef6bf60.png
[img 15]: https://img-blog.csdnimg.cn/img_convert/da2aeb6511820e8758b5cb384988d2f3.png
[img_img 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b217edcd68fb428eb8e8824e0041a5c2.png
[img 16]: https://img-blog.csdnimg.cn/img_convert/e620986f66677cd5e6aa2e5c9f9ed9c0.png
[img_img 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ae6c5eb593844665a6b0e7623df34860.png
[img 17]: https://img-blog.csdnimg.cn/img_convert/9792f3e6d3ab2bbd794624965adc7098.png
[img_img 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/54eac0cff78d4195b9cb1036b35f9b1a.png
[img 18]: https://img-blog.csdnimg.cn/img_convert/e3a383b617002881097745916b0102e2.png
[img_img 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/e1c5e6afebb34af39ff871995eed65d6.png
[img 19]: https://img-blog.csdnimg.cn/img_convert/f10a57f91fee6f64e3774e0b7cff05ca.png
[img_img 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7a17913655f643448009f3aef4d58c25.png
[img 20]: https://img-blog.csdnimg.cn/img_convert/b28cf444cb32333418553df7f20efe96.png
[img_img 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/4a9a25d76df94352a3d95de38f8df443.png
[img 21]: https://img-blog.csdnimg.cn/img_convert/974e26291868738537280574f1c07cdb.png
[img_img 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/9cd5d78ed12647678da172e8b2beaffb.png
[img 22]: https://img-blog.csdnimg.cn/img_convert/a2da69bc0fa1f016a0dea33d6262fc6e.png
[img_img 22]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f706a0b5f0204d109524dbb51af94f93.png
[img 23]: https://img-blog.csdnimg.cn/img_convert/b913d614da4d98f64178ef2f59d31d27.png
[img_img 23]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/19455b9257db44f7b8894b00c88de20c.png
[img 24]: https://img-blog.csdnimg.cn/img_convert/25620d086e5cc9b750a252ea1da8ddd8.png
[img_img 24]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a17a561fa9034ee6900ac11265df73cb.png
[img 25]: https://img-blog.csdnimg.cn/img_convert/93495932a4f8a24c107397a1d3d1749e.png
[img_img 25]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/a30647f1ba42444b98d1167894c085d1.png
[img 26]: https://img-blog.csdnimg.cn/img_convert/0e5d1c16831eaf6b0afa59a873dfa5d0.png
[img_img 26]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b7333ff947f5456fa840e272b78664c7.png
[img 27]: https://img-blog.csdnimg.cn/img_convert/bfa4be2b8a1f773649ffc775abb03ca5.png
[img_img 27]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/6bf6ed2e670e41a2ad60788f4b70b01e.png
[img 28]: https://img-blog.csdnimg.cn/img_convert/5de395054a39ce2a05c966c5b0e50709.png
[img_img 28]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ee19a17a28b342a6ae25198e5dd98e7a.png
[img 29]: https://img-blog.csdnimg.cn/img_convert/5d9a2cf096cc5a9c38eb36b945ea0f69.png
[img_img 29]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/34c3ae2eb80f4abfa459e489f43450ef.png
[img 30]: https://img-blog.csdnimg.cn/img_convert/9bb0cb600d811e3ccec12af54d3b8f81.png
[img_img 30]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/03c50defa52248acaf7bfc2b6fb67ae2.png
[img 31]: https://img-blog.csdnimg.cn/img_convert/b415f254789b8f4366a11935b769bcaa.png
[img_img 31]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8d7b7c4aad514aa4ba561764ce06df3f.png
[img 32]: https://img-blog.csdnimg.cn/img_convert/8d0c32bd76b69339a566e8a6288a7b20.png
[img_img 32]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/2a89ccdf9b134b5ea1240d0c1b86710d.png
[img 33]: https://img-blog.csdnimg.cn/img_convert/d78316e84afdd1428309ab3e07893327.png
[img_img 33]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7d52a211b0014553b8e81c972c7511a3.png
[img 34]: https://img-blog.csdnimg.cn/img_convert/abce8be7aad792c6624754c881191d54.png
[img_img 34]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/dba5a6cbacf64dc4b9fe8223f24564c4.png
[image]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/556710b369444e83b101985f54e1ce2a.png
[mavenrepository]: https://mvnrepository.com/
[image 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/ca036cfbaf9048ef8ed51932cedf7db2.png
[image 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/5e22243ddd094cb1ac5fcffdb0417b20.png
[image 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/0f5cab85995f48cb9ef8b45e2beb86f9.png
[Link 6]: http://help.sina.com.cn/comquestiondetail/view/1566/
[image.png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/47bcdbd5e2364dd08f113273326e2fae.png
[image 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/f0838078be244e1e87a4097f3cf280e2.png
[image 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/be1860e7fdcd49a6a2f383b53441a707.png
[image 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/33155b9c210942efbfe42d1ca721350b.png
[image 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/9324968c511f404aaf0dc9ab095d10e6.png
[image 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/484b6a36d87e4b3c8de442dc16adb4b6.png
[image 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/b5860f726dec4e218c13a116355d6aa4.png
[image 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/538d51c3a80c4e9aa89d0c894137bbfb.png
[image 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/17179c26bc0548c6955de035c49add7d.png
[Link 7]: https://code.google.com/archive/p/kaptcha
[image 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/9f4aa4394700462ab18d909fa5da0b70.png
[image 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/4ece9049da3742fc8b96980d0ef507fa.png
[image 14]: https://img-blog.csdnimg.cn/img_convert/67ad52979cfd2955f88e365806a31f39.png
[image 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7cec50a4f44f427a8b56e7b828f6498b.png
[image 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/e079c8b009fe4bd0ba29003563462b72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzcxMTc4OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/213fbd82702843c391fb3d80a4a55cdc.png
[image 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8323af18c4a54176b4892415b8c55ca6.png
[image 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/615238831b184cc1ad6ace5f90dc856e.png
[image.png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/abb621e623b2429b917ba0c729c9551b.png
[image 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/50761b18d81340639b329eccbdbf0c36.png
[image.png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/599698604f384557b97c555062e752cb.png
[image 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/4364f983c9ca46a2bcb22ed722447f9d.png
[image 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/7a60d4d66bfd4814b203a0d6b0649ff9.png
[image 22]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/4b6a98cc33564dd584fbe44e0eec3694.png
[image 23]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/563eb05108034911a520fe75e3cfd21d.png
[image 24]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/d25f2bbfc11b4da49b615ff0ce45b96d.png
[image 25]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c7e91a01013c4eeb9a579acb19294c37.png
[image.png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/c2af7912089643f185e47e39667c9c02.png
[image 26]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/8c3f70945dfd42549478678c6e23fea1.png
[image 27]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/18/65fd56fc324f4fd9a81622850c43d1cd.png