文章目录
- 5.1 Maven 和 Gradle - 构建你的堡垒
- 5.1.1 基础知识
- 5.1.2 重点案例：使用 Maven 构建一个简单的 Java 应用
- 5.1.3 拓展案例 1：使用 Gradle 构建一个 Spring Boot 应用
- 5.1.4 拓展案例 2：使用 Maven 管理多模块项目
- 5.2 Spring 框架 - 你的魔法棒
- 5.2.1 基础知识
- 5.2.2 重点案例：创建一个简单的 Spring Boot Web 应用
- 5.2.3 拓展案例 1：访问数据库
- 5.2.4 拓展案例 2：添加安全性
- 5.3 JUnit 测试 - 保卫你的堡垒
- 5.3.1 基础知识
- 5.3.2 重点案例：测试一个简单的计算器类
- 5.3.3 拓展案例 1：使用 Mock 对象测试
- 5.3.4 拓展案例 2：参数化测试
5.1 Maven 和 Gradle - 构建你的堡垒
在 Java 的世界里，Maven 和 Gradle 就像是构建和维护你的代码堡垒的得力助手。它们管理依赖、编译代码、运行测试和打包应用，确保你的开发过程既高效又无痛。
5.1.1 基础知识
-
Maven：Maven 使用基于 XML 的
pom.xml文件来管理项目的构建、报告和文档。它遵循"约定优于配置"的原则，意味着如果你遵循它的默认配置，就几乎不需要做额外的配置工作。 -
Gradle：Gradle 是一个基于 Groovy 的构建工具，使用
build.gradle文件来编写构建脚本。它结合了 Maven 的约定优于配置的原则和 Ant 的灵活性，同时引入了基于 Groovy 的 DSL（领域特定语言），使得构建脚本更加简洁和强大。
5.1.2 重点案例：使用 Maven 构建一个简单的 Java 应用
假设我们要创建一个简单的 Java 应用，这个应用依赖于 Google Guava 库。
pom.xml:
<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>com.example</groupId>
<artifactId>my-application</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>30.1-jre</version>
</dependency>
</dependencies>
</project>
这个 pom.xml 文件定义了一个项目和一个依赖。Maven 会自动下载和管理这个依赖，让你可以轻松使用 Guava 库的功能。
5.1.3 拓展案例 1：使用 Gradle 构建一个 Spring Boot 应用
Spring Boot 应用的构建和部署可以通过 Gradle 来简化。假设我们要创建一个简单的 Spring Boot Web 应用。
build.gradle:
plugins {
id 'org.springframework.boot' version '2.4.1'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
}
test {
useJUnitPlatform()
}
这个 build.gradle 文件使用了 Spring Boot Gradle 插件来简化 Spring 应用的构建和打包过程。
5.1.4 拓展案例 2：使用 Maven 管理多模块项目
在大型项目中，你可能需要将你的项目分解成多个模块，每个模块负责不同的任务。Maven 支持多模块项目的构建，让你可以在一个父项目中管理多个子项目。
父项目的 pom.xml:
<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>com.example</groupId>
<artifactId>parent-project</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<modules>
<module>module1</module>
<module>module2</module>
</modules>
</project
>
每个子模块都会有自己的 pom.xml 文件，但它们都是父项目的一部分，可以共享依赖和插件配置。
通过这些案例，我们可以看到 Maven 和 Gradle 如何成为 Java 开发中不可或缺的工具，帮助你高效地管理项目依赖、构建和打包应用。无论是简单的单一应用还是复杂的多模块项目，它们都能让你的开发过程更加顺畅。现在，穿上你的斗篷，开始你的构建之旅吧！
5.2 Spring 框架 - 你的魔法棒
Spring框架，就像是赋予了Java开发者超能力的魔法棒，让复杂的企业级应用开发变得简单而优雅。它提供了一套全面的编程和配置模型，支持现代Java应用的全方位开发需求。
5.2.1 基础知识
-
IoC 容器（Inversion of Control）：Spring的核心是其IoC容器，它管理应用中对象的创建、配置和管理。通过依赖注入（DI），对象之间的依赖关系在运行时自动解决，减少了代码耦合。
-
AOP（面向切面编程）：Spring支持AOP，允许开发者定义横切关注点（如日志、事务管理），从而提高模块化。
-
Spring MVC：一个用于构建Web应用的强大框架，基于Model-ViewController（模型-视图-控制器）架构。
-
Spring Boot：简化了基于Spring的应用开发，提供了大量自动配置，使得项目启动和配置更加容易。
5.2.2 重点案例：创建一个简单的 Spring Boot Web 应用
假设我们要创建一个简单的Web应用，用于返回“Hello, World!”消息。
Spring Boot 应用主类:
@SpringBootApplication
public class HelloWorldApplication {
public static void main(String[] args) {
SpringApplication.run(HelloWorldApplication.class, args);
}
@RestController
public static class HelloWorldController {
@GetMapping("/")
public String hello() {
return "Hello, World!";
}
}
}
在这个例子中，@SpringBootApplication启动了Spring的自动配置和Spring应用上下文。HelloWorldController是一个简单的REST控制器，通过@RestController和@GetMapping注解定义，当访问根URL时，返回“Hello, World!”。
5.2.3 拓展案例 1：访问数据库
使用Spring Data JPA简化数据库操作，自动实现数据访问层。
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String name;
// Getters and setters omitted for brevity
}
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
@RestController
@RequestMapping("/users")
public class UserController {
@Autowired
private UserRepository userRepository;
@GetMapping
public List<User> listUsers() {
return userRepository.findAll();
}
}
在这个例子中，User类通过@Entity注解映射到数据库表。UserRepository接口继承JpaRepository，提供了丰富的数据访问方法。UserController通过注入UserRepository来访问用户数据，并通过REST API暴露出来。
5.2.4 拓展案例 2：添加安全性
使用Spring Security添加基本的认证和授权。
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.anyRequest().authenticated()
.and()
.formLogin()
.and()
.httpBasic();
}
}
在这个例子中，WebSecurityConfig类通过@EnableWebSecurity注解启用了Web安全性，并通过重写configure方法配置了HTTP请求的安全性。所有的请求都需要认证，支持表单登录和HTTP基本认证。
通过这些案例，我们可以看到Spring框架和Spring Boot如何让企业级应用的开发变得更加简单和高效。从创建RESTful服务、操作数据库到加强安全性，Spring都提供了强大的支持。掌握Spring，让你的Java开发之旅充满魔法和可能！
5.3 JUnit 测试 - 保卫你的堡垒
在软件开发的世界中，写代码就像是建造一座堡垒，而JUnit测试则是那些守卫堡垒的勇士，确保每一块石头都牢固可靠。JUnit是Java开发中最流行的单元测试框架之一，它提供了一套简单的注解和断言来帮助开发者编写和执行测试，从而确保代码的质量和稳定性。
5.3.1 基础知识
-
基本注解：
@Test：标记一个方法为测试方法。@Before/@BeforeEach：在每个测试方法执行前运行。@After/@AfterEach：在每个测试方法执行后运行。@BeforeClass/@BeforeAll：在所有测试开始前只运行一次。@AfterClass/@AfterAll：在所有测试结束后只运行一次。
-
断言：JUnit提供了一系列的断言方法来检查测试结果是否符合预期，如
assertEquals(),assertTrue(),assertNotNull()等。
5.3.2 重点案例：测试一个简单的计算器类
假设我们有一个简单的计算器类，提供了加法和减法操作。我们将编写单元测试来验证这些功能。
Calculator.java:
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int subtract(int a, int b) {
return a - b;
}
}
CalculatorTest.java:
import static org.junit.Assert.*;
import org.junit.Test;
public class CalculatorTest {
private Calculator calculator = new Calculator();
@Test
public void testAdd() {
assertEquals(5, calculator.add(2, 3));
}
@Test
public void testSubtract() {
assertEquals(1, calculator.subtract(3, 2));
}
}
在这个案例中，我们为Calculator类的add和subtract方法编写了单元测试，使用assertEquals断言来验证方法的返回值是否符合预期。
5.3.3 拓展案例 1：使用 Mock 对象测试
在复杂的应用中，某些类的测试可能依赖于其他组件。为了隔离测试，我们可以使用Mock对象来模拟这些依赖。
假设我们有一个UserService类，它依赖于UserRepository。我们可以使用Mockito来模拟UserRepository。
UserServiceTest.java:
import static org.mockito.Mockito.*;
import static org.junit.Assert.*;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.junit.runner.RunWith;
@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {
@Mock
private UserRepository userRepository;
@InjectMocks
private UserService userService;
@Test
public void testFindUserById() {
when(userRepository.findUserById(1)).thenReturn(new User(1, "Alice"));
User user = userService.findUserById(1);
assertEquals("Alice", user.getName());
}
}
5.3.4 拓展案例 2：参数化测试
当我们需要对同一方法使用不同的输入值进行多次测试时，可以使用JUnit的参数化测试功能。
StringHelperTest.java:
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.Test;
import static org.junit.Assert.*;
@RunWith(Parameterized.class)
public class StringHelperTest {
private String input;
private String expectedOutput;
public StringHelperTest(String input, String expectedOutput) {
this.input = input;
this.expectedOutput = expectedOutput;
}
@Parameterized.Parameters
public static Collection<Object[]> testConditions() {
return Arrays.asList(new Object[][] {
{"AACD", "CD"},
{"ACD", "CD"}
});
}
@Test
public void testRemoveAInFirst2Positions() {
assertEquals(expectedOutput, StringHelper.removeAInFirst2Positions(input));
}
}
通过这些案例，我们看到JUnit测试如何成为Java开发者守卫代码质量的强大工具。它不仅可以帮助我们确保代码的正确性，还能使重构和维护变得更加容易。记得经常运行你的测试勇士们，让你的代码堡垒坚不可摧！
