Spring Dependency注入

在Spring中使用工厂方法进行依赖注入

Spring框架提供了使用工厂方法来注入bean的便利。为此，我们可以使用bean元素的两个属性。

• factory-method: 表示将被调用以注入bean的工厂方法。
• factory-bean: 表示将调用工厂方法的bean的引用。如果工厂方法是非静态的，则使用它。

一种返回类实例的方法称为 factory-method。

public class A {
public static A getA(){//factory method
    return new A();
}
}

factory-method类型

可以有三种类型的factory-method:

1)返回的 静态工厂方法 自己的类的实例。用于单例设计模式。

<bean id="a" class="com.codebaoku.A" factory-method="getA"></bean>

2)一种 静态工厂方法，它返回 另一个类的实例。所使用的实例未知，并在运行时决定。

<bean id="b" class="com.codebaoku.A" factory-method="getB"></bean>

3)一种 非静态工厂方法，该方法返回 另一个类的实例。所使用的实例未知，并在运行时决定。

<bean id="a" class="com.codebaoku.A"></bean>
<bean id="b" class="com.codebaoku.A" factory-method="getB" factory-bean="a"></bean>

类型1

让我们看一下用静态工厂方法注入依赖项的简单代码。

<bean id="a" class="com.codebaoku.A" factory-method="getA"></bean>

让我们看一下完整的示例，以在Spring使用工厂方法注入依赖项。为了创建此示例，我们创建了3个文件。

• A.java
• applicationContext.xml
• Test.java

A.java

此类是单例类。

package com.codebaoku;
public class A {
private static final A obj=new A();
private A(){System.out.println("private constructor");}
public static A getA(){
    System.out.println("factory method ");
    return obj;
}
public void msg(){
    System.out.println("hello user");
}
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="a" class="com.codebaoku.A" factory-method="getA"></bean>
</beans>

Test.java

此类从applicationContext.xml文件获取Bean并调用msg方法。

package org.sssit;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
    ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
    A a=(A)context.getBean("a");
    a.msg();
}
}

输出:

private constructor
factory method
hello user

类型2

让我们看一下通过静态工厂方法注入依赖关系的简单代码，该方法返回另一个类的实例。

要创建在此示例中，我们创建了6个文件。

• Printable.java
• A.java
• B.java
• PrintableFactory.java
• applicationContext.xml
• Test.java

Printable.java

package com.codebaoku;
public interface Printable {
void print();
}

A.java

package com.codebaoku;
public class A implements Printable{
    @Override
    public void print() {
        System.out.println("hello a");
    }
}

B.java

package com.codebaoku;
public class B implements Printable{
    @Override
    public void print() {
        System.out.println("hello b");
    }
}

PrintableFactory.java

package com.codebaoku;
public class PrintableFactory {
public static Printable getPrintable(){
    //return new B();
          return new A();//return any one instance, either A or B
}
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="p" class="com.codebaoku.PrintableFactory" factory-method="getPrintable"></bean>
</beans>

Test.java

此类从applicationContext.xml文件获取Bean并调用print()方法。

package org.sssit;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
    ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
    Printable p=(Printable)context.getBean("p");
    p.print();
}
}

输出:

hello a

类型3

让我们看一下通过非静态工厂方法注入依赖关系的示例，该方法返回另一个类的实例。

To创建这个示例，我们已经创建了6个文件。

• Printable.java
• A.java
• B.java
• PrintableFactory.java
• applicationContext.xml
• Test.java

所有文件都与以前的文件相同，您只需更改两个文件: PrintableFactory和applicationContext.xml。

PrintableFactory.java

package com.codebaoku;
public class PrintableFactory {
//non-static factory method
public Printable getPrintable(){
    return new A();//return any one instance, either A or B
}
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="pfactory" class="com.codebaoku.PrintableFactory"></bean>
<bean id="p" class="com.codebaoku.PrintableFactory" factory-method="getPrintable" 
factory-bean="pfactory"></bean>
</beans>

输出:

hello a

 Aspect Oriented Programming(AOP)从某种意义上说是对OOP的补充，因为它还提供了模块化的功能。但是模块化的关键单元是方面而不是类。AOP将程序逻辑分为不同的部分(称为关注点)。 ...