1. 背景

本篇将之前实现过的博客系统的后端api改为Spring Restful风格，虽然说是修改，但实际上还是从头到尾实现一下子。

2. 新建项目

打开eclipse，File-New-Other-Dynamic Web Project。

Project name:restfulblog

勾选Generate web.xml deployment descriptor

3. 导入jar包

将之前一直在用的jar包拷贝到WEB-INF/lib目录下。

注意Spring Restful请求都是返回json字符串，所以需要添加转换json的jar包，同时因为要访问数据库，所以添加mysql数据链接的jar包：

后续不再逐一提供jar包下载地址，给大家一个可以搜索的jar包仓库，自行下载吧：https://mvnrepository.com/。

4. 修改web.xml加载spring配置

修改web.xml如下，该配置文件配置了DispatcherServlet，同时指定了容器使用的配置文件springmvc-config.xml。

注意<url-pattern>/*</url-pattern>表示匹配所有请求，此时不再限制请求路径以.do结尾，因为跟restful风格不符合了。

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns="http://xmlns.jcp.org/xml/ns/javaee"

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"

id="WebApp_ID" version="3.1">

<display-name>restfulblog</display-name>

<servlet>

 <servlet-name>springmvc</servlet-name>

 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

 <init-param>

  <param-name>contextConfigLocation</param-name>

  <param-value>/WEB-INF/springmvc-config.xml</param-value>

 </init-param>

 <load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

 <servlet-name>springmvc</servlet-name>

 <url-pattern>/*</url-pattern>

</servlet-mapping>

</web-app>

5. 新建springmvc-config.xml，配置容器信息

在WEB/INF下新建springmvc-config.xml，添加对容器的配置，主要是开启bean自动扫描。另外开启了新的注解<mvc:annotation-driven />为MVC提供额外的支持。

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:mvc="http://www.springframework.org/schema/mvc"

xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-4.0.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

<!-- 指定扫描的包 -->

<context:component-scan

 base-package="org.maoge.restfulblog" />

<!--注解驱动，开启通过注解配置访问路径与方法的匹配 -->

<mvc:annotation-driven />

</beans>

6. 添加数据库操作类DbHelper

注意此处我们还是使用myblog数据库，不再新建数据库了，所以url依然为jdbc:mysql://127.0.0.1:3306/myblog?useUnicode=true&characterEncoding=utf-8

然后注意我们将@Component改为了@Repository，@Repository也是将DbHelper注册为bean，但是它用于持久层上，更加能表明bean的类型，一般跟持久层相关的bean使用@Repository。OK，代码如下：

package org.maoge.restfulblog;

import java.sql.Connection;

import java.sql.DriverManager;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Repository;

//@Component

@Repository//替代@Component

public class DbHelper {

@Value("com.mysql.jdbc.Driver") // 注入driver属性

private String driver;

@Value("jdbc:mysql://127.0.0.1:3306/myblog?useUnicode=true&characterEncoding=utf-8") // 注入数据库url属性

private String url;

@Value("root") // 注入用户名属性

private String username;

@Value("XXX") // 注入密码属性

private String password;

/**

 * 初始化

 */

@PostConstruct // 使用该注解，以便在项目启动时执行数据库驱动加载工作

public void init() {

 try {

  Class.forName(driver);

 } catch (Exception e) {

  // 此处应打印日志

 }

}

/**

 * 获取数据库连接

 */

public Connection getConnection() {

 Connection conn = null;

 try {

  conn = DriverManager.getConnection(url, username, password);

 } catch (Exception e) {

  // 此处应打印日志

 }

 return conn;

}

/**

 * 关闭数据库连接

 */

public void closeConnection(Connection conn) {

 if(conn!=null) {

  try {

   conn.close();

  }catch(Exception e) {

   // 此处应打印日志

  }

 }

}

}

7. 添加博客服务类BlogService与数据对象BlogBo

注意博客服务类的注解，我们将@Component改为了@Service，这个道理同上，@Service用来描述服务层（业务层）的bean。具体代码如下：

package org.maoge.restfulblog;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.util.ArrayList;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

/**

* @theme 服务--博客

* @author maoge

* @date 2020-01-27

*/

//@Component

@Service//替代@Component

public class BlogService {

@Autowired // 自动注入dbHelper组件

private DbHelper dbHelper;

/**

 * 获取博客列表

 */

public List<BlogDo> getBlogList() {

 List<BlogDo> blogList = new ArrayList<BlogDo>();

 Connection conn = null;

 try {

  conn = dbHelper.getConnection();

  String sql = "select * from blog";

  PreparedStatement stmt = conn.prepareStatement(sql);

  ResultSet rs = stmt.executeQuery();

  while (rs.next()) {

   BlogDo blog = new BlogDo();

   blogList.add(blog);

   blog.setAuthor(rs.getString("author"));

   blog.setContent(rs.getString("content"));

   blog.setId(rs.getLong("id"));

   blog.setTitle(rs.getString("title"));

  }

 } catch (Exception e) {

  // 此处应打印日志

 } finally {

  dbHelper.closeConnection(conn);

 }

 return blogList;

}

/**

 * 按id获取博客信息

 */

public BlogDo getBlogById(Long id) {

 BlogDo blog=null;

 Connection conn = null;

 try {

  conn = dbHelper.getConnection();

  String sql = "select * from blog where id=?";

  PreparedStatement stmt = conn.prepareStatement(sql);

  stmt.setLong(1, id);

  ResultSet rs = stmt.executeQuery();

  if (rs.next()) {

   blog=new BlogDo();

   blog.setAuthor(rs.getString("author"));

   blog.setContent(rs.getString("content"));

   blog.setId(rs.getLong("id"));

   blog.setTitle(rs.getString("title"));

  }

 } catch (Exception e) {

  // 此处应打印日志

 } finally {

  dbHelper.closeConnection(conn);

 }

 return blog;

}

/**

 * 新增博客

 */

public int addBlog(BlogDo blog) {

 Connection conn = null;

 try {

  conn = dbHelper.getConnection();

  String sql = "insert into blog(author,content,title)values(?,?,?)";

  PreparedStatement stmt = conn.prepareStatement(sql);

  stmt.setString(1, blog.getAuthor());

  stmt.setString(2, blog.getContent());

  stmt.setString(3, blog.getTitle());

  return stmt.executeUpdate();

 } catch (Exception e) {

  // 此处应打印日志

  return 0;

 } finally {

  dbHelper.closeConnection(conn);

 }

}

/**

 * 根据博客id更新博客信息

 */

public int updateBlog(BlogDo blog) {

 Connection conn = null;

 try {

  conn = dbHelper.getConnection();

  String sql = "update blog set author=?,content=?,title=? where id=?";

  PreparedStatement stmt = conn.prepareStatement(sql);

  stmt.setString(1, blog.getAuthor());

  stmt.setString(2, blog.getContent());

  stmt.setString(3, blog.getTitle());

  stmt.setLong(4, blog.getId());

  return stmt.executeUpdate();

 } catch (Exception e) {

  // 此处应打印日志

  return 0;

 } finally {

  dbHelper.closeConnection(conn);

 }

}

/**

 * 根据博客id删除对应博客

 */

public int deleteBlog(Long id) {

 Connection conn = null;

 try {

  conn = dbHelper.getConnection();

  String sql = "delete from blog where id=?";

  PreparedStatement stmt = conn.prepareStatement(sql);

  stmt.setLong(1, id);

  return stmt.executeUpdate();

 } catch (Exception e) {

  // 此处应打印日志

  return 0;

 } finally {

  dbHelper.closeConnection(conn);

 }

}

}

8. BlogController实现Restful API

重点来了，之前的控制器中，我们返回的都是网页，而在Restful的风格下，我们需要返回json。

SpringMVC可以通过对方法添加@ResponseBody注解，将返回的对象转换为json，完事了！就是这么简单，这就是极简的设计理念，完美。还可以更加简单，如果一个控制器中提供的都是Restful API方法，则可以直接将@Controller改写为@RestController，这样控制下所有API方法返回的对象都会被自动转换为json，比简单还简单，追求极致。

下面具体实现下，注意下注释：

package org.maoge.restfulblog;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.DeleteMapping;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.PutMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RestController;

/**

* @theme 控制器--博客

* @author maoge

* @date 2020-01-28

*/

@RestController // 通过该注解，第一将BlogController注册为控制器，第二将其中方法返回值转换为json

public class BlogController {

@Autowired // 自动装配blogService

private BlogService blogService;

/**

 * 查询博客信息

 * 1、@GetMapping表示可以使用get方法请求该api

 * 2、"/blog/{id}"表示请求路径为/blog/{id}的形式，其中{id}为占位符

 * 3、@PathVariable("id")表示将占位符{id}的值传递给id

 * 4、也就是说/blog/123请求的话，会将123传递给参数id

 */

@GetMapping("/blog/{id}")

public BlogDo getOne(@PathVariable("id") long id) {

 return blogService.getBlogById(id);

}

/**

 * 查询博客列表，使用get方法

 */

@GetMapping("/blog")

public List<BlogDo> getList(){

 return blogService.getBlogList();

}

/**

 * 新增博客

 * 1、@PostMapping表示使用post方法

 * 2、@RequestBody表示将请求中的json信息转换为BlogDo类型的对象信息，该转换也是由SpringMVC自动完成的

 */

@PostMapping("/blog")

public void add(@RequestBody BlogDo blog) {

 blogService.addBlog(blog);

}

/**

 * 修改博客

 * 实际上此处也可以不在路径中传递id，而是整个使用json传递对象信息，但是我查询了一些文档，貌似使用路径传递id更加规范一些，此处不用纠结

 */

@PutMapping("/blog/{id}")

public void update(@PathVariable("id") long id,@RequestBody BlogDo blog) {

 //修改指定id的博客信息

 blog.setId(id);

 blogService.updateBlog(blog);

}

/**

 * 删除博客

 */

@DeleteMapping("/blog/{id}")

public void delete(@PathVariable("id") long id) {

 blogService.deleteBlog(id);

}

}

9. 浏览器简单测试

由于浏览器地址栏直接输入的请求是get类型的，所以我们可简单的从浏览器测试下查询博客信息，打开谷歌浏览器，访问http://127.0.0.1:8080/restfulblog/blog/1,返回如下信息：

可见已成功返回json字符串。

10.总结

当后端可以提供规范的API，以restful风格提供服务接口，而返回值采用规范的json格式，是一个巨大的提高。

后续我们可以采用这种风格来开发web应用，前端负责界面渲染操作交互，后端提供API接口，前后端分离，更加优雅高效。