Spring：基于注解的依赖注入的使用

Spring：基于注解的依赖注⼊的使⽤
1.什么是pojo？什么是bean？
⾸先，在之前⼏篇Spring的介绍⽂章当中，⾃⼰都提到了⼀个名词叫做POJO类，但是在回顾Spring的注解的使⽤的时候，去形容java当中的对象还有⼀个名词是叫做Bean，那么究竟Pojo类和Bean之间有什么区别呢？本⼈特地为此进⾏了资料收集，总结如下：
什么是POJO类呢？所谓的POJO，即Plain old java object，翻译过来是纯净的java⽼式的对象，POJO的内在含义是指那些没有从任何类继承、也没有实现任何接⼝，更没有被其它框架侵⼊的java对象，pojo⼀般是⽤于数据的临时传递，它只能装载数据，作为数据存储的载体，⽽不具有业务逻辑处理的能⼒，常常在dao层的实现的时候需要POJO类。

⽽什么是JAVAbean呢？所谓的JAVAbean是⼀种JAVA语⾔写成的可重⽤组件。

它的⽅法命名，构造及⾏为必须符合特定的约定：
1. 这个类必须有⼀个公共的缺省构造函数。

2. 这个类的属性使⽤getter和setter来访问，其他⽅法遵从标准命名规范。

3. 这个类应是可序列化的。

因为这些要求主要是靠约定⽽不是靠实现接⼝，所以许多开发者把JavaBean看作遵从特定命名约定的POJO类。

简⽽⾔之，当⼀个Pojo可序列化，有⼀个⽆参的构造函数，使⽤getter和setter⽅法来访问属性时，他就是⼀个JavaBean。

2.通过注解的⽅式去运⽤Spring
明确了POJO类和JAVAbean的概念之后，我们接下来回顾⼀下Spring当中的依赖注⼊的⽅式，前头我们所说记录的是，是Spring当中的对象的属性注⼊的⽅式，那么在Spring当中，如何向对象注⼊所需要依赖的对象呢？在使⽤配置⽂件的时候，我们通常都是通过Spring的上下⽂，即ApplicationContext的实例当中的getBean⽅法从SpringIOC容器当中去获取到依赖对象的实例，代码如下：
package bjtu.wellhold.testSpring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class testUnit {
public static void main(String[] args) {
ApplicationContext cfg = new ClassPathXmlApplicationContext("Config.xml");
Person person = cfg.getBean("person", Person.class);
System.out.println(person);
}
}
从代码看出，通过ApplicationContext的实例cfg当中的getBean⽅法，从Spring容器当中获取到了Person类的实例person（之前已经在配置⽂件当中配置好person，如有不会，请翻看之前的⽂章）之后再对获取到的person实例进⾏其他的逻辑操作。

这是我们之前使⽤的基于配置⽂件的情况下的对象依赖注⼊的⽅式，可以看到这种⽅式还是⽐较繁琐的，因为要获取到Spring容器当中的实例之前，我们⾸先要获取到Spring上下⽂的实例，才能通过getBean的⽅法去获取到IOC容器当中的实例，在⼀点在Spring3.0之后，提出了⼀种更为简便，更为优雅的⽅式去实现了包括将pojo或bean类注册到Spring的容器当中，或者从Spring容器当中去获取到相应的实例的⽅式，那就是通过注解的形式。

⾸先回顾Spring的使⽤过程，我们第⼀步要先了解通过注解的形式，如何将我们所编写的Pojo类或者JAVAbean注册到Spring当中让其去管理，这时候我们使⽤的注解是@Component，通过这个注解可以讲所定义的JAVAbean或POJO类注册到Spring容器当中，并且根据所涉及的JAVAbean所处的层不同，还可以将@Component特化成⼀下⼏个注解：@Repository，⽤于DAO层，通常⽤于标记pojo类；
@Service，⽤于业务逻辑层，通常⽤来标记JAVAbean，@Controller，⽤于控制表⽰层，通常也是⽤于标记JAVAbean的。

使⽤⽅式也⼏乎⼀致，以下举⼀个@Repository的例⼦：
package bjtu.wellhold.testSpring;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
@Repository("person")
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
在代码中，@Repository括号中的内容指的是将这个类交付与Spring容器之后，在Spring容器当中，这个类的实例的名称，以上注解等同于在配置⽂件当中编写：
<bean id="person" class="bjtu.wellhold.testSpring.Person"></bean>
在了解了如何将编写的POJO类和JAVAbean类注册到容器当中之后，我们再来看看如何从容器当中通过注解的⽅式去获取到这些类的实例，我们通过的是@Resource这个注解去进⾏。

我们⾸先写⼀个PersonFactory类，通过注解的形式将Person的实例注⼊到PersonFactory 当中：
package bjtu.wellhold.testSpring;
import javax.annotation.Resource;
import org.springframework.stereotype.Repository;
@Repository("personFactory")
public class PersonFactory {
@Resource(name="person",type=Person.class) private Person person;
public Person createPerson()
{
System.out.println(person.toString());
return person;
}
}
从代码可以看到。

在被注⼊Person的实例的同时，PersonFactory也通过@Repository这个注解将⾃⾝托给了Spring容器去进⾏管理，之后我们来编写程序⼊⼝：
package bjtu.wellhold.testSpring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import ponent;
public class testUnit {
public static void main(String[] args) {
ApplicationContext cfg = new ClassPathXmlApplicationContext("Config.xml");
Person person = cfg.getBean("person", Person.class);
PersonFactory personfactory = cfg.getBean("personFactory", PersonFactory.class);
personfactory.createPerson();
}
}
简单的解释⼀下，为什么我们不在程序⼊⼝这⾥就直接通过注解注⼊Person的实例呢？⽽需要中间通过⼀个PersonFactory去验证注⼊的效果？因为在程序的⼊⼝。

main函数是⼀个静态的⽅法，如果需要在main函数中注⼊Person的实例，则Person实例需要定义成静态的，所谓的静态的，即是在类加载的时候就需要实例化的，但在类加载的时候，main函数没有被调⽤，并没有执⾏Spring的上下⽂，所以这时候注⼊的Person实例⼀定会报空指针错误，即在未加载Spring上下⽂之前，就已经执⾏了注⼊，所以不⾏，读者或者将来的⾃⼰可以好好思考⼀下这个前后顺序的问题，就可以明⽩其中的道理。

虽然是基于注解的⽅式去使⽤Spring，但是还是需要对配置⽂件进⾏⼀些简单的配置的，即要打开扫描和注解功能，配置⽂件如下:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance"
xmlns:aop="/schema/aop"
xmlns:context="/schema/context"
xsi:schemaLocation="
/schema/beans
/schema/beans/spring-beans-3.0.xsd
/schema/aop
/schema/aop/spring-aop-3.0.xsd
/schema/context
/schema/context/spring-context-3.0.xsd">
<bean class="monAnnotationBeanPostProcessor"/>
<context:annotation-config />
<context:component-scan base-package="bjtu.wellhold.testSpring"/>
</beans>
以上就是@Component注解以及它的分⽀的使⽤⽅法。

之后我们在来了解另⼀个注解@Configuration的使⽤⽅法，顾名思义，是可以通过java类为提供Spring容器提供Bean定义的信息了，常常与@Bean注解进⾏使⽤，每个标注了@Bean的类⽅法都相当于提供了⼀个Bean的定义信息。

为了验证@Configuration，我们做两个pojo类，⼀个名叫Person，⼀个名叫Mechine，并且将这两个类注⼊到名叫Factory类当中，Factory类可以提供⼀个公共的⽅法打印这两个类的实例的信息。

代码如下：
package bjtu.wellhold.testSpring;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
package bjtu.wellhold.testSpring;
public class Mechine {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
@Override
public String toString() {
return "Mechine [id=" + id + ", name=" + name + "]";
}
}
package bjtu.wellhold.testSpring;
import javax.annotation.Resource;
import org.springframework.stereotype.Repository;
public class Factory {
private Person person;
private Mechine mechine;
public void returnPerson()
{
System.out.println(person);
}
public void returnMechine()
{
System.out.println(mechine);
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
public Mechine getMechine() {
return mechine;
}
public void setMechine(Mechine mechine) {
this.mechine = mechine;
}
@Override
public String toString() {
return "Factory [person=" + person + ", mechine=" + mechine + "]";
}
}
之后我们通过⼀个FactoryConfiguration的类，进⾏@Configuration注解之后，为Spring提供Bean的配置信息，代码如下：package bjtu.wellhold.testSpring;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FactoryConfiguration {
@Bean
public Person person(){
return new Person();
}
@Bean
public Mechine mechine()
{
Mechine mechine=new Mechine();
mechine.setId(10);
mechine.setName("wellhold");
return mechine;
}
@Bean
public Factory factory()
{
Factory factory=new Factory();
factory.setMechine(mechine());
factory.setPerson(person());
return factory;
}
}
其效果就如同在配置⽂件当中写下如下内容
<bean id="person" class="bjtu.wellhold.testSpring.Person"></bean>
<bean id="mechine" class="bjtu.wellhold.testSpring.Mechine">
<property name="id" value="10"/>
<property name="name" value="wellhold"/>
</bean>
<bean id="factory" class="bjtu.wellhold.testSpring.Factory">
<property name="person" ref="person"/>
<property name="mechine" ref="mechine"/>
</bean>
最后我们来看看我们的程序⼊⼝：
package bjtu.wellhold.testSpring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import ponent;
public class testUnit {
public static void main(String[] args) {
ApplicationContext cfg = new ClassPathXmlApplicationContext("Config.xml");
Factory factory = cfg.getBean("factory", Factory.class);
factory.returnMechine();
factory.returnPerson();
}
}
到此，⽬前笔者了解到的Spring框架当中⽤到的常⽤的注解就讲解完毕了。

如有在看到新的注解内容，可能会继续更新此贴。