首页 > 代码库 > 使用注解属性绑定

使用注解属性绑定

2024-07-02 02:37:09   226人阅读

大家应该知道在Spring中有一个注解@Value，他可以帮助我们来讲Spring加载的配置文件（*.perperties）文件中的信息自动的注入到我们的非静态属性中的。

一般情况下我们会这样使用：

1.　　首先在Spring的配置文件中加载属性文件：

?
1
<context:property-placeholder location="classpath:component.properties"  ignore-unresolvable="true"/>

然后在Java代码中使用@Value注解就可以注入值了，比如：

 
?
1
2
@Value("${open_office_install_home}")
private String openOfficeInstallHome;
 
当然属性如果是static的话是不能注入的。
 
其实这个自动注入的过程实现起来比较简单，我们下面通过一个例子来大致描述一下这个原理吧，这个例子是我写的，并不代表Spring的源码就是这么实现的。但是原理是一样的。
 
1.　　我们先自定义一个注解：
?
1
2
3
4
5
6
7
8
9
10
11
12
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Value {
 
    public String value();
 
}

2. 然后新增一个处理类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Properties;
 
 
public class PropertyInvokationHandler implements InvocationHandler {
 
    private Properties properties;
 
    public PropertyInvokationHandler(Properties properties) {
        this.properties = properties;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Value annotation = method.getAnnotation(Value.class);
        if(annotation == null){
            throw new RuntimeException(String.format("Method:{} is not bound to a property.", method.getName()));
        }
        return properties.getProperty(annotation.value());
    }
}

3.　　创建一个公共方法：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.lang.reflect.Proxy;
import java.util.Properties;
 
public class PropertyTool {
 
    private PropertyTool() {
    }
 
    public static <T> T bindProperties(Class<T> clazz, Properties properties) {
        return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                new Class[]{clazz},
                new PropertyInvokationHandler(properties));
    }
}

这样我们就完成了这个功能了。

 

下面我们通过测试代码来验证一下我们的功能是否起作用：

我们创建一个接口：

?
1
2
3
4
5
6
7
8
9
public interface UserService {
 
    @Value("user.name")
    public String getUserName();
 
    @Value("user.password")
    public String getPassword();
 
}

然后编写测试类：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
 
public class UserServiceTester {
 
    public static void main(String[] args) {
        Properties properties = new Properties();
 
        try {
            String path = UserServiceTester.class.getResource("/user.properties").getPath();
            InputStream in = new FileInputStream(path);
            properties.load(in);
            in.close();
        } catch(IOException ex) {
            ex.printStackTrace();
        }
 
        UserService config = PropertyTool.bindProperties(UserService.class, properties);
        System.out.println("User Name: " + config.getUserName());
        System.out.println("Password: " + config.getPassword());
    }
}

而我们的user.properties属性文件中的内容为：

?
1
2
user.name=rollenholt
user.password=123

运行上面的main方法，就会输出属性文件中的内容了。

 

不知道大家有没有注意到，我们在测试代码中使用的UserService是一个接口，我们并没有创建他的实现类，但是我们在main函数中依旧可以钓鱼他的方法。那是因为在运行时自动生成了一个实现。是不是觉的这个功能可以用在很多的地方呀。

 
 


联系
我们