Java全栈教程：从入门到初级实战-原创手记-慕课网

概述

Java全栈教程涵盖了从基础入门到实战项目的全过程，包括Java基础语法、面向对象编程、Web开发技术、数据库操作、前后端集成等。本文将详细介绍如何安装Java开发环境并编写第一个Java程序，同时探讨Spring Boot、Vue.js等现代框架的使用方法。此外，还将通过一个简单的实战项目演示如何构建一个完整的Java全栈应用，包括用户注册、登录、数据操作等功能。

Java全栈教程：从入门到初级实战

Java基础入门

Java简介

Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）于1995年推出。Java的特性包括平台无关性、安全性、面向对象和强大的网络功能。它被广泛应用于Web开发、桌面应用程序、移动应用开发等领域。

安装Java开发环境

要开始编写Java程序，你需要安装Java开发工具包（JDK）。以下是安装步骤：

访问Oracle官网下载JDK安装包。
运行下载的安装程序，按照提示完成安装。
配置环境变量。在安装过程中，检查是否自动配置了环境变量。如果没有，手动配置：
- 在Windows系统中，编辑“系统属性”的“环境变量”设置。
- 在Linux或Mac系统中，编辑~/.bashrc或~/.bash_profile文件，添加以下环境变量：
```
export JAVA_HOME=/path/to/java
export PATH=$JAVA_HOME/bin:$PATH
```
验证安装是否成功。打开命令行工具，输入java -version命令，应该会显示Java版本信息。

第一个Java程序

编写一个简单的Java程序来输出“Hello, World!”。按照以下步骤操作：

使用文本编辑器创建一个新的.java文件，例如HelloWorld.java。

输入以下代码：

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

保存文件并关闭编辑器。
打开命令行工具，导航到保存文件的位置。
编译该Java文件：
```
javac HelloWorld.java
```
运行编译后的程序：
```
java HelloWorld
```
在命令行中查看运行结果，应该会看到输出“Hello, World!”。

Java基本语法

Java的基本语法包括变量声明、数据类型、流程控制语句等。下面介绍一些基本语法示例：

变量与数据类型

在Java中，可以定义各种类型的数据，如整数、浮点数、字符和布尔类型。以下是一个变量声明和赋值的示例：

int age = 25;
float weight = 68.5f;
char grade = 'A';
boolean isPassed = true;

流程控制语句

Java支持多种流程控制语句，包括条件语句、循环语句等。以下是条件语句和循环语句的示例：

条件语句：

int num = 10;
if (num > 5) {
    System.out.println("num is greater than 5.");
} else {
    System.out.println("num is less than or equal to 5.");
}

循环语句：

for (int i = 1; i <= 5; i++) {
    System.out.println("Iteration " + i);
}

int j = 1;
while (j <= 5) {
    System.out.println("Iteration " + j);
    j++;
}

数据类型和变量

在Java中，所有数据都是对象，除了基本数据类型（即原始数据类型）以外。Java中的数据类型分为基本类型和引用类型。

基本数据类型

Java有8种基本数据类型：

byte: 8位有符号整数，取值范围为-128到127。
short: 16位有符号整数。
int: 32位有符号整数。
long: 64位有符号整数。
float: 32位浮点数。
double: 64位浮点数。
char: 16位Unicode字符。
boolean: 布尔值，取值为true或false。

引用数据类型

引用类型包括类、接口、数组等。引用类型是在堆内存中创建的对象，每个对象都有一个地址（即引用）。引用类型的变量实际上存储的是对象的地址。

流程控制语句

流程控制语句包括条件语句和循环语句。

条件语句

Java支持if、if-else、if-else if-else等多种条件语句。

int x = 5;
if (x > 3) {
    System.out.println("x is greater than 3");
} else if (x == 3) {
    System.out.println("x is equal to 3");
} else {
    System.out.println("x is less than 3");
}

循环语句

Java有for、while、do-while三种循环语句。

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

// while 循环
int j = 0;
while (j < 5) {
    System.out.println("Iteration " + j);
    j++;
}

// do-while 循环
int k = 0;
do {
    System.out.println("Iteration " + k);
    k++;
} while (k < 5);

Java面向对象编程

Java是一种面向对象的编程语言，支持封装、继承、多态等面向对象特性。以下是一些关键概念的介绍。

类和对象

在Java中，类是对象的蓝图，描述了对象的属性和行为。对象是类的实例。

定义类

以下是一个简单的类定义示例：

public class Person {
    // 属性
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

创建对象

Person person1 = new Person("Alice", 25);
person1.printInfo();

封装

封装是指将对象的数据和行为封装在一起，通过类的属性和方法对外界隐藏内部细节。封装的优点包括数据保护和代码维护性。

封装示例

public class Employee {
    private String name;
    private int salary;

    public Employee(String name, int salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public void printInfo() {
        System.out.println("Name: " + name + ", Salary: " + salary);
    }
}

继承

继承允许一个类继承另一个类的属性和方法。被继承的类称为父类（或基类），继承的类称为子类（或派生类）。

继承示例

public class Animal {
    protected String name;
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    public void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    public void meow() {
        System.out.println(name + " is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy", 3);
        dog.eat();
        dog.sleep();
        dog.bark();

        Cat cat = new Cat("Whiskers", 2);
        cat.eat();
        cat.sleep();
        cat.meow();
    }
}

多态

多态是指一个对象可以表现为多种形式。在Java中，多态主要通过方法重写（覆盖）来实现。

多态示例

public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound.");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks.");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Animal();
        Animal dog = new Dog();
        Animal cat = new Cat();

        animal1.sound();  // 输出：Animal makes a sound.
        dog.sound();     // 输出：Dog barks.
        cat.sound();     // 输出：Cat meows.
    }
}

接口和抽象类

接口定义了一组行为规范，而抽象类可以包含成员变量、常量和方法。接口和抽象类不可实例化。

接口

public interface Movable {
    void move();
}

public class Car implements Movable {
    public void move() {
        System.out.println("Car is moving.");
    }
}

public class Bicycle implements Movable {
    public void move() {
        System.out.println("Bicycle is moving.");
    }
}

public class Main {
    public static void main(String[] args) {
        Movable car = new Car();
        car.move();  // 输出：Car is moving.

        Movable bicycle = new Bicycle();
        bicycle.move();  // 输出：Bicycle is moving.
    }
}

抽象类

public abstract class Animal {
    public abstract void makeSound();

    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks.");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // 输出：Dog barks.
        dog.eat();        // 输出：Animal is eating.

        Cat cat = new Cat();
        cat.makeSound();  // 输出：Cat meows.
        cat.eat();        // 输出：Animal is eating.
    }
}

包和访问修饰符

包（Package）用于组织类和接口，避免命名冲突。Java中的访问修饰符控制类、方法和变量的可见性。

包

// 在 src 目录下创建一个 com.example 包
// 文件结构如下:
// src/com/example/Person.java

package com.example;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

访问修饰符

Java中的访问修饰符包括public、protected、private和默认（无修饰符，即包内可见）。

public class Example {
    public int publicVar = 10;  // 公共变量，可被任何类访问
    protected int protectedVar = 20;  // 可被同一包内的类以及继承的子类访问
    private int privateVar = 30;  // 私有变量，仅在本类内可见
    int defaultVar = 40;  // 默认访问修饰符，仅在包内可见

    public void publicMethod() {
        System.out.println("Public Method");
    }

    protected void protectedMethod() {
        System.out.println("Protected Method");
    }

    private void privateMethod() {
        System.out.println("Private Method");
    }

    void defaultMethod() {
        System.out.println("Default Method");
    }
}

Java Web开发

Java Web开发主要涉及Servlet、JSP、MVC模式、Spring框架、数据库连接与操作等技术。

Web开发基础

Web开发通常包括客户端和服务器端技术。客户端技术主要涉及HTML、CSS和JavaScript，服务器端技术则包括Servlet、JSP等Java技术。

Web服务器

常见的Java Web服务器有Apache Tomcat、Jetty等。这里以Apache Tomcat为例进行配置和部署。

配置Apache Tomcat

下载并安装Apache Tomcat。
将编译好的Java Web应用文件（通常是.war或.jar文件）复制到webapps目录下。
启动Apache Tomcat服务器。
访问URL http://localhost:8080/应用名来查看应用。

Servlet和JSP

Servlet是运行在服务器端的Java程序，处理客户端请求和响应。JSP（Java Server Pages）是Java技术的一种应用，用于开发动态Web页面。

创建一个Servlet

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

public class HelloWorldServlet extends HttpServlet {
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html>");
        out.println("<head>");
        out.println("<title>Hello World Servlet</title>");
        out.println("</head>");
        out.println("<body>");
        out.println("<h1>Hello World!</h1>");
        out.println("</body>");
        out.println("</html>");
    }
}

配置web.xml

在WEB-INF目录下的web.xml文件中配置Servlet。

<web-app>
    <servlet>
        <servlet-name>HelloWorldServlet</servlet-name>
        <servlet-class>com.example.HelloWorldServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>HelloWorldServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

创建一个JSP页面

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Simple JSP Page</title>
</head>
<body>
    <h1>Hello, JSP!</h1>
    <p>Today's date: <%= new java.util.Date() %></p>
</body>
</html>

MVC模式

MVC（Model-View-Controller）是一种软件架构模式，用于分离应用程序的不同部分，提高代码的可维护性和可扩展性。

MVC架构

Model: 数据模型，负责管理应用程序的数据。
View: 视图，负责显示数据。
Controller: 控制器，负责接收用户请求，并调用相应的Model和View组件。

创建一个简单的MVC应用

// Model
public class User {
    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

// View
public class UserView {
    public void printUser(User user) {
        System.out.println("Name: " + user.getName() + ", Email: " + user.getEmail());
    }
}

// Controller
public class UserController {
    private User user;
    private UserView view;

    public UserController(User user, UserView view) {
        this.user = user;
        this.view = view;
    }

    public void printUserDetails() {
        view.printUser(user);
    }
}

// Main
public class Main {
    public static void main(String[] args) {
        User user = new User("Alice", "alice@example.com");
        UserView view = new UserView();
        UserController controller = new UserController(user, view);

        controller.printUserDetails();
    }
}

Spring框架基础

Spring是一个开源的Java平台，提供了全面的基础设施支持，简化了企业级应用开发。Spring框架的核心是IoC（控制反转）容器，负责管理对象的生命周期。

创建一个简单的Spring应用

// Bean类
public class HelloWorldBean {
    private String message;

    public HelloWorldBean() {
    }

    public HelloWorldBean(String message) {
        this.message = message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void printMessage() {
        System.out.println(message);
    }
}

// 配置文件
<bean id="helloWorldBean" class="com.example.HelloWorldBean">
    <property name="message" value="Hello, World!" />
</bean>

// 使用Spring容器
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");

        HelloWorldBean bean = context.getBean("helloWorldBean", HelloWorldBean.class);
        bean.printMessage();
    }
}

JPA与数据库操作

Java Persistence API（JPA）是一种Java持久化规范，用于对象关系映射（ORM）。

使用JPA

// 实体类
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // 构造函数、getter和setter省略
}

// JPA配置
<bean id="entityManagerFactory"
      class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="persistenceUnitName" value="defaultPersistenceUnit" />
    <property name="packagesToScan" value="com.example" />
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
    </property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>

// 使用JPA
@Autowired
private EntityManager entityManager;

public User createUser(String name, String email) {
    User user = new User();
    user.setName(name);
    user.setEmail(email);
    entityManager.persist(user);
    return user;
}

public User getUser(Long id) {
    return entityManager.find(User.class, id);
}

Java后端技术

Java后端技术包括数据库连接与操作、RESTful API设计、Hibernate与ORM、MyBatis持久化操作、依赖注入与Spring Boot。

数据库连接与操作

数据库连接通常使用JDBC（Java Database Connectivity）API实现。

使用JDBC连接数据库

public class DatabaseConnection {
    private static final String URL = "jdbc:mysql://localhost:3306/mydb";
    private static final String USER = "root";
    private static final String PASSWORD = "password";

    public Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }

    public void closeConnection(Connection conn) {
        try {
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

RESTful API设计

RESTful API是一种基于HTTP协议的网络服务设计风格，通过URL资源、HTTP方法（GET、POST、PUT、DELETE）等方式实现数据传输。

创建一个RESTful API

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        User user = userRepository.findById(id).orElse(null);
        if (user != null) {
            user.setName(userDetails.getName());
            user.setEmail(userDetails.getEmail());
            return userRepository.save(user);
        }
        return null;
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

Hibernate与ORM

Hibernate是一个成熟的ORM框架，简化了Java应用程序的数据库交互。

使用Hibernate

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    // 构造函数、getter和setter省略
}

// Hibernate配置
<bean id="sessionFactory"
      class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="packagesToScan" value="com.example" />
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
            <prop key="hibernate.show_sql">true</prop>
        </props>
    </property>
</bean>

@Autowired
private SessionFactory sessionFactory;

public User createUser(String name, String email) {
    User user = new User();
    user.setName(name);
    user.setEmail(email);
    sessionFactory.getCurrentSession().save(user);
    return user;
}

public User getUser(Long id) {
    return sessionFactory.getCurrentSession().get(User.class, id);
}

使用MyBatis进行持久化操作

MyBatis是一个灵活的持久化框架，支持ORM和SQL映射。

使用MyBatis

// UserMapper接口
public interface UserMapper {
    List<User> getAllUsers();
    User getUserById(Long id);
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(Long id);
}

// UserMapper.xml配置文件
<mapper namespace="com.example.mapper.UserMapper">
    <select id="getAllUsers" resultType="com.example.model.User">
        SELECT * FROM users
    </select>

    <select id="getUserById" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <insert id="insertUser">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>

    <update id="updateUser">
        UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}
    </update>

    <delete id="deleteUser">
        DELETE FROM users WHERE id = #{id}
    </delete>
</mapper>

@Autowired
private UserMapper userMapper;

public List<User> getAllUsers() {
    return userMapper.getAllUsers();
}

public User getUserById(Long id) {
    return userMapper.getUserById(id);
}

public void insertUser(User user) {
    userMapper.insertUser(user);
}

public void updateUser(User user) {
    userMapper.updateUser(user);
}

public void deleteUser(Long id) {
    userMapper.deleteUser(id);
}

依赖注入与Spring Boot

Spring Boot是一个基于Spring框架的快速应用开发框架，简化了应用的开发和部署过程。

创建一个Spring Boot应用

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

使用Spring Boot配置

spring:
  application:
    name: example
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: password
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update

创建一个RESTful API

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        User user = userRepository.findById(id).orElse(null);
        if (user != null) {
            user.setName(userDetails.getName());
            user.setEmail(userDetails.getEmail());
            return userRepository.save(user);
        }
        return null;
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

Java前端技术

Java前端技术主要涉及HTML、CSS和JavaScript，以及一些流行的前端框架和库。

HTML/CSS基础

HTML（HyperText Markup Language）用于构建Web页面的基本结构，CSS（Cascading Style Sheets）用于定义页面的样式和布局。

创建一个简单的HTML页面

<!DOCTYPE html>
<html>
<head>
    <title>Simple HTML Page</title>
    <style>
        body {
            background-color: lightblue;
            font-family: Arial, sans-serif;
        }
        h1 {
            color: navy;
        }
        p {
            font-size: 18px;
        }
    </style>
</head>
<body>
    <h1>Welcome to My Web Page</h1>
    <p>This is a simple HTML page with some basic structure and styling.</p>
</body>
</html>

JavaScript基础

JavaScript是一种广泛使用的编程语言，用于在Web页面上实现交互功能。

创建一个简单的JavaScript脚本

<!DOCTYPE html>
<html>
<head>
    <title>Simple JavaScript Example</title>
    <script>
        function greet() {
            alert("Hello, World!");
        }
    </script>
</head>
<body>
    <button onclick="greet()">Click Me</button>
</body>
</html>

使用jQuery和Bootstrap进行前端开发

jQuery是一个快速、小巧的JavaScript库，简化了HTML文档的处理和事件处理。Bootstrap是一个流行的前端框架，提供了丰富的CSS和JavaScript组件。

使用jQuery和Bootstrap

<!DOCTYPE html>
<html>
<head>
    <title>jQuery and Bootstrap Example</title>
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
    <script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
    <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.bundle.min.js"></script>
    <script>
        $(document).ready(function() {
            $('#myButton').click(function() {
                alert('Button clicked!');
            });
        });
    </script>
</head>
<body>
    <div class="container">
        <h1>Example with jQuery and Bootstrap</h1>
        <button type="button" class="btn btn-primary" id="myButton">Click Me</button>
    </div>
</body>
</html>

前端框架Vue.js入门

Vue.js是一个渐进式的JavaScript框架，用于构建用户界面。

创建一个简单的Vue.js应用

<!DOCTYPE html>
<html>
<head>
    <title>Simple Vue.js Example</title>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.6.12/dist/vue.js"></script>
</head>
<body>
    <div id="app">
        <h1>{{ message }}</h1>
        <button v-on:click="changeMessage">Change Message</button>
    </div>
    <script>
        new Vue({
            el: '#app',
            data: {
                message: 'Hello, Vue.js!'
            },
            methods: {
                changeMessage: function() {
                    this.message = 'Changed message!';
                }
            }
        });
    </script>
</body>
</html>

前后端数据交互

前后端数据交互通常通过AJAX（Asynchronous JavaScript and XML）实现。AJAX允许在不刷新整个页面的情况下与服务器交换数据。

使用Fetch API进行前后端数据交互

<!DOCTYPE html>
<html>
<head>
    <title>AJAX Example</title>
</head>
<body>
    <div id="app">
        <h1>{{ message }}</h1>
        <button onclick="fetchData()">Fetch Data</button>
    </div>
    <script>
        function fetchData() {
            fetch('https://api.example.com/data')
                .then(response => response.json())
                .then(data => {
                    document.getElementById('app').innerHTML = `<h1>Data fetched: ${data.message}</h1>`;
                })
                .catch(error => console.error('Error:', error));
        }
    </script>
</body>
</html>

实战项目

构建一个简单的Java全栈应用，包含用户注册、登录、数据操作和前后端集成等功能。

创建一个简单的Java全栈应用

用户注册与登录功能
- 前端：使用HTML、CSS和JavaScript实现注册和登录表单。
- 后端：使用Spring Boot和JPA实现用户数据的持久化和验证。

前端代码示例

<!DOCTYPE html>
<html>
<head>
    <title>User Registration and Login</title>
    <style>
        body {
            background-color: lightblue;
            font-family: Arial, sans-serif;
        }
        form {
            width: 300px;
            margin: 0 auto;
        }
        input[type="text"], input[type="password"] {
            width: 100%;
            padding: 10px;
            margin: 10px 0;
            border: 1px solid #ccc;
            border-radius: 4px;
        }
        button {
            width: 100%;
            padding: 10px;
            border: none;
            border-radius: 4px;
            background-color: #4CAF50;
            color: white;
            font-size: 16px;
            cursor: pointer;
        }
        button:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>
    <h1>User Registration</h1>
    <form id="registrationForm">
        <input type="text" id="username" placeholder="Username" required>
        <input type="password" id="password" placeholder="Password" required>
        <button type="submit">Register</button>
    </form>

    <h1>User Login</h1>
    <form id="loginForm">
        <input type="text" id="loginUsername" placeholder="Username" required>
        <input type="password" id="loginPassword" placeholder="Password" required>
        <button type="submit">Login</button>
    </form>

    <script>
        document.getElementById('registrationForm').addEventListener('submit', function(event) {
            event.preventDefault();
            const username = document.getElementById('username').value;
            const password = document.getElementById('password').value;
            fetch('http://localhost:8080/register', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ username, password })
            })
            .then(response => response.json())
            .then(data => {
                alert(data.message);
            })
            .catch(error => console.error('Error:', error));
        });

        document.getElementById('loginForm').addEventListener('submit', function(event) {
            event.preventDefault();
            const username = document.getElementById('loginUsername').value;
            const password = document.getElementById('loginPassword').value;
            fetch('http://localhost:8080/login', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ username, password })
            })
            .then(response => response.json())
            .then(data => {
                alert(data.message);
            })
            .catch(error => console.error('Error:', error));
        });
    </script>
</body>
</html>

后端代码示例

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @PostMapping("/register")
    public ResponseEntity<String> register(@RequestBody User user) {
        if (userRepository.findByUsername(user.getUsername()) != null) {
            return ResponseEntity.status(HttpStatus.CONFLICT).body("Username already exists.");
        }
        userRepository.save(user);
        return ResponseEntity.ok("User registered successfully.");
    }

    @PostMapping("/login")
    public ResponseEntity<String> login(@RequestBody LoginRequest loginRequest) {
        User user = userRepository.findByUsername(loginRequest.getUsername());
        if (user == null || !user.getPassword().equals(loginRequest.getPassword())) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid username or password.");
        }
        return ResponseEntity.ok("Login successful.");
    }
}

public class LoginRequest {
    private String username;
    private String password;

    // getters and setters
}

public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;

    // getters and setters
}

数据操作与查询
- 前端：展示用户数据列表，提供搜索功能。
- 后端：使用JPA或MyBatis实现数据的增删改查。

前端代码示例

<!DOCTYPE html>
<html>
<head>
    <title>User Data Management</title>
    <style>
        body {
            background-color: lightblue;
            font-family: Arial, sans-serif;
        }
        table {
            width: 100%;
            border-collapse: collapse;
        }
        th, td {
            border: 1px solid #ddd;
            padding: 8px;
            text-align: left;
        }
        th {
            background-color: #f2f2f2;
            font-weight: bold;
        }
        tr:nth-child(even) {
            background-color: #f2f2f2;
        }
        tr:hover {
            background-color: #ddd;
        }
    </style>
</head>
<body>
    <h1>User Data Management</h1>
    <form id="searchForm">
        <input type="text" id="searchInput" placeholder="Search by username" required>
        <button type="submit">Search</button>
    </form>
    <table id="userDataTable">
        <thead>
            <tr>
                <th>Username</th>
                <th>Email</th>
                <th>Action</th>
            </tr>
        </thead>
        <tbody id="userDataBody">
            <!-- Data will be populated here -->
        </tbody>
    </table>

    <script>
        document.getElementById('searchForm').addEventListener('submit', function(event) {
            event.preventDefault();
            const searchInput = document.getElementById('searchInput').value;
            fetch('http://localhost:8080/users/search?username=' + searchInput)
                .then(response => response.json())
                .then(data => {
                    const userDataBody = document.getElementById('userDataBody');
                    userDataBody.innerHTML = '';
                    data.forEach(user => {
                        const row = document.createElement('tr');
                        const usernameCell = document.createElement('td');
                        usernameCell.textContent = user.username;
                        const emailCell = document.createElement('td');
                        emailCell.textContent = user.email;
                        const actionCell = document.createElement('td');
                        const deleteButton = document.createElement('button');
                        deleteButton.textContent = 'Delete';
                        deleteButton.addEventListener('click', function() {
                            fetch('http://localhost:8080/users/' + user.id, {
                                method: 'DELETE'
                            })
                            .then(() => {
                                row.remove();
                                alert('User deleted successfully.');
                            })
                            .catch(error => console.error('Error:', error));
                        });
                        actionCell.appendChild(deleteButton);
                        row.appendChild(usernameCell);
                        row.appendChild(emailCell);
                        row.appendChild(actionCell);
                        userDataBody.appendChild(row);
                    });
                })
                .catch(error => console.error('Error:', error));
        });
    </script>
</body>
</html>

后端代码示例

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/users/search")
    public List<User> searchUsers(@RequestParam String username) {
        return userRepository.findByUsernameContaining(username);
    }

    @DeleteMapping("/users/{id}")
    public ResponseEntity<String> deleteUser(@PathVariable Long id) {
        if (userRepository.existsById(id)) {
            userRepository.deleteById(id);
            return ResponseEntity.ok("User deleted successfully.");
        }
        return ResponseEntity.notFound().build();
    }
}

前后端集成
- 使用Spring Boot和Vue.js实现前后端集成。
- 通过API接口传递数据。

前端代码示例

<!DOCTYPE html>
<html>
<head>
    <title>Frontend-Backend Integration</title>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.6.12/dist/vue.js"></script>
</head>
<body>
    <div id="app">
        <h1>User Data Management</h1>
        <form id="searchForm">
            <input type="text" id="searchInput" placeholder="Search by username" v-model="searchTerm">
            <button type="submit" @click="searchUsers">Search</button>
        </form>
        <table>
            <thead>
                <tr>
                    <th>Username</th>
                    <th>Email</th>
                    <th>Action</th>
                </tr>
            </thead>
            <tbody>
                <tr v-for="user in users">
                    <td>{{ user.username }}</td>
                    <td>{{ user.email }}</td>
                    <td>
                        <button @click="deleteUser(user.id)">Delete</button>
                    </td>
                </tr>
            </tbody>
        </table>
    </div>
    <script>
        new Vue({
            el: '#app',
            data: {
                searchTerm: '',
                users: []
            },
            methods: {
                searchUsers: function() {
                    fetch('http://localhost:8080/users/search?username=' + this.searchTerm)
                        .then(response => response.json())
                        .then(data => {
                            this.users = data;
                        })
                        .catch(error => console.error('Error:', error));
                },
                deleteUser: function(id) {
                    fetch('http://localhost:8080/users/' + id, {
                        method: 'DELETE'
                    })
                    .then(() => {
                        this.users = this.users.filter(user => user.id !== id);
                        alert('User deleted successfully.');
                    })
                    .catch(error => console.error('Error:', error));
                }
            }
        });
    </script>
</body>
</html>

后端代码示例

@GetMapping("/users")
public List<User> getAllUsers() {
    return userRepository.findAll();
}

@GetMapping("/users/search")
public List<User> searchUsers(@RequestParam String username) {
    return userRepository.findByUsernameContaining(username);
}

@DeleteMapping("/users/{id}")
public ResponseEntity<String> deleteUser(@PathVariable Long id) {
    if (userRepository.existsById(id)) {
        userRepository.deleteById(id);
        return ResponseEntity.ok("User deleted successfully.");
    }
    return ResponseEntity.notFound().build();
}

应用部署与测试
- 将应用程序部署到服务器（如Apache Tomcat）。
- 使用浏览器访问应用进行测试。

应用部署

编译应用程序。
将编译后的文件（通常是.war或.jar文件）复制到服务器的webapps目录下。
启动服务器。
访问URL进行测试。

应用测试

打开浏览器，访问部署的应用URL。
测试用户注册、登录、数据查询和删除等功能。
确保前后端集成正常工作，数据正确传递。

通过以上步骤，你将能够开发一个简单的Java全栈应用，并掌握基本的前后端开发技术。