Java一一一简易图书管理系统
1. 需求分析
- 功能需求：
- 添加图书
- 删除图书
- 更新图书信息
- 查询图书
- 列出所有图书
2. 设计
- 实体类：
Book - 业务逻辑类：
LibraryManager
3. 实现
3.1 Book类
public class Book {
private String id;
private String title;
private String author;
private int year;
public Book(String id, String title, String author, int year) {
this.id = id;
this.title = title;
this.author = author;
this.year = year;
}
// Getters and Setters
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
@Override
public String toString() {
return "Book{" +
"id='" + id + '\'' +
", title='" + title + '\'' +
", author='" + author + '\'' +
", year=" + year +
'}';
}
}
3.2 LibraryManager类
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class LibraryManager {
private List<Book> books;
public LibraryManager() {
this.books = new ArrayList<>();
}
public void addBook(Book book) {
books.add(book);
}
public boolean removeBook(String id) {
return books.removeIf(book -> book.getId().equals(id));
}
public void updateBook(String id, Book updatedBook) {
Book book = books.stream()
.filter(b -> b.getId().equals(id))
.findFirst()
.orElse(null);
if (book != null) {
book.setTitle(updatedBook.getTitle());
book.setAuthor(updatedBook.getAuthor());
book.setYear(updatedBook.getYear());
}
}
public List<Book> searchBooksByTitle(String title) {
return books.stream()
.filter(book -> book.getTitle().contains(title))
.collect(Collectors.toList());
}
public List<Book> getAllBooks() {
return new ArrayList<>(books);
}
}
4. 测试
public class Main {
public static void main(String[] args) {
LibraryManager manager = new LibraryManager();
// 添加图书
manager.addBook(new Book("1", "Java Basics", "John Doe", 2021));
manager.addBook(new Book("2", "Advanced Java", "Jane Doe", 2022));
// 列出所有图书
System.out.println("All Books:");
manager.getAllBooks().forEach(System.out::println);
// 更新图书
Book updatedBook = new Book("1", "Java Fundamentals", "John Doe", 2021);
manager.updateBook("1", updatedBook);
// 搜索图书
System.out.println("Search Results:");
manager.searchBooksByTitle("Java").forEach(System.out::println);
// 删除图书
manager.removeBook("2");
// 再次列出所有图书
System.out.println("All Books after removal:");
manager.getAllBooks().forEach(System.out::println);
}
}
5. 总结
这个简易的图书管理系统展示了Java在面向对象编程中的基本应用，包括类的定义、方法的实现以及简单的集合操作。通过这个案例，初学者可以学习到如何使用Java创建和管理对象集合，以及如何实现简单的业务逻辑。
请注意，这只是一个基础示例，实际应用中可能需要考虑更多的功能和异常处理，以及与数据库的交互等。
案例名称：基于Spring Boot的RESTful图书管理系统
1. 环境准备
- Java 11 或更高版本
- Spring Boot 2.5.x 或更高版本
- Maven 或 Gradle 作为构建工具
- 一个文本编辑器或IDE（如IntelliJ IDEA或Eclipse）
2. 项目结构
src/
|-- main/
| |-- java/
| | `-- com.example.bookstore/
| | |-- BookController.java
| | |-- BookService.java
| | `-- Book.java
| `-- resources/
| `-- application.properties
3. 实现步骤
3.1 创建Spring Boot项目
使用Spring Initializr来生成项目基础结构。
3.2 添加依赖
在pom.xml（Maven）或build.gradle（Gradle）中添加Web和JPA依赖。
pom.xml 示例:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<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>
</dependencies>
3.3 Book实体类
package com.example.bookstore;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String title;
private String author;
private int publishYear;
// Constructors, getters and setters
}
3.4 BookRepository接口
package com.example.bookstore;
import org.springframework.data.jpa.repository.JpaRepository;
public interface BookRepository extends JpaRepository<Book, Long> {
}
3.5 BookService业务逻辑类
package com.example.bookstore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
@Service
public class BookService {
@Autowired
private BookRepository bookRepository;
public List<Book> getAllBooks() {
return bookRepository.findAll();
}
public Book getBookById(Long id) {
return bookRepository.findById(id).orElse(null);
}
public Book addBook(Book book) {
return bookRepository.save(book);
}
public Book updateBook(Long id, Book updatedBook) {
Optional<Book> bookOptional = bookRepository.findById(id);
if (bookOptional.isPresent()) {
Book book = bookOptional.get();
book.setTitle(updatedBook.getTitle());
book.setAuthor(updatedBook.getAuthor());
book.setPublishYear(updatedBook.getPublishYear());
return bookRepository.save(book);
}
return null;
}
public void deleteBook(Long id) {
bookRepository.deleteById(id);
}
}
3.6 BookController控制器
package com.example.bookstore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/books")
public class BookController {
@Autowired
private BookService bookService;
@GetMapping
public List<Book> getAllBooks() {
return bookService.getAllBooks();
}
@GetMapping("/{id}")
public ResponseEntity<Book> getBookById(@PathVariable Long id) {
Book book = bookService.getBookById(id);
return book != null ? ResponseEntity.ok(book) : ResponseEntity.notFound().build();
}
@PostMapping
public Book addBook(@RequestBody Book book) {
return bookService.addBook(book);
}
@PutMapping("/{id}")
public ResponseEntity<Book> updateBook(@PathVariable Long id, @RequestBody Book updatedBook) {
Book book = bookService.updateBook(id, updatedBook);
return book != null ? ResponseEntity.ok(book) : ResponseEntity.notFound().build();
}
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
bookService.deleteBook(id);
return ResponseEntity.ok().build();
}
}
3.7 配置文件application.properties
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
spring.h2.console.enabled=true
4. 运行和测试
使用您喜欢的IDE运行main方法或使用Maven/Gradle命令来启动Spring Boot应用。使用Postman或curl命令行工具来测试API。
5. 总结
这个案例展示了如何使用Spring Boot创建一个简单的RESTful API，它提供了基本的CRUD操作。通过这个案例，您可以学习到Spring Boot的核心概念，如依赖注入、服务层、数据访问层以及RESTful API设计。
这个示例使用了内存数据库H2，适合开发和测试，但在生产环境中，您应该使用更健壮的数据库解决方案，并考虑安全性、异常处理和日志记录等因素。
接下来，我们将在图书管理系统中增加一个新功能：用户认证和授权。我们将使用Spring Security来实现这一功能，确保只有认证用户可以访问敏感数据和执行特定操作。
带有用户认证和授权的图书管理系统
1. 添加Spring Security依赖
首先，需要在项目的pom.xml（Maven）或build.gradle（Gradle）文件中添加Spring Security的依赖。
pom.xml 示例:
<dependencies>
<!-- ... other dependencies ... -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
</dependencies>
2. 配置Spring Security
创建一个配置类来配置Spring Security。
package com.example.bookstore;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public UserDetailsService userDetailsService(PasswordEncoder encoder) {
InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
manager.createUser(
User.withUsername("user")
.password(encoder.encode("password"))
.roles("USER")
.build()
);
return manager;
}
@Bean
public HttpSecurity httpSecurity(UserDetailsService userDetailsService) throws Exception {
return new HttpSecurity(http -> http
.authorizeRequests()
.antMatchers("/api/books/**").authenticated()
.and()
.httpBasic()
.and()
.csrf().disable()
);
}
}
3. 保护RESTful API
使用@PreAuthorize注解来保护特定的API端点。
package com.example.bookstore;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/books")
public class BookController {
// ... existing code ...
@PreAuthorize("hasRole('USER')")
@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteBook(@PathVariable Long id) {
bookService.deleteBook(id);
return ResponseEntity.ok().build();
}
}
4. 增加用户注册功能
创建一个用户注册的API端点。
// ... existing imports ...
@RestController
@RequestMapping("/api/auth")
public class AuthController {
private final UserService userService;
public AuthController(UserService userService) {
this.userService = userService;
}
@PostMapping("/register")
public ResponseEntity<?> registerUser(@RequestBody UserRegistrationDto userRegistrationDto) {
userService.registerUser(userRegistrationDto);
return ResponseEntity.ok().build();
}
}
5. 用户注册服务和数据传输对象
创建UserService和UserRegistrationDto来处理用户注册。
package com.example.bookstore;
// UserService.java
@Service
public class UserService {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder;
@Autowired
public UserService(UserRepository userRepository, PasswordEncoder passwordEncoder) {
this.userRepository = userRepository;
this.passwordEncoder = passwordEncoder;
}
public void registerUser(UserRegistrationDto userRegistrationDto) {
User newUser = new User(
userRegistrationDto.getUsername(),
passwordEncoder.encode(userRegistrationDto.getPassword())
);
userRepository.save(newUser);
}
}
// UserRegistrationDto.java
public class UserRegistrationDto {
private String username;
private String password;
// Constructors, getters and setters
}
6. 更新数据库配置
在application.properties或application.yml中添加用户表的配置。
# application.properties
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=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update
# H2 console settings
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
7. 测试和验证
启动应用程序，并使用Postman或curl测试用户注册和认证保护的API。
8. 总结
通过增加用户认证和授权，我们的图书管理系统变得更加安全。Spring Security提供了一套强大的安全工具，可以轻松地集成到Spring Boot应用程序中。通过使用@EnableWebSecurity注解和配置HttpSecurity，我们可以控制对API端点的访问。此外，@PreAuthorize注解允许我们在方法级别细粒度地控制访问权限。
请注意，本案例中的用户存储在内存中，仅用于演示目的。在实际应用中，您应该使用数据库来持久化用户信息，并考虑使用JWT或OAuth2等更先进的认证机制。
接下来，我们将在图书管理系统中增加一个新功能：基于角色的访问控制（RBAC）。这将允许我们根据用户的角色限制对某些资源的访问。
基于角色的访问控制的图书管理系统
1. 扩展用户模型
首先，我们需要扩展用户模型来包含角色信息。
package com.example.bookstore;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import javax.persistence.*;
import java.util.Collection;
import java.util.stream.Collectors;
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String password;
@ManyToMany(fetch = FetchType.EAGER)
private Set<Role> roles;
// Constructors, getters and setters
public Collection<? extends GrantedAuthority> getAuthorities() {
return roles.stream()
.map(role -> new SimpleGrantedAuthority(role.getName()))
.collect(Collectors.toList());
}
}
2. 角色模型
创建一个角色模型来定义不同的角色。
package com.example.bookstore;
@Entity
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
// Constructors, getters and setters
}
3. 用户角色关联
创建一个关联表来定义用户和角色之间的关系。
package com.example.bookstore;
import javax.persistence.*;
@Entity
@Table(name = "user_role")
public class UserRole {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@ManyToOne
@JoinColumn(name = "user_id")
private User user;
@ManyToOne
@JoinColumn(name = "role_id")
private Role role;
// Constructors, getters and setters
}
4. 更新UserRepository
添加方法来查找用户及其角色。
package com.example.bookstore;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
User findByUsername(String username);
}
5. 更新Spring Security配置
更新SecurityConfig来使用自定义的UserDetailsService。
package com.example.bookstore;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.provisioning.UserDetailsManager;
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired
private UserRepository userRepository;
@Bean
@Override
public UserDetailsService userDetailsService() {
return new UserDetailsManager() {
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
User user = userRepository.findByUsername(username);
if (user == null) {
throw new UsernameNotFoundException("User not found");
}
return user;
}
// Other methods are omitted for brevity
};
}
// Other configurations are omitted for brevity
}
6. 基于角色的访问控制
使用@PreAuthorize或@Secured注解来限制访问。
package com.example.bookstore;
import org.springframework.security.access.prepost.PreAuthorize;
@RestController
@RequestMapping("/api/books")
public class BookController {
// ... existing code ...
@PreAuthorize("hasRole('ADMIN')")
@PostMapping
public Book addBook(@RequestBody Book book) {
return bookService.addBook(book);
}
@PreAuthorize("hasRole('USER')")
@GetMapping
public List<Book> getAllBooks() {
return bookService.getAllBooks();
}
}
7. 用户角色管理
创建API端点来管理用户角色。
package com.example.bookstore;
@RestController
@RequestMapping("/api/users")
public class UserController {
private final UserService userService;
@Autowired
public UserController(UserService userService) {
this.userService = userService;
}
@PostMapping("/{username}/roles")
public ResponseEntity<?> addRoleToUser(@PathVariable String username, @RequestBody RoleRequestDto roleRequestDto) {
userService.addRoleToUser(username, roleRequestDto.getRoleName());
return ResponseEntity.ok().build();
}
}
// RoleRequestDto.java
public class RoleRequestDto {
private String roleName;
// Constructors, getters and setters
}
8. 测试和验证
启动应用程序，并使用Postman或curl测试基于角色的访问控制。
9. 总结
通过实现基于角色的访问控制，我们的图书管理系统可以更细致地控制用户对资源的访问。这在多用户应用中尤为重要，可以确保用户只能访问他们被授权的资源。
这个案例演示了如何在Spring Security中使用自定义的UserDetailsService来加载用户及其角色信息，以及如何使用@PreAuthorize注解来实现基于角色的访问控制。在实际应用中，您可能还需要实现更复杂的用户和角色管理功能，以及更细粒度的权限控制策略。