关于@Value注解 不能给static静态变量注入值的方法

最新推荐文章于 2022-08-02 20:28:38 发布
最新推荐文章于 2022-08-02 20:28:38 发布
阅读量437 收藏
点赞数
分类专栏： 平时遇到的问题 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xchnba2107/article/details/121081983
版权

正常使用方法

package cn.evun.ime.platform.schedule.configuration;
/**
 * @author ruanrj
 * @description
 * @create 2017-02-24.
 */

import cn.evun.ime.platform.schedule.servlet.TimedJobServletContextListener;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.util.Properties;

@Configuration
public class ScheduleConfiguration {

    @Value("${spring.datasource.driver-class-name}")
    private String driver;

    @Value("${spring.datasource.url}")
    private String url;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Bean
    public TimedJobServletContextListener timedJobServletContextListener() {
        return new TimedJobServletContextListener();
    }

    private Properties quartzProperties(){
        Properties properties = new Properties();
        properties.put("org.quartz.scheduler.instanceId", "AUTO");
        properties.put("org.quartz.scheduler.skipUpdateCheck", "true");//跳过Quartz版本检测更新
        properties.put("org.quartz.scheduler.jmx.export", "true");

        //任务仓库配置
        properties.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        properties.put("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
        properties.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
        properties.put("org.quartz.jobStore.isClustered", "true");//集群
        properties.put("org.quartz.jobStore.clusterCheckinInterval", "20000");//检测确认为失败的时间
        properties.put("org.quartz.jobStore.dataSource", "myDS");
        properties.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");//同步执行数量
        properties.put("org.quartz.jobStore.misfireThreshold", "120000");
        properties.put("org.quartz.jobStore.txIsolationLevelSerializable", "false");//执行JDBC时设置事物级别，setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE)
        properties.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS WHERE LOCK_NAME = ? FOR UPDATE");

        //允许调度程序一次获取触发器的最大数量
        //properties.put(PROP_SCHED_MAX_BATCH_SIZE,"10");

        //线程池配置
        properties.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        //并发线程数 需要设置线程池才有效
        properties.put("org.quartz.threadPool.threadCount", "10");//并发线程数
        properties.put("org.quartz.threadPool.threadPriority", "5");//默认优先级
        properties.put("org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread", "true");//初始化线程继承类加载器

        //数据源
        properties.put("org.quartz.dataSource.myDS.driver", driver);
        properties.put("org.quartz.dataSource.myDS.URL", url);
        properties.put("org.quartz.dataSource.myDS.user", username);
        properties.put("org.quartz.dataSource.myDS.password", password);
        //最大连接数 默认10
        //properties.put("org.quartz.dataSource.myDS.maxConnections", "100");

        //日志记录
        properties.put("org.quartz.plugin.triggHistory.class", "org.quartz.plugins.history.LoggingJobHistoryPlugin");
        //JVM终止时，关闭scheuler
        properties.put("org.quartz.plugin.shutdownhook.class", "org.quartz.plugins.management.ShutdownHookPlugin");
        properties.put("org.quartz.plugin.shutdownhook.cleanShutdown", "true");
        return properties;
    }

    @Bean(name = "scheduler")
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        //设置定时器名称
        //factoryBean.setSchedulerName();
        factoryBean.setAutoStartup(true);
        factoryBean.setStartupDelay(10);
        factoryBean.setOverwriteExistingJobs(true);
        //设置任务执行线程池
        //factoryBean.setTaskExecutor();
        //设置配置文件路径
        //factoryBean.setConfigLocation();
        //设置事务
        //factoryBean.setNonTransactionalDataSource();
        factoryBean.setQuartzProperties(quartzProperties());
        return factoryBean;
    }
}

第二种静态引用方法

package com.hikvision.mes.service.zp.configuration;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.sql.*;
import java.util.List;

@Component
public  class JdbcUtilsConfiguration {

    public static String driverClassName;
    public static String URL;
    public static String username;
    public static String password;
    private static String connect;
    private static boolean autoCommit = false;
    /**
     * 声明一个 Connection类型的静态属性，用来缓存一个已经存在的连接对象
     */
    private static Connection conn;
    @Value("${spring.datasource.driver-class-name}")
    private String driver1;
    @Value("${spring.datasource.url}")
    private String url1;
    @Value("${spring.datasource.username}")
    private String username1;
    @Value("${spring.datasource.password}")
    private String password1;

    /**
     * 载入数据库驱动类
     */
    private static boolean load() {
        try {
            Class.forName(driverClassName);
            return true;
        } catch (ClassNotFoundException e) {
            System.out.println("驱动类 " + driverClassName + " 加载失败");
        }

        return false;
    }

    /**
     * 开头配置自己的数据库信息
     */
//    private static void config() {
//
//        Global.driverClassName = driverClassName;
//        Global.URL = URL;
//        Global.username = username;
//        Global.password = password;
//
		/*
		 * 获取驱动
		 */
		driverClassName = "com.mysql.jdbc.Driver";
		/*
		 * 获取URL
		 */
		URL = "jdbc:oracle:thin:@meshzdb-sit.hikvision.com.cn:1521:meshzsit";
		/*
		 * 获取用户名
		 */
		username = "MESHIK";
		/*
		 * 获取密码
		 */
		password = "JeGJqBx4HemLWkqPt";
//        /*
//         * 设置是否自动提交，一般为false不用改
//         */
//        autoCommit = false;
//
//    }

    /**
     * 专门检查缓存的连接是否不可以被使用 ，不可以被使用的话，就返回 true
     */
    private static boolean invalid() {
        if (conn != null) {
            try {
                if (conn.isClosed() || !conn.isValid(3)) {
                    return true;
                    /*
                     * isValid方法是判断Connection是否有效,如果连接尚未关闭并且仍然有效，则返回 true
                     */
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            /*
             * conn 既不是 null 且也没有关闭 ，且 isValid 返回 true，说明是可以使用的 ( 返回 false )
             */
            return false;
        } else {
            return true;
        }
    }

    /**
     * 建立数据库连接
     */
    public static Connection connect() {
        if (invalid()) { /* invalid为true时，说明连接是失败的 */
            /* 加载驱动 */
            load();
            try {
                /* 建立连接 */
                conn = DriverManager.getConnection(URL, username, password);
            } catch (SQLException e) {
                System.out.println("建立 " + connect + " 数据库连接失败 , " + e.getMessage());
            }
        }
        return conn;
    }

    /**
     * 设置是否自动提交事务
     **/
    public static void transaction() {

        try {
            conn.setAutoCommit(autoCommit);
        } catch (SQLException e) {
            System.out.println("设置事务的提交方式为 : " + (autoCommit ? "自动提交" : "手动提交") + " 时失败: " + e.getMessage());
        }

    }

    /**
     * 创建 Statement 对象
     */
    public static Statement statement() {
        Statement st = null;
        connect();
        /* 如果连接是无效的就重新连接 */
        transaction();
        /* 设置事务的提交方式 */
        try {
            st = conn.createStatement();
        } catch (SQLException e) {
            System.out.println("创建 Statement 对象失败: " + e.getMessage());
        }

        return st;
    }

    /**
     * 根据给定的带参数占位符的SQL语句，创建 PreparedStatement 对象
     *
     * @param SQL 带参数占位符的SQL语句
     * @return 返回相应的 PreparedStatement 对象
     */
    private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) {

        PreparedStatement ps = null;
        connect();
        /* 如果连接是无效的就重新连接 */
        transaction();
        /* 设置事务的提交方式 */
        try {
            if (autoGeneratedKeys) {
                ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
            } else {
                ps = conn.prepareStatement(SQL);
            }
        } catch (SQLException e) {
            System.out.println("创建 PreparedStatement 对象失败: " + e.getMessage());
        }

        return ps;

    }

    public static ResultSet query(String SQL, List<Object> params) {

        if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) {
            throw new RuntimeException("你的SQL语句为空或不是查询语句");
        }
        ResultSet rs = null;
        if (params.size() > 0) {
            /* 说明 有参数 传入，就需要处理参数 */
            PreparedStatement ps = prepare(SQL, false);
            try {
                for (int i = 0; i < params.size(); i++) {
                    ps.setObject(i + 1, params.get(i));
                }
                rs = ps.executeQuery();
            } catch (SQLException e) {
                System.out.println("执行SQL失败: " + e.getMessage());
            }
        } else {
            /* 说明没有传入任何参数 */
            Statement st = statement();
            try {
                rs = st.executeQuery(SQL); // 直接执行不带参数的 SQL 语句
            } catch (SQLException e) {
                System.out.println("执行SQL失败: " + e.getMessage());
            }
        }

        return rs;

    }

    private static Object typeof(Object o) {
        Object r = o;

        if (o instanceof java.sql.Timestamp) {
            return r;
        }
        // 将 java.util.Date 转成 java.sql.Date
        if (o instanceof java.util.Date) {
            java.util.Date d = (java.util.Date) o;
            r = new java.sql.Date(d.getTime());
            return r;
        }
        // 将 Character 或 char 变成 String
        if (o instanceof Character || o.getClass() == char.class) {
            r = String.valueOf(o);
            return r;
        }
        return r;
    }

    public static boolean execute(String SQL, Object... params) {
        if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) {
            throw new RuntimeException("你的SQL语句为空或有错");
        }
        boolean r = false;
        /* 表示 执行 DDL 或 DML 操作是否成功的一个标识变量 */

        /* 获得 被执行的 SQL 语句的 前缀 */
        SQL = SQL.trim();
        SQL = SQL.toLowerCase();
        String prefix = SQL.substring(0, SQL.indexOf(" "));
        String operation = ""; // 用来保存操作类型的 变量
        // 根据前缀 确定操作
        switch (prefix) {
            case "create":
                operation = "create table";
                break;
            case "alter":
                operation = "update table";
                break;
            case "drop":
                operation = "drop table";
                break;
            case "truncate":
                operation = "truncate table";
                break;
            case "insert":
                operation = "insert :";
                break;
            case "update":
                operation = "update :";
                break;
            case "delete":
                operation = "delete :";
                break;
        }
        if (params.length > 0) { // 说明有参数
            PreparedStatement ps = prepare(SQL, false);
            Connection c = null;
            try {
                c = ps.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                for (int i = 0; i < params.length; i++) {
                    Object p = params[i];
                    p = typeof(p);
                    ps.setObject(i + 1, p);
                }
                ps.executeUpdate();
                commit(c);
                r = true;
            } catch (SQLException e) {
                System.out.println(operation + " 失败: " + e.getMessage());
                rollback(c);
            }

        } else { // 说明没有参数

            Statement st = statement();
            Connection c = null;
            try {
                c = st.getConnection();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            // 执行 DDL 或 DML 语句，并返回执行结果
            try {
                st.executeUpdate(SQL);
                commit(c); // 提交事务
                r = true;
            } catch (SQLException e) {
                System.out.println(operation + " 失败: " + e.getMessage());
                rollback(c); // 回滚事务
            }
        }
        return r;
    }

    /**
     * 提交事务
     */
    private static void commit(Connection c) {
        if (c != null && !autoCommit) {
            try {
                c.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 回滚事务
     */
    private static void rollback(Connection c) {
        if (c != null && !autoCommit) {
            try {
                c.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    @PostConstruct
    public void init() {
        driverClassName = driver1;
        URL = url1;
        username = username1;
        password = password1;
    }

    /*
     *
     * @param SQL 需要执行的 INSERT 语句
     *
     * @param autoGeneratedKeys 指示是否需要返回由数据库产生的键
     *
     * @param params 将要执行的SQL语句中包含的参数占位符的 参数值
     *
     * @return 如果指定 autoGeneratedKeys 为 true 则返回由数据库产生的键； 如果指定 autoGeneratedKeys
     * 为 false 则返回受当前SQL影响的记录数目
     */
    public int insert(String SQL, boolean autoGeneratedKeys, List<Object> params) {
        int var = -1;
        if (SQL == null || SQL.trim().isEmpty()) {
            throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
        }
        // 如果不是 insert 开头开头的语句
        if (!SQL.trim().toLowerCase().startsWith("insert")) {
            System.out.println(SQL.toLowerCase());
            throw new RuntimeException("你指定的SQL语句不是插入语句，请检查你的SQL语句");
        }
        // 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
        SQL = SQL.trim();
        SQL = SQL.toLowerCase();
        if (params.size() > 0) { // 说明有参数
            PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
            Connection c = null;
            try {
                c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                for (int i = 0; i < params.size(); i++) {
                    Object p = params.get(i);
                    p = typeof(p);
                    ps.setObject(i + 1, p);
                }
                int count = ps.executeUpdate();
                if (autoGeneratedKeys) { // 如果希望获得数据库产生的键
                    ResultSet rs = ps.getGeneratedKeys(); // 获得数据库产生的键集
                    if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
                        var = rs.getInt(1); // 获得值并赋值给 var 变量
                    }
                } else {
                    var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
                }
                commit(c);
            } catch (SQLException e) {
                System.out.println("数据保存失败: " + e.getMessage());
                rollback(c);
            }
        } else { // 说明没有参数
            Statement st = statement();
            Connection c = null;
            try {
                c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
            } catch (SQLException e) {
                e.printStackTrace();
            }
            // 执行 DDL 或 DML 语句，并返回执行结果
            try {
                int count = st.executeUpdate(SQL);
                if (autoGeneratedKeys) { // 如果企望获得数据库产生的键
                    ResultSet rs = st.getGeneratedKeys(); // 获得数据库产生的键集
                    if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
                        var = rs.getInt(1); // 获得值并赋值给 var 变量
                    }
                } else {
                    var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
                }
                commit(c); // 提交事务
            } catch (SQLException e) {
                System.out.println("数据保存失败: " + e.getMessage());
                rollback(c); // 回滚事务
            }
        }
        return var;
    }

    /**
     * 释放资源
     **/
    public void release(Object cloaseable) {

        if (cloaseable != null) {

            if (cloaseable instanceof ResultSet) {
                ResultSet rs = (ResultSet) cloaseable;
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (cloaseable instanceof Statement) {
                Statement st = (Statement) cloaseable;
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (cloaseable instanceof Connection) {
                Connection c = (Connection) cloaseable;
                try {
                    c.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }

    }

}

使用jdbc连接获取数据

package com.hikvision.mes.service.zp.controller;

import cn.evun.sweet.framework.core.cloud.annotation.CloudServiceResource;
import com.alibaba.fastjson.JSONObject;
import com.hikvision.mes.common.toolkit.RedisKit;
import com.hikvision.mes.service.zp.configuration.JdbcUtilsConfiguration;
import com.hikvision.mes.service.zp.service.MonitorService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.sql.ResultSet;
import java.util.ArrayList;

/**
 * @author xuchenghua
 * @date 2019-11-01
 */
@Api(value = "监控数据库和redis,controller", tags = {"监控数据库和redis接口"})
@RestController
@CloudServiceResource
public class MonitorController {
    @Autowired
    private MonitorService monitorService;
    private Logger logger = LoggerFactory.getLogger(MonitorController.class);

    @ApiOperation("查询质量事件指标")
    @RequestMapping(value = "queryDatabaseIsOnline", method = RequestMethod.GET)
    public JSONObject queryDatabaseIsOnline() {
        JSONObject result = new JSONObject();

        try {
            // 查询语句
            ArrayList<Object> arrayList = new ArrayList<>();
            arrayList.add(1);
            ResultSet res = JdbcUtilsConfiguration.query("select 1 as res  from dual where 1=?", arrayList);
            while (res.next()) {
                Integer id = res.getInt("res");
            }
            result.put("数据库连接", "success");
        } catch (Exception e) {
            result.put("数据库连接", "fail");
        }
        try {
            String key = "redisMonitor";
            String value = "123";
            RedisKit.use().set(key, value);
            RedisKit.use().expire(key, 1);
            result.put("redis连接", "success");
        } catch (Exception e) {
            result.put("redis连接", "fail");
        }

        return result;
    }


}

 

进击的豆子
关注
专栏目录
static静态变量使用@Value注入方式.md
09-26
### static静态变量使用@Value注入方式 #### 一、引言 在Java开发中，特别是基于Spring框架的应用程序中，开发者经常会遇到需要为类中的成员变量注入外部配置值的情况。Spring框架提供了多种注入机制，其中`@Value...
封装JDBC—非框架开发必备的封装类
longyajidi的博客
06-19 300
一些小型的项目，有时不想使用框架如MyBatis，Hibernate等开发时，往往在数据持久化时操作比较繁琐，以下提供了对JDBC的封装类，简化JDBC操作。 为了更客观展示MyJDBC，我们通过一般的JDBC连接数据库的增删改查来对比。 JDBC连接数据库操作通常的做法都是先建立一个公共类，来配置数据库信息，加载驱动等，这里不展示公共类（网上到处都是）。 以下对比增删改查：
SpringBoot配置数据源DataSource
米洛尔的博客
11-22 1万+
SpringBoot配置数据源DataSource 2019-03-28 categories:资料 author:iigadmin SpringBoot配置数据源DataSource 使用Spring Boot默认数据源 1.1 引入POM依赖 在pom文件中直接依赖官方提供的spring-boot-start-jdbc模块或者spring-boot-start-data-jpa模块。 ...
spring动态切换数据源
weixin_50989637的博客
08-01 2387
转载，如有侵权，立马删除
@Value不能直接给静态变量赋值的解决办法
weixin_43060346的博客
05-11 2504
1.平常使用直接在变量头上加上@Value就可以把配置文件的值注入进来 @Value("${appId}") private String appId; 2.但是变量使用static修饰时，就不能注入进来了 @Value("${appId}") private static String appId 这是因为springboot不支持把值赋值给静态变量，但也给出了响应的解决...
Spring问题集：@value放在Spring基于java的配置文件中取不到值
River的博客
07-26 915
在测试Spring的事务的时候需要连接数据库，但是发现@Value的值一直就是“{${jdbc.url}}”，并没有从配置文件中获取到值， 配置文件的代码如下： @Configuration @ComponentScan(basePackages = {"com.huanghe.*"}) @PropertySource("classpath:jdbc.properties") public...
Spring Boot使用Value注解给静态变量赋值的方法
08-27
然后，我们可以使用 @Value 注解来注入配置文件中的值，但是我们不能直接将值注入到静态变量中，而是需要使用非静态的 set 方法来注入。 例如，在下面的代码中，我们使用 @Value 注解来注入 oss.endpoint 和 oss....
spring boot静态变量注入配置文件详解
08-27
要解决静态变量注入问题，我们可以使用 Spring 的 set 注入方法，通过非静态的 setter 方法注入静态变量。例如，我们可以将 KafkaConfig 类修改为： ```java @Component(value = "KafkaConfig") @...
springboot无法从静态上下文中引用非静态变量的解决方法
08-25
在上面的代码中，我们使用@Value注解将配置文件中的值注入到静态变量kafka中，然后使用setter方法将其设置为静态变量。在tank_test方法中，我们可以直接引用静态变量kafka。 使用spring的set注入方法可以解决静态...
springboot 使用yml配置文件给静态变量赋值教程
09-16
由于我们有一个静态工具类`ClickHouseUtil`，其中的方法依赖于静态变量，所以我们不能直接使用`@Value`注解为静态变量赋值。Spring框架不允许在静态字段上直接注入值，因为它不支持实例化静态对象。 为了解决这个...
【springboot学习笔记二】spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver报错
m0_67401660的博客
04-11 7331
如何解决spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver无法引用，如下： 解决方案，在pom.xml找到自动创建项目时导入的mysql .jar包 <!-- mysql--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-conne.
Spring @Value(“#{}“)和@Value(“${}“)
jothan的博客
09-15 2178
1前言 以前对spring中@Value没有太注意，看到同事把这个注解用的花里胡哨，我就感觉铁子牛逼666呀，迭代版本结束了，我就对这个注解研究研究，争取也牛逼666。 2 #号和$符的不同用法 2.1 $符的用法 总的来说就是：用于获取配置文件中的属性值； 2.1.1简单用法： 通常用于获取写在application.properties中的内容，例如在配置文件中： jdbc.driverClass=com.mysql jdbc.url=3306@local jdbc...
springboot - 自定义配置类
weixin_42576078的博客
05-23 1796
这里使用DataSource举例 package com.example.demo.config; import com.alibaba.druid.pool.DruidDataSource; import com.example.demo.properties.JdbcPro; import lombok.extern.slf4j.Slf4j; import org.springfram...
@value取不到值_Spring项目中value注解，@Value不能够读取到配置文件的值，无法成功注入值的问题解决...
weixin_39792751的博客
11-20 1725
前言今天在做项目的时候，我在监听器里面使用@Value注解获取配置文件中的值，然后出现了空指针错误，表示值没有获取到。然后我试了一下在controller层里面设置一个get方法，然后通过get方法获取，然后发现也是不行的。有点懵！后来我发现了一个问题，我设置的Listener类和springboot不能共享spring的上下文，因为我这个类没有通过@Component注解加入到spring管理，...
记一次SpringBoot使用@Value读取属性值的采坑经历
热门推荐
sunroyfcb的博客
11-14 2万+
项目中有一个专门用来下载音频的类，这次问题涉及的主要部分如下，base-url属性在application.yml中已经定义。 public class DownloadMp3 { @Value("${base-url}") private static String url; public static void a_download(String fileName,...
解决SpringBoot @Value注解静态属性无法注入问题
jike11231的博客
05-06 1453
解决@Value注解静态属性无法注入问题解决方案一：使用 set 方法解决方案二：使用 @PostConstruct 方法 最近在项目中遇到一个问题： 在给static修饰的变量做@Value注入时，发现变量值为null，发现@Value只能给普通变量做值注入，无法为static属性赋值。 @Data @Component public class ApiConfig { @Value("${openapi.appKey:test21c454457f28a2c31}") private St
@Value注入静态变量（static）
后面牵个人的博客
09-29 9930
@Value注解介绍： 作为Spring的一个常用注解，其作用是通过注解将常量、配置文件中的值和其他bean的属性值注入到变量中，作为变量的初始值。 使用方法如下： @Value(“常量”) 常量，包括字符串,网址,文件路径等。 // 注入常量 @Value("Pavel") private String tenantName; @Value(“${}” : default_value) 读取配置文件。 // 读取配置中database的值 @Value("${spr
Spring—@Value在static中引用
花无名
08-02 1万+
@Value在静态代码块，静态方法中引用。 @Value注入原理。 Spring主动加载yml配置
Springboot 整合RocketMQ（十三）
xcc_2269861428的博客
09-08 592
1、首先看下RocketMQ启动 （可以借鉴：https://blog.csdn.net/xcc_2269861428/article/details/100593841） 2、客户端启动 3、引入pom <dependency> <groupId>org.apache.rocketmq</groupId> ...
如何把@value注解的值赋给静态变量
最新发布
06-09
在Java中，我们可以使用Spring框架提供的@Value注解来将配置文件中的属性值赋给Java类中的静态变量。具体步骤如下： 1. 在Spring的配置文件中定义属性值 ``` <property name="myStaticField" value="${my....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值