GPT编程（上）: 如何用ChatGPT辅助我们编程？

你好，我是郭屹。

这节课我们将探索GPT的基础知识及其在编程中的应用。随着开发技术与模式的演变，以GPT为代表的AI辅助编程正引领一场革命。

尽管AI的发展历程充满了起伏，但在近七十年的时间里它逐渐展现出了强大的能力，并且变得越来越成熟。特别是在自然语言处理（NLP）领域，2017年Transformer架构的出现带来了重大突破，随后GPT和BERT成为了该领域的两大明星模型。近几年里，虽然BERT一度更受关注，但自2022年底GPT演进为ChatGPT后，其影响力显著上升，标志着AI对话系统进入了一个新阶段。

ChatGPT简介

n ChatGPT是OpenAI于2022年11月发布的一个大型语言模型，全称为聊天生成预训练转换器（Chat Generative Pre-trained Transformer）。它通过人机自然语言对话的方式与用户交互，特别擅长处理上下文相关的连续对话。自推出以来，ChatGPT因其卓越的能力而迅速获得了超过一亿用户的青睐。它的主要功能包括但不限于文本创作、对话交流、内容摘要以及代码修正等。

尽管ChatGPT能够编写程序代码，但它并不真正理解编程；它基于统计规律对编码任务提供建议。随着时间推移，ChatGPT根据用户反馈不断优化升级，比如2023年3月发布的GPT-4多模态模型就体现了这一点。

注册使用ChatGPT

n 如果您想开始使用ChatGPT，可以通过访问https://chat.openai.com/进行注册。完成注册并登录后，您将直接进入主界面，在那里您可以开始与ChatGPT互动。
图片
To create a Spring MVC application which connects to a MySQL database, follow these steps:

  1. Set up a MySQL database: Install MySQL on your machine and create a database. Then, create a table with some sample data.2. Create a Spring MVC project: Create a new Spring MVC project in your favorite IDE. You can use Maven or Gradle as your build tool.3. Add MySQL dependencies: Add the MySQL JDBC driver and Spring JDBC dependencies to your project. You can add them in your build file (pom.xml or build.gradle).4. Configure the database connection: In your Spring configuration file (applicationContext.xml), configure the database connection details such as driver class, URL, username, and password.5. Create a data access object (DAO): Create a DAO class to interact with the database. This class should have methods to insert, update, delete, and select data from the database.6. Create a controller: Create a Spring controller to handle the HTTP requests. The controller should use the DAO to fetch data from the database and return it as a response.7. Create a view: Create a view to display the data returned by the controller. You can use JSP, Thymeleaf, or any other view technology. Here is the complete code for the 6th step: Create a controller
  2. Create a class called EmployeeController with the following methods:
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

@Controller
public class EmployeeController {
   @Autowired
   private EmployeeDAO employeeDAO;

   @RequestMapping(value = "/", method = RequestMethod.GET)
   public ModelAndView home() {
        List<Employee> employees = employeeDAO.getAllEmployees();
        ModelAndView model = new ModelAndView("home");
        model.addObject("employees", employees);
        return model;
    }

    @RequestMapping(value = "/addEmployee", method = RequestMethod.GET)
    public ModelAndView addEmployee() {
         ModelAndView model = new ModelAndView("addEmployee");
         model.addObject("employee", new Employee());
         return model;
     }

     @RequestMapping(value = "/saveEmployee", method = RequestMethod.POST)
     public ModelAndView saveEmployee(@ModelAttribute("employee") Employee employee) {
         employeeDAO.addEmployee(employee);
         return new ModelAndView("redirect:/");
     }
 }

对于它的答案，我们可以校正，比如告诉它最后一步我们不想用JSP，而是想用React，让它给个例子。

我：great! fot the last step, I do not want to use JSP, but prefer to use React, could give me the script to access the above controller?

它也会接着给出答案。

从这里我们可以看出，对常规的任务，它能给我们一个程序框架，像一个编程助手一样跟我们对话，很强。下面我们再看一个完整例子，在Spring Boot中开发一个数据库应用项目。

用ChatGPT辅助编程

我们以典型的CRUD应用为例。ChatGPT并不能生成完整的CRUD应用程序，但是可以给出建立程序的步骤，指引我们一步一步地建立应用。

我们先从建立项目开始，跟它开始对话。

我：create a new spring boot crud project

它的回复是：Sure, here’s a step-by-step guide on how to create a new Spring Boot CRUD project:

  1. Open your preferred IDE (Integrated Development Environment) such as Eclipse or IntelliJ IDEA.
  2. Create a new Spring Boot project using the Spring Initializr. You can do this by going to https://start.spring.io/ and filling out the necessary information such as project type, language, packaging, and dependencies. For this example, we’ll use Maven as the project type and select Spring Web, Spring Data JPA, and H2 Database as the dependencies.
  3. Click the Generate button to download the project as a zip file.
  4. Extract the contents of the downloaded zip file to a directory on your computer.
  5. Open your IDE and import the project. In Eclipse, go to File > Import > Maven > Existing Maven Projects and select the directory where you extracted the project. In IntelliJ IDEA, go to File > New > Project from Existing Sources and select the directory where you extracted the project.
  6. Once the project is imported, open the application.properties file located in the src/main/resources directory. This file contains configuration properties for the project such as database connection settings. For this example, we’ll use the default H2 database settings.
  7. Create a new package called “model” and create a new class called “Person” in that package. This class will represent our data model for the CRUD operations. Add the necessary fields such as “id”, “firstName”, “lastName”, and “email”. Add getters and setters for each field.
  8. Create a new package called “repository” and create a new interface called “PersonRepository” in that package. This interface will extend the JpaRepository interface provided by Spring Data JPA and will allow us to perform CRUD operations on the “Person” class. Add any custom methods you need for your application.
  9. Create a new package called “controller” and create a new class called “PersonController” in that package. This class will handle incoming requests and call the appropriate methods in the “PersonRepository”. Use annotations such as @RestController and @RequestMapping to define the endpoint mappings.
  10. Run the project using your IDE or by running the “mvn spring-boot:run” command in the project directory. This will start the Spring Boot application and make it available at http://localhost:8080.
  11. Test the CRUD operations by sending HTTP requests to the appropriate endpoints using a tool such as Postman or cURL. You can use the following endpoints as examples:

    • GET /person - Retrieve a list of all persons

    • GET /person/{id} - Retrieve a person by ID

    • POST /person - Create a new person

    • PUT /person/{id} - Update an existing person

    • DELETE /person/{id} - Delete a person by ID

      That’s it! You now have a basic Spring Boot CRUD project up and running. From here, you can add more features and functionality as needed for your application.

如果你熟悉Spring Boot的话，应该能看出来，ChatGPT它已经把整个应用创建的完整步骤发给我们了，我们用Intellij IDea 建立一个Spring Boot Web 项目，按照步骤就可以把项目建立起来。项目建立起来以后，还要进一步细化每一步。要实现CRUD功能，需要依次创建entity、repository、service、controller等包和类，我们完全可以用GPT，让它帮我们建立，而不用我们写一行代码。

我们继续跟它对话，根据步骤，首先我们要先创建entities。

我：create a student entity for above project

此时它回复：Sure, here’s an example of a Student entity class that you can add to your Spring Boot project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

package com.example.demo.model;
import javax.persistence.*;
@Entity
@Table(name = "students")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String firstName;
    private String lastName;
    private String email;
    public Student() {}
    public Student(String firstName, String lastName, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

它的回答中已经把student的entity代码给到我们了，我们直接复制到开发工具里。你可以看一下图片。

图片

这样entity 就建好了，然后我们创建repository。这时候我们继续询问GPT。

我：create a student repo for above project.

然后它回复：Sure, here’s an example of a StudentRepository interface that you can add to your Spring Boot project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package com.example.demo.repository;

import com.example.demo.model.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {
    Student findByEmail(String email);
    Student findByLastName(String lastName)
    // add additional CRUD methods as needed
}

我们创建StudentRepository类，将上边GPT的代码粘贴进去，这样student的repository就创建好了。如下图所示：

图片

我们继续创建service，给GPT发送指令：create Student service interface for above project.

GPT回复：Sure, here’s an example of a StudentService interface that you can add to your Spring Boot project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package com.example.demo.service;
import com.example.demo.model.Student;
import java.util.List;
public interface StudentService {
    List<Student> getAllStudents();
    Student getStudentById(Long id);
    Student createStudent(Student student);
    Student updateStudent(Long id, Student student);
    void deleteStudent(Long id);
}

GPT同样把代码给到我们了，我们创建好StudentService，把代码粘贴过去，这样Student 的数据操作接口类StudentService就创建好了。

然后我们利用GPT继续写这个类的实现类。给GPT发送指令。

我：create student service impl class for above project

GPT回复：Certainly, here’s an example of a StudentServiceImpl class that implements the StudentService interface:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package com.example.demo.service;

import com.example.demo.model.Student;
import com.example.demo.repository.StudentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

@Service
@Transactional
public class StudentServiceImpl implements StudentService {
    @Autowired
    private StudentRepository studentRepository;
    @Override
    public List<Student> getAllStudents() {
        return studentRepository.findAll();
    }
    @Override
    public Student getStudentById(Long id) {
        return studentRepository.findById(id).orElse(null);
    }
    @Override
    public Student createStudent(Student student) {
        return studentRepository.save(student);
    }
    @Override
    public Student updateStudent(Long id, Student student) {
        Student existingStudent = studentRepository.findById(id).orElse(null);
        if (existingStudent != null) {
            existingStudent.setName(student.getName());
            existingStudent.setEmail(student.getEmail());
            existingStudent.setDepartment(student.getDepartment());
            return studentRepository.save(existingStudent);
        }
        return null;
    }
    @Override
    public void deleteStudent(Long id) {
        studentRepository.deleteById(id);
    }
}

创建好StudentService类，把代码粘帖过去，一个service类就创建好了。接下来开始创建Controller。我们继续跟它对话。

我：create student controller for above project.

GPT回复：Sure! Here’s an example of a StudentController class that you can add to your Spring Boot project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

package com.example.demo.controller;

import com.example.demo.model.Student;
import com.example.demo.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/students")
public class StudentController {

    @Autowired
    private StudentService studentService;

    @GetMapping
    public ResponseEntity<List<Student>> getAllStudents() {
        List<Student> students = studentService.getAllStudents();
        return new ResponseEntity<>(students, HttpStatus.OK);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Student> getStudentById(@PathVariable("id") Long id) {
        Student student = studentService.getStudentById(id);
        if (student == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<>(student, HttpStatus.OK);
    }

    @PostMapping
    public ResponseEntity<Student> createStudent(@RequestBody Student student) {
        Student newStudent = studentService.createStudent(student);
        return new ResponseEntity<>(newStudent, HttpStatus.CREATED);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Student> updateStudent(@PathVariable("id") Long id, @RequestBody Student student) {
        Student updatedStudent = studentService.updateStudent(id, student);
        if (updatedStudent == null) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<>(updatedStudent, HttpStatus.OK);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<HttpStatus> deleteStudent(@PathVariable("id") Long id) {
        studentService.deleteStudent(id);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }

}

Application Properties for Database Connectivity

Here is a structured and organized example of an application.properties file for configuring database connectivity in a Spring Boot application.

Database Connection Settings

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Specify the database driver
spring.datasource.driver-class-name=
aaaaaaa# Database URL
spring.datasource.url=
aaaaaaa# Database username
spring.datasource.username=
aaaaaaa# Database password
spring.datasource.password=
aaaaaaa# Hibernate settings
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

Additional Configurations

1
2
3
4

# Enable Flyway database migrations
spring.flyway.enabled=true
# Enable Liquibase database migrations
spring.liquibase.enabled=true

Make sure to replace the aaaaaaa placeholders with the actual values specific to your database configuration. This setup ensures that your application can connect to the database and perform necessary operations.

1
2
3
4
5
6
7
8
9

# Database Configuration
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/your_database_name_here
spring.datasource.username=your_database_username_here
spring.datasource.password=your_database_password_here

# Hibernate Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

GPT已经给出了 application.properties 文件的内容，我们把这些内容拷贝到项目的 application.properties文件里，并把其中的your_database_name_here、your_databas_username_here、your_database_password_here换成我们实际的值。

图片
aaaaaaa a在使用IntelliJ IDEA等开发工具时，可以通过安装插件来增强编程效率和代码质量。下面我们将介绍如何利用Bito这款基于ChatGPT和GPT-4的人工智能插件来辅助开发工作。

Bito插件简介

Bito是由ChatGPT团队开发的一款集成到IDE中的AI助手插件。它提供了多种功能，如：

  • GPT对话：直接与AI交互。
  • 代码检查：自动检测潜在的代码问题。
  • 解释代码：帮助理解复杂的代码段落。
  • 自动生成注释：根据代码生成文档注释。
  • 安全检查：审查代码的安全性。
  • 样式检查：确保代码遵循特定的编码规范。
  • 优化代码：提升代码的可读性和性能。
  • 清理代码：移除不必要的部分，保持代码整洁。
  • 生成单元测试：为代码创建测试用例。

安装并注册Bito插件

  1. 在IntelliJ IDEA中打开插件市场，搜索Bito并安装。2. 按照提示完成注册过程。

使用Bito编写可靠性威布尔分布算法

一旦安装并注册成功，您就可以开始使用Bito了。免费版每天限制一小时使用时间。现在我们尝试使用Bito来编写一个可靠性威布尔分布算法。

步骤如下：

  1. 打开您的项目，在需要编写算法的地方定位光标。2. 使用Bito插件提供的输入框或快捷键启动Bito。3. 输入请求：请帮我写一个可靠性威布尔分布算法。4. 等待Bito响应，并提供相应的算法实现代码。 请注意，当您收到Bito提供的代码后，应该仔细审阅以确保其满足您的具体需求，并且正确无误地实现了所需的算法逻辑。 通过这种方式，您可以利用Bito这样的插件来加速开发流程，并提高代码的质量。记得充分利用Bito的各种特性，比如让Bito为您解释难以理解的代码片段、优化现有代码或者进行安全性检查等等。
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class WeibullDistribution {
    public static void main(String[] args) {
        double beta = 2.5; // 分布参数
        double eta = 100.0; // 可靠寿命（无故障时间）
        double t = 50.0; // 已运行时间
        double reliability = getReliability(beta, eta, t);
        System.out.println("The reliability of the system is " + reliability);
    }
     public static double getReliability(double beta, double eta, double t) {
        double reliability = Math.exp(-Math.pow(t / eta, beta));
        return reliability;
    }
}

aaaaaaa为了帮助您更好地理解代码，可以通过以下步骤使用Bito AI插件来增强代码的可读性： aaaaaaa1. 首先，选中您想要添加注释的代码段。 aaaaaaa2. 然后，右键点击选中的代码区域，从弹出菜单中选择 Bito AI -> Improve Readability 选项。这一步骤将自动为您的每一行代码生成详细的英文注释，以提高代码的理解度。 aaaaaaa3. 如果您希望将这些英文注释转换成中文，只需给Bito AI插件发送指令，要求其将现有的英文注释替换为中文版本。 aaaaaaa4. 插件将会响应您的请求，并回复如下内容：‘好的，以下是加入中文注释的重写代码。’ 通过这样的流程，您可以轻松地得到带有清晰中文注释的代码，从而让代码更易于被非英语母语者或者偏好中文文档的开发者理解和维护。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

//按照给定的beta、eta和t值计算系统的可靠性
public class Main {
    public static void main(String[] args) {
        //初始化变量
        double beta = 2.5; // 分布参数
        double eta = 100.0; // 可靠寿命（无故障时间）
        double t = 50.0; // 已运行时间
        // 计算可靠性
        double reliability = getReliability(beta, eta, t);
        // 打印结果
        System.out.println("系统可靠性为：" + reliability);
    }
     //根据给定参数计算可靠性
    public static double getReliability(double beta, double eta, double t) {
        double reliability = Math.exp(-Math.pow(t / eta, beta));
        return reliability;
    }
}

  1. 检查代码质量 如果我们想知道一段代码的执行性能如何，Bito也可以帮助我们来判断。选中代码，然后点击右键菜单，选择Bito AI->Performance Check。这时候Bito就会帮我们检查代码的性能，并给出代码修改意见。

  2. 生成单元测试代码 Bito同时也可以生成单元测试代码。选中代码，然后点击右键菜单，选择Bito AI->Generate Unit Test。这时它会帮我们生成测试代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

@Test
public void testGetReliabilityPositive() {
    double beta = 2.5;
    double eta = 100.0;
    double t = 50.0;
    double expected = 0.006737946999085467;
    double actual = Main.getReliability(beta, eta, t);
    assertEquals(expected, actual, 0.001);
}
 @Test
public void testGetReliabilityNegative() {
    double beta = 2.5;
    double eta = 100.0;
    double t = 50.0;
    double expected = 0.006737946999085468;
    double actual = Main.getReliability(beta, eta, t);
    assertNotEquals(expected, actual, 0.001);
}
 @Test
public void testGetReliabilityBoundary() {
    double beta = 0;
    double eta = 100.0;
    double t = 0;
    double expected = 1.0;
    double actual = Main.getReliability(beta, eta, t);
    assertEquals(expected, actual, 0.001);
}
 @Test
public void testGetReliabilityEdge() {
    double beta = 2.5;
    double eta = 0;
    double t = 50.0;
    double expected = Double.POSITIVE_INFINITY;
    double actual = Main.getReliability(beta, eta, t);
    assertEquals(expected, actual, 0.001);
}
 @Test
public void testGetReliabilityCorner() {
    double beta = 0;
    double eta = 0;
    double t = 0;
    double expected = 1.0;
    double actual = Main.getReliability(beta, eta, t);
    assertEquals(expected, actual, 0.001);
}

ChatGPT及其在编程领域的应用

概述

今天我们探讨了ChatGPT的基础知识，并重点分析了它在辅助编程方面的应用。ChatGPT是一个基于统计相关性的语言模型，虽然它并不真正理解知识或进行推理，但它在自然语言处理领域已接近人类水平。

ChatGPT的功能

除了基本的对话功能外，ChatGPT还提供了以下辅助编程的功能：

  • 代码生成：根据用户需求生成代码。

  • 代码调试：帮助用户找出代码中的错误并修复。

  • 算法实现：提供算法的具体实现方式。

  • 解释代码：解释代码的功能和逻辑。 此外，ChatGPT还具备Security Check、Style Check、Clean Code等工具，以增强代码的安全性和可读性。

GPT-4的Bito体验

我们体验了GPT-4的Bito版本，发现它在生成代码的质量上超越了之前的ChatGPT，并且插件的使用让操作更为便捷。这对于程序员来说无疑是一个巨大的福音。

小结

尽管ChatGPT在理解知识、推理和价值观方面存在局限，但它仍然是自然语言处理领域的佼佼者。我们期待随着技术的进步，ChatGPT能够变得更加可靠和实用。

结语

如果你觉得今天的内容对你有所帮助，欢迎分享给朋友和同事，并在评论区留下你的想法，我们一起讨论，共同进步。期待在下一节课与你相见！