开发环境搭建 #

一、环境概述 #

1.1 开发环境组成 #

一个完整的Java嵌入式开发环境包括：

text 
┌─────────────────────────────────────────────────────────┐
│                    开发环境架构                          │
├─────────────────────────────────────────────────────────┤
│  开发主机（PC/Mac）                                      │
│  ├── JDK（开发用）                                       │
│  ├── IDE（IntelliJ IDEA / Eclipse / VS Code）           │
│  ├── 构建工具（Maven / Gradle）                          │
│  ├── SSH客户端                                           │
│  └── 交叉编译工具链                                      │
├─────────────────────────────────────────────────────────┤
│  目标设备（嵌入式板卡）                                  │
│  ├── JVM（运行用）                                       │
│  ├── 应用程序                                            │
│  └── 硬件外设                                            │
└─────────────────────────────────────────────────────────┘

1.2 开发模式选择 #

模式 描述 适用场景
本地开发 在目标设备上直接开发 学习、简单项目
交叉开发 在PC开发，部署到设备 生产项目
容器开发 使用Docker容器 团队协作

二、开发主机环境配置 #

2.1 JDK安装 #

Linux/macOS

bash 
# 使用SDKMAN安装
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

# 安装LTS版本
sdk install java 17.0.9-tem

# 验证安装
java -version
javac -version

Windows

  1. 下载JDK：https://adoptium.net/
  2. 选择Temurin 17 LTS版本
  3. 运行安装程序
  4. 配置环境变量：
powershell 
# 设置JAVA_HOME
setx JAVA_HOME "C:\Program Files\Eclipse Adoptium\jdk-17.0.9"
# 添加到PATH
setx PATH "%PATH%;%JAVA_HOME%\bin"

2.2 IDE选择与配置 #

IntelliJ IDEA（推荐）

  1. 下载安装：https://www.jetbrains.com/idea/

  2. 安装插件：

    • Raspberry Pi Support
    • SSH Remote Development

  3. 配置远程部署：

xml 
<!-- .idea/deployment.xml -->
<component name="DeploymentConfiguration">
  <deploymentConfiguration>
    <option name="serverName" value="raspberry-pi" />
    <option name="serverType" value="SFTP" />
    <option name="host" value="192.168.1.100" />
    <option name="port" value="22" />
    <option name="username" value="pi" />
  </deploymentConfiguration>
</component>

VS Code

  1. 安装扩展：

    • Extension Pack for Java
    • Remote - SSH
    • Raspberry Pi

  2. 配置Java环境：

json 
// settings.json
{
    "java.configuration.runtimes": [
        {
            "name": "JavaSE-17",
            "path": "/usr/lib/jvm/temurin-17-jdk",
            "default": true
        }
    ]
}

2.3 构建工具配置 #

Maven配置

xml 
<!-- pom.xml 嵌入式项目基础配置 -->
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>embedded-app</artifactId>
    <version>1.0.0</version>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>com.pi4j</groupId>
            <artifactId>pi4j-core</artifactId>
            <version>2.3.0</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.example.Main</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Gradle配置

groovy 
// build.gradle
plugins {
    id 'java'
    id 'application'
}

java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

application {
    mainClass = 'com.example.Main'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.pi4j:pi4j-core:2.3.0'
    implementation 'com.pi4j:pi4j-plugin-raspberrypi:2.3.0'
    implementation 'com.pi4j:pi4j-plugin-pigpio:2.3.0'
}

jar {
    manifest {
        attributes 'Main-Class': 'com.example.Main'
    }
    from {
        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
    }
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

三、目标设备环境配置 #

3.1 操作系统安装 #

Raspberry Pi OS安装

  1. 下载Raspberry Pi Imager：https://www.raspberrypi.com/software/

  2. 烧录系统：

    • 选择操作系统：Raspberry Pi OS Lite（推荐，无桌面环境）
    • 选择存储设备：microSD卡
    • 高级设置：配置SSH、用户名密码、WiFi

  3. 首次启动配置：

bash 
# 更新系统
sudo apt update && sudo apt upgrade -y

# 配置时区
sudo timedatectl set-timezone Asia/Shanghai

# 配置主机名
sudo hostnamectl set-hostname embedded-java

3.2 JVM安装 #

安装OpenJDK

bash 
# 安装JDK 17
sudo apt install openjdk-17-jdk-headless -y

# 验证安装
java -version

安装优化的JVM（可选）

对于资源受限的设备，可以使用优化版JVM：

bash 
# 安装Zulu Embedded JDK
wget https://cdn.azul.com/zulu-embedded/bin/zulu17.46.19-ca-jdk17.0.10-linux_aarch32hf.tar.gz
sudo tar -xzf zulu17.46.19-ca-jdk17.0.10-linux_aarch32hf.tar.gz -C /opt
sudo ln -s /opt/zulu17.46.19-ca-jdk17.0.10-linux_aarch32hf /opt/java

# 配置环境变量
echo 'export JAVA_HOME=/opt/java' >> ~/.bashrc
echo 'export PATH=$JAVA_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

3.3 GPIO权限配置 #

bash 
# 安装pigpio库（Pi4J依赖）
sudo apt install pigpio -y

# 配置GPIO用户权限
sudo usermod -a -G gpio pi
sudo usermod -a -G spi pi
sudo usermod -a -G i2c pi
sudo usermod -a -G dialout pi

# 配置pigpio服务自启动
sudo systemctl enable pigpiod
sudo systemctl start pigpiod

四、远程开发配置 #

4.1 SSH配置 #

生成SSH密钥

bash 
# 在开发主机上生成密钥
ssh-keygen -t ed25519 -C "embedded-dev"

# 复制公钥到目标设备
ssh-copy-id pi@192.168.1.100

# 配置SSH别名
cat >> ~/.ssh/config << EOF
Host rpi
    HostName 192.168.1.100
    User pi
    IdentityFile ~/.ssh/id_ed25519
EOF

免密登录测试

bash 
ssh rpi

4.2 远程调试配置 #

IDEA远程调试

  1. 创建远程运行配置：
xml 
<!-- Run/Debug Configuration -->
<configuration name="Remote Debug">
    <option name="HOST" value="192.168.1.100" />
    <option name="PORT" value="5005" />
    <option name="AUTO_START" value="false" />
</configuration>
  1. 在目标设备启动应用（调试模式）：
bash 
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar app.jar

VS Code远程开发

json 
// .vscode/launch.json
{
    "version": "0.2.0",
    "configurations": [
        {
            "type": "java",
            "name": "Remote Debug",
            "request": "attach",
            "hostName": "192.168.1.100",
            "port": 5005
        }
    ]
}

4.3 文件同步配置 #

使用rsync同步

bash 
#!/bin/bash
# sync.sh
SOURCE="./target/"
DEST="pi@192.168.1.100:/home/pi/app/"

rsync -avz --delete \
    --exclude '*.log' \
    --exclude '*.tmp' \
    $SOURCE $DEST

echo "Sync completed at $(date)"

使用Maven部署插件

xml 
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <id>deploy</id>
            <phase>install</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target>
                    <scp 
                        file="${project.build.directory}/${project.build.finalName}.jar"
                        todir="pi@192.168.1.100:/home/pi/app"
                        keyfile="${user.home}/.ssh/id_ed25519"
                        trust="yes"/>
                </target>
            </configuration>
        </execution>
    </executions>
    <dependencies>
        <dependency>
            <groupId>org.apache.ant</groupId>
            <artifactId>ant-jsch</artifactId>
            <version>1.10.14</version>
        </dependency>
    </dependencies>
</plugin>

五、开发环境验证 #

5.1 创建测试项目 #

bash 
# 创建项目目录
mkdir embedded-hello && cd embedded-hello

# 创建Maven项目
mvn archetype:generate \
    -DgroupId=com.example \
    -DartifactId=embedded-hello \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DinteractiveMode=false

5.2 编写测试代码 #

java 
package com.example;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class SystemInfo {
    
    public static void main(String[] args) {
        System.out.println("=== Java嵌入式环境检测 ===\n");
        
        printJavaInfo();
        printOsInfo();
        printMemoryInfo();
        printCpuInfo();
        printGpioInfo();
    }
    
    private static void printJavaInfo() {
        System.out.println("【Java环境】");
        System.out.println("  Java版本: " + System.getProperty("java.version"));
        System.out.println("  JVM名称: " + System.getProperty("java.vm.name"));
        System.out.println("  JVM供应商: " + System.getProperty("java.vendor"));
        System.out.println("  Java Home: " + System.getProperty("java.home"));
        System.out.println();
    }
    
    private static void printOsInfo() {
        System.out.println("【操作系统】");
        System.out.println("  OS名称: " + System.getProperty("os.name"));
        System.out.println("  OS版本: " + System.getProperty("os.version"));
        System.out.println("  OS架构: " + System.getProperty("os.arch"));
        System.out.println();
    }
    
    private static void printMemoryInfo() {
        System.out.println("【内存信息】");
        Runtime runtime = Runtime.getRuntime();
        long maxMemory = runtime.maxMemory() / 1024 / 1024;
        long totalMemory = runtime.totalMemory() / 1024 / 1024;
        long freeMemory = runtime.freeMemory() / 1024 / 1024;
        System.out.println("  最大内存: " + maxMemory + " MB");
        System.out.println("  已分配内存: " + totalMemory + " MB");
        System.out.println("  空闲内存: " + freeMemory + " MB");
        System.out.println();
    }
    
    private static void printCpuInfo() {
        System.out.println("【CPU信息】");
        System.out.println("  可用处理器: " + Runtime.getRuntime().availableProcessors());
        
        try (BufferedReader reader = new BufferedReader(new FileReader("/proc/cpuinfo"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.startsWith("model name") || line.startsWith("Model")) {
                    System.out.println("  CPU型号: " + line.split(":")[1].trim());
                    break;
                }
            }
        } catch (IOException e) {
            System.out.println("  无法读取CPU信息");
        }
        System.out.println();
    }
    
    private static void printGpioInfo() {
        System.out.println("【GPIO状态】");
        java.io.File gpioDir = new java.io.File("/sys/class/gpio");
        if (gpioDir.exists()) {
            String[] exported = gpioDir.list((dir, name) -> name.startsWith("gpio"));
            if (exported != null && exported.length > 0) {
                System.out.println("  已导出GPIO: " + String.join(", ", exported));
            } else {
                System.out.println("  暂无导出的GPIO");
            }
        } else {
            System.out.println("  GPIO系统不可用");
        }
    }
}

5.3 编译与部署 #

bash 
# 编译项目
mvn clean package

# 部署到目标设备
scp target/embedded-hello-1.0-SNAPSHOT.jar rpi:/home/pi/

# 远程执行
ssh rpi "java -jar /home/pi/embedded-hello-1.0-SNAPSHOT.jar"

5.4 预期输出 #

text 
=== Java嵌入式环境检测 ===

【Java环境】
  Java版本: 17.0.9
  JVM名称: OpenJDK 64-Bit Server VM
  JVM供应商: Eclipse Adoptium
  Java Home: /usr/lib/jvm/java-17-openjdk-arm64

【操作系统】
  OS名称: Linux
  OS版本: 6.1.0-rpi4-rpi-v8
  OS架构: aarch64

【内存信息】
  最大内存: 954 MB
  已分配内存: 64 MB
  空闲内存: 61 MB

【CPU信息】
  可用处理器: 4
  CPU型号: ARMv7 Processor rev 3 (v7l)

【GPIO状态】
  暂无导出的GPIO

六、常见问题解决 #

6.1 内存不足 #

bash 
# 检查内存状态
free -h

# 增加交换空间
sudo dphys-swapfile swapoff
sudo nano /etc/dphys-swapfile
# 修改 CONF_SWAPSIZE=1024
sudo dphys-swapfile setup
sudo dphys-swapfile swapon

6.2 权限问题 #

bash 
# GPIO权限
sudo chmod -R 777 /sys/class/gpio
sudo chmod -R 777 /dev/gpiomem

# I2C权限
sudo chmod 666 /dev/i2c-*

# SPI权限
sudo chmod 666 /dev/spidev*

6.3 网络问题 #

bash 
# 检查网络连接
ping -c 4 8.8.8.8

# 检查DNS
nslookup google.com

# 重启网络服务
sudo systemctl restart networking

七、总结 #

搭建Java嵌入式开发环境需要配置：

  • 开发主机：JDK、IDE、构建工具
  • 目标设备：操作系统、JVM、GPIO权限
  • 远程开发：SSH、远程调试、文件同步

环境搭建完成后，建议运行系统检测程序验证配置是否正确。下一章我们将编写第一个嵌入式程序，实现LED闪烁功能。

最后更新：2026-03-27