ホーム
Java
【2025年最新】Spring Boot入門ガイド！初心者でもわかるJavaフレームワークの基礎と実践

【2025年最新】Spring Boot入門ガイド！初心者でもわかるJavaフレームワークの基礎と実践

14 May, 2025

Spring Bootとは？初心者向け基本概念の解説

Spring Bootは、Javaベースのアプリケーション開発を簡素化するフレームワークです。従来のSpringフレームワークの複雑な設定を大幅に削減し、開発者が本質的なビジネスロジックに集中できるようにしています。

Spring Bootの主な特徴は以下の通りです：

自動設定（Auto-configuration） - 必要なコンポーネントを自動的に設定
スタンドアロン - 埋め込みサーバーを含む独立したアプリケーション作成
Opinionated Approach - デフォルト設定が最適化されている
プロダクション対応 - 運用環境に必要な機能を標準搭載

Spring Bootが解決する主な問題は「設定の複雑さ」です。従来のJava EEやSpringでは、XMLファイルやアノテーションによる膨大な設定が必要でした。Spring Bootは「Convention over Configuration（設定より規約）」の原則に従い、最小限の設定で開発をスタートできます。

// Spring Boot アプリケーションの最もシンプルな例
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

たった数行のコードでWebアプリケーションが起動できるのがSpring Bootの魅力です。従来のSpringでは設定ファイルに多くの記述が必要でしたが、Spring Bootでは@SpringBootApplicationアノテーション一つで多くの設定が自動化されます。

開発環境構築とHello Worldアプリケーション作成

Spring Bootを始めるには、いくつかの基本的なツールが必要です。ここではJDK、Maven（またはGradle）、そしてIDEの設定から簡単なHello Worldアプリケーションの作成まで説明します。

開発環境を準備する

JDKのインストール - Spring Boot 3.0以降はJava 17以上が必要です
ビルドツールのインストール - Maven または Gradle
IDEのインストール - Spring Tool Suite、IntelliJ IDEA、VS Codeなど

Spring Initializrを使って簡単にプロジェクトを作成できます：https://start.spring.io/

Spring Initializrでプロジェクト作成

プロジェクトのメタデータを設定（Group、Artifact）
依存関係を追加（「Spring Web」を選択）
プロジェクトをダウンロード・解凍
IDEでプロジェクトを開く

// src/main/java/com/example/demo/HelloController.java
package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

アプリケーションの実行

Mavenを使用する場合：

./mvnw spring-boot:run

Gradleを使用する場合：

./gradlew bootRun

ブラウザで http://localhost:8080/hello にアクセスすると、「Hello, Spring Boot!」と表示されます。

ここでのポイントは、Spring Bootがトムキャットなどのサーバーを内蔵しているため、別途サーバーをインストールする必要がないことです。これにより、開発からデプロイまでのプロセスが大幅に簡素化されています。

Spring Bootの核心　依存性注入（DI）の仕組みと実装例

依存性注入（Dependency Injection, DI）はSpringフレームワークの中核概念で、Spring Bootでも重要な役割を果たしています。DIとはクラス間の依存関係をフレームワークが自動的に「注入」する仕組みです。

依存性注入の基本

DIの主なメリットは以下の通りです：

コンポーネントの疎結合化
テストの容易さ
コードの再利用性向上
設定の一元管理

Spring Bootでは、主に以下の方法で依存性注入を行います：

コンストラクタ注入 - 推奨される方法
セッター注入
フィールド注入 - テストが難しくなるため、あまり推奨されない

コンストラクタ注入の例

@Service
public class UserService {
    private final UserRepository userRepository;
    
    // コンストラクタ注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User findById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found"));
    }
}

Bean定義とコンポーネントスキャン

Spring Bootでは、@Component, @Service, @Repository, @Controllerなどのアノテーションを使って自動的にBeanを登録できます。

@Configuration
public class AppConfig {
    
    // 明示的なBean定義
    @Bean
    public SomeService someService() {
        return new SomeServiceImpl();
    }
}

@SpringBootApplicationアノテーションには@ComponentScanが含まれているため、アプリケーションのパッケージとそのサブパッケージにあるコンポーネントが自動的にスキャンされます。

スコープとライフサイクル

Spring Bootでは、Beanのスコープを指定できます：

@Service
@Scope("prototype") // デフォルトは"singleton"
public class SomeService {
    // ...
}

主なスコープは以下の通りです：

singleton - アプリケーション全体で1つのインスタンス（デフォルト）
prototype - 注入されるたびに新しいインスタンス
request - HTTPリクエストごとに新しいインスタンス
session - HTTPセッションごとに新しいインスタンス

依存性注入を理解することで、Springアプリケーションの構造をより明確に把握でき、メンテナンス性の高いコードを書くことができます。

RESTful APIの作成方法とコントローラーの実装テクニック

Spring Bootを使ったRESTful APIの開発は非常に直感的でシンプルです。ここでは、コントローラーの実装からHTTPメソッドの扱い方、パラメータのバインディングなどを説明します。

コントローラーの基本

Spring MVCでは、@Controllerまたは@RestControllerアノテーションを使ってコントローラークラスを定義します。

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
    
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
    
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.update(id, user);
    }
    
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}

リクエストパラメータの処理

Spring MVCでは、様々な方法でリクエストパラメータを処理できます：

@PathVariable - URLパス変数を取得
@RequestParam - クエリパラメータを取得
@RequestBody - リクエストボディをオブジェクトにバインド
@RequestHeader - HTTPヘッダーを取得

@GetMapping("/search")
public List<User> searchUsers(
    @RequestParam(required = false) String name,
    @RequestParam(defaultValue = "0") int page,
    @RequestParam(defaultValue = "10") int size) {
    
    return userService.search(name, page, size);
}

エラー処理

Spring Bootでは、@ExceptionHandlerと@ControllerAdviceを使ってグローバルなエラー処理を実装できます。

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(ResourceNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public Map<String, String> handleResourceNotFound(ResourceNotFoundException ex) {
        Map<String, String> errors = new HashMap<>();
        errors.put("message", ex.getMessage());
        return errors;
    }
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public Map<String, String> handleValidationExceptions(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getAllErrors().forEach(error -> {
            String fieldName = ((FieldError) error).getField();
            String errorMessage = error.getDefaultMessage();
            errors.put(fieldName, errorMessage);
        });
        return errors;
    }
}

バリデーション

Spring Bootでは、Bean Validationを使ってリクエストの入力値を検証できます。

@PostMapping
public User createUser(@Valid @RequestBody User user) {
    return userService.save(user);
}

// User.java
@Data
public class User {
    
    @NotBlank(message = "名前は必須です")
    private String name;
    
    @Email(message = "有効なメールアドレスを入力してください")
    private String email;
    
    @Min(value = 18, message = "年齢は18歳以上である必要があります")
    private int age;
}

これらの機能を活用することで、堅牢なRESTful APIを簡単に作成できます。Spring Bootは、JSON/XMLの変換、コンテンツネゴシエーション、HTTPステータスコードの管理など、多くの機能を自動的に提供します。

データベース連携の基本とJPA/Hibernateを使ったCRUD操作

Spring Bootは、データベース連携を簡単に行えるよう、多くの機能を提供しています。特にSpring Data JPAを使うことで、最小限のコードでデータベース操作が実現できます。

Spring Data JPAの設定

まず、build.gradleまたはpom.xmlに依存関係を追加します：

<!-- Maven -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

次に、application.propertiesにデータベース接続情報を設定します：

# H2データベースの設定（開発用）
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

# H2コンソールを有効化
spring.h2.console.enabled=true

# JPAの設定
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

本番環境ではMySQL、PostgreSQL、OracleなどのDBMSを使用する場合は設定を変更します：

# MySQL設定例
spring.datasource.url=jdbc:mysql://localhost:3306/mydatabase
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update

エンティティの定義

JPAでは、データベースのテーブルとマッピングするJavaクラスをエンティティとして定義します：

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(unique = true)
    private String email;
    
    private int age;
    
    // ゲッター・セッター省略
}

リポジトリの作成

Spring Data JPAでは、JPAリポジトリインターフェースを継承するだけで、CRUDなどの基本的な操作が自動的に実装されます：

public interface UserRepository extends JpaRepository<User, Long> {
    
    // 名前で検索
    List<User> findByNameContaining(String name);
    
    // 年齢で絞り込み
    List<User> findByAgeGreaterThan(int age);
    
    // メールアドレスでユーザーを検索
    Optional<User> findByEmail(String email);
    
    // カスタムクエリ
    @Query("SELECT u FROM User u WHERE u.name = :name AND u.age >= :age")
    List<User> findUsersByNameAndAge(@Param("name") String name, @Param("age") int age);
}

サービス層の実装

リポジトリを使ってビジネスロジックを実装するサービス層を作成します：

@Service
@Transactional
public class UserService {
    
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public List<User> findAll() {
        return userRepository.findAll();
    }
    
    public User findById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found with id: " + id));
    }
    
    public User save(User user) {
        // メールアドレスの重複チェック
        if (userRepository.findByEmail(user.getEmail()).isPresent()) {
            throw new IllegalArgumentException("Email already in use");
        }
        return userRepository.save(user);
    }
    
    public User update(Long id, User user) {
        User existingUser = findById(id);
        existingUser.setName(user.getName());
        existingUser.setEmail(user.getEmail());
        existingUser.setAge(user.getAge());
        return userRepository.save(existingUser);
    }
    
    public void delete(Long id) {
        User user = findById(id);
        userRepository.delete(user);
    }
    
    // 名前でユーザーを検索
    public List<User> searchByName(String name) {
        return userRepository.findByNameContaining(name);
    }
}

このような実装により、データベースの接続設定から基本的なCRUD操作、さらには独自の検索メソッドまで、最小限のコードでデータベース連携機能を実現できます。

実践的アプリケーション開発とデプロイ方法

これまで学んだ知識を活かして、実践的なSpring Bootアプリケーションの開発方法とデプロイ手順について説明します。

アプリケーション構造のベストプラクティス

Spring Bootアプリケーションの一般的なディレクトリ構造は以下のようになります：

src/
├── main/
│   ├── java/
│   │   └── com/
│   │       └── example/
│   │           └── myapp/
│   │               ├── MyAppApplication.java
│   │               ├── config/
│   │               ├── controller/
│   │               ├── model/
│   │               ├── repository/
│   │               ├── service/
│   │               └── util/
│   └── resources/
│       ├── application.properties
│       ├── static/
│       └── templates/
└── test/
    └── java/
        └── com/
            └── example/
                └── myapp/
                    └── ...

主な構成要素：

config/ - アプリケーション設定クラス
controller/ - REST APIやWebコントローラー
model/ - エンティティクラス
repository/ - データアクセス用リポジトリ
service/ - ビジネスロジックを含むサービス
resources/static/ - 静的リソース（CSS, JavaScript, 画像）
resources/templates/ - テンプレートファイル（Thymeleafなど）

プロファイルによる環境別設定

Spring Bootでは、異なる環境（開発、テスト、本番）に対して異なる設定を定義できます：

src/main/resources/
├── application.properties
├── application-dev.properties
├── application-test.properties
└── application-prod.properties

アクティブなプロファイルを指定する方法：

# 実行時にプロファイルを指定
java -jar myapp.jar --spring.profiles.active=dev

# または application.properties で設定
spring.profiles.active=dev

アプリケーションのセキュリティ対策

Spring Securityを使用すると、簡単に認証・認可機能を追加できます：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

基本的なセキュリティ設定：

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .permitAll()
            )
            .csrf(csrf -> csrf.disable());
        
        return http.build();
    }
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

デプロイオプション

Spring Bootアプリケーションのデプロイには様々な方法があります：

実行可能JARファイルとして実行

# ビルド
./mvnw clean package

# 実行
java -jar target/myapp-0.0.1-SNAPSHOT.jar

Dockerコンテナとして実行

FROM eclipse-temurin:17-jdk-alpine
VOLUME /tmp
COPY target/*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

# Dockerイメージのビルド
docker build -t myapp .

# コンテナの実行
docker run -p 8080:8080 myapp

クラウドサービスへのデプロイ

AWS Elastic Beanstalk
Google App Engine
Azure App Service
Heroku

本番環境での運用ポイント

アクチュエータの活用 - アプリケーションの監視と管理

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

# アクチュエータのエンドポイントを有効化
management.endpoints.web.exposure.include=health,info,metrics,loggers

# 詳細なヘルス情報を表示
management.endpoint.health.show-details=always

ロギングの設定

# ログレベルの設定
logging.level.root=INFO
logging.level.com.example.myapp=DEBUG

# ログファイルの出力先
logging.file.name=/var/log/myapp.log

セッション管理

# Redisを使ったセッション管理
spring.session.store-type=redis
spring.redis.host=localhost
spring.redis.port=6379

Spring Bootは、簡単な開発設定からエンタープライズレベルの本番環境まで、幅広いニーズに対応できる柔軟なフレームワークです。これらの知識を活用して、効率的かつ堅牢なアプリケーション開発を行いましょう。

Tasuke Hub管理人

東証プライム市場上場企業エンジニア

情報系修士卒業後、大手IT企業にてフルスタックエンジニアとして活躍。 Webアプリケーション開発からクラウドインフラ構築まで幅広い技術に精通し、複数のプロジェクトでリードエンジニアを担当。技術ブログやオープンソースへの貢献を通じて、日本のIT技術コミュニティに積極的に関わっている。

🎓情報系修士🏢東証プライム上場企業💻フルスタックエンジニア📝技術ブログ執筆者

Spring徹底入門第2版 Spring FrameworkによるJavaアプリケーション開発

Amazonで見る

楽天市場で見る

Yahoo!ショッピングで見る