Java Spring-如何将@Value注入数据对象？

Question

I have a data object (with getters\\setter only) that needs to be aware of the Spring profile, ie

@Value("${spring.profiles.active}")
private String profile;

I added a logic to one of it's 'set' method that checks the profile, ie

public void setItem(Item msg) {
    if (environmentProperties.isDevMode()) {
        this.msg= msg;
    }
}

since this class is often marshal\\unmarhsalled externally, so, of course the @Value isn't being populated - sine I didn't use spring Autowire to create the class instance... I tried defined the class as component, and autowire to an external class that holds the profile @Value - but it doesn't work I use spring 3.2 - with no XML definition.

any suggestions?

btw that data-objects often wrapped inside an exception class - so when it's created the profile should also be known to the data-object...

thanks!

EDITED:

• using ApplicationContextAware doesn't work - I get null the 'setApplicationContext' method is never invoked.
• also trying to get context directly doesn't work - get null instead when using: 'ApplicationContext ctx = ContextLoader.getCurrentWebApplicationContext();'

FIXED: I've eventually found an example how to access the context staticly from an external class:

@Configuration
public class ApplicationContextContainer implements ApplicationContextAware {

    private static ApplicationContext CONTEXT;

    /**
     * This method is called from within the ApplicationContext once it is
     * done starting up, it will stick a reference to itself into this bean.
     *
     * @param context a reference to the ApplicationContext.
     */
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        CONTEXT = context;
    }

    /**
     * This is about the same as context.getBean("beanName"), except it has its
     * own static handle to the Spring context, so calling this method statically
     * will give access to the beans by name in the Spring application context.
     * As in the context.getBean("beanName") call, the caller must cast to the
     * appropriate target class. If the bean does not exist, then a Runtime error
     * will be thrown.
     *
     * @param beanName the name of the bean to get.
     * @return an Object reference to the named bean.
     */
    public static Object getBean(String beanName) {
        return CONTEXT.getBean(beanName);
    }

Answer 1

If I understand you correctly you want to inject into Objects not managed by Spring, but created by some other code that internally calls new and returns objects eg a serialization framework.

To inject unmanaged Objects you will need to configure either load-time or compile-time weaving. Load-time weaving requires an agent argument and lib when you start your VM, some containers might do this for you.

Compile-time weaving requires the use of the AspectJ compiler.

Below you will find a complete example using Maven and Spring-Boot:

Eg run it with:

mvn spring-boot:run -Drun.arguments="--spring.profiles.active=dev"

DemoApplication.java:

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.aspectj.EnableSpringConfigured;
import org.springframework.stereotype.Component;

@SpringBootApplication
public class DemoApplication {
    @EnableSpringConfigured
    @ComponentScan("com.example")
    public static class AppConfiguration {
        @Value("${spring.profiles.active}")
        String profile;

        @Bean
        public String profile() {
            return profile;
        }
    }

    @Configurable
    public static class SomePojo {
        @Autowired
        private String profile;

        public void print() {
            System.out.println(this + "\t" + profile);
        }
    }

    @Component
    public static class Runner {
        public void run() {
            new SomePojo().print();
            new SomePojo().print();
        }
    }

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args).getBean(Runner.class).run();
    }

}

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.3.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>aspectj-maven-plugin</artifactId>
                <version>1.8</version>
                <configuration>
                    <complianceLevel>1.8</complianceLevel>
                    <aspectLibraries>
                        <aspectLibrary>
                            <groupId>org.springframework</groupId>
                            <artifactId>spring-aspects</artifactId>
                        </aspectLibrary>
                    </aspectLibraries>
                </configuration>
                <executions>
                    <execution>
                        <id>compile</id>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Answer 2

From your description, you're trying to inject the property into POJO, which is used in marshalling. With this structure you may look for different workarounds with static-based/any other complex solutions.

I'd suggest to separate the bean which is used as POJO from the logic which depends on the property value. You can extract that logic to BeanService (which can be placed to Spring context) and handle it on that level, so that you separate the responsibility between Service and Data layers.

Answer 3

You're doing it wrong. Your code does not need to be aware of the profile. In your example, create a Message interface, and a number of bean implementations of this interface, one for each profile, each containing an appropriate message for that profile, and assign each one to a profile so that the bean is instantiated for that profile, and inject the instance into the class that needs the message.

So,

public interface Message { String getMessage(); }

@Profile("dev") @Component
public class DevMessage implements Message { 
  public String getMessage() { return "this is the dev message"; }
}

@Profile("prod") @Component
public class ProdMessage implements Message {
  public String getMessage() { return "this is the production message"; }
}

If you prefer to describe your beans in your @Configuration class, you can mark a whole configuration with an @Profile, and have multiple configurations.

If you inject the Message instance into a class, you can call getMessage() on it. The profile will ensure that you have the appropriate implementation for your environment.

Edit: I've just reread your question and realised that I've got this wrong. You have entity objects stored outside the application and instantiated through some code/framework. These aren't spring components, and so can't use the spring approach to dependency injection. In this case, don't use spring for them -- it doesn't work, doesn't have to work, and shouldn't work. If you haven't instantiated the object through spring, then it should have nothing to do with spring. I don't know your problem domain, but I've been using spring since it was invented and have never ever had to do this.