<code>build.gradle</code> ファイルに <code>jjwt</code> ライブラリを追加します。<pre><code>implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'io.jsonwebtoken:jjwt:0.9.1'

implementation 'javax.xml.bind:jaxb-api:2.3.1'
implementation 'org.glassfish.jaxb:jaxb-runtime:2.3.1'</code></pre>

Gradle ビルドファイルの設定

<code>src/main/java/com/example/user/security</code> に <code>JwtUtils</code> を作成します。JWT の生成、パース、検証を行うためのユーティリティクラスを作成します。<pre><code>package com.example.user.security;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

@Component
public class JwtUtils {

 @Value("${jwt.secret}")
 private String secret;

 @Value("${jwt.expiration.ms}")
 private long expirationMs;

 // JWT からユーザー名を取得
 public String extractUsername(String token) {
 return extractClaim(token, Claims::getSubject);
 }

 // JWT から有効期限を取得
 public Date extractExpiration(String token) {
 return extractClaim(token, Claims::getExpiration);
 }

 // JWT からクレーム（claims）を取得
 public &lt;T&gt; T extractClaim(String token, Function&lt;Claims, T&gt; claimsResolver) {
 final Claims claims = extractAllClaims(token);
 return claimsResolver.apply(claims);
 }

 // JWT から全てのクレームを取得
 private Claims extractAllClaims(String token) {
 return Jwts.parser().setSigningKey(secret.getBytes(Charset.forName("UTF-8")))
 .parseClaimsJws(token).getBody();
 }

 // JWT が有効かどうかをチェック
 private Boolean isTokenExpired(String token) {
 return extractExpiration(token).before(new Date());
 }

 // JWT を生成
 public String generateToken(UserDetails userDetails) {
 Map&lt;String, Object&gt; claims = new HashMap&lt;&gt;();
 return createToken(claims, userDetails.getUsername());
 }

 // JWT を生成（クレームを追加可能）
 private String createToken(Map&lt;String, Object&gt; claims, String subject) {
 return Jwts.builder().setClaims(claims).setSubject(subject)
 .setIssuedAt(new Date(System.currentTimeMillis()))
 .setExpiration(new Date(System.currentTimeMillis() + expirationMs))
 .signWith(SignatureAlgorithm.HS256, secret).compact();
 }

 // JWT のバリデーション
 public Boolean validateToken(String token, UserDetails userDetails) {
 final String username = extractUsername(token);
 return (username.equals(userDetails.getUsername()) &amp;&amp; !isTokenExpired(token));
 }
}</code></pre>

 JWT ユーティリティクラスの作成

<code>src/main/java/com/example/user/security</code> に <code>JwtRequestFilter</code> を作成します。<pre><code>package com.example.user.security;

import java.io.IOException;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

@Component
public class JwtRequestFilter extends OncePerRequestFilter {

 @Autowired
 private JwtUtils jwtUtils;

 @Autowired
 private UserDetailsService userDetailsService;

 @Override
 protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
 throws ServletException, IOException {

 final String authorizationHeader = request.getHeader("Authorization");

 String username = null;
 String jwt = null;

 if (authorizationHeader != null &amp;&amp; authorizationHeader.startsWith("Bearer ")) {
 jwt = authorizationHeader.substring(7);
 username = jwtUtils.extractUsername(jwt);
 }

 if (username != null &amp;&amp; SecurityContextHolder.getContext().getAuthentication() == null) {
 UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
 if (jwtUtils.validateToken(jwt, userDetails)) {
 UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(
 userDetails, null, userDetails.getAuthorities());
 authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
 SecurityContextHolder.getContext().setAuthentication(authToken);
 }
 }
 chain.doFilter(request, response);
 }
}</code></pre>

JWT 認証フィルターの作成

<code>src/main/java/com/example/user/security</code> に <code>JwtAuthenticationEntryPoint</code> を作成します。認証エラー時のエントリーポイントをカスタムで作成します。<pre><code>package com.example.user.security;

import java.io.IOException;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {

 @Override
 public void commence(HttpServletRequest request, HttpServletResponse response,
 AuthenticationException authException) throws IOException, ServletException {
 response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
 }
}</code></pre>

認証エントリーポイントの作成

<code>src/main/java/com/example/user/security</code> に <code>SecurityConfig</code> ファイルを作成します。<pre><code>package com.example.user.security;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

 @Bean
 public PasswordEncoder passwordEncoder() {
 return new BCryptPasswordEncoder();
 }

 @Bean
 public SecurityFilterChain securityFilterChain(HttpSecurity http, JwtRequestFilter jwtRequestFilter, JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint) throws Exception {
 http
 .csrf(csrf -&gt; csrf.disable())
 .authorizeHttpRequests(auth -&gt; auth
 .requestMatchers("/authenticate", "/register").permitAll()
 .requestMatchers("/users/**").hasRole("USER")
 .anyRequest().authenticated()
 )
 .exceptionHandling(exceptions -&gt; exceptions
 .authenticationEntryPoint(jwtAuthenticationEntryPoint)
 )
 .sessionManagement(session -&gt; session
 .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
 );
 http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
 return http.build();
 }

 @Bean
 public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
 return authenticationConfiguration.getAuthenticationManager();
 }
}</code></pre>

Spring Security 設定クラスの作成

<code>application.properties</code> ファイルに、JWT の秘密鍵と有効期限を設定します。<pre><code>jwt.secret=mysecretkey
jwt.expiration.ms=3600000</code></pre>

アプリケーションプロパティの設定

<code>src/main/java/com/example/user/security</code> に <code>AuthenticationRequest</code>&nbsp;ファイルを作成します。<pre><code>package com.example.user.security;

public class AuthenticationRequest {

 private String username;

 private String password;

 // Getters and Setters
 public String getUsername() {
 return username;
 }

 public void setUsername(String username) {
 this.username = username;
 }

 public String getPassword() {
 return password;
 }

 public void setPassword(String password) {
 this.password = password;
 }
}</code></pre>

AuthenticationRequest の作成

<code>src/main/java/com/example/user/entity</code> に <code>Role</code> クラスを作成します。<pre><code>package com.example.user.entity;

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

@Entity
public class Role {

 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 private String name;

 // Getters and Setters
 public Long getId() {
 return id;
 }
 public void setId(Long id) {
 this.id = id;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
}

</code></pre>

ユーザーロールの管理

username, password, roles フィールドを追加します。(getter/setter も忘れずに)<pre><code>package com.example.user.entity;

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

@Entity
public class Users {

&nbsp; &nbsp; @Id
&nbsp; &nbsp; @GeneratedValue(strategy = GenerationType.IDENTITY)
&nbsp; &nbsp; private Long id;
&nbsp; &nbsp; private String name;
&nbsp; &nbsp; private String email;
&nbsp; &nbsp; private String username;&nbsp; // 追加
&nbsp; &nbsp; private String password;&nbsp; // 追加

 @ManyToMany(fetch = FetchType.EAGER)
 @JoinTable(
 name = "users_roles",
 joinColumns = @JoinColumn(name = "user_id"),
 inverseJoinColumns = @JoinColumn(name = "role_id")
 )
 private Set&lt;Role&gt; roles = new HashSet&lt;&gt;();

&nbsp; &nbsp; // Getters and Setters
&nbsp; &nbsp; public Long getId() {
&nbsp; &nbsp; &nbsp; &nbsp; return id;
&nbsp; &nbsp; }
&nbsp; &nbsp; public void setId(Long id) {
&nbsp; &nbsp; &nbsp; &nbsp; this.id = id;
&nbsp; &nbsp; }
&nbsp; &nbsp; public String getName() {
&nbsp; &nbsp; &nbsp; &nbsp; return name;
&nbsp; &nbsp; }
&nbsp; &nbsp; public void setName(String name) {
&nbsp; &nbsp; &nbsp; &nbsp; this.name = name;
&nbsp; &nbsp; }
&nbsp; &nbsp; public String getEmail() {
&nbsp; &nbsp; &nbsp; &nbsp; return email;
&nbsp; &nbsp; }
&nbsp; &nbsp; public void setEmail(String email) {
&nbsp; &nbsp; &nbsp; &nbsp; this.email = email;
&nbsp; &nbsp; }
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
 public Set&lt;Role&gt; getRoles() {
 return roles;
 }
 public void setRoles(Set&lt;Role&gt; roles) {
 this.roles = roles;
 }
}</code></pre>

Users モデルへの追加

<code>src/main/java/com/example/user/repository</code> に <code>RoleRepository</code> クラスを作成します。<pre><code>package com.example.user.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.user.entity.Role;

public interface RoleRepository extends JpaRepository&lt;Role, Long&gt; {
 Role findByName(String name);
}</code></pre>

Role リポジトリの作成

<code>src/main/java/com/example/user/security</code> に <code>AuthenticationController</code> ファイルを作成します。JWT トークンを生成するための認証コントローラーを作成します。<pre><code>package com.example.user.security;

import java.util.HashSet;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.example.user.entity.Role;
import com.example.user.entity.Users;
import com.example.user.repository.RoleRepository;
import com.example.user.repository.UsersRepository;

@RestController
public class AuthenticationController {

 @Autowired
 private AuthenticationManager authenticationManager;

 @Autowired
 private JwtUtils jwtUtils;

 @Autowired
 private UserDetailsService userDetailsService;

 @Autowired
 private PasswordEncoder passwordEncoder;

 @Autowired
 private UsersRepository usersRepository;

 @Autowired
 private RoleRepository roleRepository;

 @PostMapping("/authenticate")
 public String createAuthenticationToken(@RequestBody AuthenticationRequest authenticationRequest) throws Exception {

 authenticate(authenticationRequest.getUsername(), authenticationRequest.getPassword());

 final UserDetails userDetails = userDetailsService.loadUserByUsername(authenticationRequest.getUsername());
 final String token = jwtUtils.generateToken(userDetails);
 jwtUtils.extractUsername(token);
 return token;
 }

 @PostMapping("/register")
 public String registerUser(@RequestBody Users user) {
 user.setPassword(passwordEncoder.encode(user.getPassword()));
 // ロールを設定
 Role userRole = roleRepository.findByName("USER");
 if (userRole == null) {
 userRole = new Role();
 userRole.setName("USER");
 roleRepository.save(userRole);
 }
 Set&lt;Role&gt; roles = new HashSet&lt;&gt;();
 roles.add(userRole);
 user.setRoles(roles);
 usersRepository.save(user);
 return "User registered successfully";
 }
 private void authenticate(String username, String password) throws Exception {
 try {
 authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(username, password));
 } catch (Exception e) {
 throw new Exception("INVALID_CREDENTIALS", e);
 }
 }
}</code></pre>

認証コントローラーの作成

<code>src/main/java/com/example/user/repository</code> の <code>UsersRepository</code> に<code>findByUsername</code> メソッドを追加します。<pre><code>package com.example.user.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.user.entity.Users;

public interface UsersRepository extends JpaRepository&lt;Users, Long&gt; {
&nbsp; &nbsp; Users findByUsername(String username);&nbsp; // 追加
}</code></pre>

UsersRepository への追加

<code>JwtUserDetailsService</code> をロール情報に対応するように修正します。<pre><code>package com.example.user.security;

import java.util.List;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import com.example.user.entity.Users;
import com.example.user.repository.UsersRepository;

@Service
public class JwtUserDetailsService implements UserDetailsService {

 @Autowired
 private UsersRepository usersRepository;

 @Override
 public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
 Users user = usersRepository.findByUsername(username);
 if (user == null) {
 throw new UsernameNotFoundException("User not found with username: " + username);
 }
 List&lt;SimpleGrantedAuthority&gt; authorities = user.getRoles().stream()
 .map(role -&gt; new SimpleGrantedAuthority("ROLE_" + role.getName()))
 .collect(Collectors.toList());
 return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), authorities);
 }
}</code></pre>

ユーザーロールを考慮したUserDetailsServiceの実装

<code>src/main/java/com/example/user/repository</code> の <code>JwtUserDetailsService</code> を作成します。Spring Security 用のユーザーサービスを実装します。<pre><code>package com.example.user.security;

import java.util.ArrayList;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import com.example.user.entity.Users;
import com.example.user.repository.UsersRepository;

@Service
public class JwtUserDetailsService implements UserDetailsService {

 @Autowired
 private UsersRepository usersRepository;

 @Override
 public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
 Users user = usersRepository.findByUsername(username);
 if (user == null) {
 throw new UsernameNotFoundException("User not found with username: " + username);
 }
 return new org.springframework.security.core.userdetails.User(user.getName(), user.getPassword(), new ArrayList&lt;&gt;());
 }
}</code></pre>

Spring Security ユーザーのサービスの実装

schema.sql を以下のように修正します。<pre><code>CREATE SEQUENCE IF NOT EXISTS "ID_SEQ" 
MINVALUE 1 
MAXVALUE 999999999 
INCREMENT BY 1 
START WITH 2 
NOCACHE 
NOCYCLE;
CREATE TABLE IF NOT EXISTS users(
	id VARCHAR(50) DEFAULT nextval('ID_SEQ') PRIMARY KEY ,
	name VARCHAR(50),
	email VARCHAR(80),
	username VARCHAR(80),
	password VARCHAR(80)
	);
CREATE TABLE IF NOT EXISTS role (
 id BIGINT AUTO_INCREMENT PRIMARY KEY,
 name VARCHAR(255) NOT NULL
);

CREATE TABLE IF NOT EXISTS users_roles (
 user_id BIGINT NOT NULL,
 role_id BIGINT NOT NULL,
 PRIMARY KEY (user_id, role_id),
 FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
 FOREIGN KEY (role_id) REFERENCES role(id) ON DELETE CASCADE
);</code></pre>

SQL スキーマの変更

data.sql を以下のように変更します。<pre><code>INSERT INTO users(id, name, email, username, password) VALUES('1', 'Hara', 'hara@example.com', 'hara', null);

INSERT INTO role(id, name) VALUES(1, 'USER');</code></pre>

SQL データの変更

これで動くと思ったら、全部 401 になるので、次回動くように修正します！

今回はここまで

実装

Spring Boot 再入門 (4)

<code>src/main/java/com/example/user/entity</code> に <code>Users</code> Entity を作成します。パッケージが user.entity に変わっていますので、注意してください。JPAにおいて、<code>@GeneratedValue</code>を使って主キーにユニークな値を自動で生成し、<code>@Id</code>を持つフィルドに適用できます。<pre><code>package com.example.user.entity;

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

@Entity
public class Users {

&nbsp; &nbsp; @Id
&nbsp; &nbsp; @GeneratedValue(strategy = GenerationType.IDENTITY)
&nbsp; &nbsp; private Long id;
&nbsp; &nbsp; private String name;
&nbsp; &nbsp; private String email;

&nbsp; &nbsp; // Getters and Setters
&nbsp; &nbsp; public Long getId() {
&nbsp; &nbsp; &nbsp; &nbsp; return id;
&nbsp; &nbsp; }

&nbsp; &nbsp; public void setId(Long id) {
&nbsp; &nbsp; &nbsp; &nbsp; this.id = id;
&nbsp; &nbsp; }

&nbsp; &nbsp; public String getName() {
&nbsp; &nbsp; &nbsp; &nbsp; return name;
&nbsp; &nbsp; }

&nbsp; &nbsp; public void setName(String name) {
&nbsp; &nbsp; &nbsp; &nbsp; this.name = name;
&nbsp; &nbsp; }

&nbsp; &nbsp; public String getEmail() {
&nbsp; &nbsp; &nbsp; &nbsp; return email;
&nbsp; &nbsp; }

&nbsp; &nbsp; public void setEmail(String email) {
&nbsp; &nbsp; &nbsp; &nbsp; this.email = email;
&nbsp; &nbsp; }
}</code></pre>

Users Entity の作成

<code>src/main/java/com/example/user/repository</code> ディレクトリに <code>UsersRepository</code> インターフェースを作成します。<pre><code>package com.example.user.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.user.entity.Users;

public interface UsersRepository extends JpaRepository&lt;Users, Long&gt; {
}</code></pre>

User リポジトリの作成

<code>src/main/java/com/example/users/service</code> ディレクトリに <code>UsersService</code> クラスを作成します。<pre><code>package com.example.user.service;

import java.util.List;
import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.user.entity.Users;
import com.example.user.repository.UsersRepository;

@Service
public class UsersService {

 @Autowired
 private UsersRepository usersRepository;

 public List&lt;Users&gt; findAll() {
 return usersRepository.findAll();
 }

 public Optional&lt;Users&gt; findById(Long id) {
 return usersRepository.findById(id);
 }

 public Users save(Users user) {
 return usersRepository.save(user);
 }

 public void deleteById(Long id) {
 usersRepository.deleteById(id);
 }
}</code></pre> ポイント：@Service をつけると、Spring Boot がオブジェクトをサービスクラスとして管理してくれます。 <pre><code>@Service
public class UsersService {</code></pre>ポイント：@Autowired で interface の依存関係を注入しています。<pre><code> @Autowired
 private UsersRepository usersRepository;</code></pre>

Users Service の作成

<code>src/main/java/com/example/user/controller</code> ディレクトリに <code>UsersController</code> クラスを作成します。<pre><code>package com.example.user.controller;

import java.util.List;
import java.util.Optional;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.user.entity.Users;
import com.example.user.service.UsersService;

@RestController
@RequestMapping("/users")
public class UsersController {

 @Autowired
 private UsersService usersService;

 @GetMapping
 public List&lt;Users&gt; getAllUsers() {
 return usersService.findAll();
 }

 @GetMapping("/{id}")
 public ResponseEntity&lt;Users&gt; getUserById(@PathVariable Long id) {
 Optional&lt;Users&gt; user = usersService.findById(id);
 return user.map(ResponseEntity::ok).orElseGet(() -&gt; ResponseEntity.notFound().build());
 }

 @PostMapping(consumes = {"application/json"})
 public ResponseEntity&lt;Users&gt; createUser(@RequestBody Users user) {
 Users savedUser = usersService.save(user);
 return ResponseEntity.status(HttpStatus.CREATED).body(savedUser);
 }

 @PutMapping("/{id}")
 public ResponseEntity&lt;Users&gt; updateUser(@PathVariable Long id, @RequestBody Users userDetails) {

 Optional&lt;Users&gt; optionalUser = usersService.findById(id);

 if (optionalUser.isPresent()) {
 Users user = optionalUser.get();
 user.setName(userDetails.getName());
 user.setEmail(userDetails.getEmail());
 Users updatedUser = usersService.save(user);
 return ResponseEntity.ok(updatedUser);
 } else {
 return ResponseEntity.notFound().build();
 }
 }

 @DeleteMapping("/{id}")
 public ResponseEntity&lt;Void&gt; deleteUser(@PathVariable Long id) {
 usersService.deleteById(id);
 return ResponseEntity.noContent().build();
 }
}</code></pre> ポイント：@RestController をつけると、Spring Boot がオブジェクトをRestControllerクラスとして管理してくれます。ポイント：@RequestMapping("/users") をつけると、http://localhost:8080/users のパスを定義したことになります。<pre><code>@RestController
@RequestMapping("/users")
public class UsersController {</code></pre> ポイント：@Autowired で Service Class の依存関係を注入しています。<pre><code> @Autowired
 private UsersService usersService;</code></pre> ポイント：<code>Optional</code> 内の実際の <code>Users</code> オブジェクトを取得するために get メソッドを利用しています。<pre><code> Optional&lt;Users&gt; optionalUser = usersService.findById(id);
......
 Users user = optionalUser.get();</code></pre>

Users コントローラーの作成

<code>src/main/java/com/example/user/UsersApplication.java</code> に以下のようなクラスを実装します。<pre><code></code></pre>

Application クラスの作成

IDEで <code>UsersApplication</code> クラスを右クリックして「Run」を選択するか、ターミナルから以下のコマンドを実行します。<pre><code>./gradlew bootRun</code></pre> 実行されたら http://localhost:8080/users にアクセスします。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/c7d83e5096d14f86b0334c3ce65cad0c/image.png" alt="">レスポンスが返ってきたら成功です。

実行

CRUD 実装

Spring Boot 再入門 (3)

Gradle の設定ファイルに下記の記述を追加します。<pre><code>dependencies {
 runtimeOnly 'com.h2database:h2'
 implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
}</code></pre>

Gradle の設定

<code>src/main/resources/application.properties</code> ファイルに H2 データベースの設定を追加します。<pre><code># Datasource
spring.h2.console.enabled=true
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update</code></pre> DB_CLOSE_DELAY=-1： H2の接続が切れてもデータベースをドロップしなくなるDB_CLOSE_ON_EXIT=FALSE： VM終了時の自動データベースクローズを無効にする

アプリケーションの設定

/demo/src/main/resources/schema.sql に users テーブルのスキーマを用意する。※user は H2 データベースの予約語になっているため、 user テーブルだとエラーになります。<pre><code>CREATE SEQUENCE IF NOT EXISTS "ID_SEQ" 
MINVALUE 1 
MAXVALUE 999999999 
INCREMENT BY 1 
START WITH 2 
NOCACHE 
NOCYCLE;

CREATE TABLE IF NOT EXISTS users(
	id VARCHAR(50) DEFAULT nextval('ID_SEQ') PRIMARY KEY ,
	name VARCHAR(50),
	email VARCHAR(80)
	);</code></pre>

スキーマを用意する

/demo/src/main/resources/data.sql に初期データを用意する。<pre><code>INSERT INTO users (id, name, email) VALUES('1', 'Hara', 'hara@example.com')</code></pre>

初期データを用意する

http://8080/h2-console にアクセスすると下記画面が表示される。JDBC URL を画像のものに書き換えて connect をクリックする。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/798a3bbbff9f44c0832966ebf604ef28/image.png" alt="">すると、 users テーブルが作成されていることが確認できる。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/961793e95254404185c305338750b03a/image.png" alt="">

H2 データベースの起動を確認する

Spring BootでH2 DataBaseを利用する

Spring Boot 再入門 (2)

Spring Boot は Spring Frameworkに含まれるフレームワークの一つで、&nbsp;Spring Frameworkの機能を使いやすくするため&nbsp;のフレームワークです。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/074d9cecbae84681979a85034889d4c5/Spring%20Framework.png" alt="">

Spring Boot の基本

Spring Boot について

Eclipse を用意します。ここでは執筆時点の最新版 2024 を利用します。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/a9c8dc2f7a4649e9a7102a239e9e3fc5/image.png" alt="">

環境準備

新規 Spring スタータープロジェクトを選択します。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/e708da5affff42409ee92272dbc2b91c/image.png" alt="">次へをクリックします。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/04ac3bd3dbe040e38992ed039205a365/image.png" alt="">完了をクリックします。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/85cda75a2ef144fb9d22390a48cda9f4/image.png" alt="">以上で、環境構築は完了です。

Spring Boot プロジェクトの作成

実行の構成で Spring Boot アプリケーション をダブルクリックします。プロジェクト: demoメイン型: com.example.demo.DemoApplicationを選択します。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/52efbe2a7eb941d5aa589717fe0ecf82/image.png" alt="">実行をクリックします。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/6896dd76256640d5a8f00b45c4b28b1c/image.png" alt="">Spring Boot が立ち上がります。Hello World ! と返すため、 Demo コントローラーを追加します。<img src="https://images.microcms-assets.io/assets/b30d7661c2694503832399a83cea2137/878c7f20023541e7bb6d060d073d82d8/image.png" alt="">http://localhost:8080 にアクセスすると Hello World ! が表示されます。

BuildersIO produced by YOKU

#Java の記事一覧

Spring Boot 再入門 (4)

Spring Boot 再入門 (3)

Spring Boot 再入門 (2)

Spring Boot 再入門 (1)

Vercel Ship Day5 #1 〜【Vercel】Frontend App に認証機能を簡単に実装！〜

API設計スキルをブラッシュアップするための22のベストプラクティスの記事を読んだのでご紹介

Auth0環境を構築して自作のAPIと連携してみた