package refactoring_guru.proxy.example.some_cool_media_library;

import java.util.HashMap;

public interface ThirdPartyYouTubeLib {
    HashMap<String, Video> popularVideos();

    Video getVideo(String videoId);
}

package refactoring_guru.proxy.example.some_cool_media_library;

import java.util.HashMap;

public class ThirdPartyYouTubeClass implements ThirdPartyYouTubeLib {

    @Override
    public HashMap<String, Video> popularVideos() {
        connectToServer("http://www.youtube.com");
        return getRandomVideos();
    }

    @Override
    public Video getVideo(String videoId) {
        connectToServer("http://www.youtube.com/" + videoId);
        return getSomeVideo(videoId);
    }

    // -----------------------------------------------------------------------
    // Fake methods to simulate network activity. They as slow as a real life.

    private int random(int min, int max) {
        return min + (int) (Math.random() * ((max - min) + 1));
    }

    private void experienceNetworkLatency() {
        int randomLatency = random(5, 10);
        for (int i = 0; i < randomLatency; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

    private void connectToServer(String server) {
        System.out.print("Connecting to " + server + "... ");
        experienceNetworkLatency();
        System.out.print("Connected!" + "\n");
    }

    private HashMap<String, Video> getRandomVideos() {
        System.out.print("Downloading populars... ");

        experienceNetworkLatency();
        HashMap<String, Video> hmap = new HashMap<String, Video>();
        hmap.put("catzzzzzzzzz", new Video("sadgahasgdas", "Catzzzz.avi"));
        hmap.put("mkafksangasj", new Video("mkafksangasj", "Dog play with ball.mp4"));
        hmap.put("dancesvideoo", new Video("asdfas3ffasd", "Dancing video.mpq"));
        hmap.put("dlsdk5jfslaf", new Video("dlsdk5jfslaf", "Barcelona vs RealM.mov"));
        hmap.put("3sdfgsd1j333", new Video("3sdfgsd1j333", "Programing lesson#1.avi"));

        System.out.print("Done!" + "\n");
        return hmap;
    }

    private Video getSomeVideo(String videoId) {
        System.out.print("Downloading video... ");

        experienceNetworkLatency();
        Video video = new Video(videoId, "Some video title");

        System.out.print("Done!" + "\n");
        return video;
    }

}

package refactoring_guru.proxy.example.some_cool_media_library;

public class Video {
    public String id;
    public String title;
    public String data;

    Video(String id, String title) {
        this.id = id;
        this.title = title;
        this.data = "Random video.";
    }
}

package refactoring_guru.proxy.example.proxy;

import refactoring_guru.proxy.example.some_cool_media_library.ThirdPartyYouTubeClass;
import refactoring_guru.proxy.example.some_cool_media_library.ThirdPartyYouTubeLib;
import refactoring_guru.proxy.example.some_cool_media_library.Video;

import java.util.HashMap;

public class YouTubeCacheProxy implements ThirdPartyYouTubeLib {
    private ThirdPartyYouTubeLib youtubeService;
    private HashMap<String, Video> cachePopular = new HashMap<String, Video>();
    private HashMap<String, Video> cacheAll = new HashMap<String, Video>();

    public YouTubeCacheProxy() {
        this.youtubeService = new ThirdPartyYouTubeClass();
    }

    @Override
    public HashMap<String, Video> popularVideos() {
        if (cachePopular.isEmpty()) {
            cachePopular = youtubeService.popularVideos();
        } else {
            System.out.println("Retrieved list from cache.");
        }
        return cachePopular;
    }

    @Override
    public Video getVideo(String videoId) {
        Video video = cacheAll.get(videoId);
        if (video == null) {
            video = youtubeService.getVideo(videoId);
            cacheAll.put(videoId, video);
        } else {
            System.out.println("Retrieved video '" + videoId + "' from cache.");
        }
        return video;
    }

    public void reset() {
        cachePopular.clear();
        cacheAll.clear();
    }
}

package refactoring_guru.proxy.example.downloader;

import refactoring_guru.proxy.example.some_cool_media_library.ThirdPartyYouTubeLib;
import refactoring_guru.proxy.example.some_cool_media_library.Video;

import java.util.HashMap;

public class YouTubeDownloader {
    private ThirdPartyYouTubeLib api;

    public YouTubeDownloader(ThirdPartyYouTubeLib api) {
        this.api = api;
    }

    public void renderVideoPage(String videoId) {
        Video video = api.getVideo(videoId);
        System.out.println("\n-------------------------------");
        System.out.println("Video page (imagine fancy HTML)");
        System.out.println("ID: " + video.id);
        System.out.println("Title: " + video.title);
        System.out.println("Video: " + video.data);
        System.out.println("-------------------------------\n");
    }

    public void renderPopularVideos() {
        HashMap<String, Video> list = api.popularVideos();
        System.out.println("\n-------------------------------");
        System.out.println("Most popular videos on YouTube (imagine fancy HTML)");
        for (Video video : list.values()) {
            System.out.println("ID: " + video.id + " / Title: " + video.title);
        }
        System.out.println("-------------------------------\n");
    }
}

package refactoring_guru.proxy.example;

import refactoring_guru.proxy.example.downloader.YouTubeDownloader;
import refactoring_guru.proxy.example.proxy.YouTubeCacheProxy;
import refactoring_guru.proxy.example.some_cool_media_library.ThirdPartyYouTubeClass;

public class Demo {

    public static void main(String[] args) {
        YouTubeDownloader naiveDownloader = new YouTubeDownloader(new ThirdPartyYouTubeClass());
        YouTubeDownloader smartDownloader = new YouTubeDownloader(new YouTubeCacheProxy());

        long naive = test(naiveDownloader);
        long smart = test(smartDownloader);
        System.out.print("Time saved by caching proxy: " + (naive - smart) + "ms");

    }

    private static long test(YouTubeDownloader downloader) {
        long startTime = System.currentTimeMillis();

        // User behavior in our app:
        downloader.renderPopularVideos();
        downloader.renderVideoPage("catzzzzzzzzz");
        downloader.renderPopularVideos();
        downloader.renderVideoPage("dancesvideoo");
        // Users might visit the same page quite often.
        downloader.renderVideoPage("catzzzzzzzzz");
        downloader.renderVideoPage("someothervid");

        long estimatedTime = System.currentTimeMillis() - startTime;
        System.out.print("Time elapsed: " + estimatedTime + "ms\n");
        return estimatedTime;
    }
}

@RestController
@RequestMapping("/user")
public class UserController {

    @PostMapping("add")
    public ResponseEntity<String> add(User user) {
        if(user.getName()==null) {
            return ResponseResult.fail("user name should not be empty");
        } else if(user.getName().length()<5 || user.getName().length()>50){
            return ResponseResult.fail("user name length should between 5-50");
        }
        if(user.getAge()< 1 || user.getAge()> 150) {
            return ResponseResult.fail("invalid age");
        }
        // ...
        return ResponseEntity.ok("success");
    }
}

package com.example.springbootvalidation.entity;


import com.example.springbootvalidation.group.AddUserGroup;
import com.example.springbootvalidation.group.EditUserGroup;
import jakarta.validation.constraints.*;
import lombok.Builder;
import lombok.Data;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.Range;

@Data
@Builder
public class User {
    private static final long serialVersionUID = 1L;

    @NotEmpty(message = "could not be empty"controller中的接口使用校验时使用分组)
    private String userId;

    @NotEmpty(message = "could not be empty")
    @Email(message = "invalid email")
    private String email;

    @NotEmpty(message = "could not be empty")
    @Pattern(regexp = "^(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9]|X)$", message = "invalid ID")
    private String cardNo;

    @NotEmpty(message = "could not be empty")
    @Length(min = 1, max = 10, message = "nick name should be 1-10")
    private String nickName;

    @NotNull(message = "could not be empty")
    @Range(min = 0, max = 1, message = "sex should be 0-1")
    private int sex;

    @Max(value = 100, message = "Please input valid age")
    private int age;
}

package com.example.springbootvalidation.controller;

import com.example.springbootvalidation.entity.ResponseResult;
import com.example.springbootvalidation.entity.User;
import com.example.springbootvalidation.group.AddUserGroup;
import com.example.springbootvalidation.group.EditUserGroup;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.validation.ObjectError;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@Slf4j
@RestController
public class UserController {
    @PostMapping("/addUser")
    public ResponseResult<String> add(@Validated @RequestBody User user, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            List<ObjectError> errors = bindingResult.getAllErrors();
            errors.forEach(p -> {
                FieldError fieldError = (FieldError) p;
                log.error("Invalid Parameter : object - {},field - {},errorMessage - {}", fieldError.getObjectName(), fieldError.getField(), fieldError.getDefaultMessage());
            });
            return ResponseResult.fail("invalid parameter");
        }
        return ResponseResult.success();
    }
   

2024-05-07T21:51:28.371+08:00 ERROR 34844 --- [spring-boot-validation] [nio-8080-exec-2] c.e.s.controller.UserController          : Invalid Parameter : object - user,field - cardNo,errorMessage - could not be empty
2024-05-07T21:51:28.371+08:00 ERROR 34844 --- [spring-boot-validation] [nio-8080-exec-2] c.e.s.controller.UserController          : Invalid Parameter : object - user,field - userId,errorMessage - could not be empty
2024-05-07T21:51:28.371+08:00 ERROR 34844 --- [spring-boot-validation] [nio-8080-exec-2] c.e.s.controller.UserController          : Invalid Parameter : object - user,field - nickName,errorMessage - could not be empty
2024-05-07T21:51:28.371+08:00 ERROR 34844 --- [spring-boot-validation] [nio-8080-exec-2] c.e.s.controller.UserController          : Invalid Parameter : object - user,field - email,errorMessage - invalid email

public interface EditUserGroup {
}
public interface AddUserGroup {
}

public class User implements Serializable {
    private static final long serialVersionUID = 1L;

    @NotEmpty(message = "could not be empty",groups = {EditUserGroup.class})
    private String userId;

    @NotEmpty(message = "could not be empty")
    @Email(message = "invalid email")
    private String email;

    @NotEmpty(message = "could not be empty")
    @Pattern(regexp = "^(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9]|X)$", message = "invalid ID")
    private String cardNo;

    @NotEmpty(message = "could not be empty")
    @Length(min = 1, max = 10, message = "nick name should be 1-10")
    private String nickName;

    @NotNull(message = "could not be empty")
    @Range(min = 0, max = 1, message = "sex should be 0-1")
    private int sex;

    @Max(value = 100, message = "Please input valid age")
    private int age;
}

@PostMapping("/editUser")
    public ResponseResult<String> edit(@Validated({EditUserGroup.class}) @RequestBody User user, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            List<ObjectError> errors = bindingResult.getAllErrors();
            errors.forEach(p -> {
                FieldError fieldError = (FieldError) p;
                log.error("Invalid Parameter : object - {},field - {},errorMessage - {}", fieldError.getObjectName(), fieldError.getField(), fieldError.getDefaultMessage());
            });
            return ResponseResult.fail("invalid parameter");
        }
        return ResponseResult.success();
    }

2024-05-07T22:05:32.148+08:00 ERROR 35269 --- [spring-boot-validation] [nio-8080-exec-2] c.e.s.controller.UserController          : Invalid Parameter : object - user,field - userId,errorMessage - could not be empty

package com.example.springbootvalidation.annotation;

import jakarta.validation.Constraint;
import jakarta.validation.Payload;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = {TelephoneNumberValidator.class}) // 指定校验器
public @interface TelephoneNumber {
    String message() default "Invalid telephone number";
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default { };
}

package com.example.springbootvalidation.annotation;

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

import java.util.regex.Pattern;

public class TelephoneNumberValidator implements ConstraintValidator<TelephoneNumber, String> {
    private static final String REGEX_TEL = "0\\d{2,3}[-]?\\d{7,8}|0\\d{2,3}\\s?\\d{7,8}|13[0-9]\\d{8}|15[1089]\\d{8}";

    @Override
    public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
        try {
            return Pattern.matches(REGEX_TEL,s);
        } catch (Exception e) {
            return false;
        }
    }
}

   @TelephoneNumber(message = "invalid telephone number") // 这里
    private String telephone;
}

package com.boot.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.boot.entity.Perm;
import com.boot.entity.User;
import com.boot.mapper.PermMapper;
import com.boot.mapper.UserMapper;
import com.boot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

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

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    @Autowired
    UserMapper userMapper;

    @Autowired
    PermMapper permMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("username",username);
        User user = userMapper.selectOne(queryWrapper);

        if(user == null){
            throw new UsernameNotFoundException("用户未找到");
        }

        //根据用户名查找权限
        QueryWrapper<Perm> permQueryWrapper = new QueryWrapper();
        permQueryWrapper.eq("user_id",user.getId());

        List<Perm> perms = permMapper.selectList(permQueryWrapper);

        //权限标识
        List<String> permTags = perms.stream().map(Perm::getTag).collect(Collectors.toList());

        user.setAuthorities(AuthorityUtils.createAuthorityList(permTags));

        return user;
    }
}

package com.boot.security;

import com.boot.entity.User;

import jakarta.servlet.http.HttpServletRequest;

import jakarta.servlet.http.HttpServletResponse;

import lombok.SneakyThrows;

import org.springframework.security.authentication.AuthenticationServiceException;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.AuthenticationException;

import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

import java.io.BufferedReader;

import java.io.IOException;

public class LoginFilter extends UsernamePasswordAuthenticationFilter {

 @SneakyThrows

 @Override

public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {

if (!request.getMethod().equals("POST")) {

throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());

}

String username = request.getParameter("username");

String password = request.getParameter("password");

UsernamePasswordAuthenticationToken authRequest = UsernamePasswordAuthenticationToken.unauthenticated(username,password);

return this.getAuthenticationManager().authenticate(authRequest);

}

}

package com.boot.security;

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.authentication.AuthenticationFailureHandler;

import java.io.IOException;

public class LoginFailureHandler implements AuthenticationFailureHandler {

 @Override

public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {

System.out.println("登录异常信息:");

System.out.println("exception = " + exception);

}

}

SELECT * FROM TABLE_XX WHERE COLUMN_XX = "XX";

SELECT * FROM zz_user WHERE name = "子竹";

SELECT * FROM tb WHERE Y = "..." AND Z = "...";

SELECT * FROM tb WHERE X = "..." AND Y > "..." AND Z = "...";

{
****["熊猫","女","6666"]*:*1,
****["竹子","男","1234"]*:*2,
****["子竹","男","4321"]*:*3,
****["1111","男","4321"]*:*4,
****["竹竹","女","8888"]*:*5
}

Thread t=new DaemonT(); 
t.setDaemon(true); 
t.start();

package test;

public class Test
{
    public static class DaemonThread extends Thread
    {
        @Override
        public void run()
        {
            for (int i = 0; i < 10000000; i++)
            {
                System.out.println("hi");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        DaemonThread dt = new DaemonThread();
        dt.start();
    }
}

dt.setDaemon(true);

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

package test;

public class Test
{
    public static class High extends Thread
    {
        static int count = 0;
        @Override
        public void run()
        {
            while (true)
            {
                synchronized (Test.class)
                {
                    count++;
                    if (count > 10000000)
                    {
                        System.out.println("High");
                        break;
                    }
                }
            }
        }
    }
    public static class Low extends Thread
    {
        static int count = 0;
        @Override
        public void run()
        {
            while (true)
            {
                synchronized (Test.class)
                {
                    count++;
                    if (count > 10000000)
                    {
                        System.out.println("Low");
                        break;
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException
    {
        High high = new High();
        Low low = new Low();
        high.setPriority(Thread.MAX_PRIORITY);
        low.setPriority(Thread.MIN_PRIORITY);
        low.start();
        high.start();
    }
}

public interface Subject {
    void registerObserver(Observer o); // 注册：你过来听我广播
    void removeObserver(Observer o);   // 移除：你不想听了就走
    void notifyObservers();            // 通知：我广播啦，大家听着！
}

public interface Observer {
    // update：气象站通知我了，把最新数据告诉我，我来更新
    void update(float temperature, float humidity, float pressure);
}

import java.util.ArrayList;
import java.util.List;

public class WeatherData implements Subject {
    private List<Observer> observers; // 听众名单
    private float temperature;        // 温度
    private float humidity;           // 湿度
    private float pressure;           // 气压

    public WeatherData() {
        observers = new ArrayList<>(); // 初始化听众名单
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o); // 听众来了，加入名单
        System.out.println("  [气象站] " + o.getClass().getSimpleName() + " 注册成功。");
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o); // 听众走了，从名单移除
        System.out.println("  [气象站] " + o.getClass().getSimpleName() + " 已取消注册。");
    }

    @Override
    public void notifyObservers() {
        System.out.println("\n[气象站] 数据变化！开始通知所有听众...");
        for (Observer observer : observers) {
            // 遍历名单，挨个通知每个听众最新的数据
            observer.update(temperature, humidity, pressure);
        }
    }

    // 气象数据发生变化了！
    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        // 数据一变，马上通知所有听众
        measurementsChanged();
    }

    private void measurementsChanged() {
        notifyObservers(); // 内部方法，直接调用通知
    }
}

public class CurrentConditionsDisplay implements Observer {
    private float temperature;
    private float humidity;

    public CurrentConditionsDisplay(Subject weatherData) {
        weatherData.registerObserver(this); // 创建时就向气象站注册自己
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display(); // 收到数据了，赶紧显示出来
    }

    public void display() {
        System.out.println("  [当前天气] 温度: " + temperature + "F, 湿度: " + humidity + "%");
    }
}

public class StatisticsDisplay implements Observer {
    private float maxTemp = 0.0f;
    private float minTemp = 200f;
    private float tempSum = 0.0f;
    private int numReadings;

    public StatisticsDisplay(Subject weatherData) {
        weatherData.registerObserver(this); // 创建时向气象站注册自己
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        // 收到数据了，计算统计信息
        tempSum += temperature;
        numReadings++;
        if (temperature > maxTemp) maxTemp = temperature;
        if (temperature < minTemp) minTemp = temperature;
        display(); // 显示统计结果
    }

    public void display() {
        System.out.println("  [统计信息] 平均: " + (tempSum / numReadings)
            + "F, 最高: " + maxTemp + "F, 最低: " + minTemp + "F");
    }
}

public class WeatherStation {
    public static void main(String[] args) {
        // 1. 建立气象站
        WeatherData weatherData = new WeatherData();

        // 2. 准备两个显示屏，并让它们“订阅”气象站
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);

        // 3. 气象站发布第一次数据
        System.out.println("\n--- 第一次气象数据发布 ---");
        weatherData.setMeasurements(80, 65, 30.4f);

        // 4. 气象站发布第二次数据
        System.out.println("\n--- 第二次气象数据发布 ---");
        weatherData.setMeasurements(82, 70, 29.2f);

        // 5. 统计显示屏不干了，取消订阅
        System.out.println("\n--- 统计显示屏取消订阅 ---");
        weatherData.removeObserver(statisticsDisplay);

        // 6. 气象站发布第三次数据，这时统计显示屏就不会收到通知了
        System.out.println("\n--- 第三次气象数据发布 ---");
        weatherData.setMeasurements(78, 90, 29.0f);
    }
}

public @interface ExcelColumn {
    String name();
}

package org.pt;

import org.apache.poi.ss.usermodel.*;

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Field;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class ExcelReader<T> {
    private final Class<T> type;

    public ExcelReader(Class<T> type) {
        this.type = type;
    }

    public List<T> readExcel(String filePath) {
        List<T> dataList = new ArrayList<>();
        try {
            FileInputStream file = new FileInputStream(new File(filePath));
            // Create Workbook instance holding reference to .xlsx file
            Workbook workbook = WorkbookFactory.create(file);
            // Get the first sheet
            Sheet sheet = workbook.getSheetAt(0);
            // Get the header row
            Row headerRow = sheet.getRow(0);
            // 根据第一行列数来初始化header数组
            String[] headers = new String[headerRow.getLastCellNum()];
            for (int i = 0; i < headerRow.getLastCellNum(); i++) {
                // 将第一行对应列的标识符存到对应数组下标
                headers[i] = headerRow.getCell(i).getStringCellValue();
            }
            // Iterate through each row
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                Row row = sheet.getRow(i);
                // 如果这行为空直接跳过
                if (row == null) continue;
                //通过反射创建了type表示的类的一个新实例，并且假定这个类有一个无参数的构造函数
                T obj = type.getDeclaredConstructor().newInstance();
                // Iterate through each cell
                for (int j = 0; j < row.getLastCellNum(); j++) {
                    // 开始遍历每一行每一列
                    Cell cell = row.getCell(j);
                    // 获取对应列的标识符号
                    String header = headers[j];
                    Object value = getCellValue(cell);
                    // Find corresponding field using reflection
                    Field field = getFieldByName(header);
                    if (field != null) {
                        field.setAccessible(true);
                        field.set(obj, convertValueToType(value, type.getTypeName().getClass()));
                    }
                }

                dataList.add(obj);
            }
            workbook.close();
            file.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return dataList;
    }

    private Field getFieldByName(String name) {
        for (Field field : type.getDeclaredFields()) {
            ExcelColumn annotation = field.getAnnotation(ExcelColumn.class);
            if (annotation != null && annotation.name().equals(name)) {
                return field;
            }
        }
        return null;
    }

    private Object convertValueToType(Object value, Class<?> type) {
        if (value == null) {
            return null;
        }

        if (type == String.class) {
            return value.toString();
        } else if (type == int.class || type == Integer.class) {
            if (value instanceof String) {
                return Integer.parseInt((String) value);
            } else if (value instanceof Number) {
                return ((Number) value).intValue();
            }
        } else if (type == double.class || type == Double.class) {
            if (value instanceof String) {
                return Double.parseDouble((String) value);
            } else if (value instanceof Number) {
                return ((Number) value).doubleValue();
            }
        } else if (type == boolean.class || type == Boolean.class) {
            if (value instanceof String) {
                return Boolean.parseBoolean((String) value);
            } else if (value instanceof Boolean) {
                return value;
            }
        } else if (type == Date.class) {
            if (value instanceof Date) {
                return value;
            } else if (value instanceof String) {
                // 根据需要进行日期格式转换
                // 此处假设日期字符串为标准格式
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                try {
                    return dateFormat.parse((String) value);
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
        }

        // 如果没有匹配的类型，则返回原始值
        return value;
    }


    private Object getCellValue(Cell cell) {
        // 初始化一个空值
        if (cell == null) {
            return null;
        }

        // 根据单元格类型进行不同的处理
        switch (cell.getCellType()) {
            case STRING:
                // 如果是字符串类型，直接返回字符串值
                return cell.getStringCellValue();
            case NUMERIC:
                // 如果是数字类型，判断是否是日期格式
                if (DateUtil.isCellDateFormatted(cell)) {
                    // 如果是日期格式，返回日期对象
                    return cell.getDateCellValue();
                } else {
                    // 否则返回数字值
                    return cell.getNumericCellValue();
                }
            case BOOLEAN:
                // 如果是布尔类型，返回布尔值
                return cell.getBooleanCellValue();
            case FORMULA:
                // 如果是公式类型，返回公式字符串
                return cell.getCellFormula();
            default:
                // 其他类型返回空值
                return null;
        }
    }


    public static void main(String[] args) {
        ExcelReader<Employee> excelReader = new ExcelReader<>(Employee.class);
        List<Employee> dataList = excelReader.readExcel("your_excel_file.xlsx");

        // Print the data
        for (Employee employee : dataList) {
            System.out.println(employee);
        }
    }

}