入门基础
什么是Java语言?
Java是一种面向对象的跨平台编程语言,由Sun Microsystems于1995年发布,现为Oracle公司旗下产品。其核心理念是“一次编写,到处运行(Write Once, Run Anywhere)”,通过Java虚拟机(JVM)实现字节码的跨平台执行。
Java语言具有以下显著特点:
- 语法简洁清晰,易于学习和使用
- 自动内存管理机制(垃圾回收GC)
- 丰富的标准类库(Java SE API)
- 强大的多线程支持
- 健壮的安全机制与异常处理体系
- 活跃的开源社区与生态系统
自2004年Java 5引入泛型、注解、枚举等特性后,Java语言持续演进,当前主流版本为Java 17(长期支持版LTS),广泛应用于企业级应用开发、Android移动开发、大数据处理、微服务架构等领域。
Java开发流程全景图
编写一个Java程序通常包括以下步骤:
- 需求分析:明确程序要解决的问题及功能边界
- 设计架构:绘制类图、流程图、时序图等设计文档
- 编写代码:使用文本编辑器或IDE(如IntelliJ IDEA、Eclipse)创建.java源文件
- 编译源码:通过javac命令将.java文件编译为.class字节码文件
- 运行测试:使用java命令执行程序,观察输出结果与预期是否一致
- 调试优化:利用断点调试、日志输出等方式排查问题并优化性能
- 打包部署:使用Maven/Gradle构建工具打包为JAR/WAR,部署到服务器
示例:一个最简Java程序的完整生命周期
// Hello.java
public class Hello {
public static void main(String[] args) {
System.out.println("欢迎学习Java编程!");
}
}
在终端中执行以下命令:
javac Hello.java # 编译生成Hello.class
java Hello # 运行程序,输出:欢迎学习Java编程!
注意:类名需与文件名完全一致(区分大小写),main方法是程序入口点,必须声明为public static void类型,接收String数组参数。
Java语言发展简史
1991年:Oak项目启动
Sun Microsystems团队为消费类电子设备开发Oak语言,后因市场变化转向互联网应用。
1995年:Java正式发布
在SunWorld大会上宣布Java 1.0,提出“Internet的Java”战略,引发全球开发热潮。
2004年:Java 5重大升级
引入泛型、注解、枚举、增强for循环、自动装箱/拆箱等现代特性,大幅提升开发效率。
2014年:Java 8里程碑版本
首次引入Lambda表达式与Stream API,支持函数式编程风格,彻底改变开发范式。
2017年:模块化系统JPMS
Java 9发布模块化特性(Module System),提升大型系统可维护性与安全性。
2021年:Java 17 LTS
当前主流长期支持版本,新增密封类、模式匹配、文本块增强等实用特性。
环境配置
开发环境搭建指南
搭建Java开发环境需完成以下三步:
- 安装JDK:下载并安装对应操作系统的JDK(Java Development Kit)
- 配置环境变量:设置JAVA_HOME、PATH、CLASSPATH(现代JDK可省略CLASSPATH)
- 验证安装:在终端执行java -version与javac -version确认版本信息
Windows系统配置示例:
- 下载JDK安装包(如jdk-17_windows-x64_bin.exe)
- 安装至目录如:C:\Program Files\Java\jdk-17
- 系统环境变量添加:
- JAVA_HOME = C:\Program Files\Java\jdk-17
- PATH追加:;%JAVA_HOME%\bin
- 重启终端,执行:
java -version javac -version
macOS/Linux配置示例:
- 使用Homebrew(macOS)或包管理器(Linux)安装:
brew install openjdk@17 # macOS sudo apt install openjdk-17-jdk # Ubuntu/Debian - 配置bash/zsh配置文件(~/.bashrc或~/.zshrc):
export JAVA_HOME=$(/usr/libexec/java_home -v 17) # macOS export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64 # Linux export PATH=$JAVA_HOME/bin:$PATH - 执行source命令使配置生效:
source ~/.bashrc # 或 source ~/.zshrc
主流IDE推荐
虽然可用文本编辑器编写Java程序,但专业IDE能大幅提升开发效率:
| IDE名称 | 特点 | 适用场景 |
|---|---|---|
| IntelliJ IDEA Ultimate | 功能最全,支持Spring全栈、数据库工具、Docker集成 | 企业级Java开发首选 |
| IntelliJ IDEA Community | 免费基础版,支持核心Java开发 | 学习与轻量项目开发 |
| Eclipse | 老牌IDE,插件生态丰富,内存占用较高 | 历史项目维护与定制开发 |
| VS Code + Java Extension Pack | 轻量级编辑器+Java支持,启动快速 | 快速编辑与远程开发 |
| NetBeans | Oracle官方IDE,对JavaFX支持良好 | 桌面应用与教学实验 |
推荐组合:初学者可选用IntelliJ IDEA Community(免费)+ OpenJDK 17,后续进阶可升级至Ultimate版本。
命令行开发流程详解
即使使用IDE,掌握命令行开发仍至关重要:
- 创建项目目录:
mkdir -p ~/java-projects/hello/src cd ~/java-projects/hello - 编写源代码(src/com/example/Hello.java):
package com.example; public class Hello { public static void main(String[] args) { System.out.println("Hello, Java!"); } } - 编译源码:
javac -d out src/com/example/Hello.java - 运行程序:
java -cp out com.example.Hello
项目结构规范:
- 源代码存放于src目录
- 包名与目录结构严格对应(com.example对应src/com/example)
- 编译输出至out目录(避免污染源码)
- 运行时指定类路径(-cp)与完整类名(含包名)
基础语法
核心语法要素
Java程序由以下基本元素构成:
- 关键字:如class、public、static、void、if、for等,共50个(含保留字)
- 标识符:变量、方法、类名等命名规则:
- 首字符必须为字母、下划线或美元符号
- 后续字符可包含数字
- 区分大小写
- 避免使用Java关键字
- 数据类型:
- 基本类型:byte(1字节)、short(2)、int(4)、long(8)、float(4)、double(8)、char(2)、boolean(1位)
- 引用类型:类、接口、数组
- 运算符:算术、关系、逻辑、位、赋值、条件等10余类
- 控制流:if-else、switch-case、for、while、do-while、break/continue
示例:变量声明与基本运算
public class VariableDemo {
public static void main(String[] args) {
// 整数类型
byte b = 127;
int count = 1000;
long large = 10000000000L;
// 浮点类型
float price = 19.99f;
double pi = 3.141592653589793;
// 字符与字符串
char grade = 'A';
String name = "Java";
// 布尔类型
boolean isPass = true;
// 运算示例
int sum = count + 500;
boolean check = (price > 10) && (grade == 'A');
System.out.println("总和:" + sum);
System.out.println("检查结果:" + check);
}
}
数组与字符串操作
一维数组声明与初始化:
int[] numbers = new int[5]; // 声明长度为5的整型数组
int[] primes = {2, 3, 5, 7, 11}; // 直接初始化
int[] squares = new int[]{1, 4, 9, 16}; // 匿名数组
二维数组示例:
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println(matrix[1][2]); // 输出:6
字符串常用操作:
length():获取字符串长度charAt(int index):获取指定位置字符substring(int start, int end):截取子串equals(Object obj):比较字符串内容toUpperCase()/toLowerCase():大小写转换trim():去除首尾空白split(String regex):按分隔符拆分
示例:字符串处理
String text = " Java编程入门 ";
String trimmed = text.trim(); // "Java编程入门"
String[] parts = trimmed.split("编程"); // ["Java", "入门"]
System.out.println(parts[0].toUpperCase()); // "JAVA"
方法定义与重载机制
Java方法是执行特定任务的代码块,定义格式为:
访问修饰符 返回类型 方法名(参数列表) {
方法体
return 返回值;
}
方法重载规则:
- 方法名相同
- 参数列表不同(类型、数量或顺序)
- 与返回类型无关
- 可改变访问修饰符
示例:重载方法
public class MathUtil {
// 计算两数之和
public static int sum(int a, int b) {
return a + b;
}
// 计算三数之和
public static int sum(int a, int b, int c) {
return a + b + c;
}
// 计算双精度浮点数之和
public static double sum(double a, double b) {
return a + b;
}
}
面向对象编程
三大核心特性
Java是纯面向对象语言,其核心特性包括:
封装(Encapsulation)
将数据(属性)与操作数据的方法绑定为整体,并隐藏内部实现细节。通过private修饰符限制访问,提供public getter/setter方法控制数据读写。
示例:
public class Person {
private String name;
private int age;
// 公共访问方法
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) {
if (age >= 0 && age <= 150) {
this.age = age;
} else {
System.out.println("年龄无效!");
}
}
}
继承(Inheritance)
子类继承父类的属性和方法,实现代码复用。Java仅支持单继承,通过implements关键字实现接口多实现。
示例:
public class Animal {
protected String name;
public void eat() {
System.out.println(name + "正在进食");
}
}
public class Dog extends Animal {
public Dog(String name) {
this.name = name;
}
// 重写父类方法
@Override
public void eat() {
System.out.println(name + "狼吞虎咽地吃骨头");
}
// 新增特有方法
public void bark() {
System.out.println(name + "汪汪叫");
}
}
多态(Polymorphism)
同一操作作用于不同对象时,可产生不同执行结果。通过方法重写与向上转型实现。
示例:
Animal dog = new Dog("旺财"); // 向上转型
dog.eat(); // 输出:旺财狼吞虎咽地吃骨头
运行时动态绑定机制使程序具备良好扩展性,是设计模式实现的基础。
构造器与this关键字
构造器特点:
- 方法名与类名完全相同
- 无返回类型声明(不写void)
- 创建对象时自动调用
- 可重载多个构造器
示例:带参数构造器
public class Student {
private String id;
private String name;
private int score;
// 无参构造器
public Student() {}
// 全参构造器
public Student(String id, String name, int score) {
this.id = id;
this.name = name;
this.score = score;
}
// 构造器链式调用
public Student(String id, String name) {
this(id, name, 0); // 调用三参数构造器
}
}
this关键字用途:
- 区分成员变量与局部变量(如this.name = name)
- 调用其他构造器(必须在首行)
- 作为方法返回值(链式调用)
- 传递当前对象引用
抽象类与接口对比
| 特性 | 抽象类 | 接口 |
|---|---|---|
| 定义关键字 | abstract class | interface |
| 构造器 | 可有(但不可实例化) | 不可有 |
| 成员变量 | 可有各种修饰符 | 默认public static final |
| 方法实现 | 可有抽象/具体方法 | JDK8+支持default/static方法 |
| 继承/实现 | 单继承 | 多实现 |
| 设计目的 | 代码复用与模板定义 | 行为规范与解耦 |
接口默认方法示例:
public interface Flyable {
void fly();
// 默认方法(JDK8+)
default void land() {
System.out.println("安全着陆");
}
// 静态方法(JDK8+)
static void maxSpeed() {
System.out.println("最高速度:800km/h");
}
}
集合框架
集合体系总览
Java集合框架(Java Collections Framework)提供统一接口操作对象集合:
- Collection(单值集合):
- List(有序可重复):ArrayList、LinkedList、Vector
- Set(无序不重复):HashSet、LinkedHashSet、TreeSet
- Map(键值对集合):HashMap、LinkedHashMap、TreeMap、ConcurrentHashMap
核心接口对比:
| 接口 | 有序 | 可重复 | 线程安全 | 典型实现 |
|---|---|---|---|---|
| ArrayList | ✓ | ✓ | ✗ | 动态数组 |
| LinkedList | ✓ | ✓ | ✗ | 双向链表 |
| HashSet | ✗ | ✗ | ✗ | 哈希表 |
| TreeSet | ✓(排序) | ✗ | ✗ | 红黑树 |
| HashMap | ✗ | ✓(值) | ✗ | 哈希表 |
| ConcurrentHashMap | ✗ | ✓(值) | ✓ | 分段锁哈希表 |
常用集合操作示例
List操作:
import java.util.*;
List names = new ArrayList<>();
names.add("张三");
names.add("李四");
names.add(1, "王五"); // 指定位置插入
System.out.println(names.get(1)); // 输出:王五
System.out.println(names.size()); // 输出:3
// 增强for循环遍历
for (String name : names) {
System.out.println(name);
}
// Lambda表达式遍历(JDK8+)
names.forEach(name -> System.out.println(name));
Map操作:
Map scores = new HashMap<>();
scores.put("语文", 95);
scores.put("数学", 92);
// 获取值
System.out.println(scores.get("语文")); // 输出:95
// 遍历键值对
scores.forEach((subject, score) ->
System.out.println(subject + ": " + score)
);
泛型机制详解
泛型(Generics)将类型参数化,提高代码复用性与类型安全:
- 泛型类:class Box<T> { private T value; }
- 泛型方法:public <T> void print(T item)
- 通配符:?、? extends T、? super T
自定义泛型类示例
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
public void setKey(K key) { this.key = key; }
public void setValue(V value) { this.value = value; }
}
// 使用示例
Pair<String, Integer> pair = new Pair<>("年龄", 25);
System.out.println(pair.getKey() + " = " + pair.getValue());
多线程编程
线程创建方式
Java创建线程主要有三种方式:
- 继承Thread类:
class MyThread extends Thread { public void run() { System.out.println("线程执行中..."); } } new MyThread().start(); - 实现Runnable接口(推荐):
class MyRunnable implements Runnable { public void run() { System.out.println("线程执行中..."); } } new Thread(new MyRunnable()).start(); - 实现Callable接口(JDK5+):
class MyCallable implements Callable<String> { public String call() { return "计算结果"; } } FutureTask<String> task = new FutureTask<>(new MyCallable()); new Thread(task).start(); System.out.println(task.get());
推荐使用Runnable/Callable:避免单继承局限,支持多线程共享同一任务对象。
线程同步机制
多线程并发访问共享资源时需保证线程安全:
- synchronized关键字:
- 修饰方法:public synchronized void method()
- 代码块:synchronized(this) { ... }
- ReentrantLock类(JDK5+):
Lock lock = new ReentrantLock(); lock.lock(); try { // 临界区代码 } finally { lock.unlock(); } - volatile关键字:保证变量可见性,禁止指令重排序
生产者-消费者示例:
class Buffer {
private int data;
private boolean available = false;
public synchronized void put(int value) {
while (available) {
wait(); // 等待消费者消费
}
data = value;
available = true;
notifyAll(); // 唤醒等待线程
}
public synchronized int take() {
while (!available) {
wait(); // 等待生产者生产
}
available = false;
notifyAll();
return data;
}
}
线程池与Executor框架
手动管理线程易出错,推荐使用线程池:
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.execute(() -> System.out.println("任务1"));
pool.submit(() -> "任务2"); // 返回Future
pool.shutdown(); // 关闭线程池
线程池类型:
- newFixedThreadPool:固定大小线程池
- newCachedThreadPool:可缓存线程池
- newSingleThreadExecutor:单线程池
- newScheduledThreadPool:定时任务线程池
自定义线程池(推荐):
ThreadPoolExecutor pool = new ThreadPoolExecutor(
4, // 核心线程数
8, // 最大线程数
60L, TimeUnit.SECONDS, // 空闲线程存活时间
new LinkedBlockingQueue<>(100), // 任务队列
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);
数据库连接
JDBC核心操作流程
JDBC(Java Database Connectivity)提供统一API操作关系型数据库:
- 加载驱动:Class.forName("com.mysql.cj.jdbc.Driver")
- 获取连接:Connection conn = DriverManager.getConnection(url, user, pwd)
- 创建语句:Statement stmt = conn.createStatement()
- 执行查询:ResultSet rs = stmt.executeQuery(sql)
- 处理结果:遍历ResultSet获取数据
- 关闭资源:依次关闭ResultSet、Statement、Connection
完整示例(MySQL)
import java.sql.*;
public class JdbcDemo {
public static void main(String[] args) throws SQLException {
String url = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
String user = "root";
String password = "123456";
try (Connection conn = DriverManager.getConnection(url, user, password);
PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE age > ?");
ResultSet rs = stmt.executeQuery()) {
stmt.setInt(1, 18);
while (rs.next()) {
System.out.println(rs.getInt("id") + ": " + rs.getString("name"));
}
}
}
}
连接池与Druid配置
生产环境推荐使用连接池(如Druid、HikariCP):
Druid配置示例:
import com.alibaba.druid.pool.DruidDataSource;
import java.sql.Connection;
DruidDataSource ds = new DruidDataSource();
ds.setUrl("jdbc:mysql://localhost:3306/test");
ds.setUsername("root");
ds.setPassword("123456");
ds.setInitialSize(5);
ds.setMaxActive(20);
ds.setMaxWait(60000);
try (Connection conn = ds.getConnection()) {
// 执行数据库操作
}
关键配置参数:
- initialSize:初始连接数
- maxActive:最大活跃连接数
- maxWait:获取连接最大等待时间(毫秒)
- minIdle:最小空闲连接数
- validationQuery:连接有效性检测SQL
事务处理机制
JDBC事务控制通过Connection对象实现:
- 关闭自动提交:conn.setAutoCommit(false)
- 提交事务:conn.commit()
- 回滚事务:conn.rollback()
- 设置保存点:conn.setSavepoint()
事务处理示例
try {
conn.setAutoCommit(false);
// 操作1:转账扣款
stmt.executeUpdate("UPDATE accounts SET balance = balance - 100 WHERE id = 1");
// 操作2:转账入账
stmt.executeUpdate("UPDATE accounts SET balance = balance + 100 WHERE id = 2");
conn.commit(); // 提交事务
} catch (SQLException e) {
conn.rollback(); // 回滚事务
throw e;
} finally {
conn.setAutoCommit(true);
}
Spring框架
Spring核心概念
Spring是Java企业级开发的轻量级框架,核心特性包括:
- 控制反转(IoC):对象创建与依赖关系由容器管理
- 依赖注入(DI):通过构造器/Setter注入依赖
- 面向切面编程(AOP):分离横切关注点(日志、事务等)
- 声明式事务:通过注解简化事务管理
IoC容器示例
// 定义Bean
@Component
public class UserService {
@Autowired
private UserRepository userRepository;
public User getUser(Long id) {
return userRepository.findById(id);
}
}
// 配置类
@Configuration
@ComponentScan("com.example")
public class AppConfig {}
// 容器启动
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);
Spring Boot快速开发
Spring Boot简化Spring应用初始搭建与开发:
- 自动配置:基于classpath自动配置Spring
- 起步依赖:简化Maven配置
- 内嵌Tomcat:无需部署WAR文件
- Actuator监控:提供健康检查、指标收集
Hello World示例
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "Hello, Spring Boot!";
}
}
application.yml配置:
server:
port: 8080
spring:
datasource:
url: jdbc:mysql://localhost:3306/demo
username: root
password: 123456
jpa:
hibernate:
ddl-auto: update
show-sql: true
Spring Data JPA高效开发
Spring Data JPA简化数据库访问:
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
// 自定义查询方法
List<User> findByName(String name);
// 使用@Query自定义SQL
@Query("SELECT u FROM User u WHERE u.age > ?1")
List<User> findAdults(int age);
}
实体类定义
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private Integer age;
// getters and setters
}
实战项目
项目结构设计
典型Java Web项目分层结构:
- 表现层(Controller):处理HTTP请求,返回视图或JSON
- 业务层(Service):实现业务逻辑,事务管理
- 数据访问层(DAO):与数据库交互
- 实体层(Entity):ORM映射数据库表
- 工具层(Util):通用工具类(日期、加密、验证)
目录结构示例
src/main/java
├── com.example.project
│ ├── controller # 控制器层
│ │ └── UserController.java
│ ├── service # 业务层
│ │ └── UserService.java
│ │ └── impl # 实现类
│ │ └── UserServiceImpl.java
│ ├── dao # 数据访问层
│ │ └── UserRepository.java
│ ├── entity # 实体类
│ │ └── User.java
│ ├── util # 工具类
│ │ └── DateUtils.java
│ └── ProjectApplication.java # 启动类
RESTful API设计规范
遵循RESTful风格的API设计原则:
- 资源命名:使用名词复数(/users),避免动词
- HTTP方法:
- GET:获取资源
- POST:创建资源
- PUT:更新资源(全量)
- PATCH:更新资源(部分)
- DELETE:删除资源
- 状态码:
- 200:请求成功
- 201:资源创建成功
- 400:请求参数错误
- 404:资源不存在
- 500:服务器内部错误
Spring Boot控制器示例
@RestController
@RequestMapping("/api/users")
public class UserController {
@Autowired
private UserService userService;
// 获取用户列表
@GetMapping
public List<User> getAllUsers() {
return userService.findAll();
}
// 创建用户
@PostMapping
public ResponseEntity<User> createUser(@RequestBody User user) {
User saved = userService.save(user);
return ResponseEntity.status(HttpStatus.CREATED).body(saved);
}
// 更新用户
@PutMapping("/{id}")
public ResponseEntity<User> updateUser(@PathVariable Long id,
@RequestBody User user) {
user.setId(id);
User updated = userService.update(user);
return ResponseEntity.ok(updated);
}
}
项目构建与部署
Maven配置(pom.xml)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.12</version>
</parent>
<groupId>com.example</groupId>
<artifactId>demo-project</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
构建与运行
# 构建JAR包
mvn clean package -DskipTests
# 运行应用
java -jar target/demo-project-1.0.0.jar
# 指定配置文件
java -jar demo-project.jar --spring.profiles.active=prod
常见问题
- Q1:Java和JavaScript有什么区别?
Java是静态类型、编译型、面向对象的语言,主要用于后端开发;JavaScript是动态类型、解释型、基于原型的语言,主要用于前端浏览器交互。两者仅在语法上部分相似,本质完全不同。
- Q2:如何选择Java版本?
生产环境建议使用LTS版本:Java 8(2014)、Java 11(2018)、Java 17(2021)。新项目优先选择Java 17,老项目可平滑升级至Java 11或17。避免使用非LTS版本(如Java 9-10、12-16)。
- Q3:IDEA和Eclipse如何选择?
初学者推荐IntelliJ IDEA Community(免费版),界面友好、智能提示强;企业开发建议使用Ultimate版(付费),支持Spring全栈开发。Eclipse适合历史项目维护,内存占用较高但插件丰富。
- Q4:如何解决OOM(内存溢出)问题?
常见原因:堆内存不足、线程栈溢出、Metaspace溢出。解决方案:
- 调整JVM参数:-Xmx(最大堆)、-Xms(初始堆)、-Xss(线程栈)
- 使用VisualVM或JProfiler分析内存泄漏
- 优化代码:避免大对象、及时释放资源、使用对象池
- Q5:Spring Boot如何配置多环境?
通过application-{profile}.yml区分环境:
- application-dev.yml(开发环境)
- application-test.yml(测试环境)
- application-prod.yml(生产环境)
网友还关心
- Java学习路线:基础语法 → 面向对象 → 集合框架 → 多线程 → JDBC → Spring → Spring Boot → 微服务 → 分布式
- 就业方向:Web后端开发、Android应用开发、大数据工程师、云计算开发、测试开发
- 薪资水平:初级Java工程师(8-12K)、中级(15-25K)、高级(30K+),一线城市溢价30%-50%
- 必备技能:熟练使用Git、理解Linux命令、掌握SQL、了解Docker、熟悉RESTful API设计
- 开发工具:IntelliJ IDEA、Git、Maven、Postman、Navicat、Jenkins
学习资源推荐
- 官方文档:
- Java SE API文档:https://docs.oracle.com/en/java/javase/17/docs/api/
- Spring Framework文档:https://spring.io/projects/spring-framework
- 开源项目:
- Spring Boot官方示例:https://github.com/spring-projects/spring-boot/tree/main/spring-boot-samples
- Java技术栈:https://github.com/itwanger/toBeBetterJavaer
- 在线学习:
- 菜鸟教程Java教程:https://www.runoob.com/java/java-tutorial.html
- 慕课网Java课程:https://www.imooc.com/learn/158