首页手记 Java全栈教程：从入门到初级实战

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

标签：

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 class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://code.jquery.com/jquery-3.5.1.min.js"></script>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="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 class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="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 class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="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全栈应用，并掌握基本的前后端开发技术。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

蝴蝶刀刀

手记
篇

粉丝

37

获赞与收藏

183

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19187 313

Java 并发原理入门教程

26个小节 38860 566

Java 入门教程

50个小节 340924 3155

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

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

Java简介

安装Java开发环境

第一个Java程序

Java基本语法

变量与数据类型

流程控制语句

数据类型和变量

基本数据类型

引用数据类型

流程控制语句

条件语句

循环语句

类和对象

定义类

创建对象

封装

封装示例

继承

继承示例

多态

多态示例

接口和抽象类

接口

抽象类

包和访问修饰符

包

访问修饰符

Web开发基础

Web服务器

配置Apache Tomcat

Servlet和JSP

创建一个Servlet

配置web.xml

创建一个JSP页面

MVC模式

MVC架构

创建一个简单的MVC应用

Spring框架基础

创建一个简单的Spring应用

JPA与数据库操作

使用JPA

数据库连接与操作

使用JDBC连接数据库

RESTful API设计

创建一个RESTful API

Hibernate与ORM

使用Hibernate

使用MyBatis进行持久化操作

使用MyBatis

依赖注入与Spring Boot

创建一个Spring Boot应用

使用Spring Boot配置

创建一个RESTful API

HTML/CSS基础

创建一个简单的HTML页面

JavaScript基础

创建一个简单的JavaScript脚本

使用jQuery和Bootstrap进行前端开发

使用jQuery和Bootstrap

前端框架Vue.js入门

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

前后端数据交互

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

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

前端代码示例

后端代码示例

前端代码示例

后端代码示例

前端代码示例

后端代码示例

应用部署

应用测试

阅读免费教程