精华内容
下载资源
问答
  • java SpringBoot 配置文件注入的三种方式

    .properties或.ymal直接注入

    pom.xml中添加一个补丁,更方便得配置文件

     <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    

    这个补丁可以在配置类属性的时候,自动提醒

    根据实体类加自动注入注解

    package com.example.demo.pojo;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    @Component
    @ConfigurationProperties(prefix = "person")
    public class Person {
        String name;
        int age;
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    在全局配置文件中直接进行配置

    server:
      port: 8082
    person:
      name: test
      age: 18
    

    创建测试类进行测试

    在这里插入图片描述

    package com.example.demo;
    
    import com.example.demo.pojo.Person;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class DemoApplicationTests {
        @Autowired
        Person person;
        @Test
            public void contextLoads() {
            System.out.println(person);
        }
    
    }
    

    运行结果

    在这里插入图片描述

    @Value()注入

    根据全局配置文件有选择性得挑选注入数据

    根据实体类加@Value()

    package com.example.demo.pojo;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Person {
        @Value("${person.name}")
        String name;
        @Value("#{11*11}")
        int age;
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    运行结果

    在这里插入图片描述

    @PropertiesSource(@PropertiesSources)

    该注解只能用于.properties,不可用于.ymal

    添加额外的配置文件

    在这里插入图片描述

    根据实体类加@PropertySource()

    package com.example.demo.pojo;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    @Component
    @PropertySource(value = {"classpath:person.properties"})
    @ConfigurationProperties(prefix = "person")
    public class Person {
        String name;
        int age;
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    运行结果

    在这里插入图片描述

    @propertySources()同理如下

    配置文件

    在这里插入图片描述

    person.age=234
    
    person.name=testPropertiesSources
    
    

    实体类

    package com.example.demo.pojo;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    @Component
    @PropertySource(value = {"classpath:person1.properties","classpath:person2.properties"})
    @ConfigurationProperties(prefix = "person")
    public class Person {
        String name;
        int age;
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    运行结果

    在这里插入图片描述

    比较

    @ConfigurationProperties@Value
    功能批量注入配置文件中的属性一个个指定
    松散绑定(松散语法)支持不支持
    SpEL不支持支持
    JSR303数据校验支持不支持
    复杂类型封装支持不支持
    展开全文
  • JavaConfig配置文件Spring创建bean

    千次阅读 2017-06-22 15:05:41
    Spring容器创建Bean的三种方法:JavaConfig,XML配置,自动装配 JavaConfig是独立于Spring的一个项目,在...XML配置文件只有在运行的时候的才检查Bean是否配置正确,比如如果没有相应的注解,无法注入Spring容器,

    Spring容器创建Bean的三种方法:JavaConfig,XML配置,自动装配

    JavaConfig是独立于Spring的一个项目,在Spring3.0后出现。大部分企业中还是最常见的为自动装配及XML配置,其实JavaConfig也可被视为一个XML文件,只是由Java代码编写。XML配置文件只有在运行的时候的才检查Bean是否配置正确,比如如果没有相应的注解,无法注入到Spring容器,在启动时会报错,但是JavaConfig则会在编译的时候直接提示,利于提前发现错误。
    JavaConfig是一个配置类,用@Configuration注解来向Spring容器声明该类为一个配置类,通常单独放在一个包内。JavaConfig中实际就是为Spring配置Bean,通过@Bean来向Spring注入一个Bean并且返回一个类的实例化,容器中的类名就是Bean类的首个字母小写。可以想象,JavaConfig可以配置所有Spring需要的Bean,和XML文件配置及自动装配是一样的,JavaConfig注入Bean和其他两种方法向Spring容器中注入Bean是一样的,有DI依赖注入,依赖注入也相同,构造器注入,Setter方法依赖注入。下面的例子是简单的JavaConfig配置。


    该例子的意思为一个CDPlayer需要依赖一个CompactDisc也就是光盘才可以工作,依赖这个光盘。

    package JavaZhuangpeiBean;

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;

    import soudSystem.CDPlayer;
    import soudSystem.CompactDisc;
    import soudSystem.SgtPeppers;

    @Configuration
    public class CDPlayerConfig2 {

    @Bean
    public CDPlayer cdplayer(CompactDisc compactDisc){
    return new CDPlayer(
    compactDisc );                         //对这两个实例都通过构造器进行依赖注入一个compactDisc,查看一下Spring                                                                                       容器中对于同一个类的对象是否会创建多个
    }

    @Bean
    public CDPlayer anothercdplayer(CompactDisc compactDisc){
    return new CDPlayer(compactDisc);
    }
    }


    以上的配置文件向Spring容器声明了两个类,通过构造器注入了compactDisc。



    package soudSystem;

    public calss CompactDisc {
    void play(){
    System.out.println("----play------");
    }
    }

    以上创建一个类,有一个方法play。由此可以做个推断 1:如果play方法运行了,那么CompactDisc的对象肯定是创建了,否则无法运行其方法。2:CompactDisc要创建,必须CDPlayer的Bean要在容器中注册并创建,因为CDPlayer要依赖CompactDisc,CompactDisc已经创建了,CDPlayer必然创建了。那么到底是不是呢,我们用Junit来测试一下这两个Bean(CDPlayer,CompactDisc)是否为空,如果不为空,则表示已经通过JavaConfig在Spring容器中创建好了。

    package JavaZhuangpeiBean;

    import static org.junit.Assert.*;

    import org.junit.After;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

    import soudSystem.CDPlayer;
    import soudSystem.CDPlayerConfig;
    import soudSystem.CompactDisc;
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes=CDPlayerConfig2.class)
    public class CDPlayerConfig2Test {

    @Autowired
    private CompactDisc compactDisc;

    @Autowired
    private CDPlayer cdplayer;

    @Test
    public void testCdplayer() {
    assertNotNull(compactDisc);
    compactDisc.play();
    Boolean flag=compactDisc.equals(
    compactDisc);
    System.out.println(flag);
    }

    @Test
    public void testAnothercdplayer() {
    assertNotNull(compactDisc);
    Boolean flag=compactDisc.equals(compactDisc);
    System.out.println(flag);
    }

    }







    运行结果:
    ----play------                    //由运行结果可看出不为null,说明已经创建bean成功了,调用  其方法也没有错
    true                                //由此可看出两个compactDisc是相同的,表明Spring对一同一个类只创建一个,Spring                                                             中的Bean都是单单例的。
    true





    展开全文
  • 在SSH框架下,假设我们将配置文件放在项目的src/datasource.properties路径下,Spring配置文件也是src/applicationContext.xml路径下,那么我们可以借助Spring的property-placeholder读取配置文件,然后注入Bean中...

    1.简介

    在SSH框架下,假设我们将配置文件放在项目的src/datasource.properties路径下,Spring的配置文件也是src/applicationContext.xml路径下,那么我们可以借助Spring的property-placeholder读取配置文件,然后注入Bean中。我们在程序中,可以根据Bean的Id,获取注入的值。这样我们就可以借助Spring来读取配置文件。

    2.Code

    2.1Student.java

    package edu.njupt.zhb.model.mysql;
    
    
    
    /**
     * Student entity. @author MyEclipse Persistence Tools
     */
    
    public class Student  implements java.io.Serializable {
    
    
        // Fields    
    
         private String id;
         private String name;
         private String course;
         private Integer score;
         private String remarks;
    
    
        // Constructors
    
        /** default constructor */
        public Student() {
        }
    
    	/** minimal constructor */
        public Student(String name, String course, Integer score) {
            this.name = name;
            this.course = course;
            this.score = score;
        }
        
        /** full constructor */
        public Student(String name, String course, Integer score, String remarks) {
            this.name = name;
            this.course = course;
            this.score = score;
            this.remarks = remarks;
        }
    
       
        // Property accessors
    
        public String getId() {
            return this.id;
        }
        
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return this.name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
    
        public String getCourse() {
            return this.course;
        }
        
        public void setCourse(String course) {
            this.course = course;
        }
    
        public Integer getScore() {
            return this.score;
        }
        
        public void setScore(Integer score) {
            this.score = score;
        }
    
        public String getRemarks() {
            return this.remarks;
        }
        
        public void setRemarks(String remarks) {
            this.remarks = remarks;
        }
    }

    2.2datasource.properties中的配置

    #student config
    student.name=Haibo
    student.id=1012010638
    student.course=Java
    student.score=90
    student.remarks=Come from Properties

    2.3Spring配置文件applicationContext.xml部分配置

    <!-- 引入datasource配置文件 -->
    	<context:property-placeholder location="classpath:datasource.properties" />
    	<bean id="student" class="edu.njupt.zhb.model.mysql.Student">
    	    <property name="id" value="${student.id}" />
            <property name="name" value="${student.name}" />
            <property name="course" value="${student.course}" />
            <property name="score" value="${student.score}" />
            <property name="remarks" value="${student.remarks}" />
    	</bean>

    2.4读取Spring中的Bean函数

    /*
     * $filename: BeanUtils.java,v $
     * $Date: 2013-12-9  $
     * Copyright (C) ZhengHaibo, Inc. All rights reserved.
     * This software is Made by Zhenghaibo.
     */
    package edu.njupt.zhb.tools;
    
    import org.apache.struts2.ServletActionContext;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    
    /*
     *@author: ZhengHaibo  
     *web:     http://blog.csdn.net/nuptboyzhb
     *mail:    zhb931706659@126.com
     *2013-12-9  Nanjing,njupt,China
     */
    public class BeanUtils {
    	/**
    	 * 获取Spring中注入的Bean
    	 * @param beanId:id
    	 * @return
    	 */
    	public static Object getSpringBean(String beanId){
    		//Spring配置文件的路径
    		String xmlRealPath = ServletActionContext.getServletContext().getRealPath("/WEB-INF/classes/applicationContext.xml");
    		ApplicationContext ac = new FileSystemXmlApplicationContext(xmlRealPath);
    		return ac.getBean(beanId);
    	}
    }
    

    2.5我们可以通过如下方式,获得Spring注入的值

    Student stu = (Student)BeanUtils.getSpringBean("student");

    2.6用JSONObject工具打印一下stu对象的值

    System.out.println(JSONObject.fromObject(stu).toString());

    2.7运行结果为:

    {"course":"Java","id":"1012010638","name":"Haibo","remarks":"Come from Properties","score":90}

    未经允许不得用于商业目的


    展开全文
  • 圈内规矩,转载请注明出处,起码标个CSDN,虽然可能没人转 前言:总是看csdn的文章,吃水不忘挖井...因为我已经配置了一个全局过滤器设置了utf-8的编码,问题应该在spring转换的问题上。然后上百度一搜,发现是要设置

    圈内规矩,转载请注明出处,起码标个CSDN,虽然可能没人转
    前言:总是看csdn的文章,吃水不忘挖井人。有的问题csdn上面找不到,加上很多人博客互相转发,百度一搜全是一样的,根本解决不了问题。唉,圈子好乱….
    第一次写博客,写的很乱,想看结论直接翻到最下面就好了
    这几天遇到一个问题就是@ResponseBody返回字符串时,字符乱码。因为我已经配置了一个全局过滤器设置了utf-8的编码,问题应该在spring转换的问题上。然后上百度一搜,发现是要设置StringHttpMessageConverter,这货默认编码是iso-8859-1,并不是utf-8。网上找资料发现都是xml配置注解的解决方案,就像下面这样

    <mvc:annotation-driven>  
        <mvc:message-converters>  
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">  
                <property name="supportedMediaTypes">  
                    <list>  
                        <value>text/plain;charset=UTF-8</value>  
                        <value>text/html;charset=UTF-8</value>  
                    </list>  
                </property>  
            </bean>
        </mvc:message-converters>  
    </mvc:annotation-driven>

    但是这个是xml配置的写法,我是用java文件配置spring的啊。于是我想当然new了一个bean,就像下面这样

    @Bean
        public StringHttpMessageConverter StringHttpMessageConverter(){
            return new StringHttpMessageConverter(Charset.forName("utf-8"));
        }

    启动发现并没有什么用,打印日志后发现spring用的bean不是我new的那个bean。

    偶然在stackoverflow上面看到这样一句话

    <mvc:annotation-driven /> is also @EnableWebMvc
    <tx:annotation-driven /> is @EnableTransactionManagement.
    <context:component-scan /> is @ComponentScan

    原来如此,@EnableWebMvc就想当于<mvc:annotation-driven />,于是去看了一下WebMvcConfigurerAdapter的源码,发现有一个configureMessageConverters的方法可以配置。于是重写这个方法,设置编码为utf-8。启动服务器一切正常。源码如下:

    @Configuration
    @EnableWebMvc
    public class WebConfig extends WebMvcConfigurerAdapter {
    
        @Bean
        public ViewResolver getViewResolver() {
            InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
            viewResolver.setPrefix("/WEB-INF/");
            viewResolver.setSuffix(".jsp");
            viewResolver.setExposeContextBeansAsAttributes(true);
            return viewResolver;
        }
    
        @Bean
        public MultipartResolver multipartResolver() {
            return new StandardServletMultipartResolver();
        }
    
        @Override
        public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
            configurer.enable();
        }
        //设置StringHttpMessageConverter 
        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
            StringHttpMessageConverter shm = new StringHttpMessageConverter(Charset.forName("utf-8"));
            converters.add(shm);
        }
    }

    另附我的DispatcherServlet的写法

    public class DispatcherServlet extends AbstractAnnotationConfigDispatcherServletInitializer{
    
        @Override
        protected Class<?>[] getRootConfigClasses() {
            return new Class<?>[]{RootConfig.class};
        }
    
        @Override
        protected Class<?>[] getServletConfigClasses() {
            return new Class<?>[]{WebConfig.class};
        }
    
        @Override
        protected String[] getServletMappings() {
            return new String[]{"/"};
        }
    
        @Override
        protected void customizeRegistration(Dynamic registration) {
            MultipartConfigElement mConfig = new MultipartConfigElement("D:/ojFile", 524288, 6291456, 0);//TODO,上传路径需要修改
            registration.setMultipartConfig(mConfig);
        }
    }
    展开全文
  • Spring配置文件注入变量

    千次阅读 2016-03-16 18:33:56
    Spring配置文件注入数据 注入基本数据类型和String,使用@Value注解 使用格式为 : @Value(“${property:default value}”)  当配置文件没有property会设置为默认值,如果有但是没值,会注入null @Value("${...
  • java main中执行spring注入代码

    千次阅读 2016-12-15 21:18:49
    在不启动tomcat服务器时,... 通过Spring依赖注入机制,在Main方法中通过读取配置文件,获取Spring注入的bean实例。一般是做测试用,具体代码如下: public static void main(String[] args) { String paths
  • Spring Boot全局配置文件有俩种方式 application.properties application.yml 或者application.yaml 全局配置文件时可以对一些默认值进行修改,如 tocmat 的端口号 等等 什么是.yml文件? .yml是YAML 语言的文件...
  • Spring1.x时代,都是通过xml文件配置bean,随着项目的不断扩大,需要将xml配置分放到不同的配置文件中,需要频繁的在java类和xml配置文件中切换。 Spring2.x时代 随着JDK 1.5带来的注解支持,Spring2.x可以...
  • Spring Boot学习笔记(五):我们已经...下面就来介绍:Spring Boot 配置文件中的值,如何注入到我们自定义的 Java Bean 中。(或者:Java Bean 如何获取配置文件中的值来注入) 如下分别为 Java Bean类和 yml 配置...
  • PropertyPlaceholderConfigurer可以实现:在单独的标准java Properties文件中配置属性,然后在spring的xml配置文件中,通过${key}获取配置属性的效果,这样做可以达到bean配置与properties配置分离的目的。...
  • 我在service层想获取properties文件中的值,如果用spring注解的方式去获取需要把Service类也注解为Component么?
  • 现在要做的就是将如下配置文件中的内容注入到一个bean 名为Properties中。 Redis.properties配置文件中的内容如下: Properties java bean中代码如下,注意注解的使用: 测试类代码: 打印结果为:
  • 非web的JAVA应用使用Spring的依赖注入

    千次阅读 2017-08-09 18:11:57
    普通JAVA应用程序使用Spring的依赖注入 ...然后类都需要自己管理,配置文件要编码读取等多种麻烦。于是考虑引入spring的依赖注入。想着前些年Springmvc框架是为Web提供的,网上简单搜了下也没有直接利用spring
  • Spring框架中XML配置文件注入集合属性前言创建测试类与属性配置XML配置文件建立调用类调用结果 前言 某些类的属性是可能是集合,包括:数组、LIST、MAP、SET等集合,在Spring中同样可以使用XML配置文件的方式对属性...
  • 1、配置文件使用上节中yaml书写的配置信息:server: port: 8081 path: /hello person: name: zhangsan age: 20 boss: false birth: 2017/11/12 #map写法1:行内 maps1: {k1: v1, k2: v2} #map...
  • Spring注入bean的properties配置文件位置问题解决 更多0 spring properties 配置 依赖注入 java 使用...
  • Spring 注入properties文件总结

    万次阅读 2016-08-10 12:03:46
    Spring 注入properties文件
  • Spring通过ApplicationContextAware获得bean的方法、获取数据库连接的方法、获取ApplicationContext 1、思路: 应用程序启动时使用ApplicationContextAware让Spring容器传递自己生成的ApplicationContext给我们, ...
  • 注解注入顾名思义就是通过注解来实现注入Spring注入相关的常见注解有Autowired、Resource、Qualifier、Service、Controller、Repository、Component。 Autowired是自动注入,自动从spring的上下文找到合适...
  • Spring Boot - 配置文件注入及Test

    千次阅读 2018-05-03 16:07:16
    1.java Bean 1.person.java package top.wyyblogspringboot02config.springboot02config.bean; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframewo...
  • Springboot 读取配置文件注入到Map

    千次阅读 2020-07-24 11:44:15
    由于要使用到第三方配置文件,需要将配置文件注入到属性中,特此记录一个demo: 搭建springboot 简易项目: 不做展示 引入配置文件相关依赖: <!--导入配置文件处理器,配置文件进行绑定就会有提示--> <...
  • Springboot配置文件静态注入

    千次阅读 2018-08-04 15:42:20
    YML配置文件静态注入。 name: rule: entity: $Eo url: main\java\ import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.context.properties....
  • 初学Spring 5 Mvc 零配置文件/Java Config(排坑之旅) 最近,复习web项目,比如spring + spring mvc + spring data 运行环境是:jdk 1.8 + tomcat 编译工具:IntelliJ IDEA 2018.1 在配置上,是采用的配置文件...
  • 看看spring自动注入的是否可以区别出不同包下相同名字的java类,答案是不能,spring居然这么渣。 整体结构图如下: 1:首先建立两个同名的java类和接口 com.a包下面有一个IAutoInject接口和实现类AutoInject,同理...
  • 异常堆栈:Initialization of bean ... nested exception is org.springframework.beans.TypeMismatchException: Failed to convert property value of type [java.util.LinkedHashMap] to required type [java.util.c
  • (1)下边的一个java类包含了所有Map、Set、List、数组、属性集合等这些容器,主要用于演示Spring注入配置; package com.lc.collection; import java.util.List; import java.util.Map; import java.util....
  •  1、用法示例: 在springMVC.xml配置文件中添加标签 (推荐用这个,这个用的比较多,也比较简洁) &lt;context:property-placeholder location="classpath:salesman.properties"/&gt;  加载...
  • 在很多情况下我们需要在配置文件中配置一些属性,然后注入到bean中,Spring提供了org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer类,可以方便我们使用注解直接注入properties文件中的...
  • 依赖注入spring的一个特性,从配置...第一反应就是java反射呗,比如构造函数注入,我们可以通过反射读取Bean类的构造函数,参数个数,参数类型,所以只要我们在xml配置文件中指定了参数类型或参数顺序就可以轻松通...
  • 但是如果要在普通的工具类里,使用service或dao,就会报空指针,因为这个普通的Java类并不在spring管理下,不能使用spring注入的service。 下面讲一个方法,让普通工具类也能使用service。 定义一个类 Spring...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 185,693
精华内容 74,277
关键字:

java配置文件spring注入

java 订阅
spring 订阅