springboot

@SpringBootApplication

public class DemoApplication {

    public static void main(String[] args) {

        SpringApplication.run(DemoApplication.class, args);

    }

}

public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override

    public void initialize(ConfigurableApplicationContext applicationContext) {

        Map<String, Object> map = new HashMap<>();

        map.put("myName", "mof");

        // 获取属性资源管理对象

        MutablePropertySources propertySources = applicationContext.getEnvironment().getPropertySources();

        propertySources.addLast(new MapPropertySource("map", map));

    }

}

ConfigurableApplicationContext context = SpringApplication.run(SpringbootDemoApplication.class, args);

String value = context.getEnvironment().getProperty("myName");

System.out.println(value);

public class MyApplicationListener implements ApplicationListener {

    @Override

    public void onApplicationEvent(ApplicationEvent event) {

        if (event instanceof ApplicationReadyEvent){

            System.out.println("容器初始化成功");

        }

        if (event instanceof ApplicationFailedEvent){

            System.out.println("容器初始化失败");

        }

    }

}

ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();

BeanDefinition user = beanFactory.getBeanDefinition("user");

System.out.println(user.getClass());

@Component

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

        // 准备 BeanDefinition

        GenericBeanDefinition dfUser = new GenericBeanDefinition();

        dfUser.setBeanClass(User.class);

        // 注册 BeanDefinition

        DefaultListableBeanFactory dbf = (DefaultListableBeanFactory) configurableListableBeanFactory;

        dbf.registerBeanDefinition("user", dfUser);

    }

}

@Component

public class MyAware implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware {

    @Override

    public void setBeanClassLoader(ClassLoader classLoader) {

        System.out.println("setBeanClassLoader: " + classLoader);

    }

    @Override

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

        System.out.println("setBeanFactory: " + beanFactory);

    }

    @Override

    public void setBeanName(String s) {

        System.out.println("setBeanName: " + s);

    }

}

@Component

public class t implements InitializingBean, DisposableBean {

    @Override

    public void afterPropertiesSet() throws Exception {

        System.out.println("t实例化了");

    }

    @Override

    public void destroy() throws Exception {

        System.out.println("t被销毁了");

    }

}

@Component

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        System.out.println("BeanPostProcessor.postProcessBeforeInitialization：" + beanName);

        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);

    }

    @Override

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        System.out.println("BeanPostProcessor.postProcessAfterInitialization：" + beanName);

        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);

    }

}

@Component

public class t implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,

        InitializingBean, DisposableBean{

    public t(){

        System.out.println("t 构造函数");

    }

    @PostConstruct

    public void postConstruct(){

        System.out.println("t PostConstruct");

    }

    @PreDestroy

    private void preDestory(){

        System.out.println("t PreDestory");

    }

    @Override

    public void setBeanClassLoader(ClassLoader classLoader) {

        System.out.println("t BeanClassLoaderAware.setBeanClassLoader：" + classLoader);

    }

    @Override

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

        System.out.println("t BeanFactoryAware.setBeanFactory：" + beanFactory);

    }

    @Override

    public void setBeanName(String name) {

        System.out.println("t BeanNameAware.setBeanName：" + name);

    }

    @Override

    public void afterPropertiesSet() throws Exception {

        System.out.println("t InitializingBean.afterPropertiesSet");

    }

    @Override

    public void destroy() throws Exception {

        System.out.println("t DisposableBean.destroy");

    }

}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {

    Assert.notNull(singletonFactory, "Singleton factory must not be null");

    synchronized (this.singletonObjects) {

        if (!this.singletonObjects.containsKey(beanName)) {

            // 添加 EarlyBean 到 Factory 中，存储在 singletonFactories 中

            this.singletonFactories.put(beanName, singletonFactory);

            this.earlySingletonObjects.remove(beanName);

            this.registeredSingletons.add(beanName);

        }

    }

}

public class ThreadLocalUtil {

    private final static ThreadLocal THREAD_LOCAL = new ThreadLocal();

    public static <T>T get(){

        return (T) THREAD_LOCAL.get();

    }

    public static void set(Object value){

        THREAD_LOCAL.set(value);

    }

    public static void remove(){

        THREAD_LOCAL.remove();

    }

}

@ControllerAdvice

public class GlobalExceptionHandler {

    @ExceptionHandler({Exception.class})

    public void handleException(Exception ex){

        ex.printStackTrace();

    }

}

// 方法一

@RequestMapping("byId")

public String byId(@Pattern(regexp = "^\\d$") String id){

    return userService.byId(Integer.decode(id));

}

@RestControllerAdvice

public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)

    public String handleExcetion(Exception e){

        //e.printStackTrace();

        return StringUtils.isNullOrEmpty(e.toString())?"操作失败！":e.toString();

    }

}

// 方法二

@RequestMapping("byId")

public String byId(@Validated Integer id, BindingResult result){

    if (result.hasErrors()){

        return "参数错误";

    }

    return userService.byId(id);

}

public String upload(MultipartFile img) throws IOException {

    // TODO: 条件限制，格式、大小、路径

    // 获取当前路径拼接

    String dir = System.getProperty("user.dir") + uploadDir;

    String filename = "public/imgs/" + System.currentTimeMillis() + '-' + img.getOriginalFilename();

    File file = new File(dir , filename);

    img.transferTo(file);

    log.info("ProductController.upload执行完毕，结果为：{}", "图片地址：" + file.getAbsolutePath());

    return filename;

}

/**

 * @Description: 阿里云 oss 工具类

 * @Author: mof

 * @CreateTime: 2025-03-18

 */

import com.aliyun.oss.OSS;

import com.aliyun.oss.OSSClientBuilder;

import com.aliyun.oss.model.GetObjectRequest;

import com.aliyun.oss.model.ObjectMetadata;

import lombok.Data;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.util.Date;

@Component

@Data

@ConfigurationProperties(prefix = "aliyun.oss.file")

public class AliyunOssUtils {

    // 基本属性 读取配置文件

    private  String endPoint;

    private  String keyId;

    private  String keySecret;

    private  String bucketName;

    /**

     * byte 数组格式上传文件并返回上传后的 URL 地址

     * @param objectName        完整文件名，例如 abc/efg/123.jpg

     * @param content           文件内容，byte 数组格式

     * @param contentType       文件类型   image/png  image/jpeg

     * @param hours             过期时间   单位小时

     * @Author zhaoweifeng

     */

    public  String uploadImage(String objectName,

                               byte[] content,String contentType,int hours)  throws Exception {

        // 创建 OSSClient 实例。

        OSS ossClient = new OSSClientBuilder().build(endPoint, keyId, keySecret);

        // 创建上传文件的元信息，可以通过文件元信息设置 HTTP header (设置了才能通过返回的链接直接访问)。

        ObjectMetadata objectMetadata = new ObjectMetadata();

        objectMetadata.setContentType(contentType);

        // 文件上传

        ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(content), objectMetadata);

        // 设置 URL 过期时间为 hours 小时。

        Date expiration = new Date(System.currentTimeMillis() + 3600 * 1000 * 300 * hours);

        // 返回 url 地址

        String url = ossClient.generatePresignedUrl(bucketName, objectName, expiration).toString();

        // 关闭 OSSClient。

        ossClient.shutdown();

        return url;

    }

    /**

     * 下载文件到本地

     * @param objectName        完整文件名，例如 abc/efg/123.jpg

     * @param localFile         下载到本地文件目录

     * @Author zhaoweifeng

     */

    public  void downFile(String objectName,

                          String localFile) throws Exception {

        // 创建 OSSClient 实例。

        OSS ossClient = new OSSClientBuilder().build(endPoint, keyId, keySecret);

        // 下载 OSS 文件到本地文件。如果指定的本地文件存在会覆盖，不存在则新建。

        ossClient.getObject(new GetObjectRequest(bucketName, objectName), new File(localFile));

        // 关闭 OSSClient。

        ossClient.shutdown();

    }

    /**

     * 删除文件

     * @param objectName        完整文件名，例如 abc/efg/123.jpg

     * @Author zhaoweifeng

     */

    public  void deleteFile(String objectName) {

        // 创建 OSSClient 实例。

        OSS ossClient = new OSSClientBuilder().build(endPoint, keyId, keySecret);

        // 删除文件。如需删除文件夹，请将 ObjectName 设置为对应的文件夹名称。如果文件夹非空，则需要将文件夹下的所有 object 删除后才能删除该文件夹。

        ossClient.deleteObject(bucketName, objectName);

        // 关闭 OSSClient。

        ossClient.shutdown();

    }

}

@Autowired

private StringRedisTemplate stringRedisTemplate;

@Override

public void sendCode(String phone) {

    // 插入，设置键、值、过期时间、时间单位

    stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);

}

import com.auth0.jwt.JWT;

import com.auth0.jwt.algorithms.Algorithm;

import java.util.Date;

import java.util.Map;

/**

 * JWT 工具类

 */

public class JwtUtil {

    private final static String secret = "secret_key";

    /**

     * 生成 JWT token

     * @param: claim 载荷

     * @return: java.lang.String

     */

    public static String gen(Map<String, Object> claim){

        String token = JWT.create()

                .withClaim("claim", claim)  // 添加载荷

                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 3600))  // 过期时间

                .sign(Algorithm.HMAC256(secret));  // 加密算法和密钥

        return token;

    }

    /**

     * 验证 JWT token，返回内部信息

     * @param: token jwt 令牌

     * @return: java.util.Map<java.lang.String,java.lang.Object>

     */

    public static Map<String, Object> parse(String token){

        try {

            Map<String, Object> claim = JWT.require(Algorithm.HMAC256(secret))

                    .build()  // JWT 验证器

                    .verify(token)  // 生成解析后的 JWT 对象

                    .getClaim("claim")  // 获取信息

                    .asMap();

            return claim;

        } catch (Exception e) {

            return null;

        }

    }

}

@Component

public class LoginInterceptor implements HandlerInterceptor {

    @Override

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("验证失败！");

        return false;  // 不放行

    }

}

@Configuration

public class WebMvcConfiguration implements WebMvcConfigurer {

    @Autowired

    private LoginInterceptor loginInterceptor;

    @Override

    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(loginInterceptor).addPathPatterns("/**").excludePathPatterns("/login");

    }

}

@Aspect

@Component

@Slf4j

public class RecordTimeAspect {

    // @Pointcut 注解，提取公共切入点

    //execution 表达式，基于方法签名匹配切入点

    @Pointcut("execution(* com.mof.aopdemo.*.*(..))")

    public void pt1(){}

    //annotation 注解，基于注解类型匹配切入点

    @Pointcut("@annotation(com.mof.aopdemo.LogOperation)")

    public void pt2(){}

    // @Around，环绕通知，调用 ProceedingJoinPoint.proceed 执行原方法

    @Around("pt2()")

    public Object recordTime(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        long begin = System.currentTimeMillis();

        Object proceed = proceedingJoinPoint.proceed();

        long end = System.currentTimeMillis();

        log.info("RecordTimeAspect.recordTime执行完毕，{}运行时间为：{}ms", proceedingJoinPoint.getSignature(), end - begin);

        return proceed;

    }

    // @After，后置通知，调用 JoinPoint 获取原方法信息

    @After("pt2()")

    public void afterCall(JoinPoint joinPoint){

        log.info("RecordTimeAspect.afterCall执行完毕，{}执行完毕", joinPoint.getSignature());

    }

}

@Target(ElementType.METHOD)  // 加在方法上

@Retention(RetentionPolicy.RUNTIME)  // 在运行时生效

public @interface LogOperation {

}