/*椭圆曲线非对称加密算法*/
public class SM2Util {

    public static final String key_pubk= "pub";
    public static final String key_prik= "pri";

    private static SM2 sm2 = SM2.instance();

	private static final String DEFAULT_PRIVATE_KEY = "27cd96b1500f8330fc523e7c47ef02a";
	private static final String DEFAULT_PUBLIC_KEY = "047ec86bb18f57714e6c5c72383c5b122";

	/**
	 * 生成公私钥
	 * @return
	 */
    public static Map<String,String> generateKeyPair() {
        Map<String,String> result = new HashMap<>();
        AsymmetricCipherKeyPair key = sm2.eccKeyPairGenerator.generateKeyPair();

        BigInteger privateKey = ((ECPrivateKeyParameters)key.getPrivate()).getD();
        ECPoint publicKey = ((ECPublicKeyParameters)key.getPublic()).getQ();

        String pubk = new String(Hex.encode(publicKey.getEncoded(false)), StandardCharsets.UTF_8);
        String prik = new String(Hex.encode(privateKey.toByteArray()), StandardCharsets.UTF_8);


        result.put(key_pubk, pubk);
        result.put(key_prik, prik);

        return result;
    }

    /**
     * 获取默认公钥
     * @return
     */
    public static String getDefaultPublicKey() {
    	return DEFAULT_PUBLIC_KEY;
    }

    /**
     * 获取默认私钥
     * @return
     */
    public static String getDefaultPrivateKey() {
    	return DEFAULT_PRIVATE_KEY;
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    protected static byte[] encrypt(String data, byte[] publicKey) {
    	if (StringUtils.isBlank(data)) {
    		return null;
    	}


    	SM2Cipher cipher = new SM2Cipher();

    	// C1
    	byte[] c1Bytes = new byte[65];
    	ECPoint c1 = cipher.encryptInit(sm2, sm2.eccCurve.decodePoint(publicKey));
    	c1Bytes = c1.getEncoded(false);

        // C2
        byte[] c2Bytes = data.getBytes(StandardCharsets.UTF_8);
        cipher.encrypt(c2Bytes);

        // C3
        byte[] c3Bytes = new byte[32];
        cipher.doFinal(c3Bytes);

        byte[] encryptData = new byte[c1Bytes.length + c2Bytes.length + c3Bytes.length];
		System.arraycopy(c1Bytes, 0, encryptData, 0, c1Bytes.length);
		System.arraycopy(c2Bytes, 0, encryptData, c1Bytes.length, c2Bytes.length);
		System.arraycopy(c3Bytes, 0, encryptData, c1Bytes.length + c2Bytes.length, c3Bytes.length);

        return encryptData;
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static byte[] encrypt(String data, String publicKey) {
    	return encrypt(data, HexUtil.hexToByte(publicKey));
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static byte[] encrypt(byte[] data, String publicKey) {
    	return encrypt(new String(data, StandardCharsets.UTF_8), HexUtil.hexToByte(publicKey));
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static String encryptToHexString(String data, String publicKey) {
    	return HexUtil.byteToHex(encrypt(data, HexUtil.hexToByte(publicKey)));
    }

    /**
     * 加密
     * @param data
     * @param publicKey
     * @return
     */
    public static String encryptToHexString(byte[] data, String publicKey) {
    	return HexUtil.byteToHex(encrypt(new String(data, StandardCharsets.UTF_8), HexUtil.hexToByte(publicKey)));
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    protected static byte[] decrypt(byte[] encryptedData, byte[] privateKey) {
    	if (ArrayUtils.isEmpty(encryptedData)) {
    		return null;
    	}


    	SM2Cipher cipher = new SM2Cipher();

        // C1
        byte[] c1Bytes = new byte[65];
        System.arraycopy(encryptedData, 0, c1Bytes, 0, c1Bytes.length);
        ECPoint c1 = sm2.eccCurve.decodePoint(c1Bytes).normalize();

        // C3
        byte[] c3Bytes = new byte[32];
        System.arraycopy(encryptedData, encryptedData.length - 32, c3Bytes, 0, 32);

        // C2
        int c2Len = encryptedData.length - 65 - 32;
        byte[] c2Bytes = new byte[c2Len];
        System.arraycopy(encryptedData, 65, c2Bytes, 0, c2Len);

        cipher.decryptInit(new BigInteger(1, privateKey), c1);
        cipher.decrypt(c2Bytes);
        cipher.doFinal(c3Bytes);
        return c2Bytes;
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    public static byte[] decrypt(byte[] encryptedData, String privateKey) {
    	return decrypt(encryptedData, HexUtil.hexToByte(privateKey));
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    public static String decryptToString(byte[] encryptedData, String privateKey) {
    	return new String(decrypt(encryptedData, HexUtil.hexToByte(privateKey)), StandardCharsets.UTF_8);
    }

    /**
     * 解密
     * @param encryptedData
     * @param privateKey
     * @return
     */
    public static String decryptToString(String encryptedData, String privateKey) {
    	return new String(decrypt(Hex.decode(encryptedData), HexUtil.hexToByte(privateKey)), StandardCharsets.UTF_8);
    }
}

/**
 * （分组密码算法）国密对称加密算法
 */
@Slf4j
public abstract class SM4Util {

	static {
        Security.addProvider(new BouncyCastleProvider());
    }

    private static final Charset ENCODING = StandardCharsets.UTF_8;

    public static final String ALGORITHM_NAME = "SM4";

    // 加密算法/分组加密模式/分组填充方式
    public static final String ALGORITHM_NAME_ECB_PADDING = "SM4/ECB/PKCS5Padding";

    public static final String ALGORITHM_NAME_CBC_PADDING = "SM4/CBC/PKCS5Padding";

    // 128-32位16进制；256-64位16进制
    public static final int DEFAULT_KEY_SIZE = 128;

    public static final String DEFAULT_KEY = "86C63180C2806ED1F47B859DE501215B";
    public static final String DEFAULT_IV = "8F5CB6272B594B53AD1A2197361378DC";

    private static Cipher generateCipherECB(String algorithmName, int mode, byte[] key) throws Exception {
        Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);
        cipher.init(mode, new SecretKeySpec(key, ALGORITHM_NAME));
        return cipher;
    }

    private static Cipher generateCipherCBC(String algorithmName, int mode, byte[] key, byte[] iv) throws Exception {
        Cipher cipher = Cipher.getInstance(algorithmName, BouncyCastleProvider.PROVIDER_NAME);
        cipher.init(mode, new SecretKeySpec(key, ALGORITHM_NAME), new IvParameterSpec(iv));
        return cipher;
    }
    public static String generateKey() {
        try {
			return HexUtil.byteToHex(generateKey(DEFAULT_KEY_SIZE));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
        return null;
    }

    public static byte[] generateKey(int keySize) throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
        kg.init(keySize, new SecureRandom());
        return kg.generateKey().getEncoded();
    }

    protected static byte[] encryptECBPadding(byte[] data, byte[] key) throws Exception {
        Cipher cipher = generateCipherECB(ALGORITHM_NAME_ECB_PADDING, Cipher.ENCRYPT_MODE, key);
        return cipher.doFinal(data);
    }

	protected static byte[] decryptECBPadding(byte[] encrypted, byte[] key) throws Exception {
	    Cipher cipher = generateCipherECB(ALGORITHM_NAME_ECB_PADDING, Cipher.DECRYPT_MODE, key);
	    return cipher.doFinal(encrypted);
	}

    protected static byte[] encryptCBCPadding(byte[] data, byte[] key, byte[] iv) throws Exception {
        Cipher cipher = generateCipherCBC(ALGORITHM_NAME_CBC_PADDING, Cipher.ENCRYPT_MODE, key, iv);
        return cipher.doFinal(data);
    }

	protected static byte[] decryptCBCPadding(byte[] encrypted, byte[] key, byte[] iv) throws Exception {
	    Cipher cipher = generateCipherCBC(ALGORITHM_NAME_CBC_PADDING, Cipher.DECRYPT_MODE, key, iv);
	    return cipher.doFinal(encrypted);
	}

    public static String encrypt(String source) {
        return encrypt(source, DEFAULT_KEY);
    }
    public static String encrypt(byte[] source) {
        return encrypt(source, DEFAULT_KEY);
    }
    public static String encrypt(String source, String hexKey) {
        return encrypt(source.getBytes(ENCODING), hexKey);
    }
    public static String encrypt(byte[] source, String hexKey) {
        byte[] cipherArray;
		try {
			cipherArray = encryptECBPadding(source, ByteUtils.fromHexString(hexKey));
			return ByteUtils.toHexString(cipherArray);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}

        return null;
    }
    public static byte[] decrypt(String encrypted) {
		return decrypt(encrypted, DEFAULT_KEY);
    }
    public static String decryptToString(String encrypted) {
		return decryptToString(encrypted, DEFAULT_KEY);
    }
    public static String decryptToString(String encrypted, String hexKey) {
		return new String(decrypt(encrypted, hexKey), ENCODING);
    }
    public static byte[] decrypt(String encrypted, String hexKey) {
		try {
			return decryptECBPadding(ByteUtils.fromHexString(encrypted), ByteUtils.fromHexString(hexKey));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return encrypted.getBytes(StandardCharsets.UTF_8);
    }
    public static String encrypt(String source, String hexKey, String iv) {
        return encrypt(source.getBytes(ENCODING), hexKey, iv);
    }
    public static String encrypt(byte[] source, String hexKey, String iv) {
        byte[] cipherArray;
		try {
			cipherArray = encryptCBCPadding(
							source
							, ByteUtils.fromHexString(hexKey)
							, ByteUtils.fromHexString(iv));
			return ByteUtils.toHexString(cipherArray);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new RuntimeException("数据加密失败", e);
		}
    }
    public static String decryptToString(String encrypted, String hexKey, String iv) {
		return new String(decrypt(encrypted, hexKey, iv), ENCODING);
    }

    public static byte[] decrypt(String encrypted, String hexKey, String iv) {
		try {
			if (StringUtils.isBlank(encrypted)) {
				return new byte[] {};
			}

			return decryptCBCPadding(
				 	ByteUtils.fromHexString(encrypted)
					, ByteUtils.fromHexString(hexKey)
					, ByteUtils.fromHexString(iv));
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return encrypted.getBytes(StandardCharsets.UTF_8);
    }
}

package space.jachen.yygh.order.config;

import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author JaChen
 * @date 2023/2/14 15:46
 */
@Configuration
public class XxlJobConfig {

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.executor.appname}")
    private String appName;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;

    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {

        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appName);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }
}

package space.jachen.yygh.order.handler;

/**
 * @author JaChen
 * @date 2024/2/14 15:53
 */
@Component
public class MyJobHandler {

    @Autowired
    private RabbitService rabbitService;
    @Autowired
    private OrderInfoMapper orderInfoMapper;

    /**
     * 就诊提醒的handler方法
     *
     * @param param  null
     * @return  ReturnT<String>
     */
    @XxlJob(value = "demoJobHandler1",init = "init",destroy = "destroy")
    public ReturnT<String> execute(String param){
        System.out.println("execute方法执行了 ====》 ");
        // 获取查询的时间
        DateTime dateTime = new DateTime().plusDays(1);
        String dateString = dateTime.toString("yyyy-MM-dd");
        Date date = new DateTime(dateString).toDate();
        LambdaQueryWrapper<OrderInfo> queryWrapper = new LambdaQueryWrapper<OrderInfo>(){{
            eq(OrderInfo::getReserveDate,date);  // 查询就诊日期
            ne(OrderInfo::getOrderStatus, OrderStatusEnum.CANCLE.getStatus());  // 查询没有取消的订单
        }};
        List<OrderInfo> orderInfoList = orderInfoMapper.selectList(queryWrapper);
        for(OrderInfo orderInfo : orderInfoList) {
            // 短信提示
            MsmVo msmVo = new MsmVo();
            msmVo.setPhone(orderInfo.getPatientPhone());
            // 结合mq快速响应其他模块 发送消息
            rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_MSM, MqConst.ROUTING_MSM_ITEM, msmVo);
        }
        return ReturnT.SUCCESS;
    }
    private void init(){
        System.out.println("MyJobHandler init >>>>> " + true);
        String jobParam = XxlJobHelper.getJobParam();
        System.out.println("jobParam = " + jobParam);
    }
}

// 分片广播任务	    
// 当前分片数，从0开始，即执行器的序号
int shardIndex = XxlJobHelper.getShardIndex();
//总分片数，执行器集群总机器数量
int shardTotal = XxlJobHelper.getShardTotal();
// 业务逻辑
......

@Component
public class MonthRangeShardingAlgorithm implements RangeShardingAlgorithm<String> {

    @Override
    public Collection<String> doSharding(Collection<String> collection, RangeShardingValue<String> rangeShardingValue) {
        Collection<String> result = new ArrayList<>();
        List<String> rangeList = getRangeList(rangeShardingValue);
        
        for (String tableName : rangeList) {
            if (collection.contains(tableName.toLowerCase()) || collection.contains(tableName.toUpperCase())) {
                result.add(tableName);
            }
        }
        
        if (result.isEmpty()) {
            throw new UnsupportedOperationException("没有匹配到分片表");
        }
        
        return result;
    }

    private List<String> getRangeList(RangeShardingValue<String> rangeShardingValue) {
        List<String> rangeList = new ArrayList<>();
        String logicTableName = rangeShardingValue.getLogicTableName();
        SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
        Range<String> valueRange = rangeShardingValue.getValueRange();
        Object start = valueRange.lowerEndpoint();
        Object end = valueRange.upperEndpoint();
        
        try {
            Date startDate = format.parse(start.toString());
            Date endDate = format.parse(end.toString());
            DateTime startDateTime = DateUtil.beginOfMonth(startDate);
            DateTime endDateTime = DateUtil.beginOfMonth(endDate);
            
            do {
                String time = DateUtil.format(startDateTime, "yyyyMM");
                String tableName = logicTableName.concat("_").concat(time);
                rangeList.add(tableName);
                startDateTime = DateUtil.offset(startDateTime, DateField.MONTH, 1);
            } while (startDateTime.compareTo(endDateTime) <= 0);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
        return rangeList;
    }
}

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Updates;
import org.bson.Document;
import org.bson.types.ObjectId;

public class MongoDBLogicDeleteExample {
    public static void main(String[] args) {
        // 创建 MongoDB 客户端
        MongoClient mongoClient = MongoClients.create("mongodb://localhost:27017");

        // 获取数据库和集合
        MongoCollection<Document> collection = mongoClient.getDatabase("test").getCollection("collection");

        // 逻辑删除
        ObjectId id = new ObjectId("5f36f47a06c5a722497f37b5");
        collection.updateOne(Filters.eq("_id", id), Updates.set("deleted", true));

        // 关闭 MongoDB 客户端
        mongoClient.close();
    }
}

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;
import org.bson.Document;

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

public class MongoDBQueryExample {
    public static void main(String[] args) {
        // 创建 MongoDB 客户端
        MongoClient mongoClient = MongoClients.create("mongodb://localhost:27017");

        // 获取数据库和集合
        MongoCollection<Document> collection = mongoClient.getDatabase("test").getCollection("collection");

        // 查询
        List<Document> documents = new ArrayList<>();
        collection.find(Filters.ne("deleted", true)).into(documents);

        // 打印结果
        for (Document document : documents) {
            System.out.println(document);
        }

        // 关闭 MongoDB 客户端
       

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import org.bson.types.ObjectId;

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

public class LogicalDeletionExample {
    public static void main(String[] args) {
        // 创建 MongoDB 客户端
        MongoClient mongoClient = new MongoClient("mongodb://localhost:27017");

        // 获取数据库
        MongoDatabase database = mongoClient.getDatabase("test");

        // 获取原始集合
        MongoCollection<Document> collection = database.getCollection("collection");

        // 获取新集合
        MongoCollection<Document> deletedCollection = database.getCollection("deleted_collection");

        // 逻辑删除
        ObjectId id = new ObjectId("5f36f47a06c5a722497f37b5");
        Document deletedDocument = collection.find(new Document("_id", id)).first();
        deletedCollection.insertOne(deletedDocument);
        collection.deleteOne(new Document("_id", id));

        // 查询
        List<Document> documents = new ArrayList<>();
        collection.find().into(documents);

        // 打印结果
        for (Document document : documents) {
            System.out.println(document);
        }

        // 关闭客户端
        mongoClient.close();
    }
}

@Data
public class Stu {
    //设置表头名称
    @ExcelProperty("学生编号")
    private int sno;
    
    //设置表头名称
    @ExcelProperty("学生姓名")
    private String sname;
}

//循环设置要添加的数据，最终封装到list集合中
private static List<Stu> data() {
    List<Stu> list = new ArrayList<Stu>();
    for (int i = 0; i < 10; i++) {
        Stu data = new Stu();
        data.setSno(i);
        data.setSname("张三"+i);
        list.add(data);
    }
    return list;
}

public static void main(String[] args) throws Exception {
    String fileName = "E:\\11.xlsx";
    // 这里 需要指定写用哪个class去写，然后写到第一个sheet，名字为模板 然后文件流会自动关闭
    // 如果这里想使用03 则 传入excelType参数即可
    EasyExcel.write(fileName, Stu.class).sheet("写入方法一").doWrite(data());
}

@Data
public class Stu {
    
    //设置表头名称
    //设置列对应的属性
    @ExcelProperty(value = "学生编号",index = 0)
    private int sno;
    
    //设置表头名称
    //设置列对应的属性
    @ExcelProperty(value = "学生姓名",index = 1)
    private String sname;
}

public class ExcelListener extends AnalysisEventListener<Stu> {
    //创建list集合封装最终的数据
    List<Stu> list = new ArrayList<Stu>();
    //一行一行去读取excle内容
    @Override
    public void invoke(Stu user, AnalysisContext analysisContext) {
        System.out.println("***"+user);
        list.add(user);
    }
    //读取excel表头信息
    @Override
    public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
        System.out.println("表头信息："+headMap);
    }
    //读取完成后执行
    @Override
    public void doAfterAllAnalysed(AnalysisContext analysisContext) {
        System.out.println("list = " + list);
    }
}

public static void main(String[] args) throws Exception {
    String fileName = "E:\\11.xlsx";
    // 这里 需要指定调用哪个class去读，然后读取第一个sheet 文件流会自动关闭
    EasyExcel.read(fileName, Stu.class, new ExcelListener()).sheet().doRead();
}

package space.jachen.yygh.order.security;

import org.springframework.security.core.GrantedAuthority;
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.Component;
import space.jachen.yygh.security.custom.CustomUser;
import space.jachen.yygh.user.PatientFeignClient;
import space.jachen.yygh.vo.user.LoginVo;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Collection;

/**
 * @author JaChen
 * @date 2022/12/23 22:35
 */
@Component
public class UserDetailsServiceImpl implements UserDetailsService {

    @Resource
    private PatientFeignClient userInfoFeignClient;

    @Override
    public UserDetails loadUserByUsername(String phone) throws UsernameNotFoundException {
        LoginVo login = userInfoFeignClient.loginSecurity(phone);
        if(login == null) {
            throw new UsernameNotFoundException("用户名不存在！");
        }
        // 这里不比较密码 ，后面通过PasswordEncoder比较
        // 返回数据、暂时不做授权
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        return new CustomUser(login,authorities);
    }
}

package space.jachen.yygh.security.custom;

import lombok.Getter;
import lombok.Setter;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.User;
import space.jachen.yygh.vo.user.LoginVo;

import java.util.Collection;

/**
 * 访问数据库的方法loadUserByUsername，返回值为Userdetails，
 * 它封装了从数据库中返回的用户信息，但是和我们数据库表不一致，
 * 所以我们还需要自定义UserDetails实现类。
 *
 * @author JaChen
 * @date 2022/12/23 22:31
 */
@Getter
@Setter
public class CustomUser extends User {

    /**
     * 我们自己的用户实体对象，要调取用户信息时直接获取这个实体对象
     */
    private LoginVo loginVo;

    /**
     *
     * @param loginVo  从数据库中查询的用户信息
     * @param authorities  从数据库中查询的权限
     */
    public CustomUser(LoginVo loginVo,Collection<? extends GrantedAuthority> authorities) {
        super(loginVo.getPhone(), loginVo.getCode(), authorities);
        this.loginVo = loginVo;
    }
}

package space.jachen.yygh.security.custom;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;

/**
 *
 * 自定义密码组件 密码处理
 * 此项目不需要md5加密处理
 * 不需要开发者自己调用此类，SpringSecurity流程中进行密码比较时会自动调用。
 *
 * @author JaChen
 * @date 2022/12/23 22:25
 */
@Component  // 必须添加到IOC ,SpringSecurity才可以使用
public class CustomPasswordEncoder implements PasswordEncoder {


    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 如果需要加密进行加密操作后返回，这里不需要处理，
     * 因为本项目没有对用户密码进行加密，
     * 采用的是手机号+验证码的方式进行登录
     * 验证码存在redis中，为了方便演示，特定此条验证码永不过期，当作密码使用，
     *
     * @param rawPassword  明文  用户输入的密码
     * @return  密文
     */
    public String encode(CharSequence rawPassword) {
        return rawPassword.toString();
    }

    /**
     *
     * @param rawPassword  用户输入的密码  即4位验证码
     * @param encodedPassword  从redis中查询出来的验证码
     * @return boolean
     */
    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        // 写死
        encodedPassword = stringRedisTemplate.opsForValue().get("13243922402");
        return encodedPassword.equals(encode(encodedPassword));
    }
}

package space.jachen.yygh.security.filter;

/**
 * @author JaChen
 * @date 2022/12/23 22:45
 */

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.authentication.AuthenticationManager;
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 space.jachen.yygh.common.result.JsonData;
import space.jachen.yygh.common.result.ResultCodeEnum;
import space.jachen.yygh.common.utils.JwtHelper;
import space.jachen.yygh.common.utils.ResponseUtil;
import space.jachen.yygh.security.custom.CustomUser;
import space.jachen.yygh.vo.user.LoginVo;

import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * <p>
 * 登录过滤器，继承UsernamePasswordAuthenticationFilter，对用户名密码进行登录校验
 * </p>
 *
 */
public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter {

    @Resource
    private RedisTemplate redisTemplate;
    public TokenLoginFilter(AuthenticationManager authenticationManager,
                            RedisTemplate redisTemplate ) {
        //设置认证管理器
        this.setAuthenticationManager(authenticationManager);
        //设置登录的地址和请求方式
        this.setRequiresAuthenticationRequestMatcher(
                new AntPathRequestMatcher("/yygh/user/loginSecurity", "POST"));
        this.redisTemplate = redisTemplate;
    }

    /**
     * 登录认证
     * 走这个登录认证流程 不走原先的登录接口了
     *
     * @param req
     * @param res
     * @return
     * @throws AuthenticationException
     */
    @Override
    public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res)
            throws AuthenticationException {
        try {
            // 获取用户名的方法  简单封装方法
            LoginVo loginVo = new ObjectMapper().readValue(req.getInputStream(), LoginVo.class);
            String pwd = (String) redisTemplate.opsForValue().get(loginVo.getPhone());
            // 将用户名和密码封装到Authentication
            Authentication authenticationToken =
                    new UsernamePasswordAuthenticationToken(loginVo.getPhone(), pwd);
            // 调取getAuthenticationManager认证
            return this.getAuthenticationManager().authenticate(authenticationToken);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 登录成功 认证成功调用的方法
     *
     * @param request
     * @param response
     * @param chain
     * @param auth
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain,Authentication auth) throws IOException, ServletException {
        // 1、通过Authentication获取认证的对象
        CustomUser customUser = (CustomUser) auth.getPrincipal();
        // 2、通过JwtHelper生成token
        String token = JwtHelper.createToken(Long.parseLong(customUser.getLoginVo().getOpenid()), customUser.getLoginVo().getPhone());
        // 3、获取用户的权限
        // Collection<GrantedAuthority> authorities = customUser.getAuthorities();
        // 4、将权限保存到Redis中
        // redisTemplate.boundValueOps(customUser.getUsername()).set(authorities);

        // 5、保存登录日志
        // loginLogService.recordLoginLog(customUser.getUsername(), IpUtil.getIpAddress(request),1,"登录成功");

        // 创建一个Map
        Map<String, Object> map = new HashMap<>();
        map.put("token", token);
        // 6、通过ResponseUtil工具类响应到前端
        ResponseUtil.out(response, JsonData.ok(map));
    }

    /**
     * 登录失败
     *
     * @param request
     * @param response
     * @param e
     * @throws IOException
     * @throws ServletException
     */
    @Override
    protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
        if (e.getCause() instanceof RuntimeException){
            ResponseUtil.out(response, JsonData.build(null,204,e.getMessage()));
        }else {
            ResponseUtil.out(response,JsonData.build(null, ResultCodeEnum.LOGIN_MOBLE_ERROR));
        }
    }
}

package space.jachen.yygh.security.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import space.jachen.yygh.security.filter.TokenLoginFilter;

import javax.annotation.Resource;

/**
 * @author JaChen
 * @date 2022/12/23 22:24
 */
@Configuration
@EnableWebSecurity //@EnableWebSecurity是开启SpringSecurity的默认行为
@EnableGlobalMethodSecurity(prePostEnabled = true)//开启注解功能，默认禁用注解
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {


    @Resource
    private RedisTemplate redisTemplate;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 这是配置的关键，决定哪些接口开启防护，哪些接口绕过防护
        http
                //关闭csrf
                .csrf().disable()
                // 开启跨域以便前端调用接口
                .cors().and()
                .authorizeRequests()
                // 指定某些接口不需要通过验证即可访问。登陆接口肯定是不需要认证的
                .antMatchers("/yygh/user/login").permitAll()
                // 这里意思是其它所有接口需要认证才能访问
                .anyRequest().authenticated()
                .and()
                //TokenAuthenticationFilter放到UsernamePasswordAuthenticationFilter的前面，
                // 这样做就是为了除了登录的时候去查询数据库外，其他时候都用token进行认证。
//                .addFilterBefore(new TokenAuthenticationFilter(redisTemplate), UsernamePasswordAuthenticationFilter.class)
                .addFilter(new TokenLoginFilter(authenticationManager(), redisTemplate));

        //禁用session
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);
    }

    /**
     * 配置哪些请求不拦截
     * 排除swagger相关请求
     * @param web
     * @throws Exception
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers("/favicon.ico","/swagger-resources/**", "/webjars/**", "/v2/**", "/swagger-ui.html/**", "/doc.html");
    }
}

package space.jachen.yygh.security.filter;

/**
 * @author JaChen
 * @date 2022/12/23 23:04
 */

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.OncePerRequestFilter;
import space.jachen.yygh.common.result.JsonData;
import space.jachen.yygh.common.result.ResultCodeEnum;
import space.jachen.yygh.common.utils.JwtHelper;
import space.jachen.yygh.common.utils.ResponseUtil;

import javax.annotation.Resource;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Collection;

/**
 * <p>
 * 认证解析token过滤器
 * </p>
 */
public class TokenAuthenticationFilter extends OncePerRequestFilter {

    @Resource
    private RedisTemplate redisTemplate;

    public TokenAuthenticationFilter(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)throws IOException, ServletException {
        logger.info("认证解析token过滤器的url:"+request.getRequestURI());
        //如果是登录接口，直接放行
        if("/yygh/user/login".equals(request.getRequestURI())) {
            chain.doFilter(request, response);
            return;
        }

        UsernamePasswordAuthenticationToken authentication = getAuthentication(request);
        if(null != authentication) {
            SecurityContextHolder.getContext().setAuthentication(authentication);
            //放行请求
            chain.doFilter(request, response);
        } else {
            ResponseUtil.out(response, JsonData.build(null, ResultCodeEnum.PERMISSION));//209  没有权限
        }
    }

    private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request) {
        // token置于header里
        String token = request.getHeader("token");
        logger.info("token:"+token);
        if (!StringUtils.isEmpty(token)) {
            String username = JwtHelper.getUserName(token);
            logger.info("username:"+username);
            if (!StringUtils.isEmpty(username)) {
                //从Redis中获取权限
                Collection<GrantedAuthority> authorities = (Collection<GrantedAuthority>) redisTemplate.boundValueOps(username).get();
                return new UsernamePasswordAuthenticationToken(username, null, authorities);
                //返回一个认证对象
                //return new UsernamePasswordAuthenticationToken(username, null, Collections.emptyList());
            }
        }
        return null;
    }
}