[java 手把手教程][第二季]java 后端博客系统文章系统——No4

最新推荐文章于 2024-11-09 10:30:21 发布
最新推荐文章于 2024-11-09 10:30:21 发布
阅读量135 收藏 1
点赞数
文章标签： 后端 json 前端 ViewUI
原文链接：https://juejin.im/post/587c7b1d61ff4b0065026cf1
版权

转眼间第二季来到了第五章，也是我们博客系统的第四章。前段时间因为个人私事较多，项目停更了两期，但是这都不是问题，我们继续接着走下去。毕竟承诺的事情就得完成。

这一期我们的目标是完成后端博客系统的博客发布功能。

按照我们前面的设定，我们的后端博客系统需要完成最简单的博文发布，我们也得有后台管理界面，同时需要将用户权限这些都附带上，但是由于时间关系，我们后端默认账户就是管理员吧，毕竟这一期的重点是实现博客的发布。

博文发布系统

我们需要发布博文，那么后端必不可少的是登录和发布系统，至于其他的我们可以先缓一缓，毕竟我也没想好后端页面怎么设计，嘿嘿。

前面我看了一下，确实是完美兼容WordPress还是有很多难度，毕竟很多技术细节我们并不知道，不过，至少说目前我们已经兼容了博客文章，剩下的只需要一点点的适配就能大概完成任务。

不多说了，我们先完成后端登录功能。

后端登录

后端登录，我们不可能说一味的兼容WordPress，还有一些技术上面的设计理念可能也不是那么那啥，所以我们需要拿出一些自己的玩意。首先还是老规矩，从Dao→Service→Controller。

  • Dao按照老规矩就是对数据库的操作，所以我们只需要写上接口和mapper就行了。
  • Service层还是一样进行单元数据操作。
  • Controller是web应用的入口地点。
    有了上面的这些我们只需要进行一个登录验证，也就是前面说过的密码规则验证，不过具体代码如下：
@RequestMapping(value = "/login"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = RequestMethod.POST)
    @ApiOperation(
            value = "用户登录"
            , notes = "用户登录的接口，输入用户名和密码进行登录"
            , response = User.class)
    @ResponseBody
    public Object userLogin(HttpServletRequest request,
                            @ApiParam(value = "用户名不能为空，否则不允许登录"
                                    , required = true) @RequestParam("userLogin") String userLogin,
                            @ApiParam(value = "用户密码不能为空且必须为16位小写MD5，否则不允许登录"
                                    , required = true) @RequestParam("userPass") String userPass) {
        ResponseObj<User> responseObj = new ResponseObj<>();
        User user;
        if (PublicUtil.isJsonRequest(request)) {    //确认是否是post的json提交
            try {
                user = new GsonUtils().jsonRequest2Bean(request.getInputStream(), User.class);  //转换为指定类型的对象
                userLogin = user.getUserLogin();
                userPass = user.getUserPass();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (StringUtils.isEmpty(userLogin) || StringUtils.isEmpty(userPass)) {
            responseObj.setCode(ResponseObj.FAILED);
            responseObj.setMsg("用户名和密码不能为空！请检查！");
            return new GsonUtils().toJson(responseObj);
        }

        user = userService.findOneById(userLogin);

        if (null == user) {
            responseObj.setCode(ResponseObj.EMPUTY);
            responseObj.setMsg("用户不存在！请检查!");
            return new GsonUtils().toJson(responseObj);
        }

        userPass = userPass.toLowerCase();  //将大写md5转换为小写md5

        if (userPass.length() > 16 && userPass.length() == 32) {    //32位小写转换为16位小写
            userPass = userPass.substring(8, 24).toLowerCase();
        } else if (userPass.length() > 32) {
            responseObj.setCode(ResponseObj.FAILED);
            responseObj.setMsg("密码不规范！请检查！");
            return new GsonUtils().toJson(responseObj);
        }

        String encryptPassword = EncryptUtils.encryptPassword(userPass, user.getUserActivationKey());

        if (!encryptPassword.equals(user.getUserPass())) {
            responseObj.setCode(ResponseObj.FAILED);
            responseObj.setMsg("用户名和密码不匹配！请检查！");
            return new GsonUtils().toJson(responseObj);
        }

        user.setUserPass(request.getSession().getId()); //将sessionId放入用户信息中
        user.setUserActivationKey("");  //将用户注册的salt清空
        user.setUserUrl("/user/endSupport/index");

        responseObj.setData(user);
        responseObj.setCode(ResponseObj.OK);
        responseObj.setMsg("登录成功");

        return new GsonUtils().toJson(responseObj);
    }复制代码

虽然说很多东西我们在前端或者是客户端已经做了限制，但是为了防止别人搞事情我们还是需要这样做才行。

Spring-Fox，Api测试页面

什么是Spring-Fox呢？Springfox的前身是swagger-springmvc，是一个开源的API doc框架，可以将我们的Controller的方法以文档的形式展现。

为什么我们要大费周章的做这些呢？

  • 它可以帮助我们归类web访问入口
  • 它可以整理接口
  • 它可以···

确实语言描述是我的弱点，不过呢，我这个理工直男癌就需要直截了当的说出来，没时间解释，直接上图。

我的博客第五章-API_doc框架

正如上面的截图所示，我们首先应该找到对应的spring-fox的说明文档，然后仔细一看网上分为两个版本，一个是开源中国的引入说明，一个是Spring-Fox官方的使用说明，那么肯定选择官方的。

按照官方文档，我们简单总结一下：

  • 版本选择（Release或者Snapshot，推荐使用Release）
  • 依赖引入（maven或者gradle）
  • swagger设置
  • 重要细节（Spring-Fox官方文档中没有指明！！！）

按照官方文档说明的是，他们的demo是在SpringBoot下面实现的，现在我们需要单一的拆分出来，可以看成我们的项目就是Spring-Mvc，所以一些细节需要改变，当然当中一个很重要的细节官方文档也是没有指明，所以看官们且看我细细道来。

引入依赖资源

首先我们引入引来资源，通读全文最基本的依赖是：springfox-swagger、springfox-swagger-ui，所以我们直接老规矩，在gradle的配置文件中引入依赖：

compile "io.springfox:springfox-swagger2:2.6.1"
compile 'io.springfox:springfox-swagger-ui:2.6.1'复制代码

在引入上面的基本依赖后，我们查看他们关联的依赖可以发现这些依赖里面还有引入jackson，这个时候我们可以选择提升我们的Jackson或者不管他们也行，不过我还是吧Jackson的版本提升了：

compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.8.4'
compile group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.8.4'
compile group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.8.4'复制代码

swagger设置

根据官方文档我们可以看到有一个swagger设置需要先引入后，才能让我们设定的东西生效，所以我们先引入设置：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * Created by mac on 2017/1/8.
 */
@Configuration  //说明这个是spring的设置
@EnableWebMvc   //不是SpringBoot需要引入这个
@EnableSwagger2 //开启Swagger2
@ComponentScan("cn.acheng1314.controller")  //指定被扫描Controller的位置
public class Swagger2SpringMvc extends WebMvcConfigurerAdapter {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)  //Docket，Springfox的私有API设置初始化为Swagger2
                .select()
//                .apis(RequestHandlerSelectors.basePackage("cn.acheng1314.controller"))    //此处设置扫描包和上面设置的扫描包一样效果
                .paths(PathSelectors.any())
                .build()
                .apiInfo(new ApiInfoBuilder()  //设置API文档的主体说明
                        .title("博客Apis")
                        .description("雨下一整夜的博客APIs")
                        .version("1.01")
                        .termsOfServiceUrl("http://acheng1314.cn/")
                        .build())
//                .pathMapping("/")
//                .genericModelSubstitutes(ResponseEntity.class)
//                .alternateTypeRules(
//                        newRule(typeResolver.resolve(DeferredResult.class,
//                                typeResolver.resolve(ResponseEntity.class, WildcardType.class)),
//                                typeResolver.resolve(WildcardType.class)))
                ;
    }

}复制代码

设置完成上面的东西后，我们需要干什么呢？ 上面我们很明显的看到我们 @configuration是一个spring框架的注解 ，顾名思义肯定就应该是一个spring的设置。同时我们可以在idea的编辑器中看到类名有一层淡黄色的标记，然后选中类名按下代码提示(Alt+Enter)会有提示告诉我们这个设置没有使用，然后自动完成后会给我们自动添加到Spring的ApplicationContext中作为CodeContext使用。

当然，上面的是懒人做事这样做的后果会是导致apiInfo的设置不能生效。

那么正常一点的应该是怎么做呢？按照Spring的思想来说，我们需要在Spring的设置文件中直接引入bean。所以我们在spring-web.xml中插入对应的bean，如下：

<!--SpringFox设置引入-->
<bean id="SpringFox" class="cn.acheng1314.Swagger2SpringMvc"/>复制代码

通过这样的在spring的配置文件中设置后，我们感觉应该是能用的，所以我们可以先跑起来看看。

重要细节，我有特殊的装X技巧

按照官方文档我们完全设定了后，我们可以看到就算我们在代码中引入了配置后，一样的在里面不能看到网页的接口列表（只看得到上面的标题栏，下面的是空白），然后我们仔细的查看网页的请求会发现

http://localhost:8080/swagger-resources/configuration/ui复制代码

这个请求是404。说实话这个错误困扰了我很久，同时这个问题前面我处理的时候还是有一系列的综合问题，后面整个工程师重建后完成的。

但是现在这个问题简单直接找到问题所在了，那就是在我们spring的设置中，关于web的设置我们都是在spring-web.xml中完成的，同时里面的东西我们需要改动一下才能适应现在的需要，如下：

<!-- 4.扫描web相关的bean -->
    <context:component-scan base-package="cn.acheng1314.controller">
        <!-- 制定扫包规则 ,只扫描使用@Controller注解的JAVA类 -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

<!--上面的是原来的设置，现在我们新的代码如下：-->
<!-- 4.扫描web相关的bean -->
    <context:component-scan base-package="cn.acheng1314.controller,springfox">
        <!-- 制定扫包规则 ,只扫描使用@Controller注解的JAVA类 -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>复制代码

也就是说，我们除了要在Spring的配置文件中引入bean来初始化swagger相关的东西以外，我们还需要在web扫描那里添加springfox的扫描。所以我们spring-fox的设置相关的完成了。

Spring-Fox的使用

从前面的学习中我们可以明白我们所有的网络请求都是在controller中来实现的，所以我们这里需要通过对controller做适当的修改才能实现SpringFox的使用。具体的直接仍代码上来，大家详细的看看就行了，不需要什么深入钻研。


import cn.acheng1314.domain.*;
import cn.acheng1314.domain.Response.HomeBean;
import cn.acheng1314.service.postService.PostService;
import cn.acheng1314.service.userService.UserService;
import cn.acheng1314.utils.GsonUtils;
import cn.acheng1314.utils.PublicUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;

import static org.springframework.http.MediaType.APPLICATION_JSON_UTF8_VALUE;

/**
 * 前端页面的控制器，博客系统前端页面相对较少，所以都扔在这里了
 * Created by 程 on 2016/11/25.
 */
@Controller
@RequestMapping("/front")
@Api(value = "/front", description = "前台页面")
public class FrontWebController {

    @Autowired
    private PostService postService;
    @Autowired
    private UserService userService;

    /**
     * 返回主页面
     *
     * @return
     */
    @RequestMapping(value = "/main", method = RequestMethod.GET)
    @ApiOperation(
            value = "打开首页界面"
            , notes = "首页web界面，js模板加载网页数据")
    public ModelAndView frontMain(HttpServletRequest request) throws Exception {
        ModelAndView view = new ModelAndView("frontMain");
        view.addObject("framJson", getFramJson());
        view.addObject("postsJson", findPublishPost(request, 1, 10));
        return view;
    }

    /**
     * 获取文章分页列表
     *
     * @param request  用户请求
     * @param pageNum  当前页码
     * @param pageSize 每一页的长度
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/findPublishPost"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ResponseBody
    @ApiOperation(  //接口描述
            value = "获取文章分页列表"  //功能简介
            , notes = "返回文章列表，分页加载" //接口功能说明
            , response = PostBean.class,    //返回数据的值说明
            responseContainer = "List") //返回数据类型说明
    public Object findPublishPost(HttpServletRequest request,
                                  @ApiParam(value = "当前页码,默认不能为空，否则为1",
                                          required = true,    //参数是否必传
                                          defaultValue = "1" //参数默认值为1
//            ,allowableValues = "available,pending,sold"   //暂时未知，待查阅文章
//            ,allowMultiple = true    //是否允许allowMultiple类型的参数
                                  ) @RequestParam("pageNum")
                                          int pageNum,
                                  @ApiParam(value = "每一页的长度,默认不能为空，否则列表条目数量为10",
                                          required = true,    //参数是否必传
                                          defaultValue = "10" //参数默认值为1
//            ,allowableValues = "available,pending,sold"   //暂时未知，待查阅文章
//            ,allowMultiple = true    //是否允许allowMultiple类型的参数
                                  ) @RequestParam("pageSize")
                                          int pageSize) throws Exception {
        PageSplit page;
        ResponseList<PostBean> list = new ResponseList<>();

        if (PublicUtil.isJsonRequest(request)) {    //确认是否是post的json提交
            page = new GsonUtils().jsonRequest2Bean(request.getInputStream(), PageSplit.class);  //转换为指定类型的对象
            pageNum = page.getPageNum();
            pageSize = page.getPageSize();
        }
        if (pageNum <= 0) {
            pageNum = 1;
        }
        if (pageSize == 0) {
            pageSize = 10;
        }

        try {
            int toalNum; //总页码
            toalNum = postService.getAllCount();    //先把总条数赋值给总页数，作为缓存变量，减少下面算法的查找次数

            toalNum = toalNum % pageSize > 0 ? toalNum / pageSize + 1 : toalNum / pageSize;     //在每页固定条数下能不能分页完成，有余则加一页码

            List<PostBean> tmp = postService.findAllPublish(pageNum, pageSize);
            if (null == tmp || tmp.size() == 0) {
                list.setCode(ResponseList.EMPUTY);
                list.setMsg(ResponseList.EMPUTY_STR);
                return new GsonUtils().toJson(list);
            }
            list.setCode(ResponseList.OK);
            list.setMsg(ResponseList.OK_STR);
            list.setPageNum(pageNum);
            list.setTotalNum(toalNum);
            list.setPageSize(pageSize);
            list.setData(tmp);
            return new GsonUtils().toJson(list);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败
            list.setCode(ResponseObj.FAILED);
            list.setMsg(ResponseList.FAILED_STR);
            return new GsonUtils().toJson(list);
        }

    }

    /**
     * 查找最近的文章
     *
     * @return
     */
    @RequestMapping(value = "/findNewPost"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ApiOperation(
            value = "获取最近文章"
            , notes = "获取最近文章的json，具体字段请参照输出的json数据"
            , response = PostBean.class)
    @ResponseBody
    public Object findNewPost() {
        ResponseObj<Object> responseObj = new ResponseObj<>();
        try {
            List<PostBean> allNew = postService.findAllNew();
            if (null == allNew || allNew.isEmpty()) {
                responseObj.setCode(ResponseObj.EMPUTY);
                responseObj.setMsg(ResponseObj.EMPUTY_STR);
            } else {
                responseObj.setCode(ResponseObj.OK);
                responseObj.setMsg(ResponseObj.OK_STR);
                responseObj.setData(allNew);
            }
            return new GsonUtils().toJson(responseObj);
        } catch (Exception e) {
            e.printStackTrace();
            responseObj.setCode(ResponseObj.FAILED);
            responseObj.setMsg(ResponseObj.FAILED_STR);
            return new GsonUtils().toJson(responseObj);
        }
    }

    /**
     * 获取热点文章信息
     *
     * @return
     */
    @RequestMapping(value = "/findHotPost"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ApiOperation(
            value = "获取最热文章"
            , notes = "获取最热文章的json，具体字段请参照输出的json数据"
            , response = PostBean.class)
    @ResponseBody
    public Object findHotPost() {
        return findNewPost();
    }

    /**
     * 获取随机文章信息
     *
     * @return 返回json
     */
    @RequestMapping(value = "/findRandomPost"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ApiOperation(
            value = "随机获取文章"
            , notes = "随机获取文章的json，具体字段请参照输出的json数据"
            , response = PostBean.class)
    @ResponseBody
    public Object findRandomPost() {
        return findNewPost();
    }

    /**
     * 获取主页的json数据，按照道理讲这里应该根据页面结构拆分组合的
     *
     * @param user 用户信息
     * @return 返回首页json
     */
    @RequestMapping(value = "/home"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ResponseBody
    @Deprecated
    public Object getHomeJson(User user) {
        if (null != user) {
            //埋点，AOP日志记录
        }
        HomeBean homeBean = new HomeBean(); //首页内容
        HomeBean.DataBean dataBean = new HomeBean.DataBean();   //首页下面的Data内容对象
        try {
            int toalNum; //总页码

            toalNum = postService.getAllCount();    //先把总条数赋值给总页数，作为缓存变量，减少下面算法的查找次数

            toalNum = toalNum % 10 > 0 ? toalNum / 10 + 1 : toalNum / 10;     //在每页固定条数下能不能分页完成，有余则加一页码

            List<PostBean> postsData = postService.findAllPublish(1, 10);   //首页下面的文章内容
            List<PostBean> newData = postService.findAllNew();   //首页下面的文章内容
            if (null == postsData || postsData.isEmpty()) {
                dataBean.setPosts(null);
            } else {
                dataBean.setPosts(postsData);   //首页文章列表信息设定
            }
            if (null == newData || newData.isEmpty()) {
                dataBean.setNewPosts(null);
                dataBean.setHotPosts(null);
                dataBean.setRandomPosts(null);
            } else {
                dataBean.setNewPosts(newData);   //首页文章列表信息设定
                dataBean.setHotPosts(newData);
                dataBean.setRandomPosts(newData);
            }
            List<DateCountBean> allPostDateCount = postService.getAllPostDateCount();
            if (null != allPostDateCount && !allPostDateCount.isEmpty()) {
                dataBean.setDate(allPostDateCount);
            } else {
                dataBean.setDate(null);
            }
            //设置作者信息
            List<HashMap<String, String>> userMeta = userService.getUserMeta(1);
            dataBean.setAuthor(userMeta);

            dataBean.setPageNum(1);
            dataBean.setPageSize(10);
            dataBean.setTotalNum(toalNum);
            homeBean.setData(dataBean);
            homeBean.setCode(ResponseObj.OK);
            homeBean.setMsg(ResponseList.OK_STR);
            return new GsonUtils().toJson(homeBean);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败
            homeBean.setCode(ResponseObj.FAILED);
            homeBean.setMsg(ResponseList.FAILED_STR);
            return new GsonUtils().toJson(homeBean);
        }
    }

    /**
     * 页面框架的变化信息
     * 1、个人信息
     * 2、最新热点随机文章信息
     * 3、标签信息
     *
     * @return
     */
    @RequestMapping(value = "/getFramJson"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ApiOperation(
            value = "获取主题框架的json"
            , notes = "整个页面的主体框架的json数据")
    @ResponseBody
    public Object getFramJson() {
        HomeBean homeBean = new HomeBean(); //首页内容
        HomeBean.DataBean dataBean = new HomeBean.DataBean();   //首页下面的Data内容对象
        try {
            List<PostBean> newData = postService.findAllNew();
            if (null == newData || newData.isEmpty()) {
                //页面上面推荐的文章信息不为空
                dataBean.setNewPosts(null);
                dataBean.setHotPosts(null);
                dataBean.setRandomPosts(null);
            } else {
                //首页文章列表信息设定
                dataBean.setNewPosts(newData);
                dataBean.setHotPosts(newData);
                dataBean.setRandomPosts(newData);
            }

            //日期归档
            List<DateCountBean> allPostDateCount = postService.getAllPostDateCount();
            if (null != allPostDateCount && !allPostDateCount.isEmpty()) {
                dataBean.setDate(allPostDateCount);
            } else {
                dataBean.setDate(null);
            }
            //设置作者信息
            List<HashMap<String, String>> userMeta = userService.getUserMeta(1);
            dataBean.setAuthor(userMeta);

            homeBean.setData(dataBean);
            homeBean.setCode(ResponseObj.OK);
            homeBean.setMsg(ResponseList.OK_STR);
            return new GsonUtils().toJson(homeBean);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败
            homeBean.setCode(ResponseObj.FAILED);
            homeBean.setMsg(ResponseList.FAILED_STR);
            return new GsonUtils().toJson(homeBean);
        }
    }

    /**
     * 根据作者的ID获取作者的信息
     *
     * @param userId 作者ID
     * @return 返回作者的json信息
     */
    @RequestMapping(value = "/getAuthorInfo"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ApiOperation(
            value = "获取作者信息"
            , notes = "获取作者基本信息的json，具体字段请参照输出的json数据"
            , response = PostBean.class)
    @ResponseBody
    public Object getAuthorJson(int userId) {
        ResponseObj<Object> responseObj = new ResponseObj<>();
        try {
            List<HashMap<String, String>> userMeta = userService.getUserMeta(userId);
            if (null == userMeta || userMeta.isEmpty()) {
                responseObj.setCode(ResponseObj.EMPUTY);
                responseObj.setMsg(ResponseObj.EMPUTY_STR);
            } else {
                responseObj.setCode(ResponseObj.OK);
                responseObj.setMsg(ResponseObj.OK_STR);
                responseObj.setData(userMeta);
            }
            return new GsonUtils().toJson(responseObj);
        } catch (Exception e) {
            e.printStackTrace();
            responseObj.setCode(ResponseObj.FAILED);
            responseObj.setMsg(ResponseObj.FAILED_STR);
            return new GsonUtils().toJson(responseObj);
        }
    }

    /**
     * RESTful风格的文章页面
     *
     * @param postId 文章ID
     * @return 返回文章页面
     */
    @RequestMapping(path = "/post/{postId}", method = RequestMethod.GET)
    @ApiOperation(
            value = "打开文章详情web界面"
            , notes = "文章详情web界面，js模板加载网页数据")
    public ModelAndView getPostView(@PathVariable int postId) {
        ModelAndView resultView = new ModelAndView("frontPost");
        resultView.addObject("framJson", getFramJson());
        resultView.addObject("postJson", getPostById(postId));
        return resultView;
    }

    /**
     * 根据文章ID获取文章内容
     *
     * @param postId 文章ID
     * @return 返回文章ID对应的文章内容
     */
    @RequestMapping(value = "/getPost"
            , produces = {APPLICATION_JSON_UTF8_VALUE}
            , method = {RequestMethod.GET, RequestMethod.POST})
    @ApiOperation(
            value = "根据id获取文章json"
            , notes = "根据文章的ID获取文章的详情json"
            , response = PostBean.class)
    @ResponseBody
    public Object getPostById(
            @ApiParam(value = "文章ID", required = true)
            @RequestParam("postId")
                    int postId) {
        ResponseObj<Object> responseObj = new ResponseObj<>();
        try {
            PostBean postBean = postService.findPostById(postId);
            if (null == postBean) {
                responseObj.setCode(ResponseObj.EMPUTY);
                responseObj.setMsg(ResponseObj.EMPUTY_STR);
            } else {
                responseObj.setCode(ResponseObj.OK);
                responseObj.setMsg(ResponseObj.OK_STR);
                responseObj.setData(postBean);
            }
            return new GsonUtils().toJson(responseObj);
        } catch (Exception e) {
            e.printStackTrace();
            responseObj.setCode(ResponseObj.FAILED);
            responseObj.setMsg(ResponseObj.FAILED_STR);
            return new GsonUtils().toJson(responseObj);
        }
    }

}复制代码

至此我们的Spring-Fox简单实用已经完成，后续的操作我们在需要的地方再查找资料就行了。

总结

本期项目都是简单的介绍了一些东西，主要有：

  • 登录密码校验规则（MD5→SHA256）
  • Spring-Fox的引入
  • Spring-Fox在非springBoot中的使用
  • Spring-Fox的使用

这一期本来是上一周就应该完成的，但是回家懒癌发作又拖了一周，期间女朋友还各种生病，每天也没心思写代码，很对不起大家了，后面我会更加努力，也感谢一些哥们在我博客上面的留言鼓励，谢谢大家。

weixin_34306593
关注
java博客系统
01-15
基于Java Web的博客系统，包含了设计文档，数据库设计以及web源码
[手把手教程][第二季]java 后端博客系统文章系统——No1
weixin_33913377的博客
12-05 161
转眼到了博客系统第二章了。这一张我们主要介绍文章系统。毕竟博客系统的核心就是文章的发布和阅读。闲话不多说，老规矩走起来。工具IDE为idea16JDK环境为1.8gradle构建，版本：2.14.1Mysql版本为5.5.27Tomcat版本为7.0.52流程图绘制（xmind）建模分析软件PowerDesigner16.5思维导图按照前面我们第二季第一章阐述的，我们需要先了解我们这个文章系统的整...
博客归档功能的实现及相关问题的解决方法
mywindpursue的博客
09-01 1727
博客归档功能的实现及相关问题的解决 基于Django开发个人博客（https://www.solutionworks.cn）时，提供按照年份及月份实现博客文档归档功能是个人博客极其常见的功能，实现这一功能的过程中，必然要获取数据库中记录的文档创建或发布时间，统计某月创建或发布文章数量信息。实现的过程中，发现通过程序取得的时间可能存在和数据库存储的时间不一致的情况（如实际某月存在创建或发布的文章，但是根据程序获取的时间却查不到对应的文章），改用其他方法实现相同功能时，甚至出现关于MySQL时区设置问题的错误
java获取系统信息
qq_32617311的博客
08-27 1930
java获取系统信息的方法 1.System.getProperties(); 使用该方法，可以获取到一些系统的信息 Properties properties = System.getProperties(); //获取键值 Set&lt;Object&gt; keySet = properties.keySet(); for (Object object : keySet) { ...
java 后台将base64字符串保存为图片的方法
stay hungry ! stay foolish!
02-11 6218
java 后台将base64字符串保存为图片的方法本文介绍了java 后台将base64字符串保存为图片的方法，分享给大家，具体如下：直接上代码：import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; impor...
[java 手把手教程][第二季]java 后端博客系统文章系统——No6
weixin_33859231的博客
02-27 104
本期主要是文章保存功能，涉及到草稿、文章发布、历史这三个要点。 项目github地址：github.com/pc859107393… 实时项目同步的地址是国内的码云：git.oschina.net/859107393/m… 我的简书首页是：www.jianshu.com/users/86b79… 上一期是：[手把手教程][第二季]java 后端博客系统文章系统——No5 行走的java全栈 工具 ...
[java 手把手教程][第二季]java 后端博客系统文章系统——No3
weixin_34348174的博客
12-20 106
又是新的一期了，这一期我们把前面文章于都相关的基本地方都完成吧。 每次新写一章都会有很多话说，到头来觉得这些话好像无关痛痒，毕竟我们做技术的只需要技术足够，除非不只做技术才会想更多。 说实话，最近经历了很多事情，只想说：时间才是最长的告白。 项目github地址：github.com/pc859107393… 我的简书首页是：www.jianshu.com/users/86b79… 上一期是：[手...
[java 手把手教程][第二季]java 后端博客系统文章系统——No5
weixin_34082695的博客
02-17 136
[java手把手教程][第二季]java后端博客系统文章系统——No5 停更了一个月后，我们再次开始更新。具体原因只能说是过年事情太多，幼时不知努力，长大了却又事事缠身。 这一期主要是根据WordPress执行的效果来观察数据库，从而分析WordPress的程序设计。 项目github地址：github.com/pc859107393… 我的简书首页是：www.jianshu.com/users/...
[手把手教程][第二季]java 后端博客系统文章系统——No2
weixin_33991418的博客
12-11 156
这是博客系统的第三章，也是坚持写这个系列文章的第三个月了。在这期间我建立了全栈技术交流群，感谢一路鼓励我的朋友们。也要感谢我的大学导师，是他们在我需要的时候，告诉我做人的品质。 今天这一篇，主要是关于上一张的编码实现。为什么我要单路分离出来？因为做事要分先后，明白道理，执行才能确定无误。 我们还是从老套路（Dao→Service→Controller）做起来，让我们先看看数据存储相关的东西吧。 项...
[java手把手教程][第二季]java后端博客系统文章系统——No10
weixin_34357436的博客
08-03 90
项目github地址：github.com/pc859107393… 实时项目同步的地址是国内的码云：git.oschina.net/859107393/m… 我的简书首页是：www.jianshu.com/users/86b79… 上一期是：[手把手教程][第二季]java 后端博客系统文章系统——No9 行走的java全栈 工具 IDE为idea2017.1.5 JDK环境为1.8 grad...
JAVAWML信息查询与后端信息发布系统实现——WML信息查询设计(源代码+论文).rar
04-03
Java WML信息查询与后端信息发布系统是一种基于Java技术实现的移动互联网应用，主要用于在WAP（无线应用协议）设备上进行数据查询和发布。WML（Wireless Markup Language）是专门为无线通信设备设计的一种标记语言，...
JAVA手把手教程.rar
06-29
我们可以对Java程序进行编译操作，编译后生成一种和平台系统无关的文件——字节码文件(.class)。但是此时Windows、Linux均不能执行字节码文件,只有Java虚拟机(JVM)可以识别字节码文件,那么为了在Windows系统上运行该...
Access数据库应用实例——教务管理系统设计教程（含成品数据库）
08-04
#资源达人分享计划# 本教程将手把手一步一步教你从0开始制作出一个可以正式投入使用的教务管理Access数据库系统。通过本教程，即使你是完全没有基础的小白，也能掌握表、查询、窗体、报表、宏以及各种控件的使用和...
java+手把手vue+springboot前后端分离项目实战---社区项目后端代码.zip
08-17
本项目是一个基于Java、Vue和SpringBoot的前后端分离实战案例，主要涵盖了社区类Web应用的后端开发。在这个项目中，我们将深入学习和实践如何使用这些技术来构建一个功能完善的社区平台。以下是对该项目涉及的技术点...
WPF+MVVM案例实战与特效（二十六）- 3D粒子方块波浪墙效果实现
lingshuangcanxue
11-05 552
使用WPF中的3D特效实现粒子方块墙的特效
openresty入门教程：rewrite_by_lua_block
最新发布
软考鸭
11-09 357
在OpenResty中，是一个强大的工具，它允许你在Nginx的rewrite阶段执行Lua脚本。这个阶段在Nginx处理请求的早期发生，通常用于修改请求URI、请求参数、请求头等，或者根据某些条件执行重定向、返回特定响应等。以下是关于。
Unexpected response code: 400解决
STARSpace8888的博客
11-08 206
原因：Nginx配置错误，业务服务提供了 websocket 服务，基于 websocket 来实现报表数据的推送，客户在浏览器上查看报表，经过 http 代理将请求传递给后端服务。你的websocket访问地址。# 修正此行，确保正确处理连接升级。Nginx中增加websocket配置。
WPF+MVVM案例实战与特效（二十五）- 3D粒子波浪效果实现
lingshuangcanxue
11-05 309
使用WPF的3D控件以及动画效果实现3D粒子波浪的特效
LFS新手指南：第二版完整Linux系统搭建教程
"《手把手教你如何建立自己的Linux系统 第二版》是一本由孙海勇编写的指南，专注于Linux From Scratch (LFS) 的系统构建教程，特别是针对LFS-6.3版本进行了更新。这本书是第一版的延续，旨在帮助初学者快速熟悉LFS的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值