public class Device {
    private Long id;
    private String name;
    private String model;
    private String status; // 可用/借用中/維修中
    private Date purchaseDate;

    public Device(String name, String model) {
        this.name = name;
        this.model = model;
        this.status = "可用";
    }

    // Getter 和 Setter 方法
    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; }

    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }

    @Override
    public String toString() {
        return "Device{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", model='" + model + '\'' +
                ", status='" + status + '\'' +
                '}';
    }
}

public abstract class BaseDevice {
    protected String brand;
    protected double price;

    public abstract void performMaintenance();

    public String getBrand() { return brand; }
}

public class PrecisionInstrument extends BaseDevice {
    private int calibrationCycleDays;

    @Override
    public void performMaintenance() {
        System.out.println("執行高精度校準，週期：" + calibrationCycleDays + "天");
    }
}

public interface ReturnPolicy {
    void onReturn(Device device);
}

public class StandardReturnPolicy implements ReturnPolicy {
    public void onReturn(Device device) {
        device.setStatus("可用");
        System.out.println("標準歸還流程完成");
    }
}

public class InspectRequiredReturnPolicy implements ReturnPolicy {
    public void onReturn(Device device) {
        device.setStatus("待檢測");
        System.out.println("需技術檢測後方可重新啓用");
    }
}

ReturnPolicy policy = device.getType().equals("精密") ? 
    new InspectRequiredReturnPolicy() : new StandardReturnPolicy();
policy.onReturn(device);

classDiagram
    class Device {
        -Long id
        -String name
        -String model
        -String status
        +getStatus()
        +setStatus()
    }

    class User {
        -Long id
        -String username
        -String role
        +getRole()
    }

    class BorrowRecord {
        -Long id
        -Long deviceId
        -Long userId
        -Date borrowTime
        -Date returnTime
        -String status
        +calculateOverdueDays()
    }

    User "1" -- "0..*" BorrowRecord : 發起
    Device "1" -- "0..*" BorrowRecord : 被借用

public class ApprovalChain {
    private List<ApprovalHandler> handlers;

    public ApprovalChain() {
        this.handlers = new ArrayList<>();
    }

    public void addHandler(ApprovalHandler handler) {
        handlers.add(handler);
    }

    public boolean process(ApprovalContext context) {
        for (ApprovalHandler h : handlers) {
            if (!h.handle(context)) {
                return false;
            }
        }
        return true;
    }
}

classDiagram
    class ApprovalChain {
        -List~ApprovalHandler~ handlers
        +addHandler()
        +process()
    }

    class ApprovalHandler {
        <<interface>>
        +handle(context)
    }

    class TeacherApprovalHandler implements ApprovalHandler
    class AdminApprovalHandler implements ApprovalHandler

    ApprovalChain *-- ApprovalHandler : 包含
    ApprovalHandler <|-- TeacherApprovalHandler
    ApprovalHandler <|-- AdminApprovalHandler

src/
├── main/
│   ├── java/
│   │   └── com/example/labmanagement/
│   │       ├── controller/
│   │       ├── service/
│   │       ├── dao/
│   │       └── entity/
│   └── resources/
│       ├── application.yml
│       └── mapper/
└── test/
    └── java/
        └── com/example/labmanagement/

<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.microsoft.sqlserver</groupId>
        <artifactId>mssql-jdbc</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

// 持久層
@Mapper
public interface DeviceDao {
    List<Device> findAll();
    Device findById(Long id);
    int insert(Device device);
    int update(Device device);
}

// 服務層
@Service
@Transactional
public class DeviceService {
    @Autowired
    private DeviceDao deviceDao;

    public List<Device> getAllDevices() {
        return deviceDao.findAll();
    }

    public Device getDeviceById(Long id) {
        Device device = deviceDao.findById(id);
        if (device == null) {
            throw new EntityNotFoundException("設備不存在，ID：" + id);
        }
        return device;
    }

    public void saveDevice(Device device) {
        if (device.getId() == null) {
            deviceDao.insert(device);
        } else {
            deviceDao.update(device);
        }
    }
}

// 控制層
@RestController
@RequestMapping("/api/devices")
public class DeviceController {
    @Autowired
    private DeviceService deviceService;

    @GetMapping
    public ResponseEntity<List<Device>> listAll() {
        return ResponseEntity.ok(deviceService.getAllDevices());
    }

    @GetMapping("/{id}")
    public ResponseEntity<Device> getById(@PathVariable Long id) {
        return ResponseEntity.ok(deviceService.getDeviceById(id));
    }

    @PostMapping
    public ResponseEntity<String> create(@RequestBody Device device) {
        deviceService.saveDevice(device);
        return ResponseEntity.status(201).body("設備創建成功");
    }
}

{
  "code": 200,
  "message": "操作成功",
  "data": { /* 設備信息 */ }
}

public class ApiResponse<T> {
    private int code;
    private String message;
    private T data;

    public static <T> ApiResponse<T> success(T data) {
        return new ApiResponse<>(200, "操作成功", data);
    }

    // 構造函數、getter/setter...
}

@GetMapping("/{id}")
public ApiResponse<Device> getById(@PathVariable Long id) {
    Device device = deviceService.getDeviceById(id);
    return ApiResponse.success(device);
}

public class EquipmentService {
    private EquipmentDao dao = new EquipmentDao(); // 手動new，強耦合
    public List<Equipment> getAllEquipments() {
        return dao.findAll();
    }
}

classDiagram
    class EquipmentService {
        -EquipmentDao dao
        +getAllEquipments()
    }
    class EquipmentDao {
        +List~Equipment~ findAll()
    }
    EquipmentService --> "1" EquipmentDao : 依賴關係（傳統方式）
    note right of EquipmentService
      直接持有dao實例，
      創建過程緊耦合
    end note

@Component
public class EquipmentManager {

    @PostConstruct
    public void init() {
        System.out.println("EquipmentManager 初始化完成");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("EquipmentManager 正在銷燬");
    }
}

@Component
@Scope("prototype")
public class EquipmentSearchContext {
    private String keyword;
    private Date searchTime;

    // getter/setter...
}

@Configuration
@ComponentScan(basePackages = "com.lab.equipment")
public class AppConfig {
}

@Repository
public class EquipmentDaoImpl implements EquipmentDao {
    @Override
    public List<Equipment> findAll() {
        // 查詢數據庫...
        return new ArrayList<>();
    }
}

@Service
public class EquipmentServiceImpl implements EquipmentService {
    @Autowired
    private EquipmentDao equipmentDao;

    @Override
    public List<Equipment> getAll() {
        return equipmentDao.findAll();
    }
}

flowchart TD
    A[啓動類] --> B[掃描 com.lab.equipment 包]
    B --> C{發現 @Repository 註解類}
    C --> D[註冊 EquipmentDaoImpl 為 Bean]
    B --> E{發現 @Service 註解類}
    E --> F[註冊 EquipmentServiceImpl 為 Bean]
    F --> G[解析@Autowired依賴]
    G --> H[查找EquipmentDao類型Bean]
    H --> I[注入EquipmentDaoImpl實例]
    I --> J[完成EquipmentService裝配]

@Service
public class EquipmentService {
    @Autowired
    private EquipmentDao equipmentDao; // 字段直接注入
}

@Service
public class EquipmentService {
    private EquipmentDao equipmentDao;

    @Autowired
    public void setEquipmentDao(EquipmentDao equipmentDao) {
        this.equipmentDao = equipmentDao;
    }
}

@Service
public class EquipmentService {
    private final EquipmentDao equipmentDao;

    @Autowired
    public EquipmentService(EquipmentDao equipmentDao) {
        this.equipmentDao = equipmentDao;
    }
}

public EquipmentService(EquipmentDao equipmentDao) {
    Assert.notNull(equipmentDao, "EquipmentDao must not be null");
    this.equipmentDao = equipmentDao;
}

@Repository("mysqlEquipmentDao")
public class MySQLEquipmentDao implements EquipmentDao { /* ... */ }

@Repository("redisCachedEquipmentDao")
public class RedisCachedEquipmentDao implements EquipmentDao { /* ... */ }

@Service
public class EquipmentSearchService {

    @Autowired
    @Qualifier("mysqlEquipmentDao")
    private EquipmentDao primaryDao;

    @Autowired
    @Qualifier("redisCachedEquipmentDao")
    private EquipmentDao cachedDao;
}

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface PrimaryStorage {}

@PrimaryStorage
@Repository
public class MySQLEquipmentDao implements EquipmentDao { }

@Autowired
@PrimaryStorage
private EquipmentDao primaryDao;

@Configuration
public class LoggingConfig {

    @Bean
    @Conditional(DevEnvironmentCondition.class)
    public EquipmentLogger devEquipmentLogger() {
        return new DevEquipmentLogger();
    }

    @Bean
    @Conditional(ProductionEnvironmentCondition.class)
    public EquipmentLogger prodEquipmentLogger() {
        return new ProdEquipmentLogger();
    }
}

public class DevEnvironmentCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment env = context.getEnvironment();
        return "dev".equals(env.getProperty("spring.profiles.active"));
    }
}

@Bean
@ConditionalOnClass(RedisTemplate.class)
public RedisEquipmentCache redisEquipmentCache(RedisTemplate<String, Object> template) {
    return new RedisEquipmentCache(template);
}

graph LR
    A[啓動應用] --> B{檢查類路徑是否有RedisTemplate?}
    B -- 是 --> C[創建RedisEquipmentCache Bean]
    B -- 否 --> D[跳過該Bean註冊]
    C --> E[正常使用緩存功能]
    D --> F[降級使用數據庫直連]

<dependencies>
    <!-- Web應用起步依賴 -->
    <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>

    <!-- MyBatis起步依賴 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>3.0.3</version>
    </dependency>

    <!-- 緩存支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

    <!-- Redis緩存 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
</dependencies>

@SpringBootApplication
public class LabEquipmentApplication {
    public static void main(String[] args) {
        SpringApplication.run(LabEquipmentApplication.class, args);
    }
}

@Configuration
@ComponentScan
@EnableAutoConfiguration

graph TD
    A[啓動類 @SpringBootApplication] --> B{掃描 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports}
    B --> C[加載所有 Auto-configuration 類]
    C --> D[檢查 @ConditionalOnClass 條件]
    D --> E[判斷類路徑是否存在目標類]
    E --> F{條件成立?}
    F -- 是 --> G[創建對應 Bean 實例]
    F -- 否 --> H[跳過配置]
    G --> I[完成自動裝配]

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(DataSource.class)
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public DataSource dataSource(DataSourceProperties properties) {
        return properties.initializeDataSourceBuilder().build();
    }
}

@RestController
@RequestMapping("/api/equipment")
public class EquipmentController {

    @Autowired
    private EquipmentService equipmentService;

    @GetMapping
    public ResponseEntity<Page<Equipment>> getAllEquipments(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        Pageable pageable = PageRequest.of(page, size);
        Page<Equipment> result = equipmentService.findAll(pageable);
        return ResponseEntity.ok(result);
    }

    @PostMapping
    public ResponseEntity<Equipment> createEquipment(@RequestBody @Valid EquipmentDTO dto) {
        Equipment saved = equipmentService.saveFromDTO(dto);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }
}

public class EquipmentDTO {
    @NotBlank(message = "設備名稱不能為空")
    private String name;

    @Pattern(regexp = "^EQ\\d{6}$", message = "設備編號格式錯誤，應為EQ+6位數字")
    private String code;

    @Min(value = 0, message = "價格不能小於0")
    private BigDecimal price;

    // getter/setter 省略
}

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<Map<String, String>> handleValidationExceptions(
            MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(error ->
            errors.put(error.getField(), error.getDefaultMessage())
        );
        return ResponseEntity.badRequest().body(errors);
    }
}

{
  "code": 200,
  "message": "success",
  "data": { ... }
}

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.2.0</version>
</dependency>

# application.yml
springdoc:
  api-docs:
    path: /v3/api-docs
  swagger-ui:
    path: /swagger-ui.html

@Operation(summary = "分頁查詢所有設備", description = "支持按頁碼和大小檢索設備列表")
@ApiResponses({
    @ApiResponse(responseCode = "200", description = "查詢成功"),
    @ApiResponse(responseCode = "500", description = "服務器內部錯誤")
})
@GetMapping
public ResponseEntity<Page<Equipment>> getAllEquipments(...)

spring:
  redis:
    host: localhost
    port: 6379
    timeout: 5s
    lettuce:
      pool:
        max-active: 8
        max-idle: 8

@EnableCaching
@SpringBootApplication
public class LabEquipmentApplication { ... }

@Service
public class EquipmentService {

    @Cacheable(value = "equipment", key = "#id")
    public Equipment findById(Long id) {
        return equipmentRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("設備不存在"));
    }

    @CacheEvict(value = "equipment", key = "#id")
    public void updateEquipment(Long id, Equipment updated) {
        // 更新邏輯...
    }
}

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

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/equipment/**").authenticated()
            )
            .httpBasic(withDefaults()); // 啓用HTTP Basic認證
        return http.build();
    }

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails admin = User.withUsername("admin")
                .password("{noop}123456") // 生產環境應使用BCrypt加密
                .roles("ADMIN")
                .build();
        return new InMemoryUserDetailsManager(admin);
    }
}

.authorizeHttpRequests(authz -> authz
    .requestMatchers("/api/admin/**").hasRole("ADMIN")
    .requestMatchers("/api/teacher/**").hasAnyRole("TEACHER", "ADMIN")
    .requestMatchers("/api/student/borrow").hasRole("STUDENT")
    .anyRequest().authenticated()
)

// 示例：設備實體類 Device.java
public class Device {
    private Long id;
    private String name;
    private String model;
    private Integer status; // 0:空閒, 1:借用中, 2:維修中
    private Long borrowerId;
    private Date borrowTime;

    // getter/setter 略
}

<!-- DeviceMapper.xml -->
<resultMap id="DeviceWithBorrower" type="Device">
    <id property="id" column="id"/>
    <result property="name" column="name"/>
    <result property="model" column="model"/>
    <result property="status" column="status"/>
    <association property="borrowRecord" javaType="BorrowRecord">
        <id property="id" column="record_id"/>
        <result property="borrowerName" column="borrower_name"/>
        <result property="borrowTime" column="borrow_time"/>
    </association>
</resultMap>

<select id="selectDeviceWithBorrower" resultMap="DeviceWithBorrower">
    SELECT d.*, br.id AS record_id, br.borrower_name, br.borrow_time
    FROM device d
    LEFT JOIN borrow_record br ON d.id = br.device_id AND br.return_time IS NULL
    WHERE d.id = #{deviceId}
</select>

@Mapper
public interface DeviceMapper {
    List<Device> findAll();
    Device findById(Long id);
    void insert(Device device);
    void update(Device device);
    void deleteById(Long id);
    List<Device> findByConditions(Map<String, Object> params); // 動態查詢
}

<mapper namespace="com.lab.mapper.DeviceMapper">
    <insert id="insert" parameterType="Device">
        INSERT INTO device (name, model, status, borrower_id, borrow_time)
        VALUES (#{name}, #{model}, #{status}, #{borrowerId}, #{borrowTime})
    </insert>

    <update id="update" parameterType="Device">
        UPDATE device SET name=#{name}, model=#{model}, status=#{status}
        WHERE id = #{id}
    </update>
</mapper>

<select id="findByConditions" resultType="Device" parameterType="map">
    SELECT * FROM device
    <where>
        <if test="name != null and name != ''">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
        <if test="status != null">
            AND status = #{status}
        </if>
        <if test="startDate != null">
            AND borrow_time >= #{startDate}
        </if>
        <if test="endDate != null">
            AND borrow_time <= #{endDate}
        </if>
    </where>
    ORDER BY id DESC
    <if test="offset != null and limit != null">
        LIMIT #{offset}, #{limit}
    </if>
</select>

@Service
public class BorrowService {

    @Autowired
    private DeviceMapper deviceMapper;
    @Autowired
    private BorrowRecordMapper recordMapper;

    @Transactional
    public void borrowDevice(BorrowRequest request) {
        Device device = deviceMapper.findById(request.getDeviceId());
        if (device.getStatus() != 0) {
            throw new BusinessException("設備不可借用");
        }

        // 更新設備狀態
        device.setStatus(1);
        device.setBorrowerId(request.getBorrowerId());
        device.setBorrowTime(new Date());
        deviceMapper.update(device);

        // 插入借閲記錄
        BorrowRecord record = new BorrowRecord();
        record.setDeviceId(device.getId());
        record.setBorrowerId(request.getBorrowerId());
        record.setBorrowTime(new Date());
        recordMapper.insert(record);
    }
}

# application.yml
spring:
  datasource:
    url: jdbc:sqlserver://localhost:1433;databaseName=LabDB
    username: sa
    password: root
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 5
      min-idle: 5
      max-active: 20
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        login-username: admin
        login-password: admin123
      web-stat-filter:
        enabled: true

@RestController
@RequestMapping("/api/devices")
public class DeviceController {

    @Autowired
    private DeviceService deviceService;

    @GetMapping
    public ResponseEntity<PageResult<Device>> list(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size,
            @RequestParam(required = false) String name,
            @RequestParam(required = false) Integer status) {

        PageHelper.startPage(page, size);
        List<Device> devices = deviceService.findByConditions(name, status);
        PageInfo<Device> pageInfo = new PageInfo<>(devices);
        return ResponseEntity.ok(new PageResult<>(pageInfo.getTotal(), pageInfo.getList()));
    }
}

public interface DeviceState {
    void handle(DeviceContext context);
}

@Component
public class IdleState implements DeviceState {
    @Override
    public void handle(DeviceContext context) {
        // 允許借用
        context.getDevice().setStatus(1);
    }
}

@Component
public class BorrowedState implements DeviceState {
    @Override
    public void handle(DeviceContext context) {
        // 執行歸還邏輯
        context.getDevice().setStatus(0);
        context.getDevice().setBorrowerId(null);
    }
}

@Autowired
private JasperTemplateLoader templateLoader;

public byte[] generateMonthlyReport(int year, int month) throws JRException {
    List<ReportData> data = reportMapper.getMonthlyData(year, month);
    JRBeanCollectionDataSource dataSource = new JRBeanCollectionDataSource(data);

    Map<String, Object> parameters = new HashMap<>();
    parameters.put("reportTitle", "設備借用月報 - " + year + "-" + month);

    return templateLoader.fillReport("monthly_report.jrxml", parameters, dataSource);
}