为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 Java全栈开发入门教程

Java全栈开发入门教程

标签：
Java
概述

本文全面介绍了Java全栈开发的相关内容，从Java环境搭建、语法入门到面向对象编程、后端开发和前端技术选择，涵盖了Java全栈开发的各个方面。此外，还涉及了数据库操作、RESTful API设计以及前端与后端的交互，通过具体示例详细讲解了Java全栈开发的实践方法。

Java基础语法入门

Java环境搭建

Java环境搭建是进行Java开发的第一步。首先，你需要下载并安装Java开发工具包（JDK），这是Java程序运行的必要环境。下载地址为：https://www.oracle.com/java/technologies/javase-downloads.html 或者使用 OpenJDK。安装完成后，需要配置环境变量。

Windows 下配置环境变量

  1. 打开“此电脑”，点击“属性”。
  2. 点击“高级系统设置”。
  3. 点击“环境变量”。
  4. 在“系统变量”中，新建变量 JAVA_HOME，值为JDK的安装路径。
  5. 修改 Path 变量，添加 %JAVA_HOME%\bin。
  6. 打开命令行，输入 java -version 检查是否安装成功。

Linux 下配置环境变量

  1. 打开终端，编辑 ~/.bashrc 或者 /etc/profile 文件。
  2. 添加如下代码： 
    export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH
  3. 使配置生效，命令为 source ~/.bashrc 或者 source /etc/profile。
  4. 输入 java -version 检查是否安装成功。

Java基本语法介绍

Java的基本语法包括变量和数据类型、运算符、流程控制语句等。

变量与数据类型

在Java中，变量用于存储数据，数据类型定义了变量存储的数据类型和大小。

public class VariableExample {
    public static void main(String[] args) {
        int num = 10;  // 整型
        double decimal = 10.5;  // 双精度浮点型
        boolean flag = true;  // 布尔型
        String name = "John";  // 字符串型
        char letter = 'A';  // 字符型
    }
}

运算符

Java支持多种运算符，包括算术运算符、关系运算符、逻辑运算符等。

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        System.out.println(a + b);  // 算术运算符
        System.out.println(a > b);  // 关系运算符
        System.out.println(a == b);  // 关系运算符
        System.out.println(a && b);  // 逻辑运算符
    }
}

流程控制语句

Java支持if-else、switch、for、while、do-while等流程控制语句。

public class FlowControlExample {
    public static void main(String[] args) {
        int num = 5;
        if (num > 0) {
            System.out.println("Positive number");
        } else {
            System.out.println("Negative number");
        }
        switch (num) {
            case 1:
                System.out.println("Case 1");
                break;
            case 2:
                System.out.println("Case 2");
                break;
            default:
                System.out.println("Default case");
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
        int x = 0;
        while (x < 5) {
            System.out.println(x);
            x++;
        }
        do {
            System.out.println(x);
            x++;
        } while (x < 5);
    }
}

Java面向对象编程

Java是一门面向对象的语言，所有代码都在类中编写。类是由属性（变量）和方法（函数）组成的模板，对象是类的实例。Java支持继承、封装、多态等特性。

类与对象

public class Person {
    String name;
    int age;

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

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "John";
        person.age = 25;
        person.introduce();
    }
}

封装

封装是将属性和方法封装在一个类中，保护数据不被外部直接访问，提供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) {
        this.age = age;
    }
}

继承

继承允许一个类继承另一个类的属性和方法，实现代码复用。

public class Animal {
    public void eat() {
        System.out.println("Eating");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Barking");
    }
}

多态

多态允许将一个子类对象赋值给父类对象，调用子类的实现方法。

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

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

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.eat();  // 输出: Animal eating
        Dog dog = new Dog();
        dog.eat();  // 输出: Dog eating
        Animal animal2 = new Dog();
        animal2.eat();  // 输出: Dog eating
    }
}

Java后端开发

使用Spring Boot框架搭建第一个Java Web应用

Spring Boot 是一个简化了的Spring框架的开发体验的框架。它通过约定优于配置的方式，允许开发者快速地搭建应用。

创建Spring Boot项目
  1. 使用Spring Initializr创建新项目。
  2. 选择Spring Web依赖。
  3. 生成项目，导入IDE。
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {

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

    @RestController
    public class HelloController {
        @GetMapping("/")
        public String hello() {
            return "Hello, World!";
        }
    }
}
运行项目

在IDE中运行 DemoApplication 类，或者使用命令行运行 mvn spring-boot:run。

数据库的连接与操作

在Spring Boot中，可以使用JPA或MyBatis来操作数据库。这里以JPA为例。

添加依赖

在 pom.xml 文件中添加数据库的依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
配置数据库连接

在 application.properties 文件中配置数据库连接信息。

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update
创建实体类
package com.example.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

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

    // Getters and Setters
}
使用JPA进行数据库操作
package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
测试数据库操作
package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User createUser(String name, int age) {
        User user = new User();
        user.setName(name);
        user.setAge(age);
        return userRepository.save(user);
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

RESTful API设计与实现

RESTful API设计是构建Web应用的标准方式。它通过HTTP方法（GET、POST、PUT、DELETE等）来操作资源。

添加依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
创建REST控制器
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping("/")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user.getName(), user.getAge());
    }

    @PutMapping("/{id}")
    public ResponseEntity<Void> updateUser(@PathVariable Long id, @RequestBody User user) {
        userService.updateUser(id, user.getName(), user.getAge());
        return ResponseEntity.ok().build();
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.ok().build();
    }
}
Java前端开发

Java全栈开发中的前端技术选择

Java全栈开发中，前端可以选择多种技术栈，如JavaServer Pages (JSP)、Servlet、Thymeleaf等。Thymeleaf是一种现代XML/HTML5模板引擎，可以更方便地进行前后端模板绑定。此外，还可以考虑使用Angular或React等现代前端框架。

使用Thymeleaf进行前端页面开发

Thymeleaf用于生成HTML或XML内容，可以与Spring Boot无缝集成。

添加依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
创建Thymeleaf模板

创建 src/main/resources/templates/user.html 文件。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>User Page</title>
</head>
<body>
    <h1 th:text="${user.name}"></h1>
    <p th:text="${user.age}"></p>
</body>
</html>
渲染Thymeleaf模板
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/user/{id}")
    public String getUserById(@PathVariable Long id, Model model) {
        User user = userService.getUserById(id);
        model.addAttribute("user", user);
        return "user";
    }
}

前端与后端交互

在前端页面中可以通过AJAX调用后端API。

创建后端API

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserApiController {
    @Autowired
    private UserService userService;

    @GetMapping("/api/user/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

前端页面调用API

创建 src/main/resources/templates/user-ajax.html 文件。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>User Page</title>
    <script class="lazyload" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAAANSURBVBhXYzh8+PB/AAffA0nNPuCLAAAAAElFTkSuQmCC" data-original="https://code.jquery.com/jquery-3.6.0.min.js"></script>
    <script>
        $(document).ready(function() {
            var id = 1;
            $.get("/api/user/" + id, function(data) {
                $("#name").text(data.name);
                $("#age").text(data.age);
            });
        });
    </script>
</head>
<body>
    <h1 id="name"></h1>
    <p id="age"></p>
</body>
</html>
实战项目开发

开发一个简单的用户管理系统

数据库设计

数据库表 users：

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    age INT NOT NULL
);

后端代码实现

创建实体类
package com.example.demo.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

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

    // Getters and Setters
}
创建数据库访问层
package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
创建业务逻辑层
package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User createUser(String name, int age) {
        User user = new User();
        user.setName(name);
        user.setAge(age);
        return userRepository.save(user);
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}
创建控制器
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping("/")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user.getName(), user.getAge());
    }
}

Thymeleaf前端页面

创建前端页面

创建 src/main/resources/templates/users.html 文件。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>User List</title>
</head>
<body>
    <h1>User List</h1>
    <table>
        <thead>
            <tr>
                <th>Name</th>
                <th>Age</th>
            </tr>
        </thead>
        <tbody>
            <tr th:each="user : ${users}">
                <td th:text="${user.name}"></td>
                <td th:text="${user.age}"></td>
            </tr>
        </tbody>
    </table>
</body>
</html>
渲染前端页面
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public String getUsers(Model model) {
        model.addAttribute("users", userService.findAll());
        return "users";
    }
}

使用MySQL数据库存储用户数据

配置数据库连接

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update

创建数据库表

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    age INT NOT NULL
);

创建数据库索引

CREATE INDEX idx_name ON users (name);

迁移数据库表

使用Spring Boot的数据迁移工具，可以自动创建数据库表。

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

前端使用Thymeleaf展示用户信息

前端页面代码
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>User List</title>
</head>
<body>
    <h1>User List</h1>
    <table>
        <thead>
            <tr>
                <th>Name</th>
                <th>Age</th>
            </tr>
        </thead>
        <tbody>
            <tr th:each="user : ${users}">
                <td th:text="${user.name}"></td>
                <td th:text="${user.age}"></td>
            </tr>
        </tbody>
    </table>
</body>
</html>
后端控制器代码
package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public String getUsers(Model model) {
        model.addAttribute("users", userService.findAll());
        return "users";
    }
}
常见问题与调试

Java全栈开发中的常见问题

  1. 类型转换错误：在处理数据类型时需要注意转换问题。
  2. 数据库连接问题：配置错误或连接失败。
  3. 页面加载问题：前端页面无法正常加载。

调试技巧与工具介绍

使用IDE调试

大多数IDE（如IntelliJ IDEA）都支持断点调试。可以在代码中设置断点，执行到断点处时暂停，查看变量状态。

使用日志工具

使用日志工具（如SLF4J、Logback）记录运行时信息，帮助定位问题。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Example {
    private static final Logger logger = LoggerFactory.getLogger(Example.class);

    public void example() {
        logger.debug("Executing example method");
        // Do something
    }
}

使用单元测试

使用JUnit等单元测试框架进行测试。

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class ExampleTest {
    @Test
    public void testExample() {
        Example example = new Example();
        example.example();
        // Verify expected behavior
    }
}

代码优化与性能提升

  1. 使用缓存：减少数据库查询次数。
  2. 优化SQL查询：避免全表扫描，使用索引。
  3. 线程池：使用线程池处理多线程任务。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Example {
    private ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void executeTasks() {
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                // Do something
            });
        }
    }
}
学习资源推荐

在线教程与书籍推荐

推荐慕课网（https://www.imooc.com/）和其他在线教程网站，如Codecademy、LeetCode等。

开发社区与论坛推荐

推荐Stack Overflow、GitHub、Spring社区等。

其他学习资源推荐

推荐使用IDEA插件Marketplace，下载各种插件，如Lombok、Spring Boot DevTools等，提升开发效率。

点击查看更多内容
发表于 2024.11.19 19:32， 共 42 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

跃然一笑

手记
篇
粉丝
40
获赞与收藏
164

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消