第1篇:springboot/mongodb/mvc入门

2019年6月9日 175次阅读 来源: 萌萌哒小肥他爹

前言

java+spring就像个老旧而可靠的伴侣, 但代码略臃肿. 所以我一般是公司级别的项目用java, 而自己的项目用python. 但等自己用python造了一遍轮子之后, 发现其实只是一开始省点时间, 真正算下来比java也省不了多少精力, 而且动态语言的缺点大家都知道, 开始干活一时爽, 动手重构化飞灰, 恰好我又是喜欢经常整理自己代码的人… 于是就想把业务代码重新统一为java. (当然科学计算和爬虫还是用python方便). 这段时间搜了搜springboot, 发现结合了很多其他web框架的特点, 也贴近快速开发这个目标了. 又加上这几年我前端技术都用vue, 就打算把vue+springboot的最佳实践都写写, 作个总结.

《第1篇:springboot/mongodb/mvc入门》 , 但别心急, 周末静下心来看点东西写点代码… 王司徒有言:

《第1篇:springboot/mongodb/mvc入门》 meiz.jpeg

初始化springboot和mongodb

工程的初始化

spring提供了一个网站初始化项目, 挺好使的, 地址在这里: https://start.spring.io/, 页面如下:

《第1篇:springboot/mongodb/mvc入门》

可以选择maven还是gradle, 语言种类, springboot的版本, 填入maven信息, 选择所需要的库… 这里我选了mongodb 和 devtools 库. 界面做得挺好, 不用过多说明了. 然后点 generate project , 就可以下载一个zip包. 解压这个zip包, 就可以用 eclipse 或者 idea 导入.

补充说明: devtools是什么呢? 这是让tomcat热启动的类库. 这样用eclipse写代码的时候只要保存代码, 服务器就会自动重启. 如果用idea, 保存完代码之后需要点一下build project. 因为我懒得点这一下build, 所以还是习惯用eclipse. 如果你是idea, 请自行调整.

如果用eclipse导入要注意:

  • 用import maven 的方式导入工程.

  • 如果你没修改过, 默认导入maven都是jdk 1.5 的版本. 这样看起来工程会报错. 请修改为1.8以上. 什么? 你不知道在哪里修改? 看这里:

    《第1篇:springboot/mongodb/mvc入门》 image.png

  • eclipse的maven管理有点乱七八糟. 最好在工程的根目录, 右键选maven -update project, 让maven正确工作. (这里比较难截图, 自己找找)

整体效果如图:

《第1篇:springboot/mongodb/mvc入门》 image.png

然后:

  • 修改java类, 加入伟大的helloworld, 如图:

    《第1篇:springboot/mongodb/mvc入门》 image.png

  • 我假设你已经装好了mongodb, 请启动之. ubuntu类同学请注意, 安装之后mongdob并不会随系统启动而启动, 要运行 sudo service mongod start 命令才行

  • 运行这个java类, 就会看到一大堆log和伟大的helloworld了. 如下图:

    《第1篇:springboot/mongodb/mvc入门》 image.png

这里发生了什么? springboot 采取”约定优先”的做法. 即假定你整个工程都按照习惯的命名而来, 如这里你并没有配置mongodb的信息, springboot 就假定这个配置是 localhost:27017 , 无用户名密码, 然后就连上数据库了. (可以做个试验, 如果你没有启动mongodb, 那么启动会成功, 但会在控制台打印出数据库连接错误的信息). 现在我还没有加入mongodb的代码, 如果加入了, 你会发现spring自做主张在里面创建数据库.

嗯, 比 tornado flask 的快速还是差一点, 但差距已经不大了. 值得表扬的springboot !

测试mongodb的开发

接下来我们加入一点mongodb的东西来做测试.

新建 BackUser 数据表类, 如下:

package org.diego.springvue;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Field;

public class BackUser {
    
    @Id
    String id;
    
    @Field
    String account;
    
    @Field
    String password;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

我假定你是java mongodb 的新手, 这里需要掌握的知识是:

  • spring会用 @id 的字段来作为表的主键, 你也别用其他名字整些乱七八糟的幺鹅子了, 就按我这样写没错.
  • @Field表示一个个字段. 挺简单吧?

《第1篇:springboot/mongodb/mvc入门》, 这个坑导致我减少了快4个小时的游戏时间. 等说到mvc的时候再加以说明.

BackUserRepository 接口(注意是接口), 并继承 MongoRepository 接口, 如下:

package org.diego.springvue;

import org.springframework.data.mongodb.repository.MongoRepository;

public interface BackUserRepository extends MongoRepository<BackUser, String>{

    // 这个方法会自动实现
    BackUser findByAccount(String account);
}

这里很有趣的是, 凡是符合spring命名规则, 例如这个findByXXX (xxx是字段) , spring就会自动实现. 所以对于新手来说, 这里可以节省点时间. (但很严肃地说, 对于老手没啥用…. )

然后, 展开src/test/java 目录, 你会看到spring已经有一个Junit的test 类. 修改这个类, 如下:

package org.diego.springvue;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringVueApplicationTests {

    @Autowired
    BackUserRepository repository;

    @Test
    public void test() {
        String account = "diego";
        // 检查并新建一个用户
        BackUser user = repository.findByAccount(account);
        
        if(user == null) {
            user = new BackUser();
            user.setAccount(account);
            repository.insert(user);
            System.out.println("新建用户成功: " + account);
            return;
        }

        System.out.println("用户已存在: " + account);
    }

}

运行这个测试, 茫茫多的log之下, 你会发现隐藏的这句:

《第1篇:springboot/mongodb/mvc入门》 image.png

记住小肥耙耙的英文名是Diego. :-) 这表示spring已经成功创建了一条记录.

用客户端工具robomongo连接mongodb, ( 快9012年了, 别用命令行了吧, 下载地址在这: [robomongo] (https://robomongo.org/) 你可以看到表已经顺利创建了.

《第1篇:springboot/mongodb/mvc入门》 image.png

测试mvc功能

现在修改maven, 加入 spring 的mvc类库和devtools, 整个pom.xml文件应该如下:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.diego</groupId>
    <artifactId>spring-vue</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-vue</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
                
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

新建一个 TestController 类, 如下:

package org.diego.springvue;

import java.io.IOException;

import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

@RestController
public class TestController {

    @Autowired
    private BackUserRepository repository;
    
    private void jsonResult(HttpServletResponse response, Object o) {
        try {
            response.setContentType("application/json;charset=UTF-8");
            response.setHeader("Pragma", "No-cache");
            response.setHeader("Cache-Control", "no-cache");
            response.setDateHeader("Expires", 1);
            response.getWriter().write(o.toString());
            response.getWriter().flush();
            response.getWriter().close();
        } catch (IOException e) {
        }
    }
    
    @GetMapping("/test")
    public void doTest(String account) throws Exception{
        
        // mvc4 中获取 response的做法
        HttpServletResponse response = ((ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes()).getResponse();

        if(account == null) {
            this.jsonResult(response,  "请输入账号");
            return;
        }
        
        BackUser user = repository.findByAccount(account);
        if(user == null) {
            this.jsonResult(response,  "没有这个用户: " + account);
            return;         
        }
        
        this.jsonResult(response, user);
    }
}

这里的技术点说明如下:

  • 每个Controller 要加 RestController 这个annotation. (老手注意: 不用继承那个multi controller啦)
  • GetMapping 和 PostMapping 对应 get / post 方法, 还有RequestMapping 可以自己做更多定制.
  • 方法签名不用加又长又臭的request/response啦. 如果要使用到, 看我代码取response的例子.
  • 方法签名里如果是简单类型, spring会从request找到参数然后设置之. 如果是对象, 那么会试图匹配对象的每个属性. 对象匹配留到以后再谈.

启动SpringVueApplication, 你在浏览器打开 localhost:8080/test?account=test, 应该会看到如下结果:

《第1篇:springboot/mongodb/mvc入门》 image.png

如果传入的参数是diego, 应该看到如下结果:

《第1篇:springboot/mongodb/mvc入门》 image.png

我们没有为BackUser 加toString 方法, 所以这个结果是正确的.

至此, 整个入门教程就完成了. 一路按照我的代码下来,你肯定能跑出正确的结果. 但是, 既然这个系列教程叫”登堂入室”, 自然少不了聊聊我认为怎么代码能写得更好.

登堂入室Tips: 封装 request/response 方法

如果你去看springmvc 的官方教程, 会发现他们提供了一大堆annotation来帮你确定http的请求参数, 个人并不喜欢这点, 并且认为这是个过度设计. 我本人拥护的是python哲学: 简单的事情最好只有一个做法. 这样脑子能记更多有用的东西(而不是记茴香豆的n种写法), 并且在团队沟通代码审查上更为方便. 所以在获取参数上我沿用的是老做法.

新建工具类 DWebUtils

新建一个DWebUtils (D开头是为了避免WebUtils和其他类库重名, 导致查找费时间…. ) , 代码如下:

package org.diego.springvue;

import java.io.IOException;

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

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

public class DWebUtils {
    
    public static final HttpServletResponse getResponse() {
        return ((ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes()).getResponse();
    }
    
    public static final HttpServletRequest getRequest() {
        return ((ServletRequestAttributes)
                RequestContextHolder.getRequestAttributes()).getRequest();
    }

    public static final String getString(String name) {
        return getParameter(name);
    }

    public static final int getInt(String name) {
        String v = getString(name);
        if (isEmpty(v)) {
            return -1;
        };
        return Integer.parseInt(v);
    }

    public static final String getParameter(String name) {
        HttpServletRequest request = getRequest();
        String v = request.getParameter(name);
        if (isEmpty(v) || "undefined".equalsIgnoreCase(v) || "null".equalsIgnoreCase(v)) {
            return "";
        }
        return v;
    }
    
    public static final boolean isEmpty(String v) {
        return v == null || v.trim().equals("");
    }

    
    public static void jsonResult(Object o) {
        HttpServletResponse response = getResponse();
        try {
            response.setContentType("application/json;charset=UTF-8");
            response.setHeader("Pragma", "No-cache");
            response.setHeader("Cache-Control", "no-cache");
            response.setDateHeader("Expires", 1);
            response.getWriter().write(o.toString());
            response.getWriter().flush();
            response.getWriter().close();
        } catch (IOException e) {
        }
    }

}

你可以按照自己喜好加入getDate, getBigDecimal …. 等做法, 而不用学习一大堆乱七八糟的annotation. 我并不认为加个annotation 就比 加一行代码简洁.

为了测试, 我们加入新的TestController2, 代码如下:

package org.diego.springvue;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController2 {

    @Autowired
    private BackUserRepository repository;
        
    @GetMapping("/v2")
    public void doTest() throws Exception{
        
        String account = DWebUtils.getString("account");

        if(account == null) {
            DWebUtils.jsonResult("请输入账号");
            return;
        }
        
        BackUser user = repository.findByAccount(account);
        if(user == null) {
            DWebUtils.jsonResult("没有这个用户: " + account);
            return;         
        }
        
        DWebUtils.jsonResult(user);
    }
}

你可以用 localhost:8080/v2?account=test 来测试, 两者功能是一样的:

《第1篇:springboot/mongodb/mvc入门》 image.png

乍一看, 获取参数比直接注入方法签名要稍长一点, 但等你的业务复杂了你会知道: 有些页面传回的是date格式字符串, spring 需要加一个 @InitBinder 方法, 然后再要你实现一个自定义属性方法…. 简言之, 类似框架这种东西(不管是spring还是其他), 它提供的功能会满足80%的简单需求, 但是要实现20%比较麻烦的需求, 会让代码非常绕和非常难以理解. 熟悉 servlet 源码和发展史的同学都知道, springmvc 比structs 简单, structs 比直接用jsp简单, jsp又比 servlet 简单… 但这种简单的背后, spring不知不觉引入许多对于新手入门难理解, 对于老手不是刚需的知识(老手都有自己的轮子) . 我不抽象空谈, 至少在获取参数这里, 我引入了一个类, 保留了处理20%复杂情况的可能性.

总结下来, 参数注入我是这样用的:

  1. 如果是简单属性或者简单对象, 用spring注入参数.
  2. 如果是复杂对象(例如json传回来带一堆子List 子对象这种) , 用DWebUtils 直接获取参数处理.

总结

本来想简单总结下, 哪知道写了4小时….. 这篇是热身, 下一篇我们开始港定制的问题.

本文首发于简书, 作者是小肥耙耙, 同时这篇文章也会放到 github上. 请认准作者. :-)

github在这里: https://github.com/yunshichen/spring-vue

这篇文章对应目录是 demo1, 导入eclipse的时候记得是 import as maven 工程.

《第1篇:springboot/mongodb/mvc入门》

    原文作者：萌萌哒小肥他爹
    原文地址: https://www.jianshu.com/p/12ad82067761
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞