To implement a real-time chat application using WebSockets in Go, we'll use the `gorilla/websocket` package for handling WebSocket connections and the `go-sql-driver/mysql` package to interact with MySQL database. Here's an outline of how you can create this application:

1. Install the required packages:
```bash
go get -u github.com/gorilla/websocket
go get -u github.com/go-sql-driver/mysql
```

2. Create a `main.go` file and import the necessary packages:
```go
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/websocket"
	_ "github.com/go-sql-driver/mysql"
)
```

3. Define a struct for messages and clients:
```go
type Message struct {
	Username string `json:"username"`
	Message  string `json:"message"`
}

type Client struct {
	conn   *websocket.Conn
	sendCh chan Message
}
```

4. Initialize global variables for clients and upgrader:
```go
var clients = make(map[*Client]bool)
var broadcast = make(chan Message)

var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true
	},
}
```

5. Connect to the MySQL database:
```go
func connectDB() (*sql.DB, error) {
	db, err := sql.Open("mysql", "username:password@tcp(localhost:3306)/chat_db")
	if err != nil {
		return nil, err
	}
	return db, nil
}
```

6. Implement the function to handle new WebSocket connections:
```go
func handleConnections(w http.ResponseWriter, r *http.Request) {
	ws, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer ws.Close()

	client := &Client{conn: ws, sendCh: make(chan Message)}
	clients[client] = true

	for {
		var msg Message
		err := ws.ReadJSON(&msg)
		if err != nil {
			delete(clients, client)
			break
		}

		broadcast <- msg
	}
}
```

7. Implement the function to handle broadcasting messages:
```go
func handleMessages() {
	db, err := connectDB()
	if err != nil {
		log.Fatal("Database connection error:", err)
		return
	}
	defer db.Close()

	for {
		msg := <-broadcast

		stmt, err := db.Prepare("INSERT INTO chat_history(username, message) VALUES(?, ?)")
		if err != nil {
			log.Println("Error preparing statement:", err)
			continue
		}

		_, err = stmt.Exec(msg.Username, msg.Message)
		if err != nil {
			log.Println("Error saving message to database:", err)
			continue
		}

		for client := range clients {
			client.sendCh <- msg
		}
	}
}
```

8. Implement the main function to start the server and WebSocket handlers:
```go
func main() {
	fs := http.FileServer(http.Dir("public"))
	http.Handle("/", fs)

	http.HandleFunc("/ws", handleConnections)

	go handleMessages()

	fmt.Println("Server started on :8000")
	err := http.ListenAndServe(":8000", nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}
```

9. Create a `public` folder with an `index.html` file for the frontend:

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Chat App</title>
</head>
<body>
    <div id="messages"></div>
    <form id="messageForm">
        <input type="text" id="username" placeholder="Username">
        <input type="text" id="message" placeholder="Message">
        <button type="submit">Send</button>
    </form>

    <script>
        const messageForm = document.getElementById("messageForm");
        const usernameInput = document.getElementById("username");
        const messageInput = document.getElementById("message");
        const messagesDiv = document.getElementById("messages");

        const socket = new WebSocket("ws://localhost:8000/ws");

        socket.onmessage = (event) => {
            const msg = JSON.parse(event.data);
            messagesDiv.innerHTML += `<p><strong>${msg.username}:</strong> ${msg.message}</p>`;
        };

        messageForm.addEventListener("submit", (event) => {
            event.preventDefault();
            const msg = {
                username: usernameInput.value,
                message: messageInput.value
            };
            socket.send(JSON.stringify(msg));
            messageInput.value = "";
        });
    </script>
</body>
</html>
```

10. Run the application:
```bash
go run main.go
```

Now, you can open multiple browser windows and navigate to `http://localhost:8000` to test the chat application. The chat history will be stored in the MySQL database.

Note that this is a basic implementation of a real-time chat application using WebSockets in Go. You might want to add more features like user authentication, error handling, and better frontend design for a production-ready application.
Go에서 웹소켓을 사용해 실시간 채팅 애플리케이션을 구현하기 위해, 웹소켓 연결을 처리하기 위한 `gorilla/websocket` 패키지와 MySQL 데이터베이스와 상호 작용하기 위한 `go-sql-driver/mysql` 패키지를 사용하겠습니다. 다음은 이 애플리케이션을 만드는 방법에 대한 개요입니다.

1. 필요한 패키지를 설치합니다:
```bash
go get -u github.com/gorilla/websocket
go get -u github.com/go-sql-driver/mysql
```

2. `main.go` 파일을 생성하고 필요한 패키지를 가져옵니다:
```go
package main

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	"github.com/gorilla/websocket"
	_ "github.com/go-sql-driver/mysql"
)
```

3. 메시지와 클라이언트에 대한 구조체를 정의합니다:
```go
type Message struct {
	Username string `json:"username"`
	Message  string `json:"message"`
}

type Client struct {
	conn   *websocket.Conn
	sendCh chan Message
}
```

4. 클라이언트 및 업그레이더에 대한 전역 변수를 초기화합니다:
```go
var clients = make(map[*Client]bool)
var broadcast = make(chan Message)

var upgrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true
	},
}
```

5. MySQL 데이터베이스에 연결합니다:
```go
func connectDB() (*sql.DB, error) {
	db, err := sql.Open("mysql", "username:password@tcp(localhost:3306)/chat_db")
	if err != nil {
		return nil, err
	}
	return db, nil
}
```

6. 새 웹소켓 연결을 처리하는 함수를 구현합니다:
```go
func handleConnections(w http.ResponseWriter, r *http.Request) {
	ws, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer ws.Close()

	client := &Client{conn: ws, sendCh: make(chan Message)}
	clients[client] = true

	for {
		var msg Message
		err := ws.ReadJSON(&msg)
		if err != nil {
			delete(clients, client)
			break
		}

		broadcast <- msg
	}
}
```

7. 브로드캐스팅 메시지를 처리하는 기능을 구현합니다:
```go
func handleMessages() {
	db, err := connectDB()
	if err != nil {
		log.Fatal("Database connection error:", err)
		return
	}
	defer db.Close()

	for {
		msg := <-broadcast

		stmt, err := db.Prepare("INSERT INTO chat_history(username, message) VALUES(?, ?)")
		if err != nil {
			log.Println("Error preparing statement:", err)
			continue
		}

		_, err = stmt.Exec(msg.Username, msg.Message)
		if err != nil {
			log.Println("Error saving message to database:", err)
			continue
		}

		for client := range clients {
			client.sendCh <- msg
		}
	}
}
```

8. 서버와 웹소켓 핸들러를 시작하는 메인 함수를 구현합니다:
```go
func main() {
	fs := http.FileServer(http.Dir("public"))
	http.Handle("/", fs)

	http.HandleFunc("/ws", handleConnections)

	go handleMessages()

	fmt.Println("Server started on :8000")
	err := http.ListenAndServe(":8000", nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}
```

9. 프런트엔드용 `index.html` 파일이 있는 `public` 폴더를 만듭니다:

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Chat App</title>
</head>
<body>
    <div id="messages"></div>
    <form id="messageForm">
        <input type="text" id="username" placeholder="Username">
        <input type="text" id="message" placeholder="Message">
        <button type="submit">Send</button>
    </form>

    <script>
        const messageForm = document.getElementById("messageForm");
        const usernameInput = document.getElementById("username");
        const messageInput = document.getElementById("message");
        const messagesDiv = document.getElementById("messages");

        const socket = new WebSocket("ws://localhost:8000/ws");

        socket.onmessage = (event) => {
            const msg = JSON.parse(event.data);
            messagesDiv.innerHTML += `<p><strong>${msg.username}:</strong> ${msg.message}</p>`;
        };

        messageForm.addEventListener("submit", (event) => {
            event.preventDefault();
            const msg = {
                username: usernameInput.value,
                message: messageInput.value
            };
            socket.send(JSON.stringify(msg));
            messageInput.value = "";
        });
    </script>
</body>
</html>
```

10. 애플리케이션을 실행합니다:
```bash
go run main.go
```

이제 여러 브라우저 창을 열고 `http://localhost:8000`으로 이동하여 채팅 애플리케이션을 테스트할 수 있습니다. 채팅 기록은 MySQL 데이터베이스에 저장됩니다.

이것은 Go에서 WebSocket을 사용한 실시간 채팅 애플리케이션의 기본 구현입니다. 사용자 인증, 오류 처리, 더 나은 프론트엔드 디자인 등 더 많은 기능을 추가하여 프로덕션에 사용할 수 있는 애플리케이션을 구현할 수 있습니다.