Java生态 on 测试开发刚哥

单篇长文TestNG从入门到精通

Wed, 21 Jan 2026 00:00:00 +0000

简介

TestNG是Test Next Generation的缩写，它的灵感来自于JUnit和NUnit，在它们基础上增加了很多很牛的功能，比如说：

注解。
多线程，比如所有方法都在各自线程中，一个测试类一个线程等。
验证代码是否多线程安全。
灵活的测试配置。
支持数据驱动（@DataProvider）。
支持参数化。
强大的执行机制（不需要TestSuite）。
能跟各种工具结合（比如IDEA、Maven等）。
内嵌BeanShell。
提供运行时和日志的JDK函数（不需要添加dependencies）。
提供应用服务器测试依赖的方法。

一句话总结就是，TestNG强大到能覆盖所有测试类型：单元测试、功能测试、端到端测试、集成测试等等等。

一个简单的示例如下：

package example1;
 
import org.testng.annotations.*;
 
public class SimpleTest {
 
 @BeforeClass
 public void setUp() {
   // code that will be invoked when this test is instantiated
 }
 
 @Test(groups = { "fast" })
 public void aFastTest() {
   System.out.println("Fast test");
 }
 
 @Test(groups = { "slow" })
 public void aSlowTest() {
    System.out.println("Slow test");
 }
 
}

setUp()会在测试类创建后，测试方法执行前运行。
测试方法名字可以任意的，TestNG通过@Test注解来标识。
可以把测试方法按group分组。

然后使用xml来配置运行策略：

Allure+Maven+JUnit5配置实践

Tue, 20 Jan 2026 00:00:00 +0000

为什么要用JUnit5？

fastjson知多少

Mon, 19 Jan 2026 00:00:00 +0000

fastjson介绍

fastjson是一个Java库，用来在Java对象和JSON之间相互转换。

fastjson的目标（官方原话）：

我翻译一下：

性能非常好；
封装非常高；
转换非常强；
泛型也支持；
自定义表示；
复杂也支持；

这6个目标，书读少的我理解起来费劲，看着这些字，视线开始模糊…突然这些字动了，不断变幻，凝聚成了两个字：“牛逼”。阿里巴巴也确实做到了，fastjson(24.9k star)作为国产原创库，PK掉了jackson(7.6k star)和gson(21.3k star)，在国内应用领域坐上了头把交椅。

安装fastsjon

Maven引入：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>VERSION_CODE</version>
</dependency>

版本可以在 https://mvnrepository.com/artifact/com.alibaba/fastjson 查找：

虽然2.0.x版本出来了，但是使用得多的还是1.2.x版本。至少得1.2.48以上，因为这以下的版本之前出过轰动全国的安全漏洞。

入门示例

Group.java

public class Group {

    private Long       id;
    private String     name;
    private List<User> users = new ArrayList<User>();

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public void addUser(User user) {
        users.add(user);
    }
}

User.java

二刷Java官方教程

Sun, 18 Jan 2026 00:00:00 +0000

第二次阅读Java官方教程，有些不一样的理解。内容比较散乱，个人意识流笔记。

Java官方笔记14流

Sat, 17 Jan 2026 00:00:00 +0000

Processing Data in Memory

The Stream API is probably the second most important feature added to Java SE 8, after the lambda expressions. In a nutshell, the Stream API is about providing an implementation of the well known map-filter-reduce algorithm to the JDK.

map-filter-reduce：

List<Sale> sales = ...; // this is the list of all the sales
int amountSoldInMarch = 0;
for (Sale sale: sales) {
    if (sale.getDate().getMonth() == Month.MARCH) {
        amountSoldInMarch += sale.getAmount();
    }
}
System.out.println("Amount sold in March: " + amountSoldInMarch);

map：通过get取值，将部分字段映射到新数据（select字段）

Java官方笔记13集合

Fri, 16 Jan 2026 00:00:00 +0000

Storing Data

The Collections Framework is the most widely used API of the JDK.

the Collections Framework is a set of interfaces that models different way of storing data in different types of containers. Then the Framework provides at least one implementation for each interface.

There are two main categories of interfaces in the Collections Framework: collections and maps.（所以我猜想Python也是基于这样的考虑，设计了List和Dict，并作为Python基本数据类型，实际编码中要用到的也主要是这两类）

That makes two main categories, Collection and Map, a subcategory, Queue, and a side category, Iterator.

Java官方笔记12异常

Thu, 15 Jan 2026 00:00:00 +0000

Exception

Definition: An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program’s instructions.

the checked exception

比如，java.io.FileNotFoundException

the error

比如，java.io.IOError

the runtime exception

比如，NullPointerException

error和runtime exception又叫做unchecked exception

Catching and Handling Exceptions

try {
    code
}
catch and finally blocks . . .

try {

} catch (ExceptionType name) {

} catch (ExceptionType name) {

}

使用|catch多个：

Java持久层框架Mybatis入门

Wed, 14 Jan 2026 00:00:00 +0000

MyBatis是什么

MyBatis是Java的持久层框架，GitHub的star数高达15.8k，是Java技术栈中最热门的ORM框架之一。它支持自定义SQL、存储过程以及高级映射，可以通过XML或注解来配置和映射原始类型、接口和Java POJOs为数据库中的记录。

安装

Maven pom.xml：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>x.x.x</version>
</dependency>

SqlSessionFactory

SqlSessionFactory的实例是每个MyBatis应用的核心，通过SqlSessionFactoryBuilder创建，能基于XML配置，也能使用Configuration类。

基于XML配置：

String resource = "org/mybatis/example/mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory =
  new SqlSessionFactoryBuilder().build(inputStream);

实际项目中不会手动设置XML文件路径，而是直接读取classpath去找XML。

使用Configuration类：

DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
TransactionFactory transactionFactory =
  new JdbcTransactionFactory();
Environment environment =
  new Environment("development", transactionFactory, dataSource);
Configuration configuration = new Configuration(environment);
configuration.addMapper(BlogMapper.class);
SqlSessionFactory sqlSessionFactory =
  new SqlSessionFactoryBuilder().build(configuration);

由于Java注解的一些限制以及某些MyBatis映射的复杂性，MyBatis会优先选择XML配置。在上面的示例中，MyBatis会根据classpath和BlogMapper.class去找BlogMapper.xml。

Java官方笔记11包

Wed, 14 Jan 2026 00:00:00 +0000

Packages

Definition: A package is a grouping of related types providing access protection and name space management. Note that types refers to classes, interfaces, enumerations, and annotation types. Enumerations and annotation types are special kinds of classes and interfaces, respectively, so types are often referred to in this section simply as classes and interfaces.

创建

//in the Draggable.java file
package graphics;
public interface Draggable {
    . . .
}

//in the Graphic.java file
package graphics;
public abstract class Graphic {
    . . .
}

//in the Circle.java file
package graphics;
public class Circle extends Graphic
    implements Draggable {
    . . .
}

//in the Rectangle.java file
package graphics;
public class Rectangle extends Graphic
    implements Draggable {
    . . .
}

//in the Point.java file
package graphics;
public class Point extends Graphic
    implements Draggable {
    . . .
}

//in the Line.java file
package graphics;
public class Line extends Graphic
    implements Draggable {
    . . .
}

文件顶部第一行，每个文件只能有1个package关键字。

Java官方笔记10注解

Tue, 13 Jan 2026 00:00:00 +0000

注解

注解的作用：

Information for the compiler — Annotations can be used by the compiler to detect errors or suppress warnings.
Compile-time and deployment-time processing — Software tools can process annotation information to generate code, XML files, and so forth.
Runtime processing — Some annotations are available to be examined at runtime.

注解格式，使用@：

@Entity

带key-value：

@Author(
   name = "Benjamin Franklin",
   date = "3/27/2003"
)
class MyClass { ... }

只有1个key时可以省略key：

跟着官方文档学Maven构建生命周期

Tue, 13 Jan 2026 00:00:00 +0000

在IntelliJ IDEA中，显示了Maven的Lifecycle：

Java官方笔记9Lambda表达式

Mon, 12 Jan 2026 00:00:00 +0000

Lambda Expression

有了Lambda Expression，就不用再写anonymous classes。

写Lambda，首先要找到它的类型。

There is a restriction on the type of a lambda expression: it has to be a functional interface.

函数接口，只有1个抽象方法的接口：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

默认方法do not count，所以下面这个也是函数接口：

@FunctionalInterface
public interface Consumer<T> {

    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        // the body of this method has been removed
    }
}

静态方法也do not count，所以下面这个还是函数接口：

对IoC容器和Bean的学习笔记

Mon, 12 Jan 2026 00:00:00 +0000

What We Mean by “Spring”

The term “Spring” means different things in different contexts. It can be used to refer to the Spring Framework project itself, which is where it all started. Over time, other Spring projects have been built on top of the Spring Framework. Most often, when people say “Spring”, they mean the entire family of projects. This reference documentation focuses on the foundation: the Spring Framework itself.

JavaWeb开发进阶SpringMVC的DispatcherServlet

Sun, 11 Jan 2026 00:00:00 +0000

DispatcherServlet简介

DispatcherServlet是Spring MVC框架的核心组件，充当前端控制器（Front Controller）的角色。它负责接收所有的HTTP请求，并将它们分发给适当的处理器（控制器）。DispatcherServlet是整个Spring MVC应用程序的入口点，管理请求的整个生命周期。

通过源码查看DispatcherServlet定义：

public class DispatcherServlet extends FrameworkServlet
public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware
public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware

DispatcherServlet继承了FrameworkServlet，继承了HttpServletBean，继承了HttpServlet。HttpServlet来自jakarta.servlet.http.HttpServlet，也就是新版Servlet：

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.1.0</version>
    <scope>provided</scope>
</dependency>

果然，Spring MVC是基于Servlet的！

DispatcherServlet注册

DispatcherServlet是个Servlet，需要注册后才能使用。有3种注册方式：web.xml、Spring MVC、Spring Boot

① web.xml

<web-app>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/app-context.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>

</web-app>

② Spring MVC

Java官方笔记8泛型

Sun, 11 Jan 2026 00:00:00 +0000

泛型

为什么需要泛型？generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods.

泛型有个好处是不需要类型转换：

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);   // no cast

这个例子的泛型，是指List的实现使用了泛型<T>，从而给使用带来了好处。

定义

class name<T1, T2, ..., Tn> { /* ... */ }

比如定义class List<T>，使用List<String>

将以下代码：

public class Box {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

改为泛型实现：

SpringBoot官方笔记8其他

Sun, 11 Jan 2026 00:00:00 +0000

Container Images

FROM eclipse-temurin:17-jre as builder
WORKDIR application
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} application.jar
RUN java -Djarmode=layertools -jar application.jar extract

FROM eclipse-temurin:17-jre
WORKDIR application
COPY --from=builder application/dependencies/ ./
COPY --from=builder application/spring-boot-loader/ ./
COPY --from=builder application/snapshot-dependencies/ ./
COPY --from=builder application/application/ ./
ENTRYPOINT ["java", "org.springframework.boot.loader.JarLauncher"]

$ docker build --build-arg JAR_FILE=path/to/myapp.jar .

Production-ready Features

The spring-boot-actuator module provides all of Spring Boot’s production-ready features.

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

Endpoints

Actuator endpoints let you monitor and interact with your application. Spring Boot includes a number of built-in endpoints and lets you add your own. For example, the health endpoint provides basic application health information.

JavaWeb开发进阶SpringMVC简介

Sat, 10 Jan 2026 00:00:00 +0000

Spring MVC，又称为Spring Web MVC，名字来源于Spring模块spring-webmvc，是一个基于Servlet API开发的Web框架。

Java官方笔记7接口

Sat, 10 Jan 2026 00:00:00 +0000

接口

接口只能包含：constants, method signatures（abstract）, default methods, static methods, and nested types

方法体只存在于：default methods and static methods

接口不能实例化，只能被类实现，或者被其他接口继承（接口可以多继承）。

定义接口：

public interface OperateCar {

   // constant declarations, if any

   // method signatures
   
   // An enum with values RIGHT, LEFT
   int turn(Direction direction,
            double radius,
            double startSpeed,
            double endSpeed);
   int changeLanes(Direction direction,
                   double startSpeed,
                   double endSpeed);
   int signalTurn(Direction direction,
                  boolean signalOn);
   int getRadarFront(double distanceToCar,
                     double speedOfCar);
   int getRadarRear(double distanceToCar,
                    double speedOfCar);
         ......
   // more method signatures
}

类实现接口：

SpringBoot官方笔记7IO

Sat, 10 Jan 2026 00:00:00 +0000

Caching

Spring Boot auto-configures the cache infrastructure as long as caching support is enabled by using the @EnableCaching annotation.

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component
public class MyMathService {

    @Cacheable("piDecimals")
    public int computePiDecimal(int precision) {
        ...
    }

}

Before invoking computePiDecimal, the abstraction looks for an entry in the piDecimals cache that matches the i argument. If an entry is found, the content in the cache is immediately returned to the caller, and the method is not invoked. Otherwise, the method is invoked, and the cache is updated before returning the value.

JavaWeb开发基础ServletFilter

Fri, 09 Jan 2026 00:00:00 +0000

Filter是什么

Filter用于对请求和响应进行预处理和后处理。Filter链（Filter Chain）允许多个Filter依次处理同一个请求和响应。

Filter的使用场景

日志记录：记录请求和响应的详细信息，例如请求时间、响应时间、请求参数等
安全检查：检查用户是否有权限访问特定资源，例如验证用户身份、检查用户角色等
压缩：对响应内容进行压缩，例如使用GZIP压缩响应数据
字符编码设置：设置请求和响应的字符编码，例如将请求和响应的字符编码设置为UTF-8
输入验证：对请求参数进行验证，例如检查参数是否为空、参数格式是否正确等

Filter Interface

Filter接口有3个方法：

package javax.servlet;

import java.io.IOException;

public interface Filter {
    void init(FilterConfig var1) throws ServletException;

    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;

    void destroy();
}

容器在启动时创建Filter实例，并调用其init(FilterConfig filterConfig)方法进行初始化。每次请求到达时，容器调用Filter的doFilter(ServletRequest request, ServletResponse response, FilterChain chain)方法进行过滤。容器在关闭时调用Filter的destroy()方法进行清理。

Filter可以通过两种方式进行配置：

1.在web.xml中配置：

<filter>
    <filter-name>MyFilter</filter-name>
    <filter-class>com.example.MyFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>MyFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

如果采用web.xml，那么去掉Filter只需要修改web.xml即可，不需要修改代码。

2.使用注解配置：

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter("/*")
public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化操作
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 预处理操作
        System.out.println("Request received at " + System.currentTimeMillis());

        // 继续执行下一个过滤器或目标资源
        chain.doFilter(request, response);

        // 后处理操作
        System.out.println("Response sent at " + System.currentTimeMillis());
    }

    @Override
    public void destroy() {
        // 清理操作
    }
}

FilterChain Interface

Filter接口的doFilter方法，第3个参数类型是FilterChain，它的定义如下：

Java官方笔记6继承

Fri, 09 Jan 2026 00:00:00 +0000

继承

Java只有单继承，最顶级的父类是Object。

子类会继承父类的fields和methods，而不会继承constructors，因为constructors不属于methods，但是子类可以通过super调用父类的constructor。

子类继承父类的范围是：public、protected、package-private

隐式转换，子类转父类（只有1个爸爸）：

Object obj = new MountainBike();

显示转换，父类转子类（有多个子女，所以要明确指定）：

MountainBike myBike = (MountainBike)obj;

类有field，而接口没有，所以在多继承时就有问题：如果多个类有相同的field，那么子类将不知道用哪一个，而接口不存在这个问题。Java不支持继承多个类，但是可以实现多个接口。

重载

子类的方法跟父类有完全相同的签名和返回类型（也可以是子类），将会覆盖父类方法Override。

如果子类定义了1个static方法，跟父类完全相同，那么父类方法会被隐藏Hide。

Override和Hide是不同的：

public class Animal {
    public static void testClassMethod() {
        System.out.println("The static method in Animal");
    }
    public void testInstanceMethod() {
        System.out.println("The instance method in Animal");
    }
}

public class Cat extends Animal {
    public static void testClassMethod() {
        System.out.println("The static method in Cat");
    }
    public void testInstanceMethod() {
        System.out.println("The instance method in Cat");
    }

    public static void main(String[] args) {
        Cat myCat = new Cat();
        Animal myAnimal = myCat;  // 隐式转换
        Animal.testClassMethod();  // 调的父类
        myAnimal.testInstanceMethod();  // 父类对象引用，还是调的子类
    }
}

The static method in Animal
The instance method in Cat

Override只会调子类方法，而Hide取决于调用方是父还是子，比如这里的myCat，隐式转换为父类Animal后，会调父类的static方法，而调的实例方法却是子类的。（如果不是隐式转换，而是直接给父类实例化，那肯定还是调父类方法）

SpringBoot官方笔记6消息

Fri, 09 Jan 2026 00:00:00 +0000

The Spring Framework provides extensive support for integrating with messaging systems, from simplified use of the JMS API using JmsTemplate to a complete infrastructure to receive messages asynchro

JavaWeb开发基础Servlet事件和监听器

Thu, 08 Jan 2026 00:00:00 +0000

事件和监听器

事件是指在程序运行过程中发生的特定动作或情况。比如：

用户操作，如点击按钮、输入文本
系统操作，如文件读取完成、网络连接断开
应用程序内部的状态变化，如对象属性改变、方法调用

监听器是一个接口或类，用于定义在特定事件发生时要执行的操作。监听器会“监听”特定的事件，当事件发生时，监听器中的相应方法会被调用，从而执行预定义的操作。

事件和监听器是相辅相成的，它们的工作原理如下：

事件源：触发事件的来源。例如，按钮是事件源，点击按钮会触发点击事件
事件对象：当事件发生时，事件源会创建一个事件对象，包含有关事件的信息
注册监听器：监听器需要注册到事件源，以便监听特定的事件。注册后，事件源会在事件发生时通知监听器
事件处理：当事件发生时，事件源会调用监听器中的相应方法，传递事件对象，从而执行预定义的操作

Servlet Event Class

事件（Event）是一个类，封装了与特定事件相关的信息。

基本是构造方法和get方法：

ServletRequestEvent

public class ServletRequestEvent extends EventObject {
    private static final long serialVersionUID = 1L;
    private final ServletRequest request;

    public ServletRequestEvent(ServletContext sc, ServletRequest request) {
        super(sc);
        this.request = request;
    }

    public ServletRequest getServletRequest() {
        return this.request;
    }

    public ServletContext getServletContext() {
        return (ServletContext) super.getSource();
    }
}

ServletRequestAttributeEvent

public class ServletRequestAttributeEvent extends ServletRequestEvent {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final Object value;

    public ServletRequestAttributeEvent(ServletContext sc, ServletRequest request, String name, Object value) {
        super(sc, request);
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return this.name;
    }

    public Object getValue() {
        return this.value;
    }
}

ServletContextEvent

public class ServletContextEvent extends EventObject {
    private static final long serialVersionUID = 1L;

    public ServletContextEvent(ServletContext source) {
        super(source);
    }

    public ServletContext getServletContext() {
        return (ServletContext) super.getSource();
    }
}

ServletContextAttributeEvent

public class ServletContextAttributeEvent extends ServletContextEvent {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final Object value;

    public ServletContextAttributeEvent(ServletContext source, String name, Object value) {
        super(source);
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return this.name;
    }

    public Object getValue() {
        return this.value;
    }
}

HttpSessionEvent

public class HttpSessionEvent extends EventObject {
    private static final long serialVersionUID = 1L;

    public HttpSessionEvent(HttpSession source) {
        super(source);
    }

    public HttpSession getSession() {
        return (HttpSession) super.getSource();
    }
}

HttpSessionBindingEvent

public class HttpSessionBindingEvent extends HttpSessionEvent {
    private static final long serialVersionUID = 1L;
    private final String name;
    private final Object value;

    public HttpSessionBindingEvent(HttpSession session, String name, Object value) {
        super(session);
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return this.name;
    }

    public Object getValue() {
        return this.value;
    }
}

Java官方笔记5数字和字符串

Thu, 08 Jan 2026 00:00:00 +0000

Numbers

Number的子类：

另外还有BigDecimal和BigInteger，用于高精度计算，AtomicInteger和AtomicLong用于多线程应用。

我们有时候需要用包装类而非基本数据类型，理由如下：

方法入参类型为Object，只能传入对象
使用包装类提供的常量，比如MIN_VALUE和MAX_VALUE
使用包装类的方法来做类型转换

format

import java.util.Calendar;
import java.util.Locale;

public class TestFormat {

    public static void main(String[] args) {
      long n = 461012;
      System.out.format("%d%n", n);      //  -->  "461012"
      System.out.format("%08d%n", n);    //  -->  "00461012"
      System.out.format("%+8d%n", n);    //  -->  " +461012"
      System.out.format("%,8d%n", n);    // -->  " 461,012"
      System.out.format("%+,8d%n%n", n); //  -->  "+461,012"

      double pi = Math.PI;

      System.out.format("%f%n", pi);       // -->  "3.141593"
      System.out.format("%.3f%n", pi);     // -->  "3.142"
      System.out.format("%10.3f%n", pi);   // -->  "     3.142"
      System.out.format("%-10.3f%n", pi);  // -->  "3.142"
      System.out.format(Locale.FRANCE,
                        "%-10.4f%n%n", pi); // -->  "3,1416"

      Calendar c = Calendar.getInstance();
      System.out.format("%tB %te, %tY%n", c, c, c); // -->  "May 29, 2006"

      System.out.format("%tl:%tM %tp%n", c, c, c);  // -->  "2:34 am"

      System.out.format("%tD%n", c);    // -->  "05/29/06"
    }
}

DecimalFormat

SpringBoot官方笔记5Data

Thu, 08 Jan 2026 00:00:00 +0000

Spring Boot integrates with a number of data technologies, both SQL and NoSQL.

JavaWeb开发基础ServletSession

Wed, 07 Jan 2026 00:00:00 +0000

Session是什么

在Web应用程序中，Session（会话）是用于在多个请求之间保持用户状态的一种机制。由于HTTP协议是无状态的，每个请求都是独立的，服务器无法直接知道两个请求是否来自同一个用户。Session通过在服务器端存储用户状态信息，并在客户端使用一个唯一的Session ID来标识用户，从而实现状态保持。

Session工作原理如下：

创建Session：当用户第一次访问Web应用程序时，服务器创建一个新的Session，并生成一个唯一的Session ID
发送Session ID：服务器将Session ID发送给客户端，通常通过HTTP响应头中的Set-Cookie字段
存储Session ID：客户端浏览器将Session ID存储在Cookie中，并在后续请求中将其发送回服务器
识别Session：服务器通过接收到的Session ID识别用户的会话，并从服务器端存储中获取相应的Session数据

四种主要技术

Cookies
Hidden Form Field
URL Rewriting
HttpSession

1. Cookies（Cookie）

Cookie是存储在客户端浏览器中的小数据片段。它们会随着每个HTTP请求一起发送到服务器，可以用来存储会话标识符。

工作原理

当用户第一次访问网站时，服务器生成一个唯一的会话ID，并将其作为Cookie发送到客户端浏览器
浏览器存储这个Cookie，并在后续请求中将其发送回服务器
服务器使用Cookie中的会话ID来检索用户的会话数据

优点

对用户透明
由浏览器自动管理
可以存储少量数据

缺点

用户可以在浏览器中禁用Cookie
存储容量有限（通常每个Cookie大约4KB）
如果处理不当，可能存在安全问题（例如Cookie盗窃）

示例

import javax.servlet.http.Cookie;


// 在Servlet中设置Cookie
Cookie sessionCookie = new Cookie("JSESSIONID", session.getId());
sessionCookie.setMaxAge(30 * 60); // 30分钟
response.addCookie(sessionCookie);

// 在Servlet中检索Cookie
Cookie[] cookies = request.getCookies();  // 从请求获取Cookie
if (cookies != null) {
    for (Cookie cookie : cookies) {
        if ("JSESSIONID".equals(cookie.getName())) {
            String sessionId = cookie.getValue();
            // 使用会话ID检索会话数据
        }
    }
}

Cookie有两种类型：

Java官方笔记4类和对象

Wed, 07 Jan 2026 00:00:00 +0000

创建类

定义类Bicycle：

public class Bicycle {

    // the Bicycle class has
    // three fields
    public int cadence;
    public int gear;
    public int speed;

    // the Bicycle class has
    // one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // the Bicycle class has
    // four methods
    public void setCadence(int newValue) {
        cadence = newValue;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public void applyBrake(int decrement) {
        speed -= decrement;
    }

    public void speedUp(int increment) {
        speed += increment;
    }
}

创建子类MountainBike继承类Bicycle：

SpringBoot官方笔记4Web

Wed, 07 Jan 2026 00:00:00 +0000

Most web applications use the spring-boot-starter-web module to get up and running quickly. You can also choose to build reactive web applications by using the spring-boot-starter-webflux module.

JavaWeb开发基础ServletConfig与ServletContext

Tue, 06 Jan 2026 00:00:00 +0000

ServletConfig

package javax.servlet;

import java.util.Enumeration;

public interface ServletConfig {
    String getServletName();

    ServletContext getServletContext();

    String getInitParameter(String var1);

    Enumeration<String> getInitParameterNames();
}

ServletConfig用于Servlet初始化时从web.xml获取配置信息。主要有以下方法：

public String getInitParameter(String name): Returns the parameter value for the specified parameter name.
public Enumeration getInitParameterNames(): Returns an enumeration of all the initialization parameter names.
public String getServletName(): Returns the name of the servlet.
public ServletContext getServletContext(): Returns an object of ServletContext.

示例，web.xml

Java官方笔记3Java语言基础

Tue, 06 Jan 2026 00:00:00 +0000

变量

Instance Variables (Non-Static Fields) 实例变量（非静态变量）

一个类可以创造多个实例，实例中的变量叫做实例变量，相互独立。

Class Variables (Static Fields) 类变量（静态变量）

对比来看，类变量就是类的变量，一个类只能有一份，不能复制，使用static关键字来定义类变量。

代码：

public class MyVar {
    static int classVar = 1;  // 类变量（静态变量）
    int instanceVar = 2;  // 实例变量
}

对比Python来看就很清楚：

class MyVar:
class_var = 1

def __int__(self):
  instance_var = 2

Local Variables 局部变量

局部变量是由代码位置决定的，前面的实例变量和类变量，是放到Field位置，而局部变量是放到Method里面。也就是说，局部变量是放在方法的花括号里面的变量，并且只能在方法内部访问，不能被其他地方访问，这就是所谓的局部。

public class MyVar {
    static int classVar = 1;  // 类变量（静态变量）
    int instanceVar = 2;  // 实例变量

    void method() {
        int localVar = 3;  // 局部变量
    }
}

Parameters 参数

SpringBoot官方笔记3核心

Tue, 06 Jan 2026 00:00:00 +0000

SpringApplication

By default, INFO logging messages are shown, including some relevant startup details, such as the user that launched the application.

Lazy Initialization

When lazy initialization is enabled, beans are created as they are needed rather than during application startup.

spring.main.lazy-initialization=true

@Lazy(false) annotation：disable lazy initialization for certain beans

Customizing the Banner

adding a banner.txt file to your classpath or by setting the spring.banner.location property to the location of such a file. If the file has an encoding other than UTF-8, you can set spring.banner.charset.

JavaWeb开发基础Servlet请求分发与重定向

Mon, 05 Jan 2026 00:00:00 +0000

请求分发

Servlet的RequestDispatcher接口定义：

package javax.servlet;

import java.io.IOException;

public interface RequestDispatcher {
    String FORWARD_REQUEST_URI = "javax.servlet.forward.request_uri";
    String FORWARD_CONTEXT_PATH = "javax.servlet.forward.context_path";
    String FORWARD_PATH_INFO = "javax.servlet.forward.path_info";
    String FORWARD_SERVLET_PATH = "javax.servlet.forward.servlet_path";
    String FORWARD_QUERY_STRING = "javax.servlet.forward.query_string";
    String INCLUDE_REQUEST_URI = "javax.servlet.include.request_uri";
    String INCLUDE_CONTEXT_PATH = "javax.servlet.include.context_path";
    String INCLUDE_PATH_INFO = "javax.servlet.include.path_info";
    String INCLUDE_SERVLET_PATH = "javax.servlet.include.servlet_path";
    String INCLUDE_QUERY_STRING = "javax.servlet.include.query_string";
    String ERROR_EXCEPTION = "javax.servlet.error.exception";
    String ERROR_EXCEPTION_TYPE = "javax.servlet.error.exception_type";
    String ERROR_MESSAGE = "javax.servlet.error.message";
    String ERROR_REQUEST_URI = "javax.servlet.error.request_uri";
    String ERROR_SERVLET_NAME = "javax.servlet.error.servlet_name";
    String ERROR_STATUS_CODE = "javax.servlet.error.status_code";

    void forward(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

    void include(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
}

它有2个方法，forward和include：

Java官方笔记2面向对象编程基本概念

Mon, 05 Jan 2026 00:00:00 +0000

对象Object

对象有2个特征：状态state和行为behavior。我们可以用真实世界的对象来做类比，这样有助于理解面向对象编程，比如狗的状态（名字、颜色、品种）和行为（叫、抓、摇尾巴），自行车的状态（当前档位、当前踏板节奏、当前速度）和行为（切换档位、切换踏板节奏、踩刹车）。

软件对象也是由状态和行为组成：

状态，在软件对象中，叫做字段fields，或变量variables。

行为，在软件对象中，叫做方法methods，或函数functions。

所谓的数据封装data encapsulation，就是字段只在内部，不对外暴露，仅由方法进行操作，对象与对象之间通过方法来相互访问。

Java是纯粹的面向对象编程语言。

类Class

类，可以视为对象的模版，基于类来创造出同一类对象。

比如自行车的类：

class Bicycle {

    int cadence = 0;
    int speed = 0;
    int gear = 1;

    void changeCadence(int newValue) {
         cadence = newValue;
    }

    void changeGear(int newValue) {
         gear = newValue;
    }

    void speedUp(int increment) {
         speed = speed + increment;   
    }

    void applyBrakes(int decrement) {
         speed = speed - decrement;
    }

    void printStates() {
         System.out.println("cadence:" +
             cadence + " speed:" + 
             speed + " gear:" + gear);
    }
}

类也是有2个特征：字段和方法。比如Bicycle类有字段cadence、speed、gear和方法changeCadence()、changeGear()、speedUp()等。

SpringBoot官方笔记2使用

Mon, 05 Jan 2026 00:00:00 +0000

Build Systems

选择Maven or Gradle，而不要Ant（not particularly well supported）

In practice, you do not need to provide a version for any of these dependencies (spring-boot-dependencies) in your build configuration, as Spring Boot manages that for you. When you upgrade Spring Boot itself, these dependencies are upgraded as well in a consistent way.

Each release of Spring Boot is associated with a base version of the Spring Framework.

Starters are a set of convenient dependency descriptors that you can include in your application.

JavaWeb开发基础Servlet生命周期与工作原理

Sun, 04 Jan 2026 00:00:00 +0000

Servlet生命周期

Servlet的生命周期由Servlet容器（如Tomcat、Jetty等）管理，主要包括以下5个阶段：

加载Servlet类
创建Servlet实例
调用init方法
调用service方法
调用destroy方法

加载（Loading）：
- 当Servlet容器启动或第一次接收到对某个Servlet的请求时，它会加载Servlet类
- 这个过程只发生一次，除非Servlet被卸载或容器重新启动
实例化（Instantiation）：
- 在加载Servlet类之后，容器会创建一个Servlet实例
- 这个实例化过程也是一次性的，除非Servlet被卸载或容器重新启动
初始化（Initialization）：
- 容器调用Servlet实例的init()方法进行初始化
- init()方法只被调用一次，用于执行一次性的初始化任务，如读取配置参数、初始化资源等
- 你可以重写init()方法以执行自定义的初始化逻辑
```
public void init(ServletConfig config)
```
请求处理（Request Handling）：
- 每当有请求到达时，容器会调用Servlet的service()方法来处理请求
- service()方法根据请求的类型（如GET、POST等）调用相应的处理方法（如doGet()、doPost()等）
```
public void service(ServletRequest request, ServletResponse response)
```
销毁（Destruction）：
- 当容器决定卸载Servlet（如容器关闭或Servlet被重新加载）时，它会调用Servlet的destroy()方法
- destroy()方法用于执行清理任务，如关闭资源、保存状态等
- destroy()方法只被调用一次
```
public void destroy()
```

Servlet重新加载

Servlet被重新加载通常发生在以下几种情况下：

Servlet类文件被修改：
- 如果在开发过程中修改了Servlet类文件，Servlet容器可能会检测到这些更改并重新加载Servlet
- 这通常发生在开发环境中，生产环境中一般不会自动重新加载
容器配置发生变化：
- 如果修改了Servlet容器的配置文件（如web.xml），容器可能会重新加载相关的Servlet
容器重启：
- 当Servlet容器重启时，所有的Servlet都会被重新加载
手动重新加载：
- 某些Servlet容器提供了手动重新加载Servlet的功能，通常通过管理控制台或命令行工具

当Servlet被重新加载时，Servlet容器会执行以下步骤：

销毁现有的Servlet实例：
- 容器调用现有Servlet实例的destroy()方法，执行清理任务
- 释放资源，如关闭数据库连接、释放文件句柄等
卸载Servlet类：
- 容器卸载现有的Servlet类，释放类加载器持有的资源
重新加载Servlet类：
- 容器重新加载Servlet类文件，创建新的类加载器实例
实例化新的Servlet对象：
- 容器创建新的Servlet实例
初始化新的Servlet实例：
- 容器调用新的Servlet实例的init()方法进行初始化

Servlet代码示例

有3种方式使用Servlet：

①实现Servlet接口

import java.io.*;
import javax.servlet.*;

public class First implements Servlet {
    ServletConfig config = null;

    public void init(ServletConfig config) {
        this.config = config;
        System.out.println("servlet is initialized");
    }

    public void service(ServletRequest req, ServletResponse res)
            throws IOException, ServletException {
        res.setContentType("text/html");
        PrintWriter out = res.getWriter();
        out.print("<html><body>");
        out.print("<b>hello simple servlet</b>");
        out.print("</body></html>");

    }

    public void destroy() {
        System.out.println("servlet is destroyed");
    }

    public ServletConfig getServletConfig() {
        return config;
    }

    public String getServletInfo() {
        return "copyright 2007-1010";
    }
}

②继承GenericServlet类

Java官方笔记1编写运行Java程序

Sun, 04 Jan 2026 00:00:00 +0000

你可能已经迫不及待想安装Java，写个Java程序跑起来了。但是在这之前，有些概念需要提前了解，因为Java跟C、C++和Python都有点不一样。

SpringBoot官方笔记1入门

Sun, 04 Jan 2026 00:00:00 +0000

Spring Boot helps you to create stand-alone, production-grade Spring-based applications that you can run. Most Spring Boot applications need very little Spring configuration.

Dockerfile文件万字全面解析

Sat, 03 Jan 2026 00:00:00 +0000

Dockerfile是一个文本文件，包含一些Docker指令。执行docker build，Docker就会执行Dockerfile里面的指令，来自动创建镜像。

JavaWeb开发基础ServletAPI

Sat, 03 Jan 2026 00:00:00 +0000

Servlet版本

Oracle将Java EE（Java SE还自己保留）交给开源组织，Eclipse基金会接手。但Oracle不允许开源组织使用Java名号，所以Jakarta EE名称于2018.02.26应运而生。

正是因为组织变化，Servlet被割裂为了2个版本，javax.servlet和jakarta.servlet。

javax.servlet已经停止维护，但它仍然是一个非常有用和重要的技术，特别是在许多现有项目中，学习和使用它将为你提供坚实的Web开发基础。

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

如果希望使用Jakarta EE 9或更高版本的Servlet API，则需要切换到javax.servlet。

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.0.0</version>
    <scope>provided</scope>
</dependency>

本文将基于javax.servlet来介绍Servlet，从Usages来看，它仍然是使用最广泛的。

Servlet API

Servlet API主要有2个包，javax.servlet包含了servlet和web container使用的接口和类。javax.servlet.http包含了http相关的接口和类。

javax.servlet接口列表：

Servlet
ServletRequest
ServletResponse
RequestDispatcher
ServletConfig
ServletContext
SingleThreadModel
Filter
FilterConfig
FilterChain
ServletRequestListener
ServletRequestAttributeListener
ServletContextListener
ServletContextAttributeListener

javax.servlet类列表：

GenericServlet
ServletInputStream
ServletOutputStream
ServletRequestWrapper
ServletResponseWrapper
ServletRequestEvent
ServletContextEvent
ServletRequestAttributeEvent
ServletContextAttributeEvent
ServletException
UnavailableException

javax.servlet.http接口列表：

HttpServletRequest
HttpServletResponse
HttpSession
HttpSessionListener
HttpSessionAttributeListener
HttpSessionBindingListener
HttpSessionActivationListener
HttpSessionContext (deprecated now)

javax.servlet.http类列表：

关于SpringBoot开发的更多细节

Sat, 03 Jan 2026 00:00:00 +0000

在上篇文章《开发你的第一个SpringBoot应用》已经对SpringBoot基本开发流程有了大体了解，本文将继续对SpringBoot官网进行学习，发现关于SpringBoot开发的更多细节。

刷完3个Java教程后不再犹豫

Sat, 03 Jan 2026 00:00:00 +0000

成年人最大的底气是你拥有一技之长，人生才不会被动。从事测试开发岗位，需要精通一门编程语言，是核心，是大招，是招牌技能。我内心一直在Java和Python之间选择，反复横跳。

JavaWeb开发基础Servlet简介

Fri, 02 Jan 2026 00:00:00 +0000

Servlet是什么？

现在的Java Web开发，很少直接接触到Servlet。在Spring项目中，Spring Boot基于Spring Framework，简化了Spring应用程序开发，Spring Framework是一个全面的Java应用程序框架，其中包含Spring MVC模块，Spring MVC封装了Servlet，以实现Web功能。Servlet不属于Spirng项目，而是Java EE（后改名为Jakarta EE）的一部分。

Servlet可以有很多种描述：

Servlet是一个技术，用来创建Web应用程序
Servlet是一个API，提供了很多接口、类和文档
Servlet是一个接口，必须实现该接口来创建Servlet
Servlet是一个类，位于服务端，接收请求，返回响应
Servlet是一个Web组件，用来创建动态Web页面

CGI与Servlet

在Servlet技术出现以前，Web应用程序是通过CGI（Common Gateway Interface），一种脚本语言，来实现的。

但是CGI存在很多缺点：

如果客户端增多，服务端响应会变慢
对于每个请求，CGI都会创建一个进程，进程数有限
依赖C、C++、perl等编程语言

Servlet技术出现以后，解决了很多CGI问题：

性能：每个请求创建一个线程，而不是进程
可移植性：因为使用了Java语言
健壮性：JVM管理Servlet，无需关心内存泄漏、垃圾回收等
安全性：因为使用了Java语言

总的来说，Servlet是Server Applet，服务端小程序。它是单例多线程的，每个Servlet类在Web容器中只有一个实例，每次客户端请求，Web Server都会从线程池中分配一个线程去创建Servlet，每个请求由一个独立的线程处理，这些线程共享同一个Servlet实例，通过HTTP协议接收和响应来自Web Client的请求。

Java高级编程精华笔记

Fri, 02 Jan 2026 00:00:00 +0000

学习路线

本文是Java高级编程精华笔记，是对菜鸟教程中Java面向对象和Java高级编程的重要章节进行了学习，整理形成的学习笔记，知识图谱如下图所示：

如果想对Java深入学习，可以参考阿里巴巴的技术图谱：

https://developer.aliyun.com/graph/java

继承

Java使用extends关键字来声明继承：

class 父类 {
}

class 子类 extends 父类 {
}

示例，子类企鹅和子类老鼠继承父类动物：

//父类：动物
public class Animal {
    private String name;
    private int id;

    public Animal(String myName, int myid) {
        name = myName;
        id = myid;
    }

    public void eat() {
        System.out.println(name + "正在吃");
    }

    public void sleep() {
        System.out.println(name + "正在睡");
    }

    public void introduction() {
        System.out.println("大家好！我是" + id + "号" + name + ".");
    }
}

//子类：企鹅
public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

//子类：老鼠
public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

Java只支持单继承，不支持多继承，但可以多重继承：

多线程简单斗地主

Fri, 02 Jan 2026 00:00:00 +0000

多线程，通道，读写锁（单写多读），随机（洗牌），是本文涉及的主要知识点。

开发你的第一个SpringBoot应用

Fri, 02 Jan 2026 00:00:00 +0000

创建SpringBoot项目最便捷的方式一是在https://start.spring.io/根据步骤选择后，下载项目工程压缩包：

JavaWeb开发基础7个Web术语解析

Thu, 01 Jan 2026 00:00:00 +0000

7个Web术语

Website: static vs dynamic
HTTP
HTTP Requests
GET vs POST
Servlet Container
Server: Web vs Application
Content Type

Website: static vs dynamic

网站内容包括文本、图片、音频、视频，通过URL来访问。网站分为静态网站和动态网站。

静态网站

静态网站是用HTML编写的，所有内容都包含在网页内，就像是打印出来的一样。

动态网站

动态网站分为客户端和服务端，内容是可以动态变化的，可以根据用户请求动态更新网页内容。服务端语言有Servlet、ASP.NET等。

HTTP

HTTP是Hypertext Transfer Protocol缩写，超文本传输协议，位于OSI网络分层模型的应用层（第七层）。

HTTP具有以下特点：

media independent：支持任何类型的媒体内容
connectionless：无连接，客户端发送请求后，就断开了连接
stateless：无状态，服务端不会保留客户端请求的状态，不知道谁是谁

HTTP是基于TCP/IP协议的，通过TCP建立可靠连接。为什么说HTTP是无连接的，但又是基于TCP可靠连接的？如果想要可靠地传输数据，那么就必须要有稳定可靠的连接，保证数据不丢失，这个连接就是TCP连接。HTTP正是通过TCP连接来发送和接收数据的。

在HTTP/1.0中，每次请求都会建立一个新的TCP连接，完成请求后立即关闭连接。在HTTP/1.1中，引入了持久连接，允许多个请求/响应在同一个TCP连接上进行，但每个请求/响应对话仍然是独立的。HTTP/1.1是持久连接，那么还能叫做无连接吗？是的，仍然是无连接。持久连接是通过 Connection: keep-alive 头部实现的，允许连接在一段时间内保持打开状态，不需要重新建立和关闭连接。无连接的本质是每个请求/响应对话都是独立的，强调的是独立。

HTTP Requests

HTTP请求是客户端发送给服务端的请求，包含以下内容：

The Request-line（请求行）
The analysis of source IP address, proxy and port（源信息）
The analysis of destination IP address, protocol, port and host（目标信息）
The Requested URI (Uniform Resource Identifier)（链接）
The Request method and Content（方法和内容）
The User-Agent header（请求头）
The Connection control header（请求头）
The Cache control header（请求头）

可以在浏览器中通过F12开发者工具，查看HTTP请求信息。

SpringBoot简介与安装

Thu, 01 Jan 2026 00:00:00 +0000

SpringBoot简介

SpringBoot是Java技术栈的一个Web开发框架，在整个Web开发框架领域中，说SpringBoot是最成熟、最稳定、生态最强大的，一点也不为过。它最伟大的变革是让Java的Web框架也变得便捷起来，开箱即用，只需要简单配置就能快速搭建起一个后端应用，这也是它出现后迅速抢占市场，实现技术更替的重要原因。

除了Web应用开发外，SpringBoot还提供了内嵌服务器（Tomcat等）、安全、监控、健康检查等能力。

SpringBoot安装

本文主要介绍Maven这种方式：

第一步，安装Java，SpringBoot 2.5.6版本需要Java8及以上版本，最新的Java17也兼容。
第二步，安装Maven，不需要单独安装，下载一个IntelliJ就可以了，详细步骤可以参考我博客中这篇文章：

001-2021年搭建Java环境最快办法

第三步，在pom.xml中配置SpringBoot：

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
    </parent>

    <!-- Additional lines to be added here... -->

</project>

下篇文章《开发你的第一个SpringBoot应用》将继续探究SpringBoot安装后的使用。

参考资料：

https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#getting-started

测试人员学Java入门指南

Thu, 01 Jan 2026 00:00:00 +0000

目标读者

本指南特别适合有Python基础的同学学习Java入门，对于没有任何编程经验的同学可能会存在困难。

为什么测试人员要学Java

选择Java，应该不错。TesterHome测试论坛知名大佬基本都是以Java技术栈为主，少部分是Golang和Python。我公司2021年校招的两个同济大学研究生，测试开发，也是以Java为主。有一个测开同事跳槽去了美团，拿了高薪，只会Java。有一个测开同事跳槽去了创业公司做了测试架构师，只会Java。招聘网站搜索测试开发20K以上职位，基本都要求会Java。我接触到的开发，Java程序员占80%以上。

测试人员用Java能干嘛

如果你的公司是以Java技术栈为主，那么你可以用Java做所有事情，而且有些事情只能用Java来做。这个问题挺关键的，学习一门语言肯定是要能够学以致用。在自动化测试，Java会显得稍微有点笨重，而Python会适合一点。你可以用Python来写接口自动化脚本，在小范围内使用，但是当团队变大以后，脚本如何规范如何维护，就成了一个很大的问题，而Java由于静态语言特性和面向对象编程，正好可以用来解决这个问题。在测试平台和性能测试，Java有很成熟的Web开发框架和配套的生态。在测试工具开发，公司封装好的Java库可以拿来即用，碰到问题也可以找开发帮忙。白盒测试，基本上都是要靠Java来做的，看代码，用JaCoCo统计代码覆盖率。其他专项比如流量录制回放、全链路压测、Dubbo接口测试，都只能使用Java来做。

测试人员怎么学Java

我推荐刷完一遍基础语法后，在LeetCode上面刷算法题来加强练习。Java还是有一定的学习门槛的，初学者可能学起来会有些吃力，可以先从Python入手，了解编程语言的底层逻辑，等对编程有些许感知以后，再学习Java。基础语法可以快速浏览一遍，一遍并不会就能记住了，需要在编码中持续加强记忆。光学语法也不行，学习Java和其他编程语言一样，需要多敲多练，刷算法题，既能熟悉Java语法，也能熟悉算法，一举两得，题做不来就先把答案背一遍再做。另外，可以在工作中主动找研发开通下代码权限，尝试Review开发代码，看多了，有些技巧也会知道了。有机会，可以用Java写点工具或者平台，实践出真知。

搭建环境

安装Java

Java的安装包是个.exe文件，特殊地方在于文件名不是java-xxx.exe而是jdk-xxx.exe，比如jdk-8u281-windows-x64.exe，jdk是Java Development Kit 的缩写，指Java开发工具包，包括以下内容：

JDK的最新版本为15，但是国内大多数公司仍然使用的是JDK8，这是因为JDK8是各方面都很成熟稳定的版本，并且基于JDK8开发的业务系统已经具有一定规模，新版本JDK并不能完全无感知的迁移，需要做代码修改和测试，会是一笔巨大开销，为了降低成本和规避兼容问题风险，JDK8沿用到了至今。JDK8的下载地址如下：

https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html

选择相应的版本下载：

比如我的电脑是Windows 64位的系统，就选择了Windows x64这个版本，会下载到一个jdk-8u281-windows-x64.exe文件。Java已经被Oracle收购了，需要登录Oracle账号后才能下载，没有账号注册一个也很方便：

下载后可以开始安装了：

安装到默认位置即可，直接下一步。中途会让选择JRE（Java Runtime Environment，Java运行环境）的目标文件夹：

依然保持默认即可。安装结束后就能看到两个新文件夹了：

以前，还需要配置系统环境变量，设置JAVA_HOME和CLASSPATH才能使用Java（具体方法百度有很多）。现在，安装完成即可用，省去了不少麻烦，速度加快。打开cmd输入java -version，命令能执行成功就表示Java已经安装好了：

安装IntelliJ IDEA

JetBrains全家桶中也有专门用来写Java的，叫做IntelliJ IDEA，一般只说后面一个单词“哎迪儿”就知道是这个东西了。下载地址为：

https://www.jetbrains.com/idea/download/#section=windows

个人建议选择旗舰版，看着齐全。下载后双击ideaIU-2020.3.2.exe安装，先别忙着打开。

Maven仓库

Maven是用来管理Java第三方包的主流仓库工具，通过pom.xml文件来配置安装即可，在mvnrepository网站上能检索到所需配置信息：

https://mvnrepository.com/

官方仓库有时候下载速度很慢，本文用国内镜像替代，提高首次打开时同步仓库速度。我们先把Maven中央仓库从Apache替换成阿里云。打开本地目录D:\Program Files\JetBrains\IntelliJ IDEA 2020.3.2\plugins\maven\lib\maven3\conf：

编辑settings.xml文件，找到<mirrors>标签，添加代码：

    <mirror>
      <id>aliyunmaven</id>
      <mirrorOf>*</mirrorOf>
      <name>阿里云公共仓库</name>
      <url>https://maven.aliyun.com/repository/public</url>
    </mirror>

接着可以打开IDEA了，欢迎界面映入眼帘：

新建项目

选择新建Maven项目：

填写项目名和存放位置：

在pom.xml文件中添加仓库配置：

    <repositories>
        <repository>
            <id>public</id>
            <url>https://maven.aliyun.com/repository/public</url>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <url>https://maven.aliyun.com/repository/public</url>
        </pluginRepository>
    </pluginRepositories>

怎么写Go代码

Thu, 01 Jan 2026 00:00:00 +0000

安装过程略过，网上搜一大把。