Java 校招面经合集

「爱情、让人受尽委屈。」 2022-05-14 05:23 251阅读 0赞

# 小博Java面试路上的点点滴滴 #

<table> 
 <thead> 
  <tr> 
   <th>篇章</th> 
   <th>小博博客地址</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Java 面试之基础篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79772903" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之框架篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79772419" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之数据结构篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79773794" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之JVM篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79773328" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之多线程篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79772952" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之数据库篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79773362" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之计算机网络篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79773863" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之操作系统篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79773885" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之算法篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79773907" rel="nofollow">点击前往</a></td> 
  </tr> 
  <tr> 
   <td>Java 面试之附加篇</td> 
   <td><a href="https://blog.csdn.net/u012102104/article/details/79773921" rel="nofollow">点击前往</a></td> 
  </tr> 
 </tbody> 
</table>

# 小博Spring Boot 入门教程 #

相信小伙伴们在使用 Spring 或 SpringMVC 的过程中，或多或少会被各种配置问题所牵绊，这些配置不仅徒增工作量，而且在跨平台部署时容易出现问题。因此，Spring Boot 应运而生，它集成了大量常用的第三方库配置（例如 Jackson、JDBC、MongoDB、Redis、Mail 等等），这些第三方库几乎都可以零配置的开箱即用，可以帮助我们快速搭建一个项目，从而让开发者能够更加专注于业务逻辑。  
  Spring Boot 的优点及特性，就不再逐一罗列了，针对 Spring Boot 的初学者，让我们先快速学会怎么用。

## 版本列表 ##

<table> 
 <thead> 
  <tr> 
   <th align="center">名称</th> 
   <th align="center">版本</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">JDK</td> 
   <td align="center">1.8.0</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">MySQL</td> 
   <td align="center">5.7.15</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">IDEA Ultimate</td> 
   <td align="center">2017.2</td> 
   <td align="center">不能用社区版</td> 
  </tr> 
  <tr> 
   <td align="center">Maven</td> 
   <td align="center">3.5.2</td> 
   <td align="center">可用阿里仓库提速</td> 
  </tr> 
  <tr> 
   <td align="center">Spring Boot</td> 
   <td align="center">1.5.9</td> 
   <td align="center"></td> 
  </tr> 
 </tbody> 
</table>

## 快速构建项目 ##

关于 Spring Boot 项目的构建，IDEA 为我们提供了良好的支持，在 IDEA 中 New→Project→Spring Initializr→Next→Next（可自己填写相关信息）→选中 Web 栏目的 Web 依赖→Next→Finish（可自己填写相关信息），一个简单 Spring Boot 项目搭建好了。没错不用惊讶，搭好了。接下来我们看看 IDEA 自动生成目录结构（以读者填写的具体信息为准）。

*  main
    
     *  java
        
         *  xin.chung.springboot
            
             *  SpringbootApplication.java（项目入口文件）
     *  resources
        
         *  static（静态资源包）
         *  templates（页面模板包）
         *  application.properties（项目属性配置文件）
 *  test
    
     *  java
        
         *  xin.chung.springboot
            
             *  SpringbootApplicationTests.java（测试文件）

IDEA 自动为我们生成了几个文件，其中 application.properties 文件为项目属性配置文件，一般包含服务器、数据库、日志等方面的配置，以及一些自定义的属性。SpringbootApplicationTests.java 是 JUnit 测试类，用来进行开发过程中的单元测试。这两类文件，留待后面详细介绍。而至于这个 SpringbootApplication.java 文件，它其实是项目的入口文件，内容也非常简单，如下：

@SpringBootApplication
    public class SpringbootApplication { 
        public static void main(String[] args) { 
            SpringApplication.run(SpringbootApplication.class, args);
        }
    }

当我们运行这个类或主方法时，框架就会自动为我们开启服务。若见日志打印如下，说明启动成功，从日志可以看到，我们的 Tomcat 8080 端口已经准备就绪。

.   ____          _            __ _ _
     /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
    ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
     \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
      '  |____| .__|_| |_|_| |_\__, | / / / /
     =========|_|==============|___/=/_/_/_/
     :: Spring Boot ::        (v1.5.9.RELEASE)
    
    ······
    
    Tomcat started on port(s): 8080 (http)
    Started SpringbootApplication in 4.694 seconds (JVM running for 7.789)

> 关于项目构建途径或项目启动的其他方式，大家可在读者圈一起交流。

## 项目属性配置 ##

### **单元测试** ###

在后续话题开始之前，我们有必要先探讨下单元测试。以往我们写一段测试代码，有一个前置步骤：用`ClassPathXmlApplicationContext`装载上下文，然后用`ApplicationContext`对象获取 Bean 实例。接下来，才能进行我们的测试代码编写。  
  而在 Spring Boot 中，极大简化了测试代码，它为我们提供了`@RunWith`注解和`@SpringBootTest`注解分别用来指定测试运行类和运行 Spring Boot 基础测试环境。此时，你可以直接使用`@Resource`或`@Autowired`注入所需 Bean 并使用，示例如下：

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class PropertiesTests { 
        @Resource
        private DemoService demoService;//仅作展示，还未编写
    
        @Test
        public void test() { 
            System.out.println(demoService.getDemo().toString());
        }
    }

> 由于单元测试贯穿本文，所以每个章节都会在相应的地方讨论 Spring Boot 中 JUnit 的具体使用方法，此处只写出最简单的使用示例。

### **属性配置** ###

在前面提到过的 application.properties 文件中，我们可以进行一些项目的配置，也可以自定义一些项目所需要的属性参数然后用`@Value`注解在Java文件中引用，例如：

# Server 服务相关
    server.port=8080
    server.context-path=/demo
    # Log 日志相关
    logging.path=/var/logs
    logging.file=demo.log
    # Other 自定义
    author=chung
    addr=http://example.cn/activity/5a444c451f6ee91a25846ac1

我们可以编写如下测试代码，验证`.properties`文件中的值是否能被我们在 Java 文件中所使用，至于打印结果我就不贴出来了。

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class PropertiesTests { 
        @Value("${author}")
        private String author;
        @Value("${addr}")
        private String addr;
    
        @Test
        public void test() { 
            System.out.println("author:" + author + "--addr:" + addr);
        }
    }

实际上，我们也可以使用 YAML 作为项目的配置文件，这种语言更加简洁明了。以上`.properties`文件，可等价如下`.yml`文件（**切记`:`后面的空格不能少，同时注意每行的缩进**）：

# Server 服务相关
    server:
      port: 8080
      context-path: /demo
    # Log 日志相关
    logging:
      path: /var/logs
      file: demo.log
    # Other 自定义
    author: chung
    addr: http://example.cn/activity/5a444c451f6ee91a25846ac1

但是以上两种写法都有同一个弊端：项目里面自定义配置项往往会有很多，频繁使用`@Value`注入将给项目的后期维护带来极大不便。这个时候，我们就可以建立一个属性对象，利用`@ConfigurationProperties`注解来绑定属性，有效简化繁杂的注入操作。例如：

# Other
    paper:
      author: chung
      addr: http://example.cn/activity/5a444c451f6ee91a25846ac1

@Component
    // prefix对应配置文件中的前缀
    @ConfigurationProperties(prefix = "paper")
    public class Paper { 
        private String author;
        private String addr;
    	
        /***省略Getter Setter***/
    }

同理，我们可以编写如下测试代码，验证这种属性对象的方式能否正常使用。

@Resource
    private Paper paper;
    
    @Test
    public void test() { 
        System.out.println("author:" + paper.getAuthor() + " addr:" + paper.getAddr());
    }

可以看到，当属性越来越多，我们利用对象的方式优势也就越大，而至于`.properties`和`.yml`选哪种，就看个人喜好了。

## 控制器基本用法 ##

### **关于 Controller** ###

讨论完了项目的属性配置，让我们探讨一下在 Spring Boot 中如何使用控制器。在 Spring Boot Controller 的编码中，我们常用到的注解如下：

*  标注控制层组件的注解`@Controller`、`@RestController`
 *  配置URL映射的注解`@RequestMapping`
 *  获取参数的注解`@PathVariable`(URL中)、`@RequestParam`（HTTP 请求中）
 *  校验参数的注解`@Valid`

相信以上那些，大家或多或少有点熟悉，其实还有一些简洁的组合注解，这些注解在配合使用`RESTful API`时，会非常优雅非常有逼格：

*  `@GetMapping("")`
 *  `@PostMapping("")`
 *  `@PutMapping("")`
 *  `@DeleteMapping("")`

而实际上，`XXXMapping("YYY")` 和 `@RequestMapping(value = "YYY",method = RequestMethod.XXX)`没有区别，点进源码一切你就会恍然大悟。  
  看完这些注解，接下来我们瞧瞧怎么把它们用进控制器。先拿`@Controller`和`@RestController`来说，如果使用`@Controller`注解，表示控制器返回的是模板，而使用`@RestController`注解，则表示返回的可能是 JSON 或文本等等。  
  见如下代码，编写完成后启动项目，浏览器访问 [http://localhost:8080/demo/say][http_localhost_8080_demo_say]，你会看到 Hello World！，就是这么简单粗暴，什么 Jackson 配置之类的，让框架替你解决就好了。

@RestController
    public class DemoController { 
        @RequestMapping("/say")
        public String sayHello() { 
            return "Hello World!";
        }
    }

> **注意**：
> 
>  *  项目配置文件选择 application.properties 与 application.yml 之一即可（删掉其中一个）
>  *  若上一章中没有配置 server.context-path=/demo 或者 context-path: /demo，则应访问[http://localhost:8080/say][http_localhost_8080_say]
>  *  添加完依赖后，右键 pom.xml→Maven→ Reimport，重新导入

至于`@Controller`注解，我们常用来和模板引擎`Thymeleaf`一起使用，这里我们不讨论模板引擎，简单看看`@Controller`的使用：

1.  在 pom 文件中导入`Thymeleaf`依赖（IDEA 的提示功能很强大，好好利用）
2.  编写 Controller 代码，返回 hello 页面模板
3.  编写页面模板 hello.html

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>

@Controller
    public class DemoController { 
        @RequestMapping("/say")
        public String sayHello() { 
            return "hello";
        }
    }

<html>
        <head>
            <title>Hello</title>
        </head>
        <body>
            <p>Hello World!</p>
        </body>
    </html>

同样，启动项目，访问 [http://localhost:8080/demo/say][http_localhost_8080_demo_say]，我们发现，Hello World! 还是那个 Hello World!，但是它们背后的故事可就大不相同了。

> 实际上，我们点进源码就会发现，`@RestController`其实就是`@ResponseBody`＋`@Controller`，玩到后来还是被套路了…

再来看看控制器中其它注解的使用，就拿那几个代表性的传说中和`RESTful`完美搭配的那几个家伙为例，我们在`@RestController`注解标识的控制器中，编写如下方法：

@GetMapping("/getPaper/{id}")
    public Paper getPaper(@PathVariable String id) { 
        Paper paper = new Paper(null, "chung", new Date(), "http://example.cn/activity/" + id);
        return paper;
    }

其中`@GetMapping`表示此方法仅响应GET请求，其请求路径也附在括号内。而`@PathVariable`则获取了路径中的一个参数，这个参数在路径中用大括号标注。  
  还要再编写实体类 Paper 如下：

public class Paper { 
        private Integer id;
        private String author;
        private Date date;
        private String url;
    
        /***省略NoArgsConstructor AllArgsConstructor***/
        /***省略Getter Setter***/
    }

此时重启项目，再访问[http://localhost:8080/demo/getPaper/5a444c451f6ee91a25846ac1][http_localhost_8080_demo_getPaper_5a444c451f6ee91a25846ac1]，就可以看到框架已经自动帮我们把对象转换为 JSON 显示在了浏览器，如下：

{ 
        "id": null,
        "author": "chung",
        "date": 1514896266452,
        "url": "http://example.cn/activity/5a444c451f6ee91a25846ac1"
    }

在上面的例子中，我们用到了`@PathVariable`注解，它可以帮助我们从路径中获取参数。而与其不同的`@RequestParam`注解，它可以帮助我们从请求中获取参数，例如：

@GetMapping("/getPaper")
    public Paper getPaperByRequestParam(@RequestParam(defaultValue = "5a444c451f6ee91a25846ac1") String id) { 
        Paper paper = new Paper(null, "chung", new Date(), "http://example.cn/activity/" + id);
        return paper;
    }

此时重启项目，访问[http://localhost:8080/demo/getPaper?id=5a444c451f6ee91a25846ac1][http_localhost_8080_demo_getPaper_id_5a444c451f6ee91a25846ac1]也将得到同样的结果。

> **注意**：如果缺少`?id=*`这段，访问时将会报错，为避免这样的问题，我们可以设置默认值`@RequestParam(defaultValue = "5a444c451f6ee91a25846ac1")`。

### **单元测试** ###

在上一章我们讨论了 Spring Boot 中 JUnit 的简单写法，其实，我们可以使用 IDEA 插入单元测试，这样更加便捷，省去了我们新建包、新建文件、新建类的时间，步骤如下：

1.  在代码中选中`DemoController`右键→Go To→Test→Create New Test→勾选需要测试的方法→OK；
2.  这时 IDEA 已经在 test 目录下相应的包内为我们创建好了`DemoControllerTest`文件；
3.  我们使用 Spring 提供的`MockMvc`类来完成测试，用`@AutoConfigureMockMvc`注解让框架自动配置，并使用`@Resource`注入 MockMvc；
4.  编写接口测试代码并打印，测试代码及结果如下两段：

@RunWith(SpringRunner.class)
    @SpringBootTest
    @AutoConfigureMockMvc
    public class DemoControllerTest { 
        @Resource
        private MockMvc mockMvc;
    
        @Test
        public void getPaperByRequestParam() throws Exception { 
            mockMvc.perform(
                MockMvcRequestBuilders
                    .get("/getPaper")
                    .param("id", "5a444c451f6ee91a25846ac1")
            )
                .andDo(print())
                .andReturn();
        }
    }

MockHttpServletResponse:
           Status = 200
    Error message = null
          Headers = { Content-Type=[application/json;charset=UTF-8]}
     Content type = application/json;charset=UTF-8
             Body = { "author":"chung","date":1514893447007,"url":"http://example.cn/activity/5a444c451f6ee91a25846ac1"}
    Forwarded URL = null
    Redirected URL = null
          Cookies = []

测试结果限于篇幅，我只贴出了一小部分，在真实测试日志中我们可以看到各种详细的数据，包括返回页面 Body 体的具体内容也打印了出来。这样的测试代码简单优雅而又霸气十足有木有。

## 数据库基本操作 ##

### **关于 Repository** ###

看完了与前端交互的部分，我们来讨论下 Spring Boot 在数据库操作方面，提供了哪些逆天的功能。  
  提到持久化，不得不提`JPA(Java Persistence API)`，JPA 是一种规范或者说标准，`Hibernate`很好的实现了它，而我们使用到的`Spring-Data-JPA`则是`Spring`对`Hibernate`的整合。探讨实例之前，我们先做好如下准备：  
  添加`Spring-Data-JPA`的依赖如下，**注意：spring-boot-starter-data-jpa 千万不要写错**。

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

做好数据库相关配置，URL 和用户名密码等。其中`ddl-auto: update`表示对于表结构，有则更新，无则创建，`show-sql: true`则表示在控制台打印执行的SQL语句。

spring:
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/dbgirl
        username: root
        password: root
      jpa:
        hibernate:
          ddl-auto: update
        show-sql: true

我们最好还是自己提前建好相关数据库和表，SQL 语句如下：

CREATE TABLE `tbl_paper` (
      `id` int(8) unsigned NOT NULL AUTO_INCREMENT,
      `author` varchar(6) DEFAULT '',
      `date` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
      `url` varchar(255) DEFAULT '',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

此时，对与前面提到的 Paper 实体类，我们又有必要进行一定的改造，看下面这段，其中`@Entity`注解表示实体类与数据库表的映射关系，`@Id`标识主键，`@GeneratedValue`标识生成规则，默认为AUTO，这些都是常见的了。

@Entity(name = "tbl_paper")
    public class Paper { 
        @Id
        @GeneratedValue
        private Integer id;
        private String author;
        private Date date;
        private String url;
    
        /***省略NoArgsConstructor AllArgsConstructor***/
        /***省略Getter Setter***/
        /***省略Override toString***/
    }

完成了以上步骤，接下来的重头戏，当然是我们的DAO层代码啦。你没看错，仅仅只是将接口继承自`JpaRepository`就好了，<1,2>中，1为实体类，2为主键类型。至此，我们便可以进行简单的数据库CURD操作了，简单不简单？粗暴不粗暴？心动不心动？

public interface PaperRepository extends JpaRepository<Paper, Integer> { 
    }

### **单元测试** ###

话说回来，还是来测试测试DAO层代码吧。首先我们提前插入几条测试数据到到数据库中备用：

INSERT INTO `tbl_paper` VALUES ('1', 'chung', '2018-01-02 21:07:10', 'http://example.cn/activity/5a444c451f6ee91a25846ac1');
    INSERT INTO `tbl_paper` VALUES ('2', 'chung', '2018-01-02 21:07:33', 'http://example.cn/activity/5a444c451f6ee91a25846ac1');
    INSERT INTO `tbl_paper` VALUES ('3', 'charle', '2018-01-02 21:07:47', 'http://example.cn/activity/5a444c451f6ee91a25846ac1');

接着，根据提到过的方法，自动生成测试文件，并编写代码如下，其中`findAll()`是框架为我们提供的查询所有数据的方法，它会返回一个实体对象的List。

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class PaperRepositoryTest { 
        @Resource
        private PaperRepository paperRepository;
    
        @Test
        public void testFindAll(){ 
            List<Paper> all = paperRepository.findAll();
            System.out.println(all.toString());
        }
    }

我们可以看看测试结果，打印出的内容正是我们所插入的3条记录。

[Paper{id=1, author='chung', date=2018-01-02 21:07:10.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}, 
    Paper{id=2, author='chung', date=2018-01-02 21:07:33.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}, 
    Paper{id=3, author='charle', date=2018-01-02 21:07:47.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}]

你也许会问，大工程里面，这么复杂的逻辑，仅仅使用框架提供的能够满足特定需求吗。不要怕，忘了告诉你，更逆天的是，JPA也支持自定义的数据库操作甚至自定义SQL语句。举个例子如下，简简单单定义好方法之后，你就可以使用它来根据`author`查找所有满足条件的`Paper`了。**特别要注意的是**，这个类和方法的名字可不是随便起的，它们的名称必须遵循`Spring Data JPA`的命名规范，而关于这个命名规范，大家可以自行查阅资料，就不在此赘述了。

public interface PaperRepository extends JpaRepository<Paper, Integer> { 
        List<Paper> findPapersByAuthor(String author);
    }

同样，我们来测试下，这么简单的定义了一个方法之后，是否真的能够如愿满足我们的需求：

@Test
    public void findPapersByAuthor() throws Exception { 
        List<Paper> byAuthor = paperRepository.findPapersByAuthor("chung");
        System.out.println(byAuthor.toString());
    }

可以从打印出的内容中很明显的看到，这一次只有两个`author`值为`chung`的记录，说明我们的写法是可以完成查询特定条件的内容的。

以上我们只是简单地讨论了JPA的使用，其他的CURD操作，大家可以举一反三。实际上JPA的功能远不止如此，我们可以自己写实现类来自定义操作，也可以自己写`SQL`语句配合`@Query`来查询，基本上来说，只有你想不到，没有它办不到。是不是霸气侧漏？

## 事务管理简介 ##

### **关于Service** ###

前面我们讨论了和前端打交道的控制器，也讨论了和数据库打交道的持久层，是时候讨论业务层了。与Controller类似，Service类，也有一个自己的注解，叫做`@Service`，配合我们曾编写过的`PaperRepository`，我们可以编写一个简单的Service Demo，其中使用到了PaperRepository的`save()`，这个方法也是框架为我们提供的，代码如下：

@Service
    public class PaperService { 
        @Resource
        private PaperRepository paperRepository;
    
        public void savePaper() { 
            Paper paper1 = new Paper(null, "Zhang", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");
            paperRepository.save(paper1);
            Paper paper2 = new Paper(1, "ZhangChong", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");
            paperRepository.save(paper2);
        }
    }

这个时候我们测试`PaperService`的`savePaper()`，代码如下：

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class PaperServiceTest { 
        @Resource
        private PaperService paperService;
    
        @Test
        public void savePaper() throws Exception { 
            paperService.savePaper();
        }
    }

测试完成后可以发现，数据库内只增加了一条记录。没关系，还记得我们前面设计数据库的时候，特意将`author`字段长度设置为6，这里由于我们插入的第二个实体对象`author`字段超长不符要求，所以导致第二条数据插入失败了，但是这并不影响我们判断：框架为我们提供的`save()`确实可用，而且一般情况下，添加异常处理之后，简单的Service层代码这么写，是没有问题的。

### **关于事务管理** ###

很多时候，我们的业务层逻辑复杂，很多操作都需要在同一事务中进行，这个时候，`@Transactional`注解就派上了用场。  
它可以配置事务传播特性，默认是`REQUIRED`，`@Transactional`的使用也非常简单，你只需要在你的方法上加上这个注解便可：

@Service
    public class PaperService { 
        @Resource
        private PaperRepository paperRepository;
    
        @Transactional
        public void savePaper() { 
            Paper paper1 = new Paper(null, "Zhang", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");
            paperRepository.save(paper1);
            Paper paper2 = new Paper(1, "ZhangChong", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");
            paperRepository.save(paper2);
        }
    }

依旧使用`savePaper()`测试方法，只不过这一次我们测试的方法添加了`@Transactional`注解。

Caused by: com.mysql.jdbc.MysqlDataTruncation: Data truncation: Data too long for column 'author' at row 1
        at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3971)
        at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3909)
        at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:2527)
        at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2680)
        at com.mysql.jdbc.ConnectionImpl.execSQL
        ......

测试完我们发现，这一次日志中报错了，错误信息为`Data too long for column 'author' at row 1`。我们再去数据库查看，发现并没有任何新增的记录。对比上一次的测试结果可以知道，`@Transactional`将我们的两次插入操作置于同一事务中，当第二条数据插入失败时，进行了回滚操作，所以数据库不会有新增的记录。

## 拓展进阶 ##

### **表单验证** ###

在接口开发的过程中，我们经常需要对提交的各种表单数据进行验证，这个时候，我们可以借助`@Valid`注解来轻松达到目的。话不多说，我们直接来看。再次改造Paper实体类，在`author`字段上添加`@Size(min = 1, max = 6)`，他为我们限定了`author`字段的长度为1-6，在`url`字段上添加`@NotNull(message = "url不能为空")`，它为我们限制了url不能为null，并定义了错误信息。

@Entity(name = "tbl_paper")
    public class Paper { 
        @Id
        @GeneratedValue
        private Integer id;
    
        @Size(min = 1, max = 6)
        private String author;
    
        private Date date;
    
        @NotNull(message = "url不能为空")
        private String url;
    
        /***省略NoArgsConstructor AllArgsConstructor***/
        /***省略Getter Setter***/
        /***省略Override toString***/
    }

接下来在控制器中，我们这么使用`@Valid`注解：

@RestController
    public class DemoController { 
        @Resource
        private PaperService paperService;
    
        @PostMapping("/paper")
        public Object addPaper(
            @Valid Paper paper,
            BindingResult bindingResult
        ) { 
            if (bindingResult.hasErrors()) { 
                return bindingResult.getFieldError().getDefaultMessage();
            } else { 
                return paperService.savePaper(paper);
            }
        }
    }

以上`@Valid`伴随的`BindingResult`对象中，携带校验的各种信息。我们可以利用这个对象很方便的判定表单是否验证通过。让我们测试测试：

@RunWith(SpringRunner.class)
    @SpringBootTest
    @AutoConfigureMockMvc
    public class DemoControllerTest { 
        @Resource
        private MockMvc mockMvc;
    
        @Test
        public void testAddPaper() throws Exception { 
            mockMvc.perform(
                MockMvcRequestBuilders
                        .post("/paper")
                        .param("author", "ZhangChong")
                        .param("date", String.valueOf(new Date()))
                        .param("url", "http://example.cn/activity/5a444c451f6ee91a25846ac1")
            )
                .andDo(print())
                .andReturn();
        }
    }

从上面的测试代码中看到，我们故意调用接口插入一条不符规则的记录。然后从下面测试日志的`Body = size must be between 1 and 6`可以看出，提交的参数校验失败了，最后再去看看数据库，发现并没有成功添加记录。这一系列的现象或结果说明一个很简单的道理：`@Valid`为我们立下了汗马功劳，简化了我们各种判断与校验的工作。

MockHttpServletResponse:
           Status = 200
    Error message = null
          Headers = {Content-Type=[text/plain;charset=UTF-8], Content-Length=[28]}
     Content type = text/plain;charset=UTF-8
             Body = size must be between 1 and 6
    Forwarded URL = null
    Redirected URL = null
          Cookies = []

[http_localhost_8080_demo_say]: http://localhost:8080/demo/say
[http_localhost_8080_say]: http://localhost:8080/say
[http_localhost_8080_demo_getPaper_5a444c451f6ee91a25846ac1]: http://localhost:8080/demo/getPaper/5a444c451f6ee91a25846ac1
[http_localhost_8080_demo_getPaper_id_5a444c451f6ee91a25846ac1]: http://localhost:8080/demo/getPaper?id=5a444c451f6ee91a25846ac1