Spring Boot入门教程

Posted on 2025-08-24 Edited on 2025-09-04

Spring Boot入门教程

1. Spring Boot简介

Spring Boot是基于Spring框架的快速开发框架，它简化了Spring应用的配置和部署，使开发者可以更快地构建独立、生产级别的Spring应用。

核心特点：

快速入门：内置默认配置，减少样板代码。
嵌入式服务器：如Tomcat、Jetty，无需外部部署。
自动配置：根据依赖自动配置应用。
生产级特性：监控、健康检查、日志等开箱即用。

2. 搭建Spring Boot项目

方式1：使用Spring Initializr

打开 https://start.spring.io/
选择项目类型（Maven/Gradle）、Spring Boot版本、项目元信息
添加依赖（如Spring Web、Spring Data JPA）
生成并下载项目，导入IDE（如IntelliJ IDEA）

方式2：使用IDE直接创建

以IntelliJ IDEA为例：

新建项目 -> Spring Initializr
配置项目基本信息
选择依赖 -> 完成创建

3. Spring Boot主类

每个Spring Boot应用都有一个主类，使用@SpringBootApplication注解。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

说明：

@SpringBootApplication是组合注解，包括@Configuration、@EnableAutoConfiguration和@ComponentScan
SpringApplication.run启动应用

4. 创建REST接口

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

运行应用后，访问 http://localhost:8080/hello 可以看到返回结果。

5. 配置文件

Spring Boot默认使用application.properties或application.yml管理配置。

示例：

1 2	server.port=8081 spring.application.name=demo-app

修改端口或应用名称即可生效。

6. 常用注解

@RestController：标识REST控制器
@RequestMapping / @GetMapping / @PostMapping：映射HTTP请求
@Service：业务逻辑层
@Repository：数据访问层
@Autowired：自动注入依赖

7. Spring Boot特性

自动配置：减少手动配置，快速上手
嵌入式服务器：应用独立运行，无需外部容器
Actuator监控：提供健康、性能等监控接口
依赖管理：统一版本控制，避免依赖冲突

8. 总结

Spring Boot大大简化了Spring应用的开发流程，使得开发者可以专注于业务逻辑，而不用过多关注配置和部署。通过快速搭建、自动配置和嵌入式服务器，开发和发布现代Java应用变得更加高效。

Java反射教程

Posted on 2025-08-24 Edited on 2025-09-04

Java反射（Reflection）教程

1. 反射简介

Java反射机制允许程序在运行时动态获取类的信息，并可访问类的构造方法、字段、方法等。反射广泛应用于框架开发、依赖注入、序列化以及动态代理。

核心特点：

可以动态加载类
可以访问类的私有成员
可以在运行时实例化对象、调用方法

2. 获取Class对象

反射的第一步是获取目标类的Class对象：

// 方式1: 通过类名.class
Class<String> clazz1 = String.class;

// 方式2: 通过对象实例
String str = "hello";
Class<?> clazz2 = str.getClass();

// 方式3: 通过Class.forName()
Class<?> clazz3 = Class.forName("java.lang.String");

3. 获取构造方法并实例化对象

import java.lang.reflect.Constructor;

class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public void sayHello() {
        System.out.println("Hello, " + name);
    }
}

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Class<Person> clazz = Person.class;
        Constructor<Person> constructor = clazz.getConstructor(String.class);
        Person p = constructor.newInstance("张三");
        p.sayHello(); // 输出: Hello, 张三
    }
}

4. 访问字段（Field）

可以通过反射访问类的字段，包括私有字段：

import java.lang.reflect.Field;

Field field = clazz.getDeclaredField("name");
field.setAccessible(true); // 设置可访问私有字段
field.set(p, "李四");
System.out.println(field.get(p)); // 输出: 李四

5. 调用方法（Method）

通过反射获取方法并调用：

import java.lang.reflect.Method;

Method method = clazz.getMethod("sayHello");
method.invoke(p); // 输出: Hello, 李四

对于私有方法，使用getDeclaredMethod并设置setAccessible(true)。

6. 获取类的元数据

// 获取所有方法
Method[] methods = clazz.getMethods();
for(Method m : methods) {
    System.out.println(m.getName());
}

// 获取所有字段
Field[] fields = clazz.getDeclaredFields();
for(Field f : fields) {
    System.out.println(f.getName());
}

// 获取父类
Class<?> superClass = clazz.getSuperclass();
System.out.println(superClass.getName());

7. 注意事项

性能开销：反射会绕过编译期检查，运行效率较低，不适合高频调用场景。
安全性：反射可访问私有成员，需注意安全风险。
泛型信息：反射获取的类信息是原始类型，泛型信息会被擦除。

8. 总结

Java反射提供了强大的运行时动态操作能力，使程序在运行时可以分析类结构、动态调用方法和操作对象。它是许多Java框架（如Spring、MyBatis）底层实现的基础，但在使用时需注意性能和安全性。

Java内存溢出教程

Posted on 2025-08-24 Edited on 2025-09-04

Java内存溢出 (OutOfMemoryError) 教程

1. 内存溢出简介

在Java中，**内存溢出（OutOfMemoryError）**是指JVM在运行过程中无法为对象分配足够内存时抛出的错误。常见原因包括：

对象持续增加，堆内存不足
无限递归导致栈空间耗尽
资源未及时释放导致内存泄漏

内存溢出不同于普通异常，它是Error的一种，一般不通过try-catch处理，而是通过优化程序和配置JVM来解决。

2. JVM内存结构概览

JVM主要内存区域：

堆（Heap）：存放对象实例
方法区（Method Area）：存放类信息、常量、静态变量
栈（Stack）：存放方法调用及局部变量
本地方法栈（Native Stack）
程序计数器（PC Register）

堆内存不足会抛出java.lang.OutOfMemoryError: Java heap space。
栈空间不足会抛出java.lang.StackOverflowError。

3. 堆内存溢出示例

import java.util.ArrayList;
import java.util.List;

public class HeapOOM {
    public static void main(String[] args) {
        List<int[]> list = new ArrayList<>();
        while (true) {
            list.add(new int[1024 * 1024]); // 持续分配大数组
        }
    }
}

运行时会很快抛出：

1	Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

解决方法：

优化代码，减少对象创建
使用集合时注意容量，及时释放引用
增加堆内存：-Xmx512m

4. 栈内存溢出示例

public class StackOverflow {
    public static void recursive() {
        recursive(); // 无限递归
    }

    public static void main(String[] args) {
        recursive();
    }
}

运行时会抛出：

1	Exception in thread "main" java.lang.StackOverflowError

解决方法：

检查递归出口，避免无限递归
调整栈大小：-Xss1m

5. 元空间/方法区溢出

对于类加载过多或动态生成类的情况，可能会抛出：

1	java.lang.OutOfMemoryError: Metaspace

解决方法：

优化类加载和动态代理生成的类
调整元空间大小：-XX:MaxMetaspaceSize=256m

6. 内存泄漏示例

即使对象不再使用，如果仍然有引用，GC无法回收，会导致堆内存逐渐耗尽。

import java.util.ArrayList;
import java.util.List;

public class MemoryLeak {
    private static List<Object> leakList = new ArrayList<>();

    public static void main(String[] args) {
        while (true) {
            leakList.add(new Object()); // 持续添加对象导致堆溢出
        }
    }
}

解决方法：

避免静态集合无限增长
手动释放不再使用的对象引用
使用内存分析工具 (如VisualVM, MAT) 进行排查

7. 总结

Java内存溢出是程序性能和稳定性的重要问题。通过理解JVM内存结构、优化代码逻辑、及时释放对象引用以及合理配置JVM参数，可以有效减少内存溢出发生。对于大规模应用，还可使用内存分析工具进行定位和优化。

Java异常处理教程

Posted on 2025-08-24 Edited on 2025-09-04

Java异常处理

1. 异常简介

在Java中，**异常（Exception）**是程序运行过程中发生的不正常情况，例如除零、数组越界、文件未找到等。异常处理的目的是提高程序的健壮性，让程序在出现错误时能够被捕获并正确处理，而不是直接崩溃。

异常分类

检查异常（Checked Exception）：编译器要求必须处理的异常，如IOException。
非检查异常（Unchecked Exception）：运行时异常，如NullPointerException、ArrayIndexOutOfBoundsException。
错误（Error）：系统级问题，如OutOfMemoryError，一般不处理。

2. try-catch语句

try-catch用于捕获和处理异常。

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int a = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("捕获到异常: " + e);
        }
        System.out.println("程序继续运行");
    }
}

说明：

try块中放可能产生异常的代码。
catch块用于捕获指定异常并处理。
程序不会因为异常崩溃，仍可继续执行后续代码。

3. 多个catch块

可以针对不同类型异常使用多个catch块。

try {
    int[] arr = new int[3];
    System.out.println(arr[5]);
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("数组越界: " + e);
} catch (Exception e) {
    System.out.println("其他异常: " + e);
}

4. finally语句

finally块中的代码无论是否发生异常都会执行，常用于释放资源。

try {
    System.out.println("打开文件");
} catch (Exception e) {
    System.out.println("处理异常");
} finally {
    System.out.println("关闭文件");
}

5. throws关键字

方法声明中使用throws表示可能抛出的异常，需要调用者处理。

import java.io.*;

public class ThrowsExample {
    public static void readFile() throws IOException {
        FileReader file = new FileReader("test.txt");
        file.read();
        file.close();
    }

    public static void main(String[] args) {
        try {
            readFile();
        } catch (IOException e) {
            System.out.println("捕获到IO异常: " + e);
        }
    }
}

6. throw关键字

throw用于手动抛出异常。

public class ThrowExample {
    public static void checkAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("未满18岁");
        } else {
            System.out.println("年龄合法");
        }
    }

    public static void main(String[] args) {
        checkAge(15);
    }
}

7. 自定义异常

可以通过继承Exception类来创建自定义异常。

class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

public class CustomExceptionExample {
    public static void test(int number) throws MyException {
        if (number < 0) {
            throw new MyException("数字不能为负数");
        }
        System.out.println("数字合法");
    }

    public static void main(String[] args) {
        try {
            test(-5);
        } catch (MyException e) {
            System.out.println("捕获自定义异常: " + e.getMessage());
        }
    }
}

8. 总结

Java提供了丰富的异常处理机制，包括try-catch-finally、throw和throws以及自定义异常，使得程序在面对错误时更安全、可靠。掌握异常处理是写出健壮Java程序的关键。

Java基础介绍

Posted on 2025-08-24 Edited on 2025-09-04

Java基础介绍

1. Java简介

Java是一种广泛使用的面向对象编程语言，由Sun Microsystems在1995年发布，现在由Oracle公司维护和发展。它具有跨平台、面向对象、安全性强等特点，广泛应用于企业级开发、移动端(Android)、大数据以及后端服务器开发。

核心特性：

跨平台：一次编写，到处运行（Write Once, Run Anywhere）。
面向对象：支持封装、继承和多态。
内存管理：拥有垃圾回收机制（GC）。
丰富的类库：Java提供了庞大的标准库，涵盖网络、并发、数据库、UI等。

2. Java开发环境搭建

下载JDK：访问Oracle官网或OpenJDK下载对应版本的JDK。
安装JDK：按照提示安装，并配置环境变量JAVA_HOME、PATH。
验证安装：在终端输入：
1
2
java -version
javac -version
出现版本信息说明安装成功。

3. Java程序结构

一个最基本的Java程序：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

说明：

public class HelloWorld：定义了一个类。
public static void main(String[] args)：主方法，程序入口。
System.out.println：输出内容到控制台。

4. 基本语法

变量与数据类型

int age = 20;           // 整数类型
double price = 19.99;   // 浮点数
char grade = 'A';       // 字符
boolean isOk = true;    // 布尔值
String name = "Java";   // 字符串

条件语句

if (age >= 18) {
    System.out.println("成年人");
} else {
    System.out.println("未成年");
}

循环语句

for (int i = 0; i < 5; i++) {
    System.out.println("第" + i + "次循环");
}

int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

方法

public static int add(int a, int b) {
        return a + b;
        }

public static void main(String[] args) {
        int sum = add(3, 5);
        System.out.println("结果: " + sum);
        }

5. 面向对象基础

类与对象

class Person {
    String name;
    int age;

    void sayHello() {
        System.out.println("你好，我是" + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.name = "张三";
        p.age = 25;
        p.sayHello();
    }
}

封装

使用private关键字隐藏数据，通过getter和setter访问：

class Student {
    private String name;

    public String getName() {
        return name;
    }

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

继承

class Animal {
    void eat() {
        System.out.println("动物在吃");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("狗在叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.bark();
    }
}

多态

class Animal {
    void sound() {
        System.out.println("动物叫");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.sound();  // 输出: 喵喵
    }
}

6. 总结

Java是一门功能强大且应用广泛的语言，掌握其基础语法和面向对象思想是进一步学习的关键。通过不断练习，你可以逐步深入学习Java集合、异常处理、并发、多线程、网络编程、Spring框架等高级内容。